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