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         memcpy(cur, &req->ip_address, 4);

   216         cur += 4;

   217     }

   218 

   219     if (req->subnet_mask_included) {

   220         memcpy(cur, &req->subnet_mask, 4);

   221         cur += 4;

   222     }

   223 

   224     if (req->gateway_included) {

   225         memcpy(cur, &req->gateway, 4);

   226         cur += 4;

   227     }

   228 

   229     if (req->dns_included) {

   230         memcpy(cur, &req->dns, 4);

   231         cur += 4;

   232     }

   233 

   234     if (req->name_included) {

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

   236         cur += EC_MAX_HOSTNAME_SIZE;

   237     }

   238 

   239     if (master->debug_level) {

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

   241         ec_print_data(data, cur - data);

   242     }

   243 

   244     fsm->request->jiffies_sent = jiffies;

   245 

   246     return 0;

   247 }

   248 

   249 /*****************************************************************************/

   250 

   251 /** EoE state: SET IP START.

   252  */

   253 void ec_fsm_eoe_set_ip_start(

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

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

   256         )

   257 {

   258     ec_slave_t *slave = fsm->slave;

   259 

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

   261 

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

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

   264         fsm->state = ec_fsm_eoe_error;

   265         return;

   266     }

   267 

   268     if (ec_fsm_eoe_prepare_set(fsm, datagram)) {

   269         fsm->state = ec_fsm_eoe_error;

   270         return;

   271     }

   272 

   273     fsm->retries = EC_FSM_RETRIES;

   274     fsm->state = ec_fsm_eoe_set_ip_request;

   275 }

   276 

   277 /*****************************************************************************/

   278 

   279 /** EoE state: SET IP REQUEST.

   280  */

   281 void ec_fsm_eoe_set_ip_request(

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

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

   284         )

   285 {

   286     ec_slave_t *slave = fsm->slave;

   287 

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

   289         if (ec_fsm_eoe_prepare_set(fsm, datagram)) {

   290             fsm->state = ec_fsm_eoe_error;

   291         }

   292         return;

   293     }

   294 

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

   296         fsm->state = ec_fsm_eoe_error;

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

   298                 " request: ");

   299         ec_datagram_print_state(fsm->datagram);

   300         return;

   301     }

   302 

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

   304         unsigned long diff_ms =

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

   306 

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

   308             if (diff_ms < EC_EOE_RESPONSE_TIMEOUT) {

   309                 // no response; send request datagram again

   310                 if (ec_fsm_eoe_prepare_set(fsm, datagram)) {

   311                     fsm->state = ec_fsm_eoe_error;

   312                 }

   313                 return;

   314             }

   315         }

   316         fsm->state = ec_fsm_eoe_error;

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

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

   319         ec_datagram_print_wc_error(fsm->datagram);

   320         return;

   321     }

   322 

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

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

   325     fsm->retries = EC_FSM_RETRIES;

   326     fsm->state = ec_fsm_eoe_set_ip_check;

   327 }

   328 

   329 /*****************************************************************************/

   330 

   331 /** EoE state: SET IP CHECK.

   332  */

   333 void ec_fsm_eoe_set_ip_check(

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

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

   336         )

   337 {

   338     ec_slave_t *slave = fsm->slave;

   339 

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

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

   342         return;

   343     }

   344 

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

   346         fsm->state = ec_fsm_eoe_error;

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

   348         ec_datagram_print_state(fsm->datagram);

   349         return;

   350     }

   351 

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

   353         fsm->state = ec_fsm_eoe_error;

   354         EC_SLAVE_ERR(slave, "Reception of EoE mailbox check"

   355                 " datagram failed: ");

   356         ec_datagram_print_wc_error(fsm->datagram);

   357         return;

   358     }

   359 

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

   361         unsigned long diff_ms =

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

   363             1000 / HZ;

   364         if (diff_ms >= EC_EOE_RESPONSE_TIMEOUT) {

   365             fsm->state = ec_fsm_eoe_error;

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

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

   368             return;

   369         }

   370 

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

   372         fsm->retries = EC_FSM_RETRIES;

   373         return;

   374     }

   375 

   376     // fetch response

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

   378     fsm->retries = EC_FSM_RETRIES;

   379     fsm->state = ec_fsm_eoe_set_ip_response;

   380 }

   381 

   382 /*****************************************************************************/

   383 

   384 /** EoE state: SET IP RESPONSE.

   385  */

   386 void ec_fsm_eoe_set_ip_response(

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

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

   389         )

   390 {

   391     ec_slave_t *slave = fsm->slave;

   392     ec_master_t *master = slave->master;

   393     uint8_t *data, mbox_prot, frame_type;

   394     size_t rec_size;

   395     ec_eoe_request_t *req = fsm->request;

   396 

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

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

   399         return;

   400     }

   401 

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

   403         fsm->state = ec_fsm_eoe_error;

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

   405         ec_datagram_print_state(fsm->datagram);

   406         return;

   407     }

   408 

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

   410         fsm->state = ec_fsm_eoe_error;

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

   412         ec_datagram_print_wc_error(fsm->datagram);

   413         return;

   414     }

   415 

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

   417     if (IS_ERR(data)) {

   418         fsm->state = ec_fsm_eoe_error;

   419         return;

   420     }

   421 

   422     if (master->debug_level) {

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

   424         ec_print_data(data, rec_size);

   425     }

   426 

   427     if (mbox_prot != EC_MBOX_TYPE_EOE) {

   428         fsm->state = ec_fsm_eoe_error;

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

   430                 mbox_prot);

   431         return;

   432     }

   433 

   434     if (rec_size < 4) {

   435         fsm->state = ec_fsm_eoe_error;

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

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

   438         ec_print_data(data, rec_size);

   439         return;

   440     }

   441 

   442     frame_type = EC_READ_U8(data) & 0x0f;

   443 

   444     if (frame_type != EC_EOE_FRAMETYPE_SET_IP_RES) {

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

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

   447         ec_print_data(data, rec_size);

   448         fsm->state = ec_fsm_eoe_error;

   449         return;

   450     }

   451 

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

   453 

   454     if (req->result) {

   455         fsm->state = ec_fsm_eoe_error;

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

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

   458     } else {

   459         fsm->state = ec_fsm_eoe_end; // success

   460     }

   461 }

   462 

   463 /*****************************************************************************/

   464 

   465 /** State: ERROR.

   466  */

   467 void ec_fsm_eoe_error(

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

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

   470         )

   471 {

   472 }

   473 

   474 /*****************************************************************************/

   475 

   476 /** State: END.

   477  */

   478 void ec_fsm_eoe_end(

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

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

   481         )

   482 {

   483 }

   484 

   485 /*****************************************************************************/