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->debug_level = 0;

    39

    master->bus_time = 0;

    40

    master->frames_lost = 0;

    41

    master->frames_delayed = 0;

    42

    master->t_last_cyclic_output = 0;

    43

    44

    INIT_LIST_HEAD(&master->domains);

    45

}

    46

    47

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

    48

    49

/**

    50

   Destruktor eines EtherCAT-Masters.

    51

    52

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

    53

   auf das Slave-Array und gibt die Prozessdaten frei.

    54

*/

    55

    56

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

    57

{

    58

    ec_master_reset(master);

    59

    ec_device_clear(&master->device);

    60

}

    61

    62

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

    63

    64

/**

    65

   Setzt den Master zurück in den Ausgangszustand.

    66

    67

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

    68

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

    69

*/

    70

    71

void ec_master_reset(ec_master_t *master

    72

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

    73

                     )

    74

{

    75

    ec_domain_t *domain, *next;

    76

    77

    ec_master_clear_slaves(master);

    78

    79

    // Domain-Liste leeren

    80

    list_for_each_entry_safe(domain, next, &master->domains, list) {

    81

        ec_domain_clear(domain);

    82

        kfree(domain);

    83

    }

    84

    INIT_LIST_HEAD(&master->domains);

    85

    86

    master->command_index = 0;

    87

    master->debug_level = 0;

    88

    master->bus_time = 0;

    89

    master->frames_lost = 0;

    90

    master->frames_delayed = 0;

    91

    master->t_last_cyclic_output = 0;

    92

}

    93

    94

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

    95

    96

/**

    97

   Entfernt alle Slaves.

    98

*/

    99

   100

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

   101

{

   102

    unsigned int i;

   103

   104

    if (master->slaves) {

   105

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

   106

            ec_slave_clear(master->slaves + i);

   107

        }

   108

        kfree(master->slaves);

   109

        master->slaves = NULL;

   110

    }

   111

    master->slave_count = 0;

   112

}

   113

   114

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

   115

   116

/**

   117

   Öffnet das EtherCAT-Geraet des Masters.

   118

   119

   \return 0 wenn alles ok, < 0 wenn kein Gerät registriert wurde oder

   120

           es nicht geoeffnet werden konnte.

   121

*/

   122

   123

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

   124

{

   125

    if (!master->device_registered) {

   126

        EC_ERR("No device registered!\n");

   127

        return -1;

   128

    }

   129

   130

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

   131

        EC_ERR("Could not open device!\n");

   132

        return -1;

   133

    }

   134

   135

    return 0;

   136

}

   137

   138

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

   139

   140

/**

   141

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

   142

*/

   143

   144

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

   145

{

   146

    if (!master->device_registered) {

   147

        EC_WARN("Warning - Trying to close an unregistered device!\n");

   148

        return;

   149

    }

   150

   151

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

   152

        EC_WARN("Warning - Could not close device!\n");

   153

}

   154

   155

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

   156

   157

/**

   158

   Durchsucht den EtherCAT-Bus nach Slaves.

   159

   160

   Erstellt ein Array mit allen Slave-Informationen die für den

   161

   weiteren Betrieb notwendig sind.

   162

   163

   \return 0 bei Erfolg, sonst < 0

   164

*/

   165

   166

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

   167

