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

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   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

   301

        request->state = EC_EEPROM_REQ_BUSY;

   302

        up(&master->eeprom_sem);

   303

   304

        slave = request->slave;

   305

        if (slave->online_state == EC_SLAVE_OFFLINE || 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;

   309

            wake_up(&master->eeprom_queue);

   310

            continue;

   311

        }

   312

   313

        // found pending EEPROM write operation. execute it!

   314

        if (master->debug_level)

   315

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

   316

                    slave->ring_position);

   317

        fsm->eeprom_request = request;

   318

        fsm->eeprom_index = 0;

   319

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

   320

                request->words, EC_FSM_SII_NODE);

   321

        fsm->state = ec_fsm_master_state_write_eeprom;

   322

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

   323

        return 1;

   324

    }

   325

   326

    return 0;

   327

}

   328

   329

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

   330

   331

/**

   332

   Master action: PROC_STATES.

   333

   Processes the slave states.

   334

*/

   335

   336

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   337

                                         /**< master state machine */

   338

                                         )

   339

{

   340

    ec_master_t *master = fsm->master;

   341

    ec_slave_t *slave;

   342

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   343

   344

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

   345

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

   346

        if (slave->error_flag

   347

            || slave->online_state == EC_SLAVE_OFFLINE

   348

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   349

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

   350

                && slave->self_configured)) continue;

   351

   352

        if (master->debug_level) {

   353

            ec_state_string(slave->current_state, old_state);

   354

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

   355

                ec_state_string(slave->requested_state, new_state);

   356

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

   357

                       slave->ring_position, old_state, new_state);

   358

            }

   359

            else if (!slave->self_configured) {

   360

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

   361

                       slave->ring_position, old_state);

   362

            }

   363

        }

   364

   365

        fsm->slave = slave;

   366

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   367

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

   368

        fsm->state = ec_fsm_master_state_configure_slave;

   369

        return;

   370

    }

   371

   372

    // Check, if EoE processing has to be started

   373

    ec_master_eoe_start(master);

   374

   375

    if (master->mode == EC_MASTER_MODE_IDLE) {

   376

   377

        // Check for a pending SDO request

   378

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

   379

            if (master->debug_level)

   380

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

   381

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

   382

            if (slave->current_state == EC_SLAVE_STATE_INIT

   383

                || slave->online_state == EC_SLAVE_OFFLINE) {

   384

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

   385

                       slave->ring_position);

   386

                master->sdo_request->return_code = -1;

   387

                master->sdo_seq_master++;

   388

            }

   389

            else {

   390

                // start uploading SDO

   391

                fsm->slave = slave;

   392

                fsm->state = ec_fsm_master_state_sdo_request;

   393

                fsm->sdo_request = master->sdo_request;

   394

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

   395

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

   396

                return;

   397

            }

   398

        }

   399

   400

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

   401

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

   402

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   403

                || slave->sdo_dictionary_fetched

   404

                || slave->current_state == EC_SLAVE_STATE_INIT

   405

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

   406

                || slave->online_state == EC_SLAVE_OFFLINE

   407

                || slave->error_flag) continue;

   408

   409

            if (master->debug_level) {

   410

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

   411

                       slave->ring_position);

   412

            }

   413

   414

            slave->sdo_dictionary_fetched = 1;

   415

   416

            // start fetching SDO dictionary

   417

            fsm->slave = slave;

   418

            fsm->state = ec_fsm_master_state_sdodict;

   419

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   420

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

   421

            return;

   422

        }

   423

   424

        // check for pending EEPROM write operations.

   425

        if (ec_fsm_master_action_process_eeprom(fsm))

   426

            return; // EEPROM write request found

   427

    }

   428

   429

    fsm->state = ec_fsm_master_state_end;

   430

}

   431

   432

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

   433

   434

/**

   435

   Master action: Get state of next slave.

   436

*/

   437

   438

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   439

                                           /**< master state machine */)

   440

{

   441

    ec_master_t *master = fsm->master;

   442

    ec_slave_t *slave = fsm->slave;

   443

   444

    // is there another slave to query?

   445

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

   446

        // process next slave

   447

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

   448

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

   449

                         0x0130, 2);

   450

        ec_master_queue_datagram(master, fsm->datagram);

   451

        fsm->retries = EC_FSM_RETRIES;

   452

        fsm->state = ec_fsm_master_state_read_states;

   453

        return;

   454

    }

   455

   456

    // all slave states read

   457

   458

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

   459

    if (fsm->validate) {

   460

        fsm->validate = 0;

   461

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

   462

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

   463

   464

            // At least one slave is offline. validate!

   465

            EC_INFO("Validating bus.\n");

   466

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

   467

            fsm->state = ec_fsm_master_state_validate_vendor;

   468

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

   469

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

   470

            return;

   471

        }

   472

    }

   473

   474

    ec_fsm_master_action_process_states(fsm);

   475

}

   476

   477

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

   478

   479

/**

   480

   Master state: READ STATES.

   481

   Fetches the AL- and online state of a slave.

   482

*/

   483

   484

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

   485

{

   486

    ec_slave_t *slave = fsm->slave;

   487

    ec_datagram_t *datagram = fsm->datagram;

   488

   489

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