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_sdo_dictionary(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

    // bus topology change?

   194

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

   195

        fsm->topology_change_pending = 1;

   196

        fsm->slaves_responding = datagram->working_counter;

   203

    }

   204

   205

    // slave states changed?

   206

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

   207

        char states[EC_STATE_STRING_SIZE];

   208

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

   209

        ec_state_string(fsm->slave_states, states);

   210

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

   211

    }

   212

   213

    if (fsm->topology_change_pending) {

   214

        down(&master->scan_sem);

   215

        if (!master->allow_scan) {

   216

            up(&master->scan_sem);

   217

        } else {

   218

            master->scan_busy = 1;

   219

            up(&master->scan_sem);

   220

   221

            // topology change when scan is allowed:

   222

            // clear all slaves and scan the bus

   223

            fsm->topology_change_pending = 0;

   224

            fsm->idle = 0;

   225

            fsm->scan_jiffies = jiffies;

   226

   227

#ifdef EC_EOE

   228

            ec_master_eoe_stop(master);

   229

            ec_master_clear_eoe_handlers(master);

   230

#endif

   231

            ec_master_destroy_slaves(master);

   232

   233

            master->slave_count = datagram->working_counter;

   234

   235

            if (!master->slave_count) {

   236

                // no slaves present -> finish state machine.

   237

                master->scan_busy = 0;

   238

                wake_up_interruptible(&master->scan_queue);

   239

                fsm->state = ec_fsm_master_state_end;

   240

                return;

   241

            }

   242

   243

            // init slaves

   244

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

   245

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

   246

                                GFP_ATOMIC))) {

   247

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

   248

                    ec_master_destroy_slaves(master);

   249

                    master->scan_busy = 0;

   250

                    wake_up_interruptible(&master->scan_queue);

   251

                    fsm->state = ec_fsm_master_state_error;

   252

                    return;

   253

                }

   254

   255

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

   256

                    // freeing of "slave" already done

   257

                    ec_master_destroy_slaves(master);

   258

                    master->scan_busy = 0;

   259

                    wake_up_interruptible(&master->scan_queue);

   260

                    fsm->state = ec_fsm_master_state_error;

   261

                    return;

   262

                }

   263

   264

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

   265

            }

   266

   267

            // broadcast clear all station addresses

   268

            ec_datagram_bwr(datagram, 0x0010, 2);

   269

            EC_WRITE_U16(datagram->data, 0x0000);

   270

            fsm->retries = EC_FSM_RETRIES;

   271

            fsm->state = ec_fsm_master_state_clear_addresses;

   272

            return;

   273

        }

   274

    }

   275

   276

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

   277

        fsm->state = ec_fsm_master_state_end;

   278

    } else {

   279

        // fetch state from each slave

   280

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

   281

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

   282

        fsm->retries = EC_FSM_RETRIES;

   283

        fsm->state = ec_fsm_master_state_read_states;

   284

    }

   285

}

   286

   287

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

   288

   289

/**

   290

 * Check for pending SII write requests and process one.

   291

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

   292

 */

   293

   294

int ec_fsm_master_action_process_sii(

   295

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

   296

        )

   297

{

   298

    ec_master_t *master = fsm->master;

   299

    ec_sii_write_request_t *request;

   300

   301

    // search the first request to be processed

   302

    while (1) {

   303

        down(&master->sii_sem);

   304

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

   305

            up(&master->sii_sem);

   306

            break;

   307

        }

   308

        // get first request

   309

        request = list_entry(master->sii_requests.next,

   310

                ec_sii_write_request_t, list);

   311

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

   312

        request->state = EC_REQUEST_BUSY;

   313

        up(&master->sii_sem);

   314

   315

        // found pending SII write operation. execute it!

   316

        if (master->debug_level)

   319

        fsm->sii_request = request;

   320

        fsm->sii_index = 0;

   321

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

   322

                request->data, EC_FSM_SII_USE_CONFIGURED_ADDRESS);

   323

        fsm->state = ec_fsm_master_state_write_sii;

   324

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

   325

        return 1;

   326

    }

   327

   328

    return 0;

   329

}

   330

   331

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

   332

   333

/**

   334

 * Check for pending Sdo requests and process one.

   335

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

   336

 */

   337

   338

int ec_fsm_master_action_process_sdo(

   339

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

   340

        )

   341

