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

    45

#include "fsm_master.h"

    46

    47

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

    48

    49

void ec_fsm_master_state_start(ec_fsm_master_t *);

    50

void ec_fsm_master_state_broadcast(ec_fsm_master_t *);

    51

void ec_fsm_master_state_read_states(ec_fsm_master_t *);

    52

void ec_fsm_master_state_acknowledge(ec_fsm_master_t *);

    53

void ec_fsm_master_state_validate_vendor(ec_fsm_master_t *);

    54

void ec_fsm_master_state_validate_product(ec_fsm_master_t *);

    55

void ec_fsm_master_state_rewrite_addresses(ec_fsm_master_t *);

    56

void ec_fsm_master_state_configure_slave(ec_fsm_master_t *);

    57

void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *);

    58

void ec_fsm_master_state_write_eeprom(ec_fsm_master_t *);

    59

void ec_fsm_master_state_sdodict(ec_fsm_master_t *);

    60

void ec_fsm_master_state_sdo_request(ec_fsm_master_t *);

    61

void ec_fsm_master_state_end(ec_fsm_master_t *);

    62

void ec_fsm_master_state_error(ec_fsm_master_t *);

    63

    64

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

    65

    66

/**

    67

   Constructor.

    68

*/

    69

    70

void ec_fsm_master_init(ec_fsm_master_t *fsm, /**< master state machine */

    71

        ec_master_t *master, /**< EtherCAT master */

    72

        ec_datagram_t *datagram /**< datagram object to use */

    73

        )

    74

{

    75

    fsm->master = master;

    76

    fsm->datagram = datagram;

    77

    fsm->state = ec_fsm_master_state_start;

    78

    fsm->idle = 0;

    79

    fsm->slaves_responding = 0;

    80

    fsm->topology_change_pending = 0;

    81

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    82

    fsm->validate = 0;

    83

    fsm->tainted = 0;

    84

    85

    // init sub-state-machines

    86

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

    87

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

    88

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

    89

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

    90

}

    91

    92

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

    93

    94

/**

    95

   Destructor.

    96

*/

    97

    98

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

    99

{

   100

    // clear sub-state machines

   101

    ec_fsm_slave_clear(&fsm->fsm_slave);

   102

    ec_fsm_sii_clear(&fsm->fsm_sii);

   103

    ec_fsm_change_clear(&fsm->fsm_change);

   104

    ec_fsm_coe_clear(&fsm->fsm_coe);

   105

}

   106

   107

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

   108

   109

/**

   110

   Executes the current state of the state machine.

   111

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

   112

   of the state machine is delayed to the next cycle.

   113

   \return false, if state machine has terminated

   114

*/

   115

   116

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

   117

{

   118

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

   119

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

   120

        // datagram was not sent or received yet.

   121

        return ec_fsm_master_running(fsm);

   122

    }

   123

   124

    fsm->state(fsm);

   125

    return ec_fsm_master_running(fsm);

   126

}

   127

   128

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

   129

   130

/**

   131

 * \return false, if state machine has terminated

   132

 */

   133

   134

int ec_fsm_master_running(

   135

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

   136

        )

   137

{

   138

    return fsm->state != ec_fsm_master_state_end

   139

        && fsm->state != ec_fsm_master_state_error;

   140

}

   141

   142

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

   143

   144

/**

   145

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

   146

 */

   147

   148

int ec_fsm_master_idle(

   149

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

   150

        )

   151

{

   152

    return fsm->idle;

   153

}

   154

   155

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

   156

 *  master state machine

   157

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

   158

   159

/**

   160

   Master state: START.

   161

   Starts with getting slave count and slave states.

   162

*/

   163

   164

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   165

{

   166

    fsm->idle = 1;

   167

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

   168

    fsm->state = ec_fsm_master_state_broadcast;

   169

}

   170

   171

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

   172

   173

/**

   174

   Master state: BROADCAST.

   175

   Processes the broadcast read slave count and slaves states.

   176

*/

   177

   178

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

   179

