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 "master.h"

    26

#include "device.h"

    27

    28

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

    29

    30

int __init ec_init_module(void);

    31

void __exit ec_cleanup_module(void);

    32

    33

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

    34

    35

#define EC_LIT(X) #X

    36

#define EC_STR(X) EC_LIT(X)

    37

    38

#define COMPILE_INFO "Revision " EC_STR(SVNREV) \

    39

                     ", compiled by " EC_STR(USER) \

    40

                     " at " __DATE__ " " __TIME__

    41

    42

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

    43

    44

int ec_master_count = 1;

    45

ec_master_t *ec_masters = NULL;

    46

unsigned int *ec_masters_reserved = NULL;

    47

    48

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

    49

    50

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

    51

MODULE_DESCRIPTION ("EtherCAT master driver module");

    52

MODULE_LICENSE("GPL");

    53

MODULE_VERSION(COMPILE_INFO);

    54

    55

module_param(ec_master_count, int, 1);

    56

MODULE_PARM_DESC(ec_master_count, "Number of EtherCAT master to initialize.");

    57

    58

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

    59

    60

/**

    61

   Init-Funktion des EtherCAT-Master-Treibermodules

    62

    63

   Initialisiert soviele Master, wie im Parameter ec_master_count

    64

   angegeben wurde (Default ist 1).

    65

    66

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

    67

           oder zu wenig Speicher.

    68

*/

    69

    70

int __init ec_init_module(void)

    71

{

    72

    unsigned int i;

    73

    74

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

    75

    76

    if (ec_master_count < 1) {

    77

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

    78

        goto out_return;

    79

    }

    80

    81

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

    82

    83

    if (!(ec_masters = (ec_master_t *)

    84

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

    85

        EC_ERR("Failed to allocate master(s)!\n");

    86

        goto out_return;

    87

    }

    88

    89

    if (!(ec_masters_reserved = (unsigned int *)

    90

          kmalloc(sizeof(int) * ec_master_count, GFP_KERNEL))) {

    91

        EC_ERR("Failed to allocate reservation flags!\n");

    92

        goto out_free_masters;

    93

    }

    94

    95

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

    96

        ec_master_init(ec_masters + i);

    97

        ec_masters_reserved[i] = 0;

    98

    }

    99

   100

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

   101

    return 0;

   102

   103

 out_free_masters:

   104

    kfree(ec_masters);

   105

 out_return:

   106

    return -1;

   107

}

   108

   109

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

   110

   111

/**

   112

   Cleanup-Funktion des EtherCAT-Master-Treibermoduls

   113

   114

   Entfernt alle Master-Instanzen.

   115

*/

   116

   117

void __exit ec_cleanup_module(void)

   118

{

   119

    unsigned int i;

   120

   121

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

   122

   123

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

   124

        if (ec_masters_reserved[i])

   125

            EC_WARN("Master %i is still in use!\n", i);

   126

        ec_master_clear(&ec_masters[i]);

   127

    }

   128

   129

    kfree(ec_masters);

   130

    kfree(ec_masters_reserved);

   131

   132

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

   133

}

   134

   135

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

   136

 *

   137

 * Treiberschnittstelle

   138

 *

   139

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

   140

   141

/**

   142

   Registeriert das EtherCAT-Geraet fuer einen EtherCAT-Master.

   143

   144

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

   145

           oder das Geraet nicht geöffnet werden konnte.

   146

*/

   147

   148

ec_device_t *ecdev_register(unsigned int master_index,

   149

                            /**< Index des EtherCAT-Masters */

   150

                            struct net_device *net_dev,

   151

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

   152

                            ec_isr_t isr,

   153

                            /**< Interrupt-Service-Routine */

   154

                            struct module *module

   155

                            /**< Zeiger auf das Modul */

   156

                            )

   157

{

   158

    ec_master_t *master;

   159

   160

    if (!net_dev) {

   161

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

   162

        return NULL;

   163

    }

   164

   165

    if (master_index >= ec_master_count) {

   166

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

   167

        return NULL;

   168

    }

   169

   170

    master = ec_masters + master_index;

   171

   172

    if (master->device) {

   173

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

   174

        return NULL;

   175

    }

   176

   177

    if (!(master->device = (ec_device_t *)

   178

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

   179

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

   180

        return NULL;

   181

    }

   182

   183

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

   184

        kfree(master->device);

   185

        master->device = NULL;

   186

        return NULL;

   187

    }

   188

   189

    return master->device;

   190

}

   191

   192

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

   193

   194

/**

   195

   Hebt die Registrierung eines EtherCAT-Gerätes auf.

   196

*/

   197

   198

