etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:57020c731092
+:3c886ec376f5
 void ec_fsm_master_state_clear_addresses(ec_fsm_master_t *);
 void ec_fsm_master_state_scan_slave(ec_fsm_master_t *);
 void ec_fsm_master_state_write_sii(ec_fsm_master_t *);
 void ec_fsm_master_state_sdo_dictionary(ec_fsm_master_t *);
 void ec_fsm_master_state_sdo_request(ec_fsm_master_t *);
-void ec_fsm_master_state_phy_request(ec_fsm_master_t *);
+void ec_fsm_master_state_reg_request(ec_fsm_master_t *);
 void ec_fsm_master_state_foe_request(ec_fsm_master_t *);
 /*****************************************************************************/
 /** Constructor.
 return 0;
 }
 /*****************************************************************************/
-/** Check for pending phy requests and process one.
+/** Check for pending register requests and process one.
 *
-* \return non-zero, if a phy request is processed.
+* \return non-zero, if a register request is processed.
 */
-int ec_fsm_master_action_process_phy(
+int ec_fsm_master_action_process_register(
 ec_fsm_master_t *fsm /**< Master state machine. */
 )
 {
 ec_master_t *master = fsm->master;
-ec_phy_request_t *request;
+ec_reg_request_t *request;
 // search the first request to be processed
-while (!list_empty(&master->phy_requests)) {
+while (!list_empty(&master->reg_requests)) {
 // get first request
-request = list_entry(master->phy_requests.next,
+request = list_entry(master->reg_requests.next,
-ec_phy_request_t, list);
+ec_reg_request_t, list);
 list_del_init(&request->list); // dequeue
 request->state = EC_INT_REQUEST_BUSY;
 // found pending request; process it!
 if (master->debug_level)
-EC_DBG("Processing phy request for slave %u, "
+EC_DBG("Processing register request for slave %u, "
 "offset 0x%04x, length %u...\n",
 request->slave->ring_position,
 request->offset, request->length);
 if (request->length > fsm->datagram->mem_size) {
 EC_ERR("Request length (%u) exceeds maximum "
 "datagram size (%u)!\n", request->length,
 fsm->datagram->mem_size);
 request->state = EC_INT_REQUEST_FAILURE;
-wake_up(&master->phy_queue);
+wake_up(&master->reg_queue);
 continue;
 }
-fsm->phy_request = request;
+fsm->reg_request = request;
 if (request->dir == EC_DIR_INPUT) {
 ec_datagram_fprd(fsm->datagram, request->slave->station_address,
 request->offset, request->length);
 ec_datagram_zero(fsm->datagram);
 ec_datagram_fpwr(fsm->datagram, request->slave->station_address,
 request->offset, request->length);
 memcpy(fsm->datagram->data, request->data, request->length);
 }
 fsm->retries = EC_FSM_RETRIES;
-fsm->state = ec_fsm_master_state_phy_request;
+fsm->state = ec_fsm_master_state_reg_request;
 return 1;
 }
 return 0;
 }
 // check for pending SII write operations.
 if (ec_fsm_master_action_process_sii(fsm))
 return; // SII write request found
-// check for pending phy requests.
+// check for pending register requests.
-if (ec_fsm_master_action_process_phy(fsm))
+if (ec_fsm_master_action_process_register(fsm))
-return; // phy request processing
+return; // register request processing
 ec_fsm_master_restart(fsm);
 }
 /*****************************************************************************/
 ec_fsm_master_restart(fsm);
 }
 /*****************************************************************************/
-/** Master state: PHY.
+/** Master state: REG REQUEST.
 */
-void ec_fsm_master_state_phy_request(
+void ec_fsm_master_state_reg_request(
 ec_fsm_master_t *fsm /**< Master state machine. */
 )
 {
 ec_master_t *master = fsm->master;
 ec_datagram_t *datagram = fsm->datagram;
-ec_phy_request_t *request = fsm->phy_request;
+ec_reg_request_t *request = fsm->reg_request;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
-EC_ERR("Failed to receive phy request datagram (state %u).\n",
+EC_ERR("Failed to receive register request datagram (state %u).\n",
 datagram->state);
 request->state = EC_INT_REQUEST_FAILURE;
-wake_up(&master->phy_queue);
+wake_up(&master->reg_queue);
 ec_fsm_master_restart(fsm);
 return;
 }
 if (datagram->working_counter == 1) {
 if (request->dir == EC_DIR_INPUT) { // read request
 if (request->data)
 kfree(request->data);
 request->data = kmalloc(request->length, GFP_KERNEL);
 if (!request->data) {
-EC_ERR("Failed to allocate %u bytes of memory for phy request.\n",
+EC_ERR("Failed to allocate %u bytes of memory for"
-request->length);
+" register data.\n", request->length);
 request->state = EC_INT_REQUEST_FAILURE;
-wake_up(&master->phy_queue);
+wake_up(&master->reg_queue);
 ec_fsm_master_restart(fsm);
 return;
 }
 memcpy(request->data, datagram->data, request->length);
 }
 request->state = EC_INT_REQUEST_SUCCESS;
 } else {
 request->state = EC_INT_REQUEST_FAILURE;
 }
-wake_up(&master->phy_queue);
+wake_up(&master->reg_queue);
-// check for another PHY request
+// check for another register request
-if (ec_fsm_master_action_process_phy(fsm))
+if (ec_fsm_master_action_process_register(fsm))
 return; // processing another request
 ec_fsm_master_restart(fsm);
 }

changeset 1388	3c886ec376f5
parent 1386	95ec1e9bcb53
child 1400	3c4923051e43