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

/**

    31

   EtherCAT-Slave-Konstruktor.

    32

*/

    33

    34

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

    35

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

    36

                   )

    37

{

    38

    unsigned int i;

    39

    40

    slave->master = master;

    41

    slave->base_type = 0;

    42

    slave->base_revision = 0;

    43

    slave->base_build = 0;

    44

    slave->base_fmmu_count = 0;

    45

    slave->base_sync_count = 0;

    46

    slave->ring_position = 0;

    47

    slave->station_address = 0;

    48

    slave->sii_alias = 0;

    49

    slave->sii_vendor_id = 0;

    50

    slave->sii_product_code = 0;

    51

    slave->sii_revision_number = 0;

    52

    slave->sii_serial_number = 0;

    53

    slave->sii_rx_mailbox_offset = 0;

    54

    slave->sii_rx_mailbox_size = 0;

    55

    slave->sii_tx_mailbox_offset = 0;

    56

    slave->sii_tx_mailbox_size = 0;

    57

    slave->sii_mailbox_protocols = 0;

    58

    slave->type = NULL;

    59

    slave->registered = 0;

    60

    slave->fmmu_count = 0;

    61

    slave->eeprom_name = NULL;

    62

    slave->eeprom_group = NULL;

    63

    slave->eeprom_desc = NULL;

    67

    INIT_LIST_HEAD(&slave->eeprom_strings);

    68

    INIT_LIST_HEAD(&slave->eeprom_syncs);

    69

    INIT_LIST_HEAD(&slave->eeprom_pdos);

    70

    INIT_LIST_HEAD(&slave->sdo_dictionary);

    77

}

    78

    79

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

    80

    81

/**

    82

   EtherCAT-Slave-Destruktor.

    83

*/

    84

    85

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

    86

{

    87

    ec_eeprom_string_t *string, *next_str;

    88

    ec_eeprom_sync_t *sync, *next_sync;

    89

    ec_eeprom_pdo_t *pdo, *next_pdo;

    90

    ec_eeprom_pdo_entry_t *entry, *next_ent;

    91

    ec_sdo_t *sdo, *next_sdo;

    92

    ec_sdo_entry_t *en, *next_en;

    93

    94

    // Alle Strings freigeben

    95

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

    96

        list_del(&string->list);

    97

        kfree(string);

    98

    }

    99

   100

    // Alle Sync-Manager freigeben

   101

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

   102

        list_del(&sync->list);

   103

        kfree(sync);

   104

    }

   105

   106

    // Alle PDOs freigeben

   107

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

   108

        list_del(&pdo->list);

   109

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

   110

   111

        // Alle Entries innerhalb eines PDOs freigeben

   112

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

   113

            list_del(&entry->list);

   114

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

   115

            kfree(entry);

   116

        }

   117

   118

        kfree(pdo);

   119

    }

   120

   121

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

   122

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

   123

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

   124

   125

    // Alle SDOs freigeben

   126

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

   127

        list_del(&sdo->list);

   128

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

   129

        // Alle Entries freigeben

   130

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

   131

            list_del(&en->list);

   132

            kfree(en);

   133

        }

   134

        kfree(sdo);

   135

    }

   138

}

   139

   140

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

   141

   142

/**

   143

   Liest alle benötigten Informationen aus einem Slave.

   144

   145

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

   146

*/

   147

   148

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

   149

{

   150

    ec_command_t *command;

   151

    unsigned int i;

   152

    uint16_t dl_status;

   153

   154

    command = &slave->master->simple_command;

   155

   156

    // Read base data

   157

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

   159

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

   160

               slave->ring_position);

   161

        return -1;

   162

    }

   163

   164

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

   165

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

   166

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

   167

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

   168

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

   169

   170

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   171

        slave->base_fmmu_count = EC_MAX_FMMUS;

   172

   173

    // Read DL status

   174

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

   176

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

   177

               slave->ring_position);

   178

        return -1;

   179

    }

   180

   181

    dl_status = EC_READ_U16(command->data);

   182

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

   183

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

   184

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

   185

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

   186

    }

   187

   188

    // Read EEPROM data

   189

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

   190

        return -1;

   191

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

   192

        return -1;

   193

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

   194

        return -1;

   195

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

   196

        return -1;

   197

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

   198

        return -1;

   199

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

   200

        return -1;

   201

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

   202

        return -1;

   203

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

   204

        return -1;

   205

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

   206

        return -1;

   207

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

   208

        return -1;

   209

   210

    if (unlikely(ec_slave_fetch_categories(slave))) {

   211

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

   212

        return -1;

   213

    }

   214

   215

    return 0;

   216

}

   217

   218

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

   219

   220

/**

   221

   Liest 16 Bit aus dem Slave-Information-Interface

   222

   eines EtherCAT-Slaves.

   223

   224

   \return 0 bei Erfolg, sonst < 0

   225

*/

   226

   227

int ec_slave_sii_read16(ec_slave_t *slave,

   228

                        /**< EtherCAT-Slave */

   229

                        uint16_t offset,

   230

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

   231

                        uint16_t *target

   232

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

   233

                        )

   234

