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 "../include/EtherCAT_si.h"

    15

#include "globals.h"

    16

#include "slave.h"

    17

#include "frame.h"

    18

    19

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

    20

    21

/**

    22

   EtherCAT-Slave-Konstruktor.

    23

*/

    24

    25

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

    26

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

    27

                   )

    28

{

    29

    slave->master = master;

    30

    slave->base_type = 0;

    31

    slave->base_revision = 0;

    32

    slave->base_build = 0;

    33

    slave->base_fmmu_count = 0;

    34

    slave->base_sync_count = 0;

    35

    slave->ring_position = 0;

    36

    slave->station_address = 0;

    37

    slave->sii_vendor_id = 0;

    38

    slave->sii_product_code = 0;

    39

    slave->sii_revision_number = 0;

    40

    slave->sii_serial_number = 0;

    41

    slave->type = NULL;

    42

    slave->registered = 0;

    43

    slave->fmmu_count = 0;

    44

}

    45

    46

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

    47

    48

/**

    49

   EtherCAT-Slave-Destruktor.

    50

*/

    51

    52

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

    53

{

    54

    // Nichts freizugeben

    55

}

    56

    57

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

    58

    59

/**

    60

   Liest alle benötigten Informationen aus einem Slave.

    61

*/

    62

    63

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

    64

{

    65

    ec_frame_t frame;

    66

    67

    // Read base data

    68

    ec_frame_init_nprd(&frame, slave->master, slave->station_address,

    69

                       0x0000, 6);

    70

    71

    if (unlikely(ec_frame_send_receive(&frame))) return -1;

    72

    73

    if (unlikely(frame.working_counter != 1)) {

    74

        EC_ERR("Slave %i did not respond while reading base data!\n",

    75

               slave->ring_position);

    76

        return -1;

    77

    }

    78

    79

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

    80

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

    81

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

    82

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

    83

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

    84

    85

    if (slave->base_fmmu_count > EC_MAX_FMMUS)

    86

        slave->base_fmmu_count = EC_MAX_FMMUS;

    87

    88

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

    89

    90

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

    91

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

    92

        return -1;

    93

    }

    94

    95

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

    96

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

    97

        return -1;

    98

    }

    99

   100

    if (unlikely(ec_slave_sii_read(slave, 0x000C,

   101

                                   &slave->sii_revision_number))) {

   102

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

   103

        return -1;

   104

    }

   105

   106

    if (unlikely(ec_slave_sii_read(slave, 0x000E,

   107

                                   &slave->sii_serial_number))) {

   108

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

   109

        return -1;

   110

    }

   111

   112

    return 0;

   113

}

   114

   115

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

   116

   117

/**

   118

   Liest Daten aus dem Slave-Information-Interface

   119

   eines EtherCAT-Slaves.

   120

   121

   \return 0 bei Erfolg, sonst < 0

   122

*/

   123

   124

int ec_slave_sii_read(ec_slave_t *slave,

   125

                      /**< EtherCAT-Slave */

   126

                      unsigned short int offset,

   127

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

   128

                      unsigned int *target

   129

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

   130

                         der Daten */

   131

                      )

   132

{

   133

    ec_frame_t frame;

   134

    unsigned char data[10];

   135

    unsigned int tries_left;

   136

   137

    // Initiate read operation

   138

   139

    EC_WRITE_U8 (data,     0x00);

   140

    EC_WRITE_U8 (data + 1, 0x01);

   141

    EC_WRITE_U16(data + 2, offset);

   142

    EC_WRITE_U16(data + 4, 0x0000);

   143

   144

    ec_frame_init_npwr(&frame, slave->master, slave->station_address, 0x502, 6,

   145

                       data);

   146

   147

    if (unlikely(ec_frame_send_receive(&frame))) return -1;

   148

   149

    if (unlikely(frame.working_counter != 1)) {

   150

        EC_ERR("SII-read - Slave %i did not respond!\n", slave->ring_position);

   151

        return -1;

   152

    }

   153

   154

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

   155

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

   156

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

   157

   158

    tries_left = 100;

   159

    while (likely(tries_left))

   160

    {

   161

        udelay(10);

   162

   163

        ec_frame_init_nprd(&frame, slave->master, slave->station_address, 0x502,

   164

                           10);

   165

   166

        if (unlikely(ec_frame_send_receive(&frame))) return -1;

   167

   168

        if (unlikely(frame.working_counter != 1)) {

   169

            EC_ERR("SII-read status - Slave %i did not respond!\n",

   170

                   slave->ring_position);

   171

            return -1;

   172

        }

   173

   174

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

   175

            memcpy(target, frame.data + 6, 4);

   176

            break;

   177

        }

   178

   179

        tries_left--;

   180

    }

   181

   182

    if (unlikely(!tries_left)) {

   183

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

   184

        return -1;

   185

    }

   186

   187

    return 0;

   188

}

   189

   190

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

   191

   192

/**

   193

   Bestätigt einen Fehler beim Zustandswechsel.

   194

   195

   FIXME Funktioniert noch nicht...

   196

*/

   197

   198

void ec_slave_state_ack(ec_slave_t *slave,

   199

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

   200

                        uint8_t state

   201

                        /**< Alter Zustand */

   202

                        )

   203

{

   204

    ec_frame_t frame;

   205

    unsigned char data[2];

   206

    unsigned int tries_left;

   207

   208

    EC_WRITE_U16(data, state | EC_ACK);

   209

   210

    ec_frame_init_npwr(&frame, slave->master, slave->station_address, 0x0120,

   211

                       2, data);

   212

   213

    if (unlikely(ec_frame_send_receive(&frame) != 0)) {

   214

        EC_WARN("Could no acknowledge state %02X - Unable to send!\n", state);

   215

        return;

   216

    }

   217

   218

    if (unlikely(frame.working_counter != 1)) {

   219

        EC_WARN("Could not acknowledge state %02X - Slave %i did not"

   220

                " respond!\n", state, slave->ring_position);

   221

        return;

   222

    }

   223

   224

    tries_left = 100;

   225

    while (likely(tries_left))

   226

    {

   227

        udelay(10);

   228

   229

        ec_frame_init_nprd(&frame, slave->master, slave->station_address,

   230

                           0x0130, 2);

   231

   232

        if (unlikely(ec_frame_send_receive(&frame) != 0)) {

   233

            EC_WARN("Could not check state acknowledgement %02X - Unable to"

   234

                    " send!\n", state);

   235

            return;

   236

        }

   237

   238

        if (unlikely(frame.working_counter != 1)) {

   239

            EC_WARN("Could not check state acknowledgement %02X - Slave %i did"

   240

                    " not respond!\n", state, slave->ring_position);

   241

            return;

   242

        }

   243

   244

        if (unlikely(EC_READ_U8(frame.data) != state)) {

   245

            EC_WARN("Could not acknowledge state %02X on slave %i (code"

   246

                    " %02X)!\n", state, slave->ring_position,

   247

                    EC_READ_U8(frame.data));

   248

            return;

   249

        }

   250

   251

        if (likely(EC_READ_U8(frame.data) == state)) {

   252

            EC_INFO("Acknowleged state %02X on slave %i.\n", state,

   253

                    slave->ring_position);

   254

            return;

   255

        }

   256

   257

        tries_left--;

   258

    }

   259

   260

    if (unlikely(!tries_left)) {

   261

        EC_WARN("Could not check state acknowledgement %02X of slave %i -"

   262

                " Timeout while checking!\n", state, slave->ring_position);

   263

        return;

   264

    }

   265

}

   266

   267

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

   268

   269

/**

   270

   Ändert den Zustand eines Slaves.

   271

   272

   \return 0 bei Erfolg, sonst < 0

   273

*/

   274

   275

int ec_slave_state_change(ec_slave_t *slave,

   276

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

   277

                          uint8_t state

   278

                          /**< Neuer Zustand */

   279

                          )

   280

{

   281

    ec_frame_t frame;

   282

    unsigned char data[2];

   283

    unsigned int tries_left;

   284

   285

    EC_WRITE_U16(data, state);

   286

   287

    ec_frame_init_npwr(&frame, slave->master, slave->station_address, 0x0120,

   288

                       2, data);

   289

   290

    if (unlikely(ec_frame_send_receive(&frame) != 0)) {

   291

        EC_ERR("Could not set state %02X - Unable to send!\n", state);

   292

        return -1;

   293

    }

   294

   295

    if (unlikely(frame.working_counter != 1)) {

   296

        EC_ERR("Could not set state %02X - Slave %i did not respond!\n", state,

   297

               slave->ring_position);

   298

        return -1;

   299

    }

   300

   301

    tries_left = 100;

   302

    while (likely(tries_left))

   303

    {

   304

        udelay(10);

   305

   306

        ec_frame_init_nprd(&frame, slave->master, slave->station_address,

   307

                           0x0130, 2);

   308

   309

        if (unlikely(ec_frame_send_receive(&frame) != 0)) {

   310

            EC_ERR("Could not check state %02X - Unable to send!\n", state);

   311

            return -1;

   312

        }

   313

   314

        if (unlikely(frame.working_counter != 1)) {

   315

            EC_ERR("Could not check state %02X - Slave %i did not respond!\n",

   316

                   state, slave->ring_position);

   317

            return -1;

   318

        }

   319

   320

        if (unlikely(EC_READ_U8(frame.data) & 0x10)) { // State change error

   321

            EC_ERR("Could not set state %02X - Slave %i refused state change"

   322

                   " (code %02X)!\n", state, slave->ring_position,

   323

                   EC_READ_U8(frame.data));

   324

            ec_slave_state_ack(slave, EC_READ_U8(frame.data) & 0x0F);

   325

            return -1;

   326

        }

   327

   328

        if (likely(EC_READ_U8(frame.data) == (state & 0x0F))) {

   329

            // State change successful

   330

            break;

   331

        }

   332

   333

        tries_left--;

   334

    }

   335

   336

    if (unlikely(!tries_left)) {

   337

        EC_ERR("Could not check state %02X of slave %i - Timeout!\n", state,

   338

               slave->ring_position);

   339

        return -1;

   340

    }

   341

   342

    return 0;

   343

}

   344

   345

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

   346

   347

/**

   348

   Merkt eine FMMU-Konfiguration vor.

   349

   350

   Die FMMU wird so konfiguriert, dass sie den gesamten Datenbereich des

   351

   entsprechenden Sync-Managers abdeckt. Für jede Domäne werden separate

   352

   FMMUs konfiguriert.

   353

   354

   Wenn die entsprechende FMMU bereits konfiguriert ist, wird dies als

   355

   Erfolg zurückgegeben.

   356

   357

   \return 0 bei Erfolg, sonst < 0

   358

*/

   359

   360

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

   361

                      const ec_domain_t *domain, /**< Domäne */

   362

                      const ec_sync_t *sync  /**< Sync-Manager */

   363

                      )

   364

{

   365

    unsigned int i;

   366

   367

    // FMMU schon vorgemerkt?

   368

    for (i = 0; i < slave->fmmu_count; i++)

   369

        if (slave->fmmus[i].domain == domain && slave->fmmus[i].sync == sync)

   370

            return 0;

   371

   372

    if (slave->fmmu_count >= slave->base_fmmu_count) {

   373

        EC_ERR("Slave %i FMMU limit reached!\n", slave->ring_position);

   374

        return -1;

   375

    }

   376

   377

    slave->fmmus[slave->fmmu_count].domain = domain;

   378

    slave->fmmus[slave->fmmu_count].sync = sync;

   379

    slave->fmmus[slave->fmmu_count].logical_start_address = 0;

   380

    slave->fmmu_count++;

   381

    slave->registered = 1;

   382

   383

    return 0;

   384

}

   385

   386

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

   387

   388

