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

2014 lines
67 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.
*
****************************************************************************/
#include <assert.h>
#include "hal_sleep.h"
#include "besbt.h"
#include "nvrecord.h"
#include "nvrecord_dev.h"
#include "nvrecord_env.h"
#include "crc32.h"
#include "hal_timer.h"
#include "hal_norflash.h"
#include "pmu.h"
#include "tgt_hardware.h"
#include "norflash_api.h"
//#define NVREC_BURN_TEST
#define OS_DUMP8(x...)
// factory section region
#define NVRECORD_CACHE_2_UNCACHE(addr) \
((unsigned char *)((unsigned int)addr & ~(0x04000000)))
static bool dev_sector_valid = false;
uint8_t nv_record_dev_rev = NVREC_DEV_NEWEST_REV;
#define CLASSIC_BTNAME_LEN (BLE_NAME_LEN_IN_NV-5)
char classics_bt_name[CLASSIC_BTNAME_LEN]= "BES";
extern uint32_t __factory_start[];
/*
dev_version_and_magic, //0
dev_crc, // 1
dev_reserv1, // 2
dev_reserv2, //3// 3
dev_name, //[4~66]
dev_bt_addr = 67, //[67~68]
dev_ble_addr = 69, //[69~70]
dev_dongle_addr = 71,
dev_xtal_fcap = 73, //73
dev_data_len = 74,
dev_ble_name = 75, //[75~82]
*/
#if !defined(NEW_NV_RECORD_ENABLED)
#ifdef __ARMCC_VERSION
#define USERDATA_POOL_LOC __attribute__((section(".bss.userdata_pool")))
#else
#define USERDATA_POOL_LOC __attribute__((section(".userdata_pool")))
#endif
//#define LINK_KEY_ENCRYPT
#ifdef LINK_KEY_ENCRYPT
#include "aes.h"
#define LINK_KEY_ENCRYPT_KEY "\x11\x07\x9e\x34\x9B\x5F\x80\x00\x00\x80\x00\x10\x00\x00\x00\x01"
#endif
extern uint32_t __userdata_start[];
extern uint32_t __userdata_end[];
extern int nv_record_flash_flush_in_sleep(void);
static int nv_record_flash_flush_int(bool is_async);
void nv_callback(void* param);
nv_record_struct nv_record_config;
static bool nvrec_init = false;
static bool nvrec_mempool_init = false;
static uint32_t _user_data_main_start;
static uint32_t _user_data_bak_start;
static uint32_t USERDATA_POOL_LOC usrdata_ddblist_pool[1024];
static void nv_record_print_dev_record(const btif_device_record_t* record)
{
#ifdef nv_record_debug
nvrec_trace(0,"nv record bdAddr = ");
DUMP8("%02x ",record->bdAddr.address,sizeof(record->bdAddr.address));
nvrec_trace(0,"record_trusted = ");
DUMP8("%d ",&record->trusted,sizeof((uint8_t)record->trusted));
nvrec_trace(0,"record_linkKey = ");
DUMP8("%02x ",record->linkKey,sizeof(record->linkKey));
nvrec_trace(0,"record_keyType = ");
DUMP8("%x ",&record->keyType,sizeof(record->keyType));
nvrec_trace(0,"record_pinLen = ");
DUMP8("%x ",&record->pinLen,sizeof(record->pinLen));
#endif
}
heap_handle_t g_nv_mempool = NULL;
static void nv_record_mempool_init(void)
{
unsigned char *poolstart = 0;
poolstart = (unsigned char *)(usrdata_ddblist_pool+mempool_pre_offset);
if(!nvrec_mempool_init)
{
g_nv_mempool = heap_register((unsigned char*)poolstart, (size_t)(sizeof(usrdata_ddblist_pool)-(mempool_pre_offset*sizeof(uint32_t))));
nvrec_mempool_init = TRUE;
}
/*add other memory pool */
}
static bool nv_record_data_is_valid(void)
{
uint32_t crc;
uint32_t flsh_crc;
uint32_t verandmagic;
verandmagic = usrdata_ddblist_pool[0];
if(((nvrecord_struct_version<<16)|nvrecord_magic) != verandmagic)
{
nvrec_trace(2,"%s: verandmagic error! verandmagic = 0x%x.",__func__,((nvrecord_struct_version<<16)|nvrecord_magic));
return false;
}
crc = crc32(0,(uint8_t *)(&usrdata_ddblist_pool[pos_heap_contents]),(sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t))));
flsh_crc = usrdata_ddblist_pool[pos_crc];
if (flsh_crc == crc)
{
return true;
}
else
{
nvrec_trace(3,"%s: crc checking fail! flsh_crc = 0x%x,crc = 0x%x.",__func__,flsh_crc,crc);
return false;
}
}
static bool nv_record_list_is_valid(void)
{
nvrec_config_t *config = NULL;
nvrec_section_t *sec = NULL;
list_node_t *node = NULL;
list_node_t *sub_node = NULL;
nvrec_entry_t *entry = NULL;
bool ret = true;
uint32_t mem_start;
uint32_t mem_end;
config = (nvrec_config_t *)usrdata_ddblist_pool[pos_config_addr];
if(usrdata_ddblist_pool[pos_start_ram_addr] != (uint32_t)usrdata_ddblist_pool)
{
return false;
}
mem_start = (uint32_t)config;
mem_end = mem_start + (sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t)));
for (node = list_begin_ext(config->sections); node != list_end_ext(config->sections); node = list_next_ext(node))
{
sec = list_node_ext(node);
for (sub_node = list_begin_ext(sec->entries); sub_node != list_end_ext(sec->entries); sub_node = list_next_ext(sub_node))
{
entry = list_node_ext(sub_node);
if(entry->key == NULL || entry->value == NULL)
{
ret = false;
break;
}
if(((uint32_t)entry->key >= mem_start && (uint32_t)entry->key + strlen(entry->key) < mem_end)
&& ((uint32_t)entry->value >= mem_start && (uint32_t)entry->value + strlen(entry->value) < mem_end))
{
// nvrec_trace(4,"%s: entry = 0x%x,key = 0x%x, value = 0x%x.",
// __func__,(uint32_t)entry,(uint32_t)entry->key,(uint32_t)entry->value);
}
else
{
nvrec_trace(4,"%s: sec = 0x%x,name = %s, entries = 0x%x.",
__func__,(uint32_t)sec,sec->name,(uint32_t)sec->entries);
nvrec_trace(4,"%s: entry pointer error! entry = 0x%x,key = 0x%x, value = 0x%x.",
__func__,(uint32_t)entry,(uint32_t)entry->key,(uint32_t)entry->value);
ret = false;
break;
}
}
if(!ret)
{
break;
}
}
return ret;
}
void nv_record_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,
HAL_NORFLASH_ID_0,
((uint32_t)__userdata_start),
(uint32_t)__userdata_end - (uint32_t)__userdata_start,
block_size,
sector_size,
page_size,
sizeof(usrdata_ddblist_pool)*2,
nv_callback
);
ASSERT(result == NORFLASH_API_OK,"nv_record_init: module register failed! result = %d.",result);
}
bt_status_t nv_record_open(SECTIONS_ADP_ENUM section_id)
{
bt_status_t ret_status = BT_STS_FAILED;
uint32_t lock;
bool main_is_valid = false;
bool bak_is_valid = false;
bool data_is_valid = false;
if(nvrec_init)
{
return BT_STS_SUCCESS;
}
_user_data_main_start = (uint32_t)__userdata_start;
_user_data_bak_start = (uint32_t)__userdata_start + nvrecord_mem_pool_size;
lock = int_lock_global();
nv_record_config.is_update = false;
nv_record_config.written_size = 0;
nv_record_config.state = NV_STATE_IDLE;
switch(section_id)
{
case section_usrdata_ddbrecord:
// userdata main sector checking.
memcpy((void *)usrdata_ddblist_pool,(void *)_user_data_main_start,
sizeof(usrdata_ddblist_pool));
if( nv_record_data_is_valid()
&& usrdata_ddblist_pool[pos_start_ram_addr]==(uint32_t)usrdata_ddblist_pool)
{
if(nv_record_list_is_valid())
{
// nvrec_trace(1,"%s,main sector list valid.",__func__);
main_is_valid = true;
}
else
{
nvrec_trace(1,"%s,main sector list invalid.",__func__);
main_is_valid = false;
}
}
else
{
nvrec_trace(1,"%s,main sector data invalid.",__func__);
main_is_valid = false;
}
// userdata bak sector checking.
memcpy((void *)usrdata_ddblist_pool,(void *)_user_data_bak_start,
sizeof(usrdata_ddblist_pool));
if( nv_record_data_is_valid()
&& usrdata_ddblist_pool[pos_start_ram_addr]==(uint32_t)usrdata_ddblist_pool)
{
if(nv_record_list_is_valid())
{
// TRACE(1,"%s,bak sector list valid.",__func__);
bak_is_valid = true;
}
else
{
nvrec_trace(1,"%s,bak sector list invalid.",__func__);
bak_is_valid = false;
}
}
else
{
nvrec_trace(1,"%s,bak sector data invalid.",__func__);
bak_is_valid = false;
}
if(main_is_valid)
{
memcpy((void *)usrdata_ddblist_pool,(void *)_user_data_main_start,
sizeof(usrdata_ddblist_pool));
data_is_valid = true;
if(!bak_is_valid)
{
nv_record_config.is_update = true;
nv_record_config.state = NV_STATE_MAIN_DONE;
nv_record_config.config = (nvrec_config_t *)usrdata_ddblist_pool[pos_config_addr];
nv_record_flash_flush_int(false);
}
}
else
{
if(bak_is_valid)
{
memcpy((void *)usrdata_ddblist_pool,(void *)_user_data_bak_start,
sizeof(usrdata_ddblist_pool));
nv_record_config.config = (nvrec_config_t *)usrdata_ddblist_pool[pos_config_addr];
data_is_valid = true;
nv_record_config.is_update = true;
nv_record_config.state = NV_STATE_IDLE;
nv_record_flash_flush_int(false);
}
else
{
data_is_valid = false;
}
}
if(data_is_valid)
{
nv_record_config.config = (nvrec_config_t *)usrdata_ddblist_pool[pos_config_addr];
// nvrec_trace(4,"%s,config=0x%x,g_nv_mempool=0x%x,ln=%d\n",
// nvrecord_tag,usrdata_ddblist_pool[pos_config_addr],g_nv_mempool,__LINE__);
g_nv_mempool = (heap_handle_t)(&usrdata_ddblist_pool[mempool_pre_offset]);
ret_status = BT_STS_SUCCESS;
}
else
{
nvrec_trace(1,"%s,userdata invalid. ",__func__);
ret_status = nv_record_config_rebuild();
if(ret_status != BT_STS_SUCCESS)
{
break;
}
ret_status = BT_STS_SUCCESS;
}
break;
default:
break;
}
nvrec_init = true;
if (ret_status == BT_STS_SUCCESS)
{
#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
}
int_unlock_global(lock);
nvrec_trace(2,"%s,open,ret_status=%d\n",nvrecord_tag,ret_status);
return ret_status;
}
bt_status_t nv_record_config_rebuild(void)
{
nvrec_mempool_init = false;
memset(usrdata_ddblist_pool,0,sizeof(usrdata_ddblist_pool));
usrdata_ddblist_pool[pos_version_and_magic] = ((nvrecord_struct_version<<16)|nvrecord_magic);
nv_record_mempool_init();
nv_record_config.config = nvrec_config_new("PRECIOUS 4K.");
if(nv_record_config.config == NULL)
return BT_STS_FAILED;
nvrec_init = true;
nv_record_config.is_update = true;
return BT_STS_SUCCESS;
}
static size_t config_entries_get_ddbrec_length(const char *secname)
{
size_t entries_len = 0;
if(NULL != nv_record_config.config)
{
nvrec_section_t *sec = NULL;
sec = nvrec_section_find(nv_record_config.config,secname);
if (NULL != sec)
entries_len = sec->entries->length;
}
return entries_len;
}
#if 0
static bool config_entries_has_ddbrec(const btif_device_record_t* param_rec)
{
char key[BD_ADDR_SIZE+1] = {0,};
assert(param_rec != NULL);
memcpy(key,param_rec->bdAddr.address,BTIF_BD_ADDR_SIZE);
if(nvrec_config_has_key(nv_record_config.config,section_name_ddbrec,(const char *)key))
return true;
return false;
}
#endif
static void config_entries_ddbdev_delete_head(void)//delete the oldest record.
{
list_node_t *head_node = NULL;
list_t *entry = NULL;
nvrec_section_t *sec = NULL;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
entry = sec->entries;
head_node = list_begin_ext(entry);
if(NULL != head_node)
{
btif_device_record_t *rec = NULL;
unsigned int recaddr = 0;
nvrec_entry_t *entry_temp = list_node_ext(head_node);
recaddr = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,entry_temp->key,0);
rec = (btif_device_record_t *)recaddr;
pool_free(rec);
nvrec_entry_free(entry_temp);
if(1 == config_entries_get_ddbrec_length(section_name_ddbrec))
entry->head = entry->tail = NULL;
else
entry->head = list_next_ext(head_node);
pool_free(head_node);
entry->length -= 1;
}
}
static void config_entries_ddbdev_delete_tail(void)
{
list_node_t *node = NULL;
list_node_t *temp_ptr = NULL;
list_node_t *tailnode = NULL;
size_t entrieslen = 0;
nvrec_entry_t *entry_temp = NULL;
nvrec_section_t *sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
btif_device_record_t *recaddr = NULL;
unsigned int addr = 0;
if (!sec)
assert(0);
sec->entries->length -= 1;
entrieslen = sec->entries->length;
node = list_begin_ext(sec->entries);
while(entrieslen > 1)
{
node = list_next_ext(node);
entrieslen--;
}
tailnode = list_next_ext(node);
entry_temp = list_node_ext(tailnode);
addr = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,entry_temp->key,0);
recaddr = (btif_device_record_t *)addr;
pool_free(recaddr);
nvrec_entry_free(entry_temp);
//pool_free(entry_temp);
temp_ptr = node->next;
node->next = NULL;
pool_free(temp_ptr);
sec->entries->tail = node;
}
static void config_entries_ddbdev_delete(const btif_device_record_t* param_rec)
{
nvrec_section_t *sec = NULL;
list_node_t *entry_del = NULL;
list_node_t *entry_pre = NULL;
list_node_t *entry_next = NULL;
list_node_t *node = NULL;
btif_device_record_t *recaddr = NULL;
unsigned int addr = 0;
int pos = 0,pos_pre=0;
nvrec_entry_t *entry_temp = NULL;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
for(node=list_begin_ext(sec->entries);node!=NULL;node=list_next_ext(node))
{
nvrec_entry_t *entries = list_node_ext(node);
pos++;
if(0 == memcmp(entries->key,param_rec->bdAddr.address,BTIF_BD_ADDR_SIZE))
{
entry_del = node;
entry_next = entry_del->next;
break;
}
}
if (entry_del){
/*get entry_del pre node*/
pos_pre = (pos-1);
pos=0;
node=list_begin_ext(sec->entries);
pos++;
while(pos < pos_pre)
{
node=list_next_ext(node);
pos += 1;
}
entry_pre = node;
/*delete entry_del following...*/
entry_temp = list_node_ext(entry_del);
addr = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)entry_temp->key,0);
assert(0!=addr);
recaddr = (btif_device_record_t *)addr;
pool_free(recaddr);
nvrec_entry_free(entry_temp);
//pool_free(entry_temp);
pool_free(entry_pre->next);
entry_pre->next = entry_next;
sec->entries->length -= 1;
}
}
static bool config_entries_ddbdev_is_head(const btif_device_record_t* param_rec)
{
list_node_t *head_node = NULL;
nvrec_section_t *sec = NULL;
list_t *entry = NULL;
nvrec_entry_t *entry_temp = NULL;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
entry = sec->entries;
head_node = list_begin_ext(entry);
entry_temp = list_node_ext(head_node);
if(0 == memcmp(entry_temp->key,param_rec->bdAddr.address,BTIF_BD_ADDR_SIZE))
return true;
return false;
}
static bool config_entries_ddbdev_is_tail(const btif_device_record_t* param_rec)
{
list_node_t *node = NULL;
nvrec_entry_t *entry_temp = NULL;
nvrec_section_t *sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
if (!sec)
assert(0);
for (node = list_begin_ext(sec->entries); node != list_end_ext(sec->entries); node = list_next_ext(node))
{
entry_temp = list_node_ext(node);
}
if(0 == memcmp(entry_temp->key,param_rec->bdAddr.address,BTIF_BD_ADDR_SIZE))
return true;
return false;
}
/*
this function should be surrounded by OS_LockStack and OS_UnlockStack when call.
*/
static void config_specific_entry_value_delete(const btif_device_record_t* param_rec)
{
if(config_entries_ddbdev_is_head(param_rec))
config_entries_ddbdev_delete_head();
else if(config_entries_ddbdev_is_tail(param_rec))
config_entries_ddbdev_delete_tail();
else
config_entries_ddbdev_delete(param_rec);
nv_record_update_runtime_userdata();
}
/**********************************************
gyt add:list head is the odest,list tail is the latest.
this function should be surrounded by OS_LockStack and OS_UnlockStack when call.
**********************************************/
static bt_status_t POSSIBLY_UNUSED nv_record_ddbrec_add(const btif_device_record_t* param_rec)
{
btdevice_volume device_vol;
btdevice_profile device_plf;
char key[BTIF_BD_ADDR_SIZE+1] = {0,};
nvrec_btdevicerecord *nvrec_pool_record = NULL;
bool ddbrec_exist = false;
bool is_flush = true;
int getint;
#ifdef BTIF_DIP_DEVICE
uint16_t vend_id = 0;
uint16_t vend_id_source = 0;
#endif
device_vol.a2dp_vol = NVRAM_ENV_STREAM_VOLUME_A2DP_VOL_DEFAULT;
device_vol.hfp_vol = NVRAM_ENV_STREAM_VOLUME_HFP_VOL_DEFAULT;
device_plf.hfp_act = false;
device_plf.hsp_act = false;
device_plf.a2dp_act = false;
device_plf.a2dp_codectype = 0;
if(NULL == param_rec)
return BT_STS_FAILED;
memcpy(key,param_rec->bdAddr.address,BTIF_BD_ADDR_SIZE);
getint = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)key,0);
if(getint){
ddbrec_exist = true;
nvrec_pool_record = (nvrec_btdevicerecord *)getint;
device_vol.a2dp_vol = nvrec_pool_record->device_vol.a2dp_vol;
device_vol.hfp_vol = nvrec_pool_record->device_vol.hfp_vol;
device_plf.hfp_act = nvrec_pool_record->device_plf.hfp_act;
device_plf.hsp_act = nvrec_pool_record->device_plf.hsp_act;
device_plf.a2dp_act = nvrec_pool_record->device_plf.a2dp_act;
device_plf.a2dp_codectype = nvrec_pool_record->device_plf.a2dp_codectype;
#ifdef BTIF_DIP_DEVICE
vend_id = nvrec_pool_record->vend_id;
vend_id_source = nvrec_pool_record->vend_id_source;
#endif
if( memcmp(&nvrec_pool_record->record.bdAddr, &param_rec->bdAddr,sizeof(nvrec_pool_record->record.bdAddr)) == 0
&& memcmp(nvrec_pool_record->record.linkKey, param_rec->linkKey,sizeof(nvrec_pool_record->record.linkKey)) == 0
&& nvrec_pool_record->record.trusted == param_rec->trusted
&& nvrec_pool_record->record.pinLen == param_rec->pinLen
&& nvrec_pool_record->record.keyType == param_rec->keyType
&& config_entries_ddbdev_is_tail(param_rec)
){
is_flush = false;
}
}
if(is_flush){
if (pool_free_space() < sizeof(nvrec_btdevicerecord))
{
nvrec_trace(1,"%s,free space of nvrec is not enough!",nvrecord_tag);
config_entries_ddbdev_delete_head();
}
nvrec_pool_record = (nvrec_btdevicerecord *)pool_malloc(sizeof(nvrec_btdevicerecord));
if(NULL == nvrec_pool_record){
nvrec_trace(1,"%s,pool_malloc failure.",nvrecord_tag);
return BT_STS_FAILED;
}
nvrec_trace(2,"%s,pool_malloc addr = 0x%x\n",nvrecord_tag,(unsigned int)nvrec_pool_record);
memcpy(nvrec_pool_record,param_rec,sizeof(btif_device_record_t));
#ifdef LINK_KEY_ENCRYPT
U8 linkKey[16];
AES128_ECB_encrypt(param_rec->linkKey, LINK_KEY_ENCRYPT_KEY, linkKey);
memcpy(nvrec_pool_record->record.linkKey, linkKey, 16);
#endif
memcpy(key,param_rec->bdAddr.address,BTIF_BD_ADDR_SIZE);
nvrec_pool_record->device_vol.a2dp_vol = device_vol.a2dp_vol;
nvrec_pool_record->device_vol.hfp_vol = device_vol.hfp_vol;
nvrec_pool_record->device_plf.hfp_act = device_plf.hfp_act;
nvrec_pool_record->device_plf.hsp_act = device_plf.hsp_act;
nvrec_pool_record->device_plf.a2dp_act = device_plf.a2dp_act;
nvrec_pool_record->device_plf.a2dp_codectype = device_plf.a2dp_codectype;
#ifdef BTIF_DIP_DEVICE
nvrec_pool_record->vend_id = vend_id;
nvrec_pool_record->vend_id_source = vend_id_source;
#endif
if (ddbrec_exist){
config_specific_entry_value_delete(param_rec);
}
if(DDB_RECORD_NUM == config_entries_get_ddbrec_length(section_name_ddbrec)) {
nvrec_trace(1,"%s,ddbrec list is full,delete the oldest and add param_rec to list.",nvrecord_tag);
config_entries_ddbdev_delete_head();
}
nvrec_config_set_int(nv_record_config.config,section_name_ddbrec,(char *)key,(int)nvrec_pool_record);
#ifdef nv_record_debug
getint = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)key,0);
nvrec_trace(2,"%s,get pool_malloc addr = 0x%x\n",nvrecord_tag,(unsigned int)getint);
#endif
nv_record_update_runtime_userdata();
}
return BT_STS_SUCCESS;
}
/*
this function should be surrounded by OS_LockStack and OS_UnlockStack when call.
*/
bt_status_t nv_record_add(SECTIONS_ADP_ENUM type,void *record)
{
bt_status_t retstatus = BT_STS_FAILED;
if ((NULL == record) || (section_none == type))
return BT_STS_FAILED;
switch(type)
{
case section_usrdata_ddbrecord:
retstatus = nv_record_ddbrec_add(record);
break;
default:
break;
}
return retstatus;
}
/*
this function should be surrounded by OS_LockStack and OS_UnlockStack when call.
*/
bt_status_t nv_record_ddbrec_find(const bt_bdaddr_t* bd_ddr,btif_device_record_t *record)
{
unsigned int getint = 0;
char key[BTIF_BD_ADDR_SIZE+1] = {0,};
btif_device_record_t *getrecaddr = NULL;
if((NULL == nv_record_config.config) || (NULL == bd_ddr) || (NULL == record))
return BT_STS_FAILED;
memcpy(key,bd_ddr->address,BTIF_BD_ADDR_SIZE);
getint = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)key,0);
if(0 == getint)
return BT_STS_FAILED;
getrecaddr = (btif_device_record_t *)getint;
memcpy(record,(void *)getrecaddr,sizeof(btif_device_record_t));
#ifdef LINK_KEY_ENCRYPT
U8 linkKey[16];
AES128_ECB_decrypt(getrecaddr->linkKey, LINK_KEY_ENCRYPT_KEY, linkKey);
memcpy(record->linkKey, linkKey, 16);
#endif
return BT_STS_SUCCESS;
}
int nv_record_btdevicerecord_find(const bt_bdaddr_t *bd_ddr, nvrec_btdevicerecord **record)
{
unsigned int getint = 0;
char key[BTIF_BD_ADDR_SIZE+1] = {0,};
if((NULL == nv_record_config.config) || (NULL == bd_ddr) || (NULL == record))
return -1;
memcpy(key,bd_ddr->address, BTIF_BD_ADDR_SIZE);
getint = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)key,0);
if(0 == getint)
return -1;
*record = (nvrec_btdevicerecord *)getint;
return 0;
}
void nv_record_btdevicerecord_set_a2dp_vol(nvrec_btdevicerecord* pRecord, int8_t vol)
{
pRecord->device_vol.a2dp_vol = vol;
}
void nv_record_btdevicerecord_set_hfp_vol(nvrec_btdevicerecord* pRecord, int8_t vol)
{
pRecord->device_vol.hfp_vol = vol;
}
void nv_record_btdevicevolume_set_a2dp_vol(btdevice_volume* device_vol, int8_t vol)
{
device_vol->a2dp_vol = vol;
}
void nv_record_btdevicevolume_set_hfp_vol(btdevice_volume* device_vol, int8_t vol)
{
device_vol->hfp_vol = vol;
}
void nv_record_btdevicerecord_set_vend_id_and_source(nvrec_btdevicerecord* pRecord, int16_t vend_id, int16_t vend_id_source)
{
#ifdef BTIF_DIP_DEVICE
if (vend_id != pRecord->vend_id)
{
pRecord->vend_id = vend_id;
pRecord->vend_id_source = vend_id_source;
}
#endif
}
void nv_record_btdevicerecord_set_a2dp_profile_active_state(btdevice_profile* device_plf, bool isActive)
{
device_plf->a2dp_act = isActive;
}
void nv_record_btdevicerecord_set_hfp_profile_active_state(btdevice_profile* device_plf, bool isActive)
{
device_plf->hfp_act = isActive;
}
void nv_record_btdevicerecord_set_hsp_profile_active_state(btdevice_profile* device_plf, bool isActive)
{
device_plf->hsp_act = isActive;
}
void nv_record_btdevicerecord_set_a2dp_profile_codec(btdevice_profile* device_plf, uint8_t a2dpCodec)
{
device_plf->a2dp_codectype = a2dpCodec;
}
uint32_t nv_record_pre_write_operation(void)
{
return 0;
}
void nv_record_post_write_operation(uint32_t lock)
{
}
/*
this function should be surrounded by OS_LockStack and OS_UnlockStack when call.
*/
bt_status_t nv_record_ddbrec_delete(const bt_bdaddr_t *bdaddr)
{
unsigned int getint = 0;
btif_device_record_t *getrecaddr = NULL;
char key[BTIF_BD_ADDR_SIZE+1] = {0,};
memcpy(key,bdaddr->address,BTIF_BD_ADDR_SIZE);
getint = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)key,0);
if(0 == getint)
return BT_STS_FAILED;
//found ddb record,del it and return succeed.
getrecaddr = (btif_device_record_t *)getint;
config_specific_entry_value_delete((const btif_device_record_t *)getrecaddr);
return BT_STS_SUCCESS;
}
/*
this function should be surrounded by OS_LockStack and OS_UnlockStack when call.
*/
bt_status_t nv_record_enum_dev_records(unsigned short index,btif_device_record_t* record)
{
nvrec_section_t *sec = NULL;
list_node_t *node = NULL;
unsigned short pos = 0;
nvrec_entry_t *entry_temp = NULL;
btif_device_record_t *recaddr = NULL;
unsigned int addr = 0;
if((index >= DDB_RECORD_NUM) || (NULL == record) || (NULL == nv_record_config.config))
return BT_STS_FAILED;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
if(NULL == sec)
return BT_STS_INVALID_PARM;
if(NULL == sec->entries)
return BT_STS_INVALID_PARM;
if(0 == sec->entries->length)
return BT_STS_FAILED;
if(index >= sec->entries->length)
return BT_STS_FAILED;
node = list_begin_ext(sec->entries);
while(pos < index)
{
node = list_next_ext(node);
pos++;
}
entry_temp = list_node_ext(node);
addr = nvrec_config_get_int(nv_record_config.config,section_name_ddbrec,(char *)entry_temp->key,0);
if(0 == addr)
return BT_STS_FAILED;
recaddr = (btif_device_record_t *)addr;
memcpy(record,recaddr,sizeof(btif_device_record_t));
#ifdef LINK_KEY_ENCRYPT
U8 linkKey[16];
AES128_ECB_decrypt(recaddr->linkKey, LINK_KEY_ENCRYPT_KEY, linkKey);
memcpy(record->linkKey, linkKey, 16);
#endif
nv_record_print_dev_record(record);
return BT_STS_SUCCESS;
}
/*
return:
-1: enum dev failure.
0: without paired dev.
1: only 1 paired dev,store@record1.
2: get 2 paired dev.notice:record1 is the latest record.
*/
int nv_record_enum_latest_two_paired_dev(btif_device_record_t* record1,btif_device_record_t* record2)
{
bt_status_t getret1 = BT_STS_FAILED;
bt_status_t getret2 = BT_STS_FAILED;
nvrec_section_t *sec = NULL;
size_t entries_len = 0;
list_t *entry = NULL;
if((NULL == record1) || (NULL == record2))
return -1;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
if(NULL == sec)
return 0;
entry = sec->entries;
if(NULL == entry)
return 0;
entries_len = entry->length;
if(0 == entries_len)
return 0;
else if(entries_len < 0)
return -1;
if(1 == entries_len)
{
getret1 = nv_record_enum_dev_records(0,record1);
if(BT_STS_SUCCESS == getret1)
return 1;
return -1;
}
getret1 = nv_record_enum_dev_records(entries_len-1,record1);
getret2 = nv_record_enum_dev_records(entries_len-2,record2);
if((BT_STS_SUCCESS != getret1) || (BT_STS_SUCCESS != getret2))
{
memset(record1,0x0,sizeof(btif_device_record_t));
memset(record2,0x0,sizeof(btif_device_record_t));
return -1;
}
return 2;
}
int nv_record_touch_cause_flush(void)
{
nv_record_update_runtime_userdata();
return 0;
}
void nv_record_all_ddbrec_print(void)
{
list_t *entry = NULL;
int tmp_i = 0;
nvrec_section_t *sec = NULL;
size_t entries_len = 0;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
if(NULL == sec)
return;
entry = sec->entries;
if(NULL == entry)
return;
entries_len = entry->length;
if(0 == entries_len)
{
nvrec_trace(1,"%s: without btdevicerec.",__func__);
return;
}
for(tmp_i=0;tmp_i<entries_len;tmp_i++)
{
btif_device_record_t record;
bt_status_t ret_status;
ret_status = nv_record_enum_dev_records(tmp_i,&record);
if(BT_STS_SUCCESS== ret_status)
nv_record_print_dev_record(&record);
}
}
int nv_record_get_paired_dev_count(void)
{
nvrec_section_t *sec = NULL;
list_t *entry = NULL;
sec = nvrec_section_find(nv_record_config.config,section_name_ddbrec);
if(NULL == sec)
return 0;
entry = sec->entries;
if(NULL == entry)
return 0;
return entry->length;
}
void nv_record_sector_clear(void)
{
uint32_t lock;
enum NORFLASH_API_RET_T ret,ret1;
lock = int_lock_global();
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA,
(uint32_t)__userdata_start,
sizeof(usrdata_ddblist_pool),
false);
ret1 = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA,
(uint32_t)__userdata_start + nvrecord_mem_pool_size,
sizeof(usrdata_ddblist_pool),
false);
nvrec_init = false;
nvrec_mempool_init = false;
int_unlock_global(lock);
ASSERT(ret == NORFLASH_API_OK,"nv_record_sector_clear: erase main sector failed! ret = %d.",ret);
ASSERT(ret1 == NORFLASH_API_OK,"nv_record_sector_clear: erase bak sector failed! ret1 = %d.",ret1);
}
#define DISABLE_NV_RECORD_CRC_CHECK_BEFORE_FLUSH 1
void nv_record_update_runtime_userdata(void)
{
uint32_t lock;
if (NULL == nv_record_config.config)
{
return;
}
lock = int_lock();
nv_record_config.is_update = true;
#if !DISABLE_NV_RECORD_CRC_CHECK_BEFORE_FLUSH
buffer_alloc_ctx* heapctx = memory_buffer_heap_getaddr();
memcpy((void *)(&usrdata_ddblist_pool[pos_heap_contents]),heapctx,sizeof(buffer_alloc_ctx));
uint32_t crc = crc32(0,(uint8_t *)(&usrdata_ddblist_pool[pos_heap_contents]),(sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t))));
usrdata_ddblist_pool[pos_crc] = crc;
#endif
int_unlock(lock);
}
static int nv_record_flash_flush_main(bool is_async)
{
uint32_t crc;
uint32_t lock;
enum NORFLASH_API_RET_T ret = NORFLASH_API_OK;
uint8_t *burn_buf = NULL;
uint32_t verandmagic;
if(NULL == nv_record_config.config)
{
nvrec_trace(1,"%s,nv_record_config.config is null.\n", __func__);
goto _func_end;
}
burn_buf = (uint8_t *)&usrdata_ddblist_pool[0];
verandmagic = usrdata_ddblist_pool[0];
ASSERT((((nvrecord_struct_version<<16)|nvrecord_magic) == verandmagic),
"%s: verandmagic = 0x%08x.", __func__, verandmagic);
if(is_async)
{
hal_trace_pause();
lock = int_lock_global();
if(nv_record_config.state == NV_STATE_IDLE
|| nv_record_config.state == NV_STATE_MAIN_ERASING)
{
if(nv_record_config.state == NV_STATE_IDLE)
{
nv_record_config.state = NV_STATE_MAIN_ERASING;
// nvrec_trace(1,"%s: NV_STATE_MAIN_ERASING", __func__);
}
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_main_start,
sizeof(usrdata_ddblist_pool),
true);
if(ret == NORFLASH_API_OK)
{
nv_record_config.state = NV_STATE_MAIN_ERASED;
// nvrec_trace(1,"%s: NV_STATE_MAIN_ERASED", __func__);
nvrec_trace(2,"%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_record_config.state == NV_STATE_MAIN_ERASED
|| nv_record_config.state == NV_STATE_MAIN_WRITTING)
{
if(nv_record_config.state == NV_STATE_MAIN_ERASED)
{
nv_record_config.state = NV_STATE_MAIN_WRITTING;
// nvrec_trace(1,"%s: NV_STATE_MAIN_WRITTING", __func__);
}
crc = crc32(0,(uint8_t *)(&usrdata_ddblist_pool[pos_heap_contents]),(sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t))));
//nvrec_trace(2,"%s,crc=%x.\n",nvrecord_tag,crc);
usrdata_ddblist_pool[pos_version_and_magic] = ((nvrecord_struct_version<<16)|nvrecord_magic);
usrdata_ddblist_pool[pos_crc] = crc;
usrdata_ddblist_pool[pos_start_ram_addr] = (uint32_t)&usrdata_ddblist_pool;
usrdata_ddblist_pool[pos_reserv2] = 0;
usrdata_ddblist_pool[pos_config_addr] = (uint32_t)nv_record_config.config;
ASSERT(nv_record_list_is_valid(),"%s nv_record_list is invalid!",__func__);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_main_start,
burn_buf,
sizeof(usrdata_ddblist_pool),
true
);
if(ret == NORFLASH_API_OK)
{
nv_record_config.is_update = false;
nv_record_config.state = NV_STATE_MAIN_WRITTEN;
// nvrec_trace(1,"%s: NV_STATE_MAIN_WRITTEN", __func__);
nvrec_trace(2,"%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,NORFLASH_API_ALL) == 0)
{
nv_record_config.state = NV_STATE_MAIN_DONE;
// nvrec_trace(1,"%s: NV_STATE_MAIN_DONE", __func__);
}
else
{
norflash_api_flush();
}
}
int_unlock_global(lock);
hal_trace_continue();
}
else
{
// nvrec_trace(1,"%s: sync flush begin!", __func__);
if(nv_record_config.state == NV_STATE_IDLE
|| nv_record_config.state == NV_STATE_MAIN_ERASING)
{
do
{
hal_trace_pause();
lock = int_lock_global();
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_main_start,
sizeof(usrdata_ddblist_pool),
true);
int_unlock_global(lock);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_record_config.state = NV_STATE_MAIN_ERASED;
nvrec_trace(2,"%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_record_config.state == NV_STATE_MAIN_ERASED)
{
do
{
hal_trace_pause();
lock = int_lock_global();
crc = crc32(0,(uint8_t *)(&usrdata_ddblist_pool[pos_heap_contents]),(sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t))));
//nvrec_trace(2,"%s,crc=%x.\n",nvrecord_tag,crc);
usrdata_ddblist_pool[pos_version_and_magic] = ((nvrecord_struct_version<<16)|nvrecord_magic);
usrdata_ddblist_pool[pos_crc] = crc;
usrdata_ddblist_pool[pos_start_ram_addr] = (uint32_t)&usrdata_ddblist_pool;
usrdata_ddblist_pool[pos_reserv2] = 0;
usrdata_ddblist_pool[pos_config_addr] = (uint32_t)nv_record_config.config;
ASSERT(nv_record_list_is_valid(),"%s nv_record_list is invalid!",__func__);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_main_start,
burn_buf,
sizeof(usrdata_ddblist_pool),
true
);
int_unlock_global(lock);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_record_config.is_update = false;
nv_record_config.state = NV_STATE_MAIN_WRITTEN;
nvrec_trace(2,"%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,NORFLASH_API_ALL) > 0);
nv_record_config.state = NV_STATE_MAIN_DONE;
nvrec_trace(1,"%s: sync flush done.", __func__);
}
#if 0 //#ifdef nv_record_debug
if (ret == NORFLASH_API_OK)
{
uint32_t recrc;
uint32_t crc;
uint8_t* burn_buf;
uint8_t* read_buffer = (uint8_t*)__userdata_start;
burn_buf = (uint8_t *)&usrdata_ddblist_pool[0];
crc = ((uint32_t *)burn_buf)[pos_crc];
recrc = crc32(0,((uint8_t *)read_buffer + sizeof(uint32_t)*pos_heap_contents),(sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t))));
ASSERT(crc == recrc,"%s, 0x%x,recrc=%08x crc=%08x\n",
__func__,_user_data_main_start,recrc,crc);
TRACE(1,"%s crc ok.",__func__);
}
#endif
}
_func_end:
return (ret == NORFLASH_API_OK) ? 0:1;
}
static int nv_record_flash_flush_bak(bool is_async)
{
uint32_t lock;
enum NORFLASH_API_RET_T ret = NORFLASH_API_OK;
uint8_t burn_buf[128];
if(is_async)
{
hal_trace_pause();
lock = int_lock_global();
if(nv_record_config.state == NV_STATE_MAIN_DONE
|| nv_record_config.state == NV_STATE_BAK_ERASING)
{
if(nv_record_config.state == NV_STATE_MAIN_DONE)
{
nv_record_config.state = NV_STATE_BAK_ERASING;
// nvrec_trace(1,"%s: NV_STATE_BAK_ERASING", __func__);
}
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_bak_start,
sizeof(usrdata_ddblist_pool),
true);
if(ret == NORFLASH_API_OK)
{
nv_record_config.state = NV_STATE_BAK_ERASED;
nvrec_trace(2,"%s: norflash_api_erase ok,addr = 0x%x.",
__func__,_user_data_bak_start);
// nvrec_trace(1,"%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_record_config.state == NV_STATE_BAK_ERASED
|| nv_record_config.state == NV_STATE_BAK_WRITTING)
{
if(nv_record_config.state == NV_STATE_BAK_ERASED)
{
nv_record_config.state = NV_STATE_BAK_WRITTING;
nv_record_config.written_size = 0;
// nvrec_trace(1,"%s: NV_STATE_BAK_WRITTING", __func__);
}
do
{
ret = norflash_api_read(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_main_start + nv_record_config.written_size,
burn_buf,
sizeof(burn_buf)
);
ASSERT(ret == NORFLASH_API_OK,"norflash_api_read failed! ret = %d, addr = 0x%x.",
(int32_t)ret,_user_data_main_start + nv_record_config.written_size);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_bak_start + nv_record_config.written_size,
burn_buf,
sizeof(burn_buf),
true
);
if(ret == NORFLASH_API_OK)
{
nv_record_config.written_size += sizeof(burn_buf);
if(nv_record_config.written_size == nvrecord_mem_pool_size)
{
nv_record_config.state = NV_STATE_BAK_WRITTEN;
// nvrec_trace(1,"%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_record_config.written_size);
}
}while(1);
}
else
{
if(norflash_api_get_used_buffer_count(NORFLASH_API_MODULE_ID_USERDATA,NORFLASH_API_ALL) == 0)
{
// nvrec_trace(1,"%s: NV_STATE_BAK_DONE", __func__);
nv_record_config.state = NV_STATE_BAK_DONE;
}
else
{
norflash_api_flush();
}
}
int_unlock_global(lock);
hal_trace_continue();
}
else
{
// nvrec_trace(1,"%s: sync flush begin.", __func__);
if(nv_record_config.state == NV_STATE_MAIN_DONE
|| nv_record_config.state == NV_STATE_BAK_ERASING)
{
do
{
hal_trace_pause();
lock = int_lock_global();
ret = norflash_api_erase(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_bak_start,
sizeof(usrdata_ddblist_pool),
true);
int_unlock_global(lock);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_record_config.state = NV_STATE_BAK_ERASED;
nvrec_trace(2,"%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_record_config.state == NV_STATE_BAK_ERASED)
{
nv_record_config.state = NV_STATE_BAK_WRITTING;
nv_record_config.written_size = 0;
do
{
hal_trace_pause();
do
{
lock = int_lock_global();
ret = norflash_api_read(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_main_start + nv_record_config.written_size,
burn_buf,
sizeof(burn_buf)
);
ASSERT(ret == NORFLASH_API_OK,"norflash_api_read failed! ret = %d, addr = 0x%x.",
(int32_t)ret, _user_data_main_start + nv_record_config.written_size);
ret = norflash_api_write(NORFLASH_API_MODULE_ID_USERDATA,
_user_data_bak_start + nv_record_config.written_size,
burn_buf,
sizeof(burn_buf),
true
);
int_unlock_global(lock);
if(ret == NORFLASH_API_OK)
{
nv_record_config.written_size += sizeof(burn_buf);
if(nv_record_config.written_size == nvrecord_mem_pool_size)
{
nv_record_config.state = NV_STATE_BAK_WRITTEN;
break;
}
}
else if(ret == NORFLASH_API_BUFFER_FULL)
{
nv_record_config.state = NV_STATE_BAK_WRITTING;
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_record_config.written_size);
}
}while(1);
hal_trace_continue();
if(ret == NORFLASH_API_OK)
{
nv_record_config.state = NV_STATE_BAK_WRITTEN;
nvrec_trace(3,"%s: norflash_api_write ok,addr = 0x%x,len = 0x%x.",
__func__,_user_data_bak_start,nv_record_config.written_size);
}
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);
}
}while(ret == NORFLASH_API_BUFFER_FULL);
do
{
norflash_api_flush();
}while(norflash_api_get_used_buffer_count(NORFLASH_API_MODULE_ID_USERDATA,NORFLASH_API_ALL) > 0);
nv_record_config.state = NV_STATE_BAK_DONE;
nvrec_trace(1,"%s: sync flush done.", __func__);
}
}
if(nv_record_config.state == NV_STATE_BAK_DONE)
{
nv_record_config.state = NV_STATE_IDLE;
// nvrec_trace(1,"%s: NV_STATE_IDLE", __func__);
}
return (ret == NORFLASH_API_OK) ? 0:1;
}
static int nv_record_flash_flush_int(bool is_async)
{
int ret = 0;
do{
if((nv_record_config.state == NV_STATE_IDLE
&& nv_record_config.is_update == TRUE)
|| nv_record_config.state == NV_STATE_MAIN_ERASING
|| nv_record_config.state == NV_STATE_MAIN_ERASED
|| nv_record_config.state == NV_STATE_MAIN_WRITTING
|| nv_record_config.state == NV_STATE_MAIN_WRITTEN
)
{
ret = nv_record_flash_flush_main(is_async);
if(is_async)
{
break;
}
}
if(nv_record_config.state == NV_STATE_MAIN_DONE
|| nv_record_config.state == NV_STATE_BAK_ERASING
|| nv_record_config.state == NV_STATE_BAK_ERASED
|| nv_record_config.state == NV_STATE_BAK_WRITTING
|| nv_record_config.state == NV_STATE_BAK_WRITTEN
|| nv_record_config.state == NV_STATE_BAK_DONE
)
{
ret = nv_record_flash_flush_bak(is_async);
}
}while(0);
return ret;
}
void nv_record_flash_flush(void)
{
nv_record_flash_flush_int(false);
}
int nv_record_flash_flush_in_sleep(void)
{
nv_record_flash_flush_int(true);
return 0;
}
void nv_callback(void* param)
{
NORFLASH_API_OPERA_RESULT *opera_result;
//uint8_t *burn_buf;
opera_result = (NORFLASH_API_OPERA_RESULT*)param;
nvrec_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);
#ifdef nv_record_debug
if (opera_result->result == NORFLASH_API_OK){
if(opera_result->remain_num == 0 &&
opera_result->type == NORFLASH_API_WRITTING) {
uint32_t recrc;
uint32_t crc;
uint8_t* read_buffer = (uint8_t*)opera_result->addr;
crc = ((uint32_t *)read_buffer)[pos_crc];
recrc = crc32(0,
((uint8_t *)read_buffer + sizeof(uint32_t)*pos_heap_contents),
(sizeof(usrdata_ddblist_pool)-(pos_heap_contents*sizeof(uint32_t))));
ASSERT(crc == recrc,"%s:addr=0x%x,recrc=0x%x crc=0x%x.",
__func__,opera_result->addr,recrc,crc);
}
}
else{
ASSERT(0,"%s:flash write fail!addr=0x%x,result = %d.",
__func__,opera_result->addr,opera_result->result);
}
#endif
}
#ifdef NVREC_BAIDU_DATA_SECTION
#define BAIDU_DATA_FM_SPEC_VALUE (0xffee)
int nvrec_baidu_data_init(void)
{
int _fmfreq = 0;
if (!nvrec_config_has_section(nv_record_config.config, BAIDU_DATA_SECTIN)) {
nvrec_trace(0,"no baidu section default, new one!");
nvrec_config_set_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_DEF_FM_FREQ);
}
else {
nvrec_trace(1,"has baidu section, fmfreq is %d", nvrec_config_get_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_FM_SPEC_VALUE));
_fmfreq = nvrec_config_get_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_FM_SPEC_VALUE);
if (_fmfreq == BAIDU_DATA_FM_SPEC_VALUE) {
nvrec_trace(1,"fm bas bad value, set to %d", BAIDU_DATA_DEF_FM_FREQ);
nvrec_config_set_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_DEF_FM_FREQ);
_fmfreq = nvrec_config_get_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_FM_SPEC_VALUE);
if (_fmfreq == BAIDU_DATA_FM_SPEC_VALUE) {
nvrec_trace(0,"get fm freq still fail!!!");
ASSERT(0, "nvrecord fail, system down!");
}
}
}
return 0;
}
int nvrec_get_fm_freq(void)
{
int _fmfreq = 0;
_fmfreq = nvrec_config_get_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_FM_SPEC_VALUE);
if (_fmfreq == BAIDU_DATA_FM_SPEC_VALUE) {
nvrec_trace(1,"%s : get fm freq fail, reinit fmfreq data", __func__);
nvrec_baidu_data_init();
}
_fmfreq = nvrec_config_get_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, BAIDU_DATA_FM_SPEC_VALUE);
if (_fmfreq == BAIDU_DATA_FM_SPEC_VALUE) {
nvrec_trace(1,"%s : get fm freq still fail", __func__);
ASSERT(0, "%s : nvrecord fail, system down!", __func__);
}
nvrec_trace(2,"%s:get fm freq %d", __func__, _fmfreq);
return _fmfreq;
}
int nvrec_set_fm_freq(int fmfreq)
{
int t = hal_sys_timer_get();
nvrec_trace(2,"%s:fmfreq %d", __func__, fmfreq);
nvrec_config_set_int(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_FM_KEY, fmfreq);
nvrec_trace(2,"%s: use %d ms", __func__, TICKS_TO_MS(hal_sys_timer_get()-t));
nv_record_config.is_update = true;
#if defined(NVREC_BAIDU_DATA_FLUSH_DIRECT)
nv_record_flash_flush_int(false);
#endif
nvrec_trace(2,"%s: use %d ms", __func__, TICKS_TO_MS(hal_sys_timer_get()-t));
return 0;
}
int nvrec_get_rand(char *rand)
{
char * _rand = 0;
if (rand == NULL)
return 1;
#if 0
_rand = nvrec_config_get_string(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_RAND_KEY, BAIDU_DATA_DEF_RAND);
if (strcmp(_rand, BAIDU_DATA_DEF_RAND)==0 || _rand == NULL) {
TRACE(1,"%s : get rand fail!", __func__);
return 1;
}
#else
_rand = BAIDU_DATA_DEF_RAND;
#endif
memcpy(rand, _rand, BAIDU_DATA_RAND_LEN);
nvrec_trace(2,"%s:rand %s", __func__, rand);
return 0;
}
int nvrec_set_rand(char *rand)
{
int t = hal_sys_timer_get();
if (rand != NULL)
nvrec_trace(2,"%s:rand %s", __func__, rand);
else
nvrec_trace(1,"%s:rand nul", __func__);
nvrec_config_set_string(nv_record_config.config, BAIDU_DATA_SECTIN, BAIDU_DATA_RAND_KEY, rand);
nvrec_trace(2,"%s: use %d ms", __func__, TICKS_TO_MS(hal_sys_timer_get()-t));
nv_record_config.is_update = true;
#if defined(NVREC_BAIDU_DATA_FLUSH_DIRECT)
nv_record_flash_flush_int(false);
#endif
nvrec_trace(2,"%s: use %d ms", __func__, TICKS_TO_MS(hal_sys_timer_get()-t));
return 0;
}
int nvrec_clear_rand(void)
{
nvrec_set_rand(NULL);
return 0;
}
int nvrec_dev_get_sn(char *sn)
{
unsigned int sn_addr;
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
return -1;
}
else
{
sn_addr = (unsigned int)(__factory_start + rev2_dev_prod_sn);
}
if(false == dev_sector_valid)
return -1;
if (NULL == sn)
return -1;
memcpy((void *)sn, (void *)sn_addr, BAIDU_DATA_SN_LEN);
return 0;
}
#endif
#endif // !defined(NEW_NV_RECORD_ENABLED)
bool nvrec_dev_data_open(void)
{
uint32_t dev_zone_crc,dev_zone_flsh_crc;
uint32_t vermagic;
vermagic = __factory_start[dev_version_and_magic];
nvrec_trace(2,"%s,vermagic=0x%x",__func__,vermagic);
if ((nvrec_dev_magic != (vermagic&0xFFFF)) ||
((vermagic >> 16) > NVREC_DEV_NEWEST_REV))
{
dev_sector_valid = false;
nvrec_trace(1,"%s,dev sector invalid.",__func__);
return dev_sector_valid;
}
// following the nv rec version number programmed by the downloader tool,
// to be backward compatible
nv_record_dev_rev = vermagic >> 16;
nvrec_trace(1,"Nv record dev version %d", nv_record_dev_rev);
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
dev_zone_flsh_crc = __factory_start[dev_crc];
dev_zone_crc = crc32(0,(uint8_t *)(&__factory_start[dev_reserv1]),(dev_data_len-dev_reserv1)*sizeof(uint32_t));
}
else
{
// check the data length
if ((rev2_dev_section_start_reserved*sizeof(uint32_t)) + __factory_start[rev2_dev_data_len]
> 4096)
{
nvrec_trace(1,"nv rec dev data len %d has exceeds the facory sector size!.",
__factory_start[rev2_dev_data_len]);
dev_sector_valid = false;
return false;
}
// assure that in future, if the nv dev data structure is extended, the former tool
// and former bin can still be workable
dev_zone_flsh_crc = __factory_start[rev2_dev_crc];
dev_zone_crc = crc32(0,(uint8_t *)(&__factory_start[rev2_dev_section_start_reserved]),
__factory_start[rev2_dev_data_len]);
}
nvrec_trace(4,"%s: data len 0x%x,dev_zone_flsh_crc=0x%x,dev_zone_crc=0x%x",__func__,
__factory_start[rev2_dev_data_len],dev_zone_flsh_crc,dev_zone_crc);
if (dev_zone_flsh_crc == dev_zone_crc)
{
dev_sector_valid = true;
}
if (dev_sector_valid)
{
nvrec_trace(1,"%s: nv rec dev is valid.", __func__);
}
else
{
nvrec_trace(1,"%s: nv rec dev is invalid.", __func__);
}
return dev_sector_valid;
}
bool nvrec_dev_localname_addr_init(dev_addr_name *dev)
{
uint32_t *p_devdata_cache = __factory_start;
size_t name_len = 0;
if(true == dev_sector_valid)
{
nvrec_trace(1,"%s: nv dev data valid", __func__);
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
memcpy((void *) dev->btd_addr,(void *)&p_devdata_cache[dev_bt_addr],BTIF_BD_ADDR_SIZE);
memcpy((void *) dev->ble_addr,(void *)&p_devdata_cache[dev_ble_addr],BTIF_BD_ADDR_SIZE);
dev->localname = (char *)&p_devdata_cache[dev_name];
}
else
{
memcpy((void *) dev->btd_addr,(void *)&p_devdata_cache[rev2_dev_bt_addr],BTIF_BD_ADDR_SIZE);
memcpy((void *) dev->ble_addr,(void *)&p_devdata_cache[rev2_dev_ble_addr],BTIF_BD_ADDR_SIZE);
dev->localname = (char *)&p_devdata_cache[rev2_dev_name];
dev->ble_name = (char *)&p_devdata_cache[rev2_dev_ble_name];
}
if (strlen(dev->localname) < CLASSIC_BTNAME_LEN) {
name_len = strlen(dev->localname);
}
else {
name_len = CLASSIC_BTNAME_LEN - 1;
}
memcpy(classics_bt_name,dev->localname,name_len);
classics_bt_name[name_len] = '\0';
bt_set_local_name(classics_bt_name);
bt_set_local_address(dev->btd_addr);
}
else
{
nvrec_trace(1,"%s: nv dev data invalid", __func__);
}
nvrec_trace(0,"BT addr is:");
DUMP8("%02x ", dev->btd_addr, BTIF_BD_ADDR_SIZE);
nvrec_trace(0,"BLE addr is:");
DUMP8("%02x ", dev->ble_addr, BTIF_BD_ADDR_SIZE);
nvrec_trace(2,"localname=%s, namelen=%d", dev->localname, strlen(dev->localname));
if (dev->ble_name)
nvrec_trace(2,"blename=%s, namelen=%d", dev->ble_name, strlen(dev->ble_name));
return dev_sector_valid;
}
int nvrec_dev_force_get_btaddress(unsigned char *btd_addr)
{
uint32_t *p_devdata_cache = __factory_start;
memcpy((void *) btd_addr,(void *)&p_devdata_cache[dev_bt_addr],BTIF_BD_ADDR_SIZE);
return 0;
}
static void nvrec_dev_data_fill_xtal_fcap(uint32_t *mem_pool,uint32_t val)
{
uint8_t *btaddr = NULL;
uint8_t *bleaddr = NULL;
assert(0 != mem_pool);
if (!dev_sector_valid)
{
mem_pool[dev_version_and_magic] = ((nv_record_dev_rev<<16)|nvrec_dev_magic);
}
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
if(dev_sector_valid)
{
memcpy((void *)mem_pool,(void *)__factory_start,0x1000);
mem_pool[dev_xtal_fcap] = val;
mem_pool[dev_crc] = crc32(0,(uint8_t *)(&mem_pool[dev_reserv1]),(dev_data_len-dev_reserv1)*sizeof(uint32_t));
}
else
{
const char *localname = bt_get_local_name();
unsigned int namelen = strlen(localname);
btaddr = bt_get_local_address();
bleaddr = bt_get_ble_local_address();
mem_pool[dev_reserv1] = 0;
mem_pool[dev_reserv2] = 0;
memcpy((void *)&mem_pool[dev_name],(void *)localname,(size_t)namelen);
nvrec_dev_rand_btaddr_gen(btaddr);
nvrec_dev_rand_btaddr_gen(bleaddr);
memcpy((void *)&mem_pool[dev_bt_addr],(void *)btaddr,BTIF_BD_ADDR_SIZE);
memcpy((void *)&mem_pool[dev_ble_addr],(void *)bleaddr,BTIF_BD_ADDR_SIZE);
memset((void *)&mem_pool[dev_dongle_addr],0x0,BTIF_BD_ADDR_SIZE);
mem_pool[dev_xtal_fcap] = val;
mem_pool[dev_crc] = crc32(0,(uint8_t *)(&mem_pool[dev_reserv1]),(dev_data_len-dev_reserv1)*sizeof(uint32_t));
nvrec_trace(2,"%s: mem_pool[dev_crc]=%x.\n",__func__,mem_pool[dev_crc]);
}
}
else
{
if(dev_sector_valid)
{
memcpy((void *)mem_pool,(void *)__factory_start,0x1000);
mem_pool[rev2_dev_xtal_fcap] = val;
mem_pool[rev2_dev_crc] = crc32(0,
(uint8_t *)(&mem_pool[rev2_dev_section_start_reserved]),mem_pool[rev2_dev_data_len]);
}
else
{
const char *localname = bt_get_local_name();
unsigned int namelen = strlen(localname);
btaddr = bt_get_local_address();
bleaddr = bt_get_ble_local_address();
mem_pool[rev2_dev_section_start_reserved] = 0;
mem_pool[rev2_dev_reserv2] = 0;
memcpy((void *)&mem_pool[rev2_dev_name],(void *)localname,(size_t)namelen);
memcpy((void *)&mem_pool[rev2_dev_ble_name], (void *)bt_get_ble_local_name(), BLE_NAME_LEN_IN_NV);
nvrec_dev_rand_btaddr_gen(btaddr);
nvrec_dev_rand_btaddr_gen(bleaddr);
memcpy((void *)&mem_pool[rev2_dev_bt_addr],(void *)btaddr,BTIF_BD_ADDR_SIZE);
memcpy((void *)&mem_pool[rev2_dev_ble_addr],(void *)bleaddr,BTIF_BD_ADDR_SIZE);
memset((void *)&mem_pool[rev2_dev_dongle_addr],0x0,BTIF_BD_ADDR_SIZE);
mem_pool[rev2_dev_xtal_fcap] = val;
mem_pool[rev2_dev_data_len] = (rev2_dev_section_end-rev2_dev_section_start_reserved)*sizeof(uint32_t);
mem_pool[rev2_dev_crc] = crc32(0,
(uint8_t *)(&mem_pool[rev2_dev_section_start_reserved]),
mem_pool[rev2_dev_data_len]);
nvrec_trace(2,"%s: mem_pool[rev2_dev_crc] = 0x%x.\n",
__func__,mem_pool[rev2_dev_crc]);
}
}
}
void nvrec_dev_flash_flush(unsigned char *mempool)
{
uint32_t lock;
#ifdef nv_record_debug
uint32_t devdata[dev_data_len] = {0,};
uint32_t recrc;
#endif
if(NULL == mempool)
return;
lock = int_lock_global();
pmu_flash_write_config();
hal_norflash_erase(HAL_NORFLASH_ID_0,(uint32_t)NVRECORD_CACHE_2_UNCACHE(__factory_start),0x1000);
hal_norflash_write(HAL_NORFLASH_ID_0,(uint32_t)NVRECORD_CACHE_2_UNCACHE(__factory_start),(uint8_t *)mempool,0x1000);//dev_data_len*sizeof(uint32_t));
pmu_flash_read_config();
int_unlock_global(lock);
#ifdef nv_record_debug
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
memset(devdata,0x0,dev_data_len*sizeof(uint32_t));
memcpy(devdata,__factory_start,dev_data_len*sizeof(uint32_t));
recrc = crc32(0,(uint8_t *)(&devdata[dev_reserv1]),(dev_data_len-dev_reserv1)*sizeof(uint32_t));
nvrec_trace(3,"%s: devdata[dev_crc]=%x.recrc=%x\n", __func__,devdata[dev_crc],recrc);
if(devdata[dev_crc] != recrc)
assert(0);
}
#endif
}
void nvrec_dev_rand_btaddr_gen(uint8_t* bdaddr)
{
unsigned int seed;
int i;
OS_DUMP8("%x ",bdaddr,6);
seed = hal_sys_timer_get();
for(i=0;i<BTIF_BD_ADDR_SIZE;i++)
{
unsigned int randval;
srand(seed);
randval = rand();
bdaddr[i] = (randval&0xff);
seed += rand();
}
OS_DUMP8("%x ",bdaddr,6);
}
void nvrec_dev_set_xtal_fcap(unsigned int xtal_fcap)
{
uint8_t *mempool = NULL;
uint32_t lock;
#ifdef nv_record_debug
uint32_t devdata[dev_data_len] = {0,};
uint32_t recrc;
#endif
syspool_init();
syspool_get_buff(&mempool, 0x1000);
nvrec_dev_data_fill_xtal_fcap((uint32_t *)mempool,(uint32_t)xtal_fcap);
lock = int_lock_global();
norflash_api_flush_all(); //Ensure that the flash is in an operational state
pmu_flash_write_config();
hal_norflash_erase(HAL_NORFLASH_ID_0,(uint32_t)NVRECORD_CACHE_2_UNCACHE(__factory_start),0x1000);
hal_norflash_write(HAL_NORFLASH_ID_0,(uint32_t)NVRECORD_CACHE_2_UNCACHE(__factory_start),(uint8_t *)mempool,0x1000);//dev_data_len*sizeof(uint32_t));
pmu_flash_read_config();
int_unlock_global(lock);
#ifdef nv_record_debug
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
memset(devdata,0x0,dev_data_len*sizeof(uint32_t));
memcpy(devdata,__factory_start,dev_data_len*sizeof(uint32_t));
nvrec_trace(2,"%s: xtal fcap = %d", __func__, devdata[dev_xtal_fcap]);
recrc = crc32(0,(uint8_t *)(&devdata[dev_reserv1]),(dev_data_len-dev_reserv1)*sizeof(uint32_t));
nvrec_trace(2,"devdata[dev_crc]=%x.recrc=%x\n", devdata[dev_crc], recrc);
if(devdata[dev_crc] != recrc)
assert(0);
}
#endif
}
int nvrec_dev_get_xtal_fcap(unsigned int *xtal_fcap)
{
unsigned int xtal_fcap_addr;
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
xtal_fcap_addr = (unsigned int)(__factory_start + dev_xtal_fcap);
}
else
{
xtal_fcap_addr = (unsigned int)(__factory_start + rev2_dev_xtal_fcap);
}
unsigned int tmpval[1] = {0,};
if(false == dev_sector_valid)
return -1;
if (NULL == xtal_fcap)
return -1;
memcpy((void *)tmpval,(void *)xtal_fcap_addr,sizeof(unsigned int));
*xtal_fcap = tmpval[0];
return 0;
}
int nvrec_dev_get_dongleaddr(bt_bdaddr_t *dongleaddr)
{
unsigned int dongle_addr_pos;
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
dongle_addr_pos = (unsigned int)(__factory_start + dev_dongle_addr);
}
else
{
dongle_addr_pos = (unsigned int)(__factory_start + rev2_dev_dongle_addr);
}
if(false == dev_sector_valid)
return -1;
if(NULL == dongleaddr)
return -1;
memcpy((void *)dongleaddr,(void *)dongle_addr_pos,BTIF_BD_ADDR_SIZE);
return 0;
}
int nvrec_dev_get_btaddr(char *btaddr)
{
unsigned int bt_addr_pos;
if (NVREC_DEV_VERSION_1 == nv_record_dev_rev)
{
bt_addr_pos = (unsigned int)(__factory_start + dev_bt_addr);
}
else
{
bt_addr_pos = (unsigned int)(__factory_start + rev2_dev_bt_addr);
}
if(false == dev_sector_valid)
return 0;
if(NULL == btaddr)
return 0;
memcpy((void *)btaddr,(void *)bt_addr_pos,BTIF_BD_ADDR_SIZE);
return 1;
}
char* nvrec_dev_get_bt_name(void)
{
return classics_bt_name;
}
const char* nvrec_dev_get_ble_name(void)
{
if ((NVREC_DEV_VERSION_1 == nv_record_dev_rev) || (!dev_sector_valid))
{
return BLE_DEFAULT_NAME;
}
else
{
return (const char *)(&__factory_start[rev2_dev_ble_name]);
}
}
Reference in New Issue View Git Blame Copy Permalink