bldbgprc.c

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

/******************************************************************************/
/* Function: bl_WakeUpBSPI                                                    */
/*                                                                            */
/* \brief    WakeUp BSPI                                                      */
/*                                                                            */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/


void bl_WakeUpBSPI(BL_BSPI_STRUCT * bl_bspi_ptr)
{
  // Wake-up BSPI
  //!!if(bl->dwn_ctrl_flags.sdram_connected)
  //!!{
   SelectSdram(SELECT_BSPI);

   bl_bspi_ptr->sf_id = bl_bspi_rdid(bl_bspi_ptr);  // Wake up Serial Flash

   SelectSdram(SELECT_SDRAM);

  //!!}
  //!!else
  //!!{
  //!! bl_bspi_ptr->sf_id = bl_bspi_rdid(bl_bspi_ptr);  // Wake up Serial Flash	
  //!!}  	
}

/******************************************************************************/
/* Function: bl_CopyPatchedCode                                               */
/*                                                                            */
/* \brief    It copy patch code from Serial Flash into RAM_A                  */
/*           of the Serial Flash                                              */
/* \param    void                                                             */
/*                                                                            */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/

uint32 bl_CopyPatchedCode(BL_BSPI_STRUCT *bl_bspi_ptr)
{

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

  // Load Code in the Patch Area
  bl_code_addr_ptr = (uint32 *)BL_RAM_A_BASE_ADDR;
  bl_sf_addr = BL_SF_PATCH_AREA_START_ADDR;
  bl_mem_size = bl->patch_area_size;

  // It is unusful to fix the starting address of the Overlay Area
  // Load all Serial Flash Contenbt into the RAM_A
  for(i = 0; i < (bl_mem_size >>8); i++)
  {
   // Each Cycle is 256 bytes (0x100)

   //!!if(bl->dwn_ctrl_flags.sdram_connected)
   //!!{
    SelectSdram(SELECT_BSPI);

    bl_sf_read(bl_sf_addr, 256, bl_bspi_ptr );

    SelectSdram(SELECT_SDRAM);
   //!!}
   //!!else
   //!!{
   //!!	bl_sf_read(bl_sf_addr, 256, bl_bspi_ptr);
   //!!}

   j = 0;
   while(j < 256)
   {
    bl->code_word.field.b0 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b1 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b2 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b3 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    *bl_code_addr_ptr = bl->code_word.all;
    bl->code_checksum += bl->code_word.all;

    bl_code_addr_ptr++;
   }
   bl_sf_addr += 0x100;
  }
  return 1;
}


/******************************************************************************/
/* Function: bl_CopyProgram2Sdram                                             */
/*                                                                            */
/* \brief    It copy the overlay code from Serial Flash to SDRAM              */
/*           of the Serial Flash                                              */
/* \param    size: size of the overlay code                                   */
/*                                                                                         */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/


uint32 bl_CopyProgram2Sdram(uint32 size, BL_BSPI_STRUCT * bl_bspi_ptr)
{

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


  // Rounded to the next 256 bytes.
  size += 0x100;
  size &= 0xFFFFFF00;
  size = size - BL_SDRAM_BASE_ADDR;

  // Load Code in the Patch Area
  bl_code_addr_ptr = (uint32 *)BL_SDRAM_BASE_ADDR;
  bl_sf_addr = bl->sf_overlay_area_start_addr;

  // It is unusful to fix the starting address of the Overlay Area
  // Load all Serial Flash Contenbt into the RAM_A
  for(i = 0; i < (size >> 8); i++)
  {
   // Each Cycle is 256 bytes (0x100)
   //!!if(bl->dwn_ctrl_flags.sdram_connected)
   //!!{
    SelectSdram(SELECT_BSPI);

    bl_sf_read(bl_sf_addr, 256, bl_bspi_ptr);

    SelectSdram(SELECT_SDRAM);
   //!!}
   //!!else
   //!!{
   //!!	bl_sf_read(bl_sf_addr, 256, bl_bspi_ptr);
   //!!}

   j = 0;
   while(j < 256)
   {
    bl->code_word.field.b0 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b1 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b2 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b3 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    *bl_code_addr_ptr = bl->code_word.all;
    bl->code_checksum += bl->code_word.all;

    bl_code_addr_ptr++;
   }
   bl_sf_addr += 0x100;
  }
  return 1;
}