{

   342

    ec_master_t *master = fsm->master;

   343

    ec_master_sdo_request_t *request;

   344

    ec_sdo_request_t *req;

   345

    ec_slave_t *slave;

   346

   347

    // search for internal requests to be processed

   348

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

   349

        if (!slave->config)

   350

            continue;

   351

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

   352

            if (req->state == EC_REQUEST_QUEUED) {

   353

   354

                if (ec_sdo_request_timed_out(req)) {

   355

                    req->state = EC_REQUEST_FAILURE;

   356

                    if (master->debug_level)

   357

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

   358

                                slave->ring_position);

   359

                    continue;

   360

                }

   361

   362

                if (slave->current_state == EC_SLAVE_STATE_INIT ||

   363

                        slave->error_flag) {

   364

                    req->state = EC_REQUEST_FAILURE;

   365

                    continue;

   366

                }

   367

   368

                req->state = EC_REQUEST_BUSY;

   369

                if (master->debug_level)

   370

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

   371

                            slave->ring_position);

   372

   373

                fsm->idle = 0;

   374

                fsm->sdo_request = req;

   375

                fsm->slave = slave;

   376

                fsm->state = ec_fsm_master_state_sdo_request;

   377

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

   378

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

   379

                return 1;

   380

            }

   381

        }

   382

    }

   383

   384

    // search the first external request to be processed

   385

    while (1) {

   386

        down(&master->sdo_sem);

   387

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

   388

            up(&master->sdo_sem);

   389

            break;

   390

        }

   391

        // get first request

   392

        request = list_entry(master->slave_sdo_requests.next,

   393

                ec_master_sdo_request_t, list);

   394

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

   395

        request->req.state = EC_REQUEST_BUSY;

   396

        up(&master->sdo_sem);

   397

   398

        slave = request->slave;

   399

        if (slave->current_state == EC_SLAVE_STATE_INIT ||

   400

                slave->error_flag) {

   401

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

   402

                    slave->ring_position);

   403

            request->req.state = EC_REQUEST_FAILURE;

   404

            wake_up(&master->sdo_queue);

   405

            continue;

   406

        }

   407

   408

        // Found pending Sdo request. Execute it!

   409

        if (master->debug_level)

   411

                    slave->ring_position);

   412

   413

        // Start uploading Sdo

   414

        fsm->idle = 0;

   415

        fsm->sdo_request = &request->req;

   416

        fsm->slave = slave;

   417

        fsm->state = ec_fsm_master_state_sdo_request;

   418

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

   419

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

   420

        return 1;

   421

    }

   422

   423

    return 0;

   424

}

   425

   426

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

   427

   428

/**

   429

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

   430

 */

   431

   432

int ec_fsm_master_action_configure(

   433

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

   434

        )

   435

{

   436

    ec_slave_t *slave;

   437

    ec_master_t *master = fsm->master;

   438

    char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];

   439

   440

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

   441

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

   442

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

   443

        if (slave->error_flag

   444

                || slave->requested_state == EC_SLAVE_STATE_UNKNOWN

   445

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

   446

                    && slave->self_configured)) continue;

   447

   448

        if (master->debug_level) {

   449

            ec_state_string(slave->current_state, old_state);

   450

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

   451

                ec_state_string(slave->requested_state, new_state);

   452

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

   453

                        slave->ring_position, old_state, new_state);

   454

            }

   455

            else if (!slave->self_configured) {

   456

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

   457

                        slave->ring_position, old_state);

   458

            }

   459

        }

   460

   461

        fsm->idle = 0;

   462

        fsm->slave = slave;

   463

        fsm->state = ec_fsm_master_state_configure_slave;

   464

        ec_fsm_slave_config_start(&fsm->fsm_slave_config, slave);

   465

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

   466

        return 1;

   467

    }

   468

   469

    master->config_busy = 0;

   470

    wake_up_interruptible(&master->config_queue);

   471

    return 0;

   472

}

   473

   474

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

   475

   476

/**

   477

   Master action: PROC_STATES.

   478

   Processes the slave states.

   479

*/

   480

   481

void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm

   482

                                         /**< master state machine */

   483

                                         )

   484

{

   485

    ec_master_t *master = fsm->master;

   486

    ec_slave_t *slave;

   487

   488

    // Start slave configuration, if it is allowed.