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;

    78

    fsm->slaves_responding = 0;

    79

    fsm->topology_change_pending = 0;

    80

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    81

    fsm->validate = 0;

    82

    fsm->tainted = 0;

    83

    84

    // init sub-state-machines

    85

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

    86

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

    87

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

    88

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

    89

}

    90

    91

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

    92

    93

/**

    94

   Destructor.

    95

*/

    96

    97

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

    98

{

    99

    // clear sub-state machines

   100

    ec_fsm_slave_clear(&fsm->fsm_slave);

   101

    ec_fsm_sii_clear(&fsm->fsm_sii);

   102

    ec_fsm_change_clear(&fsm->fsm_change);

   103

    ec_fsm_coe_clear(&fsm->fsm_coe);

   104

}

   105

   106

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

   107

   108

/**

   109

   Executes the current state of the state machine.

   110

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

   111

   of the state machine is delayed to the next cycle.

   112

   \return false, if state machine has terminated

   113

*/

   114

   115

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

   116

{

   117

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

   118

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

   119

        // datagram was not sent or received yet.

   120

        return ec_fsm_master_running(fsm);

   121

    }

   122

   123

    fsm->state(fsm);

   124

    return ec_fsm_master_running(fsm);

   125

}

   126

   127

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

   128

   129

/**

   136

{

   137

    return fsm->state != ec_fsm_master_state_end

   138

        && fsm->state != ec_fsm_master_state_error;

   139

}

   140

   154

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

   155

 *  master state machine

   156

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

   157

   158

/**

   159

   Master state: START.

   160

   Starts with getting slave count and slave states.

   161

*/

   162

   163

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   164

{

   166

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

   167

    fsm->state = ec_fsm_master_state_broadcast;

   168

}

   169

   170

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

   171

   172

/**

   173

   Master state: BROADCAST.

   174

   Processes the broadcast read slave count and slaves states.

   175

*/

   176

   177

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

   178

{

   179

    ec_datagram_t *datagram = fsm->datagram;

   180

    unsigned int i;

   181

    ec_slave_t *slave;

   182

    ec_master_t *master = fsm->master;

   183

   184

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   185

        return; // always retry

   186

   188

        fsm->slaves_responding = 0;

   189

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

   190

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   191

        }

   192

        fsm->state = ec_fsm_master_state_error;

   193

        return;

   194

    }

   195

   196

    // bus topology change?

   197

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

   198

        fsm->topology_change_pending = 1;

   199

        fsm->slaves_responding = datagram->working_counter;

   200

   201

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

   202

                fsm->slaves_responding,

   203

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

   204

   205

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   206

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

   207

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

   208

            }

   209

            else {

   210

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

   211

                fsm->tainted = 1;

   212

            }

   213

        }

   214

    }

   215

   216

    // slave states changed?

   217

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

   218

        char states[EC_STATE_STRING_SIZE];

   219

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

   220

        ec_state_string(fsm->slave_states, states);

   221

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

   222

    }

   223

   224

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

   225

    if (fsm->topology_change_pending &&

   226

            master->mode == EC_MASTER_MODE_IDLE) {

   227

        fsm->topology_change_pending = 0;

   228

        fsm->tainted = 0;

   230

   231

        ec_master_eoe_stop(master);

   232

        ec_master_destroy_slaves(master);

   233

   234

        master->slave_count = datagram->working_counter;

   235

   236

        if (!master->slave_count) {

   237

            // no slaves present -> finish state machine.

   238

            fsm->state = ec_fsm_master_state_end;

   239

            return;

   240

        }

   241

   242

        // init slaves

   243

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

   244

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

   245

                                                 GFP_ATOMIC))) {

   246

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

   247

                ec_master_destroy_slaves(master);

   248

                fsm->state = ec_fsm_master_state_error;

   249

                return;

   250

            }

   251

   252

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

   253

                // freeing of "slave" already done

   254

                ec_master_destroy_slaves(master);

   255

                fsm->state = ec_fsm_master_state_error;

   256

                return;

   257

            }

   258

   259

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

   260

        }

   261

   262

        EC_INFO("Scanning bus.\n");

   263

   264

        // begin scanning of slaves

   265

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

   266

        fsm->state = ec_fsm_master_state_scan_slaves;

   267

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

   268

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

   269

        return;

   270

    }

   271

   272

    // fetch state from each slave

   273

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

   274

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

   275

    fsm->retries = EC_FSM_RETRIES;

   276

    fsm->state = ec_fsm_master_state_read_states;

   277

}

   278

   279

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

   280

   281

/**

   282

 * Check for pending EEPROM write requests and process one.

   283

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

   284

 */

   285

   286

int ec_fsm_master_action_process_eeprom(

   287

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

   288

        )

   289

