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 ok, < 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

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

   123

        return -1;

   124

    }

   125

   126

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

   127

        EC_ERR("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

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

   144

        return;

   145

    }

   146

   147

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

   148

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

   149

}

   150

   151

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

   152

   153

/**

   154

   Durchsucht den EtherCAT-Bus nach Slaves.

   155

   156

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

   157

   weiteren Betrieb notwendig sind.

   158

   159

   \return 0 bei Erfolg, sonst < 0

   160

*/

   161

   162

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

   163

{

   164

    ec_frame_t frame;

   165

    ec_slave_t *slave;

   166

    ec_slave_ident_t *ident;

   167

    unsigned int i;

   168

    unsigned char data[2];

   169

   170

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

   171

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

   172

        return -1;

   173

    }

   174

   175

    // Determine number of slaves on bus

   176

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

   177

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

   178

    master->slave_count = frame.working_counter;

   179

    EC_INFO("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

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

   187

        return -1;

   188

    }

   189

   190

    // Init slaves

   191

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

   192

        slave = master->slaves + i;

   193

        ec_slave_init(slave, master);

   194

        slave->ring_position = i;

   195

        slave->station_address = i + 1;

   196

    }

   197

   198

    // For every slave in the list

   199

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

   200

    {

   201

        slave = master->slaves + i;

   202

   203

        // Write station address

   204

        EC_WRITE_U16(data, slave->station_address);

   205

   206

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

   207

                           sizeof(uint16_t), data);

   208

   209

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

   210

            EC_ERR("Writing station address failed on slave %i!\n", i);

   211

            return -1;

   212

        }

   213

   214

        // Fetch all slave information

   215

        if (ec_slave_fetch(slave)) return -1;

   216

   217

        // Search for identification in "database"

   218

        ident = slave_idents;

   219

        while (ident) {

   220

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

   221

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

   222

                slave->type = ident->type;

   223

                break;

   224

            }

   225

            ident++;

   226

        }

   227

   228

        if (!slave->type)

   229

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

   230

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

   231

                    slave->sii_product_code, i);

   232

    }

   233

   234

    return 0;

   235

}

   236

   237

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

   238

   239

/**

   240

   Gibt die Anzahl verlorener Frames aus.

   241

   242

   Die Ausgabe erfolgt gesammelt höchstens einmal pro Sekunde.

   243

*/

   244

   245

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

   246

{

   247

    unsigned long int t;

   248

   249

    if (master->frames_lost) {

   250

        rdtscl(t);

   251

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

   252

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

   253

            master->frames_lost = 0;

   254

            master->t_lost_output = t;

   255

        }

   256

    }

   257

}

   258

   259

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

   260

   261

/**

   262

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

   263

   264

   Gültige Adress-Strings sind Folgende:

   265

   266

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

   267

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

   268

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

   269

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

   270

   271

   \return Zeiger auf Slave bei Erfolg, sonst NULL

   272

*/

   273

   274

ec_slave_t *ec_address(const ec_master_t *master,

   275

                       /**< EtherCAT-Master */

   276

                       const char *address

   277

                       /**< Address-String */

   278

                       )

   279

{

   280

    unsigned long first, second;

   281

    char *remainder, *remainder2;

   282

    unsigned int i;

   283

    int coupler_idx, slave_idx;

   284

    ec_slave_t *slave;

   285

   286

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

   287

   288

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

   289

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

   290

        return NULL;

   291

    }

   292

   293

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

   294

    if (remainder == address) {

   295

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

   296

        return NULL;

   297

    }

   298

   299

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

   300

        if (first < master->slave_count) {

   301

            return master->slaves + first;

   302

        }

   303

   304

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

   305

    }

   306

   307

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

   308

   309

        remainder++;

   310

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

   311

   312

        if (remainder2 == remainder) {

   313

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

   314

            return NULL;

   315

        }

   316

   317

        if (remainder2[0]) {

   318

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

   319

            return NULL;

   320

        }

   321

   322

        coupler_idx = -1;

   323

        slave_idx = 0;

   324

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

   325

            slave = master->slaves + i;

   326

            if (!slave->type) continue;

   327

   328

            if (slave->type->bus_coupler) {

   329

                coupler_idx++;

   330

                slave_idx = 0;

   331

            }

   332

   333

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

   334

        }

   335

    }

   336

   337

    else

   338

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

   339

   340

    // FIXME ???

   341

   342

    return NULL;

   343

}

   344

   345

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

   346

   347