#if 0
/******************************************************************************/
/* Function: CopyProgramToRam_A                                               */
/*                                                                            */
/* \brief    It copy form SF to RAM A                                         */
/*           of the Serial Flash                                              */
/* \param    SDRAM/BSPI                                                       */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/
uint32 bl_CopyProgramToRam_A(BL_BSPI_STRUCT *bl_bspi_ptr)
{

  uint32 i;
  uint32 j;
  uint32 *code_addr_ptr;
  uint32 sf_addr;

  bl_WakeUpBSPI(bl_bspi_ptr);  // Wake up Serial Flash

  // Verify
  code_addr_ptr = (uint32 *)BL_RAM_A_BASE_ADDR;
  sf_addr = 0x00000000;

  for(i = 0; i < (BL_RAM_A_SIZE >>8); i++)
  {
   // Each Cycle is 256 bytes (0x100)
   bl_sf_read(sf_addr, 256, bl_bspi_ptr);

   j = 0;
   while(j < 256)
   {
    bl->code_word.field.b0 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b1 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b2 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    bl->code_word.field.b3 = bl_bspi_ptr->bspi_rx_buffer[4 + j++];
    *code_addr_ptr = bl->code_word.all;
    bl->code_checksum += bl->code_word.all;

    code_addr_ptr++;
   }
   sf_addr += 0x100;
  }
  return 1;
}
#endif


/******************************************************************************/
/* Function: bl_read_patch_code_info                                                 */
/*                                                                            */
/* \brief    It reads download information stored into last 256 bytes         */
/*           of the Serial Flash                                              */
/* \param    SDRAM/BSPI                                                       */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/

void bl_read_patch_code_info(BL_BSPI_STRUCT *bl_bspi_ptr)
{

 
 
 //!!if(bl->dwn_ctrl_flags.sdram_connected)
 //!!{
  SelectSdram(SELECT_BSPI);

  bl_sf_read(bl->sf_dwn_info , 256, bl_bspi_ptr);

  SelectSdram(SELECT_SDRAM);
 //!!}
 //!!else
 //!!{
 //!! bl_sf_read(BL_SF_DWN_INFO , 256, bl_bspi_ptr);		
 //!!}

 bl->sf_sdram_code_checksum.field.b0 = bl_bspi_ptr->bspi_rx_buffer[256];
 bl->sf_sdram_code_checksum.field.b1 = bl_bspi_ptr->bspi_rx_buffer[257];
 bl->sf_sdram_code_checksum.field.b2 = bl_bspi_ptr->bspi_rx_buffer[258];
 bl->sf_sdram_code_checksum.field.b3 = bl_bspi_ptr->bspi_rx_buffer[259];

 bl->sf_sdram_code_size.field.b0 = bl_bspi_ptr->bspi_rx_buffer[252];
 bl->sf_sdram_code_size.field.b1 = bl_bspi_ptr->bspi_rx_buffer[253];
 bl->sf_sdram_code_size.field.b2 = bl_bspi_ptr->bspi_rx_buffer[254];
 bl->sf_sdram_code_size.field.b3 = bl_bspi_ptr->bspi_rx_buffer[255];

 bl->sf_sdram_max_addr.field.b0 = bl_bspi_ptr->bspi_rx_buffer[248];
 bl->sf_sdram_max_addr.field.b1 = bl_bspi_ptr->bspi_rx_buffer[249];
 bl->sf_sdram_max_addr.field.b2 = bl_bspi_ptr->bspi_rx_buffer[250];
 bl->sf_sdram_max_addr.field.b3 = bl_bspi_ptr->bspi_rx_buffer[251];

 bl->sf_code_checksum.field.b0 = bl_bspi_ptr->bspi_rx_buffer[244];
 bl->sf_code_checksum.field.b1 = bl_bspi_ptr->bspi_rx_buffer[245];
 bl->sf_code_checksum.field.b2 = bl_bspi_ptr->bspi_rx_buffer[246];
 bl->sf_code_checksum.field.b3 = bl_bspi_ptr->bspi_rx_buffer[247];

 bl->sf_code_size.field.b0 = bl_bspi_ptr->bspi_rx_buffer[240];
 bl->sf_code_size.field.b1 = bl_bspi_ptr->bspi_rx_buffer[241];
 bl->sf_code_size.field.b2 = bl_bspi_ptr->bspi_rx_buffer[242];
 bl->sf_code_size.field.b3 = bl_bspi_ptr->bspi_rx_buffer[243];

 bl->sf_max_addr.field.b0 = bl_bspi_ptr->bspi_rx_buffer[236];
 bl->sf_max_addr.field.b1 = bl_bspi_ptr->bspi_rx_buffer[237];
 bl->sf_max_addr.field.b2 = bl_bspi_ptr->bspi_rx_buffer[238];
 bl->sf_max_addr.field.b3 = bl_bspi_ptr->bspi_rx_buffer[239];

 
}


