1

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

     2

 *

     3

 *  m a s t e r . c

     4

 *

     5

 *  Methoden für einen EtherCAT-Master.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/module.h>

    12

#include <linux/kernel.h>

    13

#include <linux/string.h>

    14

#include <linux/slab.h>

    15

#include <linux/delay.h>

    16

    17

#include "../include/EtherCAT_rt.h"

    18

#include "../include/EtherCAT_si.h"

    19

#include "globals.h"

    20

#include "master.h"

    21

#include "slave.h"

    22

#include "types.h"

    23

#include "device.h"

    24

#include "frame.h"

    25

    26

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

    27

    28

/**

    29

   Konstruktor des EtherCAT-Masters.

    30

*/

    31

    32

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

    33

{

    34

    master->slaves = NULL;

    35

    master->slave_count = 0;

    36

    master->device_registered = 0;

    37

    master->command_index = 0x00;

    38

    master->domain_count = 0;

    39

    master->debug_level = 0;

    40

    master->bus_time = 0;

    41

    master->frames_lost = 0;

    42

    master->t_lost_output = 0;

    43

}

    44

    45

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

    46

    47

/**

    48

   Destruktor eines EtherCAT-Masters.

    49

    50

   Entfernt alle Kommandos aus der Liste, löscht den Zeiger

    51

   auf das Slave-Array und gibt die Prozessdaten frei.

    52

*/

    53

    54

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

    55

{

    56

    ec_master_reset(master);

    57

    ec_device_clear(&master->device);

    58

}

    59

    60

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

    61

    62

/**

    63

   Setzt den Master zurück in den Ausgangszustand.

    64

    65

   Bei einem "release" sollte immer diese Funktion aufgerufen werden,

    66

   da sonst Slave-Liste, Domains, etc. weiter existieren.

    67

*/

    68

    69

void ec_master_reset(ec_master_t *master

    70

                     /**< Zeiger auf den zurückzusetzenden Master */

    71

                     )

    72

{

    73

    unsigned int i;

    74

    75

    ec_master_clear_slaves(master);

    76

    77

    for (i = 0; i < master->domain_count; i++) {

    78

        ec_domain_clear(master->domains[i]);

    79

        kfree(master->domains[i]);

    80

    }

    81

    master->domain_count = 0;

    82

    83

    master->command_index = 0;

    84

    master->debug_level = 0;

    85

    master->bus_time = 0;

    86

    master->frames_lost = 0;

    87

    master->t_lost_output = 0;

    88

}

    89

    90

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

    91

    92

/**

    93

   Entfernt alle Slaves.

    94

*/

    95

    96

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

    97

{

    98

    unsigned int i;

    99

   100

    if (master->slaves) {

   101

        for (i = 0; i < master->slave_count; i++) {

   102

            ec_slave_clear(master->slaves + i);

   103

        }

   104

        kfree(master->slaves);

   105

        master->slaves = NULL;

   106

    }

   107

    master->slave_count = 0;

   108

}

   109

   110

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

   111

   112

/**

   113

   Öffnet das EtherCAT-Geraet des Masters.

   114

   115

   \return 0, wenn alles o.k., < 0, wenn kein Gerät registriert wurde oder

   116

   es nicht geoeffnet werden konnte.

   117

*/

   118

   119

int ec_master_open(ec_master_t *master /**< Der EtherCAT-Master */)

   120

{

   121

    if (!master->device_registered) {

   122

        printk(KERN_ERR "EtherCAT: No device registered!\n");

   123

        return -1;

   124

    }

   125

   126

    if (ec_device_open(&master->device) < 0) {

   127

        printk(KERN_ERR "EtherCAT: Could not open device!\n");

   128

        return -1;

   129

    }

   130

   131

    return 0;

   132

}

   133

   134

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

   135

   136

/**

   137

   Schliesst das EtherCAT-Geraet, auf dem der Master arbeitet.

   138

*/

   139

   140

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

   141

{

   142

    if (!master->device_registered) {

   143

        printk(KERN_WARNING "EtherCAT: Warning -"

   144

               " Trying to close an unregistered device!\n");

   145

        return;

   146

    }

   147

   148

    if (ec_device_close(&master->device) < 0) {

   149

        printk(KERN_WARNING "EtherCAT: Warning - Could not close device!\n");

   150

    }

   151

}

   152

   153

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

   154

   155

