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

int __init ec_init_module(void);

    53

void __exit ec_cleanup_module(void);

    54

    55

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

    56

    57

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

    58

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

    59

static dev_t device_number; /**< XML character device number */

    60

ec_xmldev_t xmldev; /**< XML character device */

    61

    62

char *ec_master_version_str = EC_MASTER_VERSION;

    63

    64

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

    65

    66

/** \cond */

    67

    68

module_param(ec_master_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

    76

/** \endcond */

    77

    78

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

    79

    80

/**

    81

   Module initialization.

    82

   Initializes \a ec_master_count masters.

    83

   \return 0 on success, else < 0

    84

*/

    85

    86

int __init ec_init_module(void)

    87

{

    88

    unsigned int i;

    89

    ec_master_t *master, *next;

    90

    91

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

    92

    93

    if (ec_master_count < 1) {

    94

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

    95

        goto out_return;

    96

    }

    97

    98

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

    99

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

   100

        goto out_return;

   101

    }

   102

   103

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

   104

   105

    INIT_LIST_HEAD(&ec_masters);

   106

   107

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

   108

        if (!(master =

   109

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

   110

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

   111

            goto out_free;

   112

        }

   113

   115

            goto out_free;

   116

   117

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

   118

    }

   119

   120

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

   121

    return 0;

   122

   123

 out_free:

   124

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

   125

        list_del(&master->list);

   126

        kobject_del(&master->kobj);

   127

        kobject_put(&master->kobj);

   128

    }

   129

 out_return:

   130

    return -1;

   131

}

   132

   133

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

   134

   135

/**

   136

   Module cleanup.

   137

   Clears all master instances.

   138

*/

   139

   140

void __exit ec_cleanup_module(void)

   141

{

   142

    ec_master_t *master, *next;

   143

   144

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

   145

   146

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

   147

        list_del(&master->list);

   148

        ec_master_destroy(master);

   149

    }

   150

   151

    unregister_chrdev_region(device_number, ec_master_count);

   152

   153

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

   154

}

   155

   156

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

   157

   158

/**

   159

   Gets a handle to a certain master.

   160

   \returns pointer to master

   161

*/

   162

   163

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

   164

{

   165

    ec_master_t *master;

   166

   167

    list_for_each_entry(master, &ec_masters, list) {

   168

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

   169

    }

   170

   171

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

   172

    return NULL;

   173

}

   174

   175

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

   176

   177

/**

   178

   Outputs frame contents for debugging purposes.

   179

*/

   180

   181

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

   182

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

   183

                   )

   184

{

   185

    unsigned int i;

   186

   187

    EC_DBG("");

   188

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

   189

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

   190

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

   191

            printk("\n");

   192

            EC_DBG("");

   193

        }

   194

    }

   195

    printk("\n");

   196

}

   197

   198

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

   199

   200

/**

   201

   Outputs frame contents and differences for debugging purposes.

   202

*/

   203

   204

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

   205

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

   206

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

   207

                        )

   208

{

   209

    unsigned int i;

   210

   211

    EC_DBG("");

   212

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

   213

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

   214

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

   215

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

   216

            printk("\n");

   217

            EC_DBG("");

   218

        }

   219

    }

   220

    printk("\n");

   221

}

   222

   223

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

   224

   225

/**

   226

   Prints slave states in clear text.

   227

*/

   228

   229

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

   230

                       char *buffer /**< target buffer

   231

                                       (min. EC_STATE_STRING_SIZE bytes) */

   232

                       )

   233

{

   234

    off_t off = 0;

   235

    unsigned int first = 1;

   236

   237

    if (!states) {

   238

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

   239

        return off;

   240

    }

   241

   242

    if (states & EC_SLAVE_STATE_INIT) {

   243

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

   244

        first = 0;

   245

    }

   246

    if (states & EC_SLAVE_STATE_PREOP) {

   247

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

   248

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

   249

        first = 0;

   250

    }

   251

    if (states & EC_SLAVE_STATE_SAVEOP) {

   252

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

   253

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

   254

        first = 0;

   255

    }

   256

    if (states & EC_SLAVE_STATE_OP) {

   257

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

   258

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

   259

    }

   260

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   261

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

   262

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

   263

    }

   264

   265

    return off;

   266

}

   267

   268

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

   269

 *  Device interface

   270

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

   271

   272

