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

   110

    // init kobject and add it to the hierarchy

   111

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

   112

    kobject_init(&kobj); // no ktype

   113

   114

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

   115

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

   116

        ret = -ENOMEM;

   117

        goto out_put;

   118

    }

   119

   120

    if (kobject_add(&kobj)) {

   121

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

   122

        ret = -EEXIST;

   123

        goto out_put;

   124

    }

   125

   126

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

   127

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

   128

        ret = -EBUSY;

   129

        goto out_del;

   130

    }

   131

   132

    // zero MAC addresses

   133

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

   134

   135

    // process MAC parameters

   136

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

   137

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

   138

            ret = -EINVAL;

   139

            goto out_cdev;

   140

        }

   141

   142

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

   143

            ret = -EINVAL;

   144

            goto out_cdev;

   145

        }

   146

    }

   147

   148

    if (master_count) {

   149

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

   150

                        GFP_KERNEL))) {

   151

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

   152

            ret = -ENOMEM;

   153

            goto out_cdev;

   154

        }

   155

    }

   156

   157

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

   158

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

   159

            ret = -EIO;

   160

            goto out_free_masters;

   161

        }

   162

    }

   163

   164

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

   165

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

   166

    return ret;

   167

   168

out_free_masters:

   169

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

   170

    kfree(masters);

   171

out_cdev:

   172

    unregister_chrdev_region(device_number, 1);

   173

out_del:

   174

    kobject_del(&kobj);

   175

out_put:

   176

    kobject_put(&kobj);

   177

    return ret;

   178

}

   179

   180

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

   181

   182

/**

   183

   Module cleanup.

   184

   Clears all master instances.

   185

*/

   186

   187

void __exit ec_cleanup_module(void)

   188

{

   189

    unsigned int i;

   190

   191

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

   192

        ec_master_clear(&masters[i]);

   193

    }

   194

    if (master_count)

   195

        kfree(masters);

   196

   197

    unregister_chrdev_region(device_number, 1);

   198

    kobject_del(&kobj);

   199

    kobject_put(&kobj);

   200

   201

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

   202

}

   203

   204

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

   205

 * MAC address functions

   206

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

   207

   208

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

   209

{

   210

    unsigned int i;

   211

   212

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

   213

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

   214

            return 0;

   215

   216

    return 1;

   217

}

   218

   219

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

   220

   221

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

   222

{

   223

    off_t off = 0;

   224

    unsigned int i;

   225

   226

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

   227

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

   228

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

   229

    }

   230

   231

    return off;

   232

}

   233

   234

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

   235

   236

int ec_mac_is_zero(const uint8_t *mac)

   237

{

   238

    unsigned int i;

   239

   240

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

   241

        if (mac[i])

   242

            return 0;

   243

   244

    return 1;

   245

}

   246

   247

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

   248

   249

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

   250

{

   251

    unsigned int i, value;

   252

    const char *orig = src;

   253

    char *rem;

   254

   255

    if (!strlen(src)) {

   256

        if (allow_empty){

   257

            return 0;

   258

        }

   259

        else {

   260

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

   261

            return -EINVAL;

   262

        }

   263

    }

   264

   265

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

   266

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

   267

        if (rem != src + 2

   268

                || value > 0xFF

   269

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

   270

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

   271

            return -EINVAL;

   272

        }

   273

        mac[i] = value;

   274

        if (i < ETH_ALEN - 1)

   275

            src = rem + 1; // skip colon

   276

    }

   277

   278

    return 0;

   279

}

   280

   281

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

   282

   283

/**

   284

   Outputs frame contents for debugging purposes.

   285

*/

   286

   287

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

   288

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

   289

                   )

   290

{

   291

    unsigned int i;

   292

   293

    EC_DBG("");

   294

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

   295

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

   296

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

   297

            printk("\n");

   298

            EC_DBG("");

   299

        }

   300

    }

   301

    printk("\n");

   302

}

   303

   304

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

   305

   306

