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

/**

    48

   Size of memory to allocate while reading categories.

    49

*/

    50

    51

#define EC_CAT_MEM 0x100

    52

    53

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

    54

    55

const ec_code_msg_t al_status_messages[];

    56

    57

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

    58

    59

void ec_fsm_master_start(ec_fsm_t *);

    60

void ec_fsm_master_broadcast(ec_fsm_t *);

    61

void ec_fsm_master_proc_states(ec_fsm_t *);

    62

void ec_fsm_master_scan(ec_fsm_t *);

    63

void ec_fsm_master_states(ec_fsm_t *);

    64

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    65

void ec_fsm_master_validate_product(ec_fsm_t *);

    66

void ec_fsm_master_reconfigure(ec_fsm_t *);

    67

void ec_fsm_master_address(ec_fsm_t *);

    68

void ec_fsm_master_conf(ec_fsm_t *);

    69

    70

void ec_fsm_slave_start_reading(ec_fsm_t *);

    71

void ec_fsm_slave_read_status(ec_fsm_t *);

    72

void ec_fsm_slave_read_base(ec_fsm_t *);

    73

void ec_fsm_slave_read_dl(ec_fsm_t *);

    74

void ec_fsm_slave_prepare_sii(ec_fsm_t *);

    75

void ec_fsm_slave_read_sii(ec_fsm_t *);

    76

void ec_fsm_slave_category_header(ec_fsm_t *);

    77

void ec_fsm_slave_category_data(ec_fsm_t *);

    78

void ec_fsm_slave_end(ec_fsm_t *);

    79

    80

void ec_fsm_slave_conf(ec_fsm_t *);

    81

void ec_fsm_slave_sync(ec_fsm_t *);

    82

void ec_fsm_slave_preop(ec_fsm_t *);

    83

void ec_fsm_slave_fmmu(ec_fsm_t *);

    84

void ec_fsm_slave_saveop(ec_fsm_t *);

    85

void ec_fsm_slave_op(ec_fsm_t *);

    86

void ec_fsm_slave_op2(ec_fsm_t *);

    87

    88

void ec_fsm_sii_start_reading(ec_fsm_t *);

    89

void ec_fsm_sii_check(ec_fsm_t *);

    90

void ec_fsm_sii_fetch(ec_fsm_t *);

    91

void ec_fsm_sii_end(ec_fsm_t *);

    92

void ec_fsm_sii_error(ec_fsm_t *);

    93

    94

void ec_fsm_change_start(ec_fsm_t *);

    95

void ec_fsm_change_check(ec_fsm_t *);

    96

void ec_fsm_change_status(ec_fsm_t *);

    97

void ec_fsm_change_code(ec_fsm_t *);

    98

void ec_fsm_change_ack(ec_fsm_t *);

    99

void ec_fsm_change_ack2(ec_fsm_t *);

   100

void ec_fsm_change_end(ec_fsm_t *);

   101

void ec_fsm_change_error(ec_fsm_t *);

   102

   103

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

   104

   105

/**

   106

   Constructor.

   107

*/

   108

   109

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

   110

                ec_master_t *master /**< EtherCAT master */

   111

                )

   112

{

   113

    fsm->master = master;

   114

    fsm->master_state = ec_fsm_master_start;

   115

    fsm->master_slaves_responding = 0;

   116

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   117

    fsm->master_validation = 0;

   118

    fsm->slave_cat_data = NULL;

   119

   120

    ec_command_init(&fsm->command);

   121

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

   122

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

   123

        return -1;

   124

    }

   125

   126

    return 0;

   127

}

   128

   129

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

   130

   131

/**

   132

   Destructor.

   133

*/

   134

   135

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

   136

{

   137

    if (fsm->slave_cat_data) kfree(fsm->slave_cat_data);

   138

    ec_command_clear(&fsm->command);

   139

}

   140

   141

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

   142

   143

/**

   144

   Resets the state machine.

   145

*/

   146

   147

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

   148

{

   149

    fsm->master_state = ec_fsm_master_start;

   150

    fsm->master_slaves_responding = 0;

   151

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   152

   153

    if (fsm->slave_cat_data) {

   154

        kfree(fsm->slave_cat_data);

   155

        fsm->slave_cat_data = NULL;

   156

    }

   157

}

   158

   159

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

   160

   161

/**

   162

   Executes the current state of the state machine.

   163

*/

   164

   165

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

   166

{

   167

    fsm->master_state(fsm);

   168

}

   169

   170

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

   171

 *  master state machine

   172

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

   173

   174

/**

   175

   Master state: START.

   176

   Starts with getting slave count and slave states.

   177

*/

   178

   179