/**

   273

   Connects an EtherCAT device to a certain master.

   274

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

   275

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

   276

   the device.

   277

   \return 0 on success, else < 0

   278

   \ingroup DeviceInterface

   279

*/

   280

   281

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

   282

                            struct net_device *net_dev, /**< net_device of

   283

                                                           the device */

   284

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

   285

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

   286

                            )

   287

{

   288

    ec_master_t *master;

   289

   290

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

   291

   292

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

   293

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

   294

        goto out_return;

   295

    }

   296

   297

    if (master->device) {

   298

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

   299

        goto out_up;

   300

    }

   301

   302

    if (!(master->device =

   303

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

   304

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

   305

        goto out_up;

   306

    }

   307

   308

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

   309

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

   310

        goto out_free;

   311

    }

   312

   313

    up(&master->device_sem);

   314

    return master->device;

   315

   316

 out_free:

   317

    kfree(master->device);

   318

    master->device = NULL;

   319

 out_up:

   320

    up(&master->device_sem);

   321

 out_return:

   322

    return NULL;

   323

}

   324

   325

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

   326

   327

/**

   328

   Disconnect an EtherCAT device from the master.

   329

   The device is disconnected from the master and all device ressources

   330

   are freed.

   331

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

   332

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

   333

   \ingroup DeviceInterface

   334

*/

   335

   336

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

   337

                      ec_device_t *device /**< EtherCAT device */

   338

                      )

   339

{

   340

    ec_master_t *master;

   341

   342

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

   343

   344

    down(&master->device_sem);

   345

   346

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

   347

        up(&master->device_sem);

   348

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

   349

        return;

   350

    }

   351

   352

    ec_device_clear(master->device);

   353

    kfree(master->device);

   354

    master->device = NULL;

   355

   356

    up(&master->device_sem);

   357

}

   358

   359

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

   360

   361

/**

   362

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

   363

   \return 0 on success, else < 0

   364

   \ingroup DeviceInterface

   365

*/

   366

   367

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

   368

{

   369

    if (ec_device_open(device)) {

   370

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

   371

        return -1;

   372

    }

   373

   374

    if (ec_master_enter_idle_mode(device->master)) {

   375

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

   376

        return -1;

   377

    }

   378

   379

    return 0;

   380

}

   381

   382

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

   383

   384

/**

   385

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

   386

   \return 0 on success, else < 0

   387

   \ingroup DeviceInterface

   388

*/

   389

   390

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

   391

{

   392

    ec_master_leave_idle_mode(device->master);

   393

   394

    if (ec_device_close(device))

   395

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

   396

}

   397

   398

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

   399

 *  Realtime interface

   400

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

   401

   402

/**

   403

 * Returns the version magic of the realtime interface.

   404

 * \return ECRT version magic.

   405

 * \ingroup RealtimeInterface

   406

 */

   407

   408

unsigned int ecrt_version_magic(void)

   409

{

   410

    return ECRT_VERSION_MAGIC;

   411

}

   412

   413

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

   414

   415

/**

   416

   Reserves an EtherCAT master for realtime operation.

   417

   \return pointer to reserved master, or NULL on error

   418

   \ingroup RealtimeInterface

   419

*/

   420

   421

ec_master_t *ecrt_request_master(unsigned int master_index

   422

                                 /**< master index */

   423

                                 )

   424

{

   425

    ec_master_t *master;

   426

   427

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

   428

   429

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

   430

   431

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

   432

        atomic_inc(&master->available);

   433

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

   434

        goto out_return;

   435

    }

   436

   437

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

   438

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

   439

        goto out_release;

   440

    }

   441

   442

    if (!master->device) {

   443

        up(&master->device_sem);

   444

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

   445

        goto out_release;

   446

    }

   447

   448

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

   449

        up(&master->device_sem);

   450

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

   451

        goto out_release;

   452

    }

   453

   454

    up(&master->device_sem);

   455

   456

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

   457

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

   458

        goto out_module_put;

   459

    }

   460

   461

    if (ec_master_enter_operation_mode(master)) {

   462

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

   463

        goto out_module_put;

   464

    }

   465

   466

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

   467

    return master;

   468

   469

 out_module_put:

   470

    module_put(master->device->module);

   471

 out_release:

   472

    atomic_inc(&master->available);

   473

 out_return:

   474

    return NULL;

   475

}

   476

   477

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

   478

   479

/**

   480

   Releases a reserved EtherCAT master.

   481

   \ingroup RealtimeInterface

   482

*/

   483

   484

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

   485

{

   486

    EC_INFO("Releasing master %i...\n", master->index);