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

#ifdef EC_EOE

    45

#include "ethernet.h"

    46

#endif

    47

#include "fsm_master.h"

    48

    49

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

    50

    51

void ec_fsm_master_state_start(ec_fsm_master_t *);

    52

void ec_fsm_master_state_broadcast(ec_fsm_master_t *);

    53

void ec_fsm_master_state_read_states(ec_fsm_master_t *);

    54

void ec_fsm_master_state_acknowledge(ec_fsm_master_t *);

    55

void ec_fsm_master_state_validate_vendor(ec_fsm_master_t *);

    56

void ec_fsm_master_state_validate_product(ec_fsm_master_t *);

    57

void ec_fsm_master_state_rewrite_addresses(ec_fsm_master_t *);

    58

void ec_fsm_master_state_configure_slave(ec_fsm_master_t *);

    59

void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *);

    60

void ec_fsm_master_state_write_eeprom(ec_fsm_master_t *);

    61

void ec_fsm_master_state_sdodict(ec_fsm_master_t *);

    62

void ec_fsm_master_state_sdo_request(ec_fsm_master_t *);

    63

void ec_fsm_master_state_end(ec_fsm_master_t *);

    64

void ec_fsm_master_state_error(ec_fsm_master_t *);

    65

    66

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

    67

    68

/**

    69

   Constructor.

    70

*/

    71

    72

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

    73

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

    74

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

    75

        )

    76

{

    77

    fsm->master = master;

    78

    fsm->datagram = datagram;

    79

    fsm->state = ec_fsm_master_state_start;

    80

    fsm->idle = 0;

    81

    fsm->slaves_responding = 0;

    82

    fsm->topology_change_pending = 0;

    83

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    84

    fsm->validate = 0;

    85

    fsm->tainted = 0;

    86

    87

    // init sub-state-machines

    88

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

    89

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

    90

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

    91

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

    92

}

    93

    94

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

    95

    96

/**

    97

   Destructor.

    98

*/

    99

   100

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

   101

{

   102

    // clear sub-state machines

   103

    ec_fsm_slave_clear(&fsm->fsm_slave);

   104

    ec_fsm_sii_clear(&fsm->fsm_sii);

   105

    ec_fsm_change_clear(&fsm->fsm_change);

   106

    ec_fsm_coe_clear(&fsm->fsm_coe);

   107

}

   108

   109

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

   110

   111

/**

   112

   Executes the current state of the state machine.

   113

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

   114

   of the state machine is delayed to the next cycle.

   115

   \return false, if state machine has terminated

   116

*/

   117

   118

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

   119

{

   120

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

   121

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

   122

        // datagram was not sent or received yet.

   123

        return ec_fsm_master_running(fsm);

   124

    }

   125

   126

    fsm->state(fsm);

   127

    return ec_fsm_master_running(fsm);

   128

}

   129

   130

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

   131

   132

/**

   133

 * \return false, if state machine has terminated

   134

 */

   135

   136

int ec_fsm_master_running(

   137

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

   138

        )

   139

{

   140

    return fsm->state != ec_fsm_master_state_end

   141

        && fsm->state != ec_fsm_master_state_error;

   142

}

   143

   144

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

   145

   146

/**

   147

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

   148

 */

   149

   150

int ec_fsm_master_idle(

   151

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

   152

        )

   153

{

   154

    return fsm->idle;

   155

}

   156

   157

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

   158

 *  master state machine

   159

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

   160

   161

/**

   162

   Master state: START.

   163

   Starts with getting slave count and slave states.

   164

*/

   165

   166

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   167

{

   168

    fsm->idle = 1;

   169

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

   170

    fsm->state = ec_fsm_master_state_broadcast;

   171

}

   172

   173

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

   174

   175

/**

   176

   Master state: BROADCAST.

   177

   Processes the broadcast read slave count and slaves states.

   178

*/

   179

   180

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

   181

