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

#include "mailbox.h"

    45

    46

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

    47

    48

void ec_fsm_master_start(ec_fsm_t *);

    49

void ec_fsm_master_broadcast(ec_fsm_t *);

    50

void ec_fsm_master_read_states(ec_fsm_t *);

    51

void ec_fsm_master_validate_vendor(ec_fsm_t *);

    52

void ec_fsm_master_validate_product(ec_fsm_t *);

    53

void ec_fsm_master_rewrite_addresses(ec_fsm_t *);

    54

void ec_fsm_master_configure_slave(ec_fsm_t *);

    55

void ec_fsm_master_scan_slaves(ec_fsm_t *);

    56

void ec_fsm_master_write_eeprom(ec_fsm_t *);

    57

void ec_fsm_master_sdodict(ec_fsm_t *);

    59

    60

void ec_fsm_startup_start(ec_fsm_t *);

    61

void ec_fsm_startup_broadcast(ec_fsm_t *);

    62

void ec_fsm_startup_scan(ec_fsm_t *);

    63

    64

void ec_fsm_configuration_start(ec_fsm_t *);

    65

void ec_fsm_configuration_conf(ec_fsm_t *);

    66

    67

void ec_fsm_slavescan_start(ec_fsm_t *);

    68

void ec_fsm_slavescan_address(ec_fsm_t *);

    69

void ec_fsm_slavescan_state(ec_fsm_t *);

    70

void ec_fsm_slavescan_base(ec_fsm_t *);

    71

void ec_fsm_slavescan_datalink(ec_fsm_t *);

    72

void ec_fsm_slavescan_eeprom_size(ec_fsm_t *);

    73

void ec_fsm_slavescan_eeprom_data(ec_fsm_t *);

    74

    75

void ec_fsm_slaveconf_init(ec_fsm_t *);

    76

void ec_fsm_slaveconf_sync(ec_fsm_t *);

    77

void ec_fsm_slaveconf_preop(ec_fsm_t *);

    78

void ec_fsm_slaveconf_fmmu(ec_fsm_t *);

    79

void ec_fsm_slaveconf_sdoconf(ec_fsm_t *);

    80

void ec_fsm_slaveconf_saveop(ec_fsm_t *);

    81

void ec_fsm_slaveconf_op(ec_fsm_t *);

    82

    83

void ec_fsm_sii_start_reading(ec_fsm_t *);

    84

void ec_fsm_sii_read_check(ec_fsm_t *);

    85

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    86

void ec_fsm_sii_start_writing(ec_fsm_t *);

    87

void ec_fsm_sii_write_check(ec_fsm_t *);

    88

void ec_fsm_sii_write_check2(ec_fsm_t *);

    89

    90

void ec_fsm_change_start(ec_fsm_t *);

    91

void ec_fsm_change_check(ec_fsm_t *);

    92

void ec_fsm_change_status(ec_fsm_t *);

    93

void ec_fsm_change_code(ec_fsm_t *);

    94

void ec_fsm_change_ack(ec_fsm_t *);

    95

void ec_fsm_change_check_ack(ec_fsm_t *);

    96

    97

void ec_fsm_coe_dict_start(ec_fsm_t *);

    98

void ec_fsm_coe_dict_request(ec_fsm_t *);

    99

void ec_fsm_coe_dict_check(ec_fsm_t *);

   100

void ec_fsm_coe_dict_response(ec_fsm_t *);

   101

void ec_fsm_coe_dict_desc_request(ec_fsm_t *);

   102

void ec_fsm_coe_dict_desc_check(ec_fsm_t *);

   103

void ec_fsm_coe_dict_desc_response(ec_fsm_t *);

   104

void ec_fsm_coe_dict_entry_request(ec_fsm_t *);

   105

void ec_fsm_coe_dict_entry_check(ec_fsm_t *);

   106

void ec_fsm_coe_dict_entry_response(ec_fsm_t *);

   107

   108

void ec_fsm_coe_down_start(ec_fsm_t *);

   109

void ec_fsm_coe_down_request(ec_fsm_t *);

   110

void ec_fsm_coe_down_check(ec_fsm_t *);

   111

void ec_fsm_coe_down_response(ec_fsm_t *);

   112

   121

void ec_fsm_end(ec_fsm_t *);

   122

void ec_fsm_error(ec_fsm_t *);

   123

   124

void ec_canopen_abort_msg(uint32_t);

   125

   126

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

   127

   128

