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

/**

    57

   Compile version info.

    58

*/

    59

    60

#define COMPILE_INFO EC_STR(EC_MASTER_VERSION_MAIN) \

    61

                     "." EC_STR(EC_MASTER_VERSION_SUB) \

    62

                     " (" EC_MASTER_VERSION_EXTRA ")" \

    63

                     " - rev. " EC_STR(SVNREV) \

    64

                     ", compiled by " EC_STR(USER) \

    65

                     " at " __DATE__ " " __TIME__

    66

    67

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

    68

    69

static int ec_master_count = 1;

    70

static struct list_head ec_masters;

    71

    72

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

    73

    74

/** \cond */

    75

    76

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

    77

MODULE_DESCRIPTION ("EtherCAT master driver module");

    78

MODULE_LICENSE("GPL");

    79

MODULE_VERSION(COMPILE_INFO);

    80

    81

module_param(ec_master_count, int, 1);

    82

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

    83

    84

/** \endcond */

    85

    86

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

    87

    88

/**

    89

   Module initialization.

    90

   Initializes \a ec_master_count masters.

    91

   \return 0 on success, else < 0

    92

*/

    93

    94

int __init ec_init_module(void)

    95

{

    96

    unsigned int i;

    97

    ec_master_t *master, *next;

    98

    99

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

   100

   101

    if (ec_master_count < 1) {

   102

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

   103

        goto out_return;

   104

    }

   105

   106

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

   107

   108

    INIT_LIST_HEAD(&ec_masters);

   109

   110

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

   111

        if (!(master =

   112

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

   113

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

   114

            goto out_free;

   115

        }

   116

   117

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

   118

            goto out_free;

   119

   120

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

   121

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

   122

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

   123

            goto out_free;

   124

        }

   125

   126

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

   127

    }

   128

   129

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

   130

    return 0;

   131

   132

 out_free:

   133

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

   134

        list_del(&master->list);

   135

        kobject_del(&master->kobj);

   136

        kobject_put(&master->kobj);

   137

    }

   138

 out_return:

   139

    return -1;

   140

}

   141

   142

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

   143

   144

/**

   145

   Module cleanup.

   146

   Clears all master instances.

   147

*/

   148

   149

void __exit ec_cleanup_module(void)

   150

{

   151

    ec_master_t *master, *next;

   152

   153

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

   154

   155

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

   156

        list_del(&master->list);

   157

        kobject_del(&master->kobj);

   158

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

   159

    }

   160

   161

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

   162

}

   163

   164

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

   165

   166

/**

   167

   Gets a handle to a certain master.

   168

   \returns pointer to master

   169

*/

   170

   171

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

   172

{

   173

    ec_master_t *master;

   174

   175

    list_for_each_entry(master, &ec_masters, list) {

   176

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

   177

    }

   178

   179

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

   180

    return NULL;

   181

}

   182

   183

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

   184

   185

/**

   186

   Outputs frame contents for debugging purposes.

   187

*/

   188

   189

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

   190

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

   191

                   )

   192

{

   193

    unsigned int i;

   194

   195

    EC_DBG("");

   196

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

   197

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

   198

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

   199

            printk("\n");

   200

            EC_DBG("");

   201

        }

   202

    }

   203

    printk("\n");

   204

}

   205

   206

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

   207

   208

/**

   209

   Outputs frame contents and differences for debugging purposes.

   210

*/

   211

   212

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

   213

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

   214

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

   215

                        )

   216

{

   217

    unsigned int i;

   218

   219

    EC_DBG("");

   220

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

   221

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

   222

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

   223

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

   224

            printk("\n");

   225

            EC_DBG("");

   226

        }

   227

    }

   228

    printk("\n");

   229

}

   230

   231

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

   232

 *  Device interface

   233

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

   234

   235

/**

   236

   Connects an EtherCAT device to a certain master.

   237

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

   238

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

   239

   the device.

   240

   \return 0 on success, else < 0

   241

   \ingroup DeviceInterface

   242

*/

   243

   244

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

   245

                            struct net_device *net_dev, /**< net_device of

   246

                                                           the device */

   247

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

   248

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

   249

                            )

   250

{

   251

    ec_master_t *master;

   252

   253

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

   254

   255

    if (master->device) {

   256

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

   257

        goto out_return;

   258

    }

   259

   260

    if (!(master->device =

   261

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

   262

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

   263

        goto out_return;

   264

    }

   265

   266

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

   267

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

   268

        goto out_free;

   269

    }

   270

   271

    return master->device;

   272

   273

 out_free:

   274

    kfree(master->device);

   275

    master->device = NULL;

   276

 out_return:

   277

    return NULL;

   278

}

   279

   280

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

   281

   282

/**

   283

   Disconnect an EtherCAT device from the master.

   284

   The device is disconnected from the master and all device ressources

   285

   are freed.

   286

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

   287

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

   288

   \ingroup DeviceInterface

   289

*/

   290

   291

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

   292

                      ec_device_t *device /**< EtherCAT device */

   293

                      )

   294

{

   295

    ec_master_t *master;

   296

   297

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

   298

   299

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

   300

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

   301

        return;

   302

    }

   303

   304

    ec_device_clear(master->device);

   305

    kfree(master->device);

   306

    master->device = NULL;

   307

}

   308

   309

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

   310

   311

/**

   312

   Starts the master associated with the device.

   313

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

   314

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

   315

   will enter the free-run mode then.

   316

   \ingroup DeviceInterface

   317

*/

   318

   319

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

   320

{

   321

    ec_master_t *master;

   322

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

   323

   324

    if (ec_device_open(master->device)) {

   325

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

   326

        return -1;

   327

    }

   328

   329

    ec_master_freerun_start(master);

   330

    return 0;

   331

}

   332

   333

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

   334

   335

/**

   336

   Stops the master associated with the device.

   337

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

   338

   before unregistering the device.

   339

   \ingroup DeviceInterface

   340

*/

   341

   342

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

   343

{

   344

    ec_master_t *master;

   345

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

   346

   347

    ec_master_freerun_stop(master);

   348

   349

    if (ec_device_close(master->device))

   350

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

   351

}

   352

   353

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

   354

 *  Realtime interface

   355

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

   356

   357

/**

   358

   Reserves an EtherCAT master for realtime operation.

   359

   \return pointer to reserved master, or NULL on error

   360

   \ingroup RealtimeInterface

   361

*/

   362

   363

ec_master_t *ecrt_request_master(unsigned int master_index

   364

                                 /**< master index */

   365

                                 )

   366

{

   367

    ec_master_t *master;

   368

   369

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

   370

   371

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

   372

   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

   379

    if (!master->device) {

   380

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

   381

        goto out_release;

   382

    }

   383

   384

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

   385

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

   386

        goto out_release;

   387

    }

   388

   389

    ec_master_freerun_stop(master);

   390

    ec_master_reset(master);

   391

    master->mode = EC_MASTER_MODE_RUNNING;

   392

   393

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

   394

   395

    if (ec_master_bus_scan(master)) {

   396

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

   397

        goto out_module_put;

   398

    }

   399

   400

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

   401

    return master;

   402

   403

 out_module_put:

   404

    module_put(master->device->module);

   405

    ec_master_reset(master);

   406

    ec_master_freerun_start(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.

   418

   \ingroup RealtimeInterface

   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

   444

/** \cond */

   445

   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

   456

/** \endcond */

   457

   458

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