void ec_fsm_master_start(ec_fsm_t *fsm)

   180

{

   181

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

   182

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

   183

    fsm->master_state = ec_fsm_master_broadcast;

   184

}

   185

   186

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

   187

   188

/**

   189

   Master state: BROADCAST.

   190

   Processes the broadcast read slave count and slaves states.

   191

*/

   192

   193

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

   194

{

   195

    ec_command_t *command = &fsm->command;

   196

    unsigned int topology_change, states_change, i;

   197

    ec_slave_t *slave;

   198

    ec_master_t *master = fsm->master;

   199

   200

    if (command->state != EC_CMD_RECEIVED) {

   201

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

   202

            fsm->master_slaves_responding = 0;

   203

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

   204

                slave->online = 0;

   205

            }

   206

        }

   207

        fsm->master_state = ec_fsm_master_start;

   208

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

   209

        return;

   210

    }

   211

   212

    topology_change = (command->working_counter !=

   213

                       fsm->master_slaves_responding);

   214

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

   215

   216

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

   217

    fsm->master_slaves_responding = command->working_counter;

   218

   219

    if (topology_change) {

   220

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

   221

                fsm->master_slaves_responding,

   222

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

   223

   224

        if (master->mode == EC_MASTER_MODE_RUNNING) {

   225

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

   226

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

   227

            }

   228

            else {

   229

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

   230

            }

   231

        }

   232

    }

   233

   234

    if (states_change) {

   235

        EC_INFO("Slave states: ");

   236

        ec_print_states(fsm->master_slave_states);

   237

        printk(".\n");

   238

    }

   239

   240

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

   241

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

   242

        EC_INFO("Scanning bus.\n");

   243

   244

        ec_master_eoe_stop(master);

   245

        ec_master_clear_slaves(master);

   246

   247

        if (!fsm->master_slaves_responding) {

   248

            // no slaves present -> finish state machine.

   249

            fsm->master_state = ec_fsm_master_start;

   250

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

   251

            return;

   252

        }

   253

   254

        // init slaves

   255

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

   256

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

   257

                                                 GFP_ATOMIC))) {

   258

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

   259

                fsm->master_state = ec_fsm_master_start;

   260

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

   261

                return;

   262

            }

   263

   264

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

   265

                fsm->master_state = ec_fsm_master_start;

   266

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

   267

                return;

   268

            }

   269

   270

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

   271

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

   272

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

   273

                fsm->master_state = ec_fsm_master_start;

   274

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

   275

                return;

   276

            }

   277

   278

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

   279

        }

   280

   281

        // begin scanning of slaves

   282

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

   283

        fsm->slave_state = ec_fsm_slave_start_reading;

   284

        fsm->master_state = ec_fsm_master_scan;

   285

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

   286

        return;

   287

    }

   288

   289

    // fetch state from each slave

   290

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

   291

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

   292

    ec_master_queue_command(master, &fsm->command);

   293

    fsm->master_state = ec_fsm_master_states;

   294

}

   295

   296

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

   297

   298

/**

   299

   Master action: Get state of next slave.

   300

*/

   301

   302

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   303

                                           /**< finite state machine */)

   304

{

   305

    ec_master_t *master = fsm->master;

   306

    ec_slave_t *slave = fsm->slave;

   307

   308

    // have all states been read?

   309

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

   310

   311

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

   312

        if (fsm->master_validation) {

   313

            fsm->master_validation = 0;

   314

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

   315

                if (slave->online) continue;

   316

   317

                // At least one slave is offline. validate!

   318

                EC_INFO("Validating bus.\n");

   319

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

   320

                fsm->master_state = ec_fsm_master_validate_vendor;

   321

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

   322

                fsm->sii_mode = 0;

   323

                fsm->sii_state = ec_fsm_sii_start_reading;

   324

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

   325

                return;

   326

            }

   327

        }

   328

   329

        fsm->master_state = ec_fsm_master_proc_states;

   330

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

   331

        return;

   332

    }

   333

   334

    // process next slave

   335

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

   336

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

   337

    ec_master_queue_command(master, &fsm->command);

   338

    fsm->master_state = ec_fsm_master_states;

   339

}

   340

   341

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

   342

   343

/**

   344

   Master state: STATES.

   345

   Fetches the AL- and online state of a slave.

   346

*/

   347

   348

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

   349