/**

   129

   Constructor.

   130

*/

   131

   132

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

   133

                ec_master_t *master /**< EtherCAT master */

   134

                )

   135

{

   136

    fsm->master = master;

   137

    fsm->master_state = ec_fsm_master_start;

   138

    fsm->master_slaves_responding = 0;

   139

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   140

    fsm->master_validation = 0;

   141

   142

    ec_datagram_init(&fsm->datagram);

   143

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

   144

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

   145

        return -1;

   146

    }

   147

   148

    return 0;

   149

}

   150

   151

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

   152

   153

/**

   154

   Destructor.

   155

*/

   156

   157

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

   158

{

   159

    ec_datagram_clear(&fsm->datagram);

   160

}

   161

   162

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

   163

   164

/**

   165

   Resets the state machine.

   166

*/

   167

   168

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

   169

{

   170

    fsm->master_state = ec_fsm_master_start;

   171

    fsm->master_slaves_responding = 0;

   172

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   173

}

   174

   175

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

   176

   177

/**

   178

   Executes the current state of the state machine.

   179

*/

   180

   181

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

   182

{

   183

    fsm->master_state(fsm);

   184

}

   185

   186

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

   187

   188

/**

   189

   Initializes the master startup state machine.

   190

*/

   191

   192

void ec_fsm_startup(ec_fsm_t *fsm)

   193

{

   194

    fsm->master_state = ec_fsm_startup_start;

   195

}

   196

   197

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

   198

   199

/**

   200

   Returns the running state of the master startup state machine.

   201

   \return non-zero if not terminated yet.

   202

*/

   203

   204

int ec_fsm_startup_running(ec_fsm_t *fsm /**< Finite state machine */)

   205

{

   206

    return fsm->master_state != ec_fsm_end &&

   207

        fsm->master_state != ec_fsm_error;

   208

}

   209

   210

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

   211

   212

/**

   213

   Returns, if the master startup state machine terminated with success.

   214

   \return non-zero if successful.

   215

*/

   216

   217

int ec_fsm_startup_success(ec_fsm_t *fsm /**< Finite state machine */)

   218

{

   219

    return fsm->master_state == ec_fsm_end;

   220

}

   221

   222

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

   223

   224

/**

   225

   Initializes the master configuration state machine.

   226

*/

   227

   228

void ec_fsm_configuration(ec_fsm_t *fsm)

   229

{

   230

    fsm->master_state = ec_fsm_configuration_start;

   231

}

   232

   233

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

   234

   235

/**

   236

   Returns the running state of the master configuration state machine.

   237

   \return non-zero if not terminated yet.

   238

*/

   239

   240

int ec_fsm_configuration_running(ec_fsm_t *fsm /**< Finite state machine */)

   241

{

   242

    return fsm->master_state != ec_fsm_end &&

   243

        fsm->master_state != ec_fsm_error;

   244

}

   245

   246

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

   247

   248

/**

   249

   Returns, if the master confuguration state machine terminated with success.

   250

   \return non-zero if successful.

   251

*/

   252

   253

int ec_fsm_configuration_success(ec_fsm_t *fsm /**< Finite state machine */)

   254

{

   255

    return fsm->master_state == ec_fsm_end;

   256

}

   257

   258

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

   259

 *  master startup state machine

   260

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

   261

   262

/**

   263

   Master state: START.

   264

   Starts with getting slave count and slave states.

   265

*/

   266

   267

void ec_fsm_startup_start(ec_fsm_t *fsm)

   268

{

   269

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

   270

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

   271

    fsm->master_state = ec_fsm_startup_broadcast;

   272

}

   273

   274

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

   275

   276

/**

   277

   Master state: BROADCAST.

   278

   Processes the broadcast read slave count and slaves states.

   279

*/

   280

   281

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

   282

