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

#define MAX_MASTERS 5 /**< maximum number of masters */

    53

    54

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

    55

    56

int __init ec_init_module(void);

    57

void __exit ec_cleanup_module(void);

    58

    59

static int ec_mac_parse(uint8_t *, const char *, int);

    60

    61

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

    62

    63

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

    64

    65

static char *main[MAX_MASTERS]; /**< main devices parameter */

    66

static char *backup[MAX_MASTERS]; /**< backup devices parameter */

    67

    68

static ec_master_t *masters; /**< master array */

    69

static struct semaphore master_sem; /**< master semaphore */

    70

static unsigned int master_count; /**< number of masters */

    71

static unsigned int backup_count; /**< number of backup devices */

    72

    73

static uint8_t macs[MAX_MASTERS][2][ETH_ALEN]; /**< MAC addresses */

    74

    75

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

    76

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

    77

    78

char *ec_master_version_str = EC_MASTER_VERSION;

    79

    80

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

    81

    82

/** \cond */

    83

    84

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

    85

MODULE_DESCRIPTION("EtherCAT master driver module");

    86

MODULE_LICENSE("GPL");

    87

MODULE_VERSION(EC_MASTER_VERSION);

    88

    89

module_param_array(main, charp, &master_count, S_IRUGO);

    90

MODULE_PARM_DESC(main, "MAC addresses of main devices");

    91

module_param_array(backup, charp, &backup_count, S_IRUGO);

    92

MODULE_PARM_DESC(backup, "MAC addresses of backup devices");

    93

    94

/** \endcond */

    95

    96

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

    97

    98

/**

    99

 * Module initialization.

   100

 * Initializes \a ec_master_count masters.

   101

 * \return 0 on success, else < 0

   102

 */

   103

   104

int __init ec_init_module(void)

   105

{

   106

    int i, ret = 0;

   107

   108

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

   109

   110

    init_MUTEX(&master_sem);

   111

   112

    // init kobject and add it to the hierarchy

   113

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

   114

    kobject_init(&kobj); // no ktype

   115

   116

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

   117

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

   118

        ret = -ENOMEM;

   119

        goto out_put;

   120

    }

   121

   122

    if (kobject_add(&kobj)) {

   123

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

   124

        ret = -EEXIST;

   125

        goto out_put;

   126

    }

   127

   128

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

   129

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

   130

        ret = -EBUSY;

   131

        goto out_del;

   132

    }

   133

   134

    // zero MAC addresses

   135

    memset(macs, 0x00, sizeof(uint8_t) * MAX_MASTERS * 2 * ETH_ALEN);

   136

   137

    // process MAC parameters

   138

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

   139

        if (ec_mac_parse(macs[i][0], main[i], 0)) {

   140

            ret = -EINVAL;

   141

            goto out_cdev;

   142

        }

   143

   144

        if (i < backup_count && ec_mac_parse(macs[i][1], backup[i], 1)) {

   145

            ret = -EINVAL;

   146

            goto out_cdev;

   147

        }

   148

    }

   149

   150

    if (master_count) {

   151

        if (!(masters = kmalloc(sizeof(ec_master_t) * master_count,

   152

                        GFP_KERNEL))) {

   153

            EC_ERR("Failed to allocate memory for EtherCAT masters.\n");

   154

            ret = -ENOMEM;

   155

            goto out_cdev;

   156

        }

   157

    }

   158

   159

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

   160

        if (ec_master_init(&masters[i], &kobj, i, macs[i][0], macs[i][1])) {

   161

            ret = -EIO;

   162

            goto out_free_masters;

   163

        }

   164

    }

   165

   166

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

   167

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

   168

    return ret;

   169

   170

out_free_masters:

   171

    for (i--; i >= 0; i--) ec_master_clear(&masters[i]);

   172

    kfree(masters);

   173

out_cdev:

   174

    unregister_chrdev_region(device_number, 1);

   175

out_del:

   176

    kobject_del(&kobj);

   177

out_put:

   178

    kobject_put(&kobj);

   179

    return ret;

   180

}

   181

   182

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

   183

   184

/**

   185

   Module cleanup.

   186

   Clears all master instances.

   187

*/

   188

   189

void __exit ec_cleanup_module(void)

   190

{

   191

    unsigned int i;

   192

   193

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

   194

        ec_master_clear(&masters[i]);

   195

    }

   196

    if (master_count)

   197

        kfree(masters);

   198

   199

    unregister_chrdev_region(device_number, 1);

   200

    kobject_del(&kobj);

   201

    kobject_put(&kobj);

   202

   203

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

   204

}

   205

   206

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

   207

 * MAC address functions

   208

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

   209

   210

int ec_mac_equal(const uint8_t *mac1, const uint8_t *mac2)

   211

{

   212

    unsigned int i;

   213

   214

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

   215

        if (mac1[i] != mac2[i])

   216

            return 0;

   217

   218

    return 1;

   219

}

   220

   221

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

   222

   223

ssize_t ec_mac_print(const uint8_t *mac, char *buffer)

   224

{

   225

    off_t off = 0;

   226

    unsigned int i;

   227

   228

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

   229

        off += sprintf(buffer + off, "%02X", mac[i]);

   230

        if (i < ETH_ALEN - 1) off += sprintf(buffer + off, ":");

   231

    }

   232

   233

    return off;

   234

}

   235

   236

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

   237

   238

int ec_mac_is_zero(const uint8_t *mac)

   239

{

   240

    unsigned int i;

   241

   242

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

   243

        if (mac[i])

   244

            return 0;

   245

   246

    return 1;

   247

}

   248

   249

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

   250

   251

