C++ PS_MEM_CPY函数代码示例

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