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;

   287

    ec_eeprom_write_request_t *request;

   288

    ec_slave_t *slave;

   289

   290

    // search the first request to be processed

   291

    while (1) {

   292

        down(&master->eeprom_sem);

   293

        if (list_empty(&master->eeprom_requests)) {

   294

            up(&master->eeprom_sem);

   295

            break;

   296

        }

   297

        // get first request

   298

        request = list_entry(master->eeprom_requests.next,

   299

                ec_eeprom_write_request_t, list);

   300

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

   302

        up(&master->eeprom_sem);

   303

   304

        slave = request->slave;

   305

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

   306

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

   307

                    slave->ring_position);

   308

            request->state = EC_EEPROM_REQ_ERROR;

   310

            continue;

   311

        }

   312

   313

        // found pending EEPROM write operation. execute it!

   314

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

   315

        fsm->eeprom_request = request;

   316

        fsm->eeprom_index = 0;

   317

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

   318

                request->words, EC_FSM_SII_NODE);

   319

        fsm->state = ec_fsm_master_state_write_eeprom;

   320

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

   321

        return 1;

   322

    }

   323

   324

    return 0;

   325

}

   326

   327

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

   328

   329

/**

   330

   Master action: PROC_STATES.

   331

   Processes the slave states.

   332

*/

   333

   334

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   335

                                         /**< master state machine */

   336

                                         )

   337

{

   338

    ec_master_t *master = fsm->master;

   339

    ec_slave_t *slave;

   340

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   341

   342

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

   343

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

   344

        if (slave->error_flag

   345

            || !slave->online

   346

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   347

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

   348

                && slave->self_configured)) continue;

   349

   350

        if (master->debug_level) {

   351

            ec_state_string(slave->current_state, old_state);

   352

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

   353

                ec_state_string(slave->requested_state, new_state);

   354

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

   355

                       slave->ring_position, old_state, new_state);

   356

            }

   357

            else if (!slave->self_configured) {

   358

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

   359

                       slave->ring_position, old_state);

   360

            }

   361

        }

   362

   363

        fsm->slave = slave;

   364

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   365

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

   366

        fsm->state = ec_fsm_master_state_configure_slave;

   367

        return;

   368

    }

   369

   370

    // Check, if EoE processing has to be started

   371

    ec_master_eoe_start(master);

   372

   373

    if (master->mode == EC_MASTER_MODE_IDLE) {

   374

   375

        // Check for a pending SDO request

   376

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

   377

            if (master->debug_level)

   378

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

   379

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

   380

            if (slave->current_state == EC_SLAVE_STATE_INIT

   381

                || !slave->online) {

   382

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

   383

                       slave->ring_position);

   384

                master->sdo_request->return_code = -1;

   385

                master->sdo_seq_master++;

   386

            }

   387

            else {

   388

                // start uploading SDO

   389

                fsm->slave = slave;

   390

                fsm->state = ec_fsm_master_state_sdo_request;

   391

                fsm->sdo_request = master->sdo_request;

   392

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

   393

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

   394

                return;

   395

            }

   396

        }

   397

   398

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

   399

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

   400

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   401

                || slave->sdo_dictionary_fetched

   402

                || slave->current_state == EC_SLAVE_STATE_INIT

   403

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

   404

                || !slave->online

   405

                || slave->error_flag) continue;

   406

   407

            if (master->debug_level) {

   408

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

   409

                       slave->ring_position);

   410

            }

   411

   412

            slave->sdo_dictionary_fetched = 1;

   413

   414

            // start fetching SDO dictionary

   415

            fsm->slave = slave;

   416

            fsm->state = ec_fsm_master_state_sdodict;

   417

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   418

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

   419

            return;

   420

        }

   421

   422

        // check for pending EEPROM write operations.

   423

        if (ec_fsm_master_action_process_eeprom(fsm))

   424

            return; // EEPROM write request found

   425

    }

   426

   427

    fsm->state = ec_fsm_master_state_end;

   428

}

   429

   430

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

   431

   432

/**

   433

   Master action: Get state of next slave.

   434

*/

   435

   436

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   437

                                           /**< master state machine */)

   438

{

   439

    ec_master_t *master = fsm->master;

   440

    ec_slave_t *slave = fsm->slave;

   441

   442

    // is there another slave to query?

   443

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

   444

        // process next slave

   445

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

   446

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

   447

                         0x0130, 2);

   448

        ec_master_queue_datagram(master, fsm->datagram);

   449

        fsm->retries = EC_FSM_RETRIES;

   450

        fsm->state = ec_fsm_master_state_read_states;

   451

        return;

   452

    }

   453

   454

    // all slave states read

   455

   456

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

   457

    if (fsm->validate) {

   458

        fsm->validate = 0;

   459

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

   460

            if (slave->online) continue;

   461

   462

            // At least one slave is offline. validate!

   463

            EC_INFO("Validating bus.\n");

   464

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

   465

            fsm->state = ec_fsm_master_state_validate_vendor;

   466

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

   467

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

   468

            return;

   469

        }

   470

    }

   471

   472

    ec_fsm_master_action_process_states(fsm);

   473

}

   474

   475

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

   476

   477

/**

   478

   Master state: READ STATES.

   479

   Fetches the AL- and online state of a slave.

   480

*/

   481

   482

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

   483

{

   484

    ec_slave_t *slave = fsm->slave;

   485

    ec_datagram_t *datagram = fsm->datagram;

   486

    uint8_t new_state;

   487

   488

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

   489

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

   490