VOS_VOID BST_FidTask ( VOS_UINT32 Para1, VOS_UINT32 Para2,
VOS_UINT32 Para3, VOS_UINT32 Para4 )
{
MsgBlock *pMsg = VOS_NULL_PTR;
VOS_UINT32 ulEvent = 0;
VOS_UINT32 ulTaskID = 0;
VOS_UINT32 ulEventMask = 0;
VOS_UINT32 ulExpectEvent = 0;
ulTaskID = VOS_GetCurrentTaskID();
if ( PS_NULL_UINT32 == ulTaskID )
{
BST_RLS_LOG ( "BST_FidTask: This Task Id is Error" );
return;
}
if ( VOS_OK != VOS_CreateEvent(ulTaskID) )
{
BST_RLS_LOG ( "BST_FidTask:, Create Event Fail");
return;
}
ulExpectEvent = VOS_MSG_SYNC_EVENT|BST_CDS_EVENT_RCV_DL_PROC;
ulEventMask = (VOS_EVENT_ANY | VOS_EVENT_WAIT);
g_ulBastetTaskId = VOS_GetCurrentTaskID();
g_ulBstTaskReadyFlag = BST_TRUE;
for (;;)
{
if ( VOS_OK != VOS_EventRead(ulExpectEvent,ulEventMask,0,&ulEvent) )
{
BST_RLS_LOG ( "BST_FidTask: BASTET Read Event Error" );
continue;
}
/*事件处理*/
if (VOS_MSG_SYNC_EVENT != ulEvent)
{
BST_SYS_EvtProcEntry(ulEvent);
continue;
}
pMsg = (MsgBlock *)VOS_GetMsg(ulTaskID);
if ( VOS_NULL_PTR != pMsg )
{
switch ( TTF_GET_MSG_RECV_PID( pMsg ) )
{
case UEPS_PID_BASTET:
BST_SYS_MsgProcEntry( pMsg );
break;
default:
BST_RLS_LOG1 ( "BST_FidTask: Recv Unkown Message %d\r\n", TTF_GET_MSG_NAME(pMsg) );
break;
}
PS_FREE_MSG ( UEPS_PID_BASTET, pMsg );
}
}
}
VOS_VOID TAF_CALL_ProcSupsCmdReq(SPM_IMSA_CALL_SUPS_CMD_REQ_STRU *pstSupsCmdReq)
{
MN_APP_CALL_SUPS_REQ_STRU *pstDstMsg = VOS_NULL_PTR;
/* 申请消息内存 */
pstDstMsg = (MN_APP_CALL_SUPS_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(MN_APP_CALL_SUPS_REQ_STRU));
if (VOS_NULL_PTR == pstDstMsg)
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_CALL_ProcSupsCmdReq: ERROR:Memory Alloc is fail!");
return;
}
PS_MEM_SET(pstDstMsg, 0, sizeof(MN_APP_CALL_SUPS_REQ_STRU));
/* 首先转换消息类型到call可处理的内部消息 */
TAF_CALL_ConvertSupsCmdReqMsg(pstSupsCmdReq, pstDstMsg);
/* 调用call模块SupsCmdReq消息处理函数 */
MN_CALL_CallSupsCmdReqProc((struct MsgCB *)pstDstMsg);
/* 释放分配的内存空间 */
PS_FREE_MSG(WUEPS_PID_TAF, pstDstMsg);
}
VOS_VOID AT_MNTN_TraceRPTPORT(VOS_VOID)
{
AT_MNTN_RPTPORT_STRU *pstSndMsgCB;
VOS_UINT8 ucLoop;
pstSndMsgCB = (AT_MNTN_RPTPORT_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(AT_MNTN_RPTPORT_STRU));
if ( VOS_NULL_PTR == pstSndMsgCB )
{
AT_ERR_LOG("AT_MNTN_TraceRPTPORT:ERROR: Alloc Memory Fail.");
return;
}
pstSndMsgCB->ulReceiverPid = WUEPS_PID_AT;
pstSndMsgCB->ulSenderPid = WUEPS_PID_AT;
pstSndMsgCB->ulSenderCpuId = VOS_LOCAL_CPUID;
pstSndMsgCB->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSndMsgCB->ulLength = sizeof(AT_MNTN_RPTPORT_STRU) - 20;
pstSndMsgCB->enMsgId = ID_AT_MNTN_RESULT_RPT_PORT;
for (ucLoop = 0; ucLoop < AT_MAX_CLIENT_NUM; ucLoop++)
{
pstSndMsgCB->astAtRptPort[ucLoop].enAtClientTabIndex = (AT_CLIENT_TAB_INDEX_UINT8)ucLoop;
pstSndMsgCB->astAtRptPort[ucLoop].enModemId = g_astAtClientCtx[ucLoop].stClientConfiguration.enModemId;
pstSndMsgCB->astAtRptPort[ucLoop].ucReportFlg = g_astAtClientCtx[ucLoop].stClientConfiguration.ucReportFlg;
}
AT_MNTN_TraceEvent(pstSndMsgCB);
PS_FREE_MSG(WUEPS_PID_AT, pstSndMsgCB);
return;
}
VOS_VOID TAF_CALL_ProcOrigReq(SPM_IMSA_CALL_ORIG_REQ_STRU *pstOrigReq)
{
MN_CALL_APP_REQ_MSG_STRU *pstDstMsg = VOS_NULL_PTR;
/* 申请消息内存 */
pstDstMsg = (MN_CALL_APP_REQ_MSG_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(MN_CALL_APP_REQ_MSG_STRU));
if (VOS_NULL_PTR == pstDstMsg)
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_CALL_ProcOrigReq: ERROR:Memory Alloc is fail!");
return;
}
PS_MEM_SET(pstDstMsg, 0, sizeof(MN_CALL_APP_REQ_MSG_STRU));
/* 首先转换消息类型到call可处理的内部消息 */
TAF_CALL_ConvertOrigReqMsg(pstOrigReq, pstDstMsg);
/* 调用call模块Orig Req消息处理函数 */
MN_CALL_CallOrigReqProc(pstDstMsg->clientId,
pstDstMsg->opId,
pstDstMsg->callId,
(MN_CALL_ORIG_PARAM_STRU*)&(pstDstMsg->unParm));
/* 释放分配的内存空间 */
PS_FREE_MSG(WUEPS_PID_TAF, pstDstMsg);
}
VOS_INT32 NAS_PsDomainTcDataReq(
VOS_UINT8 ucRbId,
VOS_UINT32 ulDataBitLen,
TTF_MEM_ST *pstDataMem
)
{
RABM_PDCP_TC_DATA_REQ_STRU *pMsg;
VOS_UINT32 ulRet;
if (WUE_RLC_MODE_BUTT == NAS_GetRbTxMode(RRC_NAS_PS_DOMAIN, (VOS_INT8)ucRbId))
{
return AS_RB_NO_EXIST;
}
pMsg = (RABM_PDCP_TC_DATA_REQ_STRU*)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_RABM,sizeof(RABM_PDCP_TC_DATA_REQ_STRU));
if( VOS_NULL_PTR == pMsg )
{
return AS_NO_MEMORY;
}
PS_MEM_SET((VOS_INT8*)pMsg + VOS_MSG_HEAD_LENGTH,0,
sizeof(RABM_PDCP_TC_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pMsg->ulSenderPid = WUEPS_PID_RABM;
pMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pMsg->ulReceiverPid = WUEPS_PID_PDCP;
pMsg->ulLength = sizeof(RABM_PDCP_TC_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pMsg->enMsgName = ID_RABM_PDCP_TC_DATA_REQ;
pMsg->ucRbId = ucRbId;
pMsg->pstDataMem = pstDataMem;
pMsg->ulDataBitLen = ulDataBitLen;
if (VOS_NULL_PTR == pMsg->pstDataMem)
{
/*释放消息结构体*/
PS_FREE_MSG(WUEPS_PID_RABM, pMsg);
return AS_NO_MEMORY;
}
ulRet = PS_SEND_MSG(WUEPS_PID_RABM, pMsg);
if ( VOS_OK != ulRet )
{
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_PsDomainTcDataReq, Error, call PS_SEND_MSG fail\n");
}
return AS_SUCCESS;
}
VOS_VOID TAF_CALL_ProcStartDtmfReq(SPM_IMSA_CALL_START_DTMF_REQ_STRU *pstStartDtmfReq)
{
MN_CALL_APP_REQ_MSG_STRU *pstDstMsg = VOS_NULL_PTR;
TAF_CALL_DTMF_INFO_STRU stDtmfInfo;
TAF_CS_CAUSE_ENUM_UINT32 ulResult;
/* 申请消息内存 */
pstDstMsg = (MN_CALL_APP_REQ_MSG_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(MN_CALL_APP_REQ_MSG_STRU));
if (VOS_NULL_PTR == pstDstMsg)
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_CALL_ProcSupsCmdReq: ERROR:Memory Alloc is fail!");
return;
}
PS_MEM_SET(pstDstMsg, 0, sizeof(MN_CALL_APP_REQ_MSG_STRU));
/* 首先转换消息类型到call可处理的内部消息 */
TAF_CALL_ConvertStartDtmfReqMsg(pstStartDtmfReq, pstDstMsg);
/* 如果TCH还没有分配，直接就缓存 */
if (VOS_FALSE == MN_CALL_GetTchStatus())
{
PS_MEM_SET(&stDtmfInfo, 0, sizeof(TAF_CALL_DTMF_INFO_STRU));
stDtmfInfo.opId = pstDstMsg->opId;
stDtmfInfo.usClientId = pstDstMsg->clientId;
stDtmfInfo.CallId = pstDstMsg->unParm.stDtmf.CallId;
stDtmfInfo.cKey = pstDstMsg->unParm.stDtmf.cKey;
stDtmfInfo.usOffLength = pstDstMsg->unParm.stDtmf.usOffLength;
stDtmfInfo.usOnLength = pstDstMsg->unParm.stDtmf.usOnLength;
ulResult = TAF_CALL_SaveDtmfInfo(&stDtmfInfo);
TAF_CALL_SendDtmfCnf(stDtmfInfo.usClientId,
stDtmfInfo.opId,
MN_CALL_EVT_START_DTMF_CNF,
ulResult);
}
else
{
/* 调用call模块StartDtmfReq消息处理函数 */
TAF_CALL_RcvStartDtmfReq((struct MsgCB *)pstDstMsg);
}
/* 释放分配的内存空间 */
PS_FREE_MSG(WUEPS_PID_TAF, pstDstMsg);
}
VOS_VOID CDS_SendNdDataIndMsg(TTF_MEM_ST *pstNdPkt, VOS_UINT8 ucRabId, const CDS_ENTITY_STRU *pstCdsEntity)
{
CDS_NDCLIENT_ND_DATA_IND_STRU *pstDataInd;
VOS_UINT32 ulMsgLen;
VOS_UINT32 ulPktLen;
CDS_ASSERT(VOS_NULL_PTR != pstNdPkt);
CDS_ASSERT(VOS_NULL_PTR != pstCdsEntity);
CDS_INFO_LOG1(UEPS_PID_CDS,"Enter CDS_SendNdDataIndMsg.ucRabid=",ucRabId);
/*申请消息内存*/
ulPktLen = TTF_MemGetLen(UEPS_PID_CDS,pstNdPkt);
ulMsgLen = sizeof(CDS_NDCLIENT_ND_DATA_IND_STRU) + ulPktLen;
pstDataInd = CDS_ALLOC_MSG_WITH_HDR(ulMsgLen);
if (VOS_NULL_PTR == pstDataInd)
{
CDS_ERROR_LOG1(UEPS_PID_CDS,"CDS_SendNdDataIndMsg : Alloc Msg Fail. Size=",ulMsgLen);
return;
}
/*填写消息内容*/
CDS_CFG_MSG_HDR(pstDataInd,UEPS_PID_NDCLIENT);
pstDataInd->enMsgId = ID_CDS_NDCLIENT_ND_DATA_IND;
pstDataInd->enModemId = pstCdsEntity->usModemId;
pstDataInd->ucRabId = ucRabId;
pstDataInd->ulLen = ulPktLen;
/*内存拷贝*/
if (PS_SUCC != TTF_MemGetHeadData(UEPS_PID_CDS,
pstNdPkt,
pstDataInd->aucData,
(VOS_UINT16)ulPktLen))
{
/*lint -e961*/
PS_FREE_MSG(UEPS_PID_CDS, pstDataInd);
/*lint +e961*/
CDS_ERROR_LOG(UEPS_PID_CDS,"CDS_SendNdDataIndMsg : TTF_MemGetHeadData Error.");
return ;
}
/*发送消息*/
CDS_SEND_MSG(pstDataInd);
CDS_INFO_LOG(UEPS_PID_CDS,"Leave CDS_SendNdDataIndMsg Succ.");
return;
}
VOS_VOID AT_MNTN_TraceClientData(VOS_VOID)
{
NAS_AT_SDT_AT_CLIENT_TABLE_STRU *pstSndMsgCB;
TAF_UINT8 ucLoop;
pstSndMsgCB = (NAS_AT_SDT_AT_CLIENT_TABLE_STRU *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(NAS_AT_SDT_AT_CLIENT_TABLE_STRU));
if ( VOS_NULL_PTR == pstSndMsgCB )
{
AT_ERR_LOG("AT_MNTN_TraceClientData:ERROR: Alloc Memory Fail.");
return;
}
pstSndMsgCB->ulReceiverPid = WUEPS_PID_AT;
pstSndMsgCB->ulSenderPid = WUEPS_PID_AT;
pstSndMsgCB->ulSenderCpuId = VOS_LOCAL_CPUID;
pstSndMsgCB->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSndMsgCB->ulLength = sizeof(NAS_AT_SDT_AT_CLIENT_TABLE_STRU) - 20;
pstSndMsgCB->enMsgID = ID_AT_MNTN_PC_REPLAY_CLIENT_TAB;
pstSndMsgCB->ucType = AT_PC_REPLAY_MSG_CLIENT_TAB;
pstSndMsgCB->aucReserved[0] = 0;
pstSndMsgCB->aucReserved[1] = 0;
pstSndMsgCB->aucReserved[2] = 0;
for (ucLoop = 0; ucLoop < AT_MAX_CLIENT_NUM; ucLoop++)
{
pstSndMsgCB->gastAtClientTab[ucLoop].usClientId = gastAtClientTab[ucLoop].usClientId;
pstSndMsgCB->gastAtClientTab[ucLoop].opId = gastAtClientTab[ucLoop].opId;
pstSndMsgCB->gastAtClientTab[ucLoop].ucUsed = gastAtClientTab[ucLoop].ucUsed;
pstSndMsgCB->gastAtClientTab[ucLoop].UserType = gastAtClientTab[ucLoop].UserType;
pstSndMsgCB->gastAtClientTab[ucLoop].Mode = gastAtClientTab[ucLoop].Mode;
pstSndMsgCB->gastAtClientTab[ucLoop].IndMode = gastAtClientTab[ucLoop].IndMode;
}
AT_MNTN_TraceEvent(pstSndMsgCB);
PS_FREE_MSG(WUEPS_PID_AT, pstSndMsgCB);
return;
}
VOS_VOID AT_MNTN_TraceCmdBuffer(
VOS_UINT8 ucIndex,
VOS_UINT8 *pucData,
VOS_UINT16 usDataLen
)
{
AT_MSG_STRU *pstMsg;
AT_INTER_MSG_ID_ENUM_UINT32 enEventId;
VOS_UINT32 ulLength;
AT_GetAtMsgStruMsgLength(usDataLen, &ulLength);
/* 申请消息内存 */
pstMsg = (AT_MSG_STRU *)PS_MEM_ALLOC(WUEPS_PID_AT, (ulLength + VOS_MSG_HEAD_LENGTH));
if (VOS_NULL_PTR == pstMsg)
{
AT_ERR_LOG("AT_MNTN_TraceCmdBuffer:ERROR:Alloc Mem Fail.");
return;
}
/* 填写消息头 */
enEventId = AT_GetResultMsgID(ucIndex);
AT_MNTN_CFG_MSG_HDR(pstMsg, enEventId, ulLength);
/* 填写消息内容 */
pstMsg->ucType = 0x2;
pstMsg->ucIndex = ucIndex;
pstMsg->usLen = usDataLen;
AT_GetUserTypeFromIndex(ucIndex, &pstMsg->ucUserType);
PS_MEM_SET(pstMsg->aucReserved, 0x00, sizeof(pstMsg->aucReserved));
PS_MEM_CPY((TAF_VOID*)pstMsg->aucValue, pucData, usDataLen);
/* 填写消息内容 */
AT_MNTN_TraceEvent(pstMsg);
/* 释放消息内存 */
PS_FREE_MSG(WUEPS_PID_AT, pstMsg);
return;
}
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_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_INT32 NAS_CsDomainDataReq(
VOS_INT8 cRbId,
VOS_UINT32 ulDataLength,
VOS_UINT8 *pucData
)
{
RABM_RLC_TM_DATA_REQ_STRU *pTmMsg;
RABM_RLC_UM_DATA_REQ_STRU *pUmMsg;
RABM_RLC_AM_DATA_REQ_STRU *pAmMsg;
VOS_UINT32 ulLenOct;
VOS_UINT8 ucRbMode;
VOS_VOID *pMsg;
TTF_MEM_ST *pData;
ucRbMode = NAS_GetRbTxMode(RRC_NAS_CS_DOMAIN, cRbId);
switch(ucRbMode)
{
case WUE_RLC_TM_MODE:
pTmMsg = (RABM_RLC_TM_DATA_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_RABM,sizeof(RABM_RLC_TM_DATA_REQ_STRU));
if( VOS_NULL == pTmMsg )
{
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, call PS_ALLOC_MSG_WITH_HEADER_LEN fail\n");
return AS_NO_MEMORY;
}
PS_MEM_SET((VOS_INT8*)pTmMsg + VOS_MSG_HEAD_LENGTH,0,
sizeof(RABM_RLC_TM_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pTmMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pTmMsg->ulSenderPid = WUEPS_PID_RABM;
pTmMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pTmMsg->ulReceiverPid = WUEPS_PID_RLC;
pTmMsg->ulLength = sizeof(RABM_RLC_TM_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pTmMsg->enMsgName = ID_RABM_RLC_TM_DATA_REQ;
pTmMsg->ucRbId = (VOS_UINT8)cRbId;
pTmMsg->usDataBitLen = (VOS_UINT16)ulDataLength;
ulLenOct = (ulDataLength + 7)/ 8;
pData = TTF_MemBlkCopyAlloc(WUEPS_PID_RABM, TTF_MEM_POOL_ID_UL_RLC_SDU, pucData, (VOS_UINT16)ulLenOct);
if ( VOS_NULL_PTR == pData )
{
/*释放消息内存:*/
PS_FREE_MSG(WUEPS_PID_RABM, pTmMsg);
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, call TTF_MemCopyAlloc fail\n");
return AS_NO_MEMORY;
}
pTmMsg->pstDataMem = pData;
pMsg = (VOS_VOID *)pTmMsg;
break;
case WUE_RLC_UM_MODE:
if(0 != (ulDataLength % 8))
{
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, 配置的RLC UL SDU长度不是整字节\n");
return AS_DATA_LENGTH_ERR;
}
pUmMsg = (RABM_RLC_UM_DATA_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_RABM,sizeof(RABM_RLC_UM_DATA_REQ_STRU));
if( VOS_NULL == pUmMsg )
{
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, call PS_ALLOC_MSG_WITH_HEADER_LEN fail\n");
return AS_NO_MEMORY;
}
PS_MEM_SET((VOS_INT8*)pUmMsg + VOS_MSG_HEAD_LENGTH,0,
sizeof(RABM_RLC_UM_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pUmMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pUmMsg->ulSenderPid = WUEPS_PID_RABM;
pUmMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pUmMsg->ulReceiverPid = WUEPS_PID_RLC;
pUmMsg->ulLength = sizeof(RABM_RLC_UM_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pUmMsg->enMsgName = ID_RABM_RLC_UM_DATA_REQ;
pUmMsg->ucRbId = (VOS_UINT8)cRbId;
/* 此成员为TD新加的, GU这边没用这个成员, 所以可以不使用TD的宏 */
pUmMsg->usDataBitLen = (VOS_UINT16)ulDataLength;
ulLenOct = ulDataLength / 8;
pData = TTF_MemBlkCopyAlloc(WUEPS_PID_RABM, TTF_MEM_POOL_ID_UL_RLC_SDU, pucData, (VOS_UINT16)ulLenOct);
if ( VOS_NULL_PTR == pData )
{
/*释放消息内存:*/
PS_FREE_MSG(WUEPS_PID_RABM, pUmMsg);
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, call TTF_MemCopyAlloc fail\n");
return AS_NO_MEMORY;
}
pUmMsg->pstDataMem = pData;
pMsg = (VOS_VOID *)pUmMsg;
break;
case WUE_RLC_AM_MODE:
ulLenOct = (ulDataLength + 7) / 8;
pAmMsg = (RABM_RLC_AM_DATA_REQ_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_RABM,sizeof(RABM_RLC_AM_DATA_REQ_STRU));
if( VOS_NULL == pAmMsg )
{
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, call PS_ALLOC_MSG_WITH_HEADER_LEN fail\n");
return AS_NO_MEMORY;
}
PS_MEM_SET((VOS_INT8*)pAmMsg + VOS_MSG_HEAD_LENGTH,0,
sizeof(RABM_RLC_AM_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
pAmMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pAmMsg->ulSenderPid = WUEPS_PID_RABM;
pAmMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pAmMsg->ulReceiverPid = WUEPS_PID_RLC;
pAmMsg->ulLength = sizeof(RABM_RLC_AM_DATA_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pAmMsg->enMsgName = ID_RABM_RLC_AM_DATA_REQ;
pAmMsg->ucRbId = (VOS_UINT8)cRbId;
/* 此成员为TD新加的, GU这边没用这个成员, 所以可以不使用TD的宏 */
pAmMsg->usDataBitLen = (VOS_UINT16)ulDataLength;
pData = TTF_MemBlkCopyAlloc(WUEPS_PID_RABM, TTF_MEM_POOL_ID_UL_RLC_SDU, pucData, (VOS_UINT16)ulLenOct);
if ( VOS_NULL_PTR == pData )
{
/*释放消息内存:*/
PS_FREE_MSG(WUEPS_PID_RABM, pAmMsg);
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_ERROR,
"NAS_CsDomainDataReq, Error, call TTF_MemCopyAlloc fail\n");
return AS_NO_MEMORY;
}
pAmMsg->pstDataMem = pData;
pMsg = (VOS_VOID *)pAmMsg;
break;
case WUE_RLC_MODE_BUTT:
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_WARNING,
"NAS_CsDomainDataReq, Error, No Rlc Rb exist\n");
return AS_RB_NO_EXIST;
default:
PS_LOG(WUEPS_PID_RABM, 0, PS_PRINT_WARNING,
"NAS_CsDomainDataReq, Error, Rb Tx Mode error!\n");
return AS_RB_NO_EXIST;
}
if ( VOS_OK != NAS_UTRANCTRL_SndAsMsg(WUEPS_PID_RABM, (struct MsgCB **)&pMsg) )
{
/*发送消息失败，释放申请的零拷贝内存*/
TTF_MemFree(WUEPS_PID_RABM, pData);
return AS_SEND_FAILED;
}
return AS_SUCCESS;
}
VOS_VOID ADS_DL_FidTask(
VOS_UINT32 ulQueueID,
VOS_UINT32 FID_value,
VOS_UINT32 Para1,
VOS_UINT32 Para2
)
{
MsgBlock *pMsg = VOS_NULL_PTR;
VOS_UINT32 ulEvent = 0;
VOS_UINT32 ulTaskID = 0;
VOS_UINT32 ulRtn = PS_FAIL;
VOS_UINT32 ulEventMask = 0;
VOS_UINT32 ulExpectEvent = 0;
ulTaskID = VOS_GetCurrentTaskID();
if (PS_NULL_UINT32 == ulTaskID)
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_FidTask: ERROR, TaskID is invalid.");
return;
}
if (VOS_OK != VOS_CreateEvent(ulTaskID))
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_FidTask: ERROR, create event fail.");
return;
}
g_ulAdsDLTaskId = ulTaskID;
g_ulAdsDLTaskReadyFlag = 1;
ulExpectEvent = ADS_DL_EVENT_IPF_RD_INT | ADS_DL_EVENT_IPF_ADQ_EMPTY_INT | VOS_MSG_SYNC_EVENT;
ulEventMask = (VOS_EVENT_ANY | VOS_EVENT_WAIT);
/*lint -e716*/
while (1)
/*lint +e716*/
{
ulRtn = VOS_EventRead(ulExpectEvent, ulEventMask, 0, &ulEvent);
if (VOS_OK != ulRtn)
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_FidTask: ERROR, read event error.");
continue;
}
/* 统计所有事件 */
ADS_DBG_DL_PROC_ALL_EVENT_NUM(1);
/*RD事件处理*/
if (VOS_MSG_SYNC_EVENT != ulEvent)
{
ADS_DL_ProcEvent(ulEvent);
#ifdef __PC_UT__
break;
#endif
continue;
}
pMsg = (MsgBlock*)VOS_GetMsg(ulTaskID);
if (VOS_NULL_PTR != pMsg)
{
if (ACPU_PID_ADS_DL == pMsg->ulReceiverPid)
{
ADS_DL_ProcMsg(pMsg);
}
PS_FREE_MSG(ACPU_PID_ADS_DL, pMsg);
}
else
{
/* 统计空事件 */
ADS_DBG_DL_PROC_EMPTY_EVENT_NUM(1);
}
}
}
VOS_VOID ADS_UL_FidTask(
VOS_UINT32 ulQueueID,
VOS_UINT32 FID_value,
VOS_UINT32 Para1,
VOS_UINT32 Para2
)
{
MsgBlock *pMsg = VOS_NULL_PTR;
VOS_UINT32 ulEvent = 0;
VOS_UINT32 ulTaskID = 0;
VOS_UINT32 ulRtn = VOS_ERR;
VOS_UINT32 ulEventMask = 0;
VOS_UINT32 ulExpectEvent = 0;
ulTaskID = VOS_GetCurrentTaskID();
if (PS_NULL_UINT32 == ulTaskID)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_FidTask: ERROR, TaskID is invalid.");
return;
}
if (VOS_OK != VOS_CreateEvent(ulTaskID))
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_FidTask: ERROR, create event fail.");
return;
}
g_ulAdsULTaskId = ulTaskID;
g_ulAdsULTaskReadyFlag = 1;
ulExpectEvent = ADS_UL_EVENT_DATA_PROC | VOS_MSG_SYNC_EVENT;
ulEventMask = (VOS_EVENT_ANY | VOS_EVENT_WAIT);
/*lint -e716*/
while (1)
/*lint +e716*/
{
ulRtn = VOS_EventRead(ulExpectEvent, ulEventMask, 0, &ulEvent);
if (VOS_OK != ulRtn)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_FidTask: ERROR, read event error.");
continue;
}
/*事件处理*/
if (VOS_MSG_SYNC_EVENT != ulEvent)
{
ADS_UL_ProcEvent(ulEvent);
continue;
}
pMsg = (MsgBlock*)VOS_GetMsg(ulTaskID);
if (VOS_NULL_PTR != pMsg)
{
if (ACPU_PID_ADS_UL == pMsg->ulReceiverPid)
{
ADS_UL_ProcMsg(pMsg);
}
PS_FREE_MSG(ACPU_PID_ADS_UL, pMsg);
}
}
}
VOS_VOID AT_MNTN_TraceContextData(VOS_VOID)
{
NAS_AT_SDT_AT_PART_ST *pstSndMsgCB = VOS_NULL_PTR;
NAS_AT_OUTSIDE_RUNNING_CONTEXT_PART_ST *pstOutsideCtx = VOS_NULL_PTR;
AT_MODEM_SMS_CTX_STRU *pstSmsCtx = VOS_NULL_PTR;
MODEM_ID_ENUM_UINT16 enModemId;
pstSndMsgCB = (NAS_AT_SDT_AT_PART_ST *)PS_ALLOC_MSG(WUEPS_PID_AT,
sizeof(NAS_AT_SDT_AT_PART_ST));
if (VOS_NULL_PTR == pstSndMsgCB)
{
AT_ERR_LOG("AT_MNTN_TraceContextData:ERROR: Alloc Memory Fail.");
return;
}
pstSndMsgCB->ulReceiverPid = WUEPS_PID_AT;
pstSndMsgCB->ulSenderPid = WUEPS_PID_AT;
pstSndMsgCB->ulSenderCpuId = VOS_LOCAL_CPUID;
pstSndMsgCB->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstSndMsgCB->ulLength = sizeof(NAS_AT_OUTSIDE_RUNNING_CONTEXT_PART_ST) + 4;
pstSndMsgCB->ucType = AT_PC_REPLAY_MSG;
pstSndMsgCB->enMsgID = ID_AT_MNTN_PC_REPLAY_MSG;
pstSndMsgCB->aucReserved[0] = 0;
pstSndMsgCB->aucReserved[1] = 0;
pstSndMsgCB->aucReserved[2] = 0;
for (enModemId = 0; enModemId < MODEM_ID_BUTT; enModemId++)
{
pstSmsCtx = AT_GetModemSmsCtxAddrFromModemId(enModemId);
pstOutsideCtx = &pstSndMsgCB->astOutsideCtx[enModemId];
pstOutsideCtx->gucAtCscsType = gucAtCscsType;
pstOutsideCtx->gucAtCsdhType = pstSmsCtx->ucCsdhType;
pstOutsideCtx->g_OpId = g_OpId;
pstOutsideCtx->g_enAtCsmsMsgVersion = pstSmsCtx->enCsmsMsgVersion;
pstOutsideCtx->g_enAtCmgfMsgFormat = pstSmsCtx->enCmgfMsgFormat;
PS_MEM_CPY(&pstOutsideCtx->gstAtCnmiType,
&(pstSmsCtx->stCnmiType),
sizeof(pstSmsCtx->stCnmiType));
PS_MEM_CPY(&pstOutsideCtx->g_stAtCgsmsSendDomain,
&(pstSmsCtx->stCgsmsSendDomain),
sizeof(pstSmsCtx->stCgsmsSendDomain));
PS_MEM_CPY(&pstOutsideCtx->g_stAtCscaCsmpInfo,
&(pstSmsCtx->stCscaCsmpInfo),
sizeof(pstSmsCtx->stCscaCsmpInfo));
PS_MEM_CPY(&pstOutsideCtx->g_stAtCpmsInfo,
&(pstSmsCtx->stCpmsInfo),
sizeof(pstSmsCtx->stCpmsInfo));
}
AT_MNTN_TraceEvent(pstSndMsgCB);
PS_FREE_MSG(WUEPS_PID_AT, pstSndMsgCB);
return;
}
VOS_VOID CNAS_XCC_SndApsSoCtrlMsgInd(
CNAS_XCC_CALL_INFO_CTX_STRU *pstCallInfo,
CNAS_XCC_SOCM_STRU *pstSOCM
)
{
XCC_APS_SO_CTRL_MSG_IND_STRU *pstMsg = VOS_NULL_PTR;
pstMsg = (XCC_APS_SO_CTRL_MSG_IND_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(UEPS_PID_XCC,
sizeof(XCC_APS_SO_CTRL_MSG_IND_STRU));
if (VOS_NULL_PTR == pstMsg)
{
return;
}
NAS_MEM_SET_S((VOS_UINT8*)pstMsg + VOS_MSG_HEAD_LENGTH,
sizeof(XCC_APS_SO_CTRL_MSG_IND_STRU) - VOS_MSG_HEAD_LENGTH,
0,
sizeof(XCC_APS_SO_CTRL_MSG_IND_STRU) - VOS_MSG_HEAD_LENGTH);
/* 填充消息 */
pstMsg->ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->ulSenderPid = UEPS_PID_XCC;
pstMsg->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->ulReceiverPid = CNAS_CCB_ConvertPidBasedOnModemId(CNAS_CCB_GetCdmaModeModemId(), WUEPS_PID_TAF);
pstMsg->ulLength = sizeof(XCC_APS_SO_CTRL_MSG_IND_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->enMsgId = ID_XCC_APS_SO_CTRL_MSG_IND;
pstMsg->usOpId = 0;
pstMsg->enSo = (TAF_CDMA_SO_TYPE_ENUM_UINT16)pstSOCM->usSo;
pstMsg->ucConnectId = pstCallInfo->ucConnectId;
/* 1. Dormant Timer Control
Field Length(bits)
DORM_CNTL 3
RESERVED 2
FIELD_TYPE 3
DORM_TIME 0 or 8
2. Packet Zone Reconnection Control
Field Length(bits)
PKT_CON_CNTL 3
RESERVED 2
FIELD_TYPE 3
RESERVED 0 or 4
PKT_ZONE_LIST_LEN 0 or 4 */
pstMsg->enFieldType = pstSOCM->aucData[0] & CNAS_XCC_LOW_3_BIT_MASK;
switch(pstMsg->enFieldType)
{
case XCC_APS_SO_CTRL_FIELD_DORMANT_TIMER_CTRL:
/* Dormant Timer Control */
pstMsg->ucDormCntl = (VOS_UINT8)(pstSOCM->aucData[0] >> CNAS_XCC_5_BIT_OFFSET);
if (pstSOCM->usBitLen >= CNAS_XCC_BIT_LEN_16_BIT)
{
pstMsg->ucDormTimer = pstSOCM->aucData[1];
}
break;
case XCC_APS_SO_CTRL_FIELD_PACKET_ZONE_RECONN_CTRL:
/* Packet Zone Reconnection Control */
pstMsg->ucPktConCntl = (VOS_UINT8)(pstSOCM->aucData[0] >> CNAS_XCC_5_BIT_OFFSET);
if (pstSOCM->usBitLen >= CNAS_XCC_BIT_LEN_16_BIT)
{
pstMsg->ucPktZoneListLen = (VOS_UINT8)(pstSOCM->aucData[1] & CNAS_XCC_LOW_4_BIT_MASK);
}
break;
default:
CNAS_WARNING_LOG(UEPS_PID_XCC, "CNAS_XCC_SndApsSoCtrlMsgInd: Wrong Field Type ");
PS_FREE_MSG(UEPS_PID_XCC, pstMsg);
return;
}
CNAS_MNTN_LogMsgInfo((MSG_HEADER_STRU*)pstMsg);
/* Send Message */
(VOS_VOID)PS_SEND_MSG(UEPS_PID_XCC, pstMsg);
}
