1

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

     2

 *

     3

 *  s l a v e . c

     4

 *

     5

 *  Methoden für einen EtherCAT-Slave.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/module.h>

    12

#include <linux/delay.h>

    13

    14

#include "globals.h"

    15

#include "slave.h"

    16

#include "command.h"

    17

#include "master.h"

    18

    19

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

    20

    21

int ec_slave_fetch_categories(ec_slave_t *);

    22

int ec_slave_fetch_strings(ec_slave_t *, const uint8_t *);

    23

int ec_slave_fetch_general(ec_slave_t *, const uint8_t *);

    24

int ec_slave_fetch_sync(ec_slave_t *, const uint8_t *, size_t);

    25

int ec_slave_fetch_pdo(ec_slave_t *, const uint8_t *, size_t, ec_pdo_type_t);

    26

int ec_slave_locate_string(ec_slave_t *, unsigned int, char **);

    27

    28

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

    29

    30

const ec_code_msg_t al_status_messages[];

    31

    32

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

    33

    34

/**

    35

   EtherCAT-Slave-Konstruktor.

    36

*/

    37

    38

void ec_slave_init(ec_slave_t *slave, /**< EtherCAT-Slave */

    39

                   ec_master_t *master /**< EtherCAT-Master */

    40

                   )

    41

{

    42

    unsigned int i;

    43

    44

    slave->master = master;

    45

    slave->base_type = 0;

    46

    slave->base_revision = 0;

    47

    slave->base_build = 0;

    48

    slave->base_fmmu_count = 0;

    49

    slave->base_sync_count = 0;

    50

    slave->ring_position = 0;

    51

    slave->station_address = 0;

    52

    slave->sii_alias = 0;

    53

    slave->sii_vendor_id = 0;

    54

    slave->sii_product_code = 0;

    55

    slave->sii_revision_number = 0;

    56

    slave->sii_serial_number = 0;

    57

    slave->sii_rx_mailbox_offset = 0;

    58

    slave->sii_rx_mailbox_size = 0;

    59

    slave->sii_tx_mailbox_offset = 0;

    60

    slave->sii_tx_mailbox_size = 0;

    61

    slave->sii_mailbox_protocols = 0;

    62

    slave->type = NULL;

    63

    slave->registered = 0;

    64

    slave->fmmu_count = 0;

    65

    slave->eeprom_name = NULL;

    66

    slave->eeprom_group = NULL;

    67

    slave->eeprom_desc = NULL;

    68

    69

    ec_command_init(&slave->mbox_command);

    70

    71

    INIT_LIST_HEAD(&slave->eeprom_strings);

    72

    INIT_LIST_HEAD(&slave->eeprom_syncs);

    73

    INIT_LIST_HEAD(&slave->eeprom_pdos);

    74

    INIT_LIST_HEAD(&slave->sdo_dictionary);

    75

    76

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

    77

        slave->dl_status_link[i] = 0;

    78

        slave->dl_status_loop[i] = 0;

    79

        slave->dl_status_comm[i] = 0;

    80

    }

    81

}

    82

    83

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

    84

    85

/**

    86

   EtherCAT-Slave-Destruktor.

    87

*/

    88

    89

void ec_slave_clear(ec_slave_t *slave /**< EtherCAT-Slave */)

    90

{

    91

    ec_eeprom_string_t *string, *next_str;

    92

    ec_eeprom_sync_t *sync, *next_sync;

    93

    ec_eeprom_pdo_t *pdo, *next_pdo;

    94

    ec_eeprom_pdo_entry_t *entry, *next_ent;

    95

    ec_sdo_t *sdo, *next_sdo;

    96

    ec_sdo_entry_t *en, *next_en;

    97

    98

    // Alle Strings freigeben

    99

    list_for_each_entry_safe(string, next_str, &slave->eeprom_strings, list) {

   100

        list_del(&string->list);

   101

        kfree(string);

   102

    }

   103

   104

    // Alle Sync-Manager freigeben

   105

    list_for_each_entry_safe(sync, next_sync, &slave->eeprom_syncs, list) {

   106

        list_del(&sync->list);

   107

        kfree(sync);

   108

    }

   109

   110

    // Alle PDOs freigeben

   111

    list_for_each_entry_safe(pdo, next_pdo, &slave->eeprom_pdos, list) {

   112

        list_del(&pdo->list);

   113

        if (pdo->name) kfree(pdo->name);

   114

   115

        // Alle Entries innerhalb eines PDOs freigeben

   116

        list_for_each_entry_safe(entry, next_ent, &pdo->entries, list) {

   117

            list_del(&entry->list);

   118

            if (entry->name) kfree(entry->name);

   119

            kfree(entry);

   120

        }

   121

   122

        kfree(pdo);

   123

    }

   124

   125

    if (slave->eeprom_name) kfree(slave->eeprom_name);

   126

    if (slave->eeprom_group) kfree(slave->eeprom_group);

   127

    if (slave->eeprom_desc) kfree(slave->eeprom_desc);

   128

   129

    // Alle SDOs freigeben

   130

    list_for_each_entry_safe(sdo, next_sdo, &slave->sdo_dictionary, list) {

   131

        list_del(&sdo->list);

   132

        if (sdo->name) kfree(sdo->name);

   133

   134

        // Alle Entries freigeben

   135

        list_for_each_entry_safe(en, next_en, &sdo->entries, list) {

   136

            list_del(&en->list);

   137

            kfree(en);

   138

        }

   139

        kfree(sdo);

   140

    }

   141

   142

    ec_command_clear(&slave->mbox_command);

   143

}

   144

   145

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

   146

   147

