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->type = NULL;

    52

    slave->registered = 0;

    53

    slave->fmmu_count = 0;

    54

    slave->eeprom_name = NULL;

    55

    slave->eeprom_group = NULL;

    56

    slave->eeprom_desc = NULL;

    57

    INIT_LIST_HEAD(&slave->eeprom_strings);

    58

    INIT_LIST_HEAD(&slave->eeprom_syncs);

    59

    INIT_LIST_HEAD(&slave->eeprom_pdos);

    60

}

    61

    62

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

    63

    64

/**

    65

   EtherCAT-Slave-Destruktor.

    66

*/

    67

    68

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

    69

{

    70

    ec_eeprom_string_t *string, *next_str;

    71

    ec_eeprom_sync_t *sync, *next_sync;

    72

    ec_eeprom_pdo_t *pdo, *next_pdo;

    73

    ec_eeprom_pdo_entry_t *entry, *next_ent;

    74

    75

    // Alle Strings freigeben

    76

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

    77

        list_del(&string->list);

    78

        kfree(string);

    79

    }

    80

    81

    // Alle Sync-Manager freigeben

    82

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

    83

        list_del(&sync->list);

    84

        kfree(sync);

    85

    }

    86

    87

    // Alle PDOs freigeben

    88

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

    89

        list_del(&pdo->list);

    90

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

    91

    92

        // Alle Entries innerhalb eines PDOs freigeben

    93

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

    94

            list_del(&entry->list);

    95

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

    96

            kfree(entry);

    97

        }

    98

    99

        kfree(pdo);

   100

    }

   101

   102

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

   103

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

   104

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

   105

}

   106

   107

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

   108

   109

/**

   110

   Liest alle benötigten Informationen aus einem Slave.

   111

   112

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

   113

*/

   114

   115

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

   116

{

   117

    ec_command_t command;

   118

   119

    // Read base data

   120

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

   121

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

   122

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

   123

               slave->ring_position);

   124

        return -1;

   125

    }

   126

   127

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

   128

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

   129

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

   130

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

   131

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

   132

   133

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   134

        slave->base_fmmu_count = EC_MAX_FMMUS;

   135

   136

    // Read identification from "Slave Information Interface" (SII)

   137

   138

    if (unlikely(ec_slave_sii_read(slave, 0x0004,

   139

                                   (uint32_t *) &slave->sii_alias))) {

   140

        EC_ERR("Could not read SII alias!\n");

   141

        return -1;

   142

    }

   143

   144

    if (unlikely(ec_slave_sii_read(slave, 0x0008, &slave->sii_vendor_id))) {

   145

        EC_ERR("Could not read SII vendor id!\n");

   146

        return -1;

   147

    }

   148

   149

    if (unlikely(ec_slave_sii_read(slave, 0x000A, &slave->sii_product_code))) {

   150

        EC_ERR("Could not read SII product code!\n");

   151

        return -1;

   152

    }

   153

   154

    if (unlikely(ec_slave_sii_read(slave, 0x000C,

   155

                                   &slave->sii_revision_number))) {

   156

        EC_ERR("Could not read SII revision number!\n");

   157

        return -1;

   158

    }

   159

   160

    if (unlikely(ec_slave_sii_read(slave, 0x000E,

   161

                                   &slave->sii_serial_number))) {

   162

        EC_ERR("Could not read SII serial number!\n");

   163

        return -1;

   164

    }

   165

   166

    if (unlikely(ec_slave_fetch_categories(slave))) {

   167

        EC_ERR("Could not fetch category data!\n");

   168

        return -1;

   169

    }

   170

   171

    return 0;

   172

}

   173

   174

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

   175

   176

/**

   177

   Liest Daten aus dem Slave-Information-Interface

   178

   eines EtherCAT-Slaves.

   179

   180

   \return 0 bei Erfolg, sonst < 0

   181

*/

   182

   183

