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

        if (kobject_add(&master->kobj)) {

   119

            EC_ERR("Failed to add kobj.\n");

   120

            kobject_put(&master->kobj); // free master

   121

            goto out_free;

   122

        }

   123

   124

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

   125

    }

   126

   127

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

   128

    return 0;

   129

   130

 out_free:

   131

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

   132

        list_del(&master->list);

   133

        kobject_del(&master->kobj);

   134

        kobject_put(&master->kobj);

   135

    }

   136

 out_return:

   137

    return -1;

   138

}

   139

   140

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

   141

   142

/**

   143

   Module cleanup.

   144

   Clears all master instances.

   145

*/

   146

   147

void __exit ec_cleanup_module(void)

   148

{

   149

    ec_master_t *master, *next;

   150

   151

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

   152

   153

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

   154

        list_del(&master->list);

   155

        ec_master_destroy(master);

   156

    }

   157

   158

    unregister_chrdev_region(device_number, ec_master_count);

   159

   160

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

   161

}

   162

   163

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

   164

   165

/**

   166

   Gets a handle to a certain master.

   167

   \returns pointer to master

   168

*/

   169

   170

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

   171

{

   172

    ec_master_t *master;

   173

   174

    list_for_each_entry(master, &ec_masters, list) {

   175

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

   176

    }

   177

   178

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

   179

    return NULL;

   180

}

   181

   182

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

   183

   184

/**

   185

   Outputs frame contents for debugging purposes.

   186

*/

   187

   188

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

   189

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

   190

                   )

   191

{

   192

    unsigned int i;

   193

   194

    EC_DBG("");

   195

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

   196

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

   197

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

   198

            printk("\n");

   199

            EC_DBG("");

   200

        }

   201

    }

   202

    printk("\n");

   203

}

   204

   205

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

   206

   207

/**

   208

   Outputs frame contents and differences for debugging purposes.

   209

*/

   210

   211

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

   212

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

   213

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

   214

                        )

   215

{

   216

    unsigned int i;

   217

   218

    EC_DBG("");

   219

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

   220

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

   221

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

   222

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

   223

            printk("\n");

   224

            EC_DBG("");

   225

        }

   226

    }

   227

    printk("\n");

   228

}

   229

   230

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

   231

   232

/**

   233

   Prints slave states in clear text.

   234

*/

   235

   236

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

   237

                       char *buffer /**< target buffer

   238

                                       (min. EC_STATE_STRING_SIZE bytes) */

   239

                       )

   240

{

   241

    off_t off = 0;

   242

    unsigned int first = 1;

   243

   244

    if (!states) {

   245

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

   246

        return off;

   247

    }

   248

   249

    if (states & EC_SLAVE_STATE_INIT) {

   250

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

   251

        first = 0;

   252

    }

   253

    if (states & EC_SLAVE_STATE_PREOP) {

   254

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

   255

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

   256

        first = 0;

   257

    }

   258

    if (states & EC_SLAVE_STATE_SAVEOP) {

   259

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

   260

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

   261

        first = 0;

   262

    }

   263

    if (states & EC_SLAVE_STATE_OP) {

   264

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

   265

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

   266

    }

   267

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   268

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

   269

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

   270

    }

   271

   272

    return off;

   273

}

   274

   275

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

   276

 *  Device interface

   277

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

   278

   279

/**

   280

   Connects an EtherCAT device to a certain master.

   281

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

   282

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

   283

   the device.

   284

   \return 0 on success, else < 0

   285

   \ingroup DeviceInterface

   286

*/

   287

   288

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

   289

                            struct net_device *net_dev, /**< net_device of

   290

                                                           the device */

   291

                            ec_isr_t isr, /**< interrupt service routine */

   292

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

   293

                            )

   294

{

   295

    ec_master_t *master;

   296

   297

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

   298

   299

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

   300

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

   301

        goto out_return;

   302

    }

   303

   304

    if (master->device) {

   305

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

   306

        goto out_up;

   307

    }

   308

   309

    if (!(master->device =

   310

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

   311

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

   312

        goto out_up;

   313

    }

   314

   315

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

   316

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

   317

        goto out_free;

   318

    }

   319

   320

    up(&master->device_sem);

   321

    return master->device;

   322

   323

 out_free:

   324

    kfree(master->device);

   325

    master->device = NULL;

   326

 out_up:

   327

    up(&master->device_sem);

   328

 out_return:

   329

    return NULL;

   330

}

   331

   332

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

   333

   334

/**

   335

   Disconnect an EtherCAT device from the master.

   336

   The device is disconnected from the master and all device ressources

   337

   are freed.

   338

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

   339

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

   340

   \ingroup DeviceInterface

   341

*/

   342

   343

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

   344

                      ec_device_t *device /**< EtherCAT device */

   345

                      )

   346

{

   347

    ec_master_t *master;

   348

   349

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

   350

   351

    down(&master->device_sem);

   352

   353

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

   354

        up(&master->device_sem);

   355

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

   356

        return;

   357

    }

   358

   359

    ec_device_clear(master->device);

   360

    kfree(master->device);

   361

    master->device = NULL;

   362

   363

    up(&master->device_sem);

   364

}

   365

   366

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

   367

   368

/**

   369

   Starts the master associated with the device.

   370

   This function has to be called by the network device driver to tell the

   371

   master that the device is ready to send and receive data. The master

   372

   will enter the idle mode then.

   373

   \ingroup DeviceInterface

   374

*/

   375

   376

int ecdev_start(unsigned int master_index /**< master index */)

   377

{

   378

    ec_master_t *master;

   379

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

   380

   381

    if (ec_device_open(master->device)) {

   382

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

   383

        return -1;

   384

    }

   385

   386

    ec_master_enter_idle_mode(master);

   387

   388

    return 0;

   389

}

   390

   391

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

   392

   393

/**

   394

   Stops the master associated with the device.

   395

   Tells the master to stop using the device for frame IO. Has to be called

   396

   before unregistering the device.

   397

   \ingroup DeviceInterface

   398

*/

   399

   400

void ecdev_stop(unsigned int master_index /**< master index */)

   401

{

   402

    ec_master_t *master;

   403

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

   404

   405

    ec_master_leave_idle_mode(master);

   406

   407

    if (ec_device_close(master->device))

   408

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

   409

}

   410

   411

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

   412

 *  Realtime interface

   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

{