VOS_INT __init DMS_NLK_Init(VOS_VOID)
{
struct sock *pstSock = VOS_NULL_PTR;
DMS_NLK_ENTITY_STRU *pstNlkEntity = VOS_NULL_PTR;
printk("DMS_NLK_Init entry,%u",VOS_GetSlice());
/* 初始化 netlink 实体 */
DMS_NLK_InitEntity();
/* 在内核态创建一个 netlink socket */
#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)) || (VOS_OS_VER == VOS_WIN32))
pstSock = netlink_kernel_create(&init_net, NETLINK_HW_LOGCAT, &g_stDmsNlkCfg);
#else
pstSock = netlink_kernel_create(&init_net, NETLINK_HW_LOGCAT, 0,
DMS_NLK_Input, NULL, THIS_MODULE);
#endif
if (VOS_NULL_PTR == pstSock)
{
printk(KERN_ERR "[%s][LINE: %d] Fail to create netlink socket.\n",
__func__, __LINE__);
DMS_DBG_NLK_CREATE_SOCK_FAIL_NUM(1);
return -ENOMEM;
}
/* 保存 socket */
pstNlkEntity = DMS_GET_NLK_ENTITY();
pstNlkEntity->pstSock = pstSock;
printk("DMS_NLK_Init exit,%u",VOS_GetSlice());
return 0;
}
VOS_UINT32 GU_OamSndPcMsgToCcpu(VOS_UINT8 *pucData, VOS_UINT32 ulSize)
{
VOS_INT32 lResult = VOS_ERROR;
lResult = DRV_UDI_WRITE(g_astOMACPUIccCtrlTable[OM_OM_ICC_CHANNEL].UDIHdle, pucData, ulSize);
/* 由于C核复位，写ICC通道失败会返回一个特殊值，不能复位单板 */
if (BSP_ERR_ICC_CCORE_RESETTING == lResult )
{
LogPrint1("\n# GU_OamSndPcMsgToCcpu Error,Ccore Reset,ulSize %d .\n",(VOS_INT)ulSize);
return VOS_ERR;
}
/* 当前写操作失败 */
if(ulSize != lResult)
{
LogPrint2("GU_OamSndPcMsgToCcpu: The ICC UDI Write is Error.Size:%d,lResult:%d\n",(VOS_INT)ulSize,lResult);
g_stAcpuPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrNum++;
g_stAcpuPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrLen += ulSize;
g_stAcpuPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrSlice= VOS_GetSlice();
return VOS_ERR;
}
g_stAcpuPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendMsgNum++;
g_stAcpuPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendLen += ulSize;
g_stAcpuPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendSlice= VOS_GetSlice();
return VOS_OK;
}
/*****************************************************************************
函 数 名 : GU_OamSndPcCmsMsg
功能描述 : 用于ACPU上面把PC侧数据通过ICC发送给CCPU OM模块
输入参数 : pucData: 需要发送的数据内容
ulDataLen: 数据长度
输出参数 : 无
返 回 值 : VOS_ERROR/VOS_OK
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2011年3月10日
作 者 : l46160
修改内容 : Creat Function
*****************************************************************************/
VOS_UINT32 GU_OamSndPcMsgToCcpu(OMRL_RCV_CHAN_CTRL_INFO_STRU *pstCtrlInfo, VOS_UINT8 *pucData, VOS_UINT32 ulSize)
{
VOS_INT32 lResult = VOS_ERROR;
lResult = DRV_ICC_WRITE(UDI_ICC_GUOM0, pucData, (VOS_INT32)ulSize);
/* 由于C核复位，写ICC通道失败会返回一个特殊值，不能复位单板 */
if (BSP_ERR_ICC_CCORE_RESETTING == lResult )
{
LogPrint1("\n# GU_OamSndPcMsgToCcpu Error,Ccore Reset,ulSize %d .\n",(VOS_INT)ulSize);
return VOS_ERR;
}
/* 当前写操作失败 */
if(ulSize != (VOS_UINT32)lResult)
{
LogPrint2("GU_OamSndPcMsgToCcpu: The ICC UDI Write is Error.Size:%d,lResult:%d\n",(VOS_INT)ulSize,lResult);
pstCtrlInfo->stPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrNum++;
pstCtrlInfo->stPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrLen += ulSize;
pstCtrlInfo->stPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrSlice= VOS_GetSlice();
return VOS_ERR;
}
pstCtrlInfo->stPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendMsgNum++;
pstCtrlInfo->stPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendLen += ulSize;
pstCtrlInfo->stPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendSlice= VOS_GetSlice();
return VOS_OK;
}
VOS_VOID ADS_ULFlowAdd(VOS_UINT8 ucIndex, VOS_UINT32 ulSduLen)
{
ADS_SPEC_STATS_INFO_STRU *pstAdsSpecStatsInfo;
if (PS_TRUE == g_stAdsStats.stUlComStatsInfo.ulULFlowDebugFlag)
{
pstAdsSpecStatsInfo = &(g_stAdsStats.astAdsSpecStatsInfo[ucIndex]);
/* 流量统计 */
pstAdsSpecStatsInfo->ulULFlowInfo += ulSduLen;
/* 流量统计上报 */
if (pstAdsSpecStatsInfo->ulULFlowInfo >= g_stAdsStats.stUlComStatsInfo.ulULFlowRptThreshold)
{
pstAdsSpecStatsInfo->ulULEndSlice = VOS_GetSlice();
vos_printf("ADS Index = %d, UL Flow Info = %10d, Pkt Num = %10d, Slice = %10d, Time = %10d\n",
ucIndex, pstAdsSpecStatsInfo->ulULFlowInfo,
pstAdsSpecStatsInfo->ulUlRecvPktNum, pstAdsSpecStatsInfo->ulULEndSlice,
(pstAdsSpecStatsInfo->ulULEndSlice - pstAdsSpecStatsInfo->ulULStartSlice));
pstAdsSpecStatsInfo->ulULStartSlice = pstAdsSpecStatsInfo->ulULEndSlice;
pstAdsSpecStatsInfo->ulULFlowInfo = 0;
}
}
return;
}
VOS_VOID OM_RecordInfoStart(VOS_EXC_DUMP_MEM_NUM_ENUM_UINT32 enNumber, VOS_UINT32 ulSendPid, VOS_UINT32 ulRcvPid, VOS_UINT32 ulMsgName)
{
OM_RECORD_INFO_STRU stRecordInfo;
if(VOS_EXC_DUMP_MEM_NUM_BUTT <= enNumber)
{
return;
}
if(VOS_NULL_PTR == g_astRecordInfo[enNumber].pucBuf)
{
return;
}
g_astRecordInfo[enNumber].ulLen %= VOS_TASK_DUMP_INFO_SIZE;
stRecordInfo.usSendPid = (VOS_UINT16)ulSendPid;
stRecordInfo.usRcvPid = (VOS_UINT16)ulRcvPid;
stRecordInfo.ulMsgName = ulMsgName;
stRecordInfo.ulSliceStart = VOS_GetSlice();
stRecordInfo.ulSliceEnd = 0;
/*lint -e534*/
VOS_MemCpy((g_astRecordInfo[enNumber].pucBuf + g_astRecordInfo[enNumber].ulLen),
&stRecordInfo, sizeof(OM_RECORD_INFO_STRU));
/*lint +e534*/
g_astRecordInfo[enNumber].ulLen += sizeof(OM_RECORD_INFO_STRU);
return;
}
VOS_VOID OM_RecordInfoEnd(VOS_EXC_DUMP_MEM_NUM_ENUM_UINT32 enNumber)
{
VOS_UINT32 *pulBuf;
if(VOS_EXC_DUMP_MEM_NUM_BUTT <= enNumber)
{
return;
}
if(VOS_NULL_PTR == g_astRecordInfo[enNumber].pucBuf)
{
return;
}
if(0 == g_astRecordInfo[enNumber].ulLen)
{
return;
}
/* 在start中已经变更了记录endslice的长度，因此此处回退四个字节填写endslice的值 */
pulBuf = (VOS_UINT32*)(g_astRecordInfo[enNumber].pucBuf + g_astRecordInfo[enNumber].ulLen - sizeof(VOS_UINT32));
*pulBuf = VOS_GetSlice();
return;
}
VOS_VOID MN_CALL_CsMtCallFailRecord(
NAS_ERR_LOG_CS_MT_CALL_CAUSE_ENUM_U32 enCause
)
{
NAS_ERR_LOG_CS_MT_CALL_FAIL_EVENT_STRU stCsMtCallFailEvt;
VOS_UINT32 ulLength;
VOS_UINT16 usLevel;
VOS_UINT32 ulIsLogRecord;
VOS_UINT32 ulResult;
/* 查询对应Alarm Id是否需要记录异常信息 */
usLevel = NAS_GetErrLogAlmLevel(NAS_ERR_LOG_ALM_CS_MT_CALL_FAIL);
ulIsLogRecord = TAF_SDC_IsErrLogNeedRecord(usLevel);
/* 模块异常不需要记录或异常原因值不需要记录时，不保存异常信息 */
if (VOS_FALSE == ulIsLogRecord)
{
return;
}
ulLength = sizeof(NAS_ERR_LOG_CS_MT_CALL_FAIL_EVENT_STRU);
/* 填充CS PAGING失败异常信息 */
PS_MEM_SET(&stCsMtCallFailEvt, 0x00, ulLength);
NAS_COMM_BULID_ERRLOG_HEADER_INFO(&stCsMtCallFailEvt.stHeader,
VOS_GetModemIDFromPid(WUEPS_PID_TAF),
NAS_ERR_LOG_ALM_CS_MT_CALL_FAIL,
usLevel,
VOS_GetSlice(),
(ulLength - sizeof(OM_ERR_LOG_HEADER_STRU)));
/* 获取当前位置信息 */
NAS_MNTN_OutputPositionInfo(&stCsMtCallFailEvt.stPositionInfo);
/* 填写错误原因值 */
stCsMtCallFailEvt.enCause = enCause;
/* 将CS MT CALL失败信息发送给ACPU OM模块 */
TAF_SndAcpuOmFaultErrLogInd(&stCsMtCallFailEvt, ulLength);
/*
将异常信息写入Buffer中
实际写入的字符数与需要写入的不等则打印异常
*/
ulResult = TAF_SDC_PutErrLogRingBuf((VOS_CHAR *)&stCsMtCallFailEvt, ulLength);
if (ulResult != ulLength)
{
NAS_ERROR_LOG(WUEPS_PID_TAF, "MN_CALL_SndAcpuOmCsMtCallFailInd(): Push buffer error.");
}
/* 可维可测勾包 */
NAS_COM_MntnPutRingbuf(NAS_ERR_LOG_ALM_CS_MT_CALL_FAIL,
WUEPS_PID_TAF,
(VOS_UINT8 *)&stCsMtCallFailEvt,
sizeof(stCsMtCallFailEvt));
return;
}
VOS_VOID MN_CALL_CsCallDiscInfoRecord(
MN_CALL_ID_T ucCallId,
NAS_ERR_LOG_CS_MT_CALL_CAUSE_ENUM_U32 enCause
)
{
NAS_ERR_LOG_PROCESS_INFO_IND_EVENT_STRU stProcInfoEvent;
VOS_UINT32 ulLength;
VOS_UINT16 usLevel;
VOS_UINT32 ulIsLogRecord;
VOS_UINT32 ulResult;
/* 查询对应Alarm Id是否需要记录异常信息 */
usLevel = NAS_GetErrLogAlmLevel(NAS_ERR_LOG_ALM_PORCESS_INFO_IND);
ulIsLogRecord = TAF_SDC_IsErrLogNeedRecord(usLevel);
/* 模块异常不需要记录或异常原因值不需要记录时，不保存异常信息 */
if (VOS_FALSE == ulIsLogRecord)
{
return;
}
ulLength = sizeof(NAS_ERR_LOG_PROCESS_INFO_IND_EVENT_STRU);
/* 填充过程信息 */
PS_MEM_SET(&stProcInfoEvent, 0x00, ulLength);
NAS_COMM_BULID_ERRLOG_HEADER_INFO(&stProcInfoEvent.stHeader,
VOS_GetModemIDFromPid(WUEPS_PID_TAF),
NAS_ERR_LOG_ALM_PORCESS_INFO_IND,
usLevel,
VOS_GetSlice(),
(ulLength - sizeof(OM_ERR_LOG_HEADER_STRU)));
stProcInfoEvent.enInfoType = NAS_ERR_LOG_PROCESS_INFO_TYPE_CS_CALL_DISC;
stProcInfoEvent.stDiscInfo.ucCallId = ucCallId;
stProcInfoEvent.stDiscInfo.ulCause = enCause;
/*
将异常信息写入Buffer中
实际写入的字符数与需要写入的不等则打印异常
*/
ulResult = TAF_SDC_PutErrLogRingBuf((VOS_CHAR *)&stProcInfoEvent, ulLength);
if (ulResult != ulLength)
{
NAS_ERROR_LOG(WUEPS_PID_TAF, "MN_CALL_CsCallDiscInfoRecord(): Push buffer error.");
}
/* 可维可测勾包 */
NAS_COM_MntnPutRingbuf(NAS_ERR_LOG_ALM_PORCESS_INFO_IND,
WUEPS_PID_TAF,
(VOS_UINT8 *)&stProcInfoEvent,
sizeof(stProcInfoEvent));
return;
}
VOS_INT __init DMS_InitPorCfgFile(VOS_VOID)
{
printk("DMS_InitPorCfgFile,entry,%u",VOS_GetSlice());
g_stDmsMainInfo.bPortCfgFlg = VOS_FALSE;
g_stDmsMainInfo.bPortOpenFlg = VOS_FALSE;
g_stDmsMainInfo.ulPortCfgValue = DMS_TEST_MODE;
/*lint -e960 */
if (VOS_NULL_PTR == proc_create("portcfg", DMS_VFILE_CRT_LEVEL, VOS_NULL_PTR, &g_stPortCfgOps))
{
DMS_LOG_ERROR("DMS_InitPorCfgFile: proc_create return NULL.\n");
return VOS_ERR;
}
/*lint +e960 */
printk("DMS_InitPorCfgFile,exit,%u",VOS_GetSlice());
return VOS_OK;
}
/*****************************************************************************
Function : V_IntUnlock
Description: Turn on the interrupt
Input : CPSR
Return : void;
Other : none
*****************************************************************************/
VOS_VOID V_IntUnlock(VOS_INT lLockKey)
{
g_stVosIntLockNestedInfo.ulSuffix--;
if ( VOS_NESTED_INTLOCK_MAX_NUM <= g_stVosIntLockNestedInfo.ulSuffix )
{
SRE_IntRestore((VOS_UINT32)lLockKey);
return;
}
if ( VOS_INTLOCK_MAX_INTERVAL <
(VOS_GetSlice() - g_stVosIntLockNestedInfo.astNestedInfo[g_stVosIntLockNestedInfo.ulSuffix].ulSlice) )
{
LogPrint2("# Info: intlock time too big.F %d L %d.\r\n",
(VOS_INT32)g_stVosIntLockNestedInfo.astNestedInfo[g_stVosIntLockNestedInfo.ulSuffix].ulFile,
(VOS_INT32)g_stVosIntLockNestedInfo.astNestedInfo[g_stVosIntLockNestedInfo.ulSuffix].lLine);
}
SRE_IntRestore((VOS_UINT32)lLockKey);
return;
}
VOS_VOID MN_CALL_CsCallErrRecord(
MN_CALL_ID_T ucCallId,
TAF_CS_CAUSE_ENUM_UINT32 enCause
)
{
NAS_ERR_LOG_CS_CALL_FAIL_EVENT_STRU stCsCallFailEvent;
MN_CALL_INFO_STRU stCallInfo;
VOS_UINT32 ulIsLogRecord;
VOS_UINT32 ulLength;
VOS_UINT32 ulResult;
VOS_UINT16 usLevel;
/* 查询对应Alarm Id是否需要记录异常信息 */
usLevel = NAS_GetErrLogAlmLevel(NAS_ERR_LOG_ALM_CS_CALL_FAIL);
ulIsLogRecord = TAF_SDC_IsErrLogNeedRecord(usLevel);
/* 不需要记录或没有异常时，不保存异常信息 */
if ((VOS_FALSE == ulIsLogRecord)
|| (TAF_CS_CAUSE_SUCCESS == enCause)
|| (TAF_CS_CAUSE_CC_NW_NORMAL_CALL_CLEARING == enCause))
{
return;
}
ulLength = sizeof(NAS_ERR_LOG_CS_CALL_FAIL_EVENT_STRU);
/* 填充Cs呼叫失败异常信息 */
PS_MEM_SET(&stCsCallFailEvent, 0x00, ulLength);
PS_MEM_SET(&stCallInfo, 0x00, sizeof(stCallInfo));
NAS_COMM_BULID_ERRLOG_HEADER_INFO(&stCsCallFailEvent.stHeader,
VOS_GetModemIDFromPid(WUEPS_PID_TAF),
NAS_ERR_LOG_ALM_CS_CALL_FAIL,
usLevel,
VOS_GetSlice(),
(ulLength - sizeof(OM_ERR_LOG_HEADER_STRU)));
stCsCallFailEvent.ulCcCause = enCause;
if (0 == ucCallId)
{
/* ucCallId为0说明为本地异常，无法在全局变量中获取信息 */
stCsCallFailEvent.ucCallId = ucCallId;
stCsCallFailEvent.enCallState = NAS_ERR_LOG_CALL_S_IDLE;
stCsCallFailEvent.stDiscDir.ucIsUser = VOS_TRUE;
}
else
{
MN_CALL_GetCallInfoByCallId(ucCallId, &stCallInfo);
stCsCallFailEvent.ucCallId = stCallInfo.callId;
stCsCallFailEvent.enCallState = stCallInfo.enCallState;
PS_MEM_CPY(&stCsCallFailEvent.stDiscDir, &stCallInfo.stDiscDir, sizeof(NAS_ERR_LOG_MN_CALL_DISC_DIR_STRU) );
}
/* 获取当前位置信息 */
NAS_MNTN_OutputPositionInfo(&stCsCallFailEvent.stPositionInfo);
/* 获取当前Usim信息 */
NAS_MMA_OutputUsimInfo(&stCsCallFailEvent.stUsimInfo);
stCsCallFailEvent.enRat = TAF_SDC_GetSysMode();
/*
将异常信息写入Buffer中
实际写入的字符数与需要写入的不等则打印异常
*/
ulResult = TAF_SDC_PutErrLogRingBuf((VOS_CHAR *)&stCsCallFailEvent, ulLength);
if (ulResult != ulLength)
{
NAS_ERROR_LOG(WUEPS_PID_TAF, "MN_CALL_CsCallErrRecord(): Push buffer error.");
}
NAS_COM_MntnPutRingbuf(NAS_ERR_LOG_ALM_CS_CALL_FAIL,
WUEPS_PID_TAF,
(VOS_UINT8 *)&stCsCallFailEvent,
sizeof(stCsCallFailEvent));
return;
}
VOS_UINT32 ADS_UL_InsertQueue(
VOS_UINT8 ucInstanceIndex,
IMM_ZC_STRU *pstData,
VOS_UINT8 ucRabId
)
{
VOS_UINT32 ulNonEmptyEvent;
VOS_UINT32 ulAllUlQueueDataNum;
#if(FEATURE_OFF == FEATURE_SKB_EXP)
VOS_UINT ulQueueLen;
#endif
VOS_ULONG ulLockLevel;
ulNonEmptyEvent = VOS_FALSE;
/* 此接口不释放pstData，由上层模块根据函数返回值判断是否需要释放内存 */
/* 判断RabId是否为有效值 */
if (VOS_OK != ADS_IsValidRabId(ucRabId))
{
ADS_WARNING_LOG1(ACPU_PID_ADS_UL, "ADS_UL_InsertQueue: ucRabId is", ucRabId);
return VOS_ERR;
}
/* 队列加锁 */
/*lint -e571*/
VOS_SpinLockIntLock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
/*lint +e571*/
/* 结点存在，但队列不存在 */
if (VOS_OK != ADS_UL_IsQueueExistent(ucInstanceIndex, ucRabId))
{
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
ADS_WARNING_LOG(ACPU_PID_ADS_UL, "ADS_UL_InsertQueue:the queue is not ext!");
return VOS_ERR;
}
#if(FEATURE_OFF == FEATURE_SKB_EXP)
ulQueueLen = IMM_ZcQueueLen(ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId));
if (ulQueueLen >= ADS_UL_GET_MAX_QUEUE_LENGTH(ucInstanceIndex))
{
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
ADS_DBG_UL_DROPPED_PACKET_NUM(1);
return VOS_ERR;
}
/* 插入队列前将数据打上时间戳 */
pstData->tstamp.tv64 = (VOS_INT64)VOS_GetSlice();
#endif
/* 插入队列 */
IMM_ZcQueueTail(ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId), pstData);
/* 队列由空变为非空 */
if (1 == IMM_ZcQueueLen(ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId)))
{
ulNonEmptyEvent = VOS_TRUE;
}
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
ulAllUlQueueDataNum = ADS_UL_GetAllQueueDataNum();
#if(FEATURE_OFF == FEATURE_SKB_EXP)
if (VOS_TRUE == ADS_UL_GET_THRESHOLD_ACTIVE_FLAG())
{
/* (1).jiffies超时,则直接触发发数,并停止发数定时器
(2).队列中数据已到攒包门限且当前没有在处理数据,触发上行缓存缓存处理事件
(3).队列由空变为非空时启动数据统计定时器以及保护定时器
*/
ADS_UL_ADD_STAT_PKT_NUM(1);
/* 超时长度为非零则需要启动触发发数 */
if (0 != ADS_UL_GET_JIFFIES_EXP_TMR_LEN())
{
if (ADS_TIME_AFTER_EQ(ADS_GET_CURR_KERNEL_TIME(),
(ADS_UL_GET_JIFFIES_TMR_CNT() + ADS_UL_GET_JIFFIES_EXP_TMR_LEN())))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
ADS_StopTimer(ACPU_PID_ADS_UL, TI_ADS_UL_SEND, ADS_TIMER_STOP_CAUSE_USER);
ADS_UL_SET_JIFFIES_TMR_CNT(ADS_GET_CURR_KERNEL_TIME());
return VOS_OK;
}
}
if (ADS_UL_IS_REACH_THRESHOLD_DYNAMIC(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG()))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
/* 队列由空变为非空 */
if (VOS_TRUE == ulNonEmptyEvent)
{
ADS_StartTimer(ACPU_PID_ADS_UL, TI_ADS_UL_DATA_STAT, ADS_UL_GET_STAT_TIMER_LEN());
ADS_StartTimer(ACPU_PID_ADS_UL, TI_ADS_UL_SEND, ADS_UL_GET_PROTECT_TIMER_LEN());
}
}
else
{
/* (1).队列由空变为非空时触发上行缓存处理事件
(2).队列中数据已到攒包门限的整数倍且当前没有在处理数据
触发上行缓存缓存处理事件
*/
if (VOS_TRUE == ulNonEmptyEvent)
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
else
{
if (ADS_UL_IS_REACH_THRESHOLD(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG()))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
}
}
#else
/* (1).从TCP/IP协议栈过来的的数据，ucTailPktInd为0.
当队列由空到非空,
或是达到攒包门限且当前没有在数据处理时触发上行缓存处理事件.
(2).USB过来的数据非最后一个包ucTailPktInd为2，最后一个包ucTailPktInd为1
当为最后一个IP包,
或是达到攒包门限且当前没有在数据处理时触发上行缓存处理事件.
*/
if (0 == pstData->private_mem.ucTailPktInd)
{
if ((VOS_TRUE == ulNonEmptyEvent)
|| (ADS_UL_IS_REACH_THRESHOLD(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG())))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
}
else
{
if ((1 == pstData->private_mem.ucTailPktInd)
|| (ADS_UL_IS_REACH_THRESHOLD(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG())))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
}
#endif
return VOS_OK;
}
VOS_VOID MN_MSG_FailErrRecord(TAF_MSG_ERROR_ENUM_UINT32 enErrorCode)
{
NAS_ERR_LOG_SMS_MO_FAIL_EVENT_STRU stSmsMoFailEvent;
MN_MSG_SEND_DOMAIN_ENUM_U8 enAvailableSendDomain;
VOS_UINT32 ulIsLogRecord;
VOS_UINT32 ulLength;
VOS_UINT32 ulResult;
VOS_UINT16 usLevel;
/* 查询对应Alarm Id是否需要记录异常信息 */
usLevel = NAS_GetErrLogAlmLevel(NAS_ERR_LOG_ALM_SMS_FAIL);
ulIsLogRecord = TAF_SDC_IsErrLogNeedRecord(usLevel);
/* 不需要记录时，不保存异常信息 */
if (VOS_FALSE == ulIsLogRecord)
{
return;
}
ulLength = sizeof(NAS_ERR_LOG_SMS_MO_FAIL_EVENT_STRU);
/* 填写短信发送失败事件信息 */
PS_MEM_SET(&stSmsMoFailEvent, 0x00, ulLength);
NAS_COMM_BULID_ERRLOG_HEADER_INFO(&stSmsMoFailEvent.stHeader,
VOS_GetModemIDFromPid(WUEPS_PID_TAF),
NAS_ERR_LOG_ALM_SMS_FAIL,
usLevel,
VOS_GetSlice(),
(ulLength - sizeof(OM_ERR_LOG_HEADER_STRU)));
/* 获取卡状态信息 */
NAS_MMA_OutputUsimInfo(&stSmsMoFailEvent.stUsimInfo);
/* 获取位置信息 */
NAS_MNTN_OutputPositionInfo(&stSmsMoFailEvent.stPositionInfo);
MN_MSG_OutputSmsMoFailureInfo(enErrorCode, &stSmsMoFailEvent.stMoFail);
MN_MSG_GetCurSendDomain(MN_MSG_SEND_DOMAIN_PS, &enAvailableSendDomain);
if (MN_MSG_SEND_DOMAIN_PS == enAvailableSendDomain)
{
stSmsMoFailEvent.enPsStatus = NAS_MNTN_SEND_DOMAIN_STATUS_AVAILABLE;
}
else
{
stSmsMoFailEvent.enPsStatus = NAS_MNTN_SEND_DOMAIN_STATUS_UNAVAILABLE;
}
MN_MSG_GetCurSendDomain(MN_MSG_SEND_DOMAIN_CS, &enAvailableSendDomain);
if (MN_MSG_SEND_DOMAIN_CS == enAvailableSendDomain)
{
stSmsMoFailEvent.enCsStatus = NAS_MNTN_SEND_DOMAIN_STATUS_AVAILABLE;
}
else
{
stSmsMoFailEvent.enCsStatus = NAS_MNTN_SEND_DOMAIN_STATUS_UNAVAILABLE;
}
/*
将异常信息写入Buffer中
实际写入的字符数与需要写入的不等则打印异常
*/
ulResult = TAF_SDC_PutErrLogRingBuf((VOS_CHAR *)&stSmsMoFailEvent, ulLength);
if (ulResult != ulLength)
{
NAS_ERROR_LOG(WUEPS_PID_TAF, "MN_MSG_FailErrRecord(): Push buffer error.");
}
NAS_COM_MntnPutRingbuf(NAS_ERR_LOG_ALM_SMS_FAIL,
WUEPS_PID_TAF,
(VOS_UINT8 *)&stSmsMoFailEvent,
sizeof(stSmsMoFailEvent));
return;
}
VOS_VOID WTTF_MNTN_ErrlogRlcLiErrEvt(VOS_UINT8 ucRbId,
TTF_MNTN_ERR_LOG_LI_ERR_TYPE_ENUM8 enLiErrType)
{
VOS_UINT8 ucAlmLev;
MODEM_ID_ENUM_UINT16 enModemId;
if (ucRbId > UTRAN_MAX_RB_ID)
{
PS_LOG1(WUEPS_PID_RLC, 0, PS_PRINT_WARNING,
"WTTF_MNTN_ErrlogRlcLiErrEvt, ucRbId exceed the range.", ucRbId);
return;
}
/* check need th record the Li error number */
ucAlmLev = TTF_ERR_LOG_GET_ALM_LEV(TTF_ERR_LOG_ALM_ID_WRLC_LI_ERR);
enModemId = VOS_GetModemIDFromPid(WUEPS_PID_RLC);
if (!TTF_ERR_LOG_NEED_RPT_LEV(enModemId, ucAlmLev))
{
return;
}
if (0 == g_stErrLogLiErrCtx.ucLiErrRbCnt)
{
/* register the Li error callback function */
TTF_MNTN_ErrlogCbReg(WUEPS_PID_RLC, WTTF_MNTN_ErrlogFlushRlcErrEvt);
}
if (0 == g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.ulLiErrCnt)
{
/* if ucLiErrRbCnt is full,but the rb is avaible, the g_stErrLogLiErrCtx is fail */
if (g_stErrLogLiErrCtx.ucLiErrRbCnt >= UTRAN_MAX_RB_NUM)
{
PS_MEM_SET(&g_stErrLogLiErrCtx, 0 ,sizeof(TTF_MNTN_ERR_LOG_WRLC_LI_ERR_CTX_STRU));
PS_LOG1(WUEPS_PID_RLC, 0, PS_PRINT_WARNING,
"WTTF_MNTN_ErrlogRlcLiErrEvt, g_stErrLogLiErrCtx.ucLiErrRbCnt exceed the range.",
g_stErrLogLiErrCtx.ucLiErrRbCnt);
return;
}
g_stErrLogLiErrCtx.aucLiErrRbs[g_stErrLogLiErrCtx.ucLiErrRbCnt] = ucRbId;
g_stErrLogLiErrCtx.ucLiErrRbCnt ++;
TTF_ERR_LOG_FILL_HEADER(
&g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stHeader,
enModemId,
TTF_ERR_LOG_ALM_ID_WRLC_LI_ERR,
ucAlmLev,
(sizeof(TTF_MNTN_ERR_LOG_WRLC_LI_ERR_STRU) - sizeof(OM_ERR_LOG_HEADER_STRU)));
g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.ulLstUpdtTs = 0;
g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.ulLiErrCnt = 1;
g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.ucRbId = ucRbId;
TTF_ERR_LOG_ENT_UPDT_BUF_RSV_LEN(VOS_GetModemIDFromPid(WUEPS_PID_RLC), sizeof(TTF_MNTN_ERR_LOG_WRLC_LI_ERR_STRU));
}
else
{
g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.ulLstUpdtTs = VOS_GetSlice();
g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.ulLiErrCnt ++;
}
g_stErrLogLiErrCtx.astWrlcLiErrInfo[ucRbId].stLiErrInfo.enType = enLiErrType;
return;
}
/*****************************************************************************
Function : V_IntLock
Description: Turn off the interrupt
Input : file line
Return : CPSR;
Other : none
*****************************************************************************/
VOS_INT V_IntLock(VOS_UINT32 ulFileID, VOS_INT32 lLineNo)
{
VOS_INT lFlag;
lFlag = intLock();
if ( VOS_NESTED_INTLOCK_MAX_NUM <= g_stVosIntLockNestedInfo.ulSuffix )
{
g_stVosIntLockNestedInfo.ulSuffix++;
LogPrint2("# Info: intlock nested too big.F %d L %d.\r\n", (VOS_INT32)ulFileID, (VOS_INT32)lLineNo);
return lFlag;
}
g_stVosIntLockNestedInfo.astNestedInfo[g_stVosIntLockNestedInfo.ulSuffix].ulFile = ulFileID;
g_stVosIntLockNestedInfo.astNestedInfo[g_stVosIntLockNestedInfo.ulSuffix].lLine = lLineNo;
g_stVosIntLockNestedInfo.astNestedInfo[g_stVosIntLockNestedInfo.ulSuffix].ulSlice = VOS_GetSlice();
g_stVosIntLockNestedInfo.ulSuffix++;
return lFlag;
}
VOS_UINT32 ADS_UL_InsertQueue(
VOS_UINT8 ucInstanceIndex,
IMM_ZC_STRU *pstData,
VOS_UINT8 ucRabId
)
{
VOS_UINT32 ulNonEmptyEvent;
VOS_UINT32 ulAllUlQueueDataNum;
#if(FEATURE_OFF == FEATURE_SKB_EXP)
VOS_UINT ulQueueLen;
#endif
VOS_UINT32 ulLockLevel;
ulLockLevel = 0;
ulNonEmptyEvent = VOS_FALSE;
/* 此接口不释放pstData，由上层模块根据函数返回值判断是否需要释放内存 */
/* 判断RabId是否为有效值 */
if (VOS_OK != ADS_IsValidRabId(ucRabId))
{
ADS_WARNING_LOG1(ACPU_PID_ADS_UL, "ADS_UL_InsertQueue: ucRabId is", ucRabId);
return VOS_ERR;
}
/* 队列加锁 */
VOS_SpinLockIntLock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
/* 结点存在，但队列不存在 */
if (VOS_OK != ADS_UL_IsQueueExistent(ucInstanceIndex, ucRabId))
{
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
ADS_WARNING_LOG(ACPU_PID_ADS_UL, "ADS_UL_InsertQueue:the queue is not ext!");
return VOS_ERR;
}
#if(FEATURE_OFF == FEATURE_SKB_EXP)
ulQueueLen = IMM_ZcQueueLen(ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId));
if (ulQueueLen >= ADS_UL_GET_MAX_QUEUE_LENGTH(ucInstanceIndex))
{
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
ADS_DBG_UL_DROPPED_PACKET_NUM(1);
return VOS_ERR;
}
/* 插入队列前将数据打上时间戳 */
pstData->tstamp.tv64 = (VOS_INT64)VOS_GetSlice();
#endif
/* 插入队列 */
IMM_ZcQueueTail(ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId), pstData);
/* 队列由空变为非空 */
if (1 == IMM_ZcQueueLen(ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId)))
{
ulNonEmptyEvent = VOS_TRUE;
}
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
ulAllUlQueueDataNum = ADS_UL_GetAllQueueDataNum();
#if(FEATURE_OFF == FEATURE_SKB_EXP)
/* (1).队列由空变为非空时触发上行缓存处理事件
(2).队列中数据已到攒包门限的整数倍且当前没有在处理数据
触发上行缓存缓存处理事件
*/
/* 队列由空变为非空 */
if (VOS_TRUE == ulNonEmptyEvent)
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
else
{
if (ADS_UL_IS_REACH_THRESHOLD(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG()))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
}
#else
/* (1).从TCP/IP协议栈过来的的数据，ucTailPktInd为0.
当队列由空到非空,
或是达到攒包门限且当前没有在数据处理时触发上行缓存处理事件.
(2).USB过来的数据非最后一个包ucTailPktInd为2，最后一个包ucTailPktInd为1
当为最后一个IP包,
或是达到攒包门限且当前没有在数据处理时触发上行缓存处理事件.
*/
if (0 == pstData->private_mem.ucTailPktInd)
{
if ((VOS_TRUE == ulNonEmptyEvent)
|| (ADS_UL_IS_REACH_THRESHOLD(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG())))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
}
else
{
if ((1 == pstData->private_mem.ucTailPktInd)
|| (ADS_UL_IS_REACH_THRESHOLD(ulAllUlQueueDataNum, ADS_UL_GET_SENDING_FLAG())))
{
ADS_UL_SndEvent(ADS_UL_EVENT_DATA_PROC);
}
}
#endif
return VOS_OK;
}
VOS_VOID TTF_MNTN_ErrlogBufRpt(VOS_UINT32 ulSenderPid, VOS_UINT32 ulReceiverPid, MODEM_ID_ENUM_UINT16 enModemId)
{
VOS_UINT32 ulRslt;
VOS_UINT32 ulBufSize;
VOS_UINT32 ulMsgLen;
OM_RING_ID pRingId;
VOS_UINT32 ulCpuID;
OM_ERR_LOG_REPORT_CNF_STRU *pstLogRpt;
if (enModemId >= MODEM_ID_BUTT)
{
PS_LOG1(ulSenderPid, 0, PS_PRINT_ERROR,
"TTF_MNTN_ErrlogBufRpt: enModemId Invalid!", enModemId);
return;
}
ulCpuID = VOS_GET_CPU_ID(ulReceiverPid);
if ( ulCpuID >= VOS_SUPPORT_CPU_NUM_MAX )
{
PS_LOG1(ulSenderPid, 0, PS_PRINT_ERROR,
"TTF_MNTN_ErrlogBufRpt: ulReceiverPid Invalid!", (VOS_INT32)ulReceiverPid);
return;
}
pRingId = TTF_ERR_LOG_ENT_RINGID_GET(enModemId);
/* Default没有异常 */
ulBufSize = 0;
if (VOS_NULL_PTR != pRingId)
{
/* 保留的长度复位 */
TTF_ERR_LOG_ENT_RST_BUF_RSV_LEN(enModemId);
/* 将各模块本地缓存的数据写入Buffer */
TTF_MNTN_ErrlogCbRun(enModemId);
ulRslt = VOS_SmP(TTF_ERR_LOG_ENT_SEM_GET(enModemId), TTF_ERR_SEM_TIMEOUT_LEN);
if(VOS_OK != ulRslt)
{
PS_LOG2(ulSenderPid, 0, PS_PRINT_WARNING,
"TTF_MNTN_ErrlogBufRpt: VOS_SmP <1>, ulRslt<2> fail!", enModemId, (VOS_INT32)ulRslt);
return;
}
ulBufSize = (VOS_UINT32)OM_RingBufferNBytes(pRingId);
if (ulBufSize > TTF_ERR_LOG_BUF_SIZE)
{
OM_RingBufferFlush(pRingId);
PS_LOG1(ulSenderPid, 0, PS_PRINT_WARNING,
"TTF_MNTN_ErrlogBufGet: ulBufSize invalid!", (VOS_INT32)ulBufSize);
ulBufSize = 0;
}
VOS_SmV(TTF_ERR_LOG_ENT_SEM_GET(enModemId));
}
/*lint -e413*/
ulMsgLen = (TTF_OFFSET_OF(OM_ERR_LOG_REPORT_CNF_STRU, aucContent[0])) + ulBufSize;
pstLogRpt = (OM_ERR_LOG_REPORT_CNF_STRU *)PS_ALLOC_MSG_WITH_HEADER_LEN(ulSenderPid, ulMsgLen);
if (VOS_NULL_PTR == pstLogRpt)
{
return;
}
if (0 != ulBufSize)
{
TTF_MNTN_ErrlogBufGet(ulSenderPid, enModemId, (VOS_CHAR *)(pstLogRpt->aucContent), ulBufSize);
}
pstLogRpt->ulReceiverPid = ulReceiverPid;
pstLogRpt->ulMsgName = ID_OM_ERR_LOG_REPORT_CNF;
pstLogRpt->ulMsgType = OM_ERR_LOG_MSG_ERR_REPORT;
pstLogRpt->ulMsgSN = VOS_GetSlice();
pstLogRpt->ulRptlen = ulBufSize;
/*lint +e413*/
PS_SEND_MSG(UEPS_PID_SN, pstLogRpt);
}
