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 *EtherCAT_dev_register(unsigned int master_index,

   149

                                   /**< Index des EtherCAT-Masters */

   150

                                   struct net_device *net_dev,

   151

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

   152

                                   irqreturn_t (*isr)(int, void *,

   153

                                                      struct pt_regs *),

   154

                                   /**< Interrupt-Service-Routine */

   155

                                   struct module *module

   156

                                   /**< Zeiger auf das Modul */

   157

                                   )

   158

{

   159

    ec_master_t *master;

   160

   161

    if (!net_dev) {

   162

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

   163

        return NULL;

   164

    }

   165

   166

    if (master_index >= ec_master_count) {

   167

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

   168

        return NULL;

   169

    }

   170

   171

    master = ec_masters + master_index;

   172

   173

    if (master->device) {

   174

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

   175

        return NULL;

   176

    }

   177

   178

    if (!(master->device = (ec_device_t *) kmalloc(sizeof(ec_device_t),

   179

                                                   GFP_KERNEL))) {

   180

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

   181

        return NULL;

   182

    }

   183

   184

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

   185

        return NULL;

   186

   187

    return master->device;

   188

}

   189

   190

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

   191

   192

/**

   193

   Hebt die Registrierung eines EtherCAT-Gerätes auf.

   194

*/

   195

   196

void EtherCAT_dev_unregister(unsigned int master_index,

   197

                             /**< Index des EtherCAT-Masters */

   198

                             ec_device_t *device

   199

                             /**< EtherCAT-Geraet */

   200

                             )

   201

{

   202

    ec_master_t *master;

   203

   204

    if (master_index >= ec_master_count) {

   205

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

   206

        return;

   207

    }

   208

   209

    master = ec_masters + master_index;

   210

   211

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

   212

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

   213

        return;

   214

    }

   215

   216

    ec_device_clear(master->device);

   217

    kfree(master->device);

   218

    master->device = NULL;

   219

}

   220

   221

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

   222

 *

   223

 * Echtzeitschnittstelle

   224

 *

   225

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

   226

   227

/**

   228

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

   229

   230

   Gibt einen Zeiger auf den reservierten EtherCAT-Master zurueck.

   231

   232

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

   233

*/

   234

   235

ec_master_t *EtherCAT_rt_request_master(unsigned int index

   236

                                        /**< EtherCAT-Master-Index */

   237

                                        )

   238

{

   239

    ec_master_t *master;

   240

   241

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

   242

   243

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

   244

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

   245

        goto req_return;

   246

    }

   247

   248

    if (ec_masters_reserved[index]) {

   249

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

   250

        goto req_return;

   251

    }

   252

   253

    master = &ec_masters[index];

   254

   255

    if (!master->device) {

   256

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

   257

        goto req_return;

   258

    }

   259

   260

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

   261

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

   262

        goto req_return;

   263

    }

   264

   265

    if (ec_master_open(master)) {

   266

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

   267

        goto req_module_put;

   268

    }

   269

   270

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

   271

   272

    if (ec_master_bus_scan(master) != 0) {

   273

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

   274

        goto req_close;

   275

    }

   276

   277

    ec_masters_reserved[index] = 1;

   278

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

   279

   280

    return master;

   281

   282

 req_close:

   283

    ec_master_close(master);

   284

   285

 req_module_put:

   286

    module_put(master->device->module);

   287

    ec_master_reset(master);

   288

   289

 req_return:

   290

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

   291

    return NULL;

   292

}

   293

   294

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

   295

   296

/**

   297

   Gibt einen zuvor angeforderten EtherCAT-Master wieder frei.

   298

*/

   299

   300

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

   301

{

   302

    unsigned int i, found;

   303

   304

    found = 0;

   305

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

   306

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

   307

            found = 1;

   308

            break;

   309

        }

   310

    }

   311

   312

    if (!found) {

   313

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

   314

        return;

   315

    }

   316

   317

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

   318

   319

    ec_master_close(master);

   320

    ec_master_reset(master);

   321

   322

    module_put(master->device->module);

   323

    ec_masters_reserved[i] = 0;

   324

   325

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

   326

    return;

   327

}

   328

   329

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

   330

   331

module_init(ec_init_module);

   332

module_exit(ec_cleanup_module);

   333

   334

EXPORT_SYMBOL(EtherCAT_dev_register);

   335

EXPORT_SYMBOL(EtherCAT_dev_unregister);

   336

EXPORT_SYMBOL(EtherCAT_rt_request_master);

   337

EXPORT_SYMBOL(EtherCAT_rt_release_master);

   338

   339

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

   340

   341

/* Emacs-Konfiguration

   342

;;; Local Variables: ***

   343

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

   344

;;; End: ***

   345

*/