1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  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

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

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

    15

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

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

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

    20

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

    21

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

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT finite state machines.

    37

*/

    38

    39

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

    40

    41

#include "globals.h"

    42

#include "master.h"

    43

#include "mailbox.h"

    44

#include "fsm_master.h"

    45

    46

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

    47

    48

void ec_fsm_master_state_start(ec_fsm_master_t *);

    49

void ec_fsm_master_state_broadcast(ec_fsm_master_t *);

    50

void ec_fsm_master_state_read_states(ec_fsm_master_t *);

    51

void ec_fsm_master_state_acknowledge(ec_fsm_master_t *);

    52

void ec_fsm_master_state_validate_vendor(ec_fsm_master_t *);

    53

void ec_fsm_master_state_validate_product(ec_fsm_master_t *);

    54

void ec_fsm_master_state_rewrite_addresses(ec_fsm_master_t *);

    55

void ec_fsm_master_state_configure_slave(ec_fsm_master_t *);

    56

void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *);

    57

void ec_fsm_master_state_write_eeprom(ec_fsm_master_t *);

    58

void ec_fsm_master_state_sdodict(ec_fsm_master_t *);

    59

void ec_fsm_master_state_sdo_request(ec_fsm_master_t *);

    60

void ec_fsm_master_state_end(ec_fsm_master_t *);

    61

void ec_fsm_master_state_error(ec_fsm_master_t *);

    62

    63

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

    64

    65

/**

    66

   Constructor.

    67

*/

    68

    69

void ec_fsm_master_init(ec_fsm_master_t *fsm, /**< master state machine */

    70

        ec_master_t *master, /**< EtherCAT master */

    71

        ec_datagram_t *datagram /**< datagram object to use */

    72

        )

    73

{

    74

    fsm->master = master;

    75

    fsm->datagram = datagram;

    76

    fsm->state = ec_fsm_master_state_start;

    77

    fsm->slaves_responding = 0;

    78

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    79

    fsm->validate = 0;

    80

    81

    // init sub-state-machines

    82

    ec_fsm_slave_init(&fsm->fsm_slave, fsm->datagram);

    83

    ec_fsm_sii_init(&fsm->fsm_sii, fsm->datagram);

    84

    ec_fsm_change_init(&fsm->fsm_change, fsm->datagram);

    85

    ec_fsm_coe_init(&fsm->fsm_coe, fsm->datagram);

    86

}

    87

    88

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

    89

    90

/**

    91

   Destructor.

    92

*/

    93

    94

void ec_fsm_master_clear(ec_fsm_master_t *fsm /**< master state machine */)

    95

{

    96

    // clear sub-state machines

    97

    ec_fsm_slave_clear(&fsm->fsm_slave);

    98

    ec_fsm_sii_clear(&fsm->fsm_sii);

    99

    ec_fsm_change_clear(&fsm->fsm_change);

   100

    ec_fsm_coe_clear(&fsm->fsm_coe);

   101

}

   102

   103

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

   104

   105

/**

   106

   Executes the current state of the state machine.

   107

   If the state machine's datagram is not sent or received yet, the execution

   108

   of the state machine is delayed to the next cycle.

   109

   \return false, if state machine has terminated

   110

*/

   111

   112

int ec_fsm_master_exec(ec_fsm_master_t *fsm /**< master state machine */)

   113

{

   114

    if (fsm->datagram->state == EC_DATAGRAM_SENT

   115

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

   116

        // datagram was not sent or received yet.

   117

        return ec_fsm_master_running(fsm);

   118

    }

   119

   120

    fsm->state(fsm);

   121

    return ec_fsm_master_running(fsm);

   122

}

   123

   124

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

   125

   126

/**

   127

   \return false, if state machine has terminated

   128

*/

   129

   130

int ec_fsm_master_running(ec_fsm_master_t *fsm /**< master state machine */)

   131

{

   132

    return fsm->state != ec_fsm_master_state_end

   133

        && fsm->state != ec_fsm_master_state_error;

   134

}

   135

   136

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

   137

   138

/**

   139

   \return true, if the master state machine terminated gracefully

   140

*/

   141

   142

int ec_fsm_master_success(ec_fsm_master_t *fsm /**< master state machine */)

   143

