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; /**< master version string */

    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

/**

   211

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

   212

 */

   213

   214

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

   215

{

   216

    unsigned int i;

   217

   218

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

   219

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

   220

            return 0;

   221

   222

    return 1;

   223

}

   224

   225

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

   226

   227

/**

   228

 * Print a MAC address to a buffer.

   229

 * \return number of bytes written.

   230

 */

   231

   232

ssize_t ec_mac_print(

   233

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

   234

        char *buffer /**< target buffer */

   235

        )

   236

{

   237

    off_t off = 0;

   238

    unsigned int i;

   239

   240

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

   241

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

   242

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

   243

    }

   244

   245

    return off;

   246

}

   247

   248

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

   249

   250

/**

   251

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

   252

 */

   253

   254

int ec_mac_is_zero(const uint8_t *mac)

   255

{

   256

    unsigned int i;

   257

   258

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

   259

        if (mac[i])

   260

            return 0;

   261

   262

    return 1;

   263

}

   264

   265

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

   266

   267

/**

   268

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

   269

 */

   270

   271

int ec_mac_is_broadcast(const uint8_t *mac)

   272

{

   273

    unsigned int i;

   274

   275

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

   276

        if (mac[i] != 0xff)

   277

            return 0;

   278

   279

    return 1;

   280

}

   281

   282

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

   283

   284

/**

   285

 * Parse a MAC address from a string.

   286

 * The MAC address must follow the regexp

   287

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

   288

   \return 0 on success, else < 0

   289

 */

   290

   291

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

   292

{

   293

    unsigned int i, value;

   294

    const char *orig = src;

   295

    char *rem;

   296

   297

    if (!strlen(src)) {

   298

        if (allow_empty){

   299

            return 0;

   300

        }

   301

        else {

   302

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

   303

            return -EINVAL;

   304

        }

   305

    }

   306

   307

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

   308

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

   309

        if (rem != src + 2

   310

                || value > 0xFF

   311

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

   312

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

   313

            return -EINVAL;

   314

        }

   315

        mac[i] = value;

   316

        if (i < ETH_ALEN - 1)

   317

            src = rem + 1; // skip colon

   318

    }

   319

   320

    return 0;

   321

}

   322

   323

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

   324

   325

/**

   326

   Outputs frame contents for debugging purposes.

   327

*/

   328

   329

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

   330

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

   331

                   )

   332

{

   333

    unsigned int i;

   334

   335

    EC_DBG("");

   336

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

   337

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

   338

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

   339

            printk("\n");

   340

            EC_DBG("");

   341

        }

   342

    }

   343

    printk("\n");

   344

}

   345

   346

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

   347

   348

/**

   349

   Outputs frame contents and differences for debugging purposes.

   350

*/

   351

   352

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

   353

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

   354

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

   355

                        )

   356

{

   357

    unsigned int i;

   358

   359

    EC_DBG("");

   360

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

   361

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

   362

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

   363

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

   364

            printk("\n");

   365

            EC_DBG("");

   366

        }

   367

    }

   368

    printk("\n");

   369

}

   370

   371

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

   372

   373

/**

   374

   Prints slave states in clear text.

   375

*/

   376

   377

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

   378

                       char *buffer /**< target buffer

   379

                                       (min. EC_STATE_STRING_SIZE bytes) */

   380

                       )

   381

{

   382

    off_t off = 0;

   383

    unsigned int first = 1;

   384

   385

    if (!states) {

   386

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

   387

        return off;

   388

    }

   389

   390

    if (states & EC_SLAVE_STATE_INIT) {

   391

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

   392

        first = 0;

   393

    }

   394

    if (states & EC_SLAVE_STATE_PREOP) {

   395

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

   396

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

   397

        first = 0;

   398

    }

   399

    if (states & EC_SLAVE_STATE_SAVEOP) {

   400

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

   401

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

   402

        first = 0;

   403

    }

   404

    if (states & EC_SLAVE_STATE_OP) {

   405

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

   406

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

   407

    }

   408

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   409

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

   410

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

   411

    }

   412

   413

    return off;

   414

}

   415

   416

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

   417

 *  Device interface

   418

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

   419

   420

/**

   421

   Offers an EtherCAT device to a certain master.

   422

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

   423

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

   424

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

   425

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

   426

   the pointer is written to zero.

   427

   \return 0 on success, else < 0

   428

   \ingroup DeviceInterface

   429

*/

   430

   431

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

   432

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

   433

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

   434

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

   435

        )

   436

{

   437

    ec_master_t *master;

   438

    char str[20];

   439

    unsigned int i;

   440

   441

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

   442

        master = &masters[i];

   443

   444

        down(&master->device_sem);

   445

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

   446

            up(&master->device_sem);

   447

            continue;

   448

        }

   449

   450

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

   451

                || ec_mac_is_broadcast(master->main_mac)) {

   452

            ec_mac_print(net_dev->dev_addr, str);

   453

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

   454

                    str, master->index);

   455

   456

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

   457

            up(&master->device_sem);

   458

   459

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

   460

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

   461

            return 0; // no error

   462

        }

   463

        else {

   464

            up(&master->device_sem);

   465

   466

            if (master->debug_level) {

   467

                ec_mac_print(net_dev->dev_addr, str);

   468

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

   469

            }

   470

        }

   471

    }

   472

   473

    *ecdev = NULL; // offer declined

   474

    return 0; // no error

   475

}

   476

   477

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

   478

   479

/**

   480

   Withdraws an EtherCAT device from the master.

   481

   The device is disconnected from the master and all device ressources

   482

   are freed.

   483

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

   484

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

   485

   \ingroup DeviceInterface

   486

*/

   487

   488

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

   489

{