etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:3702f0d6693b
+:370aa8c2d1b1
 fsm->slave_states = EC_READ_U8(datagram->data);
 ec_state_string(fsm->slave_states, states);
 EC_INFO("Slave states: %s.\n", states);
 }
-// topology change in idle mode: clear all slaves and scan the bus
+if (fsm->topology_change_pending) {
-if (fsm->topology_change_pending &&
+down(&master->scan_sem);
-master->mode == EC_MASTER_MODE_IDLE) {
+if (!master->allow_scan) {
-fsm->topology_change_pending = 0;
+up(&master->scan_sem);
-fsm->tainted = 0;
+}
-fsm->idle = 0;
+else {
-fsm->scan_jiffies = jiffies;
+master->scan_state = EC_REQUEST_IN_PROGRESS;
+up(&master->scan_sem);
-ec_master_eoe_stop(master);
-ec_master_destroy_slaves(master);
+// topology change when scan is allowed:
+// clear all slaves and scan the bus
-master->slave_count = datagram->working_counter;
+fsm->topology_change_pending = 0;
+fsm->tainted = 0;
-if (!master->slave_count) {
+fsm->idle = 0;
-// no slaves present -> finish state machine.
+fsm->scan_jiffies = jiffies;
-fsm->state = ec_fsm_master_state_end;
-return;
+ec_master_eoe_stop(master);
-}
+ec_master_destroy_slaves(master);
-// init slaves
+master->slave_count = datagram->working_counter;
-for (i = 0; i < master->slave_count; i++) {
-if (!(slave = (ec_slave_t *) kmalloc(sizeof(ec_slave_t),
+if (!master->slave_count) {
-GFP_ATOMIC))) {
+// no slaves present -> finish state machine.
-EC_ERR("Failed to allocate slave %i!\n", i);
+master->scan_state = EC_REQUEST_COMPLETE;
-ec_master_destroy_slaves(master);
+wake_up_interruptible(&master->scan_queue);
-fsm->state = ec_fsm_master_state_error;
+fsm->state = ec_fsm_master_state_end;
 return;
 }
-if (ec_slave_init(slave, master, i, i + 1)) {
+// init slaves
-// freeing of "slave" already done
+for (i = 0; i < master->slave_count; i++) {
-ec_master_destroy_slaves(master);
+if (!(slave = (ec_slave_t *) kmalloc(sizeof(ec_slave_t),
-fsm->state = ec_fsm_master_state_error;
+GFP_ATOMIC))) {
-return;
+EC_ERR("Failed to allocate slave %i!\n", i);
+ec_master_destroy_slaves(master);
+master->scan_state = EC_REQUEST_FAILURE;
+wake_up_interruptible(&master->scan_queue);
+fsm->state = ec_fsm_master_state_error;
+return;
+}
+if (ec_slave_init(slave, master, i, i + 1)) {
+// freeing of "slave" already done
+ec_master_destroy_slaves(master);
+master->scan_state = EC_REQUEST_FAILURE;
+wake_up_interruptible(&master->scan_queue);
+fsm->state = ec_fsm_master_state_error;
+return;
+}
+list_add_tail(&slave->list, &master->slaves);
 }
-list_add_tail(&slave->list, &master->slaves);
+EC_INFO("Scanning bus.\n");
-}
+// begin scanning of slaves
-EC_INFO("Scanning bus.\n");
+fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
+fsm->state = ec_fsm_master_state_scan_slaves;
-// begin scanning of slaves
+ec_fsm_slave_start_scan(&fsm->fsm_slave, fsm->slave);
-fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
+ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately
-fsm->state = ec_fsm_master_state_scan_slaves;
+return;
-ec_fsm_slave_start_scan(&fsm->fsm_slave, fsm->slave);
+}
-ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately
-return;
 }
 // fetch state from each slave
 fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
 ec_datagram_nprd(fsm->datagram, fsm->slave->station_address, 0x0130, 2);
 }
 /*****************************************************************************/
 /**
-Master action: PROC_STATES.
+*/
-Processes the slave states.
-*/
+int ec_fsm_master_action_configure(
+ec_fsm_master_t *fsm /**< master state machine */
-void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm
+)
-/**< master state machine */
+{
-)
+ec_slave_t *slave;
-{
 ec_master_t *master = fsm->master;
-ec_slave_t *slave;
 char old_state[EC_STATE_STRING_SIZE], new_state[EC_STATE_STRING_SIZE];
 // check if any slaves are not in the state, they're supposed to be
+// FIXME do not check all slaves in every cycle...
 list_for_each_entry(slave, &master->slaves, list) {
 if (slave->error_flag
 || slave->online_state == EC_SLAVE_OFFLINE
 || slave->requested_state == EC_SLAVE_STATE_UNKNOWN
 || (slave->current_state == slave->requested_state
 && slave->self_configured)) continue;
 if (master->debug_level) {
 ec_state_string(slave->current_state, old_state);
 if (slave->current_state != slave->requested_state) {
 ec_state_string(slave->requested_state, new_state);
 EC_DBG("Changing state of slave %i (%s -> %s).\n",
 slave->ring_position, old_state, new_state);
 }
 else if (!slave->self_configured) {
 EC_DBG("Reconfiguring slave %i (%s).\n",
 slave->ring_position, old_state);
 }
 }
 fsm->idle = 0;
 fsm->slave = slave;
 fsm->state = ec_fsm_master_state_configure_slave;
 ec_fsm_slave_start_conf(&fsm->fsm_slave, slave);
 ec_fsm_slave_exec(&fsm->fsm_slave); // execute immediately
-return;
+return 1;
+}
+if (fsm->config_error)
+master->config_state = EC_REQUEST_FAILURE;
+else
+master->config_state = EC_REQUEST_COMPLETE;
+wake_up_interruptible(&master->config_queue);
+return 0;
+}
+/*****************************************************************************/
+/**
+Master action: PROC_STATES.
+Processes the slave states.
+*/
+void ec_fsm_master_action_process_states(ec_fsm_master_t *fsm
+/**< master state machine */
+)
+{
+ec_master_t *master = fsm->master;
+ec_slave_t *slave;
+down(&master->config_sem);
+if (!master->allow_config) {
+up(&master->config_sem);
+}
+else {
+master->config_state = EC_REQUEST_IN_PROGRESS;
+fsm->config_error = 0;
+up(&master->config_sem);
+// check for pending slave configurations
+if (ec_fsm_master_action_configure(fsm))
+return;
 }
 // Check, if EoE processing has to be started
 ec_master_eoe_start(master);
 return;
 }
 EC_INFO("Bus scanning completed in %u ms.\n",
 (u32) (jiffies - fsm->scan_jiffies) * 1000 / HZ);
+master->scan_state = EC_REQUEST_COMPLETE;
-// set initial states of all slaves to PREOP to make mailbox
+wake_up_interruptible(&master->scan_queue);
-// communication possible
-list_for_each_entry(slave, &master->slaves, list) {
-if (slave->requested_state == EC_SLAVE_STATE_UNKNOWN)
-ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);
-}
 fsm->state = ec_fsm_master_state_end;
 }
 /*****************************************************************************/
 )
 {
 if (ec_fsm_slave_exec(&fsm->fsm_slave)) // execute slave's state machine
 return;
-ec_fsm_master_action_process_states(fsm);
+if (!ec_fsm_slave_success(&fsm->fsm_slave))
+fsm->config_error = 1;
+// configure next slave, if necessary
+if (ec_fsm_master_action_configure(fsm))
+return;
+fsm->state = ec_fsm_master_state_end;
 }
 /*****************************************************************************/
 /**

changeset 656	370aa8c2d1b1
parent 652	15cff76b66c7
child 661	bc1de1362efb