1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  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 and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

/** \file

    28

 *

    29

 * EtherCAT slave configuration state machine.

    30

 */

    31

    32

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

    33

    34

#include "globals.h"

    35

#include "master.h"

    36

#include "mailbox.h"

    37

#include "slave_config.h"

    38

#include "fsm_slave_config.h"

    39

    40

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

    41

    42

void ec_fsm_slave_config_state_start(ec_fsm_slave_config_t *);

    43

void ec_fsm_slave_config_state_init(ec_fsm_slave_config_t *);

    44

void ec_fsm_slave_config_state_clear_fmmus(ec_fsm_slave_config_t *);

    45

void ec_fsm_slave_config_state_mbox_sync(ec_fsm_slave_config_t *);

    46

void ec_fsm_slave_config_state_preop(ec_fsm_slave_config_t *);

    47

void ec_fsm_slave_config_state_sdo_conf(ec_fsm_slave_config_t *);

    48

void ec_fsm_slave_config_state_pdo_sync(ec_fsm_slave_config_t *);

    49

void ec_fsm_slave_config_state_pdo_conf(ec_fsm_slave_config_t *);

    50

void ec_fsm_slave_config_state_fmmu(ec_fsm_slave_config_t *);

    51

void ec_fsm_slave_config_state_safeop(ec_fsm_slave_config_t *);

    52

void ec_fsm_slave_config_state_op(ec_fsm_slave_config_t *);

    53

    54

void ec_fsm_slave_config_enter_init(ec_fsm_slave_config_t *);

    55

void ec_fsm_slave_config_enter_mbox_sync(ec_fsm_slave_config_t *);

    56

void ec_fsm_slave_config_enter_preop(ec_fsm_slave_config_t *);

    57

void ec_fsm_slave_config_enter_sdo_conf(ec_fsm_slave_config_t *);

    58

void ec_fsm_slave_config_enter_pdo_conf(ec_fsm_slave_config_t *);

    59

void ec_fsm_slave_config_enter_pdo_sync(ec_fsm_slave_config_t *);

    60

void ec_fsm_slave_config_enter_fmmu(ec_fsm_slave_config_t *);

    61

void ec_fsm_slave_config_enter_safeop(ec_fsm_slave_config_t *);

    62

    63

void ec_fsm_slave_config_state_end(ec_fsm_slave_config_t *);

    64

void ec_fsm_slave_config_state_error(ec_fsm_slave_config_t *);

    65

    66

void ec_fsm_slave_config_reconfigure(ec_fsm_slave_config_t *);

    67

    68

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

    69

    70

/** Constructor.

    71

 */

    72

void ec_fsm_slave_config_init(

    73

        ec_fsm_slave_config_t *fsm, /**< slave state machine */

    74

        ec_datagram_t *datagram, /**< datagram structure to use */

    75

        ec_fsm_change_t *fsm_change, /**< State change state machine to use. */

    76

        ec_fsm_coe_t *fsm_coe, /**< CoE state machine to use. */

    78

        )

    79

{

    80

    ec_sdo_request_init(&fsm->request_copy);

    81

    82

    fsm->datagram = datagram;

    83

    fsm->fsm_change = fsm_change;

    84

    fsm->fsm_coe = fsm_coe;

    85

    fsm->fsm_pdo = fsm_pdo;

    86

}

    87

    88

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

    89

    90

/** Destructor.

    91

 */

    92

void ec_fsm_slave_config_clear(

    93

        ec_fsm_slave_config_t *fsm /**< slave state machine */

    94

        )

    95

{

    96

    ec_sdo_request_clear(&fsm->request_copy);

    97

}

    98

    99

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

   100

   101

/** Start slave configuration state machine.

   102

 */

   103

void ec_fsm_slave_config_start(

   104

        ec_fsm_slave_config_t *fsm, /**< slave state machine */

   105

        ec_slave_t *slave /**< slave to configure */

   106

        )

   107

{

   108

    fsm->slave = slave;

   109

    fsm->state = ec_fsm_slave_config_state_start;

   110

}

   111

   112

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

   113

   114

/**

   115

 * \return false, if state machine has terminated

   116

 */

   117

int ec_fsm_slave_config_running(

   118

        const ec_fsm_slave_config_t *fsm /**< slave state machine */

   119

        )

   120

{

   121

    return fsm->state != ec_fsm_slave_config_state_end

   122

        && fsm->state != ec_fsm_slave_config_state_error;

   123

}

   124

   125

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

   126

   127

/** Executes the current state of the state machine.

   128

 *

   129

 * If the state machine's datagram is not sent or received yet, the execution

   130

 * of the state machine is delayed to the next cycle.

   131

 *

   132

 * \return false, if state machine has terminated

   133

 */

   134

