VOID
ODM_CancelTimer(
IN PDM_ODM_T pDM_Odm,
IN PRT_TIMER pTimer
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
del_timer_sync(pTimer);
#elif(DM_ODM_SUPPORT_TYPE & ODM_CE)
_cancel_timer_ex(pTimer);
#elif(DM_ODM_SUPPORT_TYPE & ODM_MP)
PADAPTER Adapter = pDM_Odm->Adapter;
PlatformCancelTimer(Adapter, pTimer);
#endif
}
void
ODM_CancelTimer(
PDM_ODM_T pDM_Odm,
PRT_TIMER pTimer
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
del_timer_sync(pTimer);
#elif(DM_ODM_SUPPORT_TYPE & ODM_CE)
_cancel_timer_ex(pTimer);
#elif(DM_ODM_SUPPORT_TYPE & ODM_MP)
struct rtw_adapter *Adapter = pDM_Odm->Adapter;
PlatformCancelTimer(Adapter, pTimer);
#endif
}
VOID
FlushRxTsPendingPkts(
IN PADAPTER Adapter,
IN PRX_TS_RECORD pTS
)
{
PMGNT_INFO pMgntInfo = &Adapter->MgntInfo;
PRX_REORDER_ENTRY pRxReorderEntry;
// PRT_RFD RfdArray[REORDER_WIN_SIZE];
PRT_RFD *RfdArray;
u2Byte RfdCnt = 0;
PRT_GEN_TEMP_BUFFER pGenBuf;
if(RTIsListEmpty(&pTS->RxPendingPktList))
{
pTS->RxIndicateSeq = 0xffff;
pTS->RxIndicateState = RXTS_INDICATE_IDLE;
return;
}
pGenBuf = GetGenTempBuffer (Adapter, sizeof(PRT_RFD)*REORDER_WIN_SIZE);
RfdArray = (PRT_RFD *)pGenBuf->Buffer.Ptr;
PlatformCancelTimer(Adapter, &pTS->RxPktPendingTimer);
while(!RTIsListEmpty(&pTS->RxPendingPktList))
{
pRxReorderEntry = (PRX_REORDER_ENTRY)RTRemoveHeadList(&pTS->RxPendingPktList);
RfdArray[RfdCnt] = pRxReorderEntry->pRfd;
RfdCnt = RfdCnt + 1;
RTInsertTailList(&pMgntInfo->RxReorder_Unused_List, &pRxReorderEntry->List);
}
DrvIFIndicatePackets(Adapter, RfdArray, RfdCnt);
ReturnGenTempBuffer(Adapter, pGenBuf);
pTS->RxIndicateSeq = 0xffff;
pTS->RxIndicateState = RXTS_INDICATE_IDLE;
}
VOID
IndicateRxReorderList(
IN PADAPTER Adapter,
IN PRX_TS_RECORD pTS,
IN BOOLEAN bForced
)
{
PMGNT_INFO pMgntInfo = &Adapter->MgntInfo;
PRT_HIGH_THROUGHPUT pHTInfo = pMgntInfo->pHTInfo;
PRX_REORDER_ENTRY pReorderEntry = NULL;
u2Byte index = 0;
BOOLEAN bPktInBuf = FALSE;
// PRT_RFD pRfdIndicateArray[REORDER_WIN_SIZE];
PRT_RFD *pRfdIndicateArray;
PRT_GEN_TEMP_BUFFER pGenBuf;
Adapter->rxReorderIndEnterCnt++;
if(PlatformAtomicExchange(&Adapter->rxReorderRefCount, TRUE) == TRUE)
{
Adapter->rxReorderIndRejectCnt[0]++;
RT_TRACE(COMP_INIT, DBG_LOUD, ("IndicateRxReorderList(): There is already another thread running by AtomicExchange, happened %d times!!!\n", Adapter->rxReorderIndRejectCnt[0]));
return;
}
// Check if there is any other indication thread running.
if(pTS->RxIndicateState == RXTS_INDICATE_PROCESSING)
{
PlatformAtomicExchange(&Adapter->rxReorderRefCount, FALSE);
Adapter->rxReorderIndRejectCnt[1]++;
RT_TRACE(COMP_INIT, DBG_LOUD, ("IndicateRxReorderList(): There is already another thread running by RXTS_INDICATE_PROCESSING, happened %d times!!!\n", Adapter->rxReorderIndRejectCnt[1]));
return;
}
// Handling some condition for forced indicate case.
if(bForced)
{
if(RTIsListEmpty(&pTS->RxPendingPktList))
{
PlatformAtomicExchange(&Adapter->rxReorderRefCount, FALSE);
Adapter->rxReorderIndRejectCnt[2]++;
RT_TRACE(COMP_INIT, DBG_LOUD, ("IndicateRxReorderList(): There is already another thread running by ListEmpty, happened %d times!!!\n", Adapter->rxReorderIndRejectCnt[2]));
return;
}
else
{
pReorderEntry = (PRX_REORDER_ENTRY)RTGetHeadList(&pTS->RxPendingPktList);
pTS->RxIndicateSeq = pReorderEntry->SeqNum;
}
}
Adapter->rxReorderIndAllowCnt++;
pGenBuf = GetGenTempBuffer (Adapter, sizeof(PRT_RFD)*REORDER_WIN_SIZE);
pRfdIndicateArray = (PRT_RFD *)pGenBuf->Buffer.Ptr;
// Prepare indication list and indication.
do{
// Check if there is any packet need indicate.
while(!RTIsListEmpty(&pTS->RxPendingPktList))
{
pReorderEntry = (PRX_REORDER_ENTRY)RTGetHeadList(&pTS->RxPendingPktList);
if(!SN_LESS(pTS->RxIndicateSeq, pReorderEntry->SeqNum))
{
// This protect buffer from overflow.
if(index >= REORDER_WIN_SIZE)
{
RT_ASSERT(FALSE, ("IndicateRxReorderList(): Buffer overflow!! \n"));
bPktInBuf = TRUE;
break;
}
if(index > 0)
{
if(PlatformCompareMemory(pReorderEntry->pRfd->Address3,pRfdIndicateArray[index-1]->Address3,6) != 0)
{
bPktInBuf = TRUE;
break;
}
}
pReorderEntry = (PRX_REORDER_ENTRY)RTRemoveHeadList(&pTS->RxPendingPktList);
if(SN_EQUAL(pReorderEntry->SeqNum, pTS->RxIndicateSeq))
pTS->RxIndicateSeq = (pTS->RxIndicateSeq + 1) % 4096;
RT_TRACE(COMP_RX_REORDER, DBG_LOUD, ("RxReorderIndicatePacket(): Packets indication!! IndicateSeq: %d\n", pReorderEntry->SeqNum));
pRfdIndicateArray[index] = pReorderEntry->pRfd;
index++;
RTInsertTailList(&pMgntInfo->RxReorder_Unused_List, &pReorderEntry->List);
}
else
{
bPktInBuf = TRUE;
break;
}
}
// Handling pending timer. Set this timer to prevent from long time Rx buffering.
if(index>0)
{
// Cancel previous pending timer.
{
PlatformCancelTimer(Adapter, &pTS->RxPktPendingTimer);
// Set this as a lock to make sure that only one thread is indicating packet.
pTS->RxIndicateState = RXTS_INDICATE_PROCESSING;
}
// Indicate packets
RT_ASSERT((index<=REORDER_WIN_SIZE), ("RxReorderIndicatePacket(): Rx Reorder buffer full!! \n"));
// Packets indication.
DrvIFIndicatePackets(Adapter, pRfdIndicateArray, index);
// Update local variables.
//bPktInBuf = FALSE;
index = 0;
}
else
{
break;
}
}while(TRUE);
ReturnGenTempBuffer(Adapter, pGenBuf);
// Release the indication lock and set to new indication step.
if(bPktInBuf)
{
u1Byte set_penf_timer=FALSE;
{
if(pTS->RxIndicateState != RXTS_INDICATE_REORDER)
set_penf_timer = TRUE;
}
if (set_penf_timer == TRUE)
{
// Set new pending timer.
pTS->RxIndicateState = RXTS_INDICATE_REORDER;
PlatformSetTimer(Adapter, &pTS->RxPktPendingTimer, pHTInfo->RxReorderPendingTime);
}
}
else
{
pTS->RxIndicateState = RXTS_INDICATE_IDLE;
}
PlatformAtomicExchange(&Adapter->rxReorderRefCount, FALSE);
}
