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

#include "xmldev.h"

    49

    50

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

    51

    52

int __init ec_init_module(void);

    53

void __exit ec_cleanup_module(void);

    54

    55

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

    56

    57

struct kobject ec_kobj; /**< kobject for master module */

    58

    59

static char *main; /**< main devices parameter */

    60

static char *backup; /**< backup devices parameter */

    61

    62

static LIST_HEAD(main_ids); /**< list of main device IDs */

    63

static LIST_HEAD(backup_ids); /**< list of main device IDs */

    64

static LIST_HEAD(masters); /**< list of masters */

    65

static dev_t device_number; /**< XML character device number */

    66

ec_xmldev_t xmldev; /**< XML character device */

    67

    68

char *ec_master_version_str = EC_MASTER_VERSION;

    69

    70

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

    71

    72

/** \cond */

    73

    74

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

    75

MODULE_DESCRIPTION("EtherCAT master driver module");

    76

MODULE_LICENSE("GPL");

    77

MODULE_VERSION(EC_MASTER_VERSION);

    78

    79

module_param(main, charp, S_IRUGO);

    80

MODULE_PARM_DESC(main, "main device IDs");

    81

module_param(backup, charp, S_IRUGO);

    82

MODULE_PARM_DESC(backup, "backup device IDs");

    83

    84

/** \endcond */

    85

    86

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

    87

    88

/**

    89

   Module initialization.

    90

   Initializes \a ec_master_count masters.

    91

   \return 0 on success, else < 0

    92

*/

    93

    94

int __init ec_init_module(void)

    95

{

    96

    ec_master_t *master, *next;

    97

    ec_device_id_t *main_dev_id, *backup_dev_id;

    98

    unsigned int master_index = 0;

    99

   100

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

   101

   102

    // init kobject and add it to the hierarchy

   103

    memset(&ec_kobj, 0x00, sizeof(struct kobject));

   104

    kobject_init(&ec_kobj); // no ktype

   105

   106

    if (kobject_set_name(&ec_kobj, "ethercat")) {

   107

        EC_ERR("Failed to set module kobject name.\n");

   108

        goto out_put;

   109

    }

   110

   111

    if (kobject_add(&ec_kobj)) {

   112

        EC_ERR("Failed to add module kobject.\n");

   113

        goto out_put;

   114

    }

   115

   116

    if (alloc_chrdev_region(&device_number, 0, 1, "EtherCAT")) {

   117

        EC_ERR("Failed to obtain device number!\n");

   118

        goto out_del;

   119

    }

   120

   121

    if (ec_device_id_process_params(main, backup, &main_ids, &backup_ids))

   122

        goto out_cdev;

   123

   124

    // create as many masters as main device IDs present

   125

    if (!list_empty(&main_ids)) {

   126

        // main_ids and backup_ids are of equal size at this point

   127

        main_dev_id =

   128

            list_entry(main_ids.next, ec_device_id_t, list);

   129

        backup_dev_id =

   130

            list_entry(backup_ids.next, ec_device_id_t, list);

   131

   132

        while (1) {

   133

            if (!(master = (ec_master_t *)

   134

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

   135

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

   136

                        master_index);

   137

                goto out_free_masters;

   138

            }

   139

   140

            if (ec_master_init(master, &ec_kobj, master_index,

   141

                        main_dev_id, backup_dev_id, 0))

   142

                goto out_free_masters;

   143

   144

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

   145

            master_index++;

   146

   147

            // last device IDs?

   148

            if (main_dev_id->list.next == &main_ids)

   149

                break;

   150

   151

            // next device IDs

   152

            main_dev_id =

   153

                list_entry(main_dev_id->list.next, ec_device_id_t, list);

   154

            backup_dev_id =

   155

                list_entry(backup_dev_id->list.next, ec_device_id_t, list);

   156

        }

   157

    }

   158

   159

    EC_INFO("%u master%s waiting for devices.\n",

   160

            master_index, (master_index == 1 ? "" : "s"));

   161

    return 0;

   162

   163

out_free_masters:

   164

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

   165

        list_del(&master->list);

   166

        ec_master_destroy(master);

   167

    }

   168

    ec_device_id_clear_list(&main_ids);

   169

    ec_device_id_clear_list(&backup_ids);

   170

out_cdev:

   171

    unregister_chrdev_region(device_number, 1);

   172

out_del:

   173

    kobject_del(&ec_kobj);

   174

out_put:

   175

    kobject_put(&ec_kobj);

   176

    return -1;

   177

}

   178

   179

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

   180

   181

/**

   182

   Module cleanup.

   183

   Clears all master instances.

   184

*/

   185

   186

void __exit ec_cleanup_module(void)

   187

{

   188

    ec_master_t *master, *next;

   189

   190

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

   191

   192

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

   193

        list_del(&master->list);

   194

        ec_master_destroy(master);

   195

    }

   196

   197

    ec_device_id_clear_list(&main_ids);

   198

    ec_device_id_clear_list(&backup_ids);

   199

    unregister_chrdev_region(device_number, 1);

   200

    kobject_del(&ec_kobj);

   201

    kobject_put(&ec_kobj);

   202

   203

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

   204

}

   205

   206

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

   207

   208

/**

   209

   Gets a handle to a certain master.

   210

   \returns pointer to master

   211

*/

   212

   213

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

   214

{

   215

    ec_master_t *master;

   216

   217

    list_for_each_entry(master, &masters, list) {

   218

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

   219

    }

   220

   221

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

   222

    return NULL;

   223

}

   224

   225

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

   226

   227

/**

   228

   Outputs frame contents for debugging purposes.

   229

*/

   230

   231

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

   232

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

   233

                   )

   234

{

   235

    unsigned int i;

   236

   237

    EC_DBG("");

   238

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

   239

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

   240

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

   241

            printk("\n");

   242

            EC_DBG("");

   243

        }

   244

    }

   245

    printk("\n");

   246

}

   247

   248

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

   249

   250

/**

   251

   Outputs frame contents and differences for debugging purposes.

   252

*/

   253

   254

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

   255

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

   256

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

   257

                        )

   258

{

   259

    unsigned int i;

   260

   261

    EC_DBG("");

   262

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

   263

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

   264

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

   265

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

   266

            printk("\n");

   267

            EC_DBG("");

   268

        }

   269

    }

   270

    printk("\n");

   271

}

   272

   273

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

   274

   275

/**

   276

   Prints slave states in clear text.

   277

*/

   278

   279

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

   280

                       char *buffer /**< target buffer

   281

                                       (min. EC_STATE_STRING_SIZE bytes) */

   282

                       )

   283

{

   284

    off_t off = 0;

   285

    unsigned int first = 1;

   286

   287

    if (!states) {

   288

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

   289

        return off;

   290

    }

   291

   292

    if (states & EC_SLAVE_STATE_INIT) {

   293

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

   294

        first = 0;

   295

    }

   296

    if (states & EC_SLAVE_STATE_PREOP) {

   297

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

   298

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

   299

        first = 0;

   300

    }

   301

    if (states & EC_SLAVE_STATE_SAVEOP) {

   302

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

   303

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

   304

        first = 0;

   305

    }

   306

    if (states & EC_SLAVE_STATE_OP) {

   307

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

   308

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

   309

    }

   310

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   311

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

   312

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

   313

    }

   314

   315

    return off;

   316

}

   317

   318

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

   319

 *  Device interface

   320

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

   321

   322

/**

   323

   Offers an EtherCAT device to a certain master.

   324

   The master decides, if it wants to use the device for EtherCAT operation,

   325

   or not. It is important, that the offered net_device is not used by

   326

   the kernel IP stack. If the master, accepted the offer, the address of

   327

   the newly created EtherCAT device is written to the ecdev pointer, else

   328

   the pointer is written to zero.

   329

   \return 0 on success, else < 0

   330

   \ingroup DeviceInterface

   331

*/

   332

   333