int ec_fsm_slave_config_exec(

   135

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   136

        )

   137

{

   138

    if (fsm->datagram->state == EC_DATAGRAM_SENT

   139

        || fsm->datagram->state == EC_DATAGRAM_QUEUED) {

   140

        // datagram was not sent or received yet.

   141

        return ec_fsm_slave_config_running(fsm);

   142

    }

   143

   144

    fsm->state(fsm);

   145

    return ec_fsm_slave_config_running(fsm);

   146

}

   147

   148

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

   149

   150

/**

   151

 * \return true, if the state machine terminated gracefully

   152

 */

   153

int ec_fsm_slave_config_success(

   154

        const ec_fsm_slave_config_t *fsm /**< slave state machine */

   155

        )

   156

{

   157

    return fsm->state == ec_fsm_slave_config_state_end;

   158

}

   159

   160

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

   161

 * Slave configuration state machine

   162

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

   163

   164

/** Slave configuration state: START.

   165

 */

   166

void ec_fsm_slave_config_state_start(

   167

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   168

        )

   169

{

   170

    if (fsm->slave->master->debug_level) {

   171

        EC_DBG("Configuring slave %u...\n", fsm->slave->ring_position);

   172

    }

   173

   174

    ec_fsm_slave_config_enter_init(fsm);

   175

}

   176

   177

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

   178

   179

/** Start state change to INIT.

   180

 */

   181

void ec_fsm_slave_config_enter_init(

   182

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   183

        )

   184

{

   185

    ec_fsm_change_start(fsm->fsm_change, fsm->slave, EC_SLAVE_STATE_INIT);

   186

    ec_fsm_change_exec(fsm->fsm_change);

   187

    fsm->state = ec_fsm_slave_config_state_init;

   188

}

   189

   190

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

   191

   192

/** Slave configuration state: INIT.

   193

 */

   194

void ec_fsm_slave_config_state_init(

   195

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   196

        )

   197

{

   198

    ec_master_t *master = fsm->slave->master;

   199

    ec_slave_t *slave = fsm->slave;

   200

    ec_datagram_t *datagram = fsm->datagram;

   201

   202

    if (ec_fsm_change_exec(fsm->fsm_change)) return;

   203

   204

    if (!ec_fsm_change_success(fsm->fsm_change)) {

   205

        if (!fsm->fsm_change->spontaneous_change)

   206

            slave->error_flag = 1;

   207

        fsm->state = ec_fsm_slave_config_state_error;

   208

        return;

   209

    }

   210

   211

    if (master->debug_level) {

   212

        EC_DBG("Slave %u is now in INIT.\n", slave->ring_position);

   213

    }

   214

   215

    if (!slave->base_fmmu_count) { // skip FMMU configuration

   216

        ec_fsm_slave_config_enter_mbox_sync(fsm);

   217

        return;

   218

    }

   219

   220

    if (master->debug_level)

   221

        EC_DBG("Clearing FMMU configurations of slave %u...\n",

   222

               slave->ring_position);

   223

   224

    // clear FMMU configurations

   225

    ec_datagram_fpwr(datagram, slave->station_address,

   226

            0x0600, EC_FMMU_PAGE_SIZE * slave->base_fmmu_count);

   227

    memset(datagram->data, 0x00, EC_FMMU_PAGE_SIZE * slave->base_fmmu_count);

   228

    fsm->retries = EC_FSM_RETRIES;

   229

    fsm->state = ec_fsm_slave_config_state_clear_fmmus;

   230

}

   231

   232

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

   233

   234

/** Slave configuration state: CLEAR FMMU.

   235

 */

   236

void ec_fsm_slave_config_state_clear_fmmus(

   237

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   238

        )

   239

{

   240

    ec_datagram_t *datagram = fsm->datagram;

   241

   242

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)

   243

        return;

   244

   245

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   246

        fsm->state = ec_fsm_slave_config_state_error;

   247

        EC_ERR("Failed receive FMMU clearing datagram for slave %u.\n",

   248

               fsm->slave->ring_position);

   249

        return;

   250

    }

   251

   252

    if (datagram->working_counter != 1) {

   253

        fsm->slave->error_flag = 1;

   254

        fsm->state = ec_fsm_slave_config_state_error;

   255

        EC_ERR("Failed to clear FMMUs of slave %u: ",

   256

               fsm->slave->ring_position);

   257

        ec_datagram_print_wc_error(datagram);

   258

        return;

   259

    }

   260

   261

    ec_fsm_slave_config_enter_mbox_sync(fsm);

   262

}

   263

   264

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

   265

   266

/** Check for mailbox sync managers to be configured.

   267

 */

   268

