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

    49

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

    50

    51

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

    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

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

    75

    76

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

    77

    78

/** \cond */

    79

    80

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

    81

MODULE_DESCRIPTION("EtherCAT master driver module");

    82

MODULE_LICENSE("GPL");

    83

MODULE_VERSION(EC_MASTER_VERSION);

    84

    85

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

    86

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

    87

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

    88

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

    89

    90

/** \endcond */

    91

    92

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

    93

    94

/**

    95

 * Module initialization.

    96

 * Initializes \a ec_master_count masters.

    97

 * \return 0 on success, else < 0

    98

 */

    99

   100

int __init ec_init_module(void)

   101

{

   102

    int i, ret = 0;

   103

   104

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

   105

   106

    init_MUTEX(&master_sem);

   107

   108

    // init kobject and add it to the hierarchy

   109

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

   110

    kobject_init(&kobj); // no ktype

   111

   112

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

   113

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

   114

        ret = -ENOMEM;

   115

        goto out_put;

   116

    }

   117

   118

    if (kobject_add(&kobj)) {

   119

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

   120

        ret = -EEXIST;

   121

        goto out_put;

   122

    }

   123

   124

    // zero MAC addresses

   125

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

   126

   127

    // process MAC parameters

   128

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

   129

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

   130

            ret = -EINVAL;

   131

            goto out_del;

   132

        }

   133

   134

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

   135

            ret = -EINVAL;

   136

            goto out_del;

   137

        }

   138

    }

   139

   140

    if (master_count) {

   141

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

   142

                        GFP_KERNEL))) {

   143

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

   144

            ret = -ENOMEM;

   145

            goto out_del;

   146

        }

   147

    }

   148

   149

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

   150

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

   151

            ret = -EIO;

   152

            goto out_free_masters;

   153

        }

   154

    }

   155

   156

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

   157

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

   158

    return ret;

   159

   160

out_free_masters:

   161

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

   162

    kfree(masters);

   163

out_del:

   164

    kobject_del(&kobj);

   165

out_put:

   166

    kobject_put(&kobj);

   167

    return ret;

   168

}

   169

   170

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

   171

   172

/**

   173

   Module cleanup.

   174

   Clears all master instances.

   175

*/

   176

   177

void __exit ec_cleanup_module(void)

   178

{

   179

    unsigned int i;

   180

   181

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

   182

        ec_master_clear(&masters[i]);

   183

    }

   184

    if (master_count)

   185

        kfree(masters);

   186

   187

    kobject_del(&kobj);

   188

    kobject_put(&kobj);

   189

   190

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

   191

}

   192

   193

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

   194

 * MAC address functions

   195

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

   196

   197

/**

   198

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

   199

 */

   200

   201

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

   202

{

   203

    unsigned int i;

   204

   205

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

   206

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

   207

            return 0;

   208

   209

    return 1;

   210

}

   211

   212

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

   213

   214

/**

   215

 * Print a MAC address to a buffer.

   216

 * \return number of bytes written.

   217

 */

   218

   219

ssize_t ec_mac_print(

   220

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

   221

        char *buffer /**< target buffer */

   222

        )

   223

{

   224

    off_t off = 0;

   225

    unsigned int i;

   226

   227

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

   228

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

   229

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

   230

    }

   231

   232

    return off;

   233

}

   234

   235

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

   236

   237

/**

   238

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

   239

 */

   240

   241

int ec_mac_is_zero(const uint8_t *mac)

   242

{

   243

    unsigned int i;

   244

   245

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

   246

        if (mac[i])

   247

            return 0;

   248

   249

    return 1;

   250

}

   251

   252

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

   253

   254

/**

   255

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

   256

 */

   257

   258

int ec_mac_is_broadcast(const uint8_t *mac)

   259

{

   260

    unsigned int i;

   261

   262

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

   263

        if (mac[i] != 0xff)

   264

            return 0;

   265

   266

    return 1;

   267

}

   268

   269

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

   270

   271

/**

   272

 * Parse a MAC address from a string.

   273

 * The MAC address must follow the regexp

   274

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

   275

   \return 0 on success, else < 0

   276

 */

   277

   278

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

   279

