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 *);

    49

void ec_fsm_master_read_states(ec_fsm_t *);

    50

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    51

void ec_fsm_master_validate_product(ec_fsm_t *);

    52

void ec_fsm_master_rewrite_addresses(ec_fsm_t *);

    53

void ec_fsm_master_configure_slave(ec_fsm_t *);

    54

void ec_fsm_master_scan_slaves(ec_fsm_t *);

    55

void ec_fsm_master_write_eeprom(ec_fsm_t *);

    56

    74

    75

void ec_fsm_sii_start_reading(ec_fsm_t *);

    76

void ec_fsm_sii_read_check(ec_fsm_t *);

    77

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    78

void ec_fsm_sii_start_writing(ec_fsm_t *);

    79

void ec_fsm_sii_write_check(ec_fsm_t *);

    80

void ec_fsm_sii_write_check2(ec_fsm_t *);

    81

void ec_fsm_sii_end(ec_fsm_t *);

    82

void ec_fsm_sii_error(ec_fsm_t *);

    83

    84

void ec_fsm_change_start(ec_fsm_t *);

    85

void ec_fsm_change_check(ec_fsm_t *);

    86

void ec_fsm_change_status(ec_fsm_t *);

    87

void ec_fsm_change_code(ec_fsm_t *);

    88

void ec_fsm_change_ack(ec_fsm_t *);

    89

void ec_fsm_change_ack2(ec_fsm_t *);

    90

void ec_fsm_change_end(ec_fsm_t *);

    91

void ec_fsm_change_error(ec_fsm_t *);

    92

    93

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

    94

    95

/**

    96

   Constructor.

    97

*/

    98

    99

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

   100

                ec_master_t *master /**< EtherCAT master */

   101

    )

   102

{

   103

    fsm->master = master;

   104

    fsm->master_state = ec_fsm_master_start;

   105

    fsm->master_slaves_responding = 0;

   106

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   107

    fsm->master_validation = 0;

   108

   109

    ec_datagram_init(&fsm->datagram);

   110

    if (ec_datagram_prealloc(&fsm->datagram, EC_MAX_DATA_SIZE)) {

   111

        EC_ERR("Failed to allocate FSM datagram.\n");

   112

        return -1;

   113

    }

   114

   115

    return 0;

   116

}

   117

   118

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

   119

   120

/**

   121

   Destructor.

   122

*/

   123

   124

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

   125

{

   126

    ec_datagram_clear(&fsm->datagram);

   127

}

   128

   129

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

   130

   131

/**

   132

   Resets the state machine.

   133

*/

   134

   135

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

   136

{

   137

    fsm->master_state = ec_fsm_master_start;

   138

    fsm->master_slaves_responding = 0;

   139

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   140

}

   141

   142

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

   143

   144

/**

   145

   Executes the current state of the state machine.

   146

*/

   147

   148

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

   149

{

   150

    fsm->master_state(fsm);

   151

}

   152

   153

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

   154

 *  master state machine

   155

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

   156

   157

/**

   158

   Master state: START.

   159

   Starts with getting slave count and slave states.

   160

*/

   161

   162

void ec_fsm_master_start(ec_fsm_t *fsm)

   163

{

   164

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

   165

    ec_master_queue_datagram(fsm->master, &fsm->datagram);

   166

    fsm->master_state = ec_fsm_master_broadcast;

   167

}

   168

   169

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

   170

   171

/**

   172

   Master state: BROADCAST.

   173

   Processes the broadcast read slave count and slaves states.

   174

*/

   175

   176

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

   177

