コード例 #1
0
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
}
コード例 #2
0
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;
}
コード例 #3
0
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;

}
コード例 #4
0
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;
}
コード例 #5
0
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;
}
コード例 #6
0
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
}
コード例 #7
0
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;
}
コード例 #8
0
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");
    }    
}
コード例 #9
0
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;
}
コード例 #10
0
ファイル: VcApi.c プロジェクト: herryfan/kernel-huawei-h60
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;
}
コード例 #11
0
ファイル: ATSndMsg.c プロジェクト: rgmabs19357/Huawei-
/*****************************************************************************
 函 数 名  : 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);
}
コード例 #12
0
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;
}
コード例 #13
0
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;
}
コード例 #14
0
ファイル: VcApi.c プロジェクト: herryfan/kernel-huawei-h60
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;
}
コード例 #15
0
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;
}
コード例 #16
0
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;
}
コード例 #17
0
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

}
コード例 #18
0
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);
}
コード例 #19
0
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;
}
コード例 #20
0
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");
    }
}
コード例 #21
0
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!");
}
コード例 #22
0
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;
}
コード例 #23
0
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;
}
コード例 #24
0
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;
}
コード例 #25
0
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;
}
コード例 #26
0
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;
}
コード例 #27
0
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);

}
コード例 #28
0
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;
}
コード例 #29
0
/******************************************************************************
 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;
}
コード例 #30
0
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;
}