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

ssize_t ec_show_slave_attribute(struct kobject *, struct attribute *, char *);

    28

    29

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

    30

    31

EC_SYSFS_READ_ATTR(ring_position);

    32

EC_SYSFS_READ_ATTR(coupler_address);

    33

EC_SYSFS_READ_ATTR(vendor_name);

    34

EC_SYSFS_READ_ATTR(product_name);

    35

EC_SYSFS_READ_ATTR(product_desc);

    36

EC_SYSFS_READ_ATTR(type);

    37

    38

static struct attribute *def_attrs[] = {

    39

    &attr_ring_position,

    40

    &attr_coupler_address,

    41

    &attr_vendor_name,

    42

    &attr_product_name,

    43

    &attr_product_desc,

    44

    &attr_type,

    45

    NULL,

    46

};

    47

    48

static struct sysfs_ops sysfs_ops = {

    49

    .show = &ec_show_slave_attribute,

    50

    .store = NULL

    51

};

    52

    53

static struct kobj_type ktype_ec_slave = {

    54

    .release = ec_slave_clear,

    55

    .sysfs_ops = &sysfs_ops,

    56

    .default_attrs = def_attrs

    57

};

    58

    59

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

    60

    61

const ec_code_msg_t al_status_messages[];

    62

    63

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

    64

    65

/**

    66

   EtherCAT-Slave-Konstruktor.

    67

*/

    68

    69

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

    70

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

    71

                  uint16_t ring_position, /**< Ringposition */

    72

                  uint16_t station_address /**< Programmierte Adresse */

    73

                  )

    74

{

    75

    unsigned int i;

    76

    77

    slave->ring_position = ring_position;

    78

    slave->station_address = station_address;

    79

    80

    // Init kobject and add it to the hierarchy

    81

    memset(&slave->kobj, 0x00, sizeof(struct kobject));

    82

    kobject_init(&slave->kobj);

    83

    slave->kobj.ktype = &ktype_ec_slave;

    84

    slave->kobj.parent = &master->kobj;

    85

    if (kobject_set_name(&slave->kobj, "slave%03i", slave->ring_position)) {

    86

        EC_ERR("Failed to set kobject name.\n");

    87

        kobject_put(&slave->kobj);

    88

        return -1;

    89

    }

    90

    91

    slave->master = master;

    92

    slave->coupler_index = 0;

    93

    slave->coupler_subindex = 0xFFFF;

    94

    slave->base_type = 0;

    95

    slave->base_revision = 0;

    96

    slave->base_build = 0;

    97

    slave->base_fmmu_count = 0;

    98

    slave->base_sync_count = 0;

    99

    slave->sii_alias = 0;

   100

    slave->sii_vendor_id = 0;

   101

    slave->sii_product_code = 0;

   102

    slave->sii_revision_number = 0;

   103

    slave->sii_serial_number = 0;

   104

    slave->sii_rx_mailbox_offset = 0;

   105

    slave->sii_rx_mailbox_size = 0;

   106

    slave->sii_tx_mailbox_offset = 0;

   107

    slave->sii_tx_mailbox_size = 0;

   108

    slave->sii_mailbox_protocols = 0;

   109

    slave->type = NULL;

   110

    slave->registered = 0;

   111

    slave->fmmu_count = 0;

   112

    slave->eeprom_name = NULL;

   113

    slave->eeprom_group = NULL;

   114

    slave->eeprom_desc = NULL;

   115

   116

    ec_command_init(&slave->mbox_command);

   117

   118

    INIT_LIST_HEAD(&slave->eeprom_strings);

   119

    INIT_LIST_HEAD(&slave->eeprom_syncs);

   120

    INIT_LIST_HEAD(&slave->eeprom_pdos);

   121

    INIT_LIST_HEAD(&slave->sdo_dictionary);

   122

   123

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

   124

        slave->dl_link[i] = 0;

   125

        slave->dl_loop[i] = 0;

   126

        slave->dl_signal[i] = 0;

   127

        slave->sii_physical_layer[i] = 0xFF;

   128

    }

   129

   130

    return 0;

   131

}

   132

   133

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

   134

   135

/**

   136

   EtherCAT-Slave-Destruktor.

   137

*/

   138

   139

void ec_slave_clear(struct kobject *kobj /**< KObject des Slaves */)

   140

