?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: rt2870: remove dead RALINK_ATE code
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / rt2870 / common / rtusb_io.c
blob61528bf00cee7025de814244a70f5717efcd286f
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 BUG_ON(pObj->RTUSBCmdThr_task == NULL);
962 CHECK_PID_LEGALITY(task_pid(pObj->RTUSBCmdThr_task))
963 return (NDIS_STATUS_RESOURCES);
964
965 status = RTMPAllocateMemory((PVOID *)&cmdqelmt, sizeof(CmdQElmt));
966 if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt == NULL))
967 return (NDIS_STATUS_RESOURCES);
968
969 cmdqelmt->buffer = NULL;
970 if (pInformationBuffer != NULL)
971 {
972 status = RTMPAllocateMemory((PVOID *)&cmdqelmt->buffer, InformationBufferLength);
973 if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt->buffer == NULL))
974 {
975 kfree(cmdqelmt);
976 return (NDIS_STATUS_RESOURCES);
977 }
978 else
979 {
980 NdisMoveMemory(cmdqelmt->buffer, pInformationBuffer, InformationBufferLength);
981 cmdqelmt->bufferlength = InformationBufferLength;
982 }
983 }
984 else
985 cmdqelmt->bufferlength = 0;
986
987 cmdqelmt->command = Oid;
988 cmdqelmt->CmdFromNdis = TRUE;
989 if (SetInformation == TRUE)
990 cmdqelmt->SetOperation = TRUE;
991 else
992 cmdqelmt->SetOperation = FALSE;
993
994 NdisAcquireSpinLock(&pAd->CmdQLock);
995 if (pAd->CmdQ.CmdQState & RT2870_THREAD_CAN_DO_INSERT)
996 {
997 EnqueueCmd((&pAd->CmdQ), cmdqelmt);
998 status = NDIS_STATUS_SUCCESS;
999 }
1000 else
1001 {
1002 status = NDIS_STATUS_FAILURE;
1003 }
1004 NdisReleaseSpinLock(&pAd->CmdQLock);
1005
1006 if (status == NDIS_STATUS_FAILURE)
1007 {
1008 if (cmdqelmt->buffer)
1009 NdisFreeMemory(cmdqelmt->buffer, cmdqelmt->bufferlength, 0);
1010 NdisFreeMemory(cmdqelmt, sizeof(CmdQElmt), 0);
1011 }
1012 else
1013 RTUSBCMDUp(pAd);
1014
1015
1016 return(NDIS_STATUS_SUCCESS);
1017 }
1018
1019 /*
1020 ========================================================================
1021
1022 Routine Description:
1023
1024 Arguments:
1025
1026 Return Value:
1027
1028 IRQL =
1029
1030 Note:
1031
1032 ========================================================================
1033 */
1034 NDIS_STATUS RTUSBEnqueueInternalCmd(
1035 IN PRTMP_ADAPTER pAd,
1036 IN NDIS_OID Oid,
1037 IN PVOID pInformationBuffer,
1038 IN UINT32 InformationBufferLength)
1039 {
1040 NDIS_STATUS status;
1041 PCmdQElmt cmdqelmt = NULL;
1042
1043
1044 status = RTMPAllocateMemory((PVOID *)&cmdqelmt, sizeof(CmdQElmt));
1045 if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt == NULL))
1046 return (NDIS_STATUS_RESOURCES);
1047 NdisZeroMemory(cmdqelmt, sizeof(CmdQElmt));
1048
1049 if(InformationBufferLength > 0)
1050 {
1051 status = RTMPAllocateMemory((PVOID *)&cmdqelmt->buffer, InformationBufferLength);
1052 if ((status != NDIS_STATUS_SUCCESS) || (cmdqelmt->buffer == NULL))
1053 {
1054 NdisFreeMemory(cmdqelmt, sizeof(CmdQElmt), 0);
1055 return (NDIS_STATUS_RESOURCES);
1056 }
1057 else
1058 {
1059 NdisMoveMemory(cmdqelmt->buffer, pInformationBuffer, InformationBufferLength);
1060 cmdqelmt->bufferlength = InformationBufferLength;
1061 }
1062 }
1063 else
1064 {
1065 cmdqelmt->buffer = NULL;
1066 cmdqelmt->bufferlength = 0;
1067 }
1068
1069 cmdqelmt->command = Oid;
1070 cmdqelmt->CmdFromNdis = FALSE;
1071
1072 if (cmdqelmt != NULL)
1073 {
1074 NdisAcquireSpinLock(&pAd->CmdQLock);
1075 if (pAd->CmdQ.CmdQState & RT2870_THREAD_CAN_DO_INSERT)
1076 {
1077 EnqueueCmd((&pAd->CmdQ), cmdqelmt);
1078 status = NDIS_STATUS_SUCCESS;
1079 }
1080 else
1081 {
1082 status = NDIS_STATUS_FAILURE;
1083 }
1084 NdisReleaseSpinLock(&pAd->CmdQLock);
1085
1086 if (status == NDIS_STATUS_FAILURE)
1087 {
1088 if (cmdqelmt->buffer)
1089 NdisFreeMemory(cmdqelmt->buffer, cmdqelmt->bufferlength, 0);
1090 NdisFreeMemory(cmdqelmt, sizeof(CmdQElmt), 0);
1091 }
1092 else
1093 RTUSBCMDUp(pAd);
1094 }
1095 return(NDIS_STATUS_SUCCESS);
1096 }
1097
1098 /*
1099 ========================================================================
1100
1101 Routine Description:
1102
1103 Arguments:
1104
1105 Return Value:
1106
1107 IRQL =
1108
1109 Note:
1110
1111 ========================================================================
1112 */
1113 VOID RTUSBDequeueCmd(
1114 IN PCmdQ cmdq,
1115 OUT PCmdQElmt *pcmdqelmt)
1116 {
1117 *pcmdqelmt = cmdq->head;
1118
1119 if (*pcmdqelmt != NULL)
1120 {
1121 cmdq->head = cmdq->head->next;
1122 cmdq->size--;
1123 if (cmdq->size == 0)
1124 cmdq->tail = NULL;
1125 }
1126 }
1127
1128 /*
1129 ========================================================================
1130 usb_control_msg - Builds a control urb, sends it off and waits for completion
1131 @dev: pointer to the usb device to send the message to
1132 @pipe: endpoint "pipe" to send the message to
1133 @request: USB message request value
1134 @requesttype: USB message request type value
1135 @value: USB message value
1136 @index: USB message index value
1137 @data: pointer to the data to send
1138 @size: length in bytes of the data to send
1139 @timeout: time in jiffies to wait for the message to complete before
1140 timing out (if 0 the wait is forever)
1141 Context: !in_interrupt ()
1142
1143 This function sends a simple control message to a specified endpoint
1144 and waits for the message to complete, or timeout.
1145 If successful, it returns the number of bytes transferred, otherwise a negative error number.
1146
1147 Don't use this function from within an interrupt context, like a
1148 bottom half handler. If you need an asynchronous message, or need to send
1149 a message from within interrupt context, use usb_submit_urb()
1150 If a thread in your driver uses this call, make sure your disconnect()
1151 method can wait for it to complete. Since you don't have a handle on
1152 the URB used, you can't cancel the request.
1153
1154
1155 Routine Description:
1156
1157 Arguments:
1158
1159 Return Value:
1160
1161 Note:
1162
1163 ========================================================================
1164 */
1165 NTSTATUS RTUSB_VendorRequest(
1166 IN PRTMP_ADAPTER pAd,
1167 IN UINT32 TransferFlags,
1168 IN UCHAR RequestType,
1169 IN UCHAR Request,
1170 IN USHORT Value,
1171 IN USHORT Index,
1172 IN PVOID TransferBuffer,
1173 IN UINT32 TransferBufferLength)
1174 {
1175 int ret;
1176 POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
1177
1178 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
1179 {
1180 DBGPRINT(RT_DEBUG_ERROR, ("device disconnected\n"));
1181 return -1;
1182 }
1183 else if (in_interrupt())
1184 {
1185 DBGPRINT(RT_DEBUG_ERROR, ("in_interrupt, RTUSB_VendorRequest Request%02x Value%04x Offset%04x\n",Request,Value,Index));
1186
1187 return -1;
1188 }
1189 else
1190 {
1191 #define MAX_RETRY_COUNT 10
1192
1193 int retryCount = 0;
1194 void *tmpBuf = TransferBuffer;
1195
1196 // Acquire Control token
1197 #ifdef INF_AMAZON_SE
1198 //Semaphore fix INF_AMAZON_SE hang
1199 //pAd->UsbVendorReqBuf is the swap for DEVICE_VENDOR_REQUEST_IN to fix dma bug.
1200 ret = down_interruptible(&(pAd->UsbVendorReq_semaphore));
1201 if (pAd->UsbVendorReqBuf)
1202 {
1203 ASSERT(TransferBufferLength <MAX_PARAM_BUFFER_SIZE);
1204
1205 tmpBuf = (void *)pAd->UsbVendorReqBuf;
1206 NdisZeroMemory(pAd->UsbVendorReqBuf, TransferBufferLength);
1207
1208 if (RequestType == DEVICE_VENDOR_REQUEST_OUT)
1209 NdisMoveMemory(tmpBuf, TransferBuffer, TransferBufferLength);
1210 }
1211 #endif // INF_AMAZON_SE //
1212 do {
1213 if( RequestType == DEVICE_VENDOR_REQUEST_OUT)
1214 ret=usb_control_msg(pObj->pUsb_Dev, usb_sndctrlpipe( pObj->pUsb_Dev, 0 ), Request, RequestType, Value,Index, tmpBuf, TransferBufferLength, CONTROL_TIMEOUT_JIFFIES);
1215 else if(RequestType == DEVICE_VENDOR_REQUEST_IN)
1216 ret=usb_control_msg(pObj->pUsb_Dev, usb_rcvctrlpipe( pObj->pUsb_Dev, 0 ), Request, RequestType, Value,Index, tmpBuf, TransferBufferLength, CONTROL_TIMEOUT_JIFFIES);
1217 else
1218 {
1219 DBGPRINT(RT_DEBUG_ERROR, ("vendor request direction is failed\n"));
1220 ret = -1;
1221 }
1222
1223 retryCount++;
1224 if (ret < 0) {
1225 printk("#\n");
1226 RTMPusecDelay(5000);
1227 }
1228 } while((ret < 0) && (retryCount < MAX_RETRY_COUNT));
1229
1230 #ifdef INF_AMAZON_SE
1231 if ((pAd->UsbVendorReqBuf) && (RequestType == DEVICE_VENDOR_REQUEST_IN))
1232 NdisMoveMemory(TransferBuffer, tmpBuf, TransferBufferLength);
1233 up(&(pAd->UsbVendorReq_semaphore));
1234 #endif // INF_AMAZON_SE //
1235
1236 if (ret < 0) {
1237 // DBGPRINT(RT_DEBUG_ERROR, ("USBVendorRequest failed ret=%d \n",ret));
1238 DBGPRINT(RT_DEBUG_ERROR, ("RTUSB_VendorRequest failed(%d),TxFlags=0x%x, ReqType=%s, Req=0x%x, Index=0x%x\n",
1239 ret, TransferFlags, (RequestType == DEVICE_VENDOR_REQUEST_OUT ? "OUT" : "IN"), Request, Index));
1240 if (Request == 0x2)
1241 DBGPRINT(RT_DEBUG_ERROR, ("\tRequest Value=0x%04x!\n", Value));
1242
1243 if ((TransferBuffer!= NULL) && (TransferBufferLength > 0))
1244 hex_dump("Failed TransferBuffer value", TransferBuffer, TransferBufferLength);
1245 }
1246
1247 #if 0
1248 // retry
1249 if (ret < 0) {
1250 int temp_i=0;
1251 DBGPRINT(RT_DEBUG_ERROR, ("USBVendorRequest failed ret=%d, \n",ret));
1252 ret = 0;
1253 do
1254 {
1255 if( RequestType == DEVICE_VENDOR_REQUEST_OUT)
1256 ret=usb_control_msg(pObj->pUsb_Dev, usb_sndctrlpipe( pObj->pUsb_Dev, 0 ), Request, RequestType, Value,Index, TransferBuffer, TransferBufferLength, CONTROL_TIMEOUT_JIFFIES);
1257 else if(RequestType == DEVICE_VENDOR_REQUEST_IN)
1258 ret=usb_control_msg(pObj->pUsb_Dev, usb_rcvctrlpipe( pObj->pUsb_Dev, 0 ), Request, RequestType, Value,Index, TransferBuffer, TransferBufferLength, CONTROL_TIMEOUT_JIFFIES);
1259 temp_i++;
1260 } while( (ret < 0) && (temp_i <= 1) );
1261
1262 if( ret >= 0)
1263 return ret;
1264
1265 }
1266 #endif
1267
1268 }
1269 return ret;
1270 }
1271
1272 /*
1273 ========================================================================
1274
1275 Routine Description:
1276 Creates an IRP to submite an IOCTL_INTERNAL_USB_RESET_PORT
1277 synchronously. Callers of this function must be running at
1278 PASSIVE LEVEL.
1279
1280 Arguments:
1281
1282 Return Value:
1283
1284 Note:
1285
1286 ========================================================================
1287 */
1288 NTSTATUS RTUSB_ResetDevice(
1289 IN PRTMP_ADAPTER pAd)
1290 {
1291 NTSTATUS Status = TRUE;
1292
1293 DBGPRINT_RAW(RT_DEBUG_TRACE, ("--->USB_ResetDevice\n"));
1294 //RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS);
1295 return Status;
1296 }
1297
1298 VOID CMDHandler(
1299 IN PRTMP_ADAPTER pAd)
1300 {
1301 PCmdQElmt cmdqelmt;
1302 PUCHAR pData;
1303 NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
1304 // ULONG Now = 0;
1305 NTSTATUS ntStatus;
1306 // unsigned long IrqFlags;
1307
1308 while (pAd->CmdQ.size > 0)
1309 {
1310 NdisStatus = NDIS_STATUS_SUCCESS;
1311
1312 NdisAcquireSpinLock(&pAd->CmdQLock);
1313 RTUSBDequeueCmd(&pAd->CmdQ, &cmdqelmt);
1314 NdisReleaseSpinLock(&pAd->CmdQLock);
1315
1316 if (cmdqelmt == NULL)
1317 break;
1318
1319 pData = cmdqelmt->buffer;
1320
1321 if(!(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST) || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)))
1322 {
1323 switch (cmdqelmt->command)
1324 {
1325 case CMDTHREAD_CHECK_GPIO:
1326 {
1327 #ifdef CONFIG_STA_SUPPORT
1328 UINT32 data;
1329 #endif // CONFIG_STA_SUPPORT //
1330
1331 #ifdef CONFIG_STA_SUPPORT
1332
1333
1334 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1335 {
1336 // Read GPIO pin2 as Hardware controlled radio state
1337
1338 RTUSBReadMACRegister( pAd, GPIO_CTRL_CFG, &data);
1339
1340 if (data & 0x04)
1341 {
1342 pAd->StaCfg.bHwRadio = TRUE;
1343 }
1344 else
1345 {
1346 pAd->StaCfg.bHwRadio = FALSE;
1347 }
1348
1349 if(pAd->StaCfg.bRadio != (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio))
1350 {
1351 pAd->StaCfg.bRadio = (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio);
1352 if(pAd->StaCfg.bRadio == TRUE)
1353 {
1354 DBGPRINT_RAW(RT_DEBUG_ERROR, ("!!! Radio On !!!\n"));
1355
1356 MlmeRadioOn(pAd);
1357 // Update extra information
1358 pAd->ExtraInfo = EXTRA_INFO_CLEAR;
1359 }
1360 else
1361 {
1362 DBGPRINT_RAW(RT_DEBUG_ERROR, ("!!! Radio Off !!!\n"));
1363
1364 MlmeRadioOff(pAd);
1365 // Update extra information
1366 pAd->ExtraInfo = HW_RADIO_OFF;
1367 }
1368 }
1369 }
1370 #endif // CONFIG_STA_SUPPORT //
1371 }
1372 break;
1373
1374 #ifdef CONFIG_STA_SUPPORT
1375 case CMDTHREAD_QKERIODIC_EXECUT:
1376 {
1377 StaQuickResponeForRateUpExec(NULL, pAd, NULL, NULL);
1378 }
1379 break;
1380 #endif // CONFIG_STA_SUPPORT //
1381
1382 case CMDTHREAD_RESET_BULK_OUT:
1383 {
1384 UINT32 MACValue;
1385 UCHAR Index;
1386 int ret=0;
1387 PHT_TX_CONTEXT pHTTXContext;
1388 // RTMP_TX_RING *pTxRing;
1389 unsigned long IrqFlags;
1390
1391 DBGPRINT_RAW(RT_DEBUG_TRACE, ("CmdThread : CMDTHREAD_RESET_BULK_OUT(ResetPipeid=0x%0x)===>\n", pAd->bulkResetPipeid));
1392 // All transfers must be aborted or cancelled before attempting to reset the pipe.
1393 //RTUSBCancelPendingBulkOutIRP(pAd);
1394 // Wait 10ms to let previous packet that are already in HW FIFO to clear. by MAXLEE 12-25-2007
1395 Index = 0;
1396 do
1397 {
1398 RTUSBReadMACRegister(pAd, TXRXQ_PCNT, &MACValue);
1399 if ((MACValue & 0xf00000/*0x800000*/) == 0)
1400 break;
1401 Index++;
1402 RTMPusecDelay(10000);
1403 }while(Index < 100);
1404 MACValue = 0;
1405 RTUSBReadMACRegister(pAd, USB_DMA_CFG, &MACValue);
1406 // To prevent Read Register error, we 2nd check the validity.
1407 if ((MACValue & 0xc00000) == 0)
1408 RTUSBReadMACRegister(pAd, USB_DMA_CFG, &MACValue);
1409 // To prevent Read Register error, we 3rd check the validity.
1410 if ((MACValue & 0xc00000) == 0)
1411 RTUSBReadMACRegister(pAd, USB_DMA_CFG, &MACValue);
1412 MACValue |= 0x80000;
1413 RTUSBWriteMACRegister(pAd, USB_DMA_CFG, MACValue);
1414
1415 // Wait 1ms to prevent next URB to bulkout before HW reset. by MAXLEE 12-25-2007
1416 RTMPusecDelay(1000);
1417
1418 MACValue &= (~0x80000);
1419 RTUSBWriteMACRegister(pAd, USB_DMA_CFG, MACValue);
1420 DBGPRINT_RAW(RT_DEBUG_TRACE, ("\tSet 0x2a0 bit19. Clear USB DMA TX path\n"));
1421
1422 // Wait 5ms to prevent next URB to bulkout before HW reset. by MAXLEE 12-25-2007
1423 //RTMPusecDelay(5000);
1424
1425 if ((pAd->bulkResetPipeid & BULKOUT_MGMT_RESET_FLAG) == BULKOUT_MGMT_RESET_FLAG)
1426 {
1427 RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1428 if (pAd->MgmtRing.TxSwFreeIdx < MGMT_RING_SIZE /* pMLMEContext->bWaitingBulkOut == TRUE */)
1429 {
1430 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
1431 }
1432 RTUSBKickBulkOut(pAd);
1433
1434 DBGPRINT_RAW(RT_DEBUG_TRACE, ("\tTX MGMT RECOVER Done!\n"));
1435 }
1436 else
1437 {
1438 pHTTXContext = &(pAd->TxContext[pAd->bulkResetPipeid]);
1439 //NdisAcquireSpinLock(&pAd->BulkOutLock[pAd->bulkResetPipeid]);
1440 RTMP_INT_LOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1441 if ( pAd->BulkOutPending[pAd->bulkResetPipeid] == FALSE)
1442 {
1443 pAd->BulkOutPending[pAd->bulkResetPipeid] = TRUE;
1444 pHTTXContext->IRPPending = TRUE;
1445 pAd->watchDogTxPendingCnt[pAd->bulkResetPipeid] = 1;
1446
1447 // no matter what, clean the flag
1448 RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1449
1450 //NdisReleaseSpinLock(&pAd->BulkOutLock[pAd->bulkResetPipeid]);
1451 RTMP_INT_UNLOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1452 /*-----------------------------------------------------------------------------------------------*/
1453 /*-----------------------------------------------------------------------------------------------*/
1454 {
1455 RTUSBInitHTTxDesc(pAd, pHTTXContext, pAd->bulkResetPipeid, pHTTXContext->BulkOutSize, (usb_complete_t)RTUSBBulkOutDataPacketComplete);
1456
1457 if((ret = RTUSB_SUBMIT_URB(pHTTXContext->pUrb))!=0)
1458 {
1459 RTMP_INT_LOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1460 pAd->BulkOutPending[pAd->bulkResetPipeid] = FALSE;
1461 pHTTXContext->IRPPending = FALSE;
1462 pAd->watchDogTxPendingCnt[pAd->bulkResetPipeid] = 0;
1463 RTMP_INT_UNLOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1464
1465 DBGPRINT(RT_DEBUG_ERROR, ("CmdThread : CMDTHREAD_RESET_BULK_OUT: Submit Tx URB failed %d\n", ret));
1466 }
1467 else
1468 {
1469 RTMP_IRQ_LOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1470 DBGPRINT_RAW(RT_DEBUG_TRACE,("\tCMDTHREAD_RESET_BULK_OUT: TxContext[%d]:CWPos=%ld, NBPos=%ld, ENBPos=%ld, bCopy=%d, pending=%d!\n",
1471 pAd->bulkResetPipeid, pHTTXContext->CurWritePosition, pHTTXContext->NextBulkOutPosition,
1472 pHTTXContext->ENextBulkOutPosition, pHTTXContext->bCopySavePad, pAd->BulkOutPending[pAd->bulkResetPipeid]));
1473 DBGPRINT_RAW(RT_DEBUG_TRACE,("\t\tBulkOut Req=0x%lx, Complete=0x%lx, Other=0x%lx\n",
1474 pAd->BulkOutReq, pAd->BulkOutComplete, pAd->BulkOutCompleteOther));
1475 RTMP_IRQ_UNLOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1476 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));
1477
1478 }
1479 }
1480 }
1481 else
1482 {
1483 //NdisReleaseSpinLock(&pAd->BulkOutLock[pAd->bulkResetPipeid]);
1484 //RTMP_INT_UNLOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1485
1486 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));
1487 if (pAd->bulkResetPipeid == 0)
1488 {
1489 UCHAR pendingContext = 0;
1490 PHT_TX_CONTEXT pHTTXContext = (PHT_TX_CONTEXT)(&pAd->TxContext[pAd->bulkResetPipeid ]);
1491 PTX_CONTEXT pMLMEContext = (PTX_CONTEXT)(pAd->MgmtRing.Cell[pAd->MgmtRing.TxDmaIdx].AllocVa);
1492 PTX_CONTEXT pNULLContext = (PTX_CONTEXT)(&pAd->PsPollContext);
1493 PTX_CONTEXT pPsPollContext = (PTX_CONTEXT)(&pAd->NullContext);
1494
1495 if (pHTTXContext->IRPPending)
1496 pendingContext |= 1;
1497 else if (pMLMEContext->IRPPending)
1498 pendingContext |= 2;
1499 else if (pNULLContext->IRPPending)
1500 pendingContext |= 4;
1501 else if (pPsPollContext->IRPPending)
1502 pendingContext |= 8;
1503 else
1504 pendingContext = 0;
1505
1506 DBGPRINT_RAW(RT_DEBUG_ERROR, ("\tTX Occupied by %d!\n", pendingContext));
1507 }
1508
1509 // no matter what, clean the flag
1510 RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
1511
1512 RTMP_INT_UNLOCK(&pAd->BulkOutLock[pAd->bulkResetPipeid], IrqFlags);
1513
1514 RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << pAd->bulkResetPipeid));
1515 }
1516
1517 RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
1518 //RTUSBKickBulkOut(pAd);
1519 }
1520
1521 }
1522 /*
1523 // Don't cancel BULKIN.
1524 while ((atomic_read(&pAd->PendingRx) > 0) &&
1525 (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
1526 {
1527 if (atomic_read(&pAd->PendingRx) > 0)
1528 {
1529 DBGPRINT_RAW(RT_DEBUG_ERROR, ("BulkIn IRP Pending!!cancel it!\n"));
1530 RTUSBCancelPendingBulkInIRP(pAd);
1531 }
1532 RTMPusecDelay(100000);
1533 }
1534
1535 if ((atomic_read(&pAd->PendingRx) == 0) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)))
1536 {
1537 UCHAR i;
1538 RTUSBRxPacket(pAd);
1539 pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
1540 pAd->NextRxBulkInIndex = 0; // Rx Bulk pointer
1541 for (i = 0; i < (RX_RING_SIZE); i++)
1542 {
1543 PRX_CONTEXT pRxContext = &(pAd->RxContext[i]);
1544
1545 pRxContext->pAd = pAd;
1546 pRxContext->InUse = FALSE;
1547 pRxContext->IRPPending = FALSE;
1548 pRxContext->Readable = FALSE;
1549 pRxContext->ReorderInUse = FALSE;
1550
1551 }
1552 RTUSBBulkReceive(pAd);
1553 DBGPRINT_RAW(RT_DEBUG_ERROR, ("RTUSBBulkReceive\n"));
1554 }*/
1555 DBGPRINT_RAW(RT_DEBUG_TRACE, ("CmdThread : CMDTHREAD_RESET_BULK_OUT<===\n"));
1556 break;
1557
1558 case CMDTHREAD_RESET_BULK_IN:
1559 DBGPRINT_RAW(RT_DEBUG_TRACE, ("CmdThread : CMDTHREAD_RESET_BULK_IN === >\n"));
1560
1561 // All transfers must be aborted or cancelled before attempting to reset the pipe.
1562 {
1563 UINT32 MACValue;
1564 /*-----------------------------------------------------------------------------------------------*/
1565 /*-----------------------------------------------------------------------------------------------*/
1566 {
1567 //while ((atomic_read(&pAd->PendingRx) > 0) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
1568 if((pAd->PendingRx > 0) && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
1569 {
1570 DBGPRINT_RAW(RT_DEBUG_ERROR, ("BulkIn IRP Pending!!!\n"));
1571 RTUSBCancelPendingBulkInIRP(pAd);
1572 RTMPusecDelay(100000);
1573 pAd->PendingRx = 0;
1574 }
1575 }
1576
1577 // Wait 10ms before reading register.
1578 RTMPusecDelay(10000);
1579 ntStatus = RTUSBReadMACRegister(pAd, MAC_CSR0, &MACValue);
1580
1581 if ((NT_SUCCESS(ntStatus) == TRUE) &&
1582 (!(RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS | fRTMP_ADAPTER_RADIO_OFF |
1583 fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST)))))
1584 {
1585 UCHAR i;
1586
1587 if (RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_RESET_IN_PROGRESS | fRTMP_ADAPTER_RADIO_OFF |
1588 fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST)))
1589 break;
1590 pAd->NextRxBulkInPosition = pAd->RxContext[pAd->NextRxBulkInIndex].BulkInOffset;
1591 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",
1592 pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex, pAd->NextRxBulkInPosition, pAd->BulkInReq, pAd->BulkInComplete, pAd->BulkInCompleteFail));
1593 for (i = 0; i < RX_RING_SIZE; i++)
1594 {
1595 DBGPRINT(RT_DEBUG_TRACE, ("\tRxContext[%d]: IRPPending=%d, InUse=%d, Readable=%d!\n"
1596 , i, pAd->RxContext[i].IRPPending, pAd->RxContext[i].InUse, pAd->RxContext[i].Readable));
1597 }
1598 /*
1599
1600 DBGPRINT_RAW(RT_DEBUG_ERROR, ("==========================================\n"));
1601
1602 pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
1603 pAd->NextRxBulkInIndex = 0; // Rx Bulk pointer
1604 for (i = 0; i < (RX_RING_SIZE); i++)
1605 {
1606 PRX_CONTEXT pRxContext = &(pAd->RxContext[i]);
1607
1608 pRxContext->pAd = pAd;
1609 pRxContext->InUse = FALSE;
1610 pRxContext->IRPPending = FALSE;
1611 pRxContext->Readable = FALSE;
1612 pRxContext->ReorderInUse = FALSE;
1613
1614 }*/
1615 RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_BULKIN_RESET);
1616 for (i = 0; i < pAd->CommonCfg.NumOfBulkInIRP; i++)
1617 {
1618 //RTUSBBulkReceive(pAd);
1619 PRX_CONTEXT pRxContext;
1620 PURB pUrb;
1621 int ret = 0;
1622 unsigned long IrqFlags;
1623
1624
1625 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1626 pRxContext = &(pAd->RxContext[pAd->NextRxBulkInIndex]);
1627 if ((pAd->PendingRx > 0) || (pRxContext->Readable == TRUE) || (pRxContext->InUse == TRUE))
1628 {
1629 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1630 break;
1631 }
1632 pRxContext->InUse = TRUE;
1633 pRxContext->IRPPending = TRUE;
1634 pAd->PendingRx++;
1635 pAd->BulkInReq++;
1636 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1637
1638 // Init Rx context descriptor
1639 RTUSBInitRxDesc(pAd, pRxContext);
1640 pUrb = pRxContext->pUrb;
1641 if ((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
1642 { // fail
1643
1644 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1645 pRxContext->InUse = FALSE;
1646 pRxContext->IRPPending = FALSE;
1647 pAd->PendingRx--;
1648 pAd->BulkInReq--;
1649 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1650 DBGPRINT(RT_DEBUG_ERROR, ("CMDTHREAD_RESET_BULK_IN: Submit Rx URB failed(%d), status=%d\n", ret, pUrb->status));
1651 }
1652 else
1653 { // success
1654 #if 0
1655 RTMP_IRQ_LOCK(&pAd->BulkInLock, IrqFlags);
1656 pRxContext->IRPPending = TRUE;
1657 //NdisInterlockedIncrement(&pAd->PendingRx);
1658 pAd->PendingRx++;
1659 RTMP_IRQ_UNLOCK(&pAd->BulkInLock, IrqFlags);
1660 pAd->BulkInReq++;
1661 #endif
1662 //printk("BIDone, Pend=%d,BIIdx=%d,BIRIdx=%d!\n", pAd->PendingRx, pAd->NextRxBulkInIndex, pAd->NextRxBulkInReadIndex);
1663 DBGPRINT_RAW(RT_DEBUG_TRACE, ("CMDTHREAD_RESET_BULK_IN: Submit Rx URB Done, status=%d!\n", pUrb->status));
1664 ASSERT((pRxContext->InUse == pRxContext->IRPPending));
1665 }
1666 }
1667
1668 }
1669 else
1670 {
1671 // Card must be removed
1672 if (NT_SUCCESS(ntStatus) != TRUE)
1673 {
1674 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST);
1675 DBGPRINT_RAW(RT_DEBUG_ERROR, ("CMDTHREAD_RESET_BULK_IN: Read Register Failed!Card must be removed!!\n\n"));
1676 }
1677 else
1678 {
1679 DBGPRINT_RAW(RT_DEBUG_ERROR, ("CMDTHREAD_RESET_BULK_IN: Cannot do bulk in because flags(0x%lx) on !\n", pAd->Flags));
1680 }
1681 }
1682 }
1683 DBGPRINT_RAW(RT_DEBUG_TRACE, ("CmdThread : CMDTHREAD_RESET_BULK_IN <===\n"));
1684 break;
1685
1686 case CMDTHREAD_SET_ASIC_WCID:
1687 {
1688 RT_SET_ASIC_WCID SetAsicWcid;
1689 USHORT offset;
1690 UINT32 MACValue, MACRValue = 0;
1691 SetAsicWcid = *((PRT_SET_ASIC_WCID)(pData));
1692
1693 if (SetAsicWcid.WCID >= MAX_LEN_OF_MAC_TABLE)
1694 return;
1695
1696 offset = MAC_WCID_BASE + ((UCHAR)SetAsicWcid.WCID)*HW_WCID_ENTRY_SIZE;
1697
1698 DBGPRINT_RAW(RT_DEBUG_TRACE, ("CmdThread : CMDTHREAD_SET_ASIC_WCID : WCID = %ld, SetTid = %lx, DeleteTid = %lx.\n", SetAsicWcid.WCID, SetAsicWcid.SetTid, SetAsicWcid.DeleteTid));
1699 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]);
1700 DBGPRINT_RAW(RT_DEBUG_TRACE, ("1-MACValue= %x,\n", MACValue));
1701 RTUSBWriteMACRegister(pAd, offset, MACValue);
1702 // Read bitmask
1703 RTUSBReadMACRegister(pAd, offset+4, &MACRValue);
1704 if ( SetAsicWcid.DeleteTid != 0xffffffff)
1705 MACRValue &= (~SetAsicWcid.DeleteTid);
1706 if (SetAsicWcid.SetTid != 0xffffffff)
1707 MACRValue |= (SetAsicWcid.SetTid);
1708 MACRValue &= 0xffff0000;
1709
1710 MACValue = (pAd->MacTab.Content[SetAsicWcid.WCID].Addr[5]<<8)+pAd->MacTab.Content[SetAsicWcid.WCID].Addr[4];
1711 MACValue |= MACRValue;
1712 RTUSBWriteMACRegister(pAd, offset+4, MACValue);
1713
1714 DBGPRINT_RAW(RT_DEBUG_TRACE, ("2-MACValue= %x,\n", MACValue));
1715 }
1716 break;
1717
1718 case CMDTHREAD_SET_ASIC_WCID_CIPHER:
1719 {
1720 #ifdef CONFIG_STA_SUPPORT
1721 RT_SET_ASIC_WCID_ATTRI SetAsicWcidAttri;
1722 USHORT offset;
1723 UINT32 MACRValue = 0;
1724 SHAREDKEY_MODE_STRUC csr1;
1725 SetAsicWcidAttri = *((PRT_SET_ASIC_WCID_ATTRI)(pData));
1726
1727 if (SetAsicWcidAttri.WCID >= MAX_LEN_OF_MAC_TABLE)
1728 return;
1729
1730 offset = MAC_WCID_ATTRIBUTE_BASE + ((UCHAR)SetAsicWcidAttri.WCID)*HW_WCID_ATTRI_SIZE;
1731
1732 DBGPRINT_RAW(RT_DEBUG_TRACE, ("Cmd : CMDTHREAD_SET_ASIC_WCID_CIPHER : WCID = %ld, Cipher = %lx.\n", SetAsicWcidAttri.WCID, SetAsicWcidAttri.Cipher));
1733 // Read bitmask
1734 RTUSBReadMACRegister(pAd, offset, &MACRValue);
1735 MACRValue = 0;
1736 MACRValue |= (((UCHAR)SetAsicWcidAttri.Cipher) << 1);
1737
1738 RTUSBWriteMACRegister(pAd, offset, MACRValue);
1739 DBGPRINT_RAW(RT_DEBUG_TRACE, ("2-offset = %x , MACValue= %x,\n", offset, MACRValue));
1740
1741 offset = PAIRWISE_IVEIV_TABLE_BASE + ((UCHAR)SetAsicWcidAttri.WCID)*HW_IVEIV_ENTRY_SIZE;
1742 MACRValue = 0;
1743 if ( (SetAsicWcidAttri.Cipher <= CIPHER_WEP128))
1744 MACRValue |= ( pAd->StaCfg.DefaultKeyId << 30);
1745 else
1746 MACRValue |= (0x20000000);
1747 RTUSBWriteMACRegister(pAd, offset, MACRValue);
1748 DBGPRINT_RAW(RT_DEBUG_TRACE, ("2-offset = %x , MACValue= %x,\n", offset, MACRValue));
1749
1750 //
1751 // Update cipher algorithm. WSTA always use BSS0
1752 //
1753 // for adhoc mode only ,because wep status slow than add key, when use zero config
1754 if (pAd->StaCfg.BssType == BSS_ADHOC )
1755 {
1756 offset = MAC_WCID_ATTRIBUTE_BASE;
1757
1758 RTUSBReadMACRegister(pAd, offset, &MACRValue);
1759 MACRValue &= (~0xe);
1760 MACRValue |= (((UCHAR)SetAsicWcidAttri.Cipher) << 1);
1761
1762 RTUSBWriteMACRegister(pAd, offset, MACRValue);
1763
1764 //Update group key cipher,,because wep status slow than add key, when use zero config
1765 RTUSBReadMACRegister(pAd, SHARED_KEY_MODE_BASE+4*(0/2), &csr1.word);
1766
1767 csr1.field.Bss0Key0CipherAlg = SetAsicWcidAttri.Cipher;
1768 csr1.field.Bss0Key1CipherAlg = SetAsicWcidAttri.Cipher;
1769
1770 RTUSBWriteMACRegister(pAd, SHARED_KEY_MODE_BASE+4*(0/2), csr1.word);
1771 }
1772 #endif // CONFIG_STA_SUPPORT //
1773 }
1774 break;
1775
1776 #ifdef CONFIG_STA_SUPPORT
1777 #ifdef QOS_DLS_SUPPORT
1778 // avoid in interrupt when write key
1779 case RT_CMD_SET_KEY_TABLE: //General call for AsicAddPairwiseKeyEntry()
1780 {
1781 RT_ADD_PAIRWISE_KEY_ENTRY KeyInfo;
1782 KeyInfo = *((PRT_ADD_PAIRWISE_KEY_ENTRY)(pData));
1783 AsicAddPairwiseKeyEntry(pAd,
1784 KeyInfo.MacAddr,
1785 (UCHAR)KeyInfo.MacTabMatchWCID,
1786 &KeyInfo.CipherKey);
1787 }
1788 break;
1789
1790 case RT_CMD_SET_RX_WCID_TABLE: //General call for RTMPAddWcidAttributeEntry()
1791 {
1792 PMAC_TABLE_ENTRY pEntry ;
1793 pEntry = (PMAC_TABLE_ENTRY)(pData);
1794 RTMPAddWcidAttributeEntry(pAd,
1795 BSS0,
1796 0,
1797 pEntry->PairwiseKey.CipherAlg,
1798 pEntry);
1799 }
1800 break;
1801 #endif // QOS_DLS_SUPPORT //
1802 #endif // CONFIG_STA_SUPPORT //
1803
1804 case CMDTHREAD_SET_CLIENT_MAC_ENTRY:
1805 {
1806 MAC_TABLE_ENTRY *pEntry;
1807 pEntry = (MAC_TABLE_ENTRY *)pData;
1808
1809
1810 #ifdef CONFIG_STA_SUPPORT
1811 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1812 {
1813 AsicRemovePairwiseKeyEntry(pAd, pEntry->apidx, (UCHAR)pEntry->Aid);
1814 if ((pEntry->AuthMode <= Ndis802_11AuthModeAutoSwitch) && (pEntry->WepStatus == Ndis802_11Encryption1Enabled))
1815 {
1816 UINT32 uIV = 0;
1817 PUCHAR ptr;
1818
1819 ptr = (PUCHAR) &uIV;
1820 *(ptr + 3) = (pAd->StaCfg.DefaultKeyId << 6);
1821 AsicUpdateWCIDIVEIV(pAd, pEntry->Aid, uIV, 0);
1822 AsicUpdateWCIDAttribute(pAd, pEntry->Aid, BSS0, pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg, FALSE);
1823 }
1824 else if (pEntry->AuthMode == Ndis802_11AuthModeWPANone)
1825 {
1826 UINT32 uIV = 0;
1827 PUCHAR ptr;
1828
1829 ptr = (PUCHAR) &uIV;
1830 *(ptr + 3) = (pAd->StaCfg.DefaultKeyId << 6);
1831 AsicUpdateWCIDIVEIV(pAd, pEntry->Aid, uIV, 0);
1832 AsicUpdateWCIDAttribute(pAd, pEntry->Aid, BSS0, pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg, FALSE);
1833 }
1834 else
1835 {
1836 //
1837 // Other case, disable engine.
1838 // Don't worry WPA key, we will add WPA Key after 4-Way handshaking.
1839 //
1840 USHORT offset;
1841 offset = MAC_WCID_ATTRIBUTE_BASE + (pEntry->Aid * HW_WCID_ATTRI_SIZE);
1842 // RX_PKEY_MODE:0 for no security; RX_KEY_TAB:0 for shared key table; BSS_IDX:0
1843 RTUSBWriteMACRegister(pAd, offset, 0);
1844 }
1845 }
1846 #endif // CONFIG_STA_SUPPORT //
1847
1848 AsicUpdateRxWCIDTable(pAd, pEntry->Aid, pEntry->Addr);
1849 printk("UpdateRxWCIDTable(): Aid=%d, Addr=%02x:%02x:%02x:%02x:%02x:%02x!\n", pEntry->Aid,
1850 pEntry->Addr[0], pEntry->Addr[1], pEntry->Addr[2], pEntry->Addr[3], pEntry->Addr[4], pEntry->Addr[5]);
1851 }
1852 break;
1853
1854 case OID_802_11_ADD_WEP:
1855 {
1856 #ifdef CONFIG_STA_SUPPORT
1857 UINT i;
1858 UINT32 KeyIdx;
1859 PNDIS_802_11_WEP pWepKey;
1860
1861 DBGPRINT(RT_DEBUG_TRACE, ("CmdThread::OID_802_11_ADD_WEP \n"));
1862
1863 pWepKey = (PNDIS_802_11_WEP)pData;
1864 KeyIdx = pWepKey->KeyIndex & 0x0fffffff;
1865
1866 // it is a shared key
1867 if ((KeyIdx >= 4) || ((pWepKey->KeyLength != 5) && (pWepKey->KeyLength != 13)))
1868 {
1869 NdisStatus = NDIS_STATUS_INVALID_DATA;
1870 DBGPRINT(RT_DEBUG_ERROR, ("CmdThread::OID_802_11_ADD_WEP, INVALID_DATA!!\n"));
1871 }
1872 else
1873 {
1874 UCHAR CipherAlg;
1875 pAd->SharedKey[BSS0][KeyIdx].KeyLen = (UCHAR) pWepKey->KeyLength;
1876 NdisMoveMemory(pAd->SharedKey[BSS0][KeyIdx].Key, &pWepKey->KeyMaterial, pWepKey->KeyLength);
1877 CipherAlg = (pAd->SharedKey[BSS0][KeyIdx].KeyLen == 5)? CIPHER_WEP64 : CIPHER_WEP128;
1878
1879 //
1880 // Change the WEP cipher to CKIP cipher if CKIP KP on.
1881 // Funk UI or Meetinghouse UI will add ckip key from this path.
1882 //
1883
1884 if (pAd->OpMode == OPMODE_STA)
1885 {
1886 pAd->MacTab.Content[BSSID_WCID].PairwiseKey.CipherAlg = pAd->SharedKey[BSS0][KeyIdx].CipherAlg;
1887 pAd->MacTab.Content[BSSID_WCID].PairwiseKey.KeyLen = pAd->SharedKey[BSS0][KeyIdx].KeyLen;
1888 }
1889 pAd->SharedKey[BSS0][KeyIdx].CipherAlg = CipherAlg;
1890 if (pWepKey->KeyIndex & 0x80000000)
1891 {
1892 // Default key for tx (shared key)
1893 UCHAR IVEIV[8];
1894 UINT32 WCIDAttri, Value;
1895 USHORT offset, offset2;
1896 NdisZeroMemory(IVEIV, 8);
1897 pAd->StaCfg.DefaultKeyId = (UCHAR) KeyIdx;
1898 // Add BSSID to WCTable. because this is Tx wep key.
1899 // WCID Attribute UDF:3, BSSIdx:3, Alg:3, Keytable:1=PAIRWISE KEY, BSSIdx is 0
1900 WCIDAttri = (CipherAlg<<1)|SHAREDKEYTABLE;
1901
1902 offset = MAC_WCID_ATTRIBUTE_BASE + (BSSID_WCID* HW_WCID_ATTRI_SIZE);
1903 RTUSBWriteMACRegister(pAd, offset, WCIDAttri);
1904 // 1. IV/EIV
1905 // Specify key index to find shared key.
1906 IVEIV[3] = (UCHAR)(KeyIdx<< 6); //WEP Eiv bit off. groupkey index is not 0
1907 offset = PAIRWISE_IVEIV_TABLE_BASE + (BSS0Mcast_WCID * HW_IVEIV_ENTRY_SIZE);
1908 offset2 = PAIRWISE_IVEIV_TABLE_BASE + (BSSID_WCID* HW_IVEIV_ENTRY_SIZE);
1909 for (i=0; i<8;)
1910 {
1911 Value = IVEIV[i];
1912 Value += (IVEIV[i+1]<<8);
1913 Value += (IVEIV[i+2]<<16);
1914 Value += (IVEIV[i+3]<<24);
1915 RTUSBWriteMACRegister(pAd, offset+i, Value);
1916 RTUSBWriteMACRegister(pAd, offset2+i, Value);
1917 i+=4;
1918 }
1919
1920 // 2. WCID Attribute UDF:3, BSSIdx:3, Alg:3, Keytable:use share key, BSSIdx is 0
1921 WCIDAttri = (pAd->SharedKey[BSS0][KeyIdx].CipherAlg<<1)|SHAREDKEYTABLE;
1922 offset = MAC_WCID_ATTRIBUTE_BASE + (BSS0Mcast_WCID* HW_WCID_ATTRI_SIZE);
1923 DBGPRINT(RT_DEBUG_TRACE, ("BSS0Mcast_WCID : offset = %x, WCIDAttri = %x\n", offset, WCIDAttri));
1924 RTUSBWriteMACRegister(pAd, offset, WCIDAttri);
1925
1926 }
1927 AsicAddSharedKeyEntry(pAd, BSS0, (UCHAR)KeyIdx, CipherAlg, pWepKey->KeyMaterial, NULL, NULL);
1928 DBGPRINT(RT_DEBUG_TRACE, ("CmdThread::OID_802_11_ADD_WEP (KeyIdx=%d, Len=%d-byte)\n", KeyIdx, pWepKey->KeyLength));
1929 }
1930 #endif // CONFIG_STA_SUPPORT //
1931 }
1932 break;
1933
1934 case CMDTHREAD_802_11_COUNTER_MEASURE:
1935 break;
1936 default:
1937 DBGPRINT(RT_DEBUG_ERROR, ("--> Control Thread !! ERROR !! Unknown(cmdqelmt->command=0x%x) !! \n", cmdqelmt->command));
1938 break;
1939 }
1940 }
1941
1942 if (cmdqelmt->CmdFromNdis == TRUE)
1943 {
1944 if (cmdqelmt->buffer != NULL)
1945 NdisFreeMemory(cmdqelmt->buffer, cmdqelmt->bufferlength, 0);
1946
1947 NdisFreeMemory(cmdqelmt, sizeof(CmdQElmt), 0);
1948 }
1949 else
1950 {
1951 if ((cmdqelmt->buffer != NULL) && (cmdqelmt->bufferlength != 0))
1952 NdisFreeMemory(cmdqelmt->buffer, cmdqelmt->bufferlength, 0);
1953 {
1954 NdisFreeMemory(cmdqelmt, sizeof(CmdQElmt), 0);
1955 }
1956 }
1957 } /* end of while */
1958 }
1959
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree