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->topology_change_pending = 0;

    79

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    80

    fsm->validate = 0;

    81

    82

    // init sub-state-machines

    83

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

    84

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

    85

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

    86

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

    87

}

    88

    89

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

    90

    91

/**

    92

   Destructor.

    93

*/

    94

    95

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

    96

{

    97

    // clear sub-state machines

    98

    ec_fsm_slave_clear(&fsm->fsm_slave);

    99

    ec_fsm_sii_clear(&fsm->fsm_sii);

   100

    ec_fsm_change_clear(&fsm->fsm_change);

   101

    ec_fsm_coe_clear(&fsm->fsm_coe);

   102

}

   103

   104

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

   105

   106

/**

   107

   Executes the current state of the state machine.

   108

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

   109

   of the state machine is delayed to the next cycle.

   110

   \return false, if state machine has terminated

   111

*/

   112

   113

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

   114

{

   115

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

   116

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

   117

        // datagram was not sent or received yet.

   118

        return ec_fsm_master_running(fsm);

   119

    }

   120

   121

    fsm->state(fsm);

   122

    return ec_fsm_master_running(fsm);

   123

}

   124

   125

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

   126

   127

/**

   128

   \return false, if state machine has terminated

   129

*/

   130

   131

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

   132

{

   133

    return fsm->state != ec_fsm_master_state_end

   134

        && fsm->state != ec_fsm_master_state_error;

   135

}

   136

   137

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

   138

   139

/**

   140

   \return true, if the master state machine terminated gracefully

   141

*/

   142

   143

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

   144

{

   145

    return fsm->state == ec_fsm_master_state_end;

   146

}

   147

   148

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

   149

 *  operation/idle state machine

   150

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

   151

   152

/**

   153

   Master state: START.

   154

   Starts with getting slave count and slave states.

   155

*/

   156

   157

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   158

{

   159

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

   160

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

   161

    fsm->state = ec_fsm_master_state_broadcast;

   162

}

   163

   164

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

   165

   166

/**

   167

   Master state: BROADCAST.

   168

   Processes the broadcast read slave count and slaves states.

   169

*/

   170

   171

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

   172

{

   173

    ec_datagram_t *datagram = fsm->datagram;

   174

    unsigned int i;

   175

    ec_slave_t *slave;

   176

    ec_master_t *master = fsm->master;

   177

   178

    if (datagram->state == EC_DATAGRAM_TIMED_OUT) {

   179

        // always retry

   180

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

   181

        return;

   182

    }

   183

   184

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

   185

        // link is down

   186

        fsm->slaves_responding = 0;

   187

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

   188

            slave->online = 0;

   189

        }

   190

        fsm->state = ec_fsm_master_state_error;

   191

        return;

   192

    }

   193

   194

    // bus topology change?

   195

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

   196

        fsm->topology_change_pending = 1;

   197

        fsm->slaves_responding = datagram->working_counter;

   198

   199

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

   200

                fsm->slaves_responding,

   201

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

   202

   203

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   204

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

   205

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

   206

            }

   207

            else {

   208

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

   209

            }

   210

        }

   211

    }

   212

   213

    // slave states changed?

   214

    if (EC_READ_U8(datagram->data) != fsm->slave_states) {

   215

        char states[EC_STATE_STRING_SIZE];

   216

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

   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 (fsm->topology_change_pending &&

   223

            master->mode == EC_MASTER_MODE_IDLE) {

   224

        fsm->topology_change_pending = 0;

   225

   226

        ec_master_eoe_stop(master);

   227

        ec_master_destroy_slaves(master);

   228

   229

        master->slave_count = datagram->working_counter;

   230

   231

        if (!master->slave_count) {

   232

            // no slaves present -> finish state machine.

   233

            fsm->state = ec_fsm_master_state_end;

   234

            return;

   235

        }

   236

   237

        // init slaves

   238

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

   239

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

   240

                                                 GFP_ATOMIC))) {

   241

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

   242

                ec_master_destroy_slaves(master);

   243

                fsm->state = ec_fsm_master_state_error;

   244

                return;

   245

            }

   246

   247

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

   248

                // freeing of "slave" already done

   249

                ec_master_destroy_slaves(master);

   250

                fsm->state = ec_fsm_master_state_error;

   251

                return;

   252

            }

   253

   254

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

   255

        }

   256

   257

        EC_INFO("Scanning bus.\n");

   258

   259

        // begin scanning of slaves

   260

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

   261

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

   262

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

   263

        fsm->state = ec_fsm_master_state_scan_slaves;

   264

        return;

   265

    }

   266

   267

    // fetch state from each slave

   268

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

   269

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

   270

    ec_master_queue_datagram(master, fsm->datagram);

   271

    fsm->retries = EC_FSM_RETRIES;

   272

    fsm->state = ec_fsm_master_state_read_states;

   273

}

   274

   275

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

   276

   277

/**

   278

 * Check for pending EEPROM write requests and process one.

   279

 * \return non-zero, if an EEPROM write request is processed.

   280

 */

   281

   282

int ec_fsm_master_action_process_eeprom(

   283

        ec_fsm_master_t *fsm /**< master state machine */

   284

        )

   285

