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

/** Time difference [ns] to tolerate without setting a new system time offset.

    48

 */

    49

#define EC_SYSTEM_TIME_TOLERANCE_NS 100000000

    50

    51

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

    52

    53

void ec_fsm_slave_config_state_start(ec_fsm_slave_config_t *);

    54

void ec_fsm_slave_config_state_init(ec_fsm_slave_config_t *);

    55

void ec_fsm_slave_config_state_clear_fmmus(ec_fsm_slave_config_t *);

    56

void ec_fsm_slave_config_state_clear_sync(ec_fsm_slave_config_t *);

    57

void ec_fsm_slave_config_state_dc_clear_assign(ec_fsm_slave_config_t *);

    58

void ec_fsm_slave_config_state_dc_read_offset(ec_fsm_slave_config_t *);

    59

void ec_fsm_slave_config_state_dc_write_offset(ec_fsm_slave_config_t *);

    60

void ec_fsm_slave_config_state_mbox_sync(ec_fsm_slave_config_t *);

    61

void ec_fsm_slave_config_state_boot_preop(ec_fsm_slave_config_t *);

    62

void ec_fsm_slave_config_state_sdo_conf(ec_fsm_slave_config_t *);

    63

void ec_fsm_slave_config_state_soe_conf(ec_fsm_slave_config_t *);

    64

void ec_fsm_slave_config_state_watchdog_divider(ec_fsm_slave_config_t *);

    65

void ec_fsm_slave_config_state_watchdog(ec_fsm_slave_config_t *);

    66

void ec_fsm_slave_config_state_pdo_sync(ec_fsm_slave_config_t *);

    67

void ec_fsm_slave_config_state_pdo_conf(ec_fsm_slave_config_t *);

    68

void ec_fsm_slave_config_state_fmmu(ec_fsm_slave_config_t *);

    69

void ec_fsm_slave_config_state_dc_cycle(ec_fsm_slave_config_t *);

    70

void ec_fsm_slave_config_state_dc_start(ec_fsm_slave_config_t *);

    71

void ec_fsm_slave_config_state_dc_assign(ec_fsm_slave_config_t *);

    72

void ec_fsm_slave_config_state_safeop(ec_fsm_slave_config_t *);

    73

void ec_fsm_slave_config_state_op(ec_fsm_slave_config_t *);

    74

    75

void ec_fsm_slave_config_enter_init(ec_fsm_slave_config_t *);

    76

void ec_fsm_slave_config_enter_clear_sync(ec_fsm_slave_config_t *);

    77

void ec_fsm_slave_config_enter_dc_clear_assign(ec_fsm_slave_config_t *);

    78

void ec_fsm_slave_config_enter_mbox_sync(ec_fsm_slave_config_t *);

    79

void ec_fsm_slave_config_enter_boot_preop(ec_fsm_slave_config_t *);

    80

void ec_fsm_slave_config_enter_sdo_conf(ec_fsm_slave_config_t *);

    81

void ec_fsm_slave_config_enter_soe_conf(ec_fsm_slave_config_t *);

    82

void ec_fsm_slave_config_enter_pdo_conf(ec_fsm_slave_config_t *);

    83

void ec_fsm_slave_config_enter_watchdog_divider(ec_fsm_slave_config_t *);

    84

void ec_fsm_slave_config_enter_watchdog(ec_fsm_slave_config_t *);

    85

void ec_fsm_slave_config_enter_pdo_sync(ec_fsm_slave_config_t *);

    86

void ec_fsm_slave_config_enter_fmmu(ec_fsm_slave_config_t *);

    87

void ec_fsm_slave_config_enter_dc_cycle(ec_fsm_slave_config_t *);

    88

void ec_fsm_slave_config_enter_safeop(ec_fsm_slave_config_t *);

    89

    90

void ec_fsm_slave_config_state_end(ec_fsm_slave_config_t *);

    91

void ec_fsm_slave_config_state_error(ec_fsm_slave_config_t *);

    92

    93

void ec_fsm_slave_config_reconfigure(ec_fsm_slave_config_t *);

    94

    95

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

    96

    97

/** Constructor.

    98

 */

    99

