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

    58

void ec_fsm_startup_start(ec_fsm_t *);

    59

void ec_fsm_startup_broadcast(ec_fsm_t *);

    60

void ec_fsm_startup_scan(ec_fsm_t *);

    61

    62

void ec_fsm_configuration_start(ec_fsm_t *);

    63

void ec_fsm_configuration_conf(ec_fsm_t *);

    64

    65

void ec_fsm_slavescan_start(ec_fsm_t *);

    66

void ec_fsm_slavescan_address(ec_fsm_t *);

    67

void ec_fsm_slavescan_state(ec_fsm_t *);

    68

void ec_fsm_slavescan_base(ec_fsm_t *);

    69

void ec_fsm_slavescan_datalink(ec_fsm_t *);

    70

void ec_fsm_slavescan_eeprom_size(ec_fsm_t *);

    71

void ec_fsm_slavescan_eeprom_data(ec_fsm_t *);

    72

    73

void ec_fsm_slaveconf_init(ec_fsm_t *);

    74

void ec_fsm_slaveconf_sync(ec_fsm_t *);

    75

void ec_fsm_slaveconf_preop(ec_fsm_t *);

    76

void ec_fsm_slaveconf_fmmu(ec_fsm_t *);

    77

void ec_fsm_slaveconf_sdoconf(ec_fsm_t *);

    78

void ec_fsm_slaveconf_saveop(ec_fsm_t *);

    79

void ec_fsm_slaveconf_op(ec_fsm_t *);

    80

    81

void ec_fsm_sii_start_reading(ec_fsm_t *);

    82

void ec_fsm_sii_read_check(ec_fsm_t *);

    83

void ec_fsm_sii_read_fetch(ec_fsm_t *);

    84

void ec_fsm_sii_start_writing(ec_fsm_t *);

    85

void ec_fsm_sii_write_check(ec_fsm_t *);

    86

void ec_fsm_sii_write_check2(ec_fsm_t *);

    87

    88

void ec_fsm_change_start(ec_fsm_t *);

    89

void ec_fsm_change_check(ec_fsm_t *);

    90

void ec_fsm_change_status(ec_fsm_t *);

    91

void ec_fsm_change_code(ec_fsm_t *);

    92

void ec_fsm_change_ack(ec_fsm_t *);

    93

void ec_fsm_change_check_ack(ec_fsm_t *);

    94

    95

void ec_fsm_coe_down_start(ec_fsm_t *);

    96

void ec_fsm_coe_down_request(ec_fsm_t *);

    97

void ec_fsm_coe_down_check(ec_fsm_t *);

    98

void ec_fsm_coe_down_fetch(ec_fsm_t *);

    99

   100

void ec_fsm_end(ec_fsm_t *);

   101

void ec_fsm_error(ec_fsm_t *);

   102

   103

void ec_canopen_abort_msg(uint32_t);

   104

   105

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

   106

   107

/**

   108

   Constructor.

   109

*/

   110

   111

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

   112

                ec_master_t *master /**< EtherCAT master */

   113

                )

   114

{

   115

    fsm->master = master;

   116

    fsm->master_state = ec_fsm_master_start;

   117

    fsm->master_slaves_responding = 0;

   118

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   119

    fsm->master_validation = 0;

   120

   121

    ec_datagram_init(&fsm->datagram);

   122

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

   123

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

   124

        return -1;

   125

    }

   126

   127

    return 0;

   128

}

   129

   130

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

   131

   132

/**

   133

   Destructor.

   134

*/

   135

   136

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

   137

{

   138

    ec_datagram_clear(&fsm->datagram);

   139

}

   140

   141

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

   142

   143

/**

   144

   Resets the state machine.

   145

*/

   146

   147

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

   148

{

   149

    fsm->master_state = ec_fsm_master_start;

   150

    fsm->master_slaves_responding = 0;

   151

    fsm->master_slave_states = EC_SLAVE_STATE_UNKNOWN;

   152

}

   153

   154

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

   155

   156

/**

   157

   Executes the current state of the state machine.

   158

*/

   159

   160

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

   161

{

   162

    fsm->master_state(fsm);

   163

}

   164

   165

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

   166

   167

void ec_fsm_startup(ec_fsm_t *fsm)

   168

{

   169

    fsm->master_state = ec_fsm_startup_start;

   170

}

   171

   172

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

   173

   174

int ec_fsm_startup_running(ec_fsm_t *fsm)

   175

{

   176

    return fsm->master_state != ec_fsm_end &&

   177

        fsm->master_state != ec_fsm_error;

   178

}

   179

   180

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

   181

   182

int ec_fsm_startup_success(ec_fsm_t *fsm)

   183

{

   184

    return fsm->master_state == ec_fsm_end;

   185

}

   186

   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

int ec_fsm_configuration_running(ec_fsm_t *fsm)

   197

{

   198

    return fsm->master_state != ec_fsm_end &&

   199

        fsm->master_state != ec_fsm_error;

   200

}

   201

   202

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

   203

   204

int ec_fsm_configuration_success(ec_fsm_t *fsm)

   205

{

   206

    return fsm->master_state == ec_fsm_end;

   207

}

   208

   209

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

   210

 *  master startup state machine

   211

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

   212

   213

/**

   214

   Master state: START.

   215

   Starts with getting slave count and slave states.

   216

*/

   217

   218

void ec_fsm_startup_start(ec_fsm_t *fsm)

   219

{

   220

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

   221

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

   222

    fsm->master_state = ec_fsm_startup_broadcast;

   223

}

   224

   225

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

   226

   227

/**

   228

   Master state: BROADCAST.

   229

   Processes the broadcast read slave count and slaves states.

   230

*/

   231

   232

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

   233