{

   168

    ec_frame_t frame;

   169

    ec_slave_t *slave;

   170

    ec_slave_ident_t *ident;

   171

    unsigned int i;

   172

    unsigned char data[2];

   173

   174

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

   175

        EC_ERR("Slave scan already done!\n");

   176

        return -1;

   177

    }

   178

   179

    // Determine number of slaves on bus

   180

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

   181

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

   182

    master->slave_count = frame.working_counter;

   183

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

   184

   185

    if (!master->slave_count) return 0;

   186

   187

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

   188

                                                  * sizeof(ec_slave_t),

   189

                                                  GFP_KERNEL))) {

   190

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

   191

        return -1;

   192

    }

   193

   194

    // Init slaves

   195

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

   196

        slave = master->slaves + i;

   197

        ec_slave_init(slave, master);

   198

        slave->ring_position = i;

   199

        slave->station_address = i + 1;

   200

    }

   201

   202

    // For every slave in the list

   203

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

   204

    {

   205

        slave = master->slaves + i;

   206

   207

        // Write station address

   208

        EC_WRITE_U16(data, slave->station_address);

   209

   210

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

   211

                           sizeof(uint16_t), data);

   212

   213

        if (unlikely(ec_frame_send_receive(&frame))) {

   214

            EC_ERR("Writing station address failed on slave %i!\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

            EC_WARN("Unknown slave device (vendor 0x%08X, code 0x%08X) at"

   234

                    " position %i.\n", slave->sii_vendor_id,

   235

                    slave->sii_product_code, i);

   236

    }

   237

   238

    return 0;

   239

}

   240

   241

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

   242

   243

/**

   244

   Ausgaben während des zyklischen Betriebs.

   245

   246

   Diese Funktion sorgt dafür, dass Ausgaben (Zählerstände) während

   247

   des zyklischen Betriebs nicht zu oft getätigt werden.

   248

   249

   Die Ausgabe erfolgt gesammelt höchstens einmal pro Sekunde.

   250

*/

   251

   252

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

   253

{

   254

    unsigned long int t;

   255

   256

    rdtscl(t);

   257

   258

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

   259

        if (master->frames_lost) {

   260

            EC_WARN("%u frame(s) LOST!\n", master->frames_lost);

   261

            master->frames_lost = 0;

   262

        }

   263

        if (master->frames_delayed) {

   264

            EC_WARN("%u frame(s) DELAYED!\n", master->frames_delayed);

   265

            master->frames_delayed = 0;

   266

        }

   267

        master->t_last_cyclic_output = t;

   268

    }

   269

}

   270

   271

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

   272

   273

/**

   274

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

   275

   276

   Gültige Adress-Strings sind Folgende:

   277

   278

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

   279

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

   280

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

   281

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

   282

   283

   \return Zeiger auf Slave bei Erfolg, sonst NULL

   284

*/

   285

   286

ec_slave_t *ec_address(const ec_master_t *master,

   287

                       /**< EtherCAT-Master */

   288

                       const char *address

   289

                       /**< Address-String */

   290

                       )

   291

{

   292

    unsigned long first, second;

   293

    char *remainder, *remainder2;

   294

    unsigned int i;

   295

    int coupler_idx, slave_idx;

   296

    ec_slave_t *slave;

   297

   298

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

   299

   300

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

   301

        EC_ERR("Bus ID \"%s\" - #<SSID> not implemented yet!\n", address);

   302

        return NULL;

   303

    }

   304

   305

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

   306

    if (remainder == address) {

   307

        EC_ERR("Bus ID \"%s\" - First number empty!\n", address);

   308

        return NULL;

   309

    }

   310

   311

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

   312

        if (first < master->slave_count) {

   313

            return master->slaves + first;

   314

        }

   315

   316

        EC_ERR("Bus ID \"%s\" - Absolute position illegal!\n", address);

   317

    }

   318

   319

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

   320

   321

        remainder++;

   322

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

   323

   324

        if (remainder2 == remainder) {

   325

            EC_ERR("Bus ID \"%s\" - Sencond number empty!\n", address);

   326

            return NULL;

   327

        }

   328

   329

        if (remainder2[0]) {

   330

            EC_ERR("Bus ID \"%s\" - Illegal trailer (2)!\n", address);

   331

            return NULL;

   332

        }

   333

   334

        coupler_idx = -1;

   335

        slave_idx = 0;

   336

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

   337

            slave = master->slaves + i;

   338

            if (!slave->type) continue;

   339

   340

            if (slave->type->bus_coupler) {

   341

                coupler_idx++;

   342

                slave_idx = 0;

   343

            }

   344

   345

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

   346

        }

   347

    }

   348

   349

    else

   350

        EC_ERR("Bus ID \"%s\" - Illegal trailer!\n", address);

   351

   352

    // FIXME ???

   353

   354

    return NULL;

   355

}

   356

   357

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

   358

   359

