1

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

     2

 *

     3

 *  m o d u l e . c

     4

 *

     5

 *  EtherCAT master driver module.

     6

 *

     7

 *  Author: Florian Pose <fp@igh-essen.com>

     8

 *

     9

 *  $Id$

    10

 *

    11

 *  (C) Copyright IgH 2005

    12

 *  Ingenieurgemeinschaft IgH

    13

 *  Heinz-Bäcker Str. 34

    14

 *  D-45356 Essen

    15

 *  Tel.: +49 201/61 99 31

    16

 *  Fax.: +49 201/61 98 36

    17

 *  E-mail: sp@igh-essen.com

    18

 *

    19

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

    20

    21

#include <linux/module.h>

    22

#include <linux/kernel.h>

    23

#include <linux/init.h>

    24

    25

#include "globals.h"

    26

#include "master.h"

    27

#include "device.h"

    28

    29

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

    30

    31

int __init ec_init_module(void);

    32

void __exit ec_cleanup_module(void);

    33

    34

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

    35

    36

#define COMPILE_INFO "Revision " EC_STR(SVNREV) \

    37

                     ", compiled by " EC_STR(USER) \

    38

                     " at " __DATE__ " " __TIME__

    39

    40

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

    41

    42

static int ec_master_count = 1;

    43

static struct list_head ec_masters;

    44

    45

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

    46

    47

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

    48

MODULE_DESCRIPTION ("EtherCAT master driver module");

    49

MODULE_LICENSE("GPL");

    50

MODULE_VERSION(COMPILE_INFO);

    51

    52

module_param(ec_master_count, int, 1);

    53

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

    54

    55

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

    56

    57

/**

    58

   Module initialization.

    59

   Initializes \a ec_master_count masters.

    60

   \return 0 on success, else < 0

    61

*/

    62

    63

int __init ec_init_module(void)

    64

{

    65

    unsigned int i;

    66

    ec_master_t *master, *next;

    67

    68

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

    69

    70

    if (ec_master_count < 1) {

    71

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

    72

        goto out_return;

    73

    }

    74

    75

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

    76

    77

    INIT_LIST_HEAD(&ec_masters);

    78

    79

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

    80

        if (!(master =

    81

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

    82

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

    83

            goto out_free;

    84

        }

    85

    86

        if (ec_master_init(master, i)) // kobject_put is done inside...

    87

            goto out_free;

    88

    89

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

    90

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

    91

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

    92

            goto out_free;

    93

        }

    94

    95

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

    96

    }

    97

    98

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

    99

    return 0;

   100

   101

 out_free:

   102

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

   103

        list_del(&master->list);

   104

        kobject_del(&master->kobj);

   105

        kobject_put(&master->kobj);

   106

    }

   107

 out_return:

   108

    return -1;

   109

}

   110

   111

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

   112

   113

/**

   114

   Module cleanup.

   115

   Clears all master instances.

   116

*/

   117

   118

void __exit ec_cleanup_module(void)

   119

{

   120

    ec_master_t *master, *next;

   121

   122

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

   123

   124

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

   125

        list_del(&master->list);

   126

        kobject_del(&master->kobj);

   127

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

   128

    }

   129

   130

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

   131

}

   132

   133

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

   134

   135

/**

   136

   Gets a handle to a certain master.

   137

   \returns pointer to master

   138

*/

   139

   140

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

   141

{

   142

    ec_master_t *master;

   143

   144

    list_for_each_entry(master, &ec_masters, list) {

   145

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

   146

    }

   147

   148

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

   149

    return NULL;

   150

}

   151

   152

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

   153

 *  Device interface

   154

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

   155

   156

/**

   157

   Registeres an EtherCAT device for a certain master.

   158

   \return 0 on success, else < 0

   159

*/

   160

   161

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

   162

                            struct net_device *net_dev, /**< net_device of

   163

                                                           the device */

   164

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

   165

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

   166

                            )

   167

{

   168

    ec_master_t *master;

   169

   170

    if (!net_dev) {

   171

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

   172

        goto out_return;

   173

    }

   174

   175

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

   176

   177

    // critical section start

   178

    if (master->device) {

   179

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

   180

        // critical section leave

   181

        goto out_return;

   182

    }

   183

   184

    if (!(master->device =

   185

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

   186

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

   187

        // critical section leave

   188

        goto out_return;

   189

    }

   190

    // critical section end

   191

   192

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

   193

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

   194

        goto out_free;

   195

    }

   196

   197

    return master->device;

   198

   199

 out_free:

   200

    kfree(master->device);

   201

    master->device = NULL;

   202

 out_return:

   203

    return NULL;

   204

}

   205

   206

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

   207

   208

