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

#include "slave_config.h"

    45

#ifdef EC_EOE

    46

#include "ethernet.h"

    47

#endif

    48

    49

#include "fsm_master.h"

    50

    51

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

    52

    53

void ec_fsm_master_state_start(ec_fsm_master_t *);

    54

void ec_fsm_master_state_broadcast(ec_fsm_master_t *);

    55

void ec_fsm_master_state_read_states(ec_fsm_master_t *);

    56

void ec_fsm_master_state_acknowledge(ec_fsm_master_t *);

    57

void ec_fsm_master_state_configure_slave(ec_fsm_master_t *);

    58

void ec_fsm_master_state_clear_addresses(ec_fsm_master_t *);

    59

void ec_fsm_master_state_scan_slaves(ec_fsm_master_t *);

    60

void ec_fsm_master_state_write_sii(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

    85

    // init sub-state-machines

    86

    ec_fsm_slave_config_init(&fsm->fsm_slave_config, fsm->datagram);

    87

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

    88

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

    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

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

    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_config_clear(&fsm->fsm_slave_config);

   105

    ec_fsm_slave_scan_clear(&fsm->fsm_slave_scan);

   106

    ec_fsm_sii_clear(&fsm->fsm_sii);

   107

    ec_fsm_change_clear(&fsm->fsm_change);

   108

    ec_fsm_coe_clear(&fsm->fsm_coe);

   109

    ec_fsm_coe_map_clear(&fsm->fsm_coe_map);

   110

}

   111

   112

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

   113

   114

/**

   115

   Executes the current state of the state machine.

   116

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

   117

   of the state machine is delayed to the next cycle.

   118

   \return false, if state machine has terminated

   119

*/

   120

   121

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

   122

{

   123

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

   124

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

   125

        // datagram was not sent or received yet.

   126

        return ec_fsm_master_running(fsm);

   127

    }

   128

   129

    fsm->state(fsm);

   130

    return ec_fsm_master_running(fsm);

   131

}

   132

   133

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

   134

   135

/**

   136

 * \return false, if state machine has terminated

   137

 */

   138

   139

int ec_fsm_master_running(

   140

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

   141

        )

   142

{

   143

    return fsm->state != ec_fsm_master_state_end

   144

        && fsm->state != ec_fsm_master_state_error;

   145

}

   146

   147

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

   148

   149

/**

   150

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

   151

 */

   152

   153

int ec_fsm_master_idle(

   154

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

   155

        )

   156

{

   157

    return fsm->idle;

   158

}

   159

   160

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

   161

 *  master state machine

   162

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

   163

   164

/**

   165

   Master state: START.

   166

   Starts with getting slave count and slave states.

   167

*/

   168

   169

void ec_fsm_master_state_start(ec_fsm_master_t *fsm)

   170

{

   171

    fsm->idle = 1;

   172

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

   173

    fsm->state = ec_fsm_master_state_broadcast;

   174

}

   175

   176

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

   177

   178

/**

   179

   Master state: BROADCAST.

   180

   Processes the broadcast read slave count and slaves states.

   181

*/

   182

   183

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

   184