{

   180

    ec_datagram_t *datagram = fsm->datagram;

   181

    unsigned int i;

   182

    ec_slave_t *slave;

   183

    ec_master_t *master = fsm->master;

   184

   185

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   186

        return; // always retry

   187

   188

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

   189

        fsm->slaves_responding = 0;

   190

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

   191

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   192

        }

   193

        fsm->state = ec_fsm_master_state_error;

   194

        return;

   195

    }

   196

   197

    // bus topology change?

   198

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

   199

        fsm->topology_change_pending = 1;

   200

        fsm->slaves_responding = datagram->working_counter;

   201

   202

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

   203

                fsm->slaves_responding,

   204

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

   205

   206

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   207

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

   208

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

   209

            }

   210

            else {

   211

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

   212

                fsm->tainted = 1;

   213

            }

   214

        }

   215

    }

   216

   217

    // slave states changed?

   218

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

   219

        char states[EC_STATE_STRING_SIZE];

   220

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

   221

        ec_state_string(fsm->slave_states, states);

   222

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

   223

    }

   224

   225

    if (fsm->topology_change_pending) {

   226

        down(&master->scan_sem);

   227

        if (!master->allow_scan) {

   228

            up(&master->scan_sem);

   229

        }

   230

        else {

   231

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   232

            up(&master->scan_sem);

   233

   234

            // topology change when scan is allowed:

   235

            // clear all slaves and scan the bus

   236

            fsm->topology_change_pending = 0;

   237

            fsm->tainted = 0;

   238

            fsm->idle = 0;

   239

            fsm->scan_jiffies = jiffies;

   240

   241

            ec_master_eoe_stop(master);

   242

            ec_master_clear_eoe_handlers(master);

   243

            ec_master_destroy_slaves(master);

   244

   245

            master->slave_count = datagram->working_counter;

   246

   247

            if (!master->slave_count) {

   248

                // no slaves present -> finish state machine.

   249

                master->scan_state = EC_REQUEST_COMPLETE;

   250

                wake_up_interruptible(&master->scan_queue);

   251

                fsm->state = ec_fsm_master_state_end;

   252

                return;

   253

            }

   254

   255

            // init slaves

   256

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

   257

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

   258

                                GFP_ATOMIC))) {

   259

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

   260

                    ec_master_destroy_slaves(master);

   261

                    master->scan_state = EC_REQUEST_FAILURE;

   262

                    wake_up_interruptible(&master->scan_queue);

   263

                    fsm->state = ec_fsm_master_state_error;

   264

                    return;

   265

                }

   266

   267

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

   268

                    // freeing of "slave" already done

   269

                    ec_master_destroy_slaves(master);

   270

                    master->scan_state = EC_REQUEST_FAILURE;

   271

                    wake_up_interruptible(&master->scan_queue);

   272

                    fsm->state = ec_fsm_master_state_error;

   273

                    return;

   274

                }

   275

   276

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

   277

            }

   278

   279

            EC_INFO("Scanning bus.\n");

   280

   281

            // begin scanning of slaves

   282

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

   283

            fsm->state = ec_fsm_master_state_scan_slaves;

   284

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

   285

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

   286

            return;

   287

        }

   288

    }

   289

   290

    // fetch state from each slave

   291

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

   292

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

   293

    fsm->retries = EC_FSM_RETRIES;

   294

    fsm->state = ec_fsm_master_state_read_states;

   295

}

   296

   297

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

   298

   299

/**

   300

 * Check for pending EEPROM write requests and process one.

   301

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

   302

 */

   303

   304

int ec_fsm_master_action_process_eeprom(

   305

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

   306

        )

   307

{

   308

    ec_master_t *master = fsm->master;

   309

    ec_eeprom_write_request_t *request;

   310

    ec_slave_t *slave;

   311

   312

    // search the first request to be processed

   313

    while (1) {

   314

        down(&master->eeprom_sem);

   315

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

   316

            up(&master->eeprom_sem);

   317

            break;

   318

        }

   319

        // get first request

   320

        request = list_entry(master->eeprom_requests.next,

   321

                ec_eeprom_write_request_t, list);

   322

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

   323

        request->state = EC_REQUEST_IN_PROGRESS;

   324

        up(&master->eeprom_sem);

   325

   326

        slave = request->slave;

   327

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

   328

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

   329

                    slave->ring_position);

   330

            request->state = EC_REQUEST_FAILURE;

   331

            wake_up(&master->eeprom_queue);

   332

            continue;

   333

        }

   334

   335

        // found pending EEPROM write operation. execute it!

   336

        if (master->debug_level)

   337

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

   338

                    slave->ring_position);

   339

        fsm->eeprom_request = request;

   340

        fsm->eeprom_index = 0;

   341

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

   342

                request->words, EC_FSM_SII_NODE);

   343

        fsm->state = ec_fsm_master_state_write_eeprom;

   344

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

   345

        return 1;

   346

    }

   347

   348

    return 0;

   349

}

   350

   351

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

   352

   353

