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->idle = 0;

    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

/**

   130

 * \return false, if state machine has terminated

   131

 */

   132

   133

int ec_fsm_master_running(

   134

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

   135

        )

   136

{

   137

    return fsm->state != ec_fsm_master_state_end

   138

        && fsm->state != ec_fsm_master_state_error;

   139

}

   140

   141

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

   142

   143

/**

   144

 * \return true, if the state machine is in an idle phase

   145

 */

   146

   147

int ec_fsm_master_idle(

   148

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

   149

        )

   150

{

   151

    return fsm->idle;

   152

}

   153

   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

{

   165

    fsm->idle = 1;

   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

   187

    if (datagram->state != EC_DATAGRAM_RECEIVED) { // link is down

   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

    if (fsm->topology_change_pending) {

   225

        down(&master->scan_sem);

   226

        if (!master->allow_scan) {

   227

            up(&master->scan_sem);

   228

        }

   229

        else {

   230

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   231

            up(&master->scan_sem);

   232

   233

            // topology change when scan is allowed:

   234

            // clear all slaves and scan the bus

   235

            fsm->topology_change_pending = 0;

   236

            fsm->tainted = 0;

   237

            fsm->idle = 0;

   238

            fsm->scan_jiffies = jiffies;

   239

   240

            ec_master_eoe_stop(master);

   241

            ec_master_destroy_slaves(master);

   242

   243

            master->slave_count = datagram->working_counter;

   244

   245

            if (!master->slave_count) {

   246

                // no slaves present -> finish state machine.

   247

                master->scan_state = EC_REQUEST_COMPLETE;

   248

                wake_up_interruptible(&master->scan_queue);

   249

                fsm->state = ec_fsm_master_state_end;

   250

                return;

   251

            }

   252

   253

            // init slaves

   254

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

   255

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

   256

                                GFP_ATOMIC))) {

   257

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

   258

                    ec_master_destroy_slaves(master);

   259

                    master->scan_state = EC_REQUEST_FAILURE;

   260

                    wake_up_interruptible(&master->scan_queue);

   261

                    fsm->state = ec_fsm_master_state_error;

   262

                    return;

   263

                }

   264

   265

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

   266

                    // freeing of "slave" already done

   267

                    ec_master_destroy_slaves(master);

   268

                    master->scan_state = EC_REQUEST_FAILURE;

   269

                    wake_up_interruptible(&master->scan_queue);

   270

                    fsm->state = ec_fsm_master_state_error;

   271

                    return;

   272

                }

   273

   274

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

   275

            }

   276

   277

            EC_INFO("Scanning bus.\n");

   278

   279

            // begin scanning of slaves

   280

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

   281

            fsm->state = ec_fsm_master_state_scan_slaves;

   282

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

   283

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

   284

            return;

   285

        }

   286

    }

   287

   288

    // fetch state from each slave

   289

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

   290

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

   291

    fsm->retries = EC_FSM_RETRIES;

   292

    fsm->state = ec_fsm_master_state_read_states;

   293

}

   294

   295

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

   296

   297

/**

   298

 * Check for pending EEPROM write requests and process one.

   299

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

   300

 */

   301

   302

int ec_fsm_master_action_process_eeprom(

   303

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

   304

        )

   305

{

   306

    ec_master_t *master = fsm->master;

   307

    ec_eeprom_write_request_t *request;

   308

    ec_slave_t *slave;

   309

   310

    // search the first request to be processed

   311

    while (1) {

   312

        down(&master->eeprom_sem);

   313

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

   314

            up(&master->eeprom_sem);

   315

            break;

   316

        }

   317

        // get first request

   318

        request = list_entry(master->eeprom_requests.next,

   319

                ec_eeprom_write_request_t, list);

   320

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

   321

        request->state = EC_REQUEST_IN_PROGRESS;

   322

        up(&master->eeprom_sem);

   323

   324

        slave = request->slave;

   325

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

   326

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

   327

                    slave->ring_position);

   328

            request->state = EC_REQUEST_FAILURE;

   329

            wake_up(&master->eeprom_queue);

   330

            continue;

   331

        }

   332

   333

        // found pending EEPROM write operation. execute it!

   334

        if (master->debug_level)

   335

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

   336

                    slave->ring_position);

   337

        fsm->eeprom_request = request;

   338

        fsm->eeprom_index = 0;

   339

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

   340

                request->words, EC_FSM_SII_NODE);

   341

        fsm->state = ec_fsm_master_state_write_eeprom;

   342

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

   343

        return 1;

   344

    }

   345

   346

    return 0;

   347

}

   348

   349

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

   350

   351

