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

const ec_code_msg_t al_status_messages[];

    48

    49

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

    50

    51

void ec_fsm_master_start(ec_fsm_t *);

    52

void ec_fsm_master_broadcast(ec_fsm_t *);

    53

void ec_fsm_master_proc_states(ec_fsm_t *);

    54

void ec_fsm_master_scan(ec_fsm_t *);

    55

void ec_fsm_master_states(ec_fsm_t *);

    56

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    57

void ec_fsm_master_validate_product(ec_fsm_t *);

    58

void ec_fsm_master_reconfigure(ec_fsm_t *);

    59

void ec_fsm_master_address(ec_fsm_t *);

    60

void ec_fsm_master_conf(ec_fsm_t *);

    61

void ec_fsm_master_eeprom(ec_fsm_t *);

    62

    63

void ec_fsm_slave_start_reading(ec_fsm_t *);

    64

void ec_fsm_slave_read_status(ec_fsm_t *);

    65

void ec_fsm_slave_read_base(ec_fsm_t *);

    66

void ec_fsm_slave_read_dl(ec_fsm_t *);

    67

void ec_fsm_slave_eeprom_size(ec_fsm_t *);

    68

void ec_fsm_slave_fetch_eeprom(ec_fsm_t *);

    69

void ec_fsm_slave_fetch_eeprom2(ec_fsm_t *);

    70

void ec_fsm_slave_end(ec_fsm_t *);

    71

    72

void ec_fsm_slave_conf(ec_fsm_t *);

    73

void ec_fsm_slave_sync(ec_fsm_t *);

    74

void ec_fsm_slave_preop(ec_fsm_t *);

    75

void ec_fsm_slave_fmmu(ec_fsm_t *);

    76

void ec_fsm_slave_saveop(ec_fsm_t *);

    77

void ec_fsm_slave_op(ec_fsm_t *);

    78

void ec_fsm_slave_op2(ec_fsm_t *);

    79

    80

void ec_fsm_sii_start_reading(ec_fsm_t *);

    81

void ec_fsm_sii_read_check(ec_fsm_t *);

    82

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    83

void ec_fsm_sii_start_writing(ec_fsm_t *);

    84

void ec_fsm_sii_write_check(ec_fsm_t *);

    85

void ec_fsm_sii_write_check2(ec_fsm_t *);

    86

void ec_fsm_sii_end(ec_fsm_t *);

    87

void ec_fsm_sii_error(ec_fsm_t *);

    88

    89

void ec_fsm_change_start(ec_fsm_t *);

    90

void ec_fsm_change_check(ec_fsm_t *);

    91

void ec_fsm_change_status(ec_fsm_t *);

    92

void ec_fsm_change_code(ec_fsm_t *);

    93

void ec_fsm_change_ack(ec_fsm_t *);

    94

void ec_fsm_change_ack2(ec_fsm_t *);

    95

void ec_fsm_change_end(ec_fsm_t *);

    96

void ec_fsm_change_error(ec_fsm_t *);

    97

    98

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

    99

   100

/**

   101

   Constructor.

   102

*/

   103

   104

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

   105

                ec_master_t *master /**< EtherCAT master */

   106

                )

   107

{

   108

    fsm->master = master;

   109

    fsm->master_state = ec_fsm_master_start;

   110

    fsm->master_slaves_responding = 0;

   111

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   112

    fsm->master_validation = 0;

   113

   114

    ec_command_init(&fsm->command);

   115

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

   116

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

   117

        return -1;

   118

    }

   119

   120

    return 0;

   121

}

   122

   123

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

   124

   125

/**

   126

   Destructor.

   127

*/

   128

   129

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

   130

{

   131

    ec_command_clear(&fsm->command);

   132

}

   133

   134

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

   135

   136

/**

   137

   Resets the state machine.

   138

*/

   139

   140

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

   141

{

   142

    fsm->master_state = ec_fsm_master_start;

   143

    fsm->master_slaves_responding = 0;

   144

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   145

}

   146

   147

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

   148

   149

/**

   150

   Executes the current state of the state machine.

   151

*/

   152

   153

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

   154

{

   155

    fsm->master_state(fsm);

   156

}

   157

   158

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

   159

 *  master state machine

   160

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

   161

   162

/**

   163

   Master state: START.

   164

   Starts with getting slave count and slave states.

   165

*/

   166

   167

