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

    48

#include "fsm_master.h"

    49

    50

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

    51

    52

void ec_fsm_master_state_start(ec_fsm_master_t *);

    53

void ec_fsm_master_state_broadcast(ec_fsm_master_t *);

    54

void ec_fsm_master_state_read_states(ec_fsm_master_t *);

    55

void ec_fsm_master_state_acknowledge(ec_fsm_master_t *);

    56

void ec_fsm_master_state_validate_vendor(ec_fsm_master_t *);

    57

void ec_fsm_master_state_validate_product(ec_fsm_master_t *);

    58

void ec_fsm_master_state_rewrite_addresses(ec_fsm_master_t *);

    59

void ec_fsm_master_state_configure_slave(ec_fsm_master_t *);

    60

void ec_fsm_master_state_clear_addresses(ec_fsm_master_t *);

    61

void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *);

    62

void ec_fsm_master_state_write_eeprom(ec_fsm_master_t *);

    63

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

    91

    ec_fsm_slave_scan_init(&fsm->fsm_slave_scan, fsm->datagram,

    92

            &fsm->fsm_slave_config, &fsm->fsm_coe_map);

    93

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

    94

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

    95

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

    96

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

    97

}

    98

    99

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

   100

   101

/**

   102

   Destructor.

   103

*/

   104

   105

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

   106

{

   107

    // clear sub-state machines

   108

    ec_fsm_slave_config_clear(&fsm->fsm_slave_config);

   109

    ec_fsm_slave_scan_clear(&fsm->fsm_slave_scan);

   110

    ec_fsm_sii_clear(&fsm->fsm_sii);

   111

    ec_fsm_change_clear(&fsm->fsm_change);

   112

    ec_fsm_coe_clear(&fsm->fsm_coe);

   113

    ec_fsm_coe_map_clear(&fsm->fsm_coe_map);

   114

}

   115

   116

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

   117

   118

/**

   119

   Executes the current state of the state machine.

   120

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

   121

   of the state machine is delayed to the next cycle.

   122

   \return false, if state machine has terminated

   123

*/

   124

   125

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

   126

{

   127

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

   128

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

   129

        // datagram was not sent or received yet.

   130

        return ec_fsm_master_running(fsm);

   131

    }

   132

   133

    fsm->state(fsm);

   134

    return ec_fsm_master_running(fsm);

   135

}

   136

   137

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

   138

   139

/**

   140

 * \return false, if state machine has terminated

   141

 */

   142

   143

int ec_fsm_master_running(

   144

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

   145

        )

   146

{

   147

    return fsm->state != ec_fsm_master_state_end

   148

        && fsm->state != ec_fsm_master_state_error;

   149

}

   150

   151

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

   152

   153

/**

   154

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

   155

 */

   156

   157

int ec_fsm_master_idle(

   158

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

   159

        )

   160

{

   161

    return fsm->idle;

   162

}

   163

   164

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

   165

 *  master state machine

   166

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

   167

   168

/**

   169

   Master state: START.

   170

   Starts with getting slave count and slave states.

   171

*/

   172

   173

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   174

{

   175

    fsm->idle = 1;

   176

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

   177

    fsm->state = ec_fsm_master_state_broadcast;

   178

}

   179

   180

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

   181

   182

/**

   183

   Master state: BROADCAST.

   184

   Processes the broadcast read slave count and slaves states.

   185

*/

   186

   187

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

   188

{

   189

    ec_datagram_t *datagram = fsm->datagram;

   190

    unsigned int i;

   191

    ec_slave_t *slave;

   192

    ec_master_t *master = fsm->master;

   193

   194

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   195

        return; // always retry

   196

   197

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

   198

        fsm->slaves_responding = 0;

   199

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

   200

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   201

        }

   202

        fsm->state = ec_fsm_master_state_error;

   203

        return;

   204

    }

   205

   206

    // bus topology change?

   207

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

   208

        fsm->topology_change_pending = 1;

   209

        fsm->slaves_responding = datagram->working_counter;

   210

   211

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

   212

                fsm->slaves_responding,

   213

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

   214

   215

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   216

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

   217

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

   218

            }

   219

            else {

   220

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

   221

                fsm->tainted = 1;

   222

            }

   223

        }

   224

    }

   225

   226

    // slave states changed?

   227

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

   228

        char states[EC_STATE_STRING_SIZE];

   229

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

   230

        ec_state_string(fsm->slave_states, states);

   231

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

   232

    }

   233

   234

    if (fsm->topology_change_pending) {

   235

        down(&master->scan_sem);

   236

        if (!master->allow_scan) {

   237

            up(&master->scan_sem);

   238

        }

   239

        else {

   240

            master->scan_state = EC_REQUEST_IN_PROGRESS;

   241

            up(&master->scan_sem);

   242

   243

            // topology change when scan is allowed:

   244

            // clear all slaves and scan the bus

   245

            fsm->topology_change_pending = 0;

   246

            fsm->tainted = 0;

   247

            fsm->idle = 0;

   248

            fsm->scan_jiffies = jiffies;

   249

   250

#ifdef EC_EOE

   251

            ec_master_eoe_stop(master);

   252

            ec_master_clear_eoe_handlers(master);

   253

#endif

   254

            ec_master_destroy_slaves(master);

   255

   256

            master->slave_count = datagram->working_counter;

   257

   258

            if (!master->slave_count) {

   259

                // no slaves present -> finish state machine.

   260

                master->scan_state = EC_REQUEST_COMPLETE;

   261

                wake_up_interruptible(&master->scan_queue);

   262

                fsm->state = ec_fsm_master_state_end;

   263

                return;

   264

            }

   265

   266

            // init slaves

   267

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

   268

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

   269

                                GFP_ATOMIC))) {

   270

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

   271

                    ec_master_destroy_slaves(master);

   272

                    master->scan_state = EC_REQUEST_FAILURE;

   273

                    wake_up_interruptible(&master->scan_queue);

   274

                    fsm->state = ec_fsm_master_state_error;

   275

                    return;

   276

                }

   277

   278

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

   279

                    // freeing of "slave" already done

   280

                    ec_master_destroy_slaves(master);

   281

                    master->scan_state = EC_REQUEST_FAILURE;

   282

                    wake_up_interruptible(&master->scan_queue);

   283

                    fsm->state = ec_fsm_master_state_error;

   284

                    return;

   285

                }

   286

   287

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

   288

            }

   289

   290

            if (master->debug_level)

   291

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

   292

   293

            ec_datagram_bwr(datagram, 0x0010, 2);

   294

            EC_WRITE_U16(datagram->data, 0x0000);

   295

            fsm->retries = EC_FSM_RETRIES;

   296

            fsm->state = ec_fsm_master_state_clear_addresses;

   297

            return;

   298

        }

   299

    }

   300

   301

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

   302

        fsm->state = ec_fsm_master_state_end;

   303

    } else {

   304

        // fetch state from each slave

   305

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

   306

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

   307

        fsm->retries = EC_FSM_RETRIES;

   308

        fsm->state = ec_fsm_master_state_read_states;

   309

    }

   310

}

   311

   312

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

   313

   314

/**

   315

 * Check for pending EEPROM write requests and process one.

   316

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

   317

 */

   318

   319

int ec_fsm_master_action_process_eeprom(

   320

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

   321

        )

   322

{

   323

    ec_master_t *master = fsm->master;

   324

    ec_eeprom_write_request_t *request;

   325

    ec_slave_t *slave;

   326

   327

    // search the first request to be processed

   328

    while (1) {

   329

        down(&master->eeprom_sem);

   330

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

   331

            up(&master->eeprom_sem);

   332

            break;

   333

        }

   334

        // get first request

   335

        request = list_entry(master->eeprom_requests.next,

   336

                ec_eeprom_write_request_t, list);

   337

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

   338

        request->state = EC_REQUEST_IN_PROGRESS;

   339

        up(&master->eeprom_sem);

   340

   341

        slave = request->slave;

   342

        if (slave->online_state == EC_SLAVE_OFFLINE) {

   343

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

   344

                    slave->ring_position);

   345

            request->state = EC_REQUEST_FAILURE;

   346

            wake_up(&master->eeprom_queue);

   347

            continue;

   348

        }

   349

   350

        // found pending EEPROM write operation. execute it!

   351

        if (master->debug_level)

   352

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

   353

                    slave->ring_position);

   354

        fsm->eeprom_request = request;

   355

        fsm->eeprom_index = 0;

   356

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

   357

                request->data, EC_FSM_SII_USE_CONFIGURED_ADDRESS);

   358

        fsm->state = ec_fsm_master_state_write_eeprom;

   359

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

   360

        return 1;

   361

    }

   362

   363

    return 0;

   364

}

   365

   366

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

   367

   368