/**

   148

   Liest alle benötigten Informationen aus einem Slave.

   149

   150

   \return 0 wenn alles ok, < 0 bei Fehler.

   151

*/

   152

   153

int ec_slave_fetch(ec_slave_t *slave /**< EtherCAT-Slave */)

   154

{

   155

    ec_command_t *command;

   156

    unsigned int i;

   157

    uint16_t dl_status;

   158

   159

    command = &slave->master->simple_command;

   160

   161

    // Read base data

   162

    if (ec_command_nprd(command, slave->station_address, 0x0000, 6)) return -1;

   163

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   164

        EC_ERR("Reading base data from slave %i failed!\n",

   165

               slave->ring_position);

   166

        return -1;

   167

    }

   168

   169

    slave->base_type =       EC_READ_U8 (command->data);

   170

    slave->base_revision =   EC_READ_U8 (command->data + 1);

   171

    slave->base_build =      EC_READ_U16(command->data + 2);

   172

    slave->base_fmmu_count = EC_READ_U8 (command->data + 4);

   173

    slave->base_sync_count = EC_READ_U8 (command->data + 5);

   174

   175

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   176

        slave->base_fmmu_count = EC_MAX_FMMUS;

   177

   178

    // Read DL status

   179

    if (ec_command_nprd(command, slave->station_address, 0x0110, 2)) return -1;

   180

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   181

        EC_ERR("Reading DL status from slave %i failed!\n",

   182

               slave->ring_position);

   183

        return -1;

   184

    }

   185

   186

    dl_status = EC_READ_U16(command->data);

   187

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

   188

        slave->dl_status_link[i] = dl_status & (1 << (4 + i)) ? 1 : 0;

   189

        slave->dl_status_loop[i] = dl_status & (1 << (8 + i * 2)) ? 1 : 0;

   190

        slave->dl_status_comm[i] = dl_status & (1 << (9 + i * 2)) ? 1 : 0;

   191

    }

   192

   193

    // Read EEPROM data

   194

    if (ec_slave_sii_read16(slave, 0x0004, &slave->sii_alias))

   195

        return -1;

   196

    if (ec_slave_sii_read32(slave, 0x0008, &slave->sii_vendor_id))

   197

        return -1;

   198

    if (ec_slave_sii_read32(slave, 0x000A, &slave->sii_product_code))

   199

        return -1;

   200

    if (ec_slave_sii_read32(slave, 0x000C, &slave->sii_revision_number))

   201

        return -1;

   202

    if (ec_slave_sii_read32(slave, 0x000E, &slave->sii_serial_number))

   203

        return -1;

   204

    if (ec_slave_sii_read16(slave, 0x0018, &slave->sii_rx_mailbox_offset))

   205

        return -1;

   206

    if (ec_slave_sii_read16(slave, 0x0019, &slave->sii_rx_mailbox_size))

   207

        return -1;

   208

    if (ec_slave_sii_read16(slave, 0x001A, &slave->sii_tx_mailbox_offset))

   209

        return -1;

   210

    if (ec_slave_sii_read16(slave, 0x001B, &slave->sii_tx_mailbox_size))

   211

        return -1;

   212

    if (ec_slave_sii_read16(slave, 0x001C, &slave->sii_mailbox_protocols))

   213

        return -1;

   214

   215

    if (unlikely(ec_slave_fetch_categories(slave))) {

   216

        EC_ERR("Failed to fetch category data!\n");

   217

        return -1;

   218

    }

   219

   220

    return 0;

   221

}

   222

   223

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

   224

   225

/**

   226

   Liest 16 Bit aus dem Slave-Information-Interface

   227

   eines EtherCAT-Slaves.

   228

   229

   \return 0 bei Erfolg, sonst < 0

   230

*/

   231

   232

