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_proc_states(ec_fsm_t *);

    50

void ec_fsm_master_scan(ec_fsm_t *);

    51

void ec_fsm_master_states(ec_fsm_t *);

    52

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    53

void ec_fsm_master_validate_product(ec_fsm_t *);

    54

void ec_fsm_master_reconfigure(ec_fsm_t *);

    55

void ec_fsm_master_address(ec_fsm_t *);

    56

void ec_fsm_master_conf(ec_fsm_t *);

    57

void ec_fsm_master_eeprom(ec_fsm_t *);

    58

    59

void ec_fsm_slave_start_reading(ec_fsm_t *);

    60

void ec_fsm_slave_read_status(ec_fsm_t *);

    61

void ec_fsm_slave_read_base(ec_fsm_t *);

    62

void ec_fsm_slave_read_dl(ec_fsm_t *);

    63

void ec_fsm_slave_eeprom_size(ec_fsm_t *);

    64

void ec_fsm_slave_fetch_eeprom(ec_fsm_t *);

    65

void ec_fsm_slave_fetch_eeprom2(ec_fsm_t *);

    66

void ec_fsm_slave_end(ec_fsm_t *);

    67

    68

void ec_fsm_slave_conf(ec_fsm_t *);

    69

void ec_fsm_slave_sync(ec_fsm_t *);

    70

void ec_fsm_slave_preop(ec_fsm_t *);

    71

void ec_fsm_slave_fmmu(ec_fsm_t *);

    72

void ec_fsm_slave_saveop(ec_fsm_t *);

    73

void ec_fsm_slave_op(ec_fsm_t *);

    74

void ec_fsm_slave_op2(ec_fsm_t *);

    75

    76

void ec_fsm_sii_start_reading(ec_fsm_t *);

    77

void ec_fsm_sii_read_check(ec_fsm_t *);

    78

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    79

void ec_fsm_sii_start_writing(ec_fsm_t *);

    80

void ec_fsm_sii_write_check(ec_fsm_t *);

    81

void ec_fsm_sii_write_check2(ec_fsm_t *);

    82

void ec_fsm_sii_end(ec_fsm_t *);

    83

void ec_fsm_sii_error(ec_fsm_t *);

    84

    85

void ec_fsm_change_start(ec_fsm_t *);

    86

void ec_fsm_change_check(ec_fsm_t *);

    87

void ec_fsm_change_status(ec_fsm_t *);

    88

void ec_fsm_change_code(ec_fsm_t *);

    89

void ec_fsm_change_ack(ec_fsm_t *);

    90

void ec_fsm_change_ack2(ec_fsm_t *);

    91

void ec_fsm_change_end(ec_fsm_t *);

    92

void ec_fsm_change_error(ec_fsm_t *);

    93

    94

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

    95

    96

/**

    97

   Constructor.

    98

*/

    99

   100

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

   101

                ec_master_t *master /**< EtherCAT master */

   102

                )

   103

{

   104

    fsm->master = master;

   105

    fsm->master_state = ec_fsm_master_start;

   106

    fsm->master_slaves_responding = 0;

   107

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   108

    fsm->master_validation = 0;

   109

   110

    ec_command_init(&fsm->command);

   111

    if (ec_command_prealloc(&fsm->command, EC_MAX_DATA_SIZE)) {

   112

        EC_ERR("FSM failed to allocate FSM command.\n");

   113

        return -1;

   114

    }

   115

   116

    return 0;

   117

}

   118

   119

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

   120

   121

/**

   122

   Destructor.

   123

*/

   124

   125

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

   126

{

   127

    ec_command_clear(&fsm->command);

   128

}

   129

   130

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

   131

   132

/**

   133

   Resets the state machine.

   134

*/

   135

   136

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

   137

{

   138

    fsm->master_state = ec_fsm_master_start;

   139

    fsm->master_slaves_responding = 0;

   140

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   141

}

   142

   143

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

   144

   145

/**

   146

   Executes the current state of the state machine.

   147

*/

   148

   149

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

   150

{

   151

    fsm->master_state(fsm);

   152

}

   153

   154

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

   155

 *  master state machine

   156

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

   157

   158

/**

   159

   Master state: START.

   160

   Starts with getting slave count and slave states.

   161

*/

   162

   163

void ec_fsm_master_start(ec_fsm_t *fsm)

   164

{

   165

    ec_command_brd(&fsm->command, 0x0130, 2);

   166

    ec_master_queue_command(fsm->master, &fsm->command);

   167

    fsm->master_state = ec_fsm_master_broadcast;

   168

}

   169

   170

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

   171

   172

/**

   173

   Master state: BROADCAST.

   174

   Processes the broadcast read slave count and slaves states.

   175

*/

   176

   177

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

   178

