pinebuds/services/nvrecord/nvrecord.c

/***************************************************************************
 *
 * 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 "nvrecord.h"
#include "besbt.h"
#include "crc32.h"
#include "hal_norflash.h"
#include "hal_sleep.h"
#include "hal_timer.h"
#include "norflash_api.h"
#include "nvrecord_dev.h"
#include "nvrecord_env.h"
#include "pmu.h"
#include "tgt_hardware.h"
#include <assert.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]);
  }
}