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

    slave->master = master;

    39

    slave->base_type = 0;

    40

    slave->base_revision = 0;

    41

    slave->base_build = 0;

    42

    slave->base_fmmu_count = 0;

    43

    slave->base_sync_count = 0;

    44

    slave->ring_position = 0;

    45

    slave->station_address = 0;

    46

    slave->sii_alias = 0;

    47

    slave->sii_vendor_id = 0;

    48

    slave->sii_product_code = 0;

    49

    slave->sii_revision_number = 0;

    50

    slave->sii_serial_number = 0;

    51

    slave->sii_rx_mailbox_offset = 0;

    52

    slave->sii_rx_mailbox_size = 0;

    53

    slave->sii_tx_mailbox_offset = 0;

    54

    slave->sii_tx_mailbox_size = 0;

    55

    slave->sii_mailbox_protocols = 0;

    56

    slave->type = NULL;

    57

    slave->registered = 0;

    58

    slave->fmmu_count = 0;

    59

    slave->eeprom_name = NULL;

    60

    slave->eeprom_group = NULL;

    61

    slave->eeprom_desc = NULL;

    62

    INIT_LIST_HEAD(&slave->eeprom_strings);

    63

    INIT_LIST_HEAD(&slave->eeprom_syncs);

    64

    INIT_LIST_HEAD(&slave->eeprom_pdos);

    65

    INIT_LIST_HEAD(&slave->sdo_dictionary);

    66

}

    67

    68

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

    69

    70

/**

    71

   EtherCAT-Slave-Destruktor.

    72

*/

    73

    74

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

    75

{

    76

    ec_eeprom_string_t *string, *next_str;

    77

    ec_eeprom_sync_t *sync, *next_sync;

    78

    ec_eeprom_pdo_t *pdo, *next_pdo;

    79

    ec_eeprom_pdo_entry_t *entry, *next_ent;

    80

    ec_sdo_t *sdo, *next_sdo;

    81

    ec_sdo_entry_t *en, *next_en;

    82

    83

    // Alle Strings freigeben

    84

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

    85

        list_del(&string->list);

    86

        kfree(string);

    87

    }

    88

    89

    // Alle Sync-Manager freigeben

    90

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

    91

        list_del(&sync->list);

    92

        kfree(sync);

    93

    }

    94

    95

    // Alle PDOs freigeben

    96

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

    97

        list_del(&pdo->list);

    98

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

    99

   100

        // Alle Entries innerhalb eines PDOs freigeben

   101

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

   102

            list_del(&entry->list);

   103

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

   104

            kfree(entry);

   105

        }

   106

   107

        kfree(pdo);

   108

    }

   109

   110

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

   111

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

   112

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

   113

   114

    // Alle SDOs freigeben

   115

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

   116

        list_del(&sdo->list);

   117

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

   118

        // Alle Entries freigeben

   119

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

   120

            list_del(&en->list);

   121

            kfree(en);

   122

        }

   123

        kfree(sdo);

   124

    }

   125

}

   126

   127

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

   128

   129

/**

   130

   Liest alle benötigten Informationen aus einem Slave.

   131

   132

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

   133

*/

   134

   135

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

   136

{

   137

    ec_command_t command;

   138

   139

    // Read base data

   140

    ec_command_init_nprd(&command, slave->station_address, 0x0000, 6);

   141

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

   142

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

   143

               slave->ring_position);

   144

        return -1;

   145

    }

   146

   147

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

   148

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

   149

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

   150

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

   151

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

   152

   153

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   154

        slave->base_fmmu_count = EC_MAX_FMMUS;

   155

   156

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

   157

        return -1;

   158

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

   159

        return -1;

   160

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

   161

        return -1;

   162

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

   163

        return -1;

   164

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

   165

        return -1;

   166

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

   167

        return -1;

   168

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

   169

        return -1;

   170

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

   171

        return -1;

   172

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

   173

        return -1;

   174

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

   175

        return -1;

   176

   177

    if (unlikely(ec_slave_fetch_categories(slave))) {

   178

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

   179

        return -1;

   180

    }

   181

   182

    return 0;

   183

}

   184

   185

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

   186

   187

/**

   188

   Liest 16 Bit aus dem Slave-Information-Interface

   189

   eines EtherCAT-Slaves.

   190

   191

   \return 0 bei Erfolg, sonst < 0

   192

*/

   193

   194

int ec_slave_sii_read16(ec_slave_t *slave,

   195

                        /**< EtherCAT-Slave */

   196

                        uint16_t offset,

   197

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

   198

                        uint16_t *target

   199

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

   200

                        )

   201

{

   202

    ec_command_t command;

   203

    uint8_t data[10];

   204

    cycles_t start, end, timeout;

   205

   206

    // Initiate read operation

   207

   208

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

   209

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

   210

    EC_WRITE_U32(data + 2, offset);

   211

   212

    ec_command_init_npwr(&command, slave->station_address, 0x502, 6, data);

   213

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

   214

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

   215

        return -1;

   216

    }

   217

   218

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

   219

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

   220

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

   221

   222

    start = get_cycles();

   223

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

   224

   225

    while (1)

   226

    {

   227

        udelay(10);

   228

   229

        ec_command_init_nprd(&command, slave->station_address, 0x502, 10);

   230

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

   231

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

   232

                   slave->ring_position);

   233

            return -1;

   234

        }

   235

   236

        end = get_cycles();

   237

   238

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

   239

            *target = EC_READ_U16(command.data + 6);

   240

            return 0;

   241

        }

   242

   243

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

   244

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

   245

            return -1;

   246

        }

   247

    }

   248

}

   249

   250

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

   251

   252

