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

    57

    slave->eeprom_name = NULL;

    58

    slave->eeprom_group = NULL;

    59

    slave->eeprom_desc = NULL;

    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_slave_string_t *string, *next;

    71

    72

    // Alle Strings freigeben

    73

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

    74

        list_del(&string->list);

    75

        kfree(string);

    76

    }

    77

    78

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

    79

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

    80

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

    81

}

    82

    83

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

    84

    85

/**

    87

    88

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

    89

*/

    90

    91

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

    92

{

    93

    ec_command_t command;

    94

    95

    // Read base data

    96

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

    97

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

    98

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

    99

               slave->ring_position);

   100

        return -1;

   101

    }

   102

   103

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

   104

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

   105

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

   106

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

   107

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

   108

   109

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   110

        slave->base_fmmu_count = EC_MAX_FMMUS;

   111

   112

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

   113

   114

    if (unlikely(ec_slave_sii_read(slave, 0x0004,

   115

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

   116

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

   117

        return -1;

   118

    }

   119

   120

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

   121

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

   122

        return -1;

   123

    }

   124

   125

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

   126

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

   127

        return -1;

   128

    }

   129

   130

    if (unlikely(ec_slave_sii_read(slave, 0x000C,

   131

                                   &slave->sii_revision_number))) {

   132

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

   133

        return -1;

   134

    }

   135

   136

    if (unlikely(ec_slave_sii_read(slave, 0x000E,

   137

                                   &slave->sii_serial_number))) {

   138

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

   139

        return -1;

   140

    }

   141

   142

    if (unlikely(ec_slave_fetch_categories(slave))) {

   143

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

   144

        return -1;

   145

    }

   146

   147

    return 0;

   148

}

   149

   150

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

   151

   152

/**

   153

   Liest Daten aus dem Slave-Information-Interface

   154

   eines EtherCAT-Slaves.

   155

   156

   \return 0 bei Erfolg, sonst < 0

   157

*/

   158

   159

int ec_slave_sii_read(ec_slave_t *slave,

   160

                      /**< EtherCAT-Slave */

   161

                      uint16_t offset,

   162

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

   163

                      uint32_t *target

   164

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

   165

                         der Daten */

   166

                      )

   167

{

   168

    ec_command_t command;

   169

    uint8_t data[10];

   170

    cycles_t start, end, timeout;

   171

   172

    // Initiate read operation

   173

   174

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

   175

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

   176

    EC_WRITE_U32(data + 2, offset);

   177

   178

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

   179

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

   180

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

   181

        return -1;

   182

    }

   183

   184

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

   186

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

   187

   188

    start = get_cycles();

   189

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

   190

   191

    while (1)

   192

    {

   193

        udelay(10);

   194

   195

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

   196

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

   197

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

   198

                   slave->ring_position);

   199

            return -1;

   200

        }

   201

   202

        end = get_cycles();

   203

   204

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

   205

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

   206

            return 0;

   207

        }

   208

   209

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

   210

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

   211

            return -1;

   212

        }

   213

    }

   214

}

   215

   216

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

   217

   218

/**

   219

   Schreibt Daten in das Slave-Information-Interface

   220

   eines EtherCAT-Slaves.

   221

   222

   \return 0 bei Erfolg, sonst < 0

   223

*/

   224

   225

int ec_slave_sii_write(ec_slave_t *slave,

   226

                       /**< EtherCAT-Slave */

   227

                       uint16_t offset,

   228

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

   229

                       uint16_t value

   230

                       /**< Zu schreibender Wert */

   231

                       )

   232

{

   233

    ec_command_t command;

   234

    uint8_t data[8];

   235

    cycles_t start, end, timeout;

   236

   237

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

   238

            slave->ring_position, offset, value);

   239

   240

    // Initiate write operation

   241

   242

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

   243

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

   244

    EC_WRITE_U32(data + 2, offset);

   245

    EC_WRITE_U16(data + 6, value);

   246

   247

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

   248

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

   249

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

   250

        return -1;

   251

    }

   252

   253

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

   255

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

   256

   257

    start = get_cycles();

   258

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

   259

   260

    while (1)

   261

    {

   262

        udelay(10);

   263

   264

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

   265

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

   266

            EC_ERR("Getting SII-write 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) & 0x82) == 0)) {

   274

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

   275

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

   276

                return -1;

   277

            }

   278

            else {

   279

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

   280

                return 0;

   281

            }

   282

        }

   283

   284

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

   285

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

   286

            return -1;

   287

        }

   288

    }

   289

}

   290

   291

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

   292

   293

