1

/******************************************************************************

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    15

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

 *****************************************************************************/

    33

    34

/**

    35

   \file

    36

   EtherCAT master driver module.

    37

*/

    38

    39

/*****************************************************************************/

    40

    41

#include <linux/module.h>

    42

#include <linux/kernel.h>

    43

#include <linux/init.h>

    44

    45

#include "globals.h"

    46

#include "master.h"

    47

#include "device.h"

    48

    49

/*****************************************************************************/

    50

    51

int __init ec_init_module(void);

    52

void __exit ec_cleanup_module(void);

    53

    54

/*****************************************************************************/

    55

    56

static int ec_master_count = 1; /**< parameter value, number of masters */

    57

static int ec_eoeif_count = 0; /**< parameter value, number of EoE interf. */

    58

static struct list_head ec_masters; /**< list of masters */

    59

    60

char *ec_master_version_str = EC_MASTER_VERSION;

    61

    62

/*****************************************************************************/

    63

    64

/** \cond */

    65

    66

module_param(ec_master_count, int, S_IRUGO);

    67

module_param(ec_eoeif_count, int, S_IRUGO);

    68

    69

MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

    70

MODULE_DESCRIPTION("EtherCAT master driver module");

    71

MODULE_LICENSE("GPL");

    72

MODULE_VERSION(EC_MASTER_VERSION);

    73

MODULE_PARM_DESC(ec_master_count, "number of EtherCAT masters to initialize");

    74

MODULE_PARM_DESC(ec_eoeif_count, "number of EoE interfaces per master");

    75

    76

/** \endcond */

    77

    78

/*****************************************************************************/

    79

    80

/**

    81

   Module initialization.

    82

   Initializes \a ec_master_count masters.

    83

   \return 0 on success, else < 0

    84

*/

    85

    86

int __init ec_init_module(void)

    87

{

    88

    unsigned int i;

    89

    ec_master_t *master, *next;

    90

    91

    EC_INFO("Master driver %s\n", EC_MASTER_VERSION);

    92

    93

    if (ec_master_count < 1) {

    94

        EC_ERR("Error - Invalid ec_master_count: %i\n", ec_master_count);

    95

        goto out_return;

    96

    }

    97

    98

    EC_INFO("Initializing %i EtherCAT master(s)...\n", ec_master_count);

    99

   100

    INIT_LIST_HEAD(&ec_masters);

   101

   102

    for (i = 0; i < ec_master_count; i++) {

   103

        if (!(master =

   104

              (ec_master_t *) kmalloc(sizeof(ec_master_t), GFP_KERNEL))) {

   105

            EC_ERR("Failed to allocate memory for EtherCAT master %i.\n", i);

   106

            goto out_free;

   107

        }

   108

   109

        if (ec_master_init(master, i, ec_eoeif_count))

   110

            goto out_free;

   111

   112

        list_add_tail(&master->list, &ec_masters);

   113

    }

   114

   115

    EC_INFO("Master driver initialized.\n");

   116

    return 0;

   117

   118

 out_free:

   119

    list_for_each_entry_safe(master, next, &ec_masters, list) {

   120

        list_del(&master->list);

   121

        kobject_del(&master->kobj);

   122

        kobject_put(&master->kobj);

   123

    }

   124

 out_return:

   125

    return -1;

   126

}

   127

   128

/*****************************************************************************/

   129

   130

/**

   131

   Module cleanup.

   132

   Clears all master instances.

   133

*/

   134

   135

void __exit ec_cleanup_module(void)

   136

{

   137

    ec_master_t *master, *next;

   138

   139

    EC_INFO("Cleaning up master driver...\n");

   140

   141

    list_for_each_entry_safe(master, next, &ec_masters, list) {

   142

        list_del(&master->list);

   143

        ec_master_destroy(master);

   144

    }

   145

   146

    EC_INFO("Master driver cleaned up.\n");

   147

}

   148

   149

/*****************************************************************************/

   150

   151

/**

   152

   Gets a handle to a certain master.

   153

   \returns pointer to master

   154

*/

   155

   156

ec_master_t *ec_find_master(unsigned int master_index /**< master index */)

   157

{

   158

    ec_master_t *master;

   159

   160

    list_for_each_entry(master, &ec_masters, list) {

   161

        if (master->index == master_index) return master;

   162

    }

   163

   164

    EC_ERR("Master %i does not exist!\n", master_index);

   165

    return NULL;

   166

}

   167

   168

/*****************************************************************************/

   169

   170

/**

   171

   Outputs frame contents for debugging purposes.

   172

*/

   173

   174

void ec_print_data(const uint8_t *data, /**< pointer to data */

   175

                   size_t size /**< number of bytes to output */

   176

                   )

   177

