?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / staging / rt2870 / common / rtusb_io.c
blob6b9ca24bbee927835d504b2c6a88c61e10fb6281
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_io.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 #ifdef RTMP_MAC_USB
40
41 #include "../rt_config.h"
42
43 /*
44 ========================================================================
45
46 Routine Description: NIC initialization complete
47
48 Arguments:
49
50 Return Value:
51
52 IRQL =
53
54 Note:
55
56 ========================================================================
57 */
58
59 static int RTUSBFirmwareRun(struct rt_rtmp_adapter *pAd)
60 {
61 int Status;
62
63 Status = RTUSB_VendorRequest(pAd,
64 USBD_TRANSFER_DIRECTION_OUT,
65 DEVICE_VENDOR_REQUEST_OUT,
66 0x01, 0x8, 0, NULL, 0);
67
68 return Status;
69 }
70
71 /*
72 ========================================================================
73
74 Routine Description: Write Firmware to NIC.
75
76 Arguments:
77
78 Return Value:
79
80 IRQL =
81
82 Note:
83
84 ========================================================================
85 */
86 int RTUSBFirmwareWrite(struct rt_rtmp_adapter *pAd,
87 const u8 *pFwImage, unsigned long FwLen)
88 {
89 u32 MacReg;
90 int Status;
91 /* unsigned long i; */
92 u16 writeLen;
93
94 Status = RTUSBReadMACRegister(pAd, MAC_CSR0, &MacReg);
95
96 writeLen = FwLen;
97 RTUSBMultiWrite(pAd, FIRMWARE_IMAGE_BASE, pFwImage, writeLen);
98
99 Status = RTUSBWriteMACRegister(pAd, 0x7014, 0xffffffff);
100 Status = RTUSBWriteMACRegister(pAd, 0x701c, 0xffffffff);
101 Status = RTUSBFirmwareRun(pAd);
102
103 /*2008/11/28:KH add to fix the dead rf frequency offset bug<-- */
104 RTMPusecDelay(10000);
105 RTUSBWriteMACRegister(pAd, H2M_MAILBOX_CSR, 0);
106 AsicSendCommandToMcu(pAd, 0x72, 0x00, 0x00, 0x00); /*reset rf by MCU supported by new firmware */
107 /*2008/11/28:KH add to fix the dead rf frequency offset bug--> */
108
109 return Status;
110 }
111
112 int RTUSBVenderReset(struct rt_rtmp_adapter *pAd)
113 {
114 int Status;
115 DBGPRINT_RAW(RT_DEBUG_ERROR, ("-->RTUSBVenderReset\n"));
116 Status = RTUSB_VendorRequest(pAd,
117 USBD_TRANSFER_DIRECTION_OUT,
118 DEVICE_VENDOR_REQUEST_OUT,
119 0x01, 0x1, 0, NULL, 0);
120
121 DBGPRINT_RAW(RT_DEBUG_ERROR, ("<--RTUSBVenderReset\n"));
122 return Status;
123 }
124
125 /*
126 ========================================================================
127
128 Routine Description: Read various length data from RT2573
129
130 Arguments:
131
132 Return Value:
133
134 IRQL =
135
136 Note:
137
138 ========================================================================
139 */
140 int RTUSBMultiRead(struct rt_rtmp_adapter *pAd,
141 u16 Offset, u8 *pData, u16 length)
142 {
143 int Status;
144
145 Status = RTUSB_VendorRequest(pAd,
146 (USBD_TRANSFER_DIRECTION_IN |
147 USBD_SHORT_TRANSFER_OK),
148 DEVICE_VENDOR_REQUEST_IN, 0x7, 0, Offset,
149 pData, length);
150
151 return Status;
152 }
153
154 /*
155 ========================================================================
156
157 Routine Description: Write various length data to RT2573
158
159 Arguments:
160
161 Return Value:
162
163 IRQL =
164
165 Note:
166
167 ========================================================================
168 */
169 int RTUSBMultiWrite_OneByte(struct rt_rtmp_adapter *pAd,
170 u16 Offset, const u8 *pData)
171 {
172 int Status;
173
174 /* TODO: In 2870, use this funciton carefully cause it's not stable. */
175 Status = RTUSB_VendorRequest(pAd,
176 USBD_TRANSFER_DIRECTION_OUT,
177 DEVICE_VENDOR_REQUEST_OUT,
178 0x6, 0, Offset, (u8 *)pData, 1);
179
180 return Status;
181 }
182
183 int RTUSBMultiWrite(struct rt_rtmp_adapter *pAd,
184 u16 Offset, const u8 *pData, u16 length)
185 {
186 int Status;
187
188 u16 index = 0, Value;
189 const u8 *pSrc = pData;
190 u16 resude = 0;
191
192 resude = length % 2;
193 length += resude;
194 do {
195 Value = (u16)(*pSrc | (*(pSrc + 1) << 8));
196 Status = RTUSBSingleWrite(pAd, Offset + index, Value);
197 index += 2;
198 length -= 2;
199 pSrc = pSrc + 2;
200 } while (length > 0);
201
202 return Status;
203 }
204
205 int RTUSBSingleWrite(struct rt_rtmp_adapter *pAd,
206 u16 Offset, u16 Value)
207 {
208 int Status;
209
210 Status = RTUSB_VendorRequest(pAd,
211 USBD_TRANSFER_DIRECTION_OUT,
212 DEVICE_VENDOR_REQUEST_OUT,
213 0x2, Value, Offset, NULL, 0);
214
215 return Status;
216
217 }
218
219 /*
220 ========================================================================
221
222 Routine Description: Read 32-bit MAC register
223
224 Arguments:
225
226 Return Value:
227
228 IRQL =
229
230 Note:
231
232 ========================================================================
233 */
234 int RTUSBReadMACRegister(struct rt_rtmp_adapter *pAd,
235 u16 Offset, u32 *pValue)
236 {
237 int Status = 0;
238 u32 localVal;
239
240 Status = RTUSB_VendorRequest(pAd,
241 (USBD_TRANSFER_DIRECTION_IN |
242 USBD_SHORT_TRANSFER_OK),
243 DEVICE_VENDOR_REQUEST_IN, 0x7, 0, Offset,
244 &localVal, 4);
245
246 *pValue = le2cpu32(localVal);
247
248 if (Status < 0)
249 *pValue = 0xffffffff;
250
251 return Status;
252 }
253
254 /*
255 ========================================================================
256
257 Routine Description: Write 32-bit MAC register
258
259 Arguments:
260
261 Return Value:
262
263 IRQL =
264
265 Note:
266
267 ========================================================================
268 */
269 int RTUSBWriteMACRegister(struct rt_rtmp_adapter *pAd,
270 u16 Offset, u32 Value)
271 {
272 int Status;
273 u32 localVal;
274
275 localVal = Value;
276
277 Status = RTUSBSingleWrite(pAd, Offset, (u16)(localVal & 0xffff));
278 Status =
279 RTUSBSingleWrite(pAd, Offset + 2,
280 (u16)((localVal & 0xffff0000) >> 16));
281
282 return Status;
283 }
284
285 /*
286 ========================================================================
287
288 Routine Description: Read 8-bit BBP register
289
290 Arguments:
291
292 Return Value:
293
294 IRQL =
295
296 Note:
297
298 ========================================================================
299 */
300 int RTUSBReadBBPRegister(struct rt_rtmp_adapter *pAd,
301 u8 Id, u8 *pValue)
302 {
303 BBP_CSR_CFG_STRUC BbpCsr;
304 u32 i = 0;
305 int status;
306
307 /* Verify the busy condition */
308 do {
309 status = RTUSBReadMACRegister(pAd, BBP_CSR_CFG, &BbpCsr.word);
310 if (status >= 0) {
311 if (!(BbpCsr.field.Busy == BUSY))
312 break;
313 }
314 DBGPRINT(RT_DEBUG_TRACE,
315 ("RTUSBReadBBPRegister(BBP_CSR_CFG_1):retry count=%d!\n",
316 i));
317 i++;
318 } while ((i < RETRY_LIMIT)
319 && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));
320
321 if ((i == RETRY_LIMIT)
322 || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {
323 /* */
324 /* Read failed then Return Default value. */
325 /* */
326 *pValue = pAd->BbpWriteLatch[Id];
327
328 DBGPRINT_RAW(RT_DEBUG_ERROR,
329 ("Retry count exhausted or device removed!!!\n"));
330 return STATUS_UNSUCCESSFUL;
331 }
332 /* Prepare for write material */
333 BbpCsr.word = 0;
334 BbpCsr.field.fRead = 1;
335 BbpCsr.field.Busy = 1;
336 BbpCsr.field.RegNum = Id;
337 RTUSBWriteMACRegister(pAd, BBP_CSR_CFG, BbpCsr.word);
338
339 i = 0;
340 /* Verify the busy condition */
341 do {
342 status = RTUSBReadMACRegister(pAd, BBP_CSR_CFG, &BbpCsr.word);
343 if (status >= 0) {
344 if (!(BbpCsr.field.Busy == BUSY)) {
345 *pValue = (u8)BbpCsr.field.Value;
346 break;
347 }
348 }
349 DBGPRINT(RT_DEBUG_TRACE,
350 ("RTUSBReadBBPRegister(BBP_CSR_CFG_2):retry count=%d!\n",
351 i));
352 i++;
353 } while ((i < RETRY_LIMIT)
354 && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));
355
356 if ((i == RETRY_LIMIT)
357 || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {
358 /* */
359 /* Read failed then Return Default value. */
360 /* */
361 *pValue = pAd->BbpWriteLatch[Id];
362
363 DBGPRINT_RAW(RT_DEBUG_ERROR,
364 ("Retry count exhausted or device removed!!!\n"));
365 return STATUS_UNSUCCESSFUL;
366 }
367
368 return STATUS_SUCCESS;
369 }
370
371 /*
372 ========================================================================
373
374 Routine Description: Write 8-bit BBP register
375
376 Arguments:
377
378 Return Value:
379
380 IRQL =
381
382 Note:
383
384 ========================================================================
385 */
386 int RTUSBWriteBBPRegister(struct rt_rtmp_adapter *pAd,
387 u8 Id, u8 Value)
388 {
389 BBP_CSR_CFG_STRUC BbpCsr;
390 u32 i = 0;
391 int status;
392 /* Verify the busy condition */
393 do {
394 status = RTUSBReadMACRegister(pAd, BBP_CSR_CFG, &BbpCsr.word);
395 if (status >= 0) {
396 if (!(BbpCsr.field.Busy == BUSY))
397 break;
398 }
399 DBGPRINT(RT_DEBUG_TRACE,
400 ("RTUSBWriteBBPRegister(BBP_CSR_CFG):retry count=%d!\n",
401 i));
402 i++;
403 } while ((i < RETRY_LIMIT)
404 && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));
405
406 if ((i == RETRY_LIMIT)
407 || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {
408 DBGPRINT_RAW(RT_DEBUG_ERROR,
409 ("Retry count exhausted or device removed!!!\n"));
410 return STATUS_UNSUCCESSFUL;
411 }
412 /* Prepare for write material */
413 BbpCsr.word = 0;
414 BbpCsr.field.fRead = 0;
415 BbpCsr.field.Value = Value;
416 BbpCsr.field.Busy = 1;
417 BbpCsr.field.RegNum = Id;
418 RTUSBWriteMACRegister(pAd, BBP_CSR_CFG, BbpCsr.word);
419
420 pAd->BbpWriteLatch[Id] = Value;
421
422 return STATUS_SUCCESS;
423 }
424
425 /*
426 ========================================================================
427
428 Routine Description: Write RF register through MAC
429
430 Arguments:
431
432 Return Value:
433
434 IRQL =
435
436 Note:
437
438 ========================================================================
439 */
440 int RTUSBWriteRFRegister(struct rt_rtmp_adapter *pAd, u32 Value)
441 {
442 PHY_CSR4_STRUC PhyCsr4;
443 u32 i = 0;
444 int status;
445
446 NdisZeroMemory(&PhyCsr4, sizeof(PHY_CSR4_STRUC));
447 do {
448 status = RTUSBReadMACRegister(pAd, RF_CSR_CFG0, &PhyCsr4.word);
449 if (status >= 0) {
450 if (!(PhyCsr4.field.Busy))
451 break;
452 }
453 DBGPRINT(RT_DEBUG_TRACE,
454 ("RTUSBWriteRFRegister(RF_CSR_CFG0):retry count=%d!\n",
455 i));
456 i++;
457 } while ((i < RETRY_LIMIT)
458 && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)));
459
460 if ((i == RETRY_LIMIT)
461 || (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) {
462 DBGPRINT_RAW(RT_DEBUG_ERROR,
463 ("Retry count exhausted or device removed!!!\n"));
464 return STATUS_UNSUCCESSFUL;
465 }
466
467 RTUSBWriteMACRegister(pAd, RF_CSR_CFG0, Value);
468
469 return STATUS_SUCCESS;
470 }
471
472 /*
473 ========================================================================
474
475 Routine Description:
476
477 Arguments:
478
479 Return Value:
480
481 IRQL =
482
483 Note:
484
485 ========================================================================
486 */
487 int RTUSBReadEEPROM(struct rt_rtmp_adapter *pAd,
488 u16 Offset, u8 *pData, u16 length)
489 {
490 int Status = STATUS_SUCCESS;
491
492 Status = RTUSB_VendorRequest(pAd,
493 (USBD_TRANSFER_DIRECTION_IN |
494 USBD_SHORT_TRANSFER_OK),
495 DEVICE_VENDOR_REQUEST_IN, 0x9, 0, Offset,
496 pData, length);
497
498 return Status;
499 }
500
501 /*
502 ========================================================================
503
504 Routine Description:
505
506 Arguments:
507
508 Return Value:
509
510 IRQL =
511
512 Note:
513
514 ========================================================================
515 */
516 int RTUSBWriteEEPROM(struct rt_rtmp_adapter *pAd,
517 u16 Offset, u8 *pData, u16 length)
518 {
519 int Status = STATUS_SUCCESS;
520
521 Status = RTUSB_VendorRequest(pAd,
522 USBD_TRANSFER_DIRECTION_OUT,
523 DEVICE_VENDOR_REQUEST_OUT,
524 0x8, 0, Offset, pData, length);
525
526 return Status;
527 }
528
529 int RTUSBReadEEPROM16(struct rt_rtmp_adapter *pAd,
530 u16 offset, u16 *pData)
531 {
532 int status;
533 u16 localData;
534
535 status = RTUSBReadEEPROM(pAd, offset, (u8 *)(&localData), 2);
536 if (status == STATUS_SUCCESS)
537 *pData = le2cpu16(localData);
538
539 return status;
540
541 }
542
543 /*
544 ========================================================================
545
546 Routine Description:
547
548 Arguments:
549
550 Return Value:
551
552 IRQL =
553
554 Note:
555
556 ========================================================================
557 */
558 void RTUSBPutToSleep(struct rt_rtmp_adapter *pAd)
559 {
560 u32 value;
561
562 /* Timeout 0x40 x 50us */
563 value = (SLEEPCID << 16) + (OWNERMCU << 24) + (0x40 << 8) + 1;
564 RTUSBWriteMACRegister(pAd, 0x7010, value);
565 RTUSBWriteMACRegister(pAd, 0x404, 0x30);
566 /*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS); */
567 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Sleep Mailbox testvalue %x\n", value));
568
569 }
570
571 /*
572 ========================================================================
573
574 Routine Description:
575
576 Arguments:
577
578 Return Value:
579
580 IRQL =
581
582 Note:
583
584 ========================================================================
585 */
586 int RTUSBWakeUp(struct rt_rtmp_adapter *pAd)
587 {
588 int Status;
589
590 Status = RTUSB_VendorRequest(pAd,
591 USBD_TRANSFER_DIRECTION_OUT,
592 DEVICE_VENDOR_REQUEST_OUT,
593 0x01, 0x09, 0, NULL, 0);
594
595 return Status;
596 }
597
598 /*
599 ========================================================================
600
601 Routine Description:
602
603 Arguments:
604
605 Return Value:
606
607 IRQL =
608
609 Note:
610
611 ========================================================================
612 */
613 void RTUSBInitializeCmdQ(struct rt_cmdq *cmdq)
614 {
615 cmdq->head = NULL;
616 cmdq->tail = NULL;
617 cmdq->size = 0;
618 cmdq->CmdQState = RTMP_TASK_STAT_INITED;
619 }
620
621 /*
622 ========================================================================
623
624 Routine Description:
625
626 Arguments:
627
628 Return Value:
629
630 IRQL =
631
632 Note:
633
634 ========================================================================
635 */
636 int RTUSBEnqueueCmdFromNdis(struct rt_rtmp_adapter *pAd,
637 IN NDIS_OID Oid,
638 IN BOOLEAN SetInformation,
639 void *pInformationBuffer,
640 u32 InformationBufferLength)
641 {
642 int status;
643 struct rt_cmdqelmt *cmdqelmt = NULL;
644 struct rt_rtmp_os_task *pTask = &pAd->cmdQTask;
645
646 #ifdef KTHREAD_SUPPORT
647 if (pTask->kthread_task == NULL)
648 #else
649 CHECK_PID_LEGALITY(pTask->taskPID) {
650 }
651 else
652 #endif
653 return NDIS_STATUS_RESOURCES;
654
655 status = os_alloc_mem(pAd, (u8 **) (&cmdqelmt), sizeof(struct rt_cmdqelmt));
656 if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt == NULL))
657 return NDIS_STATUS_RESOURCES;
658
659 cmdqelmt->buffer = NULL;
660 if (pInformationBuffer != NULL) {
661 status =
662 os_alloc_mem(pAd, (u8 **) & cmdqelmt->buffer,
663 InformationBufferLength);
664 if ((status != NDIS_STATUS_SUCCESS)
665 || (cmdqelmt->buffer == NULL)) {
666 kfree(cmdqelmt);
667 return NDIS_STATUS_RESOURCES;
668 } else {
669 NdisMoveMemory(cmdqelmt->buffer, pInformationBuffer,
670 InformationBufferLength);
671 cmdqelmt->bufferlength = InformationBufferLength;
672 }
673 } else
674 cmdqelmt->bufferlength = 0;
675
676 cmdqelmt->command = Oid;
677 cmdqelmt->CmdFromNdis = TRUE;
678 if (SetInformation == TRUE)
679 cmdqelmt->SetOperation = TRUE;
680 else
681 cmdqelmt->SetOperation = FALSE;
682
683 NdisAcquireSpinLock(&pAd->CmdQLock);
684 if (pAd->CmdQ.CmdQState & RTMP_TASK_CAN_DO_INSERT) {
685 EnqueueCmd((&pAd->CmdQ), cmdqelmt);
686 status = NDIS_STATUS_SUCCESS;
687 } else {
688 status = NDIS_STATUS_FAILURE;
689 }
690 NdisReleaseSpinLock(&pAd->CmdQLock);
691
692 if (status == NDIS_STATUS_FAILURE) {
693 if (cmdqelmt->buffer)
694 os_free_mem(pAd, cmdqelmt->buffer);
695 os_free_mem(pAd, cmdqelmt);
696 } else
697 RTUSBCMDUp(pAd);
698
699 return NDIS_STATUS_SUCCESS;
700 }
701
702 /*
703 ========================================================================
704
705 Routine Description:
706
707 Arguments:
708
709 Return Value:
710
711 IRQL =
712
713 Note:
714
715 ========================================================================
716 */
717 int RTUSBEnqueueInternalCmd(struct rt_rtmp_adapter *pAd,
718 IN NDIS_OID Oid,
719 void *pInformationBuffer,
720 u32 InformationBufferLength)
721 {
722 int status;
723 struct rt_cmdqelmt *cmdqelmt = NULL;
724
725 status = os_alloc_mem(pAd, (u8 **) & cmdqelmt, sizeof(struct rt_cmdqelmt));
726 if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt == NULL))
727 return NDIS_STATUS_RESOURCES;
728 NdisZeroMemory(cmdqelmt, sizeof(struct rt_cmdqelmt));
729
730 if (InformationBufferLength > 0) {
731 status =
732 os_alloc_mem(pAd, (u8 **) & cmdqelmt->buffer,
733 InformationBufferLength);
734 if ((status != NDIS_STATUS_SUCCESS)
735 || (cmdqelmt->buffer == NULL)) {
736 os_free_mem(pAd, cmdqelmt);
737 return NDIS_STATUS_RESOURCES;
738 } else {
739 NdisMoveMemory(cmdqelmt->buffer, pInformationBuffer,
740 InformationBufferLength);
741 cmdqelmt->bufferlength = InformationBufferLength;
742 }
743 } else {
744 cmdqelmt->buffer = NULL;
745 cmdqelmt->bufferlength = 0;
746 }
747
748 cmdqelmt->command = Oid;
749 cmdqelmt->CmdFromNdis = FALSE;
750
751 if (cmdqelmt != NULL) {
752 NdisAcquireSpinLock(&pAd->CmdQLock);
753 if (pAd->CmdQ.CmdQState & RTMP_TASK_CAN_DO_INSERT) {
754 EnqueueCmd((&pAd->CmdQ), cmdqelmt);
755 status = NDIS_STATUS_SUCCESS;
756 } else {
757 status = NDIS_STATUS_FAILURE;
758 }
759 NdisReleaseSpinLock(&pAd->CmdQLock);
760
761 if (status == NDIS_STATUS_FAILURE) {
762 if (cmdqelmt->buffer)
763 os_free_mem(pAd, cmdqelmt->buffer);
764 os_free_mem(pAd, cmdqelmt);
765 } else
766 RTUSBCMDUp(pAd);
767 }
768 return NDIS_STATUS_SUCCESS;
769 }
770
771 /*
772 ========================================================================
773
774 Routine Description:
775
776 Arguments:
777
778 Return Value:
779
780 IRQL =
781
782 Note:
783
784 ========================================================================
785 */
786 void RTUSBDequeueCmd(struct rt_cmdq *cmdq, struct rt_cmdqelmt * * pcmdqelmt)
787 {
788 *pcmdqelmt = cmdq->head;
789
790 if (*pcmdqelmt != NULL) {
791 cmdq->head = cmdq->head->next;
792 cmdq->size--;
793 if (cmdq->size == 0)
794 cmdq->tail = NULL;
795 }
796 }
797
798 /*
799 ========================================================================
800 usb_control_msg - Builds a control urb, sends it off and waits for completion
801 @dev: pointer to the usb device to send the message to
802 @pipe: endpoint "pipe" to send the message to
803 @request: USB message request value
804 @requesttype: USB message request type value
805 @value: USB message value
806 @index: USB message index value
807 @data: pointer to the data to send
808 @size: length in bytes of the data to send
809 @timeout: time in jiffies to wait for the message to complete before
810 timing out (if 0 the wait is forever)
811 Context: !in_interrupt ()
812
813 This function sends a simple control message to a specified endpoint
814 and waits for the message to complete, or timeout.
815 If successful, it returns the number of bytes transferred, otherwise a negative error number.
816
817 Don't use this function from within an interrupt context, like a
818 bottom half handler. If you need an asynchronous message, or need to send
819 a message from within interrupt context, use usb_submit_urb()
820 If a thread in your driver uses this call, make sure your disconnect()
821 method can wait for it to complete. Since you don't have a handle on
822 the URB used, you can't cancel the request.
823
824 Routine Description:
825
826 Arguments:
827
828 Return Value:
829
830 Note:
831
832 ========================================================================
833 */
834 int RTUSB_VendorRequest(struct rt_rtmp_adapter *pAd,
835 u32 TransferFlags,
836 u8 RequestType,
837 u8 Request,
838 u16 Value,
839 u16 Index,
840 void *TransferBuffer,
841 u32 TransferBufferLength)
842 {
843 int ret = 0;
844 struct os_cookie *pObj = (struct os_cookie *)pAd->OS_Cookie;
845
846 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) {
847 DBGPRINT(RT_DEBUG_ERROR, ("device disconnected\n"));
848 return -1;
849 } else if (in_interrupt()) {
850 DBGPRINT(RT_DEBUG_ERROR,
851 ("in_interrupt, RTUSB_VendorRequest Request%02x Value%04x Offset%04x\n",
852 Request, Value, Index));
853
854 return -1;
855 } else {
856 #define MAX_RETRY_COUNT 10
857
858 int retryCount = 0;
859 void *tmpBuf = TransferBuffer;
860
861 ret = down_interruptible(&(pAd->UsbVendorReq_semaphore));
862 if (pAd->UsbVendorReqBuf) {
863 ASSERT(TransferBufferLength < MAX_PARAM_BUFFER_SIZE);
864
865 tmpBuf = (void *)pAd->UsbVendorReqBuf;
866 NdisZeroMemory(pAd->UsbVendorReqBuf,
867 TransferBufferLength);
868
869 if (RequestType == DEVICE_VENDOR_REQUEST_OUT)
870 NdisMoveMemory(tmpBuf, TransferBuffer,
871 TransferBufferLength);
872 }
873
874 do {
875 if (RequestType == DEVICE_VENDOR_REQUEST_OUT)
876 ret =
877 usb_control_msg(pObj->pUsb_Dev,
878 usb_sndctrlpipe(pObj->
879 pUsb_Dev,
880 0), Request,
881 RequestType, Value, Index,
882 tmpBuf,
883 TransferBufferLength,
884 CONTROL_TIMEOUT_JIFFIES);
885 else if (RequestType == DEVICE_VENDOR_REQUEST_IN)
886 ret =
887 usb_control_msg(pObj->pUsb_Dev,
888 usb_rcvctrlpipe(pObj->
889 pUsb_Dev,
890 0), Request,
891 RequestType, Value, Index,
892 tmpBuf,
893 TransferBufferLength,
894 CONTROL_TIMEOUT_JIFFIES);
895 else {
896 DBGPRINT(RT_DEBUG_ERROR,
897 ("vendor request direction is failed\n"));
898 ret = -1;
899 }
900
901 retryCount++;
902 if (ret < 0) {
903 DBGPRINT(RT_DEBUG_OFF, ("#\n"));
904 RTMPusecDelay(5000);
905 }
906 } while ((ret < 0) && (retryCount < MAX_RETRY_COUNT));
907
908 if ((pAd->UsbVendorReqBuf)
909 && (RequestType == DEVICE_VENDOR_REQUEST_IN))
910 NdisMoveMemory(TransferBuffer, tmpBuf,
911 TransferBufferLength);
912 up(&(pAd->UsbVendorReq_semaphore));
913
914 if (ret < 0) {
915 DBGPRINT(RT_DEBUG_ERROR,
916 ("RTUSB_VendorRequest failed(%d),TxFlags=0x%x, ReqType=%s, Req=0x%x, Index=0x%x\n",
917 ret, TransferFlags,
918 (RequestType ==
919 DEVICE_VENDOR_REQUEST_OUT ? "OUT" : "IN"),
920 Request, Index));
921 if (Request == 0x2)
922 DBGPRINT(RT_DEBUG_ERROR,
923 ("\tRequest Value=0x%04x!\n", Value));
924
925 if ((TransferBuffer != NULL)
926 && (TransferBufferLength > 0))
927 hex_dump("Failed TransferBuffer value",
928 TransferBuffer, TransferBufferLength);
929 }
930
931 }
932
933 if (ret != -1)
934 return STATUS_SUCCESS;
935 else
936 return STATUS_UNSUCCESSFUL;
937 }
938
939 /*
940 ========================================================================
941
942 Routine Description:
943 Creates an IRP to submite an IOCTL_INTERNAL_USB_RESET_PORT
944 synchronously. Callers of this function must be running at
945 PASSIVE LEVEL.
946
947 Arguments:
948
949 Return Value:
950
951 Note:
952
953 ========================================================================
954 */
955 int RTUSB_ResetDevice(struct rt_rtmp_adapter *pAd)
956 {
957 int Status = TRUE;
958
959 DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->USB_ResetDevice\n"));
960 /*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS); */
961 return Status;
962 }
963
964 void CMDHandler(struct rt_rtmp_adapter *pAd)
965 {
966 struct rt_cmdqelmt *cmdqelmt;
967 u8 *pData;
968 int NdisStatus = NDIS_STATUS_SUCCESS;
969 /* unsigned long Now = 0; */
970 int ntStatus;
971 /* unsigned long IrqFlags; */
972
973 while (pAd && pAd->CmdQ.size > 0) {
974 NdisStatus = NDIS_STATUS_SUCCESS;
975
976 NdisAcquireSpinLock(&pAd->CmdQLock);
977 RTUSBDequeueCmd(&pAd->CmdQ, &cmdqelmt);
978 NdisReleaseSpinLock(&pAd->CmdQLock);
979
980 if (cmdqelmt == NULL)
981 break;
982
983 pData = cmdqelmt->buffer;
984
985 if (!
986 (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)
987 || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))) {
988 switch (cmdqelmt->command) {
989 case CMDTHREAD_CHECK_GPIO:
990 {
991 u32 data;
992
993 {
994 /* Read GPIO pin2 as Hardware controlled radio state */
995
996 RTUSBReadMACRegister(pAd,
997 GPIO_CTRL_CFG,
998 &data);
999
1000 if (data & 0x04) {
1001 pAd->StaCfg.bHwRadio =
1002 TRUE;
1003 } else {
1004 pAd->StaCfg.bHwRadio =
1005 FALSE;
1006 }
1007
1008 if (pAd->StaCfg.bRadio !=
1009 (pAd->StaCfg.bHwRadio
1010 && pAd->StaCfg.bSwRadio)) {
1011 pAd->StaCfg.bRadio =
1012 (pAd->StaCfg.
1013 bHwRadio
1014 && pAd->StaCfg.
1015 bSwRadio);
1016 if (pAd->StaCfg.
1017 bRadio == TRUE) {
1018 DBGPRINT_RAW
1019 (RT_DEBUG_ERROR,
1020 ("!!! Radio On !!!\n"));
1021
1022 MlmeRadioOn
1023 (pAd);
1024 /* Update extra information */
1025 pAd->ExtraInfo =
1026 EXTRA_INFO_CLEAR;
1027 } else {
1028 DBGPRINT_RAW
1029 (RT_DEBUG_ERROR,
1030 ("!!! Radio Off !!!\n"));
1031
1032 MlmeRadioOff
1033 (pAd);
1034 /* Update extra information */
1035 pAd->ExtraInfo =
1036 HW_RADIO_OFF;
1037 }
1038 }
1039 }
1040 }
1041 break;
1042
1043 case CMDTHREAD_QKERIODIC_EXECUT:
1044 {
1045 StaQuickResponeForRateUpExec(NULL, pAd,
1046 NULL,
1047 NULL);
1048 }
1049 break;
1050
1051 case CMDTHREAD_RESET_BULK_OUT:
1052 {
1053 u32 MACValue;
1054 u8 Index;
1055 int ret = 0;
1056 struct rt_ht_tx_context *pHTTXContext;
1057 /* struct rt_rtmp_tx_ring *pTxRing; */
1058 unsigned long IrqFlags;
1059
1060 DBGPRINT_RAW(RT_DEBUG_TRACE,
1061 ("CmdThread : CMDTHREAD_RESET_BULK_OUT(ResetPipeid=0x%0x)===>\n",
1062 pAd->bulkResetPipeid));
1063 /* All transfers must be aborted or cancelled before attempting to reset the pipe. */
1064 /*RTUSBCancelPendingBulkOutIRP(pAd); */
1065 /* Wait 10ms to let previous packet that are already in HW FIFO to clear. by MAXLEE 12-25-2007 */
1066 Index = 0;
1067 do {
1068 RTUSBReadMACRegister(pAd,
1069 TXRXQ_PCNT,
1070 &MACValue);
1071 if ((MACValue & 0xf00000
1072 /*0x800000 */) == 0)
1073 break;
1074 Index++;
1075 RTMPusecDelay(10000);
1076 } while (Index < 100);
1077 MACValue = 0;
1078 RTUSBReadMACRegister(pAd, USB_DMA_CFG,
1079 &MACValue);
1080 /* To prevent Read Register error, we 2nd check the validity. */
1081 if ((MACValue & 0xc00000) == 0)
1082 RTUSBReadMACRegister(pAd,
1083 USB_DMA_CFG,
1084 &MACValue);
1085 /* To prevent Read Register error, we 3rd check the validity. */
1086 if ((MACValue & 0xc00000) == 0)
1087 RTUSBReadMACRegister(pAd,
1088 USB_DMA_CFG,
1089 &MACValue);
1090 MACValue |= 0x80000;
1091 RTUSBWriteMACRegister(pAd, USB_DMA_CFG,
1092 MACValue);
1093
1094 /* Wait 1ms to prevent next URB to bulkout before HW reset. by MAXLEE 12-25-2007 */
1095 RTMPusecDelay(1000);
1096
1097 MACValue &= (~0x80000);
1098 RTUSBWriteMACRegister(pAd, USB_DMA_CFG,
1099 MACValue);
1100 DBGPRINT_RAW(RT_DEBUG_TRACE,
1101 ("\tSet 0x2a0 bit19. Clear USB DMA TX path\n"));
1102
1103 /* Wait 5ms to prevent next URB to bulkout before HW reset. by MAXLEE 12-25-2007 */
1104 /*RTMPusecDelay(5000); */
1105
1106 if ((pAd->
1107 bulkResetPipeid &
1108 BULKOUT_MGMT_RESET_FLAG) ==
1109 BULKOUT_MGMT_RESET_FLAG) {
1110 RTMP_CLEAR_FLAG(pAd,
1111 fRTMP_ADAPTER_BULKOUT_RESET);
1112 if (pAd->MgmtRing.TxSwFreeIdx <
1113 MGMT_RING_SIZE
1114 /* pMLMEContext->bWaitingBulkOut == TRUE */
1115 ) {
1116 RTUSB_SET_BULK_FLAG(pAd,
1117 fRTUSB_BULK_OUT_MLME);
1118 }
1119 RTUSBKickBulkOut(pAd);
1120
1121 DBGPRINT_RAW(RT_DEBUG_TRACE,
1122 ("\tTX MGMT RECOVER Done!\n"));
1123 } else {
1124 pHTTXContext =
1125 &(pAd->
1126 TxContext[pAd->
1127 bulkResetPipeid]);
1128 /*NdisAcquireSpinLock(&pAd->BulkOutLock[pAd->bulkResetPipeid]); */
1129 RTMP_INT_LOCK(&pAd->
1130 BulkOutLock[pAd->
1131 bulkResetPipeid],
1132 IrqFlags);
1133 if (pAd->
1134 BulkOutPending[pAd->
1135 bulkResetPipeid]
1136 == FALSE) {
1137 pAd->
1138 BulkOutPending[pAd->
1139 bulkResetPipeid]
1140 = TRUE;
1141 pHTTXContext->
1142 IRPPending = TRUE;
1143 pAd->
1144 watchDogTxPendingCnt
1145 [pAd->
1146 bulkResetPipeid] =
1147 1;
1148
1149 /* no matter what, clean the flag */
1150 RTMP_CLEAR_FLAG(pAd,
1151 fRTMP_ADAPTER_BULKOUT_RESET);
1152
1153 /*NdisReleaseSpinLock(&pAd->BulkOutLock[pAd->bulkResetPipeid]); */
1154 RTMP_INT_UNLOCK(&pAd->
1155 BulkOutLock
1156 [pAd->
1157 bulkResetPipeid],
1158 IrqFlags);
1159 {
1160 RTUSBInitHTTxDesc
1161 (pAd,
1162 pHTTXContext,
1163 pAd->
1164 bulkResetPipeid,
1165 pHTTXContext->
1166 BulkOutSize,
1167 (usb_complete_t)
1168 RTUSBBulkOutDataPacketComplete);
1169
1170 ret = RTUSB_SUBMIT_URB
1171 (pHTTXContext->
1172 pUrb);
1173 if (ret != 0) {
1174 RTMP_INT_LOCK
1175 (&pAd->
1176 BulkOutLock
1177 [pAd->
1178 bulkResetPipeid],
1179 IrqFlags);
1180 pAd->
1181 BulkOutPending
1182 [pAd->
1183 bulkResetPipeid]
1184 =
1185 FALSE;
1186 pHTTXContext->
1187 IRPPending
1188 =
1189 FALSE;
1190 pAd->
1191 watchDogTxPendingCnt
1192 [pAd->
1193 bulkResetPipeid]
1194 = 0;
1195 RTMP_INT_UNLOCK
1196 (&pAd->
1197 BulkOutLock
1198 [pAd->
1199 bulkResetPipeid],
1200 IrqFlags);
1201
1202 DBGPRINT
1203 (RT_DEBUG_ERROR,
1204 ("CmdThread : CMDTHREAD_RESET_BULK_OUT: Submit Tx URB failed %d\n",
1205 ret));
1206 } else {
1207 RTMP_IRQ_LOCK
1208 (&pAd->
1209 BulkOutLock
1210 [pAd->
1211 bulkResetPipeid],
1212 IrqFlags);
1213 DBGPRINT_RAW
1214 (RT_DEBUG_TRACE,
1215 ("\tCMDTHREAD_RESET_BULK_OUT: TxContext[%d]:CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d, pending=%d!\n",
1216 pAd->
1217 bulkResetPipeid,
1218 pHTTXContext->
1219 CurWritePosition,
1220 pHTTXContext->
1221 NextBulkOutPosition,
1222 pHTTXContext->
1223 ENextBulkOutPosition,
1224 pHTTXContext->
1225 bCopySavePad,
1226 pAd->
1227 BulkOutPending
1228 [pAd->
1229 bulkResetPipeid]));
1230 DBGPRINT_RAW
1231 (RT_DEBUG_TRACE,
1232 ("\t\tBulkOut Req=0x%lx, Complete=0x%lx, Other=0x%lx\n",
1233 pAd->
1234 BulkOutReq,
1235 pAd->
1236 BulkOutComplete,
1237 pAd->
1238 BulkOutCompleteOther));
1239 RTMP_IRQ_UNLOCK
1240 (&pAd->
1241 BulkOutLock
1242 [pAd->
1243 bulkResetPipeid],
1244 IrqFlags);
1245 DBGPRINT_RAW
1246 (RT_DEBUG_TRACE,
1247 ("\tCMDTHREAD_RESET_BULK_OUT: Submit Tx DATA URB for failed BulkReq(0x%lx) Done, status=%d!\n",
1248 pAd->
1249 bulkResetReq
1250 [pAd->
1251 bulkResetPipeid],
1252 pHTTXContext->
1253 pUrb->
1254 status));
1255
1256 }
1257 }
1258 } else {
1259 /*NdisReleaseSpinLock(&pAd->BulkOutLock[pAd->bulkResetPipeid]); */
1260 /*RTMP_INT_UNLOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags); */
1261
1262 DBGPRINT_RAW
1263 (RT_DEBUG_ERROR,
1264 ("CmdThread : TX DATA RECOVER FAIL for BulkReq(0x%lx) because BulkOutPending[%d] is TRUE!\n",
1265 pAd->
1266 bulkResetReq[pAd->
1267 bulkResetPipeid],
1268 pAd->
1269 bulkResetPipeid));
1270 if (pAd->
1271 bulkResetPipeid ==
1272 0) {
1273 u8
1274 pendingContext
1275 = 0;
1276 struct rt_ht_tx_context *
1277 pHTTXContext
1278 =
1279 (struct rt_ht_tx_context *)
1280 (&pAd->
1281 TxContext
1282 [pAd->
1283 bulkResetPipeid]);
1284 struct rt_tx_context *
1285 pMLMEContext
1286 =
1287 (struct rt_tx_context *)
1288 (pAd->
1289 MgmtRing.
1290 Cell[pAd->
1291 MgmtRing.
1292 TxDmaIdx].
1293 AllocVa);
1294 struct rt_tx_context *
1295 pNULLContext
1296 =
1297 (struct rt_tx_context *)
1298 (&pAd->
1299 PsPollContext);
1300 struct rt_tx_context *
1301 pPsPollContext
1302 =
1303 (struct rt_tx_context *)
1304 (&pAd->
1305 NullContext);
1306
1307 if (pHTTXContext->IRPPending)
1308 pendingContext
1309 |=
1310 1;
1311 else if
1312 (pMLMEContext->
1313 IRPPending)
1314 pendingContext
1315 |=
1316 2;
1317 else if
1318 (pNULLContext->
1319 IRPPending)
1320 pendingContext
1321 |=
1322 4;
1323 else if
1324 (pPsPollContext->
1325 IRPPending)
1326 pendingContext
1327 |=
1328 8;
1329 else
1330 pendingContext
1331 = 0;
1332
1333 DBGPRINT_RAW
1334 (RT_DEBUG_ERROR,
1335 ("\tTX Occupied by %d!\n",
1336 pendingContext));
1337 }
1338 /* no matter what, clean the flag */
1339 RTMP_CLEAR_FLAG(pAd,
1340 fRTMP_ADAPTER_BULKOUT_RESET);
1341
1342 RTMP_INT_UNLOCK(&pAd->
1343 BulkOutLock
1344 [pAd->
1345 bulkResetPipeid],
1346 IrqFlags);
1347
1348 RTUSB_SET_BULK_FLAG(pAd,
1349 (fRTUSB_BULK_OUT_DATA_NORMAL
1350 <<
1351 pAd->
1352 bulkResetPipeid));
1353 }
1354
1355 RTMPDeQueuePacket(pAd, FALSE,
1356 NUM_OF_TX_RING,
1357 MAX_TX_PROCESS);
1358 /*RTUSBKickBulkOut(pAd); */
1359 }
1360
1361 }
1362 /*
1363 // Don't cancel BULKIN.
1364 while ((atomic_read(&pAd->PendingRx) > 0) &&
1365 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
1366 {
1367 if (atomic_read(&pAd->PendingRx) > 0)
1368 {
1369 DBGPRINT_RAW(RT_DEBUG_ERROR, ("BulkIn IRP Pending!!cancel it!\n"));
1370 RTUSBCancelPendingBulkInIRP(pAd);
1371 }
1372 RTMPusecDelay(100000);
1373 }
1374
1375 if ((atomic_read(&pAd->PendingRx) == 0) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)))
1376 {
1377 u8 i;
1378 RTUSBRxPacket(pAd);
1379 pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
1380 pAd->NextRxBulkInIndex = 0; // Rx Bulk pointer
1381 for (i = 0; i < (RX_RING_SIZE); i++)
1382 {
1383 struct rt_rx_context *pRxContext = &(pAd->RxContext[i]);
1384
1385 pRxContext->pAd = pAd;
1386 pRxContext->InUse = FALSE;
1387 pRxContext->IRPPending = FALSE;
1388 pRxContext->Readable = FALSE;
1389 pRxContext->ReorderInUse = FALSE;
1390
1391 }
1392 RTUSBBulkReceive(pAd);
1393 DBGPRINT_RAW(RT_DEBUG_ERROR, ("RTUSBBulkReceive\n"));
1394 } */
1395 DBGPRINT_RAW(RT_DEBUG_TRACE,
1396 ("CmdThread : CMDTHREAD_RESET_BULK_OUT<===\n"));
1397 break;
1398
1399 case CMDTHREAD_RESET_BULK_IN:
1400 DBGPRINT_RAW(RT_DEBUG_TRACE,
1401 ("CmdThread : CMDTHREAD_RESET_BULK_IN === >\n"));
1402
1403 /* All transfers must be aborted or cancelled before attempting to reset the pipe. */
1404 {
1405 u32 MACValue;
1406 {
1407 /*while ((atomic_read(&pAd->PendingRx) > 0) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))) */
1408 if ((pAd->PendingRx > 0)
1409 &&
1410 (!RTMP_TEST_FLAG
1411 (pAd,
1412 fRTMP_ADAPTER_NIC_NOT_EXIST))) {
1413 DBGPRINT_RAW
1414 (RT_DEBUG_ERROR,
1415 ("BulkIn IRP Pending!!!\n"));
1416 RTUSBCancelPendingBulkInIRP
1417 (pAd);
1418 RTMPusecDelay(100000);
1419 pAd->PendingRx = 0;
1420 }
1421 }
1422 /* Wait 10ms before reading register. */
1423 RTMPusecDelay(10000);
1424 ntStatus =
1425 RTUSBReadMACRegister(pAd, MAC_CSR0,
1426 &MACValue);
1427
1428 if ((NT_SUCCESS(ntStatus) == TRUE) &&
1429 (!(RTMP_TEST_FLAG
1430 (pAd,
1431 (fRTMP_ADAPTER_RESET_IN_PROGRESS
1432 | fRTMP_ADAPTER_RADIO_OFF |
1433 fRTMP_ADAPTER_HALT_IN_PROGRESS
1434 |
1435 fRTMP_ADAPTER_NIC_NOT_EXIST)))))
1436 {
1437 u8 i;
1438
1439 if (RTMP_TEST_FLAG
1440 (pAd,
1441 (fRTMP_ADAPTER_RESET_IN_PROGRESS
1442 | fRTMP_ADAPTER_RADIO_OFF
1443 |
1444 fRTMP_ADAPTER_HALT_IN_PROGRESS
1445 |
1446 fRTMP_ADAPTER_NIC_NOT_EXIST)))
1447 break;
1448 pAd->NextRxBulkInPosition =
1449 pAd->RxContext[pAd->
1450 NextRxBulkInIndex].
1451 BulkInOffset;
1452 DBGPRINT(RT_DEBUG_TRACE,
1453 ("BULK_IN_RESET: NBIIdx=0x%x,NBIRIdx=0x%x, BIRPos=0x%lx. BIReq=x%lx, BIComplete=0x%lx, BICFail0x%lx\n",
1454 pAd->
1455 NextRxBulkInIndex,
1456 pAd->
1457 NextRxBulkInReadIndex,
1458 pAd->
1459 NextRxBulkInPosition,
1460 pAd->BulkInReq,
1461 pAd->BulkInComplete,
1462 pAd->
1463 BulkInCompleteFail));
1464 for (i = 0; i < RX_RING_SIZE;
1465 i++) {
1466 DBGPRINT(RT_DEBUG_TRACE,
1467 ("\tRxContext[%d]: IRPPending=%d, InUse=%d, Readable=%d!\n",
1468 i,
1469 pAd->
1470 RxContext[i].
1471 IRPPending,
1472 pAd->
1473 RxContext[i].
1474 InUse,
1475 pAd->
1476 RxContext[i].
1477 Readable));
1478 }
1479 /*
1480
1481 DBGPRINT_RAW(RT_DEBUG_ERROR, ("==========================================\n"));
1482
1483 pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
1484 pAd->NextRxBulkInIndex = 0; // Rx Bulk pointer
1485 for (i = 0; i < (RX_RING_SIZE); i++)
1486 {
1487 struct rt_rx_context *pRxContext = &(pAd->RxContext[i]);
1488
1489 pRxContext->pAd = pAd;
1490 pRxContext->InUse = FALSE;
1491 pRxContext->IRPPending = FALSE;
1492 pRxContext->Readable = FALSE;
1493 pRxContext->ReorderInUse = FALSE;
1494
1495 } */
1496 RTMP_CLEAR_FLAG(pAd,
1497 fRTMP_ADAPTER_BULKIN_RESET);
1498 for (i = 0;
1499 i <
1500 pAd->CommonCfg.
1501 NumOfBulkInIRP; i++) {
1502 /*RTUSBBulkReceive(pAd); */
1503 struct rt_rx_context *pRxContext;
1504 PURB pUrb;
1505 int ret = 0;
1506 unsigned long IrqFlags;
1507
1508 RTMP_IRQ_LOCK(&pAd->
1509 BulkInLock,
1510 IrqFlags);
1511 pRxContext =
1512 &(pAd->
1513 RxContext[pAd->
1514 NextRxBulkInIndex]);
1515 if ((pAd->PendingRx > 0)
1516 || (pRxContext->
1517 Readable ==
1518 TRUE)
1519 || (pRxContext->
1520 InUse ==
1521 TRUE)) {
1522 RTMP_IRQ_UNLOCK
1523 (&pAd->
1524 BulkInLock,
1525 IrqFlags);
1526 break;
1527 }
1528 pRxContext->InUse =
1529 TRUE;
1530 pRxContext->IRPPending =
1531 TRUE;
1532 pAd->PendingRx++;
1533 pAd->BulkInReq++;
1534 RTMP_IRQ_UNLOCK(&pAd->
1535 BulkInLock,
1536 IrqFlags);
1537
1538 /* Init Rx context descriptor */
1539 RTUSBInitRxDesc(pAd,
1540 pRxContext);
1541 pUrb = pRxContext->pUrb;
1542 ret = RTUSB_SUBMIT_URB(pUrb);
1543 if (ret != 0) { /* fail */
1544
1545 RTMP_IRQ_LOCK
1546 (&pAd->
1547 BulkInLock,
1548 IrqFlags);
1549 pRxContext->
1550 InUse =
1551 FALSE;
1552 pRxContext->
1553 IRPPending =
1554 FALSE;
1555 pAd->
1556 PendingRx--;
1557 pAd->
1558 BulkInReq--;
1559 RTMP_IRQ_UNLOCK
1560 (&pAd->
1561 BulkInLock,
1562 IrqFlags);
1563 DBGPRINT
1564 (RT_DEBUG_ERROR,
1565 ("CMDTHREAD_RESET_BULK_IN: Submit Rx URB failed(%d), status=%d\n",
1566 ret,
1567 pUrb->
1568 status));
1569 } else { /* success */
1570 /*DBGPRINT(RT_DEBUG_TRACE, ("BIDone, Pend=%d,BIIdx=%d,BIRIdx=%d!\n", */
1571 /* pAd->PendingRx, pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex)); */
1572 DBGPRINT_RAW
1573 (RT_DEBUG_TRACE,
1574 ("CMDTHREAD_RESET_BULK_IN: Submit Rx URB Done, status=%d!\n",
1575 pUrb->
1576 status));
1577 ASSERT((pRxContext->InUse == pRxContext->IRPPending));
1578 }
1579 }
1580
1581 } else {
1582 /* Card must be removed */
1583 if (NT_SUCCESS(ntStatus) !=
1584 TRUE) {
1585 RTMP_SET_FLAG(pAd,
1586 fRTMP_ADAPTER_NIC_NOT_EXIST);
1587 DBGPRINT_RAW
1588 (RT_DEBUG_ERROR,
1589 ("CMDTHREAD_RESET_BULK_IN: Read Register Failed!Card must be removed!!\n\n"));
1590 } else {
1591 DBGPRINT_RAW
1592 (RT_DEBUG_ERROR,
1593 ("CMDTHREAD_RESET_BULK_IN: Cannot do bulk in because flags(0x%lx) on !\n",
1594 pAd->Flags));
1595 }
1596 }
1597 }
1598 DBGPRINT_RAW(RT_DEBUG_TRACE,
1599 ("CmdThread : CMDTHREAD_RESET_BULK_IN <===\n"));
1600 break;
1601
1602 case CMDTHREAD_SET_ASIC_WCID:
1603 {
1604 struct rt_set_asic_wcid SetAsicWcid;
1605 u16 offset;
1606 u32 MACValue, MACRValue = 0;
1607 SetAsicWcid =
1608 *((struct rt_set_asic_wcid *)(pData));
1609
1610 if (SetAsicWcid.WCID >=
1611 MAX_LEN_OF_MAC_TABLE)
1612 return;
1613
1614 offset =
1615 MAC_WCID_BASE +
1616 ((u8)SetAsicWcid.WCID) *
1617 HW_WCID_ENTRY_SIZE;
1618
1619 DBGPRINT_RAW(RT_DEBUG_TRACE,
1620 ("CmdThread : CMDTHREAD_SET_ASIC_WCID : WCID = %ld, SetTid = %lx, DeleteTid = %lx.\n",
1621 SetAsicWcid.WCID,
1622 SetAsicWcid.SetTid,
1623 SetAsicWcid.DeleteTid));
1624 MACValue =
1625 (pAd->MacTab.
1626 Content[SetAsicWcid.WCID].
1627 Addr[3] << 24) +
1628 (pAd->MacTab.
1629 Content[SetAsicWcid.WCID].
1630 Addr[2] << 16) +
1631 (pAd->MacTab.
1632 Content[SetAsicWcid.WCID].
1633 Addr[1] << 8) +
1634 (pAd->MacTab.
1635 Content[SetAsicWcid.WCID].Addr[0]);
1636 DBGPRINT_RAW(RT_DEBUG_TRACE,
1637 ("1-MACValue= %x,\n",
1638 MACValue));
1639 RTUSBWriteMACRegister(pAd, offset,
1640 MACValue);
1641 /* Read bitmask */
1642 RTUSBReadMACRegister(pAd, offset + 4,
1643 &MACRValue);
1644 if (SetAsicWcid.DeleteTid != 0xffffffff)
1645 MACRValue &=
1646 (~SetAsicWcid.DeleteTid);
1647 if (SetAsicWcid.SetTid != 0xffffffff)
1648 MACRValue |=
1649 (SetAsicWcid.SetTid);
1650 MACRValue &= 0xffff0000;
1651
1652 MACValue =
1653 (pAd->MacTab.
1654 Content[SetAsicWcid.WCID].
1655 Addr[5] << 8) +
1656 pAd->MacTab.Content[SetAsicWcid.
1657 WCID].Addr[4];
1658 MACValue |= MACRValue;
1659 RTUSBWriteMACRegister(pAd, offset + 4,
1660 MACValue);
1661
1662 DBGPRINT_RAW(RT_DEBUG_TRACE,
1663 ("2-MACValue= %x,\n",
1664 MACValue));
1665 }
1666 break;
1667
1668 case CMDTHREAD_SET_ASIC_WCID_CIPHER:
1669 {
1670 struct rt_set_asic_wcid_attri SetAsicWcidAttri;
1671 u16 offset;
1672 u32 MACRValue = 0;
1673 SHAREDKEY_MODE_STRUC csr1;
1674 SetAsicWcidAttri =
1675 *((struct rt_set_asic_wcid_attri *)
1676 (pData));
1677
1678 if (SetAsicWcidAttri.WCID >=
1679 MAX_LEN_OF_MAC_TABLE)
1680 return;
1681
1682 offset =
1683 MAC_WCID_ATTRIBUTE_BASE +
1684 ((u8)SetAsicWcidAttri.WCID) *
1685 HW_WCID_ATTRI_SIZE;
1686
1687 DBGPRINT_RAW(RT_DEBUG_TRACE,
1688 ("Cmd : CMDTHREAD_SET_ASIC_WCID_CIPHER : WCID = %ld, Cipher = %lx.\n",
1689 SetAsicWcidAttri.WCID,
1690 SetAsicWcidAttri.Cipher));
1691 /* Read bitmask */
1692 RTUSBReadMACRegister(pAd, offset,
1693 &MACRValue);
1694 MACRValue = 0;
1695 MACRValue |=
1696 (((u8)SetAsicWcidAttri.
1697 Cipher) << 1);
1698
1699 RTUSBWriteMACRegister(pAd, offset,
1700 MACRValue);
1701 DBGPRINT_RAW(RT_DEBUG_TRACE,
1702 ("2-offset = %x , MACValue= %x,\n",
1703 offset, MACRValue));
1704
1705 offset =
1706 PAIRWISE_IVEIV_TABLE_BASE +
1707 ((u8)SetAsicWcidAttri.WCID) *
1708 HW_IVEIV_ENTRY_SIZE;
1709 MACRValue = 0;
1710 if ((SetAsicWcidAttri.Cipher <=
1711 CIPHER_WEP128))
1712 MACRValue |=
1713 (pAd->StaCfg.
1714 DefaultKeyId << 30);
1715 else
1716 MACRValue |= (0x20000000);
1717 RTUSBWriteMACRegister(pAd, offset,
1718 MACRValue);
1719 DBGPRINT_RAW(RT_DEBUG_TRACE,
1720 ("2-offset = %x , MACValue= %x,\n",
1721 offset, MACRValue));
1722
1723 /* */
1724 /* Update cipher algorithm. WSTA always use BSS0 */
1725 /* */
1726 /* for adhoc mode only ,because wep status slow than add key, when use zero config */
1727 if (pAd->StaCfg.BssType == BSS_ADHOC) {
1728 offset =
1729 MAC_WCID_ATTRIBUTE_BASE;
1730
1731 RTUSBReadMACRegister(pAd,
1732 offset,
1733 &MACRValue);
1734 MACRValue &= (~0xe);
1735 MACRValue |=
1736 (((u8)SetAsicWcidAttri.
1737 Cipher) << 1);
1738
1739 RTUSBWriteMACRegister(pAd,
1740 offset,
1741 MACRValue);
1742
1743 /*Update group key cipher,,because wep status slow than add key, when use zero config */
1744 RTUSBReadMACRegister(pAd,
1745 SHARED_KEY_MODE_BASE
1746 +
1747 4 * (0 /
1748 2),
1749 &csr1.
1750 word);
1751
1752 csr1.field.Bss0Key0CipherAlg =
1753 SetAsicWcidAttri.Cipher;
1754 csr1.field.Bss0Key1CipherAlg =
1755 SetAsicWcidAttri.Cipher;
1756
1757 RTUSBWriteMACRegister(pAd,
1758 SHARED_KEY_MODE_BASE
1759 +
1760 4 * (0 /
1761 2),
1762 csr1.
1763 word);
1764 }
1765 }
1766 break;
1767
1768 /*Benson modified for USB interface, avoid in interrupt when write key, 20080724 --> */
1769 case RT_CMD_SET_KEY_TABLE: /*General call for AsicAddPairwiseKeyEntry() */
1770 {
1771 struct rt_add_pairwise_key_entry KeyInfo;
1772 KeyInfo =
1773 *((struct rt_add_pairwise_key_entry *)
1774 (pData));
1775 AsicAddPairwiseKeyEntry(pAd,
1776 KeyInfo.MacAddr,
1777 (u8)KeyInfo.
1778 MacTabMatchWCID,
1779 &KeyInfo.
1780 CipherKey);
1781 }
1782 break;
1783
1784 case RT_CMD_SET_RX_WCID_TABLE: /*General call for RTMPAddWcidAttributeEntry() */
1785 {
1786 struct rt_mac_table_entry *pEntry;
1787 u8 KeyIdx = 0;
1788 u8 CipherAlg = CIPHER_NONE;
1789 u8 ApIdx = BSS0;
1790
1791 pEntry = (struct rt_mac_table_entry *)(pData);
1792
1793 RTMPAddWcidAttributeEntry(pAd,
1794 ApIdx,
1795 KeyIdx,
1796 CipherAlg,
1797 pEntry);
1798 }
1799 break;
1800 /*Benson modified for USB interface, avoid in interrupt when write key, 20080724 <-- */
1801
1802 case CMDTHREAD_SET_CLIENT_MAC_ENTRY:
1803 {
1804 struct rt_mac_table_entry *pEntry;
1805 pEntry = (struct rt_mac_table_entry *)pData;
1806
1807 {
1808 AsicRemovePairwiseKeyEntry(pAd,
1809 pEntry->
1810 apidx,
1811 (u8)
1812 pEntry->
1813 Aid);
1814 if ((pEntry->AuthMode <=
1815 Ndis802_11AuthModeAutoSwitch)
1816 && (pEntry->WepStatus ==
1817 Ndis802_11Encryption1Enabled))
1818 {
1819 u32 uIV = 1;
1820 u8 *ptr;
1821
1822 ptr = (u8 *)& uIV;
1823 *(ptr + 3) =
1824 (pAd->StaCfg.
1825 DefaultKeyId << 6);
1826 AsicUpdateWCIDIVEIV(pAd,
1827 pEntry->
1828 Aid,
1829 uIV,
1830 0);
1831 AsicUpdateWCIDAttribute
1832 (pAd, pEntry->Aid,
1833 BSS0,
1834 pAd->
1835 SharedKey[BSS0]
1836 [pAd->StaCfg.
1837 DefaultKeyId].
1838 CipherAlg, FALSE);
1839 } else if (pEntry->AuthMode ==
1840 Ndis802_11AuthModeWPANone)
1841 {
1842 u32 uIV = 1;
1843 u8 *ptr;
1844
1845 ptr = (u8 *)& uIV;
1846 *(ptr + 3) =
1847 (pAd->StaCfg.
1848 DefaultKeyId << 6);
1849 AsicUpdateWCIDIVEIV(pAd,
1850 pEntry->
1851 Aid,
1852 uIV,
1853 0);
1854 AsicUpdateWCIDAttribute
1855 (pAd, pEntry->Aid,
1856 BSS0,
1857 pAd->
1858 SharedKey[BSS0]
1859 [pAd->StaCfg.
1860 DefaultKeyId].
1861 CipherAlg, FALSE);
1862 } else {
1863 /* */
1864 /* Other case, disable engine. */
1865 /* Don't worry WPA key, we will add WPA Key after 4-Way handshaking. */
1866 /* */
1867 u16 offset;
1868 offset =
1869 MAC_WCID_ATTRIBUTE_BASE
1870 +
1871 (pEntry->Aid *
1872 HW_WCID_ATTRI_SIZE);
1873 /* RX_PKEY_MODE:0 for no security; RX_KEY_TAB:0 for shared key table; BSS_IDX:0 */
1874 RTUSBWriteMACRegister
1875 (pAd, offset, 0);
1876 }
1877 }
1878
1879 AsicUpdateRxWCIDTable(pAd, pEntry->Aid,
1880 pEntry->Addr);
1881 DBGPRINT(RT_DEBUG_TRACE,
1882 ("UpdateRxWCIDTable(): Aid=%d, Addr=%02x:%02x:%02x:%02x:%02x:%02x!\n",
1883 pEntry->Aid, pEntry->Addr[0],
1884 pEntry->Addr[1],
1885 pEntry->Addr[2],
1886 pEntry->Addr[3],
1887 pEntry->Addr[4],
1888 pEntry->Addr[5]));
1889 }
1890 break;
1891
1892 /* add by johnli, fix "in_interrupt" error when call "MacTableDeleteEntry" in Rx tasklet */
1893 case CMDTHREAD_UPDATE_PROTECT:
1894 {
1895 AsicUpdateProtect(pAd, 0,
1896 (ALLN_SETPROTECT),
1897 TRUE, 0);
1898 }
1899 break;
1900 /* end johnli */
1901
1902 case OID_802_11_ADD_WEP:
1903 {
1904 u32 i;
1905 u32 KeyIdx;
1906 struct rt_ndis_802_11_wep *pWepKey;
1907
1908 DBGPRINT(RT_DEBUG_TRACE,
1909 ("CmdThread::OID_802_11_ADD_WEP \n"));
1910
1911 pWepKey = (struct rt_ndis_802_11_wep *)pData;
1912 KeyIdx = pWepKey->KeyIndex & 0x0fffffff;
1913
1914 /* it is a shared key */
1915 if ((KeyIdx >= 4)
1916 || ((pWepKey->KeyLength != 5)
1917 && (pWepKey->KeyLength !=
1918 13))) {
1919 NdisStatus =
1920 NDIS_STATUS_INVALID_DATA;
1921 DBGPRINT(RT_DEBUG_ERROR,
1922 ("CmdThread::OID_802_11_ADD_WEP, INVALID_DATA!!\n"));
1923 } else {
1924 u8 CipherAlg;
1925 pAd->SharedKey[BSS0][KeyIdx].
1926 KeyLen =
1927 (u8)pWepKey->KeyLength;
1928 NdisMoveMemory(pAd->
1929 SharedKey[BSS0]
1930 [KeyIdx].Key,
1931 &pWepKey->
1932 KeyMaterial,
1933 pWepKey->
1934 KeyLength);
1935 CipherAlg =
1936 (pAd->
1937 SharedKey[BSS0][KeyIdx].
1938 KeyLen ==
1939 5) ? CIPHER_WEP64 :
1940 CIPHER_WEP128;
1941
1942 /* */
1943 /* Change the WEP cipher to CKIP cipher if CKIP KP on. */
1944 /* Funk UI or Meetinghouse UI will add ckip key from this path. */
1945 /* */
1946
1947 if (pAd->OpMode == OPMODE_STA) {
1948 pAd->MacTab.
1949 Content[BSSID_WCID].
1950 PairwiseKey.
1951 CipherAlg =
1952 pAd->
1953 SharedKey[BSS0]
1954 [KeyIdx].CipherAlg;
1955 pAd->MacTab.
1956 Content[BSSID_WCID].
1957 PairwiseKey.KeyLen =
1958 pAd->
1959 SharedKey[BSS0]
1960 [KeyIdx].KeyLen;
1961 }
1962 pAd->SharedKey[BSS0][KeyIdx].
1963 CipherAlg = CipherAlg;
1964 if (pWepKey->
1965 KeyIndex & 0x80000000) {
1966 /* Default key for tx (shared key) */
1967 u8 IVEIV[8];
1968 u32 WCIDAttri, Value;
1969 u16 offset, offset2;
1970 NdisZeroMemory(IVEIV,
1971 8);
1972 pAd->StaCfg.
1973 DefaultKeyId =
1974 (u8)KeyIdx;
1975 /* Add BSSID to WCTable. because this is Tx wep key. */
1976 /* WCID Attribute UDF:3, BSSIdx:3, Alg:3, Keytable:1=PAIRWISE KEY, BSSIdx is 0 */
1977 WCIDAttri =
1978 (CipherAlg << 1) |
1979 SHAREDKEYTABLE;
1980
1981 offset =
1982 MAC_WCID_ATTRIBUTE_BASE
1983 +
1984 (BSSID_WCID *
1985 HW_WCID_ATTRI_SIZE);
1986 RTUSBWriteMACRegister
1987 (pAd, offset,
1988 WCIDAttri);
1989 /* 1. IV/EIV */
1990 /* Specify key index to find shared key. */
1991 IVEIV[3] = (u8)(KeyIdx << 6); /*WEP Eiv bit off. groupkey index is not 0 */
1992 offset =
1993 PAIRWISE_IVEIV_TABLE_BASE
1994 +
1995 (BSS0Mcast_WCID *
1996 HW_IVEIV_ENTRY_SIZE);
1997 offset2 =
1998 PAIRWISE_IVEIV_TABLE_BASE
1999 +
2000 (BSSID_WCID *
2001 HW_IVEIV_ENTRY_SIZE);
2002 for (i = 0; i < 8;) {
2003 Value =
2004 IVEIV[i];
2005 Value +=
2006 (IVEIV
2007 [i +
2008 1] << 8);
2009 Value +=
2010 (IVEIV
2011 [i +
2012 2] << 16);
2013 Value +=
2014 (IVEIV
2015 [i +
2016 3] << 24);
2017 RTUSBWriteMACRegister
2018 (pAd,
2019 offset + i,
2020 Value);
2021 RTUSBWriteMACRegister
2022 (pAd,
2023 offset2 +
2024 i, Value);
2025 i += 4;
2026 }
2027
2028 /* 2. WCID Attribute UDF:3, BSSIdx:3, Alg:3, Keytable:use share key, BSSIdx is 0 */
2029 WCIDAttri =
2030 (pAd->
2031 SharedKey[BSS0]
2032 [KeyIdx].
2033 CipherAlg << 1) |
2034 SHAREDKEYTABLE;
2035 offset =
2036 MAC_WCID_ATTRIBUTE_BASE
2037 +
2038 (BSS0Mcast_WCID *
2039 HW_WCID_ATTRI_SIZE);
2040 DBGPRINT(RT_DEBUG_TRACE,
2041 ("BSS0Mcast_WCID : offset = %x, WCIDAttri = %x\n",
2042 offset,
2043 WCIDAttri));
2044 RTUSBWriteMACRegister
2045 (pAd, offset,
2046 WCIDAttri);
2047
2048 }
2049 AsicAddSharedKeyEntry(pAd, BSS0,
2050 (u8)
2051 KeyIdx,
2052 CipherAlg,
2053 pWepKey->
2054 KeyMaterial,
2055 NULL,
2056 NULL);
2057 DBGPRINT(RT_DEBUG_TRACE,
2058 ("CmdThread::OID_802_11_ADD_WEP (KeyIdx=%d, Len=%d-byte)\n",
2059 KeyIdx,
2060 pWepKey->KeyLength));
2061 }
2062 }
2063 break;
2064
2065 case CMDTHREAD_802_11_COUNTER_MEASURE:
2066 break;
2067
2068 case CMDTHREAD_SET_GROUP_KEY:
2069 WpaStaGroupKeySetting(pAd);
2070 break;
2071
2072 case CMDTHREAD_SET_PAIRWISE_KEY:
2073 WpaStaPairwiseKeySetting(pAd);
2074 break;
2075
2076 case CMDTHREAD_SET_PSM_BIT:
2077 {
2078 u16 *pPsm = (u16 *) pData;
2079 MlmeSetPsmBit(pAd, *pPsm);
2080 }
2081 break;
2082 case CMDTHREAD_FORCE_WAKE_UP:
2083 AsicForceWakeup(pAd, TRUE);
2084 break;
2085
2086 default:
2087 DBGPRINT(RT_DEBUG_ERROR,
2088 ("--> Control Thread !! ERROR !! Unknown(cmdqelmt->command=0x%x) !! \n",
2089 cmdqelmt->command));
2090 break;
2091 }
2092 }
2093
2094 if (cmdqelmt->CmdFromNdis == TRUE) {
2095 if (cmdqelmt->buffer != NULL)
2096 os_free_mem(pAd, cmdqelmt->buffer);
2097 os_free_mem(pAd, cmdqelmt);
2098 } else {
2099 if ((cmdqelmt->buffer != NULL)
2100 && (cmdqelmt->bufferlength != 0))
2101 os_free_mem(pAd, cmdqelmt->buffer);
2102 os_free_mem(pAd, cmdqelmt);
2103 }
2104 } /* end of while */
2105 }
2106
2107 #endif /* RTMP_MAC_USB // */
Tomato firmware and modifications.