/**

   253

   Liest 32 Bit aus dem Slave-Information-Interface

   254

   eines EtherCAT-Slaves.

   255

   256

   \return 0 bei Erfolg, sonst < 0

   257

*/

   258

   259

int ec_slave_sii_read32(ec_slave_t *slave,

   260

                        /**< EtherCAT-Slave */

   261

                        uint16_t offset,

   262

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

   263

                        uint32_t *target

   264

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

   265

                        )

   266

{

   267

    ec_command_t command;

   268

    uint8_t data[10];

   269

    cycles_t start, end, timeout;

   270

   271

    // Initiate read operation

   272

   273

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

   274

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

   275

    EC_WRITE_U32(data + 2, offset);

   276

   277

    ec_command_init_npwr(&command, slave->station_address, 0x502, 6, data);

   278

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

   279

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

   280

        return -1;

   281

    }

   282

   283

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

   284

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

   285

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

   286

   287

    start = get_cycles();

   288

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

   289

   290

    while (1)

   291

    {

   292

        udelay(10);

   293

   294

        ec_command_init_nprd(&command, slave->station_address, 0x502, 10);

   295

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

   296

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

   297

                   slave->ring_position);

   298

            return -1;

   299

        }

   300

   301

        end = get_cycles();

   302

   303

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

   304

            *target = EC_READ_U32(command.data + 6);

   305

            return 0;

   306

        }

   307

   308

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

   309

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

   310

            return -1;

   311

        }

   312

    }

   313

}

   314

   315

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

   316

   317

/**

   318

   Schreibt 16 Bit Daten in das Slave-Information-Interface

   319

   eines EtherCAT-Slaves.

   320

   321

   \return 0 bei Erfolg, sonst < 0

   322

*/

   323

   324

int ec_slave_sii_write16(ec_slave_t *slave,

   325

                         /**< EtherCAT-Slave */

   326

                         uint16_t offset,

   327

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

   328

                         uint16_t value

   329

                         /**< Zu schreibender Wert */

   330

                         )

   331

{

   332

    ec_command_t command;

   333

    uint8_t data[8];

   334

    cycles_t start, end, timeout;

   335

   336

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

   337

            slave->ring_position, offset, value);

   338

   339

    // Initiate write operation

   340

   341

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

   342

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

   343

    EC_WRITE_U32(data + 2, offset);

   344

    EC_WRITE_U16(data + 6, value);

   345

   346

    ec_command_init_npwr(&command, slave->station_address, 0x502, 8, data);

   347

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

   348

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

   349

        return -1;

   350

    }

   351

   352

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

   353

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

   354

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

   355

   356

    start = get_cycles();

   357

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

   358

   359

    while (1)

   360

    {

   361

        udelay(10);

   362

   363

        ec_command_init_nprd(&command, slave->station_address, 0x502, 2);

   364

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

   365

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

   366

                   slave->ring_position);

   367

            return -1;

   368

        }

   369

   370

        end = get_cycles();

   371

   372

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

   373

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

   374

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

   375

                return -1;

   376

            }

   377

            else {

   378

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

   379

                return 0;

   380

            }

   381

        }

   382

   383

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

   384

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

   385

            return -1;

   386

        }

   387

    }

   388

}

   389

   390

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

   391

   392

/**

   393

   Holt Daten aus dem EEPROM.

   394

   395

   \return 0, wenn alles ok, sonst < 0

   396

*/

   397

   398

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

   399

{

   400

    uint16_t word_offset, cat_type, word_count;

   401

    uint32_t value;

   402

    uint8_t *cat_data;

   403

    unsigned int i;

   404

   405

    word_offset = 0x0040;

   406

   407

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

   408

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

   409

        return -1;

   410

    }

   411

   412

    while (1) {

   413

        // read category type

   414

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

   415

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

   416

            goto out_free;

   417

        }

   418

   419

        // Last category?

   420

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

   421

   422

        cat_type = value & 0x7FFF;

   423

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

   424

   425

        // Fetch category data

   426

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

   427

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

   428

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

   429

                goto out_free;

   430

            }

   431

   432

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

   433

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

   434

   435

            // read second word "on the fly"

   436

            if (i + 1 < word_count) {

   437

                i++;

   438

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

   439

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

   440

            }

   441

        }

   442

   443

        switch (cat_type)

   444

        {

   445

            case 0x000A:

   446

                if (ec_slave_fetch_strings(slave, cat_data))

   447

                    goto out_free;

   448

                break;

   449

            case 0x001E:

   450

                if (ec_slave_fetch_general(slave, cat_data))

   451

                    goto out_free;

   452

                break;

   453

            case 0x0028:

   454

                break;

   455

            case 0x0029:

   456

                if (ec_slave_fetch_sync(slave, cat_data, word_count))

   457

                    goto out_free;

   458

                break;

   459

            case 0x0032:

   460

                if (ec_slave_fetch_pdo(slave, cat_data, word_count, EC_TX_PDO))

   461

                    goto out_free;

   462

                break;

   463

            case 0x0033:

   464

                if (ec_slave_fetch_pdo(slave, cat_data, word_count, EC_RX_PDO))

   465

                    goto out_free;

   466

                break;

   467

            default:

   468

                EC_WARN("Unknown category type 0x%04X in slave %i.\n",

   469

                        cat_type, slave->ring_position);

   470

        }

   471

   472

        word_offset += 2 + word_count;

   473

    }

   474

   475

    kfree(cat_data);

   476

    return 0;

   477

   478

 out_free:

   479

    kfree(cat_data);

   480

    return -1;

   481

}

   482

   483

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

   484

   485

/**

   486

   Holt die Daten einer String-Kategorie.

   487

   488

   \return 0 wenn alles ok, sonst < 0

   489

*/