1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2014  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

/**

    31

   \file

    32

   EtherCAT EoE state machines.

    33

*/

    34

    35

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

    36

    37

#include "globals.h"

    38

#include "master.h"

    39

#include "mailbox.h"

    40

#include "fsm_eoe.h"

    41

    42

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

    43

    44

/** Maximum time to wait for a set IP parameter response.

    45

 */

    46

#define EC_EOE_RESPONSE_TIMEOUT 3000 // [ms]

    47

    48

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

    49

    50

void ec_fsm_eoe_set_ip_start(ec_fsm_eoe_t *, ec_datagram_t *);

    51

void ec_fsm_eoe_set_ip_request(ec_fsm_eoe_t *, ec_datagram_t *);

    52

void ec_fsm_eoe_set_ip_check(ec_fsm_eoe_t *, ec_datagram_t *);

    53

void ec_fsm_eoe_set_ip_response(ec_fsm_eoe_t *, ec_datagram_t *);

    54

    55

void ec_fsm_eoe_end(ec_fsm_eoe_t *, ec_datagram_t *);

    56

void ec_fsm_eoe_error(ec_fsm_eoe_t *, ec_datagram_t *);

    57

    58

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

    59

    60

/** Constructor.

    61

 */

    62

void ec_fsm_eoe_init(

    63

        ec_fsm_eoe_t *fsm /**< finite state machine */

    64

        )

    65

{

    66

    fsm->slave = NULL;

    67

    fsm->retries = 0;

    68

    fsm->state = NULL;

    69

    fsm->datagram = NULL;

    70

    fsm->jiffies_start = 0;

    71

    fsm->request = NULL;

    72

}

    73

    74

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

    75

    76

/** Destructor.

    77

 */

    78

void ec_fsm_eoe_clear(

    79

        ec_fsm_eoe_t *fsm /**< finite state machine */

    80

        )

    81

{

    82

}

    83

    84

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

    85

    86

/** Starts to set the EoE IP partameters of a slave.

    87

 */

    88

void ec_fsm_eoe_set_ip_param(

    89

        ec_fsm_eoe_t *fsm, /**< State machine. */

    90

        ec_slave_t *slave, /**< EtherCAT slave. */

    91

        ec_eoe_request_t *request /**< EoE request. */

    92

        )

    93

{

    94

    fsm->slave = slave;

    95

    fsm->request = request;

    96

    fsm->state = ec_fsm_eoe_set_ip_start;

    97

}

    98

    99

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

   100

   101

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

   102

 *

   103

 * \return 1 if the datagram was used, else 0.

   104

 */

   105

int ec_fsm_eoe_exec(

   106

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   107

        ec_datagram_t *datagram /**< Datagram to use. */

   108

        )

   109

{

   110

    int datagram_used = 0;

   111

   112

    if (fsm->datagram &&

   113

            (fsm->datagram->state == EC_DATAGRAM_INIT ||

   114

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

   115

             fsm->datagram->state == EC_DATAGRAM_SENT)) {

   116

        // datagram not received yet

   117

        return datagram_used;

   118

    }

   119

   120

    fsm->state(fsm, datagram);

   121

   122

    datagram_used =

   123

        fsm->state != ec_fsm_eoe_end && fsm->state != ec_fsm_eoe_error;

   124

   125

    if (datagram_used) {

   126

        fsm->datagram = datagram;

   127

    } else {

   128

        fsm->datagram = NULL;

   129

    }

   130

   131

    return datagram_used;

   132

}

   133

   134

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

   135

   136

/** Returns, if the state machine terminated with success.

   137

 *

   138

 * \return non-zero if successful.

   139

 */

   140

int ec_fsm_eoe_success(const ec_fsm_eoe_t *fsm /**< Finite state machine */)

   141

{

   142

    return fsm->state == ec_fsm_eoe_end;

   143

}

   144

   145

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

   146

 * EoE set IP parameter state machine

   147

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

   148

   149

/** Prepare a set IP parameters operation.

   150

 *

   151

 * \return 0 on success, otherwise a negative error code.

   152

 */

   153

int ec_fsm_eoe_prepare_set(

   154

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   155

        ec_datagram_t *datagram /**< Datagram to use. */

   156

        )

   157

