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

    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 */

   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)) {

   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?

   317

        }

   322

}

   323

   324

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

   325

   326

/**

   327

   Master state: STATES.

   328

   Fetches the AL- and online state of a slave.

   329

*/

   330

   331

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

   332

{

   333

    ec_slave_t *slave = fsm->slave;

   334

    ec_command_t *command = &fsm->command;

   335

    uint8_t new_state;

   336

   337

    if (command->state != EC_CMD_RECEIVED) {

   338

        fsm->master_state = ec_fsm_master_start;

   339

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

   340

        return;

   341

    }

   342

   343

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

   344

    if (command->working_counter != 1) {

   345

        if (slave->online) {

   346

            slave->online = 0;

   347

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

   348

        }

   349

        ec_fsm_master_action_next_slave_state(fsm);

   350

        return;

   351

    }

   352

   353

    // slave responded

   354

    new_state = EC_READ_U8(command->data);

   355

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

   356

        slave->online = 1;

   357

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

   358

        slave->current_state = new_state;

   359

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

   360

        ec_print_states(new_state);

   361

        printk(").\n");

   362

    }

   363

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

   364

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

   365

        ec_print_states(slave->current_state);

   366

        printk(" -> ");

   367

        ec_print_states(new_state);

   368

        printk(".\n");

   369

        slave->current_state = new_state;

   370

    }

   371

   372

    ec_fsm_master_action_next_slave_state(fsm);

   373

}

   374

   375

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

   376

   377

/**

   378

   Master state: PROC_STATES.

   379

   Processes the slave states.

   380

*/

   381

   382

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

   383

{

   384

    ec_master_t *master = fsm->master;

   385

    ec_slave_t *slave;

   386

   387

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

   388

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

   389

        if (slave->error_flag ||

   390

            !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

   422

            // found pending EEPROM write operation. execute it!

   423

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

   424

            fsm->sii_offset = 0x0000;

   425

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

   426

            fsm->sii_mode = 1;

   427

            fsm->sii_state = ec_fsm_sii_start_writing;

   428

            fsm->slave = slave;

   429

            fsm->master_state = ec_fsm_master_eeprom;

   430

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

   431

            return;

   432

        }

   433

    }

   434

   435

    // nothing to do. restart master state machine.

   436

    fsm->master_state = ec_fsm_master_start;

   437

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

   438

}

   439

   440

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

   441

   442

/**

   443

   Master state: VALIDATE_VENDOR.

   444

   Validates the vendor ID of a slave.

   445

*/

   446

   447

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

   448

{

   449

    ec_slave_t *slave = fsm->slave;

   450

   451

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

   452

   453

    if (fsm->sii_state == ec_fsm_sii_error) {

   455

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

   456

               slave->ring_position);

   457

        fsm->master_state = ec_fsm_master_start;

   458

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

   459

        return;

   460

    }

   461

   462

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

   463

   464

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

   465

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

   466

        fsm->master_state = ec_fsm_master_start;

   467

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

   468

        return;

   469

    }

   470

   471

    // vendor ID is ok. check product code.

   472

    fsm->master_state = ec_fsm_master_validate_product;

   473

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

   474

    fsm->sii_mode = 0;

   475

    fsm->sii_state = ec_fsm_sii_start_reading;

   476

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

   477

}

   478

   479

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

   480

   481

/**

   482

   Master state: VALIDATE_PRODUCT.

   483

   Validates the product ID of a slave.

   484

*/

   485

   486

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

   487

{

   488

    ec_slave_t *slave = fsm->slave;

   489

   490

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

   491

   492

    if (fsm->sii_state == ec_fsm_sii_error) {

   494

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

   495

               slave->ring_position);

   496

        fsm->master_state = ec_fsm_master_start;

   497

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

   498

        return;

   499

    }