int ecdev_offer(struct net_device *net_dev, /**< net_device to offer */

   334

        ec_device_t **ecdev, /**< pointer to store a device on success */

   335

        const char *driver_name, /**< name of the network driver */

   336

        unsigned int device_index, /**< index of the supported device */

   337

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

   338

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

   339

        )

   340

{

   341

    ec_master_t *master;

   342

    char str[50]; // FIXME

   343

   344

    list_for_each_entry(master, &masters, list) {

   345

        if (ec_device_id_check(master->main_device_id, net_dev,

   346

                    driver_name, device_index)) {

   347

            ec_device_id_print(master->main_device_id, str);

   348

            EC_INFO("Accepting device %s for master %u.\n",

   349

                    str, master->index);

   350

   351

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

   352

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

   353

                return -1;

   354

            }

   355

   356

            if (master->main_device.dev) {

   357

                EC_ERR("Master %u already has a device attached.\n",

   358

                        master->index);

   359

                up(&master->device_sem);

   360

                return -1;

   361

            }

   362

   363

            ec_device_attach(&master->main_device, net_dev, poll, module);

   364

            up(&master->device_sem);

   365

   366

            sprintf(net_dev->name, "ec%u", master->index);

   367

            *ecdev = &master->main_device; // offer accepted

   368

            return 0; // no error

   369

        }

   370

    }

   371

   372

    *ecdev = NULL; // offer declined

   373

    return 0; // no error

   374

}

   375

   376

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

   377

   378

/**

   379

   Withdraws an EtherCAT device from the master.

   380

   The device is disconnected from the master and all device ressources

   381

   are freed.

   382

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

   383

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

   384

   \ingroup DeviceInterface

   385

*/

   386

   387

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

   388

{

   389

    ec_master_t *master = device->master;

   390

    char str[50]; // FIXME

   391

   392

    ec_device_id_print(master->main_device_id, str);

   393

   394

    EC_INFO("Master %u releasing main device %s.\n", master->index, str);

   395

   396

    down(&master->device_sem);

   397

    ec_device_detach(device);

   398

    up(&master->device_sem);

   399

}

   400

   401

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

   402

   403

/**

   404

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

   405

   \return 0 on success, else < 0

   406

   \ingroup DeviceInterface

   407

*/

   408

   409

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

   410

{

   411

    if (ec_device_open(device)) {

   412

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

   413

        return -1;

   414

    }

   415

   416

    if (ec_master_enter_idle_mode(device->master)) {

   417

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

   418

        return -1;

   419

    }

   420

   421

    return 0;

   422

}

   423

   424

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

   425

   426

/**

   427

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

   428

   \return 0 on success, else < 0

   429

   \ingroup DeviceInterface

   430

*/

   431

   432

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

   433

{

   434

    ec_master_leave_idle_mode(device->master);

   435

   436

    if (ec_device_close(device))

   437

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

   438

}

   439

   440

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

   441

 *  Realtime interface

   442

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

   443

   444

/**

   445

 * Returns the version magic of the realtime interface.

   446

 * \return ECRT version magic.

   447

 * \ingroup RealtimeInterface

   448

 */

   449

   450

unsigned int ecrt_version_magic(void)

   451

{

   452

    return ECRT_VERSION_MAGIC;

   453

}

   454

   455

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

   456

   457

/**

   458

   Reserves an EtherCAT master for realtime operation.

   459

   \return pointer to reserved master, or NULL on error

   460

   \ingroup RealtimeInterface

   461

*/

   462

   463

ec_master_t *ecrt_request_master(unsigned int master_index

   464

                                 /**< master index */

   465

                                 )

   466

{

   467

    ec_master_t *master;

   468

   469

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

   470

   471

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

   472

   473

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

   474

        atomic_inc(&master->available);

   475

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

   476

        goto out_return;

   477

    }

   478

   479

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

   480

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

   481

        goto out_release;

   482

    }

   483

   484

    if (master->mode != EC_MASTER_MODE_IDLE) {

   485

        up(&master->device_sem);

   486

        EC_ERR("Master %i still waiting for devices!\n", master_index);

   487

        goto out_release;