bldbgprc.c

本程序为ST公司开发的源代码

         /* Tx Message */
         /* RS232_TxBuffer[0] <- Byte Count    */
         /* RS232_TxBuffer[1] <- Error Code    */
         /* RS232_TxBuffer[2] <- Data MSB      */
         /* RS232_TxBuffer[3] <- Data          */
         /* RS232_TxBuffer[4] <- Data          */
         /* RS232_TxBuffer[5] <- Data LSB      */
         /* RS232_TxBuffer[6] <- Checksum      */
         if (bl->RS232_RxBuffer[BL_BYTE_COUNT] == BL_RDNM_MSG_LEN)
         {
          if (bl_cksum_verify(bl->RS232_RxBuffer[BL_BYTE_COUNT], bl->RS232_RxBuffer))
          {
           /* The Message Has Correct length */
           bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_NO_ERROR;
           bl->RS232_TxBuffer[2] = 0x0000;
           bl->RS232_TxBuffer[3] = 0x0000;
           bl->RS232_TxBuffer[4] = 0x0000;
           switch(bl->RS232_RxBuffer[4])
           {

            case BL_LONG_WISE:
             /* Bild a word pointer */
             //pf_lnmp = (volatile uint32 *)((RS232_RxBuffer[2] << BIT_8) | RS232_RxBuffer[3]);
             //ldata = *pf_lnmp;
             //RS232_TxBuffer[2] = (uint8)((ldata & 0xFF000000L) >> 0x18);
             //RS232_TxBuffer[3] = (uint8)((ldata & 0x00FF0000L) >> 0x10);
             //RS232_TxBuffer[4] = (uint8)((ldata & 0x0000FF00L) >> 0x08);
             //RS232_TxBuffer[5] = (uint8)((ldata & 0x000000FFL));
             bl_addr = bl_BaseAddrTbl[bl->RS232_RxBuffer[2]];
             bl_addr += bl->RS232_RxBuffer[3];
             //pf_lnmp  = (volatile uint32 *)((RS232_RxBuffer[2] << BIT_8) | RS232_RxBuffer[3]);
             //*pf_lnmp = ldata2;
             //ldata = *pf_lnmp;
             bl_data = *((uint32 *) bl_addr);
             bl->RS232_TxBuffer[2] = (bl_data & 0xFF000000) >> 0x18;
             bl->RS232_TxBuffer[3] = (bl_data & 0x00FF0000) >> 0x10;
             bl->RS232_TxBuffer[4] = (bl_data & 0x0000FF00) >> 0x08;
             bl->RS232_TxBuffer[5] = (bl_data & 0x000000FF);
            break;

            default:
             bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_ILL_CMND_ERR_CODE;
            break;
           }
          }
          else
          {
           bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_INV_CKSUM;
          }
          bl->RS232_TxBuffer[BL_BYTE_COUNT] = 6; //RDNM_ACK_LEN;
          bl_tx_msg(BL_RDNM_ACK_LEN, bl->RS232_TxBuffer, BL_PCIF);
         }
         else
         {
           /* Error Msg: Invalid Length */
         }
        break;
#endif

#if 0
        case BL_TEST_MSG_OP_CODE:
         /* Rx Message */
         /* RS232_RxBuffer[0] -> Byte Count  */
         /* RS232_RxBuffer[1] -> Op Code     */
         /* RS232_RxBuffer[2] -> Test No     */
         /* RS232_RxBuffer[3] -> Parm MSB    */
         /* RS232_RxBuffer[4] -> Parm LSB    */
         /* RS232_RxBuffer[5] -> Checksum    */
         /* Tx Message */
         /* RS232_TxBuffer[0] <- Byte Count      */
         /* RS232_TxBuffer[1] <- Error Code      */
         /* RS232_TxBuffer[2] <- Ret Parm MSB    */
         /* RS232_TxBuffer[3] <- Ret Parm LSB    */
         /* RS232_TxBuffer[4] <- Checksum        */

         if(bl->RS232_RxBuffer[BL_BYTE_COUNT] == BL_TEST_MSG_LEN)
         {
          /* The Message Has Correct length */
          if(bl_cksum_verify(bl->RS232_RxBuffer[BL_BYTE_COUNT], bl->RS232_RxBuffer))
          {
           bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_NO_ERROR;
           // data = (int16)(RS232_RxBuffer[4]);
           // sdata = (int16)((RS232_RxBuffer[3] << 8) + RS232_RxBuffer[4]);
           switch (bl->RS232_RxBuffer[2])
           {
            case BL_DWN_CODE_2_RAM_A:
             // This command is issued to enable the Software download through
             // the SDRAM into Serial Flash.
             bl->dwn_ctrl_flags.mem = BL_SDRAM;
             $Super$$sdram_init(0x40000000);
             bl->RS232_TxBuffer[BL_TEST_MSG_PARM_1]  = 0;
             bl->RS232_TxBuffer[BL_TEST_MSG_PARM_2]  = 0;
            break;


            case BL_EXECUTE_CODE_FROM_EXP_RAM:
             // The code is downloaded into EXP RAM without to be stored
             // into SF
             bl->dwn_ctrl_flags.mem = BL_EXPRAM;
             bl->RS232_TxBuffer[BL_TEST_MSG_PARM_1]  = 0;
             bl->RS232_TxBuffer[BL_TEST_MSG_PARM_2]  = 0;
            break;

            default:
             bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_TEST_NOT_IMPLEMENTED;
            break;
           }
          }
          else
          {
           bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_INV_CKSUM;
          }
          bl->RS232_TxBuffer[BL_BYTE_COUNT] = BL_TEST_MSG_ACK_LEN;
          bl_tx_msg(BL_TEST_MSG_ACK_LEN, bl->RS232_TxBuffer, BL_PCIF);
         }
         else
         {
          /* Error Msg: Invalid Length */
         }
        break;
#endif

        default:
           bl->RS232_TxBuffer[BL_BYTE_COUNT] = BL_ILL_CMND_MSG_LEN;
           bl->RS232_TxBuffer[BL_ERROR_CODE] = BL_ILL_CMND_ERR_CODE;
           bl_tx_msg(BL_ILL_CMND_MSG_LEN, bl->RS232_TxBuffer, BL_PCIF);
        break;
       } /* switch(RS232_RxBuffer[OP_CODE]) */

       // pf_cb &= ~(RX_BUSY | RX_MSG_RCVD); /* Put the Receiver in Idle Status */
      }

}


/******************************************************************************/
/* Function: bl_tx_msg                                                        */
/*                                                                            */
/* \brief    It transmits the the message on UART interface                   */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/

void bl_tx_msg(uint32 bl_msg_len, uint8 *bl_tx_msg_buf_ptr, uint32 bl_if_type)
{
    uint8 i;

    /* Calc Message Checksum */
    /* Initialize the Checksum byte */
    bl_tx_msg_buf_ptr[bl_msg_len] = 0x00;

    for (i = 0; i < bl_msg_len ; i++)
    {
       bl_tx_msg_buf_ptr[bl_msg_len] += bl_tx_msg_buf_ptr[i];
       bl_tx_msg_buf_ptr[bl_msg_len] &= 0xFF;
    }

    bl_RS232_Send();

}


/******************************************************************************/
/* Function: bl_cksum_verify                                                  */
/*                                                                            */
/* \brief    It verify the cksum of the recived message                       */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/


uint32 bl_cksum_verify(uint32 bl_byte_count, uint8 * bl_msg_buf_ptr)
{
    uint32 i;
    uint32 bl_cksum;

    bl_cksum = 0x00;

    for (i = 0; i < bl_byte_count; i++)
    {
       bl_cksum += bl_msg_buf_ptr[i];
    }

    bl_cksum &= 0xFF; // Added for uint32 Check

    if (bl_cksum == bl_msg_buf_ptr[bl_byte_count])
    {
        return BL_SUCCEEDED;
    }
    else
    {
        return BL_FAILURE;
    }
}


/******************************************************************************/
/* Function: bl_PrepareDram4Dwl                                               */
/*                                                                            */
/* \brief    It clears the RAM_A and SDRAM devoted to stores the code words   */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/

void bl_PrepareDram4Dwl(uint32 bl_start_addr, uint32 bl_end_addr)
{
 uint32 *bl_ram_addr_ptr;

 bl_ram_addr_ptr = (uint32 *) bl_start_addr;

 while(((uint32)bl_ram_addr_ptr) < bl_end_addr)
 {
  *bl_ram_addr_ptr = 0x00000000;
  bl_ram_addr_ptr++;
 }
}



/******************************************************************************/
/* Function: bl_FillDram                                                      */
/*                                                                            */
/* \brief    It stores the received code words into RAM_A and SDRAM           */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/


uint32 bl_FillDram(uint8  *bl_rx_buffer)
{
  uint32 i,len;

  uint32 * bl_ram_addr_ptr;


  //len = (bl_rx_buffer[0] & 0xFF);
  len = bl_rx_buffer[0];

  bl->ram_addr.field.b0 =  bl_rx_buffer[6];
  bl->ram_addr.field.b1 =  bl_rx_buffer[5];
  bl->ram_addr.field.b2 =  bl_rx_buffer[4];
  bl->ram_addr.field.b3 =  bl_rx_buffer[3];

  // We assume that the patch code is loaded in the following sequence:
  // 1) Patch Code into RAM_A.
  // 2) Overlay and DSP Code loaded into SDRAM address space


  if(bl->ram_addr.all >= BL_SDRAM_BASE_ADDR)
  {
   // Start to download code for SDRAM
   if(!bl->dwn_ctrl_flags.patch_code_activated)
   {
   	// Patch code (code for RAM_A) must be loaded first than SDRAM code then sdram_init()
   	// can be patched

   	bl->dwn_ctrl_flags.patch_code_activated = 1;

      sdram_init(0x40000000);

    // Clear all SDRAM that theoretically can be stored in Serial Flash
    bl_PrepareDram4Dwl(BL_SDRAM_BASE_ADDR, (BL_SDRAM_BASE_ADDR + BL_SDRAM_SIZE));
   }
  }

  bl_ram_addr_ptr = (uint32 *) (bl->ram_addr.all);


  i = 7;
  while(i < len)
  {
    bl->code_word.field.b1 = bl_rx_buffer[i++];
    bl->code_word.field.b0 = bl_rx_buffer[i++];
    bl->code_word.field.b3 = bl_rx_buffer[i++];
    bl->code_word.field.b2 = bl_rx_buffer[i++];
    *bl_ram_addr_ptr = bl->code_word.all;

    if(bl->ram_addr.all < BL_SDRAM_BASE_ADDR)
    {
      bl->code_size+=4; // code Size in Bytes
      if(bl->max_addr < (uint32) bl_ram_addr_ptr)
      {
        bl->max_addr = (uint32) bl_ram_addr_ptr;
      }  
      bl->code_checksum += bl->code_word.all;
    }
    else
    {
      bl->sdram_code_size+=4;
      if(bl->max_sdram_addr < (uint32) bl_ram_addr_ptr)
      {
      	bl->max_sdram_addr = (uint32) bl_ram_addr_ptr;
      }
      bl->sdram_code_checksum += bl->code_word.all;
    }

    bl_ram_addr_ptr++;

  }

  // Verify


  bl_ram_addr_ptr = (uint32 *) (bl->ram_addr.all);


  i = 7;
  while(i < len)
  {
    bl->code_word.field.b1 = bl_rx_buffer[i++];
    bl->code_word.field.b0 = bl_rx_buffer[i++];
    bl->code_word.field.b3 = bl_rx_buffer[i++];
    bl->code_word.field.b2 = bl_rx_buffer[i++];
    if(bl->code_word.all != *bl_ram_addr_ptr)
    {
     return 0;
    }
    bl_ram_addr_ptr++;
  }

   return 1;
}




/******************************************************************************/
/* Function: bl_StoreProgramToFlash                                           */
/*                                                                            */
/* \brief    It stores the downloaded program into Serial Flash               */
/*                                                                            */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/

uint32 bl_StoreProgramToFlash(BL_BSPI_STRUCT *bl_bspi_ptr)
{

  uint32 i;
  uint32 j;
  uint32 *bl_code_addr_ptr;
  uint32 bl_sf_addr;
  uint32 bl_mem_size;

  // Wake Up Serial Flash
  //!!if(bl->dwn_ctrl_flags.sdram_connected)
  //!!{
  
   SelectSdram(SELECT_BSPI);

   bl_bspi_ptr->sf_id = bl_bspi_rdid(bl_bspi_ptr);
   if(bl_sf_erase(bl_bspi_ptr) == 0)