279 lines
8.5 KiB
C
279 lines
8.5 KiB
C
#include <string.h>
|
|
#include "logo_table.h"
|
|
#include "common.h"
|
|
#include "loadtable.h"
|
|
//#include "asr_nor_flash.h"
|
|
#include "ptable.h"
|
|
|
|
|
|
|
|
/*********************************** new variable type definition ********************************************/
|
|
|
|
|
|
|
|
/*********************************** static variable definition ********************************************/
|
|
static UINT32 s_logo_flash_start_addr = LOGO_INVALID_VALUE;
|
|
static UINT32 s_logo_flash_size = LOGO_INVALID_VALUE;
|
|
|
|
static LogoHeaderTableStruct s_LogoHeaderInfo;
|
|
static LogoHeaderTableStruct *pLogoHeaderInfo = LOGO_INVALID_VALUE;
|
|
static LogoFunctionMagicType_Enum s_logo_function_magic_type = logo_no_function_magic;
|
|
|
|
|
|
/*********************************** static function declare ********************************************/
|
|
static BOOL init_logo_flash_info(UINT32 *pFlashStartAddr, UINT32 *pFlashSize);
|
|
static UINT32 get_logo_function_magic_value( void );
|
|
static void init_logo_function_magic_type(LogoFunctionMagicType_Enum *p_logo_function_magic_type);
|
|
static BOOL IsLogoValidMagicRight(const UINT32 LogoFlashAddr);
|
|
|
|
/*********************************** external function definition **** ************************************/
|
|
void logo_header_table_init(void)
|
|
{
|
|
UINT32 logo_flash_start_address;
|
|
static BOOL init_flag = FALSE;
|
|
|
|
if(init_flag == FALSE){
|
|
if(TRUE != init_logo_flash_info(&s_logo_flash_start_addr,&s_logo_flash_size) ){
|
|
CP_LOGE("[ERROR] func:%s, line:%d,get logo flash start addr error!\r\n",__func__,__LINE__);
|
|
while(1);
|
|
}
|
|
logo_flash_start_address = get_logo_flash_start_addr();
|
|
CP_LOGD("logo flash start addr:0x%x\r\n",logo_flash_start_address);
|
|
CP_LOGD("LogoHeaderInfo size:0x%x\r\n",sizeof(LogoHeaderTableStruct));
|
|
#ifdef MCU_DS
|
|
asr_norflash_read(logo_flash_start_address, &s_LogoHeaderInfo, sizeof(LogoHeaderTableStruct));
|
|
#else
|
|
crane_qspi_read(logo_flash_start_address - QSPI_FLASH_BASE, &s_LogoHeaderInfo, sizeof(LogoHeaderTableStruct));
|
|
#endif
|
|
|
|
pLogoHeaderInfo = (LogoHeaderTableStruct *)&s_LogoHeaderInfo;
|
|
init_logo_function_magic_type(&s_logo_function_magic_type);
|
|
CP_LOGD("func:%s,s_logo_function_magic_type:%d\r\n",__func__,s_logo_function_magic_type);
|
|
init_flag = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LogoFunctionMagicType_Enum get_logo_function_magic_type(void)
|
|
{
|
|
return s_logo_function_magic_type;
|
|
}
|
|
|
|
BOOL IsLogoSupportQueryExtImgInfo(void)
|
|
{
|
|
LogoFunctionMagicType_Enum logo_function_magic_type;
|
|
|
|
logo_function_magic_type = get_logo_function_magic_type();
|
|
|
|
return logo_function_magic_type == logo_magic2_support_query_info_and_append_dsp_adc;
|
|
}
|
|
|
|
|
|
BOOL IsLogoAppendDspAdc(void)
|
|
{
|
|
UINT32 dsp_adc_size;
|
|
|
|
dsp_adc_size = logo_get_ext_dsp_adc_size();
|
|
|
|
if( dsp_adc_size != LOGO_INVALID_VALUE ){
|
|
return TRUE;
|
|
}else{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
UINT32 get_logo_flash_start_addr(void)
|
|
{
|
|
if( s_logo_flash_start_addr != LOGO_INVALID_VALUE ){
|
|
return s_logo_flash_start_addr;
|
|
}else{
|
|
CP_LOGE("[ERROR] logo flash start addr error:0x%x\r\n",LOGO_INVALID_VALUE);
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
UINT32 get_logo_flash_size(void)
|
|
{
|
|
if( s_logo_flash_size != LOGO_INVALID_VALUE ){
|
|
return s_logo_flash_size;
|
|
}else{
|
|
CP_LOGE("[ERROR] logo flash size error:0x%x\r\n",LOGO_INVALID_VALUE);
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT32 logo_get_ext_combine_bin_size(void)
|
|
{
|
|
if( IsLogoSupportQueryExtImgInfo() ){
|
|
return (pLogoHeaderInfo->symbol_info_union.logo_symbol_info.ext_combine_bin_size.value);
|
|
}else{
|
|
CP_LOGE("file:%s,func:%s,line:%d\r\n",__FILE__,__func__,__LINE__);
|
|
CP_LOGE("[ERROR] not support get ext combine size from logo.bin\r\n");
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
|
|
UINT32 logo_get_ext_logo_size(void)
|
|
{
|
|
if( IsLogoSupportQueryExtImgInfo() ){
|
|
return (pLogoHeaderInfo->symbol_info_union.logo_symbol_info.ext_logo_size.value);
|
|
}else{
|
|
CP_LOGE("file:%s,func:%s,line:%d\r\n",__FILE__,__func__,__LINE__);
|
|
CP_LOGE("[ERROR] not support get ext logo size from logo.bin\r\n");
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
UINT32 logo_get_ext_dsp_adc_size(void)
|
|
{
|
|
if( IsLogoSupportQueryExtImgInfo() == TRUE ){
|
|
return (pLogoHeaderInfo->symbol_info_union.logo_symbol_info.ext_dsp_adc_size.value);
|
|
}else{
|
|
CP_LOGE("file:%s,func:%s,line:%d\r\n",__FILE__,__func__,__LINE__);
|
|
CP_LOGE("[ERROR] not support get ext dsp_adc size from logo.bin\r\n");
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
UINT32 logo_get_ext_dsp_adc_flash_start_addr(void)
|
|
{
|
|
return (get_logo_flash_start_addr() + logo_get_ext_logo_size());
|
|
}
|
|
|
|
|
|
UINT32 logo_get_ext_dsp_adc_exec_addr(void)
|
|
{
|
|
if( IsLogoAppendDspAdc() == TRUE ){
|
|
return (pLogoHeaderInfo->symbol_info_union.logo_symbol_info.ext_dsp_adc_exec_addr.value);
|
|
}else{
|
|
CP_LOGE("file:%s,func:%s,line:%d\r\n",__FILE__,__func__,__LINE__);
|
|
CP_LOGE("[ERROR] not support get dsp_adc exec addr from logo.bin\r\n");
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
#if (CONFIG_ADD_LOGO_HEADER_TABLE_TEST_CASE == 1)
|
|
void dump_logo_image_info(void)
|
|
{
|
|
if( IsLogoSupportQueryExtImgInfo() ){
|
|
CP_LOGD("[LOGO] logo function magic type:%d\r\n",get_logo_function_magic_type());
|
|
CP_LOGD("[LOGO] ext combine bin size : 0x%x\r\n",logo_get_ext_combine_bin_size());
|
|
CP_LOGD("[LOGO] logo size: 0x%x\r\n",logo_get_ext_logo_size());
|
|
CP_LOGD("[LOGO] dsp_adc size: %d\r\n",logo_get_ext_dsp_adc_size());
|
|
}else{
|
|
CP_LOGD("[LOGO] logo not append dsp_adc\r\n");
|
|
}
|
|
}
|
|
|
|
void test_logo_header_table(void)
|
|
{
|
|
LogoFunctionMagicType_Enum magic_type;
|
|
|
|
/* [1] header table init */
|
|
logo_header_table_init();
|
|
|
|
/* [2] get logo load addr and exec addr */
|
|
|
|
/* [3] get logo function magic type */
|
|
CP_LOGD("logo function magic type:%d\r\n",get_logo_function_magic_type());
|
|
if( IsLogoSupportQueryExtImgInfo() ){
|
|
CP_LOGD("logo ext combine size:0x%x\r\n",logo_get_ext_combine_bin_size());
|
|
CP_LOGD("logo ext logo size:0x%x\r\b",logo_get_ext_logo_size());
|
|
CP_LOGD("logo ext dsp_adc size:0x%x\r\b",logo_get_ext_dsp_adc_size());
|
|
CP_LOGD("logo ext dsp_adc start addr:0x%x\r\b",logo_get_ext_dsp_adc_flash_start_addr());
|
|
CP_LOGD("logo ext dsp_adc start addr:0x%x\r\b",logo_get_ext_dsp_adc_exec_addr());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
/*********************************** static function definition ****************************************/
|
|
/**
|
|
* @Description:
|
|
* init_logo_flash_info
|
|
* note: Firstly, give more priority to the existence of logo partition.
|
|
* Then, consider to the existence of the logo.bin at the end of cp.bin.
|
|
* @Parameter: pFlashStartAddr <OUT>: save logo.bin flash start address.
|
|
* @Parameter: pFlashSize <OUT>: logo.bin in flash size
|
|
* @Return Value:
|
|
* TRUE: If logo.bin exist in flash and valid, return TRUE.
|
|
* FALSE: If logo.bin not exist in flash or invalid, return FALSE.
|
|
*/
|
|
static BOOL init_logo_flash_info(UINT32 *pFlashStartAddr, UINT32 *pFlashSize)
|
|
{
|
|
_ptentry *logo_entry = ptable_find_entry("logo");
|
|
UINT32 StartAddr;
|
|
UINT32 FlashSize;
|
|
|
|
//[1] check logo.bin exist in ptable or not ?
|
|
if(logo_entry != NULL){
|
|
StartAddr = logo_entry->vstart;
|
|
if(IsLogoValidMagicRight(StartAddr)){
|
|
CP_LOGD("load logo in ptable\r\n");
|
|
*pFlashStartAddr = StartAddr;
|
|
*pFlashSize = logo_entry->size;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
//[2] check logo.bin exist in cp.bin or not ?
|
|
FlashSize = get_logo_length_in_cp();
|
|
if(INVALID_ADDRESS != FlashSize){
|
|
StartAddr = get_cp_load_addr() + get_cp_binary_size();
|
|
if(IsLogoValidMagicRight(StartAddr)){
|
|
CP_LOGD("load logo in cp.bin\r\n");
|
|
*pFlashStartAddr = StartAddr;
|
|
*pFlashSize = FlashSize;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
CP_LOGE("func:%s,logo.bin not exist in flash or invalid!\r\n",__func__);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
static UINT32 get_logo_function_magic_value( void )
|
|
{
|
|
return pLogoHeaderInfo->symbol_info_union.logo_symbol_info.logo_function_magic.value;
|
|
}
|
|
|
|
static void init_logo_function_magic_type(LogoFunctionMagicType_Enum *p_logo_function_magic_type)
|
|
{
|
|
UINT32 function_magic_value;
|
|
|
|
function_magic_value = get_logo_function_magic_value();
|
|
CP_LOGD("func:%s,function_magic_value:0x%x\r\n",__func__,function_magic_value);
|
|
if( function_magic_value == LOGO_FUNCTION_MAGIC_2 ){
|
|
*p_logo_function_magic_type = logo_magic2_support_query_info_and_append_dsp_adc;
|
|
}else{
|
|
*p_logo_function_magic_type = logo_no_function_magic;
|
|
}
|
|
}
|
|
|
|
|
|
static BOOL IsLogoValidMagicRight(const UINT32 LogoFlashAddr)
|
|
{
|
|
UINT32 LogoValidMagic;
|
|
|
|
#ifdef MCU_DS
|
|
asr_norflash_read(LogoFlashAddr,(UINT8 *)&LogoValidMagic,sizeof(LogoValidMagic));
|
|
#else
|
|
crane_qspi_read(LogoFlashAddr - QSPI_FLASH_BASE, (UINT8 *)&LogoValidMagic, sizeof(LogoValidMagic));
|
|
#endif
|
|
|
|
return LogoValidMagic == LOGO_VALID_MAGIC;
|
|
}
|
|
|
|
|