static void rt2870_rts_frame_complete_tasklet(unsigned long data)
{
PRTMP_ADAPTER pAd;
PTX_CONTEXT pRTSContext;
purbb_t pUrb;
NTSTATUS Status;
unsigned long irqFlag;
pUrb = (purbb_t)data;
pRTSContext = (PTX_CONTEXT)pUrb->context;
pAd = pRTSContext->pAd;
Status = pUrb->status;
// Reset RTS frame context flags
RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], irqFlag);
pRTSContext->IRPPending = FALSE;
pRTSContext->InUse = FALSE;
if (Status == USB_ST_NOERROR)
{
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
}
else // STATUS_OTHER
{
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out RTS Frame Failed\n"));
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
}
else
{
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
}
}
RTMP_SEM_LOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId]);
pAd->BulkOutPending[pRTSContext->BulkOutPipeId] = FALSE;
RTMP_SEM_UNLOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId]);
// Always call Bulk routine, even reset bulk.
// The protectioon of rest bulk should be in BulkOut routine
RTUSBKickBulkOut(pAd);
}
// RTS frame use BulkOutPipeId = PipeID
VOID RTUSBBulkOutRTSFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs)
{
PRTMP_ADAPTER pAd;
PTX_CONTEXT pRTSContext;
NTSTATUS status;
unsigned long IrqFlags;
pRTSContext= (PTX_CONTEXT)pUrb->context;
pAd = pRTSContext->pAd;
DBGPRINT_RAW(RT_DEBUG_INFO, "--->RTUSBBulkOutRTSFrameComplete\n");
// Reset RTS frame context flags
pRTSContext->IRPPending = FALSE;
pRTSContext->InUse = FALSE;
status = pUrb->status;
if (status == USB_ST_NOERROR)
{
// Don't worry about the queue is empty or not, this function will check itself
RTMPDeQueuePacket(pAd, pRTSContext->BulkOutPipeId);
}
#if 1 // STATUS_OTHER
else
{
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, "Bulk Out RTS Frame Failed\n");
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
RTUSBEnqueueInternalCmd(pAd, RT_OID_USB_RESET_BULK_OUT);
}
}
#endif
NdisAcquireSpinLock(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId], IrqFlags);
pAd->BulkOutPending[pRTSContext->BulkOutPipeId] = FALSE;
NdisReleaseSpinLock(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId], IrqFlags);
// Always call Bulk routine, even reset bulk.
// The protectioon of rest bulk should be in BulkOut routine
RTUSBKickBulkOut(pAd);
DBGPRINT_RAW(RT_DEBUG_INFO, "<---RTUSBBulkOutRTSFrameComplete\n");
}
static void rt2870_ac0_dma_done_tasklet(unsigned long data)
{
PRTMP_ADAPTER pAd;
PHT_TX_CONTEXT pHTTXContext;
UCHAR BulkOutPipeId = 0;
purbb_t pUrb;
pUrb = (purbb_t)data;
pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
pAd = pHTTXContext->pAd;
rt2870_dataout_complete_tasklet((unsigned long)pUrb);
if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
fRTMP_ADAPTER_HALT_IN_PROGRESS |
fRTMP_ADAPTER_NIC_NOT_EXIST))))
{
// do nothing and return directly.
}
else
{
if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))
{
RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
}
else
{ pHTTXContext = &pAd->TxContext[BulkOutPipeId];
if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) &&
/* ((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */
(pAd->DeQueueRunning[BulkOutPipeId] == FALSE) &&
(pHTTXContext->bCurWriting == FALSE))
{
RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);
}
RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL);
RTUSBKickBulkOut(pAd);
}
}
return;
}
// ************************ Completion Func ************************ //
VOID RTUSBBulkOutDataPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs)
{
PTX_CONTEXT pTxContext;
PRTMP_ADAPTER pAd;
NTSTATUS status;
UCHAR BulkOutPipeId;
unsigned long IrqFlags;
DBGPRINT_RAW(RT_DEBUG_INFO, "--->RTUSBBulkOutDataPacketComplete\n");
pTxContext= (PTX_CONTEXT)pUrb->context;
pAd = pTxContext->pAd;
status = pUrb->status;
// Store BulkOut PipeId
BulkOutPipeId = pTxContext->BulkOutPipeId;
pAd->BulkOutDataOneSecCount++;
if (status == USB_ST_NOERROR)
{
DBGPRINT_RAW(RT_DEBUG_INFO, "BulkOutDataPacketComplete %d (STATUS_SUCCESS)\n", BulkOutPipeId);
if (pTxContext->LastOne == TRUE)
{
pAd->Counters.GoodTransmits++;
FREE_TX_RING(pAd, BulkOutPipeId, pTxContext);
pAd->TxRingTotalNumber[BulkOutPipeId]--; // sync. to TxCount
if (pAd->SendTxWaitQueue[BulkOutPipeId].Number > 0)
{
RTMPDeQueuePacket(pAd, BulkOutPipeId);
}
}
else
{
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
FREE_TX_RING(pAd, BulkOutPipeId, pTxContext);
pAd->TxRingTotalNumber[BulkOutPipeId]--; // sync. to TxCount
// Indicate next one is frag data which has highest priority
RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId));
}
else
{
while (pTxContext->LastOne != TRUE)
{
FREE_TX_RING(pAd, BulkOutPipeId, pTxContext);
pAd->TxRingTotalNumber[BulkOutPipeId]--; // sync. to TxCount
pTxContext = &(pAd->TxContext[BulkOutPipeId][pAd->NextBulkOutIndex[BulkOutPipeId]]);
}
FREE_TX_RING(pAd, BulkOutPipeId, pTxContext);
pAd->TxRingTotalNumber[BulkOutPipeId]--; // sync. to TxCount
}
}
}
#if 1 // STATUS_OTHER
else
{
DBGPRINT_RAW(RT_DEBUG_ERROR, "BulkOutDataPacketComplete %d (STATUS_OTHER)\n", BulkOutPipeId);
while (pTxContext->LastOne != TRUE)
{
FREE_TX_RING(pAd, BulkOutPipeId, pTxContext);
pAd->TxRingTotalNumber[BulkOutPipeId]--; // sync. to TxCount
pTxContext = &(pAd->TxContext[BulkOutPipeId][pAd->NextBulkOutIndex[BulkOutPipeId]]);
}
FREE_TX_RING(pAd, BulkOutPipeId, pTxContext);
pAd->TxRingTotalNumber[BulkOutPipeId]--; // sync. to TxCount
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
RTUSBEnqueueInternalCmd(pAd, RT_OID_USB_RESET_BULK_OUT);
}
}
#endif
pTxContext = &(pAd->TxContext[BulkOutPipeId][pAd->NextBulkOutIndex[BulkOutPipeId]]);
//
// bInUse = TRUE, means some process are filling TX data, after that must turn on bWaitingBulkOut
// bWaitingBulkOut = TRUE, means the TX data are waiting for bulk out.
//
if ((pTxContext->bWaitingBulkOut == TRUE) && !RTUSB_TEST_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId)))
{
// Indicate There is data avaliable
RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
}
NdisAcquireSpinLock(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
pAd->BulkOutPending[BulkOutPipeId] = FALSE;
NdisReleaseSpinLock(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
// Always call Bulk routine, even reset bulk.
// The protectioon of rest bulk should be in BulkOut routine
RTUSBKickBulkOut(pAd);
}
/*
========================================================================
Routine Description:
This routine process Rx Irp and call rx complete function.
Arguments:
DeviceObject Pointer to the device object for next lower
device. DeviceObject passed in here belongs to
the next lower driver in the stack because we
were invoked via IoCallDriver in USB_RxPacket
AND it is not OUR device object
Irp Ptr to completed IRP
Context Ptr to our Adapter object (context specified
in IoSetCompletionRoutine
Return Value:
Always returns STATUS_MORE_PROCESSING_REQUIRED
Note:
Always returns STATUS_MORE_PROCESSING_REQUIRED
========================================================================
*/
VOID RTUSBBulkRxComplete(purbb_t pUrb, struct pt_regs *pt_regs)
{
PRX_CONTEXT pRxContext;
PRTMP_ADAPTER pAd;
NTSTATUS status;
pRxContext= (PRX_CONTEXT)pUrb->context;
pAd = pRxContext->pAd;
//
// We have a number of cases:
// 1) The USB read timed out and we received no data.
// 2) The USB read timed out and we received some data.
// 3) The USB read was successful and fully filled our irp buffer.
// 4) The irp was cancelled.
// 5) Some other failure from the USB device object.
//
//
// Free the IRP and its mdl because they were alloced by us
//
#if 0
if ( (atomread = (atomic_read(&pRxContext->IrpLock))) == IRPLOCK_CANCE_START)
{
atomic_dec(&pAd->PendingRx);
atomic_set(&pRxContext->IrpLock, IRPLOCK_CANCE_COMPLETE);
}
#endif
status = pUrb->status;
atomic_set(&pRxContext->IrpLock, IRPLOCK_COMPLETED);
if( atomic_read(&pAd->PendingRx) > 0)
atomic_dec(&pAd->PendingRx);
switch (status)
{
case 0:
break;
case -ECONNRESET: // async unlink
case -ESHUTDOWN: // hardware gone = -108
//pUrb = NULL;
DBGPRINT(RT_DEBUG_ERROR, "==> RTUSBBulkRxComplete Error code = %d\n", status);
break;
default:
DBGPRINT(RT_DEBUG_ERROR, "==> RTUSBBulkRxComplete UnKnown Error code = %d\n", status);
break;
}
if (atomic_read(&pRxContext->IrpLock) != IRPLOCK_CANCE_START)
{
pAd->rx_bh.data = (unsigned long)pUrb;
if(!RTMP_TEST_FLAG(pAd,fRTMP_ADAPTER_HALT_IN_PROGRESS)) //Add by Zero:Jan09.2008 Fix IF down crash
tasklet_schedule(&pAd->rx_bh);
//iverson patch usb 1.1 or 2.0 2007 1109
if(pAd->BulkOutMaxPacketSize == 512)
{
DBGPRINT(RT_DEBUG_INFO, "In USB 2.0 Mode \n");
}
else{
RTUSBBulkReceive(pAd);
}
}
else
DBGPRINT(RT_DEBUG_INFO, "==> RTUSBBulkRxComplete (IrpLock) = %d\n", atomic_read(&pRxContext->IrpLock));
#if 0
if ((status == USB_ST_NOERROR) && (atomic_read(&pRxContext->IrpLock) != IRPLOCK_CANCE_START))
{
RTUSBRxPacket(pUrb);
//tasklet_schedule(&pAd->rx_bh);
}// STATUS_SUCCESS
else
{
DBGPRINT(RT_DEBUG_TEMP,"==> RTUSBBulkRxComplete Error code = %d\n", status);
pRxContext->InUse = FALSE;
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, "Bulk In Failed\n");
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET);
RTUSBEnqueueInternalCmd(pAd, RT_OID_USB_RESET_BULK_IN);
}
}
#endif
}
// MLME use BulkOutPipeId = 0
VOID RTUSBBulkOutMLMEPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs)
{
PTX_CONTEXT pMLMEContext;
PRTMP_ADAPTER pAd;
NTSTATUS status;
unsigned long IrqFlags;
pMLMEContext= (PTX_CONTEXT)pUrb->context;
pAd = pMLMEContext->pAd;
status = pUrb->status;
pAd->PrioRingTxCnt--;
if (pAd->PrioRingTxCnt < 0)
pAd->PrioRingTxCnt = 0;
pAd->PrioRingFirstIndex++;
if (pAd->PrioRingFirstIndex >= PRIO_RING_SIZE)
{
pAd->PrioRingFirstIndex = 0;
}
DBGPRINT(RT_DEBUG_INFO, "RTUSBBulkOutMLMEPacketComplete::PrioRingFirstIndex = %d, PrioRingTxCnt = %d, PopMgmtIndex = %d, PushMgmtIndex = %d, NextMLMEIndex = %d\n",
pAd->PrioRingFirstIndex,
pAd->PrioRingTxCnt, pAd->PopMgmtIndex, pAd->PushMgmtIndex, pAd->NextMLMEIndex);
DBGPRINT_RAW(RT_DEBUG_INFO, "--->RTUSBBulkOutMLMEPacketComplete\n");
// Reset MLME context flags
pMLMEContext->IRPPending = FALSE;
pMLMEContext->InUse = FALSE;
pMLMEContext->bWaitingBulkOut =FALSE;
if (status == USB_ST_NOERROR)
{
// Don't worry about the queue is empty or not, this function will check itself
RTUSBDequeueMLMEPacket(pAd);
}
#if 1 // STATUS_OTHER
else
{
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, "Bulk Out MLME Failed\n");
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
RTUSBEnqueueInternalCmd(pAd, RT_OID_USB_RESET_BULK_OUT);
}
}
#endif
pMLMEContext = &pAd->MLMEContext[pAd->PrioRingFirstIndex];
if ( (pAd->PrioRingTxCnt >= 1) && (pMLMEContext->bWaitingBulkOut == TRUE))
RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
NdisAcquireSpinLock(&pAd->BulkOutLock[0], IrqFlags);
pAd->BulkOutPending[0] = FALSE;
NdisReleaseSpinLock(&pAd->BulkOutLock[0], IrqFlags);
// Always call Bulk routine, even reset bulk.
// The protectioon of rest bulk should be in BulkOut routine
RTUSBKickBulkOut(pAd);
DBGPRINT_RAW(RT_DEBUG_INFO, "<---RTUSBBulkOutMLMEPacketComplete\n");
}
VOID ATE_RTUSBBulkOutDataPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs)
{
PRTMP_ADAPTER pAd;
PTX_CONTEXT pNullContext;
NTSTATUS status;
unsigned long IrqFlags;
ULONG OldValue;
pNullContext= (PTX_CONTEXT)pUrb->context;
pAd = pNullContext->pAd;
DBGPRINT_RAW(RT_DEBUG_INFO, "--->ATE_RTUSBBulkOutDataPacketComplete\n");
// Reset Null frame context flags
pNullContext->IRPPending = FALSE;
pNullContext->InUse = FALSE;
status = pUrb->status;
if (status == USB_ST_NOERROR)
{
// Don't worry about the queue is empty or not, this function will check itself
RTMPDeQueuePacket(pAd, 0);
}
#if 1 // STATUS_OTHER
else
{
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, "Bulk Out Null Frame Failed\n");
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
RTUSBEnqueueInternalCmd(pAd, RT_OID_USB_RESET_BULK_OUT);
}
}
#endif
if (atomic_read(&pAd->BulkOutRemained) > 0)
{
atomic_dec(&pAd->BulkOutRemained);
DBGPRINT(RT_DEBUG_INFO, "Bulk Out Remained = %d\n", atomic_read(&pAd->BulkOutRemained));
}
// 1st - Transmit Success
OldValue = pAd->WlanCounters.TransmittedFragmentCount.vv.LowPart;
pAd->WlanCounters.TransmittedFragmentCount.vv.LowPart++;
if (pAd->WlanCounters.TransmittedFragmentCount.vv.LowPart < OldValue)
{
pAd->WlanCounters.TransmittedFragmentCount.vv.HighPart++;
}
if(((pAd->ContinBulkOut == TRUE ) ||(atomic_read(&pAd->BulkOutRemained) > 0)) && (pAd->ate.Mode != ATE_STASTART))
{
DBGPRINT(RT_DEBUG_INFO, "ContinBulkOut = TRUE \n");
RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
}
else
{
RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
}
NdisAcquireSpinLock(&pAd->BulkOutLock[0], IrqFlags);
pAd->BulkOutPending[0] = FALSE;
NdisReleaseSpinLock(&pAd->BulkOutLock[0], IrqFlags);
// Always call Bulk routine, even reset bulk.
// The protectioon of rest bulk should be in BulkOut routine
RTUSBKickBulkOut(pAd);
DBGPRINT_RAW(RT_DEBUG_INFO, "<---ATE_RTUSBBulkOutDataPacketComplete\n");
}
void RTUSBWatchDog(struct rt_rtmp_adapter *pAd)
{
struct rt_ht_tx_context *pHTTXContext;
int idx;
unsigned long irqFlags;
PURB pUrb;
BOOLEAN needDumpSeq = FALSE;
u32 MACValue;
u32 TxRxQ_Pcnt;
idx = 0;
RTMP_IO_READ32(pAd, TXRXQ_PCNT, &MACValue);
if ((MACValue & 0xff) != 0) {
DBGPRINT(RT_DEBUG_TRACE,
("TX QUEUE 0 Not EMPTY(Value=0x%0x)!\n",
MACValue));
RTMP_IO_WRITE32(pAd, PBF_CFG, 0xf40012);
while ((MACValue & 0xff) != 0 && (idx++ < 10)) {
RTMP_IO_READ32(pAd, TXRXQ_PCNT, &MACValue);
RTMPusecDelay(1);
}
RTMP_IO_WRITE32(pAd, PBF_CFG, 0xf40006);
}
if (pAd->watchDogRxOverFlowCnt >= 2) {
DBGPRINT(RT_DEBUG_TRACE,
("Maybe the Rx Bulk-In hanged! Cancel the pending Rx bulks request!\n"));
if ((!RTMP_TEST_FLAG
(pAd,
(fRTMP_ADAPTER_RESET_IN_PROGRESS |
fRTMP_ADAPTER_BULKIN_RESET |
fRTMP_ADAPTER_HALT_IN_PROGRESS |
fRTMP_ADAPTER_NIC_NOT_EXIST)))) {
DBGPRINT(RT_DEBUG_TRACE,
("Call CMDTHREAD_RESET_BULK_IN to cancel the pending Rx Bulk!\n"));
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET);
RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_IN,
NULL, 0);
needDumpSeq = TRUE;
}
pAd->watchDogRxOverFlowCnt = 0;
}
RTUSBReadMACRegister(pAd, 0x438, &TxRxQ_Pcnt);
for (idx = 0; idx < NUM_OF_TX_RING; idx++) {
pUrb = NULL;
RTMP_IRQ_LOCK(&pAd->BulkOutLock[idx], irqFlags);
if ((pAd->BulkOutPending[idx] == TRUE)
&& pAd->watchDogTxPendingCnt) {
int actual_length = 0, transfer_buffer_length = 0;
BOOLEAN isDataPacket = FALSE;
pAd->watchDogTxPendingCnt[idx]++;
if ((pAd->watchDogTxPendingCnt[idx] > 2) &&
(!RTMP_TEST_FLAG
(pAd,
(fRTMP_ADAPTER_RESET_IN_PROGRESS |
fRTMP_ADAPTER_HALT_IN_PROGRESS |
fRTMP_ADAPTER_NIC_NOT_EXIST |
fRTMP_ADAPTER_BULKOUT_RESET)))
) {
/* FIXME: Following code just support single bulk out. If you wanna support multiple bulk out. Modify it! */
pHTTXContext =
(struct rt_ht_tx_context *)(&pAd->TxContext[idx]);
if (pHTTXContext->IRPPending) { /* Check TxContext. */
pUrb = pHTTXContext->pUrb;
actual_length = pUrb->actual_length;
transfer_buffer_length =
pUrb->transfer_buffer_length;
isDataPacket = TRUE;
} else if (idx == MGMTPIPEIDX) {
struct rt_tx_context *pMLMEContext, *pNULLContext,
*pPsPollContext;
/*Check MgmtContext. */
pMLMEContext =
(struct rt_tx_context *)(pAd->MgmtRing.
Cell[pAd->MgmtRing.
TxDmaIdx].
AllocVa);
pPsPollContext =
(struct rt_tx_context *)(&pAd->PsPollContext);
pNULLContext =
(struct rt_tx_context *)(&pAd->NullContext);
if (pMLMEContext->IRPPending) {
ASSERT(pMLMEContext->
IRPPending);
pUrb = pMLMEContext->pUrb;
} else if (pNULLContext->IRPPending) {
ASSERT(pNULLContext->
IRPPending);
pUrb = pNULLContext->pUrb;
} else if (pPsPollContext->IRPPending) {
ASSERT(pPsPollContext->
IRPPending);
pUrb = pPsPollContext->pUrb;
}
}
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[idx],
irqFlags);
printk(KERN_INFO "%d:%lu LTL=%d , TL=%d L:%d\n",
idx, pAd->watchDogTxPendingCnt[idx],
pAd->TransferedLength[idx],
actual_length, transfer_buffer_length);
if (pUrb) {
if ((isDataPacket
&& pAd->TransferedLength[idx] ==
actual_length
&& pAd->TransferedLength[idx] <
transfer_buffer_length
&& actual_length != 0
/* && TxRxQ_Pcnt==0 */
&& pAd->watchDogTxPendingCnt[idx] >
3)
|| isDataPacket == FALSE
|| pAd->watchDogTxPendingCnt[idx] >
6) {
DBGPRINT(RT_DEBUG_TRACE,
("Maybe the Tx Bulk-Out hanged! Cancel the pending Tx bulks request of idx(%d)!\n",
idx));
DBGPRINT(RT_DEBUG_TRACE,
("Unlink the pending URB!\n"));
/* unlink it now */
RTUSB_UNLINK_URB(pUrb);
/* Sleep 200 microseconds to give cancellation time to work */
/*RTMPusecDelay(200); */
needDumpSeq = TRUE;
}
} else {
DBGPRINT(RT_DEBUG_ERROR,
("Unknown bulkOut URB maybe hanged!\n"));
}
} else {
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[idx],
irqFlags);
}
if (isDataPacket == TRUE)
pAd->TransferedLength[idx] = actual_length;
} else {
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[idx], irqFlags);
}
}
/* For Sigma debug, dump the ba_reordering sequence. */
if ((needDumpSeq == TRUE) && (pAd->CommonCfg.bDisableReordering == 0)) {
u16 Idx;
struct rt_ba_rec_entry *pBAEntry = NULL;
u8 count = 0;
struct reordering_mpdu *mpdu_blk;
Idx = pAd->MacTab.Content[BSSID_WCID].BARecWcidArray[0];
pBAEntry = &pAd->BATable.BARecEntry[Idx];
if ((pBAEntry->list.qlen > 0) && (pBAEntry->list.next != NULL)) {
DBGPRINT(RT_DEBUG_TRACE,
("NICUpdateRawCounters():The Queueing pkt in reordering buffer:\n"));
NdisAcquireSpinLock(&pBAEntry->RxReRingLock);
mpdu_blk = pBAEntry->list.next;
while (mpdu_blk) {
DBGPRINT(RT_DEBUG_TRACE,
("\t%d:Seq-%d, bAMSDU-%d!\n", count,
mpdu_blk->Sequence,
mpdu_blk->bAMSDU));
mpdu_blk = mpdu_blk->next;
count++;
}
DBGPRINT(RT_DEBUG_TRACE,
("\npBAEntry->LastIndSeq=%d!\n",
pBAEntry->LastIndSeq));
NdisReleaseSpinLock(&pBAEntry->RxReRingLock);
}
}
}
static void rt2870_mgmt_dma_done_tasklet(unsigned long data)
{
PRTMP_ADAPTER pAd;
PTX_CONTEXT pMLMEContext;
int index;
PNDIS_PACKET pPacket;
purbb_t pUrb;
NTSTATUS Status;
unsigned long IrqFlags;
pUrb = (purbb_t)data;
pMLMEContext = (PTX_CONTEXT)pUrb->context;
pAd = pMLMEContext->pAd;
Status = pUrb->status;
index = pMLMEContext->SelfIdx;
ASSERT((pAd->MgmtRing.TxDmaIdx == index));
RTMP_IRQ_LOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
if (Status != USB_ST_NOERROR)
{
//Bulk-Out fail status handle
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out MLME Failed, Status=%d!\n", Status));
// TODO: How to handle about the MLMEBulkOut failed issue. Need to resend the mgmt pkt?
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
}
}
pAd->BulkOutPending[MGMTPIPEIDX] = FALSE;
RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
RTMP_IRQ_LOCK(&pAd->MLMEBulkOutLock, IrqFlags);
// Reset MLME context flags
pMLMEContext->IRPPending = FALSE;
pMLMEContext->InUse = FALSE;
pMLMEContext->bWaitingBulkOut = FALSE;
pMLMEContext->BulkOutSize = 0;
pPacket = pAd->MgmtRing.Cell[index].pNdisPacket;
pAd->MgmtRing.Cell[index].pNdisPacket = NULL;
// Increase MgmtRing Index
INC_RING_INDEX(pAd->MgmtRing.TxDmaIdx, MGMT_RING_SIZE);
pAd->MgmtRing.TxSwFreeIdx++;
RTMP_IRQ_UNLOCK(&pAd->MLMEBulkOutLock, IrqFlags);
// No-matter success or fail, we free the mgmt packet.
if (pPacket)
RTMPFreeNdisPacket(pAd, pPacket);
if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
fRTMP_ADAPTER_HALT_IN_PROGRESS |
fRTMP_ADAPTER_NIC_NOT_EXIST))))
{
// do nothing and return directly.
}
else
{
if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET) &&
((pAd->bulkResetPipeid & BULKOUT_MGMT_RESET_FLAG) == BULKOUT_MGMT_RESET_FLAG))
{ // For Mgmt Bulk-Out failed, ignore it now.
RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
}
else
{
// Always call Bulk routine, even reset bulk.
// The protectioon of rest bulk should be in BulkOut routine
if (pAd->MgmtRing.TxSwFreeIdx < MGMT_RING_SIZE /* pMLMEContext->bWaitingBulkOut == TRUE */)
{
RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
}
RTUSBKickBulkOut(pAd);
}
}
}
/*
========================================================================
Routine Description:
Handle received packets.
Arguments:
data - URB information pointer
Return Value:
None
Note:
========================================================================
*/
static void rx_done_tasklet(unsigned long data)
{
purbb_t pUrb;
PRX_CONTEXT pRxContext;
PRTMP_ADAPTER pAd;
NTSTATUS Status;
unsigned int IrqFlags;
pUrb = (purbb_t)data;
pRxContext = (PRX_CONTEXT)pUrb->context;
pAd = pRxContext->pAd;
Status = pUrb->status;
RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
pRxContext->InUse = FALSE;
pRxContext->IRPPending = FALSE;
pRxContext->BulkInOffset += pUrb->actual_length;
//NdisInterlockedDecrement(&pAd->PendingRx);
pAd->PendingRx--;
if (Status == USB_ST_NOERROR)
{
pAd->BulkInComplete++;
pAd->NextRxBulkInPosition = 0;
if (pRxContext->BulkInOffset) // As jan's comment, it may bulk-in success but size is zero.
{
pRxContext->Readable = TRUE;
INC_RING_INDEX(pAd->NextRxBulkInIndex, RX_RING_SIZE);
}
RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
}
else // STATUS_OTHER
{
pAd->BulkInCompleteFail++;
// Still read this packet although it may comtain wrong bytes.
pRxContext->Readable = FALSE;
RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
// Parsing all packets. because after reset, the index will reset to all zero.
if ((!RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
fRTMP_ADAPTER_BULKIN_RESET |
fRTMP_ADAPTER_HALT_IN_PROGRESS |
fRTMP_ADAPTER_NIC_NOT_EXIST))))
{
DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk In Failed. Status=%d, BIIdx=0x%x, BIRIdx=0x%x, actual_length= 0x%x\n",
Status, pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex, pRxContext->pUrb->actual_length));
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET);
RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_IN, NULL, 0);
}
}
ASSERT((pRxContext->InUse == pRxContext->IRPPending));
#ifdef RALINK_ATE
if (ATE_ON(pAd))
{
// If the driver is in ATE mode and Rx frame is set into here.
if (pAd->ContinBulkIn == TRUE)
{
RTUSBBulkReceive(pAd);
}
}
else
#endif // RALINK_ATE //
RTUSBBulkReceive(pAd);
return;
}
/*
==========================================================================
Description:
Scan next channel
==========================================================================
*/
VOID ScanNextChannel(
IN PRTMP_ADAPTER pAd)
{
HEADER_802_11 Hdr80211;
PUCHAR pOutBuffer = NULL;
NDIS_STATUS NStatus;
ULONG FrameLen = 0;
UCHAR SsidLen = 0, ScanType = pAd->MlmeAux.ScanType, BBPValue = 0;
#ifdef CONFIG_STA_SUPPORT
USHORT Status;
PHEADER_802_11 pHdr80211;
#endif // CONFIG_STA_SUPPORT //
UINT ScanTimeIn5gChannel = SHORT_CHANNEL_TIME;
#ifdef CONFIG_STA_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
{
if (MONITOR_ON(pAd))
return;
}
#endif // CONFIG_STA_SUPPORT //
#ifdef RALINK_ATE
// Nothing to do in ATE mode.
if (ATE_ON(pAd))
return;
#endif // RALINK_ATE //
if (pAd->MlmeAux.Channel == 0)
{
if ((pAd->CommonCfg.BBPCurrentBW == BW_40)
#ifdef CONFIG_STA_SUPPORT
&& (INFRA_ON(pAd)
|| (pAd->OpMode == OPMODE_AP))
#endif // CONFIG_STA_SUPPORT //
)
{
AsicSwitchChannel(pAd, pAd->CommonCfg.CentralChannel, FALSE);
AsicLockChannel(pAd, pAd->CommonCfg.CentralChannel);
RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &BBPValue);
BBPValue &= (~0x18);
BBPValue |= 0x10;
RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, BBPValue);
DBGPRINT(RT_DEBUG_TRACE, ("SYNC - End of SCAN, restore to 40MHz channel %d, Total BSS[%02d]\n",pAd->CommonCfg.CentralChannel, pAd->ScanTab.BssNr));
}
else
{
AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
AsicLockChannel(pAd, pAd->CommonCfg.Channel);
DBGPRINT(RT_DEBUG_TRACE, ("SYNC - End of SCAN, restore to channel %d, Total BSS[%02d]\n",pAd->CommonCfg.Channel, pAd->ScanTab.BssNr));
}
#ifdef CONFIG_STA_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
{
//
// To prevent data lost.
// Send an NULL data with turned PSM bit on to current associated AP before SCAN progress.
// Now, we need to send an NULL data with turned PSM bit off to AP, when scan progress done
//
if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED) && (INFRA_ON(pAd)))
{
NStatus = MlmeAllocateMemory(pAd, (PVOID)&pOutBuffer);
if (NStatus == NDIS_STATUS_SUCCESS)
{
pHdr80211 = (PHEADER_802_11) pOutBuffer;
MgtMacHeaderInit(pAd, pHdr80211, SUBTYPE_NULL_FUNC, 1, pAd->CommonCfg.Bssid, pAd->CommonCfg.Bssid);
pHdr80211->Duration = 0;
pHdr80211->FC.Type = BTYPE_DATA;
pHdr80211->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE);
// Send using priority queue
MiniportMMRequest(pAd, 0, pOutBuffer, sizeof(HEADER_802_11));
DBGPRINT(RT_DEBUG_TRACE, ("MlmeScanReqAction -- Send PSM Data frame\n"));
MlmeFreeMemory(pAd, pOutBuffer);
RTMPusecDelay(5000);
}
}
pAd->Mlme.SyncMachine.CurrState = SYNC_IDLE;
Status = MLME_SUCCESS;
MlmeEnqueue(pAd, MLME_CNTL_STATE_MACHINE, MT2_SCAN_CONF, 2, &Status);
RTMPSendWirelessEvent(pAd, IW_SCAN_COMPLETED_EVENT_FLAG, NULL, BSS0, 0);
#ifdef LINUX
#ifdef RT_CFG80211_SUPPORT
RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_SCAN_END, NULL, 0);
#endif // RT_CFG80211_SUPPORT //
#endif // LINUX //
}
#endif // CONFIG_STA_SUPPORT //
RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS);
}
#ifdef RTMP_MAC_USB
#ifdef CONFIG_STA_SUPPORT
else if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST) && (pAd->OpMode == OPMODE_STA))
