Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/fsm_coe.c
changeset 1038 7ca4103ba170
parent 1037 59f191c9185b
child 1043 2abea4233a6d
equal deleted inserted replaced
1037:59f191c9185b 1038:7ca4103ba170 
   315                 slave->ring_position);
 
   315                 slave->ring_position);
 
   316         ec_datagram_print_wc_error(datagram);
 
   316         ec_datagram_print_wc_error(datagram);
 
   317         return;
 
   317         return;
 
   318     }
 
   318     }
 
   319 
   319 
   320     fsm->cycles_start = datagram->cycles_sent;
 
   320     fsm->jiffies_start = datagram->jiffies_sent;
 
   321 
   321 
   322     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   322     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   323     fsm->retries = EC_FSM_RETRIES;
 
   323     fsm->retries = EC_FSM_RETRIES;
 
   324     fsm->state = ec_fsm_coe_dict_check;
 
   324     fsm->state = ec_fsm_coe_dict_check;
 
   325 }
 
   325 }
 
   353         ec_datagram_print_wc_error(datagram);
 
   353         ec_datagram_print_wc_error(datagram);
 
   354         return;
 
   354         return;
 
   355     }
 
   355     }
 
   356 
   356 
   357     if (!ec_slave_mbox_check(datagram)) {
 
   357     if (!ec_slave_mbox_check(datagram)) {
 
   358         if (datagram->cycles_received
 
   358         unsigned long diff_ms =
 
   359             - fsm->cycles_start >= (cycles_t) 100 * cpu_khz) {
 
   359             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
       
   360         if (diff_ms >= 100) {
 
   360             fsm->state = ec_fsm_coe_error;
 
   361             fsm->state = ec_fsm_coe_error;
 
   361             EC_ERR("Timeout while checking Sdo dictionary on slave %u.\n",
 
   362             EC_ERR("Timeout while checking Sdo dictionary on slave %u.\n",
 
   362                    slave->ring_position);
 
   363                    slave->ring_position);
 
   363             return;
 
   364             return;
 
   364         }
 
   365         }
 
   492     if (slave->master->debug_level && fragments_left) {
 
   493     if (slave->master->debug_level && fragments_left) {
 
   493         EC_DBG("Sdo list fragments left: %u\n", fragments_left);
 
   494         EC_DBG("Sdo list fragments left: %u\n", fragments_left);
 
   494     }
 
   495     }
 
   495 
   496 
   496     if (EC_READ_U8(data + 2) & 0x80 || fragments_left) { // more messages waiting. check again.
 
   497     if (EC_READ_U8(data + 2) & 0x80 || fragments_left) { // more messages waiting. check again.
 
   497         fsm->cycles_start = datagram->cycles_sent;
 
   498         fsm->jiffies_start = datagram->jiffies_sent;
 
   498         ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   499         ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   499         fsm->retries = EC_FSM_RETRIES;
 
   500         fsm->retries = EC_FSM_RETRIES;
 
   500         fsm->state = ec_fsm_coe_dict_check;
 
   501         fsm->state = ec_fsm_coe_dict_check;
 
   501         return;
 
   502         return;
 
   502     }
 
   503     }
 
   554                 " request failed on slave %u: ", slave->ring_position);
 
   555                 " request failed on slave %u: ", slave->ring_position);
 
   555         ec_datagram_print_wc_error(datagram);
 
   556         ec_datagram_print_wc_error(datagram);
 
   556         return;
 
   557         return;
 
   557     }
 
   558     }
 
   558 
   559 
   559     fsm->cycles_start = datagram->cycles_sent;
 
   560     fsm->jiffies_start = datagram->jiffies_sent;
 
   560 
   561 
   561     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   562     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   562     fsm->retries = EC_FSM_RETRIES;
 
   563     fsm->retries = EC_FSM_RETRIES;
 
   563     fsm->state = ec_fsm_coe_dict_desc_check;
 
   564     fsm->state = ec_fsm_coe_dict_desc_check;
 
   564 }
 
   565 }
 
   592         ec_datagram_print_wc_error(datagram);
 
   593         ec_datagram_print_wc_error(datagram);
 
   593         return;
 
   594         return;
 
   594     }
 
   595     }
 
   595 
   596 
   596     if (!ec_slave_mbox_check(datagram)) {
 
   597     if (!ec_slave_mbox_check(datagram)) {
 
   597         if (datagram->cycles_received
 
   598         unsigned long diff_ms =
 
   598             - fsm->cycles_start >= (cycles_t) 100 * cpu_khz) {
 
   599             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
       
   600         if (diff_ms >= 100) {
 
   599             fsm->state = ec_fsm_coe_error;
 
   601             fsm->state = ec_fsm_coe_error;
 
   600             EC_ERR("Timeout while checking Sdo description on slave %u.\n",
 
   602             EC_ERR("Timeout while checking Sdo description on slave %u.\n",
 
   601                    slave->ring_position);
 
   603                    slave->ring_position);
 
   602             return;
 
   604             return;
 
   603         }
 
   605         }
 
   782                 slave->ring_position);
 
   784                 slave->ring_position);
 
   783         ec_datagram_print_wc_error(datagram);
 
   785         ec_datagram_print_wc_error(datagram);
 
   784         return;
 
   786         return;
 
   785     }
 
   787     }
 
   786 
   788 
   787     fsm->cycles_start = datagram->cycles_sent;
 
   789     fsm->jiffies_start = datagram->jiffies_sent;
 
   788 
   790 
   789     ec_slave_mbox_prepare_check(slave, datagram); // can not fail
 
   791     ec_slave_mbox_prepare_check(slave, datagram); // can not fail
 
   790     fsm->retries = EC_FSM_RETRIES;
 
   792     fsm->retries = EC_FSM_RETRIES;
 
   791     fsm->state = ec_fsm_coe_dict_entry_check;
 
   793     fsm->state = ec_fsm_coe_dict_entry_check;
 
   792 }
 
   794 }
 
   821         ec_datagram_print_wc_error(datagram);
 
   823         ec_datagram_print_wc_error(datagram);
 
   822         return;
 
   824         return;
 
   823     }
 
   825     }
 
   824 
   826 
   825     if (!ec_slave_mbox_check(datagram)) {
 
   827     if (!ec_slave_mbox_check(datagram)) {
 
   826         if (datagram->cycles_received
 
   828         unsigned long diff_ms =
 
   827             - fsm->cycles_start >= (cycles_t) 100 * cpu_khz) {
 
   829             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
       
   830         if (diff_ms >= 100) {
 
   828             fsm->state = ec_fsm_coe_error;
 
   831             fsm->state = ec_fsm_coe_error;
 
   829             EC_ERR("Timeout while checking Sdo entry on slave %u.\n",
 
   832             EC_ERR("Timeout while checking Sdo entry on slave %u.\n",
 
   830                    slave->ring_position);
 
   833                    slave->ring_position);
 
   831             return;
 
   834             return;
 
   832         }
 
   835         }
 
  1111                 slave->ring_position);
 
  1114                 slave->ring_position);
 
  1112         ec_datagram_print_wc_error(datagram);
 
  1115         ec_datagram_print_wc_error(datagram);
 
  1113         return;
 
  1116         return;
 
  1114     }
 
  1117     }
 
  1115 
  1118 
  1116     fsm->cycles_start = datagram->cycles_sent;
 
  1119     fsm->jiffies_start = datagram->jiffies_sent;
 
  1117 
  1120 
  1118     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
  1121     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
  1119     fsm->retries = EC_FSM_RETRIES;
 
  1122     fsm->retries = EC_FSM_RETRIES;
 
  1120     fsm->state = ec_fsm_coe_down_check;
 
  1123     fsm->state = ec_fsm_coe_down_check;
 
  1121 }
 
  1124 }
 
  1149         ec_datagram_print_wc_error(datagram);
 
  1152         ec_datagram_print_wc_error(datagram);
 
  1150         return;
 
  1153         return;
 
  1151     }
 
  1154     }
 
  1152 
  1155 
  1153     if (!ec_slave_mbox_check(datagram)) {
 
  1156     if (!ec_slave_mbox_check(datagram)) {
 
  1154         if (datagram->cycles_received
 
  1157         unsigned long diff_ms =
 
  1155             - fsm->cycles_start >= (cycles_t) 100 * cpu_khz) {
 
  1158             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
       
  1159         if (diff_ms >= 100) {
 
  1156             fsm->state = ec_fsm_coe_error;
 
  1160             fsm->state = ec_fsm_coe_error;
 
  1157             EC_ERR("Timeout while checking Sdo configuration on slave %u.\n",
 
  1161             EC_ERR("Timeout while checking Sdo configuration on slave %u.\n",
 
  1158                    slave->ring_position);
 
  1162                    slave->ring_position);
 
  1159             return;
 
  1163             return;
 
  1160         }
 
  1164         }
 
  1355                 slave->ring_position);
 
  1359                 slave->ring_position);
 
  1356         ec_datagram_print_wc_error(datagram);
 
  1360         ec_datagram_print_wc_error(datagram);
 
  1357         return;
 
  1361         return;
 
  1358     }
 
  1362     }
 
  1359 
  1363 
  1360     fsm->cycles_start = datagram->cycles_sent;
 
  1364     fsm->jiffies_start = datagram->jiffies_sent;
 
  1361 
  1365 
  1362     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
  1366     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
  1363     fsm->retries = EC_FSM_RETRIES;
 
  1367     fsm->retries = EC_FSM_RETRIES;
 
  1364     fsm->state = ec_fsm_coe_up_check;
 
  1368     fsm->state = ec_fsm_coe_up_check;
 
  1365 }
 
  1369 }
 
  1393         ec_datagram_print_wc_error(datagram);
 
  1397         ec_datagram_print_wc_error(datagram);
 
  1394         return;
 
  1398         return;
 
  1395     }
 
  1399     }
 
  1396 
  1400 
  1397     if (!ec_slave_mbox_check(datagram)) {
 
  1401     if (!ec_slave_mbox_check(datagram)) {
 
  1398         if (datagram->cycles_received
 
  1402         unsigned long diff_ms =
 
  1399             - fsm->cycles_start >= (cycles_t) 100 * cpu_khz) {
 
  1403             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
       
  1404         if (diff_ms >= 100) {
 
  1400             fsm->state = ec_fsm_coe_error;
 
  1405             fsm->state = ec_fsm_coe_error;
 
  1401             EC_ERR("Timeout while checking Sdo upload on slave %u.\n",
 
  1406             EC_ERR("Timeout while checking Sdo upload on slave %u.\n",
 
  1402                    slave->ring_position);
 
  1407                    slave->ring_position);
 
  1403             return;
 
  1408             return;
 
  1404         }
 
  1409         }
 
  1647                 " request failed on slave %u: ", slave->ring_position);
 
  1652                 " request failed on slave %u: ", slave->ring_position);
 
  1648         ec_datagram_print_wc_error(datagram);
 
  1653         ec_datagram_print_wc_error(datagram);
 
  1649         return;
 
  1654         return;
 
  1650     }
 
  1655     }
 
  1651 
  1656 
  1652     fsm->cycles_start = datagram->cycles_sent;
 
  1657     fsm->jiffies_start = datagram->jiffies_sent;
 
  1653 
  1658 
  1654     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
  1659     ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
  1655     fsm->retries = EC_FSM_RETRIES;
 
  1660     fsm->retries = EC_FSM_RETRIES;
 
  1656     fsm->state = ec_fsm_coe_up_seg_check;
 
  1661     fsm->state = ec_fsm_coe_up_seg_check;
 
  1657 }
 
  1662 }
 
  1685         ec_datagram_print_wc_error(datagram);
 
  1690         ec_datagram_print_wc_error(datagram);
 
  1686         return;
 
  1691         return;
 
  1687     }
 
  1692     }
 
  1688 
  1693 
  1689     if (!ec_slave_mbox_check(datagram)) {
 
  1694     if (!ec_slave_mbox_check(datagram)) {
 
  1690         if (datagram->cycles_received
 
  1695         unsigned long diff_ms =
 
  1691             - fsm->cycles_start >= (cycles_t) 100 * cpu_khz) {
 
  1696             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
       
  1697         if (diff_ms >= 100) {
 
  1692             fsm->state = ec_fsm_coe_error;
 
  1698             fsm->state = ec_fsm_coe_error;
 
  1693             EC_ERR("Timeout while checking Sdo upload segment on slave %u.\n",
 
  1699             EC_ERR("Timeout while checking Sdo upload segment on slave %u.\n",
 
  1694                    slave->ring_position);
 
  1700                    slave->ring_position);
 
  1695             return;
 
  1701             return;
 
  1696         }
 
  1702         }
etherlabmaster