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

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

    62

    63

/** \cond */

    64

    65

module_param(ec_master_count, int, S_IRUGO);

    66

module_param(ec_eoeif_count, int, S_IRUGO);

    67

    68

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

    69

MODULE_DESCRIPTION("EtherCAT master driver module");

    70

MODULE_LICENSE("GPL");

    71

MODULE_VERSION(EC_MASTER_VERSION);

    72

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

    73

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

    74

    75

/** \endcond */

    76

    77

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

    78

    79

/**

    80

   Module initialization.

    81

   Initializes \a ec_master_count masters.

    82

   \return 0 on success, else < 0

    83

*/

    84

    85

int __init ec_init_module(void)

    86

{

    87

    unsigned int i;

    88

    ec_master_t *master, *next;

    89

    90

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

    91

    92

    if (ec_master_count < 1) {

    93

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

    94

        goto out_return;

    95

    }

    96

    97

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

    98

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

    99

        goto out_return;

   100

    }

   101

   102

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

   103

   104

    INIT_LIST_HEAD(&ec_masters);

   105

   106

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

   107

        if (!(master =

   108

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

   109

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

   110

            goto out_free;

   111

        }

   112

   113

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

   114

            goto out_free;

   115

   116

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

   117

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

   118

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

   119

            goto out_free;

   120

        }

   121

   122

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

   123

    }

   124

   125

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

   126

    return 0;

   127

   128

 out_free:

   129

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

   130

        list_del(&master->list);

   131

        kobject_del(&master->kobj);

   132

        kobject_put(&master->kobj);

   133

    }

   134

 out_return:

   135

    return -1;

   136

}

   137

   138

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

   139

   140

/**

   141

   Module cleanup.

   142

   Clears all master instances.

   143

*/

   144

   145

void __exit ec_cleanup_module(void)

   146

{

   147

    ec_master_t *master, *next;

   148

   149

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

   150

   151

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

   152

        list_del(&master->list);

   153

        kobject_del(&master->kobj);

   154

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

   155

    }

   156

   157

    unregister_chrdev_region(device_number, ec_master_count);

   158

   159

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

   160

}

   161

   162

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

   163

   164

/**

   165

   Gets a handle to a certain master.

   166

   \returns pointer to master

   167

*/

   168

   169

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

   170

{

   171

    ec_master_t *master;

   172

   173

    list_for_each_entry(master, &ec_masters, list) {

   174

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

   175

    }

   176

   177

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

   178

    return NULL;

   179

}

   180

   181

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

   182

   183

/**

   184

   Outputs frame contents for debugging purposes.

   185

*/

   186

   187

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

   188

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

   189

                   )

   190

{

   191

    unsigned int i;

   192

   193

    EC_DBG("");

   194

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

   195

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

   196

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

   197

            printk("\n");

   198

            EC_DBG("");

   199

        }

   200

    }

   201

    printk("\n");

   202

}

   203

   204

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

   205

   206

/**

   207

   Outputs frame contents and differences for debugging purposes.

   208

*/

   209

   210

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

   211

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

   212

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

   213

                        )

   214

{

   215

    unsigned int i;

   216

   217

    EC_DBG("");

   218

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

   219

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

   220

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

   221

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

   222

            printk("\n");

   223

            EC_DBG("");

   224

        }

   225

    }

   226

    printk("\n");

   227

}

   228

   229

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

   230

   231

/**

   232

   Prints slave states in clear text.

   233

*/

   234

   235

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

   236

                       char *buffer /**< target buffer

   237

                                       (min. EC_STATE_STRING_SIZE bytes) */

   238

                       )

   239

{

   240

    off_t off = 0;

   241

    unsigned int first = 1;

   242

   243

    if (!states) {

   244

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

   245

        return off;

   246

    }

   247

   248

    if (states & EC_SLAVE_STATE_INIT) {

   249

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

   250

        first = 0;

   251

    }

   252

    if (states & EC_SLAVE_STATE_PREOP) {

   253

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

   254

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

   255

        first = 0;

   256

    }

   257

    if (states & EC_SLAVE_STATE_SAVEOP) {

   258

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

   259

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

   260

        first = 0;

   261

    }

   262

    if (states & EC_SLAVE_STATE_OP) {

   263

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

   264

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

   265

    }

   266

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   267

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

   268

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

   269

    }

   270

   271

    return off;

   272

}

   273

   274

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

   275

 *  Device interface

   276

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

   277

   278

