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

int __init ec_init_module(void);

    52

void __exit ec_cleanup_module(void);

    53

    54

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

    55

    56

static int ec_master_count = 1; /**< parameter value, number of masters */

    57

static int ec_eoeif_count = 0; /**< parameter value, number of EoE interf. */

    58

static struct list_head ec_masters; /**< list of masters */

    59

static dev_t device_number;

    60

    61

char *ec_master_version_str = EC_MASTER_VERSION;

    62

    63

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

    64

    65

/** \cond */

    66

    67

module_param(ec_master_count, int, S_IRUGO);

    68

module_param(ec_eoeif_count, int, S_IRUGO);

    69

    70

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

    71

MODULE_DESCRIPTION("EtherCAT master driver module");

    72

MODULE_LICENSE("GPL");

    73

MODULE_VERSION(EC_MASTER_VERSION);

    74

MODULE_PARM_DESC(ec_master_count, "number of EtherCAT masters to initialize");

    75

MODULE_PARM_DESC(ec_eoeif_count, "number of EoE interfaces per master");

    76

    77

/** \endcond */

    78

    79

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

    80

    81

/**

    82

   Module initialization.

    83

   Initializes \a ec_master_count masters.

    84

   \return 0 on success, else < 0

    85

*/

    86

    87

int __init ec_init_module(void)

    88

{

    89

    unsigned int i;

    90

    ec_master_t *master, *next;

    91

    92

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

    93

    94

    if (ec_master_count < 1) {

    95

        EC_ERR("Invalid ec_master_count: %i\n", ec_master_count);

    96

        goto out_return;

    97

    }

    98

    99

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

   100

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

   101

        goto out_return;

   102

    }

   103

   104

    EC_INFO("Initializing %i EtherCAT master(s)...\n", ec_master_count);

   105

   106

    INIT_LIST_HEAD(&ec_masters);

   107

   108

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

   109

        if (!(master =

   110

              (ec_master_t *) kmalloc(sizeof(ec_master_t), GFP_KERNEL))) {

   111

            EC_ERR("Failed to allocate memory for EtherCAT master %i.\n", i);

   112

            goto out_free;

   113

        }

   114

   115

        if (ec_master_init(master, i, ec_eoeif_count, device_number))

   116

            goto out_free;

   117

   118

        list_add_tail(&master->list, &ec_masters);

   119

    }

   120

   121

    EC_INFO("Master driver initialized.\n");

   122

    return 0;

   123

   124

 out_free:

   125

    list_for_each_entry_safe(master, next, &ec_masters, list) {

   126

        list_del(&master->list);

   127

        kobject_del(&master->kobj);

   128

        kobject_put(&master->kobj);

   129

    }

   130

 out_return:

   131

    return -1;

   132

}

   133

   134

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

   135

   136

/**

   137

   Module cleanup.

   138

   Clears all master instances.

   139

*/

   140

   141

void __exit ec_cleanup_module(void)

   142

{

   143

    ec_master_t *master, *next;

   144

   145

    EC_INFO("Cleaning up master driver...\n");

   146

   147

    list_for_each_entry_safe(master, next, &ec_masters, list) {

   148

        list_del(&master->list);

   149

        ec_master_destroy(master);

   150

    }

   151

   152

    unregister_chrdev_region(device_number, ec_master_count);

   153

   154

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

   155

}

   156

   157

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

   158

   159

/**

   160

   Gets a handle to a certain master.

   161

   \returns pointer to master

   162

*/

   163

   164

ec_master_t *ec_find_master(unsigned int master_index /**< master index */)

   165

{

   166

    ec_master_t *master;

   167

   168

    list_for_each_entry(master, &ec_masters, list) {

   169

        if (master->index == master_index) return master;

   170

    }

   171

   172

    EC_ERR("Master %i does not exist!\n", master_index);

   173

    return NULL;

   174

}

   175

   176

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

   177

   178

/**

   179

   Outputs frame contents for debugging purposes.

   180

*/

   181

   182

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

   183

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

   184

                   )

   185

{

   186

    unsigned int i;

   187

   188

    EC_DBG("");

   189

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

   190

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

   191

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

   192

            printk("\n");

   193

            EC_DBG("");

   194

        }

   195

    }

   196

    printk("\n");

   197

}

   198

   199

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

   200

   201

/**

   202

   Outputs frame contents and differences for debugging purposes.

   203

*/

   204

   205

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

   206

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

   207

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

   208

                        )

   209

{

   210

    unsigned int i;

   211

   212

    EC_DBG("");

   213

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

   214

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

   215

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

   216

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

   217

            printk("\n");

   218

            EC_DBG("");

   219

        }

   220

    }

   221

    printk("\n");

   222

}

   223

   224

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

   225

   226

/**

   227

   Prints slave states in clear text.

   228

*/

   229

   230

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

   231

                       char *buffer /**< target buffer

   232

                                       (min. EC_STATE_STRING_SIZE bytes) */

   233

                       )

   234

{

   235

    off_t off = 0;

   236

    unsigned int first = 1;

   237

   238

    if (!states) {

   239

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

   240

        return off;

   241

    }

   242

   243

    if (states & EC_SLAVE_STATE_INIT) {

   244

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

   245

        first = 0;

   246

    }

   247

    if (states & EC_SLAVE_STATE_PREOP) {

   248

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

   249

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

   250

        first = 0;

   251

    }

   252

    if (states & EC_SLAVE_STATE_SAVEOP) {

   253

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

   254

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

   255

        first = 0;

   256

    }

   257

    if (states & EC_SLAVE_STATE_OP) {

   258

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

   259

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

   260

    }

   261

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   262

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

   263

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

   264

    }

   265

   266

    return off;

   267

}

   268

   269

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

   270

 *  Device interface

   271

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

   272

   273

/**

   274

   Connects an EtherCAT device to a certain master.

   275

   The master will use the device for sending and receiving frames. It is

   276

   required that no other instance (for example the kernel IP stack) uses

   277

   the device.

   278

   \return 0 on success, else < 0

   279

   \ingroup DeviceInterface

   280

*/

   281

   282

ec_device_t *ecdev_register(unsigned int master_index, /**< master index */

   283

                            struct net_device *net_dev, /**< net_device of

   284

                                                           the device */

   285

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

   286

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

   287

                            )

   288

{

   289

    ec_master_t *master;

   290

   291

    if (!(master = ec_find_master(master_index))) return NULL;

   292

   293

    if (down_interruptible(&master->device_sem)) {

   294

        EC_ERR("Interrupted while waiting for device!\n");

   295

        goto out_return;

   296

    }

   297

   298

    if (master->device) {

   299

        EC_ERR("Master %i already has a device!\n", master_index);

   300

        goto out_up;

   301

    }

   302

   303

    if (!(master->device =

   304

          (ec_device_t *) kmalloc(sizeof(ec_device_t), GFP_KERNEL))) {

   305

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

   306

        goto out_up;

   307

    }

   308

   309

    if (ec_device_init(master->device, master, net_dev, poll, module)) {

   310

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

   311

        goto out_free;

   312

    }

   313

   314

    up(&master->device_sem);

   315

    return master->device;

   316

   317

 out_free:

   318

    kfree(master->device);

   319

    master->device = NULL;

   320

 out_up:

   321

    up(&master->device_sem);

   322

 out_return:

   323

    return NULL;

   324

}

   325

   326

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

   327

   328

/**

   329

   Disconnect an EtherCAT device from the master.

   330

   The device is disconnected from the master and all device ressources

   331

   are freed.

   332

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

   333

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

   334

   \ingroup DeviceInterface

   335

*/

   336

   337

void ecdev_unregister(unsigned int master_index, /**< master index */

   338

                      ec_device_t *device /**< EtherCAT device */

   339

                      )

   340

