1

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

     2

 *

     3

 *  $Id$

     4

 *

    21

 *

    22

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

    23

    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

    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

    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

    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

/**

   230

   \return 0 on success, else < 0

   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

/**

   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.

   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.

   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

   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

 out_release:

   408

    master->reserved = 0;

   409

 out_return:

   410

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

   411

    return NULL;

   412

}

   413

   414

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

   415

   416

/**

   417

   Releases a reserved EtherCAT master.

   419

*/

   420

   421

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

   422

{

   423

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

   424

   425

    if (!master->reserved) {

   426

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

   427

        return;

   428

    }

   429

   430

    ec_master_reset(master);

   431

   432

    master->mode = EC_MASTER_MODE_IDLE;

   433

    ec_master_freerun_start(master);

   434

   435

    module_put(master->device->module);

   436

    master->reserved = 0;

   437

   438

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

   439

    return;

   440

}

   441

   442

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

   443

   446

module_init(ec_init_module);

   447

module_exit(ec_cleanup_module);

   448

   449

EXPORT_SYMBOL(ecdev_register);

   450

EXPORT_SYMBOL(ecdev_unregister);

   451

EXPORT_SYMBOL(ecdev_start);

   452

EXPORT_SYMBOL(ecdev_stop);

   453

EXPORT_SYMBOL(ecrt_request_master);

   454

EXPORT_SYMBOL(ecrt_release_master);

   455