rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/services/nv_section/userdata_section/nvrecord_extension.c

1092 lines
34 KiB
C
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#ifdef NEW_NV_RECORD_ENABLED
#include <stdbool.h>
#include <string.h>
#include <assert.h>
#include "cmsis.h"
#include "nvrecord_extension.h"
#include "hal_trace.h"
#include "crc32.h"
#include "hal_sleep.h"
#include "hal_norflash.h"
#include "norflash_api.h"
#include "norflash_drv.h"
#include "nvrecord_bt.h"
#include "nvrecord_env.h"
#include "nvrecord_ble.h"
#include "nvrecord_dma_config.h"
#include "nvrecord_fp_account_key.h"
#include "customparam_section.h"
#include "mpu.h"
#include "besbt.h"
#include "hal_timer.h"
extern uint32_t __userdata_start[];
extern uint32_t __userdata_end[];
extern void nvrecord_rebuild_system_env(struct nvrecord_env_t* pSystemEnv);
extern void nvrecord_rebuild_paired_bt_dev_info(NV_RECORD_PAIRED_BT_DEV_INFO_T* pPairedBtInfo);
#ifdef GFPS_ENABLED
extern void nvrecord_rebuild_fp_account_key(NV_FP_ACCOUNT_KEY_RECORD_T* pFpAccountKey);
#endif
#ifdef NVREC_BAIDU_DATA_SECTION
extern void nvrecord_rebuild_dma_configuration(NV_DMA_CONFIGURATION_T* pDmaConfig);
#endif
typedef enum
{
NV_STATE_IDLE,
NV_STATE_MAIN_ERASING,
NV_STATE_MAIN_ERASED,
NV_STATE_MAIN_WRITTING,
NV_STATE_MAIN_WRITTEN,
NV_STATE_MAIN_DONE,
NV_STATE_BAK_ERASING,
NV_STATE_BAK_ERASED,
NV_STATE_BAK_WRITTING,
NV_STATE_BAK_WRITTEN,
NV_STATE_BAK_DONE,
}NV_STATE;
typedef struct
{
bool is_update;
NV_STATE state;
uint32_t written_size;
}NV_FLUSH_STATE;
static NV_FLUSH_STATE nv_flsh_state;
static bool nvrec_init = false;
static uint32_t _user_data_main_start;
static uint32_t _user_data_bak_start;
static uint8_t _nv_burn_buf[NV_EXTENSION_PAGE_SIZE];
NV_EXTENSION_RECORD_T *nvrecord_extension_p = NULL;
/*
*Note: the NV_EXTENSION_MIRROR_RAM_SIZE must be power of 2
*/
#if defined(__ARM_ARCH_8M_MAIN__)
#define __NV_BUF_MPU_ALIGNED __ALIGNED(0x20)
#else
/*
* armv7 mpu require the address must be aligned to the section size and
* the section size must be algined to power of 2
*/
#define __NV_BUF_MPU_ALIGNED __ALIGNED(NV_EXTENSION_MIRROR_RAM_SIZE)
#endif
static NV_MIRROR_BUF_T local_extension_data __NV_BUF_MPU_ALIGNED
__attribute__((section(".sram_data"))) =
{
.nv_record = {
{ // header
NV_EXTENSION_MAGIC_NUMBER,
NV_EXTENSION_MAJOR_VERSION,
NV_EXTENSION_MINOR_VERSION,
NV_EXTENSION_VALID_LEN,
0,
},
{ // system info
},
{ // bt_pair_info
0
},
{ // ble_pair_info
},
#ifdef TWS_SYSTEM_ENABLED
{ // tws_info
},
#endif
#ifdef GFPS_ENABLED
{ // fp_account_key_rec
0
},
#endif
#ifdef NVREC_BAIDU_DATA_SECTION
{ // dma_config
BAIDU_DATA_DEF_FM_FREQ,
},
#endif
#ifdef TILE_DATAPATH
{
{0}
},
#endif
#ifdef OTA_ENABLED
{
{0,},
},
#endif
#if defined(BISTO_ENABLED)
{
true,
},
#endif
#if 1//def TX_IQ_CAL
{
BT_IQ_INVALID_MAGIC_NUM,
{0},
{0},
},
#endif
// TODO:
// If want to extend the nvrecord while keeping the history information,
// append the new items to the tail of NV_EXTENSION_RECORD_T and
// set their intial content here
},
};
STATIC_ASSERT(sizeof(local_extension_data) <= NV_EXTENSION_MIRROR_RAM_SIZE, "NV local buffer too small");
static int nv_record_extension_flush(bool is_async);
#ifdef TILE_DATAPATH
static void nvrecord_rebuild_tileconfig(NV_TILE_INFO_CONFIG_T *tileConfig)
{
memset((uint8_t*)tileConfig,0,sizeof(NV_TILE_INFO_CONFIG_T));
}
#endif
#ifdef OTA_ENABLED
static void nvrecord_rebuild_ota_info(NV_OTA_INFO_T *ota_info)
{
memset((uint8_t *)ota_info, 0, OTA_DEVICE_CNT * sizeof(NV_OTA_INFO_T));
}
#endif
#if defined(BISTO_ENABLED)
static void nvrecord_rebuild_gsound_info(NV_GSOUND_INFO_T *gsound_info)
{
memset((uint8_t*)gsound_info,0,sizeof(NV_GSOUND_INFO_T));
}
#endif
#if 1//def TX_IQ_CAL
static void nvrecord_rebuild_btiqcalconfig(BT_IQ_CALIBRATION_CONFIG_T *btIqCalConfig)
{
memset((uint8_t*)btIqCalConfig,0,sizeof(BT_IQ_CALIBRATION_CONFIG_T));
btIqCalConfig->validityMagicNum = BT_IQ_INVALID_MAGIC_NUM;
}
#endif
static bool nv_record_data_is_valid(NV_EXTENSION_RECORD_T *nv_record)
{
bool is_valid = false;
NVRECORD_HEADER_T* pExtRecInFlash = &nv_record->header;
uint8_t* pData = (uint8_t*)nv_record + NV_EXTENSION_HEADER_SIZE;
TRACE(0,"nv ext magic 0x%x valid len %d", pExtRecInFlash->magicNumber,
pExtRecInFlash->validLen);
if ((NV_EXTENSION_MAJOR_VERSION == pExtRecInFlash->majorVersion) &&
(NV_EXTENSION_MAGIC_NUMBER == pExtRecInFlash->magicNumber))
{
// check whether the data length is valid
if (pExtRecInFlash->validLen <= NV_EXTENSION_SIZE-NV_EXTENSION_HEADER_SIZE)
{
// check crc32
uint32_t crc = crc32(0, pData, pExtRecInFlash->validLen);
TRACE(1,"generated crc32: 0x%x, header crc: 0x%x",
crc, pExtRecInFlash->crc32);
if (crc == pExtRecInFlash->crc32)
{
// correct
TRACE(2,"Nv extension is valid.");
TRACE(2,"Former nv ext valid len %d", pExtRecInFlash->validLen);
TRACE(2,"Current FW version nv ext valid len %d", NV_EXTENSION_VALID_LEN);
if (NV_EXTENSION_VALID_LEN < pExtRecInFlash->validLen)
{
TRACE(0,"Valid length of extension must be increased,"
"use the default value.");
}
else
{
if(NV_EXTENSION_VALID_LEN > pExtRecInFlash->validLen)
{
TRACE(2, "NV extension is extended! (0x%x) -> (0x%x)",
pExtRecInFlash->validLen,NV_EXTENSION_VALID_LEN);
}
is_valid = true;
}
}
}
}
return is_valid;
}
static bool nv_record_items_is_valid(NV_EXTENSION_RECORD_T *nv_record)
{
nv_record = nv_record;
#if 0
NV_RECORD_PAIRED_BT_DEV_INFO_T *pbt_pair_info;
pbt_pair_info = &nv_record->bt_pair_info;
TRACE(1,"%s: pairedDevNum: %d ", __func__,pbt_pair_info->pairedDevNum);
for(uint8_t i = 0; i < pbt_pair_info->pairedDevNum; i++)
{
DUMP8("0x%x,", (uint8_t*)pbt_pair_info->pairedBtDevInfo[i].record.bdAddr.address,6);
}
#endif
// TODO: add cheking for nv_record items.
return true;
}
static void nv_record_set_default(NV_EXTENSION_RECORD_T *nv_record)
{
memset((uint8_t*)nv_record, 0 ,sizeof(NV_EXTENSION_RECORD_T));
nvrecord_rebuild_system_env(&(nv_record->system_info));
nvrecord_rebuild_paired_bt_dev_info(&(nv_record->bt_pair_info));
nvrecord_rebuild_paired_ble_dev_info(&(nv_record->ble_pair_info));
#ifdef GFPS_ENABLED
nvrecord_rebuild_fp_account_key(&(nv_record->fp_account_key_rec));
#endif
#ifdef NVREC_BAIDU_DATA_SECTION
nvrecord_rebuild_dma_configuration(&(nv_record->dma_config));
#endif
#ifdef TILE_DATAPATH
nvrecord_rebuild_tileconfig(&nv_record->tileConfig);
#endif
#if defined(BISTO_ENABLED)
nvrecord_rebuild_gsound_info(&nv_record->gsound_info);
#endif
#ifdef OTA_ENABLED
nvrecord_rebuild_ota_info((NV_OTA_INFO_T *)&nv_record->ota_info);
#endif
#if 1//def TX_IQ_CAL
nvrecord_rebuild_btiqcalconfig(&nv_record->btIqCalConfig);
#endif
nv_record->header.magicNumber = NV_EXTENSION_MAGIC_NUMBER;
nv_record->header.majorVersion = NV_EXTENSION_MAJOR_VERSION;
nv_record->header.minorVersion = NV_EXTENSION_MINOR_VERSION;
nv_record->header.validLen = NV_EXTENSION_VALID_LEN;
nv_record->header.crc32 =
crc32(0, ((uint8_t *)nv_record + NV_EXTENSION_HEADER_SIZE),
NV_EXTENSION_VALID_LEN);
}
static void _nv_record_extension_init(void)
{
enum NORFLASH_API_RET_T result;
uint32_t sector_size = 0;
uint32_t block_size = 0;
uint32_t page_size = 0;
hal_norflash_get_size(HAL_NORFLASH_ID_0,
NULL,
&block_size,
&sector_size,
&page_size);
result = norflash_api_register(NORFLASH_API_MODULE_ID_USERDATA_EXT,
HAL_NORFLASH_ID_0,
((uint32_t)__userdata_start),
((uint32_t)__userdata_end - (uint32_t)__userdata_start),
block_size,
sector_size,
page_size,
NV_EXTENSION_SIZE*2,
nv_extension_callback
);
ASSERT(result == NORFLASH_API_OK,"_nv_record_extension_init: module register failed! result = %d.",result);
}
uint32_t nv_record_pre_write_operation(void)
{
uint32_t lock = int_lock_global();
mpu_clear(MPU_ID_USER_DATA_SECTION);
return lock;
}
void nv_record_post_write_operation(uint32_t lock)
{
int ret = 0;
uint32_t nv_start = (uint32_t)&local_extension_data.nv_record;
uint32_t len = NV_EXTENSION_MIRROR_RAM_SIZE;
ret = mpu_set(MPU_ID_USER_DATA_SECTION, nv_start, len, 0, MPU_ATTR_READ);
int_unlock_global(lock);
TRACE(2,"set mpu 0x%x len %d result %d", nv_start, len, ret);
}
static void nv_record_extension_init(void)
{
uint32_t lock;
bool main_is_valid = false;
bool bak_is_valid = false;
bool data_is_valid = false;
if(nvrec_init)
{
return;
}
_user_data_main_start = (uint32_t)__userdata_start;
_user_data_bak_start = (uint32_t)__userdata_start + NV_EXTENSION_SIZE;
lock = nv_record_pre_write_operation();
_nv_record_extension_init();
nv_flsh_state.is_update = false;
nv_flsh_state.written_size = 0;
nv_flsh_state.state = NV_STATE_IDLE;
nvrecord_extension_p = &local_extension_data.nv_record;
if(nvrecord_extension_p->header.magicNumber != NV_EXTENSION_MAGIC_NUMBER ||
nvrecord_extension_p->header.majorVersion != NV_EXTENSION_MAJOR_VERSION ||
nvrecord_extension_p->header.minorVersion != NV_EXTENSION_MINOR_VERSION ||
nvrecord_extension_p->header.validLen >= (NV_EXTENSION_SIZE - NV_EXTENSION_HEADER_SIZE))
{
ASSERT(0, "%s: local_extension_data error!(0x%x,0x%x,0x%x,0x%x)",
__func__,
nvrecord_extension_p->header.magicNumber,
nvrecord_extension_p->header.majorVersion,
nvrecord_extension_p->header.minorVersion,
nvrecord_extension_p->header.validLen);
}
// Check main sector.
if(nv_record_data_is_valid((NV_EXTENSION_RECORD_T*)_user_data_main_start)
&& nv_record_items_is_valid((NV_EXTENSION_RECORD_T*)_user_data_main_start))
{
TRACE(2,"%s,main sector is valid.",__func__);
main_is_valid = true;
}
else
{
TRACE(1,"%s,main sector is invalid!",__func__);
main_is_valid = false;
}
// Check bak secotr.
if(nv_record_data_is_valid((NV_EXTENSION_RECORD_T*)_user_data_bak_start)
&& nv_record_items_is_valid((NV_EXTENSION_RECORD_T*)_user_data_main_start))
{
TRACE(2,"%s,bak sector is valid.",__func__);
bak_is_valid = true;
}
else
{
TRACE(1,"%s,bak sector is invalid!",__func__);
bak_is_valid = false;
}
if(main_is_valid)
{
data_is_valid = true;
if(!bak_is_valid)
{
nv_flsh_state.is_update = true;
nv_flsh_state.state = NV_STATE_MAIN_DONE;
}
}
else
{
if(bak_is_valid)
{
data_is_valid = true;
nv_flsh_state.is_update = true;
nv_flsh_state.state = NV_STATE_IDLE;
}
else
{
data_is_valid = false;
}
}
if(data_is_valid)
{
TRACE(2,"%s,data is valid.", __func__);
if(main_is_valid)
{
memcpy((uint8_t *)nvrecord_extension_p + NV_EXTENSION_HEADER_SIZE,
(uint8_t *)_user_data_main_start + NV_EXTENSION_HEADER_SIZE,
NV_EXTENSION_VALID_LEN);
}
else
{
memcpy((uint8_t *)nvrecord_extension_p + NV_EXTENSION_HEADER_SIZE,
(uint8_t *)_user_data_bak_start + NV_EXTENSION_HEADER_SIZE,
NV_EXTENSION_VALID_LEN);
}
nvrecord_extension_p->header.crc32 =
crc32(0,
((uint8_t *)nvrecord_extension_p + NV_EXTENSION_HEADER_SIZE),
nvrecord_extension_p->header.validLen);
}
else
{
TRACE(1,"%s,data invalid, rebuild... ",__func__);
nv_record_set_default(nvrecord_extension_p);
TRACE(2,"%s,rebuild crc = 0x%x. ",__func__,nvrecord_extension_p->header.crc32);
// need to update the content in the flash
nv_record_extension_update();
}
nvrec_init = true;
nv_record_post_write_operation(lock);
if(nv_flsh_state.is_update)
{
nv_record_extension_flush(false);
}
TRACE(2,"%s,done.", __func__);
}
NV_EXTENSION_RECORD_T* nv_record_get_extension_entry_ptr(void)
{
return nvrecord_extension_p;
}
void nv_record_extension_update(void)
{
nv_flsh_state.is_update = true;
}
static int nv_record_extension_flush_main(bool is_async)
{
uint32_t crc;
uint32_t lock;
enum NORFLASH_API_RET_T ret = NORFLASH_API_OK;
if(NULL == nvrecord_extension_p)
{
TRACE(1,"%s,nvrecord_extension_p is null.", __func__);
goto _func_end;
}
// TRACE(3, "%s is_async %d state %d", __func__, is_async, nv_flsh_state.state);
if(is_async)
{
if(nv_flsh_state.state == NV_STATE_IDLE
&& nv_flsh_state.is_update == true)
{
TRACE(3,"%s: async flush begin!", __func__);
}
hal_trace_pause();
lock = int_lock_global();
if(nv_flsh_state.state == NV_STATE_IDLE
|| nv_flsh_state.state == NV_STATE_MAIN_ERASING)
{
if(nv_flsh_state.state == NV_STATE_IDLE)
{
nv_flsh_state.state = NV_STATE_MAIN_ERASING;
TRACE(4,"%s: NV_STATE_MAIN_ERASING", __func__);
}
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA_EXT,
(uint32_t)(__userdata_start),
NV_EXTENSION_SIZE,
true);
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.state = NV_STATE_MAIN_ERASED;
TRACE(4,"%s: NV_STATE_MAIN_ERASED", __func__);
TRACE(4,"%s: norflash_api_erase ok,addr = 0x%x.",__func__,_user_data_main_start);
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
norflash_api_flush();
}
else
{
ASSERT(0,"%s: norflash_api_erase err,ret = %d,addr = 0x%x.",__func__,ret,_user_data_main_start);
}
}
else if(nv_flsh_state.state == NV_STATE_MAIN_ERASED
|| nv_flsh_state.state == NV_STATE_MAIN_WRITTING)
{
if(nv_flsh_state.state == NV_STATE_MAIN_ERASED)
{
nv_flsh_state.state = NV_STATE_MAIN_WRITTING;
TRACE(4,"%s: NV_STATE_MAIN_WRITTING", __func__);
}
uint32_t tmpLock = nv_record_pre_write_operation();
crc = crc32(0,(uint8_t *)nvrecord_extension_p + NV_EXTENSION_HEADER_SIZE,
NV_EXTENSION_VALID_LEN);
nvrecord_extension_p->header.crc32 = crc;
ASSERT(nv_record_data_is_valid(nvrecord_extension_p)
&& nv_record_items_is_valid(nvrecord_extension_p),
"%s nv_record is invalid!",__func__);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA_EXT,
(uint32_t)(__userdata_start),
(uint8_t *)nvrecord_extension_p,
NV_EXTENSION_SIZE,
true);
nv_record_post_write_operation(tmpLock);
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.is_update = false;
nv_flsh_state.state = NV_STATE_MAIN_WRITTEN;
TRACE(4,"%s: NV_STATE_MAIN_WRITTEN", __func__);
TRACE(4,"%s: norflash_api_write ok,addr = 0x%x.",__func__,_user_data_main_start);
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
norflash_api_flush();
}
else
{
ASSERT(0,"%s: norflash_api_write err,ret = %d,addr = 0x%x.",__func__,ret,_user_data_main_start);
}
}
else
{
if(norflash_api_get_used_buffer_count(NORFLASH_API_MODULE_ID_USERDATA_EXT,NORFLASH_API_ALL) == 0)
{
nv_flsh_state.state = NV_STATE_MAIN_DONE;
// TRACE(1,"%s: NV_STATE_MAIN_DONE", __func__);
TRACE(1,"%s: async flush done.", __func__);
}
else
{
norflash_api_flush();
}
}
int_unlock_global(lock);
hal_trace_continue();
}
else
{
TRACE(4,"%s: sync flush begin!", __func__);
if(nv_flsh_state.state == NV_STATE_IDLE
|| nv_flsh_state.state == NV_STATE_MAIN_ERASING)
{
do
{
hal_trace_pause();
lock = int_lock_global();
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA_EXT,
(uint32_t)(__userdata_start),
NV_EXTENSION_SIZE,
true);
int_unlock_global(lock);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.state = NV_STATE_MAIN_ERASED;
TRACE(4,"%s: norflash_api_erase ok,addr = 0x%x.",__func__, _user_data_main_start);
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
do
{
norflash_api_flush();
}while(norflash_api_get_free_buffer_count(NORFLASH_API_ERASING) == 0);
}
else
{
ASSERT(0,"%s: norflash_api_erase err,ret = %d,addr = 0x%x.",__func__,ret,_user_data_main_start);
}
}while(ret == NORFLASH_API_BUFFER_FULL);
}
if(nv_flsh_state.state == NV_STATE_MAIN_ERASED
|| nv_flsh_state.state == NV_STATE_MAIN_WRITTING)
{
do
{
hal_trace_pause();
uint32_t tmpLock = nv_record_pre_write_operation();
crc = crc32(0,(uint8_t *)nvrecord_extension_p + NV_EXTENSION_HEADER_SIZE,
NV_EXTENSION_VALID_LEN);
nvrecord_extension_p->header.crc32 = crc;
ASSERT(nv_record_data_is_valid(nvrecord_extension_p)
&& nv_record_items_is_valid(nvrecord_extension_p),
"%s nv_record is invalid!",__func__);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA_EXT,
(uint32_t)(__userdata_start),
(uint8_t *)nvrecord_extension_p,
NV_EXTENSION_SIZE,
true);
nv_record_post_write_operation(tmpLock);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.is_update = false;
nv_flsh_state.state = NV_STATE_MAIN_WRITTEN;
TRACE(4,"%s: norflash_api_write ok,addr = 0x%x.",__func__,_user_data_main_start);
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
do
{
norflash_api_flush();
}while(norflash_api_get_free_buffer_count(NORFLASH_API_WRITTING) == 0);
}
else
{
ASSERT(0,"%s: norflash_api_write err,ret = %d,addr = 0x%x.",__func__,ret,_user_data_main_start);
}
}while(ret == NORFLASH_API_BUFFER_FULL);
}
do
{
norflash_api_flush();
}while(norflash_api_get_used_buffer_count(NORFLASH_API_MODULE_ID_USERDATA_EXT,NORFLASH_API_ALL) > 0);
nv_flsh_state.state = NV_STATE_MAIN_DONE;
TRACE(1,"%s: sync flush done.", __func__);
}
_func_end:
return (ret == NORFLASH_API_OK) ? 0:1;
}
static int nv_record_extension_flush_bak(bool is_async)
{
uint32_t lock;
enum NORFLASH_API_RET_T ret = NORFLASH_API_OK;
uint8_t *burn_buf = (uint8_t*)_nv_burn_buf;
if(is_async)
{
hal_trace_pause();
lock = int_lock_global();
if(nv_flsh_state.state == NV_STATE_MAIN_DONE
|| nv_flsh_state.state == NV_STATE_BAK_ERASING)
{
if(nv_flsh_state.state == NV_STATE_MAIN_DONE)
{
nv_flsh_state.state = NV_STATE_BAK_ERASING;
TRACE(3,"%s: async flush begin", __func__);
}
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA_EXT,
_user_data_bak_start,
NV_EXTENSION_SIZE,
true);
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.state = NV_STATE_BAK_ERASED;
TRACE(4,"%s: norflash_api_erase ok,addr = 0x%x.",
__func__,_user_data_bak_start);
// TRACE(4,"%s: NV_STATE_BAK_ERASED", __func__);
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
norflash_api_flush();
}
else
{
ASSERT(0,"%s: norflash_api_erase err,ret = %d,addr = 0x%x.",
__func__,ret,_user_data_bak_start);
}
}
else if(nv_flsh_state.state == NV_STATE_BAK_ERASED
|| nv_flsh_state.state == NV_STATE_BAK_WRITTING)
{
if(nv_flsh_state.state == NV_STATE_BAK_ERASED)
{
nv_flsh_state.state = NV_STATE_BAK_WRITTING;
nv_flsh_state.written_size = 0;
// TRACE(4,"%s: NV_STATE_BAK_WRITTING", __func__);
}
do
{
ret = norflash_api_read(NORFLASH_API_MODULE_ID_USERDATA_EXT,
_user_data_main_start + nv_flsh_state.written_size,
burn_buf,
NV_EXTENSION_PAGE_SIZE
);
ASSERT(ret == NORFLASH_API_OK,"norflash_api_read failed! ret = %d, addr = 0x%x.",
(int32_t)ret,_user_data_main_start + nv_flsh_state.written_size);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA_EXT,
_user_data_bak_start + nv_flsh_state.written_size,
burn_buf,
NV_EXTENSION_PAGE_SIZE,
true
);
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.written_size += NV_EXTENSION_PAGE_SIZE;
if(nv_flsh_state.written_size == NV_EXTENSION_SIZE)
{
nv_flsh_state.state = NV_STATE_BAK_WRITTEN;
// TRACE(4,"%s: NV_STATE_BAK_WRITTEN", __func__);
break;
}
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
norflash_api_flush();
break;
}
else
{
ASSERT(0,"%s: norflash_api_write err,ret = %d,addr = 0x%x.",
__func__,ret,_user_data_bak_start + nv_flsh_state.written_size);
}
}while(1);
}
else
{
if(norflash_api_get_used_buffer_count(NORFLASH_API_MODULE_ID_USERDATA_EXT,NORFLASH_API_ALL) == 0)
{
nv_flsh_state.state = NV_STATE_BAK_DONE;
TRACE(3,"%s: async flush done.", __func__);
}
else
{
norflash_api_flush();
}
}
int_unlock_global(lock);
hal_trace_continue();
}
else
{
TRACE(4,"%s: sync flush begin.", __func__);
if(nv_flsh_state.state == NV_STATE_MAIN_DONE
|| nv_flsh_state.state == NV_STATE_BAK_ERASING)
{
do
{
hal_trace_pause();
lock = int_lock_global();
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA_EXT,
_user_data_bak_start,
NV_EXTENSION_SIZE,
true);
int_unlock_global(lock);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.state = NV_STATE_BAK_ERASED;
TRACE(4,"%s: norflash_api_erase ok,addr = 0x%x.",
__func__, _user_data_bak_start);
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
do
{
norflash_api_flush();
}while(norflash_api_get_free_buffer_count(NORFLASH_API_ERASING) == 0);
}
else
{
ASSERT(0,"%s: norflash_api_erase err,ret = %d,addr = 0x%x.",__func__,ret,_user_data_bak_start);
}
}while(ret == NORFLASH_API_BUFFER_FULL);
}
if(nv_flsh_state.state == NV_STATE_BAK_ERASED
|| nv_flsh_state.state == NV_STATE_BAK_WRITTING)
{
nv_flsh_state.state = NV_STATE_BAK_WRITTING;
nv_flsh_state.written_size = 0;
hal_trace_pause();
do
{
lock = int_lock_global();
ret = norflash_api_read(NORFLASH_API_MODULE_ID_USERDATA_EXT,
_user_data_main_start + nv_flsh_state.written_size,
burn_buf,
NV_EXTENSION_PAGE_SIZE
);
ASSERT(ret == NORFLASH_API_OK,"norflash_api_read failed! ret = %d, addr = 0x%x.",
(int32_t)ret, _user_data_main_start + nv_flsh_state.written_size);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA_EXT,
_user_data_bak_start + nv_flsh_state.written_size,
burn_buf,
NV_EXTENSION_PAGE_SIZE,
true
);
int_unlock_global(lock);
if(ret == NORFLASH_API_OK)
{
nv_flsh_state.written_size += NV_EXTENSION_PAGE_SIZE;
if(nv_flsh_state.written_size == NV_EXTENSION_SIZE)
{
nv_flsh_state.state = NV_STATE_BAK_WRITTEN;
TRACE(3,"%s: NV_STATE_BAK_WRITTEN", __func__);
break;
}
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
do
{
norflash_api_flush();
}while(norflash_api_get_free_buffer_count(NORFLASH_API_WRITTING) == 0);
}
else
{
ASSERT(0,"%s: norflash_api_write err,ret = %d,addr = 0x%x.",
__func__,ret,_user_data_bak_start + nv_flsh_state.written_size);
}
}while(1);
}
hal_trace_continue();
// nv_flsh_state.state == NV_STATE_BAK_WRITTEN;
do
{
norflash_api_flush();
}while(norflash_api_get_used_buffer_count(NORFLASH_API_MODULE_ID_USERDATA_EXT,NORFLASH_API_ALL) > 0);
nv_flsh_state.state = NV_STATE_BAK_DONE;
TRACE(1,"%s: sync flush done.", __func__);
}
if(nv_flsh_state.state == NV_STATE_BAK_DONE)
{
nv_flsh_state.state = NV_STATE_IDLE;
TRACE(1,"%s: NV_STATE_IDLE", __func__);
}
return (ret == NORFLASH_API_OK) ? 0:1;
}
static int nv_record_extension_flush(bool is_async)
{
int ret = 0;
// TRACE(3, "%s state %d is_update %d", __func__, nv_flsh_state.state, nv_flsh_state.is_update);
do{
if(nv_flsh_state.state == NV_STATE_IDLE
&& nv_flsh_state.is_update == FALSE)
{
break;
}
if((nv_flsh_state.state == NV_STATE_IDLE
&& nv_flsh_state.is_update == TRUE)
|| nv_flsh_state.state == NV_STATE_MAIN_ERASING
|| nv_flsh_state.state == NV_STATE_MAIN_ERASED
|| nv_flsh_state.state == NV_STATE_MAIN_WRITTING
|| nv_flsh_state.state == NV_STATE_MAIN_WRITTEN
)
{
ret = nv_record_extension_flush_main(is_async);
if(is_async)
{
break;
}
}
if(nv_flsh_state.state == NV_STATE_MAIN_DONE
|| nv_flsh_state.state == NV_STATE_BAK_ERASING
|| nv_flsh_state.state == NV_STATE_BAK_ERASED
|| nv_flsh_state.state == NV_STATE_BAK_WRITTING
|| nv_flsh_state.state == NV_STATE_BAK_WRITTEN
|| nv_flsh_state.state == NV_STATE_BAK_DONE
)
{
ret = nv_record_extension_flush_bak(is_async);
}
}while(!is_async);
return ret;
}
void nv_extension_callback(void* param)
{
NORFLASH_API_OPERA_RESULT *opera_result;
opera_result = (NORFLASH_API_OPERA_RESULT*)param;
TRACE(6,"%s:type = %d, addr = 0x%x,len = 0x%x,remain = %d,result = %d.",
__func__,
opera_result->type,
opera_result->addr,
opera_result->len,
opera_result->remain_num,
opera_result->result);
}
void nv_record_init(void)
{
nv_record_open(section_usrdata_ddbrecord);
nv_custom_parameter_section_init();
}
bt_status_t nv_record_open(SECTIONS_ADP_ENUM section_id)
{
nv_record_extension_init();
#ifdef FLASH_SUSPEND
hal_sleep_set_sleep_hook(HAL_SLEEP_HOOK_USER_NVRECORD,
nv_record_flash_flush_in_sleep);
#else
hal_sleep_set_deep_sleep_hook(HAL_DEEP_SLEEP_HOOK_USER_NVRECORD,
nv_record_flash_flush_in_sleep);
#endif
return BT_STS_SUCCESS;
}
void nv_record_update_runtime_userdata(void)
{
nv_record_extension_update();
}
int nv_record_touch_cause_flush(void)
{
nv_record_update_runtime_userdata();
return 0;
}
void nv_record_sector_clear(void)
{
uint32_t lock;
enum NORFLASH_API_RET_T ret;
lock = int_lock_global();
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA_EXT,
(uint32_t)__userdata_start,
NV_EXTENSION_SIZE,
false);
ASSERT(ret == NORFLASH_API_OK,
"%s: norflash_api_erase(0x%x) failed! ret = %d.",
__func__, (uint32_t)__userdata_start, (int32_t)ret);
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA_EXT,
(uint32_t)__userdata_start + NV_EXTENSION_SIZE,
NV_EXTENSION_SIZE,
false);
ASSERT(ret == NORFLASH_API_OK,
"%s: norflash_api_erase(0x%x) failed! ret = %d.",
__func__, (uint32_t)__userdata_start + NV_EXTENSION_SIZE, (int32_t)ret);
//pmu_reboot();
int_unlock_global(lock);
}
void nv_record_rebuild(void)
{
if(nvrecord_extension_p)
{
uint32_t nv_start;
TRACE(1,"%s: begin.", __func__);
uint32_t lock = int_lock_global();
mpu_clear(MPU_ID_USER_DATA_SECTION);
nv_record_set_default(nvrecord_extension_p);
nv_start = (uint32_t)&local_extension_data.nv_record;
mpu_set(MPU_ID_USER_DATA_SECTION, nv_start,
NV_EXTENSION_MIRROR_RAM_SIZE, 0, MPU_ATTR_READ);
nv_record_extension_update();
nv_record_flash_flush();
int_unlock_global(lock);
TRACE(1,"%s: done.", __func__);
}
else
{
TRACE(1,"%s: begin. nvrecord_extension_p = null.", __func__);
uint32_t lock = int_lock_global();
nv_record_sector_clear();
nvrec_init = false;
nv_record_extension_init();
int_unlock_global(lock);
TRACE(1,"%s: done.", __func__);
}
}
#define NV_RECORD_FLUSH_EXECUTION_INTERVAL_MS (20*60*1000)
static uint32_t lastFlushCheckPointInMs = 0;
static void nv_record_reset_flush_checkpoint(void)
{
lastFlushCheckPointInMs = GET_CURRENT_MS();;
}
static bool nv_record_is_timer_expired_to_check(void)
{
uint32_t passedTimerMs;
uint32_t currentTimerMs = GET_CURRENT_MS();
if (0 == lastFlushCheckPointInMs)
{
passedTimerMs = currentTimerMs;
}
else
{
if (currentTimerMs > lastFlushCheckPointInMs)
{
passedTimerMs = currentTimerMs - lastFlushCheckPointInMs;
}
else
{
passedTimerMs = 0xFFFFFFFF - lastFlushCheckPointInMs + currentTimerMs + 1;
}
}
if (passedTimerMs > NV_RECORD_FLUSH_EXECUTION_INTERVAL_MS)
{
return true;
}
else
{
return false;
}
}
void nv_record_flash_flush(void)
{
nv_record_extension_flush(false);
nv_record_reset_flush_checkpoint();
}
void nv_record_execute_async_flush(void)
{
int ret = nv_record_extension_flush(true);
if (0 == ret)
{
nv_record_reset_flush_checkpoint();
}
}
int nv_record_flash_flush_in_sleep(void)
{
if ((NV_STATE_IDLE == nv_flsh_state.state) &&
!nv_record_is_timer_expired_to_check())
{
return 0;
}
nv_record_execute_async_flush();
return 0;
}
#endif // #if defined(NEW_NV_RECORD_ENABLED)
Reference in New Issue View Git Blame Copy Permalink