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_config_init(&fsm->fsm_slave_config, fsm->datagram);

    92

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

    93

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

    94

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

    95

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

    96

}

    97

    98

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

    99

   100

/**

   101

   Destructor.

   102

*/

   103

   104

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

   105

{

   106

    // clear sub-state machines

   107

    ec_fsm_slave_config_clear(&fsm->fsm_slave_config);

   108

    ec_fsm_slave_scan_clear(&fsm->fsm_slave_scan);

   109

    ec_fsm_sii_clear(&fsm->fsm_sii);

   110

    ec_fsm_change_clear(&fsm->fsm_change);

   111

    ec_fsm_coe_clear(&fsm->fsm_coe);

   112

    ec_fsm_coe_map_clear(&fsm->fsm_coe_map);

   113

}

   114

   115

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

   116

   117

/**

   118

   Executes the current state of the state machine.

   119

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

   120

   of the state machine is delayed to the next cycle.

   121

   \return false, if state machine has terminated

   122

*/

   123

   124

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

   125

{

   126

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

   127

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

   128

        // datagram was not sent or received yet.

   129

        return ec_fsm_master_running(fsm);

   130

    }

   131

   132

    fsm->state(fsm);

   133

    return ec_fsm_master_running(fsm);

   134

}

   135

   136

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

   137

   138

/**

   139

 * \return false, if state machine has terminated

   140

 */

   141

   142

int ec_fsm_master_running(

   143

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

   144

        )

   145

{

   146

    return fsm->state != ec_fsm_master_state_end

   147

        && fsm->state != ec_fsm_master_state_error;

   148

}

   149

   150

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

   151

   152

/**

   153

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

   154

 */

   155

   156

int ec_fsm_master_idle(

   157

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

   158

        )

   159

{

   160

    return fsm->idle;

   161

}

   162

   163

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

   164

 *  master state machine

   165

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

   166

   167

/**

   168

   Master state: START.

   169

   Starts with getting slave count and slave states.

   170

*/

   171

   172

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   173

{

   174

    fsm->idle = 1;

   175

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

   176

    fsm->state = ec_fsm_master_state_broadcast;

   177

}

   178

   179

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

   180

   181

/**

   182

   Master state: BROADCAST.

   183

   Processes the broadcast read slave count and slaves states.

   184

*/

   185

   186

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

   187

{

   188

    ec_datagram_t *datagram = fsm->datagram;

   189

    unsigned int i;

   190

    ec_slave_t *slave;

   191

    ec_master_t *master = fsm->master;

   192

   193

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   194

        return; // always retry

   195

   196

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

   197

        fsm->slaves_responding = 0;

   198

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

   199

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   200

        }

   201

        fsm->state = ec_fsm_master_state_error;

   202

        return;

   203

    }

   204

   205

    // bus topology change?

   206

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

   207

        fsm->topology_change_pending = 1;

   208

        fsm->slaves_responding = datagram->working_counter;

   209

   210

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

   211

                fsm->slaves_responding,

   212

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

   213

   214

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   215

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

   216

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

   217

            }

   218

            else {

   219

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

   220

                fsm->tainted = 1;

   221

            }

   222

        }

   223

    }

   224

   225

    // slave states changed?

   226

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

   227

        char states[EC_STATE_STRING_SIZE];

   228

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

   229

        ec_state_string(fsm->slave_states, states);

   230

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

   231

    }

   232

   233

    if (fsm->topology_change_pending) {

   234

        down(&master->scan_sem);

   235

        if (!master->allow_scan) {

   236

            up(&master->scan_sem);

   237

        }

   238

        else {

   239

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   240

            up(&master->scan_sem);

   241

   242

            // topology change when scan is allowed:

   243

            // clear all slaves and scan the bus

   244

            fsm->topology_change_pending = 0;

   245

            fsm->tainted = 0;

   246

            fsm->idle = 0;

   247

            fsm->scan_jiffies = jiffies;

   248

   249

#ifdef EC_EOE

   250

            ec_master_eoe_stop(master);

   251

            ec_master_clear_eoe_handlers(master);

   252

#endif

   253

            ec_master_destroy_slaves(master);

   254

   255

            master->slave_count = datagram->working_counter;

   256

   257

            if (!master->slave_count) {

   258

                // no slaves present -> finish state machine.

   259

                master->scan_state = EC_REQUEST_COMPLETE;

   260

                wake_up_interruptible(&master->scan_queue);

   261

                fsm->state = ec_fsm_master_state_end;

   262

                return;

   263

            }

   264

   265

            // init slaves

   266

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

   267

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

   268

                                GFP_ATOMIC))) {

   269

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

   270

                    ec_master_destroy_slaves(master);

   271

                    master->scan_state = EC_REQUEST_FAILURE;

   272

                    wake_up_interruptible(&master->scan_queue);

   273

                    fsm->state = ec_fsm_master_state_error;

   274

                    return;

   275

                }

   276

   277

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

   278

                    // freeing of "slave" already done

   279

                    ec_master_destroy_slaves(master);

   280

                    master->scan_state = EC_REQUEST_FAILURE;

   281

                    wake_up_interruptible(&master->scan_queue);

   282

                    fsm->state = ec_fsm_master_state_error;

   283

                    return;

   284

                }

   285

   286

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

   287

            }

   288

   289

            if (master->debug_level)

   290

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

   291

   292

            ec_datagram_bwr(datagram, 0x0010, 2);

   293

            EC_WRITE_U16(datagram->data, 0x0000);

   294

            fsm->retries = EC_FSM_RETRIES;

   295

            fsm->state = ec_fsm_master_state_clear_addresses;

   296

            return;

   297

        }

   298

    }

   299

   300

    // fetch state from each slave

   301

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

   302

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

   303

    fsm->retries = EC_FSM_RETRIES;

   304

    fsm->state = ec_fsm_master_state_read_states;

   305

}

   306

   307

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

   308

   309

