etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:505cf41488a4
+:9cdd7669dc0b
 EC_FOE_OPCODE_BUSY = 6  /**< Busy. */
 } ec_foe_opcode_t;
 /*****************************************************************************/
-int ec_foe_prepare_data_send(ec_fsm_foe_t *);
+int ec_foe_prepare_data_send(ec_fsm_foe_t *, ec_datagram_t *);
-int ec_foe_prepare_wrq_send(ec_fsm_foe_t *);
+int ec_foe_prepare_wrq_send(ec_fsm_foe_t *, ec_datagram_t *);
-int ec_foe_prepare_rrq_send(ec_fsm_foe_t *);
+int ec_foe_prepare_rrq_send(ec_fsm_foe_t *, ec_datagram_t *);
-int ec_foe_prepare_send_ack(ec_fsm_foe_t *);
+int ec_foe_prepare_send_ack(ec_fsm_foe_t *, ec_datagram_t *);
 void ec_foe_set_tx_error(ec_fsm_foe_t *, uint32_t);
 void ec_foe_set_rx_error(ec_fsm_foe_t *, uint32_t);
-void ec_fsm_foe_write(ec_fsm_foe_t *);
+void ec_fsm_foe_end(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_read(ec_fsm_foe_t *);
+void ec_fsm_foe_error(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_end(ec_fsm_foe_t *);
-void ec_fsm_foe_error(ec_fsm_foe_t *);
+void ec_fsm_foe_state_wrq_sent(ec_fsm_foe_t *, ec_datagram_t *);
+void ec_fsm_foe_state_rrq_sent(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_state_wrq_sent(ec_fsm_foe_t *);
-void ec_fsm_foe_state_rrq_sent(ec_fsm_foe_t *);
+void ec_fsm_foe_state_ack_check(ec_fsm_foe_t *, ec_datagram_t *);
+void ec_fsm_foe_state_ack_read(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_state_ack_check(ec_fsm_foe_t *);
-void ec_fsm_foe_state_ack_read(ec_fsm_foe_t *);
+void ec_fsm_foe_state_data_sent(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_state_data_sent(ec_fsm_foe_t *);
+void ec_fsm_foe_state_data_check(ec_fsm_foe_t *, ec_datagram_t *);
+void ec_fsm_foe_state_data_read(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_state_data_check(ec_fsm_foe_t *);
+void ec_fsm_foe_state_sent_ack(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_state_data_read(ec_fsm_foe_t *);
-void ec_fsm_foe_state_sent_ack(ec_fsm_foe_t *);
+void ec_fsm_foe_write_start(ec_fsm_foe_t *, ec_datagram_t *);
+void ec_fsm_foe_read_start(ec_fsm_foe_t *, ec_datagram_t *);
-void ec_fsm_foe_write_start(ec_fsm_foe_t *);
-void ec_fsm_foe_read_start(ec_fsm_foe_t *);
 /*****************************************************************************/
 /** Constructor.
 */
-void ec_fsm_foe_init(ec_fsm_foe_t *fsm, /**< finite state machine */
+void ec_fsm_foe_init(
-ec_datagram_t *datagram /**< datagram */
+ec_fsm_foe_t *fsm /**< finite state machine */
 )
 {
-fsm->state     = NULL;
+fsm->state = NULL;
-fsm->datagram  = datagram;
+fsm->datagram = NULL;
 }
 /*****************************************************************************/
 /** Destructor.
 }
 /*****************************************************************************/
 /** Executes the current state of the state machine.
-* \return false, if state machine has terminated
+*
-*/
+* \return 1, if the datagram was used, else 0.
-int ec_fsm_foe_exec(ec_fsm_foe_t *fsm /**< finite state machine */)
+*/
-{
+int ec_fsm_foe_exec(
-fsm->state(fsm);
+ec_fsm_foe_t *fsm, /**< finite state machine */
+ec_datagram_t *datagram /**< Datagram to use. */
-return fsm->state != ec_fsm_foe_end && fsm->state != ec_fsm_foe_error;
+)
+{
+int datagram_used = 0;
+if (fsm->datagram &&
+(fsm->datagram->state == EC_DATAGRAM_INIT ||
+fsm->datagram->state == EC_DATAGRAM_QUEUED ||
+fsm->datagram->state == EC_DATAGRAM_SENT)) {
+// datagram not received yet
+return datagram_used;
+}
+fsm->state(fsm, datagram);
+datagram_used =
+fsm->state != ec_fsm_foe_end && fsm->state != ec_fsm_foe_error;
+if (datagram_used) {
+fsm->datagram = datagram;
+} else {
+fsm->datagram = NULL;
+}
+return datagram_used;
 }
 /*****************************************************************************/
 /** Returns, if the state machine terminated with success.
 * \return non-zero if successful.
 */
-int ec_fsm_foe_success(ec_fsm_foe_t *fsm /**< Finite state machine */)
+int ec_fsm_foe_success(const ec_fsm_foe_t *fsm /**< Finite state machine */)
 {
 return fsm->state == ec_fsm_foe_end;
 }
 /*****************************************************************************/
 ec_foe_request_t *request /**< Sdo request. */
 )
 {
 fsm->slave = slave;
 fsm->request = request;
 if (request->dir == EC_DIR_OUTPUT) {
-fsm->state = ec_fsm_foe_write;
+fsm->tx_buffer = fsm->request->buffer;
+fsm->tx_buffer_size = fsm->request->data_size;
+fsm->tx_buffer_offset = 0;
+fsm->tx_filename = fsm->request->file_name;
+fsm->tx_filename_len = strlen(fsm->tx_filename);
+fsm->state = ec_fsm_foe_write_start;
 }
 else {
-fsm->state = ec_fsm_foe_read;
+fsm->rx_buffer = fsm->request->buffer;
+fsm->rx_buffer_size = fsm->request->buffer_size;
+fsm->rx_filename = fsm->request->file_name;
+fsm->rx_filename_len = strlen(fsm->rx_filename);
+fsm->state = ec_fsm_foe_read_start;
 }
 }
 /*****************************************************************************/
 /** State: ERROR.
 */
-void ec_fsm_foe_error(ec_fsm_foe_t *fsm /**< finite state machine */)
+void ec_fsm_foe_error(
+ec_fsm_foe_t *fsm, /**< finite state machine */
+ec_datagram_t *datagram /**< Datagram to use. */
+)
 {
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_error()\n");
 #endif
 }
 /*****************************************************************************/
 /** State: END.
 */
-void ec_fsm_foe_end(ec_fsm_foe_t *fsm /**< finite state machine */)
+void ec_fsm_foe_end(
+ec_fsm_foe_t *fsm, /**< finite state machine */
+ec_datagram_t *datagram /**< Datagram to use. */
+)
 {
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_end\n");
 #endif
 }
 /*****************************************************************************/
 /** Sends a file or the next fragment.
 */
-int ec_foe_prepare_data_send(ec_fsm_foe_t *fsm)
+int ec_foe_prepare_data_send(
+ec_fsm_foe_t *fsm,
+ec_datagram_t *datagram /**< Datagram to use. */
+)
 {
 size_t remaining_size, current_size;
 uint8_t *data;
 remaining_size = fsm->tx_buffer_size - fsm->tx_buffer_offset;
 current_size = fsm->slave->configured_tx_mailbox_size
 - EC_MBOX_HEADER_SIZE - EC_FOE_HEADER_SIZE;
 }
 data = ec_slave_mbox_prepare_send(fsm->slave,
-fsm->datagram, EC_MBOX_TYPE_FILEACCESS,
+datagram, EC_MBOX_TYPE_FILEACCESS,
 current_size + EC_FOE_HEADER_SIZE);
-if (IS_ERR(data))
+if (IS_ERR(data)) {
 return -1;
+}
-EC_WRITE_U8 ( data, EC_FOE_OPCODE_DATA );    // OpCode = DataBlock req.
-EC_WRITE_U32( data + 2, fsm->tx_packet_no ); // PacketNo, Password
+EC_WRITE_U8 (data, EC_FOE_OPCODE_DATA);    // OpCode = DataBlock req.
+EC_WRITE_U32(data + 2, fsm->tx_packet_no); // PacketNo, Password
 memcpy(data + EC_FOE_HEADER_SIZE,
 fsm->tx_buffer + fsm->tx_buffer_offset, current_size);
 fsm->tx_current_size = current_size;
 /*****************************************************************************/
 /** Prepare a write request (WRQ) with filename
 */
-int ec_foe_prepare_wrq_send(ec_fsm_foe_t *fsm)
+int ec_foe_prepare_wrq_send(
+ec_fsm_foe_t *fsm, /**< Finite state machine. */
+ec_datagram_t *datagram /**< Datagram to use. */
+)
 {
 size_t current_size;
 uint8_t *data;
 fsm->tx_buffer_offset = 0;
 fsm->tx_packet_no = 0;
 fsm->tx_last_packet = 0;
 current_size = fsm->tx_filename_len;
-data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
+data = ec_slave_mbox_prepare_send(fsm->slave, datagram,
 EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE);
-if (IS_ERR(data))
+if (IS_ERR(data)) {
 return -1;
+}
 EC_WRITE_U16( data, EC_FOE_OPCODE_WRQ); // fsm write request
 EC_WRITE_U32( data + 2, fsm->tx_packet_no );
 memcpy(data + EC_FOE_HEADER_SIZE, fsm->tx_filename, current_size);
 return 0;
 }
 /*****************************************************************************/
-/** Start a write operation.
-*/
-void ec_fsm_foe_write(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
-)
-{
-fsm->tx_buffer = fsm->request->buffer;
-fsm->tx_buffer_size = fsm->request->data_size;
-fsm->tx_buffer_offset = 0;
-fsm->tx_filename = fsm->request->file_name;
-fsm->tx_filename_len = strlen(fsm->tx_filename);
-fsm->state = ec_fsm_foe_write_start;
-}
-/*****************************************************************************/
 /** Initializes the FoE write state machine.
 */
-void ec_fsm_foe_write_start(ec_fsm_foe_t *fsm /**< finite state machine */)
+void ec_fsm_foe_write_start(
+ec_fsm_foe_t *fsm, /**< finite state machine */
+ec_datagram_t *datagram /**< Datagram to use. */
+)
 {
 ec_slave_t *slave = fsm->slave;
 fsm->tx_buffer_offset = 0;
 fsm->tx_current_size = 0;
 ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 EC_SLAVE_ERR(slave, "Slave does not support FoE!\n");
 return;
 }
-if (ec_foe_prepare_wrq_send(fsm)) {
+if (ec_foe_prepare_wrq_send(fsm, datagram)) {
 ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 return;
 }
 fsm->state = ec_fsm_foe_state_wrq_sent;
 /*****************************************************************************/
 /** Check for acknowledge.
 */
 void ec_fsm_foe_state_ack_check(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_ack_check()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to receive FoE mailbox check datagram: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
-// slave did not put anything in the mailbox yet
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE mailbox check datagram"
 " failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-if (!ec_slave_mbox_check(datagram)) {
+if (!ec_slave_mbox_check(fsm->datagram)) {
+// slave did not put anything in the mailbox yet
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= EC_FSM_FOE_TIMEOUT) {
 ec_foe_set_tx_error(fsm, FOE_TIMEOUT_ERROR);
 EC_SLAVE_ERR(slave, "Timeout while waiting for ack response.\n");
 /*****************************************************************************/
 /** Acknowledge a read operation.
 */
 void ec_fsm_foe_state_ack_read(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 uint8_t *data, mbox_prot;
 uint8_t opCode;
 size_t rec_size;
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_ack_read()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to receive FoE ack response datagram: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE ack response failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-if (!(data = ec_slave_mbox_fetch(fsm->slave, datagram,
+data = ec_slave_mbox_fetch(fsm->slave, datagram, &mbox_prot, &rec_size);
-&mbox_prot, &rec_size))) {
+if (IS_ERR(data)) {
 ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 return;
 }
 if (mbox_prot != EC_MBOX_TYPE_FILEACCESS) { // FoE
 opCode = EC_READ_U8(data);
 if (opCode == EC_FOE_OPCODE_BUSY) {
 // slave not ready
-if (ec_foe_prepare_data_send(fsm)) {
+if (ec_foe_prepare_data_send(fsm, datagram)) {
 ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 EC_SLAVE_ERR(slave, "Slave is busy.\n");
 return;
 }
 fsm->state = ec_fsm_foe_state_data_sent;
 if (fsm->tx_last_packet) {
 fsm->state = ec_fsm_foe_end;
 return;
 }
-if (ec_foe_prepare_data_send(fsm)) {
+if (ec_foe_prepare_data_send(fsm, datagram)) {
 ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 return;
 }
 fsm->state = ec_fsm_foe_state_data_sent;
 return;
 *
 * Checks is the previous transmit datagram succeded and sends the next
 * fragment, if necessary.
 */
 void ec_fsm_foe_state_wrq_sent(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_foe_state_sent_wrq()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to send FoE WRQ: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
 // slave did not put anything in the mailbox yet
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE WRQ failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-fsm->jiffies_start = datagram->jiffies_sent;
+fsm->jiffies_start = fsm->datagram->jiffies_sent;
 ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_foe_state_ack_check;
 *
 * Checks is the previous transmit datagram succeded and sends the next
 * fragment, if necessary.
 */
 void ec_fsm_foe_state_data_sent(
-ec_fsm_foe_t *fsm /**< Foe statemachine. */
+ec_fsm_foe_t *fsm, /**< Foe statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_state_data_sent()\n");
 #endif
 if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_tx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to receive FoE ack response datagram: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
 if (fsm->datagram->working_counter != 1) {
 ec_foe_set_tx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE data send failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-ec_slave_mbox_prepare_check(fsm->slave, fsm->datagram);
+ec_slave_mbox_prepare_check(fsm->slave, datagram);
 fsm->jiffies_start = jiffies;
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_foe_state_ack_check;
 }
 /*****************************************************************************/
 /** Prepare a read request (RRQ) with filename
 */
-int ec_foe_prepare_rrq_send(ec_fsm_foe_t *fsm)
+int ec_foe_prepare_rrq_send(
+ec_fsm_foe_t *fsm, /**< Finite state machine. */
+ec_datagram_t *datagram /**< Datagram to use. */
+)
 {
 size_t current_size;
 uint8_t *data;
 current_size = fsm->rx_filename_len;
-data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
+data = ec_slave_mbox_prepare_send(fsm->slave, datagram,
 EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE);
-if (IS_ERR(data))
+if (IS_ERR(data)) {
 return -1;
+}
 EC_WRITE_U16(data, EC_FOE_OPCODE_RRQ); // fsm read request
 EC_WRITE_U32(data + 2, 0x00000000); // no passwd
 memcpy(data + EC_FOE_HEADER_SIZE, fsm->rx_filename, current_size);
 /*****************************************************************************/
 /** Prepare to send an acknowledge.
 */
 int ec_foe_prepare_send_ack(
-ec_fsm_foe_t *foe /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
+ec_datagram_t *datagram /**< Datagram to use. */
 )
 {
 uint8_t *data;
-data = ec_slave_mbox_prepare_send(foe->slave, foe->datagram,
+data = ec_slave_mbox_prepare_send(fsm->slave, datagram,
 EC_MBOX_TYPE_FILEACCESS, EC_FOE_HEADER_SIZE);
-if (IS_ERR(data))
+if (IS_ERR(data)) {
 return -1;
+}
 EC_WRITE_U16(data, EC_FOE_OPCODE_ACK);
-EC_WRITE_U32(data + 2, foe->rx_expected_packet_no);
+EC_WRITE_U32(data + 2, fsm->rx_expected_packet_no);
 return 0;
 }
 /*****************************************************************************/
 /** State: RRQ SENT.
 *
-* Checks is the previous transmit datagram succeded and sends the next
+* Checks is the previous transmit datagram succeeded and sends the next
 * fragment, if necessary.
 */
 void ec_fsm_foe_state_rrq_sent(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_foe_state_rrq_sent()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to send FoE RRQ: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
 // slave did not put anything in the mailbox yet
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE RRQ failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-fsm->jiffies_start = datagram->jiffies_sent;
+fsm->jiffies_start = fsm->datagram->jiffies_sent;
 ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_foe_state_data_check;
 }
 /*****************************************************************************/
-/** Start a read operation.
-*/
-void ec_fsm_foe_read(
-ec_fsm_foe_t *fsm /**< FoE state machine. */
-)
-{
-fsm->state = ec_fsm_foe_read_start;
-fsm->rx_filename = fsm->request->file_name;
-fsm->rx_filename_len = strlen(fsm->rx_filename);
-fsm->rx_buffer = fsm->request->buffer;
-fsm->rx_buffer_size = fsm->request->buffer_size;
-}
-/*****************************************************************************/
 /** Starting state for read operations.
 */
 void ec_fsm_foe_read_start(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
+ec_datagram_t *datagram /**< Datagram to use. */
 )
 {
 ec_slave_t *slave = fsm->slave;
 fsm->rx_buffer_offset = 0;
 ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 EC_SLAVE_ERR(slave, "Slave does not support FoE!\n");
 return;
 }
-if (ec_foe_prepare_rrq_send(fsm)) {
+if (ec_foe_prepare_rrq_send(fsm, datagram)) {
 ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
 return;
 }
 fsm->state = ec_fsm_foe_state_rrq_sent;
 /*****************************************************************************/
 /** Check for data.
 */
 void ec_fsm_foe_state_data_check(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_state_data_check()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to send FoE DATA READ: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE DATA READ: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-if (!ec_slave_mbox_check(datagram)) {
+if (!ec_slave_mbox_check(fsm->datagram)) {
 unsigned long diff_ms =
-(datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
+(fsm->datagram->jiffies_received - fsm->jiffies_start) *
+1000 / HZ;
 if (diff_ms >= EC_FSM_FOE_TIMEOUT) {
 ec_foe_set_tx_error(fsm, FOE_TIMEOUT_ERROR);
 EC_SLAVE_ERR(slave, "Timeout while waiting for ack response.\n");
 return;
 }
 /*****************************************************************************/
 /** Start reading data.
 */
 void ec_fsm_foe_state_data_read(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
+ec_datagram_t *datagram /**< Datagram to use. */
 )
 {
 size_t rec_size;
 uint8_t *data, opCode, packet_no, mbox_prot;
-ec_datagram_t *datagram = fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_fsm_foe_state_data_read()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to receive FoE DATA READ datagram: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE DATA READ failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-if (!(data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot,
+data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
-&rec_size))) {
+if (IS_ERR(data)) {
 ec_foe_set_rx_error(fsm, FOE_MBOX_FETCH_ERROR);
 return;
 }
 if (mbox_prot != EC_MBOX_TYPE_FILEACCESS) { // FoE
 }
 opCode = EC_READ_U8(data);
 if (opCode == EC_FOE_OPCODE_BUSY) {
-if (ec_foe_prepare_send_ack(fsm)) {
+if (ec_foe_prepare_send_ack(fsm, datagram)) {
 ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
 }
 return;
 }
 // either it was the last packet or a new packet will fit into the
 // delivered buffer
 #ifdef DEBUG_FOE
 printk ("last_packet=true\n");
 #endif
-if (ec_foe_prepare_send_ack(fsm)) {
+if (ec_foe_prepare_send_ack(fsm, datagram)) {
 ec_foe_set_rx_error(fsm, FOE_RX_DATA_ACK_ERROR);
 return;
 }
 fsm->state = ec_fsm_foe_state_sent_ack;
 /*****************************************************************************/
 /** Sent an acknowledge.
 */
 void ec_fsm_foe_state_sent_ack(
-ec_fsm_foe_t *fsm /**< FoE statemachine. */
+ec_fsm_foe_t *fsm, /**< FoE statemachine. */
-)
+ec_datagram_t *datagram /**< Datagram to use. */
-{
+)
-ec_datagram_t *datagram = fsm->datagram;
+{
 ec_slave_t *slave = fsm->slave;
 #ifdef DEBUG_FOE
 printk("ec_foe_state_sent_ack()\n");
 #endif
-if (datagram->state != EC_DATAGRAM_RECEIVED) {
+if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 EC_SLAVE_ERR(slave, "Failed to send FoE ACK: ");
-ec_datagram_print_state(datagram);
+ec_datagram_print_state(fsm->datagram);
 return;
 }
-if (datagram->working_counter != 1) {
+if (fsm->datagram->working_counter != 1) {
 // slave did not put anything into the mailbox yet
 ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 EC_SLAVE_ERR(slave, "Reception of FoE ACK failed: ");
-ec_datagram_print_wc_error(datagram);
+ec_datagram_print_wc_error(fsm->datagram);
 return;
 }
-fsm->jiffies_start = datagram->jiffies_sent;
+fsm->jiffies_start = fsm->datagram->jiffies_sent;
 ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 if (fsm->rx_last_packet) {
 fsm->rx_expected_packet_no = 0;

branch	stable-1.5
changeset 2498	9cdd7669dc0b
parent 2257	a2a675601c98
child 2501	64cdc3b59d25