/******************************************************************************/
/* Function:  SelectSDRAM                                                     */
/*                                                                            */
/* \brief    Select SDRAM or BSPI on DRD0,DRD1,DRD2 pins                      */
/* \param    SDRAM/BSPI                                                       */
/* \return   void                                                             */
/* \remark                                                                    */
/*                                                                            */
/******************************************************************************/

void SelectSdram(uint32 sel)
{
 volatile uint32 i;
 volatile uint32 sdram_mem_config;

  if (sel == SELECT_SDRAM)
  {
    // Check if SDRAM has been initialized.
    if (CGC_PUR1.field.sdramc)
    {
      BSPI_CSR1.field.bspe = 0; // Disable BSPI
      GCR1.field.sdram_sel = 1; //Select SDRAM
      // Exit From Power Save
      sdram_mem_config = SDRAM_MEM_CONFIG.all;
      sdram_mem_config &= ~0x2000;
      SDRAM_MEM_CONFIG.all = sdram_mem_config;
    }
  }
  else
  {
    // Power Save
    if (CGC_PUR1.field.sdramc)
    {
      sdram_mem_config = SDRAM_MEM_CONFIG.all;
      sdram_mem_config |= 0x2000;
      SDRAM_MEM_CONFIG.all = sdram_mem_config;
    }
    GCR1.field.sdram_sel = 0; //Select BSPI;
    BSPI_CSR1.field.bspe = 1;
  }

  for (i = 0; i < 0x1000; i++)
    ; //TODO Wait To Be Tuned
}


#if 0
/******************************************************************************/
/* Function:  bl_copy_code                                                     */
/*                                                                            */
/*! \brief    Initalize the Monitor variables
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void bl_copy_code(void)
{
  uint32 volatile * sdram_ptr;
  uint32 volatile * ram_a_ptr;
  uint32 i;
  uint32 data;

  sdram_ptr = (uint32 *)BL_SDRAM_BASE_ADDR;
  ram_a_ptr = (uint32 *)BL_RAM_A_BASE_ADDR;

  for(i = 0; i < BL_RAM_A_SIZE>>2;i++)
  {
   data = sdram_ptr[i];
   ram_a_ptr[i] = data;
  }
}

#endif
/******************************************************************************/
/* Function:  bl_wr_bspi_tx_buffer                                                     */
/*                                                                            */
/*! \brief    Initalize the Monitor variables
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void bl_wr_bspi_tx_buffer(BL_BSPI_STRUCT *bl_bspi_ptr, uint32 *idx)
{
 bl_bspi_ptr->bspi_tx_buffer[(*idx)++] = bl->code_word.field.b0;
 bl_bspi_ptr->bspi_tx_buffer[(*idx)++] = bl->code_word.field.b1;
 bl_bspi_ptr->bspi_tx_buffer[(*idx)++] = bl->code_word.field.b2;
 bl_bspi_ptr->bspi_tx_buffer[(*idx)++] = bl->code_word.field.b3;
}

/*** (c) 2006  STMicroelectronics **************************** END OF FILE ***/