{

   178

    unsigned int i;

   179

   180

    EC_DBG("");

   181

    for (i = 0; i < size; i++) {

   182

        printk("%02X ", data[i]);

   183

        if ((i + 1) % 16 == 0) {

   184

            printk("\n");

   185

            EC_DBG("");

   186

        }

   187

    }

   188

    printk("\n");

   189

}

   190

   191

/*****************************************************************************/

   192

   193

/**

   194

   Outputs frame contents and differences for debugging purposes.

   195

*/

   196

   197

void ec_print_data_diff(const uint8_t *d1, /**< first data */

   198

                        const uint8_t *d2, /**< second data */

   199

                        size_t size /** number of bytes to output */

   200

                        )

   201

{

   202

    unsigned int i;

   203

   204

    EC_DBG("");

   205

    for (i = 0; i < size; i++) {

   206

        if (d1[i] == d2[i]) printk(".. ");

   207

        else printk("%02X ", d2[i]);

   208

        if ((i + 1) % 16 == 0) {

   209

            printk("\n");

   210

            EC_DBG("");

   211

        }

   212

    }

   213

    printk("\n");

   214

}

   215

   216

/*****************************************************************************/

   217

   218

/**

   219

   Prints slave states in clear text.

   220

*/

   221

   222

size_t ec_state_string(uint8_t states, /**< slave states */

   223

                       char *buffer /**< target buffer

   224

                                       (min. EC_STATE_STRING_SIZE bytes) */

   225

                       )

   226

{

   227

    off_t off = 0;

   228

    unsigned int first = 1;

   229

   230

    if (!states) {

   231

        off += sprintf(buffer + off, "(unknown)");

   232

        return off;

   233

    }

   234

   235

    if (states & EC_SLAVE_STATE_INIT) {

   236

        off += sprintf(buffer + off, "INIT");

   237

        first = 0;

   238

    }

   239

    if (states & EC_SLAVE_STATE_PREOP) {

   240

        if (!first) off += sprintf(buffer + off, ", ");

   241

        off += sprintf(buffer + off, "PREOP");

   242

        first = 0;

   243

    }

   244

    if (states & EC_SLAVE_STATE_SAVEOP) {

   245

        if (!first) off += sprintf(buffer + off, ", ");

   246

        off += sprintf(buffer + off, "SAVEOP");

   247

        first = 0;

   248

    }

   249

    if (states & EC_SLAVE_STATE_OP) {

   250

        if (!first) off += sprintf(buffer + off, ", ");

   251

        off += sprintf(buffer + off, "OP");

   252

    }

   253

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   254

        if (!first) off += sprintf(buffer + off, " + ");

   255

        off += sprintf(buffer + off, "ERROR");

   256

    }

   257

   258

    return off;

   259

}

   260

   261

/******************************************************************************

   262

 *  Device interface

   263

 *****************************************************************************/

   264

   265

/**

   266

   Connects an EtherCAT device to a certain master.

   267

   The master will use the device for sending and receiving frames. It is

   268

   required that no other instance (for example the kernel IP stack) uses

   269

   the device.

   270

   \return 0 on success, else < 0

   271

   \ingroup DeviceInterface

   272

*/

   273

   274

ec_device_t *ecdev_register(unsigned int master_index, /**< master index */

   275

                            struct net_device *net_dev, /**< net_device of

   276

                                                           the device */

   277

                            ec_pollfunc_t poll, /**< device poll function */

   278

                            struct module *module /**< pointer to the module */

   279

                            )

   280

{

   281

    ec_master_t *master;

   282

   283

    if (!(master = ec_find_master(master_index))) return NULL;

   284

   285

    if (down_interruptible(&master->device_sem)) {

   286

        EC_ERR("Interrupted while waiting for device!\n");

   287

        goto out_return;

   288

    }

   289

   290

    if (master->device) {

   291

        EC_ERR("Master %i already has a device!\n", master_index);

   292

        goto out_up;

   293

    }

   294

   295

    if (!(master->device =

   296

          (ec_device_t *) kmalloc(sizeof(ec_device_t), GFP_KERNEL))) {

   297

        EC_ERR("Failed to allocate device!\n");

   298

        goto out_up;

   299

    }

   300

   301

    if (ec_device_init(master->device, master, net_dev, poll, module)) {

   302

        EC_ERR("Failed to init device!\n");

   303

        goto out_free;

   304

    }

   305

   306

    up(&master->device_sem);

   307

    return master->device;

   308

   309

 out_free:

   310

    kfree(master->device);

   311

    master->device = NULL;

   312

 out_up:

   313

    up(&master->device_sem);

   314

 out_return:

   315

    return NULL;

   316

}

   317

   318

/*****************************************************************************/

   319

   320

/**

   321

   Disconnect an EtherCAT device from the master.

   322

   The device is disconnected from the master and all device ressources

   323

   are freed.

   324

   \attention Before calling this function, the ecdev_stop() function has

   325

   to be called, to be sure that the master does not use the device any more.

   326

   \ingroup DeviceInterface

   327

*/

   328

   329