/**

   348

   Initialisiert eine Sync-Manager-Konfigurationsseite.

   349

   350

   Der mit \a data referenzierte Speicher muss mindestens EC_SYNC_SIZE Bytes

   351

   groß sein.

   352

*/

   353

   354

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

   355

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

   356

                    )

   357

{

   358

    EC_WRITE_U16(data,     sync->physical_start_address);

   359

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

   360

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

   361

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

   362

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

   363

}

   364

   365

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

   366

   367

/**

   368

   Initialisiert eine FMMU-Konfigurationsseite.

   369

   370

   Der mit \a data referenzierte Speicher muss mindestens EC_FMMU_SIZE Bytes

   371

   groß sein.

   372

*/

   373

   374

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

   375

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

   376

                    )

   377

{

   378

    EC_WRITE_U32(data,      fmmu->logical_start_address);

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

}

   388

   389

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

   390

 *

   391

 * Echtzeitschnittstelle

   392

 *

   393

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

   394

   395

/**

   396

   Registriert eine neue Domäne.

   397

   398

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

   399

*/

   400

   401

ec_domain_t *EtherCAT_rt_master_register_domain(ec_master_t *master,

   402

                                                /**< Domäne */

   403

                                                ec_domain_mode_t mode,

   404

                                                /**< Modus */

   405

                                                unsigned int timeout_us

   406

                                                /**< Timeout */

   407

                                                )

   408

{

   409

    ec_domain_t *domain;

   410

   411

    if (master->domain_count >= EC_MASTER_MAX_DOMAINS) {

   412

        EC_ERR("Maximum number of domains reached!\n");

   413

        return NULL;

   414

    }

   415

   416

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

   417

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

   418

        return NULL;

   419

    }

   420

   421

    ec_domain_init(domain, master, mode, timeout_us);

   422

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

   423

    master->domain_count++;

   424

   425

    return domain;

   426

}

   427

   428

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

   429

   430

/**

   431

   Konfiguriert alle Slaves und setzt den Operational-Zustand.

   432

   433

   Führt die komplette Konfiguration und Aktivierunge aller registrierten

   434

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

   435

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

   436

   437

   \return 0 bei Erfolg, sonst < 0

   438

*/

   439

   440

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

   441

{

   442

    unsigned int i, j;

   443

    ec_slave_t *slave;

   444

    ec_frame_t frame;

   445

    const ec_sync_t *sync;

   446

    const ec_slave_type_t *type;

   447

    const ec_fmmu_t *fmmu;

   448

    uint8_t data[256];

   449

    uint32_t domain_offset;

   450

    unsigned int frame_count;

   451

    ec_domain_t *domain;

   452

   453

    // Domains erstellen

   454

    domain_offset = 0;

   455

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

   456

        domain = master->domains[i];

   457

        if (ec_domain_alloc(domain, domain_offset)) {

   458

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

   459

            return -1;

   460

        }

   461

        frame_count = domain->data_size / EC_MAX_FRAME_SIZE + 1;

   462

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

   463

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

   464

                domain->data_size, frame_count);

   465

        domain_offset += domain->data_size;

   466

    }

   467

   468

    // Slaves aktivieren

   469

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

   470

    {

   471

        slave = master->slaves + i;

   472

   473

        // Change state to INIT

   474

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

   475

            return -1;

   476

   477

        // Check if slave was registered...

   478

        if (!slave->type) {

   479

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

   480

            continue;

   481

        }

   482

   483

        type = slave->type;

   484

   485

        // Check and reset CRC fault counters

   486

        ec_slave_check_crc(slave);

   487

   488

        // Resetting FMMUs

   489

        if (slave->base_fmmu_count) {

   490