void ec_fsm_slave_config_enter_mbox_sync(

   269

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   270

        )

   271

{

   272

    ec_master_t *master = fsm->slave->master;

   273

    ec_slave_t *slave = fsm->slave;

   274

    ec_datagram_t *datagram = fsm->datagram;

   275

    unsigned int i;

   276

   277

    // slave is now in INIT

   278

    if (slave->current_state == slave->requested_state) {

   279

        fsm->state = ec_fsm_slave_config_state_end; // successful

   280

        if (master->debug_level) {

   281

            EC_DBG("Finished configuration of slave %u.\n",

   282

                   slave->ring_position);

   283

        }

   284

        return;

   285

    }

   286

   287

    if (!slave->sii.mailbox_protocols) {

   288

        // no mailbox protocols supported

   289

        if (master->debug_level)

   290

            EC_DBG("Slave %u does not support mailbox communication.\n",

   291

                    slave->ring_position);

   292

        ec_fsm_slave_config_enter_preop(fsm);

   293

        return;

   294

    }

   295

   296

    if (master->debug_level) {

   297

        EC_DBG("Configuring mailbox sync managers of slave %u.\n",

   298

               slave->ring_position);

   299

    }

   300

   301

    if (slave->sii.sync_count >= 2) { // mailbox configuration provided

   302

        ec_datagram_fpwr(datagram, slave->station_address, 0x0800,

   303

                EC_SYNC_PAGE_SIZE * slave->sii.sync_count);

   304

        memset(datagram->data, 0x00,

   305

                EC_SYNC_PAGE_SIZE * slave->sii.sync_count);

   306

   307

        for (i = 0; i < 2; i++) {

   308

            ec_sync_page(&slave->sii.syncs[i], i,

   309

                    slave->sii.syncs[i].default_length,

   310

                    EC_DIR_INVALID, // use default direction

   311

                    datagram->data + EC_SYNC_PAGE_SIZE * i);

   312

        }

   313

    } else { // no mailbox sync manager configurations provided

   314

        ec_sync_t sync;

   315

   316

        if (master->debug_level)

   317

            EC_DBG("Slave %u does not provide"

   318

                    " mailbox sync manager configurations.\n",

   319

                    slave->ring_position);

   320

   321

        ec_datagram_fpwr(datagram, slave->station_address, 0x0800,

   322

                EC_SYNC_PAGE_SIZE * 2);

   323

        memset(datagram->data, 0x00, EC_SYNC_PAGE_SIZE * 2);

   324

   325

        ec_sync_init(&sync, slave);

   326

        sync.physical_start_address = slave->sii.rx_mailbox_offset;

   327

        sync.control_register = 0x26;

   328

        sync.enable = 1;

   329

        ec_sync_page(&sync, 0, slave->sii.rx_mailbox_size,

   330

                EC_DIR_INVALID, // use default direction

   331

                datagram->data);

   332

   333

        ec_sync_init(&sync, slave);

   334

        sync.physical_start_address = slave->sii.tx_mailbox_offset;

   335

        sync.control_register = 0x22;

   336

        sync.enable = 1;

   337

        ec_sync_page(&sync, 1, slave->sii.tx_mailbox_size,

   338

                EC_DIR_INVALID, // use default direction

   339

                datagram->data + EC_SYNC_PAGE_SIZE);

   340

    }

   341

   342

    fsm->retries = EC_FSM_RETRIES;

   343

    fsm->state = ec_fsm_slave_config_state_mbox_sync;

   344

}

   345

   346

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

   347

   348

/** Slave configuration state: SYNC.

   349

 */

   350

void ec_fsm_slave_config_state_mbox_sync(

   351

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   352

        )

   353

{

   354

    ec_datagram_t *datagram = fsm->datagram;

   355

    ec_slave_t *slave = fsm->slave;

   356

   357

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)

   358

        return;

   359

   360

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   361

        fsm->state = ec_fsm_slave_config_state_error;

   362

        EC_ERR("Failed to receive sync manager configuration datagram for"

   363

               " slave %u (datagram state %u).\n",

   364

               slave->ring_position, datagram->state);

   365

        return;

   366

    }

   367

   368

    if (datagram->working_counter != 1) {

   369

        slave->error_flag = 1;

   370

        fsm->state = ec_fsm_slave_config_state_error;

   371

        EC_ERR("Failed to set sync managers of slave %u: ",

   372

               slave->ring_position);

   373

        ec_datagram_print_wc_error(datagram);

   374

        return;

   375

    }

   376

   377

    ec_fsm_slave_config_enter_preop(fsm);

   378

}

   379

   380

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

   381

   382

/** Request PREOP state.

   383

 */

   384

