VOS_UINT32 TAF_APS_RcvEsmSmEpsBearerInfoInd_Active(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT8 ucPdpId;
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity;
TAF_APS_EPS_BEARER_INFO_IND_STRU *pstBearerInfo;
pstBearerInfo = (TAF_APS_EPS_BEARER_INFO_IND_STRU*)pstMsg;
ucPdpId = TAF_APS_GetCurrFsmEntityPdpId();
/* 获取该PDPID的PDP实体内容地址 */
pstPdpEntity = TAF_APS_GetPdpEntInfoAddr(ucPdpId);
/* 根据EPS承载的操作类型(Activate, Deactivate, Modify),
调用相应的处理函数 */
if (SM_ESM_PDP_OPT_MODIFY == pstBearerInfo->enPdpOption)
{
MN_APS_ProcEsmBearerInfoIndOptModify(pstPdpEntity, pstBearerInfo);
}
else if (SM_ESM_PDP_OPT_DEACTIVATE == pstBearerInfo->enPdpOption)
{
MN_APS_ProcEsmBearerInfoIndOptDeactivate(pstPdpEntity, pstBearerInfo);
}
else
{
TAF_WARNING_LOG(WUEPS_PID_TAF,"TAF_APS_RcvEsmSmEpsBearerInfoInd_Inactive: Wrong option.");
}
return VOS_TRUE;
}
VOS_VOID TAF_CBA_ParseSpecUsimFileData (
VOS_UINT16 usFileId,
VOS_UINT8 ucFileExistFlg,
VOS_UINT8 *pucEf,
VOS_UINT16 ulEfLen
)
{
switch (usFileId)
{
case TAF_CBA_EF_CBMI_ID:
TAF_CBA_ParseUsimFileEfCbmiData(ucFileExistFlg, pucEf, ulEfLen);
break;
case TAF_CBA_EF_CBMIR_ID:
TAF_CBA_ParseUsimFileEfCbmirData(ucFileExistFlg, pucEf, ulEfLen);
break;
case TAF_CBA_EF_CBMID_ID:
TAF_CBA_ParseUsimFileEfCbmidData(ucFileExistFlg, pucEf, ulEfLen);
break;
default:
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_CBA_ParseSpecUsimFileData: The input is invalid.");
break;
}
}
VOS_VOID TAF_APS_SaveCurrSubFsmEntryMsg(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
TAF_APS_ENTRY_MSG_STRU *pstEntryMsg = VOS_NULL_PTR;
MSG_HEADER_STRU *pstMsgHeader = VOS_NULL_PTR;
VOS_UINT32 ulLen;
/* 获得当前处理入口消息的缓冲区地址 */
/* 获得当前处理APS入口消息的缓冲区地址 */
pstEntryMsg = TAF_APS_GetCurrSubFsmMsgAddr();
pstMsgHeader = (MSG_HEADER_STRU*)pstMsg;
/* 如果是空消息 */
if ( VOS_NULL_PTR == pstMsg )
{
pstEntryMsg->ulEventType = ulEventType;
TAF_WARNING_LOG( WUEPS_PID_TAF, "TAF_APS_SaveCurrSubFsmEntryMsg 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_RcvAtSetPdpContextStateReq_Inactive(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
TAF_PS_MSG_STRU *pstAppMsg;
TAF_PS_SET_PDP_STATE_REQ_STRU *pstSetPdpCtxStateReq;
/* 初始化, 获取消息内容 */
pstAppMsg = (TAF_PS_MSG_STRU*)pstMsg;
pstSetPdpCtxStateReq = (TAF_PS_SET_PDP_STATE_REQ_STRU*)(pstAppMsg->aucContent);
/* PDP激活操作处理 */
if (TAF_CGACT_ACT == pstSetPdpCtxStateReq->stCidListStateInfo.ucState)
{
/*-------------------------------------------------------
加载TAF_APS_STA_MS_ACTIVATING状态机
加载后子状态切换为TAF_APS_MS_ACTIVATING_SUBSTA_INIT
在TAF_APS_MS_ACTIVATING_SUBSTA_INIT子状态中处理
ID_MSG_TAF_PS_SET_PDP_CONTEXT_STATE_REQ消息
-------------------------------------------------------*/
TAF_APS_InitSubFsm(TAF_APS_FSM_MS_ACTIVATING,
TAF_APS_GetMsActivatingFsmDescAddr(),
TAF_APS_MS_ACTIVATING_SUBSTA_INIT);
}
else
{
/* 指定去激活的CID处于未激活状态, 在预处理中已经处理, 这里不再处理 */
TAF_WARNING_LOG(WUEPS_PID_TAF,
"TAF_APS_RcvAtSetPdpContextStateReq_Inactive: Wrong operation");
}
return VOS_TRUE;
}
VOS_UINT32 TAF_APS_RcvMmcServiceStatusInd_Inactive(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
MMC_APS_SERVICE_STATUS_IND_STRU *pstMmcServiceStatusInd;
/* 初始化, 获取消息内容 */
pstMmcServiceStatusInd = (MMC_APS_SERVICE_STATUS_IND_STRU*)pstMsg;
/* 更新接入技术 */
TAF_APS_SetCurrPdpEntityRatType(pstMmcServiceStatusInd->enRatType);
/* 更新PS域SIM卡状态 */
TAF_APS_SetCurrPdpEntitySimRegStatus(pstMmcServiceStatusInd->ulPsSimRegStatus);
/* 正常状态下只处理挂起指示 */
if (MMC_APS_RAT_TYPE_NULL != pstMmcServiceStatusInd->enRatType)
{
TAF_WARNING_LOG(WUEPS_PID_TAF,
"TAF_APS_RcvMmcServiceStatusInd_InactiveSuspend: Wrong RAT type!");
}
return VOS_TRUE;
}
VOS_UINT32 TAF_APS_RcvL4aPdpActivateInd_Inactive(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
MMC_APS_RAT_TYPE_ENUM_UINT32 enCurrRatType;
/* 获取当前网络模式*/
enCurrRatType = TAF_APS_GetCurrPdpEntityRatType();
/* 检查当前模是否为LTE, 如果不是, 丢弃该消息 */
if (MMC_APS_RAT_TYPE_LTE != enCurrRatType)
{
TAF_WARNING_LOG(WUEPS_PID_TAF,
"TAF_APS_RcvL4aPdpActivateInd_Inactive: Current RAT is not LTE!");
return VOS_TRUE;
}
/* 迁移到子状态TAF_APS_NW_ACTIVATING_SUBSTA_INIT,在子状态
TAF_APS_NW_ACTIVATING_SUBSTA_INIT中处理 ID_L4A_APS_PDP_ACTIVATE_IND
消息
*/
TAF_APS_InitSubFsm(TAF_APS_FSM_NW_ACTIVATING,
TAF_APS_GetNwActivatingFsmDescAddr(),
TAF_APS_NW_ACTIVATING_SUBSTA_INIT);
return VOS_TRUE;
}
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_UINT32 TAF_SPM_BuildUssdFdnInfo(
struct MsgCB *pstMsg,
PS_PB_FDN_NUM_STRU *pstFdnInfo
)
{
VOS_UINT32 ulAsciiStrLen;
VOS_UINT8 *pucAsciiStr = VOS_NULL_PTR;
MN_APP_REQ_MSG_STRU *pstAppMsg = VOS_NULL_PTR;
VOS_UINT32 ulRet;
/* 调用转换函数获取ASCII格式的字符串 */
pucAsciiStr = PS_MEM_ALLOC(WUEPS_PID_TAF, TAF_SS_MAX_USSDSTRING_LEN);
if (VOS_NULL_PTR == pucAsciiStr)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdFdnInfo: Fail to alloc memory.");
return VOS_FALSE;
}
pstAppMsg = (MN_APP_REQ_MSG_STRU *)pstMsg;
ulAsciiStrLen = 0;
PS_MEM_SET(pucAsciiStr, 0, TAF_SS_MAX_USSDSTRING_LEN);
ulRet = TAF_SPM_TransUssdMsgToAsciiStr((TAF_SS_PROCESS_USS_REQ_STRU*)pstAppMsg->aucContent,
pucAsciiStr,
&ulAsciiStrLen);
if (VOS_FALSE == ulRet)
{
PS_MEM_FREE(WUEPS_PID_TAF, pucAsciiStr);
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdFdnInfo: Fail to TAF_SDC_TransUssdMsgToAsciiStr.");
return VOS_FALSE;
}
/* FDN中的num1只能保存40个ascii码 */
PS_MEM_SET(pucAsciiStr + TAF_SPM_FDN_CHECK_STR_MAX_LEN, 0, TAF_SPM_FDN_CHECK_7BIT_MAX_LEN - TAF_SPM_FDN_CHECK_STR_MAX_LEN);
ulRet = TAF_STD_ConvertAsciiNumberToBcd((VOS_CHAR *)pucAsciiStr, pstFdnInfo->aucNum1, (VOS_UINT8 *)&pstFdnInfo->ulNum1Len);
PS_MEM_FREE(WUEPS_PID_TAF, pucAsciiStr);
if (MN_ERR_NO_ERROR != ulRet)
{
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_UINT32 TAF_MMA_SndInternalMsg(
VOS_VOID *pSndMsg
)
{
VOS_UINT8 ucMsgPnt;
TAF_MMA_INTERNAL_MSG_BUF_STRU *pstMmaMsg = VOS_NULL_PTR;
TAF_MMA_INTERNAL_MSG_QUEUE_STRU *pstInternalMsgQueue = VOS_NULL_PTR;
TAF_MMA_INTERNAL_MSG_BUF_STRU *pstSndMsg = VOS_NULL_PTR;
pstInternalMsgQueue = &(TAF_MMA_GetMmaCtxAddr()->stInternalMsgQueue);
pstSndMsg = (TAF_MMA_INTERNAL_MSG_BUF_STRU*)pSndMsg;
/* 1. 判断内部消息缓冲区是否已满 */
ucMsgPnt = pstInternalMsgQueue->ucTail;
if ( ((ucMsgPnt + 1) % TAF_MMA_MAX_MSG_QUEUE_SIZE) == pstInternalMsgQueue->ucHeader )
{
TAF_WARNING_LOG(WUEPS_PID_MMA, "TAF_MMA_SndInternalMsg:Warning: The Queue is full.");
TAF_MMA_SndOmInternalMsgQueueInfo(VOS_TRUE, VOS_FALSE);
return VOS_FALSE;
}
/* 2. 取得一个消息缓冲单元 */
pstMmaMsg = (TAF_MMA_INTERNAL_MSG_BUF_STRU *)&(pstInternalMsgQueue->astMmaMsgQueue[ucMsgPnt]);
/* 3. 判断消息长度是否非法 */
if ( pstSndMsg->ulLength > TAF_MMA_MAX_MSG_BUFFER_LEN)
{
TAF_WARNING_LOG(WUEPS_PID_MMC, "TAF_MMA_SndInternalMsg:Warning: ulBufLen is too long.");
return VOS_FALSE;
}
TAF_NORMAL_LOG1(WUEPS_PID_MMA, "TAF_MMA_SndInternalMsg: usMsgID is ", pstMmaMsg->usMsgID);
/* 4. 将内部消息发送到内部消息队列中 */
PS_MEM_CPY(pstMmaMsg, pstSndMsg, sizeof(TAF_MMA_INTERNAL_MSG_BUF_STRU));
/* 更新内部消息缓冲区 */
pstInternalMsgQueue->ucTail++;
pstInternalMsgQueue->ucTail %= TAF_MMA_MAX_MSG_QUEUE_SIZE;
return VOS_TRUE;
}
VOS_UINT32 TAF_SPM_BuildSsFdnInfo(
struct MsgCB *pstMsg,
PS_PB_FDN_NUM_STRU *pstFdnInfo
)
{
VOS_UINT32 ulRet;
VOS_CHAR *pcMmiStr = VOS_NULL_PTR;
/* 根据消息转换出SSC STRING */
pcMmiStr = (VOS_CHAR *)PS_MEM_ALLOC(WUEPS_PID_TAF, TAF_SPM_SSC_MAX_LEN);
if (VOS_NULL_PTR == pcMmiStr)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildSsFdnInfo: Fail to alloc memory for encode SSC.");
return VOS_FALSE;
}
PS_MEM_SET(pcMmiStr, 0, TAF_SPM_SSC_MAX_LEN);
ulRet = TAF_MmiEncodeMmiString(pstMsg, pcMmiStr);
if (VOS_TRUE != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildSsFdnInfo: Fail to Encode SSC string.");
PS_MEM_FREE(WUEPS_PID_TAF, pcMmiStr);
return VOS_FALSE;
}
ulRet = TAF_STD_ConvertAsciiNumberToBcd(pcMmiStr, pstFdnInfo->aucNum1, (VOS_UINT8 *)&(pstFdnInfo->ulNum1Len));
PS_MEM_FREE(WUEPS_PID_TAF, pcMmiStr);
if (MN_ERR_NO_ERROR != ulRet)
{
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_UINT32 TAF_APS_SndL4aPppDialReq(
TAF_PS_PPP_DIAL_ORIG_REQ_STRU *pstPppDialOrigReq,
TAF_APS_AUTH_INFO_STRU *pstAuthInfo,
TAF_APS_IPCP_INFO_STRU *pstIpcpInfo
)
{
APS_L4A_PPP_DIAL_REQ_STRU *pstPppDialReq;
/* 构造消息 */
pstPppDialReq = (APS_L4A_PPP_DIAL_REQ_STRU*)PS_ALLOC_MSG_WITH_HEADER_LEN(
WUEPS_PID_TAF,
sizeof(APS_L4A_PPP_DIAL_REQ_STRU));
if (VOS_NULL_PTR == pstPppDialReq)
{
TAF_ERROR_LOG(WUEPS_PID_TAF, "TAF_APS_SndL4aPppDialReq: Memory alloc failed.");
return VOS_ERR;
}
/* 初始化消息 */
PS_MEM_SET((VOS_CHAR*)pstPppDialReq + VOS_MSG_HEAD_LENGTH,
0x00,
(sizeof(APS_L4A_PPP_DIAL_REQ_STRU) - VOS_MSG_HEAD_LENGTH));
/* 填写消息头 */
pstPppDialReq->ulReceiverCpuId = VOS_LOCAL_CPUID;
pstPppDialReq->ulReceiverPid = MSP_L4_L4A_PID;
pstPppDialReq->enMsgId = ID_APS_L4A_PPP_DIAL_REQ;
/* 填写消息内容 */
pstPppDialReq->stAppCtrl.ulPid = WUEPS_PID_TAF;
pstPppDialReq->stAppCtrl.ulClientId = pstPppDialOrigReq->stCtrl.usClientId;
pstPppDialReq->stAppCtrl.ulOpId = pstPppDialOrigReq->stCtrl.ucOpId;
pstPppDialReq->ulCid = pstPppDialOrigReq->stPppDialParaInfo.ucCid;
PS_MEM_CPY((VOS_UINT8*)(&pstPppDialReq->stPppInfo.stAuthInfo),
(VOS_UINT8*)(pstAuthInfo),
sizeof(TAF_APS_AUTH_INFO_STRU));
PS_MEM_CPY((VOS_UINT8*)(&pstPppDialReq->stPppInfo.stIpcpInfo),
(VOS_UINT8*)(pstIpcpInfo),
sizeof(TAF_APS_IPCP_INFO_STRU));
/* 发送消息 */
if (VOS_OK != PS_SEND_MSG(WUEPS_PID_TAF, pstPppDialReq))
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_APS_SndL4aPppDialReq():WARNING:SEND MSG FIAL");
}
return VOS_OK;
}
VOS_UINT32 TAF_CBA_AddCbMiRangeListToActiveList(
TAF_CBA_CBMI_RANGE_LIST_STRU *pstOrgCbMirList
)
{
VOS_UINT16 usIndex;
VOS_UINT32 ulRet;
TAF_CBA_CBMI_RANGE_LIST_STRU *pstDstCbMirList;
VOS_UINT32 ulSaveIdx;
VOS_UINT32 ulCbmidIdx;
pstDstCbMirList = TAF_CBA_GetCbMiRangeList();
for ( usIndex = 0 ; usIndex < pstOrgCbMirList->usCbmirNum ; usIndex++ )
{
ulRet = TAF_CBA_IsCbmirExist(&(pstOrgCbMirList->astCbmiRangeInfo[usIndex]),
pstDstCbMirList,
&ulCbmidIdx);
/* 原本在列表中存在，不需要加入 */
if (VOS_TRUE == ulRet)
{
continue;
}
ulSaveIdx = TAF_CBA_GetCbmiRangNum();
/* 列表满 */
if ( ulSaveIdx >= TAF_CBA_MAX_CBMID_RANGE_NUM )
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_CBA_AddCbmirListToActiveList:No available Index");
return VOS_ERR;
}
pstDstCbMirList->astCbmiRangeInfo[ulSaveIdx].enRcvMode = TAF_CBA_CBMI_RANGE_RCV_MODE_ACCEPT;
pstDstCbMirList->astCbmiRangeInfo[ulSaveIdx].usMsgIdFrom
= pstOrgCbMirList->astCbmiRangeInfo[usIndex].usMsgIdFrom;
pstDstCbMirList->astCbmiRangeInfo[ulSaveIdx].usMsgIdTo
= pstOrgCbMirList->astCbmiRangeInfo[usIndex].usMsgIdTo;
pstDstCbMirList->usCbmirNum++;
}
return VOS_OK;
}
VOS_UINT32 TAF_SPM_RcvAppReqMsg_Main(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT16 usClientId;
VOS_UINT8 ucOpId;
VOS_UINT8 ucIdleFsmIndex;
TAF_SPM_GetClientIdWithAppMsg(pstMsg, &usClientId);
TAF_SPM_GetOpIdWithAppMsg(pstMsg, &ucOpId);
/* 判断是否有存在空闲状态机 */
ucIdleFsmIndex = TAF_SPM_GetIdleEntityFsmIndex();
if (TAF_SPM_INVALID_CLIENT_ID_ENTITY_FSM_INDEX == ucIdleFsmIndex)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_RcvAppReqMsg_Main():WARNING: No Idle Entiy Fsm Exist!");
/* 临时响应改为正式响应 */
TAF_SPM_SendServiceRequetFail_Main(ulEventType, pstMsg, MN_ERR_CLASS_SPM_BEYOND_CONCURRENCY_CAPABILITY);
#if (FEATURE_ON == FEATURE_IMS)
TAF_SPM_SetEconfPreRslt(TAF_CS_CAUSE_UNKNOWN);
TAF_SPM_ReportEconfCheckRslt();
#endif
}
else
{
/* 设置当前状态机的索引 */
TAF_SPM_SetCurrEntityFsmAddr(ucIdleFsmIndex);
/* 设置当前client ID实体状态机的client ID */
TAF_SPM_SetCurrEntityFsmClientId(usClientId);
/* 启动service ctrl状态机,进行fdn&CALL control检查 */
TAF_SPM_FSM_InitEntityFsm(TAF_SPM_FSM_SERVICE_CTRL,
TAF_SPM_GetServiceCtrlFsmDescAddr(),
TAF_SPM_SERVICE_CTRL_STA_INIT);
}
return VOS_TRUE;
}
VOS_UINT32 TAF_APS_RcvSndcpActivateRsp_Active(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT32 ulResult;
VOS_UINT8 ucPdpId;
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity;
APS_SNDCP_ACTIVATE_RSP_ST *pstSnActivateRsp;
/* 初始化, 获取消息内容 */
ulResult = VOS_OK;
pstSnActivateRsp = &((APS_SNDCP_ACTIVATE_RSP_MSG*)pstMsg)->ApsSnActRsp;
ucPdpId = TAF_APS_GetCurrFsmEntityPdpId();
pstPdpEntity = TAF_APS_GetPdpEntInfoAddr(ucPdpId);
/* 检查消息参数 */
ulResult = Aps_SnMsgModSnActRspParaCheck(pstSnActivateRsp);
if (APS_PARA_VALID != ulResult)
{
TAF_WARNING_LOG(WUEPS_PID_TAF,
"TAF_APS_RcvSndcpActivateRsp_Active: Check para failed!");
/* 上报ID_EVT_TAF_PS_CALL_PDP_DEACTIVATE_IND事件 */
TAF_APS_SndPdpDeActivateInd(ucPdpId, TAF_PS_CAUSE_SM_NW_PROTOCOL_ERR_UNSPECIFIED);
/* 发送内部消息, 触发PDP去激活流程 */
TAF_APS_SndInterPdpDeactivateReq(ucPdpId, SM_TAF_CAUSE_SM_NW_PROTOCOL_ERR_UNSPECIFIED);
return VOS_TRUE;
}
/* 收到SN_ACT_RSP后修改APS实体参数, 包括XID参数, TRANSMODE */
Aps_SnActRspChngEntity(pstSnActivateRsp, ucPdpId);
/* 设置RABM的传输模式 */
TAF_APS_SndRabmSetTransModeMsg(pstSnActivateRsp->ucNsapi,
pstPdpEntity->GprsPara.TransMode);
return VOS_TRUE;
}
VOS_VOID TAF_SPM_ReadSimCallCtrlNvim(VOS_VOID)
{
TAF_SPM_SERVICE_CTRL_CFG_INFO_STRU *pstServiceCtrlCfgInfo = VOS_NULL_PTR;
MN_CALL_NVIM_SIM_CALL_CONTROL_FLG_STRU stSimCallCtrlFlg;
pstServiceCtrlCfgInfo = TAF_SPM_GetServiceCtrlCfgInfoAddr();
if (NV_OK != NV_Read(en_NV_Item_NVIM_SIM_CALL_CONTROL_SUPPORT_FLG,
&stSimCallCtrlFlg,
sizeof(MN_CALL_NVIM_SIM_CALL_CONTROL_FLG_STRU)))
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_ReadNvimInfo():WARNING: en_NV_Item_NVIM_SIM_CALL_CONTROL_SUPPORT_FLG Error");
pstServiceCtrlCfgInfo->ucSimCallCtrlSupportFlg = VOS_FALSE;
return;
}
pstServiceCtrlCfgInfo->ucSimCallCtrlSupportFlg = stSimCallCtrlFlg.ucSimCallCtrlSupportFlg;
return;
}
VOS_VOID TAF_SPM_ReadFdnInfoNvim(VOS_VOID)
{
TAF_SPM_SERVICE_CTRL_CFG_INFO_STRU *pstServiceCtrlCfgInfo = VOS_NULL_PTR;
TAF_FDN_NVIM_CONFIG_STRU stFdnConfig;
pstServiceCtrlCfgInfo = TAF_SPM_GetServiceCtrlCfgInfoAddr();
if (NV_OK != NV_Read(en_NV_Item_FDN_Info,
&stFdnConfig,
sizeof(TAF_FDN_NVIM_CONFIG_STRU)))
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_ReadNvimInfo():WARNING: en_NV_Item_FDN_Info Error");
pstServiceCtrlCfgInfo->ulMeStatus = TAF_FDN_CHECK_FEATURE_OFF;
return;
}
pstServiceCtrlCfgInfo->ulMeStatus = stFdnConfig.ulMeStatus;
return;
}
VOS_VOID TAF_CBA_ProcMmcMsg(
struct MsgCB *pstMsg
)
{
TAFMMC_CBS_CURR_NET_MODE_IND_STRU *pstMsgInd;
switch (((MSG_HEADER_STRU *)pstMsg)->ulMsgName)
{
case TAFMMC_CBS_NO_NETWORK_IND:
TAF_CBA_SetNetRatType(TAF_CBA_NET_RAT_TYPE_BUTT);
break;
case TAFMMC_CBS_CURR_NET_MODE_IND:
pstMsgInd = (TAFMMC_CBS_CURR_NET_MODE_IND_STRU *)pstMsg;
TAF_CBA_RcvMmcNetModeInd(pstMsgInd->ucCurNetWork);
break;
default:
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_CBA_ProcMmcMsg:Rcv Invalid Msg Type");
break;
}
}
VOS_VOID TAF_SPM_ReadVideoCallNvim(VOS_VOID)
{
TAF_SPM_SERVICE_CTRL_CFG_INFO_STRU *pstServiceCtrlCfgInfo = VOS_NULL_PTR;
MN_CALL_NV_ITEM_VIDEO_CALL_STRU stVideoCall;
pstServiceCtrlCfgInfo = TAF_SPM_GetServiceCtrlCfgInfoAddr();
if (NV_OK != NV_Read(en_NV_Item_VIDEO_CALL,
&stVideoCall,
sizeof(MN_CALL_NV_ITEM_VIDEO_CALL_STRU)))
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_ReadVideoCallNvim():WARNING: en_NV_Item_VIDEO_CALL Error");
return;
}
if (VOS_TRUE == stVideoCall.ucStatus)
{
pstServiceCtrlCfgInfo->enVpCfgState = stVideoCall.ucVpCfgState;
}
return;
}
VOS_UINT32 TAF_APS_RcvSmPdpModifyInd_Active(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
VOS_UINT32 ulResult;
VOS_UINT8 ucPdpId;
MMC_APS_RAT_TYPE_ENUM_UINT32 enCurrRatType;
APS_MDFIND_PARA_ST stParam;
SMREG_PDP_MODIFY_IND_STRU *pstSmPdpModifyInd;
#if (FEATURE_ON == FEATURE_LTE)
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity;
#endif
/* 获取消息内容 */
pstSmPdpModifyInd = (SMREG_PDP_MODIFY_IND_STRU *)pstMsg;
ucPdpId = TAF_APS_GetCurrFsmEntityPdpId();
enCurrRatType = TAF_APS_GetCurrPdpEntityRatType();
#if (FEATURE_ON == FEATURE_LTE)
pstPdpEntity = TAF_APS_GetPdpEntInfoAddr(ucPdpId);
#endif
ulResult = Aps_PdpMdfIndParaCheck(pstSmPdpModifyInd, &stParam);
if (APS_PARA_INVALID == ulResult)
{
TAF_WARNING_LOG(WUEPS_PID_TAF,
"TAF_APS_RcvSmPdpModifyInd_Active: Check para failed! ");
/* 上报ID_EVT_TAF_PS_CALL_PDP_DEACTIVATE_IND事件 */
TAF_APS_SndPdpDeActivateInd(ucPdpId, TAF_PS_CAUSE_SM_NW_PROTOCOL_ERR_UNSPECIFIED);
/* 发送内部消息, 触发PDP去激活流程 */
TAF_APS_SndInterPdpDeactivateReq(ucPdpId, SM_TAF_CAUSE_SM_NW_PROTOCOL_ERR_UNSPECIFIED);
return VOS_TRUE;
}
/* 检查QOS是否满足MIN */
if (APS_PARA_VALID == Aps_CheckQosSatisify(ucPdpId, &stParam.NewQos))
{
/* 满足MINQOS */
Aps_PdpMdfIndQosSatisfy(ucPdpId, &stParam, pstSmPdpModifyInd);
#if (FEATURE_ON == FEATURE_LTE)
/* 同步PDP信息至ESM */
MN_APS_SndEsmPdpInfoInd(pstPdpEntity, SM_ESM_PDP_OPT_MODIFY);
#endif
/* 如果当前模为GSM, 迁移状态 */
if (MMC_APS_RAT_TYPE_GSM == enCurrRatType)
{
/*------------------------------------------------------------------
加载TAF_APS_STA_MS_MODIFYING状态机
加载后子状态切换为TAF_APS_MS_MODIFYING_SUBSTA_INIT
在TAF_APS_MS_MODIFYING_SUBSTA_INIT子状态中
处理D_PMC_SMREG_PDP_MODIFY_IND消息
------------------------------------------------------------------*/
TAF_APS_InitSubFsm(TAF_APS_FSM_MS_MODIFYING,
TAF_APS_GetMsModifyingFsmDescAddr(),
TAF_APS_MS_MODIFYING_SUBSTA_INIT);
}
}
else
{
/* 上报ID_EVT_TAF_PS_CALL_PDP_DEACTIVATE_IND事件 */
TAF_APS_SndPdpDeActivateInd(ucPdpId, TAF_PS_CAUSE_SM_NW_QOS_NOT_ACCEPTED);
/* 发送内部消息, 触发PDP去激活流程 */
TAF_APS_SndInterPdpDeactivateReq(ucPdpId, SM_TAF_CAUSE_SM_NW_QOS_NOT_ACCEPTED);
}
return VOS_TRUE;
}
VOS_VOID TAF_MMA_StartTimer(
TAF_MMA_TIMER_ID_ENUM_UINT32 enTimerId,
VOS_UINT32 ulLen
)
{
TAF_MMA_TIMER_CTX_STRU *pstMmaTimerCtx = VOS_NULL_PTR;
VOS_UINT32 i;
VOS_UINT32 ulRet;
if (0 == ulLen)
{
TAF_WARNING_LOG1(WUEPS_PID_MMA,"TAF_MMA_StartTimer:timer len is zero!", (VOS_INT32)enTimerId);
return;
}
if (ulLen >= VOS_TIMER_MAX_LENGTH)
{
ulLen = VOS_TIMER_MAX_LENGTH - 1;
}
pstMmaTimerCtx = TAF_MMA_GetTimerCtxAddr();
/* 如果缓存队列中该定时器已经启动则直接返回 */
for (i = 0 ; i < TAF_MMA_MAX_TIMER_NUM ; i++)
{
if ((TAF_MMA_TIMER_STATUS_RUNING == pstMmaTimerCtx[i].enTimerStatus)
&& (enTimerId == pstMmaTimerCtx[i].enTimerId))
{
TAF_WARNING_LOG1(WUEPS_PID_MMA,"TAF_MMA_StartTimer:timer is running!", (VOS_INT32)enTimerId);
return;
}
}
for (i = 0 ; i < TAF_MMA_MAX_TIMER_NUM ; i++)
{
if (TAF_MMA_TIMER_STATUS_STOP == pstMmaTimerCtx[i].enTimerStatus )
{
break;
}
}
if (i >= TAF_MMA_MAX_TIMER_NUM)
{
TAF_WARNING_LOG1(WUEPS_PID_MMA, "TAF_MMA_StartTimer:too many timer", (VOS_INT32)enTimerId);
return;
}
/* 启动定时器 */
ulRet = VOS_StartRelTimer(&(pstMmaTimerCtx[i].hTimer),
WUEPS_PID_MMA,
ulLen,
enTimerId,
0,
VOS_RELTIMER_NOLOOP,
VOS_TIMER_PRECISION_5);
if (VOS_OK != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_MMA,"TAF_MMA_StartTimer:VOS_StartRelTimer failed");
return;
}
pstMmaTimerCtx[i].enTimerId = enTimerId;
pstMmaTimerCtx[i].enTimerStatus = TAF_MMA_TIMER_STATUS_RUNING;
TAF_MMA_SndOmTimerStatus(TAF_MMA_TIMER_STATUS_RUNING, enTimerId, ulLen);
return;
}
VOS_UINT32 TAF_SPM_BuildUssdStringInfo(
TAF_SS_DATA_CODING_SCHEME ucDatacodingScheme,
TAF_SS_USSD_STRING_STRU *pstSrcUssd,
TAF_SS_USSD_STRING_STRU *pstDstUssd
)
{
VOS_UINT32 ulRslt;
MN_MSG_CBDCS_CODE_STRU stDcsInfo;
PS_MEM_SET(&stDcsInfo, 0, sizeof(stDcsInfo));
/* USSD与CBS的DCS的协议相同，调用CBS的DCS解析函数解码，详细情况参考23038 */
ulRslt = MN_MSG_DecodeCbsDcs(ucDatacodingScheme,
pstSrcUssd->aucUssdStr,
pstSrcUssd->usCnt,
&stDcsInfo);
if (MN_ERR_NO_ERROR != ulRslt)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo:WARNING: Decode Failure");
return VOS_FALSE;
}
if (MN_MSG_MSG_CODING_7_BIT == stDcsInfo.enMsgCoding)
{
PS_MEM_CPY(pstDstUssd, pstSrcUssd, sizeof(TAF_SS_USSD_STRING_STRU));
/* 非透传模式，编码方式为7bit时，上层是没有按7Bit压缩的，
仍然是ASCII，此处需要保证DCS指示的编码方式与实际内容的编码方式一致 */
if (TAF_SDC_USSD_NON_TRAN_MODE == TAF_SDC_GetUssdTransMode())
{
ulRslt = TAF_MmiEncodeUssdMessage(pstDstUssd);
if (VOS_FALSE == ulRslt)
{
TAF_NORMAL_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: SSA_EncodeUssdMessage encode failure");
return VOS_FALSE;
}
}
/* 透传模式，编码方式为7bit时，上层是按7Bit压缩的，但用户输入每一个USSD数字，
经过7Bit压缩后， 每个字节的高4bit和低4bit在此处是分别由一个Byte表示的，此处需要将两个byte还原为一个字节
例如用户要输入*199#,7bit压缩后为aa 58 2e 37 02，拆分后为61 61 35 38 32 65 33 37 30 32
*/
else
{
if (pstDstUssd->usCnt > TAF_SS_MAX_USSD_CHAR_HEX_FORMAT)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: String too Long failure");
return VOS_FALSE;
}
ulRslt = TAF_STD_AsciiNum2HexString(pstDstUssd->aucUssdStr, &pstDstUssd->usCnt);
if (VOS_FALSE == ulRslt)
{
TAF_NORMAL_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: TAF_AsciiNum2HexString encode failure");
return VOS_FALSE;
}
}
}
else
{
if (pstSrcUssd->usCnt > TAF_SS_MAX_USS_CHAR)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: String too Long failure");
return VOS_FALSE;
}
PS_MEM_CPY(pstDstUssd, pstSrcUssd, sizeof(TAF_SS_USSD_STRING_STRU));
}
return VOS_TRUE;
}
VOS_UINT32 TAF_SPM_SendUsimUssdEnvelopeReq(
VOS_UINT16 usClientId,
struct MsgCB *pstMsg
)
{
VOS_UINT8 aucLI[MN_MO_CTRL_LAI_LEN];
SI_STK_ENVELOPE_STRU stEnvelopeMsg;
VOS_UINT32 ulRet;
MN_APP_REQ_MSG_STRU *pstAppMsg = VOS_NULL_PTR;
TAF_SS_PROCESS_USS_REQ_STRU *pstUssdMsg = VOS_NULL_PTR;
TAF_SS_USSD_STRING_STRU *pstUssdInfo = VOS_NULL_PTR;
VOS_UINT8 aucCallCtrlUssdString[TAF_SPM_CALL_CTRL_USSD_STRING_LEN];
PS_MEM_SET(aucCallCtrlUssdString, 0, sizeof(aucCallCtrlUssdString));
pstUssdInfo = PS_MEM_ALLOC(WUEPS_PID_TAF, sizeof(TAF_SS_USSD_STRING_STRU));
if (VOS_NULL_PTR == pstUssdInfo)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimUssdEnvelopeReq: Fail to alloc memory for USSD string.");
return VOS_FALSE;
}
PS_MEM_SET(pstUssdInfo, 0, sizeof(TAF_SS_USSD_STRING_STRU));
pstAppMsg = (MN_APP_REQ_MSG_STRU *)pstMsg;
pstUssdMsg = (TAF_SS_PROCESS_USS_REQ_STRU *)pstAppMsg->aucContent;
aucCallCtrlUssdString[0] = pstUssdMsg->DatacodingScheme;
/* 转换用户请求中的USSD字符串为空口消息的USSD码流 */
ulRet = TAF_SPM_BuildUssdStringInfo(pstUssdMsg->DatacodingScheme,
&pstUssdMsg->UssdStr,
pstUssdInfo);
if (VOS_FALSE == ulRet)
{
PS_MEM_FREE(WUEPS_PID_TAF, pstUssdInfo);
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimUssdEnvelopeReq: Fail to TAF_SPM_BuildUssdStringInfo.");
return VOS_FALSE;
}
PS_MEM_CPY(&aucCallCtrlUssdString[TAF_SPM_SSC_OFFSET], pstUssdInfo->aucUssdStr, pstUssdInfo->usCnt);
/*
3GPP 1114:
9.1.6 Structure of ENVELOPE (CALL CONTROL)
Description Section M/O Min Length
Call control tag 13.1 M Y 1
Length (A+B+C+D+E+F) - M Y 1 or 2
Device identities 12.7 M Y A
Address or SS string or USSD string 12.1, M Y B
12.14
or 12.17
Location information 12.19 M N E
其中，
Location information 通过TAF_SDC_GetCurrentLai获取
Call control tag对应stEnvelopeMsg.EnvelopeType
Device identities对应stEnvelopeMsg.DeviceId
Address or SS string or USSD string这里是USSD string，参考协议1114 12.17
*/
PS_MEM_SET(&stEnvelopeMsg, 0, sizeof(SI_STK_ENVELOPE_STRU));
stEnvelopeMsg.EnvelopeType = SI_STK_ENVELOPE_CALLCRTL;
stEnvelopeMsg.DeviceId.ucSDId = SI_STK_DEV_TERMINAL;
stEnvelopeMsg.DeviceId.ucDDId = SI_STK_DEV_UICC;
/*
3GPP 1114:
12.17 USSD string
for USSD:
Byte(s) Description Length
1 USSD string tag 1
2 to (Y-1)+2 Length (X) Y
(Y-1)+3 Data coding scheme 1
(Y-1)+4 to (Y-1)+X+2 USSD string X-1
其中，
USSD string tag对应stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucTag
Length对应stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucLen
Data coding scheme和USSD string对应stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.pValue
*/
stEnvelopeMsg.uEnvelope.CallCtrl.OP_SepcialData = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucTag = SI_CC_USSD_TAG;
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucLen = (VOS_UINT8)(sizeof(pstUssdMsg->DatacodingScheme)
+ pstUssdInfo->usCnt);
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.pValue = (SI_UINT8 *)aucCallCtrlUssdString;
/* 获取ENVELOPE消息参数: 服务小区信息 */
stEnvelopeMsg.uEnvelope.CallCtrl.OP_LocInfo = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.LocInfo.pucATSLI = aucLI;
TAF_SDC_GetCurrentLai(aucLI, &stEnvelopeMsg.uEnvelope.CallCtrl.LocInfo.ulLen);
PS_MEM_FREE(WUEPS_PID_TAF, pstUssdInfo);
ulRet = NAS_STKAPI_EnvelopeDownload(WUEPS_PID_TAF, usClientId, &stEnvelopeMsg);
if (VOS_OK != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimUssdEnvelopeReq: Usim Returns Error.");
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_VOID TAF_CBA_ParseUsimFileEfCbmirData(
VOS_UINT8 ucEfCbmirExistFlg,
VOS_UINT8 *pucEf,
VOS_UINT16 usEfLen
)
{
TAF_CBA_USIM_EFCBMIR_FILE_INFO_STRU *pstEfCbmirFileInfo;
VOS_UINT32 ulLoop;
TAF_CBA_CBMI_RANGE_LIST_STRU *pstCbmirList;
VOS_UINT8 ucMsgIdHigh;
VOS_UINT8 ucMsgIdLow;
VOS_UINT16 usMsgId;
VOS_UINT8 *pucCbmirOct;
pstEfCbmirFileInfo = TAF_CBA_GetEfCbmiRangeInfo();
pstEfCbmirFileInfo->ucEfCbmirExistFlg = ucEfCbmirExistFlg;
if (VOS_FALSE == ucEfCbmirExistFlg)
{
return;
}
pstEfCbmirFileInfo->usEfCbmirFileLen = usEfLen;
/* 将USIM中CBMIR文件记录的ID集合填写临时内存中 */
pstCbmirList = (TAF_CBA_CBMI_RANGE_LIST_STRU *)PS_MEM_ALLOC(WUEPS_PID_TAF, sizeof(TAF_CBA_CBMI_RANGE_LIST_STRU));
if (VOS_NULL_PTR == pstCbmirList)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_CBA_ParseUsimFileEfCbmirData: Fail to Alloc memory.");
return;
}
/* 计算USIM EFCBMIR中CBMIR的个数 */
pstCbmirList->usCbmirNum = TAF_CBA_CountCbmirNum((VOS_UINT16 *)pucEf, usEfLen);
pucCbmirOct = pucEf;
/* 数据个数检查 */
if ( pstCbmirList->usCbmirNum >= TAF_CBA_MAX_CBMID_RANGE_NUM )
{
pstCbmirList->usCbmirNum = TAF_CBA_MAX_CBMID_RANGE_NUM;
}
for (ulLoop = 0; ulLoop < pstCbmirList->usCbmirNum; ulLoop++)
{
ucMsgIdHigh = *(pucCbmirOct);
pucCbmirOct++;
ucMsgIdLow = *(pucCbmirOct);
pucCbmirOct++;
usMsgId = (VOS_UINT16)( (ucMsgIdHigh << 8) | (ucMsgIdLow));
pstCbmirList->astCbmiRangeInfo[ulLoop].usMsgIdFrom = usMsgId;
ucMsgIdHigh = *(pucCbmirOct);
pucCbmirOct++;
ucMsgIdLow = *(pucCbmirOct);
pucCbmirOct++;
usMsgId = (VOS_UINT16)( (ucMsgIdHigh << 8) | (ucMsgIdLow));
pstCbmirList->astCbmiRangeInfo[ulLoop].usMsgIdTo = usMsgId;
pstCbmirList->astCbmiRangeInfo[ulLoop].enRcvMode = TAF_CBA_CBMI_RANGE_RCV_MODE_ACCEPT;
}
/* 先对range list排序 */
TAF_CBA_SortCbmiRangeList(pstCbmirList);
/* 更新内存中CBMIR的范围 */
TAF_CBA_AddCbMiRangeListToActiveList(pstCbmirList);
PS_MEM_FREE(WUEPS_PID_TAF, pstCbmirList);
}
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;
VOS_UINT32 ulGetCardImsiRslt;
ulGetCardImsiRslt = USIMM_API_RESULT_BUTT;
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;
}
ulGetCardImsiRslt = NAS_USIMMAPI_GetCardIMSI(aucMmaImsi);
if ( USIMM_API_SUCCESS != ulGetCardImsiRslt)
{
if (VOS_TRUE == TAF_SDC_IsImsiAvailableInCurrSimStatus(TAF_SDC_GetSimStatus()))
{
#if (FEATURE_ON == FEATURE_PTM)
/* 记录获取卡IMSI异常log */
TAF_SDC_GetCardImsiFailRecord(ulGetCardImsiRslt, aucMmaImsi);
#endif
}
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 )
{
(VOS_VOID)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!");
}
}
(VOS_VOID)MN_CALL_UpdateAlsLineInfo(stAlsInfo.enAlsLine,VOS_FALSE);
}
}
VOS_UINT32 TAF_SPM_TransUssdMsgToAsciiStr(
TAF_SS_PROCESS_USS_REQ_STRU *pstUssdMsg,
VOS_UINT8 *pucAsciiStr,
VOS_UINT32 *pulAsciiStrLength
)
{
VOS_UINT8 *pucUssdStr = VOS_NULL_PTR;
VOS_UINT8 *pucUssdTransTbl = VOS_NULL_PTR;
VOS_UINT8 aucUnpackUssdStr[TAF_SS_MAX_USSDSTRING_LEN];
VOS_UINT32 ulUssdStrLength;
VOS_UINT32 ulUnpackUssdStrLength;
VOS_UINT32 i;
VOS_UINT32 ulRet;
MN_MSG_CBDCS_CODE_STRU stDcsInfo;
PS_MEM_SET(&stDcsInfo, 0, sizeof(stDcsInfo));
ulRet = MN_MSG_DecodeCbsDcs(pstUssdMsg->DatacodingScheme,
pstUssdMsg->UssdStr.aucUssdStr,
pstUssdMsg->UssdStr.usCnt,
&stDcsInfo);
if (MN_ERR_NO_ERROR != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr:WARNING: Decode Failure");
return VOS_FALSE;
}
/*
非透传模式或非7BIT编码，TAF接收到的用户USSD字符串编码格式为ASCII码或UCS2码流，
不需要转换，直接拷贝到输出参数
*/
if ((TAF_SDC_USSD_TRAN_MODE != TAF_SDC_GetUssdTransMode())
|| (MN_MSG_MSG_CODING_7_BIT != stDcsInfo.enMsgCoding))
{
if (pstUssdMsg->UssdStr.usCnt > TAF_SS_MAX_USSDSTRING_LEN)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: USSD length overflow in none transparent mode.");
return VOS_FALSE;
}
*pulAsciiStrLength = pstUssdMsg->UssdStr.usCnt;
PS_MEM_CPY(pucAsciiStr, pstUssdMsg->UssdStr.aucUssdStr, *pulAsciiStrLength);
return VOS_TRUE;
}
/*
这段代码完成从7BIT压缩编码的数字字符串到ASCII码流的转换
透传模式并且DCS为7bit编码格式，用户输入每一个USSD数字，经过7Bit压缩后，
每个字节的高4bit和低4bit在此处是分别由一个Byte表示的
TAF接收到的用户USSD字符串就是2个字符表示一个数字，最大长度为320字符，
USSD空口码流容量为160BYTE，160BYTE 传输7BIT编码的字符，可以传输182个字符，
示例:
用户输入*199#的情况，应用接收到ASCII码流2A 31 39 39 23，进行7BIT编码后为
aa 58 2e 37 02，转换为数字字符串为61 61 35 38 32 65 33 37 30 32，通过AT命令
AT+CUSD=1,"61613538326533373032",15 AT透传"61613538326533373032"到TAF，所以
本函数输入: 61 61 35 38 32 65 33 37 30 32
本函数输出: ASCII码流为2A 31 39 39 23，长度为5
实现步骤:
1) TAF_AsciiNum2HexStr: 61 61 35 38 32 65 33 37 30 32 => aa 58 2e 37 02
2) MN_UnPack7Bit: aa 58 2e 37 02 => 2A 31 39 39 23
因为此处的ASCII码属于标准ASCII码，所以USSD的字符转换表对输出字符串无影响
16进制表示的USSD码流字符串转换为16进制表示的USSD码流
举例说明:
16进制表示的7BIT字符表压缩编码的USSD码流字符串 0x61 0x61 0x35 0x38 0x32 0x65 0x33 0x37 0x30 0x32
转换成
16进制表示的7BIT字符表压缩编码的码流 0xaa 0x58 0x2e 0x37 0x02
其中，0x61表示ASCII码的a 0x65表示ASCII码的e
*/
if (pstUssdMsg->UssdStr.usCnt > TAF_SS_MAX_USSD_CHAR_HEX_FORMAT)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: USSD length overflow in transparent mode.");
return VOS_FALSE;
}
pucUssdStr = (VOS_UINT8 *)PS_MEM_ALLOC(WUEPS_PID_TAF, TAF_SS_MAX_USSD_CHAR_HEX_FORMAT);
if (VOS_NULL_PTR == pucUssdStr)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: Fail to alloc memory.");
return VOS_FALSE;
}
PS_MEM_SET(pucUssdStr, 0, TAF_SS_MAX_USSD_CHAR_HEX_FORMAT);
ulUssdStrLength = pstUssdMsg->UssdStr.usCnt;
PS_MEM_CPY(pucUssdStr, pstUssdMsg->UssdStr.aucUssdStr, pstUssdMsg->UssdStr.usCnt);
ulRet = TAF_STD_AsciiNum2HexString(pucUssdStr, (VOS_UINT16 *)&ulUssdStrLength);
if (VOS_FALSE == ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: Fail to TAF_AsciiNum2HexString.");
PS_MEM_FREE(WUEPS_PID_TAF, pucUssdStr);
return VOS_FALSE;
}
/*
16进制表示的7BIT字符表压缩编码USSD码流转换成7BIT字符表非压缩编码USSD码流
举例说明:
16进制表示的7BIT字符表压缩编码USSD码流 0xaa 0x58 0x2e 0x37 0x02
转换成
7BIT字符表非压缩编码USSD码流 0x2A 0x31 0x39 0x39 0x23
*/
ulUnpackUssdStrLength = TAF_SPM_GetUssdStringSeptetLength(ulUssdStrLength,
*(pucUssdStr + ulUssdStrLength - 1));
PS_MEM_SET(aucUnpackUssdStr, 0, sizeof(aucUnpackUssdStr));
if (ulUssdStrLength > TAF_SS_MAX_USSDSTRING_LEN)
{
ulUssdStrLength = TAF_SS_MAX_USSDSTRING_LEN;
}
ulRet = TAF_STD_UnPack7Bit(pucUssdStr, ulUssdStrLength, 0, aucUnpackUssdStr);
if (VOS_OK != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr:TAF_STD_UnPack7Bit Err.");
}
PS_MEM_FREE(WUEPS_PID_TAF, pucUssdStr);
/*
7BIT字符表非压缩编码USSD码流转换成ASCII码字符表编码的码流
示例中不涉及7BIT字符表和ASCII码字符表存在差异的字符，所以无变化
*/
pucUssdTransTbl = TAF_SDC_GetCurr7BitToAsciiTableAddr();
for (i = 0; i < ulUnpackUssdStrLength; i++)
{
pucAsciiStr[i] = pucUssdTransTbl[aucUnpackUssdStr[i]];
}
return VOS_TRUE;
}
VOS_UINT32 TAF_APS_RcvEsmSmEpsBearerInfoInd_Inactive(
VOS_UINT32 ulEventType,
struct MsgCB *pstMsg
)
{
TAF_APS_EPS_BEARER_INFO_IND_STRU *pstBearerInfo;
APS_PDP_CONTEXT_ENTITY_ST *pstPdpEntity;
#if (FEATURE_ON == FEATURE_IPV6)
MMC_APS_RAT_TYPE_ENUM_UINT32 enCurrRatType;
#endif
VOS_UINT8 ucPdpId;
pstBearerInfo = (TAF_APS_EPS_BEARER_INFO_IND_STRU*)pstMsg;
#if (FEATURE_ON == FEATURE_IPV6)
/* 获取当前网络模式*/
enCurrRatType = TAF_APS_GetCurrPdpEntityRatType();
#endif
ucPdpId = TAF_APS_GetCurrFsmEntityPdpId();
/* 获取该PDPID的PDP实体内容地址 */
pstPdpEntity = TAF_APS_GetPdpEntInfoAddr(ucPdpId);
/* 根据EPS承载的操作类型(Activate, Deactivate, Modify),
调用相应的处理函数 */
if (SM_ESM_PDP_OPT_ACTIVATE == pstBearerInfo->enPdpOption)
{
MN_APS_ProcEsmBearerInfoIndOptActivate(pstPdpEntity, pstBearerInfo);
if (TAF_APS_DEFAULT_CID == TAF_APS_GetCidFromLteBitCid(pstBearerInfo->ulBitCid))
{
TAF_APS_SndInterAttachBearerActivateInd();
}
#if (FEATURE_ON == FEATURE_IMS)
/* 处理IMS专有承载 */
TAF_APS_ProcImsBearerInfoIndOptActivate(pstPdpEntity, pstBearerInfo);
#endif
#if (FEATURE_ON == FEATURE_IPV6)
/* 如果地址类型是IPv6, 需要同步给ND Client */
if ( (MMC_APS_RAT_TYPE_NULL != enCurrRatType)
&& (TAF_APS_CheckPrimaryPdp(ucPdpId))
&& (TAF_APS_CheckPdpAddrTypeIpv6(ucPdpId)) )
{
TAF_APS_SndNdPdpActInd(pstPdpEntity->ucNsapi,
pstPdpEntity->PdpAddr.aucIpV6Addr);
pstPdpEntity->ulNdClientActiveFlg = VOS_TRUE;
}
#endif
}
else
{
TAF_WARNING_LOG(WUEPS_PID_TAF,"TAF_APS_RcvEsmSmEpsBearerInfoInd_Inactive: Wrong option.");
}
/* 主状态迁移至TAF_APS_STA_ACTIVE */
TAF_APS_SetCurrPdpEntityMainFsmState(TAF_APS_STA_ACTIVE);
return VOS_TRUE;
}
VOS_UINT32 TAF_SPM_SendUsimCallEnvelopeReq(
MN_CALL_CALLED_NUM_STRU *pstCalledNumber,
MN_CALL_CS_DATA_CFG_INFO_STRU *pstDataCfgInfo,
VOS_UINT32 ulSendPara,
MN_CALL_TYPE_ENUM_U8 enCallType,
MN_CALL_MODE_ENUM_U8 enCallMode
)
{
VOS_UINT8 aucLI[MN_MO_CTRL_LAI_LEN];
VOS_UINT8 aucStkBcdNum[MN_CALL_MAX_CALLED_BCD_NUM_LEN + 1];
SI_STK_ENVELOPE_STRU stEnvelopeMsg;
NAS_CC_IE_BC_STRU stBc1;
NAS_CC_IE_BC_STRU stBc2;
MN_CALL_REP_IND_ENUM_U8 enBcRepeatInd;
VOS_UINT32 ulNumOfBc;
PS_MEM_SET(&stEnvelopeMsg, 0, sizeof(SI_STK_ENVELOPE_STRU));
stEnvelopeMsg.EnvelopeType = SI_STK_ENVELOPE_CALLCRTL;
stEnvelopeMsg.DeviceId.ucSDId = SI_STK_DEV_TERMINAL;
stEnvelopeMsg.DeviceId.ucDDId = SI_STK_DEV_UICC;
enBcRepeatInd = MN_CALL_REP_IND_NULL;
/* 根据呼叫类型, 呼叫模式和数据呼叫配置生成BC和Repeat Ind参数 */
PS_MEM_SET(&stBc1, 0, sizeof(NAS_CC_IE_BC_STRU));
PS_MEM_SET(&stBc2, 0, sizeof(NAS_CC_IE_BC_STRU));
ulNumOfBc = MN_CALL_BuildBcOfSetup(enCallType,
enCallMode,
pstDataCfgInfo,
&stBc1,
&stBc2);
if (0 == ulNumOfBc)
{
return VOS_FALSE;
}
if (TAF_CALL_MAX_BC_NUM == ulNumOfBc)
{
/* 有两个BC的情况下，repeat indicator设为alternate */
enBcRepeatInd = MN_CALL_REP_IND_ALTER;
}
else
{
/* 此处需要参考24.008 10.5.4.22 中的定义确认 */
enBcRepeatInd = MN_CALL_REP_IND_NULL;
}
stEnvelopeMsg.uEnvelope.CallCtrl.OP_Capability1 = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.Capability1.ulLen = stBc1.LastOctOffset;
stEnvelopeMsg.uEnvelope.CallCtrl.Capability1.pucCCP = (VOS_UINT8 *)&stBc1.Octet3;
if ((MN_CALL_REP_IND_NULL != enBcRepeatInd)
&& (0 != stBc2.IsExist))
{
stEnvelopeMsg.uEnvelope.CallCtrl.OP_Capability2 = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.OP_BCRepInd = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.Capability2.ulLen = stBc2.LastOctOffset;
stEnvelopeMsg.uEnvelope.CallCtrl.Capability2.pucCCP = (VOS_UINT8 *)&stBc2.Octet3;
}
stEnvelopeMsg.uEnvelope.CallCtrl.OP_SepcialData = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucTag = SI_CC_ADDRESS_TAG;
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucLen = pstCalledNumber->ucNumLen
+ sizeof(MN_CALL_NUM_TYPE_ENUM_U8);
PS_MEM_SET(aucStkBcdNum, 0, sizeof(aucStkBcdNum));
aucStkBcdNum[0] = pstCalledNumber->enNumType;
PS_MEM_CPY(&aucStkBcdNum[sizeof(pstCalledNumber->enNumType)],
pstCalledNumber->aucBcdNum,
pstCalledNumber->ucNumLen);
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.pValue = aucStkBcdNum;
stEnvelopeMsg.uEnvelope.CallCtrl.OP_LocInfo = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.LocInfo.pucATSLI = aucLI;
TAF_SDC_GetCurrentLai(aucLI, &stEnvelopeMsg.uEnvelope.CallCtrl.LocInfo.ulLen);
if (VOS_OK != NAS_STKAPI_EnvelopeDownload(WUEPS_PID_TAF, ulSendPara, &stEnvelopeMsg))
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimCallEnvelopeReq: Usim Returns Error.");
return VOS_FALSE;
}
return VOS_TRUE;
}
VOS_UINT32 TAF_SPM_SendUsimSsEnvelopeReq(
VOS_UINT16 usClientId,
struct MsgCB *pstMsg
)
{
VOS_UINT8 aucLI[MN_MO_CTRL_LAI_LEN];
VOS_UINT8 aucSsString[TAF_SPM_CALL_CTRL_SS_STRING_LEN];
VOS_UINT8 ucSscStringBcdLen;
SI_STK_ENVELOPE_STRU stEnvelopeMsg;
VOS_UINT32 ulRet;
VOS_CHAR *pcSscString = VOS_NULL_PTR;
MN_APP_REQ_MSG_STRU *pstAppReq = VOS_NULL_PTR;
MN_APP_SS_REGISTER_REQ_STRU *pstRegister = VOS_NULL_PTR;
VOS_UINT32 ulEventType;
MN_MMI_OPERATION_TYPE_ENUM_U8 enSsOpType;
pcSscString = (VOS_CHAR *)PS_MEM_ALLOC(WUEPS_PID_TAF, TAF_SPM_SSC_MAX_LEN);
if (VOS_NULL_PTR == pcSscString)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimSsEnvelopeReq: Fail to alloc memory for SS info.");
return VOS_FALSE;
}
PS_MEM_SET(pcSscString, 0, TAF_SPM_SSC_MAX_LEN);
/* 根据消息转换出SSC STRING */
ulRet = TAF_MmiEncodeMmiString(pstMsg, pcSscString);
if (VOS_TRUE != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimSsEnvelopeReq: Fail to Encode SSC string.");
PS_MEM_FREE(WUEPS_PID_TAF, pcSscString);
return VOS_FALSE;
}
/*
SS STRING的第一个字节是TON and NPI，从第二字节开始为SSC 的BCD编码
参考协议 11.11: 10.5.1 EFADN (Abbreviated dialling numbers)
TON and NPI
Contents:
Type of number (TON) and numbering plan identification (NPI).
Coding:
according to TS 04.08 [15]. If the Dialling Number/SSC String does not contain a dialling number,
e.g. a control string deactivating a service, the TON/NPI byte shall be set to 'FF' by the ME (see note 2).
NOTE 2: If a dialling number is absent, no TON/NPI byte is transmitted over the radio interface (see TS 04.08 [15]).
Accordingly, the ME should not interpret the value 'FF' and not send it over the radio interface.
*/
PS_MEM_SET(aucSsString, 0, TAF_SPM_CALL_CTRL_SS_STRING_LEN);
aucSsString[0] = TAF_SPM_NUM_TYPE_INVALID;
pstAppReq = (MN_APP_REQ_MSG_STRU *)pstMsg;
ulEventType = TAF_BuildEventType(pstAppReq->ulSenderPid, pstAppReq->usMsgName);
ulRet = TAF_MmiGetOperationType(ulEventType, &enSsOpType);
if ((VOS_TRUE == ulRet)
&& (TAF_MMI_REGISTER_SS == enSsOpType))
{
pstRegister = (MN_APP_SS_REGISTER_REQ_STRU *)pstMsg;
/* 仅呼叫转移有注册操作，呼叫转移注册操作必须有号码类型 */
aucSsString[0] = pstRegister->stTafSsRegisterSsReq.NumType;
}
ulRet = TAF_STD_ConvertAsciiNumberToBcd(pcSscString,
&aucSsString[TAF_SPM_SSC_OFFSET],
&ucSscStringBcdLen);
PS_MEM_FREE(WUEPS_PID_TAF, pcSscString);
if (MN_ERR_NO_ERROR != ulRet)
{
return VOS_FALSE;
}
PS_MEM_SET(&stEnvelopeMsg, 0, sizeof(SI_STK_ENVELOPE_STRU));
PS_MEM_SET(aucLI, 0, MN_MO_CTRL_LAI_LEN);
/*
3GPP 1114:
9.1.6 Structure of ENVELOPE (CALL CONTROL)
Description Section M/O Min Length
Call control tag 13.1 M Y 1
Length (A+B+C+D+E+F) - M Y 1 or 2
Device identities 12.7 M Y A
Address or SS string or USSD string 12.1, M Y B
12.14
or 12.17
Location information 12.19 M N E
其中，
Location information 通过TAF_SDC_GetCurrentLai获取
Call control tag对应stEnvelopeMsg.EnvelopeType
Device identities对应stEnvelopeMsg.DeviceId
Address or SS string or USSD string这里是SS string，参考协议1114 12.14
*/
stEnvelopeMsg.EnvelopeType = SI_STK_ENVELOPE_CALLCRTL;
stEnvelopeMsg.DeviceId.ucSDId = SI_STK_DEV_TERMINAL;
stEnvelopeMsg.DeviceId.ucDDId = SI_STK_DEV_UICC;
/*
12.14 SS string
SS or USSD string:
for SS:
Byte(s) Description Length
1 SS string tag 1
2 to (Y 1)+2 Length (X) Y
(Y 1)+3 TON and NPI 1
(Y 1)+4 to (Y 1)+X+2 SS or USSD string X - 1
其中，
SS string tag对应stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucTag
Length对应stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucLen
TON and NPI和SS string对应stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.pValue
*/
stEnvelopeMsg.uEnvelope.CallCtrl.OP_SepcialData = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucTag = SI_CC_SS_TAG;
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.ucLen = (VOS_UINT8)(ucSscStringBcdLen + TAF_SPM_SSC_OFFSET);
stEnvelopeMsg.uEnvelope.CallCtrl.SpecialData.pValue = aucSsString;
/* 获取ENVELOPE消息参数: 服务小区信息 */
stEnvelopeMsg.uEnvelope.CallCtrl.OP_LocInfo = VOS_TRUE;
stEnvelopeMsg.uEnvelope.CallCtrl.LocInfo.pucATSLI = aucLI;
TAF_SDC_GetCurrentLai(aucLI, &stEnvelopeMsg.uEnvelope.CallCtrl.LocInfo.ulLen);
ulRet = NAS_STKAPI_EnvelopeDownload(WUEPS_PID_TAF, usClientId, &stEnvelopeMsg);
if (VOS_OK != ulRet)
{
TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_SendUsimSsEnvelopeReq: Usim Returns Error.");
return VOS_FALSE;
}
return VOS_TRUE;
}