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