int ec_slave_sii_read16(ec_slave_t *slave,

   233

                        /**< EtherCAT-Slave */

   234

                        uint16_t offset,

   235

                        /**< Adresse des zu lesenden SII-Registers */

   236

                        uint16_t *target

   237

                        /**< Speicher für Wert (16-Bit) */

   238

                        )

   239

{

   240

    ec_command_t *command;

   241

    cycles_t start, end, timeout;

   242

   243

    command = &slave->master->simple_command;

   244

   245

    // Initiate read operation

   246

    if (ec_command_npwr(command, slave->station_address, 0x502, 6)) return -1;

   247

    EC_WRITE_U8 (command->data,     0x00); // read-only access

   248

    EC_WRITE_U8 (command->data + 1, 0x01); // request read operation

   249

    EC_WRITE_U32(command->data + 2, offset);

   250

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   251

        EC_ERR("SII-read failed on slave %i!\n", slave->ring_position);

   252

        return -1;

   253

    }

   254

   255

    // Der Slave legt die Informationen des Slave-Information-Interface

   256

    // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange

   257

    // den Status auslesen, bis das Bit weg ist.

   258

   259

    start = get_cycles();

   260

    timeout = (cycles_t) 100 * cpu_khz; // 100ms

   261

   262

    while (1)

   263

    {

   264

        udelay(10);

   265

   266

        if (ec_command_nprd(command, slave->station_address, 0x502, 10))

   267

            return -1;

   268

        if (unlikely(ec_master_simple_io(slave->master, command))) {

   269

            EC_ERR("Getting SII-read status failed on slave %i!\n",

   270

                   slave->ring_position);

   271

            return -1;

   272

        }

   273

   274

        end = get_cycles();

   275

   276

        if (likely((EC_READ_U8(command->data + 1) & 0x81) == 0)) {

   277

            *target = EC_READ_U16(command->data + 6);

   278

            return 0;

   279

        }

   280

   281

        if (unlikely((end - start) >= timeout)) {

   282

            EC_ERR("SII-read. Slave %i timed out!\n", slave->ring_position);

   283

            return -1;

   284

        }

   285

    }

   286

}

   287

   288

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

   289

   290

/**

   291

   Liest 32 Bit aus dem Slave-Information-Interface

   292

   eines EtherCAT-Slaves.

   293

   294

   \return 0 bei Erfolg, sonst < 0

   295

*/

   296

   297

int ec_slave_sii_read32(ec_slave_t *slave,

   298

                        /**< EtherCAT-Slave */

   299

                        uint16_t offset,

   300

                        /**< Adresse des zu lesenden SII-Registers */

   301

                        uint32_t *target

   302

                        /**< Speicher für Wert (32-Bit) */

   303

                        )

   304

{

   305

    ec_command_t *command;

   306

    cycles_t start, end, timeout;

   307

   308

    command = &slave->master->simple_command;

   309

   310

    // Initiate read operation

   311

    if (ec_command_npwr(command, slave->station_address, 0x502, 6)) return -1;

   312

    EC_WRITE_U8 (command->data,     0x00); // read-only access

   313

    EC_WRITE_U8 (command->data + 1, 0x01); // request read operation

   314

    EC_WRITE_U32(command->data + 2, offset);

   315

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   316

        EC_ERR("SII-read failed on slave %i!\n", slave->ring_position);

   317

        return -1;

   318

    }

   319

   320

    // Der Slave legt die Informationen des Slave-Information-Interface

   321

    // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange

   322

    // den Status auslesen, bis das Bit weg ist.

   323

   324

    start = get_cycles();

   325

    timeout = (cycles_t) 100 * cpu_khz; // 100ms

   326

   327

    while (1)

   328

    {

   329

        udelay(10);

   330

   331

        if (ec_command_nprd(command, slave->station_address, 0x502, 10))

   332

            return -1;

   333

        if (unlikely(ec_master_simple_io(slave->master, command))) {

   334

            EC_ERR("Getting SII-read status failed on slave %i!\n",

   335

                   slave->ring_position);

   336

            return -1;

   337

        }

   338

   339

        end = get_cycles();

   340

   341

        if (likely((EC_READ_U8(command->data + 1) & 0x81) == 0)) {

   342

            *target = EC_READ_U32(command->data + 6);

   343

            return 0;

   344

        }

   345

   346

        if (unlikely((end - start) >= timeout)) {

   347

            EC_ERR("SII-read. Slave %i timed out!\n", slave->ring_position);

   348

            return -1;

   349

        }

   350

    }

   351

}

   352

   353

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

   354

   355

/**

   356

   Schreibt 16 Bit Daten in das Slave-Information-Interface

   357

   eines EtherCAT-Slaves.

   358

   359

   \return 0 bei Erfolg, sonst < 0

   360

*/

   361

   362

