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

    85

    86

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

    87

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

    88

    89

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

    90

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

    91

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

    92

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

    93

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

    94

    95

char *ec_master_version_str = EC_MASTER_VERSION;

    96

    97

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

    98

    99

/** \cond */

   100

   101

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

   102

MODULE_DESCRIPTION("EtherCAT master driver module");

   103

MODULE_LICENSE("GPL");

   104

MODULE_VERSION(EC_MASTER_VERSION);

   105

   106

module_param(main, charp, S_IRUGO);

   107

MODULE_PARM_DESC(main, "main device IDs");

   108

module_param(backup, charp, S_IRUGO);

   109

MODULE_PARM_DESC(backup, "backup device IDs");

   110

   111

/** \endcond */

   112

   113

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

   114

   115

/**

   116

   Module initialization.

   117

   Initializes \a ec_master_count masters.

   118

   \return 0 on success, else < 0

   119

*/

   120

   121

int __init ec_init_module(void)

   122

{

   123

    ec_master_t *master, *next;

   124

    ec_device_id_t *main_dev_id, *backup_dev_id;

   125

    unsigned int master_index = 0;

   126

   127

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

   128

   144

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

   145

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

   147

    }

   148

   149

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

   150

        goto out_cdev;

   151

   152

    // create as many masters as main device IDs present

   153

    if (!list_empty(&main_ids)) {

   154

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

   155

        main_dev_id =

   156

            list_entry(main_ids.next, ec_device_id_t, list);

   157

        backup_dev_id =

   158

            list_entry(backup_ids.next, ec_device_id_t, list);

   159

   160

        while (1) {

   161

            if (!(master = (ec_master_t *)

   162

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

   163

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

   164

                        master_index);

   165

                goto out_free_masters;

   166

            }

   167

   169

                        main_dev_id, backup_dev_id, 0))

   170

                goto out_free_masters;

   171

   172

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

   173

            master_index++;

   174

   175

            // last device IDs?

   176

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

   177

                break;

   178

   179

            // next device IDs

   180

            main_dev_id =

   181

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

   182

            backup_dev_id =

   183

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

   184

        }

   185

    }

   186

   187

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

   188

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

   189

    return 0;

   190

   191

out_free_masters:

   192

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

   193

        list_del(&master->list);

   194

        ec_master_destroy(master);

   195

    }

   196

    ec_device_id_clear_list(&main_ids);

   197

    ec_device_id_clear_list(&backup_ids);

   198

out_cdev:

   199

    unregister_chrdev_region(device_number, 1);

   204

    return -1;

   205

}

   206

   207

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

   208

   209

/**

   210

   Module cleanup.

   211

   Clears all master instances.

   212

*/

   213

   214

void __exit ec_cleanup_module(void)

   215

{

   216

    ec_master_t *master, *next;

   217

   218

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

   219

   220

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

   221

        list_del(&master->list);

   222

        ec_master_destroy(master);

   223

    }

   224

   225

    ec_device_id_clear_list(&main_ids);

   226

    ec_device_id_clear_list(&backup_ids);

   227

    unregister_chrdev_region(device_number, 1);

   230

   231

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

   232

}

   233

   234

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

   235

   236

/**

   273

   Gets a handle to a certain master.

   274

   \returns pointer to master

   275

*/

   276

   277

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

   278

{

   279

    ec_master_t *master;

   280

   281

    list_for_each_entry(master, &masters, list) {

   282

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

   283

    }

   284

   285

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

   286

    return NULL;

   287

}

   288

   289

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

   290

   291

/**

   292

   Outputs frame contents for debugging purposes.

   293

*/

   294

   295

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

   296

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

   297

                   )

   298

{

   299

    unsigned int i;

   300

   301

    EC_DBG("");

   302

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

   303

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

   304

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

   305

            printk("\n");

   306

            EC_DBG("");

   307

        }

   308

    }

   309

    printk("\n");

   310

}

   311

   312

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

   313

   314

/**

   315

   Outputs frame contents and differences for debugging purposes.

   316

*/

   317

   318

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

   319

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

   320

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

   321

                        )

   322

