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

char *ec_master_version_str = EC_MASTER_VERSION;

    61

    62

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

    63

    64

/** \cond */

    65

    66

module_param(ec_master_count, int, S_IRUGO);

    67

module_param(ec_eoeif_count, int, S_IRUGO);

    68

    69

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

    70

MODULE_DESCRIPTION("EtherCAT master driver module");

    71

MODULE_LICENSE("GPL");

    72

MODULE_VERSION(EC_MASTER_VERSION);

    73

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

    74

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

    75

    76

/** \endcond */

    77

    78

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

    79

    80

/**

    81

   Module initialization.

    82

   Initializes \a ec_master_count masters.

    83

   \return 0 on success, else < 0

    84

*/

    85

    86

int __init ec_init_module(void)

    87

{

    88

    unsigned int i;

    89

    ec_master_t *master, *next;

    90

    91

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

    92

    93

    if (ec_master_count < 1) {

    94

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

    95

        goto out_return;

    96

    }

    97

    98

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

    99

   100

    INIT_LIST_HEAD(&ec_masters);

   101

   102

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

   103

        if (!(master =

   104

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

   105

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

   106

            goto out_free;

   107

        }

   108

   109

        if (ec_master_init(master, i, ec_eoeif_count))

   110

            goto out_free;

   111

   112

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

   113

    }

   114

   115

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

   116

    return 0;

   117

   118

 out_free:

   119

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

   120

        list_del(&master->list);

   121

        kobject_del(&master->kobj);

   122

        kobject_put(&master->kobj);

   123

    }

   124

 out_return:

   125

    return -1;

   126

}

   127

   128

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

   129

   130

/**

   131

   Module cleanup.

   132

   Clears all master instances.

   133

*/

   134

   135

void __exit ec_cleanup_module(void)

   136

{

   137

    ec_master_t *master, *next;

   138

   139

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

   140

   141

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

   142

        list_del(&master->list);

   143

        ec_master_destroy(master);

   144

    }

   145

   146

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

   147

}

   148

   149

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

   150

   151

/**

   152

   Gets a handle to a certain master.

   153

   \returns pointer to master

   154

*/

   155

   156

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

   157

{

   158

    ec_master_t *master;

   159

   160

    list_for_each_entry(master, &ec_masters, list) {

   161

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

   162

    }

   163

   164

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

   165

    return NULL;

   166

}

   167

   168

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

   169

   170

/**

   171

   Outputs frame contents for debugging purposes.

   172

*/

   173

   174

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

   175

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

   176

                   )

   177

{

   178

    unsigned int i;

   179

   180

    EC_DBG("");

   181

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

   182

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

   183

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

   184

            printk("\n");

   185

            EC_DBG("");

   186

        }

   187

    }

   188

    printk("\n");

   189

}

   190

   191

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

   192

   193

/**

   194

   Outputs frame contents and differences for debugging purposes.

   195

*/

   196

   197

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

   198

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

   199

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

   200

                        )

   201

{

   202

    unsigned int i;

   203

   204

    EC_DBG("");

   205

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

   206

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

   207

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

   208

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

   209

            printk("\n");

   210

            EC_DBG("");

   211

        }

   212

    }

   213

    printk("\n");

   214

}

   215

   216

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

   217

   218

/**

   219

   Prints slave states in clear text.

   220

*/

   221

   222

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

   223

                       char *buffer /**< target buffer

   224

                                       (min. EC_STATE_STRING_SIZE bytes) */

   225

                       )

   226

{

   227

    off_t off = 0;

   228

    unsigned int first = 1;

   229

   230

    if (!states) {

   231

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

   232

        return off;

   233

    }

   234

   235

    if (states & EC_SLAVE_STATE_INIT) {

   236

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

   237

        first = 0;

   238

    }

   239

    if (states & EC_SLAVE_STATE_PREOP) {

   240

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

   241

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

   242

        first = 0;

   243

    }

   244

    if (states & EC_SLAVE_STATE_SAVEOP) {

   245

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

   246

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

   247

        first = 0;

   248

    }

   249

    if (states & EC_SLAVE_STATE_OP) {

   250

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

   251

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

   252

    }

   253

    if (states & EC_SLAVE_STATE_ACK_ERR) {

   254

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

   255

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

   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 (down_interruptible(&master->device_sem)) {

   286

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

   287

        goto out_return;

   288

    }

   289

   290

    if (master->device) {

   291

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

   292

        goto out_up;

   293

    }

   294

   295

    if (!(master->device =

   296

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

   297

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

   298

        goto out_up;

   299

    }

   300

   301

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

   302

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

   303

        goto out_free;

   304

    }

   305

   306

    up(&master->device_sem);

   307

    return master->device;

   308

   309

 out_free:

   310

    kfree(master->device);

   311

    master->device = NULL;

   312

 out_up:

   313

    up(&master->device_sem);

   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

    down(&master->device_sem);

   338

   339

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

   340

        up(&master->device_sem);

   341

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

   342

        return;

   343

    }

   344

   345

    ec_device_clear(master->device);

   346

    kfree(master->device);

   347

    master->device = NULL;

   348

   349

    up(&master->device_sem);

   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_enter_idle_mode(master);

   373

   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_leave_idle_mode(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 (!atomic_dec_and_test(&master->available)) {

   418

        atomic_inc(&master->available);

   419

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

   420

        goto out_return;

   421

    }

   422

   423

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

   424

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

   425

        goto out_release;

   426

    }

   427

   428

    if (!master->device) {

   429

        up(&master->device_sem);

   430

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

   431

        goto out_release;

   432

    }

   433

   434

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

   435

        up(&master->device_sem);

   436

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

   437

        goto out_release;

   438

    }

   439

   440

    up(&master->device_sem);

   441

   442

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

   443

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

   444

        goto out_module_put;

   445

    }

   446

   447

    if (ec_master_enter_operation_mode(master)) {

   448

        EC_ERR("Failed to enter OPERATION mode!\n");

   449

        goto out_module_put;

   450

    }

   451

   452

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

   453

    return master;

   454

   455

 out_module_put:

   456

    module_put(master->device->module);

   457

 out_release:

   458

    atomic_inc(&master->available);

   459

 out_return:

   460

    return NULL;

   461

}

   462

   463

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

   464

   465

/**

   466

   Releases a reserved EtherCAT master.

   467

   \ingroup RealtimeInterface

   468

*/

   469

   470

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

   471

{

   472

    ec_master_leave_operation_mode(master);

   473

   474

    module_put(master->device->module);

   475

    atomic_inc(&master->available);

   476

   477

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

   478

    return;

   479

}

   480

   481

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

   482

   483

/** \cond */

   484

   485

module_init(ec_init_module);