{

   182

    ec_datagram_t *datagram = fsm->datagram;

   183

    unsigned int i;

   184

    ec_slave_t *slave;

   185

    ec_master_t *master = fsm->master;

   186

   187

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   188

        return; // always retry

   189

   190

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

   191

        fsm->slaves_responding = 0;

   192

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

   193

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   194

        }

   195

        fsm->state = ec_fsm_master_state_error;

   196

        return;

   197

    }

   198

   199

    // bus topology change?

   200

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

   201

        fsm->topology_change_pending = 1;

   202

        fsm->slaves_responding = datagram->working_counter;

   203

   204

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

   205

                fsm->slaves_responding,

   206

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

   207

   208

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   209

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

   210

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

   211

            }

   212

            else {

   213

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

   214

                fsm->tainted = 1;

   215

            }

   216

        }

   217

    }

   218

   219

    // slave states changed?

   220

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

   221

        char states[EC_STATE_STRING_SIZE];

   222

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

   223

        ec_state_string(fsm->slave_states, states);

   224

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

   225

    }

   226

   227

    if (fsm->topology_change_pending) {

   228

        down(&master->scan_sem);

   229

        if (!master->allow_scan) {

   230

            up(&master->scan_sem);

   231

        }

   232

        else {

   233

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   234

            up(&master->scan_sem);

   235

   236

            // topology change when scan is allowed:

   237

            // clear all slaves and scan the bus

   238

            fsm->topology_change_pending = 0;

   239

            fsm->tainted = 0;

   240

            fsm->idle = 0;

   241

            fsm->scan_jiffies = jiffies;

   242

   243

#ifdef EC_EOE

   244

            ec_master_eoe_stop(master);

   245

            ec_master_clear_eoe_handlers(master);

   246

#endif

   247

            ec_master_destroy_slaves(master);

   248

   249

            master->slave_count = datagram->working_counter;

   250

   251

            if (!master->slave_count) {

   252

                // no slaves present -> finish state machine.

   253

                master->scan_state = EC_REQUEST_COMPLETE;

   254

                wake_up_interruptible(&master->scan_queue);

   255

                fsm->state = ec_fsm_master_state_end;

   256

                return;

   257

            }

   258

   259

            // init slaves

   260

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

   261

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

   262

                                GFP_ATOMIC))) {

   263

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

   264

                    ec_master_destroy_slaves(master);

   265

                    master->scan_state = EC_REQUEST_FAILURE;

   266

                    wake_up_interruptible(&master->scan_queue);

   267

                    fsm->state = ec_fsm_master_state_error;

   268

                    return;

   269

                }

   270

   271

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

   272

                    // freeing of "slave" already done

   273

                    ec_master_destroy_slaves(master);

   274

                    master->scan_state = EC_REQUEST_FAILURE;

   275

                    wake_up_interruptible(&master->scan_queue);

   276

                    fsm->state = ec_fsm_master_state_error;

   277

                    return;

   278

                }

   279

   280

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

   281

            }

   282

   283

            EC_INFO("Scanning bus.\n");

   284

   285

            // begin scanning of slaves

   286

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

   287

            fsm->state = ec_fsm_master_state_scan_slaves;

   288

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

   289

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

   290

            return;

   291

        }

   292

    }

   293

   294

    // fetch state from each slave

   295

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

   296

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

   297

    fsm->retries = EC_FSM_RETRIES;

   298

    fsm->state = ec_fsm_master_state_read_states;

   299

}

   300

   301

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

   302

   303

/**

   304

 * Check for pending EEPROM write requests and process one.

   305

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

   306

 */

   307

   308

int ec_fsm_master_action_process_eeprom(

   309

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

   310

        )

   311

{

   312

    ec_master_t *master = fsm->master;

   313

    ec_eeprom_write_request_t *request;

   314

    ec_slave_t *slave;

   315

   316

    // search the first request to be processed

   317

    while (1) {

   318

        down(&master->eeprom_sem);

   319

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

   320

            up(&master->eeprom_sem);

   321

            break;

   322

        }

   323

        // get first request

   324

        request = list_entry(master->eeprom_requests.next,

   325

                ec_eeprom_write_request_t, list);

   326

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

   327

        request->state = EC_REQUEST_IN_PROGRESS;

   328

        up(&master->eeprom_sem);

   329

   330

        slave = request->slave;

   331

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

   332

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

   333

                    slave->ring_position);

   334

            request->state = EC_REQUEST_FAILURE;

   335

            wake_up(&master->eeprom_queue);

   336

            continue;

   337

        }

   338

   339

        // found pending EEPROM write operation. execute it!

   340

        if (master->debug_level)

   341

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

   342

                    slave->ring_position);

   343

        fsm->eeprom_request = request;

   344

        fsm->eeprom_index = 0;

   345

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

   346

                request->words, EC_FSM_SII_NODE);

   347

        fsm->state = ec_fsm_master_state_write_eeprom;

   348

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

   349

        return 1;

   350

    }

   351

   352

    return 0;

   353

}

   354

   355

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

   356

   357