int ec_slave_sii_read(ec_slave_t *slave,

   184

                      /**< EtherCAT-Slave */

   185

                      uint16_t offset,

   186

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

   187

                      uint32_t *target

   188

                      /**< Zeiger auf einen 4 Byte großen Speicher zum Ablegen

   189

                         der Daten */

   190

                      )

   191

{

   192

    ec_command_t command;

   193

    uint8_t data[10];

   194

    cycles_t start, end, timeout;

   195

   196

    // Initiate read operation

   197

   198

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

   199

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

   200

    EC_WRITE_U32(data + 2, offset);

   201

   202

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

   203

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

   204

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

   205

        return -1;

   206

    }

   207

   208

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

   209

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

   210

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

   211

   212

    start = get_cycles();

   213

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

   214

   215

    while (1)

   216

    {

   217

        udelay(10);

   218

   219

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

   220

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

   221

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

   222

                   slave->ring_position);

   223

            return -1;

   224

        }

   225

   226

        end = get_cycles();

   227

   228

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

   229

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

   230

            return 0;

   231

        }

   232

   233

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

   234

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

   235

            return -1;

   236

        }

   237

    }

   238

}

   239

   240

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

   241

   242

/**

   243

   Schreibt Daten in das Slave-Information-Interface

   244

   eines EtherCAT-Slaves.

   245

   246

   \return 0 bei Erfolg, sonst < 0

   247

*/

   248

   249

int ec_slave_sii_write(ec_slave_t *slave,

   250

                       /**< EtherCAT-Slave */

   251

                       uint16_t offset,

   252

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

   253

                       uint16_t value

   254

                       /**< Zu schreibender Wert */

   255

                       )

   256

{

   257

    ec_command_t command;

   258

    uint8_t data[8];

   259

    cycles_t start, end, timeout;

   260

   261

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

   262

            slave->ring_position, offset, value);

   263

   264

    // Initiate write operation

   265

   266

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

   267

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

   268

    EC_WRITE_U32(data + 2, offset);

   269

    EC_WRITE_U16(data + 6, value);

   270

   271

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

   272

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

   273

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

   274

        return -1;

   275

    }

   276

   277

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

   278

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

   279

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

   280

   281

    start = get_cycles();

   282

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

   283

   284

    while (1)

   285

    {

   286

        udelay(10);

   287

   288

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

   289

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

   290

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

   291

                   slave->ring_position);

   292

            return -1;

   293

        }

   294

   295

        end = get_cycles();

   296

   297

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

   298

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

   299

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

   300

                return -1;

   301

            }

   302

            else {

   303

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

   304

                return 0;

   305

            }

   306

        }

   307

   308

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

   309

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

   310

            return -1;

   311

        }

   312

    }

   313

}

   314

   315

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

   316

   317

/**

   318

   Holt Daten aus dem EEPROM.

   319

   320

   \return 0, wenn alles ok, sonst < 0

   321

*/

   322

   323

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

   324

{

   325

    uint16_t word_offset, cat_type, word_count;

   326

    uint32_t value;

   327

    uint8_t *cat_data;

   328

    unsigned int i;

   329

   330

    word_offset = 0x0040;

   331

   332

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

   333

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

   334

        return -1;

   335

    }

   336

   337

    while (1) {

   338

        // read category type

   339

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

   340

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

   341

            goto out_free;

   342

        }

   343

   344

        // Last category?

   345

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

   346

   347

        cat_type = value & 0x7FFF;

   348

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

   349

   350

        // Fetch category data

   351

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

   352

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

   353

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

   354

                goto out_free;

   355

            }

   356

   357

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

   358

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

   359

   360

            // read second word "on the fly"

   361

            if (i + 1 < word_count) {

   362

                i++;

   363

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

   364

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

   365

            }

   366

        }

   367

   368

        switch (cat_type)

   369

        {

   370

            case 0x000A:

   371

                if (ec_slave_fetch_strings(slave, cat_data))

   372

                    goto out_free;

   373

                break;

   374

            case 0x001E:

   375

                if (ec_slave_fetch_general(slave, cat_data))

   376

                    goto out_free;

   377

                break;

   378

            case 0x0028:

   379

                break;

   380

            case 0x0029:

   381

                if (ec_slave_fetch_sync(slave, cat_data, word_count))

   382

                    goto out_free;

   383

                break;

   384

            case 0x0032:

   385

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

   386

                    goto out_free;

   387

                break;

   388

            case 0x0033:

   389

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

   390

                    goto out_free;

   391

                break;

   392

            default:

   393

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

   394

                        cat_type, slave->ring_position);

   395

        }

   396

   397

        word_offset += 2 + word_count;

   398

    }

   399

   400

    kfree(cat_data);

   401

    return 0;

   402

   403

 out_free:

   404

    kfree(cat_data);

   405

    return -1;

   406

}

   407

   408

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

   409

   410

