VOS_VOID TAF_APS_ReadDsflowRateConfigFromNv(TAF_APS_SWITCH_DDR_RATE_INFO_STRU *pstSwitchDdrInfo)
{
TAF_NV_DFS_DSFLOW_RATE_CONFIG_STRU stRateConfig;
TAF_NV_MULTI_DFS_DSFLOW_RATE_CONFIG_STRU stMultiDfsConfig;
VOS_UINT32 ulIndex;
PS_MEM_SET(&stRateConfig, 0, sizeof(TAF_NV_DFS_DSFLOW_RATE_CONFIG_STRU));
PS_MEM_SET(&stMultiDfsConfig, 0, sizeof(TAF_NV_MULTI_DFS_DSFLOW_RATE_CONFIG_STRU));
/* 从NV中读取流速配置NV项 */
if (NV_OK != NV_Read (en_NV_Item_Dfs_Dsflow_Rate_Config,
&stRateConfig, sizeof(TAF_NV_DFS_DSFLOW_RATE_CONFIG_STRU)))
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_APS_ReadDsflowRateConfigFromNv(): NV_Read en_NV_Item_Dsflow_Rate_Config Error");
return;
}
if (NV_OK != NV_Read (en_NV_Item_Multi_Dfs_Dsflow_Rate_CFG,
&stMultiDfsConfig, sizeof(TAF_NV_MULTI_DFS_DSFLOW_RATE_CONFIG_STRU)))
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_APS_ReadDsflowRateConfigFromNv(): NV_Read en_NV_Item_Multi_Dfs_Dsflow_Rate_CFG Error");
return;
}
if (0 == stMultiDfsConfig.astDfsConfig[0].ulProfileNum)
{
if (0 == stRateConfig.ulProfileNum)
{
PS_MEM_SET((VOS_VOID *)pstSwitchDdrInfo->astDfsConfig, 0, sizeof(TAF_NV_DFS_DSFLOW_RATE_CONFIG_STRU) * TAF_NVIM_DIFF_DFS_NUM);
return;
}
pstSwitchDdrInfo->ulMultiDfsFlg = VOS_FALSE;
TAF_APS_Recorrect_ProfileNum(&stRateConfig, 1);
PS_MEM_CPY(&pstSwitchDdrInfo->astDfsConfig[0], &stRateConfig, sizeof(TAF_NV_DFS_DSFLOW_RATE_CONFIG_STRU));
}
else
{
pstSwitchDdrInfo->ulMultiDfsFlg = VOS_TRUE;
TAF_APS_Recorrect_ProfileNum(stMultiDfsConfig.astDfsConfig, TAF_NVIM_DIFF_DFS_NUM);
PS_MEM_CPY((VOS_VOID *)pstSwitchDdrInfo->astDfsConfig, (VOS_VOID *)stMultiDfsConfig.astDfsConfig, sizeof(TAF_NV_MULTI_DFS_DSFLOW_RATE_CONFIG_STRU));
}
/* NV的第一个profile存的是最小的ddr频率 */
pstSwitchDdrInfo->ulMinBand = pstSwitchDdrInfo->astDfsConfig[0].astProfile[0].ulDdrBand;
/* NV的最后一个profile存的是最大的ddr频率 */
ulIndex = pstSwitchDdrInfo->astDfsConfig[0].ulProfileNum - 1;
pstSwitchDdrInfo->ulMaxBand = pstSwitchDdrInfo->astDfsConfig[0].astProfile[ulIndex].ulDdrBand;
return;
}
VOS_VOID TAF_MMA_ReadRfAutoTestFlagNvim(VOS_VOID)
{
VOS_UINT32 ulDataLen;
VOS_UINT32 ulAutoSwitchOnFlg;
ulAutoSwitchOnFlg = MMA_RF_AUTO_TEST_DISABLE;
ulDataLen = sizeof(VOS_UINT16);
if (NV_OK != NV_Read(en_NV_Item_RF_Auto_Test_Flag,
(VOS_VOID*)(&(ulAutoSwitchOnFlg)),
ulDataLen))
{
TAF_MMA_SetAutoSwitchOnFlg(MMA_RF_AUTO_TEST_ENABLE);
return;
}
TAF_MMA_SetAutoSwitchOnFlg(ulAutoSwitchOnFlg);
#if 0
#ifdef NAS_STUB
TAF_MMA_SetAutoSwitchOnFlg(MMA_RF_AUTO_TEST_DISABLE);
#endif
#endif
return;
}
VOS_VOID MN_CAL_ReadVideoCallNvim( VOS_VOID )
{
MN_CALL_NV_ITEM_VIDEO_CALL_STRU stVideoCall;
VOS_UINT32 ulResult;
VOS_UINT32 ulLength;
ulLength = 0;
stVideoCall.ucStatus = VOS_FALSE;
stVideoCall.ucVpCfgState = MN_CALL_VP_BUTT;
NV_GetLength(en_NV_Item_VIDEO_CALL, &ulLength);
ulResult = NV_Read(en_NV_Item_VIDEO_CALL,
&stVideoCall,
ulLength);
/* PC工程,回放工程,CC默认打开 */
#if (defined(__PS_WIN32_RECUR__))
stVideoCall.ucStatus = VOS_TRUE;
stVideoCall.ucVpCfgState = MN_CALL_VP_MO_MT_BOTH;
#endif
if((ulResult == NV_OK)
&&(VOS_TRUE == stVideoCall.ucStatus))
{
TAF_CALL_SetVpCfgState(stVideoCall.ucVpCfgState);
}
else
{
TAF_CALL_SetVpCfgState(MN_CALL_VP_MO_MT_BOTH);
}
return;
}
VOS_VOID MN_CALL_ReadCustomizeServiceNvim( VOS_VOID )
{
NAS_NVIM_CUSTOMIZE_SERVICE_STRU stCustomServ;
VOS_UINT32 ulResult;
stCustomServ.ulStatus = VOS_FALSE;
stCustomServ.ulCustomizeService = VOS_FALSE;
/* 读取对应的几个NV项，并保存到全局变量中 */
ulResult = NV_Read(en_NV_Item_CustomizeService,
&stCustomServ,
sizeof(stCustomServ));
/* PC工程,回放工程,CC默认打开 */
#if (defined(__PS_WIN32_RECUR__))
stCustomServ.ulStatus = VOS_TRUE;
stCustomServ.ulCustomizeService = VOS_TRUE;
#endif
if((ulResult == NV_OK)
&&(VOS_TRUE == stCustomServ.ulStatus)
&&(VOS_TRUE == (stCustomServ.ulCustomizeService&0x01)))
{
TAF_CALL_SetCallStatusControl(VOS_TRUE);
}
else
{
TAF_CALL_SetCallStatusControl(VOS_FALSE);
}
return;
}
BST_VOID BST_SYS_InitBastetNvFlag(BST_VOID)
{
BASTET_SUPPORT_FLG_STRU stBastetFlag;
PS_MEM_SET(&stBastetFlag, 0x00, sizeof(BASTET_SUPPORT_FLG_STRU));
/* 读NV项en_NV_MODEM_RF_SHARE_CFG，失败，直接返回 */
if (NV_OK != NV_Read(en_NV_Item_Bastet_CONFIG,
&stBastetFlag, sizeof(BASTET_SUPPORT_FLG_STRU)))
{
BST_RLS_LOG("BST_SYS_InitBastetNvFlag():WARNING: read en_NV_Item_Bastet_CONFIG Error");
return;
}
if (BST_TRUE != stBastetFlag.ucActiveFlg)
{
/* NV内容异常保护 */
g_BstBastetFlg = BST_FALSE;
}
else
{
g_BstBastetFlg = BST_TRUE;
}
return;
}
VOS_VOID CNAS_HSM_ReadHrpdAccessAuthInfoNvim(VOS_VOID)
{
CNAS_NVIM_HRPD_ACCESS_AUTH_INFO_STRU stHrpdAccessAuthInfo;
CNAS_CCB_HRPD_ACCESS_AUTH_INFO_STRU *pstLastHrpdAccessAuthInfo;
pstLastHrpdAccessAuthInfo = CNAS_HSM_GetLastHrpdAccessAuthInfoCtxAddr();
NAS_MEM_SET_S(&stHrpdAccessAuthInfo, sizeof(stHrpdAccessAuthInfo), 0, sizeof(CNAS_NVIM_HRPD_ACCESS_AUTH_INFO_STRU));
if (NV_OK != NV_Read(en_Nv_Item_CNAS_HRPD_ACCESS_AUTH_INFO, &stHrpdAccessAuthInfo,
sizeof(CNAS_NVIM_HRPD_ACCESS_AUTH_INFO_STRU)))
{
CNAS_ERROR_LOG(UEPS_PID_HSM, "CNAS_HSM_ReadHrpdAccessAuthInfoNvim: Read Nvim Failed");
return;
}
CNAS_MNTN_LogReadNVInfo(en_Nv_Item_CNAS_HRPD_ACCESS_AUTH_INFO,
sizeof(CNAS_NVIM_HRPD_ACCESS_AUTH_INFO_STRU),
UEPS_PID_HSM,
(VOS_UINT8 *)&stHrpdAccessAuthInfo);
pstLastHrpdAccessAuthInfo->ucAccessAuthAvailFlag = stHrpdAccessAuthInfo.ucAccessAuthAvailFlag;
if (VOS_TRUE == stHrpdAccessAuthInfo.ucAccessAuthAvailFlag)
{
pstLastHrpdAccessAuthInfo->ucAccessAuthUserNameLen = stHrpdAccessAuthInfo.ucAccessAuthUserNameLen;
NAS_MEM_CPY_S(pstLastHrpdAccessAuthInfo->aucAccessAuthUserName,
sizeof(pstLastHrpdAccessAuthInfo->aucAccessAuthUserName),
stHrpdAccessAuthInfo.aucAccessAuthUserName,
stHrpdAccessAuthInfo.ucAccessAuthUserNameLen);
}
}
VOS_VOID CNAS_HSM_ReadHrpdSessionInfoExNvim(VOS_VOID)
{
CNAS_NVIM_HRPD_SESSION_INFO_EX_STRU stHrpdSessionInfoEx;
CNAS_NVIM_HRPD_UE_REV_INFO_STRU *pstLastHrpdUERevInfo;
NAS_MEM_SET_S(&stHrpdSessionInfoEx, sizeof(stHrpdSessionInfoEx), 0, sizeof(CNAS_NVIM_HRPD_SESSION_INFO_EX_STRU));
if (NV_OK != NV_Read(en_NV_Item_CNAS_HRPD_Session_Info_Ex, &stHrpdSessionInfoEx,
sizeof(CNAS_NVIM_HRPD_SESSION_INFO_EX_STRU)))
{
CNAS_ERROR_LOG(UEPS_PID_HSM, "CNAS_HSM_ReadHrpdSessionInfoExNvim: Read Nvim Failed");
return;
}
CNAS_MNTN_LogReadNVInfo(en_NV_Item_CNAS_HRPD_Session_Info_Ex,
sizeof(CNAS_NVIM_HRPD_SESSION_INFO_EX_STRU),
UEPS_PID_HSM,
(VOS_UINT8 *)&stHrpdSessionInfoEx);
CNAS_HSM_SetSessionSeed(stHrpdSessionInfoEx.ulSessionSeed);
pstLastHrpdUERevInfo = CNAS_HSM_GetLastHrpdUERevInfoCtxAddr();
NAS_MEM_CPY_S(pstLastHrpdUERevInfo,
sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU),
&(stHrpdSessionInfoEx.stUERevInfo),
sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU));
}
VOS_VOID NAS_UTRANCTRL_ReadSmcCtrlFlgNvim( VOS_VOID )
{
NAS_UTRANCTRL_NVIM_SMC_CTRL_FLAG_STRU stSmcCtrlFlg;
PS_MEM_SET(&stSmcCtrlFlg, 0x00, sizeof(NAS_UTRANCTRL_NVIM_SMC_CTRL_FLAG_STRU));
if ( NV_OK != NV_Read(en_NV_Item_SMC_Ctrl_Flg, &stSmcCtrlFlg, sizeof(NAS_UTRANCTRL_NVIM_SMC_CTRL_FLAG_STRU)) )
{
NAS_ERROR_LOG(WUEPS_PID_MMC, "NAS_UTRANCTRL_ReadSmcCtrlFlgNvim():WARNING: en_NV_Item_SMC_Ctrl_Flg Error");
return;
}
/* NV中的异常原因值转换 */
if ( (VOS_FALSE != stSmcCtrlFlg.ucIsUtranTddCsSmcNeeded)
&& (VOS_TRUE != stSmcCtrlFlg.ucIsUtranTddCsSmcNeeded))
{
stSmcCtrlFlg.ucIsUtranTddCsSmcNeeded = VOS_TRUE;
}
if ( (VOS_FALSE != stSmcCtrlFlg.ucIsUtranTddPsSmcNeeded)
&& (VOS_TRUE != stSmcCtrlFlg.ucIsUtranTddPsSmcNeeded))
{
stSmcCtrlFlg.ucIsUtranTddPsSmcNeeded = VOS_TRUE;
}
/* 保存NVIM中的UTRAN TDD模式下是否需要检测SMC流程值 */
NAS_UTRANCTRL_SetUtranTddCsSmcNeededFlg(stSmcCtrlFlg.ucIsUtranTddCsSmcNeeded);
NAS_UTRANCTRL_SetUtranTddPsSmcNeededFlg(stSmcCtrlFlg.ucIsUtranTddPsSmcNeeded);
return;
}
VOS_VOID USIMM_VsimConfidentialDataVerifyErrHandle(VOS_VOID)
{
NVIM_VSIM_HVSDH_NV_STRU stDhNv = {0};
VSIM_ALGORITHM_TYPE_ENUM_UINT32 enAlgorithm = {0};
USIMM_ClearVsimGlobal();
/* 清除公私钥 */
if (NV_OK != NV_Read(en_NV_Item_VSIM_HVSDH_INFO, &stDhNv, sizeof(stDhNv)))
{
USIMM_WARNING_LOG("USIMM_VsimConfidentialDataVerify: Get HVSDT Info failed.");
}
enAlgorithm = stDhNv.enAlgorithm;
VOS_MemSet(&stDhNv, 0, sizeof(NVIM_VSIM_HVSDH_NV_STRU));
stDhNv.enAlgorithm = enAlgorithm;
if (NV_OK != NV_Write(en_NV_Item_VSIM_HVSDH_INFO, &stDhNv, sizeof(stDhNv)))
{
USIMM_WARNING_LOG("USIMM_VsimConfidentialDataVerify: Clean HVSDT Info failed.");
}
USIMM_VsimReDhNegotiateInd();
return;
}
VOS_UINT32 Monitor_Init(VOS_VOID)
{
/*读取开关分集的USIM卡温度门限*/
if(NV_OK != NV_Read(en_NV_Item_W_USIM_TEMP_ANT2_CTRL,
(VOS_VOID*)&g_stMonitorUsimAntCtrl,
sizeof(MONITOR_USIM_ANT2_CTRL)))
{
g_ulMonitorErrCode |= MONITOR_ERR_CODE_NV;
return VOS_ERR;
}
if (VOS_OK != VOS_SmCCreate("MONS", 0, VOS_SEMA4_FIFO, &(g_ulMonitorCtrlSem)))
{
g_ulMonitorErrCode |= MONITOR_ERR_CODE_SEM;
return VOS_ERR;
}
#if (VOS_VXWORKS == VOS_OS_VER)
taskSpawn("MONITOR_TASK", 159, 0, 10240,(FUNCPTR)Monitor_QueryTask, 0, 0, 0, 0, 0, 0, 0, 0,0,0);
#endif
return VOS_OK;
}
VOS_VOID STK_ProfileInit(USIMM_STK_CFG_STRU *pstSTKProfileContent, VOS_UINT32 ulCardType)
{
VOS_UINT8 aucUsimProfile[]=STK_USIM_PROFILE_DEFAULT;
VOS_UINT8 aucSimProfile[]= {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xC0,
0xFF,0xFF,0xFF,0xF9,0xFF,0xF7,0xC0,0xFF,0xF0,0xFF};
if (NV_OK == NV_Read(en_NV_Item_TerminalProfile_Set, pstSTKProfileContent, sizeof(USIMM_STK_CFG_STRU)))
{
return;
}
pstSTKProfileContent->ucTimer = STK_POROTECT_TIME_LEN; /*定时器长度的单位是秒*/
pstSTKProfileContent->ucFuncEnable = TAF_TRUE;
if (USIMM_CARD_USIM == ulCardType)
{
VOS_MemCpy(pstSTKProfileContent->stUsimProfile.aucProfile, aucUsimProfile, sizeof(aucUsimProfile));
pstSTKProfileContent->stUsimProfile.ucProfileLen = sizeof(aucUsimProfile);
}
else
{
VOS_MemCpy(pstSTKProfileContent->stSimProfile.aucProfile, aucSimProfile, sizeof(aucSimProfile));
pstSTKProfileContent->stSimProfile.ucProfileLen = sizeof(aucSimProfile);
}
return;
}
VOS_UINT32 PPM_LogFileInit(VOS_VOID)
{
OM_CHANNLE_PORT_CFG_STRU stPortCfg;
/*读取SD Log在NV中的配置*/
if(NV_OK != NV_Read(en_NV_Item_Om_Port_Type, &stPortCfg, sizeof(OM_CHANNLE_PORT_CFG_STRU)))
{
PS_LOG(WUEPS_PID_OM, 0, PS_PRINT_ERROR, "PPM_LogFileInit:Read NV Config fail!");
return VOS_OK;
}
/* 读取SD Log在NV中的配置为输出到SD卡的时候才使能 */
if (CPM_OM_PORT_TYPE_SD == stPortCfg.enPortNum)
{
OM_SDInit();
return VOS_OK;
}
#if (VOS_OS_VER == VOS_LINUX)
else if (CPM_OM_PORT_TYPE_FS == stPortCfg.enPortNum)
{
PPM_FSInitLogFile();
return VOS_OK;
}
#endif
return VOS_OK;
}
VOS_VOID TAF_MMA_ReadAttEnsCustomNvim(VOS_VOID)
{
NVIM_ATT_ENS_CTRL_STRU stNvAttEns;
PS_MEM_SET(&stNvAttEns, 0x00, sizeof(stNvAttEns));
/* 读NV项en_NV_Item_Att_Ens_Ctrl_Para失败 */
if (NV_OK != NV_Read(en_NV_Item_Att_Ens_Ctrl_Para,
&stNvAttEns,
sizeof(NVIM_ATT_ENS_CTRL_STRU)))
{
MMA_ERRORLOG("TAF_MMA_ReadATTCustomNvim(): Read NV Fail");
return;
}
/* 置网络选择菜单控制标识 */
if (VOS_TRUE == stNvAttEns.ucNetSelMenuFlg)
{
TAF_MMA_SetNetworkSelectionMenuEnableFlg(VOS_TRUE);
}
/* 置接入技术平衡控制标识 */
if (VOS_TRUE == stNvAttEns.ucRatBalancingFlg)
{
TAF_MMA_SetRatBalancingEnableFlg(VOS_TRUE);
}
return;
}
VOS_VOID TAF_MMA_ReadSystemAppCofigNvim(VOS_VOID)
{
VOS_UINT32 ulLength;
NAS_NVIM_SYSTEM_APP_CONFIG_STRU stSysAppConfig;
PS_MEM_SET(&stSysAppConfig, 0x00, sizeof(NAS_NVIM_SYSTEM_APP_CONFIG_STRU));
/* 读取en_NV_Item_System_APP_Config，获取对接的上层应用 */
NV_GetLength(en_NV_Item_System_APP_Config, &ulLength);
if (NV_OK != NV_Read(en_NV_Item_System_APP_Config,
&stSysAppConfig, ulLength))
{
stSysAppConfig.usSysAppConfigType = SYSTEM_APP_MP;
MMA_WARNINGLOG("TAF_MMA_ReadSystemAppCofigNvim():Read en_NV_Item_System_APP_Config Failed!");
}
if ( SYSTEM_APP_ANDROID < stSysAppConfig.usSysAppConfigType)
{
g_usMmaAppConfigSupportType = SYSTEM_APP_MP;
MMA_WARNINGLOG("TAF_MMA_ReadSystemAppCofigNvim():en_NV_Item_System_APP_Config error!");
}
else
{
g_usMmaAppConfigSupportType = stSysAppConfig.usSysAppConfigType;
}
return;
}
VOS_VOID TAF_MMA_ReadDisplaySpnFlagNvim(VOS_VOID)
{
VOS_UINT32 ulLength;
NAS_MMA_NVIM_DISPLAY_SPN_FLAG_STRU stSpnFlag;
PS_MEM_SET(&stSpnFlag, 0x00, sizeof(NAS_MMA_NVIM_DISPLAY_SPN_FLAG_STRU));
NV_GetLength(en_NV_Item_Display_Spn_Flag, &ulLength);
if (NV_OK != NV_Read(en_NV_Item_Display_Spn_Flag,
(VOS_VOID*)(&stSpnFlag),
ulLength))
{
gstMmaValue.ucCopsNotDisplaySpnFlg = MMA_FALSE;
}
else if (NV_ITEM_ACTIVE == (stSpnFlag.aucDisplaySpnFlag)[0])
{
gstMmaValue.ucCopsNotDisplaySpnFlg = (stSpnFlag.aucDisplaySpnFlag)[1];
}
else
{
}
return;
}
VOS_VOID SSA_GetUssdMode(VOS_VOID)
{
TAF_USSD_NVIM_TRANS_MODE_STRU stUssdTranMode;
VOS_UINT32 ulLength;
ulLength = 0;
PS_MEM_SET(&stUssdTranMode, 0x00, sizeof(stUssdTranMode));
NV_GetLength(en_NV_Item_CUST_USSD_MODE, &ulLength);
/*读取USSD是否透传设置 */
if (NV_OK == NV_Read(en_NV_Item_CUST_USSD_MODE,
&stUssdTranMode,
ulLength))
{
if (TAF_SSA_NVIM_ITEM_ACTIVE == stUssdTranMode.ucStatus)
{
g_usTafSsaUssdTransMode = stUssdTranMode.ucUssdTransMode;
}
else
{
g_usTafSsaUssdTransMode = AT_USSD_TRAN_MODE;
}
}
else
{
g_usTafSsaUssdTransMode = AT_USSD_TRAN_MODE;
}
return;
}
VOS_VOID NAS_UTRANCTRL_ReadUtranModeNvim( VOS_VOID )
{
NAS_UTRANCTRL_NVIM_UTRAN_MODE_STRU stUtranMode;
VOS_UINT32 ulLength;
ulLength = 0;
PS_MEM_SET(&stUtranMode, 0x00, sizeof(NAS_UTRANCTRL_NVIM_UTRAN_MODE_STRU));
NV_GetLength(en_NV_Item_Utran_Mode, &ulLength);
if (ulLength > sizeof(stUtranMode))
{
return;
}
if ( NV_OK != NV_Read(en_NV_Item_Utran_Mode, &stUtranMode, ulLength) )
{
NAS_ERROR_LOG(WUEPS_PID_MMC, "NAS_UTRANCTRL_ReadUtranModeNvim():WARNING: en_NV_Item_Utran_Mode Error");
return;
}
/* 将NVIM中读取的UTRAN模式保存到NASUTRANCTRL中的全局变量中 */
NAS_UTRANCTRL_SetCurrUtranMode(stUtranMode.ucUtranMode);
return;
}
VOS_VOID MTC_InitIntrusionCtx(VOS_VOID)
{
VOS_UINT32 ulRet;
MTC_INTRUSION_CTX_STRU *pstMtcIntrusionCtx = VOS_NULL_PTR;
pstMtcIntrusionCtx = MTC_GetIntrusionCtxAddr();
/* 初始化上下文 */
PS_MEM_SET(pstMtcIntrusionCtx, 0, sizeof(MTC_INTRUSION_CTX_STRU));
/* 读取NV项 */
ulRet = NV_Read(en_NV_Item_RF_INTRUSION_CFG,
&pstMtcIntrusionCtx->stIntrusionCfg,
sizeof(MTC_NV_RF_INTRUSION_CFG_STRU));
if (VOS_OK != ulRet)
{
MTC_WARNING_LOG("MTC_InitIntrusionCtx: Read Nv Fail.");
}
MTC_SetNotchEnalbeFlag(PS_FALSE);
MTC_SetNarrowDcsEnalbeFlag(PS_FALSE);
MTC_SetTlRfCtrlEnalbeFlag(PS_FALSE);
MTC_SetRseCfgValue(PS_FALSE);
return;
}
VOS_VOID CNAS_HSM_ReadSessionKeepAliveInfoNvim(VOS_VOID)
{
CNAS_HSM_NVIM_SESSION_KEEP_ALIVE_INFO_STRU stNvimKeepAliveInfo;
NAS_MEM_SET_S(&stNvimKeepAliveInfo, sizeof(stNvimKeepAliveInfo), 0, sizeof(CNAS_HSM_NVIM_SESSION_KEEP_ALIVE_INFO_STRU));
if (NV_OK != NV_Read(en_Nv_Item_CNAS_HRPD_Session_Keep_Alive_Info, &stNvimKeepAliveInfo,
sizeof(CNAS_HSM_NVIM_SESSION_KEEP_ALIVE_INFO_STRU)))
{
CNAS_ERROR_LOG(UEPS_PID_HSM, "CNAS_HSM_ReadSessionKeepAliveInfoNvim: Error in NV_Read");
return;
}
CNAS_MNTN_LogReadNVInfo(en_Nv_Item_CNAS_HRPD_Session_Keep_Alive_Info,
sizeof(CNAS_HSM_NVIM_SESSION_KEEP_ALIVE_INFO_STRU),
UEPS_PID_HSM,
(VOS_UINT8 *)&stNvimKeepAliveInfo);
/* invalid keep alive info,directly return */
if (VOS_FALSE == stNvimKeepAliveInfo.ucIsKeepAliveInfoValid)
{
return;
}
/* Copy the values from the NV to the Keep alive timer context */
CNAS_HSM_SetTsmpClose(stNvimKeepAliveInfo.usTsmpClose);
CNAS_HSM_SetKeepAliveInfoValidFlag(stNvimKeepAliveInfo.ucIsKeepAliveInfoValid);
CNAS_HSM_SetTsmpCloseRemainTime(stNvimKeepAliveInfo.ulTsmpCloseRemainTime);
CNAS_HSM_SetLastPowerOffSysTime(stNvimKeepAliveInfo.aulLastPowerOffSysTime);
}
VOS_VOID MTC_InitPsTransferCtx(VOS_VOID)
{
VOS_UINT32 ulRet;
MTC_PS_TRANSFER_CTX_STRU *pstPsTransferCtx = VOS_NULL_PTR;
pstPsTransferCtx = MTC_GetPsTransferCtxAddr();
/* 初始化上下文 */
PS_MEM_SET(pstPsTransferCtx, 0, sizeof(MTC_PS_TRANSFER_CTX_STRU));
/* 初始化PSTRANSFER的上报状态值 */
pstPsTransferCtx->enReportCause = MTC_PS_TRANSFER_CAUSE_BUTT;
pstPsTransferCtx->enRrcCause = MTC_PS_TRANSFER_CAUSE_BUTT;
/* 读取NV项 */
ulRet = NV_Read(en_NV_Item_PS_TRANSFER_CFG,
&pstPsTransferCtx->stPsTransferCfg,
sizeof(MTC_NV_PS_TRANSFER_CFG_STRU));
if (VOS_OK != ulRet)
{
MTC_WARNING_LOG("MTC_InitPsTransferCtx: Read Nv Fail.");
}
return;
}
VOS_VOID CNAS_HSM_ReadHrpdUERevInfoNvim(VOS_VOID)
{
CNAS_NVIM_HRPD_UE_REV_INFO_STRU *pstHrpdUERevInfo;
CNAS_NVIM_HRPD_UE_REV_INFO_STRU stHrpdUERevInfo;
NAS_MEM_SET_S(&stHrpdUERevInfo, sizeof(stHrpdUERevInfo), 0, sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU));
if (NV_OK != NV_Read(en_NV_Item_CAS_HRPD_NVIM_AT_REV, &stHrpdUERevInfo,
sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU)))
{
CNAS_ERROR_LOG(UEPS_PID_HSM, "CNAS_HSM_ReadHrpdUERevInfoNvim: Read Nvim Failed");
return;
}
CNAS_MNTN_LogReadNVInfo(en_NV_Item_CAS_HRPD_NVIM_AT_REV,
sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU),
UEPS_PID_HSM,
(VOS_UINT8 *)&stHrpdUERevInfo);
pstHrpdUERevInfo = CNAS_HSM_GetHrpdUERevInfoCtxAddr();
NAS_MEM_CPY_S(pstHrpdUERevInfo, sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU), &stHrpdUERevInfo, sizeof(CNAS_NVIM_HRPD_UE_REV_INFO_STRU));
}
VOS_VOID NAS_RABM_ReadVoicePreferNvim(VOS_VOID)
{
NAS_RABM_NVIM_WCDMA_VOICE_PREFER_STRU stVoicePreferCfg;
VOS_UINT32 ulLength;
ulLength = 0;
PS_MEM_SET(&stVoicePreferCfg, 0x00, sizeof(NAS_RABM_NVIM_WCDMA_VOICE_PREFER_STRU));
/* 读NV失败，认为不允许VoicePrefer */
NV_GetLength(en_NV_Item_Wcdma_Voice_Prefer_Cfg, &ulLength);
if (ulLength > sizeof(NAS_RABM_NVIM_WCDMA_VOICE_PREFER_STRU))
{
NAS_WARNING_LOG(WUEPS_PID_RABM, "NAS_RABM_ReadVoicePreferNvim:WARNING:NV_GetLength ulLength fail!");
g_stNasRabmVoicePreferCtx.ucVoicePreferNvimEnableFlag = VOS_FALSE;
return;
}
if (NV_OK != NV_Read(en_NV_Item_Wcdma_Voice_Prefer_Cfg, &stVoicePreferCfg,
ulLength))
{
NAS_WARNING_LOG(WUEPS_PID_RABM, "NAS_RABM_ReadVoicePreferNvim:WARNING:NV_Read faild!");
g_stNasRabmVoicePreferCtx.ucVoicePreferNvimEnableFlag = VOS_FALSE;
return;
}
g_stNasRabmVoicePreferCtx.ucVoicePreferNvimEnableFlag = stVoicePreferCfg.ucEnableFlag;
g_stNasRabmVoicePreferCtx.ulNvTestMcc = stVoicePreferCfg.ulMcc;
g_stNasRabmVoicePreferCtx.ulNvTestMnc = stVoicePreferCfg.ulMnc;
return;
}
VOS_UINT32 OM_StartUpLogSaveReq(APP_OM_MSG_EX_STRU *pstAppToOmMsg,
VOS_UINT16 usReturnPrimId)
{
VOS_UINT32 ulResult;
LOG_FILE_SAVE_CONFIG_STRU stLogFileSaveCfg;
/* 读取NV项，更新默认文件大小以及校准结果 */
ulResult = NV_Read(en_NV_Item_LOG_FILE_SAVE, &stLogFileSaveCfg, sizeof(LOG_FILE_SAVE_CONFIG_STRU));
if (NV_OK != ulResult)
{
PS_LOG(WUEPS_PID_OM, 0, PS_PRINT_WARNING, "OM_StartUpLogSaveReq: NV_Read failed.\n");
/* 返回结果ATE */
OM_SendResult(pstAppToOmMsg->ucFuncType, ulResult, usReturnPrimId);
return VOS_OK;
}
if ( VOS_OK != stLogFileSaveCfg.ulResult )
{
/* 返回结果ATE */
OM_SendResult(pstAppToOmMsg->ucFuncType, stLogFileSaveCfg.ulResult, usReturnPrimId);
return VOS_OK;
}
/*初始化LOG文件保存*/
ulResult = OM_LittleImgInitLogFile(stLogFileSaveCfg.ulLogFileSize);
/* 返回结果ATE */
OM_SendResult(pstAppToOmMsg->ucFuncType, ulResult, usReturnPrimId);
return VOS_OK;
}
VOS_UINT32 OM_GetLogPath(VOS_CHAR *pucBuf, VOS_CHAR *pucOldPath, VOS_CHAR *pucUnitaryPath)
{
NV_PRODUCT_TYPE_FOR_LOG_DIRECTORY stLogDir;
VOS_UINT32 ulRslt;
/*lint -e534*/
VOS_MemSet(&stLogDir, 0, sizeof(stLogDir));
/*lint +e534*/
ulRslt = NV_Read(en_NV_Item_ProductTypeForLogDirectory, &stLogDir, sizeof(stLogDir));
if (VOS_OK != ulRslt)
{
/* 读NV失败,直接返回 */
return VOS_ERR;
}
/*0:MBB V3R3 stick/E5,etc.; 1:V3R3 M2M & V7R2; 2:V9R1 phone; 3:K3V3&V8R1;*/
if ((1 == stLogDir.usProductType) || (3 == stLogDir.usProductType))
{
/*lint -e534*/
VOS_StrCpy(pucBuf, pucUnitaryPath);
/*lint +e534*/
}
else
{
/*lint -e534*/
VOS_StrCpy(pucBuf, pucOldPath);
/*lint +e534*/
}
return VOS_OK;
}
VOS_VOID MN_CAL_ReadCallDeflectionNvim( VOS_VOID )
{
MN_CALL_NVIM_CALL_DEFLECTION_SUPPORT_FLG_STRU stCallDeflectionSupportFlg;
MN_CALL_CUSTOM_CFG_INFO_STRU *pstCallDeflectionSupportFlg = VOS_NULL_PTR;
stCallDeflectionSupportFlg.ucCallDeflectionSupportFlg = MN_CALL_NV_ITEM_DEACTIVE;
pstCallDeflectionSupportFlg = MN_CALL_GetCustomCfgInfo();
if (NV_OK != NV_Read(en_NV_Item_NVIM_CALL_DEFLECTION_SUPPORT_FLG,
&stCallDeflectionSupportFlg, sizeof(MN_CALL_NVIM_CALL_DEFLECTION_SUPPORT_FLG_STRU)))
{
MN_WARN_LOG("MN_CAL_ReadCallDeflectionNvim():WARNING: en_NV_Item_NVIM_CALL_DEFLECTION_SUPPORT_FLG Error");
return;
}
if ((MN_CALL_NV_ITEM_ACTIVE != stCallDeflectionSupportFlg.ucCallDeflectionSupportFlg)
&& (MN_CALL_NV_ITEM_DEACTIVE != stCallDeflectionSupportFlg.ucCallDeflectionSupportFlg))
{
pstCallDeflectionSupportFlg->ucCallDeflectionSupportFlg = MN_CALL_NV_ITEM_DEACTIVE;
MN_WARN_LOG("MN_CAL_ReadCallDeflectionNvim():WARNING: NV parameter Error");
return;
}
pstCallDeflectionSupportFlg->ucCallDeflectionSupportFlg = stCallDeflectionSupportFlg.ucCallDeflectionSupportFlg;
return;
}
VOS_VOID MN_MSG_CloseSmsCapabilityFeatureInit(VOS_VOID)
{
VOS_UINT32 ulRet;
VOS_UINT32 ulLength;
NAS_NVIM_CLOSE_SMS_CAPABILITY_CFG_STRU stCloseSmsCapabilityCfg;
ulLength = 0;
/* 先获取NV的长度 */
NV_GetLength(en_NV_Item_Close_SMS_Capability_Config, &ulLength);
if (ulLength > sizeof(stCloseSmsCapabilityCfg))
{
MN_ERR_LOG("MN_MSG_CloseSmsCapabilityFeatureInit():WARNING: en_NV_Item_Close_SMS_Capability_Config length Error");
return;
}
ulRet = NV_Read(en_NV_Item_Close_SMS_Capability_Config,
&stCloseSmsCapabilityCfg,
ulLength);
f_stMnMsgCloseSmsCapabilityMsg.ucActFlg = stCloseSmsCapabilityCfg.ucActFlg;
/* 读取关闭短信定制NV失败,默认不关闭短信功能 */
if (NV_OK != ulRet)
{
f_stMnMsgCloseSmsCapabilityMsg.ucActFlg = MN_MSG_NVIM_ITEM_INACTIVE;
MN_ERR_LOG("MN_MSG_CloseSmsCapabilityFeatureInit: Read en_NV_Item_CLOSE_SMS_Capability_Config Failed");
}
return;
}
VOS_VOID TAF_CALL_ReadAtaReportOkAsyncCfgNvim(VOS_VOID)
{
TAF_CALL_NVIM_ATA_REPORT_OK_ASYNC_CFG_STRU stAtaReportOkAsyncCfg;
VOS_UINT32 ulLength;
ulLength = 0;
NV_GetLength(en_NV_Item_Ata_Report_Ok_Async_Cfg, &ulLength);
PS_MEM_SET(&stAtaReportOkAsyncCfg, 0x0, sizeof(stAtaReportOkAsyncCfg));
/* 设置默认值为VOS_FALSE */
TAF_CALL_SetAtaReportOkAsyncFlag(VOS_FALSE);
if (ulLength > sizeof(TAF_CALL_NVIM_ATA_REPORT_OK_ASYNC_CFG_STRU))
{
return;
}
if (NV_OK != NV_Read(en_NV_Item_Ata_Report_Ok_Async_Cfg,
&stAtaReportOkAsyncCfg,
sizeof(stAtaReportOkAsyncCfg)))
{
return;
}
if (VOS_TRUE == stAtaReportOkAsyncCfg.ucAtaReportOkAsyncFlag)
{
TAF_CALL_SetAtaReportOkAsyncFlag(VOS_TRUE);
}
return;
}
VOS_VOID MN_MSG_GetMtCustomizeInfo(MN_MSG_MT_CUSTOMIZE_ENUM_UINT8 *penMtCustomize)
{
VOS_UINT32 ulRet;
MN_MSG_MT_CUSTOMIZE_INFO_STRU stMtCustomize;
PS_MEM_SET(&stMtCustomize, 0x00, sizeof(stMtCustomize));
*penMtCustomize = MN_MSG_MT_CUSTOMIZE_NONE;
ulRet = NV_Read(en_NV_Item_SMS_MT_CUSTOMIZE_INFO,
&stMtCustomize,
sizeof(stMtCustomize));
if (NV_OK != ulRet)
{
MN_WARN_LOG("MN_MSG_GetMtCustomizeInfo: Fail to read ");
return;
}
if (MN_MSG_NVIM_ITEM_ACTIVE == stMtCustomize.ucActFlag)
{
*penMtCustomize = stMtCustomize.enMtCustomize;
}
return;
}
VOS_VOID NAS_CC_ReadErrlogCtrlInfoNvim(VOS_VOID)
{
VOS_UINT32 ulResult;
VOS_UINT32 ulLength;
NV_ID_ERR_LOG_CTRL_INFO_STRU stErrorLogCtrlInfo;
ulLength = 0;
PS_MEM_SET(&stErrorLogCtrlInfo, 0x00, sizeof(NV_ID_ERR_LOG_CTRL_INFO_STRU));
NV_GetLength(en_NV_Item_ErrLogCtrlInfo, &ulLength);
ulResult = NV_Read(en_NV_Item_ErrLogCtrlInfo,
&stErrorLogCtrlInfo,
ulLength);
if (ulResult == NV_OK)
{
NAS_CC_SetErrlogCtrlFlag(stErrorLogCtrlInfo.ucAlmStatus);
NAS_CC_SetErrlogAlmLevel(stErrorLogCtrlInfo.ucAlmLevel);
}
else
{
NAS_CC_SetErrlogCtrlFlag(VOS_FALSE);
NAS_CC_SetErrlogAlmLevel(NAS_ERR_LOG_CTRL_LEVEL_CRITICAL);
}
return;
}
VOS_VOID TAF_MMA_ReadAccessModeNvim(VOS_VOID)
{
VOS_UINT32 ulLength;
NAS_MMA_NVIM_ACCESS_MODE_STRU stAccessMode;
MN_MMA_LAST_SETTED_SYSCFG_SET_STRU *pstLastSyscfgSet = VOS_NULL_PTR;
PS_MEM_SET(&stAccessMode, 0x00, sizeof(NAS_MMA_NVIM_ACCESS_MODE_STRU));
pstLastSyscfgSet = MN_MMA_GetLastSyscfgSetAddr();
ulLength = 0;
NV_GetLength(en_NV_Item_MMA_AccessMode, &ulLength);
if (ulLength > sizeof(NAS_MMA_NVIM_ACCESS_MODE_STRU))
{
return;
}
if (NV_OK != NV_Read(en_NV_Item_MMA_AccessMode ,
&stAccessMode,
ulLength))
{
MN_WARN_LOG("TAF_MMA_ReadAccessModeNvim:Read:NV_Read runs failed");
return ;
}
pstLastSyscfgSet->enPrioRat = (stAccessMode.aucAccessMode)[1];
return;
}