/**

   307

   Outputs frame contents and differences for debugging purposes.

   308

*/

   309

   310

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

   311

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

   312

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

   313

                        )

   314

{

   315

    unsigned int i;

   316

   317

    EC_DBG("");

   318

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

   319

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

   320

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

   321

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

   322

            printk("\n");

   323

            EC_DBG("");

   324

        }

   325

    }

   326

    printk("\n");

   327

}

   328

   329

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

   330

   331

/**

   332

   Prints slave states in clear text.

   333

*/

   334

   335

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

   336

                       char *buffer /**< target buffer

   337

                                       (min. EC_STATE_STRING_SIZE bytes) */

   338

                       )

   339

{

   340

    off_t off = 0;

   341

    unsigned int first = 1;

   342

   343

    if (!states) {

   344

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

   345

        return off;

   346

    }

   347

   348

    if (states & EC_SLAVE_STATE_INIT) {

   349

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

   350

        first = 0;

   351

    }

   352

    if (states & EC_SLAVE_STATE_PREOP) {

   353

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

   354

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

   355

        first = 0;

   356

    }

   357

    if (states & EC_SLAVE_STATE_SAVEOP) {

   358

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

   359

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

   360

        first = 0;

   361

    }

   362

    if (states & EC_SLAVE_STATE_OP) {

   363

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

   364

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

   365

    }

   366

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   367

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

   368

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

   369

    }

   370

   371

    return off;

   372

}

   373

   374

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

   375

 *  Device interface

   376

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

   377

   378

/**

   379

   Offers an EtherCAT device to a certain master.

   380

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

   381

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

   382

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

   383

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

   384

   the pointer is written to zero.

   385

   \return 0 on success, else < 0

   386

   \ingroup DeviceInterface

   387

*/

   388

   389

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

   390

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

   391

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

   392

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

   393

        )

   394

{

   395

    ec_master_t *master;

   396

    char str[20];

   397

    unsigned int i;

   398

   399

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

   400

        master = &masters[i];

   401

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

   402

            ec_mac_print(master->main_mac, str);

   403

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

   404

                    str, master->index);

   405

   407

            if (master->main_device.dev) {

   408

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

   409

                        master->index);

   410

                up(&master->device_sem);

   411

                return -1;

   412

            }

   413

   414

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

   415

            up(&master->device_sem);

   416

   417

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

   418

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

   419

            return 0; // no error

   420

        }

   421

        else if (master->debug_level) {

   422

            ec_mac_print(master->main_mac, str);

   423

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

   424

        }

   425

    }

   426

   427

    *ecdev = NULL; // offer declined

   428

    return 0; // no error

   429

}

   430

   431

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

   432

   433

/**

   434

   Withdraws an EtherCAT device from the master.

   435

   The device is disconnected from the master and all device ressources

   436

   are freed.

   437

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

   438

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

   439

   \ingroup DeviceInterface

   440

*/

   441

   442

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

   443

{

   444

    ec_master_t *master = device->master;

   445

    char str[20];

   446

   447

    ec_mac_print(master->main_mac, str);

   448

   449

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

   450

   451

    down(&master->device_sem);

   452

    ec_device_detach(device);

   453

    up(&master->device_sem);

   454

}

   455

   456

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

   457

   458

/**

   459

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

   460

   \return 0 on success, else < 0

   461

   \ingroup DeviceInterface

   462

*/

   463

   464

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

   465

{

   466

    if (ec_device_open(device)) {

   467

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

   468

        return -1;

   469

    }

   470

   471

    if (ec_master_enter_idle_mode(device->master)) {

   472

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

   473

        return -1;

   474

    }

   475

   476

    return 0;

   477

}

   478

   479

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

   480

   481

/**

   482

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

   483

   \return 0 on success, else < 0

   484

   \ingroup DeviceInterface

   485

*/

   486

   487

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

   488

{

   489

    ec_master_leave_idle_mode(device->master);