VOS_VOID CNAS_HSM_SndHluHandOffReq(
CNAS_HSM_CONST APS_HSM_1X_TO_HRPD_HANDOFF_REQ_STRU *pstApsHandOffReq
)
{
HSM_HLU_1X_TO_HRPD_HANDOFF_REQ_STRU *pstHluHandOffReq;
VOS_UINT32 ulLen;
ulLen = sizeof(HSM_HLU_1X_TO_HRPD_HANDOFF_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
#if defined(DMT)
pstHluHandOffReq = (HSM_HLU_1X_TO_HRPD_HANDOFF_REQ_STRU *)PS_ALLOC_MSG(UEPS_PID_HSM, ulLen);
#else
pstHluHandOffReq = (HSM_HLU_1X_TO_HRPD_HANDOFF_REQ_STRU *)CNAS_GetIntMsgSendBuf(UEPS_PID_HSM,
sizeof(HSM_HLU_1X_TO_HRPD_HANDOFF_REQ_STRU));
#endif
if (CNAS_HSM_IS_NULL_PTR(pstHluHandOffReq))
{
return;
}
NAS_MEM_SET_S(((VOS_UINT8 *)pstHluHandOffReq + VOS_MSG_HEAD_LENGTH),
ulLen,
0x00,
ulLen);
CNAS_CFG_MSG_HDR(pstHluHandOffReq,
UEPS_PID_HSM,
UEPS_PID_HLU,
ID_HSM_HLU_1X_TO_HRPD_HANDOFF_REQ,
ulLen);
pstHluHandOffReq->usSid = pstApsHandOffReq->usSid;
pstHluHandOffReq->usNid = pstApsHandOffReq->usNid;
pstHluHandOffReq->ucPktZoneId = pstApsHandOffReq->ucPktZoneId;
#if defined (DMT)
(VOS_VOID)PS_SEND_MSG(UEPS_PID_HSM, pstHluHandOffReq);
#else
(VOS_VOID)CNAS_SndInternalMsg(pstHluHandOffReq);
#endif
}
VOS_VOID TAF_MMA_SndSpmImsVoiceCapInd(
VOS_UINT8 ucAvail
)
{
VOS_UINT32 ulRet;
MMA_TAF_IMS_VOICE_CAP_IND_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_TAF_IMS_VOICE_CAP_IND_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_TAF_IMS_VOICE_CAP_IND_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndSpmImsVoiceCapInd:ERROR: Memory Alloc Error for pstMsg");
return;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_TAF_IMS_VOICE_CAP_IND_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->ulReceiverPid = WUEPS_PID_TAF;
pstMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->ulSenderPid = WUEPS_PID_MMA;
pstMsg->ulLength = sizeof(MMA_TAF_IMS_VOICE_CAP_IND_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->ulMsgName = ID_MMA_TAF_IMS_VOICE_CAP_IND;
pstMsg->ucImsVoiceAvail = ucAvail;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndSpmImsVoiceCapInd:ERROR:PS_SEND_MSG FAILURE");
return;
}
return;
}
VOS_UINT32 TAF_MMA_SndMsgCsServiceChangeNotify(
TAF_CS_SERVICE_ENUM_UINT32 enCsState
)
{
VOS_UINT32 ulRet;
MMA_MSG_CS_SERVICE_IND *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_MSG_CS_SERVICE_IND *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MSG_CS_SERVICE_IND) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMsgCsServiceChangeNotify:ERROR: Memory Alloc Error for pMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MSG_CS_SERVICE_IND) - VOS_MSG_HEAD_LENGTH);
pstMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->ulReceiverPid = WUEPS_PID_TAF;
pstMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->ulSenderPid = WUEPS_PID_MMA;
pstMsg->ulLength = sizeof(MMA_MSG_CS_SERVICE_IND) - VOS_MSG_HEAD_LENGTH;
pstMsg->ulMsgName = ID_MMA_MSG_CS_SERVICE_CHANGE_NOTIFY;
pstMsg->enCSState = enCsState;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMsgCsServiceChangeNotify:ERROR:PS_SEND_MSG FAILURE");
return VOS_ERR;
}
return VOS_OK;
}
VOS_UINT32 TAF_MMA_SndMmcPlmnSpecialReq(
MMA_MMC_PLMN_ID_STRU *pstPlmnId,
MMA_MMC_NET_RAT_TYPE_ENUM_UINT8 enAccessMode
)
{
VOS_UINT32 ulRet;
MMA_MMC_PLMN_SPECIAL_REQ_STRU *pstMsg = VOS_NULL_PTR;
pstMsg = (MMA_MMC_PLMN_SPECIAL_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MMC_PLMN_SPECIAL_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcPlmnSpecialReq:ERROR: Memory Alloc Error for pMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MMC_PLMN_SPECIAL_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->MsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->MsgHeader.ulReceiverPid = WUEPS_PID_MMC;
pstMsg->MsgHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->MsgHeader.ulSenderPid = WUEPS_PID_MMA;
pstMsg->MsgHeader.ulLength = sizeof(MMA_MMC_PLMN_SPECIAL_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->MsgHeader.ulMsgName = ID_MMA_MMC_PLMN_SPECIAL_REQ;
pstMsg->stPlmnId = *pstPlmnId;
pstMsg->enAccessMode = enAccessMode;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcPlmnSpecialReq:ERROR:PS_SEND_MSG FAILURE");
return VOS_ERR;
}
return VOS_OK;
}
VOS_UINT32 TAF_MMA_SndMmcPowerOffReq(
MMA_MMC_POWER_OFF_CAUSE_ENUM_UINT32 enCause
)
{
VOS_UINT32 ulRet;
MMA_MMC_POWER_OFF_REQ_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_MMC_POWER_OFF_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MMC_POWER_OFF_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcPowerOffReq:ERROR: Memory Alloc Error for pMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MMC_POWER_OFF_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->MsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->MsgHeader.ulReceiverPid = WUEPS_PID_MMC;
pstMsg->MsgHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->MsgHeader.ulSenderPid = WUEPS_PID_MMA;
pstMsg->MsgHeader.ulLength = sizeof(MMA_MMC_POWER_OFF_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->MsgHeader.ulMsgName = ID_MMA_MMC_POWER_OFF_REQ;
pstMsg->enCause = enCause;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcPowerOffReq:ERROR:PS_SEND_MSG FAILURE");
return VOS_ERR;
}
NAS_TRACE_HIGH("Send Msg!");
return VOS_OK;
}
VOS_VOID CNAS_HSM_SndHluSessionChangedInd(
CNAS_HSM_SESSION_TYPE_ENUM_UINT8 enSessionType
)
{
HSM_HLU_SESSION_CHANGED_IND_STRU *pstSessionChangedInd;
VOS_UINT32 ulLen;
ulLen = sizeof(HSM_HLU_SESSION_CHANGED_IND_STRU) - VOS_MSG_HEAD_LENGTH;
#if defined(DMT)
pstSessionChangedInd = (HSM_HLU_SESSION_CHANGED_IND_STRU *)PS_ALLOC_MSG(UEPS_PID_HSM, ulLen);
#else
pstSessionChangedInd = (HSM_HLU_SESSION_CHANGED_IND_STRU *)CNAS_GetIntMsgSendBuf(UEPS_PID_HSM,
sizeof(HSM_HLU_SESSION_CHANGED_IND_STRU));
#endif
if (VOS_NULL_PTR == pstSessionChangedInd)
{
return;
}
NAS_MEM_SET_S(((VOS_UINT8 *)pstSessionChangedInd + VOS_MSG_HEAD_LENGTH),
ulLen,
0x00,
ulLen);
CNAS_CFG_MSG_HDR(pstSessionChangedInd,
UEPS_PID_HSM,
UEPS_PID_HLU,
ID_HSM_HLU_SESSION_CHANGED_IND,
ulLen);
pstSessionChangedInd->enRatMode = CNAS_HSM_ConvertHsmSessionTypeToHluSessionRatMode(enSessionType);
#if defined (DMT)
(VOS_VOID)PS_SEND_MSG(UEPS_PID_HSM, pstSessionChangedInd);
#else
(VOS_VOID)CNAS_SndInternalMsg(pstSessionChangedInd);
#endif
}
VOS_UINT32 TAF_MMA_SndMmcAcqReq(
TAF_MMA_ACQ_PARA_STRU *pstMmaAcqPara
)
{
VOS_UINT32 ulRet;
MMA_MMC_ACQ_REQ_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_MMC_ACQ_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MMC_ACQ_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstMsg)
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcAcqReq:ERROR: Memory Alloc Error for pMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MMC_ACQ_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->stMsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->stMsgHeader.ulReceiverPid = WUEPS_PID_MMC;
pstMsg->stMsgHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->stMsgHeader.ulSenderPid = WUEPS_PID_MMA;
pstMsg->stMsgHeader.ulLength = sizeof(MMA_MMC_ACQ_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->stMsgHeader.ulMsgName = ID_MMA_MMC_ACQ_REQ;
pstMsg->enAcqReason = pstMmaAcqPara->enAcqReason;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG(WUEPS_PID_MMA, pstMsg);
if (VOS_OK != ulRet)
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcAcqReq:ERROR:PS_SEND_MSG FAILURE");
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID Ss_SndMmssAbortReq(
VOS_UINT8 ucTi /* 对应的MM连接的TI */
)
{
VOS_VOID *pMsg; /* 定义消息中数据 */
pMsg = PS_ALLOC_MSG(WUEPS_PID_SS, sizeof(MMSS_ABORT_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pMsg )
{
NAS_MSG_FAIL();
return;
}
(( MMSS_ABORT_REQ_STRU *)pMsg )->MsgHeader.ulReceiverPid = WUEPS_PID_MM;
(( MMSS_ABORT_REQ_STRU *)pMsg )->MsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID; /* 设置消息组名 */
(( MMSS_ABORT_REQ_STRU *)pMsg )->MsgHeader.ulMsgName = MMSS_ABORT_REQ; /* 设置消息名称 */
(( MMSS_ABORT_REQ_STRU *)pMsg )->ulTransactionId = ucTi; /* 设置对应的MM连接的TI */
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_SS, pMsg)) /* 向MM发送 */
{
NAS_WARNING_LOG(WUEPS_PID_SS, "Ss_SndMmssAbortReq():WARNING:SEND MSG FIAL");
}
}
VOS_UINT32 AT_SndSetVoicePrefer (
VOS_UINT16 usClientId,
VOS_UINT8 ucOpId,
VOS_UINT32 ulVoicePreferApStatus
)
{
AT_RABM_SET_VOICEPREFER_PARA_REQ_STRU *pstSndMsg = VOS_NULL_PTR;
VOS_UINT32 ulRslt;
/* 申请内存 */
pstSndMsg = (AT_RABM_SET_VOICEPREFER_PARA_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(AT_RABM_SET_VOICEPREFER_PARA_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstSndMsg )
{
/* 内存申请失败 */
AT_ERR_LOG("AT_SndSetVoicePrefer:ERROR: Memory Alloc Error for pstMsg");
return VOS_ERR;
}
/* 填写相关参数 */
pstSndMsg->stMsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSndMsg->stMsgHeader.ulReceiverPid = AT_GetDestPid(usClientId, I0_WUEPS_PID_RABM);
pstSndMsg->stMsgHeader.ulLength = sizeof(AT_RABM_SET_VOICEPREFER_PARA_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstSndMsg->stMsgHeader.ulMsgName = ID_AT_RABM_SET_VOICEPREFER_PARA_REQ;
pstSndMsg->usClientId = usClientId;
pstSndMsg->ucOpId = ucOpId;
pstSndMsg->ulVoicePreferApStatus = ulVoicePreferApStatus;
/* 调用VOS发送原语 */
ulRslt = PS_SEND_MSG(WUEPS_PID_AT, pstSndMsg);
if ( VOS_OK != ulRslt )
{
AT_ERR_LOG("AT_SndSetVoicePrefer:ERROR:PS_SEND_MSG ");
return VOS_ERR;
}
return VOS_OK;
}
VOS_UINT32 APP_VC_SetVoiceMode(
MN_CLIENT_ID_T ClientId,
MN_OPERATION_ID_T OpId,
VOS_UINT8 ucVoiceMode,
VOS_UINT32 ulTaskPid
)
{
/*构造消息发送消息给VC模块*/
VOS_UINT32 ulRslt;
APP_VC_REQ_MSG_STRU *pstMsg;
/* 申请消息 */
pstMsg = (APP_VC_REQ_MSG_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(APP_VC_REQ_MSG_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstMsg)
{
AT_ERR_LOG("APP_VC_SetVoiceMode: ALLOC MSG FAIL.");
return VOS_ERR;
}
pstMsg->clientId = ClientId;
pstMsg->opId = OpId;
pstMsg->enMsgName = APP_VC_MSG_REQ_SET_MODE;
pstMsg->ulSenderPid = WUEPS_PID_AT;
pstMsg->ulReceiverPid = ulTaskPid;
pstMsg->aucContent[0] = ucVoiceMode;
pstMsg->aucContent[1] = 0;
pstMsg->aucContent[2] = 0;
pstMsg->aucContent[3] = 0;
ulRslt = PS_SEND_MSG(WUEPS_PID_AT, pstMsg);
if (VOS_OK != ulRslt)
{
AT_ERR_LOG("APP_VC_SetVoiceMode: SEND MSG FAIL.");
return VOS_ERR;
}
return VOS_OK;
}
/*****************************************************************************
函 数 名 : AT_FillAndSndCSIMAMsg
功能描述 : AT到CCIMA模块消息
输入参数 : VIA Modem 复位状态
输出参数 : 无
返 回 值 : VOS_UINT32
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2013年12月20日
修改内容 : V9R1 L_plus_C项目新增
*****************************************************************************/
VOS_UINT32 AT_FillAndSndCSIMAMsg(VOS_UINT32 ulModemStatus)
{
AT_CSIMA_RESET_STATUS_IND_MSG_STRU *pstATCSIMAIndMsg;
/* 申请内存 */
pstATCSIMAIndMsg = (AT_CSIMA_RESET_STATUS_IND_MSG_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(AT_CSIMA_RESET_STATUS_IND_MSG_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstATCSIMAIndMsg )
{
/* 内存申请失败 */
AT_ERR_LOG("AT_FillAndSndCSIMAMsg:ERROR: Memory Alloc Error for pstMsg");
return VOS_ERR;
}
/* 填写相关参数 */
pstATCSIMAIndMsg->ulReceiverPid = WUEPS_PID_CSIMA;
pstATCSIMAIndMsg->ulMsgId = AT_CSIMA_RESET_IND_MSG;
pstATCSIMAIndMsg->enVIAModemStatus = (CBP_MODEM_RESET_STATUS_ENUM_UINT32)ulModemStatus;
/* 调用VOS发送原语 */
return PS_SEND_MSG(WUEPS_PID_AT, pstATCSIMAIndMsg);
}
VOS_UINT32 TAF_MMA_SndMmcModeChangeReq(
MMA_MMC_MS_MODE_ENUM_UINT32 enMsMode
)
{
VOS_UINT32 ulRet;
MMA_MMC_MODE_CHANGE_REQ_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_MMC_MODE_CHANGE_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MMC_MODE_CHANGE_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcModeChangeReq:ERROR: Memory Alloc Error for pMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MMC_MODE_CHANGE_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->MsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->MsgHeader.ulReceiverPid = WUEPS_PID_MMC;
pstMsg->MsgHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->MsgHeader.ulSenderPid = WUEPS_PID_MMA;
pstMsg->MsgHeader.ulLength = sizeof(MMA_MMC_MODE_CHANGE_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->MsgHeader.ulMsgName = ID_MMA_MMC_MODE_CHANGE_REQ;
pstMsg->enMsMode = enMsMode;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcModeChangeReq:ERROR:PS_SEND_MSG FAILURE");
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID TAF_MMA_SndMmcImsSrvInfoNotify(
VOS_UINT8 ucImsCallFlg
)
{
VOS_UINT32 ulRet;
MMA_MMC_IMS_SRV_INFO_NOTIFY_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_MMC_IMS_SRV_INFO_NOTIFY_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MMC_IMS_SRV_INFO_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
MN_ERR_LOG("TAF_MMA_SndMmcImsSrvInfoNotify:ERROR: Memory Alloc Error for pMsg");
return;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MMC_IMS_SRV_INFO_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->stMsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->stMsgHeader.ulReceiverPid = WUEPS_PID_MMC;
pstMsg->stMsgHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->stMsgHeader.ulSenderPid = WUEPS_PID_MMA;
pstMsg->stMsgHeader.ulLength = sizeof(MMA_MMC_IMS_SRV_INFO_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->stMsgHeader.ulMsgName = ID_MMA_MMC_IMS_SRV_INFO_NOTIFY;
pstMsg->ucImsCallFlg = ucImsCallFlg;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
MN_ERR_LOG("TAF_MMA_SndMmcImsSrvInfoNotify:ERROR:PS_SEND_MSG FAILURE");
}
return;
}
VOS_UINT32 APP_VC_GetVoicePort(
MN_CLIENT_ID_T ClientId,
MN_OPERATION_ID_T OpId
)
{
/*构造消息发送消息给VC模块*/
VOS_UINT32 ulRslt;
APP_VC_REQ_MSG_STRU *pstMsg;
/* 申请消息 */
pstMsg = (APP_VC_REQ_MSG_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(APP_VC_REQ_MSG_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstMsg)
{
AT_ERR_LOG("APP_VC_GetVoicePort: ALLOC MSG FAIL.");
return VOS_ERR;
}
/* 组装消息 */
pstMsg->clientId = ClientId;
pstMsg->opId = OpId;
pstMsg->enMsgName = APP_VC_MSG_REQ_QRY_PORT;
pstMsg->ulSenderPid = WUEPS_PID_AT;
pstMsg->ulReceiverPid = AT_GetDestPid(ClientId, I0_WUEPS_PID_VC);
pstMsg->aucContent[0] = 0;
pstMsg->aucContent[1] = 0;
pstMsg->aucContent[2] = 0;
pstMsg->aucContent[3] = 0;
ulRslt = PS_SEND_MSG(WUEPS_PID_AT, pstMsg);
if (VOS_OK != ulRslt)
{
AT_ERR_LOG("APP_VC_GetVoicePort: SEND MSG FAIL.");
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID MTC_SndRrcNotchChannelInd(
VOS_UINT32 ulRecvPid,
PS_BOOL_ENUM_UINT8 enEnableFlag
)
{
VOS_UINT16 ulLenth;
MTC_RRC_NOTCH_CHANNEL_IND_STRU *pstNotchChannelInd = VOS_NULL_PTR;
ulLenth = sizeof(MTC_RRC_NOTCH_CHANNEL_IND_STRU) - VOS_MSG_HEAD_LENGTH;
/* 分配消息空间 */
pstNotchChannelInd = (MTC_RRC_NOTCH_CHANNEL_IND_STRU *)PS_ALLOC_MSG(
UEPS_PID_MTC,
ulLenth);
if (VOS_NULL_PTR == pstNotchChannelInd)
{
MTC_ERROR_LOG("MTC_SndRrcNotchChannelInd: alloc msg fail.");
return;
}
/* 清消息空间 */
PS_MEM_SET((VOS_UINT8*)pstNotchChannelInd + VOS_MSG_HEAD_LENGTH, 0, ulLenth);
/* 填充消息 */
pstNotchChannelInd->stMsgHeader.ulReceiverPid = ulRecvPid;
pstNotchChannelInd->stMsgHeader.ulMsgName = ID_MTC_RRC_NOTCH_CHANNEL_IND;
pstNotchChannelInd->enStartFlag = enEnableFlag;
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(UEPS_PID_MTC, pstNotchChannelInd))
{
MTC_ERROR1_LOG("MTC_SndRrcNotchChannelInd: Snd Msg err. Rec Pid ", ulRecvPid);
return;
}
return;
}
VOS_VOID MTC_SndRrcRseCfgInd(
VOS_UINT32 ulRcvPid,
PS_BOOL_ENUM_UINT8 enRseOnFlag
)
{
MTC_RRC_RSE_CFG_IND_STRU *pstRseCfg = VOS_NULL_PTR;
VOS_UINT32 ulLength;
ulLength = sizeof(MTC_RRC_RSE_CFG_IND_STRU) - VOS_MSG_HEAD_LENGTH;
/* 分配消息空间 */
pstRseCfg = (MTC_RRC_RSE_CFG_IND_STRU *)PS_ALLOC_MSG(UEPS_PID_MTC, ulLength);
if (VOS_NULL_PTR == pstRseCfg)
{
MTC_ERROR_LOG("MTC_SndRrcRseCfgInd: alloc mem fail.");
return;
}
/* 填写消息内容 */
pstRseCfg->stMsgHeader.ulReceiverPid = ulRcvPid;
pstRseCfg->stMsgHeader.ulMsgName = ID_MTC_RRC_RSE_CFG_IND;
pstRseCfg->enRseOnFlag = enRseOnFlag;
pstRseCfg->aucRsv[0] = 0;
pstRseCfg->aucRsv[1] = 0;
pstRseCfg->aucRsv[2] = 0;
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(UEPS_PID_MTC, pstRseCfg))
{
MTC_ERROR_LOG("MTC_SndRrcRseCfgInd: Snd Msg err.");
return;
}
/* 将上报结果保存到上下文中 */
MTC_SetRseCfgValue(enRseOnFlag);
return;
}
VOS_VOID CNAS_HSM_SndHsdPowerSaveCnf(VOS_VOID)
{
HSM_HSD_POWER_SAVE_CNF_STRU *pstHsmHsdPowerSaveCnf = VOS_NULL_PTR;
#if defined(DMT)
VOS_UINT32 ulLen;
ulLen = sizeof(HSM_HSD_POWER_SAVE_CNF_STRU) - VOS_MSG_HEAD_LENGTH;
pstHsmHsdPowerSaveCnf = (HSM_HSD_POWER_SAVE_CNF_STRU *)PS_ALLOC_MSG(UEPS_PID_HSM, ulLen);
#else
pstHsmHsdPowerSaveCnf = (HSM_HSD_POWER_SAVE_CNF_STRU *)CNAS_GetIntMsgSendBuf(UEPS_PID_HSM, sizeof(HSM_HSD_POWER_SAVE_CNF_STRU));
#endif
if (VOS_NULL_PTR == pstHsmHsdPowerSaveCnf)
{
return;
}
#if defined(DMT)
NAS_MEM_SET_S(((VOS_UINT8 *)pstHsmHsdPowerSaveCnf + VOS_MSG_HEAD_LENGTH),
(sizeof(HSM_HSD_POWER_SAVE_CNF_STRU) - VOS_MSG_HEAD_LENGTH),
0,
(sizeof(HSM_HSD_POWER_SAVE_CNF_STRU) - VOS_MSG_HEAD_LENGTH));
#endif
CNAS_CFG_MSG_HDR(pstHsmHsdPowerSaveCnf,
UEPS_PID_HSM,
UEPS_PID_HSD,
ID_HSM_HSD_POWER_SAVE_CNF,
(sizeof(HSM_HSD_POWER_SAVE_CNF_STRU) - VOS_MSG_HEAD_LENGTH));
#if defined(DMT)
(VOS_VOID)PS_SEND_MSG(UEPS_PID_HSM, pstHsmHsdPowerSaveCnf);
#else
(VOS_VOID)CNAS_SndInternalMsg(pstHsmHsdPowerSaveCnf);
#endif
}
VOS_UINT32 AT_FillAndSndCSIMAMsg(VOS_UINT16 usClinetID, VOS_UINT32 ulModemStatus)
{
AT_CSIMA_RESET_STATUS_IND_MSG_STRU *pstATCSIMAIndMsg;
MODEM_ID_ENUM_UINT16 enModemID;
/* 调用接口获取Modem ID */
if(VOS_OK != AT_GetModemIdFromClient(usClinetID,&enModemID))
{
AT_ERR_LOG("AT_FillAndSndCSIMAMsg:ERROR: AT_GetModemIdFromClient Error");
return VOS_ERR;
}
/* 申请内存 */
pstATCSIMAIndMsg = (AT_CSIMA_RESET_STATUS_IND_MSG_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(AT_CSIMA_RESET_STATUS_IND_MSG_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstATCSIMAIndMsg )
{
/* 内存申请失败 */
AT_ERR_LOG("AT_FillAndSndCSIMAMsg:ERROR: Memory Alloc Error for pstMsg");
return VOS_ERR;
}
/* 填写相关参数 */
if (MODEM_ID_1 == enModemID)
{
pstATCSIMAIndMsg->ulReceiverPid = I1_WUEPS_PID_CSIMA;
}
else
{
pstATCSIMAIndMsg->ulReceiverPid = I0_WUEPS_PID_CSIMA;
}
pstATCSIMAIndMsg->ulMsgId = AT_CSIMA_RESET_IND_MSG;
pstATCSIMAIndMsg->enVIAModemStatus = (CBP_MODEM_RESET_STATUS_ENUM_UINT32)ulModemStatus;
/* 调用VOS发送原语 */
return PS_SEND_MSG(WUEPS_PID_AT, pstATCSIMAIndMsg);
}
VOS_UINT32 At_SndReleaseRrcReq (
VOS_UINT16 usClientId,
VOS_UINT8 ucOpId
)
{
AT_RABM_RELEASE_RRC_REQ_STRU *pstSndMsg;
VOS_UINT32 ulRslt;
/* 申请内存 */
pstSndMsg = (AT_RABM_RELEASE_RRC_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(AT_RABM_RELEASE_RRC_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstSndMsg )
{
/* 内存申请失败 */
AT_ERR_LOG("At_SndReleaseRrcReq:ERROR: Memory Alloc Error for pstMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_CHAR*)pstSndMsg + VOS_MSG_HEAD_LENGTH, 0x00, (sizeof(AT_RABM_RELEASE_RRC_REQ_STRU) - VOS_MSG_HEAD_LENGTH));
/* 填写相关参数 */
pstSndMsg->stMsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSndMsg->stMsgHeader.ulReceiverPid = AT_GetDestPid(usClientId, I0_WUEPS_PID_RABM);
pstSndMsg->stMsgHeader.ulLength = sizeof(AT_RABM_RELEASE_RRC_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstSndMsg->stMsgHeader.ulMsgName = ID_AT_RABM_SET_RELEASE_RRC_REQ;
pstSndMsg->usClientId = usClientId;
pstSndMsg->ucOpId = ucOpId;
/* 调用VOS发送原语 */
ulRslt = PS_SEND_MSG(WUEPS_PID_AT, pstSndMsg);
if ( VOS_OK != ulRslt )
{
AT_ERR_LOG("At_SndReleaseRrcReq:ERROR:PS_SEND_MSG ");
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID Ss_SndMmssDataReq(
VOS_UINT8 ucTi, /* 对应的MM连接的TI */
VOS_UINT8 *pucSsMsg, /* 待发送数据 */
VOS_UINT32 ulSsMsgSize /* 消息长度 */
)
{
VOS_VOID *pMsg; /* 定义消息中数据 */
MMSS_DATA_REQ_STRU *pSndMsg;
VOS_UINT32 ulMsgLen; /* 定义消息长度变量 */
ulMsgLen = (sizeof( MMSS_DATA_REQ_STRU ) + ulSsMsgSize) - 4; /* 设置消息长度 */
if ( ulMsgLen < sizeof( MMSS_DATA_REQ_STRU ) )
{
ulMsgLen = sizeof( MMSS_DATA_REQ_STRU );
}
pMsg = PS_ALLOC_MSG(WUEPS_PID_SS, ulMsgLen - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pMsg )
{
return;
}
pSndMsg = (MMSS_DATA_REQ_STRU *)pMsg;
pSndMsg->MsgHeader.ulReceiverPid = WUEPS_PID_MM;
pSndMsg->MsgHeader.ulReceiverCpuId = VOS_LOCAL_CPUID; /* 设置消息组名 */
pSndMsg->MsgHeader.ulMsgName = MMSS_DATA_REQ; /* 设置消息名称 */
pSndMsg->ulTi = ucTi; /* 设置对应的MM连接的TI */
pSndMsg->SsMsg.ulSsMsgSize = ulSsMsgSize; /* 设置消息长度 */
Ss_MemCpy(pSndMsg->SsMsg.aucSsMsg,
pucSsMsg, ulSsMsgSize ); /* 设置消息中的数据 */
/* 通过OM勾取SS空口消息 */
NAS_SS_ReportM2NOtaMsg(&pSndMsg->SsMsg);
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_SS, pSndMsg)) /* 向MM发送 */
{
NAS_WARNING_LOG(WUEPS_PID_SS, "Ss_SndMmssRelReq():WARNING:SEND MSG FIAL");
}
}
VOS_VOID CNAS_XSD_SndCasPowerOffReq(VOS_VOID)
{
CNAS_CAS_1X_POWER_OFF_REQ_STRU *pstPowerOffReq = VOS_NULL_PTR;
/* 分配消息 */
pstPowerOffReq = (CNAS_CAS_1X_POWER_OFF_REQ_STRU *)PS_ALLOC_MSG(UEPS_PID_XSD,
sizeof(CNAS_CAS_1X_POWER_OFF_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstPowerOffReq)
{
return;
}
/* 填充消息 */
pstPowerOffReq->ulReceiverPid = UEPS_PID_1XCASM;
pstPowerOffReq->enMsgId = ID_CNAS_CAS_1X_POWER_OFF_REQ;
pstPowerOffReq->usOpId = 0;
CNAS_MNTN_LogMsgInfo((MSG_HEADER_STRU*)pstPowerOffReq);
/* 发送消息 */
(VOS_VOID)PS_SEND_MSG(UEPS_PID_XSD, pstPowerOffReq);
NAS_TRACE_HIGH("Send Msg!");
}
VOS_UINT32 APP_VC_SendPhyTestModeNotify(
CALL_VC_RADIO_MODE_ENUM_U8 enMode
)
{
VC_PHY_TEST_MODE_NOTIFY_STRU *pstMsg;
/* 申请消息 */
pstMsg = (VC_PHY_TEST_MODE_NOTIFY_STRU *)PS_ALLOC_MSG(WUEPS_PID_VC,
sizeof(VC_PHY_TEST_MODE_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstMsg)
{
return VOS_ERR;
}
/*
不同接入模式，需要发送不同的测试模式消息给物理层，当前的测试模式
只有G DSP需要，所以目前的实现是只发送给GDSP，其他场景直接返回，后面
其他模的DSP有需要的时候再添加
*/
if (CALL_VC_MODE_GSM == enMode)
{
pstMsg->usMsgName = ID_VC_GPHY_TEST_MODE_NOTIFY;
pstMsg->ulReceiverPid = DSP_PID_GPHY;
}
else
{
PS_FREE_MSG(WUEPS_PID_VC, pstMsg);
return VOS_OK;
}
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_VC, pstMsg))
{
VC_WARN_LOG("APP_VC_SendPhyTestModeNotify():WARNING:SEND MSG FIAL");
}
return VOS_OK;
}
VOS_VOID NAS_SMS_SndOutsideContextData()
{
NAS_SMS_SDT_SMS_PART_ST *pSndMsgCB = VOS_NULL_PTR;
NAS_SMS_OUTSIDE_RUNNING_CONTEXT_PART_ST *pstOutsideCtx;
pSndMsgCB = (NAS_SMS_SDT_SMS_PART_ST *)PS_ALLOC_MSG(WUEPS_PID_SMS,
sizeof(NAS_SMS_SDT_SMS_PART_ST));
if ( VOS_NULL_PTR == pSndMsgCB )
{
SMS_LOG(PS_LOG_LEVEL_ERROR, "NAS_SMS_SndOutsideContextData:ERROR: Alloc Memory Fail.");
return;
}
pSndMsgCB->ulReceiverPid = WUEPS_PID_SMS;
pSndMsgCB->ulSenderPid = WUEPS_PID_SMS;
pSndMsgCB->ulSenderCpuId = VOS_LOCAL_CPUID;
pSndMsgCB->ulReceiverCpuId = VOS_LOCAL_CPUID;
pSndMsgCB->ulLength = sizeof(NAS_SMS_OUTSIDE_RUNNING_CONTEXT_PART_ST) + 4;
pSndMsgCB->ulMsgName = SMS_PC_REPLAY_MSG;
pstOutsideCtx = &pSndMsgCB->stOutsideCtx;
PS_MEM_CPY(&pstOutsideCtx->g_SmcPsEnt, &g_SmcPsEnt, sizeof(g_SmcPsEnt));
PS_MEM_CPY(&pstOutsideCtx->g_SmcCsEnt, &g_SmcCsEnt, sizeof(g_SmcCsEnt));
PS_MEM_CPY(&pstOutsideCtx->g_SmrEnt, &g_SmrEnt, sizeof(g_SmrEnt));
pstOutsideCtx->g_ucPsServiceStatus = g_ucPsServiceStatus;
pstOutsideCtx->g_ucCsRegFlg = g_ucCsRegFlg;
pstOutsideCtx->g_ucSmsMR = g_ucSmsMR;
pstOutsideCtx->g_SndDomain = g_SndDomain;
DIAG_TraceReport(pSndMsgCB);
PS_FREE_MSG(WUEPS_PID_SMS, pSndMsgCB);
return;
}
VOS_VOID MTC_SndModem0MmaPsTransferInd(
MTC_PS_TRANSFER_CAUSE_ENUM_UINT8 enPsTransferCause
)
{
VOS_UINT16 ulLenth;
MTC_MMA_PS_TRANSFER_IND_STRU *pstPsTransferInd = VOS_NULL_PTR;
ulLenth = sizeof(MTC_MMA_PS_TRANSFER_IND_STRU) - VOS_MSG_HEAD_LENGTH;
/* 分配消息空间 */
pstPsTransferInd = (MTC_MMA_PS_TRANSFER_IND_STRU*)PS_ALLOC_MSG(UEPS_PID_MTC, ulLenth);
if (VOS_NULL_PTR == pstPsTransferInd)
{
MTC_ERROR_LOG("MTC_SndMmaPsTransferInd: Alloc msg fail!");
return;
}
/* 清消息空间 */
PS_MEM_SET((VOS_UINT8*)pstPsTransferInd + VOS_MSG_HEAD_LENGTH, 0, ulLenth);
/* 填充消息 */
pstPsTransferInd->stMsgHeader.ulReceiverPid = I0_WUEPS_PID_MMA;
pstPsTransferInd->stMsgHeader.ulMsgName = ID_MTC_MMA_PS_TRANSFER_IND;
pstPsTransferInd->enSolutionCfg = MTC_GetPsTransferCfg();
pstPsTransferInd->ucCause = enPsTransferCause;
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(UEPS_PID_MTC, pstPsTransferInd))
{
MTC_ERROR1_LOG("MTC_SndMmaPsTransferInd: Snd Msg err. Rec Pid ", I0_WUEPS_PID_MMA);
return;
}
return;
}
VOS_UINT32 PPP_RcvAtCtrlOperEvent(VOS_UINT16 usPppId, PPP_AT_CTRL_OPER_TYPE_ENUM_UINT32 ulCtrlOperType)
{
PPP_AT_CTRL_OPERATION_MSG *pSndMsg;
if(PPP_AT_CTRL_BUTT <= ulCtrlOperType)
{
PPP_MNTN_LOG1(PS_PID_APP_PPP, 0, PS_PRINT_ERROR,
"PPP_RcvAtCtrlOperEvent:ulCtrlOperType ERROR!",(VOS_INT32)ulCtrlOperType);
return VOS_ERR;
}
pSndMsg = (PPP_AT_CTRL_OPERATION_MSG *)PS_ALLOC_MSG(PS_PID_APP_PPP, sizeof(PPP_AT_CTRL_OPERATION_MSG) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pSndMsg)
{
PPP_MNTN_LOG(PS_PID_APP_PPP, 0, PS_PRINT_WARNING,
"PPP, PPP_RcvAtCtrlOperEvent, WARNING, Alloc msg fail!\r\n");
return VOS_ERR;
}
pSndMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pSndMsg->ulReceiverPid = PS_PID_APP_PPP;
pSndMsg->ulMsgType = PPP_AT_CTRL_OPERATION;
pSndMsg->usPppId = usPppId;
pSndMsg->ulCtrlOpType = ulCtrlOperType;
/*发送该消息:*/
if ( VOS_OK != PS_SEND_MSG(PS_PID_APP_PPP, pSndMsg) )
{
PPP_MNTN_LOG(PS_PID_APP_PPP, 0, PS_PRINT_WARNING,
"PPP, PPP_RcvAtCtrlOperEvent, WARNING, Send msg fail!\r\n");
return VOS_ERR;
}
return VOS_OK;
}
VOS_UINT32 CNAS_XSD_SndCasCdmaCsqSetReq(
VOS_UINT8 ucRssiRptThreshold,
VOS_UINT8 ucEcIoRptThreshold,
VOS_UINT8 ucTimeInterval
)
{
CNAS_CAS_1X_SET_SIGNAL_QUALITY_REQ_STRU *pstSetCdmaCsqReq = VOS_NULL_PTR;
/* 分配消息 */
pstSetCdmaCsqReq = (CNAS_CAS_1X_SET_SIGNAL_QUALITY_REQ_STRU *)PS_ALLOC_MSG(UEPS_PID_XSD,
sizeof(CNAS_CAS_1X_SET_SIGNAL_QUALITY_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstSetCdmaCsqReq)
{
return VOS_FALSE;
}
/* 填充消息 */
pstSetCdmaCsqReq->ulReceiverPid = UEPS_PID_1XCASM;
pstSetCdmaCsqReq->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSetCdmaCsqReq->ulSenderPid = UEPS_PID_XSD;
pstSetCdmaCsqReq->ulSenderCpuId = VOS_LOCAL_CPUID;
pstSetCdmaCsqReq->enMsgId = ID_CNAS_CAS_1X_SET_SIGNAL_QUALITY_REQ;
pstSetCdmaCsqReq->usOpId = 0;
pstSetCdmaCsqReq->ucRptRssiThreshold = ucRssiRptThreshold;
pstSetCdmaCsqReq->ucRptEcIoThreshold = ucEcIoRptThreshold;
pstSetCdmaCsqReq->ucTimeInterval = ucTimeInterval;
NAS_MEM_SET_S(pstSetCdmaCsqReq->aucReserve, sizeof(pstSetCdmaCsqReq->aucReserve), 0, sizeof(pstSetCdmaCsqReq->aucReserve));
CNAS_MNTN_LogMsgInfo((MSG_HEADER_STRU*)pstSetCdmaCsqReq);
/* 发送消息 */
(VOS_VOID)PS_SEND_MSG(UEPS_PID_XSD, pstSetCdmaCsqReq);
return VOS_TRUE;
}
VOS_VOID CNAS_XSD_SndCasStopSysSyncReq(VOS_VOID)
{
CNAS_CAS_1X_STOP_SYSTEM_SYNC_REQ_STRU *pstStopSysSyncReq = VOS_NULL_PTR;
/* 分配消息 */
pstStopSysSyncReq = (CNAS_CAS_1X_STOP_SYSTEM_SYNC_REQ_STRU *)PS_ALLOC_MSG(UEPS_PID_XSD,
sizeof(CNAS_CAS_1X_STOP_SYSTEM_SYNC_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstStopSysSyncReq)
{
return;
}
NAS_MEM_SET_S(pstStopSysSyncReq->aucReserve, sizeof(pstStopSysSyncReq->aucReserve), 0x0, sizeof(VOS_UINT8) * 4);
/* 填充消息 */
pstStopSysSyncReq->ulReceiverPid = UEPS_PID_1XCASM;
pstStopSysSyncReq->enMsgId = ID_CNAS_CAS_1X_STOP_SYSTEM_SYNC_REQ;
pstStopSysSyncReq->usOpId = 0;
CNAS_MNTN_LogMsgInfo((MSG_HEADER_STRU*)pstStopSysSyncReq);
/* 发送消息 */
(VOS_VOID)PS_SEND_MSG(UEPS_PID_XSD, pstStopSysSyncReq);
}
VOS_VOID TAF_MMA_SndImsaStartReq(VOS_VOID)
{
VOS_UINT32 ulRet;
MMA_IMSA_START_REQ_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_IMSA_START_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_IMSA_START_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstMsg)
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndImsaStartReq:ERROR: Memory Alloc Error for pMsg");
return;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_IMSA_START_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->ulReceiverPid = PS_PID_IMSA;
pstMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->ulSenderPid = WUEPS_PID_MMA;
pstMsg->ulLength = sizeof(MMA_IMSA_START_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->ulMsgId = ID_MMA_IMSA_START_REQ;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG(WUEPS_PID_MMA, pstMsg);
if ( VOS_OK != ulRet )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndImsaStartReq:ERROR:PS_SEND_MSG FAILURE!");
}
return;
}
/******************************************************************************
Function: PPP_STUB_TraceDlData
Description: 将下行数据发送给GTR
Calls:
Data Accessed:
Data Updated:
Input:
Output:
Return:
Others:
******************************************************************************/
VOS_VOID PPP_STUB_TraceDlData(PPP_ZC_STRU *pstImmZc)
{
PPP_STUB_ZC_DATA_MSG_STRU *pstDlStubMsg;
VOS_UINT32 ulLength;
ulLength = sizeof(PPP_STUB_ZC_DATA_MSG_STRU) - VOS_MSG_HEAD_LENGTH;
pstDlStubMsg = (PPP_STUB_ZC_DATA_MSG_STRU *) PS_ALLOC_MSG( PS_PID_APP_PPP, ulLength);
if ( VOS_NULL_PTR == pstDlStubMsg )
{
return;
}
pstDlStubMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstDlStubMsg->ulReceiverPid = WUEPS_PID_AT;
pstDlStubMsg->ulSenderPid = PS_PID_APP_PPP;
pstDlStubMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstDlStubMsg->ulLength = ulLength;
pstDlStubMsg->ulMsgType = PPP_AT_DL_DATA_IND;
pstDlStubMsg->u.stDlDataInd.usDataLen = PPP_ZC_GET_DATA_LEN(pstImmZc);
PPP_MemSingleCopy(&(pstDlStubMsg->u.stDlDataInd.aucData[0]), PPP_ZC_GET_DATA_PTR(pstImmZc),
pstDlStubMsg->u.stDlDataInd.usDataLen);
PS_SEND_MSG(PS_PID_APP_PPP, pstDlStubMsg);
#ifdef WTTF_PS_FUSION_PC_ST
PPP_MemFree(pstImmZc);
#endif
return;
}
VOS_VOID TAF_MMA_SndSpmServiceStatusChangeNotify(VOS_VOID)
{
VOS_UINT32 ulRet;
MMA_TAF_SERVICE_STATUS_CHANGE_NOTIFY_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_TAF_SERVICE_STATUS_CHANGE_NOTIFY_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_TAF_SERVICE_STATUS_CHANGE_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndSpmServiceStatusChangeNotify:ERROR: Memory Alloc Error for pstMsg");
return;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_TAF_SERVICE_STATUS_CHANGE_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH);
pstMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->ulReceiverPid = WUEPS_PID_TAF;
pstMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->ulSenderPid = WUEPS_PID_MMA;
pstMsg->ulLength = sizeof(MMA_TAF_SERVICE_STATUS_CHANGE_NOTIFY_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->ulMsgName = ID_MMA_TAF_SERVICE_STATUS_CHANGE_NOTIFY;
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
TAF_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndSpmServiceStatusChangeNotify:ERROR:PS_SEND_MSG FAILURE");
return;
}
return;
}
