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