chenjintao/banban
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3a0714c735f5eec3eaab19ec04f12ef26e8145c1
banban/ql-bootloader/common/src/loadtable.c
T

1082 lines
35 KiB
C
Raw Blame History

#include <stdio.h>
#include <string.h>
#include "loadtable.h"
#include "ptable.h"
#include "common.h"
#if 0
#include "version_block.h"
#endif
#include "qspi_flash.h"
/*
*****************************************************************************************
* Macro Used if CP is Erased
*****************************************************************************************
*/
//#ifdef CP_ERASE //OTA_SD will Erase cp.bin
//CP Partition Parametr
#define DEFAULT_CP_HEADER (0xE320F000)
//Updater Partition Parameter
#define DEFAULT_UPDATER_START_ADDRESS (0x80FC0000)
#define DEFAULT_UPDATER_END_ADDRESS (0x80FE0000)
#define DEFAULT_UPDATER_SIZE (0x00020000)
//Fota Partition Parameter
#define DEFAULT_FOTA_PARAM_START_ADDRESS (0x80FBF000)
#define DEFAULT_FOTA_PARAM_END_ADDRESS (0x80FC0000)
extern volatile unsigned long CpFlashAddress;
//#endif
//CRC-16 table
static UINT16 crc16_table[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};
static UINT32 Crc_Check_16(UINT8* data, UINT32 length,UINT16 crc_reg)
{
UINT32 count = 0;
while (length--){
crc_reg = (crc_reg >> 8) ^ crc16_table[(crc_reg ^ *data++) & 0xff];
count++;
if(count == 0x10000)
{
count = 0;
crc_reg = ~crc_reg;
}
}
return (UINT32)(~crc_reg) & 0x0000FFFF;
}
/*
_ptentry *apnEntry, *rdEntry, *nvmEntry;
_ptentry *factory_a_Entry, *factory_b_Entry;
*/
_ptentry *fota_param_Entry ,*fota_pkg_Entry ,*updater_Entry, *updater_backup_Entry;
_ptentry *logo_entry,*dsp_adc_Entry,*dsp_adc_backup_Entry;
unsigned char updater_available = 0;
unsigned char updater_backup_available = 0;
unsigned char dsp_adc_available = 0;
unsigned char dsp_adc_backup_available = 0;
#define CRANE_QSPI_BASE_ADD 0x80000000
#define FOTAPARAM_BLOCK_SIZE (4*1024)
extern struct spi_flash_chip *chip;
void check_updater()
{
UINT16 check_crc, calc_crc = 0xFFFF;
if(updater_Entry)
{
uart_printf("updater address : 0x%x, size : 0x%x\r\n",
updater_Entry->vstart,
updater_Entry->size);
calc_crc = Crc_Check_16(updater_Entry->vstart, updater_Entry->size - 4, calc_crc);
check_crc = *(UINT16 *)(updater_Entry->vstart + updater_Entry->size - 4);
uart_printf("updater CRC: 0x%x(check), 0x%x(calc)\r\n", check_crc, calc_crc);
if(check_crc == calc_crc)
updater_available = 1;
}
check_crc = 0xFFFF;
calc_crc = 0xFFFF;
if(updater_backup_Entry)
{
uart_printf("updater backup address : 0x%x, size : 0x%x\r\n",
updater_backup_Entry->vstart,
updater_backup_Entry->size);
calc_crc = Crc_Check_16(updater_backup_Entry->vstart, updater_backup_Entry->size - 4, calc_crc);
check_crc = *(UINT16 *)(updater_backup_Entry->vstart + updater_backup_Entry->size - 4);
uart_printf("updater backup CRC: 0x%x(check), 0x%x(calc)\r\n", check_crc, calc_crc);
if(check_crc == calc_crc)
updater_backup_available = 1;
}
}
int check_updater_ram(unsigned addr,unsigned size)
{
UINT16 check_crc, calc_crc = 0xFFFF;
uart_printf("updater address : 0x%x, size : 0x%x\r\n",
addr,
size);
calc_crc = Crc_Check_16(addr, size - 4, calc_crc);
check_crc = *(UINT16 *)(addr + size - 4);
uart_printf("updater CRC: 0x%x(check), 0x%x(calc)\r\n", check_crc, calc_crc);
if(check_crc != calc_crc)
return 1;
return 0;
}
#ifdef FOTA_ASRDM
void check_and_copy_dsp_adc(void)
{
UINT16 dsp_adc_calc_crc = 0xFFFF;
UINT16 dsp_adc_backup_calc_crc = 0xFFFF;
UINT16 dsp_adc_check_crc, dsp_adc_backup_check_crc;
uart_printf("dsp_adc backup start address : 0x%08x\r\n", get_dsp_adc_backup_start_addr());
uart_printf("dsp_adc backup end address : 0x%08x\r\n", get_dsp_adc_backup_end_addr());
uart_printf("dsp_adc start address : 0x%08x\r\n", get_dsp_adc_start_addr());
uart_printf("dsp_adc end address : 0x%08x\r\n", get_dsp_adc_end_addr());
if(get_dsp_adc_backup_start_addr() != 0xFFFFFFFF)
{
dsp_adc_calc_crc = Crc_Check_16(
(UINT8 *)get_dsp_adc_start_addr(),
get_dsp_adc_end_addr() - get_dsp_adc_start_addr() - 4,
dsp_adc_calc_crc
);
dsp_adc_check_crc = *(UINT32 *)(get_dsp_adc_end_addr() - 4);
uart_printf("dsp_adc CRC(check):0x%08x, CRC(calc):0x%08x\r\n", dsp_adc_check_crc, dsp_adc_calc_crc);
if(dsp_adc_check_crc == dsp_adc_calc_crc)
dsp_adc_available = 1;
dsp_adc_backup_calc_crc = Crc_Check_16(
(UINT8 *)get_dsp_adc_backup_start_addr(),
get_dsp_adc_backup_end_addr() - get_dsp_adc_backup_start_addr() - 4,
dsp_adc_backup_calc_crc
);
dsp_adc_backup_check_crc = *(UINT32 *)(get_dsp_adc_backup_end_addr() - 4);
if(dsp_adc_backup_check_crc == dsp_adc_backup_calc_crc)
dsp_adc_backup_available = 1;
uart_printf("dsp_adc backup CRC(check):0x%08x, CRC(calc):0x%08x\r\n",
dsp_adc_backup_check_crc,
dsp_adc_backup_calc_crc);
#if 1
if(((dsp_adc_calc_crc != dsp_adc_check_crc) ||
(dsp_adc_calc_crc != dsp_adc_backup_calc_crc)) &&
dsp_adc_backup_available)
{
UINT32 index, sector_max_num;
UINT32 size = get_dsp_adc_copy_size();
UINT32 dsp_adc_start_addr, dsp_adc_backup_start_addr;
dsp_adc_start_addr = get_dsp_adc_start_addr() - CRANE_QSPI_BASE_ADD;
dsp_adc_backup_start_addr = get_dsp_adc_backup_start_addr();
sector_max_num = (size/FOTAPARAM_BLOCK_SIZE) + ((size % FOTAPARAM_BLOCK_SIZE) ? 1 : 0);
if(chip == NULL)
{
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return;
}
uart_printf("Copy dsp_adc");
for(index = 0; index < sector_max_num; index++)
{
uart_printf(".");
chip->ops->erase(chip, dsp_adc_start_addr,FOTAPARAM_BLOCK_SIZE);
chip->ops->write(chip, dsp_adc_start_addr,FOTAPARAM_BLOCK_SIZE,dsp_adc_backup_start_addr);
dsp_adc_backup_start_addr += FOTAPARAM_BLOCK_SIZE;
dsp_adc_start_addr += FOTAPARAM_BLOCK_SIZE;
}
dsp_adc_calc_crc = 0xFFFF;
dsp_adc_calc_crc = Crc_Check_16(
(UINT8 *)get_dsp_adc_start_addr(),
get_dsp_adc_end_addr() - get_dsp_adc_start_addr() - 4,
dsp_adc_calc_crc
);
dsp_adc_check_crc = *(UINT32 *)(get_dsp_adc_end_addr() - 4);
uart_printf("***dsp_adc CRC(check):0x%08x, CRC(calc):0x%08x\r\n", dsp_adc_check_crc, dsp_adc_calc_crc);
}
#endif
}
}
#endif
LoadTableType *pLoadTable = (LoadTableType*)INVALID_ADDRESS;
void loadtable_init(unsigned int cp_flash_addr)
{
pLoadTable = (LoadTableType*)(cp_flash_addr + BINARY_LOAD_TABLE_OFFSET);
#if (defined(BOOT33_FOTA_SUPPORT) || defined(FOTA_ASRDM))
//fota_param
fota_param_Entry = ptable_find_entry("fota_param");
//fota_pkg
fota_pkg_Entry = ptable_find_entry("fota_pkg");
//update updater
updater_Entry = ptable_find_entry("updater");
#endif
#ifndef SUPPORT_NO_LOGO
logo_entry = ptable_find_entry("logo");
#endif
#ifdef FOTA_ASRDM
dsp_adc_Entry = ptable_find_entry("dsp_adc");
dsp_adc_backup_Entry = ptable_find_entry("dsp_adc_b");
if(dsp_adc_backup_Entry)
{
check_and_copy_dsp_adc();
}
#endif
//#endif
}
#if 1 // quectel add
unsigned int get_nvm_start_address(void)
{
#if 1
_ptentry * nvm_start_Entry= ptable_find_entry("nvm");
return nvm_start_Entry->vstart;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.nvm_start_address.value;
#endif
}
unsigned int get_nvm_end_address(void)
{
#if 1
_ptentry * nvm_end_Entry= ptable_find_entry("nvm");
return nvm_end_Entry->vstart+nvm_end_Entry->size;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.nvm_end_address.value;
#endif
}
unsigned int get_customer_fs_start_address(void)
{
_ptentry * customer_fs_start_Entry= ptable_find_entry("customer_fs");
if(customer_fs_start_Entry==NULL)
return 0;
return customer_fs_start_Entry->vstart;
}
unsigned int get_customer_fs_end_address(void)
{
_ptentry * customer_fs_end_Entry= ptable_find_entry("customer_fs");
if(customer_fs_end_Entry==NULL)
return 0;
return customer_fs_end_Entry->vstart+customer_fs_end_Entry->size;
}
unsigned int get_reserved_end_address(void)
{
_ptentry * nvm_end_Entry= ptable_find_entry("reserved");
return nvm_end_Entry->vstart+nvm_end_Entry->size;
}
unsigned int get_erase_rd_start_address(void)
{
#if 1
_ptentry * nvm_start_Entry= ptable_find_entry("erase_rd");
return nvm_start_Entry->vstart;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.nvm_start_address.value;
#endif
}
#endif
//unused for boot33
unsigned int get_cp_load_addr(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.cp_load_addr.value;
}
//for PSRAM execute mode only
unsigned int get_cp_exec_addr(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.cp_exec_addr.value;
}
//recorder inside loadtable, to detect DSP.bin start address
unsigned int get_cp_binary_size(void){
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.binary_size.value;
}
//for PSRAM execute mode only
unsigned int get_cp_copy_size(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.image_end.value - pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.cp_exec_addr.value + 0x04 ;
}
unsigned int get_dsp_load_addr(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.dsp_begin_addr.value;
}
unsigned int get_dsp_copy_size(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.dsp_end_addr.value - pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.dsp_begin_addr.value + 0x04;
}
unsigned int get_ddr_heap_size(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_heap_guard_end_addr.value - pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_heap_guard_begin_addr.value + 0x04;
}
unsigned int get_dsp_backup_addr(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_heap_guard_begin_addr.value;
}
unsigned int get_dsp_backup_end_addr(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_heap_guard_end_addr.value;
}
unsigned int get_dsp_backup_size(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.dsp_bk_size.value;
}
//used for AliOS_OTA
unsigned int get_logo_start_addr(void)
{
#ifdef AVOID_PTABLE//not ptable solution
#else//AVOID_PTABLE the ptable solution
if(logo_entry != NULL){
return logo_entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return 0;
}
#endif //AVOID_PTABLE
}
unsigned int get_logo_end_addr(void)
{
#ifdef AVOID_PTABLE
//TODO:
#else
if(logo_entry != NULL){
return logo_entry->vstart + logo_entry->size;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return 0;
}
#endif //AVOID_PTABLE
}
unsigned int get_fota_param_start_addr(void)
{
#ifdef AVOID_PTABLE//not ptable solution
#ifdef CP_ERASE //OTA_SD will Erase cp.bin
if(*(volatile unsigned long *)(CpFlashAddress) == DEFAULT_CP_HEADER){
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.fota_param_start_address.value;
}else{
uart_printf("Note:Return Default fota_param_start_addr from Loadtable\r\n");
return DEFAULT_FOTA_PARAM_START_ADDRESS;
}
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.fota_param_start_address.value;
#endif
#else//AVOID_PTABLE the ptable solution
if(fota_param_Entry != NULL){
return fota_param_Entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return DEFAULT_FOTA_PARAM_START_ADDRESS;
}
#endif
}
unsigned int get_fota_param_end_addr(void)
{
#ifdef AVOID_PTABLE
#ifdef CP_ERASE //OTA_SD will Erase cp.bin
if(*(volatile unsigned long *)(CpFlashAddress) == DEFAULT_CP_HEADER){
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.fota_param_end_address.value;
}else{
uart_printf("Note:Return Default fota_param_end_addr from Loadtable\r\n");
return DEFAULT_FOTA_PARAM_END_ADDRESS;
}
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.fota_param_end_address.value;
#endif
#else//AVOID_PTABLE
if(fota_param_Entry != NULL){
return fota_param_Entry->vstart + fota_param_Entry->size;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return DEFAULT_FOTA_PARAM_END_ADDRESS;
}
#endif
}
unsigned int get_updater_start_addr(void)
{
#ifdef AVOID_PTABLE
#ifdef CP_ERASE //OTA_SD will Erase cp.bin
if(*(volatile unsigned long *)(CpFlashAddress) == DEFAULT_CP_HEADER){
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.updater_start_address.value;
}else{
uart_printf("Note:Return Default updater_start_addr from Loadtable\r\n");
return DEFAULT_UPDATER_START_ADDRESS;
}
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.updater_start_address.value;
#endif
#else//AVOID_PTABLE
if(updater_backup_Entry == NULL)
{
if(updater_Entry != NULL){
return updater_Entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return DEFAULT_UPDATER_START_ADDRESS;
}
}else{
if(updater_available)
return updater_Entry->vstart;
else if(updater_backup_available)
return updater_backup_Entry->vstart;
else {
uart_printf("[fatal_err][%s][%d] should never be here\r\n",__func__,__LINE__);
return -1;
}
}
#endif
}
unsigned int get_updater_end_addr(void)
{
#ifdef AVOID_PTABLE
#ifdef CP_ERASE //OTA_SD will Erase cp.bin
if(*(volatile unsigned long *)(CpFlashAddress) == DEFAULT_CP_HEADER){
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.updater_end_address.value;
}else{
uart_printf("Note:Return Default updater_end_addr from Loadtable\r\n");
return DEFAULT_UPDATER_END_ADDRESS;
}
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.updater_end_address.value;
#endif
#else//AVOID_PTABLE
if(updater_backup_Entry == NULL)
{
if(updater_Entry != NULL){
return updater_Entry->vstart + updater_Entry->size;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return DEFAULT_UPDATER_END_ADDRESS;
}
}else{
if(updater_available)
return updater_Entry->vstart + updater_Entry->size;
else if(updater_backup_available)
return updater_backup_Entry->vstart + updater_backup_Entry->size;
else {
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
}
#endif
}
unsigned int get_updater_copy_size(void)
{
return get_updater_end_addr() - get_updater_start_addr();
}
unsigned int is_have_dsp_adc(void)
{
#ifdef SMALL_CODE_LOGO
if( TRUE == IsLogoAppendDspAdc() )
return 1;
else
#elif SMALL_CODE_UPDATER
if( TRUE == IsUpdaterAppendDspAdc() )
return 1;
else
#endif
if(dsp_adc_Entry != NULL)
return 1;
else
return 0;
}
unsigned int get_dsp_adc_start_addr(void)
{
#ifdef AVOID_PTABLE
#else
if(dsp_adc_Entry != NULL){
return dsp_adc_Entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
unsigned int get_dsp_adc_end_addr(void)
{
#ifdef AVOID_PTABLE
#else
if(dsp_adc_Entry != NULL){
return dsp_adc_Entry->vstart + dsp_adc_Entry->size;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
unsigned int get_dsp_adc_copy_size(void)
{
return get_dsp_adc_end_addr() - get_dsp_adc_start_addr();
}
unsigned int get_dsp_adc_backup_start_addr(void)
{
#ifdef AVOID_PTABLE
#else
if(dsp_adc_backup_Entry != NULL){
return dsp_adc_backup_Entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
unsigned int get_dsp_adc_backup_end_addr(void)
{
#ifdef AVOID_PTABLE
#else
if(dsp_adc_backup_Entry != NULL){
return dsp_adc_backup_Entry->vstart + dsp_adc_backup_Entry->size;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
#ifdef FOTA_ASRDM
void after_updater_success(void){
if( PMIC_IS_PM803() ){
if(dsp_adc_backup_Entry)
{
check_and_copy_dsp_adc();
}
}
}
#endif
unsigned int get_fota_pkg_start_addr(void)
{
#ifdef AVOID_PTABLE
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.fota_pkg_start_address.value;
#else
if(fota_pkg_Entry != NULL){
return fota_pkg_Entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
unsigned int get_fota_pkg_end_addr(void)
{
#ifdef AVOID_PTABLE
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.fota_pkg_end_address.value;
#else
if(fota_pkg_Entry != NULL){
return fota_pkg_Entry->vstart + fota_pkg_Entry->size;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
unsigned int get_ddr_ro_exec_addr(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_ro_exec_address.value;
}
unsigned int get_ddr_ro_exec_length(void)
{
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_ro_exec_size_address.value;
}
unsigned int getLongChipId(void){
return ((*(volatile unsigned int *)0xD4282C00)&0xffffffff);
}
unsigned int get_ps_mode(void)
{
if(strstr(pLoadTable->lt_area_ver_info.version_info.ps_mode,"NBIOT")){
return NBIOT;
}else if (strstr(pLoadTable->lt_area_ver_info.version_info.ps_mode,"CATM")){
return CATM;
}else if (strstr(pLoadTable->lt_area_ver_info.version_info.ps_mode,"LTEONLY")){
return LTEONLY;
}else if (strstr(pLoadTable->lt_area_ver_info.version_info.ps_mode,"LTEGSM")){
return LTEGSM;
}
}
unsigned int get_rf_load_size(void)
{
unsigned int psmode = get_ps_mode();
unsigned int rf_load_size;
// tmp wrokaround :load the front 20K rf.bin for all mode
rf_load_size = 0x5000;//20k
#ifdef BOOT33_CP_DSP_RF
switch(psmode)
{
case NBIOT:
uart_printf("[RF ] PS_MODE=[%s] rf_load_size = [0x%08x]\r\n","NBIOT",rf_load_size);
break;
case LTEGSM:
uart_printf("[RF ] PS_MODE=[%s] rf_load_size = [0x%08x]\r\n","LTEGSM",rf_load_size);
break;
case LTEONLY:
uart_printf("[RF ] PS_MODE=[%s] rf_load_size = [0x%08x]\r\n","LTEONLY",rf_load_size);
break;
case CATM:
uart_printf("[RF ] PS_MODE=[%s] rf_load_size = [0x%08x]\r\n","CATM",rf_load_size);
break;
default:
break;
}
#endif
return rf_load_size;
}
unsigned int get_rf_load_addr(void)
{
unsigned int rf_load_addr;
//#ifdef LTEONLY_SINGLE_SIM
//rf_load_addr = pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.ddr_heap_guard_end_addr.value;
//#else
unsigned int chipID = getLongChipId();
switch(chipID)
{
case CRANE_Z2:
CP_LOGD("[CP ] CHIP_ID=[%08x] CRANE_Z2 \r\n",chipID);
rf_load_addr = pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.rf_z2_load_addr.value;
break;
case CRANE_A0:
CP_LOGD("[CP ] CHIP_ID=[%08x] CRANE_A0 \r\n",chipID);
rf_load_addr = pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.rf_a0_load_addr.value;
break;
case CRANE_A1:
CP_LOGD("[CP ] CHIP_ID=[%08x] CRANE_A1 \r\n",chipID);
rf_load_addr = pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.rf_a0_load_addr.value;
break;
default:
CP_LOGD("[CP ] CHIP_ID=[%08x] USING DEFAULT VALUE\r\n",chipID);
rf_load_addr = pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.rf_a0_load_addr.value;
break;
}
//#endif
return rf_load_addr;
}
unsigned int get_rw_cpz_struct_addr(void)
{
return (unsigned int)pLoadTable->lt_area_rw_cpz_info.compress_rw_region_list;
}
#if 0
//apn
void set_apn_begin_addr(unsigned int begin_addr){
uart_printf("[APN] apn_begin_addr = [%.08x]\r\n",begin_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.apn_begin_addr.value),begin_addr);
}
void set_apn_end_addr(unsigned int end_addr){
uart_printf("[APN] apn_end_addr = [%.08x]\r\n",end_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.apn_end_addr.value),end_addr);
}
//rd
void set_rd_begin_addr(unsigned int begin_addr){
uart_printf("[RD ] rd_begin_addr = [%.08x]\r\n",begin_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.rd_begin_addr.value),begin_addr);
}
void set_rd_end_addr(unsigned int end_addr){
uart_printf("[RD ] rd_end_addr = [%.08x]\r\n",end_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.rd_end_addr.value),end_addr);
}
//nvm
void set_nvm_end_addr(unsigned int end_addr){
uart_printf("[NVM] nvm_end_addr = [%.08x]\r\n",end_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.nvm_end_addr.value),end_addr);
}
void update_nvm_end_addr(unsigned int available_end_addr){
uart_printf("[NVM] available_end_addr = [%.08x]\r\n",available_end_addr);
available_end_addr |= FLASH_BLOCK_MASK;
available_end_addr -= FLASH_BLOCK_MASK;
set_nvm_end_addr(available_end_addr);
}
void set_nvm_begin_addr(unsigned int begin_addr){
uart_printf("[NVM] nvm_begin_addr = [%.08x]\r\n",begin_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.nvm_begin_addr.value),begin_addr);
}
void update_nvm_begin_addr(unsigned int available_base_addr){
uart_printf("[NVM] available_base_addr = [%.08x]\r\n",available_base_addr);
available_base_addr += FLASH_BLOCK_MASK;
available_base_addr &= ~(FLASH_BLOCK_MASK);
set_nvm_begin_addr(available_base_addr);
}
//factory
void set_factory_a_begin_addr(unsigned int begin_addr){
uart_printf("[F_A] factory_a_begin_addr= [%.08x]\r\n",begin_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_a_begin_addr.value),begin_addr);
}
void set_factory_a_end_addr(unsigned int end_addr){
uart_printf("[F_A] factory_a_end_addr = [%.08x]\r\n",end_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_a_end_addr.value),end_addr);
}
void set_factory_b_begin_addr(unsigned int begin_addr){
uart_printf("[F_B] factory_b_begin_addr= [%.08x]\r\n",begin_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_b_begin_addr.value),begin_addr);
}
void set_factory_b_end_addr(unsigned int end_addr){
uart_printf("[F_B] factory_b_end_addr = [%.08x]\r\n",end_addr);
crane_qspi_write_uint(&(pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_b_end_addr.value),end_addr);
}
int vergin_status_fetch(void)
{
unsigned int is_vergin = pLoadTable->lt_area_func_val.func_val.vergin.value;
if(is_vergin){
crane_qspi_write_uint(&(pLoadTable->lt_area_func_val.func_val.vergin.value),(unsigned int)0);
return 1;
}else{
return 0;
}
}
void number_of_life_update(void)
{
unsigned int bootcount = pLoadTable->lt_area_func_val.func_val.number_of_life.value;
crane_qspi_write_uint(&(pLoadTable->lt_area_func_val.func_val.number_of_life.value),(bootcount+1));
}
#endif
CP_EXECUTE_MODE get_cp_execute_mode(void)
{
return strncmp(pLoadTable->lt_area_ver_info.version_info.execute_mode,"XIP",3)?PSRAM:XIP;
}
int anti_rollback_check(void)
{
#if 0
extern Boot33VerBlockType boot33_vb;
unsigned int cp_anti_rb_ver_dec = atoi((const char*)&pLoadTable->lt_area_ver_info.version_info.anti_rollback_version);
unsigned int boot33_ver_dec = atoi((const char*)&boot33_vb.vb.version_block.version_date);
uart_printf("BOOT33_VERSION : %s[%d]\r\n",
boot33_vb.vb.version_block.version_date,
boot33_ver_dec);
uart_printf("CP_ANTI_RB_VER : %s[%d]\r\n",
pLoadTable->lt_area_ver_info.version_info.anti_rollback_version,
cp_anti_rb_ver_dec);
if(boot33_ver_dec < cp_anti_rb_ver_dec ){
uart_printf("\r\n ** ERROR: BOOT33 UPDATE EXPECTED, AT LEAST TO [%s] \r\n",pLoadTable->lt_area_ver_info.version_info.anti_rollback_version);
return -1;
}
#endif
return 0;
}
void dump_loadtable(void)
{
#if LOGO_LOGNDEBUG
rw_region_item region_info;
armlink_symbol_item * tmp_p ;
unsigned schedule_count = 0;
unsigned count = 0;
char * rw_cpz_struct_addr=(char*)get_rw_cpz_struct_addr();
//++++++++++++++++++++++++++++++++++++++++++++++++++
//AREA_1: LOADTABLE_HEADER
uart_printf("[%57s]\r\n","---------------------------------------------------------");
uart_printf("[%-15s][%-40s]\r\n","LOADTABLE AREA","LOADTABLE_AREA_HEADER");
uart_printf("[%-15s][%-40x]\r\n","INIT_ROUTINE" ,pLoadTable->lt_area_header.init_routine.init);
//++++++++++++++++++++++++++++++++++++++++++++++++++
//AREA_2: VERSION & SIGNATURE
uart_printf("[%57s]\r\n","---------------------------------------------------------");
uart_printf("[%-15s][%-40s]\r\n","LOADTABLE AREA","LOADTABLE_AREA_VER_INFO");
uart_printf("[%-15s][%-40s]\r\n","ANTI_RB_VER" ,pLoadTable->lt_area_ver_info.version_info.anti_rollback_version);
uart_printf("[%-15s][%-40s]\r\n","EXECUTE_MODE" ,pLoadTable->lt_area_ver_info.version_info.execute_mode);
uart_printf("[%-15s][%-40s]\r\n","PS_MODE" ,pLoadTable->lt_area_ver_info.version_info.ps_mode);
uart_printf("[%-15s][%-40s]\r\n","IMAGE_DESC" ,pLoadTable->lt_area_ver_info.version_info.image_info);
//++++++++++++++++++++++++++++++++++++++++++++++++++
//AREA_3: RW COMPRESS REGION SYMBOL
uart_printf("[%57s]\r\n","---------------------------------------------------------");
uart_printf("[%-15s][%-40s]\r\n","LOADTABLE AREA","LOADTABLE_AREA_RW_CPZ_INFO");
while(1){
//read NEXT region cpz info struct
memcpy(&region_info
,(void*)(rw_cpz_struct_addr + (sizeof(rw_region_item)*schedule_count++))
,sizeof(rw_region_item));
if(strncmp(region_info.RW_REGION_MARK, RW_REGION_MARK_PRE_STRING ,strlen(RW_REGION_MARK_PRE_STRING)-1))
{
break;
}else if(region_info.RW_REGION_COMPRESSED_ADDR == RW_REGION_COMPRESSED_ADDR_NONE ){
uart_printf("[%-57s]\r\n","NO RW_REGION_COMPRESSED_ADDR DETECT,SKIP");
break;
}
//dump region info
uart_printf("[%.7s%c][%7s][%.08x][%.08x][%.08x][%.08x]\r\n",
region_info.RW_REGION_MARK,
region_info.RW_REGION_MARK_NUM,
region_info.RW_REGION_NAME,
region_info.RW_REGION_EXEC_ADDR,
region_info.RW_REGION_LOAD_ADDR,
region_info.RW_REGION_LENGTH,
region_info.RW_REGION_COMPRESSED_ADDR
);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
//AREA_4: ARMLINKE SYMBOL LIST
uart_printf("[%57s]\r\n","---------------------------------------------------------");
uart_printf("[%-15s][%-40s]\r\n","LOADTABLE AREA","LOADTABLE_AREA_ARMLINK_SYMBOL");
schedule_count = sizeof(loadtable_armlink_symbol_info)/sizeof(armlink_symbol_item);
tmp_p = (armlink_symbol_item *)&(pLoadTable->lt_area_armlink_symbol);
do{
uart_printf("[%02d.%-12s][0x%.08x][%-28s]\r\n",count++,tmp_p->name, tmp_p->value
,(tmp_p->value==INVALID_ADDRESS?"INVALID":"AVAILABLE"));
tmp_p ++;
}while(schedule_count > count && tmp_p->value!=EMPTY_ADDRESS);
//++++++++++++++++++++++++++++++++++++++++++++++++++
//AREA_5: FUNCTIONAL VAL
uart_printf("[%57s]\r\n","---------------------------------------------------------");
uart_printf("[%-15s][%-40s]\r\n","LOADTABLE AREA","LOADTABLE_AREA_FUNC_VAL");
schedule_count = sizeof(loadtable_functional_info)/sizeof(functional_item);
count = 0;
tmp_p = (armlink_symbol_item * )&(pLoadTable->lt_area_func_val);
do{
uart_printf("[%02d.%-12s][%-40x]\r\n",count++,tmp_p->name, tmp_p->value);
tmp_p ++;
}while(schedule_count > count);
//++++++++++++++++++++++++++++++++++++++++++++++++++
uart_printf("[%57s]\r\n","---------------------------------------------------------");
#endif
}
unsigned int get_factory_a_start_address(void)
{
#if 1
_ptentry * factory_a_begin_Entry= ptable_find_entry("factory_a");
return factory_a_begin_Entry->vstart;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_a_start_address.value;
#endif
}
unsigned int get_factory_a_end_address(void)
{
#if 1
_ptentry * factory_a_end_Entry= ptable_find_entry("factory_a");
return factory_a_end_Entry->vstart+factory_a_end_Entry->size;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_a_end_address.value;
#endif
}
unsigned int get_factory_b_start_address(void)
{
#if 1
_ptentry * factory_b_begin_Entry= ptable_find_entry("factory_b");
return factory_b_begin_Entry->vstart;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_b_start_address.value;
#endif
}
unsigned int get_factory_b_end_address(void)
{
#if 1
_ptentry * factory_b_begin_Entry= ptable_find_entry("factory_b");
return factory_b_begin_Entry->vstart + factory_b_begin_Entry->size;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_b_start_address.value;
#endif
}
BOOL IsUpdaterbakExist(void)
{
_ptentry *updater_bak_Entry;
updater_bak_Entry = ptable_find_entry("updater_bak");
if(updater_bak_Entry != NULL){
return TRUE;
}else{
return FALSE;
}
}
unsigned int get_updater_backup_start_addr(void)
{
#ifdef AVOID_PTABLE
#else
if(updater_backup_Entry != NULL){
return updater_backup_Entry->vstart;
}else{
//TODO: once ptable block was ruined by fota erase and power shut, could not recovery
uart_printf("[fatal_err][%s][%d]\r\n",__func__,__LINE__);
return -1;
}
#endif
}
UINT32 get_logo_length_in_cp(void)
{
//return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.logo_img_length.value;
return INVALID_ADDRESS;
}
#ifdef SUPPORT_FLASH_IMAGE_PROTECT
unsigned int get_bootloader_end_address(void)
{
#if 1
_ptentry * bootloader_end_Entry= ptable_find_entry("bootloader");
return bootloader_end_Entry->vstart + bootloader_end_Entry->vsize;
#else
return pLoadTable->lt_area_armlink_symbol.armlink_symbol_info.factory_b_start_address.value;
#endif
}
extern BOOL IsChipCraneL(void);
extern BOOL IsChipCraneLS(void);
extern BOOL IsChipCraneLR(void);
extern BOOL IsChipCraneLG(void);
extern BOOL IsChipCraneLRH(void);
//flash write and erase using this interface to check invalid address--leo
BOOL IsImageProtectArea_Boot(UINT32 addr, UINT32 size,IMG_PROTECT_OPT opt)
{
UINT32 operate_addr_start = addr;
UINT32 operate_addr_end = addr + size;
UINT32 bootloader_end_addr = get_bootloader_end_address() - 0x80000000;
UINT32 factory_start_addr = get_factory_a_start_address() - 0x80000000;
UINT32 factory_end_addr;
UINT32 align_size;
if(IsChipCraneL()||IsChipCraneLS()||IsChipCraneLR()||IsChipCraneLG()||IsChipCraneLRH())
factory_end_addr = get_factory_a_end_address() - 0x80000000;
else
factory_end_addr = get_factory_b_end_address() - 0x80000000;
//bootloader and factory partition are forbidden to be erased or write in bootloader
if( (operate_addr_end <= bootloader_end_addr) || ((operate_addr_start < bootloader_end_addr) && (operate_addr_end > bootloader_end_addr)) //bootloader partition in front of reserved
|| (operate_addr_end > factory_start_addr) //factory partition
|| ((opt==IMG_PROTECT_OPT_ERASE)&&(operate_addr_start % size != 0))) //addr align
{
uart_printf("bootloader end addr:0x%x\r\n",bootloader_end_addr);
uart_printf("factory start addr:0x%x\r\n",factory_start_addr);
uart_printf("!!!!erase or write protect partition,addr:0x%x,size:0x%x,do pimc reset!!!\r\n",addr,size);
return TRUE;
}
return FALSE;
}
#endif
Reference in New Issue View Git Blame Copy Permalink