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

    84

void ec_fsm_error(ec_fsm_t *);

    85

    86

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

    87

    88

/**

    89

   Constructor.

    90

*/

    91

    92

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

    93

                ec_master_t *master /**< EtherCAT master */

    94

                )

    95

{

    96

    fsm->master = master;

    97

    fsm->master_state = ec_fsm_master_start;

    98

    fsm->master_slaves_responding = 0;

    99

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   100

    fsm->master_validation = 0;

   101

   102

    ec_datagram_init(&fsm->datagram);

   103

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

   104

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

   105

        return -1;

   106

    }

   107

   108

    // init sub-state-machines

   109

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

   110

    ec_fsm_change_init(&fsm->fsm_change, &fsm->datagram);

   111

    ec_fsm_coe_init(&fsm->fsm_coe, &fsm->datagram);

   112

   113

    return 0;

   114

}

   115

   116

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

   117

   118

/**

   119

   Destructor.

   120

*/

   121

   122

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

   123

{

   124

    // clear sub-state machines

   125

    ec_fsm_sii_clear(&fsm->fsm_sii);

   126

    ec_fsm_change_clear(&fsm->fsm_change);

   127

    ec_fsm_coe_clear(&fsm->fsm_coe);

   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

   \return false, if state machine has terminated

   150

*/

   151

   152

int ec_fsm_exec(ec_fsm_t *fsm /**< finite state machine */)

   153

{

   154

    fsm->master_state(fsm);

   155

   156

    return fsm->master_state != ec_fsm_end &&

   157

        fsm->master_state != ec_fsm_error;

   158

}

   159

   160

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

   161

   162

/**

   163

   Initializes the master startup state machine.

   164

*/

   165

   166

void ec_fsm_startup(ec_fsm_t *fsm)

   167

{

   168

    fsm->master_state = ec_fsm_startup_start;

   169

}

   170

   171

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

   172

   173

/**

   174

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

   175

   \return non-zero if successful.

   176

*/

   177

   178

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

   179

{

   180

    return fsm->master_state == ec_fsm_end;

   181

}

   182

   183

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

   184

   185

/**

   186

   Initializes the master configuration state machine.

   187

*/

   188

   189

void ec_fsm_configuration(ec_fsm_t *fsm)

   190

{

   191

    fsm->master_state = ec_fsm_configuration_start;

   192

}

   193

   194

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

   195

   196

/**

   197

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

   198

   \return non-zero if successful.

   199

*/

   200

   201

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

   202

{

   203

    return fsm->master_state == ec_fsm_end;

   204

}

   205

   206

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

   207

 *  master startup state machine

   208

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

   209

   210

/**

   211

   Master state: START.

   212

   Starts with getting slave count and slave states.

   213

*/

   214

   215

void ec_fsm_startup_start(ec_fsm_t *fsm)

   216

{

   217

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

   218

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

   219

    fsm->master_state = ec_fsm_startup_broadcast;

   220

}

   221

   222

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

   223

   224

/**

   225

   Master state: BROADCAST.

   226

   Processes the broadcast read slave count and slaves states.

   227

*/

   228

   229

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

   230

{

   231

    ec_datagram_t *datagram = &fsm->datagram;

   232

    unsigned int i;

   233

    ec_slave_t *slave;

   234

    ec_master_t *master = fsm->master;

   235

   236

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   237

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

   238

        fsm->master_state = ec_fsm_error;

   239

        return;

   240

    }

   241

   242

    EC_INFO("Scanning bus.\n");

   243

   244

    ec_master_clear_slaves(master);

   245

   246

    master->slave_count = datagram->working_counter;

   247

   248

    if (!master->slave_count) {

   249

        // no slaves present -> finish state machine.

   250

        fsm->master_state = ec_fsm_end;

   251

        return;

   252

    }

   253

   254

    // init slaves

   255

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

   256

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

   257

                                             GFP_KERNEL))) {

   258

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

   259

            fsm->master_state = ec_fsm_error;

   260

            return;

   261

        }

   262

   263

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

   264

            fsm->master_state = ec_fsm_error;

   265

            return;

   266

        }

   267

   268

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

   269

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

   270

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

   271

            fsm->master_state = ec_fsm_error;

   272

            return;

   273

        }

   274

   275

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

   276

    }

   277

   278

    // begin scanning of slaves

   279

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

   280

    fsm->slave_state = ec_fsm_slavescan_start;

   281

    fsm->master_state = ec_fsm_startup_scan;

   282

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

   283

    return;

   284

}

   285

   286

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

   287

   288

/**

   289

   Master state: SCAN.

   290

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

   291

*/

   292

   293

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

   294

