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

    64

void ec_fsm_master_state_sdo_request(ec_fsm_master_t *);

    65

void ec_fsm_master_state_end(ec_fsm_master_t *);

    66

void ec_fsm_master_state_error(ec_fsm_master_t *);

    67

    68

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

    69

    70

/**

    71

   Constructor.

    72

*/

    73

    74

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

    75

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

    76

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

    77

        )

    78

{

    79

    fsm->master = master;

    80

    fsm->datagram = datagram;

    81

    fsm->state = ec_fsm_master_state_start;

    82

    fsm->idle = 0;

    83

    fsm->slaves_responding = 0;

    84

    fsm->topology_change_pending = 0;

    85

    fsm->slave_states = EC_SLAVE_STATE_UNKNOWN;

    86

    fsm->validate = 0;

    87

    fsm->tainted = 0;

    88

    89

    // init sub-state-machines

    90

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

    91

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

    92

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

    93

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

    94

    ec_fsm_coe_map_init(&fsm->fsm_coe_map, &fsm->fsm_coe);

    95

}

    96

    97

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

    98

    99

/**

   100

   Destructor.

   101

*/

   102

   103

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

   104

{

   105

    // clear sub-state machines

   106

    ec_fsm_slave_clear(&fsm->fsm_slave);

   107

    ec_fsm_sii_clear(&fsm->fsm_sii);

   108

    ec_fsm_change_clear(&fsm->fsm_change);

   109

    ec_fsm_coe_clear(&fsm->fsm_coe);

   110

    ec_fsm_coe_map_clear(&fsm->fsm_coe_map);

   111

}

   112

   113

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

   114

   115

/**

   116

   Executes the current state of the state machine.

   117

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

   118

   of the state machine is delayed to the next cycle.

   119

   \return false, if state machine has terminated

   120

*/

   121

   122

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

   123

{

   124

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

   125

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

   126

        // datagram was not sent or received yet.

   127

        return ec_fsm_master_running(fsm);

   128

    }

   129

   130

    fsm->state(fsm);

   131

    return ec_fsm_master_running(fsm);

   132

}

   133

   134

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

   135

   136

/**

   137

 * \return false, if state machine has terminated

   138

 */

   139

   140

int ec_fsm_master_running(

   141

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

   142

        )

   143

{

   144

    return fsm->state != ec_fsm_master_state_end

   145

        && fsm->state != ec_fsm_master_state_error;

   146

}

   147

   148

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

   149

   150

/**

   151

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

   152

 */

   153

   154

int ec_fsm_master_idle(

   155

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

   156

        )

   157

{

   158

    return fsm->idle;

   159

}

   160

   161

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

   162

 *  master state machine

   163

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

   164

   165

/**

   166

   Master state: START.

   167

   Starts with getting slave count and slave states.

   168

*/

   169

   170

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   171

{

   172

    fsm->idle = 1;

   173

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

   174

    fsm->state = ec_fsm_master_state_broadcast;

   175

}

   176

   177

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

   178

   179

/**

   180

   Master state: BROADCAST.

   181

   Processes the broadcast read slave count and slaves states.

   182

*/

   183

   184

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

   185

{

   186

    ec_datagram_t *datagram = fsm->datagram;

   187

    unsigned int i;

   188

    ec_slave_t *slave;

   189

    ec_master_t *master = fsm->master;

   190

   191

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   192

        return; // always retry

   193

   194

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

   195

        fsm->slaves_responding = 0;

   196

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

   197

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   198

        }

   199

        fsm->state = ec_fsm_master_state_error;

   200

        return;

   201

    }

   202

   203

    // bus topology change?

   204

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

   205

        fsm->topology_change_pending = 1;

   206

        fsm->slaves_responding = datagram->working_counter;

   207

   208

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

   209

                fsm->slaves_responding,

   210

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

   211

   212

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   213

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

   214

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

   215

            }

   216

            else {

   217

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

   218

                fsm->tainted = 1;

   219

            }

   220

        }

   221

    }

   222

   223

    // slave states changed?

   224

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

   225

        char states[EC_STATE_STRING_SIZE];

   226

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

   227

        ec_state_string(fsm->slave_states, states);

   228

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

   229

    }

   230

   231

    if (fsm->topology_change_pending) {

   232

        down(&master->scan_sem);

   233

        if (!master->allow_scan) {

   234

            up(&master->scan_sem);

   235

        }

   236

        else {

   237

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   238

            up(&master->scan_sem);

   239

   240

            // topology change when scan is allowed:

   241

            // clear all slaves and scan the bus

   242

            fsm->topology_change_pending = 0;

   243

            fsm->tainted = 0;

   244

            fsm->idle = 0;

   245

            fsm->scan_jiffies = jiffies;

   246

   247

#ifdef EC_EOE

   248

            ec_master_eoe_stop(master);

   249

            ec_master_clear_eoe_handlers(master);

   250

#endif

   251

            ec_master_destroy_slaves(master);

   252

   253

            master->slave_count = datagram->working_counter;

   254

   255

            if (!master->slave_count) {

   256

                // no slaves present -> finish state machine.

   257

                master->scan_state = EC_REQUEST_COMPLETE;

   258

                wake_up_interruptible(&master->scan_queue);

   259

                fsm->state = ec_fsm_master_state_end;

   260

                return;

   261

            }

   262

   263

            // init slaves

   264

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

   265

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

   266

                                GFP_ATOMIC))) {

   267

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

   268

                    ec_master_destroy_slaves(master);

   269

                    master->scan_state = EC_REQUEST_FAILURE;

   270

                    wake_up_interruptible(&master->scan_queue);

   271

                    fsm->state = ec_fsm_master_state_error;

   272

                    return;

   273

                }

   274

   275

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

   276

                    // freeing of "slave" already done

   277

                    ec_master_destroy_slaves(master);

   278

                    master->scan_state = EC_REQUEST_FAILURE;

   279

                    wake_up_interruptible(&master->scan_queue);

   280

                    fsm->state = ec_fsm_master_state_error;

   281

                    return;

   282

                }

   283

   284

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

   285

            }

   286

   287

            if (master->debug_level)

   288

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

   289

   290

            ec_datagram_bwr(datagram, 0x0010, 2);

   291

            EC_WRITE_U16(datagram->data, 0x0000);

   292

            fsm->retries = EC_FSM_RETRIES;

   293

            fsm->state = ec_fsm_master_state_clear_addresses;

   294

            return;

   295

        }

   296

    }

   297

   298

    // fetch state from each slave

   299

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

   300

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

   301

    fsm->retries = EC_FSM_RETRIES;

   302

    fsm->state = ec_fsm_master_state_read_states;

   303

}

   304

   305

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

   306

   307

/**

   308

 * Check for pending EEPROM write requests and process one.

   309

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

   310

 */

   311

   312

int ec_fsm_master_action_process_eeprom(

   313

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

   314

        )

   315

{

   316

    ec_master_t *master = fsm->master;

   317

    ec_eeprom_write_request_t *request;

   318

    ec_slave_t *slave;

   319

   320

    // search the first request to be processed

   321

    while (1) {

   322

        down(&master->eeprom_sem);

   323

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

   324

            up(&master->eeprom_sem);

   325

            break;

   326

        }

   327

        // get first request

   328

        request = list_entry(master->eeprom_requests.next,

   329

                ec_eeprom_write_request_t, list);

   330

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

   331

        request->state = EC_REQUEST_IN_PROGRESS;

   332

        up(&master->eeprom_sem);

   333

   334

        slave = request->slave;

   335

        if (slave->online_state == EC_SLAVE_OFFLINE) {

   336

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

   337

                    slave->ring_position);

   338

            request->state = EC_REQUEST_FAILURE;

   339

            wake_up(&master->eeprom_queue);

   340

            continue;

   341

        }

   342

   343

        // found pending EEPROM write operation. execute it!

   344

        if (master->debug_level)

   345

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

   346

                    slave->ring_position);

   347

        fsm->eeprom_request = request;

   348

        fsm->eeprom_index = 0;

   349

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

   350

                request->data, EC_FSM_SII_NODE);

   351

        fsm->state = ec_fsm_master_state_write_eeprom;

   352

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

   353

        return 1;

   354

    }

   355

   356

    return 0;

   357

}

   358

   359

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

   360

   361

