/*****************************************************************************
Function Name : NAS_LMM_FSM_PopState
Discription : 将CCB状态栈中栈顶的状态弹出堆栈，填入当前状态。在流程模块调用
RRC_FSM_EndProcess时由MAIN模块自动完成，该接口不对外提供。
Input : 状态机栈地址
Output : None
Return : None
History:
1. hanlufeng 41410 Draft Enact
*****************************************************************************/
VOS_VOID NAS_LMM_FSM_PopState( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId )
{
NAS_LMM_FSM_STATE_STACK_STRU *pstFsmStack; /* 状态机栈地址 */
NAS_LMM_FSM_STATE_STRU *pstCurFsm; /* 状态机地址 */
NAS_LMM_FSM_STATE_STRU *pstFsmStackTop; /* 指向栈顶状态 */
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PopState, FsmId error, FsmId", enParalFsmId);
return;
}
/* 获取EMM状态机当前状态的地址和状态机栈的地址 */
pstCurFsm = NAS_LMM_GetCurFsmAddr(enParalFsmId);
pstFsmStack = NAS_LMM_GetFsmStackAddr(enParalFsmId);
/* 栈越界 */
if ( (pstFsmStack->ucStackDepth) > NAS_LMM_MAX_STACK_DEPTH )
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PopState, The stack depth overflow, ucStackDepth",
(pstFsmStack->ucStackDepth));
return;
}
/* 栈已空 */
if ( 0 == (pstFsmStack->ucStackDepth) )
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_FSM_PopState, The stack is empty!");
return;
}
/* 获取栈顶第一个有效状态的位置，即栈顶的下一个位置 */
pstFsmStack->ucStackDepth--;
/* 获取栈顶第一个有效状态 */
pstFsmStackTop = &((pstFsmStack->astFsmStack)[pstFsmStack->ucStackDepth]);
/* 设置当前状态机 */
pstCurFsm->enFsmId = pstFsmStackTop->enFsmId;
pstCurFsm->enMainState = pstFsmStackTop->enMainState;
pstCurFsm->enSubState = pstFsmStackTop->enSubState;
pstCurFsm->enStaTId = pstFsmStackTop->enStaTId;
return;
}
/*****************************************************************************
Function Name : NAS_LMM_FSM_PushState
Discription : 当前状态机压栈，不修改状态。即入栈后，当前状态仍保持入栈前
的状态，状态修改的工作由执行入栈操作的模块显式执行。
Input : 状态机栈地址
Output : None
Return : None
History:
1. hanlufeng 41410 Draft Enact
*****************************************************************************/
VOS_VOID NAS_LMM_FSM_PushState( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId)
{
NAS_LMM_FSM_STATE_STACK_STRU *pstFsmStack; /* 状态机栈地址 */
NAS_LMM_FSM_STATE_STRU *pstCurFsm; /* 状态机地址 */
NAS_LMM_FSM_STATE_STRU *pstFsmStackTop; /* 指向栈顶状态 */
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_EMM_FSM_PushState, The input is illegal! enParalFsmId",
enParalFsmId);
return;
}
/* 获取EMM状态机当前状态的地址和状态机栈的地址 */
pstCurFsm = NAS_LMM_GetCurFsmAddr(NAS_LMM_PARALLEL_FSM_EMM);
pstFsmStack = NAS_LMM_GetFsmStackAddr(NAS_LMM_PARALLEL_FSM_EMM);
/* 状态机栈是否已满 */
if ( pstFsmStack->ucStackDepth >= NAS_LMM_MAX_STACK_DEPTH )
{
NAS_LMM_PUBM_LOG1_ERR("NAS_EMM_FSM_PushState, The stack depth overflow!, ucStackDepth",
pstFsmStack->ucStackDepth);
/* 栈满应该有些出错处理 */
return;
}
/* 获取状态栈栈顶地址 */
pstFsmStackTop = &((pstFsmStack->astFsmStack)[pstFsmStack->ucStackDepth]);
/* 入栈 */
pstFsmStackTop->enFsmId = pstCurFsm->enFsmId;
pstFsmStackTop->enMainState = pstCurFsm->enMainState;
pstFsmStackTop->enSubState = pstCurFsm->enSubState;
pstFsmStackTop->enStaTId = pstCurFsm->enStaTId;
/* 栈深度加 1 */
pstFsmStack->ucStackDepth++;
return;
}
/*****************************************************************************
Function Name : NAS_LMM_FSM_PopStackCombine()
Discription : 出栈综合操作，包括3个操作:
状态出栈，
定时器出栈，
全局变量出栈，
目前只有启动MRRC的RRC连接建立和释放两个过程涉及此操作,
后续鉴权过程会涉及到;
Input : 并行状态机ID, UE1.0中固定填NAS_LMM_PARALLEL_FSM_EMM
Output : None
Return : None
History:
1. hanlufeng 41410 Draft Enact
*****************************************************************************/
VOS_VOID NAS_LMM_FSM_PopStackCombine(
NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId)
{
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("RRC_FSM_BeginProcess, FsmId error, FsmId",
enParalFsmId);
return;
}
/***************出栈前环境打印操作***************/
#if 0
/* 打印出栈前的状态 */
NAS_LMM_PrintFsmState(enParalFsmId);
/* 打印当前状态涉及到的定时器状态 */
NAS_LMM_PrintFsmTimer(enParalFsmId);
#endif
/* 打印当前状态涉及到的全局变量的值 */
/***************出栈操作***************/
/* 状态机出栈操作 */
NAS_LMM_FSM_PopState(enParalFsmId);
/* 定时器状态出栈*/
NAS_LMM_FSM_PopTimer(enParalFsmId);
/* 相关全局变量出栈*/
NAS_LMM_FSM_PopGlobPar();
/***************出栈后环境打印操作***************/
NAS_LMM_PUBM_LOG_NORM("======================================================================================");
NAS_LMM_PUBM_LOG_NORM("======NAS_EMM Pop State To:======");
/* 打印当前状态 */
NAS_LMM_PrintFsmState(enParalFsmId);
NAS_LMM_PUBM_LOG_NORM("======================================================================================");
/* 打印当前状态涉及到的定时器状态 */
/* NAS_LMM_PrintFsmTimer(enParalFsmId);
*/
/* 打印当前状态涉及到的全局变量的值 */
return;
}
VOS_UINT32 NAS_LMM_BufMsgInQue(
NAS_LMM_FSM_MSG_BUF_STRU* pstFsmAddr,
VOS_UINT32 ulPriLevel)
{
VOS_UINT32 ulRslt = NAS_LMM_FAIL;
VOS_UINT8 *pucCnt = NAS_LMM_NULL_PTR;
/* 入参检查出错 */
/* 打印错误信息 */
if ( (ulPriLevel < NAS_LMM_STORE_HIGH_PRIO_MSG ) ||
(ulPriLevel > NAS_LMM_STORE_LOW_PRIO_MSG ))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_BufMsgInQue, error: ... ",ulPriLevel);
return NAS_LMM_FAIL;
}
if(NAS_LMM_NULL_PTR == pstFsmAddr)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_BufMsgInQue, error: NAS_LMM_NULL_PTR == pstFsmAddr ");
return NAS_LMM_FAIL;
}
/* 依据优先级更新Queue的信息 */
if( NAS_LMM_STORE_HIGH_PRIO_MSG == ulPriLevel )
{
pucCnt = &(pstFsmAddr->ucHighPrioCnt);
}
else if( NAS_LMM_STORE_LOW_PRIO_MSG == ulPriLevel )
{
pucCnt = &(pstFsmAddr->ucLowPrioCnt);
}
else
{
NAS_LMM_PUBM_LOG_NORM("NAS_LMM_BufMsgInQue: OTHER PRIO QUE ");
}
/* 更新Count的值 */
if( NAS_LMM_NULL_PTR != pucCnt )
{
*pucCnt += 1;
if( *pucCnt <= NAS_EMM_BUF_MSG_MAX_NUM )
{
ulRslt = NAS_LMM_SUCC;
}
else
{
NAS_LMM_PUBM_LOG_NORM("NAS_LMM_BufMsgInQue: QUE is overflow ");;
}
}
return( ulRslt );
}
VOS_VOID NAS_LMM_FSM_ClearState( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId )
{
NAS_LMM_FSM_STATE_STACK_STRU *pstFsmStack; /* 状态机栈地址 */
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PopState, FsmId error, FsmId", enParalFsmId);
return;
}
/* 获取EMM状态机当前状态的地址和状态机栈的地址 */
pstFsmStack = NAS_LMM_GetFsmStackAddr(enParalFsmId);
/* 栈越界 */
if ( (pstFsmStack->ucStackDepth) > NAS_LMM_MAX_STACK_DEPTH )
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PopState, The stack depth overflow, ucStackDepth",
(pstFsmStack->ucStackDepth));
return;
}
/* 栈已空 */
if ( 0 == (pstFsmStack->ucStackDepth) )
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_FSM_PopState, The stack is empty!");
return;
}
/*清除栈内存储的状态机*/
pstFsmStack->ucStackDepth = 0;
NAS_LMM_MEM_SET(pstFsmStack,0,sizeof(NAS_LMM_FSM_STATE_STACK_STRU));
return;
}
NAS_LMM_FSM_MSG_BUF_STRU* NAS_LMM_GetFsmBufAddr( NAS_LMM_PARALLEL_FSM_ENUM_UINT16
enParalFsmId )
{
if(enParalFsmId >= NAS_LMM_PARALLEL_FSM_BUTT)
{
NAS_LMM_PUBM_LOG1_ERR( "NAS_LMM_GetFsmBufAddr: Error enParalFsmId:",enParalFsmId);
return(NAS_LMM_NULL_PTR);
}
else
{
return(NAS_LMM_GetFsmBufQueueAddr(enParalFsmId));
}
}
VOS_VOID NAS_LMM_FSM_ClearStackCombine( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId)
{
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("RRC_FSM_BeginProcess, FsmId error, FsmId",
enParalFsmId);
return;
}
/***************出栈前环境打印操作***************/
/* 打印出栈前的状态 */
NAS_LMM_PrintFsmState(enParalFsmId);
/* 打印当前状态涉及到的定时器状态 */
NAS_LMM_PrintFsmTimer(enParalFsmId);
/* 打印当前状态涉及到的全局变量的值 */
/***************出栈操作***************/
/* 状态机出栈操作 */
NAS_LMM_FSM_ClearState(enParalFsmId);
/* 定时器状态出栈*/
NAS_LMM_FSM_ClearTimer(enParalFsmId);
/* 相关全局变量出栈*/
NAS_LMM_FSM_ClearGlobPar();
/***************出栈后环境打印操作***************/
/* 打印当前状态 */
NAS_LMM_PrintFsmState(enParalFsmId);
/* 打印当前状态涉及到的定时器状态 */
NAS_LMM_PrintFsmTimer(enParalFsmId);
/* 打印当前状态涉及到的全局变量的值 */
return;
}
NAS_LMM_BUFF_MSG_STRU * NAS_LMM_GetStoreBufMsgAddr(
NAS_LMM_FSM_MSG_BUF_STRU* pstFsmAddr,
VOS_UINT32 ulPriLevel)
{
NAS_LMM_BUFF_MSG_STRU *pstMsgBuffAddr = NAS_LMM_NULL_PTR;
VOS_UINT8 ucCnt;
/* 入参检查出错 */
/* 打印错误信息 */
if ( (ulPriLevel < NAS_LMM_STORE_HIGH_PRIO_MSG ) ||
(ulPriLevel > NAS_LMM_STORE_LOW_PRIO_MSG ))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_GetStoreBufMsgAddr, error: ... ",ulPriLevel);
return NAS_LMM_NULL_PTR;
}
if(NAS_LMM_NULL_PTR == pstFsmAddr)
{
NAS_LMM_PUBM_LOG_ERR("NAS_GetStoreBufMsgAddr, error: NAS_LMM_NULL_PTR == pstFsmAddr ");
return NAS_LMM_NULL_PTR;
}
/* 依据优先级获得缓存Buffer的地址*/
if( NAS_LMM_STORE_HIGH_PRIO_MSG == ulPriLevel )
{
ucCnt = pstFsmAddr->ucHighPrioCnt;
if(ucCnt < NAS_EMM_BUF_MSG_MAX_NUM)
{
pstMsgBuffAddr = (pstFsmAddr->astHighPrioBufQue+ucCnt);
}
}
else if( NAS_LMM_STORE_LOW_PRIO_MSG == ulPriLevel )
{
ucCnt = pstFsmAddr->ucLowPrioCnt;
if(ucCnt < NAS_EMM_BUF_MSG_MAX_NUM)
{
pstMsgBuffAddr = (pstFsmAddr->astLowPrioBufQue+ucCnt);
}
}
else
{
NAS_LMM_PUBM_LOG_NORM("NAS_GetStoreBufMsgAddr: OTHER QUE ADDR");
}
return( pstMsgBuffAddr );
}
VOS_UINT32 NAS_LMM_ProcessHardUsimCnf( PS_USIM_GET_FILE_CNF_STRU* pstUsimFileCnf)
{
PS_USIM_GET_FILE_CNF_STRU *pstUsimCnf = NAS_LMM_NULL_PTR;
VOS_UINT32 ulRslt = NAS_LMM_MSG_HANDLED;
NAS_NVIM_CTRL_TBL stNvCtrlTbl;
VOS_UINT32 i;
NAS_LMM_NV_ACTION_FUN pActFun = NAS_LMM_NULL_PTR;
pstUsimCnf = pstUsimFileCnf;
/*Initalize NVIM ctrl tbl*/
stNvCtrlTbl.pNvData = pstUsimCnf->aucEf;
stNvCtrlTbl.usNvDataLen = pstUsimCnf->usEfLen;
NAS_LMM_PUBM_LOG2_INFO("NAS_LMM_ProcessHardUsimCnf:pstUsimCnf->usEfId=,pstUsimCnf->ucEfLen",
pstUsimCnf->usEfId,
pstUsimCnf->usEfLen);
/* 在g_astNvDataMap中查找对应的NV TYPE*/
for(i = 0; i < g_ulNvDataMapNum; i++)
{
/* 若NV类型相同,则找到了,返回当前的NV动作函数，退出循环 */
if(pstUsimCnf->usEfId == g_astNvDataMap[i].usUsimFileId)
{
pActFun = g_astNvDataMap[i].pfDecodeActionFun;
break;
}
}
if (NAS_LMM_NULL_PTR != pActFun)
{
ulRslt = (*pActFun) (&stNvCtrlTbl);
return ulRslt;
}
else
{
/* 如果找不到处理函数，表示当前没有该处理函数 */
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_NvimRead: no fun deal with UsimFileId = ",
pstUsimCnf->usEfId);
return NAS_LMM_NVIM_FAIL;
}
}
VOS_VOID NAS_LMM_FSM_PushTimer( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId)
{
NAS_LMM_FSM_STATE_STRU *pstCurFsm; /* 状态机地址 */
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID( enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR( "NAS_LMM_FSM_PushTimer, The input is illegal! enParalFsmId",
enParalFsmId);
return;
}
pstCurFsm = NAS_LMM_GetCurFsmAddr(NAS_LMM_PARALLEL_FSM_EMM);
/* 停当前状态运行的状态保护定时器*/
NAS_LMM_StopStateTimer( pstCurFsm->enStaTId);
return;
}
VOS_VOID NAS_LMM_FSM_PopTimer( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId)
{
NAS_LMM_FSM_STATE_STRU *pstCurFsm; /* 状态机地址 */
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID( enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR( "NAS_LMM_FSM_PushTimer, The input is illegal! enParalFsmId",
enParalFsmId);
return;
}
pstCurFsm = NAS_LMM_GetCurFsmAddr(NAS_LMM_PARALLEL_FSM_EMM);
/* 继续当前状态运行的状态保护定时器，即
g_stMmMainContext.stNasEmmFsm.astCurFsm.enStaTId*/
NAS_LMM_StartStateTimer( pstCurFsm->enStaTId);
return;
}
/*lint -e961*/
VOS_VOID NAS_LMM_FSM_PushStackCombine(NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId)
{
/* 入口检查 */
if ( enParalFsmId >= NAS_LMM_PARALLEL_FSM_BUTT )
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PushStackCombine, FsmId error, FsmId",
enParalFsmId);
return;
}
/***************入栈前环境打印操作***************/
#if 0
/* 打印入栈前的状态 */
NAS_LMM_PrintFsmState(enParalFsmId);
/* 打印当前状态涉及到的定时器状态 */
NAS_LMM_PrintFsmTimer(enParalFsmId);
/* 打印当前状态涉及到的全局变量的值 */
#endif
/***************入栈操作***************/
/* 状态机压栈操作 */
NAS_LMM_FSM_PushState(enParalFsmId);
/* 定时器状态入栈 */
NAS_LMM_FSM_PushTimer(enParalFsmId);
/* 相关全局变量入栈 */
NAS_LMM_FSM_PushGlobPar(enParalFsmId);
return;
}
VOS_UINT32 NAS_EMM_MsgPreProcess( NAS_EMM_EVENT_TYPE_ENUM_UINT32 ulEt,
MsgBlock *pMsg )
{
VOS_UINT32 ulRet;
LRRC_LMM_DATA_IND_STRU *pstTmpRcvMsg = NAS_EMM_NULL_PTR;
VOS_UINT8 *pRcvMsg = NAS_EMM_NULL_PTR;
VOS_UINT8 ucPD = NAS_EMM_NULL;
VOS_UINT8 ucAirMsg = NAS_EMM_NULL;
VOS_UINT8 ucKeyEvent = NAS_EMM_NULL;
NAS_LMM_FSM_STATE_STRU *pstFsmCtx = NAS_LMM_NULL_PTR;
ulRet = NAS_LMM_MSG_DISCARD;
/*结构化消息，取出消息体*/
pstTmpRcvMsg = (LRRC_LMM_DATA_IND_STRU*)pMsg;
pRcvMsg = pstTmpRcvMsg->stNasMsg.aucNasMsg;
if(ID_LRRC_LMM_DATA_IND == pstTmpRcvMsg->enMsgId)
{
/*取出PD*/
ucPD = pRcvMsg[NAS_EMM_NULL]& EMM_CN_MSG_PDMASK;
/* 如果是ESM消息直接上报ESM */
if (EMM_CN_MSG_PD_ESM == ucPD)
{
/* 转发给ESM消息 */
NAS_EMM_EsmSendDataInd((NAS_EMM_CN_MSGCON_STRU *)&(pstTmpRcvMsg->stNasMsg));
return NAS_LMM_MSG_HANDLED;
}
/* 如果是TC消息直接上报TC */
if (EMM_CN_MSG_PD_TC == ucPD)
{
/* 转发给TC消息 */
NAS_EMM_TcSendDataInd((NAS_EMM_CN_MSGCON_STRU *)&(pstTmpRcvMsg->stNasMsg));
return NAS_LMM_MSG_HANDLED;
}
/*空口消息上报*/
if(EMM_CN_MSG_PD_EMM == ucPD)
{
NAS_LMM_FindAirMsgId(pRcvMsg[NAS_LMM_CN_MSG_MT_POS], &ucAirMsg, &ucKeyEvent);
NAS_LMM_SendOmtAirMsg(NAS_EMM_OMT_AIR_MSG_DOWN,
ucAirMsg,
(NAS_MSG_STRU*)&(pstTmpRcvMsg->stNasMsg));
if (NAS_EMM_NULL != ucKeyEvent)
{
NAS_LMM_SendOmtKeyEvent(ucKeyEvent);
}
NAS_LMM_MEM_SET(&g_stCnDecodeMsgStru, 0, sizeof(NAS_EMM_CN_MSG_STRU));
ulRet = NAS_EMM_DecodeCnMsg(pMsg, &g_stCnDecodeMsgStru);
if(NAS_EMM_FAIL == ulRet )
{/* 若解码出错,打印报警 */
NAS_LMM_PUBM_LOG1_ERR("NAS_EMM_MsgProcessInFsm, ulEventType = ", ulEt);
/*发送EMM STATUS, 接收到不识别的消息 */
NAS_EMM_SendMsgEmmStatus( NAS_LMM_CAUSE_MSG_NONEXIST_NOTIMPLEMENTE );
return NAS_LMM_MSG_HANDLED;
}
/* 对EMM INFO 和 EMM STATUS 进行处理 */
ulRet = NAS_EMM_PreProcMsgDataInd();
return ulRet;
}
ulRet = NAS_LMM_MSG_DISCARD;
}
/* SM异常消息的处理*/
if(ID_EMM_ESM_REL_REQ == pstTmpRcvMsg->enMsgId)
{
/* 获取状态机地址,用于取状态 */
pstFsmCtx = NAS_LMM_GetCurFsmAddr(NAS_LMM_PARALLEL_FSM_EMM);
switch(pstFsmCtx->enMainState)
{
case EMM_MS_REG:
case EMM_MS_REG_INIT:
case EMM_MS_TAU_INIT:
case EMM_MS_SER_INIT:
NAS_EMM_SmRabmAbnarmalProc();
break;
default:
NAS_LMM_PUBM_LOG1_INFO("current MS discard abnormal MSG=========>>>>",
pstTmpRcvMsg->enMsgId);
break;
}
ulRet = NAS_LMM_MSG_HANDLED;
}
return ulRet;
}
VOS_VOID NAS_LMM_PrintFsmTimer(NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParallelFsmId)
{
NAS_LMM_FSM_STATE_STRU *pstCurFsm; /* 状态机地址 */
NAS_LMM_TIMER_CTRL_STRU *pstTimerSta; /* 状态定时器 */
NAS_LMM_TIMER_CTRL_STRU *pstTimerPtl; /* 协议定时器 */
VOS_UINT16 usPtlTid;
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParallelFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PushTimer, The input is illegal! enParalFsmId",
enParallelFsmId);
return;
}
pstCurFsm = NAS_LMM_GetCurFsmAddr(NAS_LMM_PARALLEL_FSM_EMM);
pstTimerSta = NAS_LMM_GetMmTimerStaCtrlAddrByIdx(pstCurFsm->enStaTId);
/*判断当前状态定时器状态为停止和挂起*/
if(VOS_NULL_PTR == pstTimerSta->psthTimer)
{
/*状态定时器处于挂起状态*/
if((NAS_LMM_TIMER_SS_SUSPENDING == pstTimerSta->ucTimerSs)
&& (NAS_LMM_TIMER_RS_RUNNING == pstTimerSta->ucTimerRs))
{
NAS_LMM_PUBM_LOG1_WARN("NAS_LMM_PrintFsmTimer: State Timer is suspended! enStaTId:",
pstCurFsm->enStaTId);
}
/*状态定时器处于停止状态*/
else
{
NAS_LMM_PUBM_LOG1_WARN("NAS_LMM_PrintFsmTimer: State Timer is stoped! enStaTId:",
pstCurFsm->enStaTId);
}
}
/*状态定时器处于运行状态*/
/*协议定时器*/
for(usPtlTid = TI_NAS_LMM_PTL_TI_PUB_BOUNDARY_START+1; usPtlTid < NAS_LMM_PTL_TI_BUTT; usPtlTid++)
{
pstTimerPtl = NAS_LMM_GetMmTimerPtlCtrlAddrByIdx(usPtlTid);
/*协议定时器处于运行状态*/
if(VOS_NULL_PTR != pstTimerPtl->psthTimer)
{
NAS_LMM_PUBM_LOG1_NORM("NAS_LMM_PrintFsmTimer: Ptl Timer is running! PtlTid:",
usPtlTid);
}
/*协议定时器处于停止状态*/
else
{
NAS_LMM_PUBM_LOG1_NORM("NAS_LMM_PrintFsmTimer: Ptl Timer is stoped! PtlTid:",
usPtlTid);
}
}
return;
}
VOS_UINT32 NAS_LMM_StoreMsgToQue(
NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId,
VOS_UINT32 ulBufPriLevel,
VOS_UINT32 ulMsgType,
const VOS_VOID *pMsg )
{
VOS_UINT32 ulLength;
VOS_UINT8 *pucMsgBuff = NAS_LMM_NULL_PTR;
NAS_LMM_BUFF_MSG_STRU *pstBuffer = NAS_LMM_NULL_PTR;
NAS_LMM_FSM_MSG_BUF_STRU *pstFsmMsgBuffAddr = NAS_LMM_NULL_PTR;
VOS_UINT32 ulRslt;
/* 入口检查 ，为了避免内存泄漏，当前只支持EMM,如果需要支持MMC，可以修改以下条件即可,
** 并且在对应的模块需要添加相应的处理;另外对于中优先级的缓存，也不支持;*/
if ( enParalFsmId != NAS_LMM_PARALLEL_FSM_EMM )
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_StoreMsgToQue, FsmId error, FsmId:", enParalFsmId);
return NAS_LMM_ERR_CODE_ARRAY_OVERFLOW;
}
if ( NAS_LMM_NULL_PTR == pMsg )
{
NAS_LMM_PUBM_LOG_WARN("NAS_LMM_StoreMsgToQue, Msg is NULL!");
return NAS_LMM_ERR_CODE_PTR_NULL;
}
if( (NAS_LMM_STORE_HIGH_PRIO_MSG != ulBufPriLevel) &&
(NAS_LMM_STORE_LOW_PRIO_MSG != ulBufPriLevel))
{
NAS_LMM_PUBM_LOG1_WARN("NAS_LMM_StoreMsgToQue, Prio err!",ulBufPriLevel);
return NAS_LMM_ERR_CODE_PARA_INVALID;
}
/* 获取缓存Buffer的地址 */
pstFsmMsgBuffAddr = NAS_LMM_GetFsmBufAddr( enParalFsmId );
if(NAS_LMM_NULL_PTR == pstFsmMsgBuffAddr)
{
NAS_LMM_PUBM_LOG_WARN( "NAS_LMM_StoreMsgToQue, Get pstFsmMsgBuffAddr Fail!");
return NAS_LMM_ERR_CODE_PTR_NULL;
}
/*如果消息存在，移去该消息 */
NAS_LMM_RemoveMsgFromFsmQue( pstFsmMsgBuffAddr, ulMsgType, ulBufPriLevel );
pstBuffer = NAS_LMM_GetStoreBufMsgAddr( pstFsmMsgBuffAddr, ulBufPriLevel );
if(NAS_LMM_NULL_PTR == pstBuffer)
{
NAS_LMM_PUBM_LOG_WARN( "NAS_LMM_StoreMsgToQue, GetStoreBufMsgAddr Fail!");
return NAS_LMM_ERR_CODE_PTR_NULL;
}
/* 获取消息长度 */
ulLength = ((NAS_LMM_MSG_HEADER_STRU *)pMsg)->ulLength
+ NAS_EMM_PUB_VOS_MSG_HEADER_LEN;
/* 动态分配缓存空间 */
pucMsgBuff = NAS_COMM_AllocBuffItem(NAS_COMM_BUFF_TYPE_EMM, ulLength);
if(NAS_LMM_NULL_PTR == pucMsgBuff )
{
NAS_LMM_PUBM_LOG_WARN( "NAS_LMM_StoreMsgToQue, Msg Allocate Fail!");
return NAS_LMM_ERR_CODE_PTR_NULL;
}
/* 把需要缓存的消息拷贝到申请到的地址中 */
NAS_LMM_MEM_CPY( pucMsgBuff, pMsg, ulLength );
/* 消息入队 */
pstBuffer->pBuffMsg = (VOS_VOID*)(pucMsgBuff);
pstBuffer->ulEvtType = ulMsgType;
ulRslt = NAS_LMM_BufMsgInQue( pstFsmMsgBuffAddr,ulBufPriLevel );
if( NAS_LMM_FAIL == ulRslt)
{
NAS_LMM_PUBM_LOG_WARN( "NAS_LMM_StoreMsgToQue, In Queue Fail!");
ulRslt = NAS_COMM_FreeBuffItem(NAS_COMM_BUFF_TYPE_EMM, pucMsgBuff);
if (NAS_COMM_BUFF_SUCCESS != ulRslt)
{
NAS_LMM_PUBM_LOG_WARN("NAS_LMM_StoreMsgToQue, Memory Free is not succ");
}
pstBuffer->pBuffMsg = NAS_LMM_NULL_PTR;
pstBuffer->ulEvtType = 0;
return NAS_LMM_ERR_CODE_PTR_NULL;
}
return NAS_LMM_SUCC;
}
