?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: add rt2870 wireless driver
[linux-2.6/mini2440.git] / drivers / staging / rt2870 / common / rtusb_bulk.c
blob3c6ba1b9deb1b05731d32f32a40dff0115aefbb6
1 /*
2 *************************************************************************
3 * Ralink Tech Inc.
4 * 5F., No.36, Taiyuan St., Jhubei City,
5 * Hsinchu County 302,
6 * Taiwan, R.O.C.
7 *
8 * (c) Copyright 2002-2007, Ralink Technology, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 * *
25 *************************************************************************
26
27 Module Name:
28 rtusb_bulk.c
29
30 Abstract:
31
32 Revision History:
33 Who When What
34 -------- ---------- ----------------------------------------------
35 Name Date Modification logs
36 Paul Lin 06-25-2004 created
37
38 */
39
40 #include "../rt_config.h"
41 // Match total 6 bulkout endpoint to corresponding queue.
42 UCHAR EpToQueue[6]={FIFO_EDCA, FIFO_EDCA, FIFO_EDCA, FIFO_EDCA, FIFO_EDCA, FIFO_MGMT};
43
44 //static BOOLEAN SingleBulkOut = FALSE;
45
46 void RTUSB_FILL_BULK_URB (struct urb *pUrb,
47 struct usb_device *pUsb_Dev,
48 unsigned int bulkpipe,
49 void *pTransferBuf,
50 int BufSize,
51 usb_complete_t Complete,
52 void *pContext)
53 {
54
55 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
56 usb_fill_bulk_urb(pUrb, pUsb_Dev, bulkpipe, pTransferBuf, BufSize, (usb_complete_t)Complete, pContext);
57 #else
58 FILL_BULK_URB(pUrb, pUsb_Dev, bulkpipe, pTransferBuf, BufSize, Complete, pContext);
59 #endif
60
61 }
62
63 VOID RTUSBInitTxDesc(
64 IN PRTMP_ADAPTER pAd,
65 IN PTX_CONTEXT pTxContext,
66 IN UCHAR BulkOutPipeId,
67 IN usb_complete_t Func)
68 {
69 PURB pUrb;
70 PUCHAR pSrc = NULL;
71 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
72
73 pUrb = pTxContext->pUrb;
74 ASSERT(pUrb);
75
76 // Store BulkOut PipeId
77 pTxContext->BulkOutPipeId = BulkOutPipeId;
78
79 if (pTxContext->bAggregatible)
80 {
81 pSrc = &pTxContext->TransferBuffer->Aggregation[2];
82 }
83 else
84 {
85 pSrc = (PUCHAR) pTxContext->TransferBuffer->field.WirelessPacket;
86 }
87
88
89 //Initialize a tx bulk urb
90 RTUSB_FILL_BULK_URB(pUrb,
91 pObj->pUsb_Dev,
92 usb_sndbulkpipe(pObj->pUsb_Dev, pAd->BulkOutEpAddr[BulkOutPipeId]),
93 pSrc,
94 pTxContext->BulkOutSize,
95 Func,
96 pTxContext);
97
98 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
99 if (pTxContext->bAggregatible)
100 pUrb->transfer_dma = (pTxContext->data_dma + TX_BUFFER_NORMSIZE + 2);
101 else
102 pUrb->transfer_dma = pTxContext->data_dma;
103
104 pUrb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
105 #endif
106
107 }
108
109 VOID RTUSBInitHTTxDesc(
110 IN PRTMP_ADAPTER pAd,
111 IN PHT_TX_CONTEXT pTxContext,
112 IN UCHAR BulkOutPipeId,
113 IN ULONG BulkOutSize,
114 IN usb_complete_t Func)
115 {
116 PURB pUrb;
117 PUCHAR pSrc = NULL;
118 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
119
120 pUrb = pTxContext->pUrb;
121 ASSERT(pUrb);
122
123 // Store BulkOut PipeId
124 pTxContext->BulkOutPipeId = BulkOutPipeId;
125
126 pSrc = &pTxContext->TransferBuffer->field.WirelessPacket[pTxContext->NextBulkOutPosition];
127
128
129 //Initialize a tx bulk urb
130 RTUSB_FILL_BULK_URB(pUrb,
131 pObj->pUsb_Dev,
132 usb_sndbulkpipe(pObj->pUsb_Dev, pAd->BulkOutEpAddr[BulkOutPipeId]),
133 pSrc,
134 BulkOutSize,
135 Func,
136 pTxContext);
137
138 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
139 pUrb->transfer_dma = (pTxContext->data_dma + pTxContext->NextBulkOutPosition);
140 pUrb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
141 #endif
142
143 }
144
145 VOID RTUSBInitRxDesc(
146 IN PRTMP_ADAPTER pAd,
147 IN PRX_CONTEXT pRxContext)
148 {
149 PURB pUrb;
150 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
151 ULONG RX_bulk_size;
152
153
154 pUrb = pRxContext->pUrb;
155 ASSERT(pUrb);
156
157 if ( pAd->BulkInMaxPacketSize == 64)
158 RX_bulk_size = 4096;
159 else
160 RX_bulk_size = MAX_RXBULK_SIZE;
161
162 //Initialize a rx bulk urb
163 RTUSB_FILL_BULK_URB(pUrb,
164 pObj->pUsb_Dev,
165 usb_rcvbulkpipe(pObj->pUsb_Dev, pAd->BulkInEpAddr),
166 &(pRxContext->TransferBuffer[pAd->NextRxBulkInPosition]),
167 RX_bulk_size - (pAd->NextRxBulkInPosition),
168 (usb_complete_t)RTUSBBulkRxComplete,
169 (void *)pRxContext);
170
171 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
172 pUrb->transfer_dma = pRxContext->data_dma + pAd->NextRxBulkInPosition;
173 pUrb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
174 #endif
175
176
177 }
178
179 /*
180 ========================================================================
181
182 Routine Description:
183
184 Arguments:
185
186 Return Value:
187
188 Note:
189
190 ========================================================================
191 */
192
193 #define BULK_OUT_LOCK(pLock, IrqFlags) \
194 if(1 /*!(in_interrupt() & 0xffff0000)*/) \
195 RTMP_IRQ_LOCK((pLock), IrqFlags);
196
197 #define BULK_OUT_UNLOCK(pLock, IrqFlags) \
198 if(1 /*!(in_interrupt() & 0xffff0000)*/) \
199 RTMP_IRQ_UNLOCK((pLock), IrqFlags);
200
201
202 VOID RTUSBBulkOutDataPacket(
203 IN PRTMP_ADAPTER pAd,
204 IN UCHAR BulkOutPipeId,
205 IN UCHAR Index)
206 {
207
208 PHT_TX_CONTEXT pHTTXContext;
209 PURB pUrb;
210 int ret = 0;
211 PTXINFO_STRUC pTxInfo, pLastTxInfo = NULL;
212 PTXWI_STRUC pTxWI;
213 ULONG TmpBulkEndPos, ThisBulkSize;
214 unsigned long IrqFlags = 0, IrqFlags2 = 0;
215 PUCHAR pWirelessPkt, pAppendant;
216 BOOLEAN bTxQLastRound = FALSE;
217 UCHAR allzero[4]= {0x0,0x0,0x0,0x0};
218
219 BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
220 if ((pAd->BulkOutPending[BulkOutPipeId] == TRUE) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_TX))
221 {
222 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
223 return;
224 }
225 pAd->BulkOutPending[BulkOutPipeId] = TRUE;
226
227 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
228 )
229 {
230 pAd->BulkOutPending[BulkOutPipeId] = FALSE;
231 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
232 return;
233 }
234 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
235
236
237 pHTTXContext = &(pAd->TxContext[BulkOutPipeId]);
238
239 BULK_OUT_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
240 if ((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition)
241 || ((pHTTXContext->ENextBulkOutPosition-8) == pHTTXContext->CurWritePosition))
242 {
243 BULK_OUT_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
244
245 BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
246 pAd->BulkOutPending[BulkOutPipeId] = FALSE;
247
248 // Clear Data flag
249 RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId));
250 RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
251
252 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
253 return;
254 }
255
256 // Clear Data flag
257 RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId));
258 RTUSB_CLEAR_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
259
260 //DBGPRINT(RT_DEBUG_TRACE,("BulkOut-B:I=0x%lx, CWPos=%ld, CWRPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", in_interrupt(),
261 // pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos, pHTTXContext->NextBulkOutPosition,
262 // pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
263 pHTTXContext->NextBulkOutPosition = pHTTXContext->ENextBulkOutPosition;
264 ThisBulkSize = 0;
265 TmpBulkEndPos = pHTTXContext->NextBulkOutPosition;
266 pWirelessPkt = &pHTTXContext->TransferBuffer->field.WirelessPacket[0];
267
268 if ((pHTTXContext->bCopySavePad == TRUE))
269 {
270 if (RTMPEqualMemory(pHTTXContext->SavedPad, allzero,4))
271 {
272 DBGPRINT_RAW(RT_DEBUG_ERROR,("e1, allzero : %x %x %x %x %x %x %x %x \n",
273 pHTTXContext->SavedPad[0], pHTTXContext->SavedPad[1], pHTTXContext->SavedPad[2],pHTTXContext->SavedPad[3]
274 ,pHTTXContext->SavedPad[4], pHTTXContext->SavedPad[5], pHTTXContext->SavedPad[6],pHTTXContext->SavedPad[7]));
275 }
276 NdisMoveMemory(&pWirelessPkt[TmpBulkEndPos], pHTTXContext->SavedPad, 8);
277 pHTTXContext->bCopySavePad = FALSE;
278 if (pAd->bForcePrintTX == TRUE)
279 DBGPRINT(RT_DEBUG_TRACE,("RTUSBBulkOutDataPacket --> COPY PAD. CurWrite = %ld, NextBulk = %ld. ENextBulk = %ld.\n", pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition));
280 }
281
282 do
283 {
284 pTxInfo = (PTXINFO_STRUC)&pWirelessPkt[TmpBulkEndPos];
285 pTxWI = (PTXWI_STRUC)&pWirelessPkt[TmpBulkEndPos + TXINFO_SIZE];
286
287 if (pAd->bForcePrintTX == TRUE)
288 DBGPRINT(RT_DEBUG_TRACE, ("RTUSBBulkOutDataPacket AMPDU = %d.\n", pTxWI->AMPDU));
289
290 // add by Iverson, limit BulkOut size to 4k to pass WMM b mode 2T1R test items
291 //if ((ThisBulkSize != 0) && (pTxWI->AMPDU == 0))
292 if ((ThisBulkSize != 0) && (pTxWI->PHYMODE == MODE_CCK))
293 {
294 if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&0x1000) == 0x1000))
295 {
296 // Limit BulkOut size to about 4k bytes.
297 pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
298 break;
299 }
300 else if (((pAd->BulkOutMaxPacketSize < 512) && ((ThisBulkSize&0xfffff800) != 0) ) /*|| ( (ThisBulkSize != 0) && (pTxWI->AMPDU == 0))*/)
301 {
302 // For USB 1.1 or peer which didn't support AMPDU, limit the BulkOut size.
303 // For performence in b/g mode, now just check for USB 1.1 and didn't care about the APMDU or not! 2008/06/04.
304 pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
305 break;
306 }
307 }
308 // end Iverson
309 else
310 {
311 if (((ThisBulkSize&0xffff8000) != 0) || ((ThisBulkSize&0x6000) == 0x6000))
312 { // Limit BulkOut size to about 24k bytes.
313 pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
314 break;
315 }
316 else if (((pAd->BulkOutMaxPacketSize < 512) && ((ThisBulkSize&0xfffff800) != 0) ) /*|| ( (ThisBulkSize != 0) && (pTxWI->AMPDU == 0))*/)
317 { // For USB 1.1 or peer which didn't support AMPDU, limit the BulkOut size.
318 // For performence in b/g mode, now just check for USB 1.1 and didn't care about the APMDU or not! 2008/06/04.
319 pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
320 break;
321 }
322 }
323
324 if (TmpBulkEndPos == pHTTXContext->CurWritePosition)
325 {
326 pHTTXContext->ENextBulkOutPosition = TmpBulkEndPos;
327 break;
328 }
329
330 if (pTxInfo->QSEL != FIFO_EDCA)
331 {
332 printk("%s(): ====> pTxInfo->QueueSel(%d)!= FIFO_EDCA!!!!\n", __FUNCTION__, pTxInfo->QSEL);
333 printk("\tCWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad);
334 hex_dump("Wrong QSel Pkt:", (PUCHAR)&pWirelessPkt[TmpBulkEndPos], (pHTTXContext->CurWritePosition - pHTTXContext->NextBulkOutPosition));
335 }
336
337 if (pTxInfo->USBDMATxPktLen <= 8)
338 {
339 BULK_OUT_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
340 DBGPRINT(RT_DEBUG_ERROR /*RT_DEBUG_TRACE*/,("e2, USBDMATxPktLen==0, Size=%ld, bCSPad=%d, CWPos=%ld, NBPos=%ld, CWRPos=%ld!\n",
341 pHTTXContext->BulkOutSize, pHTTXContext->bCopySavePad, pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->CurWriteRealPos));
342 {
343 DBGPRINT_RAW(RT_DEBUG_ERROR /*RT_DEBUG_TRACE*/,("%x %x %x %x %x %x %x %x \n",
344 pHTTXContext->SavedPad[0], pHTTXContext->SavedPad[1], pHTTXContext->SavedPad[2],pHTTXContext->SavedPad[3]
345 ,pHTTXContext->SavedPad[4], pHTTXContext->SavedPad[5], pHTTXContext->SavedPad[6],pHTTXContext->SavedPad[7]));
346 }
347 pAd->bForcePrintTX = TRUE;
348 BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
349 pAd->BulkOutPending[BulkOutPipeId] = FALSE;
350 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
351 //DBGPRINT(RT_DEBUG_LOUD,("Out:pTxInfo->USBDMATxPktLen=%d!\n", pTxInfo->USBDMATxPktLen));
352 return;
353 }
354
355 // Increase Total transmit byte counter
356 pAd->RalinkCounters.OneSecTransmittedByteCount += pTxWI->MPDUtotalByteCount;
357 pAd->RalinkCounters.TransmittedByteCount += pTxWI->MPDUtotalByteCount;
358
359 pLastTxInfo = pTxInfo;
360
361 // Make sure we use EDCA QUEUE.
362 pTxInfo->QSEL = FIFO_EDCA;
363 ThisBulkSize += (pTxInfo->USBDMATxPktLen+4);
364 TmpBulkEndPos += (pTxInfo->USBDMATxPktLen+4);
365
366 if (TmpBulkEndPos != pHTTXContext->CurWritePosition)
367 pTxInfo->USBDMANextVLD = 1;
368
369 if (pTxInfo->SwUseLastRound == 1)
370 {
371 if (pHTTXContext->CurWritePosition == 8)
372 pTxInfo->USBDMANextVLD = 0;
373 pTxInfo->SwUseLastRound = 0;
374
375 bTxQLastRound = TRUE;
376 pHTTXContext->ENextBulkOutPosition = 8;
377
378 #ifdef RT_BIG_ENDIAN
379 RTMPDescriptorEndianChange((PUCHAR)pTxInfo, TYPE_TXINFO);
380 RTMPWIEndianChange((PUCHAR)pTxWI, TYPE_TXWI);
381 #endif // RT_BIG_ENDIAN //
382
383 break;
384 }
385
386 #ifdef RT_BIG_ENDIAN
387 RTMPDescriptorEndianChange((PUCHAR)pTxInfo, TYPE_TXINFO);
388 RTMPWIEndianChange((PUCHAR)pTxWI, TYPE_TXWI);
389 #endif // RT_BIG_ENDIAN //
390
391 }while (TRUE);
392
393 // adjust the pTxInfo->USBDMANextVLD value of last pTxInfo.
394 if (pLastTxInfo)
395 {
396 #ifdef RT_BIG_ENDIAN
397 RTMPDescriptorEndianChange((PUCHAR)pLastTxInfo, TYPE_TXINFO);
398 #endif // RT_BIG_ENDIAN //
399 pLastTxInfo->USBDMANextVLD = 0;
400 #ifdef RT_BIG_ENDIAN
401 RTMPDescriptorEndianChange((PUCHAR)pLastTxInfo, TYPE_TXINFO);
402 #endif // RT_BIG_ENDIAN //
403 }
404
405 /*
406 We need to copy SavedPad when following condition matched!
407 1. Not the last round of the TxQueue and
408 2. any match of following cases:
409 (1). The End Position of this bulk out is reach to the Currenct Write position and
410 the TxInfo and related header already write to the CurWritePosition.
411 =>(ENextBulkOutPosition == CurWritePosition) && (CurWriteRealPos > CurWritePosition)
412
413 (2). The EndPosition of the bulk out is not reach to the Current Write Position.
414 =>(ENextBulkOutPosition != CurWritePosition)
415 */
416 if ((bTxQLastRound == FALSE) &&
417 (((pHTTXContext->ENextBulkOutPosition == pHTTXContext->CurWritePosition) && (pHTTXContext->CurWriteRealPos > pHTTXContext->CurWritePosition)) ||
418 (pHTTXContext->ENextBulkOutPosition != pHTTXContext->CurWritePosition))
419 )
420 {
421 NdisMoveMemory(pHTTXContext->SavedPad, &pWirelessPkt[pHTTXContext->ENextBulkOutPosition], 8);
422 pHTTXContext->bCopySavePad = TRUE;
423 if (RTMPEqualMemory(pHTTXContext->SavedPad, allzero,4))
424 {
425 PUCHAR pBuf = &pHTTXContext->SavedPad[0];
426 DBGPRINT_RAW(RT_DEBUG_ERROR,("WARNING-Zero-3:%02x%02x%02x%02x%02x%02x%02x%02x,CWPos=%ld, CWRPos=%ld, bCW=%d, NBPos=%ld, TBPos=%ld, TBSize=%ld\n",
427 pBuf[0], pBuf[1], pBuf[2],pBuf[3],pBuf[4], pBuf[5], pBuf[6],pBuf[7], pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos,
428 pHTTXContext->bCurWriting, pHTTXContext->NextBulkOutPosition, TmpBulkEndPos, ThisBulkSize));
429
430 pBuf = &pWirelessPkt[pHTTXContext->CurWritePosition];
431 DBGPRINT_RAW(RT_DEBUG_ERROR,("\tCWPos=%02x%02x%02x%02x%02x%02x%02x%02x\n", pBuf[0], pBuf[1], pBuf[2],pBuf[3],pBuf[4], pBuf[5], pBuf[6],pBuf[7]));
432 }
433 //DBGPRINT(RT_DEBUG_LOUD,("ENPos==CWPos=%ld, CWRPos=%ld, bCSPad=%d!\n", pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos, pHTTXContext->bCopySavePad));
434 }
435
436 if (pAd->bForcePrintTX == TRUE)
437 DBGPRINT(RT_DEBUG_TRACE,("BulkOut-A:Size=%ld, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", ThisBulkSize, pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
438 //DBGPRINT(RT_DEBUG_LOUD,("BulkOut-A:Size=%ld, CWPos=%ld, CWRPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d, bLRound=%d!\n", ThisBulkSize, pHTTXContext->CurWritePosition, pHTTXContext->CurWriteRealPos, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad, bTxQLastRound));
439
440 // USB DMA engine requires to pad extra 4 bytes. This pad doesn't count into real bulkoutsize.
441 pAppendant = &pWirelessPkt[TmpBulkEndPos];
442 NdisZeroMemory(pAppendant, 8);
443 ThisBulkSize += 4;
444 pHTTXContext->LastOne = TRUE;
445 if ((ThisBulkSize % pAd->BulkOutMaxPacketSize) == 0)
446 ThisBulkSize += 4;
447 pHTTXContext->BulkOutSize = ThisBulkSize;
448
449 pAd->watchDogTxPendingCnt[BulkOutPipeId] = 1;
450 BULK_OUT_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags2);
451
452 // Init Tx context descriptor
453 RTUSBInitHTTxDesc(pAd, pHTTXContext, BulkOutPipeId, ThisBulkSize, (usb_complete_t)RTUSBBulkOutDataPacketComplete);
454
455 pUrb = pHTTXContext->pUrb;
456 if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
457 {
458 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkOutDataPacket: Submit Tx URB failed %d\n", ret));
459
460 BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
461 pAd->BulkOutPending[BulkOutPipeId] = FALSE;
462 pAd->watchDogTxPendingCnt[BulkOutPipeId] = 0;
463 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
464
465 return;
466 }
467
468 BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
469 pHTTXContext->IRPPending = TRUE;
470 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
471 pAd->BulkOutReq++;
472
473 }
474
475
476 VOID RTUSBBulkOutDataPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs)
477 {
478 #if 0 // sample, IRQ LOCK
479 PRTMP_ADAPTER pAd;
480 POS_COOKIE pObj;
481 PHT_TX_CONTEXT pHTTXContext;
482 UCHAR BulkOutPipeId;
483 NTSTATUS Status;
484 unsigned long IrqFlags;
485
486 DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutDataPacketComplete\n"));
487
488 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
489 pAd = pHTTXContext->pAd;
490 pObj = (POS_COOKIE) pAd->OS_Cookie;
491 Status = pUrb->status;
492
493 // Store BulkOut PipeId
494 BulkOutPipeId = pHTTXContext->BulkOutPipeId;
495 pAd->BulkOutDataOneSecCount++;
496
497 //DBGPRINT(RT_DEBUG_LOUD, ("Done-B(%d):I=0x%lx, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", BulkOutPipeId, in_interrupt(), pHTTXContext->CurWritePosition,
498 // pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
499
500 RTMP_IRQ_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
501 pAd->BulkOutPending[BulkOutPipeId] = FALSE;
502 pHTTXContext->IRPPending = FALSE;
503 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
504
505 if (Status == USB_ST_NOERROR)
506 {
507 pAd->BulkOutComplete++;
508
509 pAd->Counters8023.GoodTransmits++;
510 //RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
511 FREE_HTTX_RING(pAd, BulkOutPipeId, pHTTXContext);
512 //RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
513
514
515 }
516 else // STATUS_OTHER
517 {
518 PUCHAR pBuf;
519
520 pAd->BulkOutCompleteOther++;
521
522 pBuf = &pHTTXContext->TransferBuffer->WirelessPacket[pHTTXContext->NextBulkOutPosition];
523
524 DBGPRINT_RAW(RT_DEBUG_ERROR, ("BulkOutDataPacket failed: ReasonCode=%d!\n", Status));
525 DBGPRINT_RAW(RT_DEBUG_ERROR, (">>BulkOut Req=0x%lx, Complete=0x%lx, Other=0x%lx\n", pAd->BulkOutReq, pAd->BulkOutComplete, pAd->BulkOutCompleteOther));
526 DBGPRINT_RAW(RT_DEBUG_ERROR, (">>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]));
527 //DBGPRINT_RAW(RT_DEBUG_ERROR, (">>BulkOutCompleteCancel=0x%x, BulkOutCompleteOther=0x%x\n", pAd->BulkOutCompleteCancel, pAd->BulkOutCompleteOther));
528
529 if (!RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
530 fRTMP_ADAPTER_HALT_IN_PROGRESS |
531 fRTMP_ADAPTER_NIC_NOT_EXIST |
532 fRTMP_ADAPTER_BULKOUT_RESET)))
533 {
534 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
535 pAd->bulkResetPipeid = BulkOutPipeId;
536 }
537 }
538
539 //
540 // bInUse = TRUE, means some process are filling TX data, after that must turn on bWaitingBulkOut
541 // bWaitingBulkOut = TRUE, means the TX data are waiting for bulk out.
542 //
543 //RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
544 if ((pHTTXContext->ENextBulkOutPosition != pHTTXContext->CurWritePosition) &&
545 (pHTTXContext->ENextBulkOutPosition != (pHTTXContext->CurWritePosition+8)) &&
546 !RTUSB_TEST_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId)))
547 {
548 // Indicate There is data avaliable
549 RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
550 }
551 //RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
552
553 // Always call Bulk routine, even reset bulk.
554 // The protection of rest bulk should be in BulkOut routine
555 RTUSBKickBulkOut(pAd);
556
557
558 //DBGPRINT(RT_DEBUG_LOUD,("Done-A(%d):I=0x%lx, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d\n", BulkOutPipeId, in_interrupt(),
559 // pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
560
561 switch (BulkOutPipeId)
562 {
563 case 0:
564 pObj->ac0_dma_done_task.data = (unsigned long)pAd;
565 tasklet_hi_schedule(&pObj->ac0_dma_done_task);
566 break;
567 case 1:
568 pObj->ac1_dma_done_task.data = (unsigned long)pAd;
569 tasklet_hi_schedule(&pObj->ac1_dma_done_task);
570 break;
571 case 2:
572 pObj->ac2_dma_done_task.data = (unsigned long)pAd;
573 tasklet_hi_schedule(&pObj->ac2_dma_done_task);
574 break;
575 case 3:
576 pObj->ac3_dma_done_task.data = (unsigned long)pAd;
577 tasklet_hi_schedule(&pObj->ac3_dma_done_task);
578 break;
579 case 4:
580 pObj->hcca_dma_done_task.data = (unsigned long)pAd;
581 tasklet_hi_schedule(&pObj->hcca_dma_done_task);
582 break;
583 }
584 #else
585
586 {
587 PHT_TX_CONTEXT pHTTXContext;
588 PRTMP_ADAPTER pAd;
589 POS_COOKIE pObj;
590 UCHAR BulkOutPipeId;
591
592
593 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
594 pAd = pHTTXContext->pAd;
595 pObj = (POS_COOKIE) pAd->OS_Cookie;
596
597 // Store BulkOut PipeId
598 BulkOutPipeId = pHTTXContext->BulkOutPipeId;
599 pAd->BulkOutDataOneSecCount++;
600
601 switch (BulkOutPipeId)
602 {
603 case 0:
604 pObj->ac0_dma_done_task.data = (unsigned long)pUrb;
605 tasklet_hi_schedule(&pObj->ac0_dma_done_task);
606 break;
607 case 1:
608 pObj->ac1_dma_done_task.data = (unsigned long)pUrb;
609 tasklet_hi_schedule(&pObj->ac1_dma_done_task);
610 break;
611 case 2:
612 pObj->ac2_dma_done_task.data = (unsigned long)pUrb;
613 tasklet_hi_schedule(&pObj->ac2_dma_done_task);
614 break;
615 case 3:
616 pObj->ac3_dma_done_task.data = (unsigned long)pUrb;
617 tasklet_hi_schedule(&pObj->ac3_dma_done_task);
618 break;
619 case 4:
620 pObj->hcca_dma_done_task.data = (unsigned long)pUrb;
621 tasklet_hi_schedule(&pObj->hcca_dma_done_task);
622 break;
623 }
624 }
625 #endif
626
627
628 }
629
630
631 /*
632 ========================================================================
633
634 Routine Description:
635
636 Arguments:
637
638 Return Value:
639
640 Note: NULL frame use BulkOutPipeId = 0
641
642 ========================================================================
643 */
644 VOID RTUSBBulkOutNullFrame(
645 IN PRTMP_ADAPTER pAd)
646 {
647 PTX_CONTEXT pNullContext = &(pAd->NullContext);
648 PURB pUrb;
649 int ret = 0;
650 unsigned long IrqFlags;
651
652 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], IrqFlags);
653 if ((pAd->BulkOutPending[0] == TRUE) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_TX))
654 {
655 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
656 return;
657 }
658 pAd->BulkOutPending[0] = TRUE;
659 pAd->watchDogTxPendingCnt[0] = 1;
660 pNullContext->IRPPending = TRUE;
661 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
662
663 // Increase Total transmit byte counter
664 pAd->RalinkCounters.TransmittedByteCount += pNullContext->BulkOutSize;
665
666
667 // Clear Null frame bulk flag
668 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NULL);
669
670 #ifdef RT_BIG_ENDIAN
671 RTMPDescriptorEndianChange((PUCHAR)pNullContext->TransferBuffer, TYPE_TXINFO);
672 #endif // RT_BIG_ENDIAN //
673
674 // Init Tx context descriptor
675 RTUSBInitTxDesc(pAd, pNullContext, 0, (usb_complete_t)RTUSBBulkOutNullFrameComplete);
676
677 pUrb = pNullContext->pUrb;
678 if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
679 {
680 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], IrqFlags);
681 pAd->BulkOutPending[0] = FALSE;
682 pAd->watchDogTxPendingCnt[0] = 0;
683 pNullContext->IRPPending = FALSE;
684 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
685
686 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkOutNullFrame: Submit Tx URB failed %d\n", ret));
687 return;
688 }
689
690 }
691
692 // NULL frame use BulkOutPipeId = 0
693 VOID RTUSBBulkOutNullFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs)
694 {
695 PRTMP_ADAPTER pAd;
696 PTX_CONTEXT pNullContext;
697 NTSTATUS Status;
698 #if 0 // sample, IRQ LOCK
699 unsigned long IrqFlags;
700 #endif
701 POS_COOKIE pObj;
702
703
704 pNullContext = (PTX_CONTEXT)pUrb->context;
705 pAd = pNullContext->pAd;
706 Status = pUrb->status;
707
708 #if 0 // sample, IRQ LOCK
709 // Reset Null frame context flags
710 pNullContext->IRPPending = FALSE;
711 pNullContext->InUse = FALSE;
712
713 if (Status == USB_ST_NOERROR)
714 {
715 // Don't worry about the queue is empty or not, this function will check itself
716 //RTMPUSBDeQueuePacket(pAd, 0);
717 RTMPDeQueuePacket(pAd, TRUE, NUM_OF_TX_RING, MAX_TX_PROCESS);
718 }
719 else // STATUS_OTHER
720 {
721 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
722 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
723 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
724 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
725 {
726 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out Null Frame Failed\n"));
727 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
728 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
729 }
730 }
731
732 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], IrqFlags);
733 pAd->BulkOutPending[0] = FALSE;
734 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
735
736 // Always call Bulk routine, even reset bulk.
737 // The protectioon of rest bulk should be in BulkOut routine
738 RTUSBKickBulkOut(pAd);
739 #else
740
741 pObj = (POS_COOKIE) pAd->OS_Cookie;
742 pObj->null_frame_complete_task.data = (unsigned long)pUrb;
743 tasklet_hi_schedule(&pObj->null_frame_complete_task);
744 #endif
745
746 }
747
748 #if 0 // For RT2870, RTS frame not used now, but maybe will use it latter.
749 /*
750 ========================================================================
751
752 Routine Description:
753
754 Arguments:
755
756 Return Value:
757
758 Note: RTS frame use BulkOutPipeId = 0
759
760 ========================================================================
761 */
762 VOID RTUSBBulkOutRTSFrame(
763 IN PRTMP_ADAPTER pAd)
764 {
765 PTX_CONTEXT pRTSContext = &(pAd->RTSContext);
766 PURB pUrb;
767 int ret = 0;
768 unsigned long IrqFlags;
769 UCHAR PipeID=0;
770
771 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_4))
772 PipeID= 3;
773 else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_3))
774 PipeID= 2;
775 else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_2))
776 PipeID= 1;
777 else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL))
778 PipeID= 0;
779
780 RTMP_IRQ_LOCK(&pAd->BulkOutLock[PipeID], IrqFlags);
781 if ((pAd->BulkOutPending[PipeID] == TRUE) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_TX))
782 {
783 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[PipeID], IrqFlags);
784 return;
785 }
786 pAd->BulkOutPending[PipeID] = TRUE;
787 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[PipeID], IrqFlags);
788
789 // Increase Total transmit byte counter
790 pAd->RalinkCounters.TransmittedByteCount += pRTSContext->BulkOutSize;
791
792 DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutRTSFrame \n"));
793
794 // Clear RTS frame bulk flag
795 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_RTS);
796
797 #ifdef RT_BIG_ENDIAN
798 RTMPDescriptorEndianChange((PUCHAR)pRTSContext->TransferBuffer, TYPE_TXINFO);
799 #endif // RT_BIG_ENDIAN //
800
801 // Init Tx context descriptor
802 RTUSBInitTxDesc(pAd, pRTSContext, PipeID, (usb_complete_t)RTUSBBulkOutRTSFrameComplete);
803 pRTSContext->IRPPending = TRUE;
804
805 pUrb = pRTSContext->pUrb;
806 if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
807 {
808 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkOutRTSFrame: Submit Tx URB failed %d\n", ret));
809 return;
810 }
811
812 DBGPRINT_RAW(RT_DEBUG_INFO, ("<---RTUSBBulkOutRTSFrame \n"));
813
814 }
815
816 // RTS frame use BulkOutPipeId = 0
817 VOID RTUSBBulkOutRTSFrameComplete(purbb_t pUrb, struct pt_regs *pt_regs)
818 {
819 PRTMP_ADAPTER pAd;
820 PTX_CONTEXT pRTSContext;
821 NTSTATUS Status;
822 #if 0 // sample, IRQ LOCK
823 unsigned long IrqFlags;
824 #endif
825 POS_COOKIE pObj;
826
827 DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutRTSFrameComplete\n"));
828
829 pRTSContext = (PTX_CONTEXT)pUrb->context;
830 pAd = pRTSContext->pAd;
831 Status = pUrb->status;
832
833 #if 0 // sample, IRQ LOCK
834 // Reset RTS frame context flags
835 pRTSContext->IRPPending = FALSE;
836 pRTSContext->InUse = FALSE;
837
838 if (Status == USB_ST_NOERROR)
839 {
840 // Don't worry about the queue is empty or not, this function will check itself
841 //RTMPUSBDeQueuePacket(pAd, pRTSContext->BulkOutPipeId);
842 RTMPDeQueuePacket(pAd, TRUE, NUM_OF_TX_RING, MAX_TX_PROCESS);
843 }
844 else // STATUS_OTHER
845 {
846 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
847 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
848 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
849 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
850 {
851 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out RTS Frame Failed\n"));
852 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
853 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
854 }
855 }
856
857 RTMP_IRQ_LOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId], IrqFlags);
858 pAd->BulkOutPending[pRTSContext->BulkOutPipeId] = FALSE;
859 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId], IrqFlags);
860
861 // Always call Bulk routine, even reset bulk.
862 // The protectioon of rest bulk should be in BulkOut routine
863 RTUSBKickBulkOut(pAd);
864 #else
865
866 pObj = (POS_COOKIE) pAd->OS_Cookie;
867 pObj->rts_frame_complete_task.data = (unsigned long)pUrb;
868 tasklet_hi_schedule(&pObj->rts_frame_complete_task);
869 #endif
870
871 DBGPRINT_RAW(RT_DEBUG_INFO, ("<---RTUSBBulkOutRTSFrameComplete\n"));
872
873 }
874 #endif
875
876 /*
877 ========================================================================
878
879 Routine Description:
880
881 Arguments:
882
883 Return Value:
884
885 Note: MLME use BulkOutPipeId = 0
886
887 ========================================================================
888 */
889 VOID RTUSBBulkOutMLMEPacket(
890 IN PRTMP_ADAPTER pAd,
891 IN UCHAR Index)
892 {
893 PTX_CONTEXT pMLMEContext;
894 PURB pUrb;
895 int ret = 0;
896 unsigned long IrqFlags;
897
898 pMLMEContext = (PTX_CONTEXT)pAd->MgmtRing.Cell[pAd->MgmtRing.TxDmaIdx].AllocVa;
899 pUrb = pMLMEContext->pUrb;
900
901 if ((pAd->MgmtRing.TxSwFreeIdx >= MGMT_RING_SIZE) ||
902 (pMLMEContext->InUse == FALSE) ||
903 (pMLMEContext->bWaitingBulkOut == FALSE))
904 {
905
906
907 // Clear MLME bulk flag
908 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
909
910 return;
911 }
912
913
914 RTMP_IRQ_LOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
915 if ((pAd->BulkOutPending[MGMTPIPEIDX] == TRUE) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_TX))
916 {
917 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
918 return;
919 }
920
921 pAd->BulkOutPending[MGMTPIPEIDX] = TRUE;
922 pAd->watchDogTxPendingCnt[MGMTPIPEIDX] = 1;
923 pMLMEContext->IRPPending = TRUE;
924 pMLMEContext->bWaitingBulkOut = FALSE;
925 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
926
927 // Increase Total transmit byte counter
928 pAd->RalinkCounters.TransmittedByteCount += pMLMEContext->BulkOutSize;
929
930 // Clear MLME bulk flag
931 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
932
933
934 //DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutMLMEPacket\n"));
935 #if 0 // for debug
936 {
937 printk("MLME-Out, C=%d!, D=%d, F=%d!\n", pAd->MgmtRing.TxCpuIdx, pAd->MgmtRing.TxDmaIdx, pAd->MgmtRing.TxSwFreeIdx);
938
939 //TODO: Need to remove it when formal release
940 PTXINFO_STRUC pTxInfo;
941
942 pTxInfo = (PTXINFO_STRUC)pMLMEContext->TransferBuffer;
943 if (pTxInfo->QSEL != FIFO_EDCA)
944 {
945 printk("%s(): ====> pTxInfo->QueueSel(%d)!= FIFO_EDCA!!!!\n", __FUNCTION__, pTxInfo->QSEL);
946 printk("\tMLME_Index=%d!\n", Index);
947 hex_dump("Wrong QSel Pkt:", (PUCHAR)pMLMEContext->TransferBuffer, pTxInfo->USBDMATxPktLen);
948 }
949 }
950 #endif
951
952 #ifdef RT_BIG_ENDIAN
953 RTMPDescriptorEndianChange((PUCHAR)pMLMEContext->TransferBuffer, TYPE_TXINFO);
954 #endif // RT_BIG_ENDIAN //
955
956 // Init Tx context descriptor
957 RTUSBInitTxDesc(pAd, pMLMEContext, MGMTPIPEIDX, (usb_complete_t)RTUSBBulkOutMLMEPacketComplete);
958
959 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
960 //For mgmt urb buffer, because we use sk_buff, so we need to notify the USB controller do dma mapping.
961 pUrb->transfer_dma = 0;
962 pUrb->transfer_flags &= (~URB_NO_TRANSFER_DMA_MAP);
963 #endif
964
965 pUrb = pMLMEContext->pUrb;
966 if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
967 {
968 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkOutMLMEPacket: Submit MLME URB failed %d\n", ret));
969 RTMP_IRQ_LOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
970 pAd->BulkOutPending[MGMTPIPEIDX] = FALSE;
971 pAd->watchDogTxPendingCnt[MGMTPIPEIDX] = 0;
972 pMLMEContext->IRPPending = FALSE;
973 pMLMEContext->bWaitingBulkOut = TRUE;
974 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
975
976 return;
977 }
978
979 //DBGPRINT_RAW(RT_DEBUG_INFO, ("<---RTUSBBulkOutMLMEPacket \n"));
980 // printk("<---RTUSBBulkOutMLMEPacket,Cpu=%d!, Dma=%d, SwIdx=%d!\n", pAd->MgmtRing.TxCpuIdx, pAd->MgmtRing.TxDmaIdx, pAd->MgmtRing.TxSwFreeIdx);
981 }
982
983
984 VOID RTUSBBulkOutMLMEPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs)
985 {
986 PTX_CONTEXT pMLMEContext;
987 PRTMP_ADAPTER pAd;
988 NTSTATUS Status;
989 POS_COOKIE pObj;
990 int index;
991 #if 0 // sample, IRQ LOCK
992 unsigned long IrqFlags;
993 PNDIS_PACKET pPacket;
994 #endif
995
996
997 //DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutMLMEPacketComplete\n"));
998 pMLMEContext = (PTX_CONTEXT)pUrb->context;
999 pAd = pMLMEContext->pAd;
1000 pObj = (POS_COOKIE)pAd->OS_Cookie;
1001 Status = pUrb->status;
1002 index = pMLMEContext->SelfIdx;
1003
1004
1005 #if 0 // sample, IRQ LOCK
1006 ASSERT((pAd->MgmtRing.TxDmaIdx == index));
1007 //printk("MLME-Done-B: C=%d, D=%d, F=%d, Self=%d!\n", pAd->MgmtRing.TxCpuIdx, pAd->MgmtRing.TxDmaIdx, pAd->MgmtRing.TxSwFreeIdx, pMLMEContext->SelfIdx);
1008
1009 RTMP_IRQ_LOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
1010
1011
1012 if (Status != USB_ST_NOERROR)
1013 {
1014 //Bulk-Out fail status handle
1015 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1016 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1017 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1018 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1019 {
1020 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out MLME Failed, Status=%d!\n", Status));
1021 // TODO: How to handle about the MLMEBulkOut failed issue. Need to resend the mgmt pkt?
1022 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1023 pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
1024 }
1025 }
1026 pAd->BulkOutPending[MGMTPIPEIDX] = FALSE;
1027 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
1028
1029 RTMP_IRQ_LOCK(&pAd->MLMEBulkOutLock, IrqFlags);
1030 // Reset MLME context flags
1031 pMLMEContext->IRPPending = FALSE;
1032 pMLMEContext->InUse = FALSE;
1033 pMLMEContext->bWaitingBulkOut = FALSE;
1034 pMLMEContext->BulkOutSize = 0;
1035
1036 pPacket = pAd->MgmtRing.Cell[index].pNdisPacket;
1037 pAd->MgmtRing.Cell[index].pNdisPacket = NULL;
1038
1039 // Increase MgmtRing Index
1040 INC_RING_INDEX(pAd->MgmtRing.TxDmaIdx, MGMT_RING_SIZE);
1041 pAd->MgmtRing.TxSwFreeIdx++;
1042
1043 RTMP_IRQ_UNLOCK(&pAd->MLMEBulkOutLock, IrqFlags);
1044
1045 // No-matter success or fail, we free the mgmt packet.
1046 if (pPacket)
1047 RTMPFreeNdisPacket(pAd, pPacket);
1048
1049 #if 0
1050 //Bulk-Out fail status handle
1051 if (Status != USB_ST_NOERROR)
1052 {
1053 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1054 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1055 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1056 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1057 {
1058 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out MLME Failed, Status=%d!\n", Status));
1059 // TODO: How to handle about the MLMEBulkOut failed issue. Need to reset the endpoint?
1060 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1061 pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
1062 }
1063 }
1064 #endif
1065
1066 //printk("MLME-Done-A: C=%d, D=%d, F=%d!\n", pAd->MgmtRing.TxCpuIdx, pAd->MgmtRing.TxDmaIdx, pAd->MgmtRing.TxSwFreeIdx);
1067
1068 pObj->mgmt_dma_done_task.data = (unsigned long)pAd;
1069 tasklet_hi_schedule(&pObj->mgmt_dma_done_task);
1070
1071 //DBGPRINT_RAW(RT_DEBUG_INFO, ("<---RTUSBBulkOutMLMEPacketComplete\n"));
1072 // printk("<---RTUSBBulkOutMLMEPacketComplete, Cpu=%d, Dma=%d, SwIdx=%d!\n",
1073 // pAd->MgmtRing.TxCpuIdx, pAd->MgmtRing.TxDmaIdx, pAd->MgmtRing.TxSwFreeIdx);
1074
1075 #else
1076
1077 pObj->mgmt_dma_done_task.data = (unsigned long)pUrb;
1078 tasklet_hi_schedule(&pObj->mgmt_dma_done_task);
1079 #endif
1080 }
1081
1082
1083 /*
1084 ========================================================================
1085
1086 Routine Description:
1087
1088 Arguments:
1089
1090 Return Value:
1091
1092 Note: PsPoll use BulkOutPipeId = 0
1093
1094 ========================================================================
1095 */
1096 VOID RTUSBBulkOutPsPoll(
1097 IN PRTMP_ADAPTER pAd)
1098 {
1099 PTX_CONTEXT pPsPollContext = &(pAd->PsPollContext);
1100 PURB pUrb;
1101 int ret = 0;
1102 unsigned long IrqFlags;
1103
1104 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], IrqFlags);
1105 if ((pAd->BulkOutPending[0] == TRUE) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_TX))
1106 {
1107 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
1108 return;
1109 }
1110 pAd->BulkOutPending[0] = TRUE;
1111 pAd->watchDogTxPendingCnt[0] = 1;
1112 pPsPollContext->IRPPending = TRUE;
1113 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
1114
1115
1116 // Clear PS-Poll bulk flag
1117 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_PSPOLL);
1118
1119 #ifdef RT_BIG_ENDIAN
1120 RTMPDescriptorEndianChange((PUCHAR)pPsPollContext->TransferBuffer, TYPE_TXINFO);
1121 #endif // RT_BIG_ENDIAN //
1122
1123 // Init Tx context descriptor
1124 RTUSBInitTxDesc(pAd, pPsPollContext, MGMTPIPEIDX, (usb_complete_t)RTUSBBulkOutPsPollComplete);
1125
1126 pUrb = pPsPollContext->pUrb;
1127 if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
1128 {
1129 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], IrqFlags);
1130 pAd->BulkOutPending[0] = FALSE;
1131 pAd->watchDogTxPendingCnt[0] = 0;
1132 pPsPollContext->IRPPending = FALSE;
1133 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
1134
1135 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkOutPsPoll: Submit Tx URB failed %d\n", ret));
1136 return;
1137 }
1138
1139 }
1140
1141 // PS-Poll frame use BulkOutPipeId = 0
1142 VOID RTUSBBulkOutPsPollComplete(purbb_t pUrb,struct pt_regs *pt_regs)
1143 {
1144 PRTMP_ADAPTER pAd;
1145 PTX_CONTEXT pPsPollContext;
1146 NTSTATUS Status;
1147 #if 0 // sample, IRQ LOCK
1148 unsigned long IrqFlags;
1149 #endif
1150 POS_COOKIE pObj;
1151
1152
1153 pPsPollContext= (PTX_CONTEXT)pUrb->context;
1154 pAd = pPsPollContext->pAd;
1155 Status = pUrb->status;
1156
1157 #if 0 // sample, IRQ LOCK
1158 // Reset PsPoll context flags
1159 pPsPollContext->IRPPending = FALSE;
1160 pPsPollContext->InUse = FALSE;
1161
1162 if (Status == USB_ST_NOERROR)
1163 {
1164 // Don't worry about the queue is empty or not, this function will check itself
1165 RTMPDeQueuePacket(pAd, TRUE, NUM_OF_TX_RING, MAX_TX_PROCESS);
1166 }
1167 else // STATUS_OTHER
1168 {
1169 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1170 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1171 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1172 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1173 {
1174 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out PSPoll Failed\n"));
1175 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1176 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1177 }
1178 }
1179
1180 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], IrqFlags);
1181 pAd->BulkOutPending[0] = FALSE;
1182 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
1183
1184 // Always call Bulk routine, even reset bulk.
1185 // The protectioon of rest bulk should be in BulkOut routine
1186 RTUSBKickBulkOut(pAd);
1187 #else
1188
1189 pObj = (POS_COOKIE) pAd->OS_Cookie;
1190 pObj->pspoll_frame_complete_task.data = (unsigned long)pUrb;
1191 tasklet_hi_schedule(&pObj->pspoll_frame_complete_task);
1192 #endif
1193 }
1194
1195
1196 #if 0
1197 /*
1198 ========================================================================
1199
1200 Routine Description:
1201 USB_RxPacket initializes a URB and uses the Rx IRP to submit it
1202 to USB. It checks if an Rx Descriptor is available and passes the
1203 the coresponding buffer to be filled. If no descriptor is available
1204 fails the request. When setting the completion routine we pass our
1205 Adapter Object as Context.
1206
1207 Arguments:
1208
1209 Return Value:
1210 TRUE found matched tuple cache
1211 FALSE no matched found
1212
1213 Note:
1214
1215 ========================================================================
1216 */
1217 VOID RTUSBBulkReceive(
1218 IN PRTMP_ADAPTER pAd)
1219 {
1220 PRX_CONTEXT pRxContext;
1221 PURB pUrb;
1222 int ret = 0;
1223 unsigned long IrqFlags;
1224
1225
1226 /* device had been closed */
1227 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_REMOVE_IN_PROGRESS))
1228 return;
1229
1230 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1231
1232 // Last is time point between 2 separate URB.
1233 if (pAd->NextRxBulkInPosition == 0)
1234 {
1235 //pAd->NextRxBulkInIndex = (pAd->NextRxBulkInIndex + 1) % (RX_RING_SIZE);
1236 INC_RING_INDEX(pAd->NextRxBulkInIndex, RX_RING_SIZE);
1237 }
1238 else if ((pAd->NextRxBulkInPosition&0x1ff) != 0)
1239 {
1240 //pAd->NextRxBulkInIndex = (pAd->NextRxBulkInIndex + 1) % (RX_RING_SIZE);
1241 INC_RING_INDEX(pAd->NextRxBulkInIndex, RX_RING_SIZE);
1242 DBGPRINT_RAW(RT_DEBUG_TRACE, ("pAd->NextRxBulkInPosition = 0x%lx. End of URB.\n", pAd->NextRxBulkInPosition ));
1243 pAd->NextRxBulkInPosition = 0;
1244 }
1245
1246 if (pAd->NextRxBulkInPosition == MAX_RXBULK_SIZE)
1247 pAd->NextRxBulkInPosition = 0;
1248
1249 pRxContext = &(pAd->RxContext[pAd->NextRxBulkInIndex]);
1250
1251 // TODO: Why need to check if pRxContext->InUsed == TRUE?
1252 //if ((pRxContext->InUse == TRUE) || (pRxContext->Readable == TRUE))
1253 if ((pRxContext->InUse == FALSE) && (pRxContext->Readable == TRUE))
1254 {
1255 DBGPRINT_RAW(RT_DEBUG_TRACE, ("pRxContext[%d] InUse = %d.pRxContext->Readable = %d. Return.\n", pAd->NextRxBulkInIndex,pRxContext->InUse, pRxContext->Readable ));
1256 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1257
1258 // read RxContext, Since not
1259 #ifdef CONFIG_STA_SUPPORT
1260 STARxDoneInterruptHandle(pAd, TRUE);
1261 #endif // CONFIG_STA_SUPPORT //
1262
1263 //return;
1264 }
1265 pRxContext->InUse = TRUE;
1266 pRxContext->IRPPending= TRUE;
1267
1268 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1269
1270 // Init Rx context descriptor
1271 NdisZeroMemory(pRxContext->TransferBuffer, BUFFER_SIZE);
1272 RTUSBInitRxDesc(pAd, pRxContext);
1273
1274 pUrb = pRxContext->pUrb;
1275 if ((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
1276 {
1277 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkReceive: Submit Rx URB failed %d\n", ret));
1278 return;
1279 }
1280 else // success
1281 {
1282 NdisInterlockedIncrement(&pAd->PendingRx);
1283 pAd->BulkInReq++;
1284 }
1285
1286 // read RxContext, Since not
1287 #ifdef CONFIG_STA_SUPPORT
1288 STARxDoneInterruptHandle(pAd, FALSE);
1289 #endif // CONFIG_STA_SUPPORT //
1290 }
1291
1292 /*
1293 ========================================================================
1294
1295 Routine Description:
1296 This routine process Rx Irp and call rx complete function.
1297
1298 Arguments:
1299 DeviceObject Pointer to the device object for next lower
1300 device. DeviceObject passed in here belongs to
1301 the next lower driver in the stack because we
1302 were invoked via IoCallDriver in USB_RxPacket
1303 AND it is not OUR device object
1304 Irp Ptr to completed IRP
1305 Context Ptr to our Adapter object (context specified
1306 in IoSetCompletionRoutine
1307
1308 Return Value:
1309 Always returns STATUS_MORE_PROCESSING_REQUIRED
1310
1311 Note:
1312 Always returns STATUS_MORE_PROCESSING_REQUIRED
1313 ========================================================================
1314 */
1315 VOID RTUSBBulkRxComplete(purbb_t pUrb, struct pt_regs *pt_regs)
1316 {
1317 #if 0
1318 PRX_CONTEXT pRxContext;
1319 PRTMP_ADAPTER pAd;
1320 NTSTATUS Status;
1321 // POS_COOKIE pObj;
1322
1323 pRxContext = (PRX_CONTEXT)pUrb->context;
1324 pAd = pRxContext->pAd;
1325 // pObj = (POS_COOKIE) pAd->OS_Cookie;
1326
1327
1328 Status = pUrb->status;
1329 //pRxContext->pIrp = NULL;
1330
1331 pRxContext->InUse = FALSE;
1332 pRxContext->IRPPending = FALSE;
1333
1334 if (Status == USB_ST_NOERROR)
1335 {
1336 pAd->BulkInComplete++;
1337 pRxContext->Readable = TRUE;
1338 pAd->NextRxBulkInPosition = 0;
1339
1340 }
1341 else // STATUS_OTHER
1342 {
1343 pAd->BulkInCompleteFail++;
1344 // Still read this packet although it may comtain wrong bytes.
1345 pRxContext->Readable = FALSE;
1346 // Parsing all packets. because after reset, the index will reset to all zero.
1347
1348 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1349 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET)) &&
1350 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1351 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
1352 {
1353
1354 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk In Failed. Status = %d\n", Status));
1355 DBGPRINT_RAW(RT_DEBUG_ERROR, ("==>NextRxBulkInIndex=0x%x, NextRxBulkInReadIndex=0x%x, TransferBufferLength= 0x%x\n",
1356 pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex, pRxContext->pUrb->actual_length));
1357
1358 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET);
1359 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_IN, NULL, 0);
1360 }
1361 //pUrb = NULL;
1362 }
1363
1364 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1365 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET)) &&
1366 // (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)) &&
1367 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) &&
1368 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1369 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
1370 {
1371 RTUSBBulkReceive(pAd);
1372 #if 0
1373 #if 1
1374 STARxDoneInterruptHandle(pAd, FALSE);
1375 #else
1376 pObj->rx_bh.data = (unsigned long)pUrb;
1377 tasklet_schedule(&pObj->rx_bh);
1378 #endif
1379 #endif
1380 }
1381
1382 // Call RxPacket to process packet and return the status
1383 NdisInterlockedDecrement(&pAd->PendingRx);
1384 #else
1385
1386
1387 // use a receive tasklet to handle received packets;
1388 // or sometimes hardware IRQ will be disabled here, so we can not
1389 // use spin_lock_bh()/spin_unlock_bh() after IRQ is disabled. :<
1390 PRX_CONTEXT pRxContext;
1391 PRTMP_ADAPTER pAd;
1392 POS_COOKIE pObj;
1393
1394
1395 pRxContext = (PRX_CONTEXT)pUrb->context;
1396 pAd = pRxContext->pAd;
1397 pObj = (POS_COOKIE) pAd->OS_Cookie;
1398
1399 pObj->rx_done_task.data = (unsigned long)pUrb;
1400 tasklet_hi_schedule(&pObj->rx_done_task);
1401 #endif
1402 }
1403
1404 #else
1405
1406 VOID DoBulkIn(IN RTMP_ADAPTER *pAd)
1407 {
1408 PRX_CONTEXT pRxContext;
1409 PURB pUrb;
1410 int ret = 0;
1411 unsigned long IrqFlags;
1412
1413 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1414 pRxContext = &(pAd->RxContext[pAd->NextRxBulkInIndex]);
1415 if ((pAd->PendingRx > 0) || (pRxContext->Readable == TRUE) || (pRxContext->InUse == TRUE))
1416 {
1417 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1418 return;
1419 }
1420 pRxContext->InUse = TRUE;
1421 pRxContext->IRPPending = TRUE;
1422 pAd->PendingRx++;
1423 pAd->BulkInReq++;
1424 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1425
1426 // Init Rx context descriptor
1427 NdisZeroMemory(pRxContext->TransferBuffer, pRxContext->BulkInOffset);
1428 RTUSBInitRxDesc(pAd, pRxContext);
1429
1430 pUrb = pRxContext->pUrb;
1431 if ((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
1432 { // fail
1433
1434 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1435 pRxContext->InUse = FALSE;
1436 pRxContext->IRPPending = FALSE;
1437 pAd->PendingRx--;
1438 pAd->BulkInReq--;
1439 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1440 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBBulkReceive: Submit Rx URB failed %d\n", ret));
1441 }
1442 else
1443 { // success
1444 #if 0
1445 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1446 pRxContext->IRPPending = TRUE;
1447 //NdisInterlockedIncrement(&pAd->PendingRx);
1448 pAd->PendingRx++;
1449 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1450 pAd->BulkInReq++;
1451 #endif
1452 ASSERT((pRxContext->InUse == pRxContext->IRPPending));
1453 //printk("BIDone, Pend=%d,BIIdx=%d,BIRIdx=%d!\n", pAd->PendingRx, pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex);
1454 }
1455 }
1456
1457
1458 /*
1459 ========================================================================
1460
1461 Routine Description:
1462 USB_RxPacket initializes a URB and uses the Rx IRP to submit it
1463 to USB. It checks if an Rx Descriptor is available and passes the
1464 the coresponding buffer to be filled. If no descriptor is available
1465 fails the request. When setting the completion routine we pass our
1466 Adapter Object as Context.
1467
1468 Arguments:
1469
1470 Return Value:
1471 TRUE found matched tuple cache
1472 FALSE no matched found
1473
1474 Note:
1475
1476 ========================================================================
1477 */
1478 #define fRTMP_ADAPTER_NEED_STOP_RX \
1479 (fRTMP_ADAPTER_NIC_NOT_EXIST | fRTMP_ADAPTER_HALT_IN_PROGRESS | \
1480 fRTMP_ADAPTER_RADIO_OFF | fRTMP_ADAPTER_RESET_IN_PROGRESS | \
1481 fRTMP_ADAPTER_REMOVE_IN_PROGRESS | fRTMP_ADAPTER_BULKIN_RESET)
1482
1483 #define fRTMP_ADAPTER_NEED_STOP_HANDLE_RX \
1484 (fRTMP_ADAPTER_NIC_NOT_EXIST | fRTMP_ADAPTER_HALT_IN_PROGRESS | \
1485 fRTMP_ADAPTER_RADIO_OFF | fRTMP_ADAPTER_RESET_IN_PROGRESS | \
1486 fRTMP_ADAPTER_REMOVE_IN_PROGRESS)
1487
1488 VOID RTUSBBulkReceive(
1489 IN PRTMP_ADAPTER pAd)
1490 {
1491 PRX_CONTEXT pRxContext;
1492 unsigned long IrqFlags;
1493
1494
1495 /* sanity check */
1496 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_HANDLE_RX))
1497 return;
1498
1499 while(1)
1500 {
1501
1502 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1503 pRxContext = &(pAd->RxContext[pAd->NextRxBulkInReadIndex]);
1504 if (((pRxContext->InUse == FALSE) && (pRxContext->Readable == TRUE)) &&
1505 (pRxContext->bRxHandling == FALSE))
1506 {
1507 pRxContext->bRxHandling = TRUE;
1508 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1509
1510 // read RxContext, Since not
1511 #ifdef CONFIG_STA_SUPPORT
1512 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1513 STARxDoneInterruptHandle(pAd, TRUE);
1514 #endif // CONFIG_STA_SUPPORT //
1515
1516 // Finish to handle this bulkIn buffer.
1517 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1518 pRxContext->BulkInOffset = 0;
1519 pRxContext->Readable = FALSE;
1520 pRxContext->bRxHandling = FALSE;
1521 pAd->ReadPosition = 0;
1522 pAd->TransferBufferLength = 0;
1523 INC_RING_INDEX(pAd->NextRxBulkInReadIndex, RX_RING_SIZE);
1524 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1525
1526 }
1527 else
1528 {
1529 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1530 break;
1531 }
1532 }
1533
1534 if (!(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NEED_STOP_RX)))
1535 DoBulkIn(pAd);
1536
1537 }
1538
1539
1540 /*
1541 ========================================================================
1542
1543 Routine Description:
1544 This routine process Rx Irp and call rx complete function.
1545
1546 Arguments:
1547 DeviceObject Pointer to the device object for next lower
1548 device. DeviceObject passed in here belongs to
1549 the next lower driver in the stack because we
1550 were invoked via IoCallDriver in USB_RxPacket
1551 AND it is not OUR device object
1552 Irp Ptr to completed IRP
1553 Context Ptr to our Adapter object (context specified
1554 in IoSetCompletionRoutine
1555
1556 Return Value:
1557 Always returns STATUS_MORE_PROCESSING_REQUIRED
1558
1559 Note:
1560 Always returns STATUS_MORE_PROCESSING_REQUIRED
1561 ========================================================================
1562 */
1563 VOID RTUSBBulkRxComplete(purbb_t pUrb, struct pt_regs *pt_regs)
1564 {
1565 // use a receive tasklet to handle received packets;
1566 // or sometimes hardware IRQ will be disabled here, so we can not
1567 // use spin_lock_bh()/spin_unlock_bh() after IRQ is disabled. :<
1568 PRX_CONTEXT pRxContext;
1569 PRTMP_ADAPTER pAd;
1570 POS_COOKIE pObj;
1571
1572
1573 pRxContext = (PRX_CONTEXT)pUrb->context;
1574 pAd = pRxContext->pAd;
1575 pObj = (POS_COOKIE) pAd->OS_Cookie;
1576
1577 pObj->rx_done_task.data = (unsigned long)pUrb;
1578 tasklet_hi_schedule(&pObj->rx_done_task);
1579
1580 }
1581
1582 #endif
1583
1584
1585
1586 /*
1587 ========================================================================
1588
1589 Routine Description:
1590
1591 Arguments:
1592
1593 Return Value:
1594
1595 Note:
1596
1597 ========================================================================
1598 */
1599 VOID RTUSBKickBulkOut(
1600 IN PRTMP_ADAPTER pAd)
1601 {
1602 // BulkIn Reset will reset whole USB PHY. So we need to make sure fRTMP_ADAPTER_BULKIN_RESET not flaged.
1603 if (!RTMP_TEST_FLAG(pAd ,fRTMP_ADAPTER_NEED_STOP_TX)
1604 #ifdef RALINK_ATE
1605 && !(ATE_ON(pAd))
1606 #endif // RALINK_ATE //
1607 )
1608 {
1609 #if 0 // not used now in RT28xx, but may used latter.
1610 // 1. Data Fragment has highest priority
1611 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_FRAG))
1612 {
1613 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1614 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1615 ))
1616 {
1617 RTUSBBulkOutDataPacket(pAd, 0, pAd->NextBulkOutIndex[0]);
1618 }
1619 }
1620 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_FRAG_2))
1621 {
1622 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1623 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1624 ))
1625 {
1626 RTUSBBulkOutDataPacket(pAd, 1, pAd->NextBulkOutIndex[1]);
1627 }
1628 }
1629 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_FRAG_3))
1630 {
1631 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1632 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1633 ))
1634 {
1635 RTUSBBulkOutDataPacket(pAd, 2, pAd->NextBulkOutIndex[2]);
1636 }
1637 }
1638 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_FRAG_4))
1639 {
1640 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1641 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1642 ))
1643 {
1644 RTUSBBulkOutDataPacket(pAd, 3, pAd->NextBulkOutIndex[3]);
1645 }
1646 }
1647 #endif
1648
1649 // 2. PS-Poll frame is next
1650 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_PSPOLL))
1651 {
1652 RTUSBBulkOutPsPoll(pAd);
1653 }
1654
1655 // 5. Mlme frame is next
1656 else if ((RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME)) &&
1657 (pAd->MgmtRing.TxSwFreeIdx < MGMT_RING_SIZE))
1658 {
1659 RTUSBBulkOutMLMEPacket(pAd, pAd->MgmtRing.TxDmaIdx);
1660 }
1661
1662 // 6. Data frame normal is next
1663 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL))
1664 {
1665 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1666 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1667 ))
1668 {
1669 RTUSBBulkOutDataPacket(pAd, 0, pAd->NextBulkOutIndex[0]);
1670 }
1671 }
1672 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_2))
1673 {
1674 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1675 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1676 ))
1677 {
1678 RTUSBBulkOutDataPacket(pAd, 1, pAd->NextBulkOutIndex[1]);
1679 }
1680 }
1681 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_3))
1682 {
1683 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1684 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1685 ))
1686 {
1687 RTUSBBulkOutDataPacket(pAd, 2, pAd->NextBulkOutIndex[2]);
1688 }
1689 }
1690 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL_4))
1691 {
1692 if (((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) ||
1693 (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1694 ))
1695 {
1696 RTUSBBulkOutDataPacket(pAd, 3, pAd->NextBulkOutIndex[3]);
1697 }
1698 }
1699
1700 // 7. Null frame is the last
1701 else if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NULL))
1702 {
1703 if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
1704 {
1705 RTUSBBulkOutNullFrame(pAd);
1706 }
1707 }
1708
1709 // 8. No data avaliable
1710 else
1711 {
1712
1713 }
1714 }
1715 #ifdef RALINK_ATE
1716 /* If the mode is in ATE mode. */
1717 else if((ATE_ON(pAd)) &&
1718 !RTMP_TEST_FLAG(pAd ,fRTMP_ADAPTER_NEED_STOP_TX))// PETER : watch out !
1719 {
1720 if (RTUSB_TEST_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE))
1721 {
1722 ATE_RTUSBBulkOutDataPacket(pAd, 0);
1723 }
1724 }
1725 #endif // RALINK_ATE //
1726
1727 }
1728
1729 /*
1730 ========================================================================
1731
1732 Routine Description:
1733 Call from Reset action after BulkOut failed.
1734 Arguments:
1735
1736 Return Value:
1737
1738 Note:
1739
1740 ========================================================================
1741 */
1742 VOID RTUSBCleanUpDataBulkOutQueue(
1743 IN PRTMP_ADAPTER pAd)
1744 {
1745 UCHAR Idx;
1746 PHT_TX_CONTEXT pTxContext;
1747
1748 DBGPRINT(RT_DEBUG_TRACE, ("--->CleanUpDataBulkOutQueue\n"));
1749
1750 for (Idx = 0; Idx < 4; Idx++)
1751 {
1752 pTxContext = &pAd->TxContext[Idx];
1753
1754 pTxContext->CurWritePosition = pTxContext->NextBulkOutPosition;
1755 pTxContext->LastOne = FALSE;
1756 NdisAcquireSpinLock(&pAd->BulkOutLock[Idx]);
1757 pAd->BulkOutPending[Idx] = FALSE;
1758 NdisReleaseSpinLock(&pAd->BulkOutLock[Idx]);
1759 }
1760
1761 DBGPRINT(RT_DEBUG_TRACE, ("<---CleanUpDataBulkOutQueue\n"));
1762 }
1763
1764 /*
1765 ========================================================================
1766
1767 Routine Description:
1768
1769 Arguments:
1770
1771 Return Value:
1772
1773 Note:
1774
1775 ========================================================================
1776 */
1777 VOID RTUSBCleanUpMLMEBulkOutQueue(
1778 IN PRTMP_ADAPTER pAd)
1779 {
1780 DBGPRINT(RT_DEBUG_TRACE, ("--->CleanUpMLMEBulkOutQueue\n"));
1781
1782 #if 0 // Do nothing!
1783 NdisAcquireSpinLock(&pAd->MLMEBulkOutLock);
1784 while (pAd->PrioRingTxCnt > 0)
1785 {
1786 pAd->MLMEContext[pAd->PrioRingFirstIndex].InUse = FALSE;
1787
1788 pAd->PrioRingFirstIndex++;
1789 if (pAd->PrioRingFirstIndex >= MGMT_RING_SIZE)
1790 {
1791 pAd->PrioRingFirstIndex = 0;
1792 }
1793
1794 pAd->PrioRingTxCnt--;
1795 }
1796 NdisReleaseSpinLock(&pAd->MLMEBulkOutLock);
1797 #endif
1798
1799 DBGPRINT(RT_DEBUG_TRACE, ("<---CleanUpMLMEBulkOutQueue\n"));
1800 }
1801
1802
1803 /*
1804 ========================================================================
1805
1806 Routine Description:
1807
1808 Arguments:
1809
1810 Return Value:
1811
1812
1813 Note:
1814
1815 ========================================================================
1816 */
1817 VOID RTUSBCancelPendingIRPs(
1818 IN PRTMP_ADAPTER pAd)
1819 {
1820 RTUSBCancelPendingBulkInIRP(pAd);
1821 RTUSBCancelPendingBulkOutIRP(pAd);
1822 }
1823
1824 /*
1825 ========================================================================
1826
1827 Routine Description:
1828
1829 Arguments:
1830
1831 Return Value:
1832
1833 Note:
1834
1835 ========================================================================
1836 */
1837 VOID RTUSBCancelPendingBulkInIRP(
1838 IN PRTMP_ADAPTER pAd)
1839 {
1840 PRX_CONTEXT pRxContext;
1841 UINT i;
1842
1843 DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->RTUSBCancelPendingBulkInIRP\n"));
1844 for ( i = 0; i < (RX_RING_SIZE); i++)
1845 {
1846 pRxContext = &(pAd->RxContext[i]);
1847 if(pRxContext->IRPPending == TRUE)
1848 {
1849 RTUSB_UNLINK_URB(pRxContext->pUrb);
1850 pRxContext->IRPPending = FALSE;
1851 pRxContext->InUse = FALSE;
1852 //NdisInterlockedDecrement(&pAd->PendingRx);
1853 //pAd->PendingRx--;
1854 }
1855 }
1856 DBGPRINT_RAW(RT_DEBUG_TRACE, ("<---RTUSBCancelPendingBulkInIRP\n"));
1857 }
1858
1859
1860 /*
1861 ========================================================================
1862
1863 Routine Description:
1864
1865 Arguments:
1866
1867 Return Value:
1868
1869 Note:
1870
1871 ========================================================================
1872 */
1873 VOID RTUSBCancelPendingBulkOutIRP(
1874 IN PRTMP_ADAPTER pAd)
1875 {
1876 PHT_TX_CONTEXT pHTTXContext;
1877 PTX_CONTEXT pMLMEContext;
1878 PTX_CONTEXT pBeaconContext;
1879 PTX_CONTEXT pNullContext;
1880 PTX_CONTEXT pPsPollContext;
1881 PTX_CONTEXT pRTSContext;
1882 UINT i, Idx;
1883 // unsigned int IrqFlags;
1884 // NDIS_SPIN_LOCK *pLock;
1885 // BOOLEAN *pPending;
1886
1887
1888 // pLock = &pAd->BulkOutLock[MGMTPIPEIDX];
1889 // pPending = &pAd->BulkOutPending[MGMTPIPEIDX];
1890
1891 for (Idx = 0; Idx < 4; Idx++)
1892 {
1893 pHTTXContext = &(pAd->TxContext[Idx]);
1894
1895 if (pHTTXContext->IRPPending == TRUE)
1896 {
1897
1898 // Get the USB_CONTEXT and cancel it's IRP; the completion routine will itself
1899 // remove it from the HeadPendingSendList and NULL out HeadPendingSendList
1900 // when the last IRP on the list has been cancelled; that's how we exit this loop
1901 //
1902
1903 RTUSB_UNLINK_URB(pHTTXContext->pUrb);
1904
1905 // Sleep 200 microseconds to give cancellation time to work
1906 RTMPusecDelay(200);
1907 }
1908
1909 #ifdef RALINK_ATE
1910 pHTTXContext->bCopySavePad = 0;
1911 pHTTXContext->CurWritePosition = 0;
1912 pHTTXContext->CurWriteRealPos = 0;
1913 pHTTXContext->bCurWriting = FALSE;
1914 pHTTXContext->NextBulkOutPosition = 0;
1915 pHTTXContext->ENextBulkOutPosition = 0;
1916 #endif // RALINK_ATE //
1917 pAd->BulkOutPending[Idx] = FALSE;
1918 }
1919
1920 //RTMP_IRQ_LOCK(pLock, IrqFlags);
1921 for (i = 0; i < MGMT_RING_SIZE; i++)
1922 {
1923 pMLMEContext = (PTX_CONTEXT)pAd->MgmtRing.Cell[i].AllocVa;
1924 if(pMLMEContext && (pMLMEContext->IRPPending == TRUE))
1925 {
1926
1927 // Get the USB_CONTEXT and cancel it's IRP; the completion routine will itself
1928 // remove it from the HeadPendingSendList and NULL out HeadPendingSendList
1929 // when the last IRP on the list has been cancelled; that's how we exit this loop
1930 //
1931
1932 RTUSB_UNLINK_URB(pMLMEContext->pUrb);
1933 pMLMEContext->IRPPending = FALSE;
1934
1935 // Sleep 200 microsecs to give cancellation time to work
1936 RTMPusecDelay(200);
1937 }
1938 }
1939 pAd->BulkOutPending[MGMTPIPEIDX] = FALSE;
1940 //RTMP_IRQ_UNLOCK(pLock, IrqFlags);
1941
1942
1943 for (i = 0; i < BEACON_RING_SIZE; i++)
1944 {
1945 pBeaconContext = &(pAd->BeaconContext[i]);
1946
1947 if(pBeaconContext->IRPPending == TRUE)
1948 {
1949
1950 // Get the USB_CONTEXT and cancel it's IRP; the completion routine will itself
1951 // remove it from the HeadPendingSendList and NULL out HeadPendingSendList
1952 // when the last IRP on the list has been cancelled; that's how we exit this loop
1953 //
1954
1955 RTUSB_UNLINK_URB(pBeaconContext->pUrb);
1956
1957 // Sleep 200 microsecs to give cancellation time to work
1958 RTMPusecDelay(200);
1959 }
1960 }
1961
1962 pNullContext = &(pAd->NullContext);
1963 if (pNullContext->IRPPending == TRUE)
1964 RTUSB_UNLINK_URB(pNullContext->pUrb);
1965
1966 pRTSContext = &(pAd->RTSContext);
1967 if (pRTSContext->IRPPending == TRUE)
1968 RTUSB_UNLINK_URB(pRTSContext->pUrb);
1969
1970 pPsPollContext = &(pAd->PsPollContext);
1971 if (pPsPollContext->IRPPending == TRUE)
1972 RTUSB_UNLINK_URB(pPsPollContext->pUrb);
1973
1974 for (Idx = 0; Idx < 4; Idx++)
1975 {
1976 NdisAcquireSpinLock(&pAd->BulkOutLock[Idx]);
1977 pAd->BulkOutPending[Idx] = FALSE;
1978 NdisReleaseSpinLock(&pAd->BulkOutLock[Idx]);
1979 }
1980 }
1981
Support for the Chinese Samsung S3C2440 based development boards