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

/**

    57

   Compile version info.

    58

*/

    59

    60

#define COMPILE_INFO EC_STR(EC_MASTER_VERSION_MAIN) \

    61

                     "." EC_STR(EC_MASTER_VERSION_SUB) \

    62

                     " (" EC_MASTER_VERSION_EXTRA ")" \

    63

                     " - rev. " EC_STR(SVNREV) \

    64

                     ", compiled by " EC_STR(USER) \

    65

                     " at " __DATE__ " " __TIME__

    66

    67

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

    68

    69

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

    70

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

    71

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

    72

    73

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

    74

    75

/** \cond */

    76

    77

module_param(ec_master_count, int, S_IRUGO);

    78

module_param(ec_eoeif_count, int, S_IRUGO);

    79

    80

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

    81

MODULE_DESCRIPTION("EtherCAT master driver module");

    82

MODULE_LICENSE("GPL");

    83

MODULE_VERSION(COMPILE_INFO);

    84

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

    85

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

    86

    87

/** \endcond */

    88

    89

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

    90

    91

/**

    92

   Module initialization.

    93

   Initializes \a ec_master_count masters.

    94

   \return 0 on success, else < 0

    95

*/

    96

    97

int __init ec_init_module(void)

    98

{

    99

    unsigned int i;

   100

    ec_master_t *master, *next;

   101

   102

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

   103

   104

    if (ec_master_count < 1) {

   105

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

   106

        goto out_return;

   107

    }

   108

   109

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

   110

   111

    INIT_LIST_HEAD(&ec_masters);

   112

   113

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

   114

        if (!(master =

   115

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

   116

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

   117

            goto out_free;

   118

        }

   119

   120

        if (ec_master_init(master, i, ec_eoeif_count))

   121

            goto out_free;

   122

   123

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

   124

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

   125

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

   126

            goto out_free;

   127

        }

   128

   129

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

   130

    }

   131

   132

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

   133

    return 0;

   134

   135

 out_free:

   136

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

   137

        list_del(&master->list);

   138

        kobject_del(&master->kobj);

   139

        kobject_put(&master->kobj);

   140

    }

   141

 out_return:

   142

    return -1;

   143

}

   144

   145

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

   146

   147

/**

   148

   Module cleanup.

   149

   Clears all master instances.

   150

*/

   151

   152

void __exit ec_cleanup_module(void)

   153

{

   154

    ec_master_t *master, *next;

   155

   156

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

   157

   158

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

   159

        list_del(&master->list);

   160

        kobject_del(&master->kobj);

   161

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

   162

    }

   163

   164

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

   165

}

   166

   167

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

   168

   169

/**

   170

   Gets a handle to a certain master.

   171

   \returns pointer to master

   172

*/

   173

   174

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

   175

{

   176

    ec_master_t *master;

   177

   178

    list_for_each_entry(master, &ec_masters, list) {

   179

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

   180

    }

   181

   182

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

   183

    return NULL;

   184

}

   185

   186

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

   187

   188

/**

   189

   Outputs frame contents for debugging purposes.

   190

*/

   191

   192

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

   193

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

   194

                   )

   195

{

   196

    unsigned int i;

   197

   198

    EC_DBG("");

   199

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

   200

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

   201

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

   202

            printk("\n");

   203

            EC_DBG("");

   204

        }

   205

    }

   206

    printk("\n");

   207

}

   208

   209

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

   210

   211

/**

   212

   Outputs frame contents and differences for debugging purposes.

   213

*/

   214

   215

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

   216

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

   217

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

   218

                        )

   219

{

   220

    unsigned int i;

   221

   222

    EC_DBG("");

   223

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

   224

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

   225

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

   226

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

   227

            printk("\n");

   228

            EC_DBG("");

   229

        }

   230

    }

   231

    printk("\n");

   232

}

   233

   234

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

   235

   236

/**

   237

   Prints slave states in clear text.

   238

*/

   239

   240

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

   241

                       char *buffer /**< target buffer (min. 25 bytes) */

   242

                       )

   243