{

   185

    ec_datagram_t *datagram = fsm->datagram;

   186

    unsigned int i;

   187

    ec_slave_t *slave;

   188

    ec_master_t *master = fsm->master;

   189

   190

    if (datagram->state == EC_DATAGRAM_TIMED_OUT)

   191

        return; // always retry

   192

   193

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

   194

        fsm->slaves_responding = 0;

   195

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

   196

            ec_slave_set_online_state(slave, EC_SLAVE_OFFLINE);

   197

        }

   198

        fsm->state = ec_fsm_master_state_error;

   199

        return;

   200

    }

   201

   202

    // bus topology change?

   203

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

   204

        fsm->topology_change_pending = 1;

   205

        fsm->slaves_responding = datagram->working_counter;

   206

   207

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

   208

                fsm->slaves_responding,

   209

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

   210

    }

   211

   212

    // slave states changed?

   213

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

   214

        char states[EC_STATE_STRING_SIZE];

   215

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

   216

        ec_state_string(fsm->slave_states, states);

   217

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

   218

    }

   219

   220

    if (fsm->topology_change_pending) {

   221

        down(&master->scan_sem);

   222

        if (!master->allow_scan) {

   223

            up(&master->scan_sem);

   226

            up(&master->scan_sem);

   227

   228

            // topology change when scan is allowed:

   229

            // clear all slaves and scan the bus

   230

            fsm->topology_change_pending = 0;

   231

            fsm->idle = 0;

   232

            fsm->scan_jiffies = jiffies;

   233

   234

#ifdef EC_EOE

   235

            ec_master_eoe_stop(master);

   236

            ec_master_clear_eoe_handlers(master);

   237

#endif

   238

            ec_master_destroy_slaves(master);

   239

   240

            master->slave_count = datagram->working_counter;

   241

   242

            if (!master->slave_count) {

   243

                // no slaves present -> finish state machine.

   245

                wake_up_interruptible(&master->scan_queue);

   246

                fsm->state = ec_fsm_master_state_end;

   247

                return;

   248

            }

   249

   250

            // init slaves

   251

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

   252

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

   253

                                GFP_ATOMIC))) {

   254

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

   255

                    ec_master_destroy_slaves(master);

   257

                    wake_up_interruptible(&master->scan_queue);

   258

                    fsm->state = ec_fsm_master_state_error;

   259

                    return;

   260

                }

   261

   262

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

   263

                    // freeing of "slave" already done

   264

                    ec_master_destroy_slaves(master);

   266

                    wake_up_interruptible(&master->scan_queue);

   267

                    fsm->state = ec_fsm_master_state_error;

   268

                    return;

   269

                }

   270

   271

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

   272

            }

   273

   274

            if (master->debug_level)

   275

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

   276

   277

            ec_datagram_bwr(datagram, 0x0010, 2);

   278

            EC_WRITE_U16(datagram->data, 0x0000);

   279

            fsm->retries = EC_FSM_RETRIES;

   280

            fsm->state = ec_fsm_master_state_clear_addresses;

   281

            return;

   282

        }

   283

    }

   284

   285

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

   286

        fsm->state = ec_fsm_master_state_end;

   287

    } else {

   288

        // fetch state from each slave

   289

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

   290

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

   291

        fsm->retries = EC_FSM_RETRIES;

   292

        fsm->state = ec_fsm_master_state_read_states;

   293

    }

   294

}

   295

   296

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

   297

   298

/**

   299

 * Check for pending SII write requests and process one.

   300

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

   301

 */

   302

   303

int ec_fsm_master_action_process_sii(

   304

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

   305

        )

   306

{

   307

    ec_master_t *master = fsm->master;

   308

    ec_sii_write_request_t *request;

   309

    ec_slave_t *slave;

   310

   311

    // search the first request to be processed

   312

    while (1) {

   313

        down(&master->sii_sem);

   314

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

   315

            up(&master->sii_sem);

   316

            break;

   317

        }

   318

        // get first request

   319

        request = list_entry(master->sii_requests.next,

   320

                ec_sii_write_request_t, list);

   321

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

   322

        request->state = EC_REQUEST_BUSY;

   323

        up(&master->sii_sem);

   324

   325

        slave = request->slave;

   326

        if (slave->online_state == EC_SLAVE_OFFLINE) {

   327

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

   328

                    slave->ring_position);

   329

            request->state = EC_REQUEST_FAILURE;

   330

            wake_up(&master->sii_queue);

   331

            continue;

   332

        }

   333

   334

        // found pending SII write operation. execute it!

   335

        if (master->debug_level)

   336

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

   337

                    slave->ring_position);

   338

        fsm->sii_request = request;

   339

        fsm->sii_index = 0;

   340

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

   341

                request->data, EC_FSM_SII_USE_CONFIGURED_ADDRESS);

   342

        fsm->state = ec_fsm_master_state_write_sii;

   343

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

   344

        return 1;

   345

    }

   346

   347

    return 0;

   348

}

   349

   350

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

   351

   352

/**

   353

 * Check for pending Sdo requests and process one.

   354

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

   355

 */

   356

   357