/**

   369

 * Check for pending Sdo requests and process one.

   370

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

   371

 */

   372

   373

int ec_fsm_master_action_process_sdo(

   374

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

   375

        )

   376

{

   377

    ec_master_t *master = fsm->master;

   378

    ec_master_sdo_request_t *request;

   379

    ec_slave_t *slave;

   380

   381

    // search the first request to be processed

   382

    while (1) {

   383

        down(&master->sdo_sem);

   384

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

   385

            up(&master->sdo_sem);

   386

            break;

   387

        }

   388

        // get first request

   389

        request = list_entry(master->slave_sdo_requests.next,

   390

                ec_master_sdo_request_t, list);

   391

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

   392

        request->req.state = EC_REQUEST_IN_PROGRESS;

   393

        up(&master->sdo_sem);

   394

   395

        slave = request->slave;

   396

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   397

                slave->online_state == EC_SLAVE_OFFLINE ||

   398

                slave->error_flag) {

   399

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

   400

                    slave->ring_position);

   401

            request->req.state = EC_REQUEST_FAILURE;

   402

            wake_up(&master->sdo_queue);

   403

            continue;

   404

        }

   405

   406

        // Found pending Sdo request. Execute it!

   407

        if (master->debug_level)

   408

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

   409

                    slave->ring_position);

   410

   411

        // Start uploading Sdo

   412

        fsm->idle = 0;

   413

        fsm->sdo_request = request;

   414

        fsm->state = ec_fsm_master_state_sdo_request;

   415

        ec_fsm_coe_upload(&fsm->fsm_coe, slave, &request->req);

   416

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

   417

        return 1;

   418

    }

   419

   420

    return 0;

   421

}

   422

   423

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

   424

   425

/**

   426

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

   427

 */

   428

   429

int ec_fsm_master_action_configure(

   430

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

   431

        )

   432

{

   433

    ec_slave_t *slave;

   434

    ec_master_t *master = fsm->master;

   435

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   436

   437

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

   438

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

   439

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

   440

        if (slave->error_flag

   441

                || slave->online_state == EC_SLAVE_OFFLINE

   442

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   443

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

   444

                    && slave->self_configured)) continue;

   445

   446

        if (master->debug_level) {

   447

            ec_state_string(slave->current_state, old_state);

   448

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

   449

                ec_state_string(slave->requested_state, new_state);

   450

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

   451

                        slave->ring_position, old_state, new_state);

   452

            }

   453

            else if (!slave->self_configured) {

   454

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

   455

                        slave->ring_position, old_state);

   456

            }

   457

        }

   458

   459

        fsm->idle = 0;

   460

        fsm->slave = slave;

   461

        fsm->state = ec_fsm_master_state_configure_slave;

   462

        ec_fsm_slave_config_start(&fsm->fsm_slave_config, slave);

   463

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

   464

        return 1;

   465

    }

   466

   467

    if (fsm->config_error)

   468

        master->config_state = EC_REQUEST_FAILURE;

   469

    else

   470

        master->config_state = EC_REQUEST_COMPLETE;

   471

    wake_up_interruptible(&master->config_queue);

   472

    return 0;

   473

}

   474

   475

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

   476

   477

/**

   478

   Master action: PROC_STATES.

   479

   Processes the slave states.

   480

*/

   481

   482

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   483

                                         /**< master state machine */

   484

                                         )

   485

{

   486

    ec_master_t *master = fsm->master;

   487

    ec_slave_t *slave;

   488

   489

    down(&master->config_sem);