{

   341

    ec_master_t *master;

   342

   343

    if (!(master = ec_find_master(master_index))) return;

   344

   345

    down(&master->device_sem);

   346

   347

    if (!master->device || master->device != device) {

   348

        up(&master->device_sem);

   349

        EC_WARN("Unable to unregister device!\n");

   350

        return;

   351

    }

   352

   353

    ec_device_clear(master->device);

   354

    kfree(master->device);

   355

    master->device = NULL;

   356

   357

    up(&master->device_sem);

   358

}

   359

   360

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

   361

   362

/**

   363

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

   364

   \return 0 on success, else < 0

   365

   \ingroup DeviceInterface

   366

*/

   367

   368

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

   369

{

   370

    if (ec_device_open(device)) {

   371

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

   372

        return -1;

   373

    }

   374

   375

    if (ec_master_enter_idle_mode(device->master)) {

   376

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

   377

        return -1;

   378

    }

   379

   380

    return 0;

   381

}

   382

   383

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

   384

   385

/**

   386

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

   387

   \return 0 on success, else < 0

   388

   \ingroup DeviceInterface

   389

*/

   390

   391

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

   392

{

   393

    ec_master_leave_idle_mode(device->master);

   394

   395

    if (ec_device_close(device))

   396

        EC_WARN("Failed to close device!\n");

   397

}

   398

   399

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

   400

 *  Realtime interface

   401

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

   402

   403

/**

   404

 * Returns the version magic of the realtime interface.

   405

 * \return ECRT version magic.

   406

 * \ingroup RealtimeInterface

   407

 */

   408

   409

unsigned int ecrt_version_magic(void)

   410

{

   411

    return ECRT_VERSION_MAGIC;

   412

}

   413

   414

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

   415

   416

/**

   417

   Reserves an EtherCAT master for realtime operation.

   418

   \return pointer to reserved master, or NULL on error

   419

   \ingroup RealtimeInterface

   420

*/

   421

   422

ec_master_t *ecrt_request_master(unsigned int master_index

   423

                                 /**< master index */

   424

                                 )

   425

{

   426

    ec_master_t *master;

   427

   428

    EC_INFO("Requesting master %i...\n", master_index);

   429

   430

    if (!(master = ec_find_master(master_index))) goto out_return;

   431

   432

    if (!atomic_dec_and_test(&master->available)) {

   433

        atomic_inc(&master->available);

   434

        EC_ERR("Master %i is already in use!\n", master_index);

   435

        goto out_return;

   436

    }

   437

   438

    if (down_interruptible(&master->device_sem)) {

   439

        EC_ERR("Interrupted while waiting for device!\n");

   440

        goto out_release;

   441

    }

   442

   443

    if (!master->device) {

   444

        up(&master->device_sem);

   445

        EC_ERR("Master %i has no assigned device!\n", master_index);

   446

        goto out_release;

   447

    }

   448

   449

    if (!try_module_get(master->device->module)) {

   450

        up(&master->device_sem);

   451

        EC_ERR("Device module is unloading!\n");

   452

        goto out_release;

   453

    }

   454

   455

    up(&master->device_sem);

   456

   457

    if (!master->device->link_state) {

   458

        EC_ERR("Link is DOWN.\n");

   459

        goto out_module_put;

   460

    }

   461

   462

    if (ec_master_enter_operation_mode(master)) {

   463

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

   464

        goto out_module_put;

   465

    }

   466

   467

    EC_INFO("Successfully requested master %i.\n", master_index);

   468

    return master;

   469

   470

 out_module_put:

   471

    module_put(master->device->module);

   472

 out_release:

   473

    atomic_inc(&master->available);

   474

 out_return:

   475

    return NULL;

   476

}

   477

   478

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

   479

   480

/**

   481

   Releases a reserved EtherCAT master.

   482

   \ingroup RealtimeInterface

   483

*/

   484

   485

void ecrt_release_master(ec_master_t *master /**< EtherCAT master */)

   486

{