int ec_fsm_master_action_process_sdo(

   358

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

   359

        )

   360

{

   361

    ec_master_t *master = fsm->master;

   362

    ec_master_sdo_request_t *request;

   363

    ec_sdo_request_t *req;

   364

    ec_slave_t *slave;

   365

   366

    // search for internal requests to be processed

   367

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

   368

        if (!slave->config)

   369

            continue;

   370

        list_for_each_entry(req, &slave->config->sdo_requests, list) {

   371

            if (req->state == EC_REQUEST_QUEUED) {

   372

   373

                if (ec_sdo_request_timed_out(req)) {

   374

                    req->state = EC_REQUEST_FAILURE;

   375

                    if (master->debug_level)

   376

                        EC_DBG("Sdo request for slave %u timed out...\n",

   377

                                slave->ring_position);

   378

                    continue;

   379

                }

   380

   381

                if (slave->current_state == EC_SLAVE_STATE_INIT ||

   382

                        slave->error_flag) {

   383

                    req->state = EC_REQUEST_FAILURE;

   384

                    continue;

   385

                }

   386

   387

                req->state = EC_REQUEST_BUSY;

   388

                if (master->debug_level)

   389

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

   390

                            slave->ring_position);

   391

   392

                fsm->idle = 0;

   393

                fsm->sdo_request = req;

   394

                fsm->slave = slave;

   395

                fsm->state = ec_fsm_master_state_sdo_request;

   396

                ec_fsm_coe_transfer(&fsm->fsm_coe, slave, req);

   397

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

   398

                return 1;

   399

            }

   400

        }

   401

    }

   402

   403

    // search the first external request to be processed

   404

    while (1) {

   405

        down(&master->sdo_sem);

   406

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

   407

            up(&master->sdo_sem);

   408

            break;

   409

        }

   410

        // get first request

   411

        request = list_entry(master->slave_sdo_requests.next,

   412

                ec_master_sdo_request_t, list);

   413

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

   414

        request->req.state = EC_REQUEST_BUSY;

   415

        up(&master->sdo_sem);

   416

   417

        slave = request->slave;

   418

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   419

                slave->online_state == EC_SLAVE_OFFLINE ||

   420

                slave->error_flag) {

   421

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

   422

                    slave->ring_position);

   423

            request->req.state = EC_REQUEST_FAILURE;

   424

            wake_up(&master->sdo_queue);

   425

            continue;

   426

        }

   427

   428

        // Found pending Sdo request. Execute it!

   429

        if (master->debug_level)

   430

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

   431

                    slave->ring_position);

   432

   433

        // Start uploading Sdo

   434

        fsm->idle = 0;

   435

        fsm->sdo_request = &request->req;

   436

        fsm->slave = slave;

   437

        fsm->state = ec_fsm_master_state_sdo_request;

   438

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

   439

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

   440

        return 1;

   441

    }

   442

   443

    return 0;

   444

}

   445

   446

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

   447

   448

/**

   449

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

   450

 */

   451

   452

int ec_fsm_master_action_configure(

   453

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

   454

        )

   455

{

   456

    ec_slave_t *slave;

   457

    ec_master_t *master = fsm->master;

   458

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   459

   460

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

   461

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

   462

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

   463

        if (slave->error_flag

   464

                || slave->online_state == EC_SLAVE_OFFLINE

   465

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   466

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

   467

                    && slave->self_configured)) continue;

   468

   469

        if (master->debug_level) {

   470

            ec_state_string(slave->current_state, old_state);

   471

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

   472

                ec_state_string(slave->requested_state, new_state);

   473

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

   474

                        slave->ring_position, old_state, new_state);

   475

            }

   476

            else if (!slave->self_configured) {

   477

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

   478

                        slave->ring_position, old_state);

   479

            }

   480

        }

   481

   482

        fsm->idle = 0;

   483

        fsm->slave = slave;

   484

        fsm->state = ec_fsm_master_state_configure_slave;

   485

        ec_fsm_slave_config_start(&fsm->fsm_slave_config, slave);

   486

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

   487

        return 1;

   488

    }