Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/fsm_foe.c
changeset 1343 6628cd694cba
parent 1338 eb31b5a135da
child 1363 11c0b2caa253
equal deleted inserted replaced
1342:a72b9b370277 1343:6628cd694cba 
    50  */
 
    50  */
 
    51 #define EC_FSM_FOE_TIMEOUT 3000
 
    51 #define EC_FSM_FOE_TIMEOUT 3000
 
    52 
    52 
    53 #define EC_MBOX_TYPE_FILEACCESS 0x04
 
    53 #define EC_MBOX_TYPE_FILEACCESS 0x04
 
    54 
    54 
    55 #define myDEBUG
 
    55 #define EC_FOE_HEADER_SIZE 6
 
    56 
    56 // uint8_t  OpCode
 
    57 /*****************************************************************************/
 
    57 // uint8_t  reserved
 
    58 
    58 // uint32_t PacketNo, Password, ErrorCode
 
    59 int		ec_foe_prepare_data_send( ec_fsm_foe_t * );
 
    59 
    60 int		ec_foe_prepare_wrq_send( ec_fsm_foe_t * );
 
    60 //#define DEBUG_FOE
 
    61 int		ec_foe_prepare_rrq_send( ec_fsm_foe_t * );
 
    61 
    62 int		ec_foe_prepare_send_ack( ec_fsm_foe_t * );
 
    62 /*****************************************************************************/
 
    63 
    63 
    64 void	ec_foe_set_tx_error( ec_fsm_foe_t *, uint32_t );
 
    64 enum {
 
    65 void	ec_foe_set_rx_error( ec_fsm_foe_t *, uint32_t );
 
    65     EC_FOE_OPCODE_RRQ  = 1,
 
    66 
    66     EC_FOE_OPCODE_WRQ  = 2,
 
    67 void	ec_fsm_foe_write(ec_fsm_foe_t * );
 
    67     EC_FOE_OPCODE_DATA = 3,
 
    68 void	ec_fsm_foe_read(ec_fsm_foe_t * );
 
    68     EC_FOE_OPCODE_ACK  = 4,
 
    69 void 	ec_fsm_foe_end( ec_fsm_foe_t * );
 
    69     EC_FOE_OPCODE_ERR  = 5,
 
    70 void 	ec_fsm_foe_error( ec_fsm_foe_t * );
 
    70     EC_FOE_OPCODE_BUSY = 6
 
    71 
    71 } ec_foe_opcode_t;
 
    72 void	ec_fsm_foe_state_wrq_sent( ec_fsm_foe_t * );
 
    72 
    73 void	ec_fsm_foe_state_rrq_sent( ec_fsm_foe_t * );
 
    73 /*****************************************************************************/
 
    74 
    74 
    75 void	ec_fsm_foe_state_ack_check( ec_fsm_foe_t * );
 
    75 int ec_foe_prepare_data_send(ec_fsm_foe_t *);
 
    76 void	ec_fsm_foe_state_ack_read( ec_fsm_foe_t * );
 
    76 int ec_foe_prepare_wrq_send(ec_fsm_foe_t *);
 
    77 
    77 int ec_foe_prepare_rrq_send(ec_fsm_foe_t *);
 
    78 void	ec_fsm_foe_state_data_sent( ec_fsm_foe_t * );
 
    78 int ec_foe_prepare_send_ack(ec_fsm_foe_t *);
 
    79 
    79 
    80 void	ec_fsm_foe_state_data_check( ec_fsm_foe_t * );
 
    80 void ec_foe_set_tx_error(ec_fsm_foe_t *, uint32_t);
 
    81 void	ec_fsm_foe_state_data_read ( ec_fsm_foe_t * );
 
    81 void ec_foe_set_rx_error(ec_fsm_foe_t *, uint32_t);
 
    82 void	ec_fsm_foe_state_sent_ack( ec_fsm_foe_t * );
 
    82 
    83 
    83 void ec_fsm_foe_write(ec_fsm_foe_t *);
 
    84 void	ec_fsm_foe_write_start( ec_fsm_foe_t * );
 
    84 void ec_fsm_foe_read(ec_fsm_foe_t *);
 
    85 void	ec_fsm_foe_read_start(ec_fsm_foe_t * );
 
    85 void ec_fsm_foe_end(ec_fsm_foe_t *);
 
       
    86 void ec_fsm_foe_error(ec_fsm_foe_t *);
 
       
    87 
       
    88 void ec_fsm_foe_state_wrq_sent(ec_fsm_foe_t *);
 
       
    89 void ec_fsm_foe_state_rrq_sent(ec_fsm_foe_t *);
 
       
    90 
       
    91 void ec_fsm_foe_state_ack_check(ec_fsm_foe_t *);
 
       
    92 void ec_fsm_foe_state_ack_read(ec_fsm_foe_t *);
 
       
    93 
       
    94 void ec_fsm_foe_state_data_sent(ec_fsm_foe_t *);
 
       
    95 
       
    96 void ec_fsm_foe_state_data_check(ec_fsm_foe_t *);
 
       
    97 void ec_fsm_foe_state_data_read(ec_fsm_foe_t *);
 
       
    98 void ec_fsm_foe_state_sent_ack(ec_fsm_foe_t *);
 
       
    99 
       
   100 void ec_fsm_foe_write_start(ec_fsm_foe_t *);
 
       
   101 void ec_fsm_foe_read_start(ec_fsm_foe_t *);
 
    86 
   102 
    87 /*****************************************************************************/
 
   103 /*****************************************************************************/
 
    88 
   104 
    89 /**
 
   105 /**
 
    90    Constructor.
 
   106    Constructor.
 
   160    State: ERROR.
 
   176    State: ERROR.
 
   161 */
 
   177 */
 
   162 
   178 
   163 void ec_fsm_foe_error(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   179 void ec_fsm_foe_error(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   164 {
 
   180 {
 
   165 #ifdef	myDEBUG
 
   181 #ifdef DEBUG_FOE
 
   166 	printk("ec_fsm_foe_error()\n");
 
   182     printk("ec_fsm_foe_error()\n");
 
   167 #endif
 
   183 #endif
 
   168 }
 
   184 }
 
   169 
   185 
   170 /*****************************************************************************/
 
   186 /*****************************************************************************/
 
   171 
   187 
   173    State: END.
 
   189    State: END.
 
   174 */
 
   190 */
 
   175 
   191 
   176 void ec_fsm_foe_end(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   192 void ec_fsm_foe_end(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   177 {
 
   193 {
 
   178 #ifdef	myDEBUG
 
   194 #ifdef DEBUG_FOE
 
   179     printk("ec_fsm_foe_end\n");
 
   195     printk("ec_fsm_foe_end\n");
 
   180 #endif
 
   196 #endif
 
   181 }
 
   197 }
 
   182 
       
   183 /*****************************************************************************/
 
       
   184 
       
   185 #define	EC_MBOX_HEADER_SIZE		6
 
       
   186 // uint16_t	Length
 
       
   187 // uint16_t	Address
 
       
   188 // uint8_t	reserved
 
       
   189 // uint8_t	Type:4
 
       
   190 // uint8_t	Counter:4
 
       
   191 
       
   192 #define	EC_FOE_HEADER_SIZE		6
 
       
   193 // uint8_t	OpCode
 
       
   194 // uint8_t	reserved
 
       
   195 // uint32_t	PacketNo, Password, ErrorCode
 
       
   196 
       
   197 enum {
 
       
   198 	EC_FOE_OPCODE_RRQ  = 1,
 
       
   199 	EC_FOE_OPCODE_WRQ  = 2,
 
       
   200 	EC_FOE_OPCODE_DATA = 3,
 
       
   201 	EC_FOE_OPCODE_ACK  = 4,
 
       
   202 	EC_FOE_OPCODE_ERR  = 5,
 
       
   203 	EC_FOE_OPCODE_BUSY = 6
 
       
   204 } ec_foe_opcode_t;
 
       
   205 
   198 
   206 /*****************************************************************************/
 
   199 /*****************************************************************************/
 
   207 /**
 
   200 /**
 
   208    Sends a file or the next fragment.
 
   201    Sends a file or the next fragment.
 
   209 */
 
   202 */
 
   222         current_size = fsm->slave->configured_tx_mailbox_size
 
   215         current_size = fsm->slave->configured_tx_mailbox_size
 
   223             - EC_MBOX_HEADER_SIZE - EC_FOE_HEADER_SIZE;
 
   216             - EC_MBOX_HEADER_SIZE - EC_FOE_HEADER_SIZE;
 
   224     }
 
   217     }
 
   225 
   218 
   226     if (!(data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
 
   219     if (!(data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
 
   227     		EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
 
   220                     EC_MBOX_TYPE_FILEACCESS,
 
       
   221                     current_size + EC_FOE_HEADER_SIZE)))
 
   228         return -1;
 
   222         return -1;
 
   229 
   223 
   230     EC_WRITE_U8 ( data, EC_FOE_OPCODE_DATA ); 		// OpCode = DataBlock req.
 
   224     EC_WRITE_U8 ( data, EC_FOE_OPCODE_DATA );    // OpCode = DataBlock req.
 
   231     EC_WRITE_U32( data + 2, fsm->tx_packet_no );	// PacketNo, Password
 
   225     EC_WRITE_U32( data + 2, fsm->tx_packet_no ); // PacketNo, Password
 
   232 
   226 
   233     memcpy(data + EC_FOE_HEADER_SIZE, fsm->tx_buffer + fsm->tx_buffer_offset, current_size);
 
   227     memcpy(data + EC_FOE_HEADER_SIZE,
 
   234 
   228             fsm->tx_buffer + fsm->tx_buffer_offset, current_size);
 
   235     fsm->tx_current_size = current_size;
 
   229     fsm->tx_current_size = current_size;
 
   236 
   230 
   237     return 0;
 
   231     return 0;
 
   238 }
 
   232 }
 
   239 
   233 
   247     uint8_t *data;
 
   241     uint8_t *data;
 
   248 
   242 
   249     fsm->tx_buffer_offset = 0;
 
   243     fsm->tx_buffer_offset = 0;
 
   250     fsm->tx_current_size = 0;
 
   244     fsm->tx_current_size = 0;
 
   251     fsm->tx_packet_no = 0;
 
   245     fsm->tx_packet_no = 0;
 
   252 	fsm->tx_last_packet = 0;
 
   246     fsm->tx_last_packet = 0;
 
   253 
   247 
   254     current_size = fsm->tx_filename_len;
 
   248     current_size = fsm->tx_filename_len;
 
   255 
   249 
   256     if (!(data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
 
   250     if (!(data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
 
   257     		EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
 
   251                     EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
 
   258         return -1;
 
   252         return -1;
 
   259 
   253 
   260     EC_WRITE_U16( data, EC_FOE_OPCODE_WRQ); // fsm write request
 
   254     EC_WRITE_U16( data, EC_FOE_OPCODE_WRQ); // fsm write request
 
   261     EC_WRITE_U32( data + 2, fsm->tx_packet_no );
 
   255     EC_WRITE_U32( data + 2, fsm->tx_packet_no );
 
   262 
   256 
   265     return 0;
 
   259     return 0;
 
   266 }
 
   260 }
 
   267 
   261 
   268 /*****************************************************************************/
 
   262 /*****************************************************************************/
 
   269 
   263 
   270 char		tx_buffer[0x1000];
 
       
   271 void ec_fsm_foe_write(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   264 void ec_fsm_foe_write(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   272 {
 
   265 {
 
   273     fsm->tx_buffer = fsm->request->buffer;
 
   266     fsm->tx_buffer = fsm->request->buffer;
 
   274     fsm->tx_buffer_size = fsm->request->data_size;
 
   267     fsm->tx_buffer_size = fsm->request->data_size;
 
   275     fsm->tx_buffer_offset = 0;
 
   268     fsm->tx_buffer_offset = 0;
 
   276 
   269 
   277 	fsm->tx_filename = fsm->request->file_name;
 
   270     fsm->tx_filename = fsm->request->file_name;
 
   278 	fsm->tx_filename_len = strlen(fsm->tx_filename);
 
   271     fsm->tx_filename_len = strlen(fsm->tx_filename);
 
   279 
   272 
   280 	fsm->state = ec_fsm_foe_write_start;
 
   273     fsm->state = ec_fsm_foe_write_start;
 
   281 
       
   282 #ifdef use_ext_buffer
 
       
   283 	{
 
       
   284 		int i;
 
       
   285 		fsm->tx_data = tx_buffer;
 
       
   286 		for (i=0 ; i<sizeof(tx_buffer) ; i++) {
 
       
   287 			tx_buffer[i] = (uint8_t)(i);
 
       
   288 		}
 
       
   289 		fsm->tx_data_len = sizeof(tx_buffer);
 
       
   290 	}
 
       
   291 #endif
 
       
   292 }
 
   274 }
 
   293 
   275 
   294 /*****************************************************************************/
 
   276 /*****************************************************************************/
 
   295 /**
 
   277 /**
 
   296    Initializes the SII write state machine.
 
   278    Initializes the SII write state machine.
 
   301     ec_slave_t *slave = fsm->slave;
 
   283     ec_slave_t *slave = fsm->slave;
 
   302 
   284 
   303     fsm->tx_buffer_offset = 0;
 
   285     fsm->tx_buffer_offset = 0;
 
   304     fsm->tx_current_size = 0;
 
   286     fsm->tx_current_size = 0;
 
   305     fsm->tx_packet_no = 0;
 
   287     fsm->tx_packet_no = 0;
 
   306 	fsm->tx_last_packet = 0;
 
   288     fsm->tx_last_packet = 0;
 
   307 
   289 
   308 #ifdef	myDEBUG
 
   290 #ifdef DEBUG_FOE
 
   309     printk("ec_fsm_foe_write_start()\n");
 
   291     printk("ec_fsm_foe_write_start()\n");
 
   310 #endif
 
   292 #endif
 
   311 
   293 
   312     if (!(slave->sii.mailbox_protocols & EC_MBOX_FOE)) {
 
   294     if (!(slave->sii.mailbox_protocols & EC_MBOX_FOE)) {
 
   313         ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 
   295         ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 
   327 
   309 
   328 void ec_fsm_foe_state_ack_check( ec_fsm_foe_t *fsm ) {
 
   310 void ec_fsm_foe_state_ack_check( ec_fsm_foe_t *fsm ) {
 
   329     ec_datagram_t *datagram = fsm->datagram;
 
   311     ec_datagram_t *datagram = fsm->datagram;
 
   330     ec_slave_t *slave = fsm->slave;
 
   312     ec_slave_t *slave = fsm->slave;
 
   331 
   313 
   332 #ifdef	myDEBUG
 
   314 #ifdef DEBUG_FOE
 
   333 //	printk("ec_fsm_foe_ack_check()\n");
 
   315     printk("ec_fsm_foe_ack_check()\n");
 
   334 #endif
 
   316 #endif
 
       
   317 
   335     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   318     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   336     	ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   319         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   337         EC_ERR("Failed to receive FoE mailbox check datagram for slave %u"
 
   320         EC_ERR("Failed to receive FoE mailbox check datagram for slave %u"
 
   338                 " (datagram state %u).\n",
 
   321                 " (datagram state %u).\n",
 
   339                slave->ring_position, datagram->state);
 
   322                slave->ring_position, datagram->state);
 
   340         return;
 
   323         return;
 
   341     }
 
   324     }
 
   342 
   325 
   343     if (datagram->working_counter != 1) {
 
   326     if (datagram->working_counter != 1) {
 
   344     	// slave hat noch nichts in die Mailbox getan
 
   327         // slave did not put anything in the mailbox yet
 
   345         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   328         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   346         EC_ERR("Reception of FoE mailbox check datagram failed on slave %u: ",
 
   329         EC_ERR("Reception of FoE mailbox check datagram failed on slave %u: ",
 
   347                slave->ring_position);
 
   330                slave->ring_position);
 
   348         ec_datagram_print_wc_error(datagram);
 
   331         ec_datagram_print_wc_error(datagram);
 
   349 	    return;
 
   332         return;
 
   350 	}
 
   333     }
 
   351 
   334 
   352     if (!ec_slave_mbox_check(datagram)) {
 
   335     if (!ec_slave_mbox_check(datagram)) {
 
   353         unsigned long diff_ms =
 
   336         unsigned long diff_ms =
 
   354             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
   337             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
   355         if (diff_ms >= EC_FSM_FOE_TIMEOUT) {
 
   338         if (diff_ms >= EC_FSM_FOE_TIMEOUT) {
 
   356         	ec_foe_set_tx_error(fsm, FOE_TIMEOUT_ERROR);
 
   339             ec_foe_set_tx_error(fsm, FOE_TIMEOUT_ERROR);
 
   357             EC_ERR("Timeout while waiting for ack response "
 
   340             EC_ERR("Timeout while waiting for ack response "
 
   358                     "on slave %u.\n", slave->ring_position);
 
   341                     "on slave %u.\n", slave->ring_position);
 
   359             return;
 
   342             return;
 
   360         }
 
   343         }
 
   361 //        EC_ERR("WAIT!!!!!!!!!!!!!\n");
 
   344 
   362         ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   345         ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 
   363         fsm->retries = EC_FSM_RETRIES;
 
   346         fsm->retries = EC_FSM_RETRIES;
 
   364         return;
 
   347         return;
 
   365     }
 
   348     }
 
   366 
   349 
   379     ec_slave_t *slave = fsm->slave;
 
   362     ec_slave_t *slave = fsm->slave;
 
   380     uint8_t *data, mbox_prot;
 
   363     uint8_t *data, mbox_prot;
 
   381     uint8_t opCode;
 
   364     uint8_t opCode;
 
   382     size_t rec_size;
 
   365     size_t rec_size;
 
   383 
   366 
   384 #ifdef	myDEBUG
 
   367 #ifdef DEBUG_FOE
 
   385 	printk("ec_fsm_foe_ack_read()\n");
 
   368     printk("ec_fsm_foe_ack_read()\n");
 
   386 #endif
 
   369 #endif
 
       
   370 
   387     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   371     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   388     	ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   372         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   389         EC_ERR("Failed to receive FoE ack response datagram for"
 
   373         EC_ERR("Failed to receive FoE ack response datagram for"
 
   390                " slave %u (datagram state %u).\n",
 
   374                " slave %u (datagram state %u).\n",
 
   391                slave->ring_position, datagram->state);
 
   375                slave->ring_position, datagram->state);
 
   392         return;
 
   376         return;
 
   393     }
 
   377     }
 
   398                 slave->ring_position);
 
   382                 slave->ring_position);
 
   399         ec_datagram_print_wc_error(datagram);
 
   383         ec_datagram_print_wc_error(datagram);
 
   400         return;
 
   384         return;
 
   401     }
 
   385     }
 
   402 
   386 
   403 	if (!(data = ec_slave_mbox_fetch(fsm->slave, datagram, &mbox_prot, &rec_size))) {
 
   387     if (!(data = ec_slave_mbox_fetch(fsm->slave, datagram,
 
   404     	ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 
   388                     &mbox_prot, &rec_size))) {
 
       
   389         ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 
   405         return;
 
   390         return;
 
   406     }
 
   391     }
 
   407 
   392 
   408     if (mbox_prot != EC_MBOX_TYPE_FILEACCESS) { // FoE
 
   393     if (mbox_prot != EC_MBOX_TYPE_FILEACCESS) { // FoE
 
   409     	ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 
   394         ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 
   410         EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
 
   395         EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
 
   411         return;
 
   396         return;
 
   412     }
 
   397     }
 
   413 
   398 
   414     opCode = EC_READ_U8(data);
 
   399     opCode = EC_READ_U8(data);
 
   415 
   400 
   416     if (opCode == EC_FOE_OPCODE_BUSY) {
 
   401     if (opCode == EC_FOE_OPCODE_BUSY) {
 
   417     	// slave ist noch nicht bereit
 
   402         // slave not ready
 
   418         if (ec_foe_prepare_data_send(fsm)) {
 
   403         if (ec_foe_prepare_data_send(fsm)) {
 
   419         	ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 
   404             ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 
   420             EC_ERR("Slave is busy.\n");
 
   405             EC_ERR("Slave is busy.\n");
 
   421         	return;
 
   406             return;
 
   422         }
 
   407         }
 
   423         fsm->state = ec_fsm_foe_state_data_sent;
 
   408         fsm->state = ec_fsm_foe_state_data_sent;
 
   424         return;
 
   409         return;
 
   425     }
 
   410     }
 
   426 
   411 
   427     if (opCode == EC_FOE_OPCODE_ACK) {
 
   412     if (opCode == EC_FOE_OPCODE_ACK) {
 
   428         fsm->tx_packet_no++;
 
   413         fsm->tx_packet_no++;
 
   429         fsm->tx_buffer_offset += fsm->tx_current_size;
 
   414         fsm->tx_buffer_offset += fsm->tx_current_size;
 
   430 
   415 
   431         if (fsm->tx_last_packet) {
 
   416         if (fsm->tx_last_packet) {
 
   432         	fsm->state = ec_fsm_foe_end;
 
   417             fsm->state = ec_fsm_foe_end;
 
   433         	return;
 
   418             return;
 
   434         }
 
   419         }
 
   435 
   420 
   436         if (ec_foe_prepare_data_send(fsm)) {
 
   421         if (ec_foe_prepare_data_send(fsm)) {
 
   437         	ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 
   422             ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
 
   438 	    	return;
 
   423             return;
 
   439 	    }
 
   424         }
 
   440         fsm->state = ec_fsm_foe_state_data_sent;
 
   425         fsm->state = ec_fsm_foe_state_data_sent;
 
   441     	return;
 
   426         return;
 
   442     }
 
   427     }
 
   443 	ec_foe_set_tx_error(fsm, FOE_ACK_ERROR);
 
   428     ec_foe_set_tx_error(fsm, FOE_ACK_ERROR);
 
   444 }
 
   429 }
 
   445 
   430 
   446 /*****************************************************************************/
 
   431 /*****************************************************************************/
 
   447 /**
 
   432 /**
 
   448    State: WRQ SENT.
 
   433    State: WRQ SENT.
 
   452 
   437 
   453 void ec_fsm_foe_state_wrq_sent( ec_fsm_foe_t *fsm ) {
 
   438 void ec_fsm_foe_state_wrq_sent( ec_fsm_foe_t *fsm ) {
 
   454     ec_datagram_t *datagram = fsm->datagram;
 
   439     ec_datagram_t *datagram = fsm->datagram;
 
   455     ec_slave_t *slave = fsm->slave;
 
   440     ec_slave_t *slave = fsm->slave;
 
   456 
   441 
   457 #ifdef	myDEBUG
 
   442 #ifdef DEBUG_FOE
 
   458 	printk("ec_foe_state_sent_wrq()\n");
 
   443     printk("ec_foe_state_sent_wrq()\n");
 
   459 #endif
 
   444 #endif
 
       
   445 
   460     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   446     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   461     	ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   447         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   462         EC_ERR("Failed to send FoE WRQ for slave %u"
 
   448         EC_ERR("Failed to send FoE WRQ for slave %u"
 
   463                 " (datagram state %u).\n",
 
   449                 " (datagram state %u).\n",
 
   464                 slave->ring_position, datagram->state);
 
   450                 slave->ring_position, datagram->state);
 
   465         return;
 
   451         return;
 
   466     }
 
   452     }
 
   467 
   453 
   468     if (datagram->working_counter != 1) {
 
   454     if (datagram->working_counter != 1) {
 
   469     	// slave hat noch nichts in die Mailbox getan
 
   455         // slave did not put anything in the mailbox yet
 
   470         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   456         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   471         EC_ERR("Reception of FoE WRQ failed on slave %u: ",
 
   457         EC_ERR("Reception of FoE WRQ failed on slave %u: ",
 
   472                 slave->ring_position);
 
   458                 slave->ring_position);
 
   473         ec_datagram_print_wc_error(datagram);
 
   459         ec_datagram_print_wc_error(datagram);
 
   474     	return;
 
   460         return;
 
   475     }
 
   461     }
 
   476 
   462 
   477     fsm->jiffies_start = datagram->jiffies_sent;
 
   463     fsm->jiffies_start = datagram->jiffies_sent;
 
   478 
   464 
   479     ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 
   465     ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 
   491 
   477 
   492 void ec_fsm_foe_state_data_sent( ec_fsm_foe_t *fsm ) {
 
   478 void ec_fsm_foe_state_data_sent( ec_fsm_foe_t *fsm ) {
 
   493     ec_datagram_t *datagram = fsm->datagram;
 
   479     ec_datagram_t *datagram = fsm->datagram;
 
   494     ec_slave_t *slave = fsm->slave;
 
   480     ec_slave_t *slave = fsm->slave;
 
   495 
   481 
   496 #ifdef	myDEBUG
 
   482 #ifdef DEBUG_FOE
 
   497 	printk("ec_fsm_foe_state_data_sent()\n");
 
   483     printk("ec_fsm_foe_state_data_sent()\n");
 
   498 #endif
 
   484 #endif
 
       
   485 
   499     if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 
   486     if (fsm->datagram->state != EC_DATAGRAM_RECEIVED) {
 
   500     	ec_foe_set_tx_error(fsm, FOE_RECEIVE_ERROR);
 
   487         ec_foe_set_tx_error(fsm, FOE_RECEIVE_ERROR);
 
   501         EC_ERR("Failed to receive FoE ack response datagram for"
 
   488         EC_ERR("Failed to receive FoE ack response datagram for"
 
   502                " slave %u (datagram state %u).\n",
 
   489                " slave %u (datagram state %u).\n",
 
   503                slave->ring_position, datagram->state);
 
   490                slave->ring_position, datagram->state);
 
   504         return;
 
   491         return;
 
   505     }
 
   492     }
 
   506 
   493 
   507     if (fsm->datagram->working_counter != 1) {
 
   494     if (fsm->datagram->working_counter != 1) {
 
   508 	    ec_foe_set_tx_error(fsm, FOE_WC_ERROR);
 
   495         ec_foe_set_tx_error(fsm, FOE_WC_ERROR);
 
   509         EC_ERR("Reception of FoE data send failed on slave %u: ",
 
   496         EC_ERR("Reception of FoE data send failed on slave %u: ",
 
   510                 slave->ring_position);
 
   497                 slave->ring_position);
 
   511         ec_datagram_print_wc_error(datagram);
 
   498         ec_datagram_print_wc_error(datagram);
 
   512         return;
 
   499         return;
 
   513     }
 
   500     }
 
   528     uint8_t *data;
 
   515     uint8_t *data;
 
   529 
   516 
   530     current_size = fsm->rx_filename_len;
 
   517     current_size = fsm->rx_filename_len;
 
   531 
   518 
   532     if (!(data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
 
   519     if (!(data = ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram,
 
   533     		EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
 
   520                     EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
 
   534         return -1;
 
   521         return -1;
 
   535 
   522 
   536     EC_WRITE_U16(data, EC_FOE_OPCODE_RRQ); // fsm read request
 
   523     EC_WRITE_U16(data, EC_FOE_OPCODE_RRQ); // fsm read request
 
   537     EC_WRITE_U32(data + 2, 0x00000000); // no passwd
 
   524     EC_WRITE_U32(data + 2, 0x00000000); // no passwd
 
   538     memcpy(data + EC_FOE_HEADER_SIZE, fsm->rx_filename, current_size);
 
   525     memcpy(data + EC_FOE_HEADER_SIZE, fsm->rx_filename, current_size);
 
   550 
   537 
   551 int ec_foe_prepare_send_ack( ec_fsm_foe_t *foe ) {
 
   538 int ec_foe_prepare_send_ack( ec_fsm_foe_t *foe ) {
 
   552     uint8_t *data;
 
   539     uint8_t *data;
 
   553 
   540 
   554     if (!(data = ec_slave_mbox_prepare_send(foe->slave, foe->datagram,
 
   541     if (!(data = ec_slave_mbox_prepare_send(foe->slave, foe->datagram,
 
   555     		EC_MBOX_TYPE_FILEACCESS, EC_FOE_HEADER_SIZE)))
 
   542                     EC_MBOX_TYPE_FILEACCESS, EC_FOE_HEADER_SIZE)))
 
   556         return -1;
 
   543         return -1;
 
   557 
   544 
   558     EC_WRITE_U16( data, EC_FOE_OPCODE_ACK);
 
   545     EC_WRITE_U16( data, EC_FOE_OPCODE_ACK);
 
   559     EC_WRITE_U32( data + 2, foe->rx_expected_packet_no  );
 
   546     EC_WRITE_U32( data + 2, foe->rx_expected_packet_no  );
 
   560 
   547 
   570 
   557 
   571 void ec_fsm_foe_state_rrq_sent( ec_fsm_foe_t *fsm ) {
 
   558 void ec_fsm_foe_state_rrq_sent( ec_fsm_foe_t *fsm ) {
 
   572     ec_datagram_t *datagram = fsm->datagram;
 
   559     ec_datagram_t *datagram = fsm->datagram;
 
   573     ec_slave_t *slave = fsm->slave;
 
   560     ec_slave_t *slave = fsm->slave;
 
   574 
   561 
   575 #ifdef	myDEBUG
 
   562 #ifdef DEBUG_FOE
 
   576 	printk("ec_foe_state_rrq_sent()\n");
 
   563     printk("ec_foe_state_rrq_sent()\n");
 
   577 #endif
 
   564 #endif
 
       
   565 
   578     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   566     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   579     	ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   567         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   580         EC_ERR("Failed to send FoE RRQ for slave %u"
 
   568         EC_ERR("Failed to send FoE RRQ for slave %u"
 
   581                 " (datagram state %u).\n",
 
   569                 " (datagram state %u).\n",
 
   582                 slave->ring_position, datagram->state);
 
   570                 slave->ring_position, datagram->state);
 
   583         return;
 
   571         return;
 
   584     }
 
   572     }
 
   585 
   573 
   586     if (datagram->working_counter != 1) {
 
   574     if (datagram->working_counter != 1) {
 
   587     	// slave hat noch nichts in die Mailbox getan
 
   575         // slave did not put anything in the mailbox yet
 
   588         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   576         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   589         EC_ERR("Reception of FoE RRQ failed on slave %u: ",
 
   577         EC_ERR("Reception of FoE RRQ failed on slave %u: ",
 
   590                 slave->ring_position);
 
   578                 slave->ring_position);
 
   591         ec_datagram_print_wc_error(datagram);
 
   579         ec_datagram_print_wc_error(datagram);
 
   592     	return;
 
   580         return;
 
   593     }
 
   581     }
 
   594 
   582 
   595     fsm->jiffies_start = datagram->jiffies_sent;
 
   583     fsm->jiffies_start = datagram->jiffies_sent;
 
   596 
   584 
   597     ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 
   585     ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 
   600     fsm->state = ec_fsm_foe_state_data_check;
 
   588     fsm->state = ec_fsm_foe_state_data_check;
 
   601 }
 
   589 }
 
   602 
   590 
   603 /*****************************************************************************/
 
   591 /*****************************************************************************/
 
   604 
   592 
   605 #ifdef myDEBUG
 
       
   606 char		rx_buffer[0x8000];
 
       
   607 #endif
 
       
   608 
       
   609 void ec_fsm_foe_read(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   593 void ec_fsm_foe_read(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   610 {
 
   594 {
 
   611 	fsm->state = ec_fsm_foe_read_start;
 
   595     fsm->state = ec_fsm_foe_read_start;
 
   612 	fsm->rx_filename = fsm->request->file_name;
 
   596     fsm->rx_filename = fsm->request->file_name;
 
   613 	fsm->rx_filename_len = strlen(fsm->rx_filename);
 
   597     fsm->rx_filename_len = strlen(fsm->rx_filename);
 
   614 
   598 
   615 	fsm->rx_buffer = fsm->request->buffer;
 
   599     fsm->rx_buffer = fsm->request->buffer;
 
   616 	fsm->rx_buffer_size = fsm->request->buffer_size;
 
   600     fsm->rx_buffer_size = fsm->request->buffer_size;
 
   617 
       
   618 #ifdef use_ext_buffer
 
       
   619 	fsm->rx_buffer = rx_buffer;
 
       
   620 	fsm->rx_buffer_size = sizeof(rx_buffer);
 
       
   621 #endif
 
       
   622 }
 
   601 }
 
   623 
   602 
   624 /*****************************************************************************/
 
   603 /*****************************************************************************/
 
   625 
   604 
   626 void ec_fsm_foe_read_start(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   605 void ec_fsm_foe_read_start(ec_fsm_foe_t *fsm /**< finite state machine */)
 
   627 {
 
   606 {
 
   628 	size_t current_size;
 
   607     size_t current_size;
 
   629     ec_slave_t *slave = fsm->slave;
 
   608     ec_slave_t *slave = fsm->slave;
 
   630 
   609 
   631     fsm->rx_buffer_offset = 0;
 
   610     fsm->rx_buffer_offset = 0;
 
   632     fsm->rx_current_size = 0;
 
   611     fsm->rx_current_size = 0;
 
   633     fsm->rx_packet_no = 0;
 
   612     fsm->rx_packet_no = 0;
 
   634     fsm->rx_expected_packet_no = 1;
 
   613     fsm->rx_expected_packet_no = 1;
 
   635     fsm->rx_last_packet = 0;
 
   614     fsm->rx_last_packet = 0;
 
   636 
   615 
   637     current_size = fsm->rx_filename_len;
 
   616     current_size = fsm->rx_filename_len;
 
   638 
   617 
   639 #ifdef	myDEBUG
 
   618 #ifdef DEBUG_FOE
 
   640 	printk("ec_fsm_foe_read_start()\n");
 
   619     printk("ec_fsm_foe_read_start()\n");
 
   641 #endif
 
   620 #endif
 
       
   621 
   642     if (!(slave->sii.mailbox_protocols & EC_MBOX_FOE)) {
 
   622     if (!(slave->sii.mailbox_protocols & EC_MBOX_FOE)) {
 
   643     	ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 
   623         ec_foe_set_tx_error(fsm, FOE_MBOX_PROT_ERROR);
 
   644         EC_ERR("Slave %u does not support FoE!\n", slave->ring_position);
 
   624         EC_ERR("Slave %u does not support FoE!\n", slave->ring_position);
 
   645         return;
 
   625         return;
 
   646     }
 
   626     }
 
   647 
   627 
   648     if (ec_foe_prepare_rrq_send(fsm)) {
 
   628     if (ec_foe_prepare_rrq_send(fsm)) {
 
   657 
   637 
   658 void ec_fsm_foe_state_data_check ( ec_fsm_foe_t *fsm ) {
 
   638 void ec_fsm_foe_state_data_check ( ec_fsm_foe_t *fsm ) {
 
   659     ec_datagram_t *datagram = fsm->datagram;
 
   639     ec_datagram_t *datagram = fsm->datagram;
 
   660     ec_slave_t *slave = fsm->slave;
 
   640     ec_slave_t *slave = fsm->slave;
 
   661 
   641 
   662 #ifdef	myDEBUG
 
   642 #ifdef DEBUG_FOE
 
   663 	printk("ec_fsm_foe_state_data_check()\n");
 
   643     printk("ec_fsm_foe_state_data_check()\n");
 
   664 #endif
 
   644 #endif
 
   665 	if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   645 
       
   646     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   666         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   647         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   667         EC_ERR("Failed to send FoE DATA READ for slave %u"
 
   648         EC_ERR("Failed to send FoE DATA READ for slave %u"
 
   668                 " (datagram state %u).\n",
 
   649                 " (datagram state %u).\n",
 
   669                 slave->ring_position, datagram->state);
 
   650                 slave->ring_position, datagram->state);
 
   670         return;
 
   651         return;
 
   680 
   661 
   681     if (!ec_slave_mbox_check(datagram)) {
 
   662     if (!ec_slave_mbox_check(datagram)) {
 
   682         unsigned long diff_ms =
 
   663         unsigned long diff_ms =
 
   683             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
   664             (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 
   684         if (diff_ms >= EC_FSM_FOE_TIMEOUT) {
 
   665         if (diff_ms >= EC_FSM_FOE_TIMEOUT) {
 
   685         	ec_foe_set_tx_error(fsm, FOE_TIMEOUT_ERROR);
 
   666             ec_foe_set_tx_error(fsm, FOE_TIMEOUT_ERROR);
 
   686             EC_ERR("Timeout while waiting for ack response "
 
   667             EC_ERR("Timeout while waiting for ack response "
 
   687                     "on slave %u.\n", slave->ring_position);
 
   668                     "on slave %u.\n", slave->ring_position);
 
   688             return;
 
   669             return;
 
   689         }
 
   670         }
 
   690 
   671 
   701 
   682 
   702 }
 
   683 }
 
   703 
   684 
   704 /*****************************************************************************/
 
   685 /*****************************************************************************/
 
   705 
   686 
   706 void ec_fsm_foe_state_data_read ( ec_fsm_foe_t *fsm ) {
 
   687 void ec_fsm_foe_state_data_read(ec_fsm_foe_t *fsm)
 
   707     size_t 	rec_size;
 
   688 {
 
       
   689     size_t rec_size;
 
   708     uint8_t *data, opCode, packet_no, mbox_prot;
 
   690     uint8_t *data, opCode, packet_no, mbox_prot;
 
   709 
   691 
   710     ec_datagram_t *datagram = fsm->datagram;
 
   692     ec_datagram_t *datagram = fsm->datagram;
 
   711     ec_slave_t *slave = fsm->slave;
 
   693     ec_slave_t *slave = fsm->slave;
 
   712 
   694 
   713 #ifdef	myDEBUG
 
   695 #ifdef DEBUG_FOE
 
   714 	printk("ec_fsm_foe_state_data_read()\n");
 
   696     printk("ec_fsm_foe_state_data_read()\n");
 
   715 #endif
 
   697 #endif
 
   716 
   698 
   717     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   699     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   718     	ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   700         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   719         EC_ERR("Failed to receive FoE DATA READ datagram for"
 
   701         EC_ERR("Failed to receive FoE DATA READ datagram for"
 
   720                " slave %u (datagram state %u).\n",
 
   702                " slave %u (datagram state %u).\n",
 
   721                slave->ring_position, datagram->state);
 
   703                slave->ring_position, datagram->state);
 
   722         return;
 
   704         return;
 
   723     }
 
   705     }
 
   728                 slave->ring_position);
 
   710                 slave->ring_position);
 
   729         ec_datagram_print_wc_error(datagram);
 
   711         ec_datagram_print_wc_error(datagram);
 
   730         return;
 
   712         return;
 
   731     }
 
   713     }
 
   732 
   714 
   733 	if (!(data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size))) {
 
   715     if (!(data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size))) {
 
   734     	ec_foe_set_rx_error(fsm, FOE_MBOX_FETCH_ERROR);
 
   716         ec_foe_set_rx_error(fsm, FOE_MBOX_FETCH_ERROR);
 
   735         return;
 
   717         return;
 
   736     }
 
   718     }
 
   737 
   719 
   738 	if (mbox_prot != EC_MBOX_TYPE_FILEACCESS) { // FoE
 
   720     if (mbox_prot != EC_MBOX_TYPE_FILEACCESS) { // FoE
 
   739         EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
 
   721         EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
 
   740         ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
 
   722         ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
 
   741         return;
 
   723         return;
 
   742     }
 
   724     }
 
   743 
   725 
   750         return;
 
   732         return;
 
   751     }
 
   733     }
 
   752 
   734 
   753     if (opCode == EC_FOE_OPCODE_ERR) {
 
   735     if (opCode == EC_FOE_OPCODE_ERR) {
 
   754         fsm->request->error_code = EC_READ_U32(data + 2);
 
   736         fsm->request->error_code = EC_READ_U32(data + 2);
 
   755         EC_ERR("Received FoE Error Request (code %08x) on slave %u.\n",
 
   737         EC_ERR("Received FoE Error Request (code 0x%08x) on slave %u.\n",
 
   756                 fsm->request->error_code, slave->ring_position);
 
   738                 fsm->request->error_code, slave->ring_position);
 
   757         if (rec_size > 6) {
 
   739         if (rec_size > 6) {
 
   758             uint8_t text[1024];
 
   740             uint8_t text[1024];
 
   759             strncpy(text, data + 6, min(rec_size - 6, sizeof(text)));
 
   741             strncpy(text, data + 6, min(rec_size - 6, sizeof(text)));
 
   760             EC_ERR("FoE Error Text: %s\n", text);
 
   742             EC_ERR("FoE Error Text: %s\n", text);
 
   791         (rec_size + EC_MBOX_HEADER_SIZE + EC_FOE_HEADER_SIZE
 
   773         (rec_size + EC_MBOX_HEADER_SIZE + EC_FOE_HEADER_SIZE
 
   792          != fsm->slave->configured_rx_mailbox_size);
 
   774          != fsm->slave->configured_rx_mailbox_size);
 
   793 
   775 
   794     if (fsm->rx_last_packet ||
 
   776     if (fsm->rx_last_packet ||
 
   795             (slave->configured_rx_mailbox_size - EC_MBOX_HEADER_SIZE
 
   777             (slave->configured_rx_mailbox_size - EC_MBOX_HEADER_SIZE
 
   796              - EC_FOE_HEADER_SIZE + fsm->rx_buffer_offset) <= fsm->rx_buffer_size) {
 
   778              - EC_FOE_HEADER_SIZE + fsm->rx_buffer_offset)
 
   797         // either it was the last packet or a new packet will fit into the delivered buffer
 
   779             <= fsm->rx_buffer_size) {
 
   798 #ifdef	myDEBUG
 
   780         // either it was the last packet or a new packet will fit into the
 
   799     	printk ("last_packet=true\n");
 
   781         // delivered buffer
 
   800 #endif
 
   782 #ifdef DEBUG_FOE
 
   801 	    if (ec_foe_prepare_send_ack(fsm)) {
 
   783         printk ("last_packet=true\n");
 
   802 	    	ec_foe_set_rx_error(fsm, FOE_RX_DATA_ACK_ERROR);
 
   784 #endif
 
   803 	    	return;
 
   785         if (ec_foe_prepare_send_ack(fsm)) {
 
   804 	    }
 
   786             ec_foe_set_rx_error(fsm, FOE_RX_DATA_ACK_ERROR);
 
   805 
   787             return;
 
   806 	    fsm->state = ec_fsm_foe_state_sent_ack;
 
   788         }
 
       
   789 
       
   790         fsm->state = ec_fsm_foe_state_sent_ack;
 
   807     }
 
   791     }
 
   808     else {
 
   792     else {
 
   809     	// no more data fits into the delivered buffer
 
   793         // no more data fits into the delivered buffer
 
   810     	// ... wait for new read request
 
   794         // ... wait for new read request
 
   811     	printk ("ERROR: data doesn't fit in receive buffer\n");
 
   795         printk ("ERROR: data doesn't fit in receive buffer\n");
 
   812     	printk ("       rx_buffer_size  = %d\n", fsm->rx_buffer_size);
 
   796         printk ("       rx_buffer_size  = %d\n", fsm->rx_buffer_size);
 
   813     	printk ("       rx_buffer_offset= %d\n", fsm->rx_buffer_offset);
 
   797         printk ("       rx_buffer_offset= %d\n", fsm->rx_buffer_offset);
 
   814     	printk ("       rec_size        = %d\n", rec_size);
 
   798         printk ("       rec_size        = %d\n", rec_size);
 
   815     	printk ("       rx_mailbox_size = %d\n", slave->configured_rx_mailbox_size);
 
   799         printk ("       rx_mailbox_size = %d\n",
 
   816     	printk ("       rx_last_packet  = %d\n", fsm->rx_last_packet);
 
   800                 slave->configured_rx_mailbox_size);
 
   817 //    	fsm->state = ec_fsm_state_wait_next_read;
 
   801         printk ("       rx_last_packet  = %d\n", fsm->rx_last_packet);
 
   818     	fsm->request->result = FOE_READY;
 
   802         fsm->request->result = FOE_READY;
 
   819     }
 
   803     }
 
   820 }
 
   804 }
 
   821 
   805 
   822 /*****************************************************************************/
 
   806 /*****************************************************************************/
 
   823 
   807 
   824 void ec_fsm_foe_state_sent_ack( ec_fsm_foe_t *fsm ) {
 
   808 void ec_fsm_foe_state_sent_ack( ec_fsm_foe_t *fsm ) {
 
   825 
   809 
   826     ec_datagram_t *datagram = fsm->datagram;
 
   810     ec_datagram_t *datagram = fsm->datagram;
 
   827     ec_slave_t *slave = fsm->slave;
 
   811     ec_slave_t *slave = fsm->slave;
 
   828 
   812 
   829 #ifdef	myDEBUG
 
   813 #ifdef DEBUG_FOE
 
   830 	printk("ec_foe_state_sent_ack()\n");
 
   814     printk("ec_foe_state_sent_ack()\n");
 
   831 #endif
 
   815 #endif
 
       
   816 
   832     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   817     if (datagram->state != EC_DATAGRAM_RECEIVED) {
 
   833         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   818         ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
 
   834         EC_ERR("Failed to send FoE ACK for slave %u"
 
   819         EC_ERR("Failed to send FoE ACK for slave %u"
 
   835                 " (datagram state %u).\n",
 
   820                 " (datagram state %u).\n",
 
   836                 slave->ring_position, datagram->state);
 
   821                 slave->ring_position, datagram->state);
 
   837         return;
 
   822         return;
 
   838     }
 
   823     }
 
   839 
   824 
   840     if (datagram->working_counter != 1) {
 
   825     if (datagram->working_counter != 1) {
 
   841     	// slave hat noch nichts in die Mailbox getan
 
   826         // slave did not put anything into the mailbox yet
 
   842         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   827         ec_foe_set_rx_error(fsm, FOE_WC_ERROR);
 
   843         EC_ERR("Reception of FoE ACK failed on slave %u: ",
 
   828         EC_ERR("Reception of FoE ACK failed on slave %u: ",
 
   844                 slave->ring_position);
 
   829                 slave->ring_position);
 
   845         ec_datagram_print_wc_error(datagram);
 
   830         ec_datagram_print_wc_error(datagram);
 
   846     	return;
 
   831         return;
 
   847     }
 
   832     }
 
   848 
   833 
   849     fsm->jiffies_start = datagram->jiffies_sent;
 
   834     fsm->jiffies_start = datagram->jiffies_sent;
 
   850 
   835 
   851     ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 
   836     ec_slave_mbox_prepare_check(fsm->slave, datagram); // can not fail.
 
   852 
   837 
   853     if (fsm->rx_last_packet) {
 
   838     if (fsm->rx_last_packet) {
 
   854     	fsm->rx_expected_packet_no = 0;
 
   839         fsm->rx_expected_packet_no = 0;
 
   855     	fsm->request->data_size = fsm->rx_buffer_offset;
 
   840         fsm->request->data_size = fsm->rx_buffer_offset;
 
   856     	fsm->state = ec_fsm_foe_end;
 
   841         fsm->state = ec_fsm_foe_end;
 
   857     }
 
   842     }
 
   858     else {
 
   843     else {
 
   859     	fsm->rx_expected_packet_no++;
 
   844         fsm->rx_expected_packet_no++;
 
   860         fsm->retries = EC_FSM_RETRIES;
 
   845         fsm->retries = EC_FSM_RETRIES;
 
   861         fsm->state = ec_fsm_foe_state_data_check;
 
   846         fsm->state = ec_fsm_foe_state_data_check;
 
   862     }
 
   847     }
 
   863 }
 
   848 }
 
   864 
   849 
   865 /*****************************************************************************/
 
   850 /*****************************************************************************/
 
   866 
   851 
   867 void ec_foe_set_tx_error(ec_fsm_foe_t *fsm, uint32_t errorcode)
 
   852 void ec_foe_set_tx_error(ec_fsm_foe_t *fsm, uint32_t errorcode)
 
   868 {
 
   853 {
 
   869 	fsm->tx_errors++;
 
   854     fsm->tx_errors++;
 
   870 	fsm->request->result = errorcode;
 
   855     fsm->request->result = errorcode;
 
   871 	fsm->state = ec_fsm_foe_error;
 
   856     fsm->state = ec_fsm_foe_error;
 
   872 }
 
   857 }
 
   873 
   858 
   874 /*****************************************************************************/
 
   859 /*****************************************************************************/
 
   875 
   860 
   876 void ec_foe_set_rx_error(ec_fsm_foe_t *fsm, uint32_t errorcode)
 
   861 void ec_foe_set_rx_error(ec_fsm_foe_t *fsm, uint32_t errorcode)
 
   877 {
 
   862 {
 
   878 	fsm->rx_errors++;
 
   863     fsm->rx_errors++;
 
   879 	fsm->request->result = errorcode;
 
   864     fsm->request->result = errorcode;
 
   880 	fsm->state = ec_fsm_foe_error;
 
   865     fsm->state = ec_fsm_foe_error;
 
   881 }
 
   866 }
 
   882 
   867 
   883 /*****************************************************************************/
 
   868 /*****************************************************************************/
etherlabmaster