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