{

   158

    uint8_t *data, *cur;

   159

    ec_slave_t *slave = fsm->slave;

   160

    ec_master_t *master = slave->master;

   161

    ec_eoe_request_t *req = fsm->request;

   162

    size_t size = 8;

   163

   164

    if (req->mac_address_included) {

   165

        size += ETH_ALEN;

   166

    }

   167

   168

    if (req->ip_address_included) {

   169

        size += 4;

   170

    }

   171

   172

    if (req->subnet_mask_included) {

   173

        size += 4;

   174

    }

   175

   176

    if (req->gateway_included) {

   177

        size += 4;

   178

    }

   179

   180

    if (req->dns_included) {

   181

        size += 4;

   182

    }

   183

   184

    if (req->name_included) {

   185

        size += EC_MAX_HOSTNAME_SIZE;

   186

    }

   187

   188

    data = ec_slave_mbox_prepare_send(slave, datagram, EC_MBOX_TYPE_EOE,

   189

            size);

   190

    if (IS_ERR(data)) {

   191

        return PTR_ERR(data);

   192

    }

   193

   194

    EC_WRITE_U8(data, EC_EOE_FRAMETYPE_SET_IP_REQ); // Set IP parameter req.

   195

    EC_WRITE_U8(data + 1, 0x01); // last fragment, no timestamps

   196

    EC_WRITE_U16(data + 2, 0x0000); // fragment no., offset, frame no.

   197

   198

    EC_WRITE_U32(data + 4,

   199

            ((req->mac_address_included != 0) << 0) |

   200

            ((req->ip_address_included != 0) << 1) |

   201

            ((req->subnet_mask_included != 0) << 2) |

   202

            ((req->gateway_included != 0) << 3) |

   203

            ((req->dns_included != 0) << 4) |

   204

            ((req->name_included != 0) << 5)

   205

            );

   206

   207

    cur = data + 8;

   208

   209

    if (req->mac_address_included) {

   210

        memcpy(cur, req->mac_address, ETH_ALEN);

   211

        cur += ETH_ALEN;

   212

    }

   213

   214

    if (req->ip_address_included) {

   215

        uint32_t swapped = htonl(req->ip_address);

   216

        memcpy(cur, &swapped, 4);

   217

        cur += 4;

   218

    }

   219

   220

    if (req->subnet_mask_included) {

   221

        uint32_t swapped = htonl(req->subnet_mask);

   222

        memcpy(cur, &swapped, 4);

   223

        cur += 4;

   224

    }

   225

   226

    if (req->gateway_included) {

   227

        uint32_t swapped = htonl(req->gateway);

   228

        memcpy(cur, &swapped, 4);

   229

        cur += 4;

   230

    }

   231

   232

    if (req->dns_included) {

   233

        uint32_t swapped = htonl(req->dns);

   234

        memcpy(cur, &swapped, 4);

   235

        cur += 4;

   236

    }

   237

   238

    if (req->name_included) {

   239

        memcpy(cur, req->name, EC_MAX_HOSTNAME_SIZE);

   240

        cur += EC_MAX_HOSTNAME_SIZE;

   241

    }

   242

   243

    if (master->debug_level) {

   244

        EC_SLAVE_DBG(slave, 0, "Set IP parameter request:\n");

   245

        ec_print_data(data, cur - data);

   246

    }

   247

   248

    fsm->request->jiffies_sent = jiffies;

   249

   250

    return 0;

   251

}

   252

   253

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

   254

   255

/** EoE state: SET IP START.

   256

 */

   257

void ec_fsm_eoe_set_ip_start(

   258

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   259

        ec_datagram_t *datagram /**< Datagram to use. */

   260

        )

   261

{

   262

    ec_slave_t *slave = fsm->slave;

   263

   264

    EC_SLAVE_DBG(slave, 1, "Setting IP parameters.\n");

   265

   266

    if (!(slave->sii.mailbox_protocols & EC_MBOX_EOE)) {

   267

        EC_SLAVE_ERR(slave, "Slave does not support EoE!\n");

   268

        fsm->state = ec_fsm_eoe_error;

   269

        return;

   270

    }

   271

   272

    if (ec_fsm_eoe_prepare_set(fsm, datagram)) {

   273

        fsm->state = ec_fsm_eoe_error;

   274

        return;

   275

    }

   276

   277

    fsm->retries = EC_FSM_RETRIES;

   278

    fsm->state = ec_fsm_eoe_set_ip_request;

   279

}

   280

   281

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

   282

   283

/** EoE state: SET IP REQUEST.

   284

 */

   285

void ec_fsm_eoe_set_ip_request(

   286

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   287

        ec_datagram_t *datagram /**< Datagram to use. */

   288

        )

   289

{

   290

    ec_slave_t *slave = fsm->slave;

   291

   292

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

   293

        if (ec_fsm_eoe_prepare_set(fsm, datagram)) {

   294

            fsm->state = ec_fsm_eoe_error;

   295

        }

   296

        return;

   297

    }

   298

   299

    if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {

   300

        fsm->state = ec_fsm_eoe_error;

   301

        EC_SLAVE_ERR(slave, "Failed to receive EoE set IP parameter"

   302

                " request: ");

   303

        ec_datagram_print_state(fsm->datagram);

   304

        return;

   305

    }

   306

   307

    if (fsm->datagram->working_counter != 1) {

   308

        unsigned long diff_ms =

   309

            (jiffies - fsm->request->jiffies_sent) * 1000 / HZ;

   310

   311

        if (!fsm->datagram->working_counter) {

   312

            if (diff_ms < EC_EOE_RESPONSE_TIMEOUT) {

   313

                // no response; send request datagram again

   314

                if (ec_fsm_eoe_prepare_set(fsm, datagram)) {

   315

                    fsm->state = ec_fsm_eoe_error;

   316

                }

   317

                return;

   318

            }

   319

        }

   320

        fsm->state = ec_fsm_eoe_error;

   321

        EC_SLAVE_ERR(slave, "Reception of EoE set IP parameter request"

   322

                " failed after %lu ms: ", diff_ms);

   323

        ec_datagram_print_wc_error(fsm->datagram);

   324

        return;

   325

    }

   326

   327

    fsm->jiffies_start = fsm->datagram->jiffies_sent;

   328

    ec_slave_mbox_prepare_check(slave, datagram); // can not fail.

   329

    fsm->retries = EC_FSM_RETRIES;

   330

    fsm->state = ec_fsm_eoe_set_ip_check;

   331

}

   332

   333

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

   334

   335

/** EoE state: SET IP CHECK.

   336

 */

   337

void ec_fsm_eoe_set_ip_check(

   338

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   339

        ec_datagram_t *datagram /**< Datagram to use. */

   340

        )

   341

{

   342

    ec_slave_t *slave = fsm->slave;

   343

   344

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

   345

        ec_slave_mbox_prepare_check(slave, datagram); // can not fail.

   346

        return;

   347

    }

   348

   349

    if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {

   350

        fsm->state = ec_fsm_eoe_error;

   351

        EC_SLAVE_ERR(slave, "Failed to receive EoE mailbox check datagram: ");

   352

        ec_datagram_print_state(fsm->datagram);

   353

        return;

   354

    }

   355

   356

    if (fsm->datagram->working_counter != 1) {

   357

        fsm->state = ec_fsm_eoe_error;

   358

        EC_SLAVE_ERR(slave, "Reception of EoE mailbox check"

   359

                " datagram failed: ");

   360

        ec_datagram_print_wc_error(fsm->datagram);

   361

        return;

   362

    }

   363

   364

    if (!ec_slave_mbox_check(fsm->datagram)) {

   365

        unsigned long diff_ms =

   366

            (fsm->datagram->jiffies_received - fsm->jiffies_start) *

   367

            1000 / HZ;

   368

        if (diff_ms >= EC_EOE_RESPONSE_TIMEOUT) {

   369

            fsm->state = ec_fsm_eoe_error;

   370

            EC_SLAVE_ERR(slave, "Timeout after %lu ms while waiting for"

   371

                    " set IP parameter response.\n", diff_ms);

   372

            return;

   373

        }

   374

   375

        ec_slave_mbox_prepare_check(slave, datagram); // can not fail.

   376

        fsm->retries = EC_FSM_RETRIES;

   377

        return;

   378

    }

   379

   380

    // fetch response

   381

    ec_slave_mbox_prepare_fetch(slave, datagram); // can not fail.

   382

    fsm->retries = EC_FSM_RETRIES;

   383

    fsm->state = ec_fsm_eoe_set_ip_response;

   384

}

   385

   386

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

   387

   388

