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

    60

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

    61

    62

/** \cond */

    63

    64

module_param(ec_master_count, int, S_IRUGO);

    65

module_param(ec_eoeif_count, int, S_IRUGO);

    66

    67

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

    68

MODULE_DESCRIPTION("EtherCAT master driver module");

    69

MODULE_LICENSE("GPL");

    71

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

    72

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

    73

    74

/** \endcond */

    75

    76

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

    77

    78

/**

    79

   Module initialization.

    80

   Initializes \a ec_master_count masters.

    81

   \return 0 on success, else < 0

    82

*/

    83

    84

int __init ec_init_module(void)

    85

{

    86

    unsigned int i;

    87

    ec_master_t *master, *next;

    88

    90

    91

    if (ec_master_count < 1) {

    92

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

    93

        goto out_return;

    94

    }

    95

    96

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

    97

    98

    INIT_LIST_HEAD(&ec_masters);

    99

   100

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

   101

        if (!(master =

   102

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

   103

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

   104

            goto out_free;

   105

        }

   106

   107

        if (ec_master_init(master, i, ec_eoeif_count))

   108

            goto out_free;

   109

   110

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

   111

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

   112

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

   113

            goto out_free;

   114

        }

   115

   116

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

   117

    }

   118

   119

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

   120

    return 0;

   121

   122

 out_free:

   123

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

   124

        list_del(&master->list);

   125

        kobject_del(&master->kobj);

   126

        kobject_put(&master->kobj);

   127

    }

   128

 out_return:

   129

    return -1;

   130

}

   131

   132

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

   133

   134

/**

   135

   Module cleanup.

   136

   Clears all master instances.

   137

*/

   138

   139

void __exit ec_cleanup_module(void)

   140

{

   141

    ec_master_t *master, *next;

   142

   143

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

   144

   145

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

   146

        list_del(&master->list);

   147

        kobject_del(&master->kobj);

   148

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

   149

    }

   150

   151

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

   152

}

   153

   154

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

   155

   156

/**

   157

   Gets a handle to a certain master.

   158

   \returns pointer to master

   159

*/

   160

   161

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

   162

{

   163

    ec_master_t *master;

   164

   165

    list_for_each_entry(master, &ec_masters, list) {

   166

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

   167

    }

   168

   169

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

   170

    return NULL;

   171

}

   172

   173

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

   174

   175

/**

   176

   Outputs frame contents for debugging purposes.

   177

*/

   178

   179

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

   180

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

   181

                   )

   182

{

   183

    unsigned int i;

   184

   185

    EC_DBG("");

   186

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

   187

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

   188

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

   189

            printk("\n");

   190

            EC_DBG("");

   191

        }

   192

    }

   193

    printk("\n");

   194

}

   195

   196

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

   197

   198

/**

   199

   Outputs frame contents and differences for debugging purposes.

   200

*/

   201

   202

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

   203

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

   204

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

   205

                        )

   206

{

   207

    unsigned int i;

   208

   209

    EC_DBG("");

   210

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

   211

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

   212

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

   213

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

   214

            printk("\n");

   215

            EC_DBG("");

   216

        }

   217

    }

   218

    printk("\n");

   219

}

   220

   221

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

   222

   223

/**

   224

   Prints slave states in clear text.

   225

*/

   226

   227

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

   228

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

   229

                       )

   230

{

   231

    off_t off = 0;

   232

    unsigned int first = 1;

   233

   234

    if (!states) {

   235

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

   236

        return off;

   237

    }

   238

   239

    if (states & EC_SLAVE_STATE_INIT) {

   240

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

   241

        first = 0;

   242

    }

   243

    if (states & EC_SLAVE_STATE_PREOP) {

   244

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

   245

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

   246

        first = 0;

   247

    }

   248

    if (states & EC_SLAVE_STATE_SAVEOP) {

   249

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

   250

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

   251

        first = 0;

   252

    }

   253

    if (states & EC_SLAVE_STATE_OP) {

   254

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

   255

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

   256

    }

   257

   258

    return off;

   259

}

   260

   261

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

   262

 *  Device interface

   263

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

   264

   265

/**

   266

   Connects an EtherCAT device to a certain master.

   267

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

   268

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

   269

   the device.

   270

   \return 0 on success, else < 0

   271

   \ingroup DeviceInterface

   272

*/

   273

   274

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

   275

                            struct net_device *net_dev, /**< net_device of

   276

                                                           the device */

   277

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

   278

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

   279

                            )

   280

