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");
}
}