{

   295

    ec_master_t *master = fsm->master;

   296

    ec_slave_t *slave = fsm->slave;

   297

   298

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

   299

   300

    if (fsm->slave_state == ec_fsm_error) {

   301

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

   302

        fsm->master_state = ec_fsm_error;

   303

        return;

   304

    }

   305

   306

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

   307

   308

    // another slave to scan?

   309

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

   310

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

   311

        fsm->slave_state = ec_fsm_slavescan_start;

   312

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

   313

        return;

   314

    }

   315

   316

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

   317

   318

    ec_master_calc_addressing(master);

   319

   320

    fsm->master_state = ec_fsm_end;

   321

}

   322

   323

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

   324

 *  master configuration state machine

   325

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

   326

   327

/**

   328

   Master configuration state machine: START.

   329

*/

   330

   331

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

   332

{

   333

    ec_master_t *master = fsm->master;

   334

   335

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

   336

        fsm->master_state = ec_fsm_end;

   337

        return;

   338

    }

   339

   340

    // begin configuring slaves

   341

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

   342

    fsm->slave_state = ec_fsm_slaveconf_init;

   343

    ec_fsm_change(&fsm->fsm_change, fsm->slave, EC_SLAVE_STATE_INIT);

   344

    fsm->master_state = ec_fsm_configuration_conf;

   345

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

   346

}

   347

   348

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

   349

   350

/**

   351

   Master state: CONF.

   352

*/

   353

   354

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

   355

{

   356

    ec_master_t *master = fsm->master;

   357

    ec_slave_t *slave = fsm->slave;

   358

   359

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

   360

   361

    if (fsm->slave_state == ec_fsm_error) {

   362

        fsm->master_state = ec_fsm_error;

   363

        return;

   364

    }

   365

   366

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

   367

   368

    // another slave to configure?

   369

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

   370

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

   371

        fsm->slave_state = ec_fsm_slaveconf_init;

   372

        ec_fsm_change(&fsm->fsm_change, fsm->slave, EC_SLAVE_STATE_INIT);

   373

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

   374

        return;

   375

    }

   376

   377

    fsm->master_state = ec_fsm_end;

   378

}

   379

   380

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

   381

 *  operation / idle state machine

   382

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

   383

   384

/**

   385

   Master state: START.

   386

   Starts with getting slave count and slave states.

   387

*/

   388

   389

void ec_fsm_master_start(ec_fsm_t *fsm)

   390

{

   391

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

   392

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

   393

    fsm->master_state = ec_fsm_master_broadcast;

   394

}

   395

   396

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

   397

   398

/**

   399

   Master state: BROADCAST.

   400

   Processes the broadcast read slave count and slaves states.

   401

*/

   402

   403

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

   404

{

   405

    ec_datagram_t *datagram = &fsm->datagram;

   406

    unsigned int topology_change, states_change, i;

   407

    ec_slave_t *slave;

   408

    ec_master_t *master = fsm->master;

   409

   410

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   411

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

   412

            fsm->master_slaves_responding = 0;

   413

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

   414

                slave->online = 0;

   415

            }

   416

        }

   417

        fsm->master_state = ec_fsm_master_start;

   418

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

   419

        return;

   420

    }

   421

   422

    topology_change = (datagram->working_counter !=

   423

                       fsm->master_slaves_responding);

   424

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

   425

   426

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

   427

    fsm->master_slaves_responding = datagram->working_counter;

   428

   429

    if (topology_change) {

   430

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

   431

                fsm->master_slaves_responding,

   432

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

   433

   434

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   435

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

   436

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

   437

            }

   438

            else {

   439

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

   440

            }

   441

        }

   442

    }

   443

   444

    if (states_change) {

   445

        char states[EC_STATE_STRING_SIZE];

   446

        ec_state_string(fsm->master_slave_states, states);

   447

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

   448

    }

   449

   450

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

   451

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

   452

        EC_INFO("Scanning bus.\n");

   453

   454

        ec_master_eoe_stop(master);

   455

        ec_master_clear_slaves(master);

   456

   457

        master->slave_count = datagram->working_counter;

   458

   459

        if (!master->slave_count) {

   460

            // no slaves present -> finish state machine.

   461

            fsm->master_state = ec_fsm_master_start;

   462

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

   463

            return;

   464

        }

   465

   466

        // init slaves

   467

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

   468

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

   469

                                                 GFP_ATOMIC))) {

   470

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

   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 (ec_slave_init(slave, master, i, i + 1)) {

   478

                // freeing of "slave" already done

   479

                ec_master_clear_slaves(master);

   480

                fsm->master_state = ec_fsm_master_start;

   481

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

   482

                return;

   483

            }

   484

   485

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

   486

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

   487

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

   488

                ec_master_clear_slaves(master);

   489

                fsm->master_state = ec_fsm_master_start;

   490

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

   491

                return;

   492

            }

   493

   494

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

   495