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

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

    12

 *

    13

 *  This file is part of the IgH EtherCAT Master.

    14

 *

    15

 *  The IgH EtherCAT Master is free software; you can redistribute it

    16

 *  and/or modify it under the terms of the GNU General Public License

    17

 *  as published by the Free Software Foundation; version 2 of the License.

    18

 *

    19

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

    20

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

    21

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    22

 *  GNU General Public License for more details.

    23

 *

    24

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

    25

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

    26

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

    27

 *

    28

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

    29

    30

#include <linux/module.h>

    31

#include <linux/kernel.h>

    32

#include <linux/init.h>

    33

    34

#include "globals.h"

    35

#include "master.h"

    36

#include "device.h"

    37

    38

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

    39

    40

int __init ec_init_module(void);

    41

void __exit ec_cleanup_module(void);

    42

    43

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

    44

    45

#define COMPILE_INFO EC_STR(EC_MASTER_VERSION_MAIN) \

    46

                     "." EC_STR(EC_MASTER_VERSION_SUB) \

    47

                     " (" EC_MASTER_VERSION_EXTRA ")" \

    48

                     " - rev. " EC_STR(SVNREV) \

    49

                     ", compiled by " EC_STR(USER) \

    50

                     " at " __DATE__ " " __TIME__

    51

    52

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

    53

    54

static int ec_master_count = 1;

    55

static struct list_head ec_masters;

    56

    57

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

    58

    59

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

    60

MODULE_DESCRIPTION ("EtherCAT master driver module");

    61

MODULE_LICENSE("GPL");

    62

MODULE_VERSION(COMPILE_INFO);

    63

    64

module_param(ec_master_count, int, 1);

    65

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

    66

    67

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

    68

    69

/**

    70

   Module initialization.

    71

   Initializes \a ec_master_count masters.

    72

   \return 0 on success, else < 0

    73

*/

    74

    75

int __init ec_init_module(void)

    76

{

    77

    unsigned int i;

    78

    ec_master_t *master, *next;

    79

    80

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

    81

    82

    if (ec_master_count < 1) {

    83

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

    84

        goto out_return;

    85

    }

    86

    87

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

    88

    89

    INIT_LIST_HEAD(&ec_masters);

    90

    91

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

    92

        if (!(master =

    93

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

    94

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

    95

            goto out_free;

    96

        }

    97

    98

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

    99

            goto out_free;

   100

   101

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

   102

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

   103

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

   104

            goto out_free;

   105

        }

   106

   107

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

   108

    }

   109

   110

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

   111

    return 0;

   112

   113

 out_free:

   114

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

   115

        list_del(&master->list);

   116

        kobject_del(&master->kobj);

   117

        kobject_put(&master->kobj);

   118

    }

   119

 out_return:

   120

    return -1;

   121

}

   122

   123

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

   124

   125

/**

   126

   Module cleanup.

   127

   Clears all master instances.

   128

*/

   129

   130

void __exit ec_cleanup_module(void)

   131

{

   132

    ec_master_t *master, *next;

   133

   134

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

   135

   136

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

   137

        list_del(&master->list);

   138

        kobject_del(&master->kobj);

   139

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

   140

    }

   141

   142

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

   143

}

   144

   145

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

   146

   147

/**

   148

   Gets a handle to a certain master.

   149

   \returns pointer to master

   150

*/

   151

   152

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

   153

{

   154

    ec_master_t *master;

   155

   156

    list_for_each_entry(master, &ec_masters, list) {

   157

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

   158

    }

   159

   160

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

   161

    return NULL;

   162

}

   163

   164

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

   165

   166

/**

   167

   Outputs frame contents for debugging purposes.

   168

*/

   169

   170

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

   171

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

   172

                   )

   173

{

   174

    unsigned int i;

   175

   176

    EC_DBG("");

   177

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

   178

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

   179

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

   180

            printk("\n");

   181

            EC_DBG("");

   182

        }

   183

    }

   184

    printk("\n");

   185

}

   186

   187

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

   188

   189

/**

   190

   Outputs frame contents and differences for debugging purposes.

   191

*/

   192

   193

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

   194

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

   195

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

   196

                        )

   197

{

   198

    unsigned int i;

   199

   200

    EC_DBG("");

   201

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

   202

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

   203

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

   204

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

   205

            printk("\n");

   206

            EC_DBG("");

   207

        }

   208

    }

   209

    printk("\n");

   210

}

   211

   212

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

   213

 *  Device interface

   214

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

   215

   216