{

   179

    ec_command_t *command = &fsm->command;

   180

    unsigned int topology_change, states_change, i;

   181

    ec_slave_t *slave;

   182

    ec_master_t *master = fsm->master;

   183

   184

    if (command->state != EC_CMD_RECEIVED) {

   185

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

   186

            fsm->master_slaves_responding = 0;

   187

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

   188

                slave->online = 0;

   189

            }

   190

        }

   191

        fsm->master_state = ec_fsm_master_start;

   192

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

   193

        return;

   194

    }

   195

   196

    topology_change = (command->working_counter !=

   197

                       fsm->master_slaves_responding);

   198

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

   199

   200

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

   201

    fsm->master_slaves_responding = command->working_counter;

   202

   203

    if (topology_change) {

   204

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

   205

                fsm->master_slaves_responding,

   206

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

   207

   208

        if (master->mode == EC_MASTER_MODE_RUNNING) {

   209

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

   210

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

   211

            }

   212

            else {

   213

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

   214

            }

   215

        }

   216

    }

   217

   218

    if (states_change) {

   219

        EC_INFO("Slave states: ");

   220

        ec_print_states(fsm->master_slave_states);

   221

        printk(".\n");

   222

    }

   223

   224

    // topology change in free-run mode: clear all slaves and scan the bus

   225

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

   226

        EC_INFO("Scanning bus.\n");

   227

   228

        ec_master_eoe_stop(master);

   229

        ec_master_clear_slaves(master);

   230

   231

        if (!fsm->master_slaves_responding) {

   232

            // no slaves present -> finish state machine.

   233

            fsm->master_state = ec_fsm_master_start;

   234

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

   235

            return;

   236

        }

   237

   238

        // init slaves

   239

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

   240

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

   241

                                                 GFP_ATOMIC))) {

   242

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

   243

                fsm->master_state = ec_fsm_master_start;

   244

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

   245

                return;

   246

            }

   247

   248

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

   249

                fsm->master_state = ec_fsm_master_start;

   250

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

   251

                return;

   252

            }

   253

   254

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

   255

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

   256

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

   257

                fsm->master_state = ec_fsm_master_start;

   258

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

   259

                return;

   260

            }

   261

   262

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

   263

        }

   264

   265

        // begin scanning of slaves

   266

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

   267

        fsm->slave_state = ec_fsm_slave_start_reading;

   268

        fsm->master_state = ec_fsm_master_scan;

   269

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

   270

        return;

   271

    }

   272

   273

    // fetch state from each slave

   274

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

   275

    ec_command_nprd(&fsm->command, fsm->slave->station_address, 0x0130, 2);

   276

    ec_master_queue_command(master, &fsm->command);

   277

    fsm->master_state = ec_fsm_master_states;

   278

}

   279

   280

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

   281

   282

/**

   283

   Master action: Get state of next slave.

   284

*/

   285

   286

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   287

                                           /**< finite state machine */)

   288

{

   289

    ec_master_t *master = fsm->master;

   290

    ec_slave_t *slave = fsm->slave;

   291

   292

    // have all states been read?

   293

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

   294

   295

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

   296

        if (fsm->master_validation) {

   297

            fsm->master_validation = 0;

   298

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

   299

                if (slave->online) continue;

   300

   301

                // At least one slave is offline. validate!

   302

                EC_INFO("Validating bus.\n");

   303

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

   304

                fsm->master_state = ec_fsm_master_validate_vendor;

   305

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

   306

                fsm->sii_mode = 0;

   307

                fsm->sii_state = ec_fsm_sii_start_reading;

   308

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

   309

                return;

   310

            }

   311

        }

   312

   313

        fsm->master_state = ec_fsm_master_proc_states;

   314

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

   315

        return;

   316

    }

   317

   318

    // process next slave

   319

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

   320

    ec_command_nprd(&fsm->command, fsm->slave->station_address, 0x0130, 2);

   321

    ec_master_queue_command(master, &fsm->command);

   322

    fsm->master_state = ec_fsm_master_states;

   323

}

   324

   325

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

   326

   327

/**

   328

   Master state: STATES.

   329

   Fetches the AL- and online state of a slave.

   330

*/

   331

   332

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

   333

