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;

    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

   126

    // Alle SDOs freigeben

   127

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

   128

        list_del(&sdo->list);

   129

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

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

   140

}

   141

   142

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

   143

   144

/**

   145

   Liest alle benötigten Informationen aus einem Slave.

   146

   147

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

   148

*/

   149

   150

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

   151

{

   152

    ec_command_t *command;

   153

    unsigned int i;

   154

    uint16_t dl_status;

   155

   156

    command = &slave->master->simple_command;

   157

   158

    // Read base data

   159

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

   160

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

   161

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

   162

               slave->ring_position);

   163

        return -1;

   164

    }

   165

   166

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

   167

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

   168

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

   169

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

   170

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

   171

   172

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   173

        slave->base_fmmu_count = EC_MAX_FMMUS;

   174

   175

    // Read DL status

   176

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

   177

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

   178

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

   179

               slave->ring_position);

   180

        return -1;

   181

    }

   182

   183

    dl_status = EC_READ_U16(command->data);

   184

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

   185

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

   186

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

   187

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

   188

    }

   189

   190

    // Read EEPROM data

   191

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

   192

        return -1;

   193

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

   194

        return -1;

   195

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

   196

        return -1;

   197

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

   198

        return -1;

   199

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

   200

        return -1;

   201

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

   202

        return -1;

   203

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

   204

        return -1;

   205

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

   206

        return -1;

   207

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

   208

        return -1;

   209

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

   210

        return -1;

   211

   212

    if (unlikely(ec_slave_fetch_categories(slave))) {

   213

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

   214

        return -1;

   215

    }

   216

   217

    return 0;

   218

}

   219

   220

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

   221

   222

/**

   223

   Liest 16 Bit aus dem Slave-Information-Interface

   224

   eines EtherCAT-Slaves.

   225

   226

   \return 0 bei Erfolg, sonst < 0

   227

*/

   228

   229

int ec_slave_sii_read16(ec_slave_t *slave,

   230

                        /**< EtherCAT-Slave */

   231

                        uint16_t offset,

   232

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

   233

                        uint16_t *target

   234

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

   235

                        )

   236

{

   237

    ec_command_t *command;

   238

    cycles_t start, end, timeout;

   239

   240

    command = &slave->master->simple_command;

   241

   242

    // Initiate read operation

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

        return -1;

   250

    }

   251

   252

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

   253

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

   254

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

   255

   256

    start = get_cycles();

   257

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

   258

   259

    while (1)

   260

    {

   261

        udelay(10);

   262

   263

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

   264

            return -1;

   265

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

   266

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

   267

                   slave->ring_position);

   268

            return -1;

   269

        }

   270

   271

        end = get_cycles();

   272

   273

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

   274

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

   275

            return 0;

   276

        }

   277

   278

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

   279

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

   280

            return -1;

   281

        }

   282

    }

   283

}

   284

   285

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

   286

   287

/**

   288

   Liest 32 Bit aus dem Slave-Information-Interface

   289

   eines EtherCAT-Slaves.

   290

   291

   \return 0 bei Erfolg, sonst < 0

   292

*/

   293

   294

int ec_slave_sii_read32(ec_slave_t *slave,

   295

                        /**< EtherCAT-Slave */

   296

                        uint16_t offset,

   297

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

   298

                        uint32_t *target

   299

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

   300

                        )

   301

{

   302

    ec_command_t *command;

   303

    cycles_t start, end, timeout;

   304

   305

    command = &slave->master->simple_command;

   306

   307

    // Initiate read operation

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

        return -1;

   315

    }

   316

   317

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

   318

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

   319

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

   320

   321

    start = get_cycles();

   322

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

   323

   324

    while (1)

   325

    {

   326

        udelay(10);

   327

   328

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

   329

            return -1;

   330

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

   331

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

   332

                   slave->ring_position);

   333

            return -1;

   334

        }

   335

   336

        end = get_cycles();

   337

   338

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

   339

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

   340

            return 0;

   341

        }

   342

   343

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

   344

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

   345

            return -1;

   346

        }

   347

    }

   348

}

   349

   350

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

   351

   352

/**

   353

   Schreibt 16 Bit Daten in das Slave-Information-Interface

   354

   eines EtherCAT-Slaves.

   355

   356

   \return 0 bei Erfolg, sonst < 0

   357

*/

   358

   359

int ec_slave_sii_write16(ec_slave_t *slave,

   360

                         /**< EtherCAT-Slave */

   361

                         uint16_t offset,

   362

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

   363

                         uint16_t value

   364

                         /**< Zu schreibender Wert */

   365

                         )

   366

{

   367

    ec_command_t *command;

   368

    cycles_t start, end, timeout;

   369

   370

    command = &slave->master->simple_command;

   371

   372

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

   373

            slave->ring_position, offset, value);

   374

   375

    // Initiate write operation

   376

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

   377

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

   378

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

   379

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

   380

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

   381

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

   382

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

   383

        return -1;

   384

    }

   385

   386

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

   387

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

   388

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

   389

   390

    start = get_cycles();

   391

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

   392

   393

    while (1)

   394

    {

   395

        udelay(10);

   396

   397

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

   398

            return -1;

   399

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

   400

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

   401

                   slave->ring_position);

   402

            return -1;

   403

        }

   404

   405

        end = get_cycles();

   406

   407

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

   408

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

   409

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

   410

                return -1;

   411

            }

   412

            else {

   413

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

   414

                return 0;

   415

            }

   416

        }

   417

   418

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

   419

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

   420

            return -1;

   421

        }

   422

    }

   423

}

   424

   425

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

   426

   427

/**

   428

   Holt Daten aus dem EEPROM.

   429

   430

   \return 0, wenn alles ok, sonst < 0

   431

*/

   432

   433

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

   434

{

   435

    uint16_t word_offset, cat_type, word_count;

   436

    uint32_t value;

   437

    uint8_t *cat_data;

   438

    unsigned int i;

   439

   440

    word_offset = 0x0040;

   441

   442

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

   443

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

   444

        return -1;

   445

    }

   446

   447

    while (1) {

   448

        // read category type

   449

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

   450

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

   451

            goto out_free;

   452

        }

   453

   454

        // Last category?

   455

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

   456

   457

        cat_type = value & 0x7FFF;

   458

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

   459

   460

        // Fetch category data

   461

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

   462

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

   463

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

   464

                goto out_free;

   465

            }

   466

   467

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

   468

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

   469

   470

            // read second word "on the fly"

   471

            if (i + 1 < word_count) {

   472

                i++;

   473

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

   474

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

   475

            }

   476

        }

   477

   478

        switch (cat_type)

   479

        {

   480

            case 0x000A:

   481

                if (ec_slave_fetch_strings(slave, cat_data))

   482

                    goto out_free;

   483

                break;

   484

            case 0x001E:

   485

                if (ec_slave_fetch_general(slave, cat_data))

   486

                    goto out_free;

   487

                break;