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;

   212

        fsm->tainted = 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_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_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

/**

   376

   Master action: PROC_STATES.

   377

   Processes the slave states.

   378

*/

   379

   380

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   381

                                         /**< master state machine */

   382

                                         )

   383

{

   384

    ec_master_t *master = fsm->master;

   385

    ec_slave_t *slave;

   386

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   387

   388

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

   389

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

   390

        if (slave->error_flag

   391

            || slave->online_state == EC_SLAVE_OFFLINE

   392

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   393

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

   394

                && slave->self_configured)) continue;

   395

   396

        if (master->debug_level) {

   397

            ec_state_string(slave->current_state, old_state);

   398

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

   399

                ec_state_string(slave->requested_state, new_state);

   400

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

   401

                       slave->ring_position, old_state, new_state);

   402

            }

   403

            else if (!slave->self_configured) {

   404

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

   405

                       slave->ring_position, old_state);

   406

            }

   407

        }

   408

   409

        fsm->slave = slave;

   410

        fsm->state = ec_fsm_master_state_configure_slave;

   411

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   412

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

   413

        return;

   414

    }

   415

   416

    // Check, if EoE processing has to be started

   417

    ec_master_eoe_start(master);

   418

   423

    if (master->mode == EC_MASTER_MODE_IDLE) {

   424

   425

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

   426

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

   427

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   428

                || slave->sdo_dictionary_fetched

   429

                || slave->current_state == EC_SLAVE_STATE_INIT

   430

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

   431

                || slave->online_state == EC_SLAVE_OFFLINE

   432

                || slave->error_flag) continue;

   433

   434

            if (master->debug_level) {

   435

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

   436

                       slave->ring_position);

   437

            }

   438

   439

            slave->sdo_dictionary_fetched = 1;

   440

   441

            // start fetching SDO dictionary

   442

            fsm->slave = slave;

   443

            fsm->state = ec_fsm_master_state_sdodict;

   444

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   445

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

   446

            return;

   447

        }

   448

   449

        // check for pending EEPROM write operations.

   450

        if (ec_fsm_master_action_process_eeprom(fsm))

   451

            return; // EEPROM write request found

   452

    }

   453

   454

    fsm->state = ec_fsm_master_state_end;

   455

}

   456

   457

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

   458

   459

/**

   460

   Master action: Get state of next slave.

   461

*/

   462

   463

void ec_fsm_master_action_next_slave_state(ec_fsm_master_t *fsm

   464

                                           /**< master state machine */)

   465

{

   466

    ec_master_t *master = fsm->master;

   467

    ec_slave_t *slave = fsm->slave;

   468

   469

    // is there another slave to query?

   470

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

   471

        // process next slave

   472

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

   473

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

   474

                         0x0130, 2);

   475

        fsm->retries = EC_FSM_RETRIES;

   476

        fsm->state = ec_fsm_master_state_read_states;

   477

        return;

   478

    }

   479

   480

    // all slave states read

   481

   482

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

   483

    if (fsm->validate) {

   484

        fsm->validate = 0;

   485

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

   486

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

   487

   488

            // At least one slave is offline. validate!

   489

            EC_INFO("Validating bus.\n");

   490

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