/**

   294

   Holt Daten aus dem EEPROM.

   295

   296

   \return 0, wenn alles ok, sonst < 0

   297

*/

   298

   299

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

   300

{

   301

    uint16_t word_offset, header, word_count;

   302

    uint32_t value;

   303

    uint8_t *cat_data;

   304

    unsigned int i;

   305

   306

    word_offset = 0x0040;

   307

   308

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

   309

   310

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

   311

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

   312

        return -1;

   313

    }

   314

   315

    while (1) {

   316

        // read category header

   317

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

   318

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

   319

            kfree(cat_data);

   320

            return -1;

   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

                kfree(cat_data);

   334

                return -1;

   335

            }

   336

   337

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

   338

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

   339

   340

            // read second word "on the fly"

   341

            if (i + 1 < word_count) {

   342

                i++;

   343

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

   344

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

   345

            }

   346

        }

   347

   348

        switch (header)

   349

        {

   350

            case 0x000A:

   351

                if (ec_slave_fetch_strings(slave, cat_data)) {

   352

                    kfree(cat_data);

   353

                    return -1;

   354

                }

   355

                break;

   356

            case 0x001E:

   357

            case 0x0001:

   358

                ec_slave_fetch_general(slave, cat_data);

   359

                break;

   360

            case 0x0028:

   361

            case 0x0002:

   362

                ec_slave_fetch_fmmu(slave, cat_data);

   363

                break;

   364

            case 0x0029:

   365

            case 0x0003:

   366

                ec_slave_fetch_sync(slave, cat_data);

   367

                break;

   368

            case 0x0032:

   369

            case 0x0004:

   370

                ec_slave_fetch_txpdo(slave, cat_data);

   371

                break;

   372

            case 0x0033:

   373

            case 0x0005:

   374

                ec_slave_fetch_rxpdo(slave, cat_data);

   375

                break;

   376

            default:

   377

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

   378

                        header, slave->ring_position);

   379

        }

   380

   381

        word_offset += 2 + word_count;

   382

    }

   383

   384

    kfree(cat_data);

   385

    return 0;

   386

}

   387

   388

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

   389

   390

/**

   391

   Holt die Daten einer String-Kategorie.

   392

   393

   \return 0 wenn alles ok, sonst < 0

   394

*/

   395

   396

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

   397

                           const uint8_t *data /**< Kategoriedaten */

   398

                           )

   399

{

   400

    unsigned int string_count, i;

   401

    size_t size;

   402

    off_t offset;

   403

    ec_slave_string_t *string;

   404

   405

    string_count = data[0];

   406

    offset = 1;

   407

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

   408

        size = data[offset];

   410

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

   411

                                                     + size + 1,

   412

                                                     GFP_KERNEL))) {

   413

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

   414

            return -1;

   415

        }

   416

        string->size = size;

   417

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

   418

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

   419

        string->data[size] = 0x00;

   420

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

   421

        offset += 1 + size;

   422

    }

   423

   424

    return 0;

   425

}

   426

   427

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

   428

   429

/**

   430

   Holt die Daten einer General-Kategorie.

   431

*/

   432

   433

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

   434

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

   435

                            )

   436

{

   437

}

   438

   439

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

   440

   441

/**

   442

   Holt die Daten einer FMMU-Kategorie.

   443

*/

   444

   445

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

   446

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

   447

                         )

   448

{

   449

}

   450

   451

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

   452

   453

/**

   454

   Holt die Daten einer Sync-Manager-Kategorie.

   455

*/

   456

   457

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

   458

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

   459

                         )

   460

{

   461

}

   462

   463

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

   464

   465

/**

   466

   Holt die Daten einer TXPDO-Kategorie.

   467

*/

   468

   469

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

   470

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

   471

                          )

   472

{

   473

}

   474

   475

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

   476

   477

/**

   478

   Holt die Daten einer RXPDO-Kategorie.

   479

*/

   480

   481

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

   482

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

   483

                          )

   484

{

   485

}

   486

   487

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

   488

   489

/**

   491