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 "fsm.h"

    43

#include "master.h"

    44

#include "mailbox.h"

    45

    46

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

    47

    48

void ec_fsm_master_start(ec_fsm_t *);

    49

void ec_fsm_master_broadcast(ec_fsm_t *);

    50

void ec_fsm_master_read_states(ec_fsm_t *);

    51

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    52

void ec_fsm_master_validate_product(ec_fsm_t *);

    53

void ec_fsm_master_rewrite_addresses(ec_fsm_t *);

    54

void ec_fsm_master_configure_slave(ec_fsm_t *);

    55

void ec_fsm_master_scan_slaves(ec_fsm_t *);

    56

void ec_fsm_master_write_eeprom(ec_fsm_t *);

    57

void ec_fsm_master_sdodict(ec_fsm_t *);

    58

void ec_fsm_master_sdo_request(ec_fsm_t *);

    59

void ec_fsm_master_end(ec_fsm_t *);

    60

void ec_fsm_master_error(ec_fsm_t *);

    61

    62

void ec_fsm_slavescan_start(ec_fsm_t *);

    63

void ec_fsm_slavescan_address(ec_fsm_t *);

    64

void ec_fsm_slavescan_state(ec_fsm_t *);

    65

void ec_fsm_slavescan_base(ec_fsm_t *);

    66

void ec_fsm_slavescan_datalink(ec_fsm_t *);

    67

void ec_fsm_slavescan_eeprom_size(ec_fsm_t *);

    68

void ec_fsm_slavescan_eeprom_data(ec_fsm_t *);

    69

    70

void ec_fsm_slaveconf_init(ec_fsm_t *);

    71

void ec_fsm_slaveconf_sync(ec_fsm_t *);

    72

void ec_fsm_slaveconf_preop(ec_fsm_t *);

    73

void ec_fsm_slaveconf_fmmu(ec_fsm_t *);

    74

void ec_fsm_slaveconf_sdoconf(ec_fsm_t *);

    75

void ec_fsm_slaveconf_saveop(ec_fsm_t *);

    76

void ec_fsm_slaveconf_op(ec_fsm_t *);

    77

    78

void ec_fsm_slave_end(ec_fsm_t *);

    79

void ec_fsm_slave_error(ec_fsm_t *);

    80

    81

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

    82

    83

/**

    84

   Constructor.

    85

*/

    86

    87

int ec_fsm_init(ec_fsm_t *fsm, /**< finite state machine */

    88

                ec_master_t *master /**< EtherCAT master */

    89

                )

    90

{

    91

    fsm->master = master;

    92

    fsm->master_state = ec_fsm_master_start;

    93

    fsm->master_slaves_responding = 0;

    94

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

    95

    fsm->master_validation = 0;

    96

    97

    ec_datagram_init(&fsm->datagram);

    98

    if (ec_datagram_prealloc(&fsm->datagram, EC_MAX_DATA_SIZE)) {

    99

        EC_ERR("Failed to allocate FSM datagram.\n");

   100

        return -1;

   101

    }

   102

   103

    // init sub-state-machines

   104

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

   105

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

   106

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

   107

   108

    return 0;

   109

}

   110

   111

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

   112

   113

/**

   114

   Destructor.

   115

*/

   116

   117

void ec_fsm_clear(ec_fsm_t *fsm /**< finite state machine */)

   118

{

   119

    // clear sub-state machines

   120

    ec_fsm_sii_clear(&fsm->fsm_sii);

   121

    ec_fsm_change_clear(&fsm->fsm_change);

   122

    ec_fsm_coe_clear(&fsm->fsm_coe);

   123

   124

    ec_datagram_clear(&fsm->datagram);

   125

}

   126

   127

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

   128

   129

/**

   130

   Executes the current state of the state machine.

   131

   \return false, if state machine has terminated

   132

*/

   133

   134

int ec_fsm_exec(ec_fsm_t *fsm /**< finite state machine */)

   135

{

   136

    fsm->master_state(fsm);

   137

   138

    return fsm->master_state != ec_fsm_master_end

   139

        && fsm->master_state != ec_fsm_master_error;

   140

}

   141

   142

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

   143

   144

/**

   145

   \return true, if the master state machine terminated gracefully

   146

*/

   147

   148

int ec_fsm_success(ec_fsm_t *fsm /**< finite state machine */)

   149

{

   150

    return fsm->master_state == ec_fsm_master_end;

   151

}

   152

   153

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

   154

 *  operation/idle state machine

   155

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

   156

   157

/**

   158

   Master state: START.

   159

   Starts with getting slave count and slave states.

   160

*/

   161

   162

void ec_fsm_master_start(ec_fsm_t *fsm)

   163