void ec_fsm_slave_config_init(

   100

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

   101

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

   102

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

   103

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

   104

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

   105

        )

   106

{

   107

    ec_sdo_request_init(&fsm->request_copy);

   108

    ec_soe_request_init(&fsm->soe_request_copy);

   109

   110

    fsm->datagram = datagram;

   111

    fsm->fsm_change = fsm_change;

   112

    fsm->fsm_coe = fsm_coe;

   113

    fsm->fsm_pdo = fsm_pdo;

   114

}

   115

   116

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

   117

   118

/** Destructor.

   119

 */

   120

void ec_fsm_slave_config_clear(

   121

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

   122

        )

   123

{

   124

    ec_sdo_request_clear(&fsm->request_copy);

   125

    ec_soe_request_clear(&fsm->soe_request_copy);

   126

}

   127

   128

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

   129

   130

/** Start slave configuration state machine.

   131

 */

   132

void ec_fsm_slave_config_start(

   133

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

   134

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

   135

        )

   136

{

   137

    fsm->slave = slave;

   138

    fsm->state = ec_fsm_slave_config_state_start;

   139

}

   140

   141

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

   142

   143

/**

   144

 * \return false, if state machine has terminated

   145

 */

   146

int ec_fsm_slave_config_running(

   147

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

   148

        )

   149

{

   150

    return fsm->state != ec_fsm_slave_config_state_end

   151

        && fsm->state != ec_fsm_slave_config_state_error;

   152

}

   153

   154

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

   155

   156

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

   157

 *

   158

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

   159

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

   160

 *

   161

 * \return false, if state machine has terminated

   162

 */

   163

int ec_fsm_slave_config_exec(

   164

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

   165

        )

   166

{

   167

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

   168

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

   169

        // datagram was not sent or received yet.

   170

        return ec_fsm_slave_config_running(fsm);

   171

    }

   172

   173

    fsm->state(fsm);

   174

    return ec_fsm_slave_config_running(fsm);

   175

}

   176

   177

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

   178

   179

/**

   180

 * \return true, if the state machine terminated gracefully

   181

 */

   182

int ec_fsm_slave_config_success(

   183

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

   184

        )

   185

{

   186

    return fsm->state == ec_fsm_slave_config_state_end;

   187

}

   188

   189

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

   190

 * Slave configuration state machine

   191

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

   192

   193

/** Slave configuration state: START.

   194

 */

   195

void ec_fsm_slave_config_state_start(

   196

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

   197

        )

   198

{

   199

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

   200

    ec_fsm_slave_config_enter_init(fsm);

   201

}

   202

   203

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

   204

   205

/** Start state change to INIT.

   206

 */

   207

void ec_fsm_slave_config_enter_init(

   208

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

   209

        )

   210

{

   211

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

   212

    ec_fsm_change_exec(fsm->fsm_change);

   213

    fsm->state = ec_fsm_slave_config_state_init;

   214

}

   215

   216

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

   217

   218

/** Slave configuration state: INIT.

   219

 */

   220

void ec_fsm_slave_config_state_init(

   221

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

   222

        )

   223

{

   224

    ec_slave_t *slave = fsm->slave;

   225

    ec_datagram_t *datagram = fsm->datagram;

   226

   227

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

   228

   229

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

   230

        if (!fsm->fsm_change->spontaneous_change)

   231

            slave->error_flag = 1;

   232

        fsm->state = ec_fsm_slave_config_state_error;

   233

        return;

   234

    }

   235

   236

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

   237

   238

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

   239

        ec_fsm_slave_config_enter_clear_sync(fsm);

   240

        return;

   241

    }

   242

   243

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

   244

   245

    // clear FMMU configurations

   246

    ec_datagram_fpwr(datagram, slave->station_address,

   247

            0x0600, EC_FMMU_PAGE_SIZE * slave->base_fmmu_count);

   248

    ec_datagram_zero(datagram);

   249

    fsm->retries = EC_FSM_RETRIES;

   250

    fsm->state = ec_fsm_slave_config_state_clear_fmmus;

   251

}

   252

   253

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

   254

   255

/** Slave configuration state: CLEAR FMMU.

   256

 */

   257

void ec_fsm_slave_config_state_clear_fmmus(

   258

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

   259

        )

   260

