/*****************************************************************************
Function : VOS_GetCurrentTaskID
Description: Get current task's ID
Input : none
Output : none
Return : Return task's ID if success or fail information if fail
Other : none
*****************************************************************************/
VOS_UINT32 VOS_GetCurrentTaskID( VOS_VOID )
{
pid_t ulOSID;
int i;
VOS_UINT32 ulLockLevel;
ulOSID = current->pid;
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosTaskSpinLock, ulLockLevel);
for ( i=0; i<(VOS_INT)vos_TaskCtrlBlkNumber; i++ )
{
if( VOS_TASK_CTRL_BLK_BUSY == vos_TaskCtrlBlk[i].Flag )
{
if ( ulOSID == vos_TaskCtrlBlk[i].ulLinuxThreadId )
{
/*VOS_Splx(intLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosTaskSpinLock, ulLockLevel);
return (VOS_UINT32)i;
}
}
}
/*VOS_Splx(intLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosTaskSpinLock, ulLockLevel);
LogPrint("# VOS_GetCurrentTaskID fatal error.\r\n");
return( VOS_NULL_LONG );
}
VOS_VOID IMM_RbRemoteFreeMem(VOS_VOID *pucAddr)
{
VOS_UINT32 ulResult;
VOS_UINT32 ulNum;
VOS_INT32 lIsrRet; /* 中断操作返回值 */
VOS_ULONG ulFlags = 0UL;
if ( VOS_NULL_PTR == pucAddr )
{
VOS_SpinLockIntLock(&g_stImmRbSpinLock, ulFlags);
g_stImmMemFreeMntnEntity.ulImmMemExtFreeFailCnt++;
VOS_SpinUnlockIntUnlock(&g_stImmRbSpinLock, ulFlags);
IMM_LOG(UEPS_PID_IMM_RB_FREE, IMM_PRINT_WARNING, "IMM_RB, IMM_RbRemoteFreeMem, pucAddr is Null!\n");
return;
}
VOS_SpinLockIntLock (&g_stImmRbSpinLock, ulFlags);
/* 将TTF_MEM地址放入释放队列 */
ulResult = LUP_EnSharedQueAcpu(g_pstAcpuTTFMemFreeQue, pucAddr);
g_stImmMemRbMntnEntity.ulImmMemRbEnQTotalCnt++;
ulNum = LUP_QueCnt(g_pstAcpuTTFMemFreeQue);
VOS_SpinUnlockIntUnlock(&g_stImmRbSpinLock, ulFlags);
if (PS_SUCC != ulResult)
{
VOS_SpinLockIntLock (&g_stImmRbSpinLock, ulFlags);
g_stImmMemRbMntnEntity.ulImmMemRbEnQFailCnt++;
VOS_SpinUnlockIntUnlock(&g_stImmRbSpinLock, ulFlags);
IMM_LOG(UEPS_PID_IMM_RB_FREE, IMM_PRINT_ERROR, "ERROR:IMM_RbRemoteFreeMem: LUP_EnSharedQueAcpu fail!\n");
}
#ifndef WTTF_PS_FUSION_PC_ST
if ( 0 == (ulNum & g_ulFreeIMMMemBlkNoticNum))
{
/* 触发IPC中断 */
lIsrRet = IMM_MEM_TRIG_IPC_MEMRB_INT(IPC_CORE_COMARM, IMM_IPC_MEM_RECYCLE_INT);
VOS_SpinLockIntLock (&g_stImmRbSpinLock, ulFlags);
g_stImmMemRbMntnEntity.ulImmMemRbSendIntCnt++;
VOS_SpinUnlockIntUnlock(&g_stImmRbSpinLock, ulFlags);
if (lIsrRet != VOS_OK)
{
IMM_LOG(UEPS_PID_IMM_RB_FREE, IMM_PRINT_ERROR, "ERROR:IMM_RbRemoteFreeMem: mdrv_ipc_int_send fail!\n");
}
}
#else
lIsrRet = VHW_IPC_IntSend((IPC_INT_CORE_E)IPC_CORE_COMARM, (IPC_INT_LEV_E)IPC_INT_DICC_RELDATA);
g_stImmMemRbMntnEntity.ulImmMemRbSendIntCnt++;
if (lIsrRet != VOS_OK)
{
IMM_LOG(UEPS_PID_IMM_RB_FREE, IMM_PRINT_ERROR, "ERROR:IMM_RbRemoteFreeMem: mdrv_ipc_int_send fail!\n");
}
#endif
return;
}/*IMM_RbRemoteFreeMem*/
/*****************************************************************************
Function : VOS_IncreasePidMemory
Description: Increase Pid Memory
Input : pid size
Return : void
Other : only for designer
*****************************************************************************/
VOS_VOID VOS_IncreasePidMemory(VOS_PID ulPid, VOS_UINT32 ulSize, VOS_UINT32 ulType)
{
VOS_UINT32 ulLockLevel;
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosPidMemAnaSpinLock, ulLockLevel);
if ( VOS_LOCATION_MEM == ulType )
{
vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMemSize += ulSize;
if ( vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMemSize > vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMemPeakSize )
{
vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMemPeakSize = vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMemSize;
}
}
else
{
vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMsgSize += ulSize;
if ( vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMsgSize > vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMsgPeakSize )
{
vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMsgPeakSize = vos_PidRecords[ulPid-VOS_PID_DOPRAEND].ulMsgSize;
}
}
/*VOS_Splx(intLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosPidMemAnaSpinLock, ulLockLevel);
return;
}
/*****************************************************************************
Function : VOS_TaskCtrlBlkFree
Description: free a block
Input : Tid -- task ID
Return : VOS_OK on success or errno on failure.
Other :
*****************************************************************************/
VOS_UINT32 VOS_TaskCtrlBlkFree(VOS_UINT32 Tid)
{
VOS_UINT32 ulLockLevel;
if( Tid < vos_TaskCtrlBlkNumber )
{
if(vos_TaskCtrlBlk[Tid].Flag == VOS_TASK_CTRL_BLK_IDLE)
{
Print("# VOS_TaskCtrlBlkFree free Idle Task.\r\n");
return VOS_ERR;
}
else
{
/* intLockLevel = VOS_SplIMP(); */
VOS_SpinLockIntLock(&g_stVosTaskSpinLock, ulLockLevel);
vos_TaskCtrlBlk[Tid].Flag = VOS_TASK_CTRL_BLK_IDLE;
VOS_SpinUnlockIntUnlock(&g_stVosTaskSpinLock, ulLockLevel);
/*VOS_Splx(intLockLevel);*/
return VOS_OK;
}
}
else
{
Print("# VOS_TaskCtrlBlkFree Error.\r\n");
return VOS_ERR;
}
}
/*****************************************************************************
Function : VOS_TaskCtrlBlkGet
Description: allocate a block
Input : void
: void
Return : VOS_OK on success or errno on failure.
Other :
*****************************************************************************/
VOS_UINT32 VOS_TaskCtrlBlkGet(VOS_VOID)
{
VOS_UINT32 i;
VOS_UINT32 ulLockLevel;
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosTaskSpinLock, ulLockLevel);
for(i=0; i<vos_TaskCtrlBlkNumber; i++)
{
if(vos_TaskCtrlBlk[i].Flag == VOS_TASK_CTRL_BLK_IDLE)
{
vos_TaskCtrlBlk[i].Flag = VOS_TASK_CTRL_BLK_BUSY;
break;
}
}
/*VOS_Splx(intLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosTaskSpinLock, ulLockLevel);
if( i < vos_TaskCtrlBlkNumber)
{
return i;
}
else
{
Print("# allocate task control block fail.\r\n");
return(VOS_TASK_CTRL_BLK_NULL);
}
}
/*****************************************************************************
Function : VOS_SemCtrlBlkFree
Description: fress a block
Input : Sem_Address -- address
Return : VOS_OK on success or errno on failure.
Other :
*****************************************************************************/
VOS_UINT32 VOS_SemCtrlBlkFree( SEM_CONTROL_BLOCK *Sem_Address )
{
VOS_ULONG ulLockLevel;
if( Sem_Address == Sem_Address->SemId )
{
if(Sem_Address->Flag == VOS_SEM_CTRL_BLK_IDLE)
{
return(VOS_ERR);
}
else
{
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosSemSpinLock, ulLockLevel);
Sem_Address->Flag = VOS_SEM_CTRL_BLK_IDLE;
/*VOS_Splx(intLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosSemSpinLock, ulLockLevel);
}
return(VOS_OK);
}
else
{
Print("# VOS_FreeSemCtrlBlk free NULL Sem.\r\n");
return(VOS_ERR);
}
}
VOS_UINT32 CSD_UL_InsertQueueTail(
IMM_ZC_HEAD_STRU *pstQueueHead,
IMM_ZC_STRU *pstNode
)
{
/* Modified by l60609 for AP适配项目 ，2012-08-31 Begin */
VOS_UINT32 ulLockLevel;
ulLockLevel = 0;
/* 队列加锁 */
VOS_SpinLockIntLock(&g_stCsdCtx.stSpinLock, ulLockLevel);
/* 数据插入队尾 */
IMM_ZcQueueTail(pstQueueHead, pstNode);
/* 队列解锁 */
VOS_SpinUnlockIntUnlock(&g_stCsdCtx.stSpinLock, ulLockLevel);
/* Modified by l60609 for AP适配项目 ，2012-08-31 End */
CSD_NORMAL_LOG3(ACPU_PID_CSD,
"CSD_UL_InsertQueueTail:: Queue len is %d, Pre is 0x%x, Next is 0x%x",
pstQueueHead->qlen,
pstQueueHead->next,
pstQueueHead->prev);
return VOS_OK;
}
IMM_ZC_STRU *CSD_UL_GetQueueFrontNode(IMM_ZC_HEAD_STRU *pstQueue)
{
IMM_ZC_STRU *pstNode;
/* Modified by l60609 for AP适配项目 ，2012-08-31 Begin */
VOS_UINT32 ulLockLevel;
ulLockLevel = 0;
/* 队列加锁 */
VOS_SpinLockIntLock(&g_stCsdCtx.stSpinLock, ulLockLevel);
/* 返回队尾节点指针 */
pstNode = IMM_ZcDequeueHead(pstQueue);
/* 队列解锁 */
VOS_SpinUnlockIntUnlock(&g_stCsdCtx.stSpinLock, ulLockLevel);
/* Modified by l60609 for AP适配项目 ，2012-08-31 End */
CSD_NORMAL_LOG3(ACPU_PID_CSD,
"CSD_UL_GetQueueFrontNode:: Queue len is %d, Pre is 0x%x, Next is 0x%x",
pstQueue->qlen,
pstQueue->next,
pstQueue->prev);
return pstNode;
}
IMM_ZC_STRU *CSD_UL_GetQueueFrontNode(IMM_ZC_HEAD_STRU *pstQueue)
{
IMM_ZC_STRU *pstNode;
VOS_ULONG ulLockLevel;
ulLockLevel = 0;
/* 队列加锁 */
VOS_SpinLockIntLock(&g_stCsdCtx.stSpinLock, ulLockLevel);
/* 返回队尾节点指针 */
pstNode = IMM_ZcDequeueHead(pstQueue);
/* 队列解锁 */
VOS_SpinUnlockIntUnlock(&g_stCsdCtx.stSpinLock, ulLockLevel);
CSD_NORMAL_LOG3(ACPU_PID_CSD,
"CSD_UL_GetQueueFrontNode:: Queue len is %d, Pre is 0x%x, Next is 0x%x",
pstQueue->qlen,
pstQueue->next,
pstQueue->prev);
return pstNode;
}
VOS_UINT32 CSD_UL_InsertQueueTail(
IMM_ZC_HEAD_STRU *pstQueueHead,
IMM_ZC_STRU *pstNode
)
{
VOS_ULONG ulLockLevel;
ulLockLevel = 0;
/* 队列加锁 */
VOS_SpinLockIntLock(&g_stCsdCtx.stSpinLock, ulLockLevel);
/* 数据插入队尾 */
IMM_ZcQueueTail(pstQueueHead, pstNode);
/* 队列解锁 */
VOS_SpinUnlockIntUnlock(&g_stCsdCtx.stSpinLock, ulLockLevel);
CSD_NORMAL_LOG3(ACPU_PID_CSD,
"CSD_UL_InsertQueueTail:: Queue len is %d, Pre is 0x%x, Next is 0x%x",
pstQueueHead->qlen,
pstQueueHead->next,
pstQueueHead->prev);
return VOS_OK;
}
TTF_NODE_ST* TTF_LinkSafeRemoveHead(VOS_UINT32 ulPid, TTF_LINK_ST * pLink, VOS_UINT32 *pulRemainCnt)
{
TTF_NODE_ST *pNode;
VOS_ULONG ulLockLevel = 0UL;
VOS_SpinLockIntLock(&g_stTtfLinkSpinLock, ulLockLevel);
*pulRemainCnt = 0;
if (VOS_NULL_PTR == pLink)
{
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
PS_LOG(ulPid, 0, PS_PRINT_WARNING, "Warning: pLink is Null!");
return VOS_NULL_PTR;
}
if (0 == pLink->ulCnt)
{
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
PS_LOG(ulPid, 0, PS_PRINT_INFO, "Warning: pLink Cnt is 0!");
return VOS_NULL_PTR;
}
/*异常:链表和链表个数不一致时, 容错处理*/
if ( pLink->stHead.pNext == &pLink->stHead )
{
pLink->ulCnt = 0;
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
PS_LOG1(ulPid, 0, PS_PRINT_WARNING, "Warning: pLink is null, but Cnt is <1>!", (VOS_INT32)pLink->ulCnt);
return VOS_NULL_PTR;
}
pNode = pLink->stHead.pNext;
pLink->stHead.pNext = pNode->pNext;
pNode->pNext->pPrev = &pLink->stHead;
pNode->pNext = VOS_NULL_PTR;
pNode->pPrev = VOS_NULL_PTR;
pLink->ulCnt--;
/* 获取队列里剩余元素个数 */
*pulRemainCnt = pLink->ulCnt;
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
return pNode;
} /* TTF_LinkSafeRemoveHead */
VOS_VOID PPM_PortCloseProc(OM_PROT_HANDLE_ENUM_UINT32 enHandle, CPM_PHY_PORT_ENUM_UINT32 enPhyPort)
{
VOS_ULONG ulLockLevel;
OM_LOGIC_CHANNEL_ENUM_UINT32 enChannel;
VOS_BOOL ulSndMsg;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBCloseNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBCloseSlice = OM_GetSlice();
if (VOS_ERROR == g_astOMPortUDIHandle[enHandle])
{
return;
}
DRV_UDI_CLOSE(g_astOMPortUDIHandle[enHandle]);
g_astOMPortUDIHandle[enHandle] = VOS_ERROR;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBCloseOkNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBCloseOkSlice = OM_GetSlice();
VOS_SpinLockIntLock(&g_stPpmPortSwitchSpinLock, ulLockLevel);
ulSndMsg = VOS_FALSE;
enChannel = OM_LOGIC_CHANNEL_BUTT;
/* CFG端口处理GU和TL的端口断开，发消息到GU和TL去处理，但不断开CPM的关联 */
if (OM_USB_CFG_PORT_HANDLE == enHandle)
{
if (enPhyPort == CPM_QueryPhyPort(CPM_OM_CFG_COMM))
{
ulSndMsg = VOS_TRUE;
enChannel = OM_LOGIC_CHANNEL_CNF;
}
}
/* IND端口断开时发消息到GU和TL去处理，但不断开CPM的关联 */
else if (OM_USB_IND_PORT_HANDLE == enHandle)
{
if (enPhyPort == CPM_QueryPhyPort(CPM_OM_IND_COMM))
{
ulSndMsg = VOS_TRUE;
enChannel = OM_LOGIC_CHANNEL_IND;
}
}
else
{
}
VOS_SpinUnlockIntUnlock(&g_stPpmPortSwitchSpinLock, ulLockLevel);
if (VOS_TRUE == ulSndMsg)
{
PPM_DisconnectAllPort(enChannel);
}
return;
}
VOS_UINT32 TTF_LinkSafeInsertTail(VOS_UINT32 ulPid, TTF_LINK_ST * pLink, TTF_NODE_ST *pInsert, VOS_UINT32 *pulNonEmptyEvent)
{
VOS_ULONG ulLockLevel = 0UL;
*pulNonEmptyEvent = PS_FALSE;
VOS_SpinLockIntLock(&g_stTtfLinkSpinLock, ulLockLevel);
if ( (VOS_NULL_PTR == pLink) || (VOS_NULL_PTR == pInsert) )
{
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
PS_LOG(ulPid, 0, PS_PRINT_WARNING, "Warning: pLink Or pInsert is Null!");
return PS_FAIL;
}
#ifdef WTTF_PC_ST_SWITCH
/*检查节点pInsert是否在链表pLink中*/
if ( PS_TRUE == TTF_LinkCheckNodeInLink(ulPid, pLink, pInsert) )
{
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
PS_LOG(ulPid, 0, PS_PRINT_WARNING, "Warning: pInsert has Existed in pLink!");
return PS_FAIL;
}
#endif
if (0 == TTF_LINK_CNT(pLink))
{
*pulNonEmptyEvent = PS_TRUE;
}
pInsert->pNext = (TTF_NODE_ST *)(&pLink->stHead);
pInsert->pPrev = pLink->stHead.pPrev;
pLink->stHead.pPrev->pNext = pInsert;
pLink->stHead.pPrev = pInsert;
pLink->ulCnt++;
VOS_SpinUnlockIntUnlock(&g_stTtfLinkSpinLock, ulLockLevel);
return PS_SUCC;
} /* TTF_LinkSafeInsertTail */
VOS_VOID ADS_UL_DestroyQueue(
VOS_UINT8 ucInstanceIndex,
VOS_UINT8 ucRabId
)
{
VOS_UINT32 ulLockLevel;
ulLockLevel = 0;
/* 结点存在但队列为空 */
if (VOS_ERR == ADS_UL_IsQueueExistent(ucInstanceIndex, ucRabId))
{
/* Rab Id以及优先级置为无效值 */
ADS_UL_SetQueue(ucInstanceIndex,
ucRabId,
VOS_FALSE,
VOS_NULL_PTR,
ADS_QCI_TYPE_BUTT,
ADS_PDP_TYPE_BUTT);
/* 根据最新的队列管理进行排序 */
ADS_UL_UpdateQueueInPdpDeactived(ucInstanceIndex, ucRabId);
return;
}
/* 队列加锁 */
VOS_SpinLockIntLock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
/* Modified by l60609 for AP适配项目 ，2012-09-10 Begin */
/* 销毁队列中的数据 */
ADS_UL_ClearQueue(ucRabId,
ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId));
/* Modified by l60609 for AP适配项目 ，2012-09-10 End */
/* 销毁队列头结点*/
PS_MEM_FREE(ACPU_PID_ADS_DL, ADS_UL_GET_QUEUE_LINK_PTR(ucInstanceIndex, ucRabId));
/* 将队列信息更新到上行上下文 */
ADS_UL_SetQueue(ucInstanceIndex,
ucRabId,
VOS_FALSE,
VOS_NULL_PTR,
ADS_QCI_TYPE_BUTT,
ADS_PDP_TYPE_BUTT);
/* 队列操作完成解锁 */
VOS_SpinUnlockIntUnlock(ADS_UL_GET_QUEUE_LINK_SPINLOCK(ucInstanceIndex, ucRabId), ulLockLevel);
/* 根据最新的队列管理进行排序 */
ADS_UL_UpdateQueueInPdpDeactived(ucInstanceIndex, ucRabId);
}
VOS_UINT32 SCM_SoftDecodeCfgDataRcv(VOS_UINT8 *pucBuffer, VOS_UINT32 ulLen)
{
VOS_UINT32 ulRstl;
VOS_ULONG ulLockLevel;
VOS_SpinLockIntLock(&g_stScmSoftDecodeDataRcvSpinLock, ulLockLevel);
ulRstl = SCM_SoftDecodeDataRcv(pucBuffer, ulLen);
VOS_SpinUnlockIntUnlock(&g_stScmSoftDecodeDataRcvSpinLock, ulLockLevel);
return ulRstl;
}
/*****************************************************************************
Prototype : Sock_ServerProc
Description : 服务器线程，用来处理服务器端和客户端的所有请求。
Input : lpParameter - Unused.
Output : void
Return Value : void
History : ---
Date : 2008-05-3
Author : g47350
Modification: Created function
*****************************************************************************/
VOS_VOID PPM_SockServerProc(COMM_SOCKET_CTRL_INFO_STRU *pstSockInfo)
{
VOS_INT8 acRcvBuf[OM_APP_SPLIT_MSG_LEN];
VOS_INT lRevSize = 0;
VOS_ULONG ulLockLevel;
for(;;)
{
lRevSize = recv(pstSockInfo->socket, acRcvBuf, OM_APP_SPLIT_MSG_LEN, 0);
VOS_SpinLockIntLock(&g_stSockTaskSpinLock, ulLockLevel);
/*客户端已经关闭，需要将其清空*/
#if (VOS_LINUX == VOS_OS_VER)
if (0 >= lRevSize)
#else
if ((SOCKET_ERROR == lRevSize) || (0 == lRevSize))
#endif
{
(VOS_VOID)VOS_SmP(pstSockInfo->SmClose, 0);
closesocket(pstSockInfo->socket);
pstSockInfo->socket = SOCK_NULL;
VOS_SmV(pstSockInfo->SmClose);
VOS_SpinUnlockIntUnlock(&g_stSockTaskSpinLock, ulLockLevel);
continue;
}
/*将接收到的数据提交给上层处理*/
CPM_ComRcv(pstSockInfo->enPhyPort, acRcvBuf, lRevSize);
VOS_SpinUnlockIntUnlock(&g_stSockTaskSpinLock, ulLockLevel);
}
}
/*******************************************************************************
*
* OM_RingBufferCreateEx - create an empty ring buffer in exist buffer
*
* This routine creates a ring buffer of size <nbytes>, and initializes
* it. Memory for the buffer is allocated by user.
*
* RETURNS
* The ID of the ring buffer, or NULL if memory cannot be allocated.
*
* ERRNO: N/A.
************************************************************************/
OM_RING_ID OM_RingBufferCreateEx(char *pdata, int nbytes )
{
OM_RING_ID ringId;
VOS_INT i;
VOS_INT lTempSufffix = VOS_NULL_WORD;
VOS_UINT32 ulLockLevel;
if ((VOS_NULL_PTR == pdata)||(OM_RING_BUFF_EX_MAX_LEN < nbytes))
{
return VOS_NULL_PTR;
}
/*lLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosStaticMemSpinLock, ulLockLevel);
for ( i=OM_MAX_RING_BUFFER_NUM -1; i>=0; i-- )
{
if ( VOS_FALSE == g_ucOMBufferOccupiedFlag[i] )
{
lTempSufffix = i;
g_ucOMBufferOccupiedFlag[i] = VOS_TRUE;
break;
}
}
/*VOS_Splx(lLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosStaticMemSpinLock, ulLockLevel);
if ( VOS_NULL_WORD == lTempSufffix )
{
return VOS_NULL_PTR;
}
/*
* bump number of bytes requested because ring buffer algorithm
* always leaves at least one empty byte in buffer
*/
ringId = &(g_stOMControlBlock[lTempSufffix]);
ringId->bufSize = nbytes;
ringId->buf = pdata;
OM_RingBufferFlush (ringId);
return (ringId);
}
/*****************************************************************************
Function :VOS_UINT32 VOS_EventWrite( VOS_UINT32 ulTaskID, VOS_UINT32 ulEvents )
Description:Send Event to the TaskID.
Calls :VOS_TRACE_SEND_EVENT(), VOS_CheckTaskIDValid(),VOS_SplIMP(),VOS_Splx()
Called By :Application
Input :ulTaskID, ulEvents
Output :NULL
Return :
VOS_OK when sucess
ERRNO when fail
Other :
*****************************************************************************/
VOS_UINT32 VOS_EventWrite( VOS_UINT32 ulTaskID, VOS_UINT32 ulEvents )
{
/* the functin should be full later */
VOS_UINT32 ulLockLevel;
VOS_UINT32 ulTempQueue;
VOS_UINT32 ulTempSem;
if ( VOS_OK != VOS_CheckEvent(ulTaskID) )
{
LogPrint("# VOS_EventWrite EVENT not exist.\r\n");
return VOS_ERR;
}
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosTaskSpinLock, ulLockLevel);
vos_TaskCtrlBlk[ulTaskID].ulEvents |= ulEvents;
/*VOS_Splx( intLockLevel );*/
VOS_SpinUnlockIntUnlock(&g_stVosTaskSpinLock, ulLockLevel);
ulTempQueue = VOS_GetQueueIDFromFid(vos_TaskCtrlBlk[ulTaskID].ulFid);
#if (VOS_YES == VOS_CHECK_PARA)
if ( 0xffffffff == ulTempQueue )
{
return VOS_ERR;
}
#endif
ulTempSem = VOS_GetSemIDFromQueue(ulTempQueue);
#if (VOS_YES == VOS_CHECK_PARA)
if ( 0xffffffff == ulTempSem )
{
return VOS_ERR;
}
#endif
if ( VOS_OK != VOS_SmV( ulTempSem ) )
{
LogPrint("# VOS_EventWrite error.\r\n");
return VOS_ERR;
}
else
{
return VOS_OK;
}
}
VOS_VOID TTF_MemRbRemoteFreeMem( VOS_VOID *pucAddr)
{
VOS_ULONG ulLockLevel;
VOS_UINT32 ulResult;
VOS_UINT32 ulNum;
VOS_INT32 lIsrRet; /* 中断操作返回值 */
VOS_SpinLockIntLock(&g_stTtfMemRBSpinLock, ulLockLevel);
ulResult = LUP_EnQue(g_pstCcpuIMMMemFreeQue, pucAddr);
g_stTtfMemRbMntnEntity.ulTtfMemRbEnQTotalCnt++;
ulNum = LUP_QueCnt(g_pstCcpuIMMMemFreeQue);
VOS_SpinUnlockIntUnlock(&g_stTtfMemRBSpinLock, ulLockLevel);
if (PS_SUCC != ulResult)
{
g_stTtfMemRbMntnEntity.ulTtfMemRbEnQFailCnt++;
vos_printf("TTF_MemRbRemoteFreeMem: LUP_EnQue fail!\n");
}
#ifndef WTTF_PS_FUSION_PC_ST
if ( 0 == (g_ulFreeTtfMemBlkNoticNum & ulNum))
{
lIsrRet = TTF_MEM_TRIG_IPC_MEMRB_INT(IPC_CORE_APPARM, TTF_IPC_MEM_RECYCLE_INT);
g_stTtfMemRbMntnEntity.ulTtfMemRbSendIntCnt++;
if (lIsrRet != VOS_OK)
{
TTF_LOG(UEPS_PID_TTF_MEM_RB_FREE, PS_PRINT_ERROR, "ERROR:TTF_MemRbRemoteFreeMem: DRV_IPC_INTSEND fail!\n");
}
}
#else
lIsrRet = VHW_IPC_IntSend((IPC_INT_CORE_E)IPC_CORE_APPARM, (IPC_INT_LEV_E)IPC_INT_DICC_RELDATA);
g_stTtfMemRbMntnEntity.ulTtfMemRbSendIntCnt++;
if (lIsrRet != VOS_OK)
{
TTF_LOG(UEPS_PID_TTF_MEM_RB_FREE, PS_PRINT_ERROR, "ERROR:TTF_MemRbRemoteFreeMem: DRV_IPC_INTSEND fail!\n");
}
#endif
return;
}/*TTF_MemRbRemoteFreeMem*/
/*****************************************************************************
Function : VOS_SemCtrlBlkGet
Description: allocate a control block
Input : void
Return : address
Other :
*****************************************************************************/
SEM_CONTROL_BLOCK *VOS_SemCtrlBlkGet(VOS_VOID)
{
VOS_UINT32 i;
VOS_ULONG ulLockLevel;
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosSemSpinLock, ulLockLevel);
for(i=0; i<vos_SemCtrlBlkNumber; i++)
{
if(vos_SemCtrlBlk[i].Flag == VOS_SEM_CTRL_BLK_IDLE)
{
vos_SemCtrlBlk[i].Flag = VOS_SEM_CTRL_BLK_BUSY;
break;
}
}
/*VOS_Splx(intLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosSemSpinLock, ulLockLevel);
if( i < vos_SemCtrlBlkNumber)
{
/* record the max usage of SEM */
if ( i > vos_SemMaxSemId )
{
vos_SemMaxSemId = i;
}
return vos_SemCtrlBlk+i;
}
else
{
/*lint -e534*/
LogPrint("# VOS_GetSemCtrlBlk no Idle.\r\n");
/*lint +e534*/
VOS_SetErrorNo(VOS_ERRNO_SEMA4_FULL);
return(VOS_MAX_SEM_ID_NULL);
}
}
/*****************************************************************************
Function :VOS_UINT32 VOS_EventRead( VOS_UINT32 ulEvents,
VOS_UINT32 ulFlags,
VOS_UINT32 ulTimeOutInMillSec,
VOS_UINT32 * pulRetEvents )
Description:Read event
Calls :VOS_TRACE_SEND_EVENT(),VOS_GetCurrentTaskID(),
VOS_SplIMP(),VOS_Splx(),VOS_Dispater()
Called By :Application
Input :
ulEvents the expect event, while 0 refers to check event only,
NOT get it while return.
ulFlags the Flags, refers to WAIT or NOWAIT, ANY or ALL, etc.
ulTimeOutInMillSec the deadline while WAIT for event
Output :pulRetEvents the received Event.
Return :
VOS_OK when sucess
ERRNO when failure
Other :
*****************************************************************************/
VOS_UINT32 VOS_EventRead( VOS_UINT32 ulEvents,
VOS_UINT32 ulFlags,
VOS_UINT32 ulTimeOutInMillSec,
VOS_UINT32 *pulRetEvents )
{
/* the functin should be full later */
VOS_UINT32 ulTaskSelf; /*Self task ID*/
VOS_UINT32 ulTempQueue;
VOS_UINT32 ulTempSem;
VOS_UINT32 ulLockLevel;
VOS_UINT32 ulTempEvent;
ulTaskSelf = VOS_GetCurrentTaskID();
#if (VOS_YES == VOS_CHECK_PARA)
if ( 0xffffffff == ulTaskSelf )
{
return VOS_ERR;
}
if( VOS_EVENT_NOWAIT & ulFlags )
{
LogPrint("# OSA don't support VOS_EVENT_NOWAIT.\r\n");
VOS_SuspendTask(ulTaskSelf);
return VOS_ERR;
}
#endif
if( !(VOS_EVENT_ANY & ulFlags) )
{
LogPrint("# OSA don't support VOS_EVENT_ALL.\r\n");
VOS_SuspendTask(ulTaskSelf);
return VOS_ERR;
}
if( 0 == ulEvents )
{
LogPrint("# OSA don't support event = 0.\r\n");
VOS_SuspendTask(ulTaskSelf);
return VOS_ERR;
}
if ( VOS_OK != VOS_CheckEvent(ulTaskSelf) )
{
LogPrint("# VOS_EventRead EVENT not exist.\r\n");
VOS_SuspendTask(ulTaskSelf);
return VOS_ERR;
}
ulTempQueue = VOS_GetQueueIDFromFid(vos_TaskCtrlBlk[ulTaskSelf].ulFid);
#if (VOS_YES == VOS_CHECK_PARA)
if ( 0xffffffff == ulTempQueue )
{
return VOS_ERR;
}
#endif
ulTempSem = VOS_GetSemIDFromQueue(ulTempQueue);
#if (VOS_YES == VOS_CHECK_PARA)
if ( 0xffffffff == ulTempSem )
{
return VOS_ERR;
}
#endif
if( VOS_OK != VOS_SmP( ulTempSem, ulTimeOutInMillSec ) )
{
Print("# VOS_EventRead error.\r\n");
return VOS_ERR;
}
/*intLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosTaskSpinLock, ulLockLevel);
ulTempEvent = vos_TaskCtrlBlk[ulTaskSelf].ulEvents & ulEvents;
if ( ulTempEvent )
{
vos_TaskCtrlBlk[ulTaskSelf].ulEvents &= ~ulTempEvent;
*pulRetEvents = ulTempEvent;
}
else
{
*pulRetEvents = VOS_MSG_SYNC_EVENT;
}
/*VOS_Splx( intLockLevel );*/
VOS_SpinUnlockIntUnlock(&g_stVosTaskSpinLock, ulLockLevel);
return VOS_OK;
}
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 SCM_SoftDecodeCfgRcvSelfTask(
VOS_UINT32 ulPara1,
VOS_UINT32 ulPara2,
VOS_UINT32 ulPara3,
VOS_UINT32 ulPara4)
{
VOS_INT32 sRet;
VOS_INT32 lLen;
VOS_INT32 lRemainlen;
VOS_INT32 lReadLen;
VOS_UINT32 ulPktNum;
VOS_UINT32 i;
VOS_ULONG ulLockLevel;
ulPara1 = ulPara1;
ulPara2 = ulPara2;
ulPara3 = ulPara3;
ulPara4 = ulPara4;
for (;;)
{
if (VOS_OK != VOS_SmP(g_stSCMDataRcvTaskCtrlInfo.SmID, 0))
{
continue;
}
diag_PTR(EN_DIAG_PTR_SCM_SELFTASK);
lLen = OM_RingBufferNBytes(g_stSCMDataRcvTaskCtrlInfo.rngOmRbufId);
if (lLen <= 0)
{
continue;
}
ulPktNum = (VOS_UINT32)((lLen + SCM_DATA_RCV_PKT_SIZE - 1) / SCM_DATA_RCV_PKT_SIZE);
lRemainlen = lLen;
for (i = 0; i < ulPktNum; i++)
{
if (SCM_DATA_RCV_PKT_SIZE < lRemainlen)
{
lReadLen = SCM_DATA_RCV_PKT_SIZE;
sRet = OM_RingBufferGet(g_stSCMDataRcvTaskCtrlInfo.rngOmRbufId,
g_stSCMDataRcvTaskCtrlInfo.pucBuffer,
SCM_DATA_RCV_PKT_SIZE);
}
else
{
lReadLen = lRemainlen;
sRet = OM_RingBufferGet(g_stSCMDataRcvTaskCtrlInfo.rngOmRbufId,
g_stSCMDataRcvTaskCtrlInfo.pucBuffer,
lRemainlen);
}
if (sRet != lReadLen)
{
VOS_SpinLockIntLock(&g_stScmSoftDecodeDataRcvSpinLock, ulLockLevel);
OM_RingBufferFlush(g_stSCMDataRcvTaskCtrlInfo.rngOmRbufId);
VOS_SpinUnlockIntUnlock(&g_stScmSoftDecodeDataRcvSpinLock, ulLockLevel);
g_stScmSoftDecodeInfo.stRbInfo.ulRingBufferFlush++;
diag_PTR(EN_DIAG_PTR_SCM_ERR3);
continue;
}
lRemainlen -= lReadLen;
g_stScmSoftDecodeInfo.stGetInfo.ulDataLen += lReadLen;
diag_PTR(EN_DIAG_PTR_SCM_RCVDATA);
/* 调用HDLC解封装函数 */
if (VOS_OK != SCM_SoftDecodeAcpuRcvData(&g_stScmHdlcSoftDecodeEntity,
(VOS_UINT8 *)g_stSCMDataRcvTaskCtrlInfo.pucBuffer,
(VOS_UINT32)lReadLen))
{
/*lint -e534*/
vos_printf("SCM_SoftDecodeCfgRcvSelfTask: SCM_SoftDecodeAcpuRcvData Fail.\n");
/*lint +e534*/
}
}
#if (defined(DMT))
return;
#endif
}
}
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_UINT32 PPM_LogPortSwitch(VOS_UINT32 ulPhyPort, VOS_BOOL ulEffect)
{
CPM_PHY_PORT_ENUM_UINT32 enPhyCfgPort;
CPM_PHY_PORT_ENUM_UINT32 enPhyIndPort;
VOS_ULONG ulLockLevel;
VOS_BOOL ulSndMsg;
if ((CPM_OM_PORT_TYPE_USB != ulPhyPort) && (CPM_OM_PORT_TYPE_VCOM != ulPhyPort))
{
vos_printf("\r\n PPM_LogPortSwitch: enPhyPort is error.port %d\n", ulPhyPort);
g_stPpmPortSwitchInfo.ulPortTypeErr++;
return VOS_ERR;
}
/* 切换的端口与当前端口一致不切换 */
if (ulPhyPort == g_stPortCfg.enPortNum)
{
DRV_SOCP_VOTE(SOCP_VOTE_PPM_RCV, SOCP_VOTE_FOR_WAKE);
/* 切换到VCOM输出时在LOG延迟写入开启情况下需要重新设置SOCP的超时中断 */
if (CPM_OM_PORT_TYPE_VCOM == g_stPortCfg.enPortNum)
{
(VOS_VOID)DRV_SOCP_SET_TIMEOUT(SOCP_TIMEOUT_TRF, 0);
}
/* 为了规避USB输出时开启了延时写入无法连接工具,切换到USB输出时需要重新设置SOCP的超时中断到默认值 */
if (CPM_OM_PORT_TYPE_USB == g_stPortCfg.enPortNum)
{
(VOS_VOID)DRV_SOCP_SET_TIMEOUT(SOCP_TIMEOUT_TRF, 0x17);
}
DRV_SOCP_VOTE(SOCP_VOTE_PPM_RCV, SOCP_VOTE_FOR_SLEEP);
return VOS_OK;
}
g_stPpmPortSwitchInfo.ulStartSlice = OM_GetSlice();
enPhyCfgPort = CPM_QueryPhyPort(CPM_OM_CFG_COMM);
enPhyIndPort = CPM_QueryPhyPort(CPM_OM_IND_COMM);
ulSndMsg = VOS_FALSE;
VOS_SpinLockIntLock(&g_stPpmPortSwitchSpinLock, ulLockLevel);
/* 切换到VCOM输出 */
if (CPM_OM_PORT_TYPE_VCOM == ulPhyPort)
{
/* 当前是USB输出 */
if ((CPM_CFG_PORT == enPhyCfgPort) && (CPM_IND_PORT == enPhyIndPort))
{
/* 需要断开连接 */
ulSndMsg = VOS_TRUE;
CPM_DisconnectPorts(CPM_CFG_PORT, CPM_OM_CFG_COMM);
CPM_DisconnectPorts(CPM_IND_PORT, CPM_OM_IND_COMM);
}
/* 当前OM走VCOM上报 */
CPM_ConnectPorts(CPM_VCOM_CFG_PORT, CPM_OM_CFG_COMM);
CPM_ConnectPorts(CPM_VCOM_IND_PORT, CPM_OM_IND_COMM);
g_stPortCfg.enPortNum = CPM_OM_PORT_TYPE_VCOM;
}
/* 切换到USB输出 */
else
{
/* 当前是VCOM输出 */
if ((CPM_VCOM_CFG_PORT == enPhyCfgPort) && (CPM_VCOM_IND_PORT == enPhyIndPort))
{
/* 断开连接 */
ulSndMsg = VOS_TRUE;
CPM_DisconnectPorts(CPM_VCOM_CFG_PORT, CPM_OM_CFG_COMM);
CPM_DisconnectPorts(CPM_VCOM_IND_PORT, CPM_OM_IND_COMM);
}
/* OM走USB上报 */
CPM_ConnectPorts(CPM_CFG_PORT, CPM_OM_CFG_COMM);
CPM_ConnectPorts(CPM_IND_PORT, CPM_OM_IND_COMM);
g_stPortCfg.enPortNum = CPM_OM_PORT_TYPE_USB;
}
VOS_SpinUnlockIntUnlock(&g_stPpmPortSwitchSpinLock, ulLockLevel);
if (VOS_TRUE == ulSndMsg)
{
PPM_DisconnectAllPort(OM_LOGIC_CHANNEL_CNF);
}
DRV_SOCP_VOTE(SOCP_VOTE_PPM_RCV, SOCP_VOTE_FOR_WAKE);
/* 切换到VCOM输出时在LOG延迟写入开启情况下需要重新设置SOCP的超时中断 */
if (CPM_OM_PORT_TYPE_VCOM == g_stPortCfg.enPortNum)
{
(VOS_VOID)DRV_SOCP_SET_TIMEOUT(SOCP_TIMEOUT_TRF, 0);
}
/* 为了规避USB输出时开启了延时写入无法连接工具,切换到USB输出时需要重新设置SOCP的超时中断到默认值 */
if (CPM_OM_PORT_TYPE_USB == g_stPortCfg.enPortNum)
{
(VOS_VOID)DRV_SOCP_SET_TIMEOUT(SOCP_TIMEOUT_TRF, 0x17);
}
DRV_SOCP_VOTE(SOCP_VOTE_PPM_RCV, SOCP_VOTE_FOR_SLEEP);
g_stPpmPortSwitchInfo.ulSwitchSucc++;
g_stPpmPortSwitchInfo.ulEndSlice = OM_GetSlice();
if (VOS_TRUE == ulEffect)
{
if (VOS_OK != NV_Write(en_NV_Item_Om_Port_Type, &g_stPortCfg, sizeof(OM_CHANNLE_PORT_CFG_STRU)))
{
vos_printf("\r\n PPM_LogPortSwitch: NV_Write fail\n");
}
}
return VOS_OK;
}
VOS_VOID PPM_PortStatus(OM_PROT_HANDLE_ENUM_UINT32 enHandle, CPM_PHY_PORT_ENUM_UINT32 enPhyPort,ACM_EVT_E enPortState)
{
VOS_ULONG ulLockLevel;
OM_LOGIC_CHANNEL_ENUM_UINT32 enChannel;
VOS_BOOL ulSndMsg;
if (ACM_EVT_DEV_SUSPEND == enPortState)
{
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOutNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOutTime = OM_GetSlice();
VOS_SpinLockIntLock(&g_stPpmPortSwitchSpinLock, ulLockLevel);
ulSndMsg = VOS_FALSE;
enChannel = OM_LOGIC_CHANNEL_BUTT;
/* CFG端口处理GU和TL的端口断开，发消息到GU和TL去处理，但不断开CPM的关联 */
if (OM_USB_CFG_PORT_HANDLE == enHandle)
{
if (enPhyPort == CPM_QueryPhyPort(CPM_OM_CFG_COMM))
{
ulSndMsg = VOS_TRUE;
enChannel = OM_LOGIC_CHANNEL_CNF;
}
}
/* IND端口断开时发消息到GU和TL去处理 */
else if (OM_USB_IND_PORT_HANDLE == enHandle)
{
if (enPhyPort == CPM_QueryPhyPort(CPM_OM_IND_COMM))
{
ulSndMsg = VOS_TRUE;
enChannel = OM_LOGIC_CHANNEL_IND;
}
}
else
{
}
VOS_SpinUnlockIntUnlock(&g_stPpmPortSwitchSpinLock, ulLockLevel);
if (VOS_TRUE == ulSndMsg)
{
PPM_DisconnectAllPort(enChannel);
}
}
else if(ACM_EVT_DEV_READY == enPortState)
{
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBINNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBINTime = OM_GetSlice();
}
else
{
LogPrint2("PPM_PortStatus: The USB Port %d State %d is Unknow", (VOS_INT)enPhyPort, (VOS_INT)enPortState);
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBStateErrNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBStateErrTime = OM_GetSlice();
}
return;
}
/*******************************************************************************
*
* OM_RingBufferCreate - create an empty ring buffer
*
* This routine creates a ring buffer of size <nbytes>, and initializes
* it. Memory for the buffer is allocated from the system memory partition.
*
* RETURNS
* The ID of the ring buffer, or NULL if memory cannot be allocated.
*
* ERRNO: N/A.
************************************************************************/
OM_RING_ID OM_RingBufferCreate( int nbytes )
{
char *buffer;
OM_RING_ID ringId;
VOS_INT i;
VOS_INT lTempSufffix = VOS_NULL_WORD;
VOS_UINT32 ulLockLevel;
/*lLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosStaticMemSpinLock, ulLockLevel);
for ( i=OM_MAX_RING_BUFFER_NUM -1; i>=0; i-- )
{
if ( VOS_FALSE == g_ucOMBufferOccupiedFlag[i] )
{
lTempSufffix = i;
g_ucOMBufferOccupiedFlag[i] = VOS_TRUE;
break;
}
}
/*VOS_Splx(lLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosStaticMemSpinLock, ulLockLevel);
if ( VOS_NULL_WORD == lTempSufffix )
{
return VOS_NULL_PTR;
}
/*
* bump number of bytes requested because ring buffer algorithm
* always leaves at least one empty byte in buffer
*/
/* buffer = (char *) malloc ((unsigned) ++nbytes); */
buffer = (char *) DRV_CACHEDMAM_ALLOC((unsigned) ++nbytes);
if ( VOS_NULL_PTR == buffer )
{
/*lLockLevel = VOS_SplIMP();*/
VOS_SpinLockIntLock(&g_stVosStaticMemSpinLock, ulLockLevel);
g_ucOMBufferOccupiedFlag[lTempSufffix] = VOS_FALSE;
/*VOS_Splx(lLockLevel);*/
VOS_SpinUnlockIntUnlock(&g_stVosStaticMemSpinLock, ulLockLevel);
OM_DRV_CACHEDMAM_ALLOC_ERROR();
return VOS_NULL_PTR;
}
ringId = &(g_stOMControlBlock[lTempSufffix]);
ringId->bufSize = nbytes;
ringId->buf = buffer;
OM_RingBufferFlush (ringId);
return (ringId);
}