{

   280

    unsigned int i, value;

   281

    const char *orig = src;

   282

    char *rem;

   283

   284

    if (!strlen(src)) {

   285

        if (allow_empty){

   286

            return 0;

   287

        }

   288

        else {

   289

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

   290

            return -EINVAL;

   291

        }

   292

    }

   293

   294

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

   295

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

   296

        if (rem != src + 2

   297

                || value > 0xFF

   298

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

   299

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

   300

            return -EINVAL;

   301

        }

   302

        mac[i] = value;

   303

        if (i < ETH_ALEN - 1)

   304

            src = rem + 1; // skip colon

   305

    }

   306

   307

    return 0;

   308

}

   309

   310

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

   311

   312

/**

   313

   Outputs frame contents for debugging purposes.

   314

*/

   315

   316

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

   317

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

   318

                   )

   319

{

   320

    unsigned int i;

   321

   322

    EC_DBG("");

   323

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

   324

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

   325

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

   326

            printk("\n");

   327

            EC_DBG("");

   328

        }

   329

    }

   330

    printk("\n");

   331

}

   332

   333

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

   334

   335

/**

   336

   Outputs frame contents and differences for debugging purposes.

   337

*/

   338

   339

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

   340

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

   341

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

   342

                        )

   343

{

   344

    unsigned int i;

   345

   346

    EC_DBG("");

   347

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

   348

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

   349

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

   350

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

   351

            printk("\n");

   352

            EC_DBG("");

   353

        }

   354

    }

   355

    printk("\n");

   356

}

   357

   358

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

   359

   360

/**

   361

   Prints slave states in clear text.

   362

*/

   363

   364

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

   365

                       char *buffer /**< target buffer

   366

                                       (min. EC_STATE_STRING_SIZE bytes) */

   367

                       )

   368

{

   369

    off_t off = 0;

   370

    unsigned int first = 1;

   371

   372

    if (!states) {

   373

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

   374

        return off;

   375

    }

   376

   377

    if (states & EC_SLAVE_STATE_INIT) {

   378

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

   379

        first = 0;

   380

    }

   381

    if (states & EC_SLAVE_STATE_PREOP) {

   382

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

   383

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

   384

        first = 0;

   385

    }

   386

    if (states & EC_SLAVE_STATE_SAVEOP) {

   387

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

   388

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

   389

        first = 0;

   390

    }

   391

    if (states & EC_SLAVE_STATE_OP) {

   392

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

   393

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

   394

    }

   395

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   396

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

   397

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

   398

    }

   399

   400

    return off;

   401

}

   402

   403

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

   404

 *  Device interface

   405

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

   406

   407

/**

   408

   Offers an EtherCAT device to a certain master.

   409

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

   410

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

   411

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

   412

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

   413

   the pointer is written to zero.

   414

   \return 0 on success, else < 0

   415

   \ingroup DeviceInterface

   416

*/

   417

   418

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

   419

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

   420

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

   421

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

   422

        )

   423

{

   424

    ec_master_t *master;

   425

    char str[20];

   426

    unsigned int i;

   427

   428

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

   429

        master = &masters[i];

   430

   431

        down(&master->device_sem);

   432

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

   433

            up(&master->device_sem);

   434

            continue;

   435

        }

   436

   437

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

   438

                || ec_mac_is_broadcast(master->main_mac)) {

   439

            ec_mac_print(net_dev->dev_addr, str);

   440

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

   441

                    str, master->index);

   442

   443

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

   444

            up(&master->device_sem);

   445

   446

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

   447

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

   448

            return 0; // no error

   449

        }

   450

        else {

   451

            up(&master->device_sem);

   452

   453

            if (master->debug_level) {

   454

                ec_mac_print(net_dev->dev_addr, str);

   455

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

   456

            }

   457

        }

   458

    }

   459

   460

    *ecdev = NULL; // offer declined

   461

    return 0; // no error

   462

}

   463

   464

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

   465

   466

/**

   467

   Withdraws an EtherCAT device from the master.

   468

   The device is disconnected from the master and all device ressources

   469

   are freed.

   470

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

   471

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

   472

   \ingroup DeviceInterface

   473

*/

   474

   475

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

   476

{

   477

    ec_master_t *master = device->master;

   478

    char str[20];

   479

   480

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

   481

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

   482

   483

    down(&master->device_sem);

   484

    ec_device_detach(device);

   485

    up(&master->device_sem);

   486

}

   487

   488

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

   489

   490

/**

   491

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

   492

   \return 0 on success, else < 0