/**

   156

   Durchsucht den Bus nach Slaves.

   157

   158

   @return 0 bei Erfolg, sonst < 0

   159

*/

   160

   161

int ec_scan_for_slaves(ec_master_t *master /**< EtherCAT-Master */)

   162

{

   163

    ec_frame_t frame;

   164

    ec_slave_t *slave;

   165

    ec_slave_ident_t *ident;

   166

    unsigned int i;

   167

    unsigned char data[2];

   168

   169

    if (master->slaves || master->slave_count)

   170

        printk(KERN_WARNING "EtherCAT: Slave scan already done!\n");

   171

    ec_master_clear_slaves(master);

   172

   173

    // Determine number of slaves on bus

   174

   175

    ec_frame_init_brd(&frame, master, 0x0000, 4);

   176

    if (unlikely(ec_frame_send_receive(&frame) < 0)) return -1;

   177

   178

    master->slave_count = frame.working_counter;

   179

    printk("EtherCAT: Found %i slaves on bus.\n", master->slave_count);

   180

   181

    if (!master->slave_count) return 0;

   182

   183

    if (!(master->slaves = (ec_slave_t *) kmalloc(master->slave_count

   184

                                                      * sizeof(ec_slave_t),

   185

                                                      GFP_KERNEL))) {

   186

        printk(KERN_ERR "EtherCAT: Could not allocate memory for bus"

   187

               " slaves!\n");

   188

        return -1;

   189

    }

   190

   191

    // Init slaves

   192

    for (i = 0; i < master->slave_count; i++) {

   193

        slave = master->slaves + i;

   194

        ec_slave_init(slave, master);

   195

        slave->ring_position = i;

   196

        slave->station_address = i + 1;

   197

    }

   198

   199

    // For every slave in the list

   200

    for (i = 0; i < master->slave_count; i++)

   201

    {

   202

        slave = master->slaves + i;

   203

   204

        // Write station address

   205

        EC_WRITE_U16(data, slave->station_address);

   206

   207

        ec_frame_init_apwr(&frame, master, slave->ring_position, 0x0010,

   208

                           sizeof(uint16_t), data);

   209

   210

        if (unlikely(ec_frame_send_receive(&frame) < 0)) return -1;

   211

   212

        if (unlikely(frame.working_counter != 1)) {

   213

            printk(KERN_ERR "EtherCAT: Slave %i did not repond while writing"

   214

                   " station address!\n", i);

   215

            return -1;

   216

        }

   217

   218

        // Fetch all slave information

   219

        if (ec_slave_fetch(slave)) return -1;

   220

   221

        // Search for identification in "database"

   222

        ident = slave_idents;

   223

        while (ident) {

   224

            if (unlikely(ident->vendor_id == slave->sii_vendor_id

   225

                         && ident->product_code == slave->sii_product_code)) {

   226

                slave->type = ident->type;

   227

                break;

   228

            }

   229

            ident++;

   230

        }

   231

   232

        if (!slave->type) {

   233

            printk(KERN_WARNING "EtherCAT: Unknown slave device (vendor"

   234

                   " 0x%08X, code 0x%08X) at position %i.\n",

   235

                   slave->sii_vendor_id, slave->sii_product_code, i);

   236

            return 0;

   237

        }

   238

    }

   239

   240

    return 0;

   241

}

   242

   243

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

   244

   245

/**

   246

   Gibt von Zeit zu Zeit die Anzahl verlorener Frames aus.

   247

*/

   248

   249

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

   250

{

   251

    unsigned long int t;

   252

   253

    if (master->frames_lost) {

   254

        rdtscl(t);

   255

        if ((t - master->t_lost_output) / cpu_khz > 1000) {

   256

            printk(KERN_ERR "EtherCAT: %u frame(s) LOST!\n",

   257

                   master->frames_lost);

   258

            master->frames_lost = 0;

   259

            master->t_lost_output = t;

   260

        }

   261

    }

   262

}

   263

   264

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

   265

   266

