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;

    70

static int ec_eoe_devices = 0;

    71

static struct list_head ec_masters;

    72

    73

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

    74

    75

/** \cond */

    76

    77

module_param(ec_master_count, int, S_IRUGO);

    78

module_param(ec_eoe_devices, 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_eoe_devices, "number of EoE devices 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_eoe_devices))

   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

void ec_print_states(const uint8_t states /**< slave states */)

   241

{

   242

    unsigned int first = 1;

   243

   244

    if (!states) {

   245

        printk("(unknown)");

   246

        return;

   247

    }

   248

   249

    if (states & EC_SLAVE_STATE_INIT) {

   250

        printk("INIT");

   251

        first = 0;

   252

    }

   253

    if (states & EC_SLAVE_STATE_PREOP) {

   254

        if (!first) printk(", ");

   255

        printk("PREOP");

   256

        first = 0;

   257

    }

   258

    if (states & EC_SLAVE_STATE_SAVEOP) {

   259

        if (!first) printk(", ");

   260

        printk("SAVEOP");

   261

        first = 0;

   262

    }

   263

    if (states & EC_SLAVE_STATE_OP) {

   264

        if (!first) printk(", ");

   265

        printk("OP");

   266

    }

   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_isr_t isr, /**< interrupt service routine */

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

   294

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

   295

        goto out_return;

   296

    }

   297

   298

    if (!(master->device =

   299

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

   300

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

   301

        goto out_return;

   302

    }

   303

   304

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

   305

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

   306

        goto out_free;

   307

    }

   308

   309

    return master->device;

   310

   311

 out_free:

   312

    kfree(master->device);

   313

    master->device = NULL;

   314

 out_return:

   315

    return NULL;

   316

}

   317

   318

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

   319

   320

/**

   321

   Disconnect an EtherCAT device from the master.

   322

   The device is disconnected from the master and all device ressources

   323

   are freed.

   324

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

   325

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

   326

   \ingroup DeviceInterface

   327

*/

   328

   329

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

   330

                      ec_device_t *device /**< EtherCAT device */

   331

                      )

   332

{

   333

    ec_master_t *master;

   334

   335

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

   336

   337

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

   338

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

   339

        return;

   340

    }

   341

   342

    ec_device_clear(master->device);

   343

    kfree(master->device);

   344

    master->device = NULL;

   345

}

   346

   347

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

   348

   349

/**

   350

   Starts the master associated with the device.

   351

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

   352

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

   353

   will enter the free-run mode then.

   354

   \ingroup DeviceInterface

   355

*/

   356

   357

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

   358

{

   359

    ec_master_t *master;

   360

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

   361

   362

    if (ec_device_open(master->device)) {

   363

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

   364

        return -1;

   365

    }

   366

   367

    ec_master_freerun_start(master);

   368

    return 0;

   369

}

   370

   371

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

   372

   373

/**

   374

   Stops the master associated with the device.

   375

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

   376

   before unregistering the device.

   377

   \ingroup DeviceInterface

   378

*/

   379

   380

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

   381

{

   382

    ec_master_t *master;

   383

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

   384

   385

    ec_master_freerun_stop(master);

   386

   387

    if (ec_device_close(master->device))

   388

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

   389

}

   390

   391

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

   392

 *  Realtime interface

   393

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

   394

   395

/**

   396

   Reserves an EtherCAT master for realtime operation.

   397

   \return pointer to reserved master, or NULL on error

   398

   \ingroup RealtimeInterface

   399

*/

   400

   401

ec_master_t *ecrt_request_master(unsigned int master_index

   402

                                 /**< master index */

   403

                                 )

   404

{

   405

    ec_master_t *master;

   406

   407

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

   408

   409

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

   410

   411

    if (master->reserved) {

   412

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

   413

        goto out_return;

   414

    }

   415

    master->reserved = 1;

   416

   417

    if (!master->device) {

   418

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

   419

        goto out_release;

   420

    }

   421

   422

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

   423

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

   424

        goto out_release;

   425

    }

   426

   427

    ec_master_freerun_stop(master);

   428

    ec_master_reset(master);

   429

    master->mode = EC_MASTER_MODE_RUNNING;

   430

   431

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

   432

   433

    if (ec_master_bus_scan(master)) {

   434

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

   435

        goto out_module_put;

   436

    }

   437

   438

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

   439

    return master;

   440

   441

 out_module_put:

   442

    module_put(master->device->module);

   443

    ec_master_reset(master);

   444

    ec_master_freerun_start(master);

   445

 out_release:

   446

    master->reserved = 0;

   447

 out_return:

   448

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

   449

    return NULL;

   450

}

   451

   452

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

   453

   454

/**

   455

   Releases a reserved EtherCAT master.

   456

   \ingroup RealtimeInterface

   457

*/

   458

   459

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

   460

{

   461

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

   462

   463

    if (!master->reserved) {

   464

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

   465

        return;

   466

    }

   467

   468

    ec_master_reset(master);

   469

   470

    master->mode = EC_MASTER_MODE_IDLE;

   471

    ec_master_freerun_start(master);

   472

   473

    module_put(master->device->module);

   474

    master->reserved = 0;

   475

   476

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

   477

    return;

   478

}

   479

   480

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

   481

   482

/** \cond */

   483

   484

module_init(ec_init_module);

   485

module_exit(ec_cleanup_module);

   486