master/fsm_foe.c
changeset 2606 764801a0f2aa
parent 2605 f3843f68644f
child 2607 b59d6aecdbaa
equal deleted inserted replaced
2605:f3843f68644f 2606:764801a0f2aa
   255         return -1;
   255         return -1;
   256     }
   256     }
   257 
   257 
   258     EC_WRITE_U16(data, EC_FOE_OPCODE_DATA);    // OpCode = DataBlock req.
   258     EC_WRITE_U16(data, EC_FOE_OPCODE_DATA);    // OpCode = DataBlock req.
   259     EC_WRITE_U32(data + 2, fsm->tx_packet_no); // PacketNo, Password
   259     EC_WRITE_U32(data + 2, fsm->tx_packet_no); // PacketNo, Password
       
   260 #ifdef DEBUG_FOE
       
   261     EC_SLAVE_DBG(fsm->slave, 0, "sending opcode %u packet %u\n",
       
   262             EC_FOE_OPCODE_DATA, fsm->tx_packet_no);
       
   263 #endif
   260 
   264 
   261     memcpy(data + EC_FOE_HEADER_SIZE,
   265     memcpy(data + EC_FOE_HEADER_SIZE,
   262             fsm->tx_buffer + fsm->tx_buffer_offset, current_size);
   266             fsm->tx_buffer + fsm->tx_buffer_offset, current_size);
   263     fsm->tx_current_size = current_size;
   267     fsm->tx_current_size = current_size;
   264 
   268 
   292         return -1;
   296         return -1;
   293     }
   297     }
   294 
   298 
   295     EC_WRITE_U16( data, EC_FOE_OPCODE_WRQ); // fsm write request
   299     EC_WRITE_U16( data, EC_FOE_OPCODE_WRQ); // fsm write request
   296     EC_WRITE_U32( data + 2, fsm->tx_packet_no );
   300     EC_WRITE_U32( data + 2, fsm->tx_packet_no );
       
   301 #ifdef DEBUG_FOE
       
   302     EC_SLAVE_DBG(fsm->slave, 0, "sending opcode %u packet %u\n",
       
   303             EC_FOE_OPCODE_WRQ, fsm->tx_packet_no);
       
   304 #endif
   297 
   305 
   298     memcpy(data + EC_FOE_HEADER_SIZE, fsm->tx_filename, current_size);
   306     memcpy(data + EC_FOE_HEADER_SIZE, fsm->tx_filename, current_size);
   299 
   307 
   300     return 0;
   308     return 0;
   301 }
   309 }
   429                 mbox_prot);
   437                 mbox_prot);
   430         return;
   438         return;
   431     }
   439     }
   432 
   440 
   433     opCode = EC_READ_U8(data);
   441     opCode = EC_READ_U8(data);
       
   442 #ifdef DEBUG_FOE
       
   443     EC_SLAVE_DBG(fsm->slave, 0, "received opcode %u\n", opCode);
       
   444 #endif
   434 
   445 
   435     if (opCode == EC_FOE_OPCODE_BUSY) {
   446     if (opCode == EC_FOE_OPCODE_BUSY) {
   436         // slave not ready
   447         // slave not ready
   437         if (ec_foe_prepare_data_send(fsm, datagram)) {
   448         if (ec_foe_prepare_data_send(fsm, datagram)) {
   438             ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
   449             ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
   441         }
   452         }
   442         fsm->state = ec_fsm_foe_state_data_sent;
   453         fsm->state = ec_fsm_foe_state_data_sent;
   443         return;
   454         return;
   444     }
   455     }
   445 
   456 
       
   457     if (opCode == EC_FOE_OPCODE_ERR) {
       
   458         fsm->request->error_code = EC_READ_U32(data + 2);
       
   459         EC_SLAVE_ERR(slave, "Received FoE Error Request (code 0x%08x).\n",
       
   460                 fsm->request->error_code);
       
   461         if (rec_size > 6 && data[6]) {
       
   462             uint8_t text[256];
       
   463             strncpy(text, data + 6, min(rec_size - 6, sizeof(text)));
       
   464             text[sizeof(text)-1] = 0;
       
   465             EC_SLAVE_ERR(slave, "FoE Error Text: %s\n", text);
       
   466         }
       
   467         ec_foe_set_tx_error(fsm, FOE_OPCODE_ERROR);
       
   468         return;
       
   469     }
       
   470 
   446     if (opCode == EC_FOE_OPCODE_ACK) {
   471     if (opCode == EC_FOE_OPCODE_ACK) {
   447         fsm->tx_packet_no++;
   472         fsm->tx_packet_no++;
   448         fsm->tx_buffer_offset += fsm->tx_current_size;
   473         fsm->tx_buffer_offset += fsm->tx_current_size;
   449 
   474 
   450         if (fsm->tx_last_packet) {
   475         if (fsm->tx_last_packet) {
   564     }
   589     }
   565 
   590 
   566     EC_WRITE_U16(data, EC_FOE_OPCODE_RRQ); // fsm read request
   591     EC_WRITE_U16(data, EC_FOE_OPCODE_RRQ); // fsm read request
   567     EC_WRITE_U32(data + 2, 0x00000000); // no passwd
   592     EC_WRITE_U32(data + 2, 0x00000000); // no passwd
   568     memcpy(data + EC_FOE_HEADER_SIZE, fsm->rx_filename, current_size);
   593     memcpy(data + EC_FOE_HEADER_SIZE, fsm->rx_filename, current_size);
       
   594 #ifdef DEBUG_FOE
       
   595     EC_SLAVE_DBG(fsm->slave, 0, "sending opcode %u\n", EC_FOE_OPCODE_RRQ);
       
   596 #endif
   569 
   597 
   570     if (fsm->slave->master->debug_level) {
   598     if (fsm->slave->master->debug_level) {
   571         EC_SLAVE_DBG(fsm->slave, 1, "FoE Read Request:\n");
   599         EC_SLAVE_DBG(fsm->slave, 1, "FoE Read Request:\n");
   572         ec_print_data(data, current_size + EC_FOE_HEADER_SIZE);
   600         ec_print_data(data, current_size + EC_FOE_HEADER_SIZE);
   573     }
   601     }
   594         return -1;
   622         return -1;
   595     }
   623     }
   596 
   624 
   597     EC_WRITE_U16(data, EC_FOE_OPCODE_ACK);
   625     EC_WRITE_U16(data, EC_FOE_OPCODE_ACK);
   598     EC_WRITE_U32(data + 2, fsm->rx_expected_packet_no);
   626     EC_WRITE_U32(data + 2, fsm->rx_expected_packet_no);
       
   627 #ifdef DEBUG_FOE
       
   628     EC_SLAVE_DBG(fsm->slave, 0, "sending opcode %u packet %u\n",
       
   629             EC_FOE_OPCODE_ACK, fsm->rx_expected_packet_no);
       
   630 #endif
   599 
   631 
   600     return 0;
   632     return 0;
   601 }
   633 }
   602 
   634 
   603 /*****************************************************************************/
   635 /*****************************************************************************/
   768         ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
   800         ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
   769         return;
   801         return;
   770     }
   802     }
   771 
   803 
   772     opCode = EC_READ_U8(data);
   804     opCode = EC_READ_U8(data);
       
   805 #ifdef DEBUG_FOE
       
   806     EC_SLAVE_DBG(fsm->slave, 0, "received opcode %u\n", opCode);
       
   807 #endif
   773 
   808 
   774     if (opCode == EC_FOE_OPCODE_BUSY) {
   809     if (opCode == EC_FOE_OPCODE_BUSY) {
   775         fsm->rx_expected_packet_no--;
   810         fsm->rx_expected_packet_no--;
   776         if (ec_foe_prepare_send_ack(fsm, datagram)) {
   811         if (ec_foe_prepare_send_ack(fsm, datagram)) {
   777             ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
   812             ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
       
   813         } else {
       
   814             fsm->state = ec_fsm_foe_state_sent_ack;
   778         }
   815         }
   779         fsm->state = ec_fsm_foe_state_sent_ack;
       
   780 #ifdef DEBUG_FOE
   816 #ifdef DEBUG_FOE
   781         EC_SLAVE_DBG(fsm->slave, 0, "%s() busy. Next pkt %u\n", __func__,
   817         EC_SLAVE_DBG(fsm->slave, 0, "%s() busy. Next pkt %u\n", __func__,
   782                 fsm->rx_expected_packet_no);
   818                 fsm->rx_expected_packet_no);
   783 #endif
   819 #endif
   784         return;
   820         return;
   786 
   822 
   787     if (opCode == EC_FOE_OPCODE_ERR) {
   823     if (opCode == EC_FOE_OPCODE_ERR) {
   788         fsm->request->error_code = EC_READ_U32(data + 2);
   824         fsm->request->error_code = EC_READ_U32(data + 2);
   789         EC_SLAVE_ERR(slave, "Received FoE Error Request (code 0x%08x).\n",
   825         EC_SLAVE_ERR(slave, "Received FoE Error Request (code 0x%08x).\n",
   790                 fsm->request->error_code);
   826                 fsm->request->error_code);
   791         if (rec_size > 6) {
   827         if (rec_size > 6 && data[6]) {
   792             uint8_t text[256];
   828             uint8_t text[256];
   793             strncpy(text, data + 6, min(rec_size - 6, sizeof(text)));
   829             strncpy(text, data + 6, min(rec_size - 6, sizeof(text)));
       
   830             text[sizeof(text)-1] = 0;
   794             EC_SLAVE_ERR(slave, "FoE Error Text: %s\n", text);
   831             EC_SLAVE_ERR(slave, "FoE Error Text: %s\n", text);
   795         }
   832         }
   796         ec_foe_set_rx_error(fsm, FOE_OPCODE_ERROR);
   833         ec_foe_set_rx_error(fsm, FOE_OPCODE_ERROR);
   797         return;
   834         return;
   798     }
   835     }