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

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

    58

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

    59

    62

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

    63

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

    64

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

    65

    66

char *ec_master_version_str = EC_MASTER_VERSION;

    67

    68

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

    69

    70

/** \cond */

    71

    72

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

    73

MODULE_DESCRIPTION("EtherCAT master driver module");

    74

MODULE_LICENSE("GPL");

    75

MODULE_VERSION(EC_MASTER_VERSION);

    76

    77

module_param(main, charp, S_IRUGO);

    78

MODULE_PARM_DESC(main, "main device IDs");

    79

module_param(backup, charp, S_IRUGO);

    80

MODULE_PARM_DESC(backup, "backup device IDs");

    81

    82

/** \endcond */

    83

    84

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

    85

    86

/**

    87

   Module initialization.

    88

   Initializes \a ec_master_count masters.

    89

   \return 0 on success, else < 0

    90

*/

    91

    92

int __init ec_init_module(void)

    93

{

    94

    ec_master_t *master, *next;

    95

    ec_device_id_t *main_dev_id, *backup_dev_id;

    96

    unsigned int master_index = 0;

    97

    98

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

    99

   100

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

   101

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

   102

        goto out_return;

   103

    }

   104

   107

   111

        main_dev_id =

   113

        backup_dev_id =

   115

   116

        while (1) {

   117

            if (!(master = (ec_master_t *)

   118

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

   119

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

   120

                        master_index);

   121

                goto out_free_masters;

   122

            }

   123

   124

            if (ec_master_init(master, master_index,

   125

                        main_dev_id, backup_dev_id, 0))

   126

                goto out_free_masters;

   127

   128

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

   129

            master_index++;

   130

   131

            // last device IDs?

   133

                break;

   134

   135

            // next device IDs

   136

            main_dev_id =

   137

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

   138

            backup_dev_id =

   139

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

   140

        }

   141

    }

   142

   143

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

   144

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

   145

    return 0;

   146

   147

out_free_masters:

   148

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

   149

        list_del(&master->list);

   155

    unregister_chrdev_region(device_number, 1);

   156

out_return:

   157

    return -1;

   158

}

   159

   160

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

   161

   162

/**

   163

   Module cleanup.

   164

   Clears all master instances.

   165

*/

   166

   167

void __exit ec_cleanup_module(void)

   168

{

   169

    ec_master_t *master, *next;

   170

   172

   173

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

   174

        list_del(&master->list);

   175

        ec_master_destroy(master);

   176

    }

   177

   180

    unregister_chrdev_region(device_number, 1);

   181

   183

}

   184

   185

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

   186

   187

/**

   188

   Gets a handle to a certain master.

   189

   \returns pointer to master

   190

*/

   191

   192

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

   193

{

   194

    ec_master_t *master;

   195

   196

    list_for_each_entry(master, &masters, list) {

   197

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

   198

    }

   199

   200

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

   201

    return NULL;

   202

}

   203

   204

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

   205

   206

/**

   207

   Outputs frame contents for debugging purposes.

   208

*/

   209

   210

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

   211

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

   212

                   )

   213

{

   214

    unsigned int i;

   215

   216

    EC_DBG("");

   217

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

   218

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

   219

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

   220

            printk("\n");

   221

            EC_DBG("");

   222

        }

   223

    }

   224

    printk("\n");

   225

}

   226

   227

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

   228

   229

/**

   230

   Outputs frame contents and differences for debugging purposes.

   231

*/

   232

   233

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

   234

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

   235

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

   236

                        )

   237

{

   238

    unsigned int i;

   239

   240

    EC_DBG("");

   241

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

   242

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

   243

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

   244

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

   245

            printk("\n");

   246

            EC_DBG("");

   247

        }

   248

    }

   249

    printk("\n");

   250

}

   251

   252

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

   253

   254

/**

   255

   Prints slave states in clear text.

   256

*/

   257

   258

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

   259

                       char *buffer /**< target buffer

   260

                                       (min. EC_STATE_STRING_SIZE bytes) */

   261

                       )

   262

