master/fsm_slave.c
branchstable-1.5
changeset 2462 5fc035788a3a
parent 2461 d2c48550acd0
child 2464 e6cc33cac6a2
equal deleted inserted replaced
2461:d2c48550acd0 2462:5fc035788a3a
   265 int ec_fsm_slave_action_process_reg(
   265 int ec_fsm_slave_action_process_reg(
   266         ec_fsm_slave_t *fsm /**< Slave state machine. */
   266         ec_fsm_slave_t *fsm /**< Slave state machine. */
   267         )
   267         )
   268 {
   268 {
   269     ec_slave_t *slave = fsm->slave;
   269     ec_slave_t *slave = fsm->slave;
   270     ec_reg_request_t *reg, *next;
   270     ec_reg_request_t *reg;
   271 
   271 
   272     fsm->reg_request = NULL;
   272     fsm->reg_request = NULL;
   273 
   273 
   274     if (slave->config) {
   274     if (slave->config) {
   275         // search the first internal register request to be processed
   275         // search the first internal register request to be processed
   279                 break;
   279                 break;
   280             }
   280             }
   281         }
   281         }
   282     }
   282     }
   283 
   283 
   284     if (!fsm->reg_request) {
   284     if (!fsm->reg_request && !list_empty(&slave->reg_requests)) {
   285         // search the first external request to be processed
   285         // take the first external request to be processed
   286         list_for_each_entry_safe(reg, next, &slave->reg_requests, list) {
   286         fsm->reg_request =
   287             list_del_init(&reg->list); // dequeue
   287             list_entry(slave->reg_requests.next, ec_reg_request_t, list);
   288             fsm->reg_request = reg;
   288         list_del_init(&fsm->reg_request->list); // dequeue
   289             break;
       
   290         }
       
   291     }
   289     }
   292 
   290 
   293     if (!fsm->reg_request) { // no register request to process
   291     if (!fsm->reg_request) { // no register request to process
   294         return 0;
   292         return 0;
   295     }
   293     }
   296 
   294 
   297     if (slave->current_state & EC_SLAVE_STATE_ACK_ERR) {
   295     if (slave->current_state & EC_SLAVE_STATE_ACK_ERR) {
   298         EC_SLAVE_WARN(slave, "Aborting register request,"
   296         EC_SLAVE_WARN(slave, "Aborting register request,"
   299                 " slave has error flag set.\n");
   297                 " slave has error flag set.\n");
   300         reg->state = EC_INT_REQUEST_FAILURE;
   298         fsm->reg_request->state = EC_INT_REQUEST_FAILURE;
   301         wake_up(&slave->reg_queue);
   299         wake_up(&slave->reg_queue);
   302         fsm->state = ec_fsm_slave_state_idle;
   300         fsm->state = ec_fsm_slave_state_idle;
   303         return 1;
   301         return 1;
   304     }
   302     }
   305 
   303 
   306     // Found pending register request. Execute it!
   304     // Found pending register request. Execute it!
   307     EC_SLAVE_DBG(slave, 1, "Processing register request...\n");
   305     EC_SLAVE_DBG(slave, 1, "Processing register request...\n");
   308 
   306 
   309     reg->state = EC_INT_REQUEST_BUSY;
   307     fsm->reg_request->state = EC_INT_REQUEST_BUSY;
   310 
   308 
   311     // Start register access
   309     // Start register access
   312     if (reg->dir == EC_DIR_INPUT) {
   310     if (fsm->reg_request->dir == EC_DIR_INPUT) {
   313         ec_datagram_fprd(fsm->datagram, slave->station_address,
   311         ec_datagram_fprd(fsm->datagram, slave->station_address,
   314                 reg->address, reg->transfer_size);
   312                 fsm->reg_request->address, fsm->reg_request->transfer_size);
   315         ec_datagram_zero(fsm->datagram);
   313         ec_datagram_zero(fsm->datagram);
   316     } else {
   314     } else {
   317         ec_datagram_fpwr(fsm->datagram, slave->station_address,
   315         ec_datagram_fpwr(fsm->datagram, slave->station_address,
   318                 reg->address, reg->transfer_size);
   316                 fsm->reg_request->address, fsm->reg_request->transfer_size);
   319         memcpy(fsm->datagram->data, reg->data, reg->transfer_size);
   317         memcpy(fsm->datagram->data, fsm->reg_request->data,
       
   318                 fsm->reg_request->transfer_size);
   320     }
   319     }
   321     fsm->datagram->device_index = slave->device_index;
   320     fsm->datagram->device_index = slave->device_index;
   322     ec_master_queue_external_datagram(slave->master, fsm->datagram);
   321     ec_master_queue_external_datagram(slave->master, fsm->datagram);
   323     fsm->state = ec_fsm_slave_state_reg_request;
   322     fsm->state = ec_fsm_slave_state_reg_request;
   324     return 1;
   323     return 1;