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

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

int ec_slave_locate_string(ec_slave_t *, unsigned int, char **);

    29

    30

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

    31

    32

/**

    33

   EtherCAT-Slave-Konstruktor.

    34

*/

    35

    36

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

    37

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

    38

                   )

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

    54

    slave->registered = 0;

    55

    slave->fmmu_count = 0;

    56

    57

    INIT_LIST_HEAD(&slave->eeprom_strings);

    58

    slave->eeprom_name = NULL;

    59

    slave->eeprom_group = NULL;

    60

    slave->eeprom_desc = NULL;

    61

}

    62

    63

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

    64

    65

/**

    66

   EtherCAT-Slave-Destruktor.

    67

*/

    68

    69

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

    70

{

    71

    ec_slave_string_t *string, *next;

    72

    73

    // Alle Strings freigeben

    74

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

    75

        list_del(&string->list);

    76

        kfree(string);

    77

    }

    78

    79

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

    80

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

    81

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

    82

}

    83

    84

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

    85

    86

/**

    87

   Liest alle benötigten Informationen aus einem Slave.

    88

    89

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

    90

*/

    91

    92

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

    93

{

    94

    ec_command_t command;

    95

    96

    // Read base data

    97

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

    98

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

    99

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

   100

               slave->ring_position);

   101

        return -1;

   102

    }

   103

   104

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

   105

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

   106

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

   107

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

   108

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

   109

   110

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   111

        slave->base_fmmu_count = EC_MAX_FMMUS;

   112

   113

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

   114

   115

    if (unlikely(ec_slave_sii_read(slave, 0x0004,

   116

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

   117

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

   118

        return -1;

   119

    }

   120

   121

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

   122

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

   123

        return -1;

   124

    }

   125

   126

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

   127

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

   128

        return -1;

   129

    }

   130

   131

    if (unlikely(ec_slave_sii_read(slave, 0x000C,

   132

                                   &slave->sii_revision_number))) {

   133

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

   134

        return -1;

   135

    }

   136

   137

    if (unlikely(ec_slave_sii_read(slave, 0x000E,

   138

                                   &slave->sii_serial_number))) {

   139

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

   140

        return -1;

   141

    }

   142

   143

    if (unlikely(ec_slave_fetch_categories(slave))) {

   144

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

   145

        return -1;

   146

    }

   147

   148

    return 0;

   149

}

   150

   151

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

   152

   153

/**

   154

   Liest Daten aus dem Slave-Information-Interface

   155

   eines EtherCAT-Slaves.

   156

   157

   \return 0 bei Erfolg, sonst < 0

   158

*/

   159

   160

int ec_slave_sii_read(ec_slave_t *slave,

   161

                      /**< EtherCAT-Slave */

   162

                      uint16_t offset,

   163

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

   164

                      uint32_t *target

   166

                         der Daten */

   167

                      )

   168

{

   169

    ec_command_t command;

   170

    uint8_t data[10];

   171

    cycles_t start, end, timeout;

   172

   173

    // Initiate read operation

   174

   175

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

   176

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

   177

    EC_WRITE_U32(data + 2, offset);

   178

   179

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

   180

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

   181

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

   182

        return -1;

   183

    }

   184

   185

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

   186

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

   187

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

   188

   189

    start = get_cycles();

   190

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

   191

   192

    while (1)

   193

    {

   194

        udelay(10);

   195

   196

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

   197

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

   198

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

   199

                   slave->ring_position);

   200

            return -1;

   201

        }

   202

   203

        end = get_cycles();

   204

   205

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

   206

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

   207

            return 0;

   208

        }

   209

   210

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

   211

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

   212

            return -1;

   213

        }

   214

    }

   215

}

   216

   217

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

   218

   219

/**

   220

   Schreibt Daten in das Slave-Information-Interface

   221

   eines EtherCAT-Slaves.

   222

   223

   \return 0 bei Erfolg, sonst < 0

   224

*/

   225

   226

int ec_slave_sii_write(ec_slave_t *slave,

   227

                       /**< EtherCAT-Slave */

   228

                       uint16_t offset,

   229

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

   230

                       uint16_t value

   231

                       /**< Zu schreibender Wert */

   232

                       )

   233

{

   234

    ec_command_t command;

   235

    uint8_t data[8];

   236

    cycles_t start, end, timeout;

   237

   238

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

   239

            slave->ring_position, offset, value);

   240

   241

    // Initiate write operation

   242

   243

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

   244

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

   245

    EC_WRITE_U32(data + 2, offset);

   246

    EC_WRITE_U16(data + 6, value);

   247

   248

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

   249

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

   250

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

   251

        return -1;

   252

    }

   253

   254

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

   255

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

   256

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

   257

   258

    start = get_cycles();

   259

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

   260

   261

    while (1)

   262

    {

   263

        udelay(10);

   264

   265

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

   266

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

   267

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

   268

                   slave->ring_position);

   269

            return -1;

   270

        }

   271

   272

        end = get_cycles();

   273

   274

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

   275

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

   276

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

   277

                return -1;

   278

            }

   279

            else {

   280

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

   281

                return 0;

   282

            }

   283

        }

   284

   285

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

   286

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

   287

            return -1;

   288

        }

   289

    }

   290

}

   291

   292

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

   293

   294

