992 lines
35 KiB
C
992 lines
35 KiB
C
/**
|
||
* @file ota_execute.c
|
||
* @brief OTA 功能实现文件，供OTA协议层调用
|
||
* @details
|
||
* @author George
|
||
* @date 2021/6/28
|
||
* @version A001
|
||
* @par Copyright (c):
|
||
* SmartFenda.
|
||
* @par History:
|
||
* version: author, date, desc\n
|
||
*/
|
||
|
||
#include "am_util_debug.h"
|
||
#include "sys_config.h"
|
||
|
||
#include "FreeRTOS.h"
|
||
#include "task.h"
|
||
#include "timers.h"
|
||
|
||
#include "crc32.h"
|
||
#include "am_bootloader.h"
|
||
#include "am_multi_boot.h"
|
||
//#include "amota_profile_config.h"
|
||
#include "am_hal_mram.h"
|
||
|
||
#include "ble_ota_execute.h"
|
||
#include "ble_protocol.h"
|
||
#include "flash_api.h"
|
||
//#include "user_gps.h"
|
||
#include "ppg_api.h"
|
||
#include "task_ble.h"
|
||
#include "log_api.h"
|
||
#include "rtc_api.h"
|
||
#include "user_adapter.h"
|
||
#include "motor_api.h"
|
||
#include "sys_adapter.h"
|
||
|
||
#include "user_pack_analysis.h"
|
||
#include "sys_typedef.h"
|
||
#include "ui_event.h"
|
||
#include "task_ui.h"
|
||
#include "user_charge.h"
|
||
#include "ui_port_fw.h"
|
||
#include "charge_api.h"
|
||
|
||
|
||
#define ENABLE_STATIC_PRINT false
|
||
extern uint32_t am_util_stdio_printf(const char *pcFmt, ...);
|
||
#define static_print_remind(...) am_util_stdio_printf(__VA_ARGS__)
|
||
#if ENABLE_STATIC_PRINT
|
||
#define static_print_info(...) am_util_stdio_printf(__VA_ARGS__)
|
||
#else
|
||
#define static_print_info(...)
|
||
#endif
|
||
|
||
#define OTA_READ_BUFSIZE 1024 // 若空间不够可以设1024或更小的值
|
||
|
||
#define BYTES_2_UINT32(n, p) {n = ((uint32_t)(p)[0] + ((uint32_t)(p)[1] << 8) + \
|
||
((uint32_t)(p)[2] << 16) + ((uint32_t)(p)[3] << 24));}
|
||
|
||
// Protection against NULL pointer
|
||
//#define FLASH_OPERATE(pFlash, func) ((pFlash)->func ? (pFlash)->func() : 0)
|
||
#define FLASH_OPERATE(pFlash, func)
|
||
|
||
|
||
#if 1
|
||
|
||
//MBR INFO 此定义OTA与BOOT工程中MBR严格对齐
|
||
enum {
|
||
FW_SOUR_CS_NULL,
|
||
FW_SOUR_CS_RAM,
|
||
FW_SOUR_CS_ROM,
|
||
FW_SOUR_CS_FLASH,
|
||
FW_SOUR_CS_FS,
|
||
FW_SOUR_CS_MAX,
|
||
};
|
||
|
||
typedef struct {
|
||
// 固件源地址
|
||
uint32_t fw_sour_addr;
|
||
// 固件目的地址(运行地址)
|
||
uint32_t fw_dest_addr;
|
||
// 固件源片选
|
||
uint32_t fw_sour_cs:8;
|
||
// 固件目的片选
|
||
uint32_t fw_dest_cs:8;//固件源存放片选。NULL、RAM、ROM、EXT_FLASH、FS
|
||
// 保留字节
|
||
uint32_t fw_reserve1:16;
|
||
// 固件版本号
|
||
uint8_t fw_version[4];
|
||
// 固件大小， 单位字节
|
||
uint32_t fw_bytes;
|
||
// 固件 crc32 值
|
||
uint32_t fw_crc32;
|
||
}fw_parm_t;
|
||
|
||
typedef struct {
|
||
// 0x01： 不需要搬运固件， 直接跳转到 APP 区（正式固件） 执行;
|
||
// 0x02： 不需要搬运固件， 直接跳转到 APP 区（厂测固件） 执行;
|
||
// 0x03： 不需要搬运固件， 直接跳转到 APP 区（DTM固件） 执行;
|
||
// 0x10： 需要搬运正式固件;
|
||
// 0x20： 需要搬运厂测固件;
|
||
// 0x30： 需要搬运DTM固件;
|
||
uint32_t carry_fw_flag;
|
||
// 标签
|
||
char mark[32];
|
||
// 正式固件参数
|
||
fw_parm_t formal;
|
||
// 厂测固件参数
|
||
fw_parm_t factory;
|
||
// DTM固件参数
|
||
fw_parm_t dmt;
|
||
// OTA 参数区的 crc32 校验值
|
||
uint32_t crc32;
|
||
}mbr_parm_t;
|
||
|
||
#endif
|
||
|
||
//
|
||
// Data structure for Breakpoint continuation
|
||
//
|
||
typedef struct
|
||
{
|
||
uint32_t fileOffset;
|
||
uint32_t fileSize;
|
||
uint32_t fileCrc32;
|
||
uint32_t ifResume;
|
||
uint32_t crc;
|
||
uint32_t res; // 8字节对齐
|
||
}FwBreakPointInfo_t;
|
||
|
||
otasFlashOp_t otaFlashOp = {
|
||
.bufferIndex = 0,
|
||
};
|
||
|
||
static FwBreakPointInfo_t g_otaBreakPoint = {0};
|
||
|
||
static TimerHandle_t ota_timeout_time_handle = NULL;
|
||
static TimerHandle_t g_otaResendTimer = NULL;
|
||
static OtaCtrlBlock_t g_otaCtrlBlock = {0};
|
||
static am_multiboot_flash_info_t *g_pFlash = NULL;
|
||
static am_multiboot_flash_info_t g_ext_flash = {0};
|
||
static uint8_t OtasReadBuf[OTA_READ_BUFSIZE] = {0};
|
||
|
||
static head_desc_parm g_ota_head_param;
|
||
static head_struct_parm g_ota_head_struct;
|
||
static mbr_parm_t g_boot_mbr_info;
|
||
|
||
extern void user_update_percent_show(uint8_t percent);
|
||
extern void DeviceRequestOTAFileData(uint32_t offset,uint16_t DataLen,uint32_t TotalFileSise,uint32_t ReceivedFileSize);
|
||
void OtaUpdateBreakPoint(void);
|
||
|
||
extern uint8_t user_dog_get_timeout_status(void);
|
||
int ota_flash_read_func(uint32_t ui32DestAddr, uint32_t *pSrc, uint32_t ui32Length)
|
||
{
|
||
return flash_api_read(ui32DestAddr, pSrc, ui32Length);
|
||
}
|
||
|
||
int ota_flash_write_func(uint32_t ui32DestAddr, uint32_t *pSrc, uint32_t ui32Length)
|
||
{
|
||
return flash_api_write(ui32DestAddr, pSrc, ui32Length);
|
||
}
|
||
|
||
int ota_flash_erase_func(uint32_t ui32Addr)
|
||
{
|
||
return flash_api_erase(ui32Addr);
|
||
}
|
||
|
||
int ota_ext_flash_info_init(am_multiboot_flash_info_t *pFlash)
|
||
{
|
||
pFlash->flashPageSize = flash_api_get_erase_unit_size();
|
||
pFlash->flashSectorSize = flash_api_get_erase_unit_size();
|
||
pFlash->flash_init = NULL;
|
||
pFlash->flash_deinit = NULL;
|
||
pFlash->flash_enable = NULL;
|
||
pFlash->flash_disable = NULL;
|
||
pFlash->flash_read_page = ota_flash_read_func;
|
||
pFlash->flash_write_page = ota_flash_write_func;
|
||
pFlash->flash_erase_sector = ota_flash_erase_func;
|
||
return true;
|
||
}
|
||
|
||
static void OtaTimeoutCb(TimerHandle_t xTimer)
|
||
{
|
||
static_print_info("?????ota_timeout?????\r\n");
|
||
OtaFailed(PACK_WAIE_TIMEOUT_ERROR);
|
||
}
|
||
|
||
void OtaCreatTimeoutTimer(void)
|
||
{
|
||
ota_timeout_time_handle = xTimerCreate("ota_timeout_task_time",(1000 * 10), false, NULL, OtaTimeoutCb);
|
||
if(ota_timeout_time_handle==NULL)
|
||
{
|
||
static_print_info("?????ota_timeout_creat_time fail?????\r\n");
|
||
}
|
||
}
|
||
|
||
void OtaTimeoutReset(void)
|
||
{
|
||
if(ota_timeout_time_handle != NULL)
|
||
{
|
||
xTimerReset(ota_timeout_time_handle, 0);
|
||
}
|
||
}
|
||
|
||
void OtaTimeoutTimerStop(void)
|
||
{
|
||
if(ota_timeout_time_handle != NULL)
|
||
{
|
||
xTimerStop(ota_timeout_time_handle, 0);
|
||
}
|
||
}
|
||
|
||
static void OtaResendTimerCallback(TimerHandle_t xTimer)
|
||
{
|
||
static_print_info("need resend, offset=%x!\r\n", g_otaCtrlBlock.pkt.offset);
|
||
DeviceRequestOTAFileData(g_otaCtrlBlock.pkt.offset, g_otaCtrlBlock.pkt.ApplyLen,
|
||
g_otaCtrlBlock.pkt.FileSize, g_otaCtrlBlock.pkt.offset);
|
||
}
|
||
|
||
void OtaFrameResendTimerLoad(void)
|
||
{
|
||
if(g_otaResendTimer == NULL)
|
||
{
|
||
g_otaResendTimer = xTimerCreate("otaResendTimer",(1000 * 3), false, NULL, OtaResendTimerCallback);
|
||
static_print_info("g_otaResendTimer=0x%08X\r\n", g_otaResendTimer);
|
||
if(g_otaResendTimer != NULL)
|
||
{
|
||
xTimerStart(g_otaResendTimer, 0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
xTimerReset(g_otaResendTimer, 0);
|
||
}
|
||
}
|
||
|
||
void OtaFrameResendTimerStop(void)
|
||
{
|
||
if(g_otaResendTimer != NULL)
|
||
{
|
||
xTimerStop(g_otaResendTimer, 0);
|
||
}
|
||
}
|
||
|
||
bool_t OtaIsStarted(void)
|
||
{
|
||
return g_otaCtrlBlock.ota_start_flag;
|
||
}
|
||
|
||
/*!
|
||
* brief: Get Ota CtrlBlock, for OTA service call
|
||
*/
|
||
void GetOtaCtrlBlock(OtaCtrlBlock_t *ctrl)
|
||
{
|
||
memcpy(ctrl, &g_otaCtrlBlock, sizeof(OtaCtrlBlock_t));
|
||
}
|
||
|
||
/*!
|
||
* brief: Check whether the device can be OTA，for OTA service call
|
||
*/
|
||
uint8_t OtaRequest(uint32_t FwLen)
|
||
{
|
||
uint8_t CurrBattPercent;
|
||
chg_status_e charge_status;
|
||
|
||
CurrBattPercent = ui_port_get_battary_percent();
|
||
charge_status = charge_api_get_charge_status();
|
||
static_print_remind ("Current Batt Percent:%d%. - status = %d \r\n",CurrBattPercent,charge_status);
|
||
if(charge_status == BATT_STAT_CHARGE_TEMPER_0_5
|
||
|| charge_status == BATT_STAT_CHARGE_TEMPER_6_15
|
||
|| charge_status == BATT_STAT_CHARGE_TEMPER_16_45
|
||
|| charge_status == BATT_STAT_CHARGE_DONE_NOT_CHARGE
|
||
)
|
||
{
|
||
CurrBattPercent = 80; // 若处于充电状态则不用检测电量
|
||
}
|
||
if(CurrBattPercent < OTA_BATT_THRESHOLD)
|
||
{
|
||
return 1; //1：不能升级
|
||
}
|
||
memset(&g_otaCtrlBlock, 0, sizeof(g_otaCtrlBlock));
|
||
g_otaCtrlBlock.pkt.FileSize = FwLen;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/*!
|
||
* brief: OTA completed, for OTA service call
|
||
*/
|
||
void OtaSucceed(void)
|
||
{
|
||
uint32_t BreakPointPtrVal = 0;
|
||
|
||
OtaTimeoutTimerStop();
|
||
OtaFrameResendTimerStop();
|
||
|
||
BreakPointPtrVal = *((uint32_t *)USER_OTA_BREAK_POINT_ADDR);
|
||
if((BreakPointPtrVal != 0xFFFFFFFF) && (BreakPointPtrVal != 0))
|
||
{// 若存在断点续传信息则清除
|
||
memset(&g_otaBreakPoint, 0, sizeof(g_otaBreakPoint));
|
||
OtaUpdateBreakPoint();
|
||
}
|
||
|
||
if(g_otaCtrlBlock.HeaderInfo.fwDataType == MARK_MCU_FW_BIN)
|
||
{
|
||
OtaUpdateFwInfo();
|
||
}
|
||
|
||
task_ui_notify(EVENT_OTA_TRANSMITTING, 100, NULL, 0);
|
||
|
||
// log_api_record_action(rtc_api_get_utc_timestamp(), EVT_OTA_UPDATE, INFO1_OTA_SUCC, 0, 0, NULL);
|
||
task_ble_notify(BLE_RESET_AFTER_OTA_MSG, 0); //退出升级，延时复位
|
||
}
|
||
|
||
/*!
|
||
* brief: OTA Failed, for OTA service call
|
||
*/
|
||
void OtaFailed(uint8_t reason)
|
||
{
|
||
OtaTimeoutTimerStop();
|
||
OtaFrameResendTimerStop();
|
||
recovery_ble_task_priority();
|
||
g_otaCtrlBlock.ota_start_flag = FALSE;
|
||
|
||
if(g_otaCtrlBlock.ota_status == OTA_STATE_FW_DATA && g_otaCtrlBlock.pkt.offset > AM_HAL_FLASH_PAGE_SIZE)
|
||
{
|
||
static_print_info("we need storage breakpoint info:0x%x-0x%x-0x%x\r\n",g_otaCtrlBlock.HeaderInfo.fwCrc,g_otaCtrlBlock.pkt.offset,g_otaCtrlBlock.HeaderInfo.fwLength);
|
||
g_otaBreakPoint.fileCrc32 = g_otaCtrlBlock.HeaderInfo.fwCrc;
|
||
g_otaBreakPoint.fileOffset = g_otaCtrlBlock.pkt.offset;
|
||
g_otaBreakPoint.fileSize = g_otaCtrlBlock.HeaderInfo.fwLength;
|
||
g_otaBreakPoint.ifResume = 1;
|
||
OtaUpdateBreakPoint();
|
||
}
|
||
else if(g_otaCtrlBlock.ota_status == OTA_STATE_FW_RESET)
|
||
{
|
||
int32_t BreakPointPtrVal = 0;
|
||
|
||
BreakPointPtrVal = *((uint32_t *)OTA_BREAK_POINT_ADDR);
|
||
if((BreakPointPtrVal != 0xFFFFFFFF) && (BreakPointPtrVal != 0))
|
||
{// 若存在断点续传信息则清除
|
||
memset(&g_otaBreakPoint, 0, sizeof(g_otaBreakPoint));
|
||
//OtaUpdateBreakPoint();
|
||
}
|
||
}
|
||
task_ui_notify(EVENT_OTA_FAIL, 0, NULL, 0);
|
||
log_api_record_action(rtc_api_get_utc_timestamp(), EVT_OTA_UPDATE, INFO1_OTA_FAIL, reason, g_otaBreakPoint.fileOffset, NULL);
|
||
task_ble_notify(BLE_RESET_AFTER_OTA_MSG, 0); //退出升级，延时复位
|
||
// task_ui_notify(UI_MSG_GOTO_MAINMENU, 0, NULL, 0);
|
||
}
|
||
|
||
|
||
void OtaStop(void)
|
||
{
|
||
if(!OtaIsStarted())
|
||
return;
|
||
|
||
OtaFailed(DEVICE_DISCONNECT);
|
||
}
|
||
|
||
/*!
|
||
* brief: Start OTA，for OTA service call
|
||
*/
|
||
void OtaStart(void)
|
||
{
|
||
|
||
task_ui_notify(EVENT_OTA_TRANSMITTING, 0, NULL, 0);
|
||
|
||
log_api_record_action(rtc_api_get_utc_timestamp(), EVT_OTA_UPDATE, INFO1_OTA_START, 0, 0, NULL);
|
||
motor_api_stop();
|
||
//user_gps_shutdown();
|
||
gsensor_api_close();
|
||
ppg_api_close();
|
||
//g_user_tp_ops.close(); // 关闭tp
|
||
/* OTA 过程中 主频使用48M */
|
||
sys_smart_delay_ms(100);
|
||
sys_burst_mode_switch(0, 1, false);
|
||
|
||
g_otaCtrlBlock.ota_start_flag = TRUE;
|
||
g_otaCtrlBlock.ota_status = OTA_STATE_FW_HEADER;
|
||
g_otaCtrlBlock.pkt.ApplyLen = FW_HEAD_INFO_IEN; //请求的第一包为固定长度0x30的固件头部信息
|
||
}
|
||
|
||
/*!
|
||
* brief: Verify the currently written data
|
||
*/
|
||
static int OtaVerifyFlashContent(uint32_t flashAddr, uint32_t *pSram, uint32_t len, am_multiboot_flash_info_t *pFlash)
|
||
{
|
||
// read back and check
|
||
uint32_t offset = 0;
|
||
uint32_t remaining = len;
|
||
int ret = 0;
|
||
|
||
if(remaining < g_pFlash->flashPageSize)
|
||
{
|
||
remaining = g_pFlash->flashPageSize;
|
||
}
|
||
|
||
while (remaining)
|
||
{
|
||
uint32_t tmpSize = (remaining > OTA_READ_BUFSIZE) ? OTA_READ_BUFSIZE : remaining;
|
||
|
||
//pFlash->flash_read_page((uint32_t)OtasReadBuf, (uint32_t *)(flashAddr + offset), tmpSize);
|
||
ret = pFlash->flash_read_page((flashAddr + offset), (uint32_t *)OtasReadBuf, tmpSize);
|
||
|
||
ret = memcmp(OtasReadBuf, (uint8_t*)((uint32_t)pSram + offset), tmpSize);
|
||
if ( ret != 0 )
|
||
{
|
||
// there is write failure happened.
|
||
static_print_info("\r\n??????flash write verify failed. address 0x%x. length %d????? - tmpSize = %d - ret = %x \r\n", flashAddr, len,tmpSize );
|
||
for(uint16_t i = 0; i < tmpSize; i++ )
|
||
static_print_info("i = %d >>> read =%x - tran = %x \n",i,OtasReadBuf[i], ((uint8_t*)pSram)[i]);
|
||
break;
|
||
}
|
||
|
||
offset += tmpSize;
|
||
remaining -= tmpSize;
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
/*!
|
||
* brief: OTA firmware writing to flash
|
||
*/
|
||
static uint32_t OtaWrite2Flash(uint16_t len, uint8_t *buf, uint32_t addr, bool lastPktFlag)
|
||
{
|
||
uint16_t ui16BytesRemaining = len;
|
||
uint32_t ui32TargetAddress = 0;
|
||
uint8_t ui8PageCount = 0;
|
||
uint32_t error_code = FENDA_SUCCESS;
|
||
uint16_t i;
|
||
uint8_t indx = 0;
|
||
uint32_t write_result = 0x10000;
|
||
|
||
addr -= otaFlashOp.bufferIndex;
|
||
//
|
||
// Check the target flash address to ensure we do not operation the wrong address
|
||
// make sure to write to page boundary
|
||
//
|
||
static_print_remind("len=0x%x,buf=0x%x,addr=0x%x,lastPktFlag=%d,Index=%d\n",len,buf,addr,lastPktFlag,otaFlashOp.bufferIndex);
|
||
if (((uint32_t)g_otaCtrlBlock.newFwFlashInfo.addr > addr) ||
|
||
(addr & (g_pFlash->flashPageSize - 1)))
|
||
{
|
||
//
|
||
// application is trying to write to wrong address
|
||
//
|
||
static_print_info(" application is trying to write to wrong address addr = %x\n",addr);
|
||
return DEVICE_FW_OTA_ERROR;
|
||
}
|
||
|
||
FLASH_OPERATE(g_pFlash, flash_enable);
|
||
while (ui16BytesRemaining)
|
||
{
|
||
uint16_t ui16Bytes2write = g_pFlash->flashPageSize - otaFlashOp.bufferIndex;
|
||
if (ui16Bytes2write > ui16BytesRemaining)
|
||
{
|
||
ui16Bytes2write = ui16BytesRemaining;
|
||
}
|
||
// move data into buffer
|
||
for ( i = 0; i < ui16Bytes2write; i++ )
|
||
{
|
||
// avoid using memcpy
|
||
otaFlashOp.writeBuffer[otaFlashOp.bufferIndex++] = buf[i];
|
||
}
|
||
ui16BytesRemaining -= ui16Bytes2write;
|
||
buf += ui16Bytes2write;
|
||
|
||
static_print_info("ui16BytesRemaining = %d - ui16Bytes2write = %d \n",ui16BytesRemaining,ui16Bytes2write);
|
||
//
|
||
// Write to flash when there is data more than 1 page size
|
||
// For last fragment write even if it is less than one page
|
||
//
|
||
if (lastPktFlag || (otaFlashOp.bufferIndex == g_pFlash->flashPageSize))
|
||
{
|
||
ui32TargetAddress = (addr + ui8PageCount*g_pFlash->flashPageSize);
|
||
|
||
for(indx = 0; indx < 3; indx++)
|
||
{
|
||
error_code = g_pFlash->flash_erase_sector(ui32TargetAddress);
|
||
static_print_info(" flash_erase_sector = %d \n",error_code);
|
||
if(error_code == AM_HAL_STATUS_SUCCESS)
|
||
//if(g_pFlash->flash_erase_sector(ui32TargetAddress) == AM_HAL_STATUS_SUCCESS)
|
||
{
|
||
error_code = g_pFlash->flash_write_page(ui32TargetAddress, (uint32_t *)otaFlashOp.writeBuffer, g_pFlash->flashPageSize);
|
||
static_print_info(" flash_write_page = %d \n",error_code);
|
||
if( error_code == write_result)
|
||
//if(g_pFlash->flash_write_page(ui32TargetAddress, (uint32_t *)otaFlashOp.writeBuffer, g_pFlash->flashPageSize) == AM_HAL_STATUS_SUCCESS)
|
||
{
|
||
if(OtaVerifyFlashContent(ui32TargetAddress, (uint32_t *)otaFlashOp.writeBuffer, otaFlashOp.bufferIndex, g_pFlash) == AM_HAL_STATUS_SUCCESS)
|
||
{
|
||
static_print_info("Flash write succeeded to address 0x%x. length %d\n", ui32TargetAddress, otaFlashOp.bufferIndex);
|
||
ui8PageCount++;
|
||
otaFlashOp.bufferIndex = 0;
|
||
error_code = FENDA_SUCCESS;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
error_code = DATA_CRC_OTA_ERROR;
|
||
static_print_remind("\r\n\r\n\n\nFlash verify failed to address: 0x%x. indx = %d\r \n", ui32TargetAddress, indx);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
error_code = FLASH_WRITE_OTA_ERROR;
|
||
static_print_remind("\r\n\r\n\n\nFlash write failed to address: 0x%x. indx = %d - %d\r \n", ui32TargetAddress, indx,g_pFlash->flashPageSize);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
error_code = FLASH_ERASE_OTA_ERROR;
|
||
static_print_remind("\r\n\r\n\n\nFlash erase sector failed to address: 0x%x. indx = %d\r\n", ui32TargetAddress, indx);
|
||
}
|
||
vTaskDelay(100);
|
||
}
|
||
|
||
if(indx >= 3)
|
||
{
|
||
OtaFailed(DEVICE_DISCONNECT);
|
||
static_print_remind("try 3 times to write flash, but all failed\r\n");
|
||
break;
|
||
}
|
||
|
||
// FlashOperationStatus = g_pFlash->flash_erase_sector(ui32TargetAddress);
|
||
|
||
// // Always write whole pages
|
||
// if ((g_pFlash->flash_write_page(ui32TargetAddress, (uint32_t *)otaFlashOp.writeBuffer, g_pFlash->flashPageSize) != 0)
|
||
// || (OtaVerifyFlashContent(ui32TargetAddress, (uint32_t *)otaFlashOp.writeBuffer, otaFlashOp.bufferIndex, g_pFlash) != 0))
|
||
// //if (g_pFlash->flash_write_page(ui32TargetAddress, (uint32_t *)otaFlashOp.writeBuffer, g_pFlash->flashPageSize) != 0)
|
||
// {
|
||
// static_print_info("FlashOperationStatus = %d, Flash write failed to address: 0x%x \n", FlashOperationStatus, ui32TargetAddress);
|
||
//
|
||
// bResult = false;
|
||
// break;
|
||
// }
|
||
// static_print_info("Flash write succeeded to address 0x%x. length %d\n", ui32TargetAddress, otaFlashOp.bufferIndex);
|
||
|
||
// ui8PageCount++;
|
||
// otaFlashOp.bufferIndex = 0;
|
||
// bResult = true;
|
||
}
|
||
}
|
||
FLASH_OPERATE(g_pFlash, flash_disable);
|
||
|
||
//
|
||
// If we get here, operations are done correctly
|
||
//
|
||
return error_code;
|
||
}
|
||
|
||
|
||
/*!
|
||
* brief: Verify Firmware Image CRC
|
||
*/
|
||
static bool_t OtaVerifyFirmwareCrc(void)
|
||
{
|
||
// read back the whole firmware image from flash and calculate CRC
|
||
uint32_t ui32CRC = 0;
|
||
uint32_t ui32_addr = 0;
|
||
uint32_t ui32_length = 0;
|
||
uint32_t blk_start,blk_end,blk_num,index;
|
||
uint16_t read_start_size = 0;
|
||
uint16_t read_end_size = 0;
|
||
uint32_t len_op=0;
|
||
uint32_t i=0;
|
||
// uint32_t ret=0;
|
||
|
||
//
|
||
// Check crc in external flash
|
||
//
|
||
FLASH_OPERATE(g_pFlash, flash_enable);
|
||
|
||
// if(g_otaCtrlBlock.HeaderInfo.fwDataType != MARK_MCU_FW_BIN)
|
||
{
|
||
ui32_addr = g_otaCtrlBlock.newFwFlashInfo.addr + g_otaCtrlBlock.HeaderInfo.secInfoLen;
|
||
ui32_length = g_otaCtrlBlock.HeaderInfo.fwLength - g_otaCtrlBlock.HeaderInfo.secInfoLen;
|
||
}
|
||
|
||
blk_start = ui32_addr/AMOTAS_TEMP_BUFSIZE;
|
||
len_op = ui32_addr%AMOTAS_TEMP_BUFSIZE;
|
||
if(len_op)
|
||
{
|
||
read_start_size = AMOTAS_TEMP_BUFSIZE - len_op;
|
||
if(read_start_size>ui32_length)
|
||
{
|
||
read_start_size = ui32_length;
|
||
}
|
||
}
|
||
else if(ui32_length<AMOTAS_TEMP_BUFSIZE)
|
||
{
|
||
read_start_size = ui32_length;
|
||
}
|
||
|
||
blk_end = (ui32_addr + ui32_length)/AMOTAS_TEMP_BUFSIZE;
|
||
if(blk_end>blk_start)
|
||
{
|
||
read_end_size = (ui32_addr + ui32_length)%AMOTAS_TEMP_BUFSIZE;
|
||
}
|
||
else
|
||
{
|
||
read_end_size = 0;
|
||
}
|
||
blk_num = (ui32_length - read_start_size - read_end_size)/AMOTAS_TEMP_BUFSIZE;
|
||
|
||
index = 0;
|
||
if(read_start_size)
|
||
{
|
||
len_op = read_start_size;
|
||
g_pFlash->flash_read_page((uint32_t)(ui32_addr + index),
|
||
(uint32_t *)otaFlashOp.writeBuffer,
|
||
len_op);
|
||
ui32CRC = crc32_ex(ui32CRC, otaFlashOp.writeBuffer, len_op);
|
||
blk_start++;
|
||
index += len_op;
|
||
}
|
||
|
||
if(blk_num)
|
||
{
|
||
len_op = AMOTAS_TEMP_BUFSIZE;
|
||
for(i=0;i<blk_num;i++)
|
||
{
|
||
g_pFlash->flash_read_page((uint32_t)(ui32_addr + index),
|
||
(uint32_t *)otaFlashOp.writeBuffer,
|
||
len_op);
|
||
ui32CRC = crc32_ex(ui32CRC, otaFlashOp.writeBuffer, len_op);
|
||
blk_start++;
|
||
index += len_op;
|
||
}
|
||
}
|
||
|
||
if(read_end_size)
|
||
{
|
||
len_op = read_end_size;
|
||
g_pFlash->flash_read_page((uint32_t)(ui32_addr + index),
|
||
(uint32_t *)otaFlashOp.writeBuffer,
|
||
len_op);
|
||
ui32CRC = crc32_ex(ui32CRC, otaFlashOp.writeBuffer, len_op);
|
||
blk_start++;
|
||
index += len_op;
|
||
}
|
||
|
||
if(index != ui32_length)
|
||
{
|
||
static_print_remind("error:[OtaVerifyFirmwareCrc()] ui32_addr %d index %d ui32_length %d\r\n",ui32_addr,index,ui32_length);
|
||
}
|
||
|
||
FLASH_OPERATE(g_pFlash, flash_disable);
|
||
static_print_remind("addr = 0x%x,len = %d-%d,ui32CRC = 0x%x,fwCrc = 0x%x\r\n",ui32_addr,ui32_length,index,ui32CRC, g_otaCtrlBlock.HeaderInfo.fwCrc);
|
||
|
||
return (ui32CRC == g_otaCtrlBlock.HeaderInfo.fwCrc);
|
||
}
|
||
|
||
/*!
|
||
* brief: Processing firmware header information.
|
||
*/
|
||
uint32_t ProcessingFwHeader(void)
|
||
{
|
||
uint32_t bResult = FENDA_SUCCESS;
|
||
|
||
g_otaCtrlBlock.HeaderInfo.encrypted = 0;
|
||
if(g_ota_head_struct.sour_addr)
|
||
{
|
||
g_otaCtrlBlock.HeaderInfo.fwStartAddr = g_ota_head_struct.sour_addr;
|
||
}
|
||
else
|
||
{
|
||
g_otaCtrlBlock.HeaderInfo.fwStartAddr = 0x28000;//default
|
||
}
|
||
g_otaCtrlBlock.HeaderInfo.fwLength = g_ota_head_struct.file_size+g_ota_head_param.h_len;
|
||
g_otaCtrlBlock.HeaderInfo.fwCrc = g_ota_head_struct.file_crc32;
|
||
g_otaCtrlBlock.HeaderInfo.secInfoLen = g_ota_head_param.h_len;
|
||
g_otaCtrlBlock.HeaderInfo.storageAddr = g_ota_head_struct.dest_addr;
|
||
g_otaCtrlBlock.HeaderInfo.fwDataType = g_ota_head_param.mark;
|
||
if(g_ota_head_struct.dest_cs && (g_ota_head_struct.dest_cs < FW_SOUR_CS_MAX))
|
||
{
|
||
g_otaCtrlBlock.HeaderInfo.storageType = g_ota_head_struct.dest_cs;//config
|
||
}
|
||
else
|
||
{
|
||
g_otaCtrlBlock.HeaderInfo.storageType = FW_SOUR_CS_FLASH;//default
|
||
}
|
||
|
||
static_print_info("============= fw header start ===============\n");
|
||
static_print_info("encrypted = 0x%x\n", g_otaCtrlBlock.HeaderInfo.encrypted);
|
||
//static_print_info("version = 0x%x\n", g_otaCtrlBlock.HeaderInfo.version);
|
||
static_print_info("fwLength = 0x%x\n", g_otaCtrlBlock.HeaderInfo.fwLength);
|
||
static_print_info("fwCrc = 0x%x\n", g_otaCtrlBlock.HeaderInfo.fwCrc);
|
||
static_print_info("fwStartAddr = 0x%x\n", g_otaCtrlBlock.HeaderInfo.fwStartAddr);
|
||
static_print_info("fwDataType = 0x%x\n", g_otaCtrlBlock.HeaderInfo.fwDataType);
|
||
static_print_info("storageType = 0x%x\n", g_otaCtrlBlock.HeaderInfo.storageType);
|
||
static_print_info("storageAddr = 0x%x\n", g_otaCtrlBlock.HeaderInfo.storageAddr);
|
||
static_print_info("fw_size = 0x%x\n",g_ota_head_struct.file_size);
|
||
static_print_info("============= fw header end ===============\n");
|
||
|
||
otaFlashOp.bufferIndex = 0;
|
||
g_otaCtrlBlock.pkt.offset = 0;
|
||
g_otaCtrlBlock.pkt.FileSize = g_otaCtrlBlock.HeaderInfo.fwLength;
|
||
g_otaCtrlBlock.ota_status = OTA_STATE_FW_DATA;
|
||
g_otaCtrlBlock.newFwFlashInfo.offset = 0;
|
||
|
||
// Initialize the flash operation interface and the new firmware storage address
|
||
if ( g_otaCtrlBlock.HeaderInfo.storageType == FW_SOUR_CS_ROM )
|
||
{
|
||
g_pFlash = &g_intFlash;
|
||
// Check to make sure the incoming image will fit in the space allocated for OTA
|
||
if (g_otaCtrlBlock.HeaderInfo.fwLength < AMOTA_INT_FLASH_OTA_MAX_SIZE)
|
||
{
|
||
g_otaCtrlBlock.newFwFlashInfo.addr = g_otaCtrlBlock.HeaderInfo.storageAddr;
|
||
}
|
||
else
|
||
{
|
||
static_print_info("\n??????not enough space. (len = %d)??????\n",g_otaCtrlBlock.HeaderInfo.fwLength);
|
||
bResult = DATA_PACK_SIZE_ERROR;
|
||
}
|
||
}
|
||
else if ( g_otaCtrlBlock.HeaderInfo.storageType == FW_SOUR_CS_FLASH )
|
||
{
|
||
ota_ext_flash_info_init(&g_ext_flash);
|
||
g_pFlash = &g_ext_flash;
|
||
if (g_pFlash->flash_read_page &&
|
||
g_pFlash->flash_write_page &&
|
||
g_pFlash->flash_erase_sector)
|
||
{
|
||
if(g_otaCtrlBlock.HeaderInfo.fwDataType == MARK_MCU_FW_BIN) // is a run image
|
||
{
|
||
if(g_otaCtrlBlock.HeaderInfo.fwLength > MAX_IMAGE_SIZE)
|
||
{
|
||
bResult = DATA_PACK_SIZE_ERROR;
|
||
}
|
||
}
|
||
g_otaCtrlBlock.newFwFlashInfo.addr = g_otaCtrlBlock.HeaderInfo.storageAddr;
|
||
}
|
||
else
|
||
{
|
||
bResult = DEVICE_FORBIT_OTA_ERROR;
|
||
}
|
||
}
|
||
|
||
return bResult;
|
||
}
|
||
|
||
/*!
|
||
* brief: Check whether breakpoint continuation is required.
|
||
*/
|
||
bool_t IfBreakPointValid(void)
|
||
{
|
||
uint32_t BreakPointPtrVal = 0;
|
||
|
||
BreakPointPtrVal = *((uint32_t *)USER_OTA_BREAK_POINT_ADDR);
|
||
static_print_remind("BreakPointPtrVal = %x\n", BreakPointPtrVal);
|
||
if((BreakPointPtrVal != 0xFFFFFFFF) && (BreakPointPtrVal != 0))
|
||
{
|
||
memcpy(&g_otaBreakPoint, (FwBreakPointInfo_t *)USER_OTA_BREAK_POINT_ADDR, sizeof(FwBreakPointInfo_t));
|
||
static_print_remind("g_otaBreakPoint.fileSize = %x,g_otaBreakPoint.fileCrc32 = %x\n",
|
||
g_otaBreakPoint.fileSize, g_otaBreakPoint.fileCrc32);
|
||
if(g_otaBreakPoint.ifResume &&
|
||
g_otaBreakPoint.fileSize == g_otaCtrlBlock.HeaderInfo.fwLength &&
|
||
g_otaBreakPoint.fileCrc32 == g_otaCtrlBlock.HeaderInfo.fwCrc)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
memset(&g_otaBreakPoint, 0, sizeof(g_otaBreakPoint));
|
||
OtaUpdateBreakPoint();
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/*!
|
||
* brief: New FW packet handler, for OTA service call
|
||
*/
|
||
uint32_t OtaPacketHandler(uint16_t len, uint8_t *buf)
|
||
{
|
||
uint32_t error_code = FENDA_SUCCESS;
|
||
int ret;
|
||
|
||
switch(g_otaCtrlBlock.ota_status)
|
||
{
|
||
case OTA_STATE_FW_HEADER:
|
||
ret = user_pack_json_head((char *)buf,&g_ota_head_param,&g_ota_head_struct);
|
||
static_print_info("OtaPacketHandler h_len %d = %d - %d - %d - %d- %d\n ",len,g_ota_head_param.h_len,g_ota_head_param.pack_len,g_ota_head_param.ext_offset,g_ota_head_param.struct_len,g_ota_head_param.struct_offset);
|
||
if(ret)
|
||
{
|
||
static_print_info("g_ota_head_struct %d = %d - %x - %x - %x -%x \n",
|
||
g_ota_head_struct.sour_addr,g_ota_head_struct.dest_addr,g_ota_head_struct.file_version[0],g_ota_head_struct.file_version[1],g_ota_head_struct.file_version[2],g_ota_head_struct.file_version[3]);
|
||
#if 1
|
||
//task_ui_notify(UI_MSG_DISPLAY_OPEN, 0, NULL, 0);
|
||
task_ui_notify(EVENT_OTA_TRANS_START, 0, NULL, 0);
|
||
// GoToResouceOTAScreen();
|
||
|
||
error_code = ProcessingFwHeader();
|
||
if(error_code != FENDA_SUCCESS)
|
||
{
|
||
static_print_info("\n ????? DEVICE_FW_OTA_ERROR=%d ????? \n",error_code);
|
||
return error_code;
|
||
}
|
||
|
||
if(IfBreakPointValid())
|
||
{
|
||
static_print_info("read fileOffset from BreakPointInfo = %x\r\n",g_otaBreakPoint.fileOffset);
|
||
g_otaCtrlBlock.pkt.offset = g_otaBreakPoint.fileOffset;
|
||
g_otaCtrlBlock.newFwFlashInfo.offset = g_otaBreakPoint.fileOffset;
|
||
}
|
||
else
|
||
{
|
||
//保存包头 saimen add
|
||
error_code = OtaWrite2Flash(len, buf, g_otaCtrlBlock.newFwFlashInfo.addr + g_otaCtrlBlock.newFwFlashInfo.offset,
|
||
((g_otaCtrlBlock.newFwFlashInfo.offset + len) == g_otaCtrlBlock.HeaderInfo.fwLength));
|
||
if (error_code != FENDA_SUCCESS)
|
||
{
|
||
static_print_info("\n ?????OTA FLASH WRITE ERROR ????? \n");
|
||
return error_code;
|
||
}
|
||
else
|
||
{
|
||
g_otaCtrlBlock.pkt.offset += len;//更新申请数据的地址
|
||
g_otaCtrlBlock.newFwFlashInfo.offset += len;
|
||
}
|
||
}
|
||
|
||
// Length of application firmware
|
||
g_otaCtrlBlock.pkt.ApplyLen = g_otaCtrlBlock.pkt.FileSize - g_otaCtrlBlock.pkt.offset;
|
||
g_otaCtrlBlock.pkt.ApplyLen = g_otaCtrlBlock.pkt.ApplyLen > APPLY_FW_DATA_LEN ? APPLY_FW_DATA_LEN:g_otaCtrlBlock.pkt.ApplyLen;
|
||
/* 因断点续传信息获取，第一包数据在此处申请 */
|
||
DeviceRequestOTAFileData(g_otaCtrlBlock.pkt.offset, g_otaCtrlBlock.pkt.ApplyLen,
|
||
g_otaCtrlBlock.pkt.FileSize, g_otaCtrlBlock.pkt.offset);
|
||
#endif
|
||
}
|
||
break;
|
||
|
||
case OTA_STATE_FW_DATA:
|
||
//static_print_info("ota write2flash len %x addr %x\n",len,
|
||
// g_otaCtrlBlock.newFwFlashInfo.addr + g_otaCtrlBlock.newFwFlashInfo.offset);
|
||
error_code = OtaWrite2Flash(len, buf, g_otaCtrlBlock.newFwFlashInfo.addr + g_otaCtrlBlock.newFwFlashInfo.offset,
|
||
((g_otaCtrlBlock.newFwFlashInfo.offset + len) == g_otaCtrlBlock.HeaderInfo.fwLength));
|
||
if (error_code != FENDA_SUCCESS)
|
||
{
|
||
static_print_info("\n ?????OTA FLASH WRITE ERROR ????? \n");
|
||
return error_code;
|
||
}
|
||
else
|
||
{
|
||
g_otaCtrlBlock.pkt.offset += len;//更新申请数据的地址
|
||
g_otaCtrlBlock.newFwFlashInfo.offset += len;
|
||
}
|
||
if(g_otaCtrlBlock.pkt.offset >= g_otaCtrlBlock.pkt.FileSize)
|
||
{// get the last pkg
|
||
static_print_info("ReceivedSuccess. pkt.offset = %x,\r\n", g_otaCtrlBlock.pkt.offset);
|
||
|
||
g_otaCtrlBlock.crc_verify = OtaVerifyFirmwareCrc();
|
||
g_otaCtrlBlock.ota_status = OTA_STATE_FW_RESET;
|
||
return error_code;
|
||
}
|
||
// Length of application firmware
|
||
g_otaCtrlBlock.pkt.ApplyLen = (g_otaCtrlBlock.pkt.FileSize) - g_otaCtrlBlock.pkt.offset;
|
||
g_otaCtrlBlock.pkt.ApplyLen = g_otaCtrlBlock.pkt.ApplyLen > APPLY_FW_DATA_LEN ? APPLY_FW_DATA_LEN : g_otaCtrlBlock.pkt.ApplyLen;
|
||
|
||
task_ui_notify(EVENT_OTA_TRANSMITTING, (g_otaCtrlBlock.pkt.offset * 100) / g_otaCtrlBlock.pkt.FileSize, NULL, 0);
|
||
|
||
break;
|
||
|
||
case OTA_STATE_FW_VERIFY:
|
||
break;
|
||
|
||
case OTA_STATE_FW_RESET:
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return error_code;
|
||
}
|
||
|
||
/*!
|
||
* updata user boot --saimen
|
||
*/
|
||
void ota_user_boot (void)
|
||
{
|
||
uint32_t ui32_crc;
|
||
uint8_t rw_boot_times = 3;
|
||
static uint32_t boot_run_addr = 0x00018000;
|
||
uint32_t r_boot_addr = 0;
|
||
uint32_t w_boot_addr = 0;
|
||
uint32_t rw_boot_len = 0;
|
||
uint32_t op_len = 0;
|
||
uint8_t *p_boot_data = otaFlashOp.writeBuffer;
|
||
|
||
if(g_otaCtrlBlock.HeaderInfo.fwStartAddr == boot_run_addr && g_otaCtrlBlock.HeaderInfo.storageType == FW_SOUR_CS_FLASH)//user boot addr
|
||
{
|
||
while(rw_boot_times--)
|
||
{
|
||
r_boot_addr = g_otaCtrlBlock.HeaderInfo.storageAddr + g_otaCtrlBlock.HeaderInfo.secInfoLen;
|
||
w_boot_addr = boot_run_addr;
|
||
ui32_crc = 0;
|
||
for(rw_boot_len = g_otaCtrlBlock.HeaderInfo.secInfoLen;rw_boot_len<g_otaCtrlBlock.HeaderInfo.fwLength;)
|
||
{
|
||
op_len = ((g_otaCtrlBlock.HeaderInfo.fwLength - rw_boot_len) > MCU_ROM_PAGE_SIZE)? MCU_ROM_PAGE_SIZE:(g_otaCtrlBlock.HeaderInfo.fwLength - rw_boot_len);
|
||
g_pFlash->flash_read_page(r_boot_addr, (uint32_t *)p_boot_data, op_len);
|
||
rom_api_erase(w_boot_addr);
|
||
rom_api_write(w_boot_addr, p_boot_data, op_len);
|
||
r_boot_addr += op_len;
|
||
w_boot_addr += op_len;
|
||
rw_boot_len += op_len;
|
||
static_print_remind("r_boot_addr=0x%x,w_boot_addr=0x%x,op_len=0x%x\n",r_boot_addr,w_boot_addr,op_len);
|
||
}
|
||
ui32_crc = crc32_ex(ui32_crc, (uint8_t *)boot_run_addr, g_otaCtrlBlock.HeaderInfo.fwLength - g_otaCtrlBlock.HeaderInfo.secInfoLen);
|
||
if(ui32_crc == g_otaCtrlBlock.HeaderInfo.fwCrc)
|
||
{
|
||
break;
|
||
}
|
||
static_print_remind("error:obj_crc=0x%x,temp_crc=0x%x\n",g_otaCtrlBlock.HeaderInfo.fwCrc,ui32_crc);
|
||
}
|
||
}
|
||
}
|
||
/*!
|
||
* brief: Update Flag Page with Firmware Information, for OTA service call.
|
||
*/
|
||
void OtaUpdateFwInfo(void)
|
||
{
|
||
uint32_t ui32CRC = 0;
|
||
uint32_t otaPtrPageAddr = (USER_BOOTLOADER_MBR_ADDR & ~(AM_HAL_FLASH_PAGE_SIZE - 1));
|
||
|
||
g_boot_mbr_info.carry_fw_flag = 0x10;
|
||
g_boot_mbr_info.formal.fw_sour_addr = (g_otaCtrlBlock.newFwFlashInfo.addr + g_otaCtrlBlock.HeaderInfo.secInfoLen);
|
||
g_boot_mbr_info.formal.fw_dest_addr = g_otaCtrlBlock.HeaderInfo.fwStartAddr;
|
||
g_boot_mbr_info.formal.fw_sour_cs = g_otaCtrlBlock.HeaderInfo.storageType;
|
||
g_boot_mbr_info.formal.fw_dest_cs = FW_SOUR_CS_ROM;
|
||
//g_boot_mbr_info.formal.fw_reserve1 = ;
|
||
g_boot_mbr_info.formal.fw_bytes = g_otaCtrlBlock.HeaderInfo.fwLength -g_otaCtrlBlock.HeaderInfo.secInfoLen;
|
||
g_boot_mbr_info.formal.fw_crc32 = g_otaCtrlBlock.HeaderInfo.fwCrc;
|
||
|
||
ui32CRC = 0;
|
||
ui32CRC = crc32_ex(ui32CRC, (uint8_t *)&g_boot_mbr_info, sizeof(g_boot_mbr_info) - 4);
|
||
g_boot_mbr_info.crc32 = ui32CRC;
|
||
|
||
static_print_remind("*****************************************************\n");
|
||
static_print_remind("OtaUpdateFwInfo()\n");
|
||
static_print_remind("carry_fw_flag=0x%x\n", g_boot_mbr_info.carry_fw_flag);
|
||
static_print_remind("fw_sour_addr=0x%x\n", g_boot_mbr_info.formal.fw_sour_addr);
|
||
static_print_remind("fw_dest_addr=0x%x\n", g_boot_mbr_info.formal.fw_dest_addr);
|
||
static_print_remind("fw_sour_cs=0x%x\n", g_boot_mbr_info.formal.fw_sour_cs);
|
||
static_print_remind("fw_dest_cs=0x%x\n", g_boot_mbr_info.formal.fw_dest_cs);
|
||
static_print_remind("fw_reserve1=0x%x\n", g_boot_mbr_info.formal.fw_reserve1);
|
||
static_print_remind("fw_bytes=0x%x\n", g_boot_mbr_info.formal.fw_bytes);
|
||
static_print_remind("fw_crc32=0x%x\n", g_boot_mbr_info.formal.fw_crc32);
|
||
static_print_remind("MBR CRC=0x%x\n",g_boot_mbr_info.crc32);
|
||
static_print_remind("*****************************************************\n");
|
||
|
||
|
||
// Copy the OTA descriptor
|
||
memcpy(otaFlashOp.writeBuffer, &g_boot_mbr_info, sizeof(g_boot_mbr_info));
|
||
|
||
// Write the flash Page
|
||
if(g_otaCtrlBlock.HeaderInfo.fwStartAddr < 0x28000)
|
||
{
|
||
//saimen add
|
||
static_print_remind("warning:boot ota addr=0x%x--size=%d--crc=0x%x\n",
|
||
g_otaCtrlBlock.HeaderInfo.fwStartAddr,g_otaCtrlBlock.HeaderInfo.fwLength,g_otaCtrlBlock.HeaderInfo.fwCrc);
|
||
ota_user_boot();
|
||
}
|
||
else
|
||
{
|
||
am_bootloader_program_flash_page(otaPtrPageAddr, (uint32_t *)otaFlashOp.writeBuffer, AMOTAS_TEMP_BUFSIZE);
|
||
}
|
||
}
|
||
|
||
/*!
|
||
* brief: Update Flag Page with Break Point Information .
|
||
*/
|
||
void OtaUpdateBreakPoint(void)
|
||
{
|
||
uint32_t BreakPointPtrPageAddr = (USER_OTA_BREAK_POINT_ADDR & ~(AM_HAL_FLASH_PAGE_SIZE - 1));
|
||
uint32_t otaPtrOffset = USER_OTA_BREAK_POINT_ADDR - BreakPointPtrPageAddr;
|
||
|
||
memcpy(otaFlashOp.writeBuffer, (uint8_t *)BreakPointPtrPageAddr, AM_HAL_FLASH_PAGE_SIZE);
|
||
static_print_remind("addr = %x, off = %x\r\n", BreakPointPtrPageAddr, otaPtrOffset);
|
||
|
||
memcpy(&otaFlashOp.writeBuffer[otaPtrOffset], (uint8_t *)&g_otaBreakPoint, sizeof(g_otaBreakPoint));
|
||
|
||
am_bootloader_program_flash_page(BreakPointPtrPageAddr, (uint32_t *)otaFlashOp.writeBuffer, AM_HAL_FLASH_PAGE_SIZE);
|
||
}
|
||
|
||
|