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

    fsm->tainted = 0;

    82

    83

    // init sub-state-machines

    84

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

    85

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

    86

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

    87

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

    88

}

    89

    90

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

    91

    92

/**

    93

   Destructor.

    94

*/

    95

    96

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

    97

{

    98

    // clear sub-state machines

    99

    ec_fsm_slave_clear(&fsm->fsm_slave);

   100

    ec_fsm_sii_clear(&fsm->fsm_sii);

   101

    ec_fsm_change_clear(&fsm->fsm_change);

   102

    ec_fsm_coe_clear(&fsm->fsm_coe);

   103

}

   104

   105

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

   106

   107

/**

   108

   Executes the current state of the state machine.

   109

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

   110

   of the state machine is delayed to the next cycle.

   111

   \return false, if state machine has terminated

   112

*/

   113

   114

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

   115

{

   116

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

   117

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

   118

        // datagram was not sent or received yet.

   119

        return ec_fsm_master_running(fsm);

   120

    }

   121

   122

    fsm->state(fsm);

   123

    return ec_fsm_master_running(fsm);

   124

}

   125

   126

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

   127

   128

/**

   129

   \return false, if state machine has terminated

   130

*/

   131

   132

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

   133

{

   134

    return fsm->state != ec_fsm_master_state_end

   135

        && fsm->state != ec_fsm_master_state_error;

   136

}

   137

   138

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

   139

 *  master state machine

   140

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

   141

   142

/**

   143

   Master state: START.

   144

   Starts with getting slave count and slave states.

   145

*/

   146

   147

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   148

{

   149

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

   150

    fsm->state = ec_fsm_master_state_broadcast;

   151

}

   152

   153

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

   154

   155

/**

   156

   Master state: BROADCAST.

   157

   Processes the broadcast read slave count and slaves states.

   158

*/

   159

   160

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

   161

{

   162

    ec_datagram_t *datagram = fsm->datagram;

   163

    unsigned int i;

   164

    ec_slave_t *slave;

   165

    ec_master_t *master = fsm->master;

   166

   167

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   168

        return; // always retry

   169

   170

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

   171

        // link is down

   172

        fsm->slaves_responding = 0;

   173

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

   174

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   175

        }

   176

        fsm->state = ec_fsm_master_state_error;

   177

        return;

   178

    }

   179

   180

    // bus topology change?

   181

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

   182

        fsm->topology_change_pending = 1;

   183

        fsm->slaves_responding = datagram->working_counter;

   184

   185

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

   186

                fsm->slaves_responding,

   187

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

   188

   189

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   190

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

   191

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

   192

            }

   193

            else {

   194

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

   195

                fsm->tainted = 1;

   196

            }

   197

        }

   198

    }

   199

   200

    // slave states changed?

   201

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

   202

        char states[EC_STATE_STRING_SIZE];

   203

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

   204

        ec_state_string(fsm->slave_states, states);

   205

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

   206

    }

   207

   208

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

   209

    if (fsm->topology_change_pending &&

   210

            master->mode == EC_MASTER_MODE_IDLE) {

   211

        fsm->topology_change_pending = 0;

   213

   214

        ec_master_eoe_stop(master);

   215

        ec_master_destroy_slaves(master);

   216

   217

        master->slave_count = datagram->working_counter;

   218

   219

        if (!master->slave_count) {

   220

            // no slaves present -> finish state machine.

   221

            fsm->state = ec_fsm_master_state_end;

   222

            return;

   223

        }

   224

   225

        // init slaves

   226

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

   227

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

   228

                                                 GFP_ATOMIC))) {

   229

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

   230

                ec_master_destroy_slaves(master);

   231

                fsm->state = ec_fsm_master_state_error;

   232

                return;

   233

            }

   234

   235

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

   236

                // freeing of "slave" already done

   237

                ec_master_destroy_slaves(master);

   238

                fsm->state = ec_fsm_master_state_error;

   239

                return;

   240

            }

   241

   242

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

   243

        }

   244

   245

        EC_INFO("Scanning bus.\n");

   246

   247

        // begin scanning of slaves

   248

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

   249

        fsm->state = ec_fsm_master_state_scan_slaves;

   250

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

   251

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

   252

        return;

   253

    }

   254

   255

    // fetch state from each slave

   256

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

   257

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

   258

    fsm->retries = EC_FSM_RETRIES;

   259

    fsm->state = ec_fsm_master_state_read_states;

   260

}

   261

   262

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

   263

   264

/**

   265

 * Check for pending EEPROM write requests and process one.

   266

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

   267

 */

   268

   269

int ec_fsm_master_action_process_eeprom(

   270

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

   271

        )

   272

{

   273

    ec_master_t *master = fsm->master;

   274

    ec_eeprom_write_request_t *request;

   275

    ec_slave_t *slave;

   276

   277

    // search the first request to be processed

   278

    while (1) {

   279

        down(&master->eeprom_sem);

   280

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

   281

            up(&master->eeprom_sem);

   282

            break;

   283

        }

   284

        // get first request

   285

        request = list_entry(master->eeprom_requests.next,

   286

                ec_eeprom_write_request_t, list);

   287

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

   288

        request->state = EC_EEPROM_REQ_BUSY;

   289

        up(&master->eeprom_sem);

   290

   291

        slave = request->slave;

   292

        if (slave->online_state == EC_SLAVE_OFFLINE || slave->error_flag) {

   293

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

   294

                    slave->ring_position);

   295

            request->state = EC_EEPROM_REQ_ERROR;

   296

            wake_up(&master->eeprom_queue);

   297

            continue;

   298

        }

   299

   300

        // found pending EEPROM write operation. execute it!

   301

        if (master->debug_level)

   302

            EC_DBG("Writing EEPROM data to slave %i...\n",

   303

                    slave->ring_position);

   304

        fsm->eeprom_request = request;

   305

        fsm->eeprom_index = 0;

   306

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

   307

                request->words, EC_FSM_SII_NODE);

   308

        fsm->state = ec_fsm_master_state_write_eeprom;

   309

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

   310

        return 1;

   311

    }

   312

   313

    return 0;

   314

}

   315

   316

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

   317

   318

