1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  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 and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

/** \file

    28

 * EtherCAT master driver module.

    29

 */

    30

    31

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

    32

    33

#include <linux/module.h>

    34

#include <linux/device.h>

    35

#include <linux/err.h>

    36

    37

#include "globals.h"

    38

#include "master.h"

    39

#include "device.h"

    40

    41

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

    42

    43

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

    44

    45

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

    46

    47

int __init ec_init_module(void);

    48

void __exit ec_cleanup_module(void);

    49

    50

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

    51

    52

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

    53

    54

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

    55

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

    56

    57

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

    58

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

    59

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

    60

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

    61

    62

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

    63

struct class *class; /**< Device class. */

    64

    65

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

    66

    67

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

    68

    69

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

    70

    71

/** \cond */

    72

    73

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

    74

MODULE_DESCRIPTION("EtherCAT master driver module");

    75

MODULE_LICENSE("GPL");

    76

MODULE_VERSION(EC_MASTER_VERSION);

    77

    78

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

    79

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

    80

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

    81

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

    82

    83

/** \endcond */

    84

    85

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

    86

    87

/** Module initialization.

    88

 *

    89

 * Initializes \a master_count masters.

    90

 * \return 0 on success, else < 0

    91

 */

    92

int __init ec_init_module(void)

    93

{

    94

    int i, ret = 0;

    95

    96

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

    97

    98

    init_MUTEX(&master_sem);

    99

   100

    if (master_count) {

   101

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

   102

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

   103

            ret = -EBUSY;

   104

            goto out_return;

   105

        }

   106

    }

   107

   108

    class = class_create(THIS_MODULE, "EtherCAT");

   109

    if (IS_ERR(class)) {

   110

        EC_ERR("Failed to create device class.\n");

   111

        ret = PTR_ERR(class);

   112

        goto out_cdev;

   113

    }

   114

   115

    // zero MAC addresses

   116

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

   117

   118

    // process MAC parameters

   119

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

   120

        ret = ec_mac_parse(macs[i][0], main_devices[i], 0);

   121

        if (ret)

   122

            goto out_class;

   123

   124

        if (i < backup_count) {

   125

            ret = ec_mac_parse(macs[i][1], backup_devices[i], 1);

   126

            if (ret)

   127

                goto out_class;

   128

        }

   129

    }

   130

   131

    // initialize static master variables

   132

    ec_master_init_static();

   133

   134

    if (master_count) {

   135

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

   136

                        GFP_KERNEL))) {

   137

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

   138

            ret = -ENOMEM;

   139

            goto out_class;

   140

        }

   141

    }

   142

   143

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

   144

        ret = ec_master_init(&masters[i], i, macs[i][0], macs[i][1],

   145

                    device_number, class);

   146

        if (ret)

   147

            goto out_free_masters;

   148

    }

   149

   150

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

   151

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

   152

    return ret;

   153

   154

out_free_masters:

   155

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

   156

        ec_master_clear(&masters[i]);

   157

    kfree(masters);

   158

out_class:

   159

    class_destroy(class);

   160

out_cdev:

   161

    if (master_count)

   162

        unregister_chrdev_region(device_number, master_count);

   163

out_return:

   164

    return ret;

   165

}

   166

   167

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

   168

   169

/** Module cleanup.

   170

 *

   171

 * Clears all master instances.

   172

 */

   173

void __exit ec_cleanup_module(void)

   174

{

   175

    unsigned int i;

   176

   177

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

   178

        ec_master_clear(&masters[i]);

   179

    }

   180

   181

    if (master_count)

   182

        kfree(masters);

   183

   184

    class_destroy(class);

   185

   186

    if (master_count)

   187

        unregister_chrdev_region(device_number, master_count);

   188

   189

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

   190

}

   191

   192

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

   193

 * MAC address functions

   194

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

   195

   196

/**

   197

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

   198

 */

   199

int ec_mac_equal(

   200

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

   201

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

   202

        )

   203

{

   204

    unsigned int i;

   205

   206

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

   207

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

   208

            return 0;

   209

   210

    return 1;

   211

}

   212

   213

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

   214

   215

/** Print a MAC address to a buffer.

   216

 *

   217

 * \return number of bytes written.

   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

int ec_mac_is_zero(

   241

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

   242

        )

   243

{

   244

    unsigned int i;

   245

   246

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

   247

        if (mac[i])

   248

            return 0;

   249

   250

    return 1;

   251

}

   252

   253

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

   254

   255

/**

   256

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

   257

 */

   258

int ec_mac_is_broadcast(

   259

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

   260

        )

   261

{

   262

    unsigned int i;

   263

   264

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

   265

        if (mac[i] != 0xff)

   266

            return 0;

   267

   268

    return 1;

   269

}

   270

   271

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

   272

   273

