330 {

   330 {

   331     ec_mailbox_t *mbox = fsm->mbox;

   331     ec_mailbox_t *mbox = fsm->mbox;

   332     ec_datagram_t *datagram = mbox->datagram;

   332     ec_datagram_t *datagram = mbox->datagram;

   333     ec_slave_t *slave = fsm->slave;

   333     ec_slave_t *slave = fsm->slave;

   334 

   334 

   336         return; // FIXME: request again?

   337         return; // FIXME: request again?

   339         fsm->state = ec_fsm_coe_error;

   341         fsm->state = ec_fsm_coe_error;

   340         EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   342         EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   341                 " request datagram: ");

   343                 " request datagram: ");

   342         ec_datagram_print_state(datagram);

   344         ec_datagram_print_state(datagram);

   343         return;

   345         return;

   344     }

   346     }

   345 

   347 

   347         fsm->state = ec_fsm_coe_error;

   349         fsm->state = ec_fsm_coe_error;

   348         EC_SLAVE_ERR(slave, "Reception of CoE dictionary request failed: ");

   350         EC_SLAVE_ERR(slave, "Reception of CoE dictionary request failed: ");

   349         ec_datagram_print_wc_error(datagram);

   351         ec_datagram_print_wc_error(datagram);

   350         return;

   352         return;

   351     }

   353     }

   367 {

   369 {

   368     ec_mailbox_t *mbox = fsm->mbox;

   370     ec_mailbox_t *mbox = fsm->mbox;

   369     ec_datagram_t *datagram = mbox->datagram;

   371     ec_datagram_t *datagram = mbox->datagram;

   370     ec_slave_t *slave = fsm->slave;

   372     ec_slave_t *slave = fsm->slave;

   371 

   373 

   376         fsm->state = ec_fsm_coe_error;

   380         fsm->state = ec_fsm_coe_error;

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

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

   378         ec_datagram_print_state(datagram);

   382         ec_datagram_print_state(datagram);

   379         return;

   383         return;

   380     }

   384     }

   381 

   385 

   385                 " datagram failed: ");

   389                 " datagram failed: ");

   386         ec_datagram_print_wc_error(datagram);

   390         ec_datagram_print_wc_error(datagram);

   387         return;

   391         return;

   388     }

   392     }

   389 

   393 

   426     uint16_t sdo_index, fragments_left;

   430     uint16_t sdo_index, fragments_left;

   427     ec_sdo_t *sdo;

   431     ec_sdo_t *sdo;

   428     bool first_segment;

   432     bool first_segment;

   429     size_t index_list_offset;

   433     size_t index_list_offset;

   430 

   434 

   432         return; // FIXME: request again?

   437         return; // FIXME: request again?

   435         fsm->state = ec_fsm_coe_error;

   441         fsm->state = ec_fsm_coe_error;

   436         EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   442         EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"

   437                 " response datagram: ");

   443                 " response datagram: ");

   438         ec_datagram_print_state(datagram);

   444         ec_datagram_print_state(datagram);

   439         return;

   445         return;

   440     }

   446     }

   441 

   447 

   443         fsm->state = ec_fsm_coe_error;

   449         fsm->state = ec_fsm_coe_error;

   444         EC_SLAVE_ERR(slave, "Reception of CoE dictionary response failed: ");

   450         EC_SLAVE_ERR(slave, "Reception of CoE dictionary response failed: ");

   445         ec_datagram_print_wc_error(datagram);

   451         ec_datagram_print_wc_error(datagram);

   446         return;

   452         return;

   447     }

   453     }

   581 {

   587 {

   582     ec_mailbox_t *mbox = fsm->mbox;

   588     ec_mailbox_t *mbox = fsm->mbox;

   583     ec_datagram_t *datagram = mbox->datagram;

   589     ec_datagram_t *datagram = mbox->datagram;

   584     ec_slave_t *slave = fsm->slave;

   590     ec_slave_t *slave = fsm->slave;

   585 

   591 

   587         return; // FIXME: check for response first?

   594         return; // FIXME: check for response first?

   588 

   595 

   590         fsm->state = ec_fsm_coe_error;

   597         fsm->state = ec_fsm_coe_error;

   591         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO"

   598         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO"

   592                 " description request datagram: ");

   599                 " description request datagram: ");

   593         ec_datagram_print_state(datagram);

   600         ec_datagram_print_state(datagram);

   594         return;

   601         return;

   595     }

   602     }

   596 

   603 

   598         fsm->state = ec_fsm_coe_error;

   605         fsm->state = ec_fsm_coe_error;

   599         EC_SLAVE_ERR(slave, "Reception of CoE SDO description"

   606         EC_SLAVE_ERR(slave, "Reception of CoE SDO description"

   600                 " request failed: ");

   607                 " request failed: ");

   601         ec_datagram_print_wc_error(datagram);

   608         ec_datagram_print_wc_error(datagram);

   602         return;

   609         return;

   619 {

   626 {

   620     ec_mailbox_t *mbox = fsm->mbox;

   627     ec_mailbox_t *mbox = fsm->mbox;

   621     ec_datagram_t *datagram = mbox->datagram;

   628     ec_datagram_t *datagram = mbox->datagram;

   622     ec_slave_t *slave = fsm->slave;

   629     ec_slave_t *slave = fsm->slave;

   623 

   630 

   628         fsm->state = ec_fsm_coe_error;

   637         fsm->state = ec_fsm_coe_error;

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

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

   630         ec_datagram_print_state(datagram);

   639         ec_datagram_print_state(datagram);

   631         return;

   640         return;

   632     }

   641     }

   633 

   642 

   635         fsm->state = ec_fsm_coe_error;

   644         fsm->state = ec_fsm_coe_error;

   636         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

   645         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

   637                 " datagram failed: ");

   646                 " datagram failed: ");

   638         ec_datagram_print_wc_error(datagram);

   647         ec_datagram_print_wc_error(datagram);

   639         return;

   648         return;

   676     ec_slave_t *slave = fsm->slave;

   685     ec_slave_t *slave = fsm->slave;

   677     ec_sdo_t *sdo = fsm->sdo;

   686     ec_sdo_t *sdo = fsm->sdo;

   678     uint8_t *data, mbox_prot;

   687     uint8_t *data, mbox_prot;

   679     size_t rec_size, name_size;

   688     size_t rec_size, name_size;

   680 

   689 

   682         return; // FIXME: request again?

   692         return; // FIXME: request again?

   685         fsm->state = ec_fsm_coe_error;

   696         fsm->state = ec_fsm_coe_error;

   686         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO description"

   697         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO description"

   687                 " response datagram: ");

   698                 " response datagram: ");

   688         ec_datagram_print_state(datagram);

   699         ec_datagram_print_state(datagram);

   689         return;

   700         return;

   690     }

   701     }

   691 

   702 

   693         fsm->state = ec_fsm_coe_error;

   704         fsm->state = ec_fsm_coe_error;

   694         EC_SLAVE_ERR(slave, "Reception of CoE SDO description"

   705         EC_SLAVE_ERR(slave, "Reception of CoE SDO description"

   695                 " response failed: ");

   706                 " response failed: ");

   696         ec_datagram_print_wc_error(datagram);

   707         ec_datagram_print_wc_error(datagram);

   697         return;

   708         return;

   818 {

   829 {

   819     ec_mailbox_t *mbox = fsm->mbox;

   830     ec_mailbox_t *mbox = fsm->mbox;

   820     ec_datagram_t *datagram = mbox->datagram;

   831     ec_datagram_t *datagram = mbox->datagram;

   821     ec_slave_t *slave = fsm->slave;

   832     ec_slave_t *slave = fsm->slave;

   822 

   833 

   824         return; // FIXME: check for response first?

   836         return; // FIXME: check for response first?

   827         fsm->state = ec_fsm_coe_error;

   840         fsm->state = ec_fsm_coe_error;

   828         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO entry"

   841         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO entry"

   829                 " request datagram: ");

   842                 " request datagram: ");

   830         ec_datagram_print_state(datagram);

   843         ec_datagram_print_state(datagram);

   831         return;

   844         return;

   832     }

   845     }

   833 

   846 

   835         fsm->state = ec_fsm_coe_error;

   848         fsm->state = ec_fsm_coe_error;

   836         EC_SLAVE_ERR(slave, "Reception of CoE SDO entry request failed: ");

   849         EC_SLAVE_ERR(slave, "Reception of CoE SDO entry request failed: ");

   837         ec_datagram_print_wc_error(datagram);

   850         ec_datagram_print_wc_error(datagram);

   838         return;

   851         return;

   839     }

   852     }

   856 {

   869 {

   857     ec_mailbox_t *mbox = fsm->mbox;

   870     ec_mailbox_t *mbox = fsm->mbox;

   858     ec_datagram_t *datagram = mbox->datagram;

   871     ec_datagram_t *datagram = mbox->datagram;

   859     ec_slave_t *slave = fsm->slave;

   872     ec_slave_t *slave = fsm->slave;

   860 

   873 

   865         fsm->state = ec_fsm_coe_error;

   880         fsm->state = ec_fsm_coe_error;

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

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

   867         ec_datagram_print_state(datagram);

   882         ec_datagram_print_state(datagram);

   868         return;

   883         return;

   869     }

   884     }

   870 

   885 

   872         fsm->state = ec_fsm_coe_error;

   887         fsm->state = ec_fsm_coe_error;

   873         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

   888         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

   874                 " datagram failed: ");

   889                 " datagram failed: ");

   875         ec_datagram_print_wc_error(datagram);

   890         ec_datagram_print_wc_error(datagram);

   876         return;

   891         return;

   915     uint8_t *data, mbox_prot;

   930     uint8_t *data, mbox_prot;

   916     size_t rec_size, data_size;

   931     size_t rec_size, data_size;

   917     ec_sdo_entry_t *entry;

   932     ec_sdo_entry_t *entry;

   918     u16 word;

   933     u16 word;

   919 

   934 

   921         return; // FIXME: request again?

   937         return; // FIXME: request again?

   924         fsm->state = ec_fsm_coe_error;

   941         fsm->state = ec_fsm_coe_error;

   925         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO"

   942         EC_SLAVE_ERR(slave, "Failed to receive CoE SDO"

   926                 " description response datagram: ");

   943                 " description response datagram: ");

   927         ec_datagram_print_state(datagram);

   944         ec_datagram_print_state(datagram);

   928         return;

   945         return;

   929     }

   946     }

   930 

   947 

   932         fsm->state = ec_fsm_coe_error;

   949         fsm->state = ec_fsm_coe_error;

   933         EC_SLAVE_ERR(slave, "Reception of CoE SDO description"

   950         EC_SLAVE_ERR(slave, "Reception of CoE SDO description"

   934                 " response failed: ");

   951                 " response failed: ");

   935         ec_datagram_print_wc_error(datagram);

   952         ec_datagram_print_wc_error(datagram);

   936         return;

   953         return;

  1225     ec_mailbox_t *mbox = fsm->mbox;

  1242     ec_mailbox_t *mbox = fsm->mbox;

  1226     ec_datagram_t *datagram = mbox->datagram;

  1243     ec_datagram_t *datagram = mbox->datagram;

  1227     ec_slave_t *slave = fsm->slave;

  1244     ec_slave_t *slave = fsm->slave;

  1228     unsigned long diff_ms;

  1245     unsigned long diff_ms;

  1229 

  1246 

  1231         return; // FIXME: check for response first?

  1249         return; // FIXME: check for response first?

  1234         fsm->request->errno = EIO;

  1253         fsm->request->errno = EIO;

  1235         fsm->state = ec_fsm_coe_error;

  1254         fsm->state = ec_fsm_coe_error;

  1236         EC_SLAVE_ERR(slave, "Failed to receive CoE download"

  1255         EC_SLAVE_ERR(slave, "Failed to receive CoE download"

  1237                 " request datagram: ");

  1256                 " request datagram: ");

  1238         ec_datagram_print_state(datagram);

  1257         ec_datagram_print_state(datagram);

  1239         return;

  1258         return;

  1240     }

  1259     }

  1241 

  1260 

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

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

  1243 

  1262 

  1246             if (diff_ms < fsm->request->response_timeout) {

  1265             if (diff_ms < fsm->request->response_timeout) {

  1247 #if DEBUG_RETRIES

  1266 #if DEBUG_RETRIES

  1248                 EC_SLAVE_DBG(slave, 1, "Slave did not respond to SDO"

  1267                 EC_SLAVE_DBG(slave, 1, "Slave did not respond to SDO"

  1249                         " download request. Retrying after %lu ms...\n",

  1268                         " download request. Retrying after %lu ms...\n",

  1250                         diff_ms);

  1269                         diff_ms);

  1284 {

  1303 {

  1285     ec_mailbox_t *mbox = fsm->mbox;

  1304     ec_mailbox_t *mbox = fsm->mbox;

  1286     ec_datagram_t *datagram = mbox->datagram;

  1305     ec_datagram_t *datagram = mbox->datagram;

  1287     ec_slave_t *slave = fsm->slave;

  1306     ec_slave_t *slave = fsm->slave;

  1288 

  1307 

  1293         fsm->request->errno = EIO;

  1314         fsm->request->errno = EIO;

  1294         fsm->state = ec_fsm_coe_error;

  1315         fsm->state = ec_fsm_coe_error;

  1295         EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"

  1316         EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"

  1296                 " datagram: ");

  1317                 " datagram: ");

  1297         ec_datagram_print_state(datagram);

  1318         ec_datagram_print_state(datagram);

  1298         return;

  1319         return;

  1299     }

  1320     }

  1300 

  1321 

  1302         fsm->request->errno = EIO;

  1323         fsm->request->errno = EIO;

  1303         fsm->state = ec_fsm_coe_error;

  1324         fsm->state = ec_fsm_coe_error;

  1304         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

  1325         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

  1305                 " datagram failed: ");

  1326                 " datagram failed: ");

  1306         ec_datagram_print_wc_error(datagram);

  1327         ec_datagram_print_wc_error(datagram);

  1410     ec_slave_t *slave = fsm->slave;

  1431     ec_slave_t *slave = fsm->slave;

  1411     uint8_t *data, mbox_prot;

  1432     uint8_t *data, mbox_prot;

  1412     size_t rec_size;

  1433     size_t rec_size;

  1413     ec_sdo_request_t *request = fsm->request;

  1434     ec_sdo_request_t *request = fsm->request;

  1414 

  1435 

  1416         return; // FIXME: request again?

  1438         return; // FIXME: request again?

  1419         request->errno = EIO;

  1442         request->errno = EIO;

  1420         fsm->state = ec_fsm_coe_error;

  1443         fsm->state = ec_fsm_coe_error;

  1421         EC_SLAVE_ERR(slave, "Failed to receive CoE download"

  1444         EC_SLAVE_ERR(slave, "Failed to receive CoE download"

  1422                 " response datagram: ");

  1445                 " response datagram: ");

  1423         ec_datagram_print_state(datagram);

  1446         ec_datagram_print_state(datagram);

  1424         return;

  1447         return;

  1425     }

  1448     }

  1426 

  1449 

  1428         request->errno = EIO;

  1451         request->errno = EIO;

  1429         fsm->state = ec_fsm_coe_error;

  1452         fsm->state = ec_fsm_coe_error;

  1430         EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");

  1453         EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");

  1431         ec_datagram_print_wc_error(datagram);

  1454         ec_datagram_print_wc_error(datagram);

  1432         return;

  1455         return;

  1525 {

  1548 {

  1526     ec_mailbox_t *mbox = fsm->mbox;

  1549     ec_mailbox_t *mbox = fsm->mbox;

  1527     ec_datagram_t *datagram = mbox->datagram;

  1550     ec_datagram_t *datagram = mbox->datagram;

  1528     ec_slave_t *slave = fsm->slave;

  1551     ec_slave_t *slave = fsm->slave;

  1529 

  1552 

  1534         fsm->request->errno = EIO;

  1559         fsm->request->errno = EIO;

  1535         fsm->state = ec_fsm_coe_error;

  1560         fsm->state = ec_fsm_coe_error;

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

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

  1537         ec_datagram_print_state(datagram);

  1562         ec_datagram_print_state(datagram);

  1538         return;

  1563         return;

  1539     }

  1564     }

  1540 

  1565 

  1542         fsm->request->errno = EIO;

  1567         fsm->request->errno = EIO;

  1543         fsm->state = ec_fsm_coe_error;

  1568         fsm->state = ec_fsm_coe_error;

  1544         EC_SLAVE_ERR(slave, "Reception of CoE mailbox segment check"

  1569         EC_SLAVE_ERR(slave, "Reception of CoE mailbox segment check"

  1545                 " datagram failed: ");

  1570                 " datagram failed: ");

  1546         ec_datagram_print_wc_error(datagram);

  1571         ec_datagram_print_wc_error(datagram);

  1585     ec_slave_t *slave = fsm->slave;

  1610     ec_slave_t *slave = fsm->slave;

  1586     uint8_t *data, mbox_prot;

  1611     uint8_t *data, mbox_prot;

  1587     size_t rec_size;

  1612     size_t rec_size;

  1588     ec_sdo_request_t *request = fsm->request;

  1613     ec_sdo_request_t *request = fsm->request;

  1589 

  1614 

  1591         return; // FIXME: request again?

  1617         return; // FIXME: request again?

  1594         request->errno = EIO;

  1621         request->errno = EIO;

  1595         fsm->state = ec_fsm_coe_error;

  1622         fsm->state = ec_fsm_coe_error;

  1596         EC_SLAVE_ERR(slave, "Failed to receive CoE download response"

  1623         EC_SLAVE_ERR(slave, "Failed to receive CoE download response"

  1597                 " datagram: ");

  1624                 " datagram: ");

  1598         ec_datagram_print_state(datagram);

  1625         ec_datagram_print_state(datagram);

  1599         return;

  1626         return;

  1600     }

  1627     }

  1601 

  1628 

  1603         request->errno = EIO;

  1630         request->errno = EIO;

  1604         fsm->state = ec_fsm_coe_error;

  1631         fsm->state = ec_fsm_coe_error;

  1605         EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");

  1632         EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");

  1606         ec_datagram_print_wc_error(datagram);

  1633         ec_datagram_print_wc_error(datagram);

  1607         return;

  1634         return;

  1756     ec_mailbox_t *mbox = fsm->mbox;

  1783     ec_mailbox_t *mbox = fsm->mbox;

  1757     ec_datagram_t *datagram = mbox->datagram;

  1784     ec_datagram_t *datagram = mbox->datagram;

  1758     ec_slave_t *slave = fsm->slave;

  1785     ec_slave_t *slave = fsm->slave;

  1759     unsigned long diff_ms;

  1786     unsigned long diff_ms;

  1760 

  1787 

  1762         return; // FIXME: check for response first?

  1790         return; // FIXME: check for response first?

  1765         fsm->request->errno = EIO;

  1794         fsm->request->errno = EIO;

  1766         fsm->state = ec_fsm_coe_error;

  1795         fsm->state = ec_fsm_coe_error;

  1767         EC_SLAVE_ERR(slave, "Failed to receive CoE upload request: ");

  1796         EC_SLAVE_ERR(slave, "Failed to receive CoE upload request: ");

  1768         ec_datagram_print_state(datagram);

  1797         ec_datagram_print_state(datagram);

  1769         return;

  1798         return;

  1770     }

  1799     }

  1771 

  1800 

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

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

  1773 

  1802 

  1776             if (diff_ms < fsm->request->response_timeout) {

  1805             if (diff_ms < fsm->request->response_timeout) {

  1777 #if DEBUG_RETRIES

  1806 #if DEBUG_RETRIES

  1778                 EC_SLAVE_DBG(slave, 1, "Slave did not respond to"

  1807                 EC_SLAVE_DBG(slave, 1, "Slave did not respond to"

  1779                         " SDO upload request. Retrying after %lu ms...\n",

  1808                         " SDO upload request. Retrying after %lu ms...\n",

  1780                         diff_ms);

  1809                         diff_ms);

  1816 {

  1845 {

  1817     ec_mailbox_t *mbox = fsm->mbox;

  1846     ec_mailbox_t *mbox = fsm->mbox;

  1818     ec_datagram_t *datagram = mbox->datagram;

  1847     ec_datagram_t *datagram = mbox->datagram;

  1819     ec_slave_t *slave = fsm->slave;

  1848     ec_slave_t *slave = fsm->slave;

  1820 

  1849 

  1825         fsm->request->errno = EIO;

  1856         fsm->request->errno = EIO;

  1826         fsm->state = ec_fsm_coe_error;

  1857         fsm->state = ec_fsm_coe_error;

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

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

  1828         ec_datagram_print_state(datagram);

  1859         ec_datagram_print_state(datagram);

  1829         return;

  1860         return;

  1830     }

  1861     }

  1831 

  1862 

  1833         fsm->request->errno = EIO;

  1864         fsm->request->errno = EIO;

  1834         fsm->state = ec_fsm_coe_error;

  1865         fsm->state = ec_fsm_coe_error;

  1835         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

  1866         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"

  1836                 " datagram failed: ");

  1867                 " datagram failed: ");

  1837         ec_datagram_print_wc_error(datagram);

  1868         ec_datagram_print_wc_error(datagram);

  1906     size_t rec_size, data_size;

  1937     size_t rec_size, data_size;

  1907     ec_sdo_request_t *request = fsm->request;

  1938     ec_sdo_request_t *request = fsm->request;

  1908     unsigned int expedited, size_specified;

  1939     unsigned int expedited, size_specified;

  1909     int ret;

  1940     int ret;

  1910 

  1941 

  1912         return; // FIXME: request again?

  1944         return; // FIXME: request again?

  1915         request->errno = EIO;

  1948         request->errno = EIO;

  1916         fsm->state = ec_fsm_coe_error;

  1949         fsm->state = ec_fsm_coe_error;

  1917         EC_SLAVE_ERR(slave, "Failed to receive CoE upload response"

  1950         EC_SLAVE_ERR(slave, "Failed to receive CoE upload response"

  1918                 " datagram: ");

  1951                 " datagram: ");

  1919         ec_datagram_print_state(datagram);

  1952         ec_datagram_print_state(datagram);

  1920         return;

  1953         return;

  1921     }

  1954     }

  1922 

  1955 

  1924         request->errno = EIO;

  1957         request->errno = EIO;

  1925         fsm->state = ec_fsm_coe_error;

  1958         fsm->state = ec_fsm_coe_error;

  1926         EC_SLAVE_ERR(slave, "Reception of CoE upload response failed: ");

  1959         EC_SLAVE_ERR(slave, "Reception of CoE upload response failed: ");

  1927         ec_datagram_print_wc_error(datagram);

  1960         ec_datagram_print_wc_error(datagram);

  1928         return;

  1961         return;

  2099 {

  2132 {

  2100     ec_mailbox_t *mbox = fsm->mbox;

  2133     ec_mailbox_t *mbox = fsm->mbox;

  2101     ec_datagram_t *datagram = mbox->datagram;

  2134     ec_datagram_t *datagram = mbox->datagram;

  2102     ec_slave_t *slave = fsm->slave;

  2135     ec_slave_t *slave = fsm->slave;

  2103 

  2136 

  2105         return; // FIXME: check for response first?

  2139         return; // FIXME: check for response first?

  2108         fsm->request->errno = EIO;

  2143         fsm->request->errno = EIO;

  2109         fsm->state = ec_fsm_coe_error;

  2144         fsm->state = ec_fsm_coe_error;

  2110         EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"

  2145         EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"

  2111                 " request datagram: ");

  2146                 " request datagram: ");

  2112         ec_datagram_print_state(datagram);

  2147         ec_datagram_print_state(datagram);

  2113         return;

  2148         return;

  2114     }

  2149     }

  2115 

  2150 

  2117         fsm->request->errno = EIO;

  2152         fsm->request->errno = EIO;

  2118         fsm->state = ec_fsm_coe_error;

  2153         fsm->state = ec_fsm_coe_error;

  2119         EC_SLAVE_ERR(slave, "Reception of CoE upload segment"

  2154         EC_SLAVE_ERR(slave, "Reception of CoE upload segment"

  2120                 " request failed: ");

  2155                 " request failed: ");

  2121         ec_datagram_print_wc_error(datagram);

  2156         ec_datagram_print_wc_error(datagram);

  2139 {

  2174 {

  2140     ec_mailbox_t *mbox = fsm->mbox;

  2175     ec_mailbox_t *mbox = fsm->mbox;

  2141     ec_datagram_t *datagram = mbox->datagram;

  2176     ec_datagram_t *datagram = mbox->datagram;

  2142     ec_slave_t *slave = fsm->slave;

  2177     ec_slave_t *slave = fsm->slave;

  2143 

  2178 

  2148         fsm->request->errno = EIO;

  2185         fsm->request->errno = EIO;

  2149         fsm->state = ec_fsm_coe_error;

  2186         fsm->state = ec_fsm_coe_error;

  2150         EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"

  2187         EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"

  2151                 " datagram: ");

  2188                 " datagram: ");

  2152         ec_datagram_print_state(datagram);

  2189         ec_datagram_print_state(datagram);

  2153         return;

  2190         return;

  2154     }

  2191     }

  2155 

  2192 

  2157         fsm->request->errno = EIO;

  2194         fsm->request->errno = EIO;

  2158         fsm->state = ec_fsm_coe_error;

  2195         fsm->state = ec_fsm_coe_error;

  2159         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check datagram"

  2196         EC_SLAVE_ERR(slave, "Reception of CoE mailbox check datagram"

  2160                 " failed: ");

  2197                 " failed: ");

  2161         ec_datagram_print_wc_error(datagram);

  2198         ec_datagram_print_wc_error(datagram);

  2200     uint8_t *data, mbox_prot;

  2237     uint8_t *data, mbox_prot;

  2201     size_t rec_size, data_size;

  2238     size_t rec_size, data_size;

  2202     ec_sdo_request_t *request = fsm->request;

  2239     ec_sdo_request_t *request = fsm->request;

  2203     unsigned int last_segment;

  2240     unsigned int last_segment;

  2204 

  2241 

  2206         return; // FIXME: request again?

  2244         return; // FIXME: request again?

  2209         request->errno = EIO;

  2248         request->errno = EIO;

  2210         fsm->state = ec_fsm_coe_error;

  2249         fsm->state = ec_fsm_coe_error;

  2211         EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"

  2250         EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"

  2212                 " response datagram: ");

  2251                 " response datagram: ");

  2213         ec_datagram_print_state(datagram);

  2252         ec_datagram_print_state(datagram);

  2214         return;

  2253         return;

  2215     }

  2254     }

  2216 

  2255 

  2218         request->errno = EIO;

  2257         request->errno = EIO;

  2219         fsm->state = ec_fsm_coe_error;

  2258         fsm->state = ec_fsm_coe_error;

  2220         EC_SLAVE_ERR(slave, "Reception of CoE upload segment"

  2259         EC_SLAVE_ERR(slave, "Reception of CoE upload segment"

  2221                 " response failed: ");

  2260                 " response failed: ");

  2222         ec_datagram_print_wc_error(datagram);

  2261         ec_datagram_print_wc_error(datagram);