{

   144

    return fsm->state == ec_fsm_master_state_end;

   145

}

   146

   147

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

   148

 *  operation/idle state machine

   149

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

   150

   151

/**

   152

   Master state: START.

   153

   Starts with getting slave count and slave states.

   154

*/

   155

   156

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   157

{

   158

    ec_datagram_brd(fsm->datagram, 0x0130, 2);

   159

    ec_master_queue_datagram(fsm->master, fsm->datagram);

   160

    fsm->state = ec_fsm_master_state_broadcast;

   161

}

   162

   163

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

   164

   165

/**

   166

   Master state: BROADCAST.

   167

   Processes the broadcast read slave count and slaves states.

   168

*/

   169

   170

void ec_fsm_master_state_broadcast(ec_fsm_master_t *fsm /**< master state machine */)

   171

{

   172

    ec_datagram_t *datagram = fsm->datagram;

   173

    unsigned int topology_change, states_change, i;

   174

    ec_slave_t *slave;

   175

    ec_master_t *master = fsm->master;

   176

   177

    if (datagram->state == EC_DATAGRAM_TIMED_OUT) {

   178

        // always retry

   179

        ec_master_queue_datagram(fsm->master, fsm->datagram);

   180

        return;

   181

    }

   182

   183

    if (datagram->state != EC_DATAGRAM_RECEIVED) { // EC_DATAGRAM_ERROR

   184

        // link is down

   185

        fsm->slaves_responding = 0;

   186

        list_for_each_entry(slave, &master->slaves, list) {

   187

            slave->online = 0;

   188

        }

   189

        fsm->state = ec_fsm_master_state_error;

   190

        return;

   191

    }

   192

   193

    topology_change = (datagram->working_counter !=

   194

                       fsm->slaves_responding);

   195

    states_change = (EC_READ_U8(datagram->data) != fsm->slave_states);

   196

   197

    fsm->slave_states = EC_READ_U8(datagram->data);

   198

    fsm->slaves_responding = datagram->working_counter;

   199

   200

    if (topology_change) {

   201

        EC_INFO("%i slave%s responding.\n",

   202

                fsm->slaves_responding,

   203

                fsm->slaves_responding == 1 ? "" : "s");

   204

   205

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   206

            if (fsm->slaves_responding == master->slave_count) {

   207

                fsm->validate = 1; // start validation later

   208

            }

   209

            else {

   210

                EC_WARN("Invalid slave count. Bus in tainted state.\n");

   211

            }

   212

        }

   213

    }

   214

   215

    if (states_change) {

   216

        char states[EC_STATE_STRING_SIZE];

   217

        ec_state_string(fsm->slave_states, states);

   218

        EC_INFO("Slave states: %s.\n", states);

   219

    }

   220

   221

    // topology change in idle mode: clear all slaves and scan the bus

   222

    if (topology_change && master->mode == EC_MASTER_MODE_IDLE) {

   223

   224

        ec_master_eoe_stop(master);

   225

        ec_master_destroy_slaves(master);

   226

   227

        master->slave_count = datagram->working_counter;

   228

   229

        if (!master->slave_count) {

   230

            // no slaves present -> finish state machine.

   231

            fsm->state = ec_fsm_master_state_end;

   232

            return;

   233

        }

   234

   235

        // init slaves

   236

        for (i = 0; i < master->slave_count; i++) {

   237

            if (!(slave = (ec_slave_t *) kmalloc(sizeof(ec_slave_t),

   238

                                                 GFP_ATOMIC))) {

   239

                EC_ERR("Failed to allocate slave %i!\n", i);

   240

                ec_master_destroy_slaves(master);

   241

                fsm->state = ec_fsm_master_state_error;

   242

                return;

   243

            }

   244

   245

            if (ec_slave_init(slave, master, i, i + 1)) {

   246

                // freeing of "slave" already done

   247

                ec_master_destroy_slaves(master);

   248

                fsm->state = ec_fsm_master_state_error;

   249

                return;

   250

            }

   251

   252

            list_add_tail(&slave->list, &master->slaves);

   253

        }

   254

   255

        EC_INFO("Scanning bus.\n");

   256

   257

        // begin scanning of slaves

   258

        fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);

   259

        ec_fsm_slave_start_scan(&fsm->fsm_slave, fsm->slave);

   260

        ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately

   261

        fsm->state = ec_fsm_master_state_scan_slaves;

   262

        return;

   263

    }

   264

   265

    // fetch state from each slave

   266

    fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);

   267

    ec_datagram_nprd(fsm->datagram, fsm->slave->station_address, 0x0130, 2);

   268

    ec_master_queue_datagram(master, fsm->datagram);

   269

    fsm->retries = EC_FSM_RETRIES;

   270

    fsm->state = ec_fsm_master_state_read_states;

   271

}

   272

   273

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

   274

   275

/**

   276

   Master action: PROC_STATES.

   277

   Processes the slave states.

   278

*/

   279

   280

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   281

                                         /**< master state machine */

   282

                                         )

   283

{

   284

    ec_master_t *master = fsm->master;

   285

    ec_slave_t *slave;

   286

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   287

   288

    // check if any slaves are not in the state, they're supposed to be

   289

    list_for_each_entry(slave, &master->slaves, list) {

   290

        if (slave->error_flag

   291

            || !slave->online

   292

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   293

            || (slave->current_state == slave->requested_state

   294

                && slave->self_configured)) continue;

   295

   296

        if (master->debug_level) {

   297

            ec_state_string(slave->current_state, old_state);

   298

            if (slave->current_state != slave->requested_state) {

   299

                ec_state_string(slave->requested_state, new_state);

   300

                EC_DBG("Changing state of slave %i (%s -> %s).\n",

   301

                       slave->ring_position, old_state, new_state);

   302

            }

   303

            else if (!slave->self_configured) {

   304

                EC_DBG("Reconfiguring slave %i (%s).\n",

   305

                       slave->ring_position, old_state);

   306

            }

   307

        }

   308

   309

        fsm->slave = slave;

   310

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   311

        ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately

   312

        fsm->state = ec_fsm_master_state_configure_slave;

   313

        return;

   314

    }

   315

   316

    // Check, if EoE processing has to be started

   317

    ec_master_eoe_start(master);

   318

   319

    if (master->mode == EC_MASTER_MODE_IDLE) {

   320

   321

        // Check for a pending SDO request

   322

        if (master->sdo_seq_master != master->sdo_seq_user) {

   323

            if (master->debug_level)

   324

                EC_DBG("Processing SDO request...\n");

   325

            slave = master->sdo_request->sdo->slave;

   326

            if (slave->current_state == EC_SLAVE_STATE_INIT

   327

                || !slave->online) {

   328

                EC_ERR("Failed to process SDO request, slave %i not ready.\n",

   329

                       slave->ring_position);

   330

                master->sdo_request->return_code = -1;

   331

                master->sdo_seq_master++;

   332

            }

   333

            else {

   334

                // start uploading SDO

   335

                fsm->slave = slave;

   336

                fsm->state = ec_fsm_master_state_sdo_request;

   337

                fsm->sdo_request = master->sdo_request;

   338

                ec_fsm_coe_upload(&fsm->fsm_coe, slave, fsm->sdo_request);

   339

                ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately

   340

                return;

   341

            }

   342

        }

   343

   344

        // check, if slaves have an SDO dictionary to read out.

   345

        list_for_each_entry(slave, &master->slaves, list) {

   346

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   347

                || slave->sdo_dictionary_fetched

   348

                || slave->current_state == EC_SLAVE_STATE_INIT

   349

                || jiffies - slave->jiffies_preop < EC_WAIT_SDO_DICT * HZ

   350

                || !slave->online

   351

                || slave->error_flag) continue;

   352

   353

            if (master->debug_level) {

   354

                EC_DBG("Fetching SDO dictionary from slave %i.\n",

   355

                       slave->ring_position);

   356

            }

   357

   358

            slave->sdo_dictionary_fetched = 1;

   359

   360

            // start fetching SDO dictionary

   361

            fsm->slave = slave;

   362

            fsm->state = ec_fsm_master_state_sdodict;

   363

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   364

            ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately

   365

            return;

   366

        }

   367

   368

        // check for pending EEPROM write operations.

   369

        list_for_each_entry(slave, &master->slaves, list) {

   370

            if (!slave->new_eeprom_data) continue;

   371

   372

            if (!slave->online || slave->error_flag) {

   373

                kfree(slave->new_eeprom_data);

   374

                slave->new_eeprom_data = NULL;

   375

                EC_ERR("Discarding EEPROM data, slave %i not ready.\n",

   376

                       slave->ring_position);

   377

                continue;

   378

            }

   379

   380

            // found pending EEPROM write operation. execute it!

   381

            EC_INFO("Writing EEPROM of slave %i...\n", slave->ring_position);

   382

            fsm->slave = slave;

   383

            fsm->sii_offset = 0x0000;

   384

            ec_fsm_sii_write(&fsm->fsm_sii, slave, fsm->sii_offset,

   385

                             slave->new_eeprom_data, EC_FSM_SII_NODE);

   386

            fsm->state = ec_fsm_master_state_write_eeprom;

   387

            fsm->state(fsm); // execute immediately

   388

            return;

   389

        }

   390

    }

   391

   392

    fsm->state = ec_fsm_master_state_end;

   393

}

   394

   395

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

   396

   397

/**

   398

   Master action: Get state of next slave.

   399

*/

   400

   401

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   402

                                           /**< master state machine */)

   403

{

   404

    ec_master_t *master = fsm->master;

   405

    ec_slave_t *slave = fsm->slave;

   406

   407

    // is there another slave to query?

   408

    if (slave->list.next != &master->slaves) {

   409

        // process next slave

   410

        fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);

   411

        ec_datagram_nprd(fsm->datagram, fsm->slave->station_address,

   412

                         0x0130, 2);

   413

        ec_master_queue_datagram(master, fsm->datagram);

   414

        fsm->retries = EC_FSM_RETRIES;

   415

        fsm->state = ec_fsm_master_state_read_states;

   416

        return;

   417

    }

   418

   419

    // all slave states read

   420

   421

    // check, if a bus validation has to be done

   422

    if (fsm->validate) {

   423

        fsm->validate = 0;

   424

        list_for_each_entry(slave, &master->slaves, list) {

   425

            if (slave->online) continue;

   426

   427

            // At least one slave is offline. validate!

   428

            EC_INFO("Validating bus.\n");

   429

            fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);

   430

            fsm->state = ec_fsm_master_state_validate_vendor;

   431

            ec_fsm_sii_read(&fsm->fsm_sii, slave, 0x0008, EC_FSM_SII_POSITION);

   432

            ec_fsm_sii_exec(&fsm->fsm_sii); // execute immediately

   433

            return;

   434

        }

   435

    }

   436

   437

    ec_fsm_master_action_process_states(fsm);

   438

}

   439

   440

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

   441

   442

/**

   443

   Master state: READ STATES.

   444

   Fetches the AL- and online state of a slave.

   445

*/

   446

   447

void ec_fsm_master_state_read_states(ec_fsm_master_t *fsm /**< master state machine */)

   448

{

   449

    ec_slave_t *slave = fsm->slave;

   450

    ec_datagram_t *datagram = fsm->datagram;

   451

    uint8_t new_state;

   452

   453

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

   454

        ec_master_queue_datagram(fsm->master, fsm->datagram);

   455

        return;

   456

    }

   457

   458

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   459

        EC_ERR("Failed to receive AL state datagram for slave %i!\n",

   460

               slave->ring_position);

   461

        fsm->state = ec_fsm_master_state_error;

   462

        return;

   463

    }

   464

   465

    // did the slave not respond to its station address?

   466

    if (datagram->working_counter != 1) {

   467

        if (slave->online) {

   468

            slave->online = 0;

   469

            if (slave->master->debug_level)

   470

                EC_DBG("Slave %i: offline.\n", slave->ring_position);

   471

        }

   472

        ec_fsm_master_action_next_slave_state(fsm);

   473

        return;

   474

    }

   475

   476

    // slave responded

   477

    new_state = EC_READ_U8(datagram->data);

   478

    if (!slave->online) { // slave was offline before

   479

        slave->online = 1;

   480

        slave->error_flag = 0; // clear error flag

   481

        slave->current_state = new_state;

   482

        if (slave->master->debug_level) {

   483

            char cur_state[EC_STATE_STRING_SIZE];

   484

            ec_state_string(slave->current_state, cur_state);

   485

            EC_DBG("Slave %i: online (%s).\n",

   486

                   slave->ring_position, cur_state);

   487

        }

   488

    }

   489

    else if (new_state != slave->current_state) {