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

void ec_slave_fetch_general(ec_slave_t *, const uint8_t *);

    24

void ec_slave_fetch_fmmu(ec_slave_t *, const uint8_t *);

    25

void ec_slave_fetch_sync(ec_slave_t *, const uint8_t *);

    26

void ec_slave_fetch_txpdo(ec_slave_t *, const uint8_t *);

    27

void ec_slave_fetch_rxpdo(ec_slave_t *, const uint8_t *);

    28

    29

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

    30

    31

/**

    32

   EtherCAT-Slave-Konstruktor.

    33

*/

    34

    35

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

    36

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

    37

                   )

    38

{

    39

    slave->master = master;

    40

    slave->base_type = 0;

    41

    slave->base_revision = 0;

    42

    slave->base_build = 0;

    43

    slave->base_fmmu_count = 0;

    44

    slave->base_sync_count = 0;

    45

    slave->ring_position = 0;

    46

    slave->station_address = 0;

    47

    slave->sii_alias = 0;

    48

    slave->sii_vendor_id = 0;

    49

    slave->sii_product_code = 0;

    50

    slave->sii_revision_number = 0;

    51

    slave->sii_serial_number = 0;

    52

    slave->type = NULL;

    53

    slave->registered = 0;

    54

    slave->fmmu_count = 0;

    55

    56

    INIT_LIST_HEAD(&slave->cat_strings);

    57

}

    58

    59

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

    60

    61

/**

    62

   EtherCAT-Slave-Destruktor.

    63

*/

    64

    65

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

    66

{

    67

    ec_slave_string_t *string, *next;

    68

    69

    // Alle Strings freigeben

    70

    list_for_each_entry_safe(string, next, &slave->cat_strings, list) {

    71

        list_del(&string->list);

    72

        kfree(string);

    73

    }

    74

}

    75

    76

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

    77

    78

/**

    79

   Liest alle benötigten Informationen aus einem Slave.

    80

    81

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

    82

*/

    83

    84

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

    85

{

    86

    ec_command_t command;

    87

    88

    // Read base data

    89

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

    90

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

    91

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

    92

               slave->ring_position);

    93

        return -1;

    94

    }

    95

    96

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

    97

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

    98

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

    99

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

   100

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

   101

   102

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   103

        slave->base_fmmu_count = EC_MAX_FMMUS;

   104

   105

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

   106

   107

    if (unlikely(ec_slave_sii_read(slave, 0x0004,

   108

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

   109

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

   110

        return -1;

   111

    }

   112

   113

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

   114

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

   115

        return -1;

   116

    }

   117

   118

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

   119

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

   120

        return -1;

   121

    }

   122

   123

    if (unlikely(ec_slave_sii_read(slave, 0x000C,

   124

                                   &slave->sii_revision_number))) {

   125

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

   126

        return -1;

   127

    }

   128

   129

    if (unlikely(ec_slave_sii_read(slave, 0x000E,

   130

                                   &slave->sii_serial_number))) {

   131

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

   132

        return -1;

   133

    }

   134

   135

    if (unlikely(ec_slave_fetch_categories(slave))) {

   136

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

   137

        return -1;

   138

    }

   139

   140

    return 0;

   141

}

   142

   143

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

   144

   145

/**

   146

   Liest Daten aus dem Slave-Information-Interface

   147

   eines EtherCAT-Slaves.

   148

   149

   \return 0 bei Erfolg, sonst < 0

   150

*/

   151

   152

int ec_slave_sii_read(ec_slave_t *slave,

   153

                      /**< EtherCAT-Slave */

   154

                      uint16_t offset,

   155

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

   156

                      uint32_t *target

   157

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

   158

                         der Daten */

   159

                      )

   160

{

   161

    ec_command_t command;

   162

    uint8_t data[10];

   163

    cycles_t start, end, timeout;

   164

   165

    // Initiate read operation

   166

   167

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

   168

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

   169

    EC_WRITE_U32(data + 2, offset);

   170

   171

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

   172

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

   173

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

   174

        return -1;

   175

    }

   176

   177

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

   178

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

   179

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

   180

   181

    start = get_cycles();

   183

   184

    while (1)

   185

    {

   186

        udelay(10);

   187

   188

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

   189

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

   190

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

   191

                   slave->ring_position);

   192

            return -1;

   193

        }

   194

   195

        end = get_cycles();

   196

   197

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

   198

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

   199

            return 0;

   200

        }

   201

   202

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

   203

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

   204

            return -1;

   205

        }

   206

    }

   207

}

   208

   209

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

   210

   211

/**

   212

   Schreibt Daten in das Slave-Information-Interface

   213

   eines EtherCAT-Slaves.

   214

   215

   \return 0 bei Erfolg, sonst < 0

   216

*/

   217

   218

int ec_slave_sii_write(ec_slave_t *slave,

   219

                       /**< EtherCAT-Slave */

   220

                       uint16_t offset,

   221

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

   222

                       uint16_t value

   223

                       /**< Zu schreibender Wert */

   224

                       )

   225

