int bsp_dual_modem_init(void) { int ret = ERROR; DRV_DUAL_MODEM_STR dual_modem_nv; DRV_DM_UART5_STR uart_cfg_nv; memset_s((void*)&g_dual_modem_ctrl.uart_port, sizeof(g_dual_modem_ctrl.uart_port), 0, sizeof(g_dual_modem_ctrl.uart_port)); /*lint !e545*/ //初始化串口属性 memset_s((void*)&dual_modem_nv, sizeof(DRV_DUAL_MODEM_STR), 0, sizeof(DRV_DUAL_MODEM_STR)); memset_s((void*)&uart_cfg_nv, sizeof(DRV_DM_UART5_STR), 0, sizeof(DRV_DM_UART5_STR)); ret = bsp_nvm_read(NV_ID_DRV_DUAL_MODEM ,(u8 *)&dual_modem_nv ,sizeof(DRV_DUAL_MODEM_STR)); if (ret != OK) { dm_print_err("read dual modem nv fail: %d\n", NV_ID_DRV_DUAL_MODEM); dual_modem_nv.enUartEnableCfg = DUAl_MODEM_DISABLE; } if(DUAl_MODEM_ENABLE == dual_modem_nv.enUartEnableCfg) { ret = bsp_nvm_read(NV_ID_DRV_DM_UART5_CFG ,(u8 *)&uart_cfg_nv ,sizeof(DRV_DM_UART5_STR)); if (ret != OK) { dm_print_err("read dual modem nv fail: %d\n", NV_ID_DRV_DM_UART5_CFG); uart_cfg_nv.ex1_param = 0; } g_dual_modem_ctrl.uart_port.rts_mask = (uart_cfg_nv.ex1_param << 14); if(DUAl_MODEM_ENABLE == dual_modem_nv.enUartlogEnableCfg) { g_dual_modem_ctrl.log_flag = 1; bsp_mod_level_set(BSP_MODU_DUAL_MODEM ,BSP_LOG_LEVEL_DEBUG); } ret = dual_modem_wakeup_init(dual_modem_nv); if(ret !=OK) { dm_print_err("dual modem wakeup init failed!\n"); return ERROR; } if(OK != dual_modem_dump_init()) { dm_print_err("dual_modem_dump_init fail!\n"); return ERROR; } #ifdef LPM3_GPIO /* 注册ICC读写回调 */ if(OK != bsp_icc_event_register((ICC_CHN_MCORE_CCORE << 16)|MCORE_CCORE_FUNC_UART, recv_lpm3_msg_icc_cb , NULL, NULL, NULL)) { dm_print_err("register icc callback fail\n"); return ERROR; } #endif g_dual_modem_ctrl.nv_flag = DUAl_MODEM_ENABLE; dm_print_err("dual modem init\n"); } return OK; }
/* **破坏0xD007的数据,后写入NV 0xD007 **注:串口有CRC校验不过的打印 ** 串口有从工作分区中加载数据的log打印则认为通过 */ u32 nv_crc_write_test01(void) { struct nv_global_ddr_info_stru* ddr_info = (struct nv_global_ddr_info_stru*)NV_GLOBAL_INFO_ADDR; struct nv_ref_data_info_stru ref_info = {}; struct nv_file_list_info_stru file_info = {}; u32 ret = 0; u32 nvid = 0xD007; u32 data = 0; u32 new_data = 0; if(!NV_CRC_CHECK_YES) { printf("CRC mark = 0x%x\n",NV_CRC_CHECK_YES); } ret = nv_search_byid(nvid, (u8 *)NV_GLOBAL_CTRL_INFO_ADDR, &ref_info, &file_info); if(ret) { printf("11111 ret = 0x%x\n", ret); return ret; } data = *(u32 *)(NV_GLOBAL_CTRL_INFO_ADDR + ddr_info->file_info[ref_info.file_id - 1].offset + ref_info.nv_off); data += 2; *(u32 *)(NV_GLOBAL_CTRL_INFO_ADDR + ddr_info->file_info[ref_info.file_id - 1].offset + ref_info.nv_off) = data; nv_flush_cache((void*)NV_GLOBAL_INFO_ADDR, (u32)NV_GLOBAL_INFO_SIZE); ret = bsp_nvm_read(nvid, (u8 *)&data, sizeof(u32)); if(ret) { printf("5555 ret = 0x%x\n", ret); return ret; } data+=2; ret = bsp_nvm_write(nvid, (u8 *)&data, sizeof(u32)); if(ret) { printf("3333 ret = 0x%x\n", ret); return ret; } ret = bsp_nvm_read(nvid, (u8 *)&new_data, sizeof(u32)); if(ret) { printf("6666 ret = 0x%x\n", ret); return ret; } if(new_data != data) { printf("7777 new_data = 0x%x, data = 0x%x ret = 0x%x\n", new_data, data,ret); return ret; } return NV_OK; }
u32 nv_crc_write_test04(void) { struct nv_ref_data_info_stru nvArray[10] = {}; u32 count = 0; u32 i = 0; u32 ret = 0; u8 *pOldNvData = NULL; u8 *pNewNvData = NULL; pOldNvData = (u8 *)nv_malloc(NV_MAX_UNIT_SIZE); pNewNvData = (u8 *)nv_malloc(NV_MAX_UNIT_SIZE); if((pOldNvData == NULL)||(pNewNvData == NULL)) { nv_printf("malloc error 1111\n"); return NV_ERROR; } count = nv_test_find_edge_nv(nvArray); for(i = 0; i < count; i++) { ret = bsp_nvm_read(nvArray[i].itemid, (u8 *)pOldNvData, nvArray[i].nv_len); if(ret) { nv_printf("read error 222, nvid = 0x%x\n", nvArray[i].itemid); return ret; } pOldNvData[0]+=2; ret = bsp_nvm_write(nvArray[i].itemid, (u8 *)pOldNvData, nvArray[i].nv_len); if(ret) { nv_printf("read error 3333, nvid = 0x%x\n", nvArray[i].itemid); return ret; } ret = bsp_nvm_read(nvArray[i].itemid, (u8 *)pNewNvData, nvArray[i].nv_len); if((ret)||(pNewNvData[0] != pOldNvData[0])) { nv_printf("read error 4444, nvid = 0x%x\n", nvArray[i].itemid); return ret; } ret = nv_check_ddr_crc(); if(ret) { nv_printf("read error 5555, nvid = 0x%x\n", nvArray[i].itemid); return ret; } } nv_free(pOldNvData); nv_free(pNewNvData); return NV_OK; }
u32 nv_write_test02(void) { u32 ret = NV_OK; u32 i = 0; u32 read_data = 0; u32 write_data = 0; for(i = 0;i<100;i++) { printf("\n****************第%d次读写开始**************************\n",i); write_data = i+60; ret = bsp_nvm_write(0xd007,(u8*)&write_data,sizeof(u32)); if(NV_OK != ret) { printf("****write error*****i = %d\n",i); return ret; } ret = bsp_nvm_read(0xd007,(u8*)&read_data,sizeof(u32)); if(ret) { printf("****read error*****i = %d\n",i); return ret; } } return NV_OK; }
u32 nv_read_write_test(void) { u32 i; u32 ret; struct nv_ctrl_file_info_stru* ctrl_info = (struct nv_ctrl_file_info_stru*)NV_GLOBAL_CTRL_INFO_ADDR; struct nv_ref_data_info_stru* ref_info = (struct nv_ref_data_info_stru*)(NV_GLOBAL_CTRL_INFO_ADDR+NV_GLOBAL_CTRL_INFO_SIZE\ +NV_GLOBAL_FILE_ELEMENT_SIZE*ctrl_info->file_num); u8* pdata; pdata = (u8*)nv_malloc(3072); if(NULL == pdata) { return NV_ERROR; } for(i = 0;i<ctrl_info->ref_count;i++) { printf("*****************read & write 0x%x****************\n",ref_info->itemid); ret = bsp_nvm_read(ref_info->itemid,pdata,ref_info->nv_len); if(ret) { nv_free(pdata); return ret; } ret = bsp_nvm_write(ref_info->itemid,pdata,ref_info->nv_len); if(ret) { nv_free(pdata); return ret; } ref_info++; } nv_free(pdata); return NV_OK; }
/***************************************************************************** 函 数 名 : bsp_sci_get_nv 功能描述 : 获取SCI的NV项值 输入参数 : 输出参数 : 无 返 回 值 : int 调用函数 : 被调函数 : 修改历史 : *****************************************************************************/ int bsp_sci_get_nv(unsigned int *value) { /*调用NV读接口*/ if(BSP_OK == bsp_nvm_read(NV_ID_DRV_SCI_DSDA_SELECT, (u8*)&g_SciNVValue, NV_SCI_LEN)) { #if (FEATURE_ON==FEATURE_MULTI_MODEM) if(0x802 !=g_SciNVValue && 0x102 !=g_SciNVValue) { g_SciNVValue = 0x802; } #endif /*读取成功*/ *value = g_SciNVValue; sci_print_debug("nv value:0x%x\r\n",g_SciNVValue); return BSP_OK; } else { #if (FEATURE_ON==FEATURE_MULTI_MODEM) *value = 0x802; #else /*读取失败,默认是单卡0*/ *value = 0x0; #endif sci_print_error("default value is 0x%x\r\n", 0); return BSP_ERROR; } }
/* Function: wait_ss_coul_device_work(void) * Discription: wait the smart star coul device work normal * Parameters: NULL * return value:NULL */ int __ddrrun_func wait_ss_coul_device_work(void) { int tryloop = 0,ret; char regval; coul_nv_info = alloc(sizeof(*coul_nv_info)); memset(coul_nv_info, 0, sizeof(*coul_nv_info)); ret = bsp_nvm_read(NV_HUAWEI_COUL_INFO_I, (u8*)coul_nv_info, sizeof(*coul_nv_info)); if(ret) { SMARTSTAR_COUL_ERR("read nv %s(%d) failed !\n", SS_COUL_NV_NAME, SS_COUL_NV_NUM); regval = SMARTSTAR_REG_READ(SMARTSTAR_NV_READ_SUCCESS); regval &= 0xFA; SMARTSTAR_REGS_WRITE(SMARTSTAR_NV_READ_SUCCESS, ®val, 1); nv_read_success = 0; } else { /*需要使用校准NV来得出v_offset_a和v_offset_b*/ v_offset_a = coul_nv_info->v_offset_a == 0 ? DEFAULT_V_OFF_A : coul_nv_info->v_offset_a / 1000; v_offset_b = coul_nv_info->v_offset_b == 0 ? DEFAULT_V_OFF_B : coul_nv_info->v_offset_b / 1000; c_offset_a = coul_nv_info->c_offset_a == 0 ? DEFAULT_C_OFF_A : coul_nv_info->c_offset_a / 1000; c_offset_b = coul_nv_info->c_offset_b == 0 ? DEFAULT_C_OFF_B : coul_nv_info->c_offset_b / 1000; r_pcb = coul_nv_info->r_pcb; regval = SMARTSTAR_REG_READ(SMARTSTAR_NV_READ_SUCCESS); regval |= 0x4; SMARTSTAR_REGS_WRITE(SMARTSTAR_NV_READ_SUCCESS, ®val, 1); nv_read_success = 1; SMARTSTAR_COUL_INF("read NV_HUAWEI_COUL_INFO_I success\n"); } do { regval = SMARTSTAR_REG_READ(0x0); SMARTSTAR_COUL_INF("do a dummy read, smartstar version is 0x%x\n", regval); if ((tryloop++) > 5) return -1; } while(regval != 0x20); tryloop=0; do { regval = SMARTSTAR_REG_READ(SMARTSTAR_COUL_STATE_REG); if ((tryloop++) > 15){ SMARTSTAR_COUL_ERR("wait coul work timeout, reg = 0x%x\n", regval); return -1; } sleep(110); /* sleep 110 ms more to get a valid voltage/current value */ } while(regval != COUL_WORKING); get_initial_ocv(); return 0; }
/************************************************************************ *函数原型 : PRIVATE int breathled_nv_init(void) *描述 : 呼吸灯控制参数NV读取初始化 *输入 : 无 *输出 : 无 *返回值 : BR_OK OR BR_ERRO *修改历史 : 1.日 期 : 20131205 修改内容 : 新生成函数 *************************************************************************/ PRIVATE int breathled_nv_init(void) { int ret = 0; printk(KERN_DEBUG"[*Breath-Led*] %s: led parameter nv init.\n", __func__); ret = bsp_nvm_read(NV_ID_LED_PARA, (unsigned char *)(&led_attr_default), sizeof(led_attr_default)); if(NV_OK != ret) { printk(KERN_ERR"[*Breath-Led*] %s: led parameter nv read fail.\n", __func__); return BR_ERROR; } printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.led_enable = %d.\n", __func__, led_attr_default.led_enable); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.led_dr = %d.\n", __func__, led_attr_default.led_dr); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.led_mode = %d.\n", __func__, led_attr_default.led_mode); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.full_on = %u.\n", __func__, led_attr_default.full_on); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.full_off = %u.\n", __func__, led_attr_default.full_off); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.fade_on = %u.\n", __func__, led_attr_default.fade_on); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.fade_off = %u.\n", __func__, led_attr_default.fade_off); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.delay_on = %u.\n", __func__, led_attr_default.delay_on); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.delay_period = %u.\n", __func__, led_attr_default.delay_period); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.full_long_on = %u.\n", __func__, led_attr_default.full_long_on); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.full_long_off = %u.\n", __func__, led_attr_default.full_long_off); printk(KERN_DEBUG"[*Breath-Led*] %s: led_attr_default.brightness = %u.\n", __func__, led_attr_default.brightness); return BR_OK; }
/* **测试关机写功能, 需要重新出版本将NV 0xD007的优先级设置为1~6 */ u32 nv_flush_test_00(void) { u32 ret = 0; u32 nvid = 0xD007; u32 data = 0; u32 new_data = 0; ret = bsp_nvm_read(nvid, (u8 *)&data, sizeof(u32)); if(ret) { printf("1111 ret = 0x%x\n", ret); return ret; } data+=2; ret = bsp_nvm_write(nvid, (u8 *)&data, sizeof(u32)); if(ret) { printf("2222 ret = 0x%x\n", ret); return ret; } /*关机写接口*/ ret = bsp_nvm_flush(); if(ret) { printf("3333 ret = 0x%x\n",__func__,ret); return ret; } ret = nv_resume_ddr_from_img(); if(ret) { printf("4444 ret = 0x%x\n", ret); return ret; } ret = bsp_nvm_read(nvid, (u8 *)&new_data, sizeof(u32)); if(ret) { printf("5555 ret = 0x%x\n", ret); return ret; } if(new_data != data) { printf("6666 new_data = 0x%x, data = 0x%x\n", new_data, data); } return NV_OK; }
u32 bsp_nvm_init(void) { u32 ret = NV_ERROR; struct nv_global_ddr_info_stru* ddr_info = (struct nv_global_ddr_info_stru*)NV_GLOBAL_INFO_ADDR; #ifdef BSP_CONFIG_HI3630 nv_printf("waiting for ap modem nv init ok .......\n"); BSP_SYNC_Wait(SYNC_MODULE_NV,0); #endif nv_debug(NV_FUN_NVM_INIT,0,0,0,0); if(ddr_info->ccore_init_state < NV_BOOT_INIT_OK) { nv_printf("[%s]:pre init fail,break here!\n",__FUNCTION__); nv_debug(NV_FUN_NVM_INIT,1,0,0,0); /*lint -save -e801*/ goto nv_init_fail; /*lint -restore*/ } g_nv_ctrl.shared_addr = (u32)NV_GLOBAL_INFO_ADDR; spin_lock_init(&g_nv_ctrl.spinlock); ret = nv_icc_chan_init(); if(ret) { nv_debug(NV_FUN_NVM_INIT,2,ret,0,0); /*lint -save -e801*/ goto nv_init_fail; /*lint -restore*/ } osl_sem_init(1,&g_nv_ctrl.rw_sem); osl_sem_init(0,&g_nv_ctrl.cc_sem); ret = bsp_nvm_read(NV_ID_MSP_FLASH_LESS_MID_THRED,(u8*)&g_nv_ctrl.mid_prio,sizeof(u32)); if(ret) { g_nv_ctrl.mid_prio = 20; nv_printf("read 0x%x error : 0x%x,use default count\n",NV_ID_MSP_FLASH_LESS_MID_THRED,ret); } ret = (u32)bsp_ipc_sem_create(IPC_SEM_NV_CRC); if(ret) { nv_debug(NV_FUN_KERNEL_INIT,3 ,ret ,0,0); /*lint -save -e801*/ goto nv_init_fail; /*lint -restore*/ } ddr_info->ccore_init_state = NV_INIT_OK; nv_printf("nv init ok !\n"); INIT_LIST_HEAD(&g_nv_ctrl.stList); return NV_OK; nv_init_fail: ddr_info->ccore_init_state = NV_INIT_FAIL; nv_printf("\n[%s]\n",__FUNCTION__); nv_help(NV_FUN_NVM_INIT); return ret; }
int anten_nv_init(void) { unsigned int ret = 0; /* Get ANTEN NV data by id.*/ ret = bsp_nvm_read(NV_ID_DRV_ANTEN_CFG,(u8*)&anten_stru,sizeof(DRV_DRV_ANTEN_GPIO_STRU)); if (ret != 0){ anten_print_error("anten_gpio read NV=0x%x, ret = %d \n",NV_ID_DRV_ANTEN_CFG, ret); } ret = bsp_nvm_read(en_NV_Item_FEM_GPIO_MIPI_CTRL, (u8*)&g_femio_info, sizeof(NV_FEM_GPIO_MIPI_CTRL_STRU)); if (ret != 0){ anten_print_error("anten_gpio read NV=0x%x, ret = %d \n",en_NV_Item_FEM_GPIO_MIPI_CTRL, ret); } ret = bsp_nvm_read(en_NV_Item_FEM_PIN_TO_GPIO, (u8*)&g_pin2gpio, sizeof(NV_FEMPIN_TO_GPIO_STRU)); if (ret != 0) { anten_print_error("anten_gpio read NV=0x%x, ret = %d \n",en_NV_Item_FEM_GPIO_MIPI_CTRL, ret); } return (int)ret; }
u32 nv_read_test_07(void) { u32 itemid = 0xd007; u32 ret = NV_ERROR; u32 pdata = 0; ret = bsp_nvm_read(itemid,(u8*)&pdata,1); if(ret == BSP_ERR_NV_ITEM_LEN_ERR) { return NV_OK; } return ret; }
u32 nv_read_test_06(void) { u32 itemid = 0xd007; u32 ret = NV_ERROR; u8* pdata = NULL; ret = bsp_nvm_read(itemid,pdata,sizeof(u32)); if(ret == BSP_ERR_NV_INVALID_PARAM) { return NV_OK; } return ret; }
int anten_nv_init(void) { unsigned int ret = 0; /* Get ANTEN NV data by id.*/ ret = bsp_nvm_read(NV_ID_DRV_ANTEN_CFG,(u8*)&anten_stru,sizeof(DRV_DRV_ANTEN_GPIO_STRU)); if (ret != 0) { anten_print_error("anten_gpio read NV=0x%x, ret = %d \n",NV_ID_DRV_ANTEN_CFG, ret); return -1; } return 0; }
u32 nvm_read_rand(u32 nvid) { u32 ret; u8* tempdata; u32 i= 0; struct nv_ref_data_info_stru ref_info = {0}; struct nv_file_list_info_stru file_info = {0}; ret = nv_search_byid(nvid, (u8*)NV_GLOBAL_CTRL_INFO_ADDR,&ref_info,&file_info); if(NV_OK != ret) { return ret; } if(ref_info.nv_len == 0) { return NV_ERROR; } /*lint -save -e515 -e516*/ printf_nv("[0x%x]:len 0x%x,off 0x%x,file id %d\n",nvid,ref_info.nv_len,ref_info.nv_off,ref_info.file_id); /*lint -restore*/ /*lint -save -e516*/ tempdata = (u8*)nv_malloc(ref_info.nv_len); /*lint -restore +e516*/ if(NULL == tempdata) { return BSP_ERR_NV_MALLOC_FAIL; } ret = bsp_nvm_read(nvid,tempdata,ref_info.nv_len); if(NV_OK != ret) { nv_free(tempdata); return BSP_ERR_NV_READ_DATA_FAIL; } /*lint -save -e515 -e516*/ for(i=0;i<ref_info.nv_len;i++) { if((i%32) == 0) { printf_nv("\n"); } printf_nv("%02x ",(u8)(*(tempdata+i))); } printf_nv("\n\n"); /*lint -restore*/ nv_free(tempdata); return 0; }
void pastar_init(void) { u32 ret = 0; ver_flag.NV_SW_VER_Flag = 1;/* 默认为正式版本 */ ret = bsp_nvm_read((u32)NV_ID_DRV_VER_FLAG,(u8 *)&ver_flag,(u32)sizeof(NV_SW_VER_FLAG_STRU_FORPASTAR)); if(NV_OK != ret) { printk("nv 36 read failed, ret %d!\n", ret); return; } return; }
/************************************************* 函 数 名 : secureSupport 功能描述 : 当前版本是否支持安全启动 输入参数 : unsigned char *pData 输出参数 : unsigned char *pData 返 回 值 : SEC_OK/SEC_ERROR 调用函数 : 被调函数 : 修改历史 : 日 期 : 作 者 : 修改内容 : *************************************************/ s32 secureSupport(u8* pData) { u8 usNVSecBootEnableFlag = 0xFF; if(NULL == pData) { return SEC_ERROR_NULL_PTR; } if (SEC_OK != bsp_nvm_read(NV_ID_DRV_SEC_BOOT_ENABLE_FLAG, &usNVSecBootEnableFlag, sizeof(u16))) { bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_SECURITY, "FUNC secureSupport ERR! line : %d ", __LINE__); return SEC_ERROR_NV_READ_ERR; } *pData = (SECURE_NOT_SUPPORT == usNVSecBootEnableFlag) ? (u8)SECURE_NOT_SUPPORT : (u8)SECURE_SUPPORT; return SEC_OK; }
BSP_U32 NV_QueryRestoreResult(BSP_VOID) { BSP_U32 ret = NV_ERROR; BSP_U16 resume_flag = 0; ret = bsp_nvm_read(NV_ID_DRV_RESUME_FLAG,(BSP_U8*)&resume_flag,sizeof(BSP_U16)); /*to do*/ if(ret) { return ret; } if(0 != resume_flag) { return NV_ERROR; } return 0; }
/***************************************************************************** 函数名称 : int mlog_is_factory_mode(void) 功能描述 : 输入参数 : No 输出参数 : No 返 回 值 : No 修改历史 : 1. 2014-09-23 : 00206465 qiaoyichuan created *****************************************************************************/ int mlog_is_factory_mode(void) { int ret = 0; static int mlog_ftm_mod = -1; if (-1 == mlog_ftm_mod) { ret = bsp_nvm_read(NV_ID_SOFT_FACTORY_MLOG_CFG, (unsigned char *)(& mlog_ftm_mod), sizeof( unsigned int)); if (0 != ret) { printk("get nv factory err \r\n" ); return -1; } } return mlog_ftm_mod; }
/***************************************************************************** * 函 数 : bsp_get_firmware_version * 功 能 : 获取软件版本号 *****************************************************************************/ char * bsp_version_get_firmware(void) { u32 ret = VER_OK; /*lint -save -e26 -e119*/ ret=bsp_nvm_read(NV_ID_DRV_NV_DRV_VERSION_REPLACE_I, (u8 *)&nv_sw_ver, sizeof(NV_SW_VER_STRU)); if(NV_OK != ret){ ver_print_error("get NV_SW_VERSION_REPLACE failed!\n"); return (char*)PRODUCT_DLOAD_SOFTWARE_VER; } else if(0 == nv_sw_ver.nvStatus){ return (char*)PRODUCT_DLOAD_SOFTWARE_VER; } /*lint -restore*/ return (char *)nv_sw_ver.nv_version_info; }
u32 nv_read_rand_test(u32 nvid) { u32 ret; u8* tempdata; u32 i= 0; struct nv_ref_data_info_stru ref_info = {0}; struct nv_file_list_info_stru file_info = {0}; ret = nv_search_byid(nvid, (u8*)NV_GLOBAL_CTRL_INFO_ADDR,&ref_info,&file_info); if(NV_OK != ret) { return ret; } if(ref_info.nv_len == 0) { return NV_ERROR; } tempdata = (u8*)nv_malloc((u32)(ref_info.nv_len) +1); if(NULL == tempdata) { return BSP_ERR_NV_MALLOC_FAIL; } ret = bsp_nvm_read(nvid,tempdata,ref_info.nv_len); if(NV_OK != ret) { nv_free(tempdata); return BSP_ERR_NV_READ_DATA_FAIL; } for(i=0;i<ref_info.nv_len;i++) { if((i%16) == 0) { printf("\n"); } printf("%2.2x ",(u8)(*(tempdata+i))); } printf("\n"); nv_free(tempdata); return NV_OK; }
int bsp_sci_get_nv(unsigned int *value) { /*调用NV读接口*/ if(BSP_OK == bsp_nvm_read(NV_ID_DRV_SCI_DSDA_SELECT, (u8*)&g_SciNVValue, NV_SCI_LEN)) { bsp_sci_set_default_nv(); /*读取成功*/ *value = g_SciNVValue; sci_print_debug("nv value:0x%x\r\n",g_SciNVValue); return BSP_OK; } else { *value = g_SciNVValue; sci_print("read nv error use default val %x\n",g_SciNVValue); return BSP_ERROR; } }
u32 nv_function_test(void) { u32 i; u32 ret; struct nv_ctrl_file_info_stru* ctrl_info = (struct nv_ctrl_file_info_stru*)NV_GLOBAL_CTRL_INFO_ADDR; struct nv_ref_data_info_stru* ref_info = (struct nv_ref_data_info_stru*)(NV_GLOBAL_CTRL_INFO_ADDR+NV_GLOBAL_CTRL_INFO_SIZE\ +NV_GLOBAL_FILE_ELEMENT_SIZE*ctrl_info->file_num); u8* pdata; u32 start,end; start = bsp_get_slice_value(); pdata = (u8*)nv_malloc(3072); if(NULL == pdata) { return NV_ERROR; } for(i = 0;i<100;i++) { printf("*****************read & write 0x%x****************\n",ref_info->itemid); ret = bsp_nvm_read(ref_info->itemid,pdata,ref_info->nv_len); if(ret) { nv_free(pdata); return ret; } ret = bsp_nvm_write(ref_info->itemid,pdata,ref_info->nv_len); if(ret) { nv_free(pdata); return ret; } ref_info++; } end = bsp_get_slice_value(); nv_free(pdata); printf("[%s]:slice 0x%x\n",__func__,end-start); return NV_OK; }
/***************************************************************************** 函 数 名 : bsp_coul_init 功能描述 : 库仑计模块初始化 输入参数 : void 输出参数 : 无 返 回 值 : 初始化成功或失败 调用函数 : 被调函数 : *****************************************************************************/ int bsp_coul_init(void) { int iret = BSP_COUL_OK; #if 0 unsigned int low_batt_thres = 3400; /* 库仑计默认已开启,其他功能后续提供*/ coul_power_ctrl(COUL_POWER_ON); coul_cali_ctrl(COUL_CALI_ON); coul_reflash_ctrl(COUL_REFLASH_ECO); coul_eco_ctrl(COUL_REFLASH_ECO); coul_set_vbat_value(low_batt_thres); #endif /*读取nv值,获取电压电流计算参数*/ /*read nv,get the exc protect setting*/ iret = bsp_nvm_read(NV_ID_DRV_COUL_CALI,(u8 *)&coul_cali_config,sizeof(COUL_CALI_NV_TYPE)); if(NV_OK != iret) { coul_err("coul cali read nv error,not set,use the default config!\n"); } /*for test */ #if 0 coul_err("volt offset is %d,%d!\n",coul_cali_config.v_offset_a,coul_cali_config.v_offset_b); while(!bsp_coul_is_ready()) { } //mdelay(500); coul_err("battary volt is %d mV!\n",bsp_coul_voltage()); coul_err("battary curr is %d mA!\n",bsp_coul_current()); #endif return iret; }
/***************************************************************************** * 函 数 名 : bsp_version_productinfo_init * * 功能描述 : 读NV(0xD115)的值到huawei_product_info * * 参数说明 : 无 * *返回值 : VER_ERROR表示读取异常 * VER_OK表示读取正常 *****************************************************************************/ static __inline__ int bsp_version_productinfo_init(void) { u32 ret = 0; u32 hw_ver = bsp_get_version_info()->board_id; /*lint -save -e26 -e119*/ ret = bsp_nvm_read(NV_ID_DRV_NV_VERSION_INIT,(u8*)&huawei_product_info,sizeof(PRODUCT_INFO_NV_STRU)); if(NV_OK != ret) { ver_print_error(" bsp_nvm_read failed!\n"); return VER_ERROR; } if(hw_ver!=huawei_product_info.index){ ver_print_error(" product id(0x%x) is not defined in xml!\n",hw_ver); huawei_product_info.index = hw_ver; return VER_ERROR; } /*lint -restore*/ return VER_OK; }
/*循环写入一个NV,测试双核的互斥是否有效*/ u32 nv_crc_write_test05(void) { u32 ret = 0; u32 nvid = 0xD007; u32 data = 0; u32 i = 0; for(i = 0; i < 1000; i++) { printf("\n****************第%d次测试开始**************************\n", i); ret = bsp_nvm_read(nvid, (u8 *)&data, sizeof(u32)); if(ret) { nv_printf("read fail ,ret = 0x%x\n", ret); return ret; } data++; printf("\n****************第%d次测试开始 11111**************************\n", i); DelayMs(g_crc_delay_ctrl, 0); ret = bsp_nvm_write(nvid, (u8 *)&data, sizeof(u32)); if(ret) { nv_printf("write fail ,ret = 0x%x\n", ret); return ret; } } printf("\n****************第%d次测试开始 2222**************************\n", i); data = 20; ret = bsp_nvm_write(nvid, (u8 *)&data, sizeof(u32)); if(ret) { nv_printf("write fail 22222,ret = 0x%x\n", ret); return ret; } return NV_OK; }
u32 nv_write_test_08(u32 itemid) { struct nv_file_list_info_stru file_info = {}; struct nv_ref_data_info_stru ref_info = {}; u8* pData = NULL; u32 ret = 0; pData = (u8*)nv_malloc(2*2048); if(NULL == pData) { nv_printf("alloc error\n"); return NV_ERROR; } ret = nv_search_byid(itemid, (u8 *)NV_GLOBAL_CTRL_INFO_ADDR, &ref_info, &file_info); if(ret) { nv_printf("nv_search_byid error\n"); nv_free(pData); return ret; } ret = bsp_nvm_read(itemid, pData, ref_info.nv_len); if(ret) { nv_printf("bsp_nvm_read error, ret = 0x%x 1111\n", ret); return ret; } pData[0]++; ret = bsp_nvm_write(itemid, pData, ref_info.nv_len); if(ret) { nv_printf("bsp_nvm_read error, ret = 0x%x 2222\n", ret); return ret; } nv_free(pData); return NV_OK; }
/***************************************************************************** 函 数 名 : bsp_hi6559_exc_init 功能描述 : 异常处理模块初始化函数 输入参数 : 无 输出参数 : 无 返 回 值 : 无 *****************************************************************************/ s32 bsp_hi6559_exc_init(void) { hi6559_excflags_t exc_flags = 0; u32 *volt_need_off = (u32 *)SHM_PMU_OCP_INFO_ADDR; /*过流,需要关闭的过流源*/ s32 iret = 0; s32 ret = 0; u16 i = 0; u8 reg_temp = 0; /*init default nv config*/ memset((void*)&pmu_exc_pro, 0, sizeof(PMU_EXC_PRO_NV_STRU)); pmu_exc_pro.ulOcpIsOn = 1; /* 过流的电源可以重新打开 */ pmu_exc_pro.ulOcpIsOff = 1; /* 过流的电源需要关闭 */ pmu_exc_pro.ulOtpCurIsOff = 1; /* 发生过温后需要关闭非核心电源 */ pmu_exc_pro.ulOtpIsRst = 0; /* 发生过温后系统不重启 */ pmu_exc_pro.ulOtpIsOff = 1; /* 过温150度后PMU下电 */ pmu_exc_pro.ulOtpLimit = 125; /* 温度预警阈值125度 */ pmu_exc_pro.ulUvpIsRst = 1; /* 发生欠压后系统重启 */ #if (FEATURE_ON == MBB_COMMON) pmu_exc_pro.ulUvpLimit = 2700; /* 欠压预警阈值2700mV */ #else pmu_exc_pro.ulUvpLimit = 3000; /* 欠压预警阈值3000mV */ #endif spin_lock_init(&g_hi6559_exc_st.lock); /* 中断只在Acore实现,多core互斥锁 */ /* 读NV */ iret = (s32)bsp_nvm_read(NV_ID_DRV_NV_PMU_EXC_PRO,(u8 *)&pmu_exc_pro,sizeof(PMU_EXC_PRO_NV_STRU)); if(NV_OK != iret) { pmic_print_error("ERROR: read nv failed, ret %d!\n", iret); ret |= iret; } else { /* 设置过温预警阈值 */ bsp_hi6559_otp_threshold_set((int)pmu_exc_pro.ulOtpLimit); /* 设置欠压预警阈值 */ bsp_hi6559_uvp_threshold_set((int)pmu_exc_pro.ulUvpLimit); } /* 写start flag到log文件 */ hi6559_om_log_save(PMU_OM_LOG_START); /* 保存非下电寄存器 */ hi6559_boot_om_log_save(); /* 清除非下电寄存器 */ for(i = 0; i < HI6559_NP_RECORD_REG_NUM; i++) { spin_lock_irqsave(&g_hi6559_exc_st.lock,exc_flags); bsp_hi6559_reg_read((HI6559_NP_IRQ1_RECORD_OFFSET+i), ®_temp); bsp_hi6559_reg_write((HI6559_NP_IRQ1_RECORD_OFFSET+i), reg_temp); spin_unlock_irqrestore(&g_hi6559_exc_st.lock,exc_flags); } /* 初始化过流标志位 */ *volt_need_off = 0; /* 注册中断处理函数 */ iret = hi6559_irq_callback_register(IRQ_HI6559_OCP_SCP, hi6559_ocp_scp_handle, NULL); if (iret) { pmic_print_error("hi6559 irq register ocp interrupt failed!\n"); ret |= iret; } iret = hi6559_irq_callback_register(IRQ_HI6559_OTMP, hi6559_otp_handle, NULL); if (iret) { pmic_print_error("hi6559 irq register otmp interrupt failed!\n"); ret |= iret; } iret = hi6559_irq_callback_register(IRQ_HI6559_VSYS_UNDER_2P5, hi6559_uvp_die_handle, NULL); if (iret) { pmic_print_error("hi6559 irq register ocp interrupt failed!\n"); ret |= iret; } iret = hi6559_irq_callback_register(IRQ_HI6559_VSYS_UNDER_2P85, hi6559_uvp_warning_handle, NULL); if (iret) { pmic_print_error("hi6559 irq register otmp interrupt failed!\n"); ret |= iret; } iret = hi6559_irq_callback_register(IRQ_HI6559_VSYS_OVER_6P0, hi6559_ovp_handle, NULL); if (iret) { pmic_print_error("hi6559 irq register otmp interrupt failed!\n"); ret |= iret; } pmic_print_error("hi6559 exc init ok!\n"); return ret; }
int __init bsp_reset_init(void) { s32 ret = RESET_ERROR; struct device_node *np = NULL; memset(&(g_modem_reset_ctrl), 0, sizeof(g_modem_reset_ctrl)); memset(&g_reset_debug, 0, sizeof(g_reset_debug)); g_reset_debug.print_sw = 1; /* NV控制是否打开单独复位功能以及与RIL的对接 */ if(BSP_OK != bsp_nvm_read(NV_ID_DRV_CCORE_RESET, (u8*)&(g_modem_reset_ctrl.nv_config), sizeof(DRV_CCORE_RESET_STRU))) { reset_print_err("nv read fail, use default value\n"); } np = of_find_compatible_node(NULL, NULL, "hisilicon,crgctrl"); g_modem_reset_ctrl.crg_base = of_iomap(np, 0); if (!g_modem_reset_ctrl.crg_base) { reset_print_err("get crg_base fail!\n"); return RESET_ERROR; } bsp_reset_bootflag_set(CCORE_BOOT_NORMAL); /* 置上acore与ccore之间通信状态可用标识 */ g_modem_reset_ctrl.multicore_msg_switch = 1; g_modem_reset_ctrl.modem_action = MODEM_NORMAL; osl_sem_init(0, &g_modem_reset_ctrl.task_sem); osl_sem_init(0, &g_modem_reset_ctrl.wait_mcore_reply_sem); osl_sem_init(0, &g_modem_reset_ctrl.wait_mcore_reply_reseting_sem); osl_sem_init(0, &g_modem_reset_ctrl.wait_hifi_reply_sem); osl_sem_init(0, &g_modem_reset_ctrl.wait_ccore_reset_ok_sem); osl_sem_init(0, &g_modem_reset_ctrl.wait_modem_master_in_idle_sem); wake_lock_init(&g_modem_reset_ctrl.wake_lock, WAKE_LOCK_SUSPEND, "modem_reset wake"); spin_lock_init(&g_modem_reset_ctrl.action_lock); g_modem_reset_ctrl.task = kthread_run(modem_reset_task, NULL, "modem_reset"); if(!g_modem_reset_ctrl.task) { reset_print_err("create modem_reset thread fail!\n"); return RESET_ERROR; } ret = bsp_reset_cb_func_register("drv", drv_reset_cb, 0, DRV_RESET_CB_PIOR_ALL); if(ret != RESET_OK) { reset_print_err("register drv reset callback fail!\n"); return RESET_ERROR; } ret = DRV_MAILBOX_REGISTERRECVFUNC(MAILBOX_MAILCODE_HIFI_TO_ACPU_CCORE_RESET_ID, (mb_msg_cb)from_hifi_mailbox_readcb, NULL);/*lint !e713 */ if(MAILBOX_OK != ret) { reset_print_err("register mailbox callback fail"); return RESET_ERROR; } init_completion(&(g_modem_reset_ctrl.suspend_completion)); g_modem_reset_ctrl.pm_notify.notifier_call = reset_pm_notify; register_pm_notifier(&g_modem_reset_ctrl.pm_notify); g_modem_reset_ctrl.reset_wq = create_singlethread_workqueue("reset_wq"); BUG_ON(!g_modem_reset_ctrl.reset_wq); /*lint !e548 */ INIT_WORK(&(g_modem_reset_ctrl.work_reset), modem_reset_do_work); INIT_WORK(&(g_modem_reset_ctrl.work_power_off), modem_power_off_do_work); INIT_WORK(&(g_modem_reset_ctrl.work_power_on), modem_power_on_do_work); g_modem_reset_ctrl.ipc_recv_irq_idle = IPC_ACPU_INT_SRC_CCPU_RESET_IDLE; g_modem_reset_ctrl.ipc_recv_irq_reboot = IPC_ACPU_INT_SRC_CCPU_RESET_SUCC; g_modem_reset_ctrl.ipc_send_irq_wakeup_ccore = IPC_CCPU_INT_SRC_ACPU_RESET; if (bsp_ipc_int_connect(g_modem_reset_ctrl.ipc_recv_irq_idle, (voidfuncptr)reset_ipc_isr_idle, 0)) { reset_print_err("connect idle ipc fail!\n"); return RESET_ERROR; } if (bsp_ipc_int_enable(g_modem_reset_ctrl.ipc_recv_irq_idle)) { reset_print_err("enable idle ipc fail!\n"); return RESET_ERROR; } if (bsp_ipc_int_connect(g_modem_reset_ctrl.ipc_recv_irq_reboot, (voidfuncptr)reset_ipc_isr_reboot, 0)) { reset_print_err("connect reboot ipc fail!\n"); return RESET_ERROR; } if (bsp_ipc_int_enable(g_modem_reset_ctrl.ipc_recv_irq_reboot)) { reset_print_err("enable reboot ipc fail!\n"); return RESET_ERROR; } g_modem_reset_ctrl.state = 1; reset_print_err("ok\n"); return 0; }
void bsp_cross_mipi_init(void) { u32 i = 0; int ret = 0; static NV_CROSS_MIPI_MEM cross_mipi_mem; static NV_CROSS_MIPI_CTRL cross_mipi_ctrl; if (!g_is_cross_mipi_inited) { (void)memset_s((void*)&cross_mipi_mem, sizeof(cross_mipi_mem), 0, sizeof(cross_mipi_mem)); (void)memset_s((void*)&cross_mipi_ctrl, sizeof(cross_mipi_ctrl), 0, sizeof(cross_mipi_ctrl)); ret = (int)bsp_nvm_read(NV_GU_RF_CROSS_MIPI_MEM_ID, (u8*)&cross_mipi_mem, sizeof(cross_mipi_mem)); if (ret) { bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_CROSS_MIPI, "fail to read cross mipi nv, id: %d\n", NV_GU_RF_CROSS_MIPI_MEM_ID); return; } ret = (int)bsp_nvm_read(NV_GU_RF_CROSS_MIPI_CTRL_ID, (u8*)&cross_mipi_ctrl, sizeof(cross_mipi_ctrl)); if (ret) { bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_CROSS_MIPI, "fail to read cross mipi nv, id: %d\n", NV_GU_RF_CROSS_MIPI_CTRL_ID); return; } g_cross_mipi_ctu_base_addr = (u32)bsp_bbp_part_addr_get(BBP_CTU); g_cross_mipi_mem_base_addr = (u32)bsp_bbp_part_addr_get(BBP_CROSS_MIPI_MEM); g_cross_mipi_ctrl_base_addr = (u32)bsp_bbp_part_addr_get(BBP_CROSS_MIPI_CTRL); #ifdef CONFIG_CCORE_PM ret = bsp_device_pm_add(&g_cross_mipi_dpm_device); if (ret) { bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_CROSS_MIPI, "fail to add cross_mipi dpm device\r\n"); return; } #endif } if (cross_mipi_ctrl.tuner_en) { writel(cross_mipi_ctrl.tuner_en, g_cross_mipi_ctrl_base_addr + CROSS_MIPI_EN_OFFSET); writel(cross_mipi_ctrl.tuner_req_en, g_cross_mipi_ctrl_base_addr + CROSS_MIPI_REQ_EN_OFFSET); writel(~cross_mipi_ctrl.reg.tuner_mipi_mask, g_cross_mipi_ctu_base_addr + CROSS_MIPI_MASK_OFFSET); writel(~cross_mipi_ctrl.reg.gpio_primary_en, g_cross_mipi_ctu_base_addr + CROSS_MIPI_M0_LINE_P_MASK_OFFSET); writel(~cross_mipi_ctrl.reg.gpio_secondary_en, g_cross_mipi_ctu_base_addr + CROSS_MIPI_M0_LINE_S_MASK_OFFSET); writel(~cross_mipi_ctrl.reg.gpio_modem1_en, g_cross_mipi_ctu_base_addr + CROSS_MIPI_M1_LINE_MASK_OFFSET); for (i = 0; i < sizeof(cross_mipi_mem.gpio_buffer)/sizeof(cross_mipi_mem.gpio_buffer[0][0]); i++) writel(cross_mipi_mem.gpio_buffer[0][i], g_cross_mipi_mem_base_addr + CROSS_MIPI_GPIO_MEM_OFFSET + i*4); for (i = 0; i < sizeof(cross_mipi_mem.mipi_buffer)/sizeof(cross_mipi_mem.mipi_buffer[0][0]); i++) writel(cross_mipi_mem.mipi_buffer[0][i], g_cross_mipi_mem_base_addr + CROSS_MIPI_MIPI_MEM_OFFSET + i*4); writel(0x7, g_cross_mipi_ctu_base_addr + CROSS_MIPI_FORCE_OUTPUT_OFFSET); writel(0x700, g_cross_mipi_ctu_base_addr + CROSS_MIPI_OUTPUT_VALUE_OFFSET); udelay(1); writel(0x0, g_cross_mipi_ctu_base_addr + CROSS_MIPI_OUTPUT_VALUE_OFFSET); writel(0x0, g_cross_mipi_ctu_base_addr + CROSS_MIPI_FORCE_OUTPUT_OFFSET); } if (!g_is_cross_mipi_inited) { g_is_cross_mipi_inited = 1; bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_CROSS_MIPI, "cross mipi init ok\n"); } }