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_clear_addresses(ec_fsm_master_t *);

    60

void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *);

    61

void ec_fsm_master_state_write_eeprom(ec_fsm_master_t *);

    62

void ec_fsm_master_state_sdodict(ec_fsm_master_t *);

    63

void ec_fsm_master_state_sdo_request(ec_fsm_master_t *);

    64

void ec_fsm_master_state_end(ec_fsm_master_t *);

    65

void ec_fsm_master_state_error(ec_fsm_master_t *);

    66

    67

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

    68

    69

/**

    70

   Constructor.

    71

*/

    72

    73

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

    74

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

    75

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

    76

        )

    77

{

    78

    fsm->master = master;

    79

    fsm->datagram = datagram;

    80

    fsm->state = ec_fsm_master_state_start;

    81

    fsm->idle = 0;

    82

    fsm->slaves_responding = 0;

    83

    fsm->topology_change_pending = 0;

    84

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    85

    fsm->validate = 0;

    86

    fsm->tainted = 0;

    87

    88

    // init sub-state-machines

    89

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

    90

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

    91

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

    92

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

    93

}

    94

    95

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

    96

    97

/**

    98

   Destructor.

    99

*/

   100

   101

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

   102

{

   103

    // clear sub-state machines

   104

    ec_fsm_slave_clear(&fsm->fsm_slave);

   105

    ec_fsm_sii_clear(&fsm->fsm_sii);

   106

    ec_fsm_change_clear(&fsm->fsm_change);

   107

    ec_fsm_coe_clear(&fsm->fsm_coe);

   108

}

   109

   110

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

   111

   112

/**

   113

   Executes the current state of the state machine.

   114

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

   115

   of the state machine is delayed to the next cycle.

   116

   \return false, if state machine has terminated

   117

*/

   118

   119

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

   120

{

   121

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

   122

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

   123

        // datagram was not sent or received yet.

   124

        return ec_fsm_master_running(fsm);

   125

    }

   126

   127

    fsm->state(fsm);

   128

    return ec_fsm_master_running(fsm);

   129

}

   130

   131

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

   132

   133

/**

   134

 * \return false, if state machine has terminated

   135

 */

   136

   137

int ec_fsm_master_running(

   138

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

   139

        )

   140

{

   141

    return fsm->state != ec_fsm_master_state_end

   142

        && fsm->state != ec_fsm_master_state_error;

   143

}

   144

   145

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

   146

   147

/**

   148

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

   149

 */

   150

   151

int ec_fsm_master_idle(

   152

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

   153

        )

   154

{

   155

    return fsm->idle;

   156

}

   157

   158

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

   159

 *  master state machine

   160

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

   161

   162

/**

   163

   Master state: START.

   164

   Starts with getting slave count and slave states.

   165

*/

   166

   167

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   168

{

   169

    fsm->idle = 1;

   170

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

   171

    fsm->state = ec_fsm_master_state_broadcast;

   172

}

   173

   174

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

   175

   176

/**

   177

   Master state: BROADCAST.

   178

   Processes the broadcast read slave count and slaves states.

   179

*/

   180

   181

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

   182