{

   244

    off_t off = 0;

   245

    unsigned int first = 1;

   246

   247

    if (!states) {

   248

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

   249

        return off;

   250

    }

   251

   252

    if (states & EC_SLAVE_STATE_INIT) {

   253

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

   254

        first = 0;

   255

    }

   256

    if (states & EC_SLAVE_STATE_PREOP) {

   257

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

   258

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

   259

        first = 0;

   260

    }

   261

    if (states & EC_SLAVE_STATE_SAVEOP) {

   262

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

   263

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

   264

        first = 0;

   265

    }

   266

    if (states & EC_SLAVE_STATE_OP) {

   267

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

   268

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

   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 (master->device) {

   299

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

   300

        goto out_return;

   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_return;

   307

    }

   308

   309

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

   310

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

   311

        goto out_free;

   312

    }

   313

   314

    return master->device;

   315

   316

 out_free:

   317

    kfree(master->device);

   318

    master->device = NULL;

   319

 out_return:

   320

    return NULL;

   321

}

   322

   323

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

   324

   325

/**

   326

   Disconnect an EtherCAT device from the master.

   327

   The device is disconnected from the master and all device ressources

   328

   are freed.

   329

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

   330

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

   331

   \ingroup DeviceInterface

   332

*/

   333

   334

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

   335

                      ec_device_t *device /**< EtherCAT device */

   336

                      )

   337

{

   338

    ec_master_t *master;

   339

   340

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

   341

   342

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

   343

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

   344

        return;

   345

    }

   346

   347

    ec_device_clear(master->device);

   348

    kfree(master->device);

   349

    master->device = NULL;

   350

}

   351

   352

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

   353

   354

/**

   355

   Starts the master associated with the device.

   356

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

   357

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

   358

   will enter the idle mode then.

   359

   \ingroup DeviceInterface

   360

*/

   361

   362

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

   363

{

   364

    ec_master_t *master;

   365

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

   366

   367

    if (ec_device_open(master->device)) {

   368

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

   369

        return -1;

   370

    }

   371

   372

    ec_master_measure_bus_time(master);

   373

    ec_master_idle_start(master);

   374

    return 0;

   375

}

   376

   377

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

   378

   379

/**

   380

   Stops the master associated with the device.

   381

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

   382

   before unregistering the device.

   383

   \ingroup DeviceInterface

   384

*/

   385

   386

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

   387

{

   388

    ec_master_t *master;

   389

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

   390

   391

    ec_master_idle_stop(master);

   392

   393

    if (ec_device_close(master->device))

   394

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

   395

}

   396

   397

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

   398

 *  Realtime interface

   399

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

   400

   401

/**

   402

   Reserves an EtherCAT master for realtime operation.

   403

   \return pointer to reserved master, or NULL on error

   404

   \ingroup RealtimeInterface

   405

*/

   406

   407

ec_master_t *ecrt_request_master(unsigned int master_index

   408

                                 /**< master index */

   409

                                 )

   410

{

   411

    ec_master_t *master;

   412

   413

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

   414

   415

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

   416

   417

    if (master->reserved) {

   418

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

   419

        goto out_return;

   420

    }

   421

    master->reserved = 1;

   422

   423

    if (!master->device) {

   424

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

   425

        goto out_release;

   426

    }

   427

   428

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

   429

        EC_ERR("Failed to reserve device module!\n");

   430

        goto out_release;

   431

    }

   432

   433

    ec_master_measure_bus_time(master);

   434

    ec_master_idle_stop(master);

   435

    ec_master_reset(master);

   436

    master->mode = EC_MASTER_MODE_OPERATION;

   437

   438

    if (!master->device->link_state) EC_WARN("Link is DOWN.\n");

   439

   440

    if (ec_master_bus_scan(master)) {

   441

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

   442

        goto out_module_put;

   443

    }

   444

   445

    EC_INFO("Master %i is ready.\n", master_index);

   446

    return master;

   447

   448

 out_module_put:

   449

    module_put(master->device->module);

   450

    ec_master_reset(master);

   451

    ec_master_idle_start(master);

   452

 out_release:

   453

    master->reserved = 0;

   454

 out_return:

   455

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

   456

    return NULL;

   457

}

   458

   459

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

   460

   461

/**

   462

   Releases a reserved EtherCAT master.

   463

   \ingroup RealtimeInterface

   464

*/

   465

   466

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

   467

{

   468

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

   469

   470

    if (!master->reserved) {

   471

        EC_ERR("Master %i was never requested!\n", master->index);

   472

        return;

   473

    }

   474

   475

    ec_master_reset(master);

   476

    ec_master_idle_start(master);

   477

   478

    module_put(master->device->module);

   479

    master->reserved = 0;

   480

   481

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

   482

    return;

   483

}

   484

   485

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