int ec_mac_is_broadcast(const uint8_t *mac)

   252

{

   253

    unsigned int i;

   254

   255

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

   256

        if (mac[i] != 0xff)

   257

            return 0;

   258

   259

    return 1;

   260

}

   261

   262

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

   263

   264

static int ec_mac_parse(uint8_t *mac, const char *src, int allow_empty)

   265

{

   266

    unsigned int i, value;

   267

    const char *orig = src;

   268

    char *rem;

   269

   270

    if (!strlen(src)) {

   271

        if (allow_empty){

   272

            return 0;

   273

        }

   274

        else {

   275

            EC_ERR("MAC address may not be empty.\n");

   276

            return -EINVAL;

   277

        }

   278

    }

   279

   280

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

   281

        value = simple_strtoul(src, &rem, 16);

   282

        if (rem != src + 2

   283

                || value > 0xFF

   284

                || (i < ETH_ALEN - 1 && *rem != ':')) {

   285

            EC_ERR("Invalid MAC address \"%s\".\n", orig);

   286

            return -EINVAL;

   287

        }

   288

        mac[i] = value;

   289

        if (i < ETH_ALEN - 1)

   290

            src = rem + 1; // skip colon

   291

    }

   292

   293

    return 0;

   294

}

   295

   296

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

   297

   298

/**

   299

   Outputs frame contents for debugging purposes.

   300

*/

   301

   302

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

   303

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

   304

                   )

   305

{

   306

    unsigned int i;

   307

   308

    EC_DBG("");

   309

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

   310

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

   311

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

   312

            printk("\n");

   313

            EC_DBG("");

   314

        }

   315

    }

   316

    printk("\n");

   317

}

   318

   319

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

   320

   321

/**

   322

   Outputs frame contents and differences for debugging purposes.

   323

*/

   324

   325

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

   326

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

   327

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

   328

                        )

   329

{

   330

    unsigned int i;

   331

   332

    EC_DBG("");

   333

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

   334

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

   335

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

   336

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

   337

            printk("\n");

   338

            EC_DBG("");

   339

        }

   340

    }

   341

    printk("\n");

   342

}

   343

   344

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

   345

   346

/**

   347

   Prints slave states in clear text.

   348

*/

   349

   350

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

   351

                       char *buffer /**< target buffer

   352

                                       (min. EC_STATE_STRING_SIZE bytes) */

   353

                       )

   354

{

   355

    off_t off = 0;

   356

    unsigned int first = 1;

   357

   358

    if (!states) {

   359

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

   360

        return off;

   361

    }

   362

   363

    if (states & EC_SLAVE_STATE_INIT) {

   364

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

   365

        first = 0;

   366

    }

   367

    if (states & EC_SLAVE_STATE_PREOP) {

   368

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

   369

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

   370

        first = 0;

   371

    }

   372

    if (states & EC_SLAVE_STATE_SAVEOP) {

   373

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

   374

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

   375

        first = 0;

   376

    }

   377

    if (states & EC_SLAVE_STATE_OP) {

   378

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

   379

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

   380

    }

   381

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   382

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

   383

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

   384

    }

   385

   386

    return off;

   387

}

   388

   389

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

   390

 *  Device interface

   391

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

   392

   393

/**

   394

   Offers an EtherCAT device to a certain master.

   395

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

   396

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

   397

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

   398

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

   399

   the pointer is written to zero.

   400

   \return 0 on success, else < 0

   401

   \ingroup DeviceInterface

   402

*/

   403

   404

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

   405

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

   406

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

   407

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

   408

        )

   409

{

   410

    ec_master_t *master;

   411

    char str[20];

   412

    unsigned int i;

   413

   414

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

   415

        master = &masters[i];

   416

   417

        down(&master->device_sem);

   418

        if (master->main_device.dev) { // master already has a device

   419

            up(&master->device_sem);

   420

            continue;

   421

        }

   422

   423

        if (ec_mac_equal(master->main_mac, net_dev->dev_addr)

   424

                || ec_mac_is_broadcast(master->main_mac)) {

   425

            ec_mac_print(net_dev->dev_addr, str);

   426

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

   427

                    str, master->index);

   428

   429

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

   430

            up(&master->device_sem);

   431

   432

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

   433

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

   434

            return 0; // no error

   435

        }

   436

        else {

   437

            up(&master->device_sem);

   438

   439

            if (master->debug_level) {

   440

                ec_mac_print(net_dev->dev_addr, str);

   441

                EC_DBG("Master %u declined device %s.\n", master->index, str);

   442

            }

   443

        }

   444

    }

   445

   446

    *ecdev = NULL; // offer declined

   447

    return 0; // no error

   448

}

   449

   450

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

   451

   452

/**

   453

   Withdraws an EtherCAT device from the master.

   454

   The device is disconnected from the master and all device ressources

   455

   are freed.

   456

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

   457

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

   458

   \ingroup DeviceInterface

   459

*/

   460

   461

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

   462

{

   463

    ec_master_t *master = device->master;

   464

    char str[20];

   465

   466

    ec_mac_print(device->dev->dev_addr, str);

   467

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

   468

   469

    down(&master->device_sem);

   470

    ec_device_detach(device);

   471

    up(&master->device_sem);

   472

}

   473

   474

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

   475

   476

/**

   477

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

   478

   \return 0 on success, else < 0

   479

   \ingroup DeviceInterface

   480

*/

   481

   482

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

   483

{

   484

    if (ec_device_open(device)) {

   485

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

   486

        return -1;

   487

    }

   488

   489

    if (ec_master_enter_idle_mode(device->master)) {