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

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

   221

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

   222

                    fsm->master_slaves_responding,

   223

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

   224

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

   225

        }

   226

        else {

   227

            EC_WARN("%i slave%s responding. Invalid slave count!\n",

   228

                    fsm->master_slaves_responding,

   229

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

   230

        }

   231

    }

   232

   233

    if (states_change) {

   234

        EC_INFO("Slave states: ");

   235

        ec_print_states(fsm->master_slave_states);

   236

        printk(".\n");

   237

    }

   238

   239

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

   240

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

   241

        EC_INFO("Scanning bus.\n");

   242

   243

        ec_master_eoe_stop(master);

   244

        ec_master_clear_slaves(master);

   245

   246

        if (!fsm->master_slaves_responding) {

   247

            // no slaves present -> finish state machine.

   248

            fsm->master_state = ec_fsm_master_start;

   249

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

   250

            return;

   251

        }

   252

   253

        // init slaves

   254

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

   255

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

   256

                                                 GFP_ATOMIC))) {

   257

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

   258

                fsm->master_state = ec_fsm_master_start;

   259

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

   260

                return;

   261

            }

   262

   263

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

   264

                fsm->master_state = ec_fsm_master_start;

   265

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

   266

                return;

   267

            }

   268

   269

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

   270

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

   271

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

   272

                fsm->master_state = ec_fsm_master_start;

   273

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

   274

                return;

   275

            }

   276

   277

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

   278

        }

   279

   280

        // begin scanning of slaves

   281

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

   282

        fsm->slave_state = ec_fsm_slave_start_reading;

   283

        fsm->master_state = ec_fsm_master_scan;

   284

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

   285

        return;

   286

    }

   287

   288

    // fetch state from each slave

   289

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

   290

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

   291

    ec_master_queue_command(master, &fsm->command);

   292

    fsm->master_state = ec_fsm_master_states;

   293

}

   294

   295

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

   296

   297

/**

   298

   Master action: Get state of next slave.

   299

*/

   300

   301

void ec_fsm_master_action_next_slave_state(ec_fsm_t *fsm

   302

                                           /**< finite state machine */)

   303

{

   304

    ec_master_t *master = fsm->master;

   305

    ec_slave_t *slave = fsm->slave;

   306

   307

    // have all states been read?

   308

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

   309

   310

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

   311

        if (fsm->master_validation) {

   312

            fsm->master_validation = 0;

   313

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

   314

                if (slave->online) continue;

   315

   316

                // At least one slave is offline. validate!

   317

                EC_INFO("Validating bus.\n");

   318

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

   319

                fsm->master_state = ec_fsm_master_validate_vendor;

   320

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

   321

                fsm->sii_mode = 0;

   322

                fsm->sii_state = ec_fsm_sii_start_reading;

   323

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

   324

                return;

   325

            }

   326

        }

   327

   328

        fsm->master_state = ec_fsm_master_proc_states;

   329

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

   330

        return;

   331

    }

   332

   333

    // process next slave

   334

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

   335

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

   336

    ec_master_queue_command(master, &fsm->command);

   337

    fsm->master_state = ec_fsm_master_states;

   338

}

   339

   340

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

   341

   342

/**

   343

   Master state: STATES.

   344

   Fetches the AL- and online state of a slave.

   345

*/

   346

   347

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

   348

{

   349

    ec_slave_t *slave = fsm->slave;

   350

    ec_command_t *command = &fsm->command;

   351

    uint8_t new_state;

   352

   353

    if (command->state != EC_CMD_RECEIVED) {

   354

        fsm->master_state = ec_fsm_master_start;

   355

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

   356

        return;

   357

    }

   358

   359

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

   360

    if (command->working_counter != 1) {

   361

        if (slave->online) {

   362

            slave->online = 0;

   363

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

   364

        }

   365

        ec_fsm_master_action_next_slave_state(fsm);

   366

        return;

   367

    }

   368

   369

    // slave responded

   370

    new_state = EC_READ_U8(command->data);

   371

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

   372

        slave->online = 1;

   373

        slave->state_error = 0;

   374

        slave->current_state = new_state;

   375

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

   376

        ec_print_states(new_state);

   377

        printk(").\n");

   378

    }

   379

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

   380

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

   381

        ec_print_states(slave->current_state);

   382

        printk(" -> ");

   383

        ec_print_states(new_state);

   384

        printk(".\n");

   385

        slave->current_state = new_state;

   386

    }

   387

   388

    ec_fsm_master_action_next_slave_state(fsm);

   389

}

   390

   391

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

   392

   393

/**

   394

   Master state: PROC_STATES.

   395

   Processes the slave states.

   396

*/

   397

   398

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

   399

{

   400

    ec_master_t *master = fsm->master;

   401

    ec_slave_t *slave;

   402

   403

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

   404

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

   405

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

   406

            slave->requested_state == EC_SLAVE_STATE_UNKNOWN ||

   407

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

   408

   409

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

   410

        ec_print_states(slave->current_state);

   411

        printk(" to ");

   412

        ec_print_states(slave->requested_state);

   413

        printk(".\n");

   414

   415

        fsm->slave = slave;

   416

        fsm->slave_state = ec_fsm_slave_conf;

   417

        fsm->change_new = EC_SLAVE_STATE_INIT;

   418

        fsm->change_state = ec_fsm_change_start;

   419

        fsm->master_state = ec_fsm_master_conf;

   420

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

   421

        return;

   422

    }

   423

   424

    // nothing to configure. restart master state machine.

   425

    fsm->master_state = ec_fsm_master_start;

   426

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

   427

}

   428

   429

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

   430

   431

/**

   432

   Master state: VALIDATE_VENDOR.

   433

   Validates the vendor ID of a slave.

   434

*/

   435

   436

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

   437

{

   438

    ec_slave_t *slave = fsm->slave;

   439

   440

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

   441

   442

    if (fsm->sii_state == ec_fsm_sii_error) {

   443

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

   444

               slave->ring_position);

   445

        fsm->master_state = ec_fsm_master_start;

   446

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

   447

        return;

   448

    }

   449

   450

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

   451

   452

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

   453

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

   454

        fsm->master_state = ec_fsm_master_start;

   455

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

   456

        return;

   457

    }

   458

   459

    // vendor ID is ok. check product code.

   460

    fsm->master_state = ec_fsm_master_validate_product;

   461

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

   462

    fsm->sii_mode = 0;

   463

    fsm->sii_state = ec_fsm_sii_start_reading;

   464

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

   465

}

   466

   467

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

   468

   469

/**

   470

   Master state: VALIDATE_PRODUCT.

   471

   Validates the product ID of a slave.

   472

*/

   473

   474

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

   475

{

   476

    ec_slave_t *slave = fsm->slave;

   477

   478

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

   479

   480

    if (fsm->sii_state == ec_fsm_sii_error) {

   481

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

   482

               slave->ring_position);

   483

        fsm->master_state = ec_fsm_master_start;

   484

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

   485

        return;

   486

    }

   487

   488

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

   489

   490

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

   491

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

   492

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

   493

               fsm->sii_result);

   494

        fsm->master_state = ec_fsm_master_start;

   495

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

   496

        return;

   497

    }

   498

   499

    // have all states been validated?

   500

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

   501

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