VOS_INT ADS_UL_CCpuResetCallback(
DRV_RESET_CALLCBFUN_MOMENT enParam,
VOS_INT iUserData
)
{
ADS_CCPU_RESET_IND_STRU *pstMsg = VOS_NULL_PTR;
/* 参数为0表示复位前调用 */
if (DRV_RESET_CALLCBFUN_RESET_BEFORE == enParam)
{
/* 构造消息 */
pstMsg = (ADS_CCPU_RESET_IND_STRU*)PS_ALLOC_MSG_WITH_HEADER_LEN(ACPU_PID_ADS_UL,
sizeof(ADS_CCPU_RESET_IND_STRU));
if (VOS_NULL_PTR == pstMsg)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_CCPU_RESET_IND_STRU: Malloc Msg Failed!\r\n");
return VOS_ERROR;
}
/* 填写消息头 */
pstMsg->ulReceiverPid = ACPU_PID_ADS_UL;
pstMsg->enMsgId = ID_ADS_CCPU_RESET_START_IND;
/* 发消息 */
if (VOS_OK != PS_SEND_MSG(ACPU_PID_ADS_UL, pstMsg))
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_CCpuResetCallback: Send Msg Failed!\r\n");
return VOS_ERROR;
}
/* 等待回复信号量初始为锁状态，等待消息处理完后信号量解锁。 */
if (VOS_OK != VOS_SmP(ADS_GetULResetSem(), ADS_RESET_TIMEOUT_LEN))
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_CCpuResetCallback: Lock Binary SEM Failed!\r\n");
ADS_UL_DBG_LOCK_BINARY_SEM_FAIL_NUM(1);
return VOS_ERROR;
}
return VOS_OK;
}
/* 复位后 */
else if (DRV_RESET_CALLCBFUN_RESET_AFTER == enParam)
{
ADS_UL_DBG_SAVE_CCPU_RESET_SUCCESS_NUM(1);
return VOS_OK;
}
else
{
return VOS_ERROR;
}
}
VOS_VOID ADS_FILTER_AddFilter(
ADS_FILTER_IPV4_INFO_STRU *pstFilter)
{
ADS_FILTER_NODE_STRU *pstNode = VOS_NULL_PTR;
HI_LIST_S *pstListHead = VOS_NULL_PTR;
VOS_UINT8 ucIndex;
/* 申请过滤表节点内存 */
pstNode = (ADS_FILTER_NODE_STRU *)ADS_FILTER_MALLOC(sizeof(ADS_FILTER_NODE_STRU));
if (VOS_NULL_PTR == pstNode)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_FILTER_AddFilter: Malloc Failed!");
return;
}
pstNode->stFilter = *pstFilter;
/* 获取标示信息对应的过滤表索引号 */
ucIndex = ADS_FILTER_GET_INDEX(pstFilter);
/* 通过索引号获取对应过滤链表的头结点 */
pstListHead = ADS_FILTER_GET_LIST(ucIndex);
/* 将节点增加到过滤表链表中 */
msp_list_add_tail(&pstNode->stList, pstListHead);
return;
}
VOS_VOID ADS_DL_StartAdqEmptyTimer(VOS_VOID)
{
ADS_TIMER_CTX_STRU *pstTiCtx;
VOS_TIMER_PRECISION_ENUM_UINT32 enTmrPrecision;
VOS_UINT32 ulRslt;
pstTiCtx = ADS_GetTiCtx();
/* 如果该定时器已经启动则直接返回 */
if (ADS_TIMER_STATUS_RUNNING == pstTiCtx[TI_ADS_DL_ADQ_EMPTY].enTimerStatus)
{
return;
}
enTmrPrecision = ADS_GetTimerPrecision(TI_ADS_DL_ADQ_EMPTY);
ulRslt = VOS_StartCallBackRelTimer(&(pstTiCtx[TI_ADS_DL_ADQ_EMPTY].hTimer),
ACPU_PID_ADS_DL,
TI_ADS_DL_ADQ_EMPTY_LEN,
TI_ADS_DL_ADQ_EMPTY,
0,
VOS_RELTIMER_NOLOOP,
ADS_DL_RcvTiAdqEmptyExpired,
enTmrPrecision);
if (VOS_OK != ulRslt)
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_StartAdqEmptyTimer:timer is fail start!");
return;
}
pstTiCtx[TI_ADS_DL_ADQ_EMPTY].enTimerStatus = ADS_TIMER_STATUS_RUNNING;
return;
}
VOS_VOID ADS_UL_RcvTiRptStatsInfoExpired(
VOS_UINT32 ulTimerName,
VOS_UINT32 ulParam
)
{
ADS_LOG_RPT_STATS_INFO_STRU *pstMsg = VOS_NULL_PTR;
/* 将记录的统计信息通过SDT消息勾出来 */
pstMsg = (ADS_LOG_RPT_STATS_INFO_STRU*)PS_MEM_ALLOC(ACPU_PID_ADS_UL, sizeof(ADS_LOG_RPT_STATS_INFO_STRU));
if (VOS_NULL_PTR == pstMsg)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_RcvTiRptStatsInfoExpired: ERROR:Alloc Mem Fail");
return;
}
PS_MEM_SET(pstMsg, 0, sizeof(ADS_LOG_RPT_STATS_INFO_STRU));
pstMsg->stLogHeader.ulReceiverCpuId = VOS_LOCAL_CPUID;
pstMsg->stLogHeader.ulSenderCpuId = VOS_LOCAL_CPUID;
pstMsg->stLogHeader.ulSenderPid = ACPU_PID_ADS_UL;
pstMsg->stLogHeader.ulReceiverPid = ACPU_PID_ADS_UL;
pstMsg->stLogHeader.ulLength = sizeof(ADS_LOG_RPT_STATS_INFO_STRU) - VOS_MSG_HEAD_LENGTH;;
pstMsg->stLogHeader.enMsgId = ID_ADS_LOG_RPT_STATS_INFO;
PS_MEM_CPY(&pstMsg->stAdsStats, &g_stAdsStats, sizeof(g_stAdsStats));
OM_AcpuTraceMsgHook(pstMsg);
PS_MEM_FREE(ACPU_PID_ADS_UL, pstMsg);
/* 重新启动上报统计信息定时器 */
ADS_StartTimer(ACPU_PID_ADS_UL, ulTimerName, TI_ADS_RPT_STATS_LEN);
return ;
}
VOS_VOID ADS_InitUlCtx(VOS_UINT8 ucInstanceIndex)
{
VOS_UINT32 i;
VOS_UINT32 ulRst;
ADS_SPEC_CTX_STRU *pstAdsSpecCtx = VOS_NULL_PTR;
pstAdsSpecCtx = &(g_stAdsCtx.astAdsSpecCtx[ucInstanceIndex]);
/* 默认从第一个队列开始调度 */
pstAdsSpecCtx->stAdsUlCtx.ucAdsUlCurIndex = 0;
for (i = 0; i < ADS_RAB_ID_MAX + 1; i++)
{
pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].pstAdsUlLink = VOS_NULL_PTR;
pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].ucIsQueueValid = VOS_FALSE;
pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].enPrio = ADS_QCI_TYPE_BUTT;
pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].usRecordNum = 0;
pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].enPktType = ADS_CDS_IPF_PKT_TYPE_IP;
/* 锁初始化 */
VOS_SpinLockInit(&(pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].stSpinLock));
pstAdsSpecCtx->stAdsUlCtx.astAdsUlQueue[i].ucRabSndPermitFlg = VOS_TRUE;
}
PS_MEM_SET(pstAdsSpecCtx->stAdsUlCtx.aucPrioIndex, 0, ADS_RAB_NUM_MAX);
/* 读NV，将优先级加权数读写到ADS上下文中 */
ulRst = NV_ReadEx(ucInstanceIndex,
en_NV_Item_ADS_Queue_Scheduler_Pri,
&(pstAdsSpecCtx->stAdsUlCtx.stQueuePriNv),
sizeof(ADS_UL_QUEUE_SCHEDULER_PRI_NV_STRU));
if(NV_OK != ulRst)
{
pstAdsSpecCtx->stAdsUlCtx.stQueuePriNv.ulStatus = VOS_FALSE;
for (i = 0; i < ADS_UL_QUEUE_SCHEDULER_PRI_MAX; i++)
{
pstAdsSpecCtx->stAdsUlCtx.stQueuePriNv.ausPriWeightedNum[i] = ADS_UL_DEFAULT_PRI_WEIGHTED_NUM;
}
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_InitUlCtx: NV read failed !");
}
if (VOS_FALSE == pstAdsSpecCtx->stAdsUlCtx.stQueuePriNv.ulStatus)
{
for (i = 0; i < ADS_UL_QUEUE_SCHEDULER_PRI_MAX; i++)
{
pstAdsSpecCtx->stAdsUlCtx.stQueuePriNv.ausPriWeightedNum[i] = ADS_UL_DEFAULT_PRI_WEIGHTED_NUM;
}
}
pstAdsSpecCtx->stAdsUlCtx.ucModemSndPermitFlg = VOS_TRUE;
#if(FEATURE_OFF == FEATURE_SKB_EXP)
pstAdsSpecCtx->stAdsUlCtx.ulUlMaxQueueLength = ADS_UL_MAX_QUEUE_LENGTH;
#endif
return;
}
VOS_VOID ADS_StartTimer(
VOS_UINT32 ulPid,
ADS_TIMER_ID_ENUM_UINT32 enTimerId,
VOS_UINT32 ulLen
)
{
VOS_UINT32 ulRet;
ADS_TIMER_CTX_STRU *pstTiCtx;
VOS_TIMER_PRECISION_ENUM_UINT32 enTmrPrecision;
/* 输入参数检查 */
if (0 == ulLen)
{
ADS_ERROR_LOG1(ACPU_PID_ADS_UL, "ADS_StartTimer:ulLen is",ulLen);
return;
}
if (ulLen >= VOS_TIMER_MAX_LENGTH)
{
ulLen = VOS_TIMER_MAX_LENGTH - 1;
}
/* 不在使用的定时器范围内 */
if (enTimerId >= ADS_MAX_TIMER_NUM)
{
return;
}
pstTiCtx = ADS_GetTiCtx();
if (ADS_TIMER_STATUS_RUNNING == pstTiCtx[enTimerId].enTimerStatus)
{
return;
}
enTmrPrecision = ADS_GetTimerPrecision(enTimerId);
ulRet = VOS_StartRelTimer(&(pstTiCtx[enTimerId].hTimer),
ulPid,
ulLen,
enTimerId,
0,
VOS_RELTIMER_NOLOOP,
enTmrPrecision);
if (VOS_OK != ulRet)
{
ADS_ERROR_LOG(ulPid, "ADS_StartTimer:timer is fail start!");
return;
}
pstTiCtx[enTimerId].enTimerStatus = ADS_TIMER_STATUS_RUNNING;
/*勾包ADS_TIMER_INFO_STRU*/
ADS_MNTN_TraceTimerOperation(ulPid, enTimerId, ulLen, ADS_TIMER_OPERATION_START, ADS_TIMER_STOP_CAUSE_ENUM_BUTT);
return;
}
VOS_UINT32 ADS_UL_CreateQueue(
VOS_UINT8 ucInstanceIndex,
VOS_UINT8 ucRabId,
ADS_QCI_TYPE_ENUM_UINT8 enPrio,
ADS_CDS_IPF_PKT_TYPE_ENUM_UINT8 enPktType
)
{
IMM_ZC_HEAD_STRU *pstUlQueue;
ADS_UL_CTX_STRU *pstAdsUlCtx;
pstAdsUlCtx = ADS_GetUlCtx(ucInstanceIndex);
/* RabId的队列已经存在 */
if (VOS_OK == ADS_UL_IsQueueExistent(ucInstanceIndex, ucRabId))
{
/* 对应的调度优先级也一样或者是比之前的要低，不更新QCI直接返回OK */
if (enPrio >= pstAdsUlCtx->astAdsUlQueue[ucRabId].enPrio)
{
return VOS_OK;
}
/* 如果对应的调度优先级比之前的要高，需要更新该PDP的队列优先级，并对队列管理进行排序 */
else
{
ADS_UL_UpdateQueueInPdpModified(ucInstanceIndex, enPrio, ucRabId);
return VOS_OK;
}
}
/* ucRabID的队列不存在, 需要创建队列头结点 */
pstUlQueue = (IMM_ZC_HEAD_STRU *)PS_MEM_ALLOC(ACPU_PID_ADS_UL, sizeof(IMM_ZC_HEAD_STRU));
if (VOS_NULL_PTR == pstUlQueue)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_CreateQueue: pstUlQueue is null");
return VOS_ERR;
}
/* 队列初始化 */
IMM_ZcQueueHeadInit(pstUlQueue);
/* 将队列信息更新到上行上下文 */
ADS_UL_SetQueue(ucInstanceIndex,
ucRabId,
VOS_TRUE,
pstUlQueue,
enPrio,
enPktType);
/* 队列不可能被用尽，一个RABID对应一个队列，而无效的已经在消息处理处屏蔽，
故不需要判断是否满，可以直接重新排序 */
ADS_UL_OrderQueueIndex(ucInstanceIndex, ucRabId);
/*lint -e429*/
return VOS_OK;
/*lint +e429*/
}
VOS_VOID ADS_UL_SendCdsStopSendDataRsp(
MODEM_ID_ENUM_UINT16 enModemId,
VOS_UINT8 ucRabId
)
{
VOS_UINT32 ulResult;
CDS_ADS_STOP_SENDDATA_RSP_STRU *pstStopSendDataRsp;
/* 申请消息 */
pstStopSendDataRsp = (CDS_ADS_STOP_SENDDATA_RSP_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
ACPU_PID_ADS_UL,
sizeof(CDS_ADS_STOP_SENDDATA_RSP_STRU));
/* 内存申请失败，返回 */
if( VOS_NULL_PTR == pstStopSendDataRsp )
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_SendCdsStopSendDataRsp: pstStopSendDataRsp is null!");
return;
}
PS_MEM_SET((VOS_INT8 *)pstStopSendDataRsp + VOS_MSG_HEAD_LENGTH,
0x00,
(VOS_SIZE_T)(sizeof(CDS_ADS_STOP_SENDDATA_RSP_STRU) - VOS_MSG_HEAD_LENGTH));
/*填写消息内容*/
pstStopSendDataRsp->ulReceiverPid = UEPS_PID_CDS;
pstStopSendDataRsp->enMsgId = ID_CDS_ADS_STOP_SENDDATA_RSP;
pstStopSendDataRsp->enModemId = enModemId;
pstStopSendDataRsp->ucRabId = ucRabId;
/* 调用VOS发送原语 */
ulResult = PS_SEND_MSG(ACPU_PID_ADS_UL, pstStopSendDataRsp);
if(VOS_OK != ulResult)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_SendCdsStopSendDataRsp: Send Msg Fail!");
}
return;
}
VOS_VOID ADS_InitIpfCtx(VOS_VOID)
{
VOS_UINT32 ulRst;
ADS_NV_DYNAMIC_THRESHOLD_STRU stThreshold;
ADS_UL_DYNAMIC_ASSEM_INFO_STRU *pstUlAssemParmInfo;
#if(FEATURE_OFF == FEATURE_SKB_EXP)
VOS_UINT8 i;
for (i = 0; i < ADS_DL_ADQ_MAX_NUM; i++)
{
PS_MEM_SET(g_stAdsCtx.stAdsIpfCtx.astIpfDlAdBuff[i], 0x00, (VOS_SIZE_T)(IPF_DLAD0_DESC_SIZE * sizeof(IPF_AD_DESC_S)));
}
/* 初始化上行源内存释放队列 */
IMM_ZcQueueHeadInit(&g_stAdsCtx.stAdsIpfCtx.stUlSrcMemFreeQue);
#endif
/* 初始化上行BD BUFF*/
PS_MEM_SET(g_stAdsCtx.stAdsIpfCtx.astIpfUlBdBuff, 0x00, (VOS_SIZE_T)(IPF_ULBD_DESC_SIZE * sizeof(IPF_CONFIG_ULPARAM_S)));
/* 初始化下行RD BUFF*/
PS_MEM_SET(g_stAdsCtx.stAdsIpfCtx.astIpfDlRdBuff, 0x00, (VOS_SIZE_T)(IPF_DLRD_DESC_SIZE * sizeof(IPF_RD_DESC_S)));
/* 默认上行数据发送保护定时器时长为10ms */
g_stAdsCtx.stAdsIpfCtx.ulProtectTmrLen = 10;
pstUlAssemParmInfo = &g_stAdsCtx.stAdsIpfCtx.stUlAssemParmInfo;
PS_MEM_SET(&stThreshold, 0x00, (VOS_SIZE_T)sizeof(ADS_NV_DYNAMIC_THRESHOLD_STRU));
ulRst = NV_ReadEx(MODEM_ID_0,
en_NV_Item_ADS_DYNAMIC_THRESHOLD_CFG,
&stThreshold,
sizeof(ADS_NV_DYNAMIC_THRESHOLD_STRU));
if(NV_OK != ulRst)
{
pstUlAssemParmInfo->ulActiveFlag = VOS_FALSE;
pstUlAssemParmInfo->ulProtectTmrExpCnt = 0;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel1 = 80;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel2 = 150;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel3 = 500;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel4 = 0xFFFFFFFF;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold1 = 1;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold2 = 13;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold3 = 60;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold4 = 64;
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_InitIpfCtx: NV read failed !");
}
pstUlAssemParmInfo->ulActiveFlag = stThreshold.ulActiveFlag;
pstUlAssemParmInfo->ulProtectTmrExpCnt = stThreshold.ulProtectTmrExpCnt;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel1 = stThreshold.stWaterMarkLevel.ulWaterLevel1;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel2 = stThreshold.stWaterMarkLevel.ulWaterLevel2;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel3 = stThreshold.stWaterMarkLevel.ulWaterLevel3;
pstUlAssemParmInfo->stWaterMarkLevel.ulWaterLevel4 = stThreshold.stWaterMarkLevel.ulWaterLevel4;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold1 = stThreshold.stThresholdLevel.ulThreshold1;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold2 = stThreshold.stThresholdLevel.ulThreshold2;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold3 = stThreshold.stThresholdLevel.ulThreshold3;
pstUlAssemParmInfo->stThresholdLevel.ulThreshold4 = stThreshold.stThresholdLevel.ulThreshold4;
/* 默认上行数据统计定时器时长为100ms */
pstUlAssemParmInfo->stThresholdStatInfo.ulStatTmrLen = 100;
pstUlAssemParmInfo->stThresholdStatInfo.ulStatPktNum = 0;
/* 超时时长大于零才需要启动jiffies保护定时器 */
if (0 != pstUlAssemParmInfo->ulProtectTmrExpCnt)
{
pstUlAssemParmInfo->ulProtectTmrCnt = ADS_GET_CURR_KERNEL_TIME();
}
/* 默认攒包的最大个数 */
if (VOS_TRUE == pstUlAssemParmInfo->ulActiveFlag)
{
g_stAdsCtx.stAdsIpfCtx.ulThredHoldNum = ADS_UL_DATA_THRESHOLD_ONE;
}
else
{
g_stAdsCtx.stAdsIpfCtx.ulThredHoldNum = 32;
}
/* 默认数据不在发送 */
g_stAdsCtx.stAdsIpfCtx.ucSendingFlg = VOS_FALSE;
}
VOS_VOID ADS_UL_ConfigBD(VOS_UINT32 ulBdNum)
{
VOS_UINT32 ulCnt;
VOS_INT32 lRslt;
VOS_UINT8 ucRabId;
IMM_ZC_STRU *pstImmZcNode;
IPF_CONFIG_ULPARAM_S *pstIpfConfigUlParam;
VOS_UINT8 ucInstanceIndex;
IMM_MEM_STRU *pstImmMemNode = VOS_NULL_PTR;
for (ulCnt = 0; ulCnt < ulBdNum; ulCnt++)
{
pstImmZcNode = ADS_UL_GetNextQueueNode(&ucRabId, &ucInstanceIndex);
if (VOS_NULL_PTR == pstImmZcNode)
{
break;
}
IPS_MNTN_TraceIpInfo(pstImmZcNode,ID_IPS_TRACE_IP_ADS_UL);
/* 把IMM_Zc零拷贝控制节点转换成IMM_Mem控制节点 */
pstImmMemNode = IMM_ZcMapToImmMem(pstImmZcNode);
if (VOS_NULL_PTR == pstImmMemNode)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_ConfigBD: IMM_ZcMapToImmMem return NULL!");
break;
}
/* 获取配置IPF的BD信息 */
pstIpfConfigUlParam = ADS_UL_GET_BD_CFG_PARA_PTR(ulCnt);
pstIpfConfigUlParam->u32Data = (VOS_UINT32)TTF_VIRT_TO_PHY((VOS_VOID *)pstImmZcNode->data);
/* 上行只过滤不搬移，源地址和目的地址相同 */
pstIpfConfigUlParam->u32DesAddr = pstIpfConfigUlParam->u32Data;
pstIpfConfigUlParam->u16Len = (VOS_UINT16)pstImmZcNode->len;
pstIpfConfigUlParam->u16UsrField1 = (VOS_UINT16)ADS_UL_BUILD_BD_USER_FIELD_1(ucInstanceIndex, ucRabId);
pstIpfConfigUlParam->u32UsrField2 = (VOS_UINT32)pstImmMemNode;
#if (FEATURE_ON == FEATURE_TTFMEM_CACHE)
ADS_CACHE_FLUSH(pstImmZcNode->data, pstIpfConfigUlParam->u16Len);
#endif
/* 释放SK_BUFF 头 */
IMM_ZcHeadFree(pstImmZcNode);
}
/* 实际从队列中取的数据个数如果为0，异常 */
if (0 == ulCnt)
{
return;
}
/* 配置BD、写入IPF */
lRslt = BSP_IPF_ConfigUpFilter(ulCnt,
ADS_UL_GET_BD_CFG_PARA_PTR(0),
BSP_TRUE);
if (IPF_SUCCESS != lRslt)
{
/* 写IPF失败的处理 */
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_ConfigBD: IPF CONFIG FAIL!");
ADS_UL_ProcIpfFailConfig(ulCnt, ADS_UL_GET_BD_CFG_PARA_PTR(0));
ADS_DBG_UL_SEND_PKT_FAIL_NUM(ulCnt);
return;
}
ADS_DBG_UL_SEND_BUFF_PKT_NUM(ulCnt);
/* 追踪上行发送数据 */
ADS_MNTN_TraceSndUlData();
return;
}
VOS_VOID ADS_UL_ConfigBD(VOS_UINT32 ulBdNum)
{
VOS_UINT32 ulCnt;
VOS_INT32 lRslt;
VOS_UINT8 ucRabId;
IMM_ZC_STRU *pstImmZcNode;
IPF_CONFIG_ULPARAM_S *pstIpfConfigUlParam;
VOS_UINT8 ucInstanceIndex;
VOS_UINT32 i;
#ifdef CONFIG_ARM64
struct device dev;
VOS_UINT64 dma_mask = 0xffffffffULL;
VOS_MemSet(&dev, 0, (VOS_SIZE_T)sizeof(dev));
dev.dma_mask = &(dma_mask);
#endif
for (ulCnt = 0; ulCnt < ulBdNum; ulCnt++)
{
pstImmZcNode = ADS_UL_GetNextQueueNode(&ucRabId, &ucInstanceIndex);
if (VOS_NULL_PTR == pstImmZcNode)
{
break;
}
IPS_MNTN_TraceIpInfo(pstImmZcNode,ID_IPS_TRACE_IP_ADS_UL);
/* 获取配置IPF的BD信息 */
pstIpfConfigUlParam = ADS_UL_GET_BD_CFG_PARA_PTR(ulCnt);
pstIpfConfigUlParam->u32Data = (VOS_UINT32)virt_to_phys((VOS_VOID *)pstImmZcNode->data);
pstIpfConfigUlParam->u16Len = (VOS_UINT16)pstImmZcNode->len;
pstIpfConfigUlParam->u16UsrField1 = (VOS_UINT16)ADS_UL_BUILD_BD_USER_FIELD_1(ucInstanceIndex, ucRabId);
pstIpfConfigUlParam->u32UsrField3 = (VOS_UINT)pstImmZcNode->tstamp.tv64;
/* ADS 上行数据打印开关 */
if (VOS_TRUE == g_ulAdsPrintUlDataFlg)
{
vos_printf("ADS_UL_ConfigBD: ucInstanceIndex is %d, ucRabId is %d, attribute is %d\r\n", ucInstanceIndex, ucRabId, pstIpfConfigUlParam->u16UsrField1);
vos_printf("ADS_UL_ConfigBD: Data Len is %d.\r\n", pstImmZcNode->len);
vos_printf("ADS_UL_ConfigBD: Data Content is :\r\n");
for (i = 0; i < pstImmZcNode->len; i++)
{
if (pstImmZcNode->data[i] > 0xf)
{
vos_printf("%x", pstImmZcNode->data[i]);
}
else
{
vos_printf("0%x", pstImmZcNode->data[i]);
}
}
vos_printf("\r\n");
}
/* Attribute: 中断使能，过滤加搬移，过滤器组号modem0用0，modem1用1 */
pstIpfConfigUlParam->u16Attribute = (VOS_UINT16)ADS_UL_BUILD_BD_ATTRIBUTE(VOS_FALSE, IPF_MODE_FILTERANDTRANS, ADS_UL_GET_BD_FC_HEAD(ucInstanceIndex));
/* 需要将数据写回DDR，IPF从DDR中读数据 */
#ifdef CONFIG_ARM64
ADS_CACHE_FLUSH_WITH_DEV(&dev, pstImmZcNode->data, pstIpfConfigUlParam->u16Len);
#else
ADS_CACHE_FLUSH(pstImmZcNode->data, pstIpfConfigUlParam->u16Len);
#endif
/* 将已配置的BD源内存保存到源内存队列 */
ADS_UL_SaveIpfUlSrcMem(pstImmZcNode);
}
/* 实际从队列中取的数据个数如果为0，异常 */
if (0 == ulCnt)
{
return;
}
/* 最后一个BD配置中断使能 */
pstIpfConfigUlParam = ADS_UL_GET_BD_CFG_PARA_PTR(0);
ADS_UL_SET_BD_ATTR_INT_FLAG(pstIpfConfigUlParam[ulCnt -1].u16Attribute);
/* 配置BD、写入IPF */
lRslt = BSP_IPF_ConfigUpFilter(ulCnt, ADS_UL_GET_BD_CFG_PARA_PTR(0));
if (IPF_SUCCESS != lRslt)
{
/* 写IPF失败的处理 */
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_ConfigBD: IPF CONFIG FAIL!");
/* IPF配置失败，需要释放源内存 */
ADS_UL_FreeIpfUlConfigFailSrcMem(ulCnt);
ADS_DBG_UL_SEND_PKT_FAIL_NUM(ulCnt);
return;
}
ADS_DBG_UL_SEND_BUFF_PKT_NUM(ulCnt);
/* 追踪上行发送数据 */
ADS_MNTN_TraceSndUlData();
return;
}
VOS_UINT32 ADS_UL_RcvCdsIpPacketMsg(MsgBlock *pMsg)
{
VOS_UINT32 ulResult;
ADS_NDIS_DATA_IND_STRU *pstAdsNdisDataInd;
IMM_ZC_STRU *pstZcData;
CDS_ADS_DATA_IND_STRU *pstDataInd;
VOS_CHAR *pstZcPutData;
pstDataInd = (CDS_ADS_DATA_IND_STRU *)pMsg;
/* 申请消息 */
pstAdsNdisDataInd = (ADS_NDIS_DATA_IND_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(
ACPU_PID_ADS_UL,
sizeof(ADS_NDIS_DATA_IND_STRU));
if (VOS_NULL_PTR == pstAdsNdisDataInd)
{
return VOS_ERR;
}
PS_MEM_SET((VOS_INT8 *)pstAdsNdisDataInd + VOS_MSG_HEAD_LENGTH,
0x00,
(VOS_SIZE_T)(sizeof(ADS_NDIS_DATA_IND_STRU) - VOS_MSG_HEAD_LENGTH));
/* 填写消息内容 */
pstAdsNdisDataInd->ulReceiverPid = PS_PID_APP_NDIS;
pstAdsNdisDataInd->enMsgId = ID_ADS_NDIS_DATA_IND;
pstAdsNdisDataInd->enModemId = pstDataInd->enModemId;
pstAdsNdisDataInd->ucRabId = pstDataInd->ucRabId;
pstAdsNdisDataInd->enIpPacketType = pstDataInd->enIpPacketType;
pstZcData = (IMM_ZC_STRU *)IMM_ZcStaticAlloc((VOS_UINT32)pstDataInd->usLen);
if (VOS_NULL_PTR == pstZcData)
{
PS_MEM_FREE(ACPU_PID_ADS_UL, pstAdsNdisDataInd);
return VOS_ERR;
}
/*此步骤不能少，用来偏移数据尾指针*/
pstZcPutData = (VOS_CHAR *)IMM_ZcPut(pstZcData, pstDataInd->usLen);
PS_MEM_CPY(pstZcPutData, pstDataInd->aucData, pstDataInd->usLen);
pstAdsNdisDataInd->pstSkBuff = pstZcData;
/* 调用VOS发送原语 */
ulResult = PS_SEND_MSG(ACPU_PID_ADS_UL, pstAdsNdisDataInd);
if(VOS_OK != ulResult)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_RcvCdsIpPacketMsg: Send Msg Fail!");
IMM_ZcFree(pstZcData);
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID ADS_DL_FidTask(
VOS_UINT32 ulQueueID,
VOS_UINT32 FID_value,
VOS_UINT32 Para1,
VOS_UINT32 Para2
)
{
MsgBlock *pMsg = VOS_NULL_PTR;
VOS_UINT32 ulEvent = 0;
VOS_UINT32 ulTaskID = 0;
VOS_UINT32 ulRtn = PS_FAIL;
VOS_UINT32 ulEventMask = 0;
VOS_UINT32 ulExpectEvent = 0;
ulTaskID = VOS_GetCurrentTaskID();
if (PS_NULL_UINT32 == ulTaskID)
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_FidTask: ERROR, TaskID is invalid.");
return;
}
if (VOS_OK != VOS_CreateEvent(ulTaskID))
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_FidTask: ERROR, create event fail.");
return;
}
g_ulAdsDLTaskId = ulTaskID;
g_ulAdsDLTaskReadyFlag = 1;
ulExpectEvent = ADS_DL_EVENT_IPF_RD_INT | ADS_DL_EVENT_IPF_ADQ_EMPTY_INT | VOS_MSG_SYNC_EVENT;
ulEventMask = (VOS_EVENT_ANY | VOS_EVENT_WAIT);
/*lint -e716*/
while (1)
/*lint +e716*/
{
ulRtn = VOS_EventRead(ulExpectEvent, ulEventMask, 0, &ulEvent);
if (VOS_OK != ulRtn)
{
ADS_ERROR_LOG(ACPU_PID_ADS_DL, "ADS_DL_FidTask: ERROR, read event error.");
continue;
}
/* 统计所有事件 */
ADS_DBG_DL_PROC_ALL_EVENT_NUM(1);
/*RD事件处理*/
if (VOS_MSG_SYNC_EVENT != ulEvent)
{
ADS_DL_ProcEvent(ulEvent);
#ifdef __PC_UT__
break;
#endif
continue;
}
pMsg = (MsgBlock*)VOS_GetMsg(ulTaskID);
if (VOS_NULL_PTR != pMsg)
{
if (ACPU_PID_ADS_DL == pMsg->ulReceiverPid)
{
ADS_DL_ProcMsg(pMsg);
}
PS_FREE_MSG(ACPU_PID_ADS_DL, pMsg);
}
else
{
/* 统计空事件 */
ADS_DBG_DL_PROC_EMPTY_EVENT_NUM(1);
}
}
}
VOS_VOID ADS_UL_FidTask(
VOS_UINT32 ulQueueID,
VOS_UINT32 FID_value,
VOS_UINT32 Para1,
VOS_UINT32 Para2
)
{
MsgBlock *pMsg = VOS_NULL_PTR;
VOS_UINT32 ulEvent = 0;
VOS_UINT32 ulTaskID = 0;
VOS_UINT32 ulRtn = VOS_ERR;
VOS_UINT32 ulEventMask = 0;
VOS_UINT32 ulExpectEvent = 0;
ulTaskID = VOS_GetCurrentTaskID();
if (PS_NULL_UINT32 == ulTaskID)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_FidTask: ERROR, TaskID is invalid.");
return;
}
if (VOS_OK != VOS_CreateEvent(ulTaskID))
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_FidTask: ERROR, create event fail.");
return;
}
g_ulAdsULTaskId = ulTaskID;
g_ulAdsULTaskReadyFlag = 1;
ulExpectEvent = ADS_UL_EVENT_DATA_PROC | VOS_MSG_SYNC_EVENT;
ulEventMask = (VOS_EVENT_ANY | VOS_EVENT_WAIT);
/*lint -e716*/
while (1)
/*lint +e716*/
{
ulRtn = VOS_EventRead(ulExpectEvent, ulEventMask, 0, &ulEvent);
if (VOS_OK != ulRtn)
{
ADS_ERROR_LOG(ACPU_PID_ADS_UL, "ADS_UL_FidTask: ERROR, read event error.");
continue;
}
/*事件处理*/
if (VOS_MSG_SYNC_EVENT != ulEvent)
{
ADS_UL_ProcEvent(ulEvent);
continue;
}
pMsg = (MsgBlock*)VOS_GetMsg(ulTaskID);
if (VOS_NULL_PTR != pMsg)
{
if (ACPU_PID_ADS_UL == pMsg->ulReceiverPid)
{
ADS_UL_ProcMsg(pMsg);
}
PS_FREE_MSG(ACPU_PID_ADS_UL, pMsg);
}
}
}