{

   226

    ec_command_t command;

   227

    uint8_t data[8];

   228

    cycles_t start, end, timeout;

   229

   230

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

   231

            slave->ring_position, offset, value);

   232

   233

    // Initiate write operation

   234

   235

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

   236

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

   237

    EC_WRITE_U32(data + 2, offset);

   238

    EC_WRITE_U16(data + 6, value);

   239

   240

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

   241

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

   242

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

   243

        return -1;

   244

    }

   245

   246

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

   247

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

   248

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

   249

   250

    start = get_cycles();

   252

   253

    while (1)

   254

    {

   255

        udelay(10);

   256

   257

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

   258

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

   259

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

   260

                   slave->ring_position);

   261

            return -1;

   262

        }

   263

   264

        end = get_cycles();

   265

   266

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

   267

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

   268

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

   269

                return -1;

   270

            }

   271

            else {

   272

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

   273

                return 0;

   274

            }

   275

        }

   276

   277

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

   278

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

   279

            return -1;

   280

        }

   281

    }

   282

}

   283

   284

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

   285

   286

/**

   287

   Holt Daten aus dem EEPROM.

   288

   289

   \return 0, wenn alles ok, sonst < 0

   290

*/

   291

   292

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

   293

{

   294

    uint16_t word_offset, header, word_count;

   295

    uint32_t value;

   296

    uint8_t *cat_data;

   297

    unsigned int i;

   298

   299

    word_offset = 0x0040;

   300

   301

    //EC_DBG("Slave %i...\n", slave->ring_position);

   302

   303

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

   304

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

   305

        return -1;

   306

    }

   307

   308

    while (1) {

   309

        // read category header

   310

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

   311

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

   312

            kfree(cat_data);

   313

            return -1;

   314

        }

   315

   316

        // Last category?

   317

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

   318

   319

        header = value & 0x7FFF;

   320

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

   321

   322

        // Fetch category data

   323

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

   324

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

   325

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

   326

                kfree(cat_data);

   327

                return -1;

   328

            }

   329

   330

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

   331

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

   332

   333

            // read second word "on the fly"

   334

            if (i + 1 < word_count) {

   335

                i++;

   336

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

   337

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

   338

            }

   339

        }

   340

   341

        switch (header)

   342

        {

   343

            case 0x000A:

   344

                if (ec_slave_fetch_strings(slave, cat_data)) {

   345

                    kfree(cat_data);

   346

                    return -1;

   347

                }

   348

                break;

   349

            case 0x001E:

   350

            case 0x0001:

   351

                ec_slave_fetch_general(slave, cat_data);

   352

                break;

   353

            case 0x0028:

   354

            case 0x0002:

   355

                ec_slave_fetch_fmmu(slave, cat_data);

   356

                break;

   357

            case 0x0029:

   358

            case 0x0003:

   359

                ec_slave_fetch_sync(slave, cat_data);

   360

                break;

   361

            case 0x0032:

   362

            case 0x0004:

   363

                ec_slave_fetch_txpdo(slave, cat_data);

   364

                break;

   365

            case 0x0033:

   366

            case 0x0005:

   367

                ec_slave_fetch_rxpdo(slave, cat_data);

   368

                break;

   369

            default:

   370

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

   371

                        header, slave->ring_position);

   372

        }

   373

   374

        word_offset += 2 + word_count;

   375

    }

   376

   377

    kfree(cat_data);

   378

    return 0;

   379

}

   380

   381

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

   382

   383

/**

   384

   Holt die Daten einer String-Kategorie.

   385

   386

   \return 0 wenn alles ok, sonst < 0

   387

*/

   388

   389

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

   390

                           const uint8_t *data /**< Kategoriedaten */

   391

                           )

   392

{

   393

    unsigned int string_count, i;

   394

    size_t size;

   395

    off_t offset;

   396

    ec_slave_string_t *string;

   397

   398

    string_count = data[0];

   399

    offset = 1;

   400

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

   401

        size = data[offset];

   402

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

   403

        if (!(string = (ec_slave_string_t *) kmalloc(sizeof(ec_slave_string_t)

   404

                                                     + size + 1,

   405

                                                     GFP_KERNEL))) {

   406

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

   407

            return -1;

   408

        }

   409

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

   410

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

   411

        string->data[size] = 0x00;

   412

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

   413

        offset += 1 + size;

   414

    }

   415

   416

    return 0;

   417

}

   418

   419

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

   420

   421

/**

   422

   Holt die Daten einer General-Kategorie.

   423

*/

   424

   425

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

   426

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

   427

                            )

   428

{

   429

}

   430

   431

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

   432

   433

/**

   434

   Holt die Daten einer FMMU-Kategorie.

   435

*/

   436

   437

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

   438

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

   439

                         )

   440

{

   441

}

   442

   443

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

   444

   445

/**

   446

   Holt die Daten einer Sync-Manager-Kategorie.

   447

*/

   448

   449

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

   450

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

   451

                         )

   452

{

   453

}

   454

   455

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

   456

   457

/**

   458

   Holt die Daten einer TXPDO-Kategorie.

   459

*/

   460

   461

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

   462

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

   463

                          )

   464

{

   465

}

   466

   467

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

   468

   469

/**

   470

   Holt die Daten einer RXPDO-Kategorie.

   471

*/

   472

   473

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

   474

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

   475

                          )

   476

{

   477

}

   478

   479

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

   480

   481

/**

   482

   Bestätigt einen Fehler beim Zustandswechsel.

   483

   484

   \todo Funktioniert noch nicht...

   485

*/

   486

   487

void ec_slave_state_ack(ec_slave_t *slave,

   488

                        /**< Slave, dessen Zustand geändert werden soll */

   489

                        uint8_t state

   490

                        /**< Alter Zustand */

   491

                        )

   492

{