VOS_UINT32 NAS_MSCC_RcvHsdStartCnf_SwitchOn_WaitHsdStartCnf(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
HSD_MSCC_START_CNF_STRU *pstStartCnf = VOS_NULL_PTR;
VOS_UINT32 ulModuleId;
VOS_UINT32 ulRslt;
ulModuleId = 0;
pstStartCnf = (HSD_MSCC_START_CNF_STRU*)pstMsg;
NAS_TRACE_HIGH("start result=%d", pstStartCnf->enRslt);
/* Stop the protection Timer */
NAS_MSCC_StopTimer(TI_NAS_MSCC_WAIT_HSD_START_CNF);
/* Check whether the switch on result is success or not
1)If result is success get the next module and the start request to nest module
2)If result is Success and MOdule array is empty then send success result
3)If result is failure send failure result */
if ( HSD_MSCC_START_RESULT_SUCC == pstStartCnf->enRslt )
{
/* Get the next module ID*/
ulRslt = NAS_MSCC_GetNextModuleId_SwitchOn(&ulModuleId);
if (VOS_TRUE == ulRslt)
{
/* send start request to next module */
NAS_MSCC_SndStartReq_SwitchOn(ulModuleId);
return VOS_TRUE;
}
/* If the module array is empty send the result */
NAS_MSCC_SndSwitchOnRslt(NAS_MSCC_SWITCH_ON_RESULT_SUCCESS);
}
else
{
NAS_TRACE_HIGH("NAS_MSCC_RcvHsdStartCnf_SwitchOn_WaitHsdStartCnf:Result Failure!");
/* If the result is failure send the failure result */
NAS_MSCC_SndSwitchOnRslt(NAS_MSCC_SWITCH_ON_RESULT_FAILURE);
}
/* Quit the SubFSM */
NAS_MSCC_QuitFsmL2();
return VOS_TRUE;
}
VOS_VOID CNAS_XSD_SndCasStartReq(
MSCC_XSD_START_REQ_STRU *pstRcvMsg
)
{
CNAS_CAS_1X_START_REQ_STRU *pstStartrReq = VOS_NULL_PTR;
/* 分配消息 */
pstStartrReq = (CNAS_CAS_1X_START_REQ_STRU *)PS_ALLOC_MSG(UEPS_PID_XSD,
sizeof(CNAS_CAS_1X_START_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstStartrReq)
{
return;
}
/* 填充消息 */
pstStartrReq->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstStartrReq->ulReceiverPid = UEPS_PID_1XCASM;
pstStartrReq->enModemId = pstRcvMsg->enModemId;
pstStartrReq->enMsgId = ID_CNAS_CAS_1X_START_REQ;
pstStartrReq->enUimStatus = CNAS_CCB_GetCasCardStatus();
pstStartrReq->ucSuppRatNum = pstRcvMsg->ucSuppRatNum;
NAS_MEM_CPY_S(pstStartrReq->aenRatMode,
sizeof(pstStartrReq->aenRatMode),
pstRcvMsg->aenRatMode,
VOS_RATMODE_BUTT * sizeof(VOS_RATMODE_ENUM_UINT32));
CNAS_MNTN_LogMsgInfo((MSG_HEADER_STRU*)pstStartrReq);
/* 发送消息 */
(VOS_VOID)PS_SEND_MSG(UEPS_PID_XSD, pstStartrReq);
NAS_TRACE_HIGH("Send Msg!");
}
VOS_UINT32 NAS_MSCC_RcvTiWaitImsaStartCnfExpired_SwitchOn_WaitImsaStartCnf(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT32 ulModuleId;
VOS_UINT32 ulRslt;
ulModuleId = 0;
/* warning打印 */
NAS_TRACE_HIGH("NAS_MSCC_RcvTiWaitImsaStartCnfExpired_SwitchOn_WaitImsaStartCnf:time expired!");
NAS_MSCC_SndMmaImsSwitchStateInd(NAS_MSCC_PIF_IMS_SWITCH_STATE_OFF);
/* Get next Module ID */
ulRslt = NAS_MSCC_GetNextModuleId_SwitchOn(&ulModuleId);
if (VOS_TRUE == ulRslt)
{
/* send start request to next module */
NAS_MSCC_SndStartReq_SwitchOn(ulModuleId);
return VOS_TRUE;
}
NAS_MSCC_ProcTimerExpired_SwitchOn();
return VOS_TRUE;
}
VOS_UINT32 NAS_MSCC_RcvTiWaitMmcStartCnfExpired_SwitchOn_WaitMmcStartCnf(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
/* Print Error LOG */
NAS_TRACE_HIGH("NAS_MSCC_RcvTiWaitMmcStartCnfExpired_SwitchOn_WaitMmcStartCnf:time expired!");
/* Process the Timer Expired message */
NAS_MSCC_ProcTimerExpired_SwitchOn();
return VOS_TRUE;
}
VOS_VOID TAF_MMA_InitTask( VOS_VOID )
{
VOS_UINT32 ulAutoInitPsFlg;
NAS_TRACE_HIGH("Mma Init Task Begin!!");
/* 全局变量初始化 */
TAF_MMA_InitCtx(TAF_MMA_INIT_CTX_STARTUP, TAF_MMA_GetMmaCtxAddr());
/* 读取NV */
TAF_MMA_ReadNvim();
TAF_MMA_InitTimerLen();
/* 注册状态机 */
TAF_MMA_RegFsm();
ulAutoInitPsFlg = TAF_MMA_GetAutoInitPsFlg();
NAS_TRACE_HIGH("ulAutoInitPsFlg = %d",ulAutoInitPsFlg);
/* 上电初始化协议栈NV打开并且不是SFT平台则自动上电 */
if ((DRV_NOT_START_UMTS != mdrv_sysboot_check_startps())
&& (VOS_TRUE == ulAutoInitPsFlg))
{
/* 发送内部上电消息 */
TAF_MMA_SndInterPowerInitReq();
}
else
{
NAS_TRACE_HIGH("Not start PS");
/* FID初始化已投票禁止睡眠,非自动开机的场景允许睡眠 */
TAF_DRVAPI_PWRCTRL_SLEEPVOTE_UNLOCK(PWRCTRL_SLEEP_NAS);
}
return;
}
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;
}
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!");
}
VOS_UINT32 NAS_MSCC_RcvTiWaitCardReadTimerExpire_SwitchOn_WaitCardReadCnf(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT32 ulModuleId;
VOS_UINT32 ulRslt;
NAS_WARNING_LOG(UEPS_PID_MSCC, "NAS_MSCC_RcvTiWaitCardReadTimerExpire_SwitchOn_WaitCardReadCnf: timer out");
NAS_MSCC_ResetWaitCardReadCnfFlg_SwitchOn();
NAS_MSCC_ProcMlplMsplReadRslt_SwitchOn();
if (VOS_TRUE == NAS_MSCC_IsModuleOrderValid_SwitchOn())
{
/* Get the next Module ID*/
ulRslt = NAS_MSCC_GetNextModuleId_SwitchOn(&ulModuleId);
if (VOS_TRUE == ulRslt)
{
/* Send the start request to Next module */
NAS_MSCC_SndStartReq_SwitchOn(ulModuleId);
return VOS_TRUE;
}
}
NAS_TRACE_HIGH("NAS_MSCC_RcvMmaStartReq_SwitchOn_Init():Invalid Module order");
/* send the result to Main FSM */
NAS_MSCC_SndSwitchOnRslt(NAS_MSCC_SWITCH_ON_RESULT_FAILURE);
/* Quit the SubFSM */
NAS_MSCC_QuitFsmL2();
return VOS_TRUE;
}
VOS_VOID NAS_MSCC_SndStartReq_SwitchOn(
VOS_UINT32 ulReceivePid
)
{
MMA_MSCC_START_REQ_STRU *pstStartReq = VOS_NULL_PTR;
#if (FEATURE_ON == FEATURE_UE_MODE_CDMA)
NAS_MSCC_PIF_RAT_PRIO_STRU *pstRatPrio = VOS_NULL_PTR;
NAS_MSCC_PIF_CARD_STATUS_ENUM_UINT8 enCsimStatus;
NAS_MSCC_PIF_CARD_STATUS_ENUM_UINT8 enUsimStatus;
#endif
switch (ulReceivePid)
{
case WUEPS_PID_MMC:
{
/* Get the Start from Entry message */
pstStartReq = (MMA_MSCC_START_REQ_STRU *)NAS_MSCC_GetCurrFsmEntryMsgBufferAddr();
/* Send the Switch on indication to MMC */
NAS_MSCC_SndMmcStartReq(pstStartReq);
/* Update the currewnt FSM State */
NAS_MSCC_SetCurrFsmState(NAS_MSCC_SWITCHON_STA_WAIT_MMC_START_CNF);
/* Start the protection timer */
(VOS_VOID)NAS_MSCC_StartTimer(TI_NAS_MSCC_WAIT_MMC_START_CNF, TI_NAS_MSCC_WAIT_MMC_START_CNF_LEN);
}
break;
#if (FEATURE_ON == FEATURE_IMS)
case PS_PID_IMSA:
{
/* Send the Switch on indication to IMSA */
NAS_MSCC_SndImsaStartReq(MSCC_IMSA_START_TYPE_POWER_ON);
/* Update the currewnt FSM State */
NAS_MSCC_SetCurrFsmState(NAS_MSCC_SWITCHON_STA_WAIT_IMSA_START_CNF);
/* Start the protection timer */
(VOS_VOID)NAS_MSCC_StartTimer(TI_NAS_MSCC_WAIT_IMSA_START_CNF, TI_NAS_MSCC_WAIT_IMSA_START_CNF_LEN);
}
break;
#endif
#if (FEATURE_ON == FEATURE_UE_MODE_CDMA)
case UEPS_PID_XSD:
{
/* Get the Csim status from entry message */
enCsimStatus = NAS_MSCC_GetCsimStatus_SwitchOn();
/* Get Platform Rat capabilites */
pstRatPrio = NAS_MSCC_GetRatPrio_SwitchOn();
/* Send the Switch on indication to XSD */
NAS_MSCC_SndXsdStartReq(enCsimStatus, pstRatPrio);
/* Update the currewnt FSM State */
NAS_MSCC_SetCurrFsmState(NAS_MSCC_SWITCHON_STA_WAIT_XSD_START_CNF);
/* Start the protection timer */
(VOS_VOID)NAS_MSCC_StartTimer(TI_NAS_MSCC_WAIT_XSD_START_CNF, TI_NAS_MSCC_WAIT_XSD_START_CNF_LEN);
}
break;
case UEPS_PID_HSD:
{
/* Get the Csim status from entry message */
enCsimStatus = NAS_MSCC_GetCsimStatus_SwitchOn();
/* Get the Usim status from entry message */
enUsimStatus = NAS_MSCC_GetUsimStatus_SwitchOn();
/* Get Platform Rat capabilites */
pstRatPrio = NAS_MSCC_GetRatPrio_SwitchOn();
/* Send the Switch on indication to HSD */
NAS_MSCC_SndHsdStartReq(enCsimStatus, enUsimStatus, pstRatPrio);
/* Update the currewnt FSM State */
NAS_MSCC_SetCurrFsmState(NAS_MSCC_SWITCHON_STA_WAIT_HSD_START_CNF);
/* Start the protection timer */
(VOS_VOID)NAS_MSCC_StartTimer(TI_NAS_MSCC_WAIT_HSD_START_CNF, TI_NAS_MSCC_WAIT_HSD_START_CNF_LEN);
}
break;
#endif
default:
NAS_TRACE_HIGH("\n*NAS_MSCC_SndStartReq_SwitchOn():invalid ulReceivePid \n");
break;
}
}
VOS_UINT32 NAS_MSCC_RcvUsimmReadFileCnf_SwitchOn_WaitCardReadCnf(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
USIMM_READFILE_CNF_STRU *pstUsimmReadCnfMsg = VOS_NULL_PTR;
USIMM_DEF_FILEID_ENUM_UINT32 enEfId;
VOS_UINT32 ulModuleId;
VOS_UINT32 ulRslt;
#ifdef DMT
/* DMT测试: 构造读卡MLPL、MSPL失败，定时器超时场景 */
if (NAS_MSCC_CARD_READ_STUB_TYPE_MLPL_MSPL_NO_REPLY == genCardReadStubTypeForDmt)
{
NAS_MSCC_SendCardReadTimerExpireMsgForDmt();
return VOS_TRUE;
}
#endif
pstUsimmReadCnfMsg = (USIMM_READFILE_CNF_STRU*)pstMsg;
if (VOS_OK != USIMM_ChangePathToDefFileID(pstUsimmReadCnfMsg->stCmdResult.enApptype,
pstUsimmReadCnfMsg->stFilePath.ulPathLen,
pstUsimmReadCnfMsg->stFilePath.acPath, &enEfId))
{
NAS_TRACE_HIGH("NAS_MSCC_RcvUsimmReadFileCnf_SwitchOn_WaitCardReadCnf :Error In USIMM_ChangePathToDefFileID!");
return VOS_TRUE;
}
NAS_MSCC_RcvUsimmReadFileCnf(pstUsimmReadCnfMsg, enEfId);
NAS_MSCC_ClearWaitCardReadCnfFlg_SwitchOn(enEfId);
if (NAS_MSCC_WAIT_CARD_READ_CNF_FLAG_NULL == NAS_MSCC_GetWaitCardReadCnfFlag_SwitchOn())
{
NAS_MSCC_StopTimer(TI_NAS_MSCC_WAIT_CARD_READ_CNF);
NAS_MSCC_ProcMlplMsplReadRslt_SwitchOn();
if (VOS_TRUE == NAS_MSCC_IsModuleOrderValid_SwitchOn())
{
/* Get the next Module ID*/
ulRslt = NAS_MSCC_GetNextModuleId_SwitchOn(&ulModuleId);
if (VOS_TRUE == ulRslt)
{
/* Send the start request to Next module */
NAS_MSCC_SndStartReq_SwitchOn(ulModuleId);
return VOS_TRUE;
}
}
NAS_TRACE_HIGH("NAS_MSCC_RcvUsimmReadFileCnf_SwitchOn_WaitCardReadCnf :Invalid Module order");
/* send the result to Main FSM */
NAS_MSCC_SndSwitchOnRslt(NAS_MSCC_SWITCH_ON_RESULT_FAILURE);
/* Quit the SubFSM */
NAS_MSCC_QuitFsmL2();
}
return VOS_TRUE;
}
VOS_UINT32 NAS_MSCC_RcvMmaStartReq_SwitchOn_Init(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT32 ulModuleId;
VOS_UINT32 ulRslt;
MMA_MSCC_START_REQ_STRU *pstMsgStartReq;
/* Save the entry message */
NAS_MSCC_SaveCurEntryMsg(ulEventType, pstMsg);
pstMsgStartReq = (MMA_MSCC_START_REQ_STRU*)pstMsg;
/* save card status */
NAS_MSCC_SaveCardStatus(pstMsgStartReq->enUsimStatus, pstMsgStartReq->enCsimStatus);
/* save prio rat list */
NAS_MSCC_SavePrioRatList(&pstMsgStartReq->stRatPrio);
/* 保存ICCID是否发生改变的标识 */
NAS_MSCC_SaveIsCardChangedFlg(pstMsgStartReq->ucIsCardChanged);
#if (FEATURE_ON == FEATURE_UE_MODE_CDMA)
if ((NAS_MSCC_PIF_CARD_STATUS_CSIM_PRESENT == pstMsgStartReq->enCsimStatus)
&& (NAS_MSCC_PIF_CARD_STATUS_USIM_PRESENT == pstMsgStartReq->enUsimStatus))
{
if (VOS_TRUE == NAS_MSCC_IsPlatformSupport3Gpp2())
{
/* Read files from card */
NAS_MSCC_SndUsimmReadFileReq_SwitchOn();
NAS_MSCC_SetCurrFsmState(NAS_MSCC_SWITCHON_STA_WAIT_CARD_READ_CNF);
(VOS_VOID)NAS_MSCC_StartTimer(TI_NAS_MSCC_WAIT_CARD_READ_CNF,
TI_NAS_MSCC_WAIT_CARD_READ_CNF_LEN);
return VOS_TRUE;
}
}
#endif
if (VOS_TRUE == NAS_MSCC_IsModuleOrderValid_SwitchOn())
{
/* Get the next Module ID*/
ulRslt = NAS_MSCC_GetNextModuleId_SwitchOn(&ulModuleId);
if (VOS_TRUE == ulRslt)
{
/* Send the start request to Next module */
NAS_MSCC_SndStartReq_SwitchOn(ulModuleId);
return VOS_TRUE;
}
}
NAS_TRACE_HIGH("NAS_MSCC_RcvMmaStartReq_SwitchOn_Init():Invalid Module order");
/* send the result to Main FSM */
NAS_MSCC_SndSwitchOnRslt(NAS_MSCC_SWITCH_ON_RESULT_FAILURE);
/* Quit the SubFSM */
NAS_MSCC_QuitFsmL2();
return VOS_TRUE;
}
VOS_UINT32 TAF_MMA_SndMmcStartReq(
MMA_MMC_CARD_STATUS_ENUM_UINT8 enCardStatus,
MMA_MMC_PLMN_RAT_PRIO_STRU *pstPlmnRatPrio
)
{
VOS_UINT32 ulRet;
MMA_MMC_START_REQ_STRU *pstMsg = VOS_NULL_PTR;
/* 申请内存 */
pstMsg = (MMA_MMC_START_REQ_STRU *)PS_ALLOC_MSG(WUEPS_PID_MMA,
sizeof(MMA_MMC_START_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if ( VOS_NULL_PTR == pstMsg )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcStartReq:ERROR: Memory Alloc Error for pMsg");
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8*)pstMsg + VOS_MSG_HEAD_LENGTH, 0,
sizeof(MMA_MMC_START_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_START_REQ_STRU) - VOS_MSG_HEAD_LENGTH;
pstMsg->MsgHeader.ulMsgName = ID_MMA_MMC_START_REQ;
pstMsg->enRegDomain = TAF_MMA_GetRegDomain();
pstMsg->enCardStatus = enCardStatus;
pstMsg->stPlmnRatPrio = *pstPlmnRatPrio;
/* 开机请求适配新的接口，支持CDMA技术接口 */
if (VOS_TRUE == TAF_MMA_IsPowerOnCLInterWork())/* C+L模式 */
{
pstMsg->enRegCtrl = MMA_MMC_REG_CONTROL_BY_3GPP2_CBP;
pstMsg->st3Gpp2Rat.ucRatNum = 1;
pstMsg->st3Gpp2Rat.auc3GPP2Rat[0] = MMA_MMC_3GPP2_RAT_TYPE_HRPD;
}
else
{
pstMsg->enRegCtrl = MMA_MMC_REG_CONTROL_BY_3GPP_MMC;
pstMsg->st3Gpp2Rat.ucRatNum = 0;
}
if (MMA_MMC_CARD_STATUS_ABSENT != enCardStatus)
{
PS_MEM_CPY(pstMsg->aucImsi, TAF_SDC_GetSimImsi(), NAS_MAX_IMSI_LENGTH);
}
/* 调用VOS发送原语 */
ulRet = PS_SEND_MSG( WUEPS_PID_MMA, pstMsg );
if ( VOS_OK != ulRet )
{
NAS_ERROR_LOG(WUEPS_PID_MMA, "TAF_MMA_SndMmcStartReq:ERROR:PS_SEND_MSG FAILURE");
return VOS_ERR;
}
NAS_TRACE_HIGH("Send Msg!");
return VOS_OK;
}
