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

/**

    31

   \file

    32

   EtherCAT CoE state machines.

    33

*/

    34

    35

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

    36

    37

#include "globals.h"

    38

#include "master.h"

    39

#include "mailbox.h"

    40

#include "fsm_coe.h"

    41

#include "slave_config.h"

    42

    43

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

    44

    45

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

    46

 */

    47

#define EC_FSM_COE_DICT_TIMEOUT 1000

    48

    49

/** CoE download request header size.

    50

 */

    51

#define EC_COE_DOWN_REQ_HEADER_SIZE 10

    52

    53

/** CoE download segment request header size.

    54

 */

    55

#define EC_COE_DOWN_SEG_REQ_HEADER_SIZE 3

    56

    57

/** Minimum size of download segment.

    58

 */

    59

#define EC_COE_DOWN_SEG_MIN_DATA_SIZE 7

    60

    61

/** Enable debug output for CoE retries.

    62

 */

    63

#define DEBUG_RETRIES 0

    64

    65

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

    66

 */

    67

#define DEBUG_LONG 0

    68

    69

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

    70

    71

void ec_fsm_coe_dict_start(ec_fsm_coe_t *);

    72

void ec_fsm_coe_dict_request(ec_fsm_coe_t *);

    73

void ec_fsm_coe_dict_check(ec_fsm_coe_t *);

    74

void ec_fsm_coe_dict_response(ec_fsm_coe_t *);

    75

void ec_fsm_coe_dict_desc_request(ec_fsm_coe_t *);

    76

void ec_fsm_coe_dict_desc_check(ec_fsm_coe_t *);

    77

void ec_fsm_coe_dict_desc_response(ec_fsm_coe_t *);

    78

void ec_fsm_coe_dict_entry_request(ec_fsm_coe_t *);

    79

void ec_fsm_coe_dict_entry_check(ec_fsm_coe_t *);

    80

void ec_fsm_coe_dict_entry_response(ec_fsm_coe_t *);

    81

    82

void ec_fsm_coe_down_start(ec_fsm_coe_t *);

    83

void ec_fsm_coe_down_request(ec_fsm_coe_t *);

    84

void ec_fsm_coe_down_check(ec_fsm_coe_t *);

    85

void ec_fsm_coe_down_response(ec_fsm_coe_t *);

    86

void ec_fsm_coe_down_seg_check(ec_fsm_coe_t *);

    87

void ec_fsm_coe_down_seg_response(ec_fsm_coe_t *);

    88

    89

void ec_fsm_coe_up_start(ec_fsm_coe_t *);

    90

void ec_fsm_coe_up_request(ec_fsm_coe_t *);

    91

void ec_fsm_coe_up_check(ec_fsm_coe_t *);

    92

void ec_fsm_coe_up_response(ec_fsm_coe_t *);

    93

void ec_fsm_coe_up_seg_request(ec_fsm_coe_t *);

    94

void ec_fsm_coe_up_seg_check(ec_fsm_coe_t *);

    95

void ec_fsm_coe_up_seg_response(ec_fsm_coe_t *);

    96

    97

void ec_fsm_coe_end(ec_fsm_coe_t *);

    98

void ec_fsm_coe_error(ec_fsm_coe_t *);

    99

   100

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

   101

   102

/**

   103

   SDO abort messages.

   104

   The "abort SDO transfer request" supplies an abort code,

   105

   which can be translated to clear text. This table does

   106

   the mapping of the codes and messages.

   107

*/

   108

   109

const ec_code_msg_t sdo_abort_messages[] = {

   110

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

   111

    {0x05040000, "SDO protocol timeout"},

   112

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

   113

    {0x05040005, "Out of memory"},

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

     " exceed the PDO length"},

   121

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

   122

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

   123

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

   124

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

   125

     " not match"},

   126

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

   127

     " high"},

   128

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

   129

     " low"},

   130

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

   131

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

   132

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

   133

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

   134

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

   135

    {0x08000000, "General error"},

   136

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

   137

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

   138

     " because of local control"},

   139

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

   140

     " because of the present device state"},

   141

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

   142

     " dictionary is present"},

   143

    {}

   144

};

   145

   146

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

   147

   148

/** Outputs an SDO abort message.

   149

 */

   150

void ec_canopen_abort_msg(const ec_slave_t *slave, uint32_t abort_code)

   151

{

   152

    const ec_code_msg_t *abort_msg;

   153

   154

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

   155

        if (abort_msg->code == abort_code) {

   156

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

   157

                   abort_msg->code, abort_msg->message);

   158

            return;

   159

        }

   160

    }

   161

   162

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

   163

}

   164

   165

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

   166

   167

/**

   168

   Constructor.

   169

*/

   170

   171

void ec_fsm_coe_init(ec_fsm_coe_t *fsm, /**< finite state machine */

   172

                     ec_datagram_t *datagram /**< datagram */

   173

                     )

   174

{

   175

    fsm->state = NULL;

   176

    fsm->datagram = datagram;

   177

}

   178

   179

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

   180

   181

/**

   182

   Destructor.

   183

*/

   184

   185

void ec_fsm_coe_clear(ec_fsm_coe_t *fsm /**< finite state machine */)

   186

{

   187

}

   188

   189

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

   190

   191

/**

   192

   Starts reading a slaves' SDO dictionary.

   193

*/

   194

   195

void ec_fsm_coe_dictionary(ec_fsm_coe_t *fsm, /**< finite state machine */

   196

                           ec_slave_t *slave /**< EtherCAT slave */

   197

                           )

   198

{

   199

    fsm->slave = slave;

   200

    fsm->state = ec_fsm_coe_dict_start;

   201

}

   202

   203

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

   204

   205

/**

   206

   Starts to transfer an SDO to/from a slave.

   207

*/

   208

   209

void ec_fsm_coe_transfer(

   210

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

   211

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

   212

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

   213

        )

   214

{

   215

    fsm->slave = slave;

   216

    fsm->request = request;

   217

    if (request->dir == EC_DIR_OUTPUT)

   218

        fsm->state = ec_fsm_coe_down_start;

   219

    else

   220

        fsm->state = ec_fsm_coe_up_start;

   221

}

   222

   223

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

   224

   225

/**

   226

   Executes the current state of the state machine.

   227

   \return false, if state machine has terminated

   228

*/

   229

   230

int ec_fsm_coe_exec(ec_fsm_coe_t *fsm /**< finite state machine */)

   231

{

   232

    fsm->state(fsm);

   233

   234

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

   235

}

   236

   237

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

   238

   239

/**

   240

   Returns, if the state machine terminated with success.

   241

   \return non-zero if successful.

   242

*/

   243

   244

int ec_fsm_coe_success(ec_fsm_coe_t *fsm /**< Finite state machine */)

   245

{

   246

    return fsm->state == ec_fsm_coe_end;

   247

}

   248

   249

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

   250

   251

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

   252

 *

   253

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

   254

 *

   255

 * \return The data were an emergency request.

   256

 */

   257

int ec_fsm_coe_check_emergency(

   258

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

   259

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

   260

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

   261

        )

   262

{

   263

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

   264

        return 0;

   265

   266

    if (size < 10) {

   267

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

   268

                " request:\n");

   269

        ec_print_data(data, size);

   270

        return 1;

   271

    }

   272

   273

    {

   274

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

   275

        if (sc) {

   276

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

   277

        }

   278

    }

   279

   280

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

   281

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

   282

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

   283

    ec_print_data(data + 5, 5);

   284

    return 1;

   285

}

   286

   287

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

   288

 *  CoE dictionary state machine

   289

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

   290

   291

/**

   292

   CoE state: DICT START.

   293

*/

   294

   295

void ec_fsm_coe_dict_start(ec_fsm_coe_t *fsm /**< finite state machine */)

   296

{

   297

    ec_datagram_t *datagram = fsm->datagram;

   298

    ec_slave_t *slave = fsm->slave;

   299

    uint8_t *data;

   300

   301

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

   302

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

   303

        fsm->state = ec_fsm_coe_error;

   304

        return;

   305

    }

   306

   307

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

   308

        EC_SLAVE_ERR(slave, "Slave does not support"

   309

                " SDO information service!\n");

   310

        fsm->state = ec_fsm_coe_error;

   311

        return;

   312

    }

   313

   314

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

   315

    if (IS_ERR(data)) {

   316

        fsm->state = ec_fsm_coe_error;

   317

        return;

   318

    }

   319

   320

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

   321

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

   322

    EC_WRITE_U8 (data + 3, 0x00);

   323

    EC_WRITE_U16(data + 4, 0x0000);

   324

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

   325

   326

    fsm->retries = EC_FSM_RETRIES;

   327

    fsm->state = ec_fsm_coe_dict_request;

   328

}

   329

   330

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

   331

   332

/**

   333

   CoE state: DICT REQUEST.

   334

   \todo Timeout behavior

   335

*/

   336

   337

void ec_fsm_coe_dict_request(ec_fsm_coe_t *fsm /**< finite state machine */)

   338

{

   339

    ec_datagram_t *datagram = fsm->datagram;

   340

    ec_slave_t *slave = fsm->slave;

   341

   342

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

   343

        return; // FIXME: request again?

   344

   345

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   346

        fsm->state = ec_fsm_coe_error;

   347

        EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   348

                " request datagram: ");

   349

        ec_datagram_print_state(datagram);

   350

        return;

   351

    }

   352

   353

    if (datagram->working_counter != 1) {

   354

        fsm->state = ec_fsm_coe_error;

   355

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

   356

        ec_datagram_print_wc_error(datagram);

   357

        return;

   358

    }

   359

   360

    fsm->jiffies_start = datagram->jiffies_sent;

   361

   362

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

   363

    fsm->retries = EC_FSM_RETRIES;

   364

    fsm->state = ec_fsm_coe_dict_check;

   365

}

   366

   367

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

   368

   369

/**

   370

   CoE state: DICT CHECK.

   371

*/

   372

   373

void ec_fsm_coe_dict_check(ec_fsm_coe_t *fsm /**< finite state machine */)

   374

{

   375

    ec_datagram_t *datagram = fsm->datagram;

   376

    ec_slave_t *slave = fsm->slave;

   377

   378

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

   379

        return;

   380

   381

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   382

        fsm->state = ec_fsm_coe_error;

   383

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

   384

        ec_datagram_print_state(datagram);

   385

        return;

   386

    }

   387

   388

    if (datagram->working_counter != 1) {

   389

        fsm->state = ec_fsm_coe_error;

   390

        EC_SLAVE_ERR(slave,"Reception of CoE mailbox check"

   391

                " datagram failed: ");

   392

        ec_datagram_print_wc_error(datagram);

   393

        return;

   394

    }

   395

   396

    if (!ec_slave_mbox_check(datagram)) {

   397

        unsigned long diff_ms =

   398

            (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;

   399

        if (diff_ms >= EC_FSM_COE_DICT_TIMEOUT) {

   400

            fsm->state = ec_fsm_coe_error;

   401

            EC_SLAVE_ERR(slave, "Timeout while waiting for"

   402

                    " SDO dictionary list response.\n");

   403

            return;

   404

        }

   405

   406

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

   407

        fsm->retries = EC_FSM_RETRIES;

   408

        return;

   409

    }

   410

   411

    // Fetch response

   412

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

   413

    fsm->retries = EC_FSM_RETRIES;

   414

    fsm->state = ec_fsm_coe_dict_response;

   415

}

   416

   417

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

   418

   419

/**

   420

   CoE state: DICT RESPONSE.

   421

   \todo Timeout behavior

   422

*/

   423

   424

void ec_fsm_coe_dict_response(ec_fsm_coe_t *fsm /**< finite state machine */)

   425

{

   426

    ec_datagram_t *datagram = fsm->datagram;

   427

    ec_slave_t *slave = fsm->slave;

   428

    uint8_t *data, mbox_prot;

   429

    size_t rec_size;

   430

    unsigned int sdo_count, i;

   431

    uint16_t sdo_index, fragments_left;

   432

    ec_sdo_t *sdo;

   433

    bool first_segment;

   434

    size_t index_list_offset;

   435

   436

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

   437

        return; // FIXME: request again?

   438

   439

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   440

        fsm->state = ec_fsm_coe_error;

   441

        EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   442

                " response datagram: ");

   443

        ec_datagram_print_state(datagram);

   444

        return;

   445

    }

   446

   447

    if (datagram->working_counter != 1) {

   448

        fsm->state = ec_fsm_coe_error;

   449

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

   450

        ec_datagram_print_wc_error(datagram);

   451

        return;

   452

    }

   453

   454

    data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);

   455

    if (IS_ERR(data)) {

   456

        fsm->state = ec_fsm_coe_error;

   457

        return;

   458

    }

   459

   460

    if (mbox_prot != 0x03) { // CoE

   461

        EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",

   462

                mbox_prot);

   463

        fsm->state = ec_fsm_coe_error;

   464

        return;

   465

    }

   466

   467

    if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {

   468

        // check for CoE response again

   469

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

   470

        fsm->retries = EC_FSM_RETRIES;

   471

        fsm->state = ec_fsm_coe_dict_check;

   472

        return;

   473

    }

   474

   475

    if (rec_size < 3) {

   476

        EC_SLAVE_ERR(slave, "Received corrupted SDO dictionary response"

   477

                " (size %zu).\n", rec_size);

   478

        fsm->state = ec_fsm_coe_error;

   479

        return;

   480

    }

   481

   482

    if (EC_READ_U16(data) >> 12 == 0x8 && // SDO information

   483

        (EC_READ_U8(data + 2) & 0x7F) == 0x07) { // error response

   484

        EC_SLAVE_ERR(slave, "SDO information error response!\n");

   485

        if (rec_size < 10) {

   486

            EC_SLAVE_ERR(slave, "Incomplete SDO information"

   487

                    " error response:\n");

   488

            ec_print_data(data, rec_size);

   489

        } else {

   490

            ec_canopen_abort_msg(slave, EC_READ_U32(data + 6));

   491

        }

   492

        fsm->state = ec_fsm_coe_error;

   493

        return;

   494

    }

   495

   496

    if (EC_READ_U16(data) >> 12 != 0x8 || // SDO information

   497

        (EC_READ_U8 (data + 2) & 0x7F) != 0x02) { // Get OD List response

   498

        if (fsm->slave->master->debug_level) {

   499

            EC_SLAVE_DBG(slave, 1, "Invalid SDO list response!"

   500

                    " Retrying...\n");

   501

            ec_print_data(data, rec_size);

   502

        }

   503

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

   504

        fsm->retries = EC_FSM_RETRIES;

   505

        fsm->state = ec_fsm_coe_dict_check;