{

   261

    ec_datagram_t *datagram = fsm->datagram;

   262

   263

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

   264

        return;

   265

   266

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   267

        fsm->state = ec_fsm_slave_config_state_error;

   268

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

   269

        return;

   270

    }

   271

   272

    if (datagram->working_counter != 1) {

   273

        fsm->slave->error_flag = 1;

   274

        fsm->state = ec_fsm_slave_config_state_error;

   275

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

   276

        ec_datagram_print_wc_error(datagram);

   277

        return;

   278

    }

   279

   280

    ec_fsm_slave_config_enter_clear_sync(fsm);

   281

}

   282

   283

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

   284

   285

/** Clear the sync manager configurations.

   286

 */

   287

void ec_fsm_slave_config_enter_clear_sync(

   288

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

   289

        )

   290

{

   291

    ec_slave_t *slave = fsm->slave;

   292

    ec_datagram_t *datagram = fsm->datagram;

   293

    size_t sync_size;

   294

   295

    if (!slave->base_sync_count) {

   296

        // no sync managers

   297

        ec_fsm_slave_config_enter_dc_clear_assign(fsm);

   298

        return;

   299

    }

   300

   301

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

   302

   303

    sync_size = EC_SYNC_PAGE_SIZE * slave->base_sync_count;

   304

   305

    // clear sync manager configurations

   306

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

   307

    ec_datagram_zero(datagram);

   308

    fsm->retries = EC_FSM_RETRIES;

   309

    fsm->state = ec_fsm_slave_config_state_clear_sync;

   310

}

   311

   312

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

   313

   314

/** Slave configuration state: CLEAR SYNC.

   315

 */

   316

void ec_fsm_slave_config_state_clear_sync(

   317

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

   318

        )

   319

{

   320

    ec_datagram_t *datagram = fsm->datagram;

   321

   322

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

   323

        return;

   324

   325

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   326

        fsm->state = ec_fsm_slave_config_state_error;

   327

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

   328

                " clearing datagram.\n");

   329

        return;

   330

    }

   331

   332

    if (datagram->working_counter != 1) {

   333

        fsm->slave->error_flag = 1;

   334

        fsm->state = ec_fsm_slave_config_state_error;

   335

        EC_SLAVE_ERR(fsm->slave,

   336

                "Failed to clear sync manager configurations: ");

   337

        ec_datagram_print_wc_error(datagram);

   338

        return;

   339

    }

   340

   341

    ec_fsm_slave_config_enter_dc_clear_assign(fsm);

   342

}

   343

   344

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

   345

   346

/** Clear the DC assignment.

   347

 */

   348

void ec_fsm_slave_config_enter_dc_clear_assign(

   349

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

   350

        )

   351

{

   352

    ec_slave_t *slave = fsm->slave;

   353

    ec_datagram_t *datagram = fsm->datagram;

   354

   355

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

   356

        ec_fsm_slave_config_enter_mbox_sync(fsm);

   357

        return;

   358

    }

   359

   360

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

   361

   362

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

   363

    ec_datagram_zero(datagram);

   364

    fsm->retries = EC_FSM_RETRIES;

   365

    fsm->state = ec_fsm_slave_config_state_dc_clear_assign;

   366

}

   367

   368

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

   369

   370

/** Slave configuration state: CLEAR DC ASSIGN.

   371

 */

   372

void ec_fsm_slave_config_state_dc_clear_assign(

   373

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

   374

        )

   375

{

   376

    ec_datagram_t *datagram = fsm->datagram;

   377

   378

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

   379

        return;

   380

   381

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   382

        fsm->state = ec_fsm_slave_config_state_error;

   383

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

   384

                " clearing datagram.\n");

   385

        return;

   386

    }

   387

   388

    if (datagram->working_counter != 1) {

   389

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

   390

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

   391

        ec_datagram_print_wc_error(datagram);

   392

    }

   393

   394

    // read DC system time (0x0910, 64 bit)

   395

    //                         gap (64 bit)

   396

    //     and time offset (0x0920, 64 bit)

   397

    ec_datagram_fprd(fsm->datagram, fsm->slave->station_address, 0x0910, 24);

   398

    fsm->retries = EC_FSM_RETRIES;

   399

    fsm->state = ec_fsm_slave_config_state_dc_read_offset;

   400

}

   401

   402

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

   403

   404

/** Configure 32 bit time offset.

   405

 */

   406

u64 ec_fsm_slave_config_dc_offset32(

   407

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

   408

        u64 system_time, /**< System time register. */

   409

        u64 old_offset, /**< Time offset register. */

   410

        unsigned long jiffies_since_read /**< Jiffies for correction. */

   411

        )

   412

{

   413

    ec_slave_t *slave = fsm->slave;

   414

    u32 correction, system_time32, old_offset32, new_offset;

   415

    s32 time_diff;

   416

   417

    system_time32 = (u32) system_time;

   418

    old_offset32 = (u32) old_offset;

   419

   420

    // correct read system time by elapsed time since read operation

   421

    correction = jiffies_since_read * 1000 / HZ * 1000000;

   422

    system_time32 += correction;

   423

    time_diff = (u32) slave->master->app_time - system_time32;

   424

   425

    EC_SLAVE_DBG(slave, 1, "Calculating DC time offset (32 bit):"

   426

            " system_time=%u (corrected with %u), app_time=%u, diff=%i\n",

   427

            system_time32, correction,

   428

            (u32) slave->master->app_time, time_diff);

   429

   430

    if (EC_ABS(time_diff) > EC_SYSTEM_TIME_TOLERANCE_NS) {

   431

        new_offset = time_diff + old_offset32;

   432

        EC_SLAVE_DBG(slave, 1, "Setting time offset to %u (was %u)\n",

   433

                new_offset, old_offset32);

   434

        return (u64) new_offset;

   435

    } else {

   436

        EC_SLAVE_DBG(slave, 1, "Not touching time offset.\n");

   437

        return old_offset;

   438

    }

   439

}

   440

   441

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

   442

   443

/** Configure 64 bit time offset.

   444

 */

   445

u64 ec_fsm_slave_config_dc_offset64(

   446

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

   447

        u64 system_time, /**< System time register. */

   448

        u64 old_offset, /**< Time offset register. */

   449

        unsigned long jiffies_since_read /**< Jiffies for correction. */

   450

        )

   451

{

   452

    ec_slave_t *slave = fsm->slave;

   453

    u64 new_offset, correction;

   454

    s64 time_diff;

   455

   456

    // correct read system time by elapsed time since read operation

   457

    correction = (u64) (jiffies_since_read * 1000 / HZ) * 1000000;

   458

    system_time += correction;

   459

    time_diff = fsm->slave->master->app_time - system_time;

   460

   461

    EC_SLAVE_DBG(slave, 1, "Calculating DC time offset (64 bit):"

   462

            " system_time=%llu (corrected with %llu),"

   463

            " app_time=%llu, diff=%lli\n",

   464

            system_time, correction,

   465

            slave->master->app_time, time_diff);

   466

   467

    if (EC_ABS(time_diff) > EC_SYSTEM_TIME_TOLERANCE_NS) {

   468

        new_offset = time_diff + old_offset;

   469

        EC_SLAVE_DBG(slave, 1, "Setting time offset to %llu (was %llu)\n",

   470

                new_offset, old_offset);

   471

    } else {

   472

        new_offset = old_offset;

   473

        EC_SLAVE_DBG(slave, 1, "Not touching time offset.\n");

   474

    }

   475

   476

    return new_offset;

   477

}

   478

   479

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

   480

   481

/** Slave configuration state: DC READ OFFSET.

   482

 */

   483

void ec_fsm_slave_config_state_dc_read_offset(

   484

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

   485

        )

   486

{

   487

    ec_datagram_t *datagram = fsm->datagram;

   488

    ec_slave_t *slave = fsm->slave;

   489

    u64 system_time, old_offset, new_offset;

   490

    unsigned long jiffies_since_read;

   491

   492

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

   493

        return;

   494

   495

    if (datagram->state != EC_DATAGRAM_RECEIVED) {

   496

        fsm->state = ec_fsm_slave_config_state_error;

   497

        EC_SLAVE_ERR(slave, "Failed to receive DC times datagram: ");