/**

   319

   Master action: PROC_STATES.

   320

   Processes the slave states.

   321

*/

   322

   323

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   324

                                         /**< master state machine */

   325

                                         )

   326

{

   327

    ec_master_t *master = fsm->master;

   328

    ec_slave_t *slave;

   329

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   330

   331

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

   332

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

   333

        if (slave->error_flag

   334

            || slave->online_state == EC_SLAVE_OFFLINE

   335

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   336

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

   337

                && slave->self_configured)) continue;

   338

   339

        if (master->debug_level) {

   340

            ec_state_string(slave->current_state, old_state);

   341

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

   342

                ec_state_string(slave->requested_state, new_state);

   343

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

   344

                       slave->ring_position, old_state, new_state);

   345

            }

   346

            else if (!slave->self_configured) {

   347

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

   348

                       slave->ring_position, old_state);

   349

            }

   350

        }

   351

   352

        fsm->slave = slave;

   353

        fsm->state = ec_fsm_master_state_configure_slave;

   354

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   355

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

   356

        return;

   357

    }

   358

   359

    // Check, if EoE processing has to be started

   360

    ec_master_eoe_start(master);

   361

   362

    if (master->mode == EC_MASTER_MODE_IDLE) {

   363

   364

        // Check for a pending SDO request

   365

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

   366

            if (master->debug_level)

   367

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

   368

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

   369

            if (slave->current_state == EC_SLAVE_STATE_INIT

   370

                || slave->online_state == EC_SLAVE_OFFLINE) {

   371

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

   372

                       slave->ring_position);

   373

                master->sdo_request->return_code = -1;

   374

                master->sdo_seq_master++;

   375

            }

   376

            else {

   377

                // start uploading SDO

   378

                fsm->slave = slave;

   379

                fsm->sdo_request = master->sdo_request;

   380

                fsm->state = ec_fsm_master_state_sdo_request;

   381

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

   382

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

   383

                return;

   384

            }

   385

        }

   386

   387

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

   388

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

   389

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   390

                || slave->sdo_dictionary_fetched

   391

                || slave->current_state == EC_SLAVE_STATE_INIT

   392

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

   393

                || slave->online_state == EC_SLAVE_OFFLINE

   394

                || slave->error_flag) continue;

   395

   396

            if (master->debug_level) {

   397

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

   398

                       slave->ring_position);

   399

            }

   400

   401

            slave->sdo_dictionary_fetched = 1;

   402

   403

            // start fetching SDO dictionary

   404

            fsm->slave = slave;

   405

            fsm->state = ec_fsm_master_state_sdodict;

   406

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   407

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

   408

            return;

   409

        }

   410

   411

        // check for pending EEPROM write operations.

   412

        if (ec_fsm_master_action_process_eeprom(fsm))

   413

            return; // EEPROM write request found

   414

    }

   415

   416

    fsm->state = ec_fsm_master_state_end;

   417

}

   418

   419

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

   420

   421

/**

   422

   Master action: Get state of next slave.

   423

*/

   424

   425

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   426

                                           /**< master state machine */)

   427

{

   428

    ec_master_t *master = fsm->master;

   429

    ec_slave_t *slave = fsm->slave;

   430

   431

    // is there another slave to query?

   432

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

   433

        // process next slave

   434

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

   435

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

   436

                         0x0130, 2);

   437

        fsm->retries = EC_FSM_RETRIES;

   438

        fsm->state = ec_fsm_master_state_read_states;

   439

        return;

   440

    }

   441

   442

    // all slave states read

   443

   444

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

   445

    if (fsm->validate) {

   446

        fsm->validate = 0;

   447

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

   448

            if (slave->online_state == EC_SLAVE_ONLINE) continue;

   449

   450

            // At least one slave is offline. validate!

   451

            EC_INFO("Validating bus.\n");

   452

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

   453

            fsm->state = ec_fsm_master_state_validate_vendor;

   454

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

   455

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

   456

            return;

   457

        }

   458

    }

   459

   460

    ec_fsm_master_action_process_states(fsm);

   461

}

   462

   463

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

   464

   465

/**

   466

   Master state: READ STATES.

   467

   Fetches the AL- and online state of a slave.

   468

*/

   469

   470

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

   471

{

   472

    ec_slave_t *slave = fsm->slave;

   473

    ec_datagram_t *datagram = fsm->datagram;

   474

   475

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

   476

        return;

   477

   478

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   479

        EC_ERR("Failed to receive AL state datagram for slave %i"

   480

                " (datagram state %i)\n", slave->ring_position, datagram->state);

   481

        fsm->state = ec_fsm_master_state_error;

   482

        return;

   483

    }

   484

   485

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

   486

    if (datagram->working_counter != 1) {

   487

        ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   488

        ec_fsm_master_action_next_slave_state(fsm);