1

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

     2

 *

     3

 *  m o d u l e . c

     4

 *

     5

 *  EtherCAT-Master-Treiber

     6

 *

     7

 *  Autoren: Wilhelm Hagemeister, Florian Pose

     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 master to initialize.");

    54

    55

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

    56

    57

/**

    58

   Init-Funktion des EtherCAT-Master-Treibermodules

    59

    60

   Initialisiert soviele Master, wie im Parameter ec_master_count

    61

   angegeben wurde (Default ist 1).

    62

    63

   \return 0 wenn alles ok, < 0 bei ungültiger Anzahl Master

    64

           oder zu wenig Speicher.

    65

*/

    66

    67

int __init ec_init_module(void)

    68

{

    69

    unsigned int i;

    70

    ec_master_t *master, *next;

    71

    72

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

    73

    74

    if (ec_master_count < 1) {

    75

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

    76

        goto out_return;

    77

    }

    78

    79

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

    80

    81

    INIT_LIST_HEAD(&ec_masters);

    82

    83

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

    84

        if (!(master =

    85

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

    86

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

    87

            goto out_free;

    88

        }

    89

    90

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

    91

            goto out_free;

    92

    93

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

    94

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

    95

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

    96

            goto out_free;

    97

        }

    98

    99

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

   100

    }

   101

   102

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

   103

    return 0;

   104

   105

 out_free:

   106

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

   107

        list_del(&master->list);

   108

        kobject_del(&master->kobj);

   109

        kobject_put(&master->kobj);

   110

    }

   111

 out_return:

   112

    return -1;

   113

}

   114

   115

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

   116

   117

/**

   118

   Cleanup-Funktion des EtherCAT-Master-Treibermoduls

   119

   120

   Entfernt alle Master-Instanzen.

   121

*/

   122

   123

void __exit ec_cleanup_module(void)

   124

{

   125

    ec_master_t *master, *next;

   126

   127

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

   128

   129

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

   130

        list_del(&master->list);

   131

        kobject_del(&master->kobj);

   132

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

   133

    }

   134

   135

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

   136

}

   137

   138

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

   139

   140

/**

   141

   Gets a handle to a certain master.

   142

   \returns pointer to master

   143

*/

   144

   145

ec_master_t *ec_find_master(unsigned int master_index)

   146

{

   147

    ec_master_t *master;

   148

   149

    list_for_each_entry(master, &ec_masters, list) {

   150

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

   151

    }

   152

   153

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

   154

    return NULL;

   155

}

   156

   157

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

   158

 *

   159

 * Treiberschnittstelle

   160

 *

   161

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

   162

   163

/**

   164

   Registeriert das EtherCAT-Geraet fuer einen EtherCAT-Master.

   165

   166

   \return 0 wenn alles ok, oder < 0 wenn bereits ein Gerät registriert

   167

           oder das Geraet nicht geöffnet werden konnte.

   168

*/

   169

   170

ec_device_t *ecdev_register(unsigned int master_index,

   171

                            /**< Index des EtherCAT-Masters */

   172

                            struct net_device *net_dev,

   173

                            /**< net_device des EtherCAT-Gerätes */

   174

                            ec_isr_t isr,

   175

                            /**< Interrupt-Service-Routine */

   176

                            struct module *module

   177

                            /**< Zeiger auf das Modul */

   178

                            )

   179

{

   180

    ec_master_t *master;

   181

   182

    if (!net_dev) {

   183

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

   184

        goto out_return;

   185

    }

   186

   187

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

   188

   189

    // critical section start

   190

    if (master->device) {

   191

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

   192

        // critical section leave

   193

        goto out_return;

   194

    }

   195

   196

    if (!(master->device =

   197

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

   198

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

   199

        // critical section leave

   200

        goto out_return;

   201

    }

   202

    // critical section end

   203

   204

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

   205

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

   206

        goto out_free;

   207

    }

   208

   209

    return master->device;

   210

   211

 out_free:

   212

    kfree(master->device);

   213

    master->device = NULL;

   214

 out_return:

   215

    return NULL;

   216

}

   217

   218

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

   219

   220

/**

   221

   Hebt die Registrierung eines EtherCAT-Gerätes auf.

   222

*/

   223

   224

void ecdev_unregister(unsigned int master_index,

   225

                      /**< Index des EtherCAT-Masters */

   226

                      ec_device_t *device

   227

                      /**< EtherCAT-Geraet */

   228

                      )

   229

{

   230

    ec_master_t *master;

   231

   232

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

   233

   234

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

   235

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

   236

        return;

   237

    }

   238

   239

    ec_device_clear(master->device);

   240

    kfree(master->device);

   241

    master->device = NULL;

   242

}

   243

   244

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

   245

   246

/**

   247

   Starts the master.

   248

*/

   249

   250

