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; version 2 of the License.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    14

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16

 *  GNU General Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License

    19

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

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

    23

    24

/**

    25

   \file

    26

   EtherCAT master driver module.

    27

*/

    28

    29

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

    30

    31

#include <linux/module.h>

    32

#include <linux/kernel.h>

    33

#include <linux/init.h>

    34

    35

#include "globals.h"

    36

#include "master.h"

    37

#include "device.h"

    38

    39

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

    40

    41

int __init ec_init_module(void);

    42

void __exit ec_cleanup_module(void);

    43

    44

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

    45

    46

/**

    47

   Compile version info.

    48

*/

    49

    50

#define COMPILE_INFO EC_STR(EC_MASTER_VERSION_MAIN) \

    51

                     "." EC_STR(EC_MASTER_VERSION_SUB) \

    52

                     " (" EC_MASTER_VERSION_EXTRA ")" \

    53

                     " - rev. " EC_STR(SVNREV) \

    54

                     ", compiled by " EC_STR(USER) \

    55

                     " at " __DATE__ " " __TIME__

    56

    57

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

    58

    59

static int ec_master_count = 1;

    60

static struct list_head ec_masters;

    61

    62

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

    63

    64

/** \cond */

    65

    66

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

    67

MODULE_DESCRIPTION ("EtherCAT master driver module");

    68

MODULE_LICENSE("GPL");

    69

MODULE_VERSION(COMPILE_INFO);

    70

    71

module_param(ec_master_count, int, 1);

    72

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

    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

    89

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

    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)) // kobject_put is done inside...

   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

 *  Device interface

   223

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

   224

   225

/**

   226

   Connects an EtherCAT device to a certain master.

   227

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

   228

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

   229

   the device.

   230

   \return 0 on success, else < 0

   231

   \ingroup DeviceInterface

   232

*/

   233

   234

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

   235

                            struct net_device *net_dev, /**< net_device of

   236

                                                           the device */

   237

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

   238

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

   239

                            )

   240

{

   241

    ec_master_t *master;

   242

   243

    if (!net_dev) {

   244

        EC_WARN("Device is NULL!\n");

   245

        goto out_return;

   246

    }

   247

   248

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

   249

   250

    // critical section start

   251

    if (master->device) {

   252

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

   253

        // critical section leave

   254

        goto out_return;

   255

    }

   256

   257

    if (!(master->device =

   258

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

   259

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

   260

        // critical section leave

   261

        goto out_return;

   262

    }

   263

    // critical section end

   264

   265

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

   266

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

   267

        goto out_free;

   268

    }

   269

   270

    return master->device;

   271

   272

 out_free:

   273

    kfree(master->device);

   274

    master->device = NULL;

   275

 out_return:

   276

    return NULL;

   277

}

   278

   279

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

   280

   281

/**

   282

   Disconnect an EtherCAT device from the master.

   283

   The device is disconnected from the master and all device ressources

   284

   are freed.

   285

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

   286

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

   287

   \ingroup DeviceInterface

   288

*/

   289

   290

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

   291

                      ec_device_t *device /**< EtherCAT device */

   292

                      )

   293

{

   294

    ec_master_t *master;

   295

   296

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

   297

   298

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

   299

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

   300

        return;

   301

    }

   302

   303

    ec_device_clear(master->device);

   304

    kfree(master->device);

   305

    master->device = NULL;

   306

}

   307

   308

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

   309

   310

/**

   311

   Starts the master associated with the device.

   312

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

   313

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

   314

   will enter the free-run mode then.

   315

   \ingroup DeviceInterface

   316

*/

   317

   318

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

   319

{

   320

    ec_master_t *master;

   321

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

   322

   323

    if (ec_device_open(master->device)) {

   324

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

   325

        return -1;

   326

    }

   327

   328

    ec_master_freerun_start(master);

   329

    return 0;

   330

}

   331

   332

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

   333

   334

/**

   335

   Stops the master associated with the device.

   336

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

   337

   before unregistering the device.

   338

   \ingroup DeviceInterface

   339

*/

   340

   341

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

   342

{

   343

    ec_master_t *master;

   344

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

   345

   346

    ec_master_freerun_stop(master);

   347

   348

    if (ec_device_close(master->device))

   349

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

   350

}

   351

   352

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

   353

 *  Realtime interface

   354

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

   355

   356

/**

   357

   Reserves an EtherCAT master for realtime operation.

   358

   \return pointer to reserved master, or NULL on error

   359

   \ingroup RealtimeInterface

   360

*/

   361

   362

ec_master_t *ecrt_request_master(unsigned int master_index

   363

                                 /**< master index */

   364

                                 )

   365

{

   366

    ec_master_t *master;

   367

   368

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

   369

   370

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

   371

   372

    // begin critical section

   373

    if (master->reserved) {

   374

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

   375

        goto out_return;

   376

    }

   377

    master->reserved = 1;

   378

    // end critical section

   379

   380

    if (!master->device) {

   381

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

   382

        goto out_release;

   383

    }

   384

   385

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

   386

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

   387

        goto out_release;

   388

    }

   389

   390

    ec_master_freerun_stop(master);

   391

    ec_master_reset(master);

   392

    master->mode = EC_MASTER_MODE_RUNNING;

   393

   394

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

   395

   396

    if (ec_master_bus_scan(master)) {

   397

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

   398

        goto out_module_put;

   399

    }

   400

   401

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

   402

    return master;

   403

   404

 out_module_put:

   405

    module_put(master->device->module);

   406

    ec_master_reset(master);

   407

    ec_master_freerun_start(master);

   408

 out_release:

   409

    master->reserved = 0;

   410

 out_return:

   411

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

   412

    return NULL;

   413

}

   414

   415

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

   416

   417

/**

   418

   Releases a reserved EtherCAT master.

   419

   \ingroup RealtimeInterface

   420

*/

   421

   422

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

   423

{

   424

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

   425

   426

    if (!master->reserved) {

   427

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

   428

        return;

   429

    }

   430

   431

    ec_master_reset(master);

   432

   433

    master->mode = EC_MASTER_MODE_IDLE;

   434

    ec_master_freerun_start(master);

   435

   436

    module_put(master->device->module);

   437

    master->reserved = 0;

   438

   439

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

   440

    return;

   441

}

   442

   443

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

   444

   445

/** \cond */

   446

   447

module_init(ec_init_module);

   448

module_exit(ec_cleanup_module);

   449

   450

EXPORT_SYMBOL(ecdev_register);

   451

EXPORT_SYMBOL(ecdev_unregister);

   452

EXPORT_SYMBOL(ecdev_start);

   453

EXPORT_SYMBOL(ecdev_stop);

   454

EXPORT_SYMBOL(ecrt_request_master);

   455

EXPORT_SYMBOL(ecrt_release_master);

   456

   457

/** \endcond */

   458

   459

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