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

   140

/**

   141

   \return true, if the master state machine terminated gracefully

   142

*/

   143

   144

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

   145

{

   146

    return fsm->state == ec_fsm_master_state_end;

   147

}

   148

   149

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

   150

 *  operation/idle state machine

   151

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

   152

   153

/**

   154

   Master state: START.

   155

   Starts with getting slave count and slave states.

   156

*/

   157

   158

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   159

{

   160

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

   161

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

   162

    fsm->state = ec_fsm_master_state_broadcast;

   163

}

   164

   165

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

   166

   167

/**

   168

   Master state: BROADCAST.

   169

   Processes the broadcast read slave count and slaves states.

   170

*/

   171

   172

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

   173

{

   174

    ec_datagram_t *datagram = fsm->datagram;

   175

    unsigned int i;

   176

    ec_slave_t *slave;

   177

    ec_master_t *master = fsm->master;

   178

   179

    if (datagram->state == EC_DATAGRAM_TIMED_OUT) {

   180

        // always retry

   181

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

   182

        return;

   183

    }

   184

   185

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

   186

        // link is down

   187

        fsm->slaves_responding = 0;

   188

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

   189

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   190

        }

   191

        fsm->state = ec_fsm_master_state_error;

   192

        return;

   193

    }

   194

   195

    // bus topology change?

   196

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

   197

        fsm->topology_change_pending = 1;

   198

        fsm->slaves_responding = datagram->working_counter;

   199

   200

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

   201

                fsm->slaves_responding,

   202

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

   203

   204

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   205

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

   206

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

   207

            }

   208

            else {

   209

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

   210

                fsm->tainted = 1;

   211

            }

   212

        }

   213

    }

   214

   215

    // slave states changed?

   216

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

   217

        char states[EC_STATE_STRING_SIZE];

   218

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

   219

        ec_state_string(fsm->slave_states, states);

   220

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

   221

    }

   222

   223

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

   224

    if (fsm->topology_change_pending &&

   225

            master->mode == EC_MASTER_MODE_IDLE) {

   226

        fsm->topology_change_pending = 0;

   227

   228

        ec_master_eoe_stop(master);

   229

        ec_master_destroy_slaves(master);

   230

   231

        master->slave_count = datagram->working_counter;

   232

   233

        if (!master->slave_count) {

   234

            // no slaves present -> finish state machine.

   235

            fsm->state = ec_fsm_master_state_end;

   236

            return;

   237

        }

   238

   239

        // init slaves

   240

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

   241

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

   242

                                                 GFP_ATOMIC))) {

   243

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

   244

                ec_master_destroy_slaves(master);

   245

                fsm->state = ec_fsm_master_state_error;

   246

                return;

   247

            }

   248

   249

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

   250

                // freeing of "slave" already done

   251

                ec_master_destroy_slaves(master);

   252

                fsm->state = ec_fsm_master_state_error;

   253

                return;

   254

            }

   255

   256

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

   257

        }

   258

   259

        EC_INFO("Scanning bus.\n");

   260

   261

        // begin scanning of slaves

   262

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

   263

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

   264

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

   265

        fsm->state = ec_fsm_master_state_scan_slaves;

   266

        return;

   267

    }

   268

   269

    // fetch state from each slave

   270

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

   271

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

   272

    ec_master_queue_datagram(master, fsm->datagram);

   273

    fsm->retries = EC_FSM_RETRIES;

   274

    fsm->state = ec_fsm_master_state_read_states;

   275

}

   276

   277

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

   278

   279

/**

   280

 * Check for pending EEPROM write requests and process one.

   281

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

   282

 */

   283

   284

int ec_fsm_master_action_process_eeprom(

   285

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

   286

        )

   287

{

   288

    ec_master_t *master = fsm->master;

   289

    ec_eeprom_write_request_t *request;

   290

    ec_slave_t *slave;

   291

   292

    // search the first request to be processed

   293

    while (1) {

   294

        down(&master->eeprom_sem);

   295

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

   296

            up(&master->eeprom_sem);

   297

            break;

   298

        }

   299

        // get first request

   300

        request = list_entry(master->eeprom_requests.next,

   301

                ec_eeprom_write_request_t, list);

   302

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

   303

        request->state = EC_EEPROM_REQ_BUSY;

   304

        up(&master->eeprom_sem);

   305

   306

        slave = request->slave;

   307

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

   308

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

   309

                    slave->ring_position);

   310

            request->state = EC_EEPROM_REQ_ERROR;

   311

            wake_up(&master->eeprom_queue);

   312

            continue;

   313

        }

   314

   315

        // found pending EEPROM write operation. execute it!

   316

        if (master->debug_level)

   317

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

   318

                    slave->ring_position);

   319

        fsm->eeprom_request = request;

   320

        fsm->eeprom_index = 0;

   321

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

   322

                request->words, EC_FSM_SII_NODE);

   323

        fsm->state = ec_fsm_master_state_write_eeprom;

   324

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

   325

        return 1;

   326

    }

   327

   328

    return 0;

   329

}

   330

   331

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

   332

   333