void ec_fsm_master_start(ec_fsm_t *fsm)

   168

{

   169

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

   170

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

   171

    fsm->master_state = ec_fsm_master_broadcast;

   172

}

   173

   174

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

   175

   176

/**

   177

   Master state: BROADCAST.

   178

   Processes the broadcast read slave count and slaves states.

   179

*/

   180

   181

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

   182

{

   183

    ec_command_t *command = &fsm->command;

   184

    unsigned int topology_change, states_change, i;

   185

    ec_slave_t *slave;

   186

    ec_master_t *master = fsm->master;

   187

   188

    if (command->state != EC_CMD_RECEIVED) {

   189

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

   190

            fsm->master_slaves_responding = 0;

   191

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

   192

                slave->online = 0;

   193

            }

   194

        }

   195

        fsm->master_state = ec_fsm_master_start;

   196

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

   197

        return;

   198

    }

   199

   200

    topology_change = (command->working_counter !=

   201

                       fsm->master_slaves_responding);

   202

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

   203

   204

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

   205

    fsm->master_slaves_responding = command->working_counter;

   206

   207

    if (topology_change) {

   208

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

   209

                fsm->master_slaves_responding,

   210

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

   211

   212

        if (master->mode == EC_MASTER_MODE_RUNNING) {

   213

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

   214

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

   215

            }

   216

            else {

   217

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

   218

            }

   219

        }

   220

    }

   221

   222

    if (states_change) {

   223

        EC_INFO("Slave states: ");

   224

        ec_print_states(fsm->master_slave_states);

   225

        printk(".\n");

   226

    }

   227

   228

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

   229

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

   230

        EC_INFO("Scanning bus.\n");

   231

   232

        ec_master_eoe_stop(master);

   233

        ec_master_clear_slaves(master);

   234

   235

        if (!fsm->master_slaves_responding) {

   236

            // no slaves present -> finish state machine.

   237

            fsm->master_state = ec_fsm_master_start;

   238

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

   239

            return;

   240

        }

   241

   242

        // init slaves

   243

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

   244

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

   245

                                                 GFP_ATOMIC))) {

   246

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

   247

                fsm->master_state = ec_fsm_master_start;

   248

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

   249

                return;

   250

            }

   251

   252

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

   253

                fsm->master_state = ec_fsm_master_start;

   254

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

   255

                return;

   256

            }

   257

   258

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

   259

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

   260

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

   261

                fsm->master_state = ec_fsm_master_start;

   262

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

   263

                return;

   264

            }

   265

   266

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

   267

        }

   268

   269

        // begin scanning of slaves

   270

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

   271

        fsm->slave_state = ec_fsm_slave_start_reading;

   272

        fsm->master_state = ec_fsm_master_scan;

   273

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

   274

        return;

   275

    }

   276

   277

    // fetch state from each slave

   278

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

   279

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

   280

    ec_master_queue_command(master, &fsm->command);

   281

    fsm->master_state = ec_fsm_master_states;

   282

}

   283

   284

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

   285

   286

/**

   287

   Master action: Get state of next slave.

   288

*/

   289

   290

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   291

                                           /**< finite state machine */)

   292

{

   293

    ec_master_t *master = fsm->master;

   294

    ec_slave_t *slave = fsm->slave;

   295

   296

    // have all states been read?

   297

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

   298

   299

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

   300

        if (fsm->master_validation) {

   301

            fsm->master_validation = 0;

   302

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

   303

                if (slave->online) continue;

   304

   305

                // At least one slave is offline. validate!

   306

                EC_INFO("Validating bus.\n");

   307

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

   308

                fsm->master_state = ec_fsm_master_validate_vendor;

   309

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

   310

                fsm->sii_mode = 0;

   311

                fsm->sii_state = ec_fsm_sii_start_reading;

   312

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

   313

                return;

   314

            }

   315

        }

   316

   317

        fsm->master_state = ec_fsm_master_proc_states;

   318

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

   319

        return;

   320

    }

   321

   322

    // process next slave

   323

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

   324

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

   325

    ec_master_queue_command(master, &fsm->command);

   326

    fsm->master_state = ec_fsm_master_states;

   327

}

   328

   329

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

   330

   331

/**

   332

   Master state: STATES.

   333

   Fetches the AL- and online state of a slave.

   334

*/

   335

   336

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

   337