/** EoE state: SET IP RESPONSE.

   389

 */

   390

void ec_fsm_eoe_set_ip_response(

   391

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   392

        ec_datagram_t *datagram /**< Datagram to use. */

   393

        )

   394

{

   395

    ec_slave_t *slave = fsm->slave;

   396

    ec_master_t *master = slave->master;

   397

    uint8_t *data, mbox_prot, frame_type;

   398

    size_t rec_size;

   399

    ec_eoe_request_t *req = fsm->request;

   400

   401

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

   402

        ec_slave_mbox_prepare_fetch(slave, datagram); // can not fail.

   403

        return;

   404

    }

   405

   406

    if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {

   407

        fsm->state = ec_fsm_eoe_error;

   408

        EC_SLAVE_ERR(slave, "Failed to receive EoE read response datagram: ");

   409

        ec_datagram_print_state(fsm->datagram);

   410

        return;

   411

    }

   412

   413

    if (fsm->datagram->working_counter != 1) {

   414

        fsm->state = ec_fsm_eoe_error;

   415

        EC_SLAVE_ERR(slave, "Reception of EoE read response failed: ");

   416

        ec_datagram_print_wc_error(fsm->datagram);

   417

        return;

   418

    }

   419

   420

    data = ec_slave_mbox_fetch(slave, fsm->datagram, &mbox_prot, &rec_size);

   421

    if (IS_ERR(data)) {

   422

        fsm->state = ec_fsm_eoe_error;

   423

        return;

   424

    }

   425

   426

    if (master->debug_level) {

   427

        EC_SLAVE_DBG(slave, 0, "Set IP parameter response:\n");

   428

        ec_print_data(data, rec_size);

   429

    }

   430

   431

    if (mbox_prot != EC_MBOX_TYPE_EOE) {

   432

        fsm->state = ec_fsm_eoe_error;

   433

        EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",

   434

                mbox_prot);

   435

        return;

   436

    }

   437

   438

    if (rec_size < 4) {

   439

        fsm->state = ec_fsm_eoe_error;

   440

        EC_SLAVE_ERR(slave, "Received currupted EoE set IP parameter response"

   441

                " (%zu bytes)!\n", rec_size);

   442

        ec_print_data(data, rec_size);

   443

        return;

   444

    }

   445

   446

    frame_type = EC_READ_U8(data) & 0x0f;

   447

   448

    if (frame_type != EC_EOE_FRAMETYPE_SET_IP_RES) {

   449

        EC_SLAVE_ERR(slave, "Received no set IP parameter response"

   450

                " (frame type %x).\n", frame_type);

   451

        ec_print_data(data, rec_size);

   452

        fsm->state = ec_fsm_eoe_error;

   453

        return;

   454

    }

   455

   456

    req->result = EC_READ_U16(data + 2);

   457

   458

    if (req->result) {

   459

        fsm->state = ec_fsm_eoe_error;

   460

        EC_SLAVE_DBG(slave, 1, "EoE set IP parameters failed with result code"

   461

                " 0x%04X.\n", req->result);

   462

    } else {

   463

        fsm->state = ec_fsm_eoe_end; // success

   464

    }

   465

}

   466

   467

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

   468

   469

/** State: ERROR.

   470

 */

   471

void ec_fsm_eoe_error(

   472

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   473

        ec_datagram_t *datagram /**< Datagram to use. */

   474

        )

   475

{

   476

}

   477

   478

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

   479

   480

/** State: END.

   481

 */

   482

void ec_fsm_eoe_end(

   483

        ec_fsm_eoe_t *fsm, /**< finite state machine */

   484

        ec_datagram_t *datagram /**< Datagram to use. */

   485

        )

   486

{

   487

}

   488

   489

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