/**

   389

   Gibt alle Informationen über einen EtherCAT-Slave aus.

   390

*/

   391

   392

void ec_slave_print(const ec_slave_t *slave /**< EtherCAT-Slave */)

   393

{

   394

    EC_INFO("--- EtherCAT slave information ---\n");

   395

   396

    if (slave->type) {

   397

        EC_INFO("  Vendor \"%s\", Product \"%s\": %s\n",

   398

                slave->type->vendor_name, slave->type->product_name,

   399

                slave->type->description);

   400

    }

   401

    else {

   402

        EC_INFO("  *** This slave has no type information! ***\n");

   403

    }

   404

   405

    EC_INFO("  Ring position: %i, Station address: 0x%04X\n",

   406

            slave->ring_position, slave->station_address);

   407

   408

    EC_INFO("  Base information:\n");

   409

    EC_INFO("    Type %u, Revision %i, Build %i\n",

   410

            slave->base_type, slave->base_revision, slave->base_build);

   411

    EC_INFO("    Supported FMMUs: %i, Sync managers: %i\n",

   412

            slave->base_fmmu_count, slave->base_sync_count);

   413

   414

    EC_INFO("  Slave information interface:\n");

   415

    EC_INFO("    Vendor-ID: 0x%08X, Product code: 0x%08X\n",

   416

            slave->sii_vendor_id, slave->sii_product_code);

   417

    EC_INFO("    Revision number: 0x%08X, Serial number: 0x%08X\n",

   418

            slave->sii_revision_number, slave->sii_serial_number);

   419

}

   420

   421

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

   422

   423

/**

   424

   Gibt die Zählerstände der CRC-Fault-Counter aus und setzt diese zurück.

   425

   426

   \return 0 bei Erfolg, sonst < 0

   427

*/

   428

   429

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

   430

{

   431

    ec_frame_t frame;

   432

    uint8_t data[4];

   433

   434

    ec_frame_init_nprd(&frame, slave->master, slave->station_address, 0x0300,

   435

                       4);

   436

   437

    if (unlikely(ec_frame_send_receive(&frame))) {

   438

        EC_WARN("Reading CRC fault counters failed on slave %i - Could not"

   439

                " send command!\n", slave->ring_position);

   440

        return -1;

   441

    }

   442

   443

    if (unlikely(frame.working_counter != 1)) {

   444

        EC_WARN("Reading CRC fault counters - Slave %i did not respond!\n",

   445

                slave->ring_position);

   446

        return -1;

   447

    }

   448

   449

    // No CRC faults.

   450

    if (!EC_READ_U16(frame.data) && !EC_READ_U16(frame.data + 2)) return 0;

   451

   452

    EC_WARN("CRC faults on slave %i. A: %i, B: %i\n", slave->ring_position,

   453

            EC_READ_U16(frame.data), EC_READ_U16(frame.data + 2));

   454

   455

    // Reset CRC counters

   456

    EC_WRITE_U16(data,     0x0000);

   457

    EC_WRITE_U16(data + 2, 0x0000);

   458

    ec_frame_init_npwr(&frame, slave->master, slave->station_address, 0x0300,

   459

                       4, data);

   460

   461

    if (unlikely(ec_frame_send_receive(&frame))) return -1;

   462

   463

    if (unlikely(frame.working_counter != 1)) {

   464

        EC_WARN("Resetting CRC fault counters - Slave %i did not respond!\n",

   465

                slave->ring_position);

   466

        return -1;

   467

    }

   468

   469

    return 0;

   470

}

   471

   472

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

   473

   474

/* Emacs-Konfiguration

   475

;;; Local Variables: ***

   476

;;; c-basic-offset:4 ***

   477

;;; End: ***

   478

*/