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,

   322

			EC_MBOX_TYPE_COE, 8);

   323

    if (IS_ERR(data)) {

   324

        return PTR_ERR(data);

   325

    }

   326

   327

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

   328

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

   329

    EC_WRITE_U8 (data + 3, 0x00);

   330

    EC_WRITE_U16(data + 4, 0x0000);

   331

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

   332

   333

    fsm->state = ec_fsm_coe_dict_request;

   334

    return 0;

   335

}

   336

   337

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

   338

   339

/** CoE state: DICT START.

   340

 */

   341

void ec_fsm_coe_dict_start(

   342

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

   343

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

   344

        )

   345

{

   346

    ec_slave_t *slave = fsm->slave;

   347

   348

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

   349

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

   350

        fsm->state = ec_fsm_coe_error;

   351

        return;

   352

    }

   353

   354

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

   355

        EC_SLAVE_ERR(slave, "Slave does not support"

   356

                " SDO information service!\n");

   357

        fsm->state = ec_fsm_coe_error;

   358

        return;

   359

    }

   360

   361

    fsm->retries = EC_FSM_RETRIES;

   362

   363

    if (ec_fsm_coe_prepare_dict(fsm, datagram)) {

   364

        fsm->state = ec_fsm_coe_error;

   365

    }

   366

}

   367

   368

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

   369

   370

/** CoE state: DICT REQUEST.

   371

 * \todo Timeout behavior

   372

 */

   373

void ec_fsm_coe_dict_request(

   374

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

   375

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

   376

        )

   377

{

   378

    ec_slave_t *slave = fsm->slave;

   379

   380

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

   381

        if (ec_fsm_coe_prepare_dict(fsm, datagram)) {

   382

            fsm->state = ec_fsm_coe_error;

   383

        }

   384

        return;

   385

    }

   386

   387

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

   388

        fsm->state = ec_fsm_coe_error;

   389

        EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   390

                " request datagram: ");

   391

        ec_datagram_print_state(fsm->datagram);

   392

        return;

   393

    }

   394

   395

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

   396

        fsm->state = ec_fsm_coe_error;

   397

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

   398

        ec_datagram_print_wc_error(fsm->datagram);

   399

        return;

   400

    }

   401

   402

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

   403

   404

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

   405

    fsm->retries = EC_FSM_RETRIES;

   406

    fsm->state = ec_fsm_coe_dict_check;

   407

}

   408

   409

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

   410

   411

/** CoE state: DICT CHECK.

   412

 */

   413

void ec_fsm_coe_dict_check(

   414

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

   415

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

   416

        )

   417

{

   418

    ec_slave_t *slave = fsm->slave;

   419

   420

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

   421

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

   422

        return;

   423

    }

   424

   425

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

   426

        fsm->state = ec_fsm_coe_error;

   427

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

   428

        ec_datagram_print_state(fsm->datagram);

   429

        return;

   430

    }

   431

   432

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

   433

        fsm->state = ec_fsm_coe_error;

   434

        EC_SLAVE_ERR(slave,"Reception of CoE mailbox check"

   435

                " datagram failed: ");

   436

        ec_datagram_print_wc_error(fsm->datagram);

   437

        return;

   438

    }

   439

   440

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

   441

        unsigned long diff_ms =

   442

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

   443

            1000 / HZ;

   444

        if (diff_ms >= EC_FSM_COE_DICT_TIMEOUT) {

   445

            fsm->state = ec_fsm_coe_error;

   446

            EC_SLAVE_ERR(slave, "Timeout while waiting for"

   447

                    " SDO dictionary list response.\n");

   448

            return;

   449

        }

   450

   451

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

   452

        fsm->retries = EC_FSM_RETRIES;

   453

        return;

   454

    }

   455

   456

    // Fetch response

   457

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

   458

    fsm->retries = EC_FSM_RETRIES;

   459

    fsm->state = ec_fsm_coe_dict_response;

   460

}

   461

   462

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

   463

   464

/** Prepare an object description request.

   465

 *

   466

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

   467

 */

   468

int ec_fsm_coe_dict_prepare_desc(

   469

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

   470

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

   471

        )

   472

{

   473

    ec_slave_t *slave = fsm->slave;

   474

    u8 *data = ec_slave_mbox_prepare_send(slave, datagram, EC_MBOX_TYPE_COE,

   475

			8);

   476

    if (IS_ERR(data)) {

   477

        return PTR_ERR(data);

   478

    }

   479

   480

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

   481

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

   482

    EC_WRITE_U8 (data + 3, 0x00);

   483

    EC_WRITE_U16(data + 4, 0x0000);

   484

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

   485

   486

    fsm->state = ec_fsm_coe_dict_desc_request;

   487

    return 0;

   488

}

   489

   490

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

   491

   492

/**

   493

   CoE state: DICT RESPONSE.

   494

   \todo Timeout behavior

   495

*/

   496

   497

void ec_fsm_coe_dict_response(