{

   141

    ec_slave_t *slave;

   142

    ec_eeprom_string_t *string, *next_str;

   143

    ec_eeprom_sync_t *sync, *next_sync;

   144

    ec_eeprom_pdo_t *pdo, *next_pdo;

   145

    ec_eeprom_pdo_entry_t *entry, *next_ent;

   146

    ec_sdo_t *sdo, *next_sdo;

   147

    ec_sdo_entry_t *en, *next_en;

   148

   149

    slave = container_of(kobj, ec_slave_t, kobj);

   150

   151

    // Alle Strings freigeben

   152

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

   153

        list_del(&string->list);

   154

        kfree(string);

   155

    }

   156

   157

    // Alle Sync-Manager freigeben

   158

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

   159

        list_del(&sync->list);

   160

        kfree(sync);

   161

    }

   162

   163

    // Alle PDOs freigeben

   164

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

   165

        list_del(&pdo->list);

   166

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

   167

   168

        // Alle Entries innerhalb eines PDOs freigeben

   169

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

   170

            list_del(&entry->list);

   171

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

   172

            kfree(entry);

   173

        }

   174

   175

        kfree(pdo);

   176

    }

   177

   178

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

   179

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

   180

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

   181

   182

    // Alle SDOs freigeben

   183

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

   184

        list_del(&sdo->list);

   185

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

   186

   187

        // Alle Entries freigeben

   188

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

   189

            list_del(&en->list);

   190

            kfree(en);

   191

        }

   192

        kfree(sdo);

   193

    }

   194

   195

    ec_command_clear(&slave->mbox_command);

   196

}

   197

   198

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

   199

   200

/**

   201

   Liest alle benötigten Informationen aus einem Slave.

   202

   203

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

   204

*/

   205

   206

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

   207

{

   208

    ec_command_t *command;

   209

    unsigned int i;

   210

    uint16_t dl_status;

   211

   212

    command = &slave->master->simple_command;

   213

   214

    // Read base data

   215

    if (ec_command_nprd(command, slave->station_address, 0x0000, 6)) return -1;

   216

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

   217

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

   218

               slave->ring_position);

   219

        return -1;

   220

    }

   221

   222

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

   223

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

   224

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

   225

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

   226

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

   227

   228

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

   229

        slave->base_fmmu_count = EC_MAX_FMMUS;

   230

   231

    // Read DL status

   232

    if (ec_command_nprd(command, slave->station_address, 0x0110, 2)) return -1;

   233

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

   234

        EC_ERR("Reading DL status from slave %i failed!\n",

   235

               slave->ring_position);

   236

        return -1;

   237

    }

   238

   239

    dl_status = EC_READ_U16(command->data);

   240

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

   241

        slave->dl_link[i] = dl_status & (1 << (4 + i)) ? 1 : 0;

   242

        slave->dl_loop[i] = dl_status & (1 << (8 + i * 2)) ? 1 : 0;

   243

        slave->dl_signal[i] = dl_status & (1 << (9 + i * 2)) ? 1 : 0;

   244

    }

   245

   246

    // Read EEPROM data

   247

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

   248

        return -1;

   249

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

   250

        return -1;

   251

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

   252

        return -1;

   253

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

   254

        return -1;

   255

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

   256

        return -1;

   257

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

   258

        return -1;

   259

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

   260

        return -1;

   261

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

   262

        return -1;

   263

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

   264

        return -1;

   265

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

   266

        return -1;

   267

   268

    if (unlikely(ec_slave_fetch_categories(slave))) {

   269

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

   270

        return -1;

   271

    }

   272

   273

    return 0;

   274

}

   275

   276

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

   277

   278

/**

   279

   Liest 16 Bit aus dem Slave-Information-Interface

   280

   eines EtherCAT-Slaves.

   281

   282

   \return 0 bei Erfolg, sonst < 0

   283

*/

   284

   285

int ec_slave_sii_read16(ec_slave_t *slave,

   286

                        /**< EtherCAT-Slave */

   287

                        uint16_t offset,

   288

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

   289

                        uint16_t *target

   290

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

   291

                        )

   292