{

   178

    ec_datagram_t *datagram = &fsm->datagram;

   179

    unsigned int topology_change, states_change, i;

   180

    ec_slave_t *slave;

   181

    ec_master_t *master = fsm->master;

   182

   183

    if (datagram->state != EC_CMD_RECEIVED) {

   184

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

   185

            fsm->master_slaves_responding = 0;

   186

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

   187

                slave->online = 0;

   188

            }

   189

        }

   190

        fsm->master_state = ec_fsm_master_start;

   191

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

   192

        return;

   193

    }

   194

   195

    topology_change = (datagram->working_counter !=

   196

                       fsm->master_slaves_responding);

   197

    states_change = (EC_READ_U8(datagram->data) != fsm->master_slave_states);

   198

   199

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

   200

    fsm->master_slaves_responding = datagram->working_counter;

   201

   202

    if (topology_change) {

   203

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

   204

                fsm->master_slaves_responding,

   205

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

   206

   207

        if (master->mode == EC_MASTER_MODE_RUNNING) {

   208

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

   209

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

   210

            }

   211

            else {

   212

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

   213

            }

   214

        }

   215

    }

   216

   217

    if (states_change) {

   218

        EC_INFO("Slave states: ");

   219

        ec_print_states(fsm->master_slave_states);

   220

        printk(".\n");

   221

    }

   222

   223

    // topology change in idle mode: clear all slaves and scan the bus

   224

    if (topology_change && master->mode == EC_MASTER_MODE_IDLE) {

   225

        EC_INFO("Scanning bus.\n");

   226

   227

        ec_master_eoe_stop(master);

   228

        ec_master_clear_slaves(master);

   229

   230

        if (!fsm->master_slaves_responding) {

   231

            // no slaves present -> finish state machine.

   232

            fsm->master_state = ec_fsm_master_start;

   233

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

   234

            return;

   235

        }

   236

   237

        // init slaves

   238

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

   239

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

   240

                                                 GFP_ATOMIC))) {

   241

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

   242

                fsm->master_state = ec_fsm_master_start;

   243

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

   244

                return;

   245

            }

   246

   247

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

   248

                fsm->master_state = ec_fsm_master_start;

   249

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

   250

                return;

   251

            }

   252

   253

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

   254

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

   255

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

   256

                fsm->master_state = ec_fsm_master_start;

   257

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

   258

                return;

   259

            }

   260

   261

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

   262

        }

   263

   264

        // begin scanning of slaves

   265

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

   267

        fsm->master_state = ec_fsm_master_scan_slaves;

   268

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

   269

        return;

   270

    }

   271

   272

    // fetch state from each slave

   273

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

   274

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

   275

    ec_master_queue_datagram(master, &fsm->datagram);

   276

    fsm->master_state = ec_fsm_master_read_states;

   277

}

   278

   279

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

   280

   281

/**

   282

   Master action: PROC_STATES.

   283

   Processes the slave states.

   284

*/

   285

   286

void ec_fsm_master_action_process_states(ec_fsm_t *fsm

   287

                                         /**< finite state machine */

   288

                                         )

   289

{

   290

    ec_master_t *master = fsm->master;

   291

    ec_slave_t *slave;

   292

   293

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

   294

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

   295

        if (slave->error_flag ||

   296

            !slave->online ||

   297

            slave->requested_state == EC_SLAVE_STATE_UNKNOWN ||

   298

            slave->current_state == slave->requested_state) continue;

   299

   300

        EC_INFO("Changing state of slave %i from ", slave->ring_position);

   301

        ec_print_states(slave->current_state);

   302

        printk(" to ");

   303

        ec_print_states(slave->requested_state);

   304

        printk(".\n");

   305

   306

        fsm->slave = slave;

   308

        fsm->change_new = EC_SLAVE_STATE_INIT;

   309

        fsm->change_state = ec_fsm_change_start;

   310

        fsm->master_state = ec_fsm_master_configure_slave;

   311

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

   312

        return;

   313

    }

   314

   315

    if (master->mode == EC_MASTER_MODE_IDLE) {

   316

        // nothing to configure. check for pending EEPROM write operations.

   317

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

   318

            if (!slave->new_eeprom_data) continue;

   319

   320

            if (!slave->online || slave->error_flag) {

   321

                kfree(slave->new_eeprom_data);

   322

                slave->new_eeprom_data = NULL;

   323

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

   324

                       slave->ring_position);

   325

                continue;

   326

            }

   327

   328

            // found pending EEPROM write operation. execute it!

   329

            EC_INFO("Writing EEPROM of slave %i...\n", slave->ring_position);

   330

            fsm->sii_offset = 0x0000;

   331

            memcpy(fsm->sii_value, slave->new_eeprom_data, 2);

   332

            fsm->sii_mode = 1;

   333

            fsm->sii_state = ec_fsm_sii_start_writing;

   334

            fsm->slave = slave;

   335

            fsm->master_state = ec_fsm_master_write_eeprom;

   336

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

   337

            return;

   338

        }

   339

    }

   340

   341

    // nothing to do. restart master state machine.

   342

    fsm->master_state = ec_fsm_master_start;

   343

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

   344

}

   345

   346

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

   347

   348

