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 "fsm.h"

    43

#include "master.h"

    44

    45

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

    46

    47

void ec_fsm_master_start(ec_fsm_t *);

    48

void ec_fsm_master_broadcast(ec_fsm_t *);

    50

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    51

void ec_fsm_master_validate_product(ec_fsm_t *);

    73

    74

void ec_fsm_sii_start_reading(ec_fsm_t *);

    75

void ec_fsm_sii_read_check(ec_fsm_t *);

    76

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    77

void ec_fsm_sii_start_writing(ec_fsm_t *);

    78

void ec_fsm_sii_write_check(ec_fsm_t *);

    79

void ec_fsm_sii_write_check2(ec_fsm_t *);

    80

void ec_fsm_sii_end(ec_fsm_t *);

    81

void ec_fsm_sii_error(ec_fsm_t *);

    82

    83

void ec_fsm_change_start(ec_fsm_t *);

    84

void ec_fsm_change_check(ec_fsm_t *);

    85

void ec_fsm_change_status(ec_fsm_t *);

    86

void ec_fsm_change_code(ec_fsm_t *);

    87

void ec_fsm_change_ack(ec_fsm_t *);

    89

void ec_fsm_change_end(ec_fsm_t *);

    90

void ec_fsm_change_error(ec_fsm_t *);

    91

    92

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

    93

    94

/**

    95

   Constructor.

    96

*/

    97

    98

int ec_fsm_init(ec_fsm_t *fsm, /**< finite state machine */

    99

                ec_master_t *master /**< EtherCAT master */

   101

{

   102

    fsm->master = master;

   103

    fsm->master_state = ec_fsm_master_start;

   104

    fsm->master_slaves_responding = 0;

   105

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   106

    fsm->master_validation = 0;

   107

   111

        return -1;

   112

    }

   113

   114

    return 0;

   115

}

   116

   117

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

   118

   119

/**

   120

   Destructor.

   121

*/

   122

   123

void ec_fsm_clear(ec_fsm_t *fsm /**< finite state machine */)

   124

{

   126

}

   127

   128

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

   129

   130

/**

   131

   Resets the state machine.

   132

*/

   133

   134

void ec_fsm_reset(ec_fsm_t *fsm /**< finite state machine */)

   135

{

   136

    fsm->master_state = ec_fsm_master_start;

   137

    fsm->master_slaves_responding = 0;

   138

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   139

}

   140

   141

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

   142

   143

/**

   144

   Executes the current state of the state machine.

   145

*/

   146

   147

void ec_fsm_execute(ec_fsm_t *fsm /**< finite state machine */)

   148

{

   149

    fsm->master_state(fsm);

   150

}

   151

   152

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

   153

 *  master state machine

   154

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

   155

   156

/**

   157

   Master state: START.

   158

   Starts with getting slave count and slave states.

   159

*/

   160

   161

void ec_fsm_master_start(ec_fsm_t *fsm)

   162

{

   165

    fsm->master_state = ec_fsm_master_broadcast;

   166

}

   167

   168

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

   169

   170

/**

   171

   Master state: BROADCAST.

   172

   Processes the broadcast read slave count and slaves states.

   173

*/

   174

   175

void ec_fsm_master_broadcast(ec_fsm_t *fsm /**< finite state machine */)

   176

{

   178

    unsigned int topology_change, states_change, i;

   179

    ec_slave_t *slave;

   180

    ec_master_t *master = fsm->master;

   181

   183

        if (!master->device->link_state) {

   184

            fsm->master_slaves_responding = 0;

   185

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

   186

                slave->online = 0;

   187

            }

   188

        }

   189

        fsm->master_state = ec_fsm_master_start;

   190

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

   191

        return;

   192

    }

   193

   195

                       fsm->master_slaves_responding);

   200

   201

    if (topology_change) {

   202

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

   203

                fsm->master_slaves_responding,

   204

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

   205

   206

        if (master->mode == EC_MASTER_MODE_RUNNING) {

   207

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

   208

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

   209

            }

   210

            else {

   211

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

   212

            }

   213

        }

   214

    }

   215

   216

    if (states_change) {

   217

        EC_INFO("Slave states: ");

   218

        ec_print_states(fsm->master_slave_states);

   219

        printk(".\n");

   220

    }

   221

   224

        EC_INFO("Scanning bus.\n");

   225

   226

        ec_master_eoe_stop(master);

   227

        ec_master_clear_slaves(master);

   228

   229

        if (!fsm->master_slaves_responding) {

   230

            // no slaves present -> finish state machine.

   231

            fsm->master_state = ec_fsm_master_start;

   232

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

   233

            return;

   234

        }

   235

   236

        // init slaves

   237

        for (i = 0; i < fsm->master_slaves_responding; i++) {

   238

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

   239

                                                 GFP_ATOMIC))) {

   240

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

   241

                fsm->master_state = ec_fsm_master_start;

   242

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

   243

                return;

   244

            }

   245

   246

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

   247

                fsm->master_state = ec_fsm_master_start;

   248

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

   249

                return;

   250

            }

   251

   252

            if (kobject_add(&slave->kobj)) {

   253

                EC_ERR("Failed to add kobject.\n");

   254

                kobject_put(&slave->kobj); // free

   255

                fsm->master_state = ec_fsm_master_start;

   256

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

   257

                return;

   258

            }

   259

   260

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

   261

        }

   262

   263

        // begin scanning of slaves

   264

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

   267

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

   268

        return;

   269

    }

   270

   271

    // fetch state from each slave

   272

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

   343

}

   344

   345

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

   346

   347