{

   183

    ec_datagram_t *datagram = fsm->datagram;

   184

    unsigned int i;

   185

    ec_slave_t *slave;

   186

    ec_master_t *master = fsm->master;

   187

   188

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   189

        return; // always retry

   190

   191

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

   192

        fsm->slaves_responding = 0;

   193

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

   194

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   195

        }

   196

        fsm->state = ec_fsm_master_state_error;

   197

        return;

   198

    }

   199

   200

    // bus topology change?

   201

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

   202

        fsm->topology_change_pending = 1;

   203

        fsm->slaves_responding = datagram->working_counter;

   204

   205

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

   206

                fsm->slaves_responding,

   207

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

   208

   209

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   210

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

   211

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

   212

            }

   213

            else {

   214

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

   215

                fsm->tainted = 1;

   216

            }

   217

        }

   218

    }

   219

   220

    // slave states changed?

   221

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

   222

        char states[EC_STATE_STRING_SIZE];

   223

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

   224

        ec_state_string(fsm->slave_states, states);

   225

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

   226

    }

   227

   228

    if (fsm->topology_change_pending) {

   229

        down(&master->scan_sem);

   230

        if (!master->allow_scan) {

   231

            up(&master->scan_sem);

   232

        }

   233

        else {

   234

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   235

            up(&master->scan_sem);

   236

   237

            // topology change when scan is allowed:

   238

            // clear all slaves and scan the bus

   239

            fsm->topology_change_pending = 0;

   240

            fsm->tainted = 0;

   241

            fsm->idle = 0;

   242

            fsm->scan_jiffies = jiffies;

   243

   244

#ifdef EC_EOE

   245

            ec_master_eoe_stop(master);

   246

            ec_master_clear_eoe_handlers(master);

   247

#endif

   248

            ec_master_destroy_slaves(master);

   249

   250

            master->slave_count = datagram->working_counter;

   251

   252

            if (!master->slave_count) {

   253

                // no slaves present -> finish state machine.

   254

                master->scan_state = EC_REQUEST_COMPLETE;

   255

                wake_up_interruptible(&master->scan_queue);

   256

                fsm->state = ec_fsm_master_state_end;

   257

                return;

   258

            }

   259

   260

            // init slaves

   261

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

   262

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

   263

                                GFP_ATOMIC))) {

   264

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

   265

                    ec_master_destroy_slaves(master);

   266

                    master->scan_state = EC_REQUEST_FAILURE;

   267

                    wake_up_interruptible(&master->scan_queue);

   268

                    fsm->state = ec_fsm_master_state_error;

   269

                    return;

   270

                }

   271

   272

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

   273

                    // freeing of "slave" already done

   274

                    ec_master_destroy_slaves(master);

   275

                    master->scan_state = EC_REQUEST_FAILURE;

   276

                    wake_up_interruptible(&master->scan_queue);

   277

                    fsm->state = ec_fsm_master_state_error;

   278

                    return;

   279

                }

   280

   281

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

   282

            }

   283

   284

            if (master->debug_level)

   285

                EC_DBG("Clearing station addresses...\n");

   286

   287

            ec_datagram_bwr(datagram, 0x0010, 2);

   288

            EC_WRITE_U16(datagram->data, 0x0000);

   289

            fsm->retries = EC_FSM_RETRIES;

   290

            fsm->state = ec_fsm_master_state_clear_addresses;

   291

            return;

   292

        }

   293

    }

   294

   295

    // fetch state from each slave

   296

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

   297

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

   298

    fsm->retries = EC_FSM_RETRIES;

   299

    fsm->state = ec_fsm_master_state_read_states;

   300

}

   301

   302

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

   303

   304

/**

   305

 * Check for pending EEPROM write requests and process one.

   306

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

   307

 */

   308

   309

int ec_fsm_master_action_process_eeprom(

   310

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

   311

        )

   312

{

   313

    ec_master_t *master = fsm->master;

   314

    ec_eeprom_write_request_t *request;

   315

    ec_slave_t *slave;

   316

   317

    // search the first request to be processed

   318

    while (1) {

   319

        down(&master->eeprom_sem);

   320

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

   321

            up(&master->eeprom_sem);

   322

            break;

   323

        }

   324

        // get first request

   325

        request = list_entry(master->eeprom_requests.next,

   326

                ec_eeprom_write_request_t, list);

   327

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

   328

        request->state = EC_REQUEST_IN_PROGRESS;

   329

        up(&master->eeprom_sem);

   330

   331

        slave = request->slave;

   332

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

   333

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

   334

                    slave->ring_position);

   335

            request->state = EC_REQUEST_FAILURE;

   336

            wake_up(&master->eeprom_queue);

   337

            continue;

   338

        }

   339

   340

        // found pending EEPROM write operation. execute it!

   341

        if (master->debug_level)

   342

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

   343

                    slave->ring_position);

   344

        fsm->eeprom_request = request;

   345

        fsm->eeprom_index = 0;

   346

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

   347

                request->words, EC_FSM_SII_NODE);

   348

        fsm->state = ec_fsm_master_state_write_eeprom;

   349

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

   350

        return 1;

   351

    }

   352

   353

    return 0;

   354

}

   355

   356

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

   357

   358