/**

   334

   Master action: PROC_STATES.

   335

   Processes the slave states.

   336

*/

   337

   338

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   339

                                         /**< master state machine */

   340

                                         )

   341

{

   342

    ec_master_t *master = fsm->master;

   343

    ec_slave_t *slave;

   344

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   345

   346

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

   347

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

   348

        if (slave->error_flag

   349

            || slave->online_state == EC_SLAVE_OFFLINE

   350

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   351

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

   352

                && slave->self_configured)) continue;

   353

   354

        if (master->debug_level) {

   355

            ec_state_string(slave->current_state, old_state);

   356

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

   357

                ec_state_string(slave->requested_state, new_state);

   358

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

   359

                       slave->ring_position, old_state, new_state);

   360

            }

   361

            else if (!slave->self_configured) {

   362

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

   363

                       slave->ring_position, old_state);

   364

            }

   365

        }

   366

   367

        fsm->slave = slave;

   368

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   369

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

   370

        fsm->state = ec_fsm_master_state_configure_slave;

   371

        return;

   372

    }

   373

   374

    // Check, if EoE processing has to be started

   375

    ec_master_eoe_start(master);

   376

   377

    if (master->mode == EC_MASTER_MODE_IDLE) {

   378

   379

        // Check for a pending SDO request

   380

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

   381

            if (master->debug_level)

   382

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

   383

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

   384

            if (slave->current_state == EC_SLAVE_STATE_INIT

   385

                || slave->online_state == EC_SLAVE_OFFLINE) {

   386

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

   387

                       slave->ring_position);

   388

                master->sdo_request->return_code = -1;

   389

                master->sdo_seq_master++;

   390

            }

   391

            else {

   392

                // start uploading SDO

   393

                fsm->slave = slave;

   394

                fsm->state = ec_fsm_master_state_sdo_request;

   395

                fsm->sdo_request = master->sdo_request;

   396

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

   397

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

   398

                return;

   399

            }

   400

        }

   401

   402

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

   403

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

   404

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   405

                || slave->sdo_dictionary_fetched

   406

                || slave->current_state == EC_SLAVE_STATE_INIT

   407

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

   408

                || slave->online_state == EC_SLAVE_OFFLINE

   409

                || slave->error_flag) continue;

   410

   411

            if (master->debug_level) {

   412

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

   413

                       slave->ring_position);

   414

            }

   415

   416

            slave->sdo_dictionary_fetched = 1;

   417

   418

            // start fetching SDO dictionary

   419

            fsm->slave = slave;

   420

            fsm->state = ec_fsm_master_state_sdodict;

   421

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   422

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

   423

            return;

   424

        }

   425

   426

        // check for pending EEPROM write operations.

   427

        if (ec_fsm_master_action_process_eeprom(fsm))

   428

            return; // EEPROM write request found

   429

    }

   430

   431

    fsm->state = ec_fsm_master_state_end;

   432

}

   433

   434

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

   435

   436

/**

   437

   Master action: Get state of next slave.

   438

*/

   439

   440

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   441

                                           /**< master state machine */)

   442

{

   443

    ec_master_t *master = fsm->master;

   444

    ec_slave_t *slave = fsm->slave;

   445

   446

    // is there another slave to query?

   447

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

   448

        // process next slave

   449

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

   450

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

   451

                         0x0130, 2);

   452

        ec_master_queue_datagram(master, fsm->datagram);

   453

        fsm->retries = EC_FSM_RETRIES;

   454

        fsm->state = ec_fsm_master_state_read_states;

   455

        return;

   456

    }

   457

   458

    // all slave states read

   459

   460

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

   461

    if (fsm->validate) {

   462

        fsm->validate = 0;

   463

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

   464

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

   465

   466

            // At least one slave is offline. validate!

   467

            EC_INFO("Validating bus.\n");

   468

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

   469

            fsm->state = ec_fsm_master_state_validate_vendor;

   470

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

   471

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

   472

            return;

   473

        }

   474

    }

   475

   476

    ec_fsm_master_action_process_states(fsm);

   477

}

   478

   479

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

   480

   481

/**

   482

   Master state: READ STATES.

   483

   Fetches the AL- and online state of a slave.

   484

*/

   485

   486

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

   487

{

   488

    ec_slave_t *slave = fsm->slave;

   489

    ec_datagram_t *datagram = fsm->datagram;