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

    37

    38

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

    39

    40

#include <linux/module.h>

    41

#include <linux/kernel.h>

    42

#include <linux/init.h>

    43

    44

#include "globals.h"

    45

#include "master.h"

    46

#include "device.h"

    47

#include "xmldev.h"

    48

    49

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

    50

    52

    53

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

    54

    55

int __init ec_init_module(void);

    56

void __exit ec_cleanup_module(void);

    57

    58

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

    59

    60

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

    61

    62

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

    63

    64

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

    65

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

    66

    67

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

    68

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

    69

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

    70

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

    71

    72

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

    73

    74

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

    75

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

    76

    77

char *ec_master_version_str = EC_MASTER_VERSION; /**< master version string */

    78

    79

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

    80

    81

/** \cond */

    82

    83

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

    84

MODULE_DESCRIPTION("EtherCAT master driver module");

    85

MODULE_LICENSE("GPL");

    86

MODULE_VERSION(EC_MASTER_VERSION);

    87

    88

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

    89

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

    90

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

    91

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

    92

    93

/** \endcond */

    94

    95

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

    96

    97

/**

    98

 * Module initialization.

    99

 * Initializes \a ec_master_count masters.

   100

 * \return 0 on success, else < 0

   101

 */

   102

   103

int __init ec_init_module(void)

   104

{

   105

    int i, ret = 0;

   106

   107

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

   108

   109

    init_MUTEX(&master_sem);

   110

   111

    // init kobject and add it to the hierarchy

   112

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

   113

    kobject_init(&kobj); // no ktype

   114

   115

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

   116

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

   117

        ret = -ENOMEM;

   118

        goto out_put;

   119

    }

   120

   121

    if (kobject_add(&kobj)) {

   122

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

   123

        ret = -EEXIST;

   124

        goto out_put;

   125

    }

   126

   127

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

   128

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

   129

        ret = -EBUSY;

   130

        goto out_del;

   131

    }

   132

   133

    // zero MAC addresses

   134

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

   135

   136

    // process MAC parameters

   137

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

   138

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

   139

            ret = -EINVAL;

   140

            goto out_cdev;

   141

        }

   142

   143

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

   144

            ret = -EINVAL;

   145

            goto out_cdev;

   146

        }

   147

    }

   148

   149

    if (master_count) {

   150

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

   151

                        GFP_KERNEL))) {

   152

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

   153

            ret = -ENOMEM;

   154

            goto out_cdev;

   155

        }

   156

    }

   157

   158

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

   159

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

   160

            ret = -EIO;

   161

            goto out_free_masters;

   162

        }

   163

    }

   164

   165

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

   166

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

   167

    return ret;

   168

   169

out_free_masters:

   170

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

   171

    kfree(masters);

   172

out_cdev:

   173

    unregister_chrdev_region(device_number, 1);

   174

out_del:

   175

    kobject_del(&kobj);

   176

out_put:

   177

    kobject_put(&kobj);

   178

    return ret;

   179

}

   180

   181

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

   182

   183

/**

   184

   Module cleanup.

   185

   Clears all master instances.

   186

*/

   187

   188

void __exit ec_cleanup_module(void)

   189

{

   190

    unsigned int i;

   191

   192

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

   193

        ec_master_clear(&masters[i]);

   194

    }

   195

    if (master_count)

   196

        kfree(masters);

   197

   198

    unregister_chrdev_region(device_number, 1);

   199

    kobject_del(&kobj);

   200

    kobject_put(&kobj);

   201

   202

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

   203

}

   204

   205

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

   206

 * MAC address functions

   207

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

   208

   209

/**

   210

 * \return true, if two MAC addresses are equal.

   211

 */

   212

   213

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

   214

{

   215

    unsigned int i;

   216

   217

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

   218

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

   219

            return 0;

   220

   221

    return 1;

   222

}

   223

   224

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

   225

   226

/**

   227

 * Print a MAC address to a buffer.

   228

 * \return number of bytes written.

   229

 */

   230

   231

ssize_t ec_mac_print(

   232

        const uint8_t *mac, /**< MAC address */

   233

        char *buffer /**< target buffer */

   234

        )

   235

{

   236

    off_t off = 0;

   237

    unsigned int i;

   238

   239

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

   240

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

   241

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

   242

    }

   243

   244

    return off;

   245

}

   246

   247

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

   248

   249

/**

   250

 * \return true, if the MAC address is all-zero.

   251

 */

   252

   253

int ec_mac_is_zero(const uint8_t *mac)

   254

{

   255

    unsigned int i;

   256

   257

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

   258

        if (mac[i])

   259

            return 0;

   260

   261

    return 1;

   262

}

   263

   264

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

   265

   266

