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;

    64

    65

    ec_command_init(&slave->mbox_command);

    66

    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);

    71

    72

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

    73

        slave->dl_status_link[i] = 0;

    74

        slave->dl_status_loop[i] = 0;

    75

        slave->dl_status_comm[i] = 0;

    76

    }

    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

   130

        // Alle Entries freigeben

   131

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

   132

            list_del(&en->list);

   133

            kfree(en);

   134

        }

   135

        kfree(sdo);

   136

    }

   137

   138

    ec_command_clear(&slave->mbox_command);

   139

}

   140

   141

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

   142

   143

/**

   144

   Liest alle benötigten Informationen aus einem Slave.

   145

   146

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

   147

*/

   148

   149

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

   150

{

   151

    ec_command_t *command;

   152

    unsigned int i;

   153

    uint16_t dl_status;

   154

   155

    command = &slave->master->simple_command;

   156

   157

    // Read base data

   158

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

   159

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

   160

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

   161

               slave->ring_position);

   162

        return -1;

   163

    }

   164

   165

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

   166

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

   167

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

   168

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

   169

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

   170

   171

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   172

        slave->base_fmmu_count = EC_MAX_FMMUS;

   173

   174

    // Read DL status

   175

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

   176

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

   177

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

   178

               slave->ring_position);

   179

        return -1;

   180

    }

   181

   182

    dl_status = EC_READ_U16(command->data);

   183

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

   184

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

   185

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

   186

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

   187

    }

   188

   189

    // Read EEPROM data

   190

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

   191

        return -1;

   192

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

   193

        return -1;

   194

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

   195

        return -1;

   196

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

   197

        return -1;

   198

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

   199

        return -1;

   200

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

   201

        return -1;

   202

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

   203

        return -1;

   204

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

   205

        return -1;

   206

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

   207

        return -1;

   208

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

   209

        return -1;

   210

   211

    if (unlikely(ec_slave_fetch_categories(slave))) {

   212

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

   213

        return -1;

   214

    }

   215

   216

    return 0;

   217

}

   218

   219

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

   220

   221

/**

   222

   Liest 16 Bit aus dem Slave-Information-Interface

   223

   eines EtherCAT-Slaves.

   224

   225

   \return 0 bei Erfolg, sonst < 0

   226

*/

   227

   228

int ec_slave_sii_read16(ec_slave_t *slave,

   229

                        /**< EtherCAT-Slave */

   230

                        uint16_t offset,

   231

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

   232

                        uint16_t *target

   233

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

   234

                        )

   235

{

   236

    ec_command_t *command;

   237

    cycles_t start, end, timeout;

   238

   239

    command = &slave->master->simple_command;

   240

   241

    // Initiate read operation

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

        return -1;

   249

    }

   250

   251

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

   252

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

   253

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

   254

   255

    start = get_cycles();

   256

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

   257

   258

    while (1)

   259

    {

   260

        udelay(10);

   261

   262

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

   263

            return -1;

   264

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

   265

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

   266

                   slave->ring_position);

   267

            return -1;

   268

        }

   269

   270

        end = get_cycles();

   271

   272

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

   273

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

   274

            return 0;

   275

        }

   276

   277

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

   278

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

   279

            return -1;

   280

        }

   281

    }

   282

}

   283

   284

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

   285

   286

/**

   287

   Liest 32 Bit aus dem Slave-Information-Interface

   288

   eines EtherCAT-Slaves.

   289

   290

   \return 0 bei Erfolg, sonst < 0

   291

*/

   292

   293

int ec_slave_sii_read32(ec_slave_t *slave,

   294

                        /**< EtherCAT-Slave */

   295

                        uint16_t offset,

   296

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

   297

                        uint32_t *target

   298

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

   299

                        )

   300

{

   301

    ec_command_t *command;

   302

    cycles_t start, end, timeout;

   303

   304

    command = &slave->master->simple_command;

   305

   306

    // Initiate read operation

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

        return -1;

   314

    }

   315

   316

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

   317

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

   318

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

   319

   320

    start = get_cycles();

   321

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

   322

   323

    while (1)

   324

    {

   325

        udelay(10);

   326

   327

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

   328

            return -1;

   329

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

   330

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

   331

                   slave->ring_position);

   332

            return -1;

   333

        }

   334

   335

        end = get_cycles();

   336

   337

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

   338

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

   339

            return 0;

   340

        }

   341

   342

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

   343

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

   344

            return -1;

   345

        }

   346

    }

   347

}

   348

   349

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

   350

   351

/**

   352

   Schreibt 16 Bit Daten in das Slave-Information-Interface

   353

   eines EtherCAT-Slaves.

   354

   355

   \return 0 bei Erfolg, sonst < 0

   356

*/

   357

   358

int ec_slave_sii_write16(ec_slave_t *slave,

   359

                         /**< EtherCAT-Slave */

   360

                         uint16_t offset,

   361

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

   362

                         uint16_t value

   363

                         /**< Zu schreibender Wert */

   364

                         )

   365

{

   366

    ec_command_t *command;

   367

    cycles_t start, end, timeout;

   368

   369

    command = &slave->master->simple_command;

   370

   371

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

   372

            slave->ring_position, offset, value);

   373

   374

    // Initiate write operation

   375

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

   376

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

   377

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

   378

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

   379

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

   380

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

   381

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

   382

        return -1;

   383

    }

   384

   385

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

   386

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

   387

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

   388

   389

    start = get_cycles();

   390

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

   391

   392

    while (1)

   393

    {

   394

        udelay(10);

   395

   396

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

   397

            return -1;

   398

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

   399

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

   400

                   slave->ring_position);

   401

            return -1;

   402

        }

   403

   404

        end = get_cycles();

   405

   406

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

   407

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

   408

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

   409

                return -1;

   410

            }

   411

            else {

   412

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

   413

                return 0;

   414

            }

   415

        }

   416

   417

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

   418

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

   419

            return -1;

   420

        }

   421

    }

   422

}

   423

   424

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

   425

   426

/**

   427

   Holt Daten aus dem EEPROM.

   428

   429

   \return 0, wenn alles ok, sonst < 0

   430

*/

   431

   432

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

   433

{

   434

    uint16_t word_offset, cat_type, word_count;

   435

    uint32_t value;

   436

    uint8_t *cat_data;

   437

    unsigned int i;

   438

   439

    word_offset = 0x0040;

   440

   441

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

   442

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

   443

        return -1;

   444

    }

   445

   446

    while (1) {

   447

        // read category type

   448

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

   449

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

   450

            goto out_free;

   451

        }

   452

   453

        // Last category?

   454

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

   455

   456

        cat_type = value & 0x7FFF;

   457

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

   458

   459

        // Fetch category data

   460

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

   461

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

   462

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

   463

                goto out_free;

   464

            }

   465

   466

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

   467

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

   468

   469

            // read second word "on the fly"

   470

            if (i + 1 < word_count) {

   471

                i++;

   472

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

   473

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

   474

            }

   475

        }

   476

   477

        switch (cat_type)

   478

        {

   479

            case 0x000A:

   480

                if (ec_slave_fetch_strings(slave, cat_data))

   481

                    goto out_free;

   482

                break;

   483

            case 0x001E:

   484

                if (ec_slave_fetch_general(slave, cat_data))

   485

                    goto out_free;

   486

                break;

   487

            case 0x0028: