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

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

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

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/** \file

    31

 *

    32

 * EtherCAT slave configuration state machine.

    33

 */

    34

    35

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

    36

    37

#include <asm/div64.h>

    38

    39

#include "globals.h"

    40

#include "master.h"

    41

#include "mailbox.h"

    42

#include "slave_config.h"

    43

#include "fsm_slave_config.h"

    44

    45

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

    46

    47

/** Maximum clock difference (in ns) before going to SAFEOP.

    48

 *

    49

 * Wait for DC time difference to drop under this absolute value before

    50

 * requesting SAFEOP.

    51

 */

    52

#define EC_DC_MAX_SYNC_DIFF_NS 10000

    53

    54

/** Maximum time (in ms) to wait for clock discipline.

    55

 */

    56

#define EC_DC_SYNC_WAIT_MS 5000

    57

    58

/** Time offset (in ns), that is added to cyclic start time.

    59

 */

    60

#define EC_DC_START_OFFSET 100000000ULL

    61

    62

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

    63

    64

void ec_fsm_slave_config_state_start(ec_fsm_slave_config_t *);

    65

void ec_fsm_slave_config_state_init(ec_fsm_slave_config_t *);

    66

void ec_fsm_slave_config_state_clear_fmmus(ec_fsm_slave_config_t *);

    67

void ec_fsm_slave_config_state_clear_sync(ec_fsm_slave_config_t *);

    68

void ec_fsm_slave_config_state_dc_clear_assign(ec_fsm_slave_config_t *);

    69

void ec_fsm_slave_config_state_mbox_sync(ec_fsm_slave_config_t *);

    70

void ec_fsm_slave_config_state_boot_preop(ec_fsm_slave_config_t *);

    71

void ec_fsm_slave_config_state_sdo_conf(ec_fsm_slave_config_t *);

    72

void ec_fsm_slave_config_state_soe_conf_preop(ec_fsm_slave_config_t *);

    73

void ec_fsm_slave_config_state_watchdog_divider(ec_fsm_slave_config_t *);

    74

void ec_fsm_slave_config_state_watchdog(ec_fsm_slave_config_t *);

    75

void ec_fsm_slave_config_state_pdo_sync(ec_fsm_slave_config_t *);

    76

void ec_fsm_slave_config_state_pdo_conf(ec_fsm_slave_config_t *);

    77

void ec_fsm_slave_config_state_fmmu(ec_fsm_slave_config_t *);

    78

void ec_fsm_slave_config_state_dc_cycle(ec_fsm_slave_config_t *);

    79

void ec_fsm_slave_config_state_dc_sync_check(ec_fsm_slave_config_t *);

    80

void ec_fsm_slave_config_state_dc_start(ec_fsm_slave_config_t *);

    81

void ec_fsm_slave_config_state_dc_assign(ec_fsm_slave_config_t *);

    82

void ec_fsm_slave_config_state_safeop(ec_fsm_slave_config_t *);

    83

void ec_fsm_slave_config_state_soe_conf_safeop(ec_fsm_slave_config_t *);

    84

void ec_fsm_slave_config_state_op(ec_fsm_slave_config_t *);

    85

    86

void ec_fsm_slave_config_enter_init(ec_fsm_slave_config_t *);

    87

void ec_fsm_slave_config_enter_clear_sync(ec_fsm_slave_config_t *);

    88

void ec_fsm_slave_config_enter_dc_clear_assign(ec_fsm_slave_config_t *);

    89

void ec_fsm_slave_config_enter_mbox_sync(ec_fsm_slave_config_t *);

    90

void ec_fsm_slave_config_enter_boot_preop(ec_fsm_slave_config_t *);

    91

void ec_fsm_slave_config_enter_sdo_conf(ec_fsm_slave_config_t *);

    92

void ec_fsm_slave_config_enter_soe_conf_preop(ec_fsm_slave_config_t *);

    93

void ec_fsm_slave_config_enter_pdo_conf(ec_fsm_slave_config_t *);

    94

void ec_fsm_slave_config_enter_watchdog_divider(ec_fsm_slave_config_t *);

    95

void ec_fsm_slave_config_enter_watchdog(ec_fsm_slave_config_t *);

    96

void ec_fsm_slave_config_enter_pdo_sync(ec_fsm_slave_config_t *);

    97

void ec_fsm_slave_config_enter_fmmu(ec_fsm_slave_config_t *);

    98

void ec_fsm_slave_config_enter_dc_cycle(ec_fsm_slave_config_t *);

    99

void ec_fsm_slave_config_enter_safeop(ec_fsm_slave_config_t *);

   100

void ec_fsm_slave_config_enter_soe_conf_safeop(ec_fsm_slave_config_t *);

   101

void ec_fsm_slave_config_enter_op(ec_fsm_slave_config_t *);

   102

   103

void ec_fsm_slave_config_state_end(ec_fsm_slave_config_t *);

   104

void ec_fsm_slave_config_state_error(ec_fsm_slave_config_t *);

   105

   106

void ec_fsm_slave_config_reconfigure(ec_fsm_slave_config_t *);

   107

   108

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

   109

   110

/** Constructor.

   111

 */

   112

void ec_fsm_slave_config_init(

   113

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

   114

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

   115

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

   116

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

   117

        ec_fsm_soe_t *fsm_soe, /**< SoE state machine to use. */

   118

        ec_fsm_pdo_t *fsm_pdo /**< PDO configuration state machine to use. */

   119

        )

   120

{

   121

    ec_sdo_request_init(&fsm->request_copy);

   122

    ec_soe_request_init(&fsm->soe_request_copy);

   123

   124

    fsm->datagram = datagram;

   125

    fsm->fsm_change = fsm_change;

   126

    fsm->fsm_coe = fsm_coe;

   127

    fsm->fsm_soe = fsm_soe;

   128

    fsm->fsm_pdo = fsm_pdo;

   129

}

   130

   131

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

   132

   133

/** Destructor.

   134

 */

   135

void ec_fsm_slave_config_clear(

   136

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

   137

        )

   138

{

   139

    ec_sdo_request_clear(&fsm->request_copy);

   140

    ec_soe_request_clear(&fsm->soe_request_copy);

   141

}

   142

   143

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

   144

   145

/** Start slave configuration state machine.

   146

 */

   147

void ec_fsm_slave_config_start(

   148

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

   149

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

   150

        )

   151

{

   152

    fsm->slave = slave;

   153

    fsm->state = ec_fsm_slave_config_state_start;

   154

}

   155

   156

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

   157

   158

/**

   159

 * \return false, if state machine has terminated

   160

 */

   161

int ec_fsm_slave_config_running(

   162

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

   163

        )

   164

{

   165

    return fsm->state != ec_fsm_slave_config_state_end

   166

        && fsm->state != ec_fsm_slave_config_state_error;

   167

}

   168

   169

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

   170

   171

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

   172

 *

   173

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

   174

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

   175

 *

   176

 * \return false, if state machine has terminated

   177

 */

   178

int ec_fsm_slave_config_exec(

   179

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

   180

        )

   181

{

   182

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

   183

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

   184

        // datagram was not sent or received yet.

   185

        return ec_fsm_slave_config_running(fsm);

   186

    }

   187

   188

    fsm->state(fsm);

   189

    return ec_fsm_slave_config_running(fsm);

   190

}

   191

   192

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

   193

   194

/**

   195

 * \return true, if the state machine terminated gracefully

   196

 */

   197

int ec_fsm_slave_config_success(

   198

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

   199

        )

   200

{

   201

    return fsm->state == ec_fsm_slave_config_state_end;

   202

}

   203

   204

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

   205

 * Slave configuration state machine

   206

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

   207

   208

/** Slave configuration state: START.

   209

 */

   210

void ec_fsm_slave_config_state_start(

   211

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

   212

        )

   213

{

   214

    EC_SLAVE_DBG(fsm->slave, 1, "Configuring...\n");

   215

    ec_fsm_slave_config_enter_init(fsm);

   216

}

   217

   218

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

   219

   220

/** Start state change to INIT.

   221

 */

   222

void ec_fsm_slave_config_enter_init(

   223

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

   224

        )

   225

{

   226

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

   227

    ec_fsm_change_exec(fsm->fsm_change);

   228

    fsm->state = ec_fsm_slave_config_state_init;

   229

}

   230

   231

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

   232

   233

/** Slave configuration state: INIT.

   234

 */

   235

void ec_fsm_slave_config_state_init(

   236

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

   237

        )

   238

{

   239

    ec_slave_t *slave = fsm->slave;

   240

    ec_datagram_t *datagram = fsm->datagram;

   241

   242

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

   243

   244

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

   245

        if (!fsm->fsm_change->spontaneous_change)

   246

            slave->error_flag = 1;

   247

        fsm->state = ec_fsm_slave_config_state_error;

   248

        return;

   249

    }

   250

   251

    EC_SLAVE_DBG(slave, 1, "Now in INIT.\n");

   252

   253

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

   254

        ec_fsm_slave_config_enter_clear_sync(fsm);

   255

        return;

   256

    }

   257

   258

    EC_SLAVE_DBG(slave, 1, "Clearing FMMU configurations...\n");

   259

   260

    // clear FMMU configurations

   261

    ec_datagram_fpwr(datagram, slave->station_address,

   262

            0x0600, EC_FMMU_PAGE_SIZE * slave->base_fmmu_count);

   263

    ec_datagram_zero(datagram);

   264

    fsm->retries = EC_FSM_RETRIES;

   265

    fsm->state = ec_fsm_slave_config_state_clear_fmmus;

   266

}

   267

   268

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

   269

   270

/** Slave configuration state: CLEAR FMMU.

   271

 */

   272

void ec_fsm_slave_config_state_clear_fmmus(

   273

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

   274

        )

   275

{

   276

    ec_datagram_t *datagram = fsm->datagram;

   277

   278

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

   279

        return;

   280

   281

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   282

        fsm->state = ec_fsm_slave_config_state_error;

   283

        EC_SLAVE_ERR(fsm->slave, "Failed receive FMMU clearing datagram.\n");

   284

        return;

   285

    }

   286

   287

    if (datagram->working_counter != 1) {

   288

        fsm->slave->error_flag = 1;

   289

        fsm->state = ec_fsm_slave_config_state_error;

   290

        EC_SLAVE_ERR(fsm->slave, "Failed to clear FMMUs: ");

   291

        ec_datagram_print_wc_error(datagram);

   292

        return;

   293

    }

   294

   295

    ec_fsm_slave_config_enter_clear_sync(fsm);

   296

}

   297

   298

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

   299

   300

/** Clear the sync manager configurations.

   301

 */

   302

void ec_fsm_slave_config_enter_clear_sync(

   303

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

   304

        )

   305

{

   306

    ec_slave_t *slave = fsm->slave;

   307

    ec_datagram_t *datagram = fsm->datagram;

   308

    size_t sync_size;

   309

   310

    if (!slave->base_sync_count) {

   311

        // no sync managers

   312

        ec_fsm_slave_config_enter_dc_clear_assign(fsm);

   313

        return;

   314

    }

   315

   316

    EC_SLAVE_DBG(slave, 1, "Clearing sync manager configurations...\n");

   317

   318

    sync_size = EC_SYNC_PAGE_SIZE * slave->base_sync_count;

   319

   320

    // clear sync manager configurations

   321

    ec_datagram_fpwr(datagram, slave->station_address, 0x0800, sync_size);

   322

    ec_datagram_zero(datagram);

   323

    fsm->retries = EC_FSM_RETRIES;

   324

    fsm->state = ec_fsm_slave_config_state_clear_sync;

   325

}

   326

   327

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

   328

   329

/** Slave configuration state: CLEAR SYNC.

   330

 */

   331

void ec_fsm_slave_config_state_clear_sync(

   332

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

   333

        )

   334

{

   335

    ec_datagram_t *datagram = fsm->datagram;

   336

   337

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

   338

        return;

   339

   340

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   341

        fsm->state = ec_fsm_slave_config_state_error;

   342

        EC_SLAVE_ERR(fsm->slave, "Failed receive sync manager"

   343

                " clearing datagram.\n");

   344

        return;

   345

    }

   346

   347

    if (datagram->working_counter != 1) {

   348

        fsm->slave->error_flag = 1;

   349

        fsm->state = ec_fsm_slave_config_state_error;

   350

        EC_SLAVE_ERR(fsm->slave,

   351

                "Failed to clear sync manager configurations: ");

   352

        ec_datagram_print_wc_error(datagram);

   353

        return;

   354

    }

   355

   356

    ec_fsm_slave_config_enter_dc_clear_assign(fsm);

   357

}

   358

   359

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

   360

   361

/** Clear the DC assignment.

   362

 */

   363

void ec_fsm_slave_config_enter_dc_clear_assign(

   364

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

   365

        )

   366

{

   367

    ec_slave_t *slave = fsm->slave;

   368

    ec_datagram_t *datagram = fsm->datagram;

   369

   370

    if (!slave->base_dc_supported || !slave->has_dc_system_time) {

   371

        ec_fsm_slave_config_enter_mbox_sync(fsm);

   372

        return;

   373

    }

   374

   375

    EC_SLAVE_DBG(slave, 1, "Clearing DC assignment...\n");

   376

   377

    ec_datagram_fpwr(datagram, slave->station_address, 0x0980, 2);

   378

    ec_datagram_zero(datagram);

   379

    fsm->retries = EC_FSM_RETRIES;

   380

    fsm->state = ec_fsm_slave_config_state_dc_clear_assign;

   381

}

   382

   383

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

   384

   385

/** Slave configuration state: CLEAR DC ASSIGN.

   386

 */

   387

void ec_fsm_slave_config_state_dc_clear_assign(

   388

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

   389

        )

   390

{

   391

    ec_datagram_t *datagram = fsm->datagram;

   392

   393

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

   394

        return;

   395

   396

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   397

        fsm->state = ec_fsm_slave_config_state_error;

   398

        EC_SLAVE_ERR(fsm->slave, "Failed receive DC assignment"

   399

                " clearing datagram.\n");

   400

        return;

   401

    }

   402

   403

    if (datagram->working_counter != 1) {

   404

        // clearing the DC assignment does not succeed on simple slaves

   405

        EC_SLAVE_DBG(fsm->slave, 1, "Failed to clear DC assignment: ");

   406

        ec_datagram_print_wc_error(datagram);

   407

    }

   408

   409

    ec_fsm_slave_config_enter_mbox_sync(fsm);

   410

}

   411

   412

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

   413

   414

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

   415

 */

   416

void ec_fsm_slave_config_enter_mbox_sync(

   417

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

   418

        )

   419

{

   420

    ec_slave_t *slave = fsm->slave;

   421

    ec_datagram_t *datagram = fsm->datagram;

   422

    unsigned int i;

   423

   424

    // slave is now in INIT

   425

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

   426

        fsm->state = ec_fsm_slave_config_state_end; // successful

   427

        EC_SLAVE_DBG(slave, 1, "Finished configuration.\n");

   428

        return;

   429

    }

   430

   431

    if (!slave->sii.mailbox_protocols) {

   432

        // no mailbox protocols supported

   433

        EC_SLAVE_DBG(slave, 1, "Slave does not support"

   434

                " mailbox communication.\n");

   435

        ec_fsm_slave_config_enter_boot_preop(fsm);

   436

        return;

   437

    }

   438

   439

    EC_SLAVE_DBG(slave, 1, "Configuring mailbox sync managers...\n");

   440

   441

    if (slave->requested_state == EC_SLAVE_STATE_BOOT) {

   442

        ec_sync_t sync;

   443

   444

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

   445

                EC_SYNC_PAGE_SIZE * 2);

   446

        ec_datagram_zero(datagram);

   447

   448

        ec_sync_init(&sync, slave);

   449

        sync.physical_start_address = slave->sii.boot_rx_mailbox_offset;

   450

        sync.control_register = 0x26;

   451

        sync.enable = 1;

   452

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

   453

                EC_DIR_INVALID, // use default direction

   454

                0, // no PDO xfer

   455

                datagram->data);

   456

        slave->configured_rx_mailbox_offset =

   457

            slave->sii.boot_rx_mailbox_offset;

   458

        slave->configured_rx_mailbox_size =

   459

            slave->sii.boot_rx_mailbox_size;

   460

   461

        ec_sync_init(&sync, slave);

   462

        sync.physical_start_address = slave->sii.boot_tx_mailbox_offset;

   463

        sync.control_register = 0x22;

   464

        sync.enable = 1;

   465

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

   466

                EC_DIR_INVALID, // use default direction

   467

                0, // no PDO xfer

   468

                datagram->data + EC_SYNC_PAGE_SIZE);

   469

        slave->configured_tx_mailbox_offset =

   470

            slave->sii.boot_tx_mailbox_offset;

   471

        slave->configured_tx_mailbox_size =

   472

            slave->sii.boot_tx_mailbox_size;

   473

   474

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

   475

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

   476

                EC_SYNC_PAGE_SIZE * slave->sii.sync_count);

   477

        ec_datagram_zero(datagram);

   478

   479

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

   480

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

   481

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

   482

                    NULL, // use default sync manager configuration

   483

                    0, // no PDO xfer

   484

                    datagram->data + EC_SYNC_PAGE_SIZE * i);

   485

        }

   486

   487

        slave->configured_rx_mailbox_offset =

   488

            slave->sii.syncs[0].physical_start_address;

   489

        slave->configured_rx_mailbox_size =

   490

            slave->sii.syncs[0].default_length;

   491

        slave->configured_tx_mailbox_offset =

   492

            slave->sii.syncs[1].physical_start_address;

   493

        slave->configured_tx_mailbox_size =

   494

            slave->sii.syncs[1].default_length;

   495

    } else { // no mailbox sync manager configurations provided

   496

        ec_sync_t sync;

   497