{

   281

    ec_master_t *master;

   282

   283

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

   284

   285

    if (master->device) {

   286

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

   287

        goto out_return;

   288

    }

   289

   290

    if (!(master->device =

   291

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

   292

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

   293

        goto out_return;

   294

    }

   295

   296

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

   297

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

   298

        goto out_free;

   299

    }

   300

   301

    return master->device;

   302

   303

 out_free:

   304

    kfree(master->device);

   305

    master->device = NULL;

   306

 out_return:

   307

    return NULL;

   308

}

   309

   310

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

   311

   312

/**

   313

   Disconnect an EtherCAT device from the master.

   314

   The device is disconnected from the master and all device ressources

   315

   are freed.

   316

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

   317

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

   318

   \ingroup DeviceInterface

   319

*/

   320

   321

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

   322

                      ec_device_t *device /**< EtherCAT device */

   323

                      )

   324

{

   325

    ec_master_t *master;

   326

   327

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

   328

   329

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

   330

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

   331

        return;

   332

    }

   333

   334

    ec_device_clear(master->device);

   335

    kfree(master->device);

   336

    master->device = NULL;

   337

}

   338

   339

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

   340

   341

/**

   342

   Starts the master associated with the device.

   343

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

   344

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

   345

   will enter the idle mode then.

   346

   \ingroup DeviceInterface

   347

*/

   348

   349

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

   350

{

   351

    ec_master_t *master;

   352

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

   353

   354

    if (ec_device_open(master->device)) {

   355

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

   356

        return -1;

   357

    }

   358

   359

    ec_master_measure_bus_time(master);

   360

    ec_master_idle_start(master);

   361

    return 0;

   362

}

   363

   364

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

   365

   366

/**

   367

   Stops the master associated with the device.

   368

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

   369

   before unregistering the device.

   370

   \ingroup DeviceInterface

   371

*/

   372

   373

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

   374

{

   375

    ec_master_t *master;

   376

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

   377

   378

    ec_master_idle_stop(master);

   379

   380

    if (ec_device_close(master->device))

   381

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

   382

}

   383

   384

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

   385

 *  Realtime interface

   386

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

   387

   388

/**

   389

   Reserves an EtherCAT master for realtime operation.

   390

   \return pointer to reserved master, or NULL on error

   391

   \ingroup RealtimeInterface

   392

*/

   393

   394

ec_master_t *ecrt_request_master(unsigned int master_index

   395

                                 /**< master index */

   396

                                 )

   397

{

   398

    ec_master_t *master;

   399

   400

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

   401

   402

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

   403

   404

    if (master->reserved) {

   405

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

   406

        goto out_return;

   407

    }

   408

    master->reserved = 1;

   409

   410

    if (!master->device) {

   411

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

   412

        goto out_release;

   413

    }

   414

   415

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

   416

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

   417

        goto out_release;

   418

    }

   419

   420

    ec_master_measure_bus_time(master);

   421

    ec_master_idle_stop(master);

   422

    ec_master_reset(master);

   423

    master->mode = EC_MASTER_MODE_OPERATION;

   424

   425

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

   426

   427

    if (ec_master_bus_scan(master)) {

   428

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

   429

        goto out_module_put;

   430

    }

   431

   432

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

   433

    return master;

   434

   435

 out_module_put:

   436

    module_put(master->device->module);

   437

    ec_master_reset(master);

   438

    ec_master_idle_start(master);

   439

 out_release:

   440

    master->reserved = 0;

   441

 out_return:

   442

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

   443

    return NULL;

   444

}

   445

   446

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

   447

   448

/**

   449

   Releases a reserved EtherCAT master.

   450

   \ingroup RealtimeInterface

   451

*/

   452

   453

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

   454

{

   455

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

   456

   457

    if (!master->reserved) {

   458

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

   459

        return;

   460

    }

   461

   462

    ec_master_reset(master);

   463

    ec_master_idle_start(master);

   464

   465

    module_put(master->device->module);

   466

    master->reserved = 0;

   467

   468

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

   469

    return;

   470

}

   471

   472

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

   473

   474

/** \cond */

   475

   476

module_init(ec_init_module);

   477

module_exit(ec_cleanup_module);

   478

   479

EXPORT_SYMBOL(ecdev_register);

   480

EXPORT_SYMBOL(ecdev_unregister);

   481

EXPORT_SYMBOL(ecdev_start);

   482

EXPORT_SYMBOL(ecdev_stop);

   483

EXPORT_SYMBOL(ecrt_request_master);

   484

EXPORT_SYMBOL(ecrt_release_master);

   485