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

/** \file

    35

 * EtherCAT master driver module.

    36

 */

    37

    38

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

    39

    40

#include <linux/module.h>

    41

    42

#include "globals.h"

    43

#include "master.h"

    44

#include "device.h"

    45

    46

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

    47

    48

#define MAX_MASTERS 5 /**< Maximum number of masters. */

    49

    50

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

    51

    52

int __init ec_init_module(void);

    53

void __exit ec_cleanup_module(void);

    54

    55

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

    56

    57

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

    58

    59

static char *main_devices[MAX_MASTERS]; /**< Main devices parameter. */

    60

static char *backup_devices[MAX_MASTERS]; /**< Backup devices parameter. */

    61

    62

static ec_master_t *masters; /**< Array of masters. */

    63

static struct semaphore master_sem; /**< Master semaphore. */

    64

static unsigned int master_count; /**< Number of masters. */

    65

static unsigned int backup_count; /**< Number of backup devices. */

    66

    67

dev_t device_number; /**< Device number for master cdevs. */

    68

    69

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

    70

    71

char *ec_master_version_str = EC_MASTER_VERSION; /**< Version string. */

    72

    73

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

    74

    75

/** \cond */

    76

    77

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

    78

MODULE_DESCRIPTION("EtherCAT master driver module");

    79

MODULE_LICENSE("GPL");

    80

MODULE_VERSION(EC_MASTER_VERSION);

    81

    82

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

    83

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

    84

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

    85

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

    86

    87

/** \endcond */

    88

    89

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

    90

    91

/** Module initialization.

    92

 *

    93

 * Initializes \a master_count masters.

    94

 * \return 0 on success, else < 0

    95

 */

    96

int __init ec_init_module(void)

    97

{

    98

    int i, ret = 0;

    99

   100

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

   101

   102

    init_MUTEX(&master_sem);

   103

   104

    if (master_count) {

   105

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

   106

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

   107

            ret = -EBUSY;

   108

            goto out_return;

   109

        }

   110

    }

   111

   112

    // zero MAC addresses

   113

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

   114

   115

    // process MAC parameters

   116

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

   117

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

   118

            ret = -EINVAL;

   119

            goto out_cdev;

   120

        }

   121

   122

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

   123

            ret = -EINVAL;

   124

            goto out_cdev;

   125

        }

   126

    }

   127

   128

    if (master_count) {

   129

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

   130

                        GFP_KERNEL))) {

   131

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

   132

            ret = -ENOMEM;

   133

            goto out_cdev;

   134

        }

   135

    }

   136

   137

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

   138

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

   139

                    device_number)) {

   140

            ret = -ENOMEM;

   141

            goto out_free_masters;

   142

        }

   143

    }

   144

   145

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

   146

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

   147

    return ret;

   148

   149

out_free_masters:

   150

    for (i--; i >= 0; i--)

   151

        ec_master_clear(&masters[i]);

   152

    kfree(masters);

   153

out_cdev:

   154

    unregister_chrdev_region(device_number, master_count);

   155

out_return:

   156

    return ret;

   157

}

   158

   159

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

   160

   161

/** Module cleanup.

   162

 *

   163

 * Clears all master instances.

   164

 */

   165

void __exit ec_cleanup_module(void)

   166

{

   167

    unsigned int i;

   168

   169

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

   170

        ec_master_clear(&masters[i]);

   171

    }

   172

    if (master_count) {

   173

        kfree(masters);

   174

        unregister_chrdev_region(device_number, master_count);

   175

    }

   176

   177

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

   178

}

   179

   180

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

   181

 * MAC address functions

   182

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

   183

   184

/**

   185

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

   186

 */

   187

int ec_mac_equal(

   188

        const uint8_t *mac1, /**< First MAC address. */

   189

        const uint8_t *mac2 /**< Second MAC address. */

   190

        )

   191

{

   192

    unsigned int i;

   193

   194

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

   195

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

   196

            return 0;

   197

   198

    return 1;

   199

}

   200

   201

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

   202

   203

/** Print a MAC address to a buffer.

   204

 *

   205

 * \return number of bytes written.

   206

 */

   207

ssize_t ec_mac_print(

   208

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

   209

        char *buffer /**< target buffer */

   210

        )

   211

{

   212

    off_t off = 0;

   213

    unsigned int i;

   214

   215

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

   216

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

   217

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

   218

    }

   219

   220

    return off;

   221

}

   222

   223

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

   224

   225

/**

   226

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

   227

 */

   228

int ec_mac_is_zero(

   229

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

   230

        )

   231

{

   232

    unsigned int i;

   233

   234

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

   235

        if (mac[i])

   236

            return 0;

   237

   238

    return 1;

   239

}

   240

   241

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

   242

   243

/**

   244

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

   245

 */

   246

int ec_mac_is_broadcast(

   247

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

   248

        )

   249