/**

   267

   Wandelt eine ASCII-kodierte Bus-Adresse in einen Slave-Zeiger.

   268

   269

   Gültige Adress-Strings sind Folgende:

   270

   271

   - \a "X" = der X. Slave im Bus,

   272

   - \a "X:Y" = der Y. Slave hinter dem X. Buskoppler,

   273

   - \a "#X" = der Slave mit der SSID X,

   274

   - \a "#X:Y" = der Y. Slave hinter dem Buskoppler mit der SSID X.

   275

   276

   \return Zeiger auf Slave bei Erfolg, sonst NULL

   277

*/

   278

   279

ec_slave_t *ec_address(const ec_master_t *master,

   280

                       /**< EtherCAT-Master */

   281

                       const char *address

   282

                       /**< Address-String */

   283

                       )

   284

{

   285

    unsigned long first, second;

   286

    char *remainder, *remainder2;

   287

    unsigned int i;

   288

    int coupler_idx, slave_idx;

   289

    ec_slave_t *slave;

   290

   291

    if (!address || address[0] == 0) return NULL;

   292

   293

    if (address[0] == '#') {

   294

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - #<SSID> not implemented"

   295

               " yet!\n", address);

   296

        return NULL;

   297

    }

   298

   299

    first = simple_strtoul(address, &remainder, 0);

   300

    if (remainder == address) {

   301

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - First number empty!\n",

   302

               address);

   303

        return NULL;

   304

    }

   305

   306

    if (!remainder[0]) { // absolute position

   307

        if (first < master->slave_count) {

   308

            return master->slaves + first;

   309

        }

   310

   311

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Absolute position"

   312

               " illegal!\n", address);

   313

    }

   314

   315

    else if (remainder[0] == ':') { // field position

   316

   317

        remainder++;

   318

        second = simple_strtoul(remainder, &remainder2, 0);

   319

   320

        if (remainder2 == remainder) {

   321

            printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Sencond number"

   322

                   " empty!\n", address);

   323

            return NULL;

   324

        }

   325

   326

        if (remainder2[0]) {

   327

            printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Illegal trailer"

   328

                   " (2)!\n", address);

   329

            return NULL;

   330

        }

   331

   332

        coupler_idx = -1;

   333

        slave_idx = 0;

   334

        for (i = 0; i < master->slave_count; i++, slave_idx++) {

   335

            slave = master->slaves + i;

   336

            if (!slave->type) continue;

   337

   339

                coupler_idx++;

   340

                slave_idx = 0;

   341

            }

   342

   343

            if (coupler_idx == first && slave_idx == second) return slave;

   344

        }

   345

    }

   346

   347

    else {

   348

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Illegal trailer!\n",

   349

               address);

   350

    }

   351

   352

    return NULL;

   353

}

   354

   355

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

   356

   357

/**

   358

   Initialisiert eine Sync-Manager-Konfigurationsseite.

   359

   360

   Der mit \a data referenzierte Speicher muss mindestens EC_SYNC_SIZE Bytes

   361

   groß sein.

   362

*/

   363

   364

void ec_sync_config(const ec_sync_t *sync, /**< Sync-Manager */

   365

                    uint8_t *data /**> Zeiger auf Konfigurationsspeicher */

   366

                    )

   367

{

   368

    EC_WRITE_U16(data,     sync->physical_start_address);

   369

    EC_WRITE_U16(data + 2, sync->size);

   370

    EC_WRITE_U8 (data + 4, sync->control_byte);

   371

    EC_WRITE_U8 (data + 5, 0x00); // status byte (read only)

   372

    EC_WRITE_U16(data + 6, 0x0001); // enable

   373

}

   374

   375

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

   376

   377

/**

   378

   Initialisiert eine FMMU-Konfigurationsseite.

   379

   380

   Der mit \a data referenzierte Speicher muss mindestens EC_FMMU_SIZE Bytes

   381

   groß sein.

   382

*/

   383

   384

void ec_fmmu_config(const ec_fmmu_t *fmmu, /**< Sync-Manager */

   385

                    uint8_t *data /**> Zeiger auf Konfigurationsspeicher */

   386

                    )

   387