/**

   348

   Master action: Get state of next slave.

   349

*/

   350

   351

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   352

                                           /**< finite state machine */)

   353

{

   354

    ec_master_t *master = fsm->master;

   355

    ec_slave_t *slave = fsm->slave;

   356

   385

        }

   389

}

   390

   391

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

   392

   393

/**

   394

   Master state: STATES.

   395

   Fetches the AL- and online state of a slave.

   396

*/

   397

   402

    uint8_t new_state;

   403

   405

        fsm->master_state = ec_fsm_master_start;

   406

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

   407

        return;

   408

    }

   409

   410

    // did the slave not respond to its station address?

   412

        if (slave->online) {

   413

            slave->online = 0;

   414

            EC_INFO("Slave %i: offline.\n", slave->ring_position);

   415

        }

   416

        ec_fsm_master_action_next_slave_state(fsm);

   417

        return;

   418

    }

   419

   420

    // slave responded

   422

    if (!slave->online) { // slave was offline before

   423

        slave->online = 1;

   425

        slave->current_state = new_state;

   426

        EC_INFO("Slave %i: online (", slave->ring_position);

   427

        ec_print_states(new_state);

   428

        printk(").\n");

   429

    }

   430

    else if (new_state != slave->current_state) {

   431

        EC_INFO("Slave %i: ", slave->ring_position);

   432

        ec_print_states(slave->current_state);

   433

        printk(" -> ");

   434

        ec_print_states(new_state);

   435

        printk(".\n");

   436

        slave->current_state = new_state;

   437

    }

   438

   439

    ec_fsm_master_action_next_slave_state(fsm);

   440

}

   441

   442

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

   443

   444

/**

   445

   Master state: VALIDATE_VENDOR.

   446

   Validates the vendor ID of a slave.

   447

*/

   448

   449

void ec_fsm_master_validate_vendor(ec_fsm_t *fsm /**< finite state machine */)

   450

{

   451

    ec_slave_t *slave = fsm->slave;

   452

   453

    fsm->sii_state(fsm); // execute SII state machine

   454

   455

    if (fsm->sii_state == ec_fsm_sii_error) {

   457

        EC_ERR("Failed to validate vendor ID of slave %i.\n",

   458

               slave->ring_position);

   459

        fsm->master_state = ec_fsm_master_start;

   460

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

   461

        return;

   462

    }

   463

   464

    if (fsm->sii_state != ec_fsm_sii_end) return;

   465

   466

    if (EC_READ_U32(fsm->sii_value) != slave->sii_vendor_id) {

   467

        EC_ERR("Slave %i: invalid vendor ID!\n", slave->ring_position);

   468

        fsm->master_state = ec_fsm_master_start;

   469

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

   470

        return;

   471

    }

   472

   473

    // vendor ID is ok. check product code.

   474

    fsm->master_state = ec_fsm_master_validate_product;

   475

    fsm->sii_offset = 0x000A; // product code

   476

    fsm->sii_mode = 0;

   477

    fsm->sii_state = ec_fsm_sii_start_reading;

   478

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

   479

}

   480

   481

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

   482

   483

/**

   485

   Looks for slave, that have lost their configuration and writes

   486

   their station address, so that they can be reconfigured later.

   487

*/

   488

   492

   493

    while (fsm->slave->online) {

   494

        if (fsm->slave->list.next == &fsm->master->slaves) { // last slave?

   495

            fsm->master_state = ec_fsm_master_start;

   496

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

   497

            return;

   498

        }

   499

        // check next slave

   500

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

   501

    }

   502

   503

    EC_INFO("Reinitializing slave %i.\n", fsm->slave->ring_position);

   504

   505

    // write station address