/**

   310

 * Check for pending EEPROM write requests and process one.

   311

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

   312

 */

   313

   314

int ec_fsm_master_action_process_eeprom(

   315

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

   316

        )

   317

{

   318

    ec_master_t *master = fsm->master;

   319

    ec_eeprom_write_request_t *request;

   320

    ec_slave_t *slave;

   321

   322

    // search the first request to be processed

   323

    while (1) {

   324

        down(&master->eeprom_sem);

   325

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

   326

            up(&master->eeprom_sem);

   327

            break;

   328

        }

   329

        // get first request

   330

        request = list_entry(master->eeprom_requests.next,

   331

                ec_eeprom_write_request_t, list);

   332

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

   333

        request->state = EC_REQUEST_IN_PROGRESS;

   334

        up(&master->eeprom_sem);

   335

   336

        slave = request->slave;

   337

        if (slave->online_state == EC_SLAVE_OFFLINE) {

   338

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

   339

                    slave->ring_position);

   340

            request->state = EC_REQUEST_FAILURE;

   341

            wake_up(&master->eeprom_queue);

   342

            continue;

   343

        }

   344

   345

        // found pending EEPROM write operation. execute it!

   346

        if (master->debug_level)

   347

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

   348

                    slave->ring_position);

   349

        fsm->eeprom_request = request;

   350

        fsm->eeprom_index = 0;

   351

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

   352

                request->data, EC_FSM_SII_USE_CONFIGURED_ADDRESS);

   353

        fsm->state = ec_fsm_master_state_write_eeprom;

   354

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

   355

        return 1;

   356

    }

   357

   358

    return 0;

   359

}

   360

   361

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

   362

   363

/**

   364

 * Check for pending Sdo requests and process one.

   365

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

   366

 */

   367

   368

int ec_fsm_master_action_process_sdo(

   369

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

   370

        )

   371

{

   372

    ec_master_t *master = fsm->master;

   373

    ec_sdo_request_t *request;

   374

    ec_slave_t *slave;

   375

   376

    // search the first request to be processed

   377

    while (1) {

   378

        down(&master->sdo_sem);

   379

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

   380

            up(&master->sdo_sem);

   381

            break;

   382

        }

   383

        // get first request

   384

        request =

   385

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

   386

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

   387

        request->state = EC_REQUEST_IN_PROGRESS;

   388

        up(&master->sdo_sem);

   389

   391

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   392

                slave->online_state == EC_SLAVE_OFFLINE ||

   393

                slave->error_flag) {

   394

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

   395

                    slave->ring_position);

   396

            request->state = EC_REQUEST_FAILURE;

   397

            wake_up(&master->sdo_queue);

   398

            continue;

   399

        }

   400

   401

        // found pending Sdo request. execute it!

   402

        if (master->debug_level)

   403

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

   404

                    slave->ring_position);

   405

   406

        // start uploading Sdo

   407

        fsm->idle = 0;

   408

        fsm->slave = slave;

   409

        fsm->sdo_request = request;

   410

        fsm->state = ec_fsm_master_state_sdo_request;

   411

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

   412

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

   413

        return 1;

   414

    }

   415

   416

    return 0;

   417

}

   418

   419

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

   420

   421

/**

   422

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

   423

 */

   424

   425

int ec_fsm_master_action_configure(

   426

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

   427

        )

   428

{

   429

    ec_slave_t *slave;

   430

    ec_master_t *master = fsm->master;

   431

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   432

   433

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

   434

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

   435

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

   436

        if (slave->error_flag

   437

                || slave->online_state == EC_SLAVE_OFFLINE

   438

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   439

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

   440

                    && slave->self_configured)) continue;

   441

   442

        if (master->debug_level) {

   443

            ec_state_string(slave->current_state, old_state);

   444

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

   445

                ec_state_string(slave->requested_state, new_state);

   446

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

   447

                        slave->ring_position, old_state, new_state);

   448

            }

   449

            else if (!slave->self_configured) {

   450

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

   451

                        slave->ring_position, old_state);

   452

            }

   453

        }

   454

   455

        fsm->idle = 0;

   456

        fsm->slave = slave;

   457

        fsm->state = ec_fsm_master_state_configure_slave;

   458

        ec_fsm_slave_config_start(&fsm->fsm_slave_config, slave);

   459

        ec_fsm_slave_config_exec(&fsm->fsm_slave_config); // execute immediately

   460

        return 1;

   461

    }

   462

   463

    if (fsm->config_error)

   464

        master->config_state = EC_REQUEST_FAILURE;

   465

    else

   466

        master->config_state = EC_REQUEST_COMPLETE;

   467

    wake_up_interruptible(&master->config_queue);

   468

    return 0;

   469

}

   470

   471

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

   472

   473

/**

   474

   Master action: PROC_STATES.

   475

   Processes the slave states.

   476

*/

   477

   478

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   479

                                         /**< master state machine */

   480

                                         )

   481

{

   482

    ec_master_t *master = fsm->master;

   483

    ec_slave_t *slave;

   484

   485

    down(&master->config_sem);

   486

    if (!master->allow_config) {

   487

        up(&master->config_sem);

   488

    } else {

   489

        master->config_state = EC_REQUEST_IN_PROGRESS;

   490

        fsm->config_error = 0;