{

   338

    ec_slave_t *slave = fsm->slave;

   339

    ec_command_t *command = &fsm->command;

   340

    uint8_t new_state;

   341

   342

    if (command->state != EC_CMD_RECEIVED) {

   343

        fsm->master_state = ec_fsm_master_start;

   344

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

   345

        return;

   346

    }

   347

   348

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

   349

    if (command->working_counter != 1) {

   350

        if (slave->online) {

   351

            slave->online = 0;

   352

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

   353

        }

   354

        ec_fsm_master_action_next_slave_state(fsm);

   355

        return;

   356

    }

   357

   358

    // slave responded

   359

    new_state = EC_READ_U8(command->data);

   360

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

   361

        slave->online = 1;

   362

        slave->state_error = 0;

   363

        slave->current_state = new_state;

   364

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

   365

        ec_print_states(new_state);

   366

        printk(").\n");

   367

    }

   368

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

   369

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

   370

        ec_print_states(slave->current_state);

   371

        printk(" -> ");

   372

        ec_print_states(new_state);

   373

        printk(".\n");

   374

        slave->current_state = new_state;

   375

    }

   376

   377

    ec_fsm_master_action_next_slave_state(fsm);

   378

}

   379

   380

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

   381

   382

/**

   383

   Master state: PROC_STATES.

   384

   Processes the slave states.

   385

*/

   386

   387

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

   388

{

   389

    ec_master_t *master = fsm->master;

   390

    ec_slave_t *slave;

   391

   392

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

   393

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

   394

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

   395

            slave->requested_state == EC_SLAVE_STATE_UNKNOWN ||

   396

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

   397

   398

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

   399

        ec_print_states(slave->current_state);

   400

        printk(" to ");

   401

        ec_print_states(slave->requested_state);

   402

        printk(".\n");

   403

   404

        fsm->slave = slave;

   405

        fsm->slave_state = ec_fsm_slave_conf;

   406

        fsm->change_new = EC_SLAVE_STATE_INIT;

   407

        fsm->change_state = ec_fsm_change_start;

   408

        fsm->master_state = ec_fsm_master_conf;

   409

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

   410

        return;

   411

    }

   412

   413

    if (master->mode == EC_MASTER_MODE_FREERUN) {

   414

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

   415

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

   416

            if (!slave->new_eeprom_data) continue;

   417

   418

            // found pending EEPROM write operation. execute it!

   419

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

   420

            fsm->sii_offset = 0x0000;

   421

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

   422

            fsm->sii_mode = 1;

   423

            fsm->sii_state = ec_fsm_sii_start_writing;

   424

            fsm->slave = slave;

   425

            fsm->master_state = ec_fsm_master_eeprom;

   426

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

   427

            return;

   428

        }

   429

    }

   430

   431

    // nothing to do. restart master state machine.

   432

    fsm->master_state = ec_fsm_master_start;

   433

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

   434

}

   435

   436

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

   437

   438

/**

   439

   Master state: VALIDATE_VENDOR.

   440

   Validates the vendor ID of a slave.

   441

*/

   442

   443

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

   444

{

   445

    ec_slave_t *slave = fsm->slave;

   446

   447

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

   448

   449

    if (fsm->sii_state == ec_fsm_sii_error) {

   450

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

   451

               slave->ring_position);

   452

        fsm->master_state = ec_fsm_master_start;

   453

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

   454

        return;

   455

    }

   456

   457

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

   458

   459

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

   460

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

   461

        fsm->master_state = ec_fsm_master_start;

   462

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

   463

        return;

   464

    }

   465

   466

    // vendor ID is ok. check product code.

   467

    fsm->master_state = ec_fsm_master_validate_product;

   468

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

   469

    fsm->sii_mode = 0;

   470

    fsm->sii_state = ec_fsm_sii_start_reading;

   471

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

   472

}

   473

   474

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

   475

   476

/**

   477

   Master state: VALIDATE_PRODUCT.

   478

   Validates the product ID of a slave.

   479

*/

   480

   481

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

   482

{

   483

    ec_slave_t *slave = fsm->slave;

   484

   485

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

   486

   487

    if (fsm->sii_state == ec_fsm_sii_error) {

   488

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

   489

               slave->ring_position);

   490

        fsm->master_state = ec_fsm_master_start;

   491

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

   492

        return;

   493

    }

   494

   495

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

   496

   497

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

   498

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

   499

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

   500