chenjintao/banban
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
5f5604e45bf31d8f590b55b75bc512bb43728972
banban/ql-bootloader/boot33/src/ota.c
T

835 lines
25 KiB
C
Raw Blame History

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cpu.h"
#include "qspi.h"
#include "reg.h"
#include "system.h"
//#include "uart.h"
#include "ptable.h"
#include "loadtable.h"
#include "sdio.h"
#include "pmic.h"
#include "ff.h"
#include "version_block.h"
#include "bspatch.h"
#include "fip.h"
#include "LzmaDec.h"
#include "FreqChange.h"
#include "fbf_parse.h"
#include "ota.h"
#include "tinyalloc.h"
#include "asr_property.h"
#include "secboot.h"
#include "updater_table.h"
#ifdef BOOT33_FOTA_SUPPORT
#define QUEC_SUPPORT_FULL_FOTA_NAND 1
extern void TransferControl(unsigned int);
extern int crane_qspi_read(unsigned int addr, unsigned int buf_addr, unsigned int size);
extern int crane_qspi_write(unsigned int addr, unsigned int buf_addr,unsigned int size);
extern int crane_qspi_erase(unsigned int addr, unsigned int size);
extern int malloc_init(unsigned int ta_base, unsigned int length);
extern unsigned int get_fota_param_end_addr(void);
extern unsigned int get_fota_param_start_addr(void);
extern unsigned int get_ddr_ro_exec_length(void);
extern unsigned int get_ddr_ro_exec_addr(void);
extern unsigned long mini_system_enable;
unsigned int get_ps_ncah_address(void)
{
char region_compress_mark[8];
unsigned schedule_count = 0;
rw_region_item region_info;
char * rw_cpz_struct_addr=(char*)get_rw_cpz_struct_addr();
//load region compressed struct
memcpy(region_compress_mark,
rw_cpz_struct_addr,
sizeof(region_compress_mark));
if(!strncmp(region_compress_mark, RW_REGION_MARK_PRE_STRING ,strlen(RW_REGION_MARK_PRE_STRING)-1)){
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));
//dump region info
//uart_printf("[CP ] decompress [%8s] from [%.08x] to [%.08x]\r\n",
// region_info.RW_REGION_NAME,
// region_info.RW_REGION_COMPRESSED_ADDR,
// region_info.RW_REGION_EXEC_ADDR
// );
if(!strncmp(region_info.RW_REGION_NAME,"PS_NCAH",7)){
return region_info.RW_REGION_EXEC_ADDR;
}
}
}
else
{
uart_printf("[CP ] Region CPZ struct not detected from loadtable\r\n");
}
return 0;
}
static void fota_uudelay(int us)
{
volatile uint32_t i;
for(i=0; i<us*100;i++)
i = i+1;
}
static void fota_mdelay(int ms){
volatile uint32_t i;
for(i=0; i<ms;i++)
fota_uudelay(100);
}
static UINT32 CalcImageChecksum( UINT32* DownloadArea, UINT32 ImageLength,UINT32 checksum)
{
UINT32 ImageChecksum = checksum;
UINT32* ptr32 = DownloadArea;
UINT32* pEnd = ptr32 + (ImageLength / sizeof(UINT32));
UINT32 BytesSummed = 0;
while ( ptr32 < pEnd )
{
// checksum format version 2 algorithm as defined by flasher
ImageChecksum ^= (*ptr32);
ptr32++;
BytesSummed += sizeof(UINT32);
}
return ImageChecksum;
}
#if (!defined(BOOT33_FOTA_NO_UPDATER) || !defined(LTEONLY_SINGLE_SIM))
#if (!defined(CRANEM_SINGLE_SIM))
UINT32 OTA_Check_FotaImage(UINT32 buf, UINT32 size, UINT32 flash_Addr)
{
UINT32 old_checksum = 0,new_checksum = 0;
char *temp=NULL;
temp =(char *) tiny_malloc(size);
memset(temp,0,size);
memcpy(temp,flash_Addr+QSPI_FLASH_BASE,size);
old_checksum = CalcImageChecksum((UINT32*)buf,size,0);
new_checksum = CalcImageChecksum((UINT32*)temp,size,0);
if(old_checksum != new_checksum){
uart_printf("OTA_Check_FotaImage,failed!!![0x%08X]:[0x%08X]\n\r",old_checksum,new_checksum);
}else{
tiny_free(temp);
return NoError;
}
tiny_free(temp);
return DFota_WriteFlashCheckFailed;
}
static UINT32 OTA_Update_FotaParam(UINT32 buf, UINT32 size, UINT32 flash_Addr)
{
UINT32 Retval = 0;
int i=0;
//char temp[FLASH_4K_SIZE];
uart_printf("OTA_Update_FotaParam, flash_Addr[0x%08X],size[0x%08X]\n\r", flash_Addr,size);
//temp =(char *) malloc(FLASH_4K_SIZE);
//memcpy(temp,(char *)buf,size);
start:
Retval=crane_qspi_erase(flash_Addr, FLASH_4K_SIZE);
if (Retval != 0)
goto exit;
Retval = crane_qspi_write(flash_Addr, buf, FLASH_4K_SIZE);
if (Retval != 0)
goto exit;
exit:
Retval=OTA_Check_FotaImage(buf,size,flash_Addr);
if(NoError!=Retval ){
if(i>10){
uart_printf("OTA_Check_FotaImage filed,Wait...\n\r");
while(1){
fota_mdelay(10*1000);
}
}
uart_printf("OTA_Check_FotaImage filed,Wait (%d)sec ...\n\r",(i+1)*10);
fota_mdelay((i+1)*10*1000);
uart_printf("OTA_Check_FotaImage filed,Wait (%d)sec end\n\r",(i+1)*10);
i++;
goto start;
}
uart_printf("OTA_Update_FotaParam end\n\r");
return Retval;
}
static UINT32 OTA_Update_FotaImage(UINT32 buf, UINT32 size, UINT32 flash_Addr)
{
UINT32 Retval = 1;
char *temp=NULL;
UINT32 index=0;
UINT32 tempsize = size;
int i=0;
uart_printf("OTA_Update_FotaImage: flash_Addr[0x%08x], size: 0x%08x\n\r", flash_Addr, size);
start:
temp =(char *) tiny_malloc(FLASH_4K_SIZE);
while(size > FLASH_4K_SIZE){
memcpy(temp,(char *)(buf+index),FLASH_4K_SIZE);
Retval=crane_qspi_erase(flash_Addr + index, FLASH_4K_SIZE);
if (Retval != 0)
goto error;
if(index==0){
#if 0
uart_printf("+++++++++++++++++++++++++++++OTA_Update_FotaImage,delay for poweroff test++++++++++++++\n\r");
fota_delay();
uart_printf("-----------------------------OTA_Update_FotaImage,delay end----------------------------\n\r");
#endif
}
if(index%FLASH_1M_SIZE==0){
uart_printf("\r\n");
}
if(index%CRANE_NOR_BLOCKSIZE==0){
uart_printf("...");
}
Retval = crane_qspi_write(flash_Addr + index, (UINT32)temp, FLASH_4K_SIZE);
if (Retval != 0)
goto error;
index += FLASH_4K_SIZE;
size -= FLASH_4K_SIZE;
}
if(size>0){
memset(temp,0,FLASH_4K_SIZE);
memcpy(temp,(char *)(buf+index),size);
Retval=crane_qspi_erase(flash_Addr + index, FLASH_4K_SIZE);
if (Retval != 0)
goto error;
Retval = crane_qspi_write(flash_Addr + index, (UINT32)temp, FLASH_4K_SIZE);
if (Retval != 0)
goto error;
index += size;
size -= size;
}
Retval = 0;
error:
if(temp) tiny_free(temp);
Retval=OTA_Check_FotaImage(buf,tempsize,flash_Addr);
if(NoError!=Retval ){
if(i>10){
uart_printf("OTA_Check_FotaImage filed,Wait...\n\r");
while(1){
fota_mdelay(10*1000);
}
}
uart_printf("OTA_Check_FotaImage filed,Wait (%d)sec ...\n\r",(i+1)*10);
fota_mdelay((i+1)*10*1000);
uart_printf("OTA_Check_FotaImage filed,Wait (%d)sec end\n\r",(i+1)*10);
i++;
goto start;
}
uart_printf("OTA_Update_FotaImage end\n\r");
return Retval;
}
static UINT32 System_ota_updater(struct fota_firmwar_flag* pFOTA_T,struct fota_param *param,unsigned long FotaParamStartAddress)
{
UINT32 Retval = GeneralError;
UINT32 LoadAddr = 0;
MasterBlockHeader *pMasterHeader = NULL;
PDeviceHeader_11 pDevHeader_11=NULL;
PImageStruct_11 pImage_11 = NULL;
UINT32 temp_p = NULL;
UINT32 imageChecksum = 0;
UINT32 imagenum;
UINT32 ImageAddr;
UINT32 updaterSize=0,updateImageSize=0;
_ptentry * fota_pkg=ptable_find_entry("fota_pkg");
if(fota_pkg==NULL){
uart_printf("[OTA] not found fota_pkg\r\n");
return NotFoundError;
}
if (pFOTA_T->header != FOTA_HEADER_MAGIC)
{
uart_printf("[OTA] FBF Flag mismatch,Header[%.08x]\r\n",pFOTA_T->header);
return NotFoundError;
}
if (pFOTA_T->upgrade_flag != 1)
{
uart_printf("[OTA] No need to upgrade[%d]\r\n",pFOTA_T->upgrade_flag);
return NotFoundError;
}
if(pFOTA_T->upgrade_method != 1)
{
uart_printf("[OTA] Not ota upgrader\r\n");
return NotOtaUpdaterError;
}
#if QUEC_SUPPORT_FULL_FOTA_NAND
if(pFOTA_T->fbf_file_size > 0x32000)/*fbf bigger then 200k exit*/
{
uart_printf("[OTA] FBF greater than 200k,is not updater\r\n");
return NotFoundError;
}
#endif
LoadAddr = (UINT32)tiny_malloc(pFOTA_T->fbf_file_size);
if(LoadAddr == 0){
uart_printf("[OTA] tiny_malloc error\n\r");
return InvalidSizeError;
}
//uart_printf("LoadAddr: 0x%08x\n\r", LoadAddr);
memset((void *)LoadAddr,0,pFOTA_T->fbf_file_size);
//fota_dump_buffer("MasterBlockHeader",(unsigned char *)pFOTA_T->fbf_flash_address+QSPI_FLASH_BASE,0,sizeof(MasterBlockHeader));
memcpy((void *)LoadAddr,(void*)(pFOTA_T->fbf_flash_address+QSPI_FLASH_BASE),pFOTA_T->fbf_file_size);
pMasterHeader = (MasterBlockHeader *)LoadAddr;
if (pMasterHeader->Format_Version != 11){
Retval = FBF_VersionNotMatch;
goto error;
}
if (pMasterHeader->nOfDevices != 1){
Retval = FBF_DeviceMoreThanOne;
goto error;
}
temp_p = pMasterHeader->deviceHeaderOffset[0] + LoadAddr;
pDevHeader_11 = (PDeviceHeader_11)temp_p;
for ( imagenum = pDevHeader_11->nOfImages; imagenum > 0; imagenum -- )
{
temp_p = (UINT32)&pDevHeader_11->imageStruct_11[imagenum - 1];
pImage_11 = (PImageStruct_11)temp_p;
updaterSize = get_updater_copy_size();
updateImageSize = pImage_11->length;
uart_printf("[OTA] Flash_Start_Address: 0x%08x length: 0x%08x\n\r", pImage_11->Flash_Start_Address,updateImageSize);
uart_printf("[OTA] get_updater_start_addr: 0x%08x get_updater_copy_size: 0x%08x\n\r", get_updater_start_addr(),updaterSize);
if(updateImageSize & (FLASH_4K_SIZE-1)){
updateImageSize += (FLASH_4K_SIZE - updateImageSize & (FLASH_4K_SIZE-1));
}
if(get_updater_start_addr()!=(pImage_11->Flash_Start_Address+QSPI_FLASH_BASE) || updaterSize < updateImageSize)
{
Retval = NotOtaUpdaterError;
goto error;
}
uart_printf("[OTA] boot ota updater, nOfImages: %d\n\r",pDevHeader_11->nOfImages);
ImageAddr = LoadAddr+((pImage_11->First_Sector+7)<<ALIGN_1K_SIZE);
// add checksum for images in FBF file
imageChecksum = CalcImageChecksum((UINT32*)ImageAddr, pImage_11->length,0);
if (imageChecksum != pImage_11->ChecksumFormatVersion2){
Retval = CRCFailedError;
uart_printf("[OTA]fbf file CORRUPT,checksum failed\n\r");
goto error;
}
if(pImage_11->ChecksumFormatVersion2==0){
continue;
}
uart_printf("[OTA] Flash_Start_Address: 0x%08X, EraseLen: 0x%08X, length=0x%08X\n\r",
pImage_11->Flash_Start_Address,pImage_11->Flash_erase_size,pImage_11->length);
Retval=OTA_Update_FotaImage( ImageAddr, pImage_11->length, pImage_11->Flash_Start_Address);
if (Retval != NoError )
goto error;
}
tiny_free((void*)LoadAddr);
LoadAddr=0;
memset(param->fotaFlag,0,ASR_FOTA_FLAG_LEN_MAX);
param->mini_sys_enable = 0;
OTA_Update_FotaParam((UINT32)param, sizeof(struct fota_param),get_fota_param_start_addr()-QSPI_FLASH_BASE);
uart_printf("[OTA] Clear upgrade flag OK\r\n");
pFOTA_T->header = 0;
pFOTA_T->upgrade_flag = 0;
pFOTA_T->upgrade_method = 0;
pFOTA_T->checksum = 0;
Retval = OTA_Update_FotaParam((UINT32)pFOTA_T, sizeof(struct fota_firmwar_flag),FotaParamStartAddress);
if (Retval != NoError)
return Retval;
Retval = OTA_Update_FotaParam((UINT32)pFOTA_T, sizeof(struct fota_firmwar_flag),FotaParamStartAddress + FLASH_4K_SIZE);
if (Retval != NoError)
return Retval;
uart_printf("[OTA] Clear fota param OK\r\n");
return NoError;
error:
//free buffers
uart_printf("[OTA]ota updater,Retval=%x\n\r", Retval);
if(LoadAddr) tiny_free((void*)LoadAddr);
return Retval;
}
#endif
#endif
#define UpdaterExecAddress 0x7E040000//bind on updater build sct loader config
#define UpdaterVersionIndex 0x00800//bind on updater build sct loader config
UpdaterHeaderInfo updater_version_vb={0};
extern _ptentry *updater_Entry;
void get_updater_vb(void)
{
#ifdef SUPPORT_EXTERNAL_NORFLASH
_ptentry *fipEntry = ptable_find_entry("updater");
#endif
#ifdef BOOT33_SECBOOT_SUPPORT
#ifdef BOOT33_SECBOOT_V2
if(secboot_is_fuse_enabled()==1){
#endif
fip_image_t fip_item;
//[sec.0]secboot init from updater partition
// which is updater.bin with a secboot ToC struct with only one FIP header
// for updater.bin
//
// |----------------|
// | FIP Header |
// |----------------|
// | Updater.bin |
// |----------------|
#ifdef SUPPORT_EXTERNAL_NORFLASH
unsigned char * updater_buf = NULL;
if(fipEntry->vstart >= 0x90000000){ //����updater������flash
updater_buf = malloc(fipEntry->size);
memset(updater_buf, 0, fipEntry->size);
crane_ext_spi_read(fipEntry->start, (unsigned int)updater_buf, fipEntry->vsize);
fip_open((void*)updater_buf);
}else
#endif
{ //updater������flash
secboot_init("updater");
}
//[sec.1]do updater verify
//Timer0_enable(TRUE);
//secboot_item_check(ITEM_UPDATER);
//Timer0_enable(FALSE);
//[sec.2]get info from fip of updater.bin
secboot_item_get_img_addr_size(ITEM_UPDATER,(fip_image_handle)&fip_item);
//[sec.3]for debug to dump header of real updater.bin
//display_binary((void *)(fip_item.start+fip_item.offset),256);
//[sec.4]load updater_a or updater_b to psram
memcpy(&updater_version_vb,
(void *)(fip_item.start+fip_item.offset),
sizeof(UpdaterHeaderInfo));
//memcpy( (void *)UpdaterExecAddress,
// (void *)(fip_item.start+fip_item.offset),
// fip_item.size
// );
#ifdef BOOT33_SECBOOT_V2
secboot_deinit();
}
else{
#ifdef SUPPORT_EXTERNAL_NORFLASH
if(fipEntry->vstart >= 0x90000000){ //����updater������flash
crane_ext_spi_read(fipEntry->start, (unsigned int)&updater_version_vb, sizeof(UpdaterHeaderInfo));
}else
#endif
memcpy(&updater_version_vb,get_updater_start_addr(),sizeof(UpdaterHeaderInfo));
}
#endif
#else
#ifdef SUPPORT_EXTERNAL_NORFLASH
if(fipEntry->vstart >= 0x90000000){ //����updater������flash
crane_ext_spi_read(fipEntry->start, (unsigned int)&updater_version_vb, sizeof(UpdaterHeaderInfo));
}else
#endif
memcpy(&updater_version_vb,get_updater_start_addr(),sizeof(UpdaterHeaderInfo));
#endif
asr_property_set("updater.version",updater_version_vb.version_union.version_info_block.string);
asr_property_set("updater.solution",updater_version_vb.fota_solution_union.fota_solution_block.string);
CP_LOGD("[OTA] get updater version %s !\r\n",updater_version_vb.version_union.version_info_block.string);
CP_LOGD("[OTA] get updater solution %s !\r\n",updater_version_vb.fota_solution_union.fota_solution_block.string);
}
UINT32 UncompressUpdater(struct fota_firmwar_flag *fotaPara,unsigned char * address)
{
UINT32 res = NoError;
int outLen = -1;
unsigned int inLen = fotaPara->ota_header.mini_ota_head.nonDiffInfo.updater_size;
unsigned int offset = fotaPara->ota_header.mini_ota_head.nonDiffInfo.updater_offset;
unsigned char * inAddr = NULL,*dfota_buf=NULL;
if(inLen==0){
return NotFoundError;
}
CP_LOGD("[OTA] updater_addr [0x%.08x]\r\n", fotaPara->ota_header.mini_ota_head.nonDiffInfo.updater_addr);
if(fotaPara->ota_header.mini_ota_head.nonDiffInfo.updater_addr){
inAddr = fotaPara->ota_header.mini_ota_head.nonDiffInfo.updater_addr;
inAddr += QSPI_FLASH_BASE;
}else{
CP_LOGD("[OTA] first_flash_addr[0x%.08x], first_file_size[0x%.08x]\r\n", fotaPara->ota_header.mini_ota_head.first_flash_addr,fotaPara->ota_header.mini_ota_head.first_file_size);
CP_LOGD("[OTA] second_flash_address[0x%.08x], second_file_size[0x%.08x]\r\n", fotaPara->ota_header.mini_ota_head.second_flash_address,fotaPara->ota_header.mini_ota_head.second_file_size);
dfota_buf = (unsigned char *)tiny_malloc(fotaPara->ota_header.mini_ota_head.first_file_size + fotaPara->ota_header.mini_ota_head.second_file_size);
crane_qspi_read(fotaPara->ota_header.mini_ota_head.first_flash_addr - QSPI_FLASH_BASE, dfota_buf, fotaPara->ota_header.mini_ota_head.first_file_size);
if(fotaPara->ota_header.mini_ota_head.second_flash_address && fotaPara->ota_header.mini_ota_head.second_file_size){
crane_qspi_read(fotaPara->ota_header.mini_ota_head.second_flash_address - QSPI_FLASH_BASE, dfota_buf + fotaPara->ota_header.mini_ota_head.first_file_size, fotaPara->ota_header.mini_ota_head.second_file_size);
}
inAddr = dfota_buf + offset;
}
if(!LzmaUncompress((unsigned char *)address,(size_t *)&outLen, (const unsigned char *)inAddr, (size_t *)&inLen))
{
CP_LOGD("[OTA] released updater size [0x%.08x] inLen[0x%.08x]\r\n", outLen,inLen);
memcpy(&updater_version_vb,address,sizeof(UpdaterHeaderInfo));
if(updater_version_vb.loadtable_union.loadtable_block.magic != UPDATER_VALID_MAGIC){
res = UpdaterMagicError;
}else{
res=check_updater_ram(address,outLen);
if(res){
res = CheckUpdaterError;
}
}
}else{
res = UnpressedUpdaterError;
}
return res;
}
void ota_entry(void) {
volatile unsigned long FotaParamStartAddress;
volatile unsigned long FotaParamEndAddress;
struct fota_param param;
unsigned long entry_mini_system_only=0;
struct fota_firmwar_flag *fotaPara_1=NULL;
struct fota_firmwar_flag *fotaPara_2=NULL;
struct fota_firmwar_flag *fotaPara=NULL;
UINT32 Retval = NoError;
UpdaterHeaderInfo updater_version;
#ifdef SUPPORT_EXTERNAL_NORFLASH
_ptentry *fipEntry = ptable_find_entry("updater");
#endif
//detect whether fota partition supported
FotaParamStartAddress = get_fota_param_start_addr();
FotaParamEndAddress = get_fota_param_end_addr();
if(FotaParamStartAddress == FotaParamEndAddress){
CP_LOGE("[OTA] FotaParamStartAddress == FotaParamEndAddress , FOTA not supported\r\n");
return;
}
#if (!defined(BOOT33_FOTA_NO_UPDATER) || !defined(LTEONLY_SINGLE_SIM))
#if (!defined(CRANEM_SINGLE_SIM))
if(updater_Entry){
get_updater_vb();
asr_property_dump();
}
#endif
#endif
//check OTA flag or
memcpy(&param,(void *)FotaParamStartAddress,sizeof(struct fota_param));
//if(!strncmp(fota_flag,"ASROTA",6) || Keypad_OTA_Flag_Check_B()){
if(!strncmp((char *)param.fotaFlag,"ASROTA",6) ){
UINT32 stack=0x7e200000;
//The bspatch/lzma lib needs malloc/free APIs
UINT32 poolLen = 0x00600000;
malloc_init(stack, poolLen);
#if (!defined(BOOT33_FOTA_NO_UPDATER) || !defined(LTEONLY_SINGLE_SIM))
#if (!defined(CRANEM_SINGLE_SIM))
if(updater_Entry){
#ifdef SUPPORT_EXTERNAL_NORFLASH
if(get_updater_start_addr() >= 0x90000000){
crane_ext_spi_read(get_updater_start_addr()-0x90000000, (unsigned int)&updater_version, sizeof(UpdaterHeaderInfo));
}else
#endif
memcpy(&updater_version,get_updater_start_addr(),sizeof(UpdaterHeaderInfo));
CP_LOGD("[OTA] get updater version %s !\r\n",updater_version.version_union.version_info_block.string);
}
#endif
#endif
fotaPara_1=(struct fota_firmwar_flag*)tiny_malloc(sizeof(struct fota_firmwar_flag));
fotaPara_2=(struct fota_firmwar_flag*)tiny_malloc(sizeof(struct fota_firmwar_flag));
memcpy(fotaPara_1,(void *)(FotaParamStartAddress+FLASH_4K_SIZE),sizeof(struct fota_firmwar_flag));
memcpy(fotaPara_2,(void *)(FotaParamStartAddress+2*FLASH_4K_SIZE),sizeof(struct fota_firmwar_flag));
if(fotaPara_1->checksum!=CalcImageChecksum((UINT32*)fotaPara_1,sizeof(struct fota_firmwar_flag)-sizeof(unsigned int),0)
|| fotaPara_1->header != FOTA_HEADER_MAGIC){
if(fotaPara_2->checksum!=CalcImageChecksum((UINT32*)fotaPara_2,sizeof(struct fota_firmwar_flag)-sizeof(unsigned int),0)
|| fotaPara_2->header != FOTA_HEADER_MAGIC){
CP_LOGD("[OTA] fotaPara error!!!\r\n");
goto done;
}else{
CP_LOGD("[OTA]using fotaPara_2,not copy temp flash\r\n");
fotaPara = fotaPara_2;
}
}else{
if(fotaPara_2->checksum!=CalcImageChecksum((UINT32*)fotaPara_2,sizeof(struct fota_firmwar_flag)-sizeof(unsigned int),0)
|| fotaPara_2->header != FOTA_HEADER_MAGIC){
fotaPara = fotaPara_1;
CP_LOGD("[OTA]using fotaPara_1,need copy temp flash\r\n");
}else{
if(fotaPara_1->index > fotaPara_2->index){
fotaPara = fotaPara_1;
CP_LOGD("[OTA]using fotaPara_1,need copy temp flash\r\n");
}else{
fotaPara = fotaPara_2;
CP_LOGD("[OTA]using fotaPara_2,not copy temp flash,checksum[%08x]\r\n",fotaPara_2->checksum);
}
}
}
if(param.mini_sys_enable==1){
mini_system_enable=1;
if(fotaPara->ota_header.mini_ota_head.mini_dfota_status==MINI_SYS_DFOTA_START){
CP_LOGD("[OTA]MINI_SYS_DFOTA_START\r\n");
entry_mini_system_only = 1;
}else if(fotaPara->ota_header.mini_ota_head.mini_dfota_status>=MINI_SYS_DFOTA_DONE){
entry_mini_system_only = 1;
CP_LOGD("[OTA]MINI_SYS_DFOTA_DONE\r\n");
}
if(entry_mini_system_only==1){
asr_property_set("mini.sys.enable","1");
tiny_free(fotaPara_1);
tiny_free(fotaPara_2);
uart_printf("[OTA]ENTRY MINI SYSTEM ONLY\r\n");
return;
}
#if defined(BOOT33_FOTA_NO_UPDATER)
if(!updater_Entry){
Retval=UncompressUpdater(fotaPara,UpdaterExecAddress);
CP_LOGD("[OTA]UncompressUpdater[%d] %s !!!\r\n",Retval,Retval?"error":"success");
if(Retval != NoError){
CP_LOGE("[OTA] no updater paritition,parse updater failed[%02x]!!!\r\n",Retval);
tiny_free(fotaPara_1);
tiny_free(fotaPara_2);
return;
}
}
#endif
tiny_free(fotaPara_1);
tiny_free(fotaPara_2);
}
#if (!defined(BOOT33_FOTA_NO_UPDATER) || !defined(LTEONLY_SINGLE_SIM))
#if (!defined(CRANEM_SINGLE_SIM))
else{
Retval=System_ota_updater(fotaPara,&param,FotaParamStartAddress+FLASH_4K_SIZE-QSPI_FLASH_BASE);
if(Retval==0){
CP_LOGD("[OTA]System_ota_updater success!\r\n");
#ifdef SUPPORT_EXTERNAL_NORFLASH
if(get_updater_start_addr() >= 0x90000000){
crane_ext_spi_read(get_updater_start_addr()-0x90000000, (unsigned int)&updater_version, sizeof(UpdaterHeaderInfo));
}else
#endif
memcpy(&updater_version,get_updater_start_addr(),sizeof(UpdaterHeaderInfo));
CP_LOGD("[OTA] get new updater version %s !\r\n",updater_version.version_union.version_info_block.string);
tiny_free(fotaPara_1);
tiny_free(fotaPara_2);
return;
}
tiny_free(fotaPara_1);
tiny_free(fotaPara_2);
}
#endif
#endif
done:
#if (!defined(BOOT33_FOTA_NO_UPDATER) || !defined(LTEONLY_SINGLE_SIM))
#if (!defined(CRANEM_SINGLE_SIM))
#ifdef ADD_VIBRATOR_IN_CODE
//[0] Before jump to updater, disable vibrator
NingboVibratorDisable();
#endif
//[1] TODO:detect ADUPS flags
CP_LOGD("[OTA] ASROTA prefix detected or Keypad Flag detect!\r\n");
if(!updater_Entry){
if(Retval != NoError){
CP_LOGE("[OTA] no updater paritition,parse updater failed[%02x]!!!\r\n",Retval);
return;
}
goto jump;
}
#ifdef BOOT33_SECBOOT_SUPPORT
#ifdef BOOT33_SECBOOT_V2
if(secboot_is_fuse_enabled()==1){
#endif
fip_image_t fip_item;
//[sec.0]secboot init from updater partition
// which is updater.bin with a secboot ToC struct with only one FIP header
// for updater.bin
//
// |----------------|
// | FIP Header |
// |----------------|
// | Updater.bin |
// |----------------|
#ifdef SUPPORT_EXTERNAL_NORFLASH
unsigned char * updater_buf = NULL;
if(fipEntry->vstart >= 0x90000000){ //����updater������flash
updater_buf = malloc(fipEntry->size);
memset(updater_buf, 0, fipEntry->size);
crane_ext_spi_read(fipEntry->start, (unsigned int)updater_buf, fipEntry->vsize);
fip_open((void*)updater_buf);
}else
#endif
{ //updater������flash
secboot_init("updater");
}
//[sec.1]do updater verify
Timer0_enable(TRUE);
secboot_item_check(ITEM_UPDATER);
Timer0_enable(FALSE);
//[sec.2]get info from fip of updater.bin
secboot_item_get_img_addr_size(ITEM_UPDATER,(fip_image_handle)&fip_item);
//[sec.3]for debug to dump header of real updater.bin
//display_binary((void *)(fip_item.start+fip_item.offset),256);
//[sec.4]load updater_a or updater_b to psram
memcpy( (void *)UpdaterExecAddress,
(void *)(fip_item.start+fip_item.offset),
fip_item.size
);
#ifdef BOOT33_SECBOOT_V2
}else{
//[2] TODO:load updater_a or updater_b to psram
#ifdef SUPPORT_EXTERNAL_NORFLASH
if(fipEntry->vstart >= 0x90000000){ //����updater������flash
crane_ext_spi_read(fipEntry->start, (unsigned int)UpdaterExecAddress, get_updater_copy_size());
}else
#endif
{
memcpy( (void *)UpdaterExecAddress,
(void *)get_updater_start_addr(),
get_updater_copy_size());
}
}
#endif
#else
//[2] TODO:load updater_a or updater_b to psram
#ifdef SUPPORT_EXTERNAL_NORFLASH
if(fipEntry->vstart >= 0x90000000){ //����updater������flash
crane_ext_spi_read(fipEntry->start, (unsigned int)UpdaterExecAddress, get_updater_copy_size());
}else
#endif
{
memcpy( (void *)UpdaterExecAddress,
(void *)get_updater_start_addr(),
get_updater_copy_size());
}
#endif
#endif
#endif
jump:
//[3] jump to execute updater
CP_LOGD("\r\n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
CP_LOGD("\r\n >> BOOTLOADER DONE JUMP TO UPDATER");
CP_LOGD("\r\n >> PC : 0x%x",UpdaterExecAddress);
CP_LOGD("\r\n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n");
TransferControl(UpdaterExecAddress);
}else{
CP_LOGD("[OTA] NO FOTA FLAG DETECTED \r\n");
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink