1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/** \file

    31

 * EtherCAT CoE state machines.

    32

 */

    33

    34

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

    35

    36

#include "globals.h"

    37

#include "master.h"

    38

#include "mailbox.h"

    39

#include "fsm_coe.h"

    40

#include "slave_config.h"

    41

    42

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

    43

    44

/** Maximum time in ms to wait for responses when reading out the dictionary.

    45

 */

    46

#define EC_FSM_COE_DICT_TIMEOUT 1000

    47

    48

/** CoE download request header size.

    49

 */

    50

#define EC_COE_DOWN_REQ_HEADER_SIZE 10

    51

    52

/** CoE download segment request header size.

    53

 */

    54

#define EC_COE_DOWN_SEG_REQ_HEADER_SIZE 3

    55

    56

/** Minimum size of download segment.

    57

 */

    58

#define EC_COE_DOWN_SEG_MIN_DATA_SIZE 7

    59

    60

/** Enable debug output for CoE retries.

    61

 */

    62

#define DEBUG_RETRIES 0

    63

    64

/** Enable warning output if transfers take too long.

    65

 */

    66

#define DEBUG_LONG 0

    67

    68

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

    69

    70

void ec_fsm_coe_dict_start(ec_fsm_coe_t *, ec_datagram_t *);

    71

void ec_fsm_coe_dict_request(ec_fsm_coe_t *, ec_datagram_t *);

    72

void ec_fsm_coe_dict_check(ec_fsm_coe_t *, ec_datagram_t *);

    73

void ec_fsm_coe_dict_response(ec_fsm_coe_t *, ec_datagram_t *);

    74

void ec_fsm_coe_dict_desc_request(ec_fsm_coe_t *, ec_datagram_t *);

    75

void ec_fsm_coe_dict_desc_check(ec_fsm_coe_t *, ec_datagram_t *);

    76

void ec_fsm_coe_dict_desc_response(ec_fsm_coe_t *, ec_datagram_t *);

    77

void ec_fsm_coe_dict_entry_request(ec_fsm_coe_t *, ec_datagram_t *);

    78

void ec_fsm_coe_dict_entry_check(ec_fsm_coe_t *, ec_datagram_t *);

    79

void ec_fsm_coe_dict_entry_response(ec_fsm_coe_t *, ec_datagram_t *);

    80

    81

void ec_fsm_coe_down_start(ec_fsm_coe_t *, ec_datagram_t *);

    82

void ec_fsm_coe_down_request(ec_fsm_coe_t *, ec_datagram_t *);

    83

void ec_fsm_coe_down_check(ec_fsm_coe_t *, ec_datagram_t *);

    84

void ec_fsm_coe_down_response(ec_fsm_coe_t *, ec_datagram_t *);

    85

void ec_fsm_coe_down_seg_check(ec_fsm_coe_t *, ec_datagram_t *);

    86

void ec_fsm_coe_down_seg_response(ec_fsm_coe_t *, ec_datagram_t *);

    87

    88

void ec_fsm_coe_up_start(ec_fsm_coe_t *, ec_datagram_t *);

    89

void ec_fsm_coe_up_request(ec_fsm_coe_t *, ec_datagram_t *);

    90

void ec_fsm_coe_up_check(ec_fsm_coe_t *, ec_datagram_t *);

    91

void ec_fsm_coe_up_response(ec_fsm_coe_t *, ec_datagram_t *);

    92

void ec_fsm_coe_up_seg_request(ec_fsm_coe_t *, ec_datagram_t *);

    93

void ec_fsm_coe_up_seg_check(ec_fsm_coe_t *, ec_datagram_t *);

    94

void ec_fsm_coe_up_seg_response(ec_fsm_coe_t *, ec_datagram_t *);

    95

    96

void ec_fsm_coe_end(ec_fsm_coe_t *, ec_datagram_t *);

    97

void ec_fsm_coe_error(ec_fsm_coe_t *, ec_datagram_t *);

    98

    99

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

   100

   101

/** SDO abort messages.

   102

 *

   103

 * The "abort SDO transfer request" supplies an abort code, which can be

   104

 * translated to clear text. This table does the mapping of the codes and

   105

 * messages.

   106

 */

   107

