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 - Illegal ec_master_count: %i\n", ec_master_count);

    78

        return -1;

    79

    }

    80

    81

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

    82

    83

    if ((ec_masters = (ec_master_t *) kmalloc(sizeof(ec_master_t)

    84

                                              * ec_master_count,

    85

                                              GFP_KERNEL)) == NULL) {

    86

        EC_ERR("Could not allocate memory for EtherCAT master(s)!\n");

    87

        return -1;

    88

    }

    89

    90

    if ((ec_masters_reserved =

    91

         (unsigned int *) kmalloc(sizeof(int) * ec_master_count,

    92

                                  GFP_KERNEL)) == NULL) {

    93

        EC_ERR("Could not allocate memory for reservation flags!\n");

    94

        kfree(ec_masters);

    95

        return -1;

    96

    }

    97

    98

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

    99

        ec_master_init(ec_masters + i);

   100

        ec_masters_reserved[i] = 0;

   101

    }

   102

   103

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

   104

   105

    return 0;

   106

}

   107

   108

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

   109

   110

/**

   111

   Cleanup-Funktion des EtherCAT-Master-Treibermoduls

   112

   113

   Entfernt alle Master-Instanzen.

   114

*/

   115

   116

void __exit ec_cleanup_module(void)

   117

{

   118

    unsigned int i;

   119

   120

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

   121

   122

    if (ec_masters) {

   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

            }

   127

            ec_master_clear(&ec_masters[i]);

   128

        }

   129

        kfree(ec_masters);

   130

    }

   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 *) kmalloc(sizeof(ec_device_t),

   178

                                                   GFP_KERNEL))) {

   179

        EC_ERR("Failed allocating device!\n");

   180

        return NULL;

   181

    }

   182

   183

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

   184

        return NULL;

   185

   186

    return master->device;

   187

}

   188

   189

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

   190

   191

/**

   192

   Hebt die Registrierung eines EtherCAT-Gerätes auf.

   193

*/

   194

   195

void ecdev_unregister(unsigned int master_index,

   196

                      /**< Index des EtherCAT-Masters */

   197

                      ec_device_t *device

   198

                      /**< EtherCAT-Geraet */

   199

                      )

   200

{

   201

    ec_master_t *master;

   202

   203

    if (master_index >= ec_master_count) {

   204

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

   205

        return;

   206

    }

   207

   208

    master = ec_masters + master_index;

   209

   210

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

   211

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

   212

        return;

   213

    }

   214

   215

    ec_device_clear(master->device);

   216

    kfree(master->device);

   217

    master->device = NULL;

   218

}

   219

   220

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

   221

 *

   222

 * Echtzeitschnittstelle

   223

 *

   224

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

   225

   226

/**

   227

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

   228

   229

   Gibt einen Zeiger auf den reservierten EtherCAT-Master zurueck.

   230

   231

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

   232

*/

   233

   234

ec_master_t *ecrt_request_master(unsigned int index

   235

                                 /**< EtherCAT-Master-Index */

   236

                                 )

   237

{

   238

    ec_master_t *master;

   239

   240

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

   241

   242

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

   243

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

   244

        goto req_return;

   245

    }

   246

   247

    if (ec_masters_reserved[index]) {

   248

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

   249

        goto req_return;

   250

    }

   251

   252

    master = &ec_masters[index];

   253

   254

    if (!master->device) {

   255

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

   256

        goto req_return;

   257

    }

   258

   259

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

   260

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

   261

        goto req_return;

   262

    }

   263

   264

    if (ec_master_open(master)) {

   265

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

   266

        goto req_module_put;

   267

    }

   268

   269

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

   270

   271

    if (ec_master_bus_scan(master) != 0) {

   272

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

   273

        goto req_close;

   274

    }

   275

   276

    ec_masters_reserved[index] = 1;

   277

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

   278

   279

    return master;

   280

   281

 req_close:

   282

    ec_master_close(master);

   283

   284

 req_module_put:

   285

    module_put(master->device->module);

   286

    ec_master_reset(master);

   287

   288

 req_return:

   289

    EC_INFO("===== Failed to start master %i =====\n", index);

   290

    return NULL;

   291

}

   292

   293

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

   294

   295

/**

   296

   Gibt einen zuvor angeforderten EtherCAT-Master wieder frei.

   297

*/

   298

   299

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

   300

{

   301

    unsigned int i, found;

   302

   303

    found = 0;

   304

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

   305

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

   306

            found = 1;

   307

            break;

   308

        }

   309

    }

   310

   311

    if (!found) {

   312

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

   313

        return;

   314

    }

   315

   316

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

   317

   318

    ec_master_close(master);

   319

    ec_master_reset(master);

   320

   321

    module_put(master->device->module);

   322

    ec_masters_reserved[i] = 0;

   323

   324

    EC_INFO("===== Master %i stopped. =====\n", i);

   325

    return;

   326

}

   327

   328

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

   329

   330

module_init(ec_init_module);

   331

module_exit(ec_cleanup_module);

   332

   333

EXPORT_SYMBOL(ecdev_register);

   334

EXPORT_SYMBOL(ecdev_unregister);

   335

EXPORT_SYMBOL(ecrt_request_master);

   336

EXPORT_SYMBOL(ecrt_release_master);

   337

   338

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

   339

   340

/* Emacs-Konfiguration

   341

;;; Local Variables: ***

   342

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

   343

;;; End: ***

   344

*/