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_state(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_datagram_init(&fsm->datagram);

   111

    if (ec_datagram_prealloc(&fsm->datagram, EC_MAX_DATA_SIZE)) {

   112

        EC_ERR("Failed to allocate FSM datagram.\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_datagram_clear(&fsm->datagram);

   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_datagram_brd(&fsm->datagram, 0x0130, 2);

   166

    ec_master_queue_datagram(fsm->master, &fsm->datagram);

   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_datagram_t *datagram = &fsm->datagram;

   180

    unsigned int topology_change, states_change, i;

   181

    ec_slave_t *slave;

   182

    ec_master_t *master = fsm->master;

   183

   184

    if (datagram->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 = (datagram->working_counter !=

   197

                       fsm->master_slaves_responding);

   198

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

   199

   200

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

   201

    fsm->master_slaves_responding = datagram->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_datagram_nprd(&fsm->datagram, fsm->slave->station_address, 0x0130, 2);

   276

    ec_master_queue_datagram(master, &fsm->datagram);

   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

        // process next slave

   295

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

   296

        ec_datagram_nprd(&fsm->datagram, fsm->slave->station_address,

   297

                         0x0130, 2);

   298

        ec_master_queue_datagram(master, &fsm->datagram);

   299

        fsm->master_state = ec_fsm_master_states;

   300

        return;

   301

    }

   302

   303

    // all slave stated read; check, if a bus validation has to be done

   304

    if (fsm->master_validation) {

   305

        fsm->master_validation = 0;

   306

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

   307

            if (slave->online) continue;

   308

   309

            // At least one slave is offline. validate!

   310

            EC_INFO("Validating bus.\n");

   311

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

   312

            fsm->master_state = ec_fsm_master_validate_vendor;

   313

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

   314

            fsm->sii_mode = 0;

   315

            fsm->sii_state = ec_fsm_sii_start_reading;

   316

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

   317

            return;

   318

        }

   319

    }

   320

   321

    fsm->master_state = ec_fsm_master_proc_states;

   322

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

   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_datagram_t *datagram = &fsm->datagram;

   336

    uint8_t new_state;

   337

   338

    if (datagram->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 (datagram->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(datagram->data);

   356

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

   357

        slave->online = 1;

   358

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

   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->error_flag ||

   391

            !slave->online ||

   392

            slave->requested_state == EC_SLAVE_STATE_UNKNOWN ||

   393

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

   394

   395

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

   396

        ec_print_states(slave->current_state);

   397

        printk(" to ");

   398

        ec_print_states(slave->requested_state);

   399

        printk(".\n");

   400

   401

        fsm->slave = slave;

   402

        fsm->slave_state = ec_fsm_slave_conf;

   403

        fsm->change_new = EC_SLAVE_STATE_INIT;

   404

        fsm->change_state = ec_fsm_change_start;

   405

        fsm->master_state = ec_fsm_master_conf;

   406

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

   407

        return;

   408

    }

   409

   410

    if (master->mode == EC_MASTER_MODE_FREERUN) {

   411

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

   412

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

   413

            if (!slave->new_eeprom_data) continue;

   414

   415

            if (!slave->online || slave->error_flag) {

   416

                kfree(slave->new_eeprom_data);

   417

                slave->new_eeprom_data = NULL;

   418

                EC_ERR("Discarding EEPROM data, slave %i not ready.\n",

   419

                       slave->ring_position);

   420

                continue;

   421

            }

   422

   423

            // found pending EEPROM write operation. execute it!

   424

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

   425

            fsm->sii_offset = 0x0000;

   426

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

   427

            fsm->sii_mode = 1;

   428

            fsm->sii_state = ec_fsm_sii_start_writing;

   429

            fsm->slave = slave;

   430

            fsm->master_state = ec_fsm_master_eeprom;

   431

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

   432

            return;

   433

        }

   434

    }

   435

   436

    // nothing to do. restart master state machine.

   437

    fsm->master_state = ec_fsm_master_start;

   438

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

   439

}

   440

   441

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

   442

   443

/**

   444

   Master state: VALIDATE_VENDOR.

   445

   Validates the vendor ID of a slave.

   446

*/

   447

   448

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

   449

{

   450

    ec_slave_t *slave = fsm->slave;

   451

   452

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

   453

   454

    if (fsm->sii_state == ec_fsm_sii_error) {

   455

        fsm->slave->error_flag = 1;

   456

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

   457

               slave->ring_position);

   458

        fsm->master_state = ec_fsm_master_start;

   459

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

   460

        return;

   461

    }

   462

   463

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

   464

   465

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

   466

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

   467

        fsm->master_state = ec_fsm_master_start;

   468

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

   469

        return;

   470

    }

   471

   472

    // vendor ID is ok. check product code.

   473

    fsm->master_state = ec_fsm_master_validate_product;

   474

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

   475

    fsm->sii_mode = 0;

   476

    fsm->sii_state = ec_fsm_sii_start_reading;

   477

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

   478

}

   479

   480

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

   481

   482

/**

   483

   Master state: VALIDATE_PRODUCT.

   484

   Validates the product ID of a slave.

   485

*/

   486

   487

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

   488

{

   489

    ec_slave_t *slave = fsm->slave;

   490

   491

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

   492

   493

    if (fsm->sii_state == ec_fsm_sii_error) {

   494

        fsm->slave->error_flag = 1;

   495

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

   496

               slave->ring_position);

   497

        fsm->master_state = ec_fsm_master_start;