/**

   362

 * Check for pending SDO requests and process one.

   363

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

   364

 */

   365

   366

int ec_fsm_master_action_process_sdo(

   367

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

   368

        )

   369

{

   370

    ec_master_t *master = fsm->master;

   371

    ec_sdo_request_t *request;

   372

    ec_slave_t *slave;

   373

   374

    // search the first request to be processed

   375

    while (1) {

   376

        down(&master->sdo_sem);

   377

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

   378

            up(&master->sdo_sem);

   379

            break;

   380

        }

   381

        // get first request

   382

        request =

   383

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

   384

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

   385

        request->state = EC_REQUEST_IN_PROGRESS;

   386

        up(&master->sdo_sem);

   387

   388

        slave = request->entry->sdo->slave;

   389

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   390

                slave->online_state == EC_SLAVE_OFFLINE ||

   391

                slave->error_flag) {

   392

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

   393

                    slave->ring_position);

   394

            request->state = EC_REQUEST_FAILURE;

   395

            wake_up(&master->sdo_queue);

   396

            continue;

   397

        }

   398

   399

        // found pending SDO request. execute it!

   400

        if (master->debug_level)

   401

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

   402

                    slave->ring_position);

   403

   404

        // start uploading SDO

   405

        fsm->idle = 0;

   406

        fsm->slave = slave;

   407

        fsm->sdo_request = request;

   408

        fsm->state = ec_fsm_master_state_sdo_request;

   409

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

   410

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

   411

        return 1;

   412

    }

   413

   414

    return 0;

   415

}

   416

   417

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

   418

   419

/**

   420

 * Check for slaves that are not configured and configure them.

   421

 */

   422

   423

int ec_fsm_master_action_configure(

   424

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

   425

        )

   426

{

   427

    ec_slave_t *slave;

   428

    ec_master_t *master = fsm->master;

   429

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   430

   431

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

   432

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

   433

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

   434

        if (slave->error_flag

   435

                || slave->online_state == EC_SLAVE_OFFLINE

   436

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   437

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

   438

                    && slave->self_configured)) continue;

   439

   440

        if (master->debug_level) {

   441

            ec_state_string(slave->current_state, old_state);

   442

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

   443

                ec_state_string(slave->requested_state, new_state);

   444

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

   445

                        slave->ring_position, old_state, new_state);

   446

            }

   447

            else if (!slave->self_configured) {

   448

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

   449

                        slave->ring_position, old_state);

   450

            }

   451

        }

   452

   453

        fsm->idle = 0;

   454

        fsm->slave = slave;

   455

        fsm->state = ec_fsm_master_state_configure_slave;

   456

        ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);

   457

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

   458

        return 1;

   459

    }

   460

   461

    if (fsm->config_error)

   462

        master->config_state = EC_REQUEST_FAILURE;

   463

    else

   464

        master->config_state = EC_REQUEST_COMPLETE;

   465

    wake_up_interruptible(&master->config_queue);

   466

    return 0;

   467

}

   468

   469

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

   470

   471

/**

   472

   Master action: PROC_STATES.

   473

   Processes the slave states.

   474

*/

   475

   476

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   477

                                         /**< master state machine */

   478

                                         )

   479

{

   480

    ec_master_t *master = fsm->master;

   481

    ec_slave_t *slave;

   482

   483

    down(&master->config_sem);

   484

    if (!master->allow_config) {

   485

        up(&master->config_sem);

   486

    }

   487

    else {

   488

        master->config_state = EC_REQUEST_IN_PROGRESS;

   489

        fsm->config_error = 0;

   490

        up(&master->config_sem);

   491

   492

        // check for pending slave configurations

   493

        if (ec_fsm_master_action_configure(fsm))

   494

            return;

   495

    }

   496

   497

    // Check for a pending SDO request

   498

    if (ec_fsm_master_action_process_sdo(fsm))

   499

        return;

   500

   501

    if (master->mode == EC_MASTER_MODE_IDLE) {

   502

   503

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

   504

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

   505

            if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)

   506

                || slave->sdo_dictionary_fetched

   507

                || slave->current_state == EC_SLAVE_STATE_INIT

   508