/**

   295

   Holt Daten aus dem EEPROM.

   296

   297

   \return 0, wenn alles ok, sonst < 0

   298

*/

   299

   300

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

   301

{

   302

    uint16_t word_offset, header, word_count;

   303

    uint32_t value;

   304

    uint8_t *cat_data;

   305

    unsigned int i;

   306

   307

    word_offset = 0x0040;

   308

   309

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

   310

   311

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

   312

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

   313

        return -1;

   314

    }

   315

   316

    while (1) {

   317

        // read category header

   318

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

   319

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

   320

            goto out_free;

   321

        }

   322

   323

        // Last category?

   324

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

   325

   326

        header = value & 0x7FFF;

   327

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

   328

   329

        // Fetch category data

   330

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

   331

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

   332

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

   333

                goto out_free;

   334

            }

   335

   336

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

   337

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

   338

   339

            // read second word "on the fly"

   340

            if (i + 1 < word_count) {

   341

                i++;

   342

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

   343

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

   344

            }

   345

        }

   346

   347

        switch (header)

   348

        {

   349

            case 0x000A:

   350

                if (ec_slave_fetch_strings(slave, cat_data))

   351

                    goto out_free;

   352

                break;

   353

            case 0x001E:

   354

            case 0x0001:

   355

                if (ec_slave_fetch_general(slave, cat_data))

   356

                    goto out_free;

   357

                break;

   358

            case 0x0028:

   359

            case 0x0002:

   360

                ec_slave_fetch_fmmu(slave, cat_data);

   361

                break;

   362

            case 0x0029:

   363

            case 0x0003:

   364

                ec_slave_fetch_sync(slave, cat_data);

   365

                break;

   366

            case 0x0032:

   367

            case 0x0004:

   368

                ec_slave_fetch_txpdo(slave, cat_data);

   369

                break;

   370

            case 0x0033:

   371

            case 0x0005:

   372

                ec_slave_fetch_rxpdo(slave, cat_data);

   373

                break;

   374

            default:

   375

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

   376

                        header, slave->ring_position);

   377

        }

   378

   379

        word_offset += 2 + word_count;

   380

    }

   381

   382

    kfree(cat_data);

   383

    return 0;

   384

   385

 out_free:

   386

    kfree(cat_data);

   387

    return -1;

   388

}

   389

   390

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

   391

   392

/**

   393

   Holt die Daten einer String-Kategorie.

   394

   395

   \return 0 wenn alles ok, sonst < 0

   396

*/

   397

   398

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

   399

                           const uint8_t *data /**< Kategoriedaten */

   400

                           )

   401

{

   402

    unsigned int string_count, i;

   403

    size_t size;

   404

    off_t offset;

   405

    ec_slave_string_t *string;

   406

   407

    string_count = data[0];

   408

    offset = 1;

   409

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

   410

        size = data[offset];

   411

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

   412

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

   413

                                                     + size + 1,

   414

                                                     GFP_KERNEL))) {

   415

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

   416

            return -1;

   417

        }

   418

        string->size = size;

   419

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

   420

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

   421

        string->data[size] = 0x00;

   422

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

   423

        offset += 1 + size;

   424

    }

   425

   426

    return 0;

   427

}

   428

   429

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

   430

   431

/**

   432

   Holt die Daten einer General-Kategorie.

   433

*/

   434

   435

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

   436

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

   437

                           )

   438

{

   439

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

   440

        return -1;

   441

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

   442

        return -1;

   443

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

   444

        return -1;

   445

   446

    return 0;

   447

}

   448

   449

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

   450

   451

/**

   452

   Holt die Daten einer FMMU-Kategorie.

   453

*/

   454

   455

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

   456

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

   457

                         )

   458

{

   459

}

   460

   461

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

   462

   463

/**

   464

   Holt die Daten einer Sync-Manager-Kategorie.

   465

*/

   466

   467

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

   468

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

   469

                         )

   470

{

   471

}

   472

   473

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

   474

   475

/**

   476

   Holt die Daten einer TXPDO-Kategorie.

   477

*/

   478

   479

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

   480

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

   481

                          )

   482

{

   483

}

   484

   485

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

   486

   487

/**

   488

   Holt die Daten einer RXPDO-Kategorie.

   489

*/

   490