void ec_fsm_slave_config_enter_preop(

   385

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   386

        )

   387

{

   388

    fsm->state = ec_fsm_slave_config_state_preop;

   389

    ec_fsm_change_start(fsm->fsm_change, fsm->slave, EC_SLAVE_STATE_PREOP);

   390

    ec_fsm_change_exec(fsm->fsm_change); // execute immediately

   391

}

   392

   393

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

   394

   395

/** Slave configuration state: PREOP.

   396

 */

   397

void ec_fsm_slave_config_state_preop(

   398

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   399

        )

   400

{

   401

    ec_slave_t *slave = fsm->slave;

   402

    ec_master_t *master = fsm->slave->master;

   403

   404

    if (ec_fsm_change_exec(fsm->fsm_change)) return;

   405

   406

    if (!ec_fsm_change_success(fsm->fsm_change)) {

   407

        if (!fsm->fsm_change->spontaneous_change)

   408

            slave->error_flag = 1;

   409

        fsm->state = ec_fsm_slave_config_state_error;

   410

        return;

   411

    }

   412

   413

    // slave is now in PREOP

   414

    slave->jiffies_preop = fsm->datagram->jiffies_received;

   415

   416

    if (master->debug_level) {

   417

        EC_DBG("Slave %u is now in PREOP.\n", slave->ring_position);

   418

    }

   419

   420

    if (slave->current_state == slave->requested_state) {

   421

        fsm->state = ec_fsm_slave_config_state_end; // successful

   422

        if (master->debug_level) {

   423

            EC_DBG("Finished configuration of slave %u.\n",

   424

                   slave->ring_position);

   425

        }

   426

        return;

   427

    }

   428

   429

    if (!slave->config) {

   430

        EC_DBG("Slave %u is not configured.\n", slave->ring_position);

   431

        ec_fsm_slave_config_enter_safeop(fsm);

   432

        return;

   433

    }

   434

   435

    ec_fsm_slave_config_enter_sdo_conf(fsm);

   436

}

   437

   438

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

   439

   441

 */

   442

void ec_fsm_slave_config_enter_sdo_conf(

   443

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   444

        )

   445

{

   446

    ec_slave_t *slave = fsm->slave;

   447

   448

    // No CoE configuration to be applied?

   450

        ec_fsm_slave_config_enter_pdo_conf(fsm);

   451

        return;

   452

    }

   453

   455

    fsm->state = ec_fsm_slave_config_state_sdo_conf;

   456

    fsm->request = list_entry(fsm->slave->config->sdo_configs.next,

   457

            ec_sdo_request_t, list);

   458

    ec_sdo_request_copy(&fsm->request_copy, fsm->request);

   459

    ecrt_sdo_request_write(&fsm->request_copy);

   460

    ec_fsm_coe_transfer(fsm->fsm_coe, fsm->slave, &fsm->request_copy);

   461

    ec_fsm_coe_exec(fsm->fsm_coe); // execute immediately

   462

}

   463

   464

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

   465

   466

/** Slave configuration state: SDO_CONF.

   467

 */

   468

void ec_fsm_slave_config_state_sdo_conf(

   469

        ec_fsm_slave_config_t *fsm /**< slave state machine */

   470

        )

   471

{

   472

    if (ec_fsm_coe_exec(fsm->fsm_coe)) return;

   473

   474

    if (!ec_fsm_coe_success(fsm->fsm_coe)) {

   476

                fsm->slave->ring_position);

   477

        fsm->slave->error_flag = 1;

   478

        fsm->state = ec_fsm_slave_config_state_error;

   479

        return;

   480

    }

   481

   482

    if (!fsm->slave->config) { // config removed in the meantime

   483

        ec_fsm_slave_config_reconfigure(fsm);

   484

        return;

   485

    }

   486

   488

    if (fsm->request->list.next != &fsm->slave->config->sdo_configs) {

   489

        fsm->request = list_entry(fsm->request->list.next,

   490

                ec_sdo_request_t, list);

   491

        ec_sdo_request_copy(&fsm->request_copy, fsm->request);

   492

        ecrt_sdo_request_write(&fsm->request_copy);

   493

        ec_fsm_coe_transfer(fsm->fsm_coe, fsm->slave, &fsm->request_copy);

   494

        ec_fsm_coe_exec(fsm->fsm_coe); // execute immediately

   495

        return;

   496

    }

   497

   499

    ec_fsm_slave_config_enter_pdo_conf(fsm);

   500

}

   501

   502

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

   503

   504

/** PDO_CONF entry function.

   505

 */

   506

void ec_fsm_slave_config_enter_pdo_conf(

   507

        ec_fsm_slave_config_t *fsm /**< slave state machine */