/**

   359

 * Check for pending SDO requests and process one.

   360

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

   361

 */

   362

   363

int ec_fsm_master_action_process_sdo(

   364

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

   365

        )

   366

{

   367

    ec_master_t *master = fsm->master;

   368

    ec_sdo_request_t *request;

   369

    ec_slave_t *slave;

   370

   371

    // search the first request to be processed

   372

    while (1) {

   373

        down(&master->sdo_sem);

   374

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

   375

            up(&master->sdo_sem);

   376

            break;

   377

        }

   378

        // get first request

   379

        request =

   380

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

   381

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

   382

        request->state = EC_REQUEST_IN_PROGRESS;

   383

        up(&master->sdo_sem);

   384

   385

        slave = request->sdo->slave;

   386

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   387

                slave->online_state == EC_SLAVE_OFFLINE ||

   388

                slave->error_flag) {

   389

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

   390

                    slave->ring_position);

   391

            request->state = EC_REQUEST_FAILURE;

   392

            wake_up(&master->sdo_queue);

   393

            continue;

   394

        }

   395

   396

        // found pending SDO request. execute it!

   397

        if (master->debug_level)

   398

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

   399

                    slave->ring_position);

   400

   401

        // start uploading SDO

   402

        fsm->idle = 0;

   403

        fsm->slave = slave;

   404

        fsm->sdo_request = request;

   405

        fsm->state = ec_fsm_master_state_sdo_request;

   406

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

   407

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

   408

        return 1;

   409

    }

   410

   411

    return 0;

   412

}

   413

   414

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

   415

   416

/**

   417

 */

   418

   419

int ec_fsm_master_action_configure(

   420

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

   421

        )

   422

{

   423

    ec_slave_t *slave;

   424

    ec_master_t *master = fsm->master;

   425

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   426

   427

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

   428

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

   429

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

   430

        if (slave->error_flag

   431

                || slave->online_state == EC_SLAVE_OFFLINE

   432

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   433

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

   434

                    && slave->self_configured)) continue;

   435

   436

        if (master->debug_level) {

   437

            ec_state_string(slave->current_state, old_state);

   438

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

   439

                ec_state_string(slave->requested_state, new_state);

   440

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

   441

                        slave->ring_position, old_state, new_state);

   442

            }

   443

            else if (!slave->self_configured) {

   444

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

   445

                        slave->ring_position, old_state);

   446

            }

   447

        }

   448

   449

        fsm->idle = 0;

   450

        fsm->slave = slave;

   451

        fsm->state = ec_fsm_master_state_configure_slave;

   452

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   453

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

   454

        return 1;

   455

    }

   456

   457

    if (fsm->config_error)

   458

        master->config_state = EC_REQUEST_FAILURE;

   459

    else

   460

        master->config_state = EC_REQUEST_COMPLETE;

   461

    wake_up_interruptible(&master->config_queue);

   462

    return 0;

   463

}

   464

   465

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

   466

   467

/**

   468

   Master action: PROC_STATES.

   469

   Processes the slave states.

   470

*/

   471

   472

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   473

                                         /**< master state machine */

   474

                                         )

   475

{

   476

    ec_master_t *master = fsm->master;

   477

    ec_slave_t *slave;

   478

   479

    down(&master->config_sem);

   480

    if (!master->allow_config) {

   481

        up(&master->config_sem);

   482

    }

   483

    else {

   484

        master->config_state = EC_REQUEST_IN_PROGRESS;

   485

        fsm->config_error = 0;

   486

        up(&master->config_sem);

   487

   488

        // check for pending slave configurations

   489

        if (ec_fsm_master_action_configure(fsm))

   490

            return;

   491

    }