git.oblomov.eu Git - linux-2.6/blob - drivers/staging/rt2870/common/rtusb_io.c

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