etherlabmaster: comparison master/fsm.c

equal deleted inserted replaced

-:ffec9aae50a5
+:d50b139c8601
 void ec_fsm_master_rewrite_addresses(ec_fsm_t *);
 void ec_fsm_master_configure_slave(ec_fsm_t *);
 void ec_fsm_master_scan_slaves(ec_fsm_t *);
 void ec_fsm_master_write_eeprom(ec_fsm_t *);
-void ec_fsm_slave_start_reading(ec_fsm_t *);
+void ec_fsm_slavescan_start(ec_fsm_t *);
-void ec_fsm_slave_read_state(ec_fsm_t *);
+void ec_fsm_slavescan_state(ec_fsm_t *);
-void ec_fsm_slave_read_base(ec_fsm_t *);
+void ec_fsm_slavescan_base(ec_fsm_t *);
-void ec_fsm_slave_read_dl(ec_fsm_t *);
+void ec_fsm_slavescan_datalink(ec_fsm_t *);
-void ec_fsm_slave_eeprom_size(ec_fsm_t *);
+void ec_fsm_slavescan_eeprom_size(ec_fsm_t *);
-void ec_fsm_slave_fetch_eeprom(ec_fsm_t *);
+void ec_fsm_slavescan_eeprom_data(ec_fsm_t *);
-void ec_fsm_slave_fetch_eeprom2(ec_fsm_t *);
+void ec_fsm_slavescan_eeprom_data2(ec_fsm_t *);
-void ec_fsm_slave_end(ec_fsm_t *);
+void ec_fsm_slavescan_end(ec_fsm_t *);
-void ec_fsm_slave_conf(ec_fsm_t *);
+void ec_fsm_slaveconf_start(ec_fsm_t *);
-void ec_fsm_slave_sync(ec_fsm_t *);
+void ec_fsm_slaveconf_sync(ec_fsm_t *);
-void ec_fsm_slave_preop(ec_fsm_t *);
+void ec_fsm_slaveconf_preop(ec_fsm_t *);
-void ec_fsm_slave_fmmu(ec_fsm_t *);
+void ec_fsm_slaveconf_fmmu(ec_fsm_t *);
-void ec_fsm_slave_saveop(ec_fsm_t *);
+void ec_fsm_slaveconf_saveop(ec_fsm_t *);
-void ec_fsm_slave_op(ec_fsm_t *);
+void ec_fsm_slaveconf_op(ec_fsm_t *);
-void ec_fsm_slave_op2(ec_fsm_t *);
+void ec_fsm_slaveconf_op2(ec_fsm_t *);
+void ec_fsm_slaveconf_end(ec_fsm_t *);
 void ec_fsm_sii_start_reading(ec_fsm_t *);
 void ec_fsm_sii_read_check(ec_fsm_t *);
 void ec_fsm_sii_read_fetch(ec_fsm_t *);
 void ec_fsm_sii_start_writing(ec_fsm_t *);
 list_add_tail(&slave->list, &master->slaves);
 }
 // begin scanning of slaves
 fsm->slave = list_entry(master->slaves.next, ec_slave_t, list);
-fsm->slave_state = ec_fsm_slave_start_reading;
+fsm->slave_state = ec_fsm_slavescan_start;
 fsm->master_state = ec_fsm_master_scan_slaves;
 fsm->master_state(fsm); // execute immediately
 return;
 }
 printk(" to ");
 ec_print_states(slave->requested_state);
 printk(".\n");
 fsm->slave = slave;
-fsm->slave_state = ec_fsm_slave_conf;
+fsm->slave_state = ec_fsm_slaveconf_start;
 fsm->change_new = EC_SLAVE_STATE_INIT;
 fsm->change_state = ec_fsm_change_start;
 fsm->master_state = ec_fsm_master_configure_slave;
 fsm->master_state(fsm); // execute immediately
 return;
 uint16_t reverse_coupler_index, current_coupler_index;
 ec_slave_ident_t *ident;
 fsm->slave_state(fsm); // execute slave state machine
-if (fsm->slave_state != ec_fsm_slave_end) return;
+if (fsm->slave_state != ec_fsm_slavescan_end) return;
 // have all slaves been fetched?
 if (slave->list.next == &master->slaves) {
 EC_INFO("Bus scanning completed.\n");
 return;
 }
 // process next slave
 fsm->slave = list_entry(fsm->slave->list.next, ec_slave_t, list);