void ecdev_unregister(unsigned int master_index, /**< master index */

   330

                      ec_device_t *device /**< EtherCAT device */

   331

                      )

   332

{

   333

    ec_master_t *master;

   334

   335

    if (!(master = ec_find_master(master_index))) return;

   336

   337

    down(&master->device_sem);

   338

   339

    if (!master->device || master->device != device) {

   340

        up(&master->device_sem);

   341

        EC_WARN("Unable to unregister device!\n");

   342

        return;

   343

    }

   344

   345

    ec_device_clear(master->device);

   346

    kfree(master->device);

   347

    master->device = NULL;

   348

   349

    up(&master->device_sem);

   350

}

   351

   352

/*****************************************************************************/

   353

   354

/**

   355

   Opens the network device and makes the master enter IDLE mode.

   356

   \return 0 on success, else < 0

   357

   \ingroup DeviceInterface

   358

*/

   359

   360

int ecdev_open(ec_device_t *device /**< EtherCAT device */)

   361

{

   362

    if (ec_device_open(device)) {

   363

        EC_ERR("Failed to open device!\n");

   364

        return -1;

   365

    }

   366

   367

    if (ec_master_enter_idle_mode(device->master)) {

   368

        EC_ERR("Failed to enter idle mode!\n");

   369

        return -1;

   370

    }

   371

   372

    return 0;

   373

}

   374

   375

/*****************************************************************************/

   376

   377

/**

   378

   Makes the master leave IDLE mode and closes the network device.

   379

   \return 0 on success, else < 0

   380

   \ingroup DeviceInterface

   381

*/

   382

   383

void ecdev_close(ec_device_t *device /**< EtherCAT device */)

   384

{

   385

    ec_master_leave_idle_mode(device->master);

   386

   387

    if (ec_device_close(device))

   388

        EC_WARN("Failed to close device!\n");

   389

}

   390

   391

/******************************************************************************

   392

 *  Realtime interface

   393

 *****************************************************************************/

   394

   395

/**

   396

 * Returns the version magic of the realtime interface.

   397

 * \return ECRT version magic.

   398

 * \ingroup RealtimeInterface

   399

 */

   400

   401

unsigned int ecrt_version_magic(void)

   402

{

   403

    return ECRT_VERSION_MAGIC;

   404

}

   405

   406

/*****************************************************************************/

   407

   408

/**

   409

   Reserves an EtherCAT master for realtime operation.

   410

   \return pointer to reserved master, or NULL on error

   411

   \ingroup RealtimeInterface

   412

*/

   413

   414

ec_master_t *ecrt_request_master(unsigned int master_index

   415

                                 /**< master index */

   416

                                 )

   417

{

   418

    ec_master_t *master;

   419

   420

    EC_INFO("Requesting master %i...\n", master_index);

   421

   422

    if (!(master = ec_find_master(master_index))) goto out_return;

   423

   424

    if (!atomic_dec_and_test(&master->available)) {

   425

        atomic_inc(&master->available);

   426

        EC_ERR("Master %i is already in use!\n", master_index);

   427

        goto out_return;

   428

    }

   429

   430

    if (down_interruptible(&master->device_sem)) {

   431

        EC_ERR("Interrupted while waiting for device!\n");

   432

        goto out_release;

   433

    }

   434

   435

    if (!master->device) {

   436

        up(&master->device_sem);

   437

        EC_ERR("Master %i has no assigned device!\n", master_index);

   438

        goto out_release;

   439

    }

   440

   441

    if (!try_module_get(master->device->module)) {

   442

        up(&master->device_sem);

   443

        EC_ERR("Device module is unloading!\n");

   444

        goto out_release;

   445

    }

   446

   447

    up(&master->device_sem);

   448

   449

    if (!master->device->link_state) {

   450

        EC_ERR("Link is DOWN.\n");

   451

        goto out_module_put;

   452

    }

   453

   454

    if (ec_master_enter_operation_mode(master)) {

   455

        EC_ERR("Failed to enter OPERATION mode!\n");

   456

        goto out_module_put;

   457

    }

   458

   459

    EC_INFO("Successfully requested master %i.\n", master_index);

   460

    return master;

   461

   462

 out_module_put:

   463

    module_put(master->device->module);

   464

 out_release:

   465

    atomic_inc(&master->available);

   466

 out_return:

   467

    return NULL;

   468

}

   469

   470

/*****************************************************************************/

   471

   472

/**

   473

   Releases a reserved EtherCAT master.

   474

   \ingroup RealtimeInterface

   475

*/

   476

   477

void ecrt_release_master(ec_master_t *master /**< EtherCAT master */)

   478

{

   479

    EC_INFO("Releasing master %i...\n", master->index);

   480

   481

    if (master->mode != EC_MASTER_MODE_OPERATION) {

   482

        EC_WARN("Master %i was was not requested!\n", master->index);

   483

        return;

   484

    }

   485

   486