{

   234

    ec_datagram_t *datagram = &fsm->datagram;

   235

    unsigned int i;

   236

    ec_slave_t *slave;

   237

    ec_master_t *master = fsm->master;

   238

   239

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   240

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

   241

        fsm->master_state = ec_fsm_error;

   242

        return;

   243

    }

   244

   245

    EC_INFO("Scanning bus.\n");

   246

   247

    ec_master_clear_slaves(master);

   248

   249

    master->slave_count = datagram->working_counter;

   250

   251

    if (!master->slave_count) {

   252

        // no slaves present -> finish state machine.

   253

        fsm->master_state = ec_fsm_end;

   254

        return;

   255

    }

   256

   257

    // init slaves

   258

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

   259

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

   260

                                             GFP_KERNEL))) {

   261

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

   262

            fsm->master_state = ec_fsm_error;

   263

            return;

   264

        }

   265

   266

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

   267

            fsm->master_state = ec_fsm_error;

   268

            return;

   269

        }

   270

   271

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

   272

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

   273

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

   274

            fsm->master_state = ec_fsm_error;

   275

            return;

   276

        }

   277

   278

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

   279

    }

   280

   281

    // begin scanning of slaves

   282

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

   283

    fsm->slave_state = ec_fsm_slavescan_start;

   284

    fsm->master_state = ec_fsm_startup_scan;

   285

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

   286

    return;

   287

}

   288

   289

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

   290

   291

/**

   292

   Master state: SCAN.

   293

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

   294

*/

   295

   296

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

   297

{

   298

    ec_master_t *master = fsm->master;

   299

    ec_slave_t *slave = fsm->slave;

   300

   301

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

   302

   303

    if (fsm->slave_state == ec_fsm_error) {

   304

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

   305

        fsm->master_state = ec_fsm_error;

   306

        return;

   307

    }

   308

   309

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

   310

   311

    // another slave to scan?

   312

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

   313

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

   314

        fsm->slave_state = ec_fsm_slavescan_start;

   315

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

   316

        return;

   317

    }

   318

   319

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

   320

   321

    ec_master_calc_addressing(master);

   322

   323

    fsm->master_state = ec_fsm_end;

   324

}

   325

   326

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

   327

 *  master configuration state machine

   328

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

   329

   330

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

   331

{

   332

    ec_master_t *master = fsm->master;

   333

   334

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

   335

        fsm->master_state = ec_fsm_end;

   336

        return;

   337

    }

   338

   339

    // begin configuring slaves

   340

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

   341

    fsm->slave_state = ec_fsm_slaveconf_init;

   342

    fsm->change_new = EC_SLAVE_STATE_INIT;

   343

    fsm->change_state = ec_fsm_change_start;

   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

        fsm->change_new = EC_SLAVE_STATE_INIT;

   373

        fsm->change_state = ec_fsm_change_start;

   374

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

   375

        return;

   376

    }

   377

   378

    fsm->master_state = ec_fsm_end;

   379

}

   380

   381

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

   382

 *  operation / idle state machine

   383

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

   384

   385

/**

   386

   Master state: START.

   387

   Starts with getting slave count and slave states.

   388

*/

   389

   390

void ec_fsm_master_start(ec_fsm_t *fsm)

   391

{

   392

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

   393

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

   394

    fsm->master_state = ec_fsm_master_broadcast;

   395

}

   396

   397

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

   398

   399

/**

   400

   Master state: BROADCAST.

   401

   Processes the broadcast read slave count and slaves states.

   402

*/

   403

   404

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

   405

{

   406

    ec_datagram_t *datagram = &fsm->datagram;

   407

    unsigned int topology_change, states_change, i;

   408

    ec_slave_t *slave;

   409

    ec_master_t *master = fsm->master;

   410

   411

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   412

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

   413

            fsm->master_slaves_responding = 0;

   414

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

   415

                slave->online = 0;

   416

            }

   417

        }

   418

        fsm->master_state = ec_fsm_master_start;

   419

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

   420

        return;

   421

    }

   422

   423

    topology_change = (datagram->working_counter !=

   424

                       fsm->master_slaves_responding);

   425

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

   426

   427

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

   428

    fsm->master_slaves_responding = datagram->working_counter;

   429

   430

    if (topology_change) {

   431

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

   432

                fsm->master_slaves_responding,

   433

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

   434

   435

        if (master->mode == EC_MASTER_MODE_OPERATION) {

   436

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

   437

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

   438

            }

   439

            else {

   440

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

   441

            }

   442

        }

   443

    }

   444

   445

    if (states_change) {

   446

        char states[25];

   447

        ec_state_string(fsm->master_slave_states, states);

   448

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

   449

    }

   450

   451

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

   452

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

   453

        EC_INFO("Scanning bus.\n");

   454

   455

        ec_master_eoe_stop(master);

   456

        ec_master_clear_slaves(master);

   457

   458

        master->slave_count = datagram->working_counter;

   459

   460

        if (!master->slave_count) {

   461

            // no slaves present -> finish state machine.

   462

            fsm->master_state = ec_fsm_master_start;

   463

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

   464

            return;

   465

        }

   466

   467

        // init slaves

   468

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

   469

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

   470

                                                 GFP_ATOMIC))) {

   471

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

   472

                ec_master_clear_slaves(master);

   473

                fsm->master_state = ec_fsm_master_start;

   474

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

   475

                return;

   476

            }

   477

   478

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

   479

                // freeing of "slave" already done

   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

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

   487

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

   488

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

   489

                ec_master_clear_slaves(master);

   490

                fsm->master_state = ec_fsm_master_start;

   491

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

   492

                return;

   493

            }

   494

   495

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

   496

        }