VOS_VOID NAS_UTRANCTRL_SaveCurEntryMsg(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
NAS_UTRANCTRL_ENTRY_MSG_STRU *pstEntryMsg = VOS_NULL_PTR;
MSG_HEADER_STRU *pstMsgHeader = VOS_NULL_PTR;
VOS_UINT32 ulLen;
/* 获得当前UTRANCTRL模块状态机入口消息的缓冲区地址 */
pstEntryMsg = NAS_UTRANCTRL_GetCurrEntryMsgAddr();
pstMsgHeader = (MSG_HEADER_STRU*)pstMsg;
/* 如果是空消息 */
if ( VOS_NULL_PTR == pstMsg )
{
pstEntryMsg->ulEventType = ulEventType;
NAS_WARNING_LOG( WUEPS_PID_MMC, "NAS_MMC_SaveCurEntryMsg Entry Message Pointer is NULL!" );
return;
}
ulLen = pstMsgHeader->ulLength + VOS_MSG_HEAD_LENGTH;
/* 将当前处理的入口消息拷贝到Context对应的缓冲区 */
PS_MEM_CPY( pstEntryMsg->aucEntryMsgBuffer, pstMsg, ulLen );
/* 填写Context中的参数 */
pstEntryMsg->ulEventType = ulEventType;
return;
}
VOS_UINT32 TAF_APS_RcvL4aPdpModifyInd_Active(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT8 ucPdpId;
APS_L4A_PDP_MODIFY_IND_STRU *pstPdpModify;
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity;
pstPdpModify = (APS_L4A_PDP_MODIFY_IND_STRU*)pstMsg;
/* 初始化, 获取PDP ID */
ucPdpId = TAF_APS_GetCurrFsmEntityPdpId();
pstPdpEntity = TAF_APS_GetPdpEntInfoAddr(ucPdpId);
/* 如果不是默认承载，则上报，默认承载不上报 */
if (TAF_APS_DEFAULT_CID != pstPdpModify->ucCid)
{
if (VOS_TRUE == pstPdpModify->bitOpEpsQos)
{
pstPdpEntity->bitOpEpsQos = VOS_TRUE;
PS_MEM_CPY((VOS_UINT8 *)&pstPdpEntity->stEpsQos,
(VOS_UINT8 *)&pstPdpModify->stEpsQosInfo,
sizeof(APS_L4A_EPS_QOS_STRU));
}
/* 上报ID_EVT_TAF_PS_CALL_PDP_MODIFIED_IND事件 */
TAF_APS_SndPdpModifyInd(ucPdpId);
}
return VOS_TRUE;
}
/*****************************************************************************
函 数 名 : GTTF_MNTN_ErrlogMdlErrEvt
功能描述 : 生成GSM MDL Err事件
输入参数 : VOS_UINT32 ulPid
VOS_VOID *pMdlErr
输出参数 : 无
返 回 值 : VOS_VOID
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2013年9月23日
作 者 : t00148005
修改内容 : 新生成函数
*****************************************************************************/
VOS_VOID GTTF_MNTN_ErrlogMdlErrEvt(VOS_UINT32 ulPid, VOS_VOID *pMdlErr)
{
TTF_MNTN_ERR_LOG_GDL_MDL_ERR_STRU stMdlErrEvt;
VOS_UINT8 ucAlmLev;
MODEM_ID_ENUM_UINT16 enModemId;
if (VOS_NULL_PTR == pMdlErr)
{
return;
}
ucAlmLev = TTF_ERR_LOG_GET_ALM_LEV(TTF_ERR_LOG_ALM_ID_GSM_MDL_ERR);
enModemId = VOS_GetModemIDFromPid(ulPid);
if (!TTF_ERR_LOG_NEED_RPT_LEV(enModemId, ucAlmLev))
{
return;
}
TTF_ERR_LOG_FILL_HEADER(
&stMdlErrEvt.stHeader,
enModemId,
TTF_ERR_LOG_ALM_ID_GSM_MDL_ERR,
ucAlmLev,
(sizeof(TTF_MNTN_ERR_LOG_GDL_MDL_ERR_STRU) - sizeof(OM_ERR_LOG_HEADER_STRU)));
PS_MEM_CPY(&stMdlErrEvt.stDlMdlErrInfo, pMdlErr, sizeof(TTF_MNTN_GDL_MDL_ERR_INFO_STRU));
TTF_MNTN_ErrlogBufPut(ulPid, (VOS_CHAR *)&stMdlErrEvt, sizeof(TTF_MNTN_ERR_LOG_GDL_MDL_ERR_STRU));
}
VOS_VOID PS_Qnode_ResetCtrlInitNvPara(VOS_VOID)
{
VOS_UINT32 ulRslt;
NV_NODE_RESET_CTRL_STRU stNvNodeResetCtrl;
PS_MEM_SET(&g_stNvPsQnodeResetCtrl, 0x00, sizeof(NV_RATIO_RESET_CTRL_STRU));
ulRslt = NV_Read(en_NV_Item_NODE_RESET_CTRL,
&stNvNodeResetCtrl, sizeof(NV_NODE_RESET_CTRL_STRU));
if (NV_OK != ulRslt)
{
TTF_LOG1(MSPS_PID_1X_RMAC, DIAG_MODE_COMM, PS_PRINT_WARNING,
"PS_Qnode_ResetCtrlInitNvPara, Read Nv Fail", ulRslt);
/* 若NV读取失败, 将复位控制参数置为默认置 */
g_stNvPsQnodeResetCtrl.enResetEnable = PS_TRUE;
g_stNvPsQnodeResetCtrl.ucFailPercent = 95;
g_stNvPsQnodeResetCtrl.usTotalStat = 500;
return;
}
PS_MEM_CPY(&g_stNvPsQnodeResetCtrl,
&(stNvNodeResetCtrl.astNvResetCtrl[PS_QNODE_RESET_TYPE]),
sizeof(NV_RATIO_RESET_CTRL_STRU));
return;
}
VOS_VOID TAF_MSG_ListLeftMsg(VOS_VOID)
{
MN_MSG_LIST_EVT_INFO_STRU *pstListEvt;
pstListEvt = (MN_MSG_LIST_EVT_INFO_STRU *)PS_MEM_ALLOC(WUEPS_PID_TAF, sizeof(MN_MSG_LIST_EVT_INFO_STRU));
if (VOS_NULL_PTR == pstListEvt)
{
MN_ERR_LOG("TAF_MSG_ListLeftMsg:ALLOC MEM FAIL");
return;
}
else
{
pstListEvt->bSuccess = VOS_TRUE;
pstListEvt->bLastListEvt = VOS_TRUE;
pstListEvt->bFirstListEvt = VOS_FALSE;
PS_MEM_CPY( &(pstListEvt->stReceivedListPara), &g_stList, sizeof(MN_MSG_LIST_PARM_STRU) );
}
if (0 == g_ulLeftReportNum)
{
pstListEvt->ulReportNum = 0;
pstListEvt->ulFailCause = MN_ERR_NO_ERROR;
MN_MSG_ReportListEvent(g_clientId,g_opId,pstListEvt,MN_MSG_EVT_LIST);
}
else
{
/* 调用函数分段上报需列表个数 */
MN_MSG_RptMsg(g_clientId, g_opId, g_ulLeftReportNum, &g_stList, pstListEvt);
}
PS_MEM_FREE(WUEPS_PID_TAF, pstListEvt);
}
int bastet_comm_write(u8 *msg, u32 len)
{
BASTET_MSG_STRU *pMsg = NULL;
VOS_UINT32 ulLength = 0;
if (NULL == msg) {
return -1;
}
ulLength = sizeof(BASTET_MSG_STRU) + BST_MAX_WRITE_PAYLOAD - 4;
pMsg = (BASTET_MSG_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(ACPU_PID_BASTET_COMM, ulLength);
if (NULL == pMsg) {
BASTET_LOGE("PS_ALLOC_MSG_WITH_HEADER_LEN failed");
return -1;
}
pMsg->ulReceiverPid = UEPS_PID_BASTET;
PS_MEM_CPY((VOS_VOID*)pMsg->aucValue, msg, len);
pMsg->usLen = len;
if (PS_SEND_MSG(ACPU_PID_BASTET_COMM, pMsg) != 0) {
BASTET_LOGE("PS_SEND_MSG failed");
return -1;
}
return 0;
}
PS_RSLT_CODE_ENUM_UINT32 PS_Qnode_FillMemInfo(VOS_UINT16 usFileId,
VOS_UINT16 usLineId,
VOS_UINT32 ulPid,
PS_QNODE_STRU *pstQnode,
PS_QNODE_MEM_SOURCE_STRU *pstMemSrc,
VOS_UINT8 ucParaOctetCnt,
VOS_UINT8 aucPara[])
{
VOS_UINT32 ulTick;
ulTick = VOS_GetTick();
if (VOS_NULL_PTR == pstQnode)
{
TTF_LOG4(ulPid, DIAG_MODE_COMM, PS_PRINT_WARNING, "fileid, line, pid, tick, pstQnode is NULL",
usFileId, usLineId, (VOS_INT32)ulPid, (VOS_INT32)ulTick);
return PS_FAIL;
}
if (VOS_NULL_PTR == pstMemSrc)
{
TTF_LOG4(ulPid, DIAG_MODE_COMM, PS_PRINT_WARNING, "fileid, line, pid, tick, pstMemSrc is NULL",
usFileId, usLineId, (VOS_INT32)ulPid, (VOS_INT32)ulTick);
return PS_FAIL;
}
if (PS_QNODE_FREE_STATE == pstQnode->enState)
{
TTF_LOG4(ulPid, DIAG_MODE_COMM, PS_PRINT_WARNING, "fileid, line, pid, tick, pstQnode state is free",
usFileId, usLineId, (VOS_INT32)ulPid, (VOS_INT32)ulTick);
return PS_FAIL;
}
if (ucParaOctetCnt > MAX_PARA_OCTET_NUM)
{
TTF_LOG(ulPid, DIAG_MODE_COMM, PS_PRINT_WARNING, "more than allowed para octet num");
return PS_FAIL;
}
PS_MEM_CPY(&(pstQnode->stMemSrc), pstMemSrc, sizeof(pstQnode->stMemSrc));
if (0 != ucParaOctetCnt)
{
PS_MEM_CPY(&(pstQnode->aucPara[0]), aucPara, (ucParaOctetCnt * sizeof(VOS_UINT8)));
}
return PS_SUCC;
} /* PS_Qnode_FillMemInfo */
VOS_INT32 As_RrDataReq(
VOS_UINT8 ucCnDomain, /* CN DOMAIN */
VOS_UINT8 ucPriority, /* 信令数据优先级 */
VOS_UINT32 ulSize, /* 信令数据长度 */
VOS_INT8 *pData /* 信令数据指针 */
)
{
RRMM_DATA_REQ_STRU* pMsg = VOS_NULL; /* 定义原语类型指针 */
VOS_UINT32 ulTmpSize;
ulTmpSize = ulSize;
if(ulTmpSize < 4)
{
ulTmpSize = 4;
}
if(RRC_NAS_CS_DOMAIN == ucCnDomain)
{
pMsg = (RRMM_DATA_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_MM,(sizeof(RRMM_DATA_REQ_STRU) + ulTmpSize) - 4);
}
else
{
pMsg = (RRMM_DATA_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_GMM,(sizeof(RRMM_DATA_REQ_STRU) + ulTmpSize) - 4);
}
if( VOS_NULL == pMsg )
{ /* 内存申请失败 */
return AS_VOS_ERR; /* 返回 */
}
PS_MEM_SET((VOS_INT8*)pMsg + VOS_MSG_HEAD_LENGTH,0,
((sizeof(RRMM_DATA_REQ_STRU) + ulTmpSize) - 4) - VOS_MSG_HEAD_LENGTH);
pMsg->MsgHeader.ulReceiverPid = WUEPS_PID_WRR;
pMsg->MsgHeader.ulMsgName = RRMM_DATA_REQ; /* 消息名称 */
pMsg->ulCnDomainId = ucCnDomain;
pMsg->ulPriorityInd = ucPriority;
pMsg->SendNasMsg.ulNasMsgSize = ulSize;
if(VOS_NULL_PTR != pData)
{
PS_MEM_CPY(pMsg->SendNasMsg.aucNasMsg,pData,ulSize);
}
if (RRC_NAS_CS_DOMAIN == ucCnDomain)
{
pMsg->MsgHeader.ulSenderPid = WUEPS_PID_MM;
}
else
{
pMsg->MsgHeader.ulSenderPid = WUEPS_PID_GMM;
}
if (VOS_OK != NAS_UTRANCTRL_SndAsMsg(pMsg->MsgHeader.ulSenderPid, (struct MsgCB **)&pMsg))
{
return AS_SEND_FAILED;
}
return AS_SUCCESS;
}
VOS_VOID MN_CALL_LineInfo(
MNPH_USIM_STATUS_ENUM_U32 enUsimStatus
)
{
MN_CALL_ALS_LINE_INFO_STRU stAlsInfo;
VOS_UINT8 aucMmaImsi[9];
VOS_BOOL bWriteNvim;
VOS_UINT32 ulLength;
ulLength = 0;
stAlsInfo.enAlsLine = MN_CALL_ALS_LINE_NO_BUTT;
PS_MEM_SET(stAlsInfo.aucMmaImsi, 0x00, sizeof(stAlsInfo.aucMmaImsi));
if ( MNPH_USIM_STATUS_AVILABLE == enUsimStatus )
{
bWriteNvim = VOS_FALSE;
if ( NV_OK != NV_Read(en_NV_Item_ALS_LINE_Config,&stAlsInfo,sizeof(stAlsInfo)))
{
return;
}
if ( USIMM_API_SUCCESS != NAS_USIMMAPI_GetCardIMSI(aucMmaImsi) )
{
return ;
}
/*线路号值不在取值范围内*/
if ( ( MN_CALL_ALS_LINE_NO_1 != stAlsInfo.enAlsLine )
&& ( MN_CALL_ALS_LINE_NO_2 != stAlsInfo.enAlsLine ) )
{
stAlsInfo.enAlsLine = MN_CALL_ALS_LINE_NO_1;
bWriteNvim = VOS_TRUE;
}
/*判断NV中当前使用线路号对应的IMSI和SIM卡中IMSI是否相同，若不同则清NV
项，并填入默认线路号1*/
if ( 0 != VOS_StrCmp( (VOS_CHAR *)aucMmaImsi,
(VOS_CHAR *)stAlsInfo.aucMmaImsi) )
{
stAlsInfo.enAlsLine = MN_CALL_ALS_LINE_NO_1;
PS_MEM_CPY(stAlsInfo.aucMmaImsi,aucMmaImsi,9);
bWriteNvim = VOS_TRUE;
}
/*需要更新NVIM*/
if ( VOS_TRUE == bWriteNvim )
{
NV_GetLength(en_NV_Item_ALS_LINE_Config, &ulLength);
if (NV_OK != NV_Write(en_NV_Item_ALS_LINE_Config,
&stAlsInfo,
ulLength) )
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "MN_CALL_LineInfo: en_NV_Item_ALS_LINE_Config NV Write Fail!");
}
}
MN_CALL_UpdateAlsLineInfo(stAlsInfo.enAlsLine,VOS_FALSE);
}
}
VOS_VOID TAF_MMA_InitSyscfgInfo(VOS_VOID)
{
MN_MMA_LAST_SETTED_SYSCFG_SET_STRU *pstLastSyscfgSet = VOS_NULL_PTR;
pstLastSyscfgSet = MN_MMA_GetLastSyscfgSetAddr();
pstLastSyscfgSet->stRatPrioList = gstMmaValue.pg_StatusContext->stRatPrioList;
/* 初始化LastSyscfg */
pstLastSyscfgSet->ucSrvDomain = TAF_PH_SERVICE_NULL;
pstLastSyscfgSet->ucRoam = MMA_MMC_ROAM_BUTT;
pstLastSyscfgSet->enPrioRat = TAF_MMA_USER_SET_PRIO_AUTO;
/* 初始化接入技术，如果ATT的接入技术平衡定制NV激活，开机读4F36文件，否则从NV中获取接入技术 */
MN_MMA_SetDefaultRatPrioList(&(pstLastSyscfgSet->stRatPrioList));
/* 更新gstMmaValue.pg_StatusContext.stRatPrioList全局变量 */
PS_MEM_CPY(&gstMmaValue.pg_StatusContext->stRatPrioList, &(pstLastSyscfgSet->stRatPrioList), sizeof(TAF_PH_RAT_ORDER_STRU));
/* 更新stSysCfgSet全局变量 */
PS_MEM_SET(&(gstMmaValue.stSysCfgSet), 0, sizeof(MMA_SYS_CFG_SET_STRU));
gstMmaValue.stSysCfgSet.usSetFlag = MMA_SYS_CFG_NONE_SET;
gstMmaValue.stSysCfgSet.ucAttachType = TAF_PH_ATTACH_DETACH_NULL;
gstMmaValue.stSysCfgSet.ucDetachType = TAF_PH_ATTACH_DETACH_NULL;
gstMmaValue.stSysCfgSet.ucOpId = 0;
gstMmaValue.stSysCfgSet.usClientId = 0;
gstMmaValue.stSysCfgSet.stSysCfgSetPara.enUserPrio = TAF_MMA_USER_SET_PRIO_AUTO;
gstMmaValue.stSysCfgSet.stSysCfgSetPara.ucRoam = MMA_MMC_ROAM_BUTT;
gstMmaValue.stSysCfgSet.stSysCfgSetPara.ucSrvDomain = TAF_PH_SERVICE_NULL;
/* GSM的支持的Band */
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsm1800= VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsm1900= VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsm450 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsm480 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsm700 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsm850 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsmE900= VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsmP900= VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unGsmBand.BitBand.BandGsmR900= VOS_FALSE;
/* WCDMA的支持的Band */
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_III_1800 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_II_1900 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_IV_1700 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_IX_J1700 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_I_2100 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_VIII_900 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_VII_2600 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_VI_800 = VOS_TRUE;
pstLastSyscfgSet->stUserSetBand.uUserSetUeFormatGuBand.unWcdmaBand.BitBand.BandWCDMA_V_850 = VOS_TRUE;
#if(FEATURE_ON == FEATURE_LTE)
/* LTE的支持的Band */
pstLastSyscfgSet->stUserSetBand.stUserSetLteBand.ulBandHigh = MN_MMA_LTE_HIGH_BAND_ANY;
pstLastSyscfgSet->stUserSetBand.stUserSetLteBand.ulBandLow = MN_MMA_LTE_LOW_BAND_ANY;
#endif
return;
}
VOS_VOID NAS_SM_RcvTafBearerModifyInd(
SMREG_BEARER_MODIFY_IND_STRU *pstBearerModifyInd
)
{
NAS_SM_PDP_CONTEXT_INFO_STRU *pstPdpCtxInfo;
VOS_UINT8 ucPdpCtxIndex;
VOS_UINT8 ucTi;
VOS_UINT8 ucNsapi;
/*----------------------------------------------------------------
提取TI: 根据TiFlag决定TI的取值范围, 以网侧下发TI为准
若TiFlag为TRUE(SM_TI_MS_ORG), TI取值区间[128, 254]
若TiFlag为FALSE(SM_TI_NET_ORG), TI取值区间[0, 127]
----------------------------------------------------------------*/
ucTi = (VOS_FALSE == pstBearerModifyInd->stTransId.ucTiFlag) ?
(pstBearerModifyInd->stTransId.ucTiValue) :
(pstBearerModifyInd->stTransId.ucTiValue + 0x80);
/* 获取TI对应的PDP CONTEXT索引 */
ucPdpCtxIndex = NAS_SM_GetNsapiFromTiMap(ucTi);
/* 检查是否存在和TI和CR对应的PDP CONTEXT */
if (0xFF == ucPdpCtxIndex)
{
NAS_ERROR_LOG(WUEPS_PID_SM,
"NAS_SM_RcvTafBearerModifyInd: NSAPI is not used.");
return;
}
/* 获取PDP CONTEXT索引对应的NSAPI: NSAPI = PDP_INDEX - NSAPI_OFFSET(5) */
ucNsapi = ucPdpCtxIndex + SM_NSAPI_OFFSET;
/* 获取当前PDP CONTEXT内容地址 */
pstPdpCtxInfo = NAS_SM_GetPdpCtxInfoAddr(ucPdpCtxIndex);
/* 更新RADIO PRIORITY */
if (VOS_TRUE == pstBearerModifyInd->bitOpRadioPriority)
{
pstPdpCtxInfo->ucRadioPri = pstBearerModifyInd->ucRadioPriority;
}
/* 更新QOS信息 */
if (VOS_TRUE == pstBearerModifyInd->bitOpPdpQos)
{
pstPdpCtxInfo->QoS.ulQosLength = pstBearerModifyInd->stNegQos.ulQosLen;
PS_MEM_CPY(pstPdpCtxInfo->QoS.aucQosValue,
pstBearerModifyInd->stNegQos.aucQos,
NAS_SM_MAX_QOS_LEN);
}
/* 通知RABM更新状态 */
NAS_SM_SndRabmBearerModifyInd(ucNsapi, pstPdpCtxInfo);
/* 通知GMM pdp上下文发生修改，GMM根据此消息需判断是否要去激活ISR */
NAS_SM_SndGmmPdpModifyInd(ucNsapi);
}
VOS_UINT32 TAF_MMA_SetSysCfgReq(
VOS_UINT32 ulModuleId,
VOS_UINT16 usClientId,
VOS_UINT8 ucOpId,
TAF_MMA_SYS_CFG_PARA_STRU *pstSysCfgPara
)
{
TAF_MMA_SYS_CFG_REQ_STRU *pstMsg = VOS_NULL_PTR;
VOS_UINT32 ulReceiverPid;
VOS_UINT32 ulSenderPid;
#if (OSA_CPU_ACPU == VOS_OSA_CPU)
ulReceiverPid = AT_GetDestPid(usClientId, WUEPS_PID_MMA);
ulSenderPid = AT_GetDestPid(usClientId, WUEPS_PID_TAF);
#else
ulReceiverPid = WUEPS_PID_MMA;
ulSenderPid = WUEPS_PID_TAF;
#endif
/* 参数检查 */
if (VOS_NULL_PTR == pstSysCfgPara)
{
return VOS_FALSE;
}
/* 申请消息包TAF_MMA_SYS_CFG_REQ_STRU */
pstMsg = (TAF_MMA_SYS_CFG_REQ_STRU*)PS_ALLOC_MSG_WITH_HEADER_LEN(
ulSenderPid,
sizeof(TAF_MMA_SYS_CFG_REQ_STRU));
/* 内存申请失败，返回 */
if (VOS_NULL_PTR == pstMsg)
{
return VOS_FALSE;
}
PS_MEM_SET( (VOS_INT8 *)pstMsg + VOS_MSG_HEAD_LENGTH, 0X00,
sizeof(TAF_MMA_SYS_CFG_REQ_STRU) - VOS_MSG_HEAD_LENGTH );
/* 根据输入参数填充TAF_MMA_SYS_CFG_REQ_STRU */
/* 发送PID统一填写为WUEPS_PID_TAF */
pstMsg->ulSenderPid = ulSenderPid;
pstMsg->ulReceiverPid = ulReceiverPid;
pstMsg->ulMsgName = ID_TAF_MMA_SYS_CFG_SET_REQ;
pstMsg->stCtrl.ulModuleId = ulModuleId;
pstMsg->stCtrl.usClientId = usClientId;
pstMsg->stCtrl.ucOpId = ucOpId;
PS_MEM_CPY(&(pstMsg->stSysCfgPara), pstSysCfgPara, sizeof(TAF_MMA_SYS_CFG_PARA_STRU));
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(ulSenderPid, pstMsg))
{
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_UINT32 TAF_SPM_SendImsaCallInviteNewPtptReq(
MN_CALL_APP_REQ_MSG_STRU *pstAppMsg
)
{
SPM_IMSA_CALL_INVITE_NEW_PTPT_REQ_STRU *pstSendImsaMsg = VOS_NULL_PTR;
/* 构造消息 */
pstSendImsaMsg = (SPM_IMSA_CALL_INVITE_NEW_PTPT_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(SPM_IMSA_CALL_INVITE_NEW_PTPT_REQ_STRU));
if (VOS_NULL_PTR == pstSendImsaMsg)
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_SPM_SendImsaCallInviteNewPtptReq: ERROR:Memory Alloc Error for pstMsg!");
return VOS_FALSE;
}
/* 初始化消息 */
PS_MEM_SET(((VOS_UINT8*)pstSendImsaMsg) + VOS_MSG_HEAD_LENGTH,
0x00,
sizeof(SPM_IMSA_CALL_INVITE_NEW_PTPT_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
/* 填写消息头 */
pstSendImsaMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstSendImsaMsg->ulSenderPid = WUEPS_PID_TAF;
pstSendImsaMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSendImsaMsg->ulReceiverPid = PS_PID_IMSA;
pstSendImsaMsg->ulLength = sizeof(SPM_IMSA_CALL_INVITE_NEW_PTPT_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
/* 填写消息内容 */
pstSendImsaMsg->ulMsgId = ID_SPM_IMSA_CALL_INVITE_NEW_PTPT_REQ;
pstSendImsaMsg->usClientId = pstAppMsg->clientId;
pstSendImsaMsg->ucOpId = pstAppMsg->opId;
/* 填写对方号码及呼叫类型 */
pstSendImsaMsg->stNewPtptNumber.enNumType = pstAppMsg->unParm.stOrig.stDialNumber.enNumType;
pstSendImsaMsg->stNewPtptNumber.ucNumLen = pstAppMsg->unParm.stOrig.stDialNumber.ucNumLen;
if (MN_CALL_MAX_CALLED_BCD_NUM_LEN < pstSendImsaMsg->stNewPtptNumber.ucNumLen)
{
pstSendImsaMsg->stNewPtptNumber.ucNumLen = MN_CALL_MAX_CALLED_BCD_NUM_LEN;
}
PS_MEM_CPY(&(pstSendImsaMsg->stNewPtptNumber.aucBcdNum[0]),
&(pstAppMsg->unParm.stOrig.stDialNumber.aucBcdNum[0]),
pstSendImsaMsg->stNewPtptNumber.ucNumLen);
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_TAF, pstSendImsaMsg))
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_SPM_SendImsaCallInviteNewPtptReq: Send message failed.");
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_UINT32 TAF_APS_SndL4aIpv6InfoNotifyInd(
VOS_UINT8 ucRabId,
TAF_PDP_IPV6_RA_INFO_STRU *pstIpv6RaInfo
)
{
VOS_UINT32 i;
APS_L4A_IPV6_INFO_NOTIFY_IND_STRU *pstL4aIpv6InfoNotifyInd;
if (VOS_FALSE == TAF_SDC_IsPlatformSupportLte())
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_APS_SndL4aIpv6InfoNotifyInd: Platform don't support LTE.");
return VOS_ERR;
}
/* 构造消息 */
pstL4aIpv6InfoNotifyInd = (APS_L4A_IPV6_INFO_NOTIFY_IND_STRU*)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(APS_L4A_IPV6_INFO_NOTIFY_IND_STRU));
if (VOS_NULL_PTR == pstL4aIpv6InfoNotifyInd)
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_APS_SndL4aIpv6InfoNotifyInd: Memory alloc failed.");
return VOS_ERR;
}
/* 初始化消息 */
PS_MEM_SET((VOS_CHAR*)pstL4aIpv6InfoNotifyInd + VOS_MSG_HEAD_LENGTH,
0x00,
sizeof(APS_L4A_IPV6_INFO_NOTIFY_IND_STRU) - VOS_MSG_HEAD_LENGTH);
/* 填写消息头 */
pstL4aIpv6InfoNotifyInd->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstL4aIpv6InfoNotifyInd->ulReceiverPid = MSP_L4_L4A_PID;
pstL4aIpv6InfoNotifyInd->enMsgId = ID_APS_L4A_IPV6_INFO_NOTIFY_IND;
/* 填写消息内容 */
pstL4aIpv6InfoNotifyInd->ucRabId = ucRabId;
pstL4aIpv6InfoNotifyInd->ucIpv6PrefixNum = (VOS_UINT8)pstIpv6RaInfo->ulPrefixNum;
for (i = 0; i < pstIpv6RaInfo->ulPrefixNum; i++)
{
pstL4aIpv6InfoNotifyInd->astIpv6PrefixArray[i].ucPrefixLen
= pstIpv6RaInfo->astPrefixList[i].ulBitPrefixLen/8;
PS_MEM_CPY(pstL4aIpv6InfoNotifyInd->astIpv6PrefixArray[i].aucPrefix,
pstIpv6RaInfo->astPrefixList[i].aucPrefix,
APS_L4A_MAX_IPV6_ADDR_LEN);
}
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_TAF, pstL4aIpv6InfoNotifyInd))
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_APS_SndL4aIpv6InfoNotifyInd: Send message failed.");
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID TAF_SPM_GetCallInfoFromFsmEntryMsg(
MN_CALL_CALLED_NUM_STRU *pstDialNumber,
MN_CALL_TYPE_ENUM_U8 *penCallType,
MN_CALL_MODE_ENUM_U8 *penCallMode,
MN_CALL_CS_DATA_CFG_STRU *pstDataCfg
)
{
MN_APP_REQ_MSG_STRU *pstAppMsg = VOS_NULL_PTR;
MN_APP_CALL_CALLORIG_REQ_STRU *pstStkOrigParam = VOS_NULL_PTR;
TAF_SPM_ENTRY_MSG_STRU *pstEntryMsg = VOS_NULL_PTR;
MN_CALL_APP_REQ_PARM_UNION *pstAtOrigParam = VOS_NULL_PTR;
NAS_CC_IE_BC_STRU stBc1CallCnf;
pstEntryMsg = TAF_SPM_GetCurrEntityFsmEntryMsgAddr();
pstAppMsg = (MN_APP_REQ_MSG_STRU *)pstEntryMsg->aucEntryMsgBuffer;
/* 区分AT或STK的 */
if (WUEPS_PID_AT == TAF_SPM_GetCurrEntityFsmEntryMsgSndPid())
{
pstAtOrigParam = (MN_CALL_APP_REQ_PARM_UNION *)pstAppMsg->aucContent;
*penCallType = pstAtOrigParam->stOrig.enCallType;
*penCallMode = pstAtOrigParam->stOrig.enCallMode;
PS_MEM_CPY(pstDialNumber, &pstAtOrigParam->stOrig.stDialNumber, sizeof(pstAtOrigParam->stOrig.stDialNumber));
PS_MEM_CPY(pstDataCfg, &pstAtOrigParam->stOrig.stDataCfg, sizeof(pstAtOrigParam->stOrig.stDataCfg));
}
else
{
pstStkOrigParam = (MN_APP_CALL_CALLORIG_REQ_STRU *)pstAppMsg;
*penCallType = pstStkOrigParam->enCallType;
*penCallMode = MN_CALL_MODE_SINGLE;
PS_MEM_CPY(pstDialNumber, (MN_CALL_CALLED_NUM_STRU *)&pstStkOrigParam->stCalledAddr, sizeof(pstStkOrigParam->stCalledAddr));
stBc1CallCnf.IsExist = VOS_TRUE;
stBc1CallCnf.LastOctOffset = (VOS_UINT8)pstStkOrigParam->stBc.ucLen;
PS_MEM_CPY(&stBc1CallCnf.Octet3, pstStkOrigParam->stBc.aucBc, pstStkOrigParam->stBc.ucLen);
MN_CALL_GetDataCfgInfoFromBc(&stBc1CallCnf, (MN_CALL_CS_DATA_CFG_INFO_STRU *)pstDataCfg);
}
return;
}
VOS_VOID MN_APS_FillSmBearerActivateIndPara(
SMREG_BEARER_ACTIVATE_IND_STRU *pstSmBearerActivateInd,
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity
)
{
/* 填写 TI */
pstSmBearerActivateInd->stTransId.ucTiFlag = pstPdpEntity->stTransId.ucTiFlag;
pstSmBearerActivateInd->stTransId.ucTiValue = pstPdpEntity->stTransId.ucTiValue;
/* 填写 ConnectId (CR)，当前CR等同于Pdp Id */
pstSmBearerActivateInd->ucConnectId = pstPdpEntity->ucPdpId;
/* 填写 NSAPI */
pstSmBearerActivateInd->ucNsapi = pstPdpEntity->ucNsapi;
/* 填写 PDP ADDRESS */
Aps_PackSmAddr(&(pstPdpEntity->PdpAddr.ucPdpTypeNum),
pstPdpEntity->PdpAddr.aucIpAddr,
&pstSmBearerActivateInd->stPdpAddr);
/* 填写 APN */
if (VOS_TRUE == pstPdpEntity->PdpApnFlag)
{
pstSmBearerActivateInd->bitOpApn = VOS_TRUE;
pstSmBearerActivateInd->stApn.ulApnLen = pstPdpEntity->PdpApn.ucLength;
PS_MEM_CPY(pstSmBearerActivateInd->stApn.aucApnAddr,
pstPdpEntity->PdpApn.aucValue,
pstPdpEntity->PdpApn.ucLength);
}
/* 填写 QOS */
if (VOS_TRUE == pstPdpEntity->PdpQosFlag)
{
pstSmBearerActivateInd->bitOpPdpQos = VOS_TRUE;
Aps_PackSmQos(&pstPdpEntity->PdpQos,
&pstSmBearerActivateInd->stNegQos);
}
/* 填写 PDP TYPE: PRI or SEC */
if (APS_PDP_ACT_SEC == pstPdpEntity->ActType)
{
pstSmBearerActivateInd->bitOpLinkedNsapi = VOS_TRUE;
pstSmBearerActivateInd->ucLinkedNsapi = pstPdpEntity->ucLinkedNsapi;
}
/* 填写 RADIO PRIORITY */
if (VOS_TRUE == pstPdpEntity->GprsPara.Op_RadioPriority)
{
pstSmBearerActivateInd->bitOpRadioPriority = VOS_TRUE;
pstSmBearerActivateInd->ucRadioPriority = pstPdpEntity->GprsPara.ucRadioPriority;
}
/* LLC SAPI未实际使用, 暂不填写 LLC SAPI */
/* PACKET FLOW ID未实际使用, 暂不填写 PACKET FLOW ID */
}
VOS_VOID TAF_APS_SaveItemInCmdBufferQueue(
TAF_APS_TIMER_ID_ENUM_UINT32 enTimerId,
VOS_UINT32 *pulMsgInfo,
VOS_UINT32 ulMsgInfoLen,
VOS_UINT32 ulPara
)
{
VOS_UINT32 i;
VOS_UINT32 *pulMsgBuf;
TAF_APS_CMD_BUFFER_STRU *pstCmdBufferQueue;
/* 如果消息指针为空，直接返回 */
if (VOS_NULL_PTR == pulMsgInfo)
{
return;
}
pstCmdBufferQueue = TAF_APS_GetCmdBufferQueueAddr();
for ( i = 0 ; i < TAF_APS_MAX_CMD_BUFFER_QUEUE_SIZE; i++ )
{
if (TI_TAF_APS_TIMER_BUTT == pstCmdBufferQueue[i].enTimerId)
{
break;
}
}
/* 判定当前的循环队列是否已经满了，如果满了则直接返回，进行异常打印 */
if ( i >= TAF_APS_MAX_CMD_BUFFER_QUEUE_SIZE )
{
/* 缓存队列已满 */
TAF_ERROR_LOG1(WUEPS_PID_TAF,
"TAF_APS_SaveInfoInWaitL4aCnfMsgQueue, Buffer Full, Timer Id :",
enTimerId);
return;
}
/* 在队列增加相应的信息，分配内存，进行信息赋值 */
pulMsgBuf = (VOS_UINT32 *)PS_MEM_ALLOC(WUEPS_PID_TAF, ulMsgInfoLen);
if (VOS_NULL_PTR == pulMsgBuf)
{
/* 缓存队列已满 */
TAF_ERROR_LOG1(WUEPS_PID_TAF,
"TAF_APS_SaveInfoInWaitL4aCnfMsgQueue, Mem Alloc Fail, Timer Id :",
enTimerId);
return;
}
/* 赋值 */
PS_MEM_CPY((VOS_UINT8 *)pulMsgBuf, (VOS_UINT8 *)pulMsgInfo, ulMsgInfoLen);
pstCmdBufferQueue[i].pulMsgInfo = pulMsgBuf;
pstCmdBufferQueue[i].enTimerId = enTimerId;
pstCmdBufferQueue[i].ulMsgInfoLen = ulMsgInfoLen;
pstCmdBufferQueue[i].ulPara = ulPara;
return;
}
VOS_VOID MTC_RcvRrcNcellInfoInd(VOS_VOID * pMsg)
{
MODEM_ID_ENUM_UINT16 enModemId;
MODEM_ID_ENUM_UINT16 enOtherModemId;
RRC_MTC_NCELL_INFO_IND_STRU *pstNcellInfoInd;
MTC_MMA_TDS_NCELL_INFO_STRU stTdsNcellInfo;
MTC_MMA_LTE_NCELL_INFO_STRU stLteNcellInfo;
pstNcellInfoInd = (RRC_MTC_NCELL_INFO_IND_STRU*)pMsg;
enModemId = VOS_GetModemIDFromPid(pstNcellInfoInd->stMsgHeader.ulSenderPid);
enOtherModemId = MODEM_ID_BUTT;
PS_MEM_SET(&stTdsNcellInfo, 0x00, sizeof(stTdsNcellInfo));
PS_MEM_SET(&stLteNcellInfo, 0x00, sizeof(stLteNcellInfo));
if (enModemId >= MODEM_ID_BUTT)
{
MTC_ERROR1_LOG("MTC_RcvRrcNcellInfoInd: Err ModemId ", enModemId);
return;
}
/* 只有在PS域迁移策略使能时才执行后续流程 */
if (MTC_PS_TRANSFER_NONE == MTC_GetPsTransferCfg())
{
return;
}
/* 只有中移SVLTE方案才需要发送 */
if (MTC_OPERATOR_CUST_CMCC_SVLTE == MTC_GetOperatorCustSolution())
{
if (VOS_OK == MTC_GetOtherModemId(enModemId, &enOtherModemId))
{
stTdsNcellInfo.ucTdsArfcnNum = pstNcellInfoInd->stTdsNCellInfo.ucTdsArfcnNum;
PS_MEM_CPY(stTdsNcellInfo.ausTdsArfcnList, pstNcellInfoInd->stTdsNCellInfo.ausTdsArfcnList,
sizeof(stTdsNcellInfo.ausTdsArfcnList));
stLteNcellInfo.ucLteArfcnNum = pstNcellInfoInd->stLteNCellInfo.ucLteArfcnNum;
PS_MEM_CPY(stLteNcellInfo.ausLteArfcnList, pstNcellInfoInd->stLteNCellInfo.ausLteArfcnList,
sizeof(stLteNcellInfo.ausLteArfcnList));
MTC_SndMmaNcellInfoInd(enOtherModemId, &stTdsNcellInfo, &stLteNcellInfo);
}
}
return;
}
VOS_VOID TAF_MTA_SaveItemInCmdBufferQueue(
TAF_MTA_TIMER_ID_ENUM_UINT32 enTimerId,
VOS_UINT8 *pucMsgInfo,
VOS_UINT32 ulMsgInfoLen
)
{
VOS_UINT32 i;
VOS_UINT8 *pucMsgBuf;
TAF_MTA_CMD_BUFFER_STRU *pstCmdBufferQueue;
/* 如果消息指针为空，直接返回 */
if (VOS_NULL_PTR == pucMsgInfo)
{
return;
}
pstCmdBufferQueue = TAF_MTA_GetCmdBufferQueueAddr();
for ( i = 0; i < TAF_MTA_MAX_CMD_BUFFER_QUEUE_SIZE; i++ )
{
if (TI_TAF_MTA_TIMER_BUTT == pstCmdBufferQueue[i].enTimerId)
{
break;
}
}
/* 判定当前的循环队列是否已经满了，如果满了则直接返回，进行异常打印 */
if ( i >= TAF_MTA_MAX_CMD_BUFFER_QUEUE_SIZE )
{
/* 缓存队列已满 */
MTA_WARNING2_LOG("TAF_MTA_SaveItemInCmdBufferQueue, Buffer Full, Timer Id :",
UEPS_PID_MTA,
enTimerId);
return;
}
/* 在队列增加相应的信息，分配内存，进行信息赋值 */
pucMsgBuf = (VOS_UINT8 *)PS_MEM_ALLOC(UEPS_PID_MTA, ulMsgInfoLen);
if (VOS_NULL_PTR == pucMsgBuf)
{
/* 内存分配失败 */
MTA_WARNING2_LOG("TAF_MTA_SaveItemInCmdBufferQueue, Mem Alloc Fail, Timer Id :",
UEPS_PID_MTA,
enTimerId );
return;
}
/* 赋值 */
PS_MEM_CPY((VOS_UINT8 *)pucMsgBuf, pucMsgInfo, ulMsgInfoLen);
pstCmdBufferQueue[i].pucMsgInfo = pucMsgBuf;
pstCmdBufferQueue[i].enTimerId = enTimerId;
pstCmdBufferQueue[i].ulMsgInfoLen = ulMsgInfoLen;
return;
}
VOS_UINT32 CNAS_HSD_RcvCasNetworkLostIndProc_PreProc(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
CAS_CNAS_HRPD_NETWORK_LOST_IND_STRU *pstCasNetworkLostMsg;
CNAS_HSD_NETWORK_LOST_SYS_RECORD_STRU *pstNetwkLostSysRec;
CNAS_HSD_HISTORY_SYS_LIST_STRU *pstHistorySys;
VOS_UINT32 ulIsChange;
CNAS_HSD_SYS_MODE_TYPD_ENUM_UINT32 enSysMode;
pstCasNetworkLostMsg = (CAS_CNAS_HRPD_NETWORK_LOST_IND_STRU*)pstMsg;
pstHistorySys = CNAS_HSD_GetHistorySysList();
pstNetwkLostSysRec = CNAS_HSD_GetNetwkLostSysRec();
enSysMode = CNAS_HSD_GetModeType();
/* 非混合模式下不对signal fade进行avoid处理 */
if (CNAS_HSD_SYS_MODE_NONHYBRID == enSysMode)
{
return VOS_FALSE;
}
/* 成功驻留过后才进行处理 */
if (0 != pstHistorySys->ulTotalNum)
{
/* 非no rf和abnormal 的场景才进行avoid处理 */
if ((CAS_CNAS_HRPD_NETWORK_LOST_NO_RF != pstCasNetworkLostMsg->enNetworkLostReason)
&& (CAS_CNAS_HRPD_NETWORK_LOST_ABNORMAL != pstCasNetworkLostMsg->enNetworkLostReason))
{
/* 是否在同一系统上丢网 */
ulIsChange = CNAS_HSD_IsHrpdSysChange(&(pstHistorySys->stCampedHrpdSysInfo[0]),
&(pstNetwkLostSysRec->stHrpdSys));
if (VOS_TRUE == ulIsChange)
{
PS_MEM_CPY(&(pstNetwkLostSysRec->stHrpdSys),
&(pstHistorySys->stCampedHrpdSysInfo[0]),
sizeof(CNAS_PRL_HRPD_SYSTEM_STRU));
pstNetwkLostSysRec->ucNetwkLostCnt = 0x01;
pstNetwkLostSysRec->ulLastRecSlice = CNAS_HSD_GetSystemSlice();
}
else
{
CNAS_HSD_AvoidNetwkLostProc(pstNetwkLostSysRec);
}
}
}
else
{}
return VOS_FALSE;
}
VOS_VOID MN_APS_UpdatePdpAddrFromEpsBearer(
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity,
SM_ESM_EPS_BEARER_INFO_IND_STRU *pstEpsBearerInfoInd
)
{
/* 第一阶段只处理IPV4 */
pstPdpEntity->PdpAddrFlag = VOS_TRUE;
pstPdpEntity->PdpAddr.ucPdpTypeOrgan = APS_ADDR_ORGAN_IETF;
if (SM_ESM_PDP_IPV4 == pstEpsBearerInfoInd->stPdnAddr.ucIpType)
{
PS_MEM_CPY(pstPdpEntity->PdpAddr.aucIpAddr,
pstEpsBearerInfoInd->stPdnAddr.aucIpV4Addr,
SM_ESM_IPV4_ADDR_LEN);
pstPdpEntity->PdpAddr.ucPdpTypeNum = APS_ADDR_STATIC_IPV4;
}
#if (FEATURE_ON == FEATURE_IPV6)
if (SM_ESM_PDP_IPV6 == pstEpsBearerInfoInd->stPdnAddr.ucIpType)
{
PS_MEM_CPY(pstPdpEntity->PdpAddr.aucIpV6Addr,
pstEpsBearerInfoInd->stPdnAddr.aucIpV6Addr,
SM_ESM_IPV6_ADDR_LEN);
pstPdpEntity->PdpAddr.ucPdpTypeNum = MN_APS_ADDR_IPV6;
}
if (SM_ESM_PDP_IPV4V6 == pstEpsBearerInfoInd->stPdnAddr.ucIpType)
{
PS_MEM_CPY(pstPdpEntity->PdpAddr.aucIpV6Addr,
pstEpsBearerInfoInd->stPdnAddr.aucIpV6Addr,
SM_ESM_IPV6_ADDR_LEN);
PS_MEM_CPY(pstPdpEntity->PdpAddr.aucIpAddr,
pstEpsBearerInfoInd->stPdnAddr.aucIpV4Addr,
SM_ESM_IPV4_ADDR_LEN);
pstPdpEntity->PdpAddr.ucPdpTypeNum = MN_APS_ADDR_IPV4V6;
}
#endif
}
VOS_UINT32 NAS_UTRANCTRL_RestoreContextData_Main(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
NAS_UTRANCTRL_CTX_STRU *pstUtranCtrlCtx;
NAS_MML_PC_REPLAY_COMPRESS_CONTEXT_STRU *pstRcMsg;
VOS_UINT32 ulExpectCount;
VOS_UINT32 ulCount;
VOS_UINT32 ulItemCount;
VOS_UINT8 *pucDest;
VOS_UINT8 *pucSrc;
VOS_UINT32 ulDestLen;
pstUtranCtrlCtx = NAS_UTRANCTRL_GetUtranCtrlCtx();
ulExpectCount = 0;
ulCount = 0;
ulItemCount = 0;
ulExpectCount = sizeof(NAS_UTRANCTRL_CTX_STRU);
/*注册状态机*/
NAS_UTRANCTRL_RegFsm();
pstRcMsg = (NAS_MML_PC_REPLAY_COMPRESS_CONTEXT_STRU *)pstMsg;
pucSrc = pstRcMsg->aucData;
/* 解析总长度 */
PS_MEM_CPY(&ulCount, pucSrc, sizeof(VOS_UINT32));
pucSrc += sizeof(VOS_UINT32);
if( ulExpectCount != ulCount )
{
return VOS_FALSE;
}
/* g_stNasUtranCtrlCtx目标地址 */
pucDest = (VOS_UINT8 *)pstUtranCtrlCtx;
ulDestLen = sizeof(NAS_UTRANCTRL_CTX_STRU);
/* 解压缩 */
if (VOS_FALSE == NAS_MML_UnCompressData(pucDest, &ulDestLen, pucSrc, &ulItemCount) )
{
return VOS_FALSE;
}
pucSrc += (ulItemCount);
NAS_UTRANCTRL_ReloadFsmDesc(NAS_UTRANCTRL_GetCurFsmAddr(), pstUtranCtrlCtx->stCurFsm.enFsmId);
NAS_INFO_LOG(WUEPS_PID_MMC, "UTRANCTRL: NAS_UTRANCTRL_RestoreContextData_Main - data is restored.");
return VOS_TRUE;
}
VOS_UINT32 TAF_SPM_SendImsaEconfAddUsersReq(
MN_CALL_APP_REQ_MSG_STRU *pstAppMsg
)
{
SPM_IMSA_CALL_ECONF_ADD_USERS_REQ_STRU *pstSendImsaMsg = VOS_NULL_PTR;
TAF_CALL_ECONF_DIAL_REQ_STRU *pstEconfDialReq = VOS_NULL_PTR;
VOS_UINT32 ulMsgLen;
ulMsgLen = sizeof(SPM_IMSA_CALL_ECONF_ADD_USERS_REQ_STRU);
/* 构造消息 */
pstSendImsaMsg = (SPM_IMSA_CALL_ECONF_ADD_USERS_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
ulMsgLen);
if (VOS_NULL_PTR == pstSendImsaMsg)
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_SPM_SendImsaEconfAddUsersReq: ERROR:Memory Alloc Error for pstMsg!");
return VOS_FALSE;
}
/* 初始化消息 */
PS_MEM_SET(((VOS_UINT8 *)pstSendImsaMsg) + VOS_MSG_HEAD_LENGTH,
0x00,
(ulMsgLen - VOS_MSG_HEAD_LENGTH));
pstEconfDialReq = (TAF_CALL_ECONF_DIAL_REQ_STRU *)&pstAppMsg->unParm;
/* 填写消息头 */
pstSendImsaMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstSendImsaMsg->ulSenderPid = WUEPS_PID_TAF;
pstSendImsaMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSendImsaMsg->ulReceiverPid = PS_PID_IMSA;
pstSendImsaMsg->ulLength = ulMsgLen - VOS_MSG_HEAD_LENGTH;
/* 填写消息内容 */
pstSendImsaMsg->ulMsgId = ID_SPM_IMSA_CALL_ECONF_ADD_USERS_REQ;
pstSendImsaMsg->usClientId = pstAppMsg->clientId;
pstSendImsaMsg->ucOpId = pstAppMsg->opId;
/* 填充有效的电话号码 */
PS_MEM_CPY(&pstSendImsaMsg->stEconfCalllist, &pstEconfDialReq->stEconfCalllist, sizeof(TAF_CALL_ECONF_CALL_LIST_STRU));
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_TAF, pstSendImsaMsg))
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_SPM_SendImsaEconfAddUsersReq: Send message failed.");
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_UINT32 PPPC_EAP_PRF_PRIME
(
VOS_UINT8 *pucKey,
PPPC_SHA256_PARA_STRU *pstPara,
VOS_UINT8 *pucMK,
VOS_UINT8 ucMKLen
)
{
VOS_UINT8 aucHash[PPPC_SHA256_MAC_LEN];
VOS_UINT8 ucIter;
PPPC_SHA256_PARA_STRU stTempPara;
VOS_UINT8 ucIndex;
VOS_UINT8 ucHashLen;
/*
* PRF'(K,S) = T1 | T2 | T3 | T4 | ...
* T1 = HMAC-SHA-256 (K, S | 0x01)
* T2 = HMAC-SHA-256 (K, T1 | S | 0x02)
* T3 = HMAC-SHA-256 (K, T2 | S | 0x03)
* T4 = HMAC-SHA-256 (K, T3 | S | 0x04)
* ...
*/
PS_MEM_SET(aucHash, 0x00, sizeof(aucHash));
ucIter = 0;
stTempPara.ucNum = pstPara->ucNum + 2;
stTempPara.apucAdrr[0] = aucHash;
stTempPara.aulLen[0] = 0;
for (ucIndex = 0; ucIndex < pstPara->ucNum; ucIndex++)
{
stTempPara.apucAdrr[ucIndex + 1] = pstPara->apucAdrr[ucIndex];
stTempPara.aulLen[ucIndex + 1] = pstPara->aulLen[ucIndex];
}
stTempPara.apucAdrr[pstPara->ucNum + 1] = &ucIter;
stTempPara.aulLen[pstPara->ucNum + 1] = 1;
ucIndex = ucMKLen;
while (ucIndex > 0)
{
ucIter++;
if (VOS_OK != PPPC_HMAC_SHA256(pucKey, 32, &stTempPara, aucHash))
{
PPPC_WARNING_LOG("Error When hmac in prf'!");
return VOS_ERR;
}
stTempPara.aulLen[0] = (VOS_UINT8)PPPC_SHA256_MAC_LEN;
ucHashLen = ucIndex > PPPC_SHA256_MAC_LEN ? PPPC_SHA256_MAC_LEN : ucIndex;
PS_MEM_CPY(pucMK, aucHash, ucHashLen);
pucMK += ucHashLen;
ucIndex -= ucHashLen;
}
return VOS_OK;
}
VOS_UINT32 TAF_SPM_SndServiceCtrlRsltInd(
TAF_SPM_SERVICE_CTRL_RESULT_ENUM_UINT32 enRslt,
VOS_UINT32 ulCause,
VOS_UINT16 usClientId,
TAF_SPM_ENTRY_MSG_STRU *pstEntryMsg
)
{
TAF_SPM_SERVICE_CTRL_RSLT_STRU *pstServiceCtrlRstInd = VOS_NULL_PTR;
/* 构造消息 */
pstServiceCtrlRstInd = (TAF_SPM_SERVICE_CTRL_RSLT_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(TAF_SPM_SERVICE_CTRL_RSLT_STRU));
if (VOS_NULL_PTR == pstServiceCtrlRstInd)
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_SPM_SndServiceCtrlRsltInd: ERROR:Memory Alloc Error for pstMsg!");
return VOS_FALSE;
}
/* 初始化消息 */
PS_MEM_SET(((VOS_INT8*)pstServiceCtrlRstInd) + VOS_MSG_HEAD_LENGTH,
0x00,
sizeof(TAF_SPM_SERVICE_CTRL_RSLT_STRU) - VOS_MSG_HEAD_LENGTH);
/* 填写消息头 */
pstServiceCtrlRstInd->MsgHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstServiceCtrlRstInd->MsgHeader.ulSenderPid = WUEPS_PID_TAF;
pstServiceCtrlRstInd->MsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstServiceCtrlRstInd->MsgHeader.ulReceiverPid = WUEPS_PID_TAF;
pstServiceCtrlRstInd->MsgHeader.ulLength = sizeof(TAF_SPM_SERVICE_CTRL_RSLT_STRU) - VOS_MSG_HEAD_LENGTH;
pstServiceCtrlRstInd->MsgHeader.ulMsgName = TAF_SPM_INTERNAL_SERVICE_CTRL_RESULT_IND;
/* 填写消息内容 */
pstServiceCtrlRstInd->enResult = enRslt;
pstServiceCtrlRstInd->ulCause = ulCause;
pstServiceCtrlRstInd->usClientId = usClientId;
pstServiceCtrlRstInd->stEntryMsg.ulEventType = pstEntryMsg->ulEventType;
PS_MEM_CPY(pstServiceCtrlRstInd->stEntryMsg.aucEntryMsgBuffer,
pstEntryMsg->aucEntryMsgBuffer,
sizeof(pstEntryMsg->aucEntryMsgBuffer));
/* 发送内部消息 */
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_TAF, pstServiceCtrlRstInd))
{
TAF_ERROR_LOG(WUEPS_PID_TAF,
"TAF_SPM_SndServiceCtrlRsltInd: Send message failed.");
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_VOID MTC_SndRrcIntrusionBandSetReq(
VOS_UINT32 ulRecvPid,
RRC_MTC_MS_BAND_INFO_STRU *pstForbiddenBandInfo
)
{
VOS_UINT16 ulLenth;
MODEM_ID_ENUM_UINT16 enModemId;
MTC_RRC_INTRUSION_BAND_SET_REQ_STRU *pstBandSetReq = VOS_NULL_PTR;
enModemId = VOS_GetModemIDFromPid(ulRecvPid);
if (enModemId >= MODEM_ID_BUTT)
{
return;
}
/* 如果当前已经关机，则停止发送信息 */
if (MTC_MODEM_POWER_OFF == MTC_GetModemPowerState(enModemId))
{
return;
}
/* 分配消息空间 */
ulLenth = sizeof(MTC_RRC_INTRUSION_BAND_SET_REQ_STRU);
pstBandSetReq = (MTC_RRC_INTRUSION_BAND_SET_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
UEPS_PID_MTC,
ulLenth);
if (VOS_NULL_PTR == pstBandSetReq)
{
MTC_ERROR_LOG("MTC_SndRrcIntrusionActionSetReq: Alloc Msg Fail!");
return;
}
/* 填充消息 */
pstBandSetReq->stMsgHeader.ulReceiverPid = ulRecvPid;
pstBandSetReq->stMsgHeader.ulMsgName = ID_MTC_RRC_INTRUSION_BAND_SET_REQ;
PS_MEM_CPY(&pstBandSetReq->stForbiddenBandInfo,
pstForbiddenBandInfo,
sizeof(RRC_MTC_MS_BAND_INFO_STRU));
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(UEPS_PID_MTC, pstBandSetReq))
{
MTC_ERROR1_LOG("MTC_SndRrcIntrusionActionSetReq: Snd Msg Err. ReceiverPid: ", ulRecvPid);
return;
}
/* 记录可维可测 */
MTC_DEBUG_IntrusionSendSetBandReq(ulRecvPid);
return;
}
VOS_VOID MTC_RcvGsmCellInfoInd(VOS_VOID *pMsg)
{
RRC_MTC_GSM_CELL_INFO_IND_STRU *pstGsmInfoInd = VOS_NULL_PTR;
MTC_RRC_GSM_CELL_INFO_IND_STRU *pstGsmCellInfo = VOS_NULL_PTR;
VOS_UINT32 ulReceiverPid;
/* 如果当前已经关机，则停止发送信息 */
if (MTC_MODEM_POWER_OFF == MTC_GetModemPowerState(MODEM_ID_0))
{
return;
}
/* 判断当前主模状态, 为TDS/LTE时发送 */
if (MTC_RATMODE_TDS == MTC_GetModemRatMode(MODEM_ID_0))
{
ulReceiverPid = TPS_PID_RRC;
}
else if (MTC_RATMODE_LTE== MTC_GetModemRatMode(MODEM_ID_0))
{
ulReceiverPid = PS_PID_ERRC;
}
else
{
return;
}
/* 分配消息空间 */
pstGsmCellInfo = (MTC_RRC_GSM_CELL_INFO_IND_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
UEPS_PID_MTC,
sizeof(MTC_RRC_GSM_CELL_INFO_IND_STRU));
if (VOS_NULL_PTR == pstGsmCellInfo)
{
MTC_ERROR_LOG("MTC_RcvGsmCellInfoInd: Alloc Msg Fail!");
return;
}
pstGsmCellInfo->stMsgHeader.ulReceiverPid = ulReceiverPid;
pstGsmCellInfo->stMsgHeader.ulMsgName = ID_MTC_RRC_GSM_CELL_INFO_IND;
pstGsmInfoInd = (RRC_MTC_GSM_CELL_INFO_IND_STRU *)pMsg;
PS_MEM_CPY(&pstGsmCellInfo->stGsmCellInfo,
&pstGsmInfoInd->stGsmCellInfo,
sizeof(RRC_MTC_GSM_CELL_INFO_STRU));
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(UEPS_PID_MTC, pstGsmCellInfo))
{
MTC_ERROR_LOG("MTC_RcvGsmCellInfoInd: Snd Msg Err!");
}
return;
}
VOS_VOID TAF_MMA_ReadOplFileCnf(
USIMM_READFILE_CNF_STRU *pUsimTafMsg,
USIMM_DEF_FILEID_ENUM_UINT32 enFileID
)
{
TAF_SDC_OPL_FILE_INFO_STRU *pstOplFileInfo = VOS_NULL_PTR;
VOS_UINT8 ucEfLen;
VOS_UINT8 *pucContent = VOS_NULL_PTR;
VOS_UINT32 i;
TAF_SDC_SIM_FORMAT_PLMN_ID stSimPlmn;
pstOplFileInfo = TAF_SDC_GetUsimOplFileInfo();
PS_MEM_SET(&stSimPlmn, 0, sizeof(stSimPlmn));
if (USIMM_GSM_EFOPL_ID == enFileID)
{
pstOplFileInfo = TAF_SDC_GetSimOplFileInfo();
}
/*如果读取文件失败*/
if (MMA_SUCCESS != pUsimTafMsg->stCmdResult.ulResult)
{
MMA_ERRORLOG("TAF_MMA_ReadOplFileCnf(): Read usim opl file failed");
return;
}
if (0 == pUsimTafMsg->usEfLen)
{
MMA_ERRORLOG("TAF_MMA_ReadOplFileCnf(): usEfLen is 0");
return;
}
ucEfLen = (VOS_UINT8)pUsimTafMsg->usEfLen;
pucContent = pUsimTafMsg->aucEf;
pstOplFileInfo->ulOplRecordNum = pUsimTafMsg->ucTotalNum;
pstOplFileInfo->ulOplEfLen = (VOS_UINT32)pUsimTafMsg->usEfLen;
for (i = 0; i < pstOplFileInfo->ulOplRecordNum; i++)
{
PS_MEM_CPY(stSimPlmn.aucSimPlmn, pucContent, TAF_SDC_SIM_FORMAT_PLMN_LEN); /* [false alarm]: 数组已动态分配 */
TAF_SDC_ConvertSimPlmnToNasPLMN(&stSimPlmn, &pstOplFileInfo->astOplRecordInfo[i].stPlmnId);
pstOplFileInfo->astOplRecordInfo[i].usLacRangeLow = (*(pucContent + TAF_SDC_OCTET_MOVE_THREE_BYTES) << TAF_SDC_OCTET_MOVE_EIGHT_BITS) + (*(pucContent + TAF_SDC_OCTET_MOVE_FOUR_BYTES));/* [false alarm]: 数组已动态分配 */
pstOplFileInfo->astOplRecordInfo[i].usLacRangeHigh = (*(pucContent + TAF_SDC_OCTET_MOVE_FIVE_BYTES) << TAF_SDC_OCTET_MOVE_EIGHT_BITS) + (*(pucContent + TAF_SDC_OCTET_MOVE_SIX_BYTES));/* [false alarm]: 数组已动态分配 */
pstOplFileInfo->astOplRecordInfo[i].usPnnIndex = pucContent[TAF_SDC_OCTET_MOVE_SEVEN_BYTES]; /* [false alarm]: 数组已动态分配 */
pucContent += ucEfLen;
}
return;
}
VOS_UINT32 TAF_SPM_SendUsimEconfFdnReq(
VOS_UINT16 usClientId,
struct MsgCB *pstMsg
)
{
TAF_SPM_CALL_ECONF_INFO_STRU *pstEconfInfoAddr = VOS_NULL_PTR;
MN_CALL_CALLED_NUM_STRU *pstCalledNumber = VOS_NULL_PTR;
PS_PB_FDN_NUM_STRU stFdnInfo;
VOS_UINT32 ulRet;
VOS_UINT8 ucIndex;
VOS_UINT32 ulSendPara;
PS_MEM_SET(&stFdnInfo, 0x0, sizeof(stFdnInfo));
pstEconfInfoAddr = TAF_SPM_GetCallEconfInfoAddr();
pstEconfInfoAddr->ucSendSuccNum = 0;
pstEconfInfoAddr->ucRcvNum = 0;
for (ucIndex = 0; ucIndex < pstEconfInfoAddr->ucCallNum; ucIndex++)
{
pstEconfInfoAddr->astEconfCheckInfo[ucIndex].ulCheckCnfFlag = VOS_FALSE;
pstCalledNumber = &pstEconfInfoAddr->astEconfCheckInfo[ucIndex].stCalledNumber;
stFdnInfo.ulNum1Len = pstCalledNumber->ucNumLen <= MN_CALL_MAX_BCD_NUM_LEN ?
pstCalledNumber->ucNumLen : MN_CALL_MAX_BCD_NUM_LEN;
PS_MEM_CPY(stFdnInfo.aucNum1, pstCalledNumber->aucBcdNum, stFdnInfo.ulNum1Len);
/* 增强型多方通话情况下，高16位为表示第几个电话号码，低16位为ClinedId */
ulSendPara = TAF_SPM_ECONF_SET_SEND_PARA(ucIndex, usClientId);
ulRet = NAS_PBAPI_FdnNumCheck(WUEPS_PID_TAF, 0, ulSendPara, &stFdnInfo);
if (VOS_OK != ulRet)
{
/* 记录为失败 */
TAF_SPM_RecordEconfCheckRslt(ucIndex, TAF_CS_CAUSE_FDN_CHECK_FAILURE);
}
else
{
pstEconfInfoAddr->ucSendSuccNum++;
}
}
/* 全部发送失败，则退出 */
if (0 == pstEconfInfoAddr->ucSendSuccNum)
{
/* 上报结果 */
TAF_SPM_ReportEconfCheckRslt();
return VOS_FALSE;
}
return VOS_TRUE;
}
void
SendPapCode(struct link *l, VOS_CHAR code, VOS_CHAR *message)
{
struct fsmheader lh;
struct ppp_mbuf *bp;
VOS_CHAR *cp;
VOS_UINT32 plen, mlen;
lh.code = code;
lh.id = l->pap.auth.id;
mlen = VOS_StrNLen(message,20);
plen = mlen + 1;
lh.length = (VOS_UINT16)VOS_HTONS(plen + sizeof(struct fsmheader));
bp = ppp_m_get(plen + PPP_RECIEVE_RESERVE_FOR_HEAD + PPP_RECIEVE_RESERVE_FOR_TAIL + sizeof(struct fsmheader));
if(bp == VOS_NULL)
{
PPP_MNTN_LOG(PS_PID_APP_PPP, 0, PS_PRINT_WARNING, "no mbuf");
return;
}
/*预留头部*/
bp->m_offset = PPP_RECIEVE_RESERVE_FOR_HEAD;
/*头部与尾部都留出来了*/
bp->m_len = plen + sizeof(struct fsmheader);
PS_MEM_CPY(PPP_MBUF_CTOP(bp), &lh, sizeof(struct fsmheader));
cp = PPP_MBUF_CTOP(bp) + sizeof(struct fsmheader);
/*
* If our message is longer than 255 bytes, truncate the length to
* 255 and send the entire message anyway. Maybe the other end will
* display it... (see pap_Input() !)
*/
*cp++ = (VOS_CHAR)(mlen > 255 ? 255 : mlen);
PS_MEM_CPY(cp, message, mlen);
PPP_MNTN_LOG(PS_PID_APP_PPP, 0, PS_PRINT_NORMAL, "Pap Output\r\n");
link_PushPacket(l, bp,/* authp->physical->dl->bundle,*/
LINK_QUEUES(l) - 1, PROTO_PAP);
}