int ecdev_start(unsigned int master_index

   251

                /**< Index des EtherCAT-Masters */

   252

                )

   253

{

   254

    ec_master_t *master;

   255

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

   256

   257

    if (ec_device_open(master->device)) {

   258

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

   259

        return -1;

   260

    }

   261

   262

    ec_master_freerun_start(master);

   263

    return 0;

   264

}

   265

   266

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

   267

   268

/**

   269

   Stops the master.

   270

*/

   271

   272

void ecdev_stop(unsigned int master_index

   273

                /**< Index des EtherCAT-Masters */

   274

                )

   275

{

   276

    ec_master_t *master;

   277

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

   278

   279

    ec_master_freerun_stop(master);

   280

   281

    if (ec_device_close(master->device))

   282

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

   283

}

   284

   285

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

   286

 *

   287

 * Echtzeitschnittstelle

   288

 *

   289

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

   290

   291

/**

   292

   Reserviert einen bestimmten EtherCAT-Master und das zugehörige Gerät.

   293

   294

   Gibt einen Zeiger auf den reservierten EtherCAT-Master zurueck.

   295

   296

   \return Zeiger auf EtherCAT-Master oder NULL, wenn Parameter ungueltig.

   297

*/

   298

   299

ec_master_t *ecrt_request_master(unsigned int master_index

   300

                                 /**< EtherCAT-Master-Index */

   301

                                 )

   302

{

   303

    ec_master_t *master;

   304

   305

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

   306

   307

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

   308

   309

    // begin critical section

   310

    if (master->reserved) {

   311

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

   312

        goto out_return;

   313

    }

   314

    master->reserved = 1;

   315

    // end critical section

   316

   317

    if (!master->device) {

   318

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

   319

        goto out_release;

   320

    }

   321

   322

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

   323

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

   324

        goto out_release;

   325

    }

   326

   327

    ec_master_freerun_stop(master);

   328

    ec_master_reset(master);

   329

    master->mode = EC_MASTER_MODE_RUNNING;

   330

   331

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

   332

   333

    if (ec_master_bus_scan(master)) {

   334

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

   335

        goto out_module_put;

   336

    }

   337

   338

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

   339

    return master;

   340

   341

 out_module_put:

   342

    module_put(master->device->module);

   343

    ec_master_reset(master);

   344

 out_release:

   345

    master->reserved = 0;

   346

 out_return:

   347

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

   348

    return NULL;

   349

}

   350

   351

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

   352

   353

/**

   354

   Gibt einen zuvor angeforderten EtherCAT-Master wieder frei.

   355

*/

   356

   357

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

   358

{

   359

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

   360

   361

    if (!master->reserved) {

   362

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

   363

        return;

   364

    }

   365

   366

    ec_master_reset(master);

   367

   368

    master->mode = EC_MASTER_MODE_IDLE;

   369

    ec_master_freerun_start(master);

   370

   371

    module_put(master->device->module);

   372

    master->reserved = 0;

   373

   374

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

   375

    return;

   376

}

   377

   378

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

   379

   380

/**

   381

   Gibt Frame-Inhalte zwecks Debugging aus.

   382

*/

   383

   384

void ec_print_data(const uint8_t *data, size_t size)

   385

{

   386

    unsigned int i;

   387

   388

    EC_DBG("");

   389

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

   390

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

   391

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

   392

            printk("\n");

   393

            EC_DBG("");

   394

        }

   395

    }

   396

    printk("\n");

   397

}

   398

   399

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

   400

   401

/**

   402

   Gibt Frame-Inhalte zwecks Debugging aus, differentiell.

   403

*/

   404

   405

void ec_print_data_diff(const uint8_t *d1, /**< Daten 1 */

   406

                        const uint8_t *d2, /**< Daten 2 */

   407

                        size_t size /** Anzahl Bytes */

   408

                        )

   409

{

   410

    unsigned int i;

   411

   412

    EC_DBG("");

   413

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

   414

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

   415

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

   416

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

   417

            printk("\n");

   418

            EC_DBG("");

   419

        }

   420

    }

   421

    printk("\n");

   422

}

   423

   424

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

   425

   426

module_init(ec_init_module);

   427

module_exit(ec_cleanup_module);

   428

   429

EXPORT_SYMBOL(ecdev_register);

   430

EXPORT_SYMBOL(ecdev_unregister);

   431

EXPORT_SYMBOL(ecdev_start);

   432

EXPORT_SYMBOL(ecdev_stop);

   433

EXPORT_SYMBOL(ecrt_request_master);

   434

EXPORT_SYMBOL(ecrt_release_master);

   435

   436

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

   437

   438

/* Emacs-Konfiguration

   439

;;; Local Variables: ***

   440

;;; c-basic-offset:4 ***

   441

;;; End: ***

   442

*/