{

   164

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

   165

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

   166

    fsm->master_state = ec_fsm_master_broadcast;

   167

}

   168

   169

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

   170

   171

/**

   172

   Master state: BROADCAST.

   173

   Processes the broadcast read slave count and slaves states.

   174

*/

   175

   176

void ec_fsm_master_broadcast(ec_fsm_t *fsm /**< finite state machine */)

   177

{

   178

    ec_datagram_t *datagram = &fsm->datagram;

   179

    unsigned int topology_change, states_change, i;

   180

    ec_slave_t *slave;

   181

    ec_master_t *master = fsm->master;

   182

   183

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   184

        if (!master->device->link_state) {

   185

            fsm->master_slaves_responding = 0;

   186

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

   187

                slave->online = 0;

   188

            }

   189

        }

   190

        else {

   191

            EC_ERR("Failed to receive broadcast datagram.\n");

   192

        }

   193

        fsm->master_state = ec_fsm_master_error;

   194

        return;

   195

    }

   196

   197

    topology_change = (datagram->working_counter !=

   198

                       fsm->master_slaves_responding);

   199

    states_change = (EC_READ_U8(datagram->data) != fsm->master_slave_states);

   200

   201

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

   202

    fsm->master_slaves_responding = datagram->working_counter;

   203

   204

    if (topology_change) {

   205

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

   206

                fsm->master_slaves_responding,

   207

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

   208

   209

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   210

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

   211

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

   212

            }

   213

            else {

   214

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

   215

            }

   216

        }

   217

    }

   218

   219

    if (states_change) {

   220

        char states[EC_STATE_STRING_SIZE];

   221

        ec_state_string(fsm->master_slave_states, states);

   222

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

   223

    }

   224

   225

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

   226

    if (topology_change && master->mode == EC_MASTER_MODE_IDLE) {

   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->master_state = ec_fsm_master_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->master_state = ec_fsm_master_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->master_state = ec_fsm_master_error;

   253

                return;

   254

            }

   255

   256

            if (kobject_add(&slave->kobj)) {

   257

                EC_ERR("Failed to add kobject.\n");

   258

                kobject_put(&slave->kobj); // free

   259

                ec_master_destroy_slaves(master);

   260

                fsm->master_state = ec_fsm_master_error;

   261

                return;

   262

            }

   263

   264

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

   265

        }

   266

   267

        EC_INFO("Scanning bus.\n");

   268

   269

        // begin scanning of slaves

   270

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

   271

        fsm->slave_state = ec_fsm_slavescan_start;

   272

        fsm->master_state = ec_fsm_master_scan_slaves;

   273

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

   274

        return;

   275

    }

   276

   277

    // fetch state from each slave

   278

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

   279

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

   280

    ec_master_queue_datagram(master, &fsm->datagram);

   281

    fsm->master_state = ec_fsm_master_read_states;

   282

}

   283

   284

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

   285

   286

/**

   287

   Master action: PROC_STATES.

   288

   Processes the slave states.

   289

*/

   290

   291

void ec_fsm_master_action_process_states(ec_fsm_t *fsm

   292

                                         /**< finite state machine */

   293

                                         )

   294

{

   295

    ec_master_t *master = fsm->master;

   296

    ec_slave_t *slave;

   297

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   298

   299

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

   300

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

   301

        if (slave->error_flag

   302

            || !slave->online

   303

            || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   304

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

   305

                && (slave->configured

   306

                    || slave->current_state == EC_SLAVE_STATE_INIT))) continue;

   307

   308

        if (master->debug_level) {

   309

            ec_state_string(slave->current_state, old_state);

   310

            if (!slave->configured

   311

                && slave->current_state != EC_SLAVE_STATE_INIT) {

   312

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

   313

                        slave->ring_position, old_state);

   314

            }

   315

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

   316

                ec_state_string(slave->requested_state, new_state);

   317

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

   318

                        slave->ring_position, old_state, new_state);

   319

            }

   320

        }

   321

   322

        fsm->slave = slave;

   323

        fsm->slave_state = ec_fsm_slaveconf_init;

   324

        ec_fsm_change(&fsm->fsm_change, fsm->slave, EC_SLAVE_STATE_INIT);

   325

        fsm->master_state = ec_fsm_master_configure_slave;

   326

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

   327

        return;

   328

    }

   329

   330

    // Check, if EoE processing has to be started

   331

    ec_master_eoe_start(master);

   332

   333

    if (master->mode == EC_MASTER_MODE_IDLE) {

   334

   335

        // Check for a pending SDO request

   336

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

   337

            if (master->debug_level)

   338

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

   339

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

   340

            if (slave->current_state == EC_SLAVE_STATE_INIT

   341

                || !slave->online

   342

                || slave->error_flag) {

   343

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

   344

                       slave->ring_position);

   345

                master->sdo_request->return_code = -1;

   346

                master->sdo_seq_master++;

   347

            }

   348

            else {

   349

                // start uploading SDO

   350

                fsm->slave = slave;

   351

                fsm->master_state = ec_fsm_master_sdo_request;

   352

                fsm->sdo_request = master->sdo_request;

   353

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

   354

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

   355

                return;

   356

            }

   357

        }

   358

   359

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

   360

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

   361

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   362

                || slave->sdo_dictionary_fetched

   363

                || slave->current_state == EC_SLAVE_STATE_INIT

   364

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

   365

                || !slave->online

   366

                || slave->error_flag) continue;

   367

   368

            if (master->debug_level) {

   369

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

   370

                       slave->ring_position);

   371

            }

   372

   373

            if (kobject_add(&slave->sdo_kobj)) {

   374

                EC_ERR("Failed to add SDO kobj of slave %i.\n",

   375

                       slave->ring_position);

   376

                slave->error_flag = 1;

   377

                fsm->master_state = ec_fsm_master_error;

   378

                return;

   379

            }

   380

   381

            slave->sdo_dictionary_fetched = 1;

   382

   383

            // start fetching SDO dictionary

   384

            fsm->slave = slave;

   385

            fsm->master_state = ec_fsm_master_sdodict;

   386

            ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);

   387

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

   388

            return;

   389

        }

   390

   391

        // check for pending EEPROM write operations.

   392

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

   393

            if (!slave->new_eeprom_data) continue;

   394

   395

            if (!slave->online || slave->error_flag) {

   396

                kfree(slave->new_eeprom_data);

   397

                slave->new_eeprom_data = NULL;

   398

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

   399

                       slave->ring_position);

   400

                continue;

   401

            }

   402

   403

            // found pending EEPROM write operation. execute it!

   404

            EC_INFO("Writing EEPROM of slave %i...\n", slave->ring_position);

   405

            fsm->sii_offset = 0x0000;

   406

            ec_fsm_sii_write(&fsm->fsm_sii, slave, fsm->sii_offset,

   407

                             slave->new_eeprom_data, EC_FSM_SII_NODE);

   408

            fsm->master_state = ec_fsm_master_write_eeprom;

   409

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

   410

            return;

   411

        }

   412

    }

   413

   414

    fsm->master_state = ec_fsm_master_end;

   415

}

   416

   417

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

   418

   419

/**

   420

   Master action: Get state of next slave.

   421

*/

   422

   423

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   424

                                           /**< finite state machine */)

   425

{

   426

    ec_master_t *master = fsm->master;

   427

    ec_slave_t *slave = fsm->slave;

   428

   429

    // is there another slave to query?

   430

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

   431

        // process next slave

   432

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

   433

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

   434

                         0x0130, 2);

   435

        ec_master_queue_datagram(master, &fsm->datagram);

   436

        fsm->master_state = ec_fsm_master_read_states;

   437

        return;

   438

    }

   439

   440

    // all slave states read

   441

   442

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

   443

    if (fsm->master_validation) {

   444

        fsm->master_validation = 0;

   445

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

   446

            if (slave->online) continue;

   447

   448

            // At least one slave is offline. validate!

   449

            EC_INFO("Validating bus.\n");

   450

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

   451

            fsm->master_state = ec_fsm_master_validate_vendor;

   452

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

   453

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

   454

            return;

   455

        }

   456

    }

   457

   458

    ec_fsm_master_action_process_states(fsm);

   459

}

   460

   461

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

   462

   463

/**

   464

   Master state: READ STATES.

   465

   Fetches the AL- and online state of a slave.

   466

*/

   467

   468

void ec_fsm_master_read_states(ec_fsm_t *fsm /**< finite state machine */)

   469

{

   470

    ec_slave_t *slave = fsm->slave;

   471

    ec_datagram_t *datagram = &fsm->datagram;

   472

    uint8_t new_state;

   473

   474

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   475

        EC_ERR("Failed to receive AL state datagram for slave %i!\n",

   476

               slave->ring_position);

   477

        fsm->master_state = ec_fsm_master_error;

   478

        return;

   479

    }

   480

   481

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

   482

    if (datagram->working_counter != 1) {

   483

        if (slave->online) {

   484

            slave->online = 0;

   485

            EC_INFO("Slave %i: offline.\n", slave->ring_position);

   486

        }

   487

        ec_fsm_master_action_next_slave_state(fsm);

   488

        return;

   489

    }

   490

   491

    // slave responded