{

   290

    ec_master_t *master = fsm->master;

   291

    ec_eeprom_write_request_t *request;

   292

    ec_slave_t *slave;

   293

   294

    // search the first request to be processed

   295

    while (1) {

   296

        down(&master->eeprom_sem);

   297

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

   298

            up(&master->eeprom_sem);

   299

            break;

   300

        }

   301

        // get first request

   302

        request = list_entry(master->eeprom_requests.next,

   303

                ec_eeprom_write_request_t, list);

   304

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

   305

        request->state = EC_REQUEST_IN_PROGRESS;

   306

        up(&master->eeprom_sem);

   307

   308

        slave = request->slave;

   309

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

   310

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

   311

                    slave->ring_position);

   312

            request->state = EC_REQUEST_FAILURE;

   313

            wake_up(&master->eeprom_queue);

   314

            continue;

   315

        }

   316

   317

        // found pending EEPROM write operation. execute it!

   318

        if (master->debug_level)

   319

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

   320

                    slave->ring_position);

   321

        fsm->eeprom_request = request;

   322

        fsm->eeprom_index = 0;

   323

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

   324

                request->words, EC_FSM_SII_NODE);

   325

        fsm->state = ec_fsm_master_state_write_eeprom;

   326

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

   327

        return 1;

   328

    }

   329

   330

    return 0;

   331

}

   332

   333

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

   334

   335

/**

   336

 * Check for pending SDO requests and process one.

   337

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

   338

 */

   339

   340

int ec_fsm_master_action_process_sdo(

   341

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

   342

        )

   343

{

   344

    ec_master_t *master = fsm->master;

   345

    ec_sdo_request_t *request;

   346

    ec_slave_t *slave;

   347

   348

    // search the first request to be processed

   349

    while (1) {

   350

        down(&master->sdo_sem);

   351

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

   352

            up(&master->sdo_sem);

   353

            break;

   354

        }

   355

        // get first request

   356

        request =

   357

            list_entry(master->sdo_requests.next, ec_sdo_request_t, list);

   358

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

   359

        request->state = EC_REQUEST_IN_PROGRESS;

   360

        up(&master->sdo_sem);

   361

   362

        slave = request->sdo->slave;

   363

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   364

                slave->online_state == EC_SLAVE_OFFLINE ||

   365

                slave->error_flag) {

   366

            EC_ERR("Discarding SDO request, slave %i not ready.\n",

   367

                    slave->ring_position);

   368

            request->state = EC_REQUEST_FAILURE;

   369

            wake_up(&master->sdo_queue);

   370

            continue;

   371

        }

   372

   373

        // found pending SDO request. execute it!

   374

        if (master->debug_level)

   375

            EC_DBG("Processing SDO request for slave %i...\n",

   376

                    slave->ring_position);

   377

   378

        // start uploading SDO

   380

        fsm->slave = slave;

   381

        fsm->sdo_request = request;

   382

        fsm->state = ec_fsm_master_state_sdo_request;

   383

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

   384

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

   385

        return 1;

   386

    }

   387

   388

    return 0;

   389

}

   390

   391

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

   392

   393

/**

   394

   Master action: PROC_STATES.

   395

   Processes the slave states.

   396

*/

   397

   398

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   399

                                         /**< master state machine */

   400

                                         )

   401

{

   402

    ec_master_t *master = fsm->master;

   403

    ec_slave_t *slave;

   404

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   405

   406

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

   407

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

   408

        if (slave->error_flag

   409

            || slave->online_state == EC_SLAVE_OFFLINE

   410

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   411

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

   412

                && slave->self_configured)) continue;

   413

   414

        if (master->debug_level) {

   415

            ec_state_string(slave->current_state, old_state);

   416

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

   417

                ec_state_string(slave->requested_state, new_state);

   418

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

   419

                       slave->ring_position, old_state, new_state);

   420

            }

   421

            else if (!slave->self_configured) {

   422

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

   423

                       slave->ring_position, old_state);

   424

            }

   425

        }

   426

   428

        fsm->slave = slave;

   429

        fsm->state = ec_fsm_master_state_configure_slave;

   430

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   431

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

   432

        return;

   433

    }

   434

   435

    // Check, if EoE processing has to be started

   436

    ec_master_eoe_start(master);

   437

   438

    // Check for a pending SDO request

   439

    if (ec_fsm_master_action_process_sdo(fsm))

   440

        return;

   441

   442

    if (master->mode == EC_MASTER_MODE_IDLE) {

   443

   444

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

   445

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

   446

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   447

                || slave->sdo_dictionary_fetched

   448

                || slave->current_state == EC_SLAVE_STATE_INIT

   449

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

   450

                || slave->online_state == EC_SLAVE_OFFLINE

   451

                || slave->error_flag) continue;

   452

   453

            if (master->debug_level) {

   454

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

   455

                       slave->ring_position);

   456

            }

   457

   458

            slave->sdo_dictionary_fetched = 1;

   459

   460

            // start fetching SDO dictionary

   462

            fsm->slave = slave;

   463

            fsm->state = ec_fsm_master_state_sdodict;

   464

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   465

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

   466

            return;

   467

        }

   468

   469

        // check for pending EEPROM write operations.

   470

        if (ec_fsm_master_action_process_eeprom(fsm))

   471

            return; // EEPROM write request found

   472

    }

   473

   474

    fsm->state = ec_fsm_master_state_end;

   475

}

   476

   477

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

   478

   479

/**

   480

   Master action: Get state of next slave.

   481

*/

   482

   483

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   484

                                           /**< master state machine */)

   485

{

   486

    ec_master_t *master = fsm->master;

   487

    ec_slave_t *slave = fsm->slave;

   488

   489

    // is there another slave to query?