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_read_states(ec_fsm_t *);

    50

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    51

void ec_fsm_master_validate_product(ec_fsm_t *);

    52

void ec_fsm_master_rewrite_addresses(ec_fsm_t *);

    53

void ec_fsm_master_configure_slave(ec_fsm_t *);

    54

void ec_fsm_master_scan_slaves(ec_fsm_t *);

    55

void ec_fsm_master_write_eeprom(ec_fsm_t *);

    56

    57

void ec_fsm_startup_start(ec_fsm_t *);

    58

void ec_fsm_startup_broadcast(ec_fsm_t *);

    59

void ec_fsm_startup_scan(ec_fsm_t *);

    60

    61

void ec_fsm_configuration_start(ec_fsm_t *);

    62

void ec_fsm_configuration_conf(ec_fsm_t *);

    63

    64

void ec_fsm_slavescan_start(ec_fsm_t *);

    65

void ec_fsm_slavescan_address(ec_fsm_t *);

    66

void ec_fsm_slavescan_state(ec_fsm_t *);

    67

void ec_fsm_slavescan_base(ec_fsm_t *);

    68

void ec_fsm_slavescan_datalink(ec_fsm_t *);

    69

void ec_fsm_slavescan_eeprom_size(ec_fsm_t *);

    70

void ec_fsm_slavescan_eeprom_data(ec_fsm_t *);

    71

    72

void ec_fsm_slaveconf_init(ec_fsm_t *);

    73

void ec_fsm_slaveconf_sync(ec_fsm_t *);

    74

void ec_fsm_slaveconf_preop(ec_fsm_t *);

    75

void ec_fsm_slaveconf_fmmu(ec_fsm_t *);

    76

void ec_fsm_slaveconf_saveop(ec_fsm_t *);

    77

void ec_fsm_slaveconf_op(ec_fsm_t *);

    78

    79

void ec_fsm_sii_start_reading(ec_fsm_t *);

    80

void ec_fsm_sii_read_check(ec_fsm_t *);

    81

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    82

void ec_fsm_sii_start_writing(ec_fsm_t *);

    83

void ec_fsm_sii_write_check(ec_fsm_t *);

    84

void ec_fsm_sii_write_check2(ec_fsm_t *);

    85

    86

void ec_fsm_change_start(ec_fsm_t *);

    87

void ec_fsm_change_check(ec_fsm_t *);

    88

void ec_fsm_change_status(ec_fsm_t *);

    89

void ec_fsm_change_code(ec_fsm_t *);

    90

void ec_fsm_change_ack(ec_fsm_t *);

    91

void ec_fsm_change_check_ack(ec_fsm_t *);

    92

    93

void ec_fsm_end(ec_fsm_t *);

    94

void ec_fsm_error(ec_fsm_t *);

    95

    96

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

    97

    98

/**

    99

   Constructor.

   100

*/

   101

   102

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

   103

                ec_master_t *master /**< EtherCAT master */

   104

                )

   105

{

   106

    fsm->master = master;

   107

    fsm->master_state = ec_fsm_master_start;

   108

    fsm->master_slaves_responding = 0;

   109

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   110

    fsm->master_validation = 0;

   111

   112

    ec_datagram_init(&fsm->datagram);

   113

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

   114

        EC_ERR("Failed to allocate FSM datagram.\n");

   115

        return -1;

   116

    }

   117

   118

    return 0;

   119

}

   120

   121

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

   122

   123

/**

   124

   Destructor.

   125

*/

   126

   127

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

   128

{

   129

    ec_datagram_clear(&fsm->datagram);

   130

}

   131

   132

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

   133

   134

/**

   135

   Resets the state machine.

   136

*/

   137

   138

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

   139

{

   140

    fsm->master_state = ec_fsm_master_start;

   141

    fsm->master_slaves_responding = 0;

   142

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   143

}

   144

   145

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

   146

   147

/**

   148

   Executes the current state of the state machine.

   149

*/

   150

   151

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

   152

{

   153

    fsm->master_state(fsm);

   154

}

   155

   156

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

   157

   158

void ec_fsm_startup(ec_fsm_t *fsm)

   159

{

   160

    fsm->master_state = ec_fsm_startup_start;

   161

}

   162

   163

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

   164

   165

int ec_fsm_startup_running(ec_fsm_t *fsm)

   166

{

   167

    return fsm->master_state != ec_fsm_end &&

   168

        fsm->master_state != ec_fsm_error;

   169

}

   170

   171

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

   172

   173

int ec_fsm_startup_success(ec_fsm_t *fsm)

   174

{

   175

    return fsm->master_state == ec_fsm_end;

   176

}

   177

   178

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

   179

   180

void ec_fsm_configuration(ec_fsm_t *fsm)

   181

{

   182

    fsm->master_state = ec_fsm_configuration_start;

   183

}

   184

   185

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

   186

   187

int ec_fsm_configuration_running(ec_fsm_t *fsm)

   188

{

   189

    return fsm->master_state != ec_fsm_end &&

   190

        fsm->master_state != ec_fsm_error;

   191

}

   192

   193

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

   194

   195

int ec_fsm_configuration_success(ec_fsm_t *fsm)

   196

{

   197

    return fsm->master_state == ec_fsm_end;

   198

}

   199

   200

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

   201

 *  master startup state machine

   202

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

   203

   204

/**

   205

   Master state: START.

   206

   Starts with getting slave count and slave states.

   207

*/

   208

   209

void ec_fsm_startup_start(ec_fsm_t *fsm)

   210

{

   211

    ec_datagram_brd(&fsm->datagram, 0x0130, 2);

   212

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

   213

    fsm->master_state = ec_fsm_startup_broadcast;

   214

}

   215

   216

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

   217

   218

/**

   219

   Master state: BROADCAST.

   220

   Processes the broadcast read slave count and slaves states.

   221

*/

   222

   223

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

   224

{

   225

    ec_datagram_t *datagram = &fsm->datagram;

   226

    unsigned int i;

   227

    ec_slave_t *slave;

   228

    ec_master_t *master = fsm->master;

   229

   230

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   231

        EC_ERR("Failed tor receive broadcast datagram.\n");

   232

        fsm->master_state = ec_fsm_error;

   233

        return;

   234

    }

   235

   236

    EC_INFO("Scanning bus.\n");

   237

   238

    ec_master_clear_slaves(master);

   239

   240

    master->slave_count = datagram->working_counter;

   241

   242

    if (!master->slave_count) {

   243

        // no slaves present -> finish state machine.

   244

        fsm->master_state = ec_fsm_end;

   245

        return;

   246

    }

   247

   248

    // init slaves

   249

    for (i = 0; i < master->slave_count; i++) {

   250

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

   251

                                             GFP_KERNEL))) {

   252

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

   253

            fsm->master_state = ec_fsm_error;

   254

            return;

   255

        }

   256

   257

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

   258

            fsm->master_state = ec_fsm_error;

   259

            return;

   260

        }

   261

   262

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

   263

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

   264

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

   265

            fsm->master_state = ec_fsm_error;

   266

            return;

   267

        }

   268

   269

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

   270

    }

   271

   272

    // begin scanning of slaves

   273

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

   274

    fsm->slave_state = ec_fsm_slavescan_start;

   275

    fsm->master_state = ec_fsm_startup_scan;

   276

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

   277

    return;

   278

}

   279

   280

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

   281

   282

/**

   283

   Master state: SCAN.

   284

   Executes the sub-statemachine for the scanning of a slave.

   285

*/

   286

   287

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

   288

{

   289

    ec_master_t *master = fsm->master;

   290

    ec_slave_t *slave = fsm->slave;

   291

   292

    fsm->slave_state(fsm); // execute slave state machine

   293

   294

    if (fsm->slave_state == ec_fsm_error) {

   295

        EC_ERR("Slave scanning failed.\n");

   296

        fsm->master_state = ec_fsm_error;

   297

        return;

   298

    }

   299

   300

    if (fsm->slave_state != ec_fsm_end) return;

   301

   302

    // another slave to scan?

   303

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

   304

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

   305

        fsm->slave_state = ec_fsm_slavescan_start;

   306

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

   307

        return;

   308

    }

   309

   310

    EC_INFO("Bus scanning completed.\n");

   311

   312

    ec_master_calc_addressing(master);

   313

   314

    fsm->master_state = ec_fsm_end;

   315

}

   316

   317

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

   318

 *  master configuration state machine

   319

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

   320

   321

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

   322

{

   323

    ec_master_t *master = fsm->master;

   324

   325

    if (list_empty(&master->slaves)) {

   326

        fsm->master_state = ec_fsm_end;

   327

        return;

   328

    }

   329

   330

    // begin configuring slaves

   331

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

   332

    fsm->slave_state = ec_fsm_slaveconf_init;

   333

    fsm->change_new = EC_SLAVE_STATE_INIT;

   334

    fsm->change_state = ec_fsm_change_start;

   335

    fsm->master_state = ec_fsm_configuration_conf;

   336

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

   337

}

   338

   339

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

   340

   341