{

   293

    ec_command_t *command;

   294

    cycles_t start, end, timeout;

   295

   296

    command = &slave->master->simple_command;

   297

   298

    // Initiate read operation

   299

    if (ec_command_npwr(command, slave->station_address, 0x502, 6)) return -1;

   300

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

   301

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

   302

    EC_WRITE_U32(command->data + 2, offset);

   303

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

   304

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

   305

        return -1;

   306

    }

   307

   308

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

   309

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

   310

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

   311

   312

    start = get_cycles();

   313

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

   314

   315

    while (1)

   316

    {

   317

        udelay(10);

   318

   319

        if (ec_command_nprd(command, slave->station_address, 0x502, 10))

   320

            return -1;

   321

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

   322

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

   323

                   slave->ring_position);

   324

            return -1;

   325

        }

   326

   327

        end = get_cycles();

   328

   329

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

   330

            *target = EC_READ_U16(command->data + 6);

   331

            return 0;

   332

        }

   333

   334

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

   335

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

   336

            return -1;

   337

        }

   338

    }

   339

}

   340

   341

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

   342

   343

/**

   344

   Liest 32 Bit aus dem Slave-Information-Interface

   345

   eines EtherCAT-Slaves.

   346

   347

   \return 0 bei Erfolg, sonst < 0

   348

*/

   349

   350

int ec_slave_sii_read32(ec_slave_t *slave,

   351

                        /**< EtherCAT-Slave */

   352

                        uint16_t offset,

   353

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

   354

                        uint32_t *target

   355

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

   356

                        )

   357

{

   358

    ec_command_t *command;

   359

    cycles_t start, end, timeout;

   360

   361

    command = &slave->master->simple_command;

   362

   363

    // Initiate read operation

   364

    if (ec_command_npwr(command, slave->station_address, 0x502, 6)) return -1;

   365

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

   366

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

   367

    EC_WRITE_U32(command->data + 2, offset);

   368

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

   369

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

   370

        return -1;

   371

    }

   372

   373

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

   374

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

   375

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

   376

   377

    start = get_cycles();

   378

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

   379

   380

    while (1)

   381

    {

   382

        udelay(10);

   383

   384

        if (ec_command_nprd(command, slave->station_address, 0x502, 10))

   385

            return -1;

   386

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

   387

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

   388

                   slave->ring_position);

   389

            return -1;

   390

        }

   391

   392

        end = get_cycles();

   393

   394

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

   395

            *target = EC_READ_U32(command->data + 6);

   396

            return 0;

   397

        }

   398

   399

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

   400

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

   401

            return -1;

   402

        }

   403

    }

   404

}

   405

   406

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

   407

   408

/**

   409

   Schreibt 16 Bit Daten in das Slave-Information-Interface

   410

   eines EtherCAT-Slaves.

   411

   412

   \return 0 bei Erfolg, sonst < 0

   413

*/

   414

   415

int ec_slave_sii_write16(ec_slave_t *slave,

   416

                         /**< EtherCAT-Slave */

   417

                         uint16_t offset,

   418

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

   419

                         uint16_t value

   420

                         /**< Zu schreibender Wert */

   421

                         )

   422

{

   423

    ec_command_t *command;

   424

    cycles_t start, end, timeout;

   425

   426

    command = &slave->master->simple_command;

   427

   428

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

   429

            slave->ring_position, offset, value);

   430

   431

    // Initiate write operation

   432

    if (ec_command_npwr(command, slave->station_address, 0x502, 8)) return -1;

   433

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

   434

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

   435

    EC_WRITE_U32(command->data + 2, offset);

   436

    EC_WRITE_U16(command->data + 6, value);

   437

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

   438

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

   439

        return -1;

   440

    }

   441

   442

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

   443

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

   444

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

   445

   446

    start = get_cycles();

   447

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

   448

   449

    while (1)

   450

    {

   451

        udelay(10);

   452

   453

        if (ec_command_nprd(command, slave->station_address, 0x502, 2))

   454

            return -1;

   455

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

   456

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

   457

                   slave->ring_position);

   458

            return -1;

   459

        }

   460

   461

        end = get_cycles();

   462

   463

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

   464

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

   465

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

   466

                return -1;

   467

            }

   468

            else {

   469

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

   470

                return 0;

   471

            }

   472

        }

   473

   474

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

   475

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

   476

            return -1;

   477

        }

   478

    }

   479

}

   480

   481

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

   482

   483

/**

   484

   Holt Daten aus dem EEPROM.

   485

   486

   \return 0, wenn alles ok, sonst < 0

   487