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

    58

void ec_fsm_master_sdo_request(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_coe_dict_start(ec_fsm_t *);

    84

void ec_fsm_coe_dict_request(ec_fsm_t *);

    85

void ec_fsm_coe_dict_check(ec_fsm_t *);

    86

void ec_fsm_coe_dict_response(ec_fsm_t *);

    87

void ec_fsm_coe_dict_desc_request(ec_fsm_t *);

    88

void ec_fsm_coe_dict_desc_check(ec_fsm_t *);

    89

void ec_fsm_coe_dict_desc_response(ec_fsm_t *);

    90

void ec_fsm_coe_dict_entry_request(ec_fsm_t *);

    91

void ec_fsm_coe_dict_entry_check(ec_fsm_t *);

    92

void ec_fsm_coe_dict_entry_response(ec_fsm_t *);

    93

    94

void ec_fsm_coe_down_start(ec_fsm_t *);

    95

void ec_fsm_coe_down_request(ec_fsm_t *);

    96

void ec_fsm_coe_down_check(ec_fsm_t *);

    97

void ec_fsm_coe_down_response(ec_fsm_t *);

    98

    99

void ec_fsm_coe_up_start(ec_fsm_t *);

   100

void ec_fsm_coe_up_request(ec_fsm_t *);

   101

void ec_fsm_coe_up_check(ec_fsm_t *);

   102

void ec_fsm_coe_up_response(ec_fsm_t *);

   103

void ec_fsm_coe_up_seg_request(ec_fsm_t *);

   104

void ec_fsm_coe_up_seg_check(ec_fsm_t *);

   105

void ec_fsm_coe_up_seg_response(ec_fsm_t *);

   106

   107

void ec_fsm_end(ec_fsm_t *);

   108

void ec_fsm_error(ec_fsm_t *);

   109

   110

void ec_canopen_abort_msg(uint32_t);

   111

   112

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

   113

   114

/**

   115

   Constructor.

   116

*/

   117

   118

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

   119

                ec_master_t *master /**< EtherCAT master */

   120

                )

   121

{

   122

    fsm->master = master;

   123

    fsm->master_state = ec_fsm_master_start;

   124

    fsm->master_slaves_responding = 0;

   125

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   126

    fsm->master_validation = 0;

   127

   128

    ec_datagram_init(&fsm->datagram);

   129

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

   130

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

   131

        return -1;

   132

    }

   133

   134

    ec_fsm_sii_init(&fsm->fsm_sii, &fsm->datagram);

   136

   137

    return 0;

   138

}

   139

   140

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

   141

   142

/**

   143

   Destructor.

   144

*/

   145

   146

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

   147

{

   148

    ec_fsm_sii_clear(&fsm->fsm_sii);

   150

   151

    ec_datagram_clear(&fsm->datagram);

   152

}

   153

   154

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

   155

   156

/**

   157

   Resets the state machine.

   158

*/

   159

   160

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

   161

{

   162

    fsm->master_state = ec_fsm_master_start;

   163

    fsm->master_slaves_responding = 0;

   164

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   165

}

   166

   167

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

   168

   169

/**

   170

   Executes the current state of the state machine.

   171

*/

   172

   173

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

   174

{

   175

    fsm->master_state(fsm);

   176

}

   177

   178

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

   179

   180

/**

   181

   Initializes the master startup state machine.

   182

*/

   183

   184

void ec_fsm_startup(ec_fsm_t *fsm)

   185

{

   186

    fsm->master_state = ec_fsm_startup_start;

   187

}

   188

   189

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

   190

   191

/**

   192

   Returns the running state of the master startup state machine.

   193

   \return non-zero if not terminated yet.

   194

*/

   195

   196

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

   197

{

   198

    return fsm->master_state != ec_fsm_end &&

   199

        fsm->master_state != ec_fsm_error;

   200

}

   201

   202

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

   203

   204

/**

   205

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

   206

   \return non-zero if successful.

   207

*/

   208

   209

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

   210

{

   211

    return fsm->master_state == ec_fsm_end;

   212

}

   213

   214

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

   215

   216

/**

   217

   Initializes the master configuration state machine.

   218

*/

   219

   220

void ec_fsm_configuration(ec_fsm_t *fsm)

   221

{

   222

    fsm->master_state = ec_fsm_configuration_start;

   223

}

   224

   225

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

   226

   227

/**

   228

   Returns the running state of the master configuration state machine.

   229

   \return non-zero if not terminated yet.

   230

*/

   231

   232

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

   233

{

   234

    return fsm->master_state != ec_fsm_end &&

   235

        fsm->master_state != ec_fsm_error;

   236

}

   237

   238

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

   239

   240

/**

   241

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

   242

   \return non-zero if successful.

   243

*/

   244

   245

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

   246

{

   247

    return fsm->master_state == ec_fsm_end;

   248

}

   249

   250

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

   251

 *  master startup state machine

   252

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

   253

   254

/**

   255

   Master state: START.

   256

   Starts with getting slave count and slave states.

   257

*/

   258

   259

void ec_fsm_startup_start(ec_fsm_t *fsm)

   260

{

   261

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

   262

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

   263

    fsm->master_state = ec_fsm_startup_broadcast;

   264

}

   265

   266

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

   267

   268