/**

   342

   Master state: CONF.

   343

*/

   344

   345

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

   346

{

   347

    ec_master_t *master = fsm->master;

   348

    ec_slave_t *slave = fsm->slave;

   349

   350

    fsm->slave_state(fsm); // execute slave's state machine

   351

   352

    if (fsm->slave_state == ec_fsm_error) {

   353

        fsm->master_state = ec_fsm_error;

   354

        return;

   355

    }

   356

   357

    if (fsm->slave_state != ec_fsm_end) return;

   358

   359

    // another slave to configure?

   360

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

   361

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

   362

        fsm->slave_state = ec_fsm_slaveconf_init;

   363

        fsm->change_new = EC_SLAVE_STATE_INIT;

   364

        fsm->change_state = ec_fsm_change_start;

   365

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

   366

        return;

   367

    }

   368

   369

    fsm->master_state = ec_fsm_end;

   370

}

   371

   372

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

   373

 *  operation / idle state machine

   374

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

   375

   376

/**

   377

   Master state: START.

   378

   Starts with getting slave count and slave states.

   379

*/

   380

   381

void ec_fsm_master_start(ec_fsm_t *fsm)

   382

{

   383

    ec_datagram_brd(&fsm->datagram, 0x0130, 2);

   384

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

   385

    fsm->master_state = ec_fsm_master_broadcast;

   386

}

   387

   388

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

   389

   390

/**

   391

   Master state: BROADCAST.

   392

   Processes the broadcast read slave count and slaves states.

   393

*/

   394

   395

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

   396

{

   397

    ec_datagram_t *datagram = &fsm->datagram;

   398

    unsigned int topology_change, states_change, i;

   399

    ec_slave_t *slave;

   400

    ec_master_t *master = fsm->master;

   401

   402

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   403

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

   404

            fsm->master_slaves_responding = 0;

   405

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

   406

                slave->online = 0;

   407

            }

   408

        }

   409

        fsm->master_state = ec_fsm_master_start;

   410

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

   411

        return;

   412

    }

   413

   414

    topology_change = (datagram->working_counter !=

   415

                       fsm->master_slaves_responding);

   416

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

   417

   418

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

   419

    fsm->master_slaves_responding = datagram->working_counter;

   420

   421

    if (topology_change) {

   422

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

   423

                fsm->master_slaves_responding,

   424

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

   425

   426

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   427

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

   428

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

   429

            }

   430

            else {

   431

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

   432

            }

   433

        }

   434

    }

   435

   436

    if (states_change) {

   437

        char states[25];

   438

        ec_state_string(fsm->master_slave_states, states);

   439

        EC_INFO("Slave states: %s.\n", states);

   440

    }

   441

   442

    // topology change in idle mode: clear all slaves and scan the bus

   443

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

   444

        EC_INFO("Scanning bus.\n");

   445

   446

        ec_master_eoe_stop(master);

   447

        ec_master_clear_slaves(master);

   448

   449

        master->slave_count = datagram->working_counter;

   450

   451

        if (!master->slave_count) {

   452

            // no slaves present -> finish state machine.

   453

            fsm->master_state = ec_fsm_master_start;

   454

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

   455

            return;

   456

        }

   457

   458

        // init slaves

   459

        for (i = 0; i < master->slave_count; i++) {

   460

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

   461

                                                 GFP_ATOMIC))) {

   462

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

   463

                ec_master_clear_slaves(master);

   464

                fsm->master_state = ec_fsm_master_start;

   465

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

   466

                return;

   467

            }

   468

   469

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

   470

                // freeing of "slave" already done

   471

                ec_master_clear_slaves(master);

   472

                fsm->master_state = ec_fsm_master_start;

   473

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

   474

                return;

   475

            }

   476

   477

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

   478

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

   479

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

   480

                ec_master_clear_slaves(master);

   481

                fsm->master_state = ec_fsm_master_start;

   482

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

   483

                return;

   484

            }

   485

   486

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

   487

        }

   488

   489

        // begin scanning of slaves

   490

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

   491

        fsm->slave_state = ec_fsm_slavescan_start;

   492

        fsm->master_state = ec_fsm_master_scan_slaves;

   493

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

   494

        return;

   495

    }

   496

   497

    // fetch state from each slave