/**

   352

 * Check for pending SDO requests and process one.

   353

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

   354

 */

   355

   356

int ec_fsm_master_action_process_sdo(

   357

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

   358

        )

   359

{

   360

    ec_master_t *master = fsm->master;

   361

    ec_sdo_request_t *request;

   362

    ec_slave_t *slave;

   363

   364

    // search the first request to be processed

   365

    while (1) {

   366

        down(&master->sdo_sem);

   367

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

   368

            up(&master->sdo_sem);

   369

            break;

   370

        }

   371

        // get first request

   372

        request =

   373

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

   374

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

   375

        request->state = EC_REQUEST_IN_PROGRESS;

   376

        up(&master->sdo_sem);

   377

   378

        slave = request->sdo->slave;

   379

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   380

                slave->online_state == EC_SLAVE_OFFLINE ||

   381

                slave->error_flag) {

   382

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

   383

                    slave->ring_position);

   384

            request->state = EC_REQUEST_FAILURE;

   385

            wake_up(&master->sdo_queue);

   386

            continue;

   387

        }

   388

   389

        // found pending SDO request. execute it!

   390

        if (master->debug_level)

   391

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

   392

                    slave->ring_position);

   393

   394

        // start uploading SDO

   395

        fsm->idle = 0;

   396

        fsm->slave = slave;

   397

        fsm->sdo_request = request;

   398

        fsm->state = ec_fsm_master_state_sdo_request;

   399

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

   400

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

   401

        return 1;

   402

    }

   403

   404

    return 0;

   405

}

   406

   407

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

   408

   409

/**

   410

 */

   411

   412

int ec_fsm_master_action_configure(

   413

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

   414

        )

   415

{

   416

    ec_slave_t *slave;

   417

    ec_master_t *master = fsm->master;

   418

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   419

   420

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

   421

    // FIXME do not check all slaves in every cycle...

   422

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

   423

        if (slave->error_flag

   424

                || slave->online_state == EC_SLAVE_OFFLINE

   425

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   426

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

   427

                    && slave->self_configured)) continue;

   428

   429

        if (master->debug_level) {

   430

            ec_state_string(slave->current_state, old_state);

   431

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

   432

                ec_state_string(slave->requested_state, new_state);

   433

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

   434

                        slave->ring_position, old_state, new_state);

   435

            }

   436

            else if (!slave->self_configured) {

   437

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

   438

                        slave->ring_position, old_state);

   439

            }

   440

        }

   441

   442

        fsm->idle = 0;

   443

        fsm->slave = slave;

   444

        fsm->state = ec_fsm_master_state_configure_slave;

   445

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   446

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

   447

        return 1;

   448

    }

   449

   450

    if (fsm->config_error)

   451

        master->config_state = EC_REQUEST_FAILURE;

   452

    else

   453

        master->config_state = EC_REQUEST_COMPLETE;

   454

    wake_up_interruptible(&master->config_queue);

   455

    return 0;

   456

}

   457

   458

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

   459

   460

/**

   461

   Master action: PROC_STATES.

   462

   Processes the slave states.

   463

*/

   464

   465

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   466

                                         /**< master state machine */

   467

                                         )

   468

{

   469

    ec_master_t *master = fsm->master;

   470

    ec_slave_t *slave;

   471

   472

    down(&master->config_sem);

   473

    if (!master->allow_config) {

   474

        up(&master->config_sem);

   475

    }

   476

    else {

   477

        master->config_state = EC_REQUEST_IN_PROGRESS;

   478

        fsm->config_error = 0;

   479

        up(&master->config_sem);

   480

   481

        // check for pending slave configurations

   482

        if (ec_fsm_master_action_configure(fsm))

   483

            return;

   484

    }

   485

   486

    // Check, if EoE processing has to be started

   487

    ec_master_eoe_start(master);

   488

   489

    // Check for a pending SDO request

   490

    if (ec_fsm_master_action_process_sdo(fsm))

   491

        return;