diff options
Diffstat (limited to 'drivers/staging/rt2860/rt_usb.c')
-rw-r--r-- | drivers/staging/rt2860/rt_usb.c | 799 |
1 files changed, 799 insertions, 0 deletions
diff --git a/drivers/staging/rt2860/rt_usb.c b/drivers/staging/rt2860/rt_usb.c new file mode 100644 index 000000000000..01a7eb4e8ba8 --- /dev/null +++ b/drivers/staging/rt2860/rt_usb.c @@ -0,0 +1,799 @@ +/* + ************************************************************************* + * Ralink Tech Inc. + * 5F., No.36, Taiyuan St., Jhubei City, + * Hsinchu County 302, + * Taiwan, R.O.C. + * + * (c) Copyright 2002-2007, Ralink Technology, Inc. + * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * * + ************************************************************************* + + Module Name: + rtusb_bulk.c + + Abstract: + + Revision History: + Who When What + -------- ---------- ---------------------------------------------- + Name Date Modification logs + +*/ + +#include "rt_config.h" + +void dump_urb(struct urb *purb) +{ + printk("urb :0x%08lx\n", (unsigned long)purb); + printk("\tdev :0x%08lx\n", (unsigned long)purb->dev); + printk("\t\tdev->state :0x%d\n", purb->dev->state); + printk("\tpipe :0x%08x\n", purb->pipe); + printk("\tstatus :%d\n", purb->status); + printk("\ttransfer_flags :0x%08x\n", purb->transfer_flags); + printk("\ttransfer_buffer :0x%08lx\n", + (unsigned long)purb->transfer_buffer); + printk("\ttransfer_buffer_length:%d\n", purb->transfer_buffer_length); + printk("\tactual_length :%d\n", purb->actual_length); + printk("\tsetup_packet :0x%08lx\n", + (unsigned long)purb->setup_packet); + printk("\tstart_frame :%d\n", purb->start_frame); + printk("\tnumber_of_packets :%d\n", purb->number_of_packets); + printk("\tinterval :%d\n", purb->interval); + printk("\terror_count :%d\n", purb->error_count); + printk("\tcontext :0x%08lx\n", + (unsigned long)purb->context); + printk("\tcomplete :0x%08lx\n\n", + (unsigned long)purb->complete); +} + +/* +======================================================================== +Routine Description: + Create kernel threads & tasklets. + +Arguments: + *net_dev Pointer to wireless net device interface + +Return Value: + NDIS_STATUS_SUCCESS + NDIS_STATUS_FAILURE + +Note: +======================================================================== +*/ +int RtmpMgmtTaskInit(struct rt_rtmp_adapter *pAd) +{ + struct rt_rtmp_os_task *pTask; + int status; + + /* + Creat TimerQ Thread, We need init timerQ related structure before create the timer thread. + */ + RtmpTimerQInit(pAd); + + pTask = &pAd->timerTask; + RtmpOSTaskInit(pTask, "RtmpTimerTask", pAd); + status = RtmpOSTaskAttach(pTask, RtmpTimerQThread, pTask); + if (status == NDIS_STATUS_FAILURE) { + printk(KERN_WARNING "%s: unable to start RtmpTimerQThread\n", + RTMP_OS_NETDEV_GET_DEVNAME(pAd->net_dev)); + return NDIS_STATUS_FAILURE; + } + + /* Creat MLME Thread */ + pTask = &pAd->mlmeTask; + RtmpOSTaskInit(pTask, "RtmpMlmeTask", pAd); + status = RtmpOSTaskAttach(pTask, MlmeThread, pTask); + if (status == NDIS_STATUS_FAILURE) { + printk(KERN_WARNING "%s: unable to start MlmeThread\n", + RTMP_OS_NETDEV_GET_DEVNAME(pAd->net_dev)); + return NDIS_STATUS_FAILURE; + } + + /* Creat Command Thread */ + pTask = &pAd->cmdQTask; + RtmpOSTaskInit(pTask, "RtmpCmdQTask", pAd); + status = RtmpOSTaskAttach(pTask, RTUSBCmdThread, pTask); + if (status == NDIS_STATUS_FAILURE) { + printk(KERN_WARNING "%s: unable to start RTUSBCmdThread\n", + RTMP_OS_NETDEV_GET_DEVNAME(pAd->net_dev)); + return NDIS_STATUS_FAILURE; + } + + return NDIS_STATUS_SUCCESS; +} + +/* +======================================================================== +Routine Description: + Close kernel threads. + +Arguments: + *pAd the raxx interface data pointer + +Return Value: + NONE + +Note: +======================================================================== +*/ +void RtmpMgmtTaskExit(struct rt_rtmp_adapter *pAd) +{ + int ret; + struct rt_rtmp_os_task *pTask; + + /* Sleep 50 milliseconds so pending io might finish normally */ + RTMPusecDelay(50000); + + /* We want to wait until all pending receives and sends to the */ + /* device object. We cancel any */ + /* irps. Wait until sends and receives have stopped. */ + RTUSBCancelPendingIRPs(pAd); + + /* We need clear timerQ related structure before exits of the timer thread. */ + RtmpTimerQExit(pAd); + + /* Terminate Mlme Thread */ + pTask = &pAd->mlmeTask; + ret = RtmpOSTaskKill(pTask); + if (ret == NDIS_STATUS_FAILURE) { + DBGPRINT(RT_DEBUG_ERROR, ("%s: kill task(%s) failed!\n", + RTMP_OS_NETDEV_GET_DEVNAME(pAd-> + net_dev), + pTask->taskName)); + } + + /* Terminate cmdQ thread */ + pTask = &pAd->cmdQTask; +#ifdef KTHREAD_SUPPORT + if (pTask->kthread_task) +#else + CHECK_PID_LEGALITY(pTask->taskPID) +#endif + { + mb(); + NdisAcquireSpinLock(&pAd->CmdQLock); + pAd->CmdQ.CmdQState = RTMP_TASK_STAT_STOPED; + NdisReleaseSpinLock(&pAd->CmdQLock); + mb(); + /*RTUSBCMDUp(pAd); */ + ret = RtmpOSTaskKill(pTask); + if (ret == NDIS_STATUS_FAILURE) { + DBGPRINT(RT_DEBUG_ERROR, ("%s: kill task(%s) failed!\n", + RTMP_OS_NETDEV_GET_DEVNAME + (pAd->net_dev), + pTask->taskName)); + } + pAd->CmdQ.CmdQState = RTMP_TASK_STAT_UNKNOWN; + } + + /* Terminate timer thread */ + pTask = &pAd->timerTask; + ret = RtmpOSTaskKill(pTask); + if (ret == NDIS_STATUS_FAILURE) { + DBGPRINT(RT_DEBUG_ERROR, ("%s: kill task(%s) failed!\n", + RTMP_OS_NETDEV_GET_DEVNAME(pAd-> + net_dev), + pTask->taskName)); + } + +} + +static void rtusb_dataout_complete(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct urb *pUrb; + struct os_cookie *pObj; + struct rt_ht_tx_context *pHTTXContext; + u8 BulkOutPipeId; + int Status; + unsigned long IrqFlags; + + pUrb = (struct urb *)data; + pHTTXContext = (struct rt_ht_tx_context *)pUrb->context; + pAd = pHTTXContext->pAd; + pObj = (struct os_cookie *)pAd->OS_Cookie; + Status = pUrb->status; + + /* Store BulkOut PipeId */ + BulkOutPipeId = pHTTXContext->BulkOutPipeId; + pAd->BulkOutDataOneSecCount++; + + /*DBGPRINT(RT_DEBUG_LOUD, ("Done-B(%d):I=0x%lx, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", BulkOutPipeId, in_interrupt(), pHTTXContext->CurWritePosition, */ + /* pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad)); */ + + RTMP_IRQ_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags); + pAd->BulkOutPending[BulkOutPipeId] = FALSE; + pHTTXContext->IRPPending = FALSE; + pAd->watchDogTxPendingCnt[BulkOutPipeId] = 0; + + if (Status == USB_ST_NOERROR) { + pAd->BulkOutComplete++; + + RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags); + + pAd->Counters8023.GoodTransmits++; + /*RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags); */ + FREE_HTTX_RING(pAd, BulkOutPipeId, pHTTXContext); + /*RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags); */ + + } else /* STATUS_OTHER */ + { + u8 *pBuf; + + pAd->BulkOutCompleteOther++; + + pBuf = + &pHTTXContext->TransferBuffer->field. + WirelessPacket[pHTTXContext->NextBulkOutPosition]; + + if (!RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS | + fRTMP_ADAPTER_HALT_IN_PROGRESS | + fRTMP_ADAPTER_NIC_NOT_EXIST | + fRTMP_ADAPTER_BULKOUT_RESET))) { + RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET); + pAd->bulkResetPipeid = BulkOutPipeId; + pAd->bulkResetReq[BulkOutPipeId] = pAd->BulkOutReq; + } + RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags); + + DBGPRINT_RAW(RT_DEBUG_ERROR, + ("BulkOutDataPacket failed: ReasonCode=%d!\n", + Status)); + DBGPRINT_RAW(RT_DEBUG_ERROR, + ("\t>>BulkOut Req=0x%lx, Complete=0x%lx, Other=0x%lx\n", + pAd->BulkOutReq, pAd->BulkOutComplete, + pAd->BulkOutCompleteOther)); + DBGPRINT_RAW(RT_DEBUG_ERROR, + ("\t>>BulkOut Header:%x %x %x %x %x %x %x %x\n", + pBuf[0], pBuf[1], pBuf[2], pBuf[3], pBuf[4], + pBuf[5], pBuf[6], pBuf[7])); + /*DBGPRINT_RAW(RT_DEBUG_ERROR, (">>BulkOutCompleteCancel=0x%x, BulkOutCompleteOther=0x%x\n", pAd->BulkOutCompleteCancel, pAd->BulkOutCompleteOther)); */ + + } + + /* */ + /* 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. */ + /* */ + /*RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags); */ + if ((pHTTXContext->ENextBulkOutPosition != + pHTTXContext->CurWritePosition) + && (pHTTXContext->ENextBulkOutPosition != + (pHTTXContext->CurWritePosition + 8)) + && !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)); + } + /*RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags); */ + + /* Always call Bulk routine, even reset bulk. */ + /* The protection of rest bulk should be in BulkOut routine */ + RTUSBKickBulkOut(pAd); +} + +static void rtusb_null_frame_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_tx_context *pNullContext; + struct urb *pUrb; + int Status; + unsigned long irqFlag; + + pUrb = (struct urb *)data; + pNullContext = (struct rt_tx_context *)pUrb->context; + pAd = pNullContext->pAd; + Status = pUrb->status; + + /* Reset Null frame context flags */ + RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], irqFlag); + pNullContext->IRPPending = FALSE; + pNullContext->InUse = FALSE; + pAd->BulkOutPending[0] = FALSE; + pAd->watchDogTxPendingCnt[0] = 0; + + 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 Null Frame Failed, ReasonCode=%d!\n", + Status)); + 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); + } + } + + /* Always call Bulk routine, even reset bulk. */ + /* The protectioon of rest bulk should be in BulkOut routine */ + RTUSBKickBulkOut(pAd); +} + +static void rtusb_rts_frame_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_tx_context *pRTSContext; + struct urb *pUrb; + int Status; + unsigned long irqFlag; + + pUrb = (struct urb *)data; + pRTSContext = (struct rt_tx_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); + +} + +static void rtusb_pspoll_frame_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_tx_context *pPsPollContext; + struct urb *pUrb; + int Status; + + pUrb = (struct urb *)data; + pPsPollContext = (struct rt_tx_context *)pUrb->context; + pAd = pPsPollContext->pAd; + Status = pUrb->status; + + /* Reset PsPoll context flags */ + pPsPollContext->IRPPending = FALSE; + pPsPollContext->InUse = FALSE; + pAd->watchDogTxPendingCnt[0] = 0; + + if (Status == USB_ST_NOERROR) { + 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 PSPoll Failed\n")); + RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET); + pAd->bulkResetPipeid = + (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG); + RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, + NULL, 0); + } + } + + RTMP_SEM_LOCK(&pAd->BulkOutLock[0]); + pAd->BulkOutPending[0] = FALSE; + RTMP_SEM_UNLOCK(&pAd->BulkOutLock[0]); + + /* Always call Bulk routine, even reset bulk. */ + /* The protectioon of rest bulk should be in BulkOut routine */ + RTUSBKickBulkOut(pAd); + +} + +/* +======================================================================== +Routine Description: + Handle received packets. + +Arguments: + data - URB information pointer + +Return Value: + None + +Note: +======================================================================== +*/ +static void rx_done_tasklet(unsigned long data) +{ + struct urb *pUrb; + struct rt_rx_context *pRxContext; + struct rt_rtmp_adapter *pAd; + int Status; + unsigned int IrqFlags; + + pUrb = (struct urb *)data; + pRxContext = (struct rt_rx_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)); + + RTUSBBulkReceive(pAd); + + return; + +} + +static void rtusb_mgmt_dma_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_tx_context *pMLMEContext; + int index; + void *pPacket; + struct urb *pUrb; + int Status; + unsigned long IrqFlags; + + pUrb = (struct urb *)data; + pMLMEContext = (struct rt_tx_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); + } + } + +} + +static void rtusb_ac3_dma_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_ht_tx_context *pHTTXContext; + u8 BulkOutPipeId = 3; + struct urb *pUrb; + + pUrb = (struct urb *)data; + pHTTXContext = (struct rt_ht_tx_context *)pUrb->context; + pAd = pHTTXContext->pAd; + + rtusb_dataout_complete((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 << 3); + RTUSBKickBulkOut(pAd); + } + } + + return; +} + +static void rtusb_ac2_dma_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_ht_tx_context *pHTTXContext; + u8 BulkOutPipeId = 2; + struct urb *pUrb; + + pUrb = (struct urb *)data; + pHTTXContext = (struct rt_ht_tx_context *)pUrb->context; + pAd = pHTTXContext->pAd; + + rtusb_dataout_complete((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 << 2); + RTUSBKickBulkOut(pAd); + } + } + + return; +} + +static void rtusb_ac1_dma_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_ht_tx_context *pHTTXContext; + u8 BulkOutPipeId = 1; + struct urb *pUrb; + + pUrb = (struct urb *)data; + pHTTXContext = (struct rt_ht_tx_context *)pUrb->context; + pAd = pHTTXContext->pAd; + + rtusb_dataout_complete((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 << 1); + RTUSBKickBulkOut(pAd); + } + } + return; + +} + +static void rtusb_ac0_dma_done_tasklet(unsigned long data) +{ + struct rt_rtmp_adapter *pAd; + struct rt_ht_tx_context *pHTTXContext; + u8 BulkOutPipeId = 0; + struct urb *pUrb; + + pUrb = (struct urb *)data; + pHTTXContext = (struct rt_ht_tx_context *)pUrb->context; + pAd = pHTTXContext->pAd; + + rtusb_dataout_complete((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; + +} + +int RtmpNetTaskInit(struct rt_rtmp_adapter *pAd) +{ + struct os_cookie *pObj = (struct os_cookie *)pAd->OS_Cookie; + + /* Create receive tasklet */ + tasklet_init(&pObj->rx_done_task, rx_done_tasklet, (unsigned long)pAd); + tasklet_init(&pObj->mgmt_dma_done_task, rtusb_mgmt_dma_done_tasklet, + (unsigned long)pAd); + tasklet_init(&pObj->ac0_dma_done_task, rtusb_ac0_dma_done_tasklet, + (unsigned long)pAd); + tasklet_init(&pObj->ac1_dma_done_task, rtusb_ac1_dma_done_tasklet, + (unsigned long)pAd); + tasklet_init(&pObj->ac2_dma_done_task, rtusb_ac2_dma_done_tasklet, + (unsigned long)pAd); + tasklet_init(&pObj->ac3_dma_done_task, rtusb_ac3_dma_done_tasklet, + (unsigned long)pAd); + tasklet_init(&pObj->tbtt_task, tbtt_tasklet, (unsigned long)pAd); + tasklet_init(&pObj->null_frame_complete_task, + rtusb_null_frame_done_tasklet, (unsigned long)pAd); + tasklet_init(&pObj->rts_frame_complete_task, + rtusb_rts_frame_done_tasklet, (unsigned long)pAd); + tasklet_init(&pObj->pspoll_frame_complete_task, + rtusb_pspoll_frame_done_tasklet, (unsigned long)pAd); + + return NDIS_STATUS_SUCCESS; +} + +void RtmpNetTaskExit(struct rt_rtmp_adapter *pAd) +{ + struct os_cookie *pObj; + + pObj = (struct os_cookie *)pAd->OS_Cookie; + + tasklet_kill(&pObj->rx_done_task); + tasklet_kill(&pObj->mgmt_dma_done_task); + tasklet_kill(&pObj->ac0_dma_done_task); + tasklet_kill(&pObj->ac1_dma_done_task); + tasklet_kill(&pObj->ac2_dma_done_task); + tasklet_kill(&pObj->ac3_dma_done_task); + tasklet_kill(&pObj->tbtt_task); + tasklet_kill(&pObj->null_frame_complete_task); + tasklet_kill(&pObj->rts_frame_complete_task); + tasklet_kill(&pObj->pspoll_frame_complete_task); +} |