/**

   360

   Initialisiert eine Sync-Manager-Konfigurationsseite.

   361

   362

   Der mit \a data referenzierte Speicher muss mindestens EC_SYNC_SIZE Bytes

   363

   groß sein.

   364

*/

   365

   366

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

   367

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

   368

                    )

   369

{

   370

    EC_WRITE_U16(data,     sync->physical_start_address);

   371

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

   372

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

   373

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

   374

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

   375

}

   376

   377

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

   378

   379

/**

   380

   Initialisiert eine FMMU-Konfigurationsseite.

   381

   382

   Der mit \a data referenzierte Speicher muss mindestens EC_FMMU_SIZE Bytes

   383

   groß sein.

   384

*/

   385

   386

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

   387

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

   388

                    )

   389

{

   390

    EC_WRITE_U32(data,      fmmu->logical_start_address);

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

}

   400

   401

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

   402

 *

   403

 * Echtzeitschnittstelle

   404

 *

   405

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

   406

   407

/**

   408

   Registriert eine neue Domäne.

   409

   410

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

   411

*/

   412

   413

ec_domain_t *EtherCAT_rt_master_register_domain(ec_master_t *master,

   414

                                                /**< Domäne */

   415

                                                ec_domain_mode_t mode,

   416

                                                /**< Modus */

   417

                                                unsigned int timeout_us

   418

                                                /**< Timeout */

   419

                                                )

   420

{

   421

    ec_domain_t *domain;

   422

   423

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

   424

        EC_ERR("Error allocating domain memory!\n");

   425

        return NULL;

   426

    }

   427

   428

    ec_domain_init(domain, master, mode, timeout_us);

   429

   430

    list_add_tail(&domain->list, &master->domains);

   431

   432

    return domain;

   433

}

   434

   435

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

   436

   437

/**

   438

   Konfiguriert alle Slaves und setzt den Operational-Zustand.

   439

   440

   Führt die komplette Konfiguration und Aktivierunge aller registrierten

   441

   Slaves durch. Setzt Sync-Manager und FMMUs, führt die entsprechenden

   442

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

   443

   444

   \return 0 bei Erfolg, sonst < 0

   445

*/

   446

   447

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

   448

{

   449

    unsigned int i, j;

   450

    ec_slave_t *slave;

   451

    ec_frame_t frame;

   452

    const ec_sync_t *sync;

   453

    const ec_slave_type_t *type;

   454

    const ec_fmmu_t *fmmu;

   455

    uint8_t data[256];

   456

    uint32_t domain_offset;

   457

    unsigned int frame_count;

   458

    ec_domain_t *domain;

   459

   460

    // Domains erstellen

   461

    domain_offset = 0;

   462

    list_for_each_entry(domain, &master->domains, list) {

   463

        if (ec_domain_alloc(domain, domain_offset)) {

   464

            EC_ERR("Failed to allocate domain %X!\n", (u32) domain);

   465

            return -1;

   466

        }

   467

        frame_count = domain->data_size / EC_MAX_FRAME_SIZE + 1;

   468

        if (!domain->data_size) frame_count = 0;

   469

        EC_INFO("Domain %X - Allocated %i bytes (%i Frame(s))\n",

   470

                (u32) domain, domain->data_size, frame_count);

   471

        domain_offset += domain->data_size;

   472

    }

   473

   474

    // Slaves aktivieren

   475

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

   476

    {

   477

        slave = master->slaves + i;

   478

   479

        // Change state to INIT

   480

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

   481

            return -1;

   482

   483

        // Check if slave was registered...

   484

        if (!slave->type) {

   485

            EC_WARN("Slave %i has unknown type!\n", i);

   486

            continue;

   487

        }

   488

   489

        type = slave->type;