/**

   269

   Master state: BROADCAST.

   270

   Processes the broadcast read slave count and slaves states.

   271

*/

   272

   273

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

   274

{

   275

    ec_datagram_t *datagram = &fsm->datagram;

   276

    unsigned int i;

   277

    ec_slave_t *slave;

   278

    ec_master_t *master = fsm->master;

   279

   280

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   281

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

   282

        fsm->master_state = ec_fsm_error;

   283

        return;

   284

    }

   285

   286

    EC_INFO("Scanning bus.\n");

   287

   288

    ec_master_clear_slaves(master);

   289

   290

    master->slave_count = datagram->working_counter;

   291

   292

    if (!master->slave_count) {

   293

        // no slaves present -> finish state machine.

   294

        fsm->master_state = ec_fsm_end;

   295

        return;

   296

    }

   297

   298

    // init slaves

   299

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

   300

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

   301

                                             GFP_KERNEL))) {

   302

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

   303

            fsm->master_state = ec_fsm_error;

   304

            return;

   305

        }

   306

   307

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

   308

            fsm->master_state = ec_fsm_error;

   309

            return;

   310

        }

   311

   312

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

   313

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

   314

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

   315

            fsm->master_state = ec_fsm_error;

   316

            return;

   317

        }

   318

   319

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

   320

    }

   321

   322

    // begin scanning of slaves

   323

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

   324

    fsm->slave_state = ec_fsm_slavescan_start;

   325

    fsm->master_state = ec_fsm_startup_scan;

   326

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

   327

    return;

   328

}

   329

   330

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

   331

   332

/**

   333

   Master state: SCAN.

   334

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

   335

*/

   336

   337

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

   338

{

   339

    ec_master_t *master = fsm->master;

   340

    ec_slave_t *slave = fsm->slave;

   341

   342

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

   343

   344

    if (fsm->slave_state == ec_fsm_error) {

   345

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

   346

        fsm->master_state = ec_fsm_error;

   347

        return;

   348

    }

   349

   350

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

   351

   352

    // another slave to scan?

   353

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

   354

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

   355

        fsm->slave_state = ec_fsm_slavescan_start;

   356

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

   357

        return;

   358

    }

   359

   360

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

   361

   362

    ec_master_calc_addressing(master);

   363

   364

    fsm->master_state = ec_fsm_end;

   365

}

   366

   367

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

   368

 *  master configuration state machine

   369

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

   370

   371

/**

   372

   Master configuration state machine: START.

   373

*/

   374

   375

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

   376

{

   377

    ec_master_t *master = fsm->master;

   378

   379

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

   380

        fsm->master_state = ec_fsm_end;

   381

        return;

   382

    }

   383

   384

    // begin configuring slaves

   385

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

   386

    fsm->slave_state = ec_fsm_slaveconf_init;

   388

    fsm->master_state = ec_fsm_configuration_conf;

   389

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

   390

}

   391

   392

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

   393

   394

/**

   395

   Master state: CONF.

   396

*/

   397

   398

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

   399

{

   400

    ec_master_t *master = fsm->master;

   401

    ec_slave_t *slave = fsm->slave;

   402

   403

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

   404

   405

    if (fsm->slave_state == ec_fsm_error) {

   406

        fsm->master_state = ec_fsm_error;

   407

        return;

   408

    }

   409

   410

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

   411

   412

    // another slave to configure?

   413

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

   414

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

   415

        fsm->slave_state = ec_fsm_slaveconf_init;

   417

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

   418

        return;

   419

    }

   420

   421

    fsm->master_state = ec_fsm_end;

   422

}

   423

   424

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

   425

 *  operation / idle state machine

   426

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

   427

   428

/**

   429

   Master state: START.

   430

   Starts with getting slave count and slave states.

   431

*/

   432

   433

void ec_fsm_master_start(ec_fsm_t *fsm)

   434

{

   435

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

   436

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

   437

    fsm->master_state = ec_fsm_master_broadcast;

   438

}

   439

   440

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

   441

   442

/**

   443

   Master state: BROADCAST.

   444

   Processes the broadcast read slave count and slaves states.

   445

*/

   446

   447

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

   448

{

   449

    ec_datagram_t *datagram = &fsm->datagram;

   450

    unsigned int topology_change, states_change, i;

   451

    ec_slave_t *slave;

   452

    ec_master_t *master = fsm->master;

   453

   454

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   455

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

   456

            fsm->master_slaves_responding = 0;

   457

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

   458

                slave->online = 0;

   459

            }

   460

        }

   461

        fsm->master_state = ec_fsm_master_start;

   462

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

   463

        return;

   464

    }

   465

   466

    topology_change = (datagram->working_counter !=

   467

                       fsm->master_slaves_responding);

   468

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

   469

   470

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

   471

    fsm->master_slaves_responding = datagram->working_counter;

   472

   473

    if (topology_change) {

   474

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

   475

                fsm->master_slaves_responding,

   476

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

   477

   478

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   479

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

   480

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

   481

            }

   482

            else {

   483

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

   484

            }

   485

        }

   486

    }

   487

   488

    if (states_change) {

   489

        char states[EC_STATE_STRING_SIZE];

   490

        ec_state_string(fsm->master_slave_states, states);

   491

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

   492

    }

   493

   494

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

   495

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