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;

    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

   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

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

   211

{

   212

    unsigned int i;

   213

   214

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

   215

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

   216

            return 0;

   217

   218

    return 1;

   219

}

   220

   221

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

   222

   223

ssize_t ec_mac_print(const uint8_t *mac, char *buffer)

   224

{

   225

    off_t off = 0;

   226

    unsigned int i;

   227

   228

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

   229

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

   230

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

   231

    }

   232

   233

    return off;

   234

}

   235

   236

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

   237

   238

int ec_mac_is_zero(const uint8_t *mac)

   239

{

   240

    unsigned int i;

   241

   242

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

   243

        if (mac[i])

   244

            return 0;

   245

   246

    return 1;

   247

}

   248

   249

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

   250

   251

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

   252

{

   253

    unsigned int i, value;

   254

    const char *orig = src;

   255

    char *rem;

   256

   257

    if (!strlen(src)) {

   258

        if (allow_empty){

   259

            return 0;

   260

        }

   261

        else {

   262

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

   263

            return -EINVAL;

   264

        }

   265

    }

   266

   267

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

   268

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

   269

        if (rem != src + 2

   270

                || value > 0xFF

   271

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

   272

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

   273

            return -EINVAL;

   274

        }

   275

        mac[i] = value;

   276

        if (i < ETH_ALEN - 1)

   277

            src = rem + 1; // skip colon

   278

    }

   279

   280

    return 0;

   281

}

   282

   283

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

   284

   285

/**

   286

   Outputs frame contents for debugging purposes.

   287

*/

   288

   289

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

   290

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

   291

                   )

   292

{

   293

    unsigned int i;

   294

   295

    EC_DBG("");

   296

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

   297

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

   298

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

   299

            printk("\n");

   300

            EC_DBG("");

   301

        }

   302

    }

   303

    printk("\n");

   304

}

   305

   306

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

   307

   308

/**

   309

   Outputs frame contents and differences for debugging purposes.

   310

*/

   311

   312

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

   313

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

   314

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

   315

                        )

   316

{

   317

    unsigned int i;

   318

   319

    EC_DBG("");

   320

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

   321

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

   322

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

   323

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

   324

            printk("\n");

   325

            EC_DBG("");

   326

        }

   327

    }

   328

    printk("\n");

   329

}

   330

   331

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

   332

   333

/**

   334

   Prints slave states in clear text.

   335

*/

   336

   337

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

   338

                       char *buffer /**< target buffer

   339

                                       (min. EC_STATE_STRING_SIZE bytes) */

   340

                       )

   341

{

   342

    off_t off = 0;

   343

    unsigned int first = 1;

   344

   345

    if (!states) {

   346

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

   347

        return off;

   348

    }

   349

   350

    if (states & EC_SLAVE_STATE_INIT) {

   351

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

   352

        first = 0;

   353

    }

   354

    if (states & EC_SLAVE_STATE_PREOP) {

   355

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

   356

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

   357

        first = 0;

   358

    }

   359

    if (states & EC_SLAVE_STATE_SAVEOP) {

   360

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

   361

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

   362

        first = 0;

   363

    }

   364

    if (states & EC_SLAVE_STATE_OP) {

   365

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

   366

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

   367

    }

   368

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   369

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

   370

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

   371

    }

   372

   373

    return off;

   374

}

   375

   376

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

   377

 *  Device interface

   378

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

   379

   380

/**

   381

   Offers an EtherCAT device to a certain master.

   382

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

   383

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

   384

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

   385

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

   386

   the pointer is written to zero.

   387

   \return 0 on success, else < 0

   388

   \ingroup DeviceInterface

   389

*/

   390

   391

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

   392

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

   393

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

   394

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

   395

        )

   396

{

   397

    ec_master_t *master;

   398

    char str[20];

   399

    unsigned int i;

   400

   401

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

   402

        master = &masters[i];

   403

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

   404

            ec_mac_print(master->main_mac, str);

   405

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

   406

                    str, master->index);

   407

   408

            down(&master->device_sem);

   409

            if (master->main_device.dev) {

   410

                EC_ERR("Master %u already has a device attached.\n",

   411

                        master->index);

   412

                up(&master->device_sem);

   413

                return -1;

   414

            }

   415

   416

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

   417

            up(&master->device_sem);

   418

   419

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

   420

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

   421

            return 0; // no error

   422

        }

   423

        else if (master->debug_level) {

   424

            ec_mac_print(master->main_mac, str);

   425

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

   426

        }

   427

    }

   428

   429

    *ecdev = NULL; // offer declined

   430

    return 0; // no error

   431

}

   432

   433

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

   434

   435

/**

   436

   Withdraws an EtherCAT device from the master.

   437

   The device is disconnected from the master and all device ressources

   438

   are freed.

   439

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

   440

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

   441

   \ingroup DeviceInterface

   442

*/

   443

   444

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

   445

{

   446

    ec_master_t *master = device->master;

   447

    char str[20];

   448

   449

    ec_mac_print(master->main_mac, str);

   450

   451

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

   452

   453

    down(&master->device_sem);

   454

    ec_device_detach(device);

   455

    up(&master->device_sem);

   456

}

   457

   458

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

   459

   460

/**

   461

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

   462

   \return 0 on success, else < 0

   463

   \ingroup DeviceInterface

   464

*/

   465

   466

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

   467

{

   468

    if (ec_device_open(device)) {

   469

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

   470

        return -1;

   471

    }

   472

   473

    if (ec_master_enter_idle_mode(device->master)) {

   474

        EC_ERR("Failed to enter idle mode!\n");

   475

        return -1;

   476

    }

   477

   478

    return 0;

   479

}

   480

   481

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

   482

   483

/**

   484

   Makes the master leave IDLE mode and closes the network device.

   485

   \return 0 on success, else < 0

   486

   \ingroup DeviceInterface

   487

*/

   488

   489

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