{

   334

    ec_slave_t *slave = fsm->slave;

   335

    ec_command_t *command = &fsm->command;

   336

    uint8_t new_state;

   337

   338

    if (command->state != EC_CMD_RECEIVED) {

   339

        fsm->master_state = ec_fsm_master_start;

   340

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

   341

        return;

   342

    }

   343

   344

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

   345

    if (command->working_counter != 1) {

   346

        if (slave->online) {

   347

            slave->online = 0;

   348

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

   349

        }

   350

        ec_fsm_master_action_next_slave_state(fsm);

   351

        return;

   352

    }

   353

   354

    // slave responded

   355

    new_state = EC_READ_U8(command->data);

   356

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

   357

        slave->online = 1;

   358

        slave->state_error = 0;

   359

        slave->current_state = new_state;

   360

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

   361

        ec_print_states(new_state);

   362

        printk(").\n");

   363

    }

   364

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

   365

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

   366

        ec_print_states(slave->current_state);

   367

        printk(" -> ");

   368

        ec_print_states(new_state);

   369

        printk(".\n");

   370

        slave->current_state = new_state;

   371

    }

   372

   373

    ec_fsm_master_action_next_slave_state(fsm);

   374

}

   375

   376

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

   377

   378

/**

   379

   Master state: PROC_STATES.

   380

   Processes the slave states.

   381

*/

   382

   383

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

   384

{

   385

    ec_master_t *master = fsm->master;

   386

    ec_slave_t *slave;

   387

   388

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

   389

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

   390

        if (slave->state_error || !slave->online ||

   391

            slave->requested_state == EC_SLAVE_STATE_UNKNOWN ||

   392

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

   393

   394

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

   395

        ec_print_states(slave->current_state);

   396

        printk(" to ");

   397

        ec_print_states(slave->requested_state);

   398

        printk(".\n");

   399

   400

        fsm->slave = slave;

   401

        fsm->slave_state = ec_fsm_slave_conf;

   402

        fsm->change_new = EC_SLAVE_STATE_INIT;

   403

        fsm->change_state = ec_fsm_change_start;

   404

        fsm->master_state = ec_fsm_master_conf;

   405

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

   406

        return;

   407

    }

   408

   409

    if (master->mode == EC_MASTER_MODE_FREERUN) {

   410

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

   411

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

   412

            if (!slave->new_eeprom_data) continue;

   413

   414

            // found pending EEPROM write operation. execute it!

   415

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

   416

            fsm->sii_offset = 0x0000;

   417

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

   418

            fsm->sii_mode = 1;

   419

            fsm->sii_state = ec_fsm_sii_start_writing;

   420

            fsm->slave = slave;

   421

            fsm->master_state = ec_fsm_master_eeprom;

   422

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

   423

            return;

   424

        }

   425

    }

   426

   427

    // nothing to do. restart master state machine.

   428

    fsm->master_state = ec_fsm_master_start;

   429

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

   430

}

   431

   432

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

   433

   434

/**

   435

   Master state: VALIDATE_VENDOR.

   436

   Validates the vendor ID of a slave.

   437

*/

   438

   439

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

   440

{

   441

    ec_slave_t *slave = fsm->slave;

   442

   443

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

   444

   445

    if (fsm->sii_state == ec_fsm_sii_error) {

   446

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

   447

               slave->ring_position);

   448

        fsm->master_state = ec_fsm_master_start;

   449

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

   450

        return;

   451

    }

   452

   453

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

   454

   455

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

   456

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

   457

        fsm->master_state = ec_fsm_master_start;

   458

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

   459

        return;

   460

    }

   461

   462

    // vendor ID is ok. check product code.

   463

    fsm->master_state = ec_fsm_master_validate_product;

   464

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

   465

    fsm->sii_mode = 0;

   466

    fsm->sii_state = ec_fsm_sii_start_reading;

   467

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

   468

}

   469

   470

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

   471

   472

/**

   473

   Master state: VALIDATE_PRODUCT.

   474

   Validates the product ID of a slave.

   475

*/

   476

   477

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

   478

{

   479

    ec_slave_t *slave = fsm->slave;

   480

   481

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

   482

   483

    if (fsm->sii_state == ec_fsm_sii_error) {

   484

        EC_ERR("Failed to validate product code of slave %i.\n",

   485

               slave->ring_position);

   486

        fsm->master_state = ec_fsm_master_start;

   487

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

   488

        return;

   489

    }

   490

   491

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

   492

   493

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

   494

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

   495

        EC_ERR("expected 0x%08X, got 0x%08X.\n", slave->sii_product_code,

   496

               EC_READ_U32(fsm->sii_value));

   497

        fsm->master_state = ec_fsm_master_start;

   498

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

   499

        return;

   500

    }

   501

   502

    // have all states been validated?

   503

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

   504

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

   505

        fsm->master_state = ec_fsm_master_reconfigure;

   506

        return;

   507

    }

   508

   509

    // validate next slave

   510

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

   511

    fsm->master_state = ec_fsm_master_validate_vendor;

   512

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

   513

    fsm->sii_mode = 0;

   514

    fsm->sii_state = ec_fsm_sii_start_reading;

   515

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

   516

}

   517

   518

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

   519

   520

/**

   521

   Master state: RECONFIGURE.

   522

   Looks for slave, that have lost their configuration and writes

   523

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

   524

*/

   525

   526

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