/**

   349

   Master action: Get state of next slave.

   350

*/

   351

   352

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   353

                                           /**< finite state machine */)

   354

{

   355

    ec_master_t *master = fsm->master;

   356

    ec_slave_t *slave = fsm->slave;

   357

   358

    // is there another slave to query?

   359

    if (slave->list.next != &master->slaves) {

   360

        // process next slave

   361

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

   362

        ec_datagram_nprd(&fsm->datagram, fsm->slave->station_address,

   363

                         0x0130, 2);

   364

        ec_master_queue_datagram(master, &fsm->datagram);

   365

        fsm->master_state = ec_fsm_master_read_states;

   366

        return;

   367

    }

   368

   369

    // all slave states read

   370

   371

    // check, if a bus validation has to be done

   372

    if (fsm->master_validation) {

   373

        fsm->master_validation = 0;

   374

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

   375

            if (slave->online) continue;

   376

   377

            // At least one slave is offline. validate!

   378

            EC_INFO("Validating bus.\n");

   379

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

   380

            fsm->master_state = ec_fsm_master_validate_vendor;

   381

            fsm->sii_offset = 0x0008; // vendor ID

   382

            fsm->sii_mode = 0;

   383

            fsm->sii_state = ec_fsm_sii_start_reading;

   384

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

   385

            return;

   386

        }

   387

    }

   388

   389

    ec_fsm_master_action_process_states(fsm);

   390

}

   391

   392

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

   393

   394

/**

   395

   Master state: STATES.

   396

   Fetches the AL- and online state of a slave.

   397

*/

   398

   399

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

   400

{

   401

    ec_slave_t *slave = fsm->slave;

   402

    ec_datagram_t *datagram = &fsm->datagram;

   403

    uint8_t new_state;

   404

   405

    if (datagram->state != EC_CMD_RECEIVED) {

   406

        fsm->master_state = ec_fsm_master_start;

   407

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

   408

        return;

   409

    }

   410

   411

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

   412

    if (datagram->working_counter != 1) {

   413

        if (slave->online) {

   414

            slave->online = 0;

   415

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

   416

        }

   417

        ec_fsm_master_action_next_slave_state(fsm);

   418

        return;

   419

    }

   420

   421

    // slave responded

   422

    new_state = EC_READ_U8(datagram->data);

   423

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

   424

        slave->online = 1;

   425

        slave->error_flag = 0; // clear error flag

   426

        slave->current_state = new_state;

   427

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

   428

        ec_print_states(new_state);

   429

        printk(").\n");

   430

    }

   431

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

   432

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

   433

        ec_print_states(slave->current_state);

   434

        printk(" -> ");

   435

        ec_print_states(new_state);

   436

        printk(".\n");

   437

        slave->current_state = new_state;

   438

    }

   439

   440

    ec_fsm_master_action_next_slave_state(fsm);

   441

}

   442

   443

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

   444

   445

/**

   446

   Master state: VALIDATE_VENDOR.

   447

   Validates the vendor ID of a slave.

   448

*/

   449

   450

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

   451

{

   452

    ec_slave_t *slave = fsm->slave;

   453

   454

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

   455

   456

    if (fsm->sii_state == ec_fsm_sii_error) {

   457

        fsm->slave->error_flag = 1;

   458

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

   459

               slave->ring_position);

   460

        fsm->master_state = ec_fsm_master_start;

   461

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

   462

        return;

   463

    }

   464

   465

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

   466

   467

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

   468

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

   469

        fsm->master_state = ec_fsm_master_start;

   470

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

   471

        return;

   472

    }

   473

   474

    // vendor ID is ok. check product code.

   475

    fsm->master_state = ec_fsm_master_validate_product;

   476

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

   477

    fsm->sii_mode = 0;

   478

    fsm->sii_state = ec_fsm_sii_start_reading;

   479

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

   480

}

   481

   482

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

   483

   484

/**

   485

   Master action: ADDRESS.

   486

   Looks for slave, that have lost their configuration and writes

   487

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

   488

*/

   489

   490

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

   491

{

   492

    ec_datagram_t *datagram = &fsm->datagram;

   493

   494

    while (fsm->slave->online) {

   495

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

   496

            fsm->master_state = ec_fsm_master_start;

   497