{

   250

    unsigned int i;

   251

   252

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

   253

        if (mac[i] != 0xff)

   254

            return 0;

   255

   256

    return 1;

   257

}

   258

   259

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

   260

   261

/** Parse a MAC address from a string.

   262

 *

   263

 * The MAC address must follow the regexp

   264

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

   265

 *

   266

 * \return 0 on success, else < 0

   267

 */

   268

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

   269

{

   270

    unsigned int i, value;

   271

    const char *orig = src;

   272

    char *rem;

   273

   274

    if (!strlen(src)) {

   275

        if (allow_empty){

   276

            return 0;

   277

        }

   278

        else {

   279

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

   280

            return -EINVAL;

   281

        }

   282

    }

   283

   284

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

   285

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

   286

        if (rem != src + 2

   287

                || value > 0xFF

   288

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

   289

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

   290

            return -EINVAL;

   291

        }

   292

        mac[i] = value;

   293

        if (i < ETH_ALEN - 1)

   294

            src = rem + 1; // skip colon

   295

    }

   296

   297

    return 0;

   298

}

   299

   300

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

   301

   302

/** Outputs frame contents for debugging purposes.

   303

 */

   304

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

   305

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

   306

                   )

   307

{

   308

    unsigned int i;

   309

   310

    EC_DBG("");

   311

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

   312

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

   313

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

   314

            printk("\n");

   315

            EC_DBG("");

   316

        }

   317

    }

   318

    printk("\n");

   319

}

   320

   321

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

   322

   323

/** Outputs frame contents and differences for debugging purposes.

   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

/** Prints slave states in clear text.

   347

 */

   348

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

   349

                       char *buffer /**< target buffer

   350

                                       (min. EC_STATE_STRING_SIZE bytes) */

   351

                       )

   352

{

   353

    off_t off = 0;

   354

    unsigned int first = 1;

   355

   356

    if (!states) {

   357

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

   358

        return off;

   359

    }

   360

   361

    if (states & EC_SLAVE_STATE_INIT) {

   362

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

   363

        first = 0;

   364

    }

   365

    if (states & EC_SLAVE_STATE_PREOP) {

   366

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

   367

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

   368

        first = 0;

   369

    }

   370

    if (states & EC_SLAVE_STATE_SAFEOP) {

   371

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

   372

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

   373

        first = 0;

   374

    }

   375

    if (states & EC_SLAVE_STATE_OP) {

   376

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

   377

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

   378

    }

   379

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   380

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

   381

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

   382

    }

   383

   384

    return off;

   385

}

   386

   387

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

   388

 *  Device interface

   389

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

   390

   391

/** Offers an EtherCAT device to a certain master.

   392

 *

   393

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

   394

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

   395

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

   396

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

   397

 * pointer is written to zero.

   398

 *

   399

 * \return 0 on success, else < 0

   400

 * \ingroup DeviceInterface

   401

 */

   402

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

   403

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

   404

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

   405

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

   406

        )

   407

{

   408

    ec_master_t *master;

   409

    char str[20];

   410

    unsigned int i;

   411

   412

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

   413

        master = &masters[i];

   414

   415

        down(&master->device_sem);

   416

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

   417

            up(&master->device_sem);

   418

            continue;

   419

        }

   420

   421

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

   422

                || ec_mac_is_broadcast(master->main_mac)) {

   423

            ec_mac_print(net_dev->dev_addr, str);

   424

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

   425

                    str, master->index);

   426

   427

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

   428

            up(&master->device_sem);

   429

   430

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

   431

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

   432

            return 0; // no error

   433

        }

   434

        else {

   435

            up(&master->device_sem);

   436

   437

            if (master->debug_level) {

   438

                ec_mac_print(net_dev->dev_addr, str);

   439

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

   440

            }

   441

        }

   442

    }

   443

   444

    *ecdev = NULL; // offer declined

   445

    return 0; // no error

   446

}

   447

   448

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

   449

   450

/** Withdraws an EtherCAT device from the master.

   451

 *

   452

 * The device is disconnected from the master and all device ressources

   453

 * are freed.

   454

 *

   455

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

   456

 *            to be called, to be sure that the master does not use the device

   457

 *            any more.

   458

 * \ingroup DeviceInterface

   459

 */

   460

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

   461

{

   462

    ec_master_t *master = device->master;

   463

    char str[20];

   464

   465

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

   466

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

   467

   468

    down(&master->device_sem);

   469

    ec_device_detach(device);

   470

    up(&master->device_sem);

   471

}

   472

   473

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

   474

   475

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

   476

 *

   477

 * \return 0 on success, else < 0

   478

 * \ingroup DeviceInterface

   479

 */

   480

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

   481

{

   482

    if (ec_device_open(device)) {

   483

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

   484

        return -1;

   485

    }

   486

   487

    if (ec_master_enter_idle_mode(device->master)) {