{

   388

    EC_WRITE_U32(data,      fmmu->logical_start_address);

   389

    EC_WRITE_U16(data + 4,  fmmu->sync->size);

   390

    EC_WRITE_U8 (data + 6,  0x00); // Logical start bit

   391

    EC_WRITE_U8 (data + 7,  0x07); // Logical end bit

   392

    EC_WRITE_U16(data + 8,  fmmu->sync->physical_start_address);

   393

    EC_WRITE_U8 (data + 10, 0x00); // Physical start bit

   394

    EC_WRITE_U8 (data + 11, (fmmu->sync->control_byte & 0x04) ? 0x02 : 0x01);

   395

    EC_WRITE_U16(data + 12, 0x0001); // Enable

   396

    EC_WRITE_U16(data + 14, 0x0000); // res.

   397

}

   398

   399

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

   400

 *

   401

 * Echtzeitschnittstelle

   402

 *

   403

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

   404

   405

/**

   406

   Registriert eine neue Domäne.

   407

   408

   \return Zeiger auf die Domäne bei Erfolg, sonst NULL.

   409

*/

   410

   411

ec_domain_t *EtherCAT_rt_master_register_domain(ec_master_t *master,

   412

                                                /**< Domäne */

   413

                                                ec_domain_mode_t mode,

   414

                                                /**< Modus */

   415

                                                unsigned int timeout_us

   416

                                                /**< Timeout */

   417

                                                )

   418

{

   419

    ec_domain_t *domain;

   420

   421

    if (master->domain_count >= EC_MASTER_MAX_DOMAINS) {

   422

        printk(KERN_ERR "EtherCAT: Maximum number of domains reached!\n");

   423

        return NULL;

   424

    }

   425

   426

    if (!(domain = (ec_domain_t *) kmalloc(sizeof(ec_domain_t), GFP_KERNEL))) {

   427

        printk(KERN_ERR "EthertCAT: Error allocating domain memory!\n");

   428

        return NULL;

   429

    }

   430

   431

    ec_domain_init(domain, master, mode, timeout_us);

   432

    master->domains[master->domain_count] = domain;

   433

    master->domain_count++;

   434

   435

    return domain;

   436

}

   437

   438

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

   439

   440

/**

   441

   Konfiguriert alle Slaves und setzt den Operational-Zustand.

   442

   443

   Führt die komplette Konfiguration und Aktivierunge aller registrierten

   444

   Slaves durch. Setzt Sync-Manager und FMMU's, führt die entsprechenden

   445

   Zustandsübergänge durch, bis der Slave betriebsbereit ist.

   446

   447

   \return 0 bei Erfolg, sonst < 0

   448

*/

   449

   450

int EtherCAT_rt_master_activate(ec_master_t *master /**< EtherCAT-Master */)

   451

{

   452

    unsigned int i, j;

   453

    ec_slave_t *slave;

   454

    ec_frame_t frame;

   455

    const ec_sync_t *sync;

   456

    const ec_slave_type_t *type;

   457

    const ec_fmmu_t *fmmu;

   458

    uint8_t data[256];

   459

    uint32_t domain_offset;

   460

   461

    // Domains erstellen

   462

    domain_offset = 0;

   463

    for (i = 0; i < master->domain_count; i++) {

   464

        ec_domain_t *domain = master->domains[i];

   465

        if (ec_domain_alloc(domain, domain_offset)) {

   466

            printk(KERN_INFO "EtherCAT: Failed to allocate domain %i!\n", i);

   467

            return -1;

   468

        }

   469

        printk(KERN_INFO "EtherCAT: Domain %i - Allocated %i bytes (%i"

   470

               " Frame(s))\n", i, domain->data_size,

   471

               domain->data_size / EC_MAX_FRAME_SIZE + 1);

   472

        domain_offset += domain->data_size;

   473

    }

   474

   475

    // Slaves aktivieren

   476

    for (i = 0; i < master->slave_count; i++)

   477

    {

   478

        slave = master->slaves + i;

   479

   480

        // Change state to INIT

   481

        if (unlikely(ec_slave_state_change(slave, EC_SLAVE_STATE_INIT)))

   482

            return -1;

   483

   484

        // Check if slave was registered...

   485

        if (!slave->type) {

   486

            printk(KERN_INFO "EtherCAT: Slave %i has unknown type!\n", i);

   487

            continue;

   488

        }

   489

   490

        type = slave->type;

   491

   492

        // Check and reset CRC fault counters

   493

        ec_slave_check_crc(slave);