?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: rt2870: add fRTUSB_BULK_OUT_DATA_NORMAL_5 quirk
[linux-2.6/kvm.git] / drivers / staging / rt2870 / common / 2870_rtmp_init.c
blobf517d9e902711fae99a6f01a680dbff223bc3382
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 2870_rtmp_init.c
29
30 Abstract:
31 Miniport generic portion header file
32
33 Revision History:
34 Who When What
35 -------- ---------- ----------------------------------------------
36 Paul Lin 2002-08-01 created
37 John Chang 2004-08-20 RT2561/2661 use scatter-gather scheme
38 Jan Lee 2006-09-15 RT2860. Change for 802.11n , EEPROM, Led, BA, HT.
39 Sample Lin 2007-05-31 Merge RT2860 and RT2870 drivers.
40 */
41
42 #include "../rt_config.h"
43
44
45 static void rx_done_tasklet(unsigned long data);
46 static void rt2870_hcca_dma_done_tasklet(unsigned long data);
47 static void rt2870_ac3_dma_done_tasklet(unsigned long data);
48 static void rt2870_ac2_dma_done_tasklet(unsigned long data);
49 static void rt2870_ac1_dma_done_tasklet(unsigned long data);
50 static void rt2870_ac0_dma_done_tasklet(unsigned long data);
51 static void rt2870_mgmt_dma_done_tasklet(unsigned long data);
52 static void rt2870_null_frame_complete_tasklet(unsigned long data);
53 static void rt2870_rts_frame_complete_tasklet(unsigned long data);
54 static void rt2870_pspoll_frame_complete_tasklet(unsigned long data);
55 static void rt2870_dataout_complete_tasklet(unsigned long data);
56
57
58 /*
59 ========================================================================
60 Routine Description:
61 Initialize receive data structures.
62
63 Arguments:
64 pAd Pointer to our adapter
65
66 Return Value:
67 NDIS_STATUS_SUCCESS
68 NDIS_STATUS_RESOURCES
69
70 Note:
71 Initialize all receive releated private buffer, include those define
72 in RTMP_ADAPTER structure and all private data structures. The mahor
73 work is to allocate buffer for each packet and chain buffer to
74 NDIS packet descriptor.
75 ========================================================================
76 */
77 NDIS_STATUS NICInitRecv(
78 IN PRTMP_ADAPTER pAd)
79 {
80 UCHAR i;
81 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
82 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
83
84
85 DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitRecv\n"));
86 pObj = pObj;
87
88 //InterlockedExchange(&pAd->PendingRx, 0);
89 pAd->PendingRx = 0;
90 pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
91 pAd->NextRxBulkInIndex = 0 ; //RX_RING_SIZE -1; // Rx Bulk pointer
92 pAd->NextRxBulkInPosition = 0;
93
94 for (i = 0; i < (RX_RING_SIZE); i++)
95 {
96 PRX_CONTEXT pRxContext = &(pAd->RxContext[i]);
97
98 //Allocate URB
99 pRxContext->pUrb = RTUSB_ALLOC_URB(0);
100 if (pRxContext->pUrb == NULL)
101 {
102 Status = NDIS_STATUS_RESOURCES;
103 goto out1;
104 }
105
106 // Allocate transfer buffer
107 pRxContext->TransferBuffer = RTUSB_URB_ALLOC_BUFFER(pObj->pUsb_Dev, MAX_RXBULK_SIZE, &pRxContext->data_dma);
108 if (pRxContext->TransferBuffer == NULL)
109 {
110 Status = NDIS_STATUS_RESOURCES;
111 goto out1;
112 }
113
114 NdisZeroMemory(pRxContext->TransferBuffer, MAX_RXBULK_SIZE);
115
116 pRxContext->pAd = pAd;
117 pRxContext->pIrp = NULL;
118 pRxContext->InUse = FALSE;
119 pRxContext->IRPPending = FALSE;
120 pRxContext->Readable = FALSE;
121 //pRxContext->ReorderInUse = FALSE;
122 pRxContext->bRxHandling = FALSE;
123 pRxContext->BulkInOffset = 0;
124 }
125
126 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitRecv\n"));
127 return Status;
128
129 out1:
130 for (i = 0; i < (RX_RING_SIZE); i++)
131 {
132 PRX_CONTEXT pRxContext = &(pAd->RxContext[i]);
133
134 if (NULL != pRxContext->TransferBuffer)
135 {
136 RTUSB_URB_FREE_BUFFER(pObj->pUsb_Dev, MAX_RXBULK_SIZE,
137 pRxContext->TransferBuffer, pRxContext->data_dma);
138 pRxContext->TransferBuffer = NULL;
139 }
140
141 if (NULL != pRxContext->pUrb)
142 {
143 RTUSB_UNLINK_URB(pRxContext->pUrb);
144 RTUSB_FREE_URB(pRxContext->pUrb);
145 pRxContext->pUrb = NULL;
146 }
147 }
148
149 return Status;
150 }
151
152
153 /*
154 ========================================================================
155 Routine Description:
156 Initialize transmit data structures.
157
158 Arguments:
159 pAd Pointer to our adapter
160
161 Return Value:
162 NDIS_STATUS_SUCCESS
163 NDIS_STATUS_RESOURCES
164
165 Note:
166 ========================================================================
167 */
168 NDIS_STATUS NICInitTransmit(
169 IN PRTMP_ADAPTER pAd)
170 {
171 #define LM_USB_ALLOC(pObj, Context, TB_Type, BufferSize, Status, msg1, err1, msg2, err2) \
172 Context->pUrb = RTUSB_ALLOC_URB(0); \
173 if (Context->pUrb == NULL) { \
174 DBGPRINT(RT_DEBUG_ERROR, msg1); \
175 Status = NDIS_STATUS_RESOURCES; \
176 goto err1; } \
177 \
178 Context->TransferBuffer = \
179 (TB_Type)RTUSB_URB_ALLOC_BUFFER(pObj->pUsb_Dev, BufferSize, &Context->data_dma); \
180 if (Context->TransferBuffer == NULL) { \
181 DBGPRINT(RT_DEBUG_ERROR, msg2); \
182 Status = NDIS_STATUS_RESOURCES; \
183 goto err2; }
184
185 #define LM_URB_FREE(pObj, Context, BufferSize) \
186 if (NULL != Context->pUrb) { \
187 RTUSB_UNLINK_URB(Context->pUrb); \
188 RTUSB_FREE_URB(Context->pUrb); \
189 Context->pUrb = NULL; } \
190 if (NULL != Context->TransferBuffer) { \
191 RTUSB_URB_FREE_BUFFER(pObj->pUsb_Dev, BufferSize, \
192 Context->TransferBuffer, \
193 Context->data_dma); \
194 Context->TransferBuffer = NULL; }
195
196 UCHAR i, acidx;
197 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
198 PTX_CONTEXT pNullContext = &(pAd->NullContext);
199 PTX_CONTEXT pPsPollContext = &(pAd->PsPollContext);
200 PTX_CONTEXT pRTSContext = &(pAd->RTSContext);
201 PTX_CONTEXT pMLMEContext = NULL;
202 // PHT_TX_CONTEXT pHTTXContext = NULL;
203 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
204 PVOID RingBaseVa;
205 // RTMP_TX_RING *pTxRing;
206 RTMP_MGMT_RING *pMgmtRing;
207
208 DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitTransmit\n"));
209 pObj = pObj;
210
211 // Init 4 set of Tx parameters
212 for(acidx = 0; acidx < NUM_OF_TX_RING; acidx++)
213 {
214 // Initialize all Transmit releated queues
215 InitializeQueueHeader(&pAd->TxSwQueue[acidx]);
216
217 // Next Local tx ring pointer waiting for buck out
218 pAd->NextBulkOutIndex[acidx] = acidx;
219 pAd->BulkOutPending[acidx] = FALSE; // Buck Out control flag
220 //pAd->DataBulkDoneIdx[acidx] = 0;
221 }
222
223 //pAd->NextMLMEIndex = 0;
224 //pAd->PushMgmtIndex = 0;
225 //pAd->PopMgmtIndex = 0;
226 //InterlockedExchange(&pAd->MgmtQueueSize, 0);
227 //InterlockedExchange(&pAd->TxCount, 0);
228
229 //pAd->PrioRingFirstIndex = 0;
230 //pAd->PrioRingTxCnt = 0;
231
232 do
233 {
234 //
235 // TX_RING_SIZE, 4 ACs
236 //
237 for(acidx=0; acidx<4; acidx++)
238 {
239 PHT_TX_CONTEXT pHTTXContext = &(pAd->TxContext[acidx]);
240
241 NdisZeroMemory(pHTTXContext, sizeof(HT_TX_CONTEXT));
242 //Allocate URB
243 LM_USB_ALLOC(pObj, pHTTXContext, PHTTX_BUFFER, sizeof(HTTX_BUFFER), Status,
244 ("<-- ERROR in Alloc TX TxContext[%d] urb!! \n", acidx),
245 done,
246 ("<-- ERROR in Alloc TX TxContext[%d] HTTX_BUFFER !! \n", acidx),
247 out1);
248
249 NdisZeroMemory(pHTTXContext->TransferBuffer->Aggregation, 4);
250 pHTTXContext->pAd = pAd;
251 pHTTXContext->pIrp = NULL;
252 pHTTXContext->IRPPending = FALSE;
253 pHTTXContext->NextBulkOutPosition = 0;
254 pHTTXContext->ENextBulkOutPosition = 0;
255 pHTTXContext->CurWritePosition = 0;
256 pHTTXContext->CurWriteRealPos = 0;
257 pHTTXContext->BulkOutSize = 0;
258 pHTTXContext->BulkOutPipeId = acidx;
259 pHTTXContext->bRingEmpty = TRUE;
260 pHTTXContext->bCopySavePad = FALSE;
261
262 pAd->BulkOutPending[acidx] = FALSE;
263 }
264
265
266 //
267 // MGMT_RING_SIZE
268 //
269 // Allocate MGMT ring descriptor's memory
270 pAd->MgmtDescRing.AllocSize = MGMT_RING_SIZE * sizeof(TX_CONTEXT);
271 RTMPAllocateMemory(&pAd->MgmtDescRing.AllocVa, pAd->MgmtDescRing.AllocSize);
272 if (pAd->MgmtDescRing.AllocVa == NULL)
273 {
274 DBGPRINT_ERR(("Failed to allocate a big buffer for MgmtDescRing!\n"));
275 Status = NDIS_STATUS_RESOURCES;
276 goto out1;
277 }
278 NdisZeroMemory(pAd->MgmtDescRing.AllocVa, pAd->MgmtDescRing.AllocSize);
279 RingBaseVa = pAd->MgmtDescRing.AllocVa;
280
281 // Initialize MGMT Ring and associated buffer memory
282 pMgmtRing = &pAd->MgmtRing;
283 for (i = 0; i < MGMT_RING_SIZE; i++)
284 {
285 // link the pre-allocated Mgmt buffer to MgmtRing.Cell
286 pMgmtRing->Cell[i].AllocSize = sizeof(TX_CONTEXT);
287 pMgmtRing->Cell[i].AllocVa = RingBaseVa;
288 pMgmtRing->Cell[i].pNdisPacket = NULL;
289 pMgmtRing->Cell[i].pNextNdisPacket = NULL;
290
291 //Allocate URB for MLMEContext
292 pMLMEContext = (PTX_CONTEXT) pAd->MgmtRing.Cell[i].AllocVa;
293 pMLMEContext->pUrb = RTUSB_ALLOC_URB(0);
294 if (pMLMEContext->pUrb == NULL)
295 {
296 DBGPRINT(RT_DEBUG_ERROR, ("<-- ERROR in Alloc TX MLMEContext[%d] urb!! \n", i));
297 Status = NDIS_STATUS_RESOURCES;
298 goto out2;
299 }
300 pMLMEContext->pAd = pAd;
301 pMLMEContext->pIrp = NULL;
302 pMLMEContext->TransferBuffer = NULL;
303 pMLMEContext->InUse = FALSE;
304 pMLMEContext->IRPPending = FALSE;
305 pMLMEContext->bWaitingBulkOut = FALSE;
306 pMLMEContext->BulkOutSize = 0;
307 pMLMEContext->SelfIdx = i;
308
309 // Offset to next ring descriptor address
310 RingBaseVa = (PUCHAR) RingBaseVa + sizeof(TX_CONTEXT);
311 }
312 DBGPRINT(RT_DEBUG_TRACE, ("MGMT Ring: total %d entry allocated\n", i));
313
314 //pAd->MgmtRing.TxSwFreeIdx = (MGMT_RING_SIZE - 1);
315 pAd->MgmtRing.TxSwFreeIdx = MGMT_RING_SIZE;
316 pAd->MgmtRing.TxCpuIdx = 0;
317 pAd->MgmtRing.TxDmaIdx = 0;
318
319 //
320 // BEACON_RING_SIZE
321 //
322 for(i=0; i<BEACON_RING_SIZE; i++) // 2
323 {
324 PTX_CONTEXT pBeaconContext = &(pAd->BeaconContext[i]);
325
326
327 NdisZeroMemory(pBeaconContext, sizeof(TX_CONTEXT));
328
329 //Allocate URB
330 LM_USB_ALLOC(pObj, pBeaconContext, PTX_BUFFER, sizeof(TX_BUFFER), Status,
331 ("<-- ERROR in Alloc TX BeaconContext[%d] urb!! \n", i),
332 out2,
333 ("<-- ERROR in Alloc TX BeaconContext[%d] TX_BUFFER !! \n", i),
334 out3);
335
336 pBeaconContext->pAd = pAd;
337 pBeaconContext->pIrp = NULL;
338 pBeaconContext->InUse = FALSE;
339 pBeaconContext->IRPPending = FALSE;
340 }
341
342 //
343 // NullContext
344 //
345 NdisZeroMemory(pNullContext, sizeof(TX_CONTEXT));
346
347 //Allocate URB
348 LM_USB_ALLOC(pObj, pNullContext, PTX_BUFFER, sizeof(TX_BUFFER), Status,
349 ("<-- ERROR in Alloc TX NullContext urb!! \n"),
350 out3,
351 ("<-- ERROR in Alloc TX NullContext TX_BUFFER !! \n"),
352 out4);
353
354 pNullContext->pAd = pAd;
355 pNullContext->pIrp = NULL;
356 pNullContext->InUse = FALSE;
357 pNullContext->IRPPending = FALSE;
358
359 //
360 // RTSContext
361 //
362 NdisZeroMemory(pRTSContext, sizeof(TX_CONTEXT));
363
364 //Allocate URB
365 LM_USB_ALLOC(pObj, pRTSContext, PTX_BUFFER, sizeof(TX_BUFFER), Status,
366 ("<-- ERROR in Alloc TX RTSContext urb!! \n"),
367 out4,
368 ("<-- ERROR in Alloc TX RTSContext TX_BUFFER !! \n"),
369 out5);
370
371 pRTSContext->pAd = pAd;
372 pRTSContext->pIrp = NULL;
373 pRTSContext->InUse = FALSE;
374 pRTSContext->IRPPending = FALSE;
375
376 //
377 // PsPollContext
378 //
379 //NdisZeroMemory(pPsPollContext, sizeof(TX_CONTEXT));
380 //Allocate URB
381 LM_USB_ALLOC(pObj, pPsPollContext, PTX_BUFFER, sizeof(TX_BUFFER), Status,
382 ("<-- ERROR in Alloc TX PsPollContext urb!! \n"),
383 out5,
384 ("<-- ERROR in Alloc TX PsPollContext TX_BUFFER !! \n"),
385 out6);
386
387 pPsPollContext->pAd = pAd;
388 pPsPollContext->pIrp = NULL;
389 pPsPollContext->InUse = FALSE;
390 pPsPollContext->IRPPending = FALSE;
391 pPsPollContext->bAggregatible = FALSE;
392 pPsPollContext->LastOne = TRUE;
393
394 } while (FALSE);
395
396
397 done:
398 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitTransmit\n"));
399
400 return Status;
401
402 /* --------------------------- ERROR HANDLE --------------------------- */
403 out6:
404 LM_URB_FREE(pObj, pPsPollContext, sizeof(TX_BUFFER));
405
406 out5:
407 LM_URB_FREE(pObj, pRTSContext, sizeof(TX_BUFFER));
408
409 out4:
410 LM_URB_FREE(pObj, pNullContext, sizeof(TX_BUFFER));
411
412 out3:
413 for(i=0; i<BEACON_RING_SIZE; i++)
414 {
415 PTX_CONTEXT pBeaconContext = &(pAd->BeaconContext[i]);
416 if (pBeaconContext)
417 LM_URB_FREE(pObj, pBeaconContext, sizeof(TX_BUFFER));
418 }
419
420 out2:
421 if (pAd->MgmtDescRing.AllocVa)
422 {
423 pMgmtRing = &pAd->MgmtRing;
424 for(i=0; i<MGMT_RING_SIZE; i++)
425 {
426 pMLMEContext = (PTX_CONTEXT) pAd->MgmtRing.Cell[i].AllocVa;
427 if (pMLMEContext)
428 LM_URB_FREE(pObj, pMLMEContext, sizeof(TX_BUFFER));
429 }
430 NdisFreeMemory(pAd->MgmtDescRing.AllocVa, pAd->MgmtDescRing.AllocSize, 0);
431 pAd->MgmtDescRing.AllocVa = NULL;
432 }
433
434 out1:
435 for (acidx = 0; acidx < 4; acidx++)
436 {
437 PHT_TX_CONTEXT pTxContext = &(pAd->TxContext[acidx]);
438 if (pTxContext)
439 LM_URB_FREE(pObj, pTxContext, sizeof(HTTX_BUFFER));
440 }
441
442 // Here we didn't have any pre-allocated memory need to free.
443
444 return Status;
445 }
446
447
448 /*
449 ========================================================================
450 Routine Description:
451 Allocate DMA memory blocks for send, receive.
452
453 Arguments:
454 pAd Pointer to our adapter
455
456 Return Value:
457 NDIS_STATUS_SUCCESS
458 NDIS_STATUS_FAILURE
459 NDIS_STATUS_RESOURCES
460
461 Note:
462 ========================================================================
463 */
464 NDIS_STATUS RTMPAllocTxRxRingMemory(
465 IN PRTMP_ADAPTER pAd)
466 {
467 // COUNTER_802_11 pCounter = &pAd->WlanCounters;
468 NDIS_STATUS Status;
469 INT num;
470
471
472 DBGPRINT(RT_DEBUG_TRACE, ("--> RTMPAllocTxRxRingMemory\n"));
473
474
475 do
476 {
477 // Init the CmdQ and CmdQLock
478 NdisAllocateSpinLock(&pAd->CmdQLock);
479 NdisAcquireSpinLock(&pAd->CmdQLock);
480 RTUSBInitializeCmdQ(&pAd->CmdQ);
481 NdisReleaseSpinLock(&pAd->CmdQLock);
482
483
484 NdisAllocateSpinLock(&pAd->MLMEBulkOutLock);
485 //NdisAllocateSpinLock(&pAd->MLMEWaitQueueLock);
486 NdisAllocateSpinLock(&pAd->BulkOutLock[0]);
487 NdisAllocateSpinLock(&pAd->BulkOutLock[1]);
488 NdisAllocateSpinLock(&pAd->BulkOutLock[2]);
489 NdisAllocateSpinLock(&pAd->BulkOutLock[3]);
490 NdisAllocateSpinLock(&pAd->BulkOutLock[4]);
491 NdisAllocateSpinLock(&pAd->BulkOutLock[5]);
492 NdisAllocateSpinLock(&pAd->BulkInLock);
493
494 for (num = 0; num < NUM_OF_TX_RING; num++)
495 {
496 NdisAllocateSpinLock(&pAd->TxContextQueueLock[num]);
497 }
498
499 // NdisAllocateSpinLock(&pAd->MemLock); // Not used in RT28XX
500
501 // NdisAllocateSpinLock(&pAd->MacTabLock); // init it in UserCfgInit()
502 // NdisAllocateSpinLock(&pAd->BATabLock); // init it in BATableInit()
503
504 // for(num=0; num<MAX_LEN_OF_BA_REC_TABLE; num++)
505 // {
506 // NdisAllocateSpinLock(&pAd->BATable.BARecEntry[num].RxReRingLock);
507 // }
508
509 //
510 // Init Mac Table
511 //
512 // MacTableInitialize(pAd);
513
514 //
515 // Init send data structures and related parameters
516 //
517 Status = NICInitTransmit(pAd);
518 if (Status != NDIS_STATUS_SUCCESS)
519 break;
520
521 //
522 // Init receive data structures and related parameters
523 //
524 Status = NICInitRecv(pAd);
525 if (Status != NDIS_STATUS_SUCCESS)
526 break;
527
528 pAd->PendingIoCount = 1;
529
530 } while (FALSE);
531
532 NdisZeroMemory(&pAd->FragFrame, sizeof(FRAGMENT_FRAME));
533 pAd->FragFrame.pFragPacket = RTMP_AllocateFragPacketBuffer(pAd, RX_BUFFER_NORMSIZE);
534
535 if (pAd->FragFrame.pFragPacket == NULL)
536 {
537 Status = NDIS_STATUS_RESOURCES;
538 }
539
540 DBGPRINT_S(Status, ("<-- RTMPAllocTxRxRingMemory, Status=%x\n", Status));
541 return Status;
542 }
543
544
545 /*
546 ========================================================================
547 Routine Description:
548 Calls USB_InterfaceStop and frees memory allocated for the URBs
549 calls NdisMDeregisterDevice and frees the memory
550 allocated in VNetInitialize for the Adapter Object
551
552 Arguments:
553 *pAd the raxx interface data pointer
554
555 Return Value:
556 None
557
558 Note:
559 ========================================================================
560 */
561 VOID RTMPFreeTxRxRingMemory(
562 IN PRTMP_ADAPTER pAd)
563 {
564 #define LM_URB_FREE(pObj, Context, BufferSize) \
565 if (NULL != Context->pUrb) { \
566 RTUSB_UNLINK_URB(Context->pUrb); \
567 RTUSB_FREE_URB(Context->pUrb); \
568 Context->pUrb = NULL; } \
569 if (NULL != Context->TransferBuffer) { \
570 RTUSB_URB_FREE_BUFFER(pObj->pUsb_Dev, BufferSize, \
571 Context->TransferBuffer, \
572 Context->data_dma); \
573 Context->TransferBuffer = NULL; }
574
575
576 UINT i, acidx;
577 PTX_CONTEXT pNullContext = &pAd->NullContext;
578 PTX_CONTEXT pPsPollContext = &pAd->PsPollContext;
579 PTX_CONTEXT pRTSContext = &pAd->RTSContext;
580 // PHT_TX_CONTEXT pHTTXContext;
581 //PRTMP_REORDERBUF pReorderBuf;
582 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
583 // RTMP_TX_RING *pTxRing;
584
585 DBGPRINT(RT_DEBUG_ERROR, ("---> RTMPFreeTxRxRingMemory\n"));
586 pObj = pObj;
587
588 // Free all resources for the RECEIVE buffer queue.
589 for(i=0; i<(RX_RING_SIZE); i++)
590 {
591 PRX_CONTEXT pRxContext = &(pAd->RxContext[i]);
592 if (pRxContext)
593 LM_URB_FREE(pObj, pRxContext, MAX_RXBULK_SIZE);
594 }
595
596 // Free PsPoll frame resource
597 LM_URB_FREE(pObj, pPsPollContext, sizeof(TX_BUFFER));
598
599 // Free NULL frame resource
600 LM_URB_FREE(pObj, pNullContext, sizeof(TX_BUFFER));
601
602 // Free RTS frame resource
603 LM_URB_FREE(pObj, pRTSContext, sizeof(TX_BUFFER));
604
605
606 // Free beacon frame resource
607 for(i=0; i<BEACON_RING_SIZE; i++)
608 {
609 PTX_CONTEXT pBeaconContext = &(pAd->BeaconContext[i]);
610 if (pBeaconContext)
611 LM_URB_FREE(pObj, pBeaconContext, sizeof(TX_BUFFER));
612 }
613
614
615 // Free mgmt frame resource
616 for(i = 0; i < MGMT_RING_SIZE; i++)
617 {
618 PTX_CONTEXT pMLMEContext = (PTX_CONTEXT)pAd->MgmtRing.Cell[i].AllocVa;
619 //LM_URB_FREE(pObj, pMLMEContext, sizeof(TX_BUFFER));
620 if (NULL != pAd->MgmtRing.Cell[i].pNdisPacket)
621 {
622 RTMPFreeNdisPacket(pAd, pAd->MgmtRing.Cell[i].pNdisPacket);
623 pAd->MgmtRing.Cell[i].pNdisPacket = NULL;
624 pMLMEContext->TransferBuffer = NULL;
625 }
626
627 if (pMLMEContext)
628 {
629 if (NULL != pMLMEContext->pUrb)
630 {
631 RTUSB_UNLINK_URB(pMLMEContext->pUrb);
632 RTUSB_FREE_URB(pMLMEContext->pUrb);
633 pMLMEContext->pUrb = NULL;
634 }
635 }
636 }
637 if (pAd->MgmtDescRing.AllocVa)
638 NdisFreeMemory(pAd->MgmtDescRing.AllocVa, pAd->MgmtDescRing.AllocSize, 0);
639
640
641 // Free Tx frame resource
642 for(acidx=0; acidx<4; acidx++)
643 {
644 PHT_TX_CONTEXT pHTTXContext = &(pAd->TxContext[acidx]);
645 if (pHTTXContext)
646 LM_URB_FREE(pObj, pHTTXContext, sizeof(HTTX_BUFFER));
647 }
648
649 if (pAd->FragFrame.pFragPacket)
650 RELEASE_NDIS_PACKET(pAd, pAd->FragFrame.pFragPacket, NDIS_STATUS_SUCCESS);
651
652 for(i=0; i<6; i++)
653 {
654 NdisFreeSpinLock(&pAd->BulkOutLock[i]);
655 }
656
657 NdisFreeSpinLock(&pAd->BulkInLock);
658 NdisFreeSpinLock(&pAd->MLMEBulkOutLock);
659
660 NdisFreeSpinLock(&pAd->CmdQLock);
661
662 // Clear all pending bulk-out request flags.
663 RTUSB_CLEAR_BULK_FLAG(pAd, 0xffffffff);
664
665 // NdisFreeSpinLock(&pAd->MacTabLock);
666
667 // for(i=0; i<MAX_LEN_OF_BA_REC_TABLE; i++)
668 // {
669 // NdisFreeSpinLock(&pAd->BATable.BARecEntry[i].RxReRingLock);
670 // }
671
672 DBGPRINT(RT_DEBUG_ERROR, ("<--- ReleaseAdapter\n"));
673 }
674
675
676 /*
677 ========================================================================
678 Routine Description:
679 Allocate memory for adapter control block.
680
681 Arguments:
682 pAd Pointer to our adapter
683
684 Return Value:
685 NDIS_STATUS_SUCCESS
686 NDIS_STATUS_FAILURE
687 NDIS_STATUS_RESOURCES
688
689 Note:
690 ========================================================================
691 */
692 NDIS_STATUS AdapterBlockAllocateMemory(
693 IN PVOID handle,
694 OUT PVOID *ppAd)
695 {
696 PUSB_DEV usb_dev;
697 POS_COOKIE pObj = (POS_COOKIE) handle;
698
699
700 usb_dev = pObj->pUsb_Dev;
701
702 pObj->MLMEThr_pid = NULL;
703 pObj->RTUSBCmdThr_pid = NULL;
704
705 *ppAd = (PVOID)vmalloc(sizeof(RTMP_ADAPTER));
706
707 if (*ppAd)
708 {
709 NdisZeroMemory(*ppAd, sizeof(RTMP_ADAPTER));
710 ((PRTMP_ADAPTER)*ppAd)->OS_Cookie = handle;
711 return (NDIS_STATUS_SUCCESS);
712 }
713 else
714 {
715 return (NDIS_STATUS_FAILURE);
716 }
717 }
718
719
720 /*
721 ========================================================================
722 Routine Description:
723 Create kernel threads & tasklets.
724
725 Arguments:
726 *net_dev Pointer to wireless net device interface
727
728 Return Value:
729 NDIS_STATUS_SUCCESS
730 NDIS_STATUS_FAILURE
731
732 Note:
733 ========================================================================
734 */
735 NDIS_STATUS CreateThreads(
736 IN struct net_device *net_dev)
737 {
738 PRTMP_ADAPTER pAd = net_dev->ml_priv;
739 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
740 pid_t pid_number;
741
742 //init_MUTEX(&(pAd->usbdev_semaphore));
743
744 init_MUTEX_LOCKED(&(pAd->mlme_semaphore));
745 init_completion (&pAd->mlmeComplete);
746
747 init_MUTEX_LOCKED(&(pAd->RTUSBCmd_semaphore));
748 init_completion (&pAd->CmdQComplete);
749
750 init_MUTEX_LOCKED(&(pAd->RTUSBTimer_semaphore));
751 init_completion (&pAd->TimerQComplete);
752
753 // Creat MLME Thread
754 pObj->MLMEThr_pid = NULL;
755 pid_number = kernel_thread(MlmeThread, pAd, CLONE_VM);
756 if (pid_number < 0)
757 {
758 printk (KERN_WARNING "%s: unable to start Mlme thread\n",pAd->net_dev->name);
759 return NDIS_STATUS_FAILURE;
760 }
761
762 pObj->MLMEThr_pid = find_get_pid(pid_number);
763
764 // Wait for the thread to start
765 wait_for_completion(&(pAd->mlmeComplete));
766
767 // Creat Command Thread
768 pObj->RTUSBCmdThr_pid = NULL;
769 pid_number = kernel_thread(RTUSBCmdThread, pAd, CLONE_VM);
770 if (pid_number < 0)
771 {
772 printk (KERN_WARNING "%s: unable to start RTUSBCmd thread\n",pAd->net_dev->name);
773 return NDIS_STATUS_FAILURE;
774 }
775
776 pObj->RTUSBCmdThr_pid = find_get_pid(pid_number);
777
778 wait_for_completion(&(pAd->CmdQComplete));
779
780 pObj->TimerQThr_pid = NULL;
781 pid_number = kernel_thread(TimerQThread, pAd, CLONE_VM);
782 if (pid_number < 0)
783 {
784 printk (KERN_WARNING "%s: unable to start TimerQThread\n",pAd->net_dev->name);
785 return NDIS_STATUS_FAILURE;
786 }
787
788 pObj->TimerQThr_pid = find_get_pid(pid_number);
789
790 // Wait for the thread to start
791 wait_for_completion(&(pAd->TimerQComplete));
792
793 // Create receive tasklet
794 tasklet_init(&pObj->rx_done_task, rx_done_tasklet, (ULONG)pAd);
795 tasklet_init(&pObj->mgmt_dma_done_task, rt2870_mgmt_dma_done_tasklet, (unsigned long)pAd);
796 tasklet_init(&pObj->ac0_dma_done_task, rt2870_ac0_dma_done_tasklet, (unsigned long)pAd);
797 tasklet_init(&pObj->ac1_dma_done_task, rt2870_ac1_dma_done_tasklet, (unsigned long)pAd);
798 tasklet_init(&pObj->ac2_dma_done_task, rt2870_ac2_dma_done_tasklet, (unsigned long)pAd);
799 tasklet_init(&pObj->ac3_dma_done_task, rt2870_ac3_dma_done_tasklet, (unsigned long)pAd);
800 tasklet_init(&pObj->hcca_dma_done_task, rt2870_hcca_dma_done_tasklet, (unsigned long)pAd);
801 tasklet_init(&pObj->tbtt_task, tbtt_tasklet, (unsigned long)pAd);
802 tasklet_init(&pObj->null_frame_complete_task, rt2870_null_frame_complete_tasklet, (unsigned long)pAd);
803 tasklet_init(&pObj->rts_frame_complete_task, rt2870_rts_frame_complete_tasklet, (unsigned long)pAd);
804 tasklet_init(&pObj->pspoll_frame_complete_task, rt2870_pspoll_frame_complete_tasklet, (unsigned long)pAd);
805
806 return NDIS_STATUS_SUCCESS;
807 }
808
809 /*
810 ========================================================================
811 Routine Description:
812 As STA's BSSID is a WC too, it uses shared key table.
813 This function write correct unicast TX key to ASIC WCID.
814 And we still make a copy in our MacTab.Content[BSSID_WCID].PairwiseKey.
815 Caller guarantee TKIP/AES always has keyidx = 0. (pairwise key)
816 Caller guarantee WEP calls this function when set Txkey, default key index=0~3.
817
818 Arguments:
819 pAd Pointer to our adapter
820 pKey Pointer to the where the key stored
821
822 Return Value:
823 NDIS_SUCCESS Add key successfully
824
825 Note:
826 ========================================================================
827 */
828 VOID RTMPAddBSSIDCipher(
829 IN PRTMP_ADAPTER pAd,
830 IN UCHAR Aid,
831 IN PNDIS_802_11_KEY pKey,
832 IN UCHAR CipherAlg)
833 {
834 PUCHAR pTxMic, pRxMic;
835 BOOLEAN bKeyRSC, bAuthenticator; // indicate the receive SC set by KeyRSC value
836 // UCHAR CipherAlg;
837 UCHAR i;
838 ULONG WCIDAttri;
839 USHORT offset;
840 UCHAR KeyIdx, IVEIV[8];
841 UINT32 Value;
842
843 DBGPRINT(RT_DEBUG_TRACE, ("RTMPAddBSSIDCipher==> Aid = %d\n",Aid));
844
845 // Bit 29 of Add-key KeyRSC
846 bKeyRSC = (pKey->KeyIndex & 0x20000000) ? TRUE : FALSE;
847
848 // Bit 28 of Add-key Authenticator
849 bAuthenticator = (pKey->KeyIndex & 0x10000000) ? TRUE : FALSE;
850 KeyIdx = (UCHAR)pKey->KeyIndex&0xff;
851
852 if (KeyIdx > 4)
853 return;
854
855
856 if (pAd->MacTab.Content[Aid].PairwiseKey.CipherAlg == CIPHER_TKIP)
857 { if (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPANone)
858 {
859 // for WPA-None Tx, Rx MIC is the same
860 pTxMic = (PUCHAR) (&pKey->KeyMaterial) + 16;
861 pRxMic = pTxMic;
862 }
863 else if (bAuthenticator == TRUE)
864 {
865 pTxMic = (PUCHAR) (&pKey->KeyMaterial) + 16;
866 pRxMic = (PUCHAR) (&pKey->KeyMaterial) + 24;
867 }
868 else
869 {
870 pRxMic = (PUCHAR) (&pKey->KeyMaterial) + 16;
871 pTxMic = (PUCHAR) (&pKey->KeyMaterial) + 24;
872 }
873
874 offset = PAIRWISE_KEY_TABLE_BASE + (Aid * HW_KEY_ENTRY_SIZE) + 0x10;
875 for (i=0; i<8; )
876 {
877 Value = *(pTxMic+i);
878 Value += (*(pTxMic+i+1)<<8);
879 Value += (*(pTxMic+i+2)<<16);
880 Value += (*(pTxMic+i+3)<<24);
881 RTUSBWriteMACRegister(pAd, offset+i, Value);
882 i+=4;
883 }
884
885 offset = PAIRWISE_KEY_TABLE_BASE + (Aid * HW_KEY_ENTRY_SIZE) + 0x18;
886 for (i=0; i<8; )
887 {
888 Value = *(pRxMic+i);
889 Value += (*(pRxMic+i+1)<<8);
890 Value += (*(pRxMic+i+2)<<16);
891 Value += (*(pRxMic+i+3)<<24);
892 RTUSBWriteMACRegister(pAd, offset+i, Value);
893 i+=4;
894 }
895
896 // Only Key lenth equal to TKIP key have these
897 NdisMoveMemory(pAd->MacTab.Content[Aid].PairwiseKey.RxMic, pRxMic, 8);
898 NdisMoveMemory(pAd->MacTab.Content[Aid].PairwiseKey.TxMic, pTxMic, 8);
899
900 DBGPRINT(RT_DEBUG_TRACE,
901 (" TxMIC = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x \n",
902 pTxMic[0],pTxMic[1],pTxMic[2],pTxMic[3],
903 pTxMic[4],pTxMic[5],pTxMic[6],pTxMic[7]));
904 DBGPRINT(RT_DEBUG_TRACE,
905 (" RxMIC = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x \n",
906 pRxMic[0],pRxMic[1],pRxMic[2],pRxMic[3],
907 pRxMic[4],pRxMic[5],pRxMic[6],pRxMic[7]));
908 }
909
910 // 2. Record Security Key.
911 pAd->MacTab.Content[BSSID_WCID].PairwiseKey.KeyLen= (UCHAR)pKey->KeyLength;
912 NdisMoveMemory(pAd->MacTab.Content[Aid].PairwiseKey.Key, &pKey->KeyMaterial, pKey->KeyLength);
913
914 // 3. Check RxTsc. And used to init to ASIC IV.
915 if (bKeyRSC == TRUE)
916 NdisMoveMemory(pAd->MacTab.Content[Aid].PairwiseKey.RxTsc, &pKey->KeyRSC, 6);
917 else
918 NdisZeroMemory(pAd->MacTab.Content[Aid].PairwiseKey.RxTsc, 6);
919
920 // 4. Init TxTsc to one based on WiFi WPA specs
921 pAd->MacTab.Content[Aid].PairwiseKey.TxTsc[0] = 1;
922 pAd->MacTab.Content[Aid].PairwiseKey.TxTsc[1] = 0;
923 pAd->MacTab.Content[Aid].PairwiseKey.TxTsc[2] = 0;
924 pAd->MacTab.Content[Aid].PairwiseKey.TxTsc[3] = 0;
925 pAd->MacTab.Content[Aid].PairwiseKey.TxTsc[4] = 0;
926 pAd->MacTab.Content[Aid].PairwiseKey.TxTsc[5] = 0;
927
928 CipherAlg = pAd->MacTab.Content[Aid].PairwiseKey.CipherAlg;
929
930 offset = PAIRWISE_KEY_TABLE_BASE + (Aid * HW_KEY_ENTRY_SIZE);
931 RTUSBMultiWrite(pAd, (USHORT) offset, pKey->KeyMaterial,
932 ((pKey->KeyLength == LEN_TKIP_KEY) ? 16 : (USHORT)pKey->KeyLength));
933
934 offset = SHARED_KEY_TABLE_BASE + (KeyIdx * HW_KEY_ENTRY_SIZE);
935 RTUSBMultiWrite(pAd, (USHORT) offset, pKey->KeyMaterial, (USHORT)pKey->KeyLength);
936
937 offset = PAIRWISE_IVEIV_TABLE_BASE + (Aid * HW_IVEIV_ENTRY_SIZE);
938 NdisZeroMemory(IVEIV, 8);
939
940 // IV/EIV
941 if ((CipherAlg == CIPHER_TKIP) ||
942 (CipherAlg == CIPHER_TKIP_NO_MIC) ||
943 (CipherAlg == CIPHER_AES))
944 {
945 IVEIV[3] = 0x20; // Eiv bit on. keyid always 0 for pairwise key
946 }
947 // default key idx needs to set.
948 // in TKIP/AES KeyIdx = 0 , WEP KeyIdx is default tx key.
949 else
950 {
951 IVEIV[3] |= (KeyIdx<< 6);
952 }
953 RTUSBMultiWrite(pAd, (USHORT) offset, IVEIV, 8);
954
955 // WCID Attribute UDF:3, BSSIdx:3, Alg:3, Keytable:1=PAIRWISE KEY, BSSIdx is 0
956 if ((CipherAlg == CIPHER_TKIP) ||
957 (CipherAlg == CIPHER_TKIP_NO_MIC) ||
958 (CipherAlg == CIPHER_AES))
959 {
960 WCIDAttri = (CipherAlg<<1)|SHAREDKEYTABLE;
961 }
962 else
963 WCIDAttri = (CipherAlg<<1)|SHAREDKEYTABLE;
964
965 offset = MAC_WCID_ATTRIBUTE_BASE + (Aid* HW_WCID_ATTRI_SIZE);
966 RTUSBWriteMACRegister(pAd, offset, WCIDAttri);
967 RTUSBReadMACRegister(pAd, offset, &Value);
968
969 DBGPRINT(RT_DEBUG_TRACE, ("BSSID_WCID : offset = %x, WCIDAttri = %lx\n",
970 offset, WCIDAttri));
971
972 // pAddr
973 // Add Bssid mac address at linkup. not here. check!
974 /*offset = MAC_WCID_BASE + (BSSID_WCID * HW_WCID_ENTRY_SIZE);
975 *for (i=0; i<MAC_ADDR_LEN; i++)
976 {
977 RTMP_IO_WRITE8(pAd, offset+i, pKey->BSSID[i]);
978 }
979 */
980
981 DBGPRINT(RT_DEBUG_ERROR, ("AddBSSIDasWCIDEntry: Alg=%s, KeyLength = %d\n",
982 CipherName[CipherAlg], pKey->KeyLength));
983 DBGPRINT(RT_DEBUG_TRACE, ("Key [idx=%x] [KeyLen = %d]\n",
984 pKey->KeyIndex, pKey->KeyLength));
985 for(i=0; i<pKey->KeyLength; i++)
986 DBGPRINT_RAW(RT_DEBUG_TRACE,(" %x:", pKey->KeyMaterial[i]));
987 DBGPRINT(RT_DEBUG_TRACE,(" \n"));
988 }
989
990 /*
991 ========================================================================
992 Routine Description:
993 Get a received packet.
994
995 Arguments:
996 pAd device control block
997 pSaveRxD receive descriptor information
998 *pbReschedule need reschedule flag
999 *pRxPending pending received packet flag
1000
1001 Return Value:
1002 the recieved packet
1003
1004 Note:
1005 ========================================================================
1006 */
1007 #define RT2870_RXDMALEN_FIELD_SIZE 4
1008 PNDIS_PACKET GetPacketFromRxRing(
1009 IN PRTMP_ADAPTER pAd,
1010 OUT PRT28XX_RXD_STRUC pSaveRxD,
1011 OUT BOOLEAN *pbReschedule,
1012 IN OUT UINT32 *pRxPending)
1013 {
1014 PRX_CONTEXT pRxContext;
1015 PNDIS_PACKET pSkb;
1016 PUCHAR pData;
1017 ULONG ThisFrameLen;
1018 ULONG RxBufferLength;
1019 PRXWI_STRUC pRxWI;
1020
1021 pRxContext = &pAd->RxContext[pAd->NextRxBulkInReadIndex];
1022 if ((pRxContext->Readable == FALSE) || (pRxContext->InUse == TRUE))
1023 return NULL;
1024
1025 RxBufferLength = pRxContext->BulkInOffset - pAd->ReadPosition;
1026 if (RxBufferLength < (RT2870_RXDMALEN_FIELD_SIZE + sizeof(RXWI_STRUC) + sizeof(RXINFO_STRUC)))
1027 {
1028 goto label_null;
1029 }
1030
1031 pData = &pRxContext->TransferBuffer[pAd->ReadPosition]; /* 4KB */
1032 // The RXDMA field is 4 bytes, now just use the first 2 bytes. The Length including the (RXWI + MSDU + Padding)
1033 ThisFrameLen = *pData + (*(pData+1)<<8);
1034 if (ThisFrameLen == 0)
1035 {
1036 DBGPRINT(RT_DEBUG_TRACE, ("BIRIdx(%d): RXDMALen is zero.[%ld], BulkInBufLen = %ld)\n",
1037 pAd->NextRxBulkInReadIndex, ThisFrameLen, pRxContext->BulkInOffset));
1038 goto label_null;
1039 }
1040 if ((ThisFrameLen&0x3) != 0)
1041 {
1042 DBGPRINT(RT_DEBUG_ERROR, ("BIRIdx(%d): RXDMALen not multiple of 4.[%ld], BulkInBufLen = %ld)\n",
1043 pAd->NextRxBulkInReadIndex, ThisFrameLen, pRxContext->BulkInOffset));
1044 goto label_null;
1045 }
1046
1047 if ((ThisFrameLen + 8)> RxBufferLength) // 8 for (RT2870_RXDMALEN_FIELD_SIZE + sizeof(RXINFO_STRUC))
1048 {
1049 DBGPRINT(RT_DEBUG_TRACE,("BIRIdx(%d):FrameLen(0x%lx) outranges. BulkInLen=0x%lx, remaining RxBufLen=0x%lx, ReadPos=0x%lx\n",
1050 pAd->NextRxBulkInReadIndex, ThisFrameLen, pRxContext->BulkInOffset, RxBufferLength, pAd->ReadPosition));
1051
1052 // error frame. finish this loop
1053 goto label_null;
1054 }
1055
1056 // skip USB frame length field
1057 pData += RT2870_RXDMALEN_FIELD_SIZE;
1058 pRxWI = (PRXWI_STRUC)pData;
1059
1060 if (pRxWI->MPDUtotalByteCount > ThisFrameLen)
1061 {
1062 DBGPRINT(RT_DEBUG_ERROR, ("%s():pRxWIMPDUtotalByteCount(%d) large than RxDMALen(%ld)\n",
1063 __func__, pRxWI->MPDUtotalByteCount, ThisFrameLen));
1064 goto label_null;
1065 }
1066
1067 // allocate a rx packet
1068 pSkb = dev_alloc_skb(ThisFrameLen);
1069 if (pSkb == NULL)
1070 {
1071 DBGPRINT(RT_DEBUG_ERROR,("%s():Cannot Allocate sk buffer for this Bulk-In buffer!\n", __func__));
1072 goto label_null;
1073 }
1074
1075 // copy the rx packet
1076 memcpy(skb_put(pSkb, ThisFrameLen), pData, ThisFrameLen);
1077 RTPKT_TO_OSPKT(pSkb)->dev = get_netdev_from_bssid(pAd, BSS0);
1078 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pSkb), PKTSRC_NDIS);
1079
1080 // copy RxD
1081 *pSaveRxD = *(PRXINFO_STRUC)(pData + ThisFrameLen);
1082
1083 // update next packet read position.
1084 pAd->ReadPosition += (ThisFrameLen + RT2870_RXDMALEN_FIELD_SIZE + RXINFO_SIZE); // 8 for (RT2870_RXDMALEN_FIELD_SIZE + sizeof(RXINFO_STRUC))
1085
1086 return pSkb;
1087
1088 label_null:
1089
1090 return NULL;
1091 }
1092
1093
1094 /*
1095 ========================================================================
1096 Routine Description:
1097 Handle received packets.
1098
1099 Arguments:
1100 data - URB information pointer
1101
1102 Return Value:
1103 None
1104
1105 Note:
1106 ========================================================================
1107 */
1108 static void rx_done_tasklet(unsigned long data)
1109 {
1110 purbb_t pUrb;
1111 PRX_CONTEXT pRxContext;
1112 PRTMP_ADAPTER pAd;
1113 NTSTATUS Status;
1114 unsigned int IrqFlags;
1115
1116 pUrb = (purbb_t)data;
1117 pRxContext = (PRX_CONTEXT)pUrb->context;
1118 pAd = pRxContext->pAd;
1119 Status = pUrb->status;
1120
1121
1122 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1123 pRxContext->InUse = FALSE;
1124 pRxContext->IRPPending = FALSE;
1125 pRxContext->BulkInOffset += pUrb->actual_length;
1126 //NdisInterlockedDecrement(&pAd->PendingRx);
1127 pAd->PendingRx--;
1128
1129 if (Status == USB_ST_NOERROR)
1130 {
1131 pAd->BulkInComplete++;
1132 pAd->NextRxBulkInPosition = 0;
1133 if (pRxContext->BulkInOffset) // As jan's comment, it may bulk-in success but size is zero.
1134 {
1135 pRxContext->Readable = TRUE;
1136 INC_RING_INDEX(pAd->NextRxBulkInIndex, RX_RING_SIZE);
1137 }
1138 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1139 }
1140 else // STATUS_OTHER
1141 {
1142 pAd->BulkInCompleteFail++;
1143 // Still read this packet although it may comtain wrong bytes.
1144 pRxContext->Readable = FALSE;
1145 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1146
1147 // Parsing all packets. because after reset, the index will reset to all zero.
1148 if ((!RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1149 fRTMP_ADAPTER_BULKIN_RESET |
1150 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1151 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1152 {
1153
1154 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk In Failed. Status=%d, BIIdx=0x%x, BIRIdx=0x%x, actual_length= 0x%x\n",
1155 Status, pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex, pRxContext->pUrb->actual_length));
1156
1157 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET);
1158 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_IN, NULL, 0);
1159 }
1160 }
1161
1162 ASSERT((pRxContext->InUse == pRxContext->IRPPending));
1163
1164 RTUSBBulkReceive(pAd);
1165
1166 return;
1167
1168 }
1169
1170
1171 static void rt2870_mgmt_dma_done_tasklet(unsigned long data)
1172 {
1173 PRTMP_ADAPTER pAd;
1174 PTX_CONTEXT pMLMEContext;
1175 int index;
1176 PNDIS_PACKET pPacket;
1177 purbb_t pUrb;
1178 NTSTATUS Status;
1179 unsigned long IrqFlags;
1180
1181
1182 pUrb = (purbb_t)data;
1183 pMLMEContext = (PTX_CONTEXT)pUrb->context;
1184 pAd = pMLMEContext->pAd;
1185 Status = pUrb->status;
1186 index = pMLMEContext->SelfIdx;
1187
1188 ASSERT((pAd->MgmtRing.TxDmaIdx == index));
1189
1190 RTMP_IRQ_LOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
1191
1192
1193 if (Status != USB_ST_NOERROR)
1194 {
1195 //Bulk-Out fail status handle
1196 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1197 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1198 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1199 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1200 {
1201 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out MLME Failed, Status=%d!\n", Status));
1202 // TODO: How to handle about the MLMEBulkOut failed issue. Need to resend the mgmt pkt?
1203 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1204 pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
1205 }
1206 }
1207
1208 pAd->BulkOutPending[MGMTPIPEIDX] = FALSE;
1209 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[MGMTPIPEIDX], IrqFlags);
1210
1211 RTMP_IRQ_LOCK(&pAd->MLMEBulkOutLock, IrqFlags);
1212 // Reset MLME context flags
1213 pMLMEContext->IRPPending = FALSE;
1214 pMLMEContext->InUse = FALSE;
1215 pMLMEContext->bWaitingBulkOut = FALSE;
1216 pMLMEContext->BulkOutSize = 0;
1217
1218 pPacket = pAd->MgmtRing.Cell[index].pNdisPacket;
1219 pAd->MgmtRing.Cell[index].pNdisPacket = NULL;
1220
1221 // Increase MgmtRing Index
1222 INC_RING_INDEX(pAd->MgmtRing.TxDmaIdx, MGMT_RING_SIZE);
1223 pAd->MgmtRing.TxSwFreeIdx++;
1224 RTMP_IRQ_UNLOCK(&pAd->MLMEBulkOutLock, IrqFlags);
1225
1226 // No-matter success or fail, we free the mgmt packet.
1227 if (pPacket)
1228 RTMPFreeNdisPacket(pAd, pPacket);
1229
1230 if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1231 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1232 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1233 {
1234 // do nothing and return directly.
1235 }
1236 else
1237 {
1238 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET) &&
1239 ((pAd->bulkResetPipeid & BULKOUT_MGMT_RESET_FLAG) == BULKOUT_MGMT_RESET_FLAG))
1240 { // For Mgmt Bulk-Out failed, ignore it now.
1241 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1242 }
1243 else
1244 {
1245
1246 // Always call Bulk routine, even reset bulk.
1247 // The protectioon of rest bulk should be in BulkOut routine
1248 if (pAd->MgmtRing.TxSwFreeIdx < MGMT_RING_SIZE /* pMLMEContext->bWaitingBulkOut == TRUE */)
1249 {
1250 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
1251 }
1252 RTUSBKickBulkOut(pAd);
1253 }
1254 }
1255
1256 }
1257
1258
1259 static void rt2870_hcca_dma_done_tasklet(unsigned long data)
1260 {
1261 PRTMP_ADAPTER pAd;
1262 PHT_TX_CONTEXT pHTTXContext;
1263 UCHAR BulkOutPipeId = 4;
1264 purbb_t pUrb;
1265
1266 DBGPRINT_RAW(RT_DEBUG_ERROR, ("--->hcca_dma_done_tasklet\n"));
1267
1268 pUrb = (purbb_t)data;
1269 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
1270 pAd = pHTTXContext->pAd;
1271
1272 rt2870_dataout_complete_tasklet((unsigned long)pUrb);
1273
1274 if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1275 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1276 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1277 {
1278 // do nothing and return directly.
1279 }
1280 else
1281 {
1282 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))
1283 {
1284 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1285 }
1286 else
1287 { pHTTXContext = &pAd->TxContext[BulkOutPipeId];
1288 if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) &&
1289 /*((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */
1290 (pAd->DeQueueRunning[BulkOutPipeId] == FALSE) &&
1291 (pHTTXContext->bCurWriting == FALSE))
1292 {
1293 RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);
1294 }
1295
1296 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL<<4);
1297 RTUSBKickBulkOut(pAd);
1298 }
1299 }
1300
1301 DBGPRINT_RAW(RT_DEBUG_ERROR, ("<---hcca_dma_done_tasklet\n"));
1302 }
1303
1304
1305 static void rt2870_ac3_dma_done_tasklet(unsigned long data)
1306 {
1307 PRTMP_ADAPTER pAd;
1308 PHT_TX_CONTEXT pHTTXContext;
1309 UCHAR BulkOutPipeId = 3;
1310 purbb_t pUrb;
1311
1312
1313 pUrb = (purbb_t)data;
1314 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
1315 pAd = pHTTXContext->pAd;
1316
1317 rt2870_dataout_complete_tasklet((unsigned long)pUrb);
1318
1319 if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1320 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1321 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1322 {
1323 // do nothing and return directly.
1324 }
1325 else
1326 {
1327 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))
1328 {
1329 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1330 }
1331 else
1332 { pHTTXContext = &pAd->TxContext[BulkOutPipeId];
1333 if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) &&
1334 /*((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */
1335 (pAd->DeQueueRunning[BulkOutPipeId] == FALSE) &&
1336 (pHTTXContext->bCurWriting == FALSE))
1337 {
1338 RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);
1339 }
1340
1341 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL<<3);
1342 RTUSBKickBulkOut(pAd);
1343 }
1344 }
1345
1346
1347 return;
1348 }
1349
1350
1351 static void rt2870_ac2_dma_done_tasklet(unsigned long data)
1352 {
1353 PRTMP_ADAPTER pAd;
1354 PHT_TX_CONTEXT pHTTXContext;
1355 UCHAR BulkOutPipeId = 2;
1356 purbb_t pUrb;
1357
1358
1359 pUrb = (purbb_t)data;
1360 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
1361 pAd = pHTTXContext->pAd;
1362
1363 rt2870_dataout_complete_tasklet((unsigned long)pUrb);
1364
1365 if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1366 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1367 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1368 {
1369 // do nothing and return directly.
1370 }
1371 else
1372 {
1373 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))
1374 {
1375 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1376 }
1377 else
1378 { pHTTXContext = &pAd->TxContext[BulkOutPipeId];
1379 if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) &&
1380 /*((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */
1381 (pAd->DeQueueRunning[BulkOutPipeId] == FALSE) &&
1382 (pHTTXContext->bCurWriting == FALSE))
1383 {
1384 RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);
1385 }
1386
1387 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL<<2);
1388 RTUSBKickBulkOut(pAd);
1389 }
1390 }
1391
1392 return;
1393 }
1394
1395
1396 static void rt2870_ac1_dma_done_tasklet(unsigned long data)
1397 {
1398 PRTMP_ADAPTER pAd;
1399 PHT_TX_CONTEXT pHTTXContext;
1400 UCHAR BulkOutPipeId = 1;
1401 purbb_t pUrb;
1402
1403
1404 pUrb = (purbb_t)data;
1405 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
1406 pAd = pHTTXContext->pAd;
1407
1408 rt2870_dataout_complete_tasklet((unsigned long)pUrb);
1409
1410 if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1411 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1412 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1413 {
1414 // do nothing and return directly.
1415 }
1416 else
1417 {
1418 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))
1419 {
1420 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1421 }
1422 else
1423 { pHTTXContext = &pAd->TxContext[BulkOutPipeId];
1424 if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) &&
1425 /*((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */
1426 (pAd->DeQueueRunning[BulkOutPipeId] == FALSE) &&
1427 (pHTTXContext->bCurWriting == FALSE))
1428 {
1429 RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);
1430 }
1431
1432 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL<<1);
1433 RTUSBKickBulkOut(pAd);
1434 }
1435 }
1436
1437
1438 return;
1439 }
1440
1441
1442 static void rt2870_ac0_dma_done_tasklet(unsigned long data)
1443 {
1444 PRTMP_ADAPTER pAd;
1445 PHT_TX_CONTEXT pHTTXContext;
1446 UCHAR BulkOutPipeId = 0;
1447 purbb_t pUrb;
1448
1449
1450 pUrb = (purbb_t)data;
1451 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
1452 pAd = pHTTXContext->pAd;
1453
1454 rt2870_dataout_complete_tasklet((unsigned long)pUrb);
1455
1456 if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1457 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1458 fRTMP_ADAPTER_NIC_NOT_EXIST))))
1459 {
1460 // do nothing and return directly.
1461 }
1462 else
1463 {
1464 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET))
1465 {
1466 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1467 }
1468 else
1469 { pHTTXContext = &pAd->TxContext[BulkOutPipeId];
1470 if ((pAd->TxSwQueue[BulkOutPipeId].Number > 0) &&
1471 /* ((pHTTXContext->CurWritePosition > (pHTTXContext->NextBulkOutPosition + 0x6000)) || (pHTTXContext->NextBulkOutPosition > pHTTXContext->CurWritePosition + 0x6000)) && */
1472 (pAd->DeQueueRunning[BulkOutPipeId] == FALSE) &&
1473 (pHTTXContext->bCurWriting == FALSE))
1474 {
1475 RTMPDeQueuePacket(pAd, FALSE, BulkOutPipeId, MAX_TX_PROCESS);
1476 }
1477
1478 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NORMAL);
1479 RTUSBKickBulkOut(pAd);
1480 }
1481 }
1482
1483
1484 return;
1485
1486 }
1487
1488
1489 static void rt2870_null_frame_complete_tasklet(unsigned long data)
1490 {
1491 PRTMP_ADAPTER pAd;
1492 PTX_CONTEXT pNullContext;
1493 purbb_t pUrb;
1494 NTSTATUS Status;
1495 unsigned long irqFlag;
1496
1497
1498 pUrb = (purbb_t)data;
1499 pNullContext = (PTX_CONTEXT)pUrb->context;
1500 pAd = pNullContext->pAd;
1501 Status = pUrb->status;
1502
1503 // Reset Null frame context flags
1504 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], irqFlag);
1505 pNullContext->IRPPending = FALSE;
1506 pNullContext->InUse = FALSE;
1507 pAd->BulkOutPending[0] = FALSE;
1508 pAd->watchDogTxPendingCnt[0] = 0;
1509
1510 if (Status == USB_ST_NOERROR)
1511 {
1512 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
1513
1514 RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
1515 }
1516 else // STATUS_OTHER
1517 {
1518 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1519 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1520 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1521 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1522 {
1523 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out Null Frame Failed, ReasonCode=%d!\n", Status));
1524 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1525 pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
1526 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
1527 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1528 }
1529 else
1530 {
1531 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
1532 }
1533 }
1534
1535 // Always call Bulk routine, even reset bulk.
1536 // The protectioon of rest bulk should be in BulkOut routine
1537 RTUSBKickBulkOut(pAd);
1538
1539 }
1540
1541
1542 static void rt2870_rts_frame_complete_tasklet(unsigned long data)
1543 {
1544 PRTMP_ADAPTER pAd;
1545 PTX_CONTEXT pRTSContext;
1546 purbb_t pUrb;
1547 NTSTATUS Status;
1548 unsigned long irqFlag;
1549
1550
1551 pUrb = (purbb_t)data;
1552 pRTSContext = (PTX_CONTEXT)pUrb->context;
1553 pAd = pRTSContext->pAd;
1554 Status = pUrb->status;
1555
1556 // Reset RTS frame context flags
1557 RTMP_IRQ_LOCK(&pAd->BulkOutLock[0], irqFlag);
1558 pRTSContext->IRPPending = FALSE;
1559 pRTSContext->InUse = FALSE;
1560
1561 if (Status == USB_ST_NOERROR)
1562 {
1563 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
1564 RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
1565 }
1566 else // STATUS_OTHER
1567 {
1568 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1569 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1570 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1571 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1572 {
1573 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out RTS Frame Failed\n"));
1574 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1575 pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
1576 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
1577 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1578 }
1579 else
1580 {
1581 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[0], irqFlag);
1582 }
1583 }
1584
1585 RTMP_SEM_LOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId]);
1586 pAd->BulkOutPending[pRTSContext->BulkOutPipeId] = FALSE;
1587 RTMP_SEM_UNLOCK(&pAd->BulkOutLock[pRTSContext->BulkOutPipeId]);
1588
1589 // Always call Bulk routine, even reset bulk.
1590 // The protectioon of rest bulk should be in BulkOut routine
1591 RTUSBKickBulkOut(pAd);
1592
1593 }
1594
1595
1596 static void rt2870_pspoll_frame_complete_tasklet(unsigned long data)
1597 {
1598 PRTMP_ADAPTER pAd;
1599 PTX_CONTEXT pPsPollContext;
1600 purbb_t pUrb;
1601 NTSTATUS Status;
1602
1603
1604 pUrb = (purbb_t)data;
1605 pPsPollContext = (PTX_CONTEXT)pUrb->context;
1606 pAd = pPsPollContext->pAd;
1607 Status = pUrb->status;
1608
1609 // Reset PsPoll context flags
1610 pPsPollContext->IRPPending = FALSE;
1611 pPsPollContext->InUse = FALSE;
1612 pAd->watchDogTxPendingCnt[0] = 0;
1613
1614 if (Status == USB_ST_NOERROR)
1615 {
1616 RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
1617 }
1618 else // STATUS_OTHER
1619 {
1620 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
1621 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
1622 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
1623 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
1624 {
1625 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Bulk Out PSPoll Failed\n"));
1626 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1627 pAd->bulkResetPipeid = (MGMTPIPEIDX | BULKOUT_MGMT_RESET_FLAG);
1628 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
1629 }
1630 }
1631
1632 RTMP_SEM_LOCK(&pAd->BulkOutLock[0]);
1633 pAd->BulkOutPending[0] = FALSE;
1634 RTMP_SEM_UNLOCK(&pAd->BulkOutLock[0]);
1635
1636 // Always call Bulk routine, even reset bulk.
1637 // The protectioon of rest bulk should be in BulkOut routine
1638 RTUSBKickBulkOut(pAd);
1639
1640 }
1641
1642
1643 static void rt2870_dataout_complete_tasklet(unsigned long data)
1644 {
1645 PRTMP_ADAPTER pAd;
1646 purbb_t pUrb;
1647 POS_COOKIE pObj;
1648 PHT_TX_CONTEXT pHTTXContext;
1649 UCHAR BulkOutPipeId;
1650 NTSTATUS Status;
1651 unsigned long IrqFlags;
1652
1653
1654 pUrb = (purbb_t)data;
1655 pHTTXContext = (PHT_TX_CONTEXT)pUrb->context;
1656 pAd = pHTTXContext->pAd;
1657 pObj = (POS_COOKIE) pAd->OS_Cookie;
1658 Status = pUrb->status;
1659
1660 // Store BulkOut PipeId
1661 BulkOutPipeId = pHTTXContext->BulkOutPipeId;
1662 pAd->BulkOutDataOneSecCount++;
1663
1664 //DBGPRINT(RT_DEBUG_LOUD, ("Done-B(%d):I=0x%lx, CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d!\n", BulkOutPipeId, in_interrupt(), pHTTXContext->CurWritePosition,
1665 // pHTTXContext->NextBulkOutPosition, pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad));
1666
1667 RTMP_IRQ_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
1668 pAd->BulkOutPending[BulkOutPipeId] = FALSE;
1669 pHTTXContext->IRPPending = FALSE;
1670 pAd->watchDogTxPendingCnt[BulkOutPipeId] = 0;
1671
1672 if (Status == USB_ST_NOERROR)
1673 {
1674 pAd->BulkOutComplete++;
1675
1676 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
1677
1678 pAd->Counters8023.GoodTransmits++;
1679 //RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
1680 FREE_HTTX_RING(pAd, BulkOutPipeId, pHTTXContext);
1681 //RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
1682
1683
1684 }
1685 else // STATUS_OTHER
1686 {
1687 PUCHAR pBuf;
1688
1689 pAd->BulkOutCompleteOther++;
1690
1691 pBuf = &pHTTXContext->TransferBuffer->field.WirelessPacket[pHTTXContext->NextBulkOutPosition];
1692
1693 if (!RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS |
1694 fRTMP_ADAPTER_HALT_IN_PROGRESS |
1695 fRTMP_ADAPTER_NIC_NOT_EXIST |
1696 fRTMP_ADAPTER_BULKOUT_RESET)))
1697 {
1698 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1699 pAd->bulkResetPipeid = BulkOutPipeId;
1700 pAd->bulkResetReq[BulkOutPipeId] = pAd->BulkOutReq;
1701 }
1702 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
1703
1704 DBGPRINT_RAW(RT_DEBUG_ERROR, ("BulkOutDataPacket failed: ReasonCode=%d!\n", Status));
1705 DBGPRINT_RAW(RT_DEBUG_ERROR, ("\t>>BulkOut Req=0x%lx, Complete=0x%lx, Other=0x%lx\n", pAd->BulkOutReq, pAd->BulkOutComplete, pAd->BulkOutCompleteOther));
1706 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]));
1707 //DBGPRINT_RAW(RT_DEBUG_ERROR, (">>BulkOutCompleteCancel=0x%x, BulkOutCompleteOther=0x%x\n", pAd->BulkOutCompleteCancel, pAd->BulkOutCompleteOther));
1708
1709 }
1710
1711 //
1712 // bInUse = TRUE, means some process are filling TX data, after that must turn on bWaitingBulkOut
1713 // bWaitingBulkOut = TRUE, means the TX data are waiting for bulk out.
1714 //
1715 //RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
1716 if ((pHTTXContext->ENextBulkOutPosition != pHTTXContext->CurWritePosition) &&
1717 (pHTTXContext->ENextBulkOutPosition != (pHTTXContext->CurWritePosition+8)) &&
1718 !RTUSB_TEST_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_FRAG << BulkOutPipeId)))
1719 {
1720 // Indicate There is data avaliable
1721 RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << BulkOutPipeId));
1722 }
1723 //RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[BulkOutPipeId], IrqFlags);
1724
1725 // Always call Bulk routine, even reset bulk.
1726 // The protection of rest bulk should be in BulkOut routine
1727 RTUSBKickBulkOut(pAd);
1728 }
1729
1730 /* End of 2870_rtmp_init.c */
kernel-based virtual machine