int ec_slave_sii_write16(ec_slave_t *slave,

   363

                         /**< EtherCAT-Slave */

   364

                         uint16_t offset,

   365

                         /**< Adresse des zu lesenden SII-Registers */

   366

                         uint16_t value

   367

                         /**< Zu schreibender Wert */

   368

                         )

   369

{

   370

    ec_command_t *command;

   371

    cycles_t start, end, timeout;

   372

   373

    command = &slave->master->simple_command;

   374

   375

    EC_INFO("SII-write (slave %i, offset 0x%04X, value 0x%04X)\n",

   376

            slave->ring_position, offset, value);

   377

   378

    // Initiate write operation

   379

    if (ec_command_npwr(command, slave->station_address, 0x502, 8)) return -1;

   380

    EC_WRITE_U8 (command->data,     0x01); // enable write access

   381

    EC_WRITE_U8 (command->data + 1, 0x02); // request write operation

   382

    EC_WRITE_U32(command->data + 2, offset);

   383

    EC_WRITE_U16(command->data + 6, value);

   384

    if (unlikely(ec_master_simple_io(slave->master, command))) {

   385

        EC_ERR("SII-write failed on slave %i!\n", slave->ring_position);

   386

        return -1;

   387

    }

   388

   389

    // Der Slave legt die Informationen des Slave-Information-Interface

   390

    // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange

   391

    // den Status auslesen, bis das Bit weg ist.

   392

   393

    start = get_cycles();

   394

    timeout = (cycles_t) 100 * cpu_khz; // 100ms

   395

   396

    while (1)

   397

    {

   398

        udelay(10);

   399

   400

        if (ec_command_nprd(command, slave->station_address, 0x502, 2))

   401

            return -1;

   402

        if (unlikely(ec_master_simple_io(slave->master, command))) {

   403

            EC_ERR("Getting SII-write status failed on slave %i!\n",

   404

                   slave->ring_position);

   405

            return -1;

   406

        }

   407

   408

        end = get_cycles();

   409

   410

        if (likely((EC_READ_U8(command->data + 1) & 0x82) == 0)) {

   411

            if (EC_READ_U8(command->data + 1) & 0x40) {

   412

                EC_ERR("SII-write failed!\n");

   413

                return -1;

   414

            }

   415

            else {

   416

                EC_INFO("SII-write succeeded!\n");

   417

                return 0;

   418

            }

   419

        }

   420

   421

        if (unlikely((end - start) >= timeout)) {

   422

            EC_ERR("SII-write: Slave %i timed out!\n", slave->ring_position);

   423

            return -1;

   424

        }

   425

    }

   426

}

   427

   428

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

   429

   430

/**

   431

   Holt Daten aus dem EEPROM.

   432

   433

   \return 0, wenn alles ok, sonst < 0

   434

*/

   435

   436

int ec_slave_fetch_categories(ec_slave_t *slave /**< EtherCAT-Slave */)

   437

{

   438

    uint16_t word_offset, cat_type, word_count;

   439

    uint32_t value;

   440

    uint8_t *cat_data;

   441

    unsigned int i;

   442

   443

    word_offset = 0x0040;

   444

   445

    if (!(cat_data = (uint8_t *) kmalloc(0x10000, GFP_KERNEL))) {

   446

        EC_ERR("Failed to allocate 64k bytes for category data.\n");

   447

        return -1;

   448

    }

   449

   450

    while (1) {

   451

        // read category type

   452

        if (ec_slave_sii_read32(slave, word_offset, &value)) {

   453

            EC_ERR("Unable to read category header.\n");

   454

            goto out_free;

   455

        }

   456

   457

        // Last category?

   458

        if ((value & 0xFFFF) == 0xFFFF) break;

   459

   460

        cat_type = value & 0x7FFF;

   461

        word_count = (value >> 16) & 0xFFFF;

   462

   463

        // Fetch category data

   464

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

   465

            if (ec_slave_sii_read32(slave, word_offset + 2 + i, &value)) {

   466

                EC_ERR("Unable to read category data word %i.\n", i);

   467

                goto out_free;

   468

            }

   469

   470

            cat_data[i * 2]     = (value >> 0) & 0xFF;

   471

            cat_data[i * 2 + 1] = (value >> 8) & 0xFF;

   472

   473

            // read second word "on the fly"

   474

            if (i + 1 < word_count) {

   475

                i++;

   476

                cat_data[i * 2]     = (value >> 16) & 0xFF;

   477

                cat_data[i * 2 + 1] = (value >> 24) & 0xFF;

   478

            }

   479

        }

   480

   481

        switch (cat_type)

   482

        {

   483

            case 0x000A:

   484

                if (ec_slave_fetch_strings(slave, cat_data))

   485

                    goto out_free;

   486

                break;

   487

            case 0x001E: