Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/fsm_slave_scan.c
changeset 986 a486591ba86b
parent 977 167ae3e76cc7
child 998 05a24788f3b2
equal deleted inserted replaced
985:90bcaf9ce3d5 986:a486591ba86b 
   185     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   185     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   186         return;
 
   186         return;
 
   187 
   187 
   188     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   188     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   189         fsm->state = ec_fsm_slave_scan_state_error;
 
   189         fsm->state = ec_fsm_slave_scan_state_error;
 
   190         EC_ERR("Failed to receive station address datagram for slave %i"
 
   190         EC_ERR("Failed to receive station address datagram for slave %u"
 
   191                 " (datagram state %i)\n",
 
   191                 " (datagram state %u)\n",
 
   192                 fsm->slave->ring_position, datagram->state);
 
   192                 fsm->slave->ring_position, datagram->state);
 
   193         return;
 
   193         return;
 
   194     }
 
   194     }
 
   195 
   195 
   196     if (datagram->working_counter != 1) {
 
   196     if (datagram->working_counter != 1) {
 
   197         fsm->slave->error_flag = 1;
 
   197         fsm->slave->error_flag = 1;
 
   198         fsm->state = ec_fsm_slave_scan_state_error;
 
   198         fsm->state = ec_fsm_slave_scan_state_error;
 
   199         EC_ERR("Failed to write station address on slave %i: ",
 
   199         EC_ERR("Failed to write station address on slave %u: ",
 
   200                fsm->slave->ring_position);
 
   200                fsm->slave->ring_position);
 
   201         ec_datagram_print_wc_error(datagram);
 
   201         ec_datagram_print_wc_error(datagram);
 
   202         return;
 
   202         return;
 
   203     }
 
   203     }
 
   204 
   204 
   224     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   224     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   225         return;
 
   225         return;
 
   226 
   226 
   227     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   227     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   228         fsm->state = ec_fsm_slave_scan_state_error;
 
   228         fsm->state = ec_fsm_slave_scan_state_error;
 
   229         EC_ERR("Failed to receive AL state datagram from slave %i"
 
   229         EC_ERR("Failed to receive AL state datagram from slave %u"
 
   230                 " (datagram state %i).\n",
 
   230                 " (datagram state %u).\n",
 
   231                fsm->slave->ring_position, datagram->state);
 
   231                fsm->slave->ring_position, datagram->state);
 
   232         return;
 
   232         return;
 
   233     }
 
   233     }
 
   234 
   234 
   235     if (datagram->working_counter != 1) {
 
   235     if (datagram->working_counter != 1) {
 
   236         fsm->slave->error_flag = 1;
 
   236         fsm->slave->error_flag = 1;
 
   237         fsm->state = ec_fsm_slave_scan_state_error;
 
   237         fsm->state = ec_fsm_slave_scan_state_error;
 
   238         EC_ERR("Failed to read AL state of slave %i: ",
 
   238         EC_ERR("Failed to read AL state of slave %u: ",
 
   239                fsm->slave->ring_position);
 
   239                fsm->slave->ring_position);
 
   240         ec_datagram_print_wc_error(datagram);
 
   240         ec_datagram_print_wc_error(datagram);
 
   241         return;
 
   241         return;
 
   242     }
 
   242     }
 
   243 
   243 
   244     slave->current_state = EC_READ_U8(datagram->data);
 
   244     slave->current_state = EC_READ_U8(datagram->data);
 
   245     if (slave->current_state & EC_SLAVE_STATE_ACK_ERR) {
 
   245     if (slave->current_state & EC_SLAVE_STATE_ACK_ERR) {
 
   246         char state_str[EC_STATE_STRING_SIZE];
 
   246         char state_str[EC_STATE_STRING_SIZE];
 
   247         ec_state_string(slave->current_state, state_str);
 
   247         ec_state_string(slave->current_state, state_str);
 
   248         EC_WARN("Slave %i has state error bit set (%s)!\n",
 
   248         EC_WARN("Slave %u has state error bit set (%s)!\n",
 
   249                 slave->ring_position, state_str);
 
   249                 slave->ring_position, state_str);
 
   250     }
 
   250     }
 
   251 
   251 
   252     // read base data
 
   252     // read base data
 
   253     ec_datagram_fprd(datagram, fsm->slave->station_address, 0x0000, 6);
 
   253     ec_datagram_fprd(datagram, fsm->slave->station_address, 0x0000, 6);
 
   269     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   269     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   270         return;
 
   270         return;
 
   271 
   271 
   272     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   272     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   273         fsm->state = ec_fsm_slave_scan_state_error;
 
   273         fsm->state = ec_fsm_slave_scan_state_error;
 
   274         EC_ERR("Failed to receive base data datagram for slave %i"
 
   274         EC_ERR("Failed to receive base data datagram for slave %u"
 
   275                 " (datagram state %i).\n",
 
   275                 " (datagram state %u).\n",
 
   276                slave->ring_position, datagram->state);
 
   276                slave->ring_position, datagram->state);
 
   277         return;
 
   277         return;
 
   278     }
 
   278     }
 
   279 
   279 
   280     if (datagram->working_counter != 1) {
 
   280     if (datagram->working_counter != 1) {
 
   281         fsm->slave->error_flag = 1;
 
   281         fsm->slave->error_flag = 1;
 
   282         fsm->state = ec_fsm_slave_scan_state_error;
 
   282         fsm->state = ec_fsm_slave_scan_state_error;
 
   283         EC_ERR("Failed to read base data from slave %i: ",
 
   283         EC_ERR("Failed to read base data from slave %u: ",
 
   284                slave->ring_position);
 
   284                slave->ring_position);
 
   285         ec_datagram_print_wc_error(datagram);
 
   285         ec_datagram_print_wc_error(datagram);
 
   286         return;
 
   286         return;
 
   287     }
 
   287     }
 
   288 
   288 
   320     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   320     if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 
   321         return;
 
   321         return;
 
   322 
   322 
   323     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   323     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   324         fsm->state = ec_fsm_slave_scan_state_error;
 
   324         fsm->state = ec_fsm_slave_scan_state_error;
 
   325         EC_ERR("Failed to receive DL status datagram from slave %i"
 
   325         EC_ERR("Failed to receive DL status datagram from slave %u"
 
   326                 " (datagram state %i).\n",
 
   326                 " (datagram state %u).\n",
 
   327                slave->ring_position, datagram->state);
 
   327                slave->ring_position, datagram->state);
 
   328         return;
 
   328         return;
 
   329     }
 
   329     }
 
   330 
   330 
   331     if (datagram->working_counter != 1) {
 
   331     if (datagram->working_counter != 1) {
 
   332         fsm->slave->error_flag = 1;
 
   332         fsm->slave->error_flag = 1;
 
   333         fsm->state = ec_fsm_slave_scan_state_error;
 
   333         fsm->state = ec_fsm_slave_scan_state_error;
 
   334         EC_ERR("Failed to read DL status from slave %i: ",
 
   334         EC_ERR("Failed to read DL status from slave %u: ",
 
   335                slave->ring_position);
 
   335                slave->ring_position);
 
   336         ec_datagram_print_wc_error(datagram);
 
   336         ec_datagram_print_wc_error(datagram);
 
   337         return;
 
   337         return;
 
   338     }
 
   338     }
 
   339 
   339 
   367     if (ec_fsm_sii_exec(&fsm->fsm_sii)) return;
 
   367     if (ec_fsm_sii_exec(&fsm->fsm_sii)) return;
 
   368 
   368 
   369     if (!ec_fsm_sii_success(&fsm->fsm_sii)) {
 
   369     if (!ec_fsm_sii_success(&fsm->fsm_sii)) {
 
   370         fsm->slave->error_flag = 1;
 
   370         fsm->slave->error_flag = 1;
 
   371         fsm->state = ec_fsm_slave_scan_state_error;
 
   371         fsm->state = ec_fsm_slave_scan_state_error;
 
   372         EC_ERR("Failed to read SII size of slave %i.\n",
 
   372         EC_ERR("Failed to read SII size of slave %u.\n",
 
   373                slave->ring_position);
 
   373                slave->ring_position);
 
   374         return;
 
   374         return;
 
   375     }
 
   375     }
 
   376 
   376 
   377     cat_type = EC_READ_U16(fsm->fsm_sii.value);
 
   377     cat_type = EC_READ_U16(fsm->fsm_sii.value);
 
   378     cat_size = EC_READ_U16(fsm->fsm_sii.value + 2);
 
   378     cat_size = EC_READ_U16(fsm->fsm_sii.value + 2);
 
   379 
   379 
   380     if (cat_type != 0xFFFF) { // not the last category
 
   380     if (cat_type != 0xFFFF) { // not the last category
 
   381         off_t next_offset = 2UL + fsm->sii_offset + cat_size;
 
   381         off_t next_offset = 2UL + fsm->sii_offset + cat_size;
 
   382         if (next_offset >= EC_MAX_SII_SIZE) {
 
   382         if (next_offset >= EC_MAX_SII_SIZE) {
 
   383             EC_WARN("SII size of slave %i exceeds"
 
   383             EC_WARN("SII size of slave %u exceeds"
 
   384                     " %u words (0xffff limiter missing?).\n",
 
   384                     " %u words (0xffff limiter missing?).\n",
 
   385                     slave->ring_position, EC_MAX_SII_SIZE);
 
   385                     slave->ring_position, EC_MAX_SII_SIZE);
 
   386             // cut off category data...
 
   386             // cut off category data...
 
   387             slave->sii_nwords = EC_FIRST_SII_CATEGORY_OFFSET;
 
   387             slave->sii_nwords = EC_FIRST_SII_CATEGORY_OFFSET;
 
   388             goto alloc_sii;
 
   388             goto alloc_sii;
 
   396 
   396 
   397     slave->sii_nwords = fsm->sii_offset + 1;
 
   397     slave->sii_nwords = fsm->sii_offset + 1;
 
   398 
   398 
   399 alloc_sii:
 
   399 alloc_sii:
 
   400     if (slave->sii_words) {
 
   400     if (slave->sii_words) {
 
   401         EC_WARN("Freeing old SII data on slave %i...\n",
 
   401         EC_WARN("Freeing old SII data on slave %u...\n",
 
   402                 slave->ring_position);
 
   402                 slave->ring_position);
 
   403         kfree(slave->sii_words);
 
   403         kfree(slave->sii_words);
 
   404     }
 
   404     }
 
   405 
   405 
   406     if (!(slave->sii_words =
 
   406     if (!(slave->sii_words =
 
   436     if (ec_fsm_sii_exec(&fsm->fsm_sii)) return;
 
   436     if (ec_fsm_sii_exec(&fsm->fsm_sii)) return;
 
   437 
   437 
   438     if (!ec_fsm_sii_success(&fsm->fsm_sii)) {
 
   438     if (!ec_fsm_sii_success(&fsm->fsm_sii)) {
 
   439         fsm->slave->error_flag = 1;
 
   439         fsm->slave->error_flag = 1;
 
   440         fsm->state = ec_fsm_slave_scan_state_error;
 
   440         fsm->state = ec_fsm_slave_scan_state_error;
 
   441         EC_ERR("Failed to fetch SII contents of slave %i.\n",
 
   441         EC_ERR("Failed to fetch SII contents of slave %u.\n",
 
   442                slave->ring_position);
 
   442                slave->ring_position);
 
   443         return;
 
   443         return;
 
   444     }
 
   444     }
 
   445 
   445 
   446     // 2 words fetched
 
   446     // 2 words fetched
 
   549                             cat_size * 2, EC_DIR_OUTPUT)) // RxPdo
 
   549                             cat_size * 2, EC_DIR_OUTPUT)) // RxPdo
 
   550                     goto end;
 
   550                     goto end;
 
   551                 break;
 
   551                 break;
 
   552             default:
 
   552             default:
 
   553                 if (fsm->slave->master->debug_level)
 
   553                 if (fsm->slave->master->debug_level)
 
   554                     EC_WARN("Unknown category type 0x%04X in slave %i.\n",
 
   554                     EC_WARN("Unknown category type 0x%04X in slave %u.\n",
 
   555                             cat_type, slave->ring_position);
 
   555                             cat_type, slave->ring_position);
 
   556         }
 
   556         }
 
   557 
   557 
   558         cat_word += cat_size;
 
   558         cat_word += cat_size;
 
   559         if (cat_word - slave->sii_words >= slave->sii_nwords) {
 
   559         if (cat_word - slave->sii_words >= slave->sii_nwords) {
etherlabmaster