/**

   411

   Holt die Daten einer String-Kategorie.

   412

   413

   \return 0 wenn alles ok, sonst < 0

   414

*/

   415

   416

int ec_slave_fetch_strings(ec_slave_t *slave, /**< EtherCAT-Slave */

   417

                           const uint8_t *data /**< Kategoriedaten */

   418

                           )

   419

{

   420

    unsigned int string_count, i;

   421

    size_t size;

   422

    off_t offset;

   423

    ec_eeprom_string_t *string;

   424

   425

    string_count = data[0];

   426

    offset = 1;

   427

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

   428

        size = data[offset];

   429

        // Speicher für String-Objekt und Daten in einem Rutsch allozieren

   430

        if (!(string = (ec_eeprom_string_t *)

   431

              kmalloc(sizeof(ec_eeprom_string_t) + size + 1, GFP_KERNEL))) {

   432

            EC_ERR("Failed to allocate string memory.\n");

   433

            return -1;

   434

        }

   435

        string->size = size;

   436

        string->data = (char *) string + sizeof(ec_eeprom_string_t);

   437

        memcpy(string->data, data + offset + 1, size);

   438

        string->data[size] = 0x00;

   439

        list_add_tail(&string->list, &slave->eeprom_strings);

   440

        offset += 1 + size;

   441

    }

   442

   443

    return 0;

   444

}

   445

   446

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

   447

   448

/**

   449

   Holt die Daten einer General-Kategorie.

   450

*/

   451

   452

int ec_slave_fetch_general(ec_slave_t *slave, /**< EtherCAT-Slave */

   453

                           const uint8_t *data /**< Kategorie-Daten */

   454

                           )

   455

{

   456

    if (ec_slave_locate_string(slave, data[0], &slave->eeprom_group))

   457

        return -1;

   458

    if (ec_slave_locate_string(slave, data[1], &slave->eeprom_name))

   459

        return -1;

   460

    if (ec_slave_locate_string(slave, data[3], &slave->eeprom_desc))

   461

        return -1;

   462

   463

    return 0;

   464

}

   465

   466

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

   467

   468

/**

   469

   Holt die Daten einer Sync-Manager-Kategorie.

   470

*/

   471

   472

int ec_slave_fetch_sync(ec_slave_t *slave, /**< EtherCAT-Slave */

   473

                        const uint8_t *data, /**< Kategorie-Daten */

   474

                        size_t word_count /**< Anzahl Words */

   475

                        )

   476

{

   477

    unsigned int sync_count, i;

   478

    ec_eeprom_sync_t *sync;

   479

   480

    sync_count = word_count / 4; // Sync-Manager-Strunktur ist 4 Worte lang

   481

   482

    for (i = 0; i < sync_count; i++, data += 8) {

   483

        if (!(sync = (ec_eeprom_sync_t *)

   484

              kmalloc(sizeof(ec_eeprom_sync_t), GFP_KERNEL))) {

   485

            EC_ERR("Failed to allocate Sync-Manager memory.\n");

   486

            return -1;

   487

        }

   488