/**

   267

 * \return true, if the given MAC address is the broadcast address.

   268

 */

   269

   270

int ec_mac_is_broadcast(const uint8_t *mac)

   271

{

   272

    unsigned int i;

   273

   274

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

   275

        if (mac[i] != 0xff)

   276

            return 0;

   277

   278

    return 1;

   279

}

   280

   281

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

   282

   283

/**

   284

 * Parse a MAC address from a string.

   285

 * The MAC address must follow the regexp

   286

 * "([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}".

   287

   \return 0 on success, else < 0

   288

 */

   289

   290

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

   291

{

   292

    unsigned int i, value;

   293

    const char *orig = src;

   294

    char *rem;

   295

   296

    if (!strlen(src)) {

   297

        if (allow_empty){

   298

            return 0;

   299

        }

   300

        else {

   301

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

   302

            return -EINVAL;

   303

        }

   304

    }

   305

   306

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

   307

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

   308

        if (rem != src + 2

   309

                || value > 0xFF

   310

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

   311

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

   312

            return -EINVAL;

   313

        }

   314

        mac[i] = value;

   315

        if (i < ETH_ALEN - 1)

   316

            src = rem + 1; // skip colon

   317

    }

   318

   319

    return 0;

   320

}

   321

   322

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

   323

   324

/**

   325

   Outputs frame contents for debugging purposes.

   326

*/

   327

   328

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

   329

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

   330

                   )

   331

{

   332

    unsigned int i;

   333

   334

    EC_DBG("");

   335

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

   336

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

   337

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

   338

            printk("\n");

   339

            EC_DBG("");

   340

        }

   341

    }

   342

    printk("\n");

   343

}

   344

   345

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

   346

   347

/**

   348

   Outputs frame contents and differences for debugging purposes.

   349

*/

   350

   351

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

   352

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

   353

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

   354

                        )

   355

{

   356

    unsigned int i;

   357

   358

    EC_DBG("");

   359

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

   360

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

   361

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

   362

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

   363

            printk("\n");

   364

            EC_DBG("");

   365

        }

   366

    }

   367

    printk("\n");

   368

}

   369

   370

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

   371

   372

/**

   373

   Prints slave states in clear text.

   374

*/

   375

   376

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

   377

                       char *buffer /**< target buffer

   378

                                       (min. EC_STATE_STRING_SIZE bytes) */

   379

                       )

   380

{

   381

    off_t off = 0;

   382

    unsigned int first = 1;

   383

   384

    if (!states) {

   385

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

   386

        return off;

   387

    }

   388

   389

    if (states & EC_SLAVE_STATE_INIT) {

   390

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

   391

        first = 0;

   392

    }

   393

    if (states & EC_SLAVE_STATE_PREOP) {

   394

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

   395

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

   396

        first = 0;

   397

    }

   398

    if (states & EC_SLAVE_STATE_SAVEOP) {

   399

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

   400

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

   401

        first = 0;

   402

    }

   403

    if (states & EC_SLAVE_STATE_OP) {

   404

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

   405

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

   406

    }

   407

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   408

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

   409

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

   410

    }

   411

   412

    return off;

   413

}

   414

   415

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

   416

 *  Device interface

   417

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

   418

   419

/**

   420

   Offers an EtherCAT device to a certain master.

   421

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

   422

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

   423

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

   424

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

   425

   the pointer is written to zero.

   426

   \return 0 on success, else < 0

   427

   \ingroup DeviceInterface

   428

*/

   429

   430

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

   431

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

   432

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

   433

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

   434

        )

   435

{

   436

    ec_master_t *master;

   437

    char str[20];

   438

    unsigned int i;

   439

   440

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

   441

        master = &masters[i];

   442

   443

        down(&master->device_sem);

   444

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

   445

            up(&master->device_sem);

   446

            continue;

   447

        }

   448

   449

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

   450

                || ec_mac_is_broadcast(master->main_mac)) {

   451

            ec_mac_print(net_dev->dev_addr, str);

   452

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

   453

                    str, master->index);

   454

   455

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

   456

            up(&master->device_sem);

   457

   458

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

   459

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

   460

            return 0; // no error

   461

        }

   462

        else {

   463

            up(&master->device_sem);

   464

   465

            if (master->debug_level) {

   466

                ec_mac_print(net_dev->dev_addr, str);

   467

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

   468

            }

   469

        }

   470

    }

   471

   472

    *ecdev = NULL; // offer declined

   473

    return 0; // no error

   474

}

   475

   476

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

   477

   478

/**

   479

   Withdraws an EtherCAT device from the master.

   480

   The device is disconnected from the master and all device ressources

   481

   are freed.

   482

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

   483

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

   484

   \ingroup DeviceInterface

   485

*/

   486

   487

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

   488

{

   489