VOS_VOID NAS_LMM_CheckNvDrxParamAndTransVal(
CONST NAS_MM_DRX_STRU *pstNvimDrxParam,
NAS_MM_DRX_STRU *pstTransDrxParam)
{
/*检查入参指针*/
if ((VOS_NULL_PTR == pstNvimDrxParam)
||(VOS_NULL_PTR == pstTransDrxParam))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_CheckNvDrxParamAndTransVal: Input NULL PTR.");
return;
}
/*SPLIT on CCCH有效性验证,无效赋值 0*/
if (NAS_EMM_PARA_INVALID == NAS_LMM_IsDrxSplitOnCcchValid(pstNvimDrxParam->ucSplitOnCcch))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_CheckNvDrxParamAndTransVal: SplitOnCcch InValid.");
pstTransDrxParam->ucSplitOnCcch = NAS_LMM_SPLIT_ON_CCCH_NOT_SUPPORT;
}
else
{
pstTransDrxParam->ucSplitOnCcch = pstNvimDrxParam->ucSplitOnCcch;
}
/*non_DRX Timer有效性验证，无效则赋值 0*/
if (NAS_EMM_PARA_INVALID == NAS_LMM_IsDrxNonDrxTimerValid(pstNvimDrxParam->ucNonDrxTimer))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_CheckNvDrxParamAndTransVal: NonDrxTimer InValid.");
pstTransDrxParam->ucNonDrxTimer = NAS_LMM_NO_NONE_DRX_MODE;
}
else
{
pstTransDrxParam->ucNonDrxTimer = pstNvimDrxParam->ucNonDrxTimer;
}
/*SPLIT PG CYCLE CODE有效则直接赋值，无效则按照协议转换*/
if (NAS_EMM_PARA_INVALID == NAS_LMM_IsDrxPgCycleCodeValid(pstNvimDrxParam->ucSplitPgCode))
{
pstTransDrxParam->ucSplitPgCode = NAS_LMM_SPLIT_PG_CYCLE_CODE_ONE;
}
else
{
pstTransDrxParam->ucSplitPgCode = pstNvimDrxParam->ucSplitPgCode;
}
/*DRX Valude for S1 Mode有效则直接赋值，无效则按照协议转换*/
if (NAS_EMM_PARA_INVALID == NAS_LMM_IsUeDrxCycleValid(pstNvimDrxParam->ucPsDrxLen))
{
pstTransDrxParam->ucPsDrxLen = NAS_LMM_UE_NOT_SPEC_DRX_VALUE;
}
else
{
pstTransDrxParam->ucPsDrxLen = pstNvimDrxParam->ucPsDrxLen;
}
return;
}
VOS_VOID NAS_LMM_GetMccMncFromPlmn
(
const NAS_MM_PLMN_ID_STRU *pstPlmnId,
VOS_UINT32 *pulMCC,
VOS_UINT32 *pulMNC
)
{
VOS_UINT8 ucMccDigit1 = NAS_LMM_NULL;
VOS_UINT8 ucMccDigit2 = NAS_LMM_NULL;
VOS_UINT8 ucMccDigit3 = NAS_LMM_NULL;
VOS_UINT8 ucMncDigit1 = NAS_LMM_NULL;
VOS_UINT8 ucMncDigit2 = NAS_LMM_NULL;
VOS_UINT8 ucMncDigit3 = NAS_LMM_NULL;
if ( (VOS_NULL_PTR == pulMCC)
||(VOS_NULL_PTR == pulMNC)
||(VOS_NULL_PTR == pstPlmnId))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_GetMccMncFromPlmn: ERR--input NULL !!");
return;
}
/* PLMN未定义，则返回0 */
if (VOS_TRUE == NAS_LMM_PlmnIsUndef(pstPlmnId))
{
*pulMCC = 0;
*pulMNC = 0;
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_GetMccMncFromPlmn: PLMN is not defined.");
return;
}
/* 获取MCC每一位 */
NAS_LMM_GetMccFromPlmn(pstPlmnId,&ucMccDigit1,&ucMccDigit2,&ucMccDigit3);
/* 获取MNC每一位 */
NAS_LMM_GetMncFromPlmn(pstPlmnId,&ucMncDigit1,&ucMncDigit2,&ucMncDigit3);
*pulMCC = (100*ucMccDigit1) + (10*ucMccDigit2) + ucMccDigit3;
/* MNC3:F,只取MNC1,MNC2*/
if ( NAS_LMM_HEX_DIGIT_F == ucMncDigit3 )
{
*pulMNC = (10*ucMncDigit1) + ucMncDigit2;
}
else
{
*pulMNC = (100*ucMncDigit1) + (10*ucMncDigit2) + ucMncDigit3;
}
return;
}
VOS_VOID NAS_LMM_DeletePlmnFromPlmnList
(
const NAS_MM_PLMN_ID_STRU *pstPlmnId,
NAS_MM_PLMN_LIST_STRU *pstPlmnList,
VOS_UINT32 ulListNumMax
)
{
VOS_UINT32 i;
VOS_UINT32 ulFound;
/* 传入指针非空检查 */
if ( (VOS_NULL_PTR == pstPlmnId)
||(VOS_NULL_PTR == pstPlmnList))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_DeletePlmnFromPlmnList: ERR--input NULL !!");
return;
}
if (pstPlmnList->ulPlmnNum > ulListNumMax)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_DeletePlmnFromPlmnList:List num or ulListNumMax is err!!");
return;
}
/* 被删除的PLMN在列表中才删除 */
ulFound = VOS_FALSE;
for (i=0; i<pstPlmnList->ulPlmnNum; i++)
{
if (VOS_FALSE == ulFound)
{
if (NAS_LMM_MATCH_SUCCESS == NAS_LMM_PlmnMatch( pstPlmnId, &pstPlmnList->astPlmnId[i]))
{
ulFound = VOS_TRUE;
}
}
if ( (VOS_TRUE == ulFound) && (i < (ulListNumMax-1)) )
{
NAS_LMM_PlmnCpy(&(pstPlmnList->astPlmnId[i]),
&(pstPlmnList->astPlmnId[i+1]));
}
}
/* 被删除的PLMN在当前列表中,列表个数减少一个 */
if (VOS_TRUE == ulFound)
{
pstPlmnList->ulPlmnNum--;
}
return;
}
VOS_VOID NAS_LMM_GetMncFromPlmn
(
const NAS_MM_PLMN_ID_STRU *pstPlmnId,
VOS_UINT8 *pucMnc1,
VOS_UINT8 *pucMnc2,
VOS_UINT8 *pucMnc3
)
{
if ( (VOS_NULL_PTR == pucMnc1)
||(VOS_NULL_PTR == pucMnc2)
||(VOS_NULL_PTR == pucMnc3)
||(VOS_NULL_PTR == pstPlmnId))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_GetMncFromPlmn: ERR--input NULL !!");
return;
}
/* PLMN未定义，则返回F */
if (VOS_TRUE == NAS_LMM_PlmnIsUndef(pstPlmnId))
{
*pucMnc1 = NAS_LMM_HEX_DIGIT_F;
*pucMnc2 = NAS_LMM_HEX_DIGIT_F;
*pucMnc3 = NAS_LMM_HEX_DIGIT_F;
}
else
{
/* 取出每一位MNC */
*pucMnc1 = pstPlmnId->aucPlmnId[2] & NAS_LMM_HIGH_HALF_BYTE_MASK;
*pucMnc2 = (pstPlmnId->aucPlmnId[2] & NAS_LMM_LOW_HALF_BYTE_MASK)
>> NAS_LMM_RIGHT_SHIFT_HALF_BYTE;
*pucMnc3 = (pstPlmnId->aucPlmnId[1] & NAS_LMM_LOW_HALF_BYTE_MASK)
>> NAS_LMM_RIGHT_SHIFT_HALF_BYTE;
}
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 );
}
/*****************************************************************************
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;
}
VOS_VOID NAS_LMM_ClearTaList(NAS_MM_FORB_TA_LIST_STRU *pstTaList)
{
NAS_LMM_PUBM_LOG_INFO("NAS_LMM_ClearTaList: is entered !!");
/* 传入指针非空检查 */
if (VOS_NULL_PTR == pstTaList)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_ClearTaList: ERR--input NULL !!");
return;
}
NAS_LMM_MEM_SET(pstTaList,0,sizeof(NAS_MM_FORB_TA_LIST_STRU));
return;
}
VOS_VOID NAS_LMM_UndefTac
(
NAS_MM_TAC_STRU *pstTac
)
{
/* 传入指针非空检查 */
if (VOS_NULL_PTR == pstTac)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_UndefTac: ERR--input NULL !!");
return;
}
pstTac->ucTac = 0xff;
pstTac->ucTacCnt = 0xfe;
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_VOID NAS_LMM_PlmnCpy
(
NAS_MM_PLMN_ID_STRU *pstDestPlmn,
const NAS_MM_PLMN_ID_STRU *pstOrgPlmn
)
{
if ( (VOS_NULL_PTR == pstDestPlmn)
||(VOS_NULL_PTR == pstOrgPlmn))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_PlmnCpy: ERR--input NULL !!");
return;
}
pstDestPlmn->aucPlmnId[0] = pstOrgPlmn->aucPlmnId[0];
pstDestPlmn->aucPlmnId[1] = pstOrgPlmn->aucPlmnId[1];
pstDestPlmn->aucPlmnId[2] = pstOrgPlmn->aucPlmnId[2];
return;
}
VOS_VOID NAS_EMM_CompCnDetachReqMo( NAS_EMM_MRRC_DATA_REQ_STRU *pDetReqMoMsg)
{
VOS_UINT32 ulIndex;
VOS_UINT32 ulDataReqLenNoHeader;
NAS_EMM_MRRC_DATA_REQ_STRU *pTempDetReqMsg = pDetReqMoMsg;
if (NAS_EMM_NULL_PTR == pDetReqMoMsg)
{
/*打印错误*/
NAS_EMM_ATTACH_LOG_ERR("NAS_EMM_CompCnDetachReqMo: Mem Alloc Err!");
return;
}
ulIndex = 0;
/*计算DETACH REQ空口消息*/
NAS_EMM_CompCnDetachReqMoNasMsg(pTempDetReqMsg->stNasMsg.aucNasMsg, &ulIndex);
/*内部消息长度计算*/
ulDataReqLenNoHeader = NAS_EMM_CountMrrcDataReqLen(ulIndex);
if ( NAS_EMM_INTRA_MSG_MAX_SIZE < ulDataReqLenNoHeader )
{
/* 打印错误信息 */
NAS_LMM_PUBM_LOG_ERR("NAS_EMM_CompCnDetachReqMo, Size error");
return ;
}
/*填充消息长度*/
pTempDetReqMsg->stNasMsg.ulNasMsgSize = ulIndex;
/*填充消息头*/
NAS_EMM_COMP_AD_INTRA_MSG_HEADER(pTempDetReqMsg, ulDataReqLenNoHeader);
/*填充消息ID*/
pTempDetReqMsg->ulMsgId = ID_NAS_LMM_INTRA_MRRC_DATA_REQ;
pTempDetReqMsg->enDataCnf = LRRC_LMM_DATA_CNF_NEED;
/*填充消息内容*/
pTempDetReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_SIGNALLING;
pTempDetReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_SIGNALLING;
pTempDetReqMsg->enEmmMsgType = NAS_EMM_MSG_DETACH_REQ;
return;
}
VOS_VOID NAS_EMM_UpdateBearISRFlag(NAS_MML_PS_BEARER_CONTEXT_STRU *pstBearerCtx)
{
VOS_UINT32 i = NAS_EMM_NULL;
NAS_LMM_PUBM_LOG_INFO("NAS_EMM_UpdateBearISRFlag Enter.");
if (NAS_EMM_NULL_PTR == pstBearerCtx)
{
NAS_LMM_PUBM_LOG_ERR("NAS_EMM_UpdateBearISRFlag:Input para is invalid");
return;
}
for (i = 0; i < EMM_ESM_MAX_EPS_BEARER_NUM; i++)
{
pstBearerCtx[i].enPsBearerIsrFlg = NAS_MML_PS_BEARER_EXIST_BEFORE_ISR_ACT;
}
return;
}
VOS_VOID NAS_LMM_UndefPlmn
(
NAS_MM_PLMN_ID_STRU *pstPlmnId
)
{
/* 传入指针非空检查 */
if (VOS_NULL_PTR == pstPlmnId)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_UndefPlmn: ERR--input NULL !!");
return;
}
pstPlmnId->aucPlmnId[0] = 0xff;
pstPlmnId->aucPlmnId[1] = 0xff;
pstPlmnId->aucPlmnId[2] = 0xff;
return;
}
VOS_VOID NAS_LMM_SetArrayAllBytesFF( VOS_UINT8 *pucArray,
const VOS_UINT32 ulLen )
{
VOS_UINT32 i;
if ((VOS_NULL_PTR == pucArray) || (VOS_NULL == ulLen))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_CheckWhetherAnyByteIsFF: ERR--input NULL !!");
return ;
}
for (i = 0; i < ulLen; i++)
{
pucArray[i] = NAS_LMM_HEX_DIGIT_FF;
}
return;
}
VOS_VOID NAS_LMM_ClearPlmnList(NAS_MM_PLMN_LIST_STRU *pstPlmnList)
{
NAS_LMM_PUBM_LOG_INFO("NAS_LMM_ClearPlmnList: is entered !!");
/* 传入指针非空检查 */
if (VOS_NULL_PTR == pstPlmnList)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_ClearPlmnList: ERR--input NULL !!");
return;
}
pstPlmnList->ulPlmnNum = 0;
NAS_LMM_MEM_SET( pstPlmnList->astPlmnId,
0,
NAS_MM_MAX_PLMN_NUM * sizeof(NAS_MM_PLMN_ID_STRU));
return;
}
VOS_VOID NAS_LMM_AddPlmnInPlmnList
(
const NAS_MM_PLMN_ID_STRU *pstPlmnId,
NAS_MM_PLMN_LIST_STRU *pstPlmnList,
VOS_UINT32 ulListNumMax
)
{
VOS_UINT32 i;
/* 传入指针非空检查 */
if ( (VOS_NULL_PTR == pstPlmnId)
||(VOS_NULL_PTR == pstPlmnList))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_AddPlmnInPlmnList: ERR--input NULL !!");
return;
}
/* 被添加的PLMN不在列表中才添加 */
if (NAS_LMM_MATCH_FAIL == NAS_LMM_PlmnIDMatchPlmnList(pstPlmnId, pstPlmnList))
{
/* 列表未满，直接添加到最后 */
if (ulListNumMax > pstPlmnList->ulPlmnNum)
{
NAS_LMM_PlmnCpy(&pstPlmnList->astPlmnId[pstPlmnList->ulPlmnNum],
pstPlmnId);
pstPlmnList->ulPlmnNum++;
}
/* 列表满，将第一个FPLMN移出,被添加的PLMN加到最后 */
else
{
pstPlmnList->ulPlmnNum = ulListNumMax;
for (i=0; i<(ulListNumMax -1) ; i++)
{
NAS_LMM_PlmnCpy(&(pstPlmnList->astPlmnId[i]),
&(pstPlmnList->astPlmnId[i+1]));
}
NAS_LMM_PlmnCpy(&pstPlmnList->astPlmnId[i],pstPlmnId);
}
}
return;
}
VOS_VOID NAS_LMM_TaCpy
(
NAS_MM_TA_STRU *pstDestTa,
const NAS_MM_TA_STRU *pstOrgTa
)
{
if ( (VOS_NULL_PTR == pstDestTa)
||(VOS_NULL_PTR == pstOrgTa))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_TaCpy: ERR--input NULL !!");
return;
}
pstDestTa->stTac.ucTac = pstOrgTa->stTac.ucTac;
pstDestTa->stTac.ucTacCnt = pstOrgTa->stTac.ucTacCnt;
NAS_LMM_PlmnCpy(&(pstDestTa->stPlmnId), &(pstOrgTa->stPlmnId));
return;
}
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;
}
/*******************************************************************************
Module :
Function : NAS_EMM_SMS_CompMsgUpLinkNasTransportMrrcDataReqMsg
Input :pMsg :SMS透传过来的消息
Output :pMrrcDataReqMsg : 指向 LRRC_LNAS_MSG_STRU
NOTE :
Return :
History :
1. FTY 2011.11.15 新规作成
*******************************************************************************/
VOS_VOID NAS_EMM_SMS_CompMsgUpLinkNasTransportMrrcDataReqMsg
(NAS_EMM_MRRC_DATA_REQ_STRU *pMrrcDataReqMsg, const LMM_SMS_MSG_STRU * pSmsMsg)
{
VOS_UINT32 uldataReqMsgLenNoHeader = NAS_LMM_NULL;
VOS_UINT32 ulCnNasMsgLen = NAS_LMM_NULL;
NAS_LMM_PUBM_LOG_NORM("NAS_EMM_CompMsgUpLinkNasTransportMrrcDataReqMsg enter!");
/*构造MRRC_DATA_REQ 中的 NAS_MSG_STRU,即CN消息(Compose the msg of):UpLink NAS Transport*/
NAS_EMM_SMS_CompCnUplinkNasTransportMsg(pMrrcDataReqMsg->stNasMsg.aucNasMsg, &ulCnNasMsgLen, pSmsMsg);
pMrrcDataReqMsg->stNasMsg.ulNasMsgSize = ulCnNasMsgLen;
uldataReqMsgLenNoHeader = NAS_EMM_CountMrrcDataReqLen(ulCnNasMsgLen);
if ( NAS_EMM_INTRA_MSG_MAX_SIZE < uldataReqMsgLenNoHeader )
{
/* 打印错误信息 */
NAS_LMM_PUBM_LOG_ERR("NAS_EMM_SMS_CompMsgUpLinkNasTransportMrrcDataReqMsg, Size error ");
return ;
}
/* 填写MRRC_DATA_REQ 的DOPRA消息头 */
EMM_COMP_MM_MSG_HEADER(pMrrcDataReqMsg, uldataReqMsgLenNoHeader);
/* 填写MRRC_DATA_REQ 的消息ID标识 */
pMrrcDataReqMsg->ulMsgId = ID_NAS_LMM_INTRA_MRRC_DATA_REQ;
/*填充 NAS_EMM_NAS_UPLINK_NAS_TRANSPORT*/
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_DATA;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_CALL;
pMrrcDataReqMsg->enEmmMsgType = NAS_EMM_NAS_UPLINK_NAS_TRANSPORT;
pMrrcDataReqMsg->enDataCnf = LRRC_LMM_DATA_CNF_NOT_NEED;
pMrrcDataReqMsg->ulEsmMmOpId = NAS_LMM_OPID;
return;
}
VOS_UINT32 NAS_LMM_CheckWhetherAllBytesAreFF( const VOS_UINT8 *pucSimRecord,
const VOS_UINT32 ulIndex,
const VOS_UINT32 ulLen )
{
VOS_UINT32 i;
if ((VOS_NULL_PTR == pucSimRecord) || (VOS_NULL == ulLen))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_CheckWhetherAllBytesAreFF: ERR--input NULL !!");
return VOS_FALSE;
}
for (i = 0; i< ulLen; i++)
{
if ( NAS_LMM_HEX_DIGIT_FF != pucSimRecord[ulIndex + i])
{
/* 如果存在不为0xFF,返回失败 */
return VOS_FALSE;
}
}
return VOS_TRUE;
}
VOS_VOID NAS_LMM_PlmnListCpy
(
NAS_MM_PLMN_LIST_STRU *pstDestPlmnList,
const NAS_MM_PLMN_LIST_STRU *pstOrgPlmnList
)
{
VOS_UINT8 i;
if ( (VOS_NULL_PTR == pstDestPlmnList)
||(VOS_NULL_PTR == pstOrgPlmnList))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_PlmnListCpy: ERR--input NULL !!");
return;
}
pstDestPlmnList->ulPlmnNum = pstOrgPlmnList->ulPlmnNum;
for (i=0; i<pstOrgPlmnList->ulPlmnNum; i++)
{
NAS_LMM_PlmnCpy(&pstDestPlmnList->astPlmnId[i],
&pstOrgPlmnList->astPlmnId[i]);
}
return;
}
VOS_UINT32 NAS_LMM_CheckWhetherAnyByteIsFF( const VOS_UINT8 *pucSimRecord,
const VOS_UINT32 ulIndex,
const VOS_UINT32 ulLen)
{
VOS_UINT32 i;
if ((VOS_NULL_PTR == pucSimRecord) || (VOS_NULL == ulLen))
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_CheckWhetherAnyByteIsFF: ERR--input NULL !!");
return VOS_FALSE;
}
for (i = 0; i < ulLen; i++)
{
if ( NAS_LMM_HEX_DIGIT_FF == pucSimRecord[ulIndex + i])
{
return VOS_TRUE;
}
}
/*如果不存在0xff,返回VOS_FALSE*/
return VOS_FALSE;
}
VOS_UINT32 NAS_LMM_PreProcMmcDisableReq( MsgBlock *pMsg )
{
MMC_LMM_DISABLE_LTE_NOTIFY_STRU *pstMsg = NAS_LMM_NULL_PTR;
NAS_LMM_PUBM_LOG_INFO("NAS_LMM_PreProcMmcDisableReq Enter.");
/* 检查如果不是IDLE态，则直接丢弃*/
if (NAS_EMM_NO == NAS_LMM_IsRrcConnectStatusIdle())
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_PreProcMmcDisableReq:NOT IDLE.");
return NAS_LMM_MSG_HANDLED;
}
pstMsg = (MMC_LMM_DISABLE_LTE_NOTIFY_STRU *)(VOS_VOID *)pMsg;
/* 记录LTE接入技术为DISABLE态*/
NAS_EMM_SetLteEnableSta( NAS_LMM_LTE_DISABLED);
/* 清空T3412Exp标志*/
NAS_LMM_SetEmmInfoT3412ExpCtrl( NAS_EMM_T3412_EXP_NO);
/*NAS_LMM_SetEmmInfoUpdateMmFlag(NAS_EMM_UPDATE_MM_FLAG_INVALID);*/
/*清空DrxNetCapability标志*/
NAS_LMM_SetEmmInfoDrxNetCapChange(NAS_EMM_NO);
/*清空RRC删除原因标识*/
NAS_LMM_SetEmmInfoTriggerTauRrcRel(NAS_EMM_TRIGGER_TAU_RRC_REL_NO);
/* 清除GU发起过LAU或者联合RAU标识*/
NAS_LMM_SetEmmInfoLauOrComRauFlag(NAS_EMM_LAU_OR_COMBINED_RAU_NOT_HAPPENED);
NAS_LMM_SetEmmInfoSrvccFlag(NAS_EMM_SRVCC_NOT_HAPPENED);
/*清空 EPS 承载上下文变更标志*/
NAS_EMM_SetEpsContextStatusChange(NAS_EMM_EPS_BEARER_STATUS_NOCHANGE);
NAS_LMM_SetEmmInfoTriggerTauSysChange(NAS_EMM_NO);
/* 清除异系统变换触发和类型记录信息 */
NAS_EMM_ClearResumeInfo();
NAS_LMM_SetEmmInfoPsState(GMM_LMM_GPRS_NOT_SUSPENSION);
if( (MMC_LMM_DISABLE_LTE_REASON_LTE_VOICE_NOT_AVAILABLE == pstMsg->enDisableLteReason)
|| (MMC_LMM_DISABLE_LTE_REASON_EMERGENCY_CALL == pstMsg->enDisableLteReason)
|| (MMC_LMM_DISABLE_LTE_REASON_LTE_REJ_CAUSE_14 == pstMsg->enDisableLteReason))
{
/* 收到MMC的DISABLE LTE消息时，将CS域和PS服务状态设置成无服务，并上报给MMC */
NAS_LMM_SetNasMmcCSServiceState(MMC_LMM_SERVICE_STATUS_NO_SERVICE);
NAS_LMM_SetNasMmcServiceState(MMC_LMM_SERVICE_STATUS_NO_SERVICE);
NAS_EMM_SendMmcServiceStatInd(NAS_EMM_YES, NAS_EMM_YES);
/* 给MMC上报无服务之后，将CS域和PS域的服务状态设置成BUTT，以便再次ENABLE LTE
时肯定会再上报服务状态 */
NAS_LMM_SetNasMmcCSServiceState(MMC_LMM_SERVICE_STATUS_TYPE_BUTT);
NAS_LMM_SetNasMmcServiceState(MMC_LMM_SERVICE_STATUS_TYPE_BUTT);
}
NAS_EMM_ClrAllUlDataReqBufferMsg();
/*参考协议24301，5.5.3.3.4.2， 5.5.3.3.4.3，
5.5.1.3.4.2，当前设置位语音中心&IMS不可用， 如果
TAU 5次都是eps only成功，此时会disable LTE，此时
需要停止定时器3402，否则回到L的时候不会立即发起TAU
*/
/*NAS_LMM_StopPtlTimer(TI_NAS_EMM_PTL_T3402);*/
/* 美国AT&T定制需求: disable LTE清除CService计数 */
NAS_EMM_GetEmmInfoDamParaCserviceCnt() = 0;
/* 通知LRRC当前LTE被disable */
NAS_LMM_SendRrcDisableLteNotify();
return NAS_LMM_MSG_HANDLED;
}
VOS_VOID NAS_EMM_SendMsgEmmStatus( VOS_UINT8 ucRes )
{
NAS_EMM_MRRC_DATA_REQ_STRU *pIntraMsg;
VOS_UINT32 ulDataReqMsgLenNoHeader;
NAS_MSG_STRU *pstNasMsg;
VOS_UINT32 ulIndex =0;
NAS_EMM_ATTACH_LOG_INFO("Enter NAS_EMM_SendMsgEmmStatus,Status MSG LEN");
/*申请消息内存*/
pIntraMsg = (VOS_VOID *) NAS_LMM_MEM_ALLOC(NAS_EMM_INTRA_MSG_MAX_SIZE);
/*判断申请结果，若失败退出*/
if (NAS_EMM_NULL_PTR == pIntraMsg)
{
return;
}
/* xiongxianghui00253310 add memset 2013-11-26 begin */
NAS_LMM_MEM_SET(pIntraMsg, 0, NAS_EMM_INTRA_MSG_MAX_SIZE);
/* xiongxianghui00253310 add memset 2013-11-26 end */
/*构造EmmStatus消息*/
NAS_EMM_CompCnEmmStatus( &(pIntraMsg->stNasMsg),&ulIndex,ucRes);
ulDataReqMsgLenNoHeader = NAS_EMM_CountMrrcDataReqLen(ulIndex);
if ( NAS_EMM_INTRA_MSG_MAX_SIZE < ulDataReqMsgLenNoHeader )
{
/* 打印错误信息 */
NAS_LMM_PUBM_LOG_ERR("NAS_EMM_SendMsgEmmStatus, Size error");
NAS_LMM_MEM_FREE(pIntraMsg);
return ;
}
/*填充消息头*/
NAS_EMM_INTRA_MSG_HEADER(pIntraMsg, ulDataReqMsgLenNoHeader);
/*填充消息ID*/
pIntraMsg->ulMsgId = ID_NAS_LMM_INTRA_MRRC_DATA_REQ;
/*填充消息内容*/
pIntraMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_SIGNALLING;
pIntraMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_SIGNALLING;
pIntraMsg->enEmmMsgType = NAS_EMM_NAS_STATUS;
pIntraMsg->enDataCnf = LRRC_LMM_DATA_CNF_NOT_NEED;
/*填充消息长度*/
pIntraMsg->stNasMsg.ulNasMsgSize = ulIndex;
/*向OM发送空口消息ATTACH COMPLETE*/
pstNasMsg = (NAS_MSG_STRU *)(&(pIntraMsg->stNasMsg));
NAS_LMM_SendOmtAirMsg(NAS_EMM_OMT_AIR_MSG_UP, NAS_EMM_STATUS, pstNasMsg);
/*向MRRC发送消息*/
NAS_EMM_SndUplinkNasMsg( pIntraMsg);
NAS_LMM_MEM_FREE(pIntraMsg);
return;
}
VOS_VOID NAS_EMM_SER_SendMrrcDataReq_ExtendedServiceReq(VOS_VOID)
{
NAS_EMM_MRRC_DATA_REQ_STRU *pMrrcDataReqMsg = NAS_EMM_NULL_PTR;
VOS_UINT32 ulDataReqMsgLenNoHeader = NAS_EMM_NULL;
VOS_UINT32 ulIndex = NAS_EMM_NULL;
NAS_EMM_SER_LOG_INFO("NAS_EMM_SER_SendMrrcDataReq_ExtendedServiceReq is entered.");
/*以最小消息长度，申请消息内存,主要是看是否队列有空间*/
pMrrcDataReqMsg = (VOS_VOID *) NAS_LMM_MEM_ALLOC(NAS_EMM_INTRA_MSG_MAX_SIZE);
/*判断申请结果，若失败打印错误并退出*/
if (NAS_EMM_NULL_PTR == pMrrcDataReqMsg)
{
/*打印错误*/
NAS_EMM_ATTACH_LOG_ERR("NAS_EMM_SER_SendMrrcDataReq_ExtendedServiceReq: MSG ALLOC ERR!");
return;
}
/* 清除CSFB ABORT标识 */
NAS_EMM_SER_SaveEmmSerCsfbAbortFlag(NAS_EMM_CSFB_ABORT_FLAG_INVALID);
/*组装EXTENDED SERVICE REQ消息*/
NAS_EMM_CompCnExtendedSerReqMoNasMsg(pMrrcDataReqMsg->stNasMsg.aucNasMsg, &ulIndex);
/*内部消息长度计算*/
ulDataReqMsgLenNoHeader = NAS_EMM_CountMrrcDataReqLen(ulIndex);
if ( NAS_EMM_INTRA_MSG_MAX_SIZE < ulDataReqMsgLenNoHeader )
{
/* 打印错误信息 */
NAS_LMM_PUBM_LOG_ERR("NAS_EMM_SER_SendMrrcDataReq_ExtendedServiceReq, Size error");
NAS_LMM_MEM_FREE(pMrrcDataReqMsg);
return ;
}
/*填充消息长度*/
pMrrcDataReqMsg->stNasMsg.ulNasMsgSize = ulIndex;
/*填充消息头*/
EMM_COMP_MM_MSG_HEADER(pMrrcDataReqMsg, ulDataReqMsgLenNoHeader);
/* 填写MRRC_DATA_REQ 的消息ID标识 */
pMrrcDataReqMsg->ulMsgId = ID_NAS_LMM_INTRA_MRRC_DATA_REQ;
/*填写建立原因*/
switch(NAS_EMM_SER_GetEmmSERStartCause())
{
case NAS_EMM_SER_START_CAUSE_MT_CSFB_REQ:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MT_ACCESS;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_TERMINATING_CALL;
break;
case NAS_EMM_SER_START_CAUSE_MO_CSFB_REQ:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_DATA;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_MO_CSFB;
break;
case NAS_EMM_SER_START_CAUSE_MO_EMERGENCY_CSFB_REQ:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_EMERGENCY_CALL;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_EMERGENCY_CALL;
break;
default:
NAS_EMM_SER_LOG_ERR("Nas_Emm_SER_SendMrrcDataReq_ServiceReq:StartCause ERR");
break;
}
pMrrcDataReqMsg->enEmmMsgType = NAS_EMM_MSG_EXTENDED_SERVICE_REQ;
pMrrcDataReqMsg->enDataCnf = LRRC_LMM_DATA_CNF_NEED;
/*空口消息上报SER REQ*/
NAS_LMM_SendOmtAirMsg(NAS_EMM_OMT_AIR_MSG_UP, NAS_EMM_EXTENDED_SER_REQ, (NAS_MSG_STRU*)&(pMrrcDataReqMsg->stNasMsg));
/*关键事件上报SER REQ*/
NAS_LMM_SendOmtKeyEvent( EMM_OMT_KE_EXTENDED_SER_REQ);
/* 发送消息(Send the msg of) MRRC_DATA_REQ(SER_REQ) */
NAS_EMM_SndUplinkNasMsg( pMrrcDataReqMsg);
NAS_LMM_MEM_FREE(pMrrcDataReqMsg);
return;
}