/**

   358

 * Check for pending SDO requests and process one.

   359

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

   360

 */

   361

   362

int ec_fsm_master_action_process_sdo(

   363

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

   364

        )

   365

{

   366

    ec_master_t *master = fsm->master;

   367

    ec_sdo_request_t *request;

   368

    ec_slave_t *slave;

   369

   370

    // search the first request to be processed

   371

    while (1) {

   372

        down(&master->sdo_sem);

   373

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

   374

            up(&master->sdo_sem);

   375

            break;

   376

        }

   377

        // get first request

   378

        request =

   379

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

   380

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

   381

        request->state = EC_REQUEST_IN_PROGRESS;

   382

        up(&master->sdo_sem);

   383

   384

        slave = request->sdo->slave;

   385

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   386

                slave->online_state == EC_SLAVE_OFFLINE ||

   387

                slave->error_flag) {

   388

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

   389

                    slave->ring_position);

   390

            request->state = EC_REQUEST_FAILURE;

   391

            wake_up(&master->sdo_queue);

   392

            continue;

   393

        }

   394

   395

        // found pending SDO request. execute it!

   396

        if (master->debug_level)

   397

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

   398

                    slave->ring_position);

   399

   400

        // start uploading SDO

   401

        fsm->idle = 0;

   402

        fsm->slave = slave;

   403

        fsm->sdo_request = request;

   404

        fsm->state = ec_fsm_master_state_sdo_request;

   405

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

   406

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

   407

        return 1;

   408

    }

   409

   410

    return 0;

   411

}

   412

   413

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

   414

   415

/**

   416

 */

   417

   418

int ec_fsm_master_action_configure(

   419

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

   420

        )

   421

{

   422

    ec_slave_t *slave;

   423

    ec_master_t *master = fsm->master;

   424

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   425

   426

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

   427

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

   428

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

   429

        if (slave->error_flag

   430

                || slave->online_state == EC_SLAVE_OFFLINE

   431

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   432

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

   433

                    && slave->self_configured)) continue;

   434

   435

        if (master->debug_level) {

   436

            ec_state_string(slave->current_state, old_state);

   437

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

   438

                ec_state_string(slave->requested_state, new_state);

   439

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

   440

                        slave->ring_position, old_state, new_state);

   441

            }

   442

            else if (!slave->self_configured) {

   443

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

   444

                        slave->ring_position, old_state);

   445

            }

   446

        }

   447

   448

        fsm->idle = 0;

   449

        fsm->slave = slave;

   450

        fsm->state = ec_fsm_master_state_configure_slave;

   451

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   452

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

   453

        return 1;

   454

    }

   455

   456

    if (fsm->config_error)

   457

        master->config_state = EC_REQUEST_FAILURE;

   458

    else

   459

        master->config_state = EC_REQUEST_COMPLETE;

   460

    wake_up_interruptible(&master->config_queue);

   461

    return 0;

   462

}

   463

   464

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

   465

   466

/**

   467

   Master action: PROC_STATES.

   468

   Processes the slave states.

   469

*/

   470

   471

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   472

                                         /**< master state machine */

   473

                                         )

   474

{

   475

    ec_master_t *master = fsm->master;

   476

    ec_slave_t *slave;

   477

   478

    down(&master->config_sem);

   479

    if (!master->allow_config) {

   480

        up(&master->config_sem);

   481

    }

   482

    else {

   483

        master->config_state = EC_REQUEST_IN_PROGRESS;

   484

        fsm->config_error = 0;

   485

        up(&master->config_sem);

   486

   487

        // check for pending slave configurations

   488

        if (ec_fsm_master_action_configure(fsm))

   489

            return;

   490

    }

   491