-fsm->slave_state = ec_fsm_slave_start_reading;
+fsm->slave_state = ec_fsm_slavescan_start;
 fsm->slave_state(fsm); // execute immediately
 }
 /*****************************************************************************/
 void ec_fsm_master_configure_slave(ec_fsm_t *fsm
 /**< finite state machine */
 )
 {
 fsm->slave_state(fsm); // execute slave's state machine
-if (fsm->slave_state != ec_fsm_slave_end) return;
+if (fsm->slave_state != ec_fsm_slaveconf_end) return;
 ec_fsm_master_action_process_states(fsm);
 }
 /*****************************************************************************/
 EC_INFO("Finished writing EEPROM of slave %i.\n", slave->ring_position);
 kfree(slave->new_eeprom_data);
 slave->new_eeprom_data = NULL;
 // restart master state machine.
-fsm->master_state = ec_fsm_master_start; // TODO: Scan slaves!
+fsm->master_state = ec_fsm_master_start; // TODO: Evaluate new contents!
 fsm->master_state(fsm); // execute immediately
 return;
 }
 /******************************************************************************
-*  slave state machine
+*  slave scan sub state machine
 *****************************************************************************/
 /**
 Slave state: START_READING.
 First state of the slave state machine. Writes the station address to the
 slave, according to its ring position.
 */
-void ec_fsm_slave_start_reading(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_start(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 // write station address
 ec_datagram_apwr(datagram, fsm->slave->ring_position, 0x0010, 2);
 EC_WRITE_U16(datagram->data, fsm->slave->station_address);
 ec_master_queue_datagram(fsm->master, datagram);
-fsm->slave_state = ec_fsm_slave_read_state;
+fsm->slave_state = ec_fsm_slavescan_state;
 }
 /*****************************************************************************/
 /**
 Slave state: READ_STATUS.
 */
-void ec_fsm_slave_read_state(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_state(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to write station address of slave %i.\n",
 fsm->slave->ring_position);
 return;
 }
 // Read AL state
 ec_datagram_nprd(datagram, fsm->slave->station_address, 0x0130, 2);
 ec_master_queue_datagram(fsm->master, datagram);
-fsm->slave_state = ec_fsm_slave_read_base;
+fsm->slave_state = ec_fsm_slavescan_base;
 }
 /*****************************************************************************/
 /**
 Slave state: READ_BASE.
 */
-void ec_fsm_slave_read_base(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_base(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to read AL state of slave %i.\n",
 fsm->slave->ring_position);
 return;
 }
 }
 // read base data
 ec_datagram_nprd(datagram, fsm->slave->station_address, 0x0000, 6);
 ec_master_queue_datagram(fsm->master, datagram);
-fsm->slave_state = ec_fsm_slave_read_dl;
+fsm->slave_state = ec_fsm_slavescan_datalink;
 }
 /*****************************************************************************/
 /**
 Slave state: READ_DL.
 */
-void ec_fsm_slave_read_dl(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_datalink(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to read base data of slave %i.\n",
 slave->ring_position);
 return;
 }
 slave->base_fmmu_count = EC_MAX_FMMUS;
 // read data link status
 ec_datagram_nprd(datagram, slave->station_address, 0x0110, 2);
 ec_master_queue_datagram(slave->master, datagram);
-fsm->slave_state = ec_fsm_slave_eeprom_size;
+fsm->slave_state = ec_fsm_slavescan_eeprom_size;
 }
 /*****************************************************************************/
 /**
 Slave state: EEPROM_SIZE.
 Read the actual size of the EEPROM to allocate the EEPROM image.
 */
-void ec_fsm_slave_eeprom_size(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_eeprom_size(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 uint16_t dl_status;
 unsigned int i;
 if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to read DL status of slave %i.\n",
 slave->ring_position);
 return;
 }
 // Start fetching EEPROM size
 fsm->sii_offset = 0x0040; // first category header
 fsm->sii_mode = 1;
 fsm->sii_state = ec_fsm_sii_start_reading;
-fsm->slave_state = ec_fsm_slave_fetch_eeprom;
+fsm->slave_state = ec_fsm_slavescan_eeprom_data;
 fsm->slave_state(fsm); // execute state immediately
 }
 /*****************************************************************************/
 /**
 Slave state: FETCH_EEPROM.
 */
-void ec_fsm_slave_fetch_eeprom(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_eeprom_data(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 uint16_t cat_type, cat_size;
 // execute SII state machine
 fsm->sii_state(fsm);
 if (fsm->sii_state == ec_fsm_sii_error) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to read EEPROM size of slave %i.\n",
 slave->ring_position);
 return;
 }
 }
 if (!(slave->eeprom_data =
 (uint8_t *) kmalloc(slave->eeprom_size, GFP_ATOMIC))) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to allocate EEPROM data on slave %i.\n",
 slave->ring_position);
 return;
 }
 // Start fetching EEPROM contents
 fsm->sii_offset = 0x0000;
 fsm->sii_mode = 1;
 fsm->sii_state = ec_fsm_sii_start_reading;
-fsm->slave_state = ec_fsm_slave_fetch_eeprom2;
+fsm->slave_state = ec_fsm_slavescan_eeprom_data2;
 fsm->slave_state(fsm); // execute state immediately
 }
 /*****************************************************************************/
 /**
 Slave state: FETCH_EEPROM2.
 */
-void ec_fsm_slave_fetch_eeprom2(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slavescan_eeprom_data2(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 uint16_t *cat_word, cat_type, cat_size;
 // execute SII state machine
 fsm->sii_state(fsm);
 if (fsm->sii_state == ec_fsm_sii_error) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 EC_ERR("Failed to fetch EEPROM contents of slave %i.\n",
 slave->ring_position);
 return;
 }
 cat_word += cat_size + 2;
 }
 end:
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slavescan_end;
 }
 /*****************************************************************************/
+/**
+Slave state: END.
+End state of the slave state machine.
+*/
+void ec_fsm_slavescan_end(ec_fsm_t *fsm /**< finite state machine */)
+{
+}
+/******************************************************************************
+*  slave configuration sub state machine
+*****************************************************************************/
 /**
 Slave state: CONF.
 */
-void ec_fsm_slave_conf(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_start(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 ec_master_t *master = fsm->master;
 ec_datagram_t *datagram = &fsm->datagram;
 fsm->change_state(fsm); // execute state change state machine
 if (fsm->change_state == ec_fsm_change_error) {
 slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 return;
 }
 if (fsm->change_state != ec_fsm_change_end) return;
 // slave is now in INIT
 if (slave->current_state == slave->requested_state) {
-fsm->slave_state = ec_fsm_slave_end; // successful
+fsm->slave_state = ec_fsm_slaveconf_end; // successful
 return;
 }
 // check for slave registration
 if (!slave->type) {
 // check and reset CRC fault counters
 //ec_slave_check_crc(slave);
 if (!slave->base_fmmu_count) { // no fmmus
-fsm->slave_state = ec_fsm_slave_sync;
+fsm->slave_state = ec_fsm_slaveconf_sync;
 fsm->slave_state(fsm); // execute immediately
 return;
 }
 // reset FMMUs
 ec_datagram_npwr(datagram, slave->station_address, 0x0600,
 EC_FMMU_SIZE * slave->base_fmmu_count);
 memset(datagram->data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);
 ec_master_queue_datagram(master, datagram);
-fsm->slave_state = ec_fsm_slave_sync;
+fsm->slave_state = ec_fsm_slaveconf_sync;
 }
 /*****************************************************************************/
 /**
 Slave state: SYNC.
 Configure sync managers.
 */
-void ec_fsm_slave_sync(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_sync(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 unsigned int j;
 const ec_sync_t *sync;
 ec_eeprom_sync_t *eeprom_sync, mbox_sync;
 if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 EC_ERR("Failed to reset FMMUs of slave %i.\n",
 slave->ring_position);
 return;
 }
 if (!slave->base_sync_count) { // no sync managers
-fsm->slave_state = ec_fsm_slave_preop;
+fsm->slave_state = ec_fsm_slaveconf_preop;
 fsm->slave_state(fsm); // execute immediately
 return;
 }
 // configure sync managers
 // does the slave supply sync manager configurations in its EEPROM?
 if (!list_empty(&slave->eeprom_syncs)) {
 list_for_each_entry(eeprom_sync, &slave->eeprom_syncs, list) {
 if (eeprom_sync->index >= slave->base_sync_count) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 EC_ERR("Invalid sync manager configuration found!");
 return;
 }
 ec_eeprom_sync_config(eeprom_sync, slave,
 datagram->data + EC_SYNC_SIZE
 EC_INFO("Mailbox configured for unknown slave %i\n",
 slave->ring_position);
 }
 ec_master_queue_datagram(fsm->master, datagram);
-fsm->slave_state = ec_fsm_slave_preop;
+fsm->slave_state = ec_fsm_slaveconf_preop;
 }
 /*****************************************************************************/
 /**
 Slave state: PREOP.
 Change slave state to PREOP.
 */
-void ec_fsm_slave_preop(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_preop(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 if (datagram->state != EC_CMD_RECEIVED || datagram->working_counter != 1) {
 slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 EC_ERR("Failed to set sync managers on slave %i.\n",
 slave->ring_position);
 return;
 }
 fsm->change_new = EC_SLAVE_STATE_PREOP;
 fsm->change_state = ec_fsm_change_start;
-fsm->slave_state = ec_fsm_slave_fmmu;
+fsm->slave_state = ec_fsm_slaveconf_fmmu;
 fsm->change_state(fsm); // execute immediately
 }
 /*****************************************************************************/
 /**
 Slave state: FMMU.
 Configure FMMUs.
 */
-void ec_fsm_slave_fmmu(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_fmmu(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_slave_t *slave = fsm->slave;
 ec_master_t *master = fsm->master;
 ec_datagram_t *datagram = &fsm->datagram;
 unsigned int j;
 fsm->change_state(fsm); // execute state change state machine
 if (fsm->change_state == ec_fsm_change_error) {
 slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 return;
 }
 if (fsm->change_state != ec_fsm_change_end) return;
 // slave is now in PREOP
 if (slave->current_state == slave->requested_state) {
-fsm->slave_state = ec_fsm_slave_end; // successful
+fsm->slave_state = ec_fsm_slaveconf_end; // successful
 return;
 }
 // stop activation here for slaves without type
 if (!slave->type) {
-fsm->slave_state = ec_fsm_slave_end; // successful
+fsm->slave_state = ec_fsm_slaveconf_end; // successful
 return;
 }
 if (!slave->base_fmmu_count) {
-fsm->slave_state = ec_fsm_slave_saveop;
+fsm->slave_state = ec_fsm_slaveconf_saveop;
 fsm->slave_state(fsm); // execute immediately
 return;
 }
 // configure FMMUs
 ec_fmmu_config(&slave->fmmus[j], slave,
 datagram->data + EC_FMMU_SIZE * j);
 }
 ec_master_queue_datagram(master, datagram);
-fsm->slave_state = ec_fsm_slave_saveop;
+fsm->slave_state = ec_fsm_slaveconf_saveop;
 }
 /*****************************************************************************/
 /**
 Slave state: SAVEOP.
 Set slave state to SAVEOP.
 */
-void ec_fsm_slave_saveop(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_saveop(ec_fsm_t *fsm /**< finite state machine */)
 {
 ec_datagram_t *datagram = &fsm->datagram;
 if (fsm->slave->base_fmmu_count && (datagram->state != EC_CMD_RECEIVED ||
 datagram->working_counter != 1)) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 EC_ERR("Failed to set FMMUs on slave %i.\n",
 fsm->slave->ring_position);
 return;
 }
 // set state to SAVEOP
-fsm->slave_state = ec_fsm_slave_op;
+fsm->slave_state = ec_fsm_slaveconf_op;
 fsm->change_new = EC_SLAVE_STATE_SAVEOP;
 fsm->change_state = ec_fsm_change_start;
 fsm->change_state(fsm); // execute immediately
 }
 /**
 Slave state: OP.
 Set slave state to OP.
 */
-void ec_fsm_slave_op(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_op(ec_fsm_t *fsm /**< finite state machine */)
 {
 fsm->change_state(fsm); // execute state change state machine
 if (fsm->change_state == ec_fsm_change_error) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 return;
 }
 if (fsm->change_state != ec_fsm_change_end) return;
 // slave is now in SAVEOP
 if (fsm->slave->current_state == fsm->slave->requested_state) {
-fsm->slave_state = ec_fsm_slave_end; // successful
+fsm->slave_state = ec_fsm_slaveconf_end; // successful
 return;
 }
 // set state to OP
-fsm->slave_state = ec_fsm_slave_op2;
+fsm->slave_state = ec_fsm_slaveconf_op2;
 fsm->change_new = EC_SLAVE_STATE_OP;
 fsm->change_state = ec_fsm_change_start;
 fsm->change_state(fsm); // execute immediately
 }
 /**
 Slave state: OP2
 Executes the change state machine, until the OP state is set.
 */
-void ec_fsm_slave_op2(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_op2(ec_fsm_t *fsm /**< finite state machine */)
 {
 fsm->change_state(fsm); // execute state change state machine
 if (fsm->change_state == ec_fsm_change_error) {
 fsm->slave->error_flag = 1;
-fsm->slave_state = ec_fsm_slave_end;
+fsm->slave_state = ec_fsm_slaveconf_end;
 return;
 }
 if (fsm->change_state != ec_fsm_change_end) return;
 // slave is now in OP
-fsm->slave_state = ec_fsm_slave_end; // successful
+fsm->slave_state = ec_fsm_slaveconf_end; // successful
 }
 /*****************************************************************************/
 /**
 Slave state: END.
 End state of the slave state machine.
 */
-void ec_fsm_slave_end(ec_fsm_t *fsm /**< finite state machine */)
+void ec_fsm_slaveconf_end(ec_fsm_t *fsm /**< finite state machine */)
 {
 }
 /******************************************************************************
-*  SII state machine
+*  SII sub state machine
 *****************************************************************************/
 /**
 SII state: START_READING.
 Starts reading the slave information interface.
 void ec_fsm_sii_error(ec_fsm_t *fsm /**< finite state machine */)
 {
 }
 /******************************************************************************
-*  state change state machine
+*  state change sub state machine
 *****************************************************************************/
 /**
 Change state: START.
 */

changeset 308	d50b139c8601
parent 306	45886de3db87
child 309	42e69cf31495