{

   263

    off_t off = 0;

   264

    unsigned int first = 1;

   265

   266

    if (!states) {

   267

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

   268

        return off;

   269

    }

   270

   271

    if (states & EC_SLAVE_STATE_INIT) {

   272

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

   273

        first = 0;

   274

    }

   275

    if (states & EC_SLAVE_STATE_PREOP) {

   276

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

   277

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

   278

        first = 0;

   279

    }

   280

    if (states & EC_SLAVE_STATE_SAVEOP) {

   281

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

   282

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

   283

        first = 0;

   284

    }

   285

    if (states & EC_SLAVE_STATE_OP) {

   286

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

   287

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

   288

    }

   289

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   290

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

   291

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

   292

    }

   293

   294

    return off;

   295

}

   296

   297

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

   298

 *  Device interface

   299

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

   300

   301

/**

   302

   Offers an EtherCAT device to a certain master.

   303

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

   304

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

   305

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

   306

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

   307

   the pointer is written to zero.

   308

   \return 0 on success, else < 0

   309

   \ingroup DeviceInterface

   310

*/

   311

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

        )

   319

{

   320

    ec_master_t *master;

   321

    unsigned int i;

   322

   323

    list_for_each_entry(master, &masters, list) {

   324

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

   325

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

   326

            goto out_return;

   327

        }

   328

   330

                    driver_name, device_index)) {

   331

   332

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

   333

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

   334

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

   335

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

   336

            }

   337

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

   338

   339

            if (master->device) {

   340

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

   341

                goto out_up;

   342

            }

   343

   344

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

   345

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

   346

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

   347

                goto out_up;

   348

            }

   349

   350

            if (ec_device_init(master->device, master,

   351

                        net_dev, poll, module)) {

   352

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

   353

                goto out_free;

   354

            }

   355

   356

            up(&master->device_sem);

   357

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

   358

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

   359

            return 0; // no error

   360

        }

   361

   362

        up(&master->device_sem);

   363

    }

   364

   365

    *ecdev = NULL; // offer declined

   366

    return 0; // no error

   367

   368

 out_free:

   369

    kfree(master->device);

   370

    master->device = NULL;

   371

 out_up:

   372

    up(&master->device_sem);

   373

 out_return:

   374

    return 1;

   375

}

   376

   377

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

   378

   379

/**

   380

   Withdraws an EtherCAT device from the master.

   381

   The device is disconnected from the master and all device ressources

   382

   are freed.

   383

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

   384

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

   385

   \ingroup DeviceInterface

   386

*/

   387

   388

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

   389

{

   390

    ec_master_t *master = device->master;

   391

    unsigned int i;

   392

   393

    down(&master->device_sem);

   394

   395

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

   396

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

   397

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

   398

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

   399

    }

   400

    printk(".\n");

   401

   402

    ec_device_clear(master->device);

   403

    kfree(master->device);

   404

    master->device = NULL;

   405

   406

    up(&master->device_sem);

   407

}

   408

   409

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

   410

   411

/**

   412

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

   413

   \return 0 on success, else < 0

   414

   \ingroup DeviceInterface

   415

*/

   416

   417

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

   418

{

   419

    if (ec_device_open(device)) {

   420

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

   421

        return -1;

   422

    }

   423

   424

    if (ec_master_enter_idle_mode(device->master)) {

   425

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

   426

        return -1;

   427

    }

   428

   429

    return 0;

   430

}

   431

   432

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

   433

   434

/**

   435

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

   436

   \return 0 on success, else < 0

   437

   \ingroup DeviceInterface

   438

*/

   439

   440

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

   441

{

   442

    ec_master_leave_idle_mode(device->master);

   443

   444

    if (ec_device_close(device))

   445

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

   446

}

   447

   448

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

   449

 *  Realtime interface

   450

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

   451

   452

/**

   453

 * Returns the version magic of the realtime interface.

   454

 * \return ECRT version magic.

   455

 * \ingroup RealtimeInterface

   456

 */

   457

   458

unsigned int ecrt_version_magic(void)

   459

{

   460

    return ECRT_VERSION_MAGIC;

   461

}

   462

   463

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

   464

   465

/**

   466

   Reserves an EtherCAT master for realtime operation.

   467

   \return pointer to reserved master, or NULL on error

   468

   \ingroup RealtimeInterface

   469

*/

   470

   471

ec_master_t *ecrt_request_master(unsigned int master_index

   472

                                 /**< master index */

   473

                                 )

   474

{

   475

    ec_master_t *master;

   476

   477

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

   478

   479

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

   480

   481

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

   482

        atomic_inc(&master->available);

   483

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

   484

        goto out_return;

   485

    }

   486

   487

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

   488

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