/**

   209

   Unregisteres an EtherCAT device.

   210

*/

   211

   212

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

   213

                      ec_device_t *device /**< EtherCAT device */

   214

                      )

   215

{

   216

    ec_master_t *master;

   217

   218

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

   219

   220

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

   221

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

   222

        return;

   223

    }

   224

   225

    ec_device_clear(master->device);

   226

    kfree(master->device);

   227

    master->device = NULL;

   228

}

   229

   230

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

   231

   232

/**

   233

   Starts the master associated with the device.

   234

*/

   235

   236

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

   237

{

   238

    ec_master_t *master;

   239

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

   240

   241

    if (ec_device_open(master->device)) {

   242

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

   243

        return -1;

   244

    }

   245

   246

    ec_master_freerun_start(master);

   247

    return 0;

   248

}

   249

   250

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

   251

   252

/**

   253

   Stops the master associated with the device.

   254

*/

   255

   256

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

   257

{

   258

    ec_master_t *master;

   259

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

   260

   261

    ec_master_freerun_stop(master);

   262

   263

    if (ec_device_close(master->device))

   264

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

   265

}

   266

   267

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

   268

 *  Realtime interface

   269

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

   270

   271

/**

   272

   Reserves an EtherCAT master for realtime operation.

   273

   \return pointer to reserved master, or NULL on error

   274

*/

   275

   276

ec_master_t *ecrt_request_master(unsigned int master_index

   277

                                 /**< master index */

   278

                                 )

   279

{

   280

    ec_master_t *master;

   281

   282

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

   283

   284

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

   285

   286

    // begin critical section

   287

    if (master->reserved) {

   288

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

   289

        goto out_return;

   290

    }

   291

    master->reserved = 1;

   292

    // end critical section

   293

   294

    if (!master->device) {

   295

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

   296

        goto out_release;

   297

    }

   298

   299

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

   300

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

   301

        goto out_release;

   302

    }

   303

   304

    ec_master_freerun_stop(master);

   305

    ec_master_reset(master);

   306

    master->mode = EC_MASTER_MODE_RUNNING;

   307

   308

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

   309

   310

    if (ec_master_bus_scan(master)) {

   311

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

   312

        goto out_module_put;

   313

    }

   314

   315

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

   316

    return master;

   317

   318

 out_module_put:

   319

    module_put(master->device->module);

   320

    ec_master_reset(master);

   321

 out_release:

   322

    master->reserved = 0;

   323

 out_return:

   324

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

   325

    return NULL;

   326

}

   327

   328

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

   329

   330

/**

   331

   Releases a reserved EtherCAT master.

   332

*/

   333

   334

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

   335

{

   336

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

   337

   338

    if (!master->reserved) {

   339

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

   340

        return;

   341

    }

   342

   343

    ec_master_reset(master);

   344

   345

    master->mode = EC_MASTER_MODE_IDLE;

   346

    ec_master_freerun_start(master);

   347

   348

    module_put(master->device->module);

   349

    master->reserved = 0;

   350

   351

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

   352

    return;

   353

}

   354

   355

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

   356

   357

/**

   358

   Outputs frame contents for debugging purposes.

   359

*/

   360

   361

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

   362

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

   363

                   )

   364

{

   365

    unsigned int i;

   366

   367

    EC_DBG("");

   368

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

   369

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

   370

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

   371

            printk("\n");

   372

            EC_DBG("");

   373

        }

   374

    }

   375

    printk("\n");

   376

}

   377

   378

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

   379

   380

/**

   381

   Outputs frame contents and differences for debugging purposes.

   382

*/

   383

   384

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

   385

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

   386

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

   387

                        )

   388

{

   389

    unsigned int i;

   390

   391

    EC_DBG("");

   392

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

   393

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

   394

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

   395

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

   396

            printk("\n");

   397

            EC_DBG("");

   398

        }

   399

    }

   400

    printk("\n");

   401

}

   402

   403

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

   404

   405

module_init(ec_init_module);

   406

module_exit(ec_cleanup_module);

   407

   408

EXPORT_SYMBOL(ecdev_register);

   409

EXPORT_SYMBOL(ecdev_unregister);

   410

EXPORT_SYMBOL(ecdev_start);

   411

EXPORT_SYMBOL(ecdev_stop);

   412

EXPORT_SYMBOL(ecrt_request_master);

   413

EXPORT_SYMBOL(ecrt_release_master);

   414

   415

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