void ecdev_unregister(unsigned int master_index,

   199

                      /**< Index des EtherCAT-Masters */

   200

                      ec_device_t *device

   201

                      /**< EtherCAT-Geraet */

   202

                      )

   203

{

   204

    ec_master_t *master;

   205

   206

    if (master_index >= ec_master_count) {

   207

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

   208

        return;

   209

    }

   210

   211

    master = ec_masters + master_index;

   212

   213

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

   214

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

   215

        return;

   216

    }

   217

   218

    ec_device_clear(master->device);

   219

    kfree(master->device);

   220

    master->device = NULL;

   221

}

   222

   223

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

   224

 *

   225

 * Echtzeitschnittstelle

   226

 *

   227

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

   228

   229

/**

   230

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

   231

   232

   Gibt einen Zeiger auf den reservierten EtherCAT-Master zurueck.

   233

   234

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

   235

*/

   236

   237

ec_master_t *ecrt_request_master(unsigned int index

   238

                                 /**< EtherCAT-Master-Index */

   239

                                 )

   240

{

   241

    ec_master_t *master;

   242

   243

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

   244

   245

    if (index < 0 || index >= ec_master_count) {

   246

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

   247

        goto req_return;

   248

    }

   249

   250

    if (ec_masters_reserved[index]) {

   251

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

   252

        goto req_return;

   253

    }

   254

   255

    ec_masters_reserved[index] = 1;

   256

    master = &ec_masters[index];

   257

   258

    if (!master->device) {

   259

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

   260

        goto req_release;

   261

    }

   262

   263

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

   264

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

   265

        goto req_release;

   266

    }

   267

   268

    if (ec_device_open(master->device)) {

   269

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

   270

        goto req_module_put;

   271

    }

   272

   273

    if (!master->device->link_state)

   274

        EC_WARN("Link is DOWN.\n");

   275

   276

    if (ec_master_bus_scan(master) != 0) {

   277

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

   278

        goto req_close;

   279

    }

   280

   281

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

   282

    return master;

   283

   284

 req_close:

   285

    if (ec_device_close(master->device))

   286

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

   287

 req_module_put:

   288

    module_put(master->device->module);

   289

    ec_master_reset(master);

   290

 req_release:

   291

    ec_masters_reserved[index] = 0;

   292

 req_return:

   293

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

   294

    return NULL;

   295

}

   296

   297

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

   298

   299

/**

   300

   Gibt einen zuvor angeforderten EtherCAT-Master wieder frei.

   301

*/

   302

   303

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

   304

{

   305

    unsigned int i, found;

   306

   307

    found = 0;

   308

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

   309

        if (&ec_masters[i] == master) {

   310

            found = 1;

   311

            break;

   312

        }

   313

    }

   314

   315

    if (!found) {

   316

        EC_WARN("Master 0x%08X was never requested!\n", (u32) master);

   317

        return;

   318

    }

   319

   320

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

   321

   322

    ec_master_reset(master);

   323

   324

    if (ec_device_close(master->device))

   325

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

   326

   327

    module_put(master->device->module);

   328

    ec_masters_reserved[i] = 0;

   329

   330

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

   331

    return;

   332

}

   333

   334

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

   335

   336

/**

   337

   Gibt Frame-Inhalte zwecks Debugging aus.

   338

*/

   339

   340

void ec_print_data(const uint8_t *data, size_t size)

   341

{

   342

    unsigned int i;

   343

   344

    EC_DBG("");

   345

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

   346

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

   347

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

   348

            printk("\n");

   349

            EC_DBG("");

   350

        }

   351

    }

   352

    printk("\n");

   353

}

   354

   355

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

   356

   357

/**

   358

   Gibt Frame-Inhalte zwecks Debugging aus, differentiell.

   359

*/

   360

   361

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

   362

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

   363

                        size_t size /** Anzahl Bytes */

   364

                        )

   365

{

   366

    unsigned int i;

   367

   368

    EC_DBG("");

   369

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

   370

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

   371

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

   372

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

   373

            printk("\n");

   374

            EC_DBG("");

   375

        }

   376

    }

   377

    printk("\n");

   378

}

   379

   380

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

   381

   382

module_init(ec_init_module);

   383

module_exit(ec_cleanup_module);

   384

   385

EXPORT_SYMBOL(ecdev_register);

   386

EXPORT_SYMBOL(ecdev_unregister);

   387

EXPORT_SYMBOL(ecrt_request_master);

   388

EXPORT_SYMBOL(ecrt_release_master);

   389

   390

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

   391

   392

/* Emacs-Konfiguration

   393

;;; Local Variables: ***

   394

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

   395

;;; End: ***

   396

*/