{

   350

    ec_slave_t *slave = fsm->slave;

   351

    ec_command_t *command = &fsm->command;

   352

    uint8_t new_state;

   353

   354

    if (command->state != EC_CMD_RECEIVED) {

   355

        fsm->master_state = ec_fsm_master_start;

   356

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

   357

        return;

   358

    }

   359

   360

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

   361

    if (command->working_counter != 1) {

   362

        if (slave->online) {

   363

            slave->online = 0;

   364

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

   365

        }

   366

        ec_fsm_master_action_next_slave_state(fsm);

   367

        return;

   368

    }

   369

   370

    // slave responded

   371

    new_state = EC_READ_U8(command->data);

   372

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

   373

        slave->online = 1;

   374

        slave->state_error = 0;

   375

        slave->current_state = new_state;

   376

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

   377

        ec_print_states(new_state);

   378

        printk(").\n");

   379

    }

   380

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

   381

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

   382

        ec_print_states(slave->current_state);

   383

        printk(" -> ");

   384

        ec_print_states(new_state);

   385

        printk(".\n");

   386

        slave->current_state = new_state;

   387

    }

   388

   389

    ec_fsm_master_action_next_slave_state(fsm);

   390

}

   391

   392

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

   393

   394

/**

   395

   Master state: PROC_STATES.

   396

   Processes the slave states.

   397

*/

   398

   399

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

   400

{

   401

    ec_master_t *master = fsm->master;

   402

    ec_slave_t *slave;

   403

   404

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

   405

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

   406

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

   407

            slave->requested_state == EC_SLAVE_STATE_UNKNOWN ||

   408

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

   409

   410

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

   411

        ec_print_states(slave->current_state);

   412

        printk(" to ");

   413

        ec_print_states(slave->requested_state);

   414

        printk(".\n");

   415

   416

        fsm->slave = slave;

   417

        fsm->slave_state = ec_fsm_slave_conf;

   418

        fsm->change_new = EC_SLAVE_STATE_INIT;

   419

        fsm->change_state = ec_fsm_change_start;

   420

        fsm->master_state = ec_fsm_master_conf;

   421

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

   422

        return;

   423

    }

   424

   425

    // nothing to configure. restart master state machine.

   426

    fsm->master_state = ec_fsm_master_start;

   427

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

   428

}

   429

   430

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

   431

   432

/**

   433

   Master state: VALIDATE_VENDOR.

   434

   Validates the vendor ID of a slave.

   435

*/

   436

   437

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

   438

{

   439

    ec_slave_t *slave = fsm->slave;

   440

   441

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

   442

   443

    if (fsm->sii_state == ec_fsm_sii_error) {

   444

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

   445

               slave->ring_position);

   446

        fsm->master_state = ec_fsm_master_start;

   447

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

   448

        return;

   449

    }

   450

   451

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

   452

   453

    if (fsm->sii_result != slave->sii_vendor_id) {

   454

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

   455

        fsm->master_state = ec_fsm_master_start;

   456

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

   457

        return;

   458

    }

   459

   460

    // vendor ID is ok. check product code.

   461

    fsm->master_state = ec_fsm_master_validate_product;

   462

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

   463

    fsm->sii_mode = 0;

   464

    fsm->sii_state = ec_fsm_sii_start_reading;

   465

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

   466

}

   467

   468

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

   469

   470

/**

   471

   Master state: VALIDATE_PRODUCT.

   472

   Validates the product ID of a slave.

   473

*/

   474

   475

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

   476

{

   477

    ec_slave_t *slave = fsm->slave;

   478

   479

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

   480

   481

    if (fsm->sii_state == ec_fsm_sii_error) {

   482

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

   483

               slave->ring_position);

   484

        fsm->master_state = ec_fsm_master_start;

   485

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

   486

        return;

   487

    }

   488

   489

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

   490

   491

    if (fsm->sii_result != slave->sii_product_code) {

   492

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

   493

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

   494

               fsm->sii_result);

   495

        fsm->master_state = ec_fsm_master_start;

   496

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

   497

        return;

   498

    }

   499

   500

    // have all states been validated?

   501

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

   502

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

   503

        fsm->master_state = ec_fsm_master_reconfigure;

   504

        return;

   505

    }

   506

   507

    // validate next slave

   508

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

   509

    fsm->master_state = ec_fsm_master_validate_vendor;

   510

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

   511

    fsm->sii_mode = 0;

   512

    fsm->sii_state = ec_fsm_sii_start_reading;

   513

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

   514

}

   515

   516

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

   517

   518

/**

   519

   Master state: RECONFIGURE.

   520

   Looks for slave, that have lost their configuration and writes

   521

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

   522

*/

   523

   524

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

   525

{

   526

    ec_command_t *command = &fsm->command;

   527

   528

    while (fsm->slave->online) {

   529

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

   530