/** Parse a MAC address from a string.

   274

 *

   275

 * The MAC address must follow the regexp

   276

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

   277

 *

   278

 * \return 0 on success, else < 0

   279

 */

   280

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

   281

{

   282

    unsigned int i, value;

   283

    const char *orig = src;

   284

    char *rem;

   285

   286

    if (!strlen(src)) {

   287

        if (allow_empty){

   288

            return 0;

   289

        }

   290

        else {

   291

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

   292

            return -EINVAL;

   293

        }

   294

    }

   295

   296

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

   297

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

   298

        if (rem != src + 2

   299

                || value > 0xFF

   300

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

   301

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

   302

            return -EINVAL;

   303

        }

   304

        mac[i] = value;

   305

        if (i < ETH_ALEN - 1)

   306

            src = rem + 1; // skip colon

   307

    }

   308

   309

    return 0;

   310

}

   311

   312

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

   313

   314

/** Outputs frame contents for debugging purposes.

   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

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

   336

 */

   337

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

   338

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

   339

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

   340

                        )

   341

{

   342

    unsigned int i;

   343

   344

    EC_DBG("");

   345

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

   346

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

   347

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

   348

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

   349

            printk("\n");

   350

            EC_DBG("");

   351

        }

   352

    }

   353

    printk("\n");

   354

}

   355

   356

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

   357

   358

/** Prints slave states in clear text.

   359

 */

   360

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

   361

                       char *buffer, /**< target buffer

   362

                                       (min. EC_STATE_STRING_SIZE bytes) */

   363

                       uint8_t multi /**< Show multi-state mask. */

   364

                       )

   365

{

   366

    off_t off = 0;

   367

    unsigned int first = 1;

   368

   369

    if (!states) {

   370

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

   371

        return off;

   372

    }

   373

   374

    if (multi) { // multiple slaves

   375

        if (states & EC_SLAVE_STATE_INIT) {

   376

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

   377

            first = 0;

   378

        }

   379

        if (states & EC_SLAVE_STATE_PREOP) {

   380

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

   381

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

   382

            first = 0;

   383

        }

   384

        if (states & EC_SLAVE_STATE_SAFEOP) {

   385

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

   386

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

   387

            first = 0;

   388

        }

   389

        if (states & EC_SLAVE_STATE_OP) {

   390

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

   391

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

   392

        }

   393

    } else { // single slave

   394

        if ((states & EC_SLAVE_STATE_MASK) == EC_SLAVE_STATE_INIT) {

   395

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

   396

        } else if ((states & EC_SLAVE_STATE_MASK) == EC_SLAVE_STATE_PREOP) {

   397

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

   398

        } else if ((states & EC_SLAVE_STATE_MASK) == EC_SLAVE_STATE_BOOT) {

   399

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

   400

        } else if ((states & EC_SLAVE_STATE_MASK) == EC_SLAVE_STATE_SAFEOP) {

   401

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

   402

        } else if ((states & EC_SLAVE_STATE_MASK) == EC_SLAVE_STATE_OP) {

   403

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

   404

        } else {

   405

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

   406

        }

   407

        first = 0;

   408

    }

   409

   410

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   411

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

   412

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

   413

    }

   414

   415

    return off;

   416

}

   417

   418

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

   419

 *  Device interface

   420

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

   421

   422

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

   423

 *

   424

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

   425

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

   426

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

   427

 * newly created EtherCAT device is returned, else \a NULL is returned.

   428

 *

   429

 * \return Pointer to device, if accepted, or NULL if declined.

   430

 * \ingroup DeviceInterface

   431

 */

   432

ec_device_t *ecdev_offer(

   433

        struct net_device *net_dev, /**< net_device to offer */

   434

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

   435

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

   436

        )

   437

{

   438

    ec_master_t *master;

   439

    char str[20];

   440

    unsigned int i;

   441

   442

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

   443

        master = &masters[i];

   444

   445

        down(&master->device_sem);

   446

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

   447

            up(&master->device_sem);

   448

            continue;

   449

        }

   450

   451

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

   452

                || ec_mac_is_broadcast(master->main_mac)) {

   453

            ec_mac_print(net_dev->dev_addr, str);

   454

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

   455

                    str, master->index);

   456

   457

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

   458

            up(&master->device_sem);

   459

   460

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

   461

            return &master->main_device; // offer accepted

   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

    return NULL; // offer declined

   474

}

   475

   476

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

   477

 *  Realtime interface

   478

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

   479

   480

/** Request a master.

   481

 *

   482

 * Same as ecrt_request_master(), but with ERR_PTR() return value.

   483

 */

   484

ec_master_t *ecrt_request_master_err(

   485

        unsigned int master_index /**< Master index. */

   486

        )

   487

{