master/fsm.c
changeset 442 6607875255d9
parent 441 ffa13db95e10
child 446 8fede404c01f
equal deleted inserted replaced
441:ffa13db95e10 442:6607875255d9
   555     }
   555     }
   556 
   556 
   557     // Check, if EoE processing has to be started
   557     // Check, if EoE processing has to be started
   558     ec_master_eoe_start(master);
   558     ec_master_eoe_start(master);
   559 
   559 
   560     // Check for a pending SDO request
   560     if (master->mode == EC_MASTER_MODE_IDLE) {
   561     if (master->sdo_seq_master != master->sdo_seq_user) {
   561 
   562         if (master->debug_level)
   562         // Check for a pending SDO request
   563             EC_DBG("Processing SDO request...\n");
   563         if (master->sdo_seq_master != master->sdo_seq_user) {
   564         slave = master->sdo_request->sdo->slave;
   564             if (master->debug_level)
   565         if (slave->current_state == EC_SLAVE_STATE_INIT
   565                 EC_DBG("Processing SDO request...\n");
   566             || !slave->online
   566             slave = master->sdo_request->sdo->slave;
   567             || slave->error_flag) {
   567             if (slave->current_state == EC_SLAVE_STATE_INIT
   568             EC_ERR("Failed to process SDO request, slave %i not ready.\n",
   568                 || !slave->online
   569                    slave->ring_position);
   569                 || slave->error_flag) {
   570             master->sdo_request->return_code = -1;
   570                 EC_ERR("Failed to process SDO request, slave %i not ready.\n",
   571             master->sdo_seq_master++;
   571                        slave->ring_position);
   572         }
   572                 master->sdo_request->return_code = -1;
   573         else {
   573                 master->sdo_seq_master++;
   574             // start uploading SDO
   574             }
       
   575             else {
       
   576                 // start uploading SDO
       
   577                 fsm->slave = slave;
       
   578                 fsm->master_state = ec_fsm_master_sdo_request;
       
   579                 fsm->sdo_request = master->sdo_request;
       
   580                 ec_fsm_coe_upload(&fsm->fsm_coe, slave, fsm->sdo_request);
       
   581                 ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
       
   582                 return;
       
   583             }
       
   584         }
       
   585 
       
   586         // check, if slaves have an SDO dictionary to read out.
       
   587         list_for_each_entry(slave, &master->slaves, list) {
       
   588             if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)
       
   589                 || slave->sdo_dictionary_fetched
       
   590                 || slave->current_state == EC_SLAVE_STATE_INIT
       
   591                 || jiffies - slave->jiffies_preop < EC_WAIT_SDO_DICT * HZ
       
   592                 || !slave->online
       
   593                 || slave->error_flag) continue;
       
   594 
       
   595             if (master->debug_level) {
       
   596                 EC_DBG("Fetching SDO dictionary from slave %i.\n",
       
   597                        slave->ring_position);
       
   598             }
       
   599 
       
   600             if (kobject_add(&slave->sdo_kobj)) {
       
   601                 EC_ERR("Failed to add SDO kobj of slave %i.\n",
       
   602                        slave->ring_position);
       
   603                 slave->error_flag = 1;
       
   604                 fsm->master_state = ec_fsm_master_start;
       
   605                 fsm->master_state(fsm); // execute immediately
       
   606                 return;
       
   607             }
       
   608 
       
   609             slave->sdo_dictionary_fetched = 1;
       
   610 
       
   611             // start fetching SDO dictionary
   575             fsm->slave = slave;
   612             fsm->slave = slave;
   576             fsm->master_state = ec_fsm_master_sdo_request;
   613             fsm->master_state = ec_fsm_master_sdodict;
   577             fsm->sdo_request = master->sdo_request;
   614             ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);
   578             ec_fsm_coe_upload(&fsm->fsm_coe, slave, fsm->sdo_request);
       
   579             ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
   615             ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
   580             return;
   616             return;
   581         }
   617         }
   582     }
   618 
   583 
   619         // check for pending EEPROM write operations.
   584     // check, if slaves have an SDO dictionary to read out.
       
   585     list_for_each_entry(slave, &master->slaves, list) {
       
   586         if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)
       
   587             || slave->sdo_dictionary_fetched
       
   588             || slave->current_state == EC_SLAVE_STATE_INIT
       
   589             || jiffies - slave->jiffies_preop < EC_WAIT_SDO_DICT * HZ
       
   590             || !slave->online
       
   591             || slave->error_flag) continue;
       
   592 
       
   593         if (master->debug_level) {
       
   594             EC_DBG("Fetching SDO dictionary from slave %i.\n",
       
   595                    slave->ring_position);
       
   596         }
       
   597 
       
   598         if (kobject_add(&slave->sdo_kobj)) {
       
   599             EC_ERR("Failed to add SDO kobj of slave %i.\n",
       
   600                    slave->ring_position);
       
   601             slave->error_flag = 1;
       
   602             fsm->master_state = ec_fsm_master_start;
       
   603             fsm->master_state(fsm); // execute immediately
       
   604             return;
       
   605         }
       
   606 
       
   607         slave->sdo_dictionary_fetched = 1;
       
   608 
       
   609         // start fetching SDO dictionary
       
   610         fsm->slave = slave;
       
   611         fsm->master_state = ec_fsm_master_sdodict;
       
   612         ec_fsm_coe_dictionary(&fsm->fsm_coe, slave);
       
   613         ec_fsm_coe_exec(&fsm->fsm_coe); // execute immediately
       
   614         return;
       
   615     }
       
   616 
       
   617     if (master->mode == EC_MASTER_MODE_IDLE) {
       
   618         // nothing to configure. check for pending EEPROM write operations.
       
   619         list_for_each_entry(slave, &master->slaves, list) {
   620         list_for_each_entry(slave, &master->slaves, list) {
   620             if (!slave->new_eeprom_data) continue;
   621             if (!slave->new_eeprom_data) continue;
   621 
   622 
   622             if (!slave->online || slave->error_flag) {
   623             if (!slave->online || slave->error_flag) {
   623                 kfree(slave->new_eeprom_data);
   624                 kfree(slave->new_eeprom_data);