/**

   354

 * Check for pending SDO requests and process one.

   355

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

   356

 */

   357

   358

int ec_fsm_master_action_process_sdo(

   359

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

   360

        )

   361

{

   362

    ec_master_t *master = fsm->master;

   363

    ec_sdo_request_t *request;

   364

    ec_slave_t *slave;

   365

   366

    // search the first request to be processed

   367

    while (1) {

   368

        down(&master->sdo_sem);

   369

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

   370

            up(&master->sdo_sem);

   371

            break;

   372

        }

   373

        // get first request

   374

        request =

   375

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

   376

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

   377

        request->state = EC_REQUEST_IN_PROGRESS;

   378

        up(&master->sdo_sem);

   379

   380

        slave = request->sdo->slave;

   381

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   382

                slave->online_state == EC_SLAVE_OFFLINE ||

   383

                slave->error_flag) {

   384

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

   385

                    slave->ring_position);

   386

            request->state = EC_REQUEST_FAILURE;

   387

            wake_up(&master->sdo_queue);

   388

            continue;

   389

        }

   390

   391

        // found pending SDO request. execute it!

   392

        if (master->debug_level)

   393

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

   394

                    slave->ring_position);

   395

   396

        // start uploading SDO

   397

        fsm->idle = 0;

   398

        fsm->slave = slave;

   399

        fsm->sdo_request = request;

   400

        fsm->state = ec_fsm_master_state_sdo_request;

   401

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

   402

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

   403

        return 1;

   404

    }

   405

   406

    return 0;

   407

}

   408

   409

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

   410

   411

/**

   412

 */

   413

   414

int ec_fsm_master_action_configure(

   415

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

   416

        )

   417

{

   418

    ec_slave_t *slave;

   419

    ec_master_t *master = fsm->master;

   420

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   421

   422

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

   423

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

   424

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

   425

        if (slave->error_flag

   426

                || slave->online_state == EC_SLAVE_OFFLINE

   427

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   428

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

   429

                    && slave->self_configured)) continue;

   430

   431

        if (master->debug_level) {

   432

            ec_state_string(slave->current_state, old_state);

   433

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

   434

                ec_state_string(slave->requested_state, new_state);

   435

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

   436

                        slave->ring_position, old_state, new_state);

   437

            }

   438

            else if (!slave->self_configured) {

   439

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

   440

                        slave->ring_position, old_state);

   441

            }

   442

        }

   443

   444

        fsm->idle = 0;

   445

        fsm->slave = slave;

   446

        fsm->state = ec_fsm_master_state_configure_slave;

   447

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   448

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

   449

        return 1;

   450

    }

   451

   452

    if (fsm->config_error)

   453

        master->config_state = EC_REQUEST_FAILURE;

   454

    else

   455

        master->config_state = EC_REQUEST_COMPLETE;

   456

    wake_up_interruptible(&master->config_queue);

   457

    return 0;

   458

}

   459

   460

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

   461

   462

/**

   463

   Master action: PROC_STATES.

   464

   Processes the slave states.

   465

*/

   466

   467

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   468

                                         /**< master state machine */

   469

                                         )

   470

{

   471

    ec_master_t *master = fsm->master;

   472

    ec_slave_t *slave;

   473

   474

    down(&master->config_sem);

   475

    if (!master->allow_config) {

   476

        up(&master->config_sem);

   477

    }

   478

    else {

   479

        master->config_state = EC_REQUEST_IN_PROGRESS;

   480

        fsm->config_error = 0;

   481

        up(&master->config_sem);

   482

   483

        // check for pending slave configurations

   484

        if (ec_fsm_master_action_configure(fsm))

   485

            return;

   486

    }

   487

   488

    // Check for a pending SDO request

   489

    if (ec_fsm_master_action_process_sdo(fsm))

   490

        return;

   491