/**

   279

   Connects an EtherCAT device to a certain master.

   280

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

   281

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

   282

   the device.

   283

   \return 0 on success, else < 0

   284

   \ingroup DeviceInterface

   285

*/

   286

   287

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

   288

                            struct net_device *net_dev, /**< net_device of

   289

                                                           the device */

   290

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

   291

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

   292

                            )

   293

{

   294

    ec_master_t *master;

   295

   296

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

   297

   298

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

   299

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

   300

        goto out_return;

   301

    }

   302

   303

    if (master->device) {

   304

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

   305

        goto out_up;

   306

    }

   307

   308

    if (!(master->device =

   309

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

   310

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

   311

        goto out_up;

   312

    }

   313

   314

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

   315

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

   316

        goto out_free;

   317

    }

   318

   319

    up(&master->device_sem);

   320

    return master->device;

   321

   322

 out_free:

   323

    kfree(master->device);

   324

    master->device = NULL;

   325

 out_up:

   326

    up(&master->device_sem);

   327

 out_return:

   328

    return NULL;

   329

}

   330

   331

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

   332

   333

/**

   334

   Disconnect an EtherCAT device from the master.

   335

   The device is disconnected from the master and all device ressources

   336

   are freed.

   337

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

   338

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

   339

   \ingroup DeviceInterface

   340

*/

   341

   342

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

   343

                      ec_device_t *device /**< EtherCAT device */

   344

                      )

   345

{

   346

    ec_master_t *master;

   347

   348

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

   349

   350

    down(&master->device_sem);

   351

   352

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

   353

        up(&master->device_sem);

   354

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

   355

        return;

   356

    }

   357

   358

    ec_device_clear(master->device);

   359

    kfree(master->device);

   360

    master->device = NULL;

   361

   362

    up(&master->device_sem);

   363

}

   364

   365

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

   366

   367

/**

   368

   Starts the master associated with the device.

   369

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

   370

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

   371

   will enter the idle mode then.

   372

   \ingroup DeviceInterface

   373

*/

   374

   375

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

   376

{

   377

    ec_master_t *master;

   378

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

   379

   380

    if (ec_device_open(master->device)) {

   381

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

   382

        return -1;

   383

    }

   384

   385

    ec_master_idle_start(master);

   386

    return 0;

   387

}

   388

   389

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

   390

   391

/**

   392

   Stops the master associated with the device.

   393

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

   394

   before unregistering the device.

   395

   \ingroup DeviceInterface

   396

*/

   397

   398

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

   399

{

   400

    ec_master_t *master;

   401

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

   402

   403

    ec_master_idle_stop(master);

   404

   405

    if (ec_device_close(master->device))

   406

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

   407

}

   408

   409

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

   410

 *  Realtime interface

   411

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

   412

   413

/**

   414

   Reserves an EtherCAT master for realtime operation.

   415

   \return pointer to reserved master, or NULL on error

   416

   \ingroup RealtimeInterface

   417

*/

   418

   419

ec_master_t *ecrt_request_master(unsigned int master_index

   420

                                 /**< master index */

   421

                                 )

   422

{

   423

    ec_master_t *master;

   424

   425

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

   426

   427

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

   428

   429

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

   430

        atomic_inc(&master->available);

   431

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

   432

        goto out_return;

   433

    }

   434

   435

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

   436

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

   437

        goto out_release;

   438

    }

   439

   440

    if (!master->device) {

   441

        up(&master->device_sem);

   442

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

   443

        goto out_release;

   444

    }

   445

   446

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

   447

        up(&master->device_sem);

   448

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

   449

        goto out_release;

   450

    }

   451

   452

    up(&master->device_sem);

   453

   454

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

   455

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

   456

        goto out_module_put;

   457

    }

   458

   459

    ec_master_reset(master); // also stops idle mode

   460

    master->mode = EC_MASTER_MODE_OPERATION;

   461

   462

    if (ec_master_measure_bus_time(master)) {

   463

        EC_ERR("Bus time measuring failed!\n");

   464

        goto out_reset;

   465

    }

   466

   467

    if (ec_master_bus_scan(master)) {

   468

        EC_ERR("Bus scan failed!\n");

   469

        goto out_reset;

   470

    }

   471

   472

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

   473

    return master;

   474

   475

 out_reset:

   476

    ec_master_reset(master);

   477

    ec_master_idle_start(master);

   478

 out_module_put:

   479

    module_put(master->device->module);

   480

 out_release:

   481

    atomic_inc(&master->available);

   482

 out_return:

   483

    EC_ERR("Failed to request master %i.\n", master_index);

   484

    return NULL;

   485

}

   486