/**

   217

   Registeres an EtherCAT device for a certain master.

   218

   \return 0 on success, else < 0

   219

*/

   220

   221

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

   222

                            struct net_device *net_dev, /**< net_device of

   223

                                                           the device */

   224

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

   225

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

   226

                            )

   227

{

   228

    ec_master_t *master;

   229

   230

    if (!net_dev) {

   231

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

   232

        goto out_return;

   233

    }

   234

   235

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

   236

   237

    // critical section start

   238

    if (master->device) {

   239

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

   240

        // critical section leave

   241

        goto out_return;

   242

    }

   243

   244

    if (!(master->device =

   245

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

   246

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

   247

        // critical section leave

   248

        goto out_return;

   249

    }

   250

    // critical section end

   251

   252

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

   253

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

   254

        goto out_free;

   255

    }

   256

   257

    return master->device;

   258

   259

 out_free:

   260

    kfree(master->device);

   261

    master->device = NULL;

   262

 out_return:

   263

    return NULL;

   264

}

   265

   266

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

   267

   268

/**

   269

   Unregisteres an EtherCAT device.

   270

*/

   271

   272

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

   273

                      ec_device_t *device /**< EtherCAT device */

   274

                      )

   275

{

   276

    ec_master_t *master;

   277

   278

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

   279

   280

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

   281

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

   282

        return;

   283

    }

   284

   285

    ec_device_clear(master->device);

   286

    kfree(master->device);

   287

    master->device = NULL;

   288

}

   289

   290

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

   291

   292

/**

   293

   Starts the master associated with the device.

   294

*/

   295

   296

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

   297

{

   298

    ec_master_t *master;

   299

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

   300

   301

    if (ec_device_open(master->device)) {

   302

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

   303

        return -1;

   304

    }

   305

   306

    ec_master_freerun_start(master);

   307

    return 0;

   308

}

   309

   310

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

   311

   312

/**

   313

   Stops the master associated with the device.

   314

*/

   315

   316

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

   317

{

   318

    ec_master_t *master;

   319

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

   320

   321

    ec_master_freerun_stop(master);

   322

   323

    if (ec_device_close(master->device))

   324

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

   325

}

   326

   327

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

   328

 *  Realtime interface

   329

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

   330

   331

/**

   332

   Reserves an EtherCAT master for realtime operation.

   333

   \return pointer to reserved master, or NULL on error

   334

*/

   335

   336

ec_master_t *ecrt_request_master(unsigned int master_index

   337

                                 /**< master index */

   338

                                 )

   339

{

   340

    ec_master_t *master;

   341

   342

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

   343

   344

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

   345

   346

    // begin critical section

   347

    if (master->reserved) {

   348

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

   349

        goto out_return;

   350

    }

   351

    master->reserved = 1;

   352

    // end critical section

   353

   354

    if (!master->device) {

   355

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

   356

        goto out_release;

   357

    }

   358

   359

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

   360

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

   361

        goto out_release;

   362

    }

   363

   364

    ec_master_freerun_stop(master);

   365

    ec_master_reset(master);

   366

    master->mode = EC_MASTER_MODE_RUNNING;

   367

   368

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

   369

   370

    if (ec_master_bus_scan(master)) {

   371

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

   372

        goto out_module_put;

   373

    }

   374

   375

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

   376

    return master;

   377

   378

 out_module_put:

   379

    module_put(master->device->module);

   380

    ec_master_reset(master);

   381

 out_release:

   382

    master->reserved = 0;

   383

 out_return:

   384

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

   385

    return NULL;

   386

}

   387

   388

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

   389

   390

/**

   391

   Releases a reserved EtherCAT master.

   392

*/

   393

   394

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

   395

{

   396

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

   397

   398

    if (!master->reserved) {

   399

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

   400

        return;

   401

    }

   402

   403

    ec_master_reset(master);

   404

   405

    master->mode = EC_MASTER_MODE_IDLE;

   406

    ec_master_freerun_start(master);

   407

   408

    module_put(master->device->module);

   409

    master->reserved = 0;

   410

   411

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

   412

    return;

   413

}

   414

   415

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

   416

   417

module_init(ec_init_module);

   418

module_exit(ec_cleanup_module);

   419

   420

EXPORT_SYMBOL(ecdev_register);

   421

EXPORT_SYMBOL(ecdev_unregister);

   422

EXPORT_SYMBOL(ecdev_start);

   423

EXPORT_SYMBOL(ecdev_stop);

   424

EXPORT_SYMBOL(ecrt_request_master);

   425

EXPORT_SYMBOL(ecrt_release_master);

   426

   427

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