{

   323

    unsigned int i;

   324

   325

    EC_DBG("");

   326

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

   327

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

   328

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

   329

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

   330

            printk("\n");

   331

            EC_DBG("");

   332

        }

   333

    }

   334

    printk("\n");

   335

}

   336

   337

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

   338

   339

/**

   340

   Prints slave states in clear text.

   341

*/

   342

   343

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

   344

                       char *buffer /**< target buffer

   345

                                       (min. EC_STATE_STRING_SIZE bytes) */

   346

                       )

   347

{

   348

    off_t off = 0;

   349

    unsigned int first = 1;

   350

   351

    if (!states) {

   352

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

   353

        return off;

   354

    }

   355

   356

    if (states & EC_SLAVE_STATE_INIT) {

   357

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

   358

        first = 0;

   359

    }

   360

    if (states & EC_SLAVE_STATE_PREOP) {

   361

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

   362

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

   363

        first = 0;

   364

    }

   365

    if (states & EC_SLAVE_STATE_SAVEOP) {

   366

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

   367

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

   368

        first = 0;

   369

    }

   370

    if (states & EC_SLAVE_STATE_OP) {

   371

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

   372

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

   373

    }

   374

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   375

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

   376

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

   377

    }

   378

   379

    return off;

   380

}

   381

   382

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

   383

 *  Device interface

   384

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

   385

   386

/**

   387

   Offers an EtherCAT device to a certain master.

   388

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

   389

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

   390

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

   391

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

   392

   the pointer is written to zero.

   393

   \return 0 on success, else < 0

   394

   \ingroup DeviceInterface

   395

*/

   396

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

        )

   404

{

   405

    ec_master_t *master;

   406

    unsigned int i;

   407

   408

    list_for_each_entry(master, &masters, list) {

   409

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

   410

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

   411

            goto out_return;

   412

        }

   413

   414

        if (ec_device_id_check(master->main_device_id, net_dev,

   415

                    driver_name, device_index)) {

   416

   417

            EC_INFO("Accepting device %s:%u (", driver_name, device_index);

   418

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

   419

                printk("%02X", net_dev->dev_addr[i]);

   420

                if (i < ETH_ALEN - 1) printk(":");

   421

            }

   422

            printk(") for master %u.\n", master->index);

   423

   424

            if (master->device) {

   425

                EC_ERR("Master already has a device.\n");

   426

                goto out_up;

   427

            }

   428

   429

            if (!(master->device = (ec_device_t *)

   430

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

   431

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

   432

                goto out_up;

   433

            }

   434

   435

            if (ec_device_init(master->device, master,

   436

                        net_dev, poll, module)) {

   437

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

   438

                goto out_free;

   439

            }

   440

   441

            up(&master->device_sem);

   442

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

   443

            *ecdev = master->device; // offer accepted

   444

            return 0; // no error

   445

        }

   446

   447

        up(&master->device_sem);

   448

    }

   449

   450

    *ecdev = NULL; // offer declined

   451

    return 0; // no error

   452

   453

 out_free:

   454

    kfree(master->device);

   455

    master->device = NULL;

   456

 out_up:

   457

    up(&master->device_sem);

   458

 out_return:

   459

    return 1;

   460

}

   461

   462

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

   463

   464

/**

   465

   Withdraws an EtherCAT device from the master.

   466

   The device is disconnected from the master and all device ressources

   467

   are freed.

   468

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

   469

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

   470

   \ingroup DeviceInterface

   471

*/

   472

   473

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

   474

{

   475

    ec_master_t *master = device->master;

   476

    unsigned int i;

   477

   478

    down(&master->device_sem);

   479

   480

    EC_INFO("Master %u releasing device ", master->index);

   481

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

   482

        printk("%02X", device->dev->dev_addr[i]);

   483

        if (i < ETH_ALEN - 1) printk(":");

   484

    }

   485

    printk(".\n");

   486

   487

    ec_device_clear(master->device);

   488

    kfree(master->device);

   489

    master->device = NULL;