const ec_code_msg_t sdo_abort_messages[] = {

   108

    {0x05030000, "Toggle bit not changed"},

   109

    {0x05040000, "SDO protocol timeout"},

   110

    {0x05040001, "Client/Server command specifier not valid or unknown"},

   111

    {0x05040005, "Out of memory"},

   112

    {0x06010000, "Unsupported access to an object"},

   113

    {0x06010001, "Attempt to read a write-only object"},

   114

    {0x06010002, "Attempt to write a read-only object"},

   115

    {0x06020000, "This object does not exist in the object directory"},

   116

    {0x06040041, "The object cannot be mapped into the PDO"},

   117

    {0x06040042, "The number and length of the objects to be mapped would"

   118

     " exceed the PDO length"},

   119

    {0x06040043, "General parameter incompatibility reason"},

   120

    {0x06040047, "Gerneral internal incompatibility in device"},

   121

    {0x06060000, "Access failure due to a hardware error"},

   122

    {0x06070010, "Data type does not match, length of service parameter does"

   123

     " not match"},

   124

    {0x06070012, "Data type does not match, length of service parameter too"

   125

     " high"},

   126

    {0x06070013, "Data type does not match, length of service parameter too"

   127

     " low"},

   128

    {0x06090011, "Subindex does not exist"},

   129

    {0x06090030, "Value range of parameter exceeded"},

   130

    {0x06090031, "Value of parameter written too high"},

   131

    {0x06090032, "Value of parameter written too low"},

   132

    {0x06090036, "Maximum value is less than minimum value"},

   133

    {0x08000000, "General error"},

   134

    {0x08000020, "Data cannot be transferred or stored to the application"},

   135

    {0x08000021, "Data cannot be transferred or stored to the application"

   136

     " because of local control"},

   137

    {0x08000022, "Data cannot be transferred or stored to the application"

   138

     " because of the present device state"},

   139

    {0x08000023, "Object dictionary dynamic generation fails or no object"

   140

     " dictionary is present"},

   141

    {}

   142

};

   143

   144

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

   145

   146

/** Outputs an SDO abort message.

   147

 */

   148

void ec_canopen_abort_msg(

   149

        const ec_slave_t *slave, /**< Slave. */

   150

        uint32_t abort_code /**< Abort code to search for. */

   151

        )

   152

{

   153

    const ec_code_msg_t *abort_msg;

   154

   155

    for (abort_msg = sdo_abort_messages; abort_msg->code; abort_msg++) {

   156

        if (abort_msg->code == abort_code) {

   157

            EC_SLAVE_ERR(slave, "SDO abort message 0x%08X: \"%s\".\n",

   158

                   abort_msg->code, abort_msg->message);

   159

            return;

   160

        }

   161

    }

   162

   163

    EC_SLAVE_ERR(slave, "Unknown SDO abort code 0x%08X.\n", abort_code);

   164

}

   165

   166

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

   167

   168

/** Constructor.

   169

 */

   170

void ec_fsm_coe_init(

   171

        ec_fsm_coe_t *fsm /**< Finite state machine */

   172

        )

   173

{

   174

    fsm->state = NULL;

   175

    fsm->datagram = NULL;

   176

}

   177

   178

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

   179

   180

/** Destructor.

   181

 */

   182

void ec_fsm_coe_clear(

   183

        ec_fsm_coe_t *fsm /**< Finite state machine */

   184

        )

   185

{

   186

}

   187

   188

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

   189

   190

/** Starts reading a slaves' SDO dictionary.

   191

 */

   192

void ec_fsm_coe_dictionary(

   193

        ec_fsm_coe_t *fsm, /**< Finite state machine */

   194

        ec_slave_t *slave /**< EtherCAT slave */

   195

        )

   196

{

   197

    fsm->slave = slave;

   198

    fsm->state = ec_fsm_coe_dict_start;

   199

}

   200

   201

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

   202

   203

/** Starts to transfer an SDO to/from a slave.

   204

 */

   205

void ec_fsm_coe_transfer(

   206

        ec_fsm_coe_t *fsm, /**< State machine. */

   207

        ec_slave_t *slave, /**< EtherCAT slave. */

   208

        ec_sdo_request_t *request /**< SDO request. */

   209

        )

   210

{

   211

    fsm->slave = slave;

   212

    fsm->request = request;

   213

   214

    if (request->dir == EC_DIR_OUTPUT) {

   215

        fsm->state = ec_fsm_coe_down_start;

   216

    }

   217

    else {

   218

        fsm->state = ec_fsm_coe_up_start;

   219

    }

   220

}

   221

   222

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

   223

   224

/** Executes the current state of the state machine.

   225

 *

   226

 * \return 1 if the datagram was used, else 0.

   227

 */

   228

int ec_fsm_coe_exec(

   229

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   230

        ec_datagram_t *datagram /**< Datagram to use. */

   231

        )

   232

{

   233

    int datagram_used = 0;

   234

   235

    if (fsm->datagram &&

   236

            (fsm->datagram->state == EC_DATAGRAM_INIT ||

   237

             fsm->datagram->state == EC_DATAGRAM_QUEUED ||

   238

             fsm->datagram->state == EC_DATAGRAM_SENT)) {

   239

        // datagram not received yet

   240

        return datagram_used;

   241

    }

   242

   243

    fsm->state(fsm, datagram);

   244

   245

    datagram_used =

   246

        fsm->state != ec_fsm_coe_end && fsm->state != ec_fsm_coe_error;

   247

   248

    if (datagram_used) {

   249

        fsm->datagram = datagram;

   250

    } else {

   251

        fsm->datagram = NULL;

   252

    }

   253

   254

    return datagram_used;

   255

}

   256

   257

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

   258

   259

/** Returns, if the state machine terminated with success.

   260

 * \return non-zero if successful.

   261

 */

   262

int ec_fsm_coe_success(

   263

        const ec_fsm_coe_t *fsm /**< Finite state machine */

   264

        )

   265

{

   266

    return fsm->state == ec_fsm_coe_end;

   267

}

   268

   269

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

   270

   271

/** Check if the received data are a CoE emergency request.

   272

 *

   273

 * If the check is positive, the emergency request is output.

   274

 *

   275

 * \return The data were an emergency request.

   276

 */

   277

int ec_fsm_coe_check_emergency(

   278

        ec_fsm_coe_t *fsm, /**< Finite state machine */

   279

        const uint8_t *data, /**< CoE mailbox data. */

   280

        size_t size /**< CoE mailbox data size. */

   281

        )

   282

{

   283

    if (size < 2 || ((EC_READ_U16(data) >> 12) & 0x0F) != 0x01)

   284

        return 0;

   285

   286

    if (size < 10) {

   287

        EC_SLAVE_WARN(fsm->slave, "Received incomplete CoE Emergency"

   288

                " request:\n");

   289

        ec_print_data(data, size);

   290

        return 1;

   291

    }

   292

   293

    {

   294

        ec_slave_config_t *sc = fsm->slave->config;

   295

        if (sc) {

   296

            ec_coe_emerg_ring_push(&sc->emerg_ring, data + 2);

   297

        }

   298

    }

   299

   300

    EC_SLAVE_WARN(fsm->slave, "CoE Emergency Request received:\n"

   301

            "Error code 0x%04X, Error register 0x%02X, data:\n",

   302

            EC_READ_U16(data + 2), EC_READ_U8(data + 4));

   303

    ec_print_data(data + 5, 5);

   304

    return 1;

   305

}

   306

   307

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

   308

 *  CoE dictionary state machine

   309

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

   310

   311

/** Prepare a dictionary request.

   312

 *

   313

 * \return Zero on success, otherwise a negative error code.

   314

 */

   315

int ec_fsm_coe_prepare_dict(

   316

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   317

        ec_datagram_t *datagram /**< Datagram to use. */

   318

        )

   319

{

   320

    ec_slave_t *slave = fsm->slave;

   321

    uint8_t *data = ec_slave_mbox_prepare_send(slave, datagram, 0x03, 8);

   322

    if (IS_ERR(data)) {

   323

        return PTR_ERR(data);

   324

    }

   325

   326

    EC_WRITE_U16(data, 0x8 << 12); // SDO information

   327

    EC_WRITE_U8 (data + 2, 0x01); // Get OD List Request

   328

    EC_WRITE_U8 (data + 3, 0x00);

   329

    EC_WRITE_U16(data + 4, 0x0000);

   330

    EC_WRITE_U16(data + 6, 0x0001); // deliver all SDOs!

   331

   332

    fsm->state = ec_fsm_coe_dict_request;

   333

    return 0;

   334

}

   335

   336

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

   337

   338

/** CoE state: DICT START.

   339

 */

   340

void ec_fsm_coe_dict_start(

   341

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   342

        ec_datagram_t *datagram /**< Datagram to use. */

   343

        )

   344

{

   345

    ec_slave_t *slave = fsm->slave;

   346

   347

    if (!(slave->sii.mailbox_protocols & EC_MBOX_COE)) {

   348

        EC_SLAVE_ERR(slave, "Slave does not support CoE!\n");

   349

        fsm->state = ec_fsm_coe_error;

   350

        return;

   351

    }

   352

   353

    if (slave->sii.has_general && !slave->sii.coe_details.enable_sdo_info) {

   354

        EC_SLAVE_ERR(slave, "Slave does not support"

   355

                " SDO information service!\n");

   356

        fsm->state = ec_fsm_coe_error;

   357

        return;

   358

    }

   359

   360

    fsm->retries = EC_FSM_RETRIES;

   361

   362

    if (ec_fsm_coe_prepare_dict(fsm, datagram)) {

   363

        fsm->state = ec_fsm_coe_error;

   364

    }

   365

}

   366

   367

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

   368

   369

/** CoE state: DICT REQUEST.

   370

 * \todo Timeout behavior

   371

 */

   372

void ec_fsm_coe_dict_request(

   373

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   374

        ec_datagram_t *datagram /**< Datagram to use. */

   375

        )

   376

{

   377

    ec_slave_t *slave = fsm->slave;

   378

   379

    if (fsm->datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {

   380

        if (ec_fsm_coe_prepare_dict(fsm, datagram)) {

   381

            fsm->state = ec_fsm_coe_error;

   382

        }

   383

        return;

   384

    }

   385

   386

    if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {

   387

        fsm->state = ec_fsm_coe_error;

   388

        EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   389

                " request datagram: ");

   390

        ec_datagram_print_state(fsm->datagram);

   391

        return;

   392

    }

   393

   394

    if (fsm->datagram->working_counter != 1) {

   395

        fsm->state = ec_fsm_coe_error;

   396

        EC_SLAVE_ERR(slave, "Reception of CoE dictionary request failed: ");

   397

        ec_datagram_print_wc_error(fsm->datagram);

   398

        return;

   399

    }

   400

   401

    fsm->jiffies_start = fsm->datagram->jiffies_sent;

   402

   403

    ec_slave_mbox_prepare_check(slave, datagram); // can not fail.

   404

    fsm->retries = EC_FSM_RETRIES;

   405

    fsm->state = ec_fsm_coe_dict_check;

   406

}

   407

   408

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

   409

   410

/** CoE state: DICT CHECK.

   411

 */

   412

void ec_fsm_coe_dict_check(

   413

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   414

        ec_datagram_t *datagram /**< Datagram to use. */

   415

        )

   416

{

   417

    ec_slave_t *slave = fsm->slave;

   418

   419

    if (fsm->datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {

   420

        ec_slave_mbox_prepare_check(slave, datagram); // can not fail.

   421

        return;

   422

    }

   423

   424

    if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {

   425

        fsm->state = ec_fsm_coe_error;

   426

        EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");

   427

        ec_datagram_print_state(fsm->datagram);

   428

        return;

   429

    }

   430

   431

    if (fsm->datagram->working_counter != 1) {

   432

        fsm->state = ec_fsm_coe_error;

   433

        EC_SLAVE_ERR(slave,"Reception of CoE mailbox check"

   434

                " datagram failed: ");

   435

        ec_datagram_print_wc_error(fsm->datagram);

   436

        return;

   437

    }

   438

   439

    if (!ec_slave_mbox_check(fsm->datagram)) {

   440

        unsigned long diff_ms =

   441

            (fsm->datagram->jiffies_received - fsm->jiffies_start) *

   442

            1000 / HZ;

   443

        if (diff_ms >= EC_FSM_COE_DICT_TIMEOUT) {

   444

            fsm->state = ec_fsm_coe_error;

   445

            EC_SLAVE_ERR(slave, "Timeout while waiting for"

   446

                    " SDO dictionary list response.\n");

   447

            return;

   448

        }

   449

   450

        ec_slave_mbox_prepare_check(slave, datagram); // can not fail.

   451

        fsm->retries = EC_FSM_RETRIES;

   452

        return;

   453

    }

   454

   455

    // Fetch response

   456

    ec_slave_mbox_prepare_fetch(slave, datagram); // can not fail.

   457

    fsm->retries = EC_FSM_RETRIES;

   458

    fsm->state = ec_fsm_coe_dict_response;

   459

}

   460

   461

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

   462

   463

/** Prepare an object description request.

   464

 *

   465

 * \return Zero on success, otherwise a negative error code.

   466

 */

   467

int ec_fsm_coe_dict_prepare_desc(

   468

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   469

        ec_datagram_t *datagram /**< Datagram to use. */

   470

        )

   471

{

   472

    ec_slave_t *slave = fsm->slave;

   473

    u8 *data = ec_slave_mbox_prepare_send(slave, datagram, 0x03, 8);

   474

    if (IS_ERR(data)) {

   475

        return PTR_ERR(data);

   476

    }

   477

   478

    EC_WRITE_U16(data, 0x8 << 12); // SDO information

   479

    EC_WRITE_U8 (data + 2, 0x03); // Get object description request

   480

    EC_WRITE_U8 (data + 3, 0x00);

   481

    EC_WRITE_U16(data + 4, 0x0000);

   482

    EC_WRITE_U16(data + 6, fsm->sdo->index); // SDO index

   483

   484

    fsm->state = ec_fsm_coe_dict_desc_request;

   485

    return 0;

   486

}

   487

   488

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

   489

   490

/**

   491

   CoE state: DICT RESPONSE.

   492

   \todo Timeout behavior

   493

*/

   494

   495

void ec_fsm_coe_dict_response(

   496

        ec_fsm_coe_t *fsm, /**< Finite state machine. */

   497

        ec_datagram_t *datagram /**< Datagram to use. */