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

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