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

        return NULL;

   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

        return NULL;

   193

    }

   194

   195

    if (!(master->device =

   196

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

   197

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

   198

        return NULL;

   199

    }

   200

    // critical section end

   201

   202

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

   203

        kfree(master->device);

   204

        master->device = NULL;

   205

        return NULL;

   206

    }

   207

   208

    return master->device;

   209

}

   210

   211

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

   212

   213

/**

   214

   Hebt die Registrierung eines EtherCAT-Gerätes auf.

   215

*/

   216

   217

void ecdev_unregister(unsigned int master_index,

   218

                      /**< Index des EtherCAT-Masters */

   219

                      ec_device_t *device

   220

                      /**< EtherCAT-Geraet */

   221

                      )

   222

{

   223

    ec_master_t *master;

   224

   225

    if (master_index >= ec_master_count) {

   226

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

   227

        return;

   228

    }

   229

   230

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

   231

   232

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

   233

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

   234

        return;

   235

    }

   236

   237

    ec_device_clear(master->device);

   238

    kfree(master->device);

   239

    master->device = NULL;

   240

}

   241

   242

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

   243

 *

   244

 * Echtzeitschnittstelle

   245

 *

   246

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

   247

   248

/**

   249

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

   250

   251

   Gibt einen Zeiger auf den reservierten EtherCAT-Master zurueck.

   252

   253

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

   254

*/

   255

   256

ec_master_t *ecrt_request_master(unsigned int master_index

   257

                                 /**< EtherCAT-Master-Index */

   258

                                 )

   259

{

   260

    ec_master_t *master;

   261

   262

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

   263

   264

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

   265

   266

    // begin critical section

   267

    if (master->reserved) {

   268

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

   269

        goto req_return;

   270

    }

   271

    master->reserved = 1;

   272

    // end critical section

   273

   274

    if (!master->device) {

   275

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

   276

        goto req_release;

   277

    }

   278

   279

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

   280

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

   281

        goto req_release;

   282

    }

   283

   284

    if (ec_device_open(master->device)) {

   285

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

   286

        goto req_module_put;

   287

    }

   288

   289

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

   290

   291

    if (ec_master_bus_scan(master)) {

   292

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

   293

        goto req_close;

   294

    }

   295

   296

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

   297

    return master;

   298

   299

 req_close:

   300

    if (ec_device_close(master->device))

   301

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

   302

 req_module_put:

   303

    module_put(master->device->module);

   304

    ec_master_reset(master);

   305

 req_release:

   306

    master->reserved = 0;

   307

 req_return:

   308

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

   309

    return NULL;

   310

}

   311

   312

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

   313

   314

/**

   315

   Gibt einen zuvor angeforderten EtherCAT-Master wieder frei.

   316

*/

   317

   318

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

   319

{

   320

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

   321

   322

    if (!master->reserved) {

   323

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

   324

        return;

   325

    }

   326

   327

    ec_master_reset(master);

   328

   329

    if (ec_device_close(master->device))

   330

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

   331

   332

    module_put(master->device->module);

   333

    master->reserved = 0;

   334

   335

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

   336

    return;

   337

}

   338

   339

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

   340

   341

/**

   342

   Gibt Frame-Inhalte zwecks Debugging aus.

   343

*/

   344

   345

void ec_print_data(const uint8_t *data, size_t size)

   346

{

   347

    unsigned int i;

   348

   349

    EC_DBG("");

   350

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

   351

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

   352

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

   353

            printk("\n");

   354

            EC_DBG("");

   355

        }

   356

    }

   357

    printk("\n");

   358

}

   359

   360

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

   361

   362

/**

   363

   Gibt Frame-Inhalte zwecks Debugging aus, differentiell.

   364

*/

   365

   366

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

   367

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

   368

                        size_t size /** Anzahl Bytes */

   369

                        )

   370

{

   371

    unsigned int i;

   372

   373

    EC_DBG("");

   374

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

   375

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

   376

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

   377

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

   378

            printk("\n");

   379

            EC_DBG("");

   380

        }

   381

    }

   382

    printk("\n");

   383

}

   384

   385

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

   386

   387

module_init(ec_init_module);

   388

module_exit(ec_cleanup_module);

   389

   390

EXPORT_SYMBOL(ecdev_register);

   391

EXPORT_SYMBOL(ecdev_unregister);

   392

EXPORT_SYMBOL(ecrt_request_master);

   393

EXPORT_SYMBOL(ecrt_release_master);

   394

   395

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

   396

   397

/* Emacs-Konfiguration

   398

;;; Local Variables: ***

   399

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

   400

;;; End: ***

   401

*/