{

   283

    ec_datagram_t *datagram = &fsm->datagram;

   284

    unsigned int i;

   285

    ec_slave_t *slave;

   286

    ec_master_t *master = fsm->master;

   287

   288

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   289

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

   290

        fsm->master_state = ec_fsm_error;

   291

        return;

   292

    }

   293

   294

    EC_INFO("Scanning bus.\n");

   295

   296

    ec_master_clear_slaves(master);

   297

   298

    master->slave_count = datagram->working_counter;

   299

   300

    if (!master->slave_count) {

   301

        // no slaves present -> finish state machine.

   302

        fsm->master_state = ec_fsm_end;

   303

        return;

   304

    }

   305

   306

    // init slaves

   307

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

   308

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

   309

                                             GFP_KERNEL))) {

   310

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

   311

            fsm->master_state = ec_fsm_error;

   312

            return;

   313

        }

   314

   315

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

   316

            fsm->master_state = ec_fsm_error;

   317

            return;

   318

        }

   319

   320

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

   321

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

   322

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

   323

            fsm->master_state = ec_fsm_error;

   324

            return;

   325

        }

   326

   327

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

   328

    }

   329

   330

    // begin scanning of slaves

   331

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

   332

    fsm->slave_state = ec_fsm_slavescan_start;

   333

    fsm->master_state = ec_fsm_startup_scan;

   334

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

   335

    return;

   336

}

   337

   338

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

   339

   340

/**

   341

   Master state: SCAN.

   342

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

   343

*/

   344

   345

void ec_fsm_startup_scan(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 state machine

   351

   352

    if (fsm->slave_state == ec_fsm_error) {

   353

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

   354

        fsm->master_state = ec_fsm_error;

   355

        return;

   356

    }

   357

   358

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

   359

   360

    // another slave to scan?

   361

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

   362

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

   363

        fsm->slave_state = ec_fsm_slavescan_start;

   364

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

   365

        return;

   366

    }

   367

   368

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

   369

   370

    ec_master_calc_addressing(master);

   371

   372

    fsm->master_state = ec_fsm_end;

   373

}

   374

   375

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

   376

 *  master configuration state machine

   377

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

   378

   379

/**

   380

   Master configuration state machine: START.

   381

*/

   382

   383

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

   384

{

   385

    ec_master_t *master = fsm->master;

   386

   387

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

   388

        fsm->master_state = ec_fsm_end;

   389

        return;

   390

    }

   391

   392

    // begin configuring slaves

   393

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

   394

    fsm->slave_state = ec_fsm_slaveconf_init;

   395

    fsm->change_new = EC_SLAVE_STATE_INIT;

   396

    fsm->change_state = ec_fsm_change_start;

   397

    fsm->master_state = ec_fsm_configuration_conf;

   398

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

   399

}

   400

   401

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

   402

   403

/**

   404

   Master state: CONF.

   405

*/

   406

   407

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

   408

{

   409

    ec_master_t *master = fsm->master;

   410

    ec_slave_t *slave = fsm->slave;

   411

   412

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

   413

   414

    if (fsm->slave_state == ec_fsm_error) {

   415

        fsm->master_state = ec_fsm_error;

   416

        return;

   417

    }

   418

   419

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

   420

   421

    // another slave to configure?

   422

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

   423

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

   424

        fsm->slave_state = ec_fsm_slaveconf_init;

   425

        fsm->change_new = EC_SLAVE_STATE_INIT;

   426

        fsm->change_state = ec_fsm_change_start;

   427

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

   428

        return;

   429

    }

   430

   431

    fsm->master_state = ec_fsm_end;

   432

}

   433

   434

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

   435

 *  operation / idle state machine

   436

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

   437

   438

/**

   439

   Master state: START.

   440

   Starts with getting slave count and slave states.

   441

*/

   442

   443

void ec_fsm_master_start(ec_fsm_t *fsm)

   444

{

   445

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

   446

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

   447

    fsm->master_state = ec_fsm_master_broadcast;

   448

}

   449

   450

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

   451

   452

/**

   453

   Master state: BROADCAST.

   454

   Processes the broadcast read slave count and slaves states.

   455

*/

   456

   457

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

   458

{

   459

    ec_datagram_t *datagram = &fsm->datagram;

   460

    unsigned int topology_change, states_change, i;

   461

    ec_slave_t *slave;

   462

    ec_master_t *master = fsm->master;

   463

   464

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   465

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

   466

            fsm->master_slaves_responding = 0;

   467

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

   468

                slave->online = 0;

   469

            }

   470

        }

   471

        fsm->master_state = ec_fsm_master_start;

   472

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

   473

        return;

   474

    }

   475

   476

    topology_change = (datagram->working_counter !=

   477

                       fsm->master_slaves_responding);

   478

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

   479

   480

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

   481

    fsm->master_slaves_responding = datagram->working_counter;

   482

   483

    if (topology_change) {

   484

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

   485

                fsm->master_slaves_responding,

   486

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

   487

   488

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   489

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

   490

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

   491

            }

   492

            else {

   493

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

   494

            }

   495

        }

   496

    }