{

   235

    ec_command_t *command;

   236

    cycles_t start, end, timeout;

   237

   238

    command = &slave->master->simple_command;

   239

   240

    // Initiate read operation

   241

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

   242

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

   243

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

   244

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

   246

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

   247

        return -1;

   248

    }

   249

   250

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

   251

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

   252

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

   253

   254

    start = get_cycles();

   255

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

   256

   257

    while (1)

   258

    {

   259

        udelay(10);

   260

   261

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

   262

            return -1;

   264

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

   265

                   slave->ring_position);

   266

            return -1;

   267

        }

   268

   269

        end = get_cycles();

   270

   271

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

   272

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

   273

            return 0;

   274

        }

   275

   276

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

   277

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

   278

            return -1;

   279

        }

   280

    }

   281

}

   282

   283

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

   284

   285

/**

   286

   Liest 32 Bit aus dem Slave-Information-Interface

   287

   eines EtherCAT-Slaves.

   288

   289

   \return 0 bei Erfolg, sonst < 0

   290

*/

   291

   292

int ec_slave_sii_read32(ec_slave_t *slave,

   293

                        /**< EtherCAT-Slave */

   294

                        uint16_t offset,

   295

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

   296

                        uint32_t *target

   297

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

   298

                        )

   299

{

   300

    ec_command_t *command;

   301

    cycles_t start, end, timeout;

   302

   303

    command = &slave->master->simple_command;

   304

   305

    // Initiate read operation

   306

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

   307

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

   308

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

   309

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

   311

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

   312

        return -1;

   313

    }

   314

   315

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

   316

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

   317

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

   318

   319

    start = get_cycles();

   320

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

   321

   322

    while (1)

   323

    {

   324

        udelay(10);

   325

   326

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

   327

            return -1;

   329

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

   330

                   slave->ring_position);

   331

            return -1;

   332

        }

   333

   334

        end = get_cycles();

   335

   336

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

   337

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

   338

            return 0;

   339

        }

   340

   341

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

   342

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

   343

            return -1;

   344

        }

   345

    }

   346

}

   347

   348

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

   349

   350

/**

   351

   Schreibt 16 Bit Daten in das Slave-Information-Interface

   352

   eines EtherCAT-Slaves.

   353

   354

   \return 0 bei Erfolg, sonst < 0

   355

*/

   356

   357

int ec_slave_sii_write16(ec_slave_t *slave,

   358

                         /**< EtherCAT-Slave */

   359

                         uint16_t offset,

   360

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

   361

                         uint16_t value

   362

                         /**< Zu schreibender Wert */

   363

                         )

   364

{

   365

    ec_command_t *command;

   366

    cycles_t start, end, timeout;

   367

   368

    command = &slave->master->simple_command;

   369

   370

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

   371

            slave->ring_position, offset, value);

   372

   373

    // Initiate write operation

   374

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

   375

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

   376

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

   377

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

   378

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

   380

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

   381

        return -1;

   382

    }

   383

   384

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

   385

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

   386

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

   387

   388

    start = get_cycles();

   389

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

   390

   391

    while (1)

   392

    {

   393

        udelay(10);

   394

   395

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

   396

            return -1;

   398

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

   399

                   slave->ring_position);

   400

            return -1;

   401

        }

   402

   403

        end = get_cycles();

   404

   405

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

   406

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

   407

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

   408

                return -1;

   409

            }

   410

            else {

   411

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

   412

                return 0;

   413

            }

   414

        }

   415

   416

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

   417

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

   418

            return -1;

   419

        }

   420

    }

   421

}

   422

   423

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

   424

   425

/**

   426

   Holt Daten aus dem EEPROM.

   427

   428

   \return 0, wenn alles ok, sonst < 0

   429

*/

   430

   431

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

   432

{

   433

    uint16_t word_offset, cat_type, word_count;

   434

    uint32_t value;

   435

    uint8_t *cat_data;

   436

    unsigned int i;

   437

   438

    word_offset = 0x0040;

   439

   440

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

   441

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

   442

        return -1;

   443

    }

   444

   445

    while (1) {

   446

        // read category type

   447

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

   448

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

   449

            goto out_free;

   450

        }

   451

   452

        // Last category?

   453

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

   454

   455

        cat_type = value & 0x7FFF;

   456

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

   457

   458

        // Fetch category data

   459

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

   460

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

   461

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

   462

                goto out_free;

   463

            }

   464

   465

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

   466

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

   467

   468

            // read second word "on the fly"

   469

            if (i + 1 < word_count) {

   470

                i++;

   471

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

   472

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

   473

            }

   474

        }

   475

   476

        switch (cat_type)

   477

        {

   478

            case 0x000A:

   479

                if (ec_slave_fetch_strings(slave, cat_data))

   480

                    goto out_free;

   481

                break;

   482

            case 0x001E:

   483

                if (ec_slave_fetch_general(slave, cat_data))

   484

                    goto out_free;

   485

                break;

   486

            case 0x0028:

   487

                break;