{

   286

    ec_master_t *master = fsm->master;

   288

    ec_slave_t *slave;

   289

   300

        list_del_init(&request->list); // dequeue

   301

        up(&master->eeprom_sem);

   302

   303

        slave = request->slave;

   304

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

   305

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

   306

                    slave->ring_position);

   307

            request->state = EC_EEPROM_REQ_ERROR;

   308

            wake_up_interruptible(&master->eeprom_queue);

   309

            continue;

   310

        }

   311

   312

        // found pending EEPROM write operation. execute it!

   313

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

   314

        fsm->eeprom_request = request;

   315

        fsm->eeprom_index = 0;

   316

        ec_fsm_sii_write(&fsm->fsm_sii, request->slave, request->offset,

   317

                request->words, EC_FSM_SII_NODE);

   318

        fsm->state = ec_fsm_master_state_write_eeprom;

   319

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

   320

        return 1;

   321

    }

   322

   323

    return 0;

   324

}

   325

   326

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

   327

   328

/**

   329

   Master action: PROC_STATES.

   330

   Processes the slave states.

   331

*/

   332

   333

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   334

                                         /**< master state machine */

   335

                                         )

   336

{

   337

    ec_master_t *master = fsm->master;

   338

    ec_slave_t *slave;

   339

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   340

   341

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

   342

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

   343

        if (slave->error_flag

   344

            || !slave->online

   345

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   346

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

   347

                && slave->self_configured)) continue;

   348

   349

        if (master->debug_level) {

   350

            ec_state_string(slave->current_state, old_state);

   351

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

   352

                ec_state_string(slave->requested_state, new_state);

   353

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

   354

                       slave->ring_position, old_state, new_state);

   355

            }

   356

            else if (!slave->self_configured) {

   357

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

   358

                       slave->ring_position, old_state);

   359

            }

   360

        }

   361

   362

        fsm->slave = slave;

   363

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   364

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

   365

        fsm->state = ec_fsm_master_state_configure_slave;

   366

        return;

   367

    }

   368

   369

    // Check, if EoE processing has to be started

   370

    ec_master_eoe_start(master);

   371

   372

    if (master->mode == EC_MASTER_MODE_IDLE) {

   373

   374

        // Check for a pending SDO request

   375

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

   376

            if (master->debug_level)

   377

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

   378

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

   379

            if (slave->current_state == EC_SLAVE_STATE_INIT

   380

                || !slave->online) {

   381

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

   382

                       slave->ring_position);

   383

                master->sdo_request->return_code = -1;

   384

                master->sdo_seq_master++;

   385

            }

   386

            else {

   387

                // start uploading SDO

   388

                fsm->slave = slave;

   389

                fsm->state = ec_fsm_master_state_sdo_request;

   390

                fsm->sdo_request = master->sdo_request;

   391

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

   392

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

   393

                return;

   394

            }

   395

        }

   396

   397

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

   398

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

   399

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   400

                || slave->sdo_dictionary_fetched

   401

                || slave->current_state == EC_SLAVE_STATE_INIT

   402

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

   403

                || !slave->online

   404

                || slave->error_flag) continue;

   405

   406

            if (master->debug_level) {

   407

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

   408

                       slave->ring_position);

   409

            }

   410

   411

            slave->sdo_dictionary_fetched = 1;

   412

   413

            // start fetching SDO dictionary

   414

            fsm->slave = slave;

   415

            fsm->state = ec_fsm_master_state_sdodict;

   416

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   417

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

   418

            return;

   419

        }

   420

   421

        // check for pending EEPROM write operations.

   422

        if (ec_fsm_master_action_process_eeprom(fsm))

   423

            return; // EEPROM write request found

   424

    }

   425

   426

    fsm->state = ec_fsm_master_state_end;

   427

}

   428

   429

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

   430

   431

/**

   432

   Master action: Get state of next slave.

   433

*/

   434

   435

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   436

                                           /**< master state machine */)

   437

{

   438

    ec_master_t *master = fsm->master;

   439

    ec_slave_t *slave = fsm->slave;

   440

   441

    // is there another slave to query?

   442

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

   443

        // process next slave

   444

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

   445

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

   446

                         0x0130, 2);

   447

        ec_master_queue_datagram(master, fsm->datagram);

   448

        fsm->retries = EC_FSM_RETRIES;

   449

        fsm->state = ec_fsm_master_state_read_states;

   450

        return;

   451

    }

   452

   453

    // all slave states read

   454

   455

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

   456

    if (fsm->validate) {

   457

        fsm->validate = 0;

   458

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

   459

            if (slave->online) continue;

   460

   461

            // At least one slave is offline. validate!

   462

            EC_INFO("Validating bus.\n");

   463

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

   464

            fsm->state = ec_fsm_master_state_validate_vendor;

   465

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

   466

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

   467

            return;

   468

        }

   469

    }

   470

   471

    ec_fsm_master_action_process_states(fsm);

   472

}

   473

   474

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

   475

   476

/**

   477

   Master state: READ STATES.

   478

   Fetches the AL- and online state of a slave.

   479

*/

   480

   481

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

   482

{

   483

    ec_slave_t *slave = fsm->slave;

   484

    ec_datagram_t *datagram = fsm->datagram;

   485

    uint8_t new_state;

   486

   487

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

   488

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

   489

        return;

   490

    }