drivers/staging/rt2870/rt_ate.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
  28 #include "rt_config.h"
  29
  30 #ifdef RALINK_ATE
  31 UCHAR TemplateFrame[24] = {0x08/* Data type */,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0xAA,0xBB,0x12,0x34,0x56,0x00,0x11,0x22,0xAA,0xBB,0xCC,0x00,0x00};     // 802.11 MAC Header, Type:Data, Length:24bytes
  32 extern RTMP_RF_REGS RF2850RegTable[];
  33 extern UCHAR NUM_OF_2850_CHNL;
  34
  35 #ifdef RT2870
  36 extern UCHAR EpToQueue[];
  37 extern VOID     RTUSBRejectPendingPackets(      IN      PRTMP_ADAPTER   pAd);
  38 #endif // RT2870 //
  39
  40 static CHAR CCKRateTable[] = {0, 1, 2, 3, 8, 9, 10, 11, -1}; /* CCK Mode. */
  41 static CHAR OFDMRateTable[] = {0, 1, 2, 3, 4, 5, 6, 7, -1}; /* OFDM Mode. */
  42 static CHAR HTMIXRateTable[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, -1}; /* HT Mix Mode. */
  43
  44 static INT TxDmaBusy(
  45         IN PRTMP_ADAPTER pAd);
  46
  47 static INT RxDmaBusy(
  48         IN PRTMP_ADAPTER pAd);
  49
  50 static VOID RtmpDmaEnable(
  51         IN PRTMP_ADAPTER pAd,
  52         IN INT Enable);
  53
  54 static VOID BbpSoftReset(
  55         IN PRTMP_ADAPTER pAd);
  56
  57 static VOID RtmpRfIoWrite(
  58         IN PRTMP_ADAPTER pAd);
  59
  60 static INT ATESetUpFrame(
  61         IN PRTMP_ADAPTER pAd,
  62         IN UINT32 TxIdx);
  63
  64 static INT ATETxPwrHandler(
  65         IN PRTMP_ADAPTER pAd,
  66         IN char index);
  67
  68 static INT ATECmdHandler(
  69         IN      PRTMP_ADAPTER   pAd,
  70         IN      PUCHAR                  arg);
  71
  72 static int CheckMCSValid(
  73         IN UCHAR Mode,
  74         IN UCHAR Mcs);
  75
  76
  77 #ifdef RT2870
  78 static VOID ATEWriteTxInfo(
  79         IN      PRTMP_ADAPTER   pAd,
  80         IN      PTXINFO_STRUC   pTxInfo,
  81         IN        USHORT                USBDMApktLen,
  82         IN        BOOLEAN               bWiv,
  83         IN        UCHAR                 QueueSel,
  84         IN        UCHAR                 NextValid,
  85         IN        UCHAR                 TxBurst);
  86
  87 static VOID ATEWriteTxWI(
  88         IN      PRTMP_ADAPTER   pAd,
  89         IN      PTXWI_STRUC     pTxWI,
  90         IN      BOOLEAN                 FRAG,
  91         IN      BOOLEAN                 InsTimestamp,
  92         IN      BOOLEAN                 AMPDU,
  93         IN      BOOLEAN                 Ack,
  94         IN      BOOLEAN                 NSeq,           // HW new a sequence.
  95         IN      UCHAR                   BASize,
  96         IN      UCHAR                   WCID,
  97         IN      ULONG                   Length,
  98         IN      UCHAR                   PID,
  99         IN      UCHAR                   MIMOps,
 100         IN      UCHAR                   Txopmode,
 101         IN      BOOLEAN                 CfAck,
 102         IN      HTTRANSMIT_SETTING      Transmit);
 103
 104 #endif // RT2870 //
 105
 106 static VOID SetJapanFilter(
 107         IN      PRTMP_ADAPTER   pAd);
 108
 109 /*=========================end of prototype=========================*/
 110
 111
 112 #ifdef RT2870
 113 static INT TxDmaBusy(
 114         IN PRTMP_ADAPTER pAd)
 115 {
 116         INT result;
 117         USB_DMA_CFG_STRUC UsbCfg;
 118
 119         RTMP_IO_READ32(pAd, USB_DMA_CFG, &UsbCfg.word); // disable DMA
 120         if (UsbCfg.field.TxBusy)
 121                 result = 1;
 122         else
 123                 result = 0;
 124
 125         return result;
 126 }
 127
 128 static INT RxDmaBusy(
 129         IN PRTMP_ADAPTER pAd)
 130 {
 131         INT result;
 132         USB_DMA_CFG_STRUC UsbCfg;
 133
 134         RTMP_IO_READ32(pAd, USB_DMA_CFG, &UsbCfg.word); // disable DMA
 135         if (UsbCfg.field.RxBusy)
 136                 result = 1;
 137         else
 138                 result = 0;
 139
 140         return result;
 141 }
 142
 143 static VOID RtmpDmaEnable(
 144         IN PRTMP_ADAPTER pAd,
 145         IN INT Enable)
 146 {
 147         BOOLEAN value;
 148         ULONG WaitCnt;
 149         USB_DMA_CFG_STRUC UsbCfg;
 150
 151         value = Enable > 0 ? 1 : 0;
 152
 153         // check DMA is in busy mode.
 154         WaitCnt = 0;
 155         while (TxDmaBusy(pAd) || RxDmaBusy(pAd))
 156         {
 157                 RTMPusecDelay(10);
 158                 if (WaitCnt++ > 100)
 159                         break;
 160         }
 161
 162         //Why not to clear USB DMA TX path first ???
 163         RTMP_IO_READ32(pAd, USB_DMA_CFG, &UsbCfg.word); // disable DMA
 164         UsbCfg.field.TxBulkEn = value;
 165         UsbCfg.field.RxBulkEn = value;
 166         RTMP_IO_WRITE32(pAd, USB_DMA_CFG, UsbCfg.word); // abort all TX rings
 167         RTMPusecDelay(5000);
 168
 169         return;
 170 }
 171 #endif // RT2870 //
 172
 173 static VOID BbpSoftReset(
 174         IN PRTMP_ADAPTER pAd)
 175 {
 176         UCHAR BbpData = 0;
 177
 178         // Soft reset, set BBP R21 bit0=1->0
 179         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R21, &BbpData);
 180         BbpData |= 0x00000001; //set bit0=1
 181         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R21, BbpData);
 182
 183         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R21, &BbpData);
 184         BbpData &= ~(0x00000001); //set bit0=0
 185         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R21, BbpData);
 186
 187         return;
 188 }
 189
 190 static VOID RtmpRfIoWrite(
 191         IN PRTMP_ADAPTER pAd)
 192 {
 193         // Set RF value 1's set R3[bit2] = [0]
 194         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
 195         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
 196         RTMP_RF_IO_WRITE32(pAd, (pAd->LatchRfRegs.R3 & (~0x04)));
 197         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
 198
 199         RTMPusecDelay(200);
 200
 201         // Set RF value 2's set R3[bit2] = [1]
 202         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
 203         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
 204         RTMP_RF_IO_WRITE32(pAd, (pAd->LatchRfRegs.R3 | 0x04));
 205         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
 206
 207         RTMPusecDelay(200);
 208
 209         // Set RF value 3's set R3[bit2] = [0]
 210         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
 211         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
 212         RTMP_RF_IO_WRITE32(pAd, (pAd->LatchRfRegs.R3 & (~0x04)));
 213         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
 214
 215         return;
 216 }
 217
 218 static int CheckMCSValid(
 219         UCHAR Mode,
 220         UCHAR Mcs)
 221 {
 222         int i;
 223         PCHAR pRateTab;
 224
 225         switch(Mode)
 226         {
 227                 case 0:
 228                         pRateTab = CCKRateTable;
 229                         break;
 230                 case 1:
 231                         pRateTab = OFDMRateTable;
 232                         break;
 233                 case 2:
 234                 case 3:
 235                         pRateTab = HTMIXRateTable;
 236                         break;
 237                 default:
 238                         ATEDBGPRINT(RT_DEBUG_ERROR, ("unrecognizable Tx Mode %d\n", Mode));
 239                         return -1;
 240                         break;
 241         }
 242
 243         i = 0;
 244         while(pRateTab[i] != -1)
 245         {
 246                 if (pRateTab[i] == Mcs)
 247                         return 0;
 248                 i++;
 249         }
 250
 251         return -1;
 252 }
 253
 254 #if 1
 255 static INT ATETxPwrHandler(
 256         IN PRTMP_ADAPTER pAd,
 257         IN char index)
 258 {
 259         ULONG R;
 260         CHAR TxPower;
 261         UCHAR Bbp94 = 0;
 262         BOOLEAN bPowerReduce = FALSE;
 263
 264 #ifdef RALINK_28xx_QA
 265         if ((pAd->ate.bQATxStart == TRUE) || (pAd->ate.bQARxStart == TRUE))
 266         {
 267                 /* When QA is used for Tx, pAd->ate.TxPower0/1 and real tx power
 268                 ** are not synchronized.
 269                 */
 270 /*
 271                 pAd->ate.TxPower0 = pAd->LatchRfRegs.xxx;
 272                 pAd->ate.TxPower1 = pAd->LatchRfRegs.xxx;
 273 */
 274                 return 0;
 275         }
 276         else
 277 #endif // RALINK_28xx_QA //
 278         {
 279                 TxPower = index == 0 ? pAd->ate.TxPower0 : pAd->ate.TxPower1;
 280
 281                 if (pAd->ate.Channel <= 14)
 282                 {
 283                         if (TxPower > 31)
 284                         {
 285                                 //
 286                                 // R3, R4 can't large than 31 (0x24), 31 ~ 36 used by BBP 94
 287                                 //
 288                                 R = 31;
 289                                 if (TxPower <= 36)
 290                                         Bbp94 = BBPR94_DEFAULT + (UCHAR)(TxPower - 31);
 291                         }
 292                         else if (TxPower < 0)
 293                         {
 294                                 //
 295                                 // R3, R4 can't less than 0, -1 ~ -6 used by BBP 94
 296                                 //
 297                                 R = 0;
 298                                 if (TxPower >= -6)
 299                                         Bbp94 = BBPR94_DEFAULT + TxPower;
 300                         }
 301                         else
 302                         {
 303                                 // 0 ~ 31
 304                                 R = (ULONG) TxPower;
 305                                 Bbp94 = BBPR94_DEFAULT;
 306                         }
 307
 308                         ATEDBGPRINT(RT_DEBUG_TRACE, ("%s (TxPower=%d, R=%ld, BBP_R94=%d)\n", __func__, TxPower, R, Bbp94));
 309                 }
 310                 else// 5.5 GHz
 311                 {
 312                         if (TxPower > 15)
 313                         {
 314                                 //
 315                                 // R3, R4 can't large than 15 (0x0F)
 316                                 //
 317                                 R = 15;
 318                         }
 319                         else if (TxPower < 0)
 320                         {
 321                                 //
 322                                 // R3, R4 can't less than 0
 323                                 //
 324                                 // -1 ~ -7
 325                                 ASSERT((TxPower >= -7));
 326                                 R = (ULONG)(TxPower + 7);
 327                                 bPowerReduce = TRUE;
 328                         }
 329                         else
 330                         {
 331                                 // 0 ~ 15
 332                                 R = (ULONG) TxPower;
 333                         }
 334
 335                         ATEDBGPRINT(RT_DEBUG_TRACE, ("%s (TxPower=%d, R=%lu)\n", __func__, TxPower, R));
 336                 }
 337
 338                 if (pAd->ate.Channel <= 14)
 339                 {
 340                         if (index == 0)
 341                         {
 342                                 R = R << 9;             // shift TX power control to correct RF(R3) register bit position
 343                                 R |= (pAd->LatchRfRegs.R3 & 0xffffc1ff);
 344                                 pAd->LatchRfRegs.R3 = R;
 345                         }
 346                         else
 347                         {
 348                                 R = R << 6;             // shift TX power control to correct RF(R4) register bit position
 349                                 R |= (pAd->LatchRfRegs.R4 & 0xfffff83f);
 350                                 pAd->LatchRfRegs.R4 = R;
 351                         }
 352                 }
 353                 else// 5.5GHz
 354                 {
 355                         if (bPowerReduce == FALSE)
 356                         {
 357                                 if (index == 0)
 358                                 {
 359                                         R = (R << 10) | (1 << 9);               // shift TX power control to correct RF(R3) register bit position
 360                                         R |= (pAd->LatchRfRegs.R3 & 0xffffc1ff);
 361                                         pAd->LatchRfRegs.R3 = R;
 362                                 }
 363                                 else
 364                                 {
 365                                         R = (R << 7) | (1 << 6);                // shift TX power control to correct RF(R4) register bit position
 366                                         R |= (pAd->LatchRfRegs.R4 & 0xfffff83f);
 367                                         pAd->LatchRfRegs.R4 = R;
 368                                 }
 369                         }
 370                         else
 371                         {
 372                                 if (index == 0)
 373                                 {
 374                                         R = (R << 10);          // shift TX power control to correct RF(R3) register bit position
 375                                         R |= (pAd->LatchRfRegs.R3 & 0xffffc1ff);
 376
 377                                         /* Clear bit 9 of R3 to reduce 7dB. */
 378                                         pAd->LatchRfRegs.R3 = (R & (~(1 << 9)));
 379                                 }
 380                                 else
 381                                 {
 382                                         R = (R << 7);           // shift TX power control to correct RF(R4) register bit position
 383                                         R |= (pAd->LatchRfRegs.R4 & 0xfffff83f);
 384
 385                                         /* Clear bit 6 of R4 to reduce 7dB. */
 386                                         pAd->LatchRfRegs.R4 = (R & (~(1 << 6)));
 387                                 }
 388                         }
 389                 }
 390
 391                 RtmpRfIoWrite(pAd);
 392
 393                 return 0;
 394         }
 395 }
 396 #else// 1 //
 397 static INT ATETxPwrHandler(
 398         IN PRTMP_ADAPTER pAd,
 399         IN char index)
 400 {
 401         ULONG R;
 402         CHAR TxPower;
 403         UCHAR Bbp94 = 0;
 404
 405 #ifdef RALINK_28xx_QA
 406         if ((pAd->ate.bQATxStart == TRUE) || (pAd->ate.bQARxStart == TRUE))
 407         {
 408                 // TODO: how to get current TxPower0/1 from pAd->LatchRfRegs ?
 409                 /* When QA is used for Tx, pAd->ate.TxPower0/1 and real tx power
 410                 ** are not synchronized.
 411                 */
 412 /*
 413                 pAd->ate.TxPower0 = pAd->LatchRfRegs.xxx;
 414                 pAd->ate.TxPower1 = pAd->LatchRfRegs.xxx;
 415 */
 416                 return 0;
 417         }
 418         else
 419 #endif // RALINK_28xx_QA //
 420         {
 421                 TxPower = index == 0 ? pAd->ate.TxPower0 : pAd->ate.TxPower1;
 422
 423         if (TxPower > 31)
 424         {
 425                 //
 426                 // R3, R4 can't large than 36 (0x24), 31 ~ 36 used by BBP 94
 427                 //
 428                 R = 31;
 429                 if (TxPower <= 36)
 430                         Bbp94 = BBPR94_DEFAULT + (UCHAR)(TxPower - 31);
 431         }
 432         else if (TxPower < 0)
 433         {
 434                 //
 435                 // R3, R4 can't less than 0, -1 ~ -6 used by BBP 94
 436                 //
 437                 R = 0;
 438                 if (TxPower >= -6)
 439                         Bbp94 = BBPR94_DEFAULT + TxPower;
 440         }
 441         else
 442         {
 443                 // 0 ~ 31
 444                 R = (ULONG) TxPower;
 445                 Bbp94 = BBPR94_DEFAULT;
 446         }
 447
 448         ATEDBGPRINT(RT_DEBUG_TRACE, ("%s (TxPower=%d, R3=%ld, BBP_R94=%d)\n", __func__, TxPower, R, Bbp94));
 449
 450                 if (pAd->ate.Channel <= 14)
 451                 {
 452         if (index == 0)
 453         {
 454                 R = R << 9;             // shift TX power control to correct RF(R3) register bit position
 455                 R |= (pAd->LatchRfRegs.R3 & 0xffffc1ff);
 456                 pAd->LatchRfRegs.R3 = R;
 457         }
 458         else
 459         {
 460                 R = R << 6;             // shift TX power control to correct RF(R4) register bit position
 461                 R |= (pAd->LatchRfRegs.R4 & 0xfffff83f);
 462                 pAd->LatchRfRegs.R4 = R;
 463         }
 464                 }
 465                 else
 466                 {
 467                         if (index == 0)
 468                         {
 469                                 R = (R << 10) | (1 << 9);               // shift TX power control to correct RF(R3) register bit position
 470                                 R |= (pAd->LatchRfRegs.R3 & 0xffffc1ff);
 471                                 pAd->LatchRfRegs.R3 = R;
 472                         }
 473                         else
 474                         {
 475                                 R = (R << 7) | (1 << 6);                // shift TX power control to correct RF(R4) register bit position
 476                                 R |= (pAd->LatchRfRegs.R4 & 0xfffff83f);
 477                                 pAd->LatchRfRegs.R4 = R;
 478                         }
 479                 }
 480
 481         RtmpRfIoWrite(pAd);
 482
 483         return 0;
 484         }
 485 }
 486 #endif // 1 //
 487 /*
 488     ==========================================================================
 489     Description:
 490         Set ATE operation mode to
 491         0. ATESTART  = Start ATE Mode
 492         1. ATESTOP   = Stop ATE Mode
 493         2. TXCONT    = Continuous Transmit
 494         3. TXCARR    = Transmit Carrier
 495         4. TXFRAME   = Transmit Frames
 496         5. RXFRAME   = Receive Frames
 497 #ifdef RALINK_28xx_QA
 498         6. TXSTOP    = Stop Any Type of Transmition
 499         7. RXSTOP    = Stop Receiving Frames
 500 #endif // RALINK_28xx_QA //
 501     Return:
 502         TRUE if all parameters are OK, FALSE otherwise
 503     ==========================================================================
 504 */
 505 /*                                                           */
 506 /*                                                           */
 507 /*=======================End of RT2860=======================*/
 508
 509
 510 /*======================Start of RT2870======================*/
 511 /*                                                           */
 512 /*                                                           */
 513
 514 #ifdef RT2870
 515 static INT      ATECmdHandler(
 516         IN      PRTMP_ADAPTER   pAd,
 517         IN      PUCHAR                  arg)
 518 {
 519         UINT32                  Value;
 520         UCHAR                   BbpData;
 521         UINT32          MacData;
 522         UINT                    i=0, atemode;
 523         //NDIS_STATUS           Status = NDIS_STATUS_SUCCESS;
 524         //PUCHAR                        pDest;
 525         UINT32                  temp;
 526         ULONG                   IrqFlags;
 527
 528         ATEDBGPRINT(RT_DEBUG_TRACE, ("===> ATECmdHandler()\n"));
 529         ATEAsicSwitchChannel(pAd);
 530         /* AsicLockChannel() is empty function so far in fact */
 531         AsicLockChannel(pAd, pAd->ate.Channel);
 532
 533         RTMPusecDelay(5000);
 534
 535         // Default value in BBP R22 is 0x0.
 536         BbpData = 0;
 537
 538         /* Enter ATE mode and set Tx/Rx Idle */
 539         if (!strcmp(arg, "ATESTART"))
 540         {
 541 #ifdef CONFIG_STA_SUPPORT
 542                 BOOLEAN       Cancelled;
 543 #endif // CONFIG_STA_SUPPORT //
 544                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: ATESTART\n"));
 545
 546                 netif_stop_queue(pAd->net_dev);
 547
 548                 atemode = pAd->ate.Mode;
 549                 pAd->ate.Mode = ATE_START;
 550 //              pAd->ate.TxDoneCount = pAd->ate.TxCount;
 551                 // Disable Rx
 552                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 553                 Value &= ~(1 << 3);
 554                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 555
 556                 // Disable auto responder
 557                 RTMP_IO_READ32(pAd, AUTO_RSP_CFG, &temp);
 558                 temp = temp & 0xFFFFFFFE;
 559                 RTMP_IO_WRITE32(pAd, AUTO_RSP_CFG, temp);
 560
 561                 // read MAC_SYS_CTRL and backup MAC_SYS_CTRL value.
 562                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
 563                 // clean bit4 to stop continuous Tx production test.
 564                 MacData &= 0xFFFFFFEF;
 565                 // Stop continuous TX production test.
 566                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);//disable or cancel pending irp first ???
 567
 568         if (atemode & ATE_TXCARR)
 569                 {
 570                         // No Carrier Test set BBP R22 bit7=0, bit6=0, bit[5~0]=0x0
 571                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
 572                         BbpData &= 0xFFFFFF00; //clear bit7, bit6, bit[5~0]
 573                     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 574                 }
 575                 else if (atemode & ATE_TXCARRSUPP)
 576                 {
 577                         // No Cont. TX set BBP R22 bit7=0
 578                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
 579                         BbpData &= ~(1 << 7); //set bit7=0
 580                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 581
 582                         // No Carrier Suppression set BBP R24 bit0=0
 583                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R24, &BbpData);
 584                         BbpData &= 0xFFFFFFFE; //clear bit0
 585                     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, BbpData);
 586                 }
 587                 // We should free some resource which allocate when ATE_TXFRAME , ATE_STOP, and ATE_TXCONT.
 588                 // TODO:Should we free some resource which was allocated when LoopBack and ATE_STOP ?
 589                 else if ((atemode & ATE_TXFRAME) || (atemode == ATE_STOP))
 590                 {
 591                         if (atemode & ATE_TXCONT)
 592                         {
 593                                 // Not Cont. TX anymore, so set BBP R22 bit7=0
 594                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
 595                                 BbpData &= ~(1 << 7); //set bit7=0
 596                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 597                         }
 598                         // Abort Tx, Rx DMA.
 599                         RtmpDmaEnable(pAd, 0);
 600
 601                         {
 602                                 // It seems nothing to free,
 603                                 // because we didn't allocate any resource when we entered ATE_TXFRAME mode latestly.
 604                         }
 605
 606                         // Start Tx, RX DMA
 607                         RtmpDmaEnable(pAd, 1);
 608                 }
 609
 610                 RTUSBRejectPendingPackets(pAd);
 611                 RTUSBCleanUpDataBulkOutQueue(pAd);
 612
 613 #ifdef CONFIG_STA_SUPPORT
 614                 //
 615                 // It will be called in MlmeSuspend().
 616                 //
 617                 // Cancel pending timers
 618                 RTMPCancelTimer(&pAd->MlmeAux.AssocTimer,     &Cancelled);
 619                 RTMPCancelTimer(&pAd->MlmeAux.ReassocTimer,   &Cancelled);
 620                 RTMPCancelTimer(&pAd->MlmeAux.DisassocTimer,   &Cancelled);
 621                 RTMPCancelTimer(&pAd->MlmeAux.AuthTimer,       &Cancelled);
 622                 RTMPCancelTimer(&pAd->MlmeAux.BeaconTimer,     &Cancelled);
 623                 RTMPCancelTimer(&pAd->MlmeAux.ScanTimer,       &Cancelled);
 624 #endif // CONFIG_STA_SUPPORT //
 625
 626                 //RTUSBCleanUpMLMEWaitQueue(pAd);       /* not used in RT28xx */
 627                 RTUSBCleanUpMLMEBulkOutQueue(pAd);
 628
 629                 // Sometimes kernel will hang on, so we avoid calling MlmeSuspend().
 630 //              MlmeSuspend(pAd, TRUE);
 631                 //RTMPCancelTimer(&pAd->Mlme.PeriodicTimer, &Cancelled);
 632
 633                 // Disable Rx
 634                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 635                 Value &= ~(1 << 3);
 636                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 637
 638                 // Abort Tx, RX DMA.
 639                 RtmpDmaEnable(pAd, 0);
 640
 641                 // Disable Tx
 642                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 643                 Value &= ~(1 << 2);
 644                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 645
 646                 // Make sure there are no pending bulk in/out IRPs before we go on.
 647 /*=========================================================================*/
 648                 /* pAd->PendingRx is not of type atomic_t anymore in 28xx */
 649 //              while ((atomic_read(&pAd->PendingRx) > 0))      //pAd->BulkFlags != 0 wait bulk out finish
 650                 while ((pAd->PendingRx > 0))    //pAd->BulkFlags != 0 wait bulk out finish
 651                 {
 652 #if 1
 653                         ATE_RTUSBCancelPendingBulkInIRP(pAd);
 654 #else
 655                         NdisInterlockedDecrement(&pAd->PendingRx);
 656 #endif
 657                         /* delay 0.5 seconds */
 658                         RTMPusecDelay(500000);
 659                         pAd->PendingRx = 0;
 660                 }
 661                 /* peter : why don't we have to get BulkOutLock first ? */
 662                 while (((pAd->BulkOutPending[0] == TRUE) ||
 663                                 (pAd->BulkOutPending[1] == TRUE) ||
 664                                 (pAd->BulkOutPending[2] == TRUE) ||
 665                                 (pAd->BulkOutPending[3] == TRUE)) && (pAd->BulkFlags != 0))     //pAd->BulkFlags != 0 wait bulk out finish
 666                 {
 667                         do
 668                         {
 669                                 /* pAd->BulkOutPending[y] will be set to FALSE in RTUSBCancelPendingBulkOutIRP(pAd) */
 670                                 RTUSBCancelPendingBulkOutIRP(pAd);
 671                         } while (FALSE);
 672
 673                         /* we have enough time delay in RTUSBCancelPendingBulkOutIRP(pAd)
 674                         ** so this is not necessary
 675                         */
 676 //                      RTMPusecDelay(500000);
 677                 }
 678
 679                 /* pAd->PendingRx is not of type atomic_t anymore in 28xx */
 680 //              ASSERT(atomic_read(&pAd->PendingRx) == 0);
 681                 ASSERT(pAd->PendingRx == 0);
 682 /*=========================================================================*/
 683
 684                 // reset Rx statistics.
 685                 pAd->ate.LastSNR0 = 0;
 686                 pAd->ate.LastSNR1 = 0;
 687                 pAd->ate.LastRssi0 = 0;
 688                 pAd->ate.LastRssi1 = 0;
 689                 pAd->ate.LastRssi2 = 0;
 690                 pAd->ate.AvgRssi0 = 0;
 691                 pAd->ate.AvgRssi1 = 0;
 692                 pAd->ate.AvgRssi2 = 0;
 693                 pAd->ate.AvgRssi0X8 = 0;
 694                 pAd->ate.AvgRssi1X8 = 0;
 695                 pAd->ate.AvgRssi2X8 = 0;
 696                 pAd->ate.NumOfAvgRssiSample = 0;
 697
 698 #ifdef RALINK_28xx_QA
 699                 // Tx frame
 700                 pAd->ate.bQATxStart = FALSE;
 701                 pAd->ate.bQARxStart = FALSE;
 702                 pAd->ate.seq = 0;
 703
 704                 // counters
 705                 pAd->ate.U2M = 0;
 706                 pAd->ate.OtherData = 0;
 707                 pAd->ate.Beacon = 0;
 708                 pAd->ate.OtherCount = 0;
 709                 pAd->ate.TxAc0 = 0;
 710                 pAd->ate.TxAc1 = 0;
 711                 pAd->ate.TxAc2 = 0;
 712                 pAd->ate.TxAc3 = 0;
 713                 pAd->ate.TxHCCA = 0;
 714                 pAd->ate.TxMgmt = 0;
 715                 pAd->ate.RSSI0 = 0;
 716                 pAd->ate.RSSI1 = 0;
 717                 pAd->ate.RSSI2 = 0;
 718                 pAd->ate.SNR0 = 0;
 719                 pAd->ate.SNR1 = 0;
 720
 721                 // control
 722                 pAd->ate.TxDoneCount = 0;
 723                 pAd->ate.TxStatus = 0; // task Tx status // 0 --> task is idle, 1 --> task is running
 724 #endif // RALINK_28xx_QA //
 725
 726                 // Soft reset BBP.
 727                 BbpSoftReset(pAd);
 728
 729
 730 #ifdef CONFIG_STA_SUPPORT
 731                 AsicDisableSync(pAd);
 732
 733                 /*
 734                 ** If we skip "LinkDown()", we should disable protection
 735                 ** to prevent from sending out RTS or CTS-to-self.
 736                 */
 737                 ATEDisableAsicProtect(pAd);
 738                 RTMPStationStop(pAd);
 739 #endif // CONFIG_STA_SUPPORT //
 740
 741                 // Default value in BBP R22 is 0x0.
 742                 BbpData = 0;
 743                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
 744
 745                 // Clean bit4 to stop continuous Tx production test.
 746                 MacData &= 0xFFFFFFEF;
 747                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 748                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);
 749                 //Clean ATE Bulk in/out counter and continue setup
 750                 InterlockedExchange(&pAd->BulkOutRemained, 0);
 751
 752                 /* NdisAcquireSpinLock()/NdisReleaseSpinLock() need only one argument in RT28xx */
 753                 NdisAcquireSpinLock(&pAd->GenericLock);
 754                 pAd->ContinBulkOut = FALSE;
 755                 pAd->ContinBulkIn = FALSE;
 756                 NdisReleaseSpinLock(&pAd->GenericLock);
 757
 758                 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
 759         }
 760         else if (!strcmp(arg, "ATESTOP"))
 761         {
 762                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE : ATESTOP ===>\n"));
 763
 764                 // Default value in BBP R22 is 0x0.
 765                 BbpData = 0;
 766                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);//0820
 767                 // Clean bit4 to stop continuous Tx production test.
 768                 MacData &= 0xFFFFFFEF;
 769                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 770                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData); // recover the MAC_SYS_CTRL register back.
 771
 772                 // Disable Rx
 773                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 774                 Value &= ~(1 << 3);
 775                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 776
 777                 /*
 778                 ** Abort Tx, RX DMA.
 779                 ** Q   : How to do the following I/O if Tx, Rx DMA is aborted ?
 780                 ** Ans : Bulk endpoints are aborted, while the control endpoint is not.
 781                 */
 782                 RtmpDmaEnable(pAd, 0);
 783
 784                 // Disable Tx
 785                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 786                 Value &= ~(1 << 2);
 787                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 788
 789                 /* Make sure there are no pending bulk in/out IRPs before we go on. */
 790 /*=========================================================================*/
 791 //              while ((atomic_read(&pAd->PendingRx) > 0))      //pAd->BulkFlags != 0 wait bulk out finish
 792                 while (pAd->PendingRx > 0)
 793                 {
 794 #if 1
 795                         ATE_RTUSBCancelPendingBulkInIRP(pAd);
 796 #else
 797 //                      NdisInterlockedDecrement(&pAd->PendingRx);
 798                         pAd->PendingRx--;
 799 #endif
 800                         RTMPusecDelay(500000);
 801                 }
 802
 803                 while (((pAd->BulkOutPending[0] == TRUE) ||
 804                                 (pAd->BulkOutPending[1] == TRUE) ||
 805                                 (pAd->BulkOutPending[2] == TRUE) ||
 806                                 (pAd->BulkOutPending[3] == TRUE)) && (pAd->BulkFlags != 0))     //pAd->BulkFlags != 0 wait bulk out finish
 807                 {
 808                         do
 809                         {
 810                                 RTUSBCancelPendingBulkOutIRP(pAd);
 811                         } while (FALSE);
 812
 813                         RTMPusecDelay(500000);
 814                 }
 815
 816 //              ASSERT(atomic_read(&pAd->PendingRx) == 0);
 817                 ASSERT(pAd->PendingRx == 0);
 818 /*=========================================================================*/
 819 /*      Reset Rx RING                                                      */
 820 /*=========================================================================*/
 821 //              InterlockedExchange(&pAd->PendingRx, 0);
 822                 pAd->PendingRx = 0;
 823                 pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
 824                 pAd->NextRxBulkInIndex = RX_RING_SIZE - 1;      // Rx Bulk pointer
 825                 pAd->NextRxBulkInPosition = 0;
 826                 for (i = 0; i < (RX_RING_SIZE); i++)
 827                 {
 828                         PRX_CONTEXT  pRxContext = &(pAd->RxContext[i]);
 829                         NdisZeroMemory(pRxContext->TransferBuffer, MAX_RXBULK_SIZE);
 830                         /* peter : why don't we have to get BulkInLock first ? */
 831                         pRxContext->pAd = pAd;
 832                         pRxContext->pIrp = NULL;
 833             /* peter debug ++ */
 834                         pRxContext->BulkInOffset = 0;
 835                         pRxContext->bRxHandling = FALSE;
 836             /* peter debug -- */
 837                         pRxContext->InUse               = FALSE;
 838                         pRxContext->IRPPending  = FALSE;
 839                         pRxContext->Readable    = FALSE;
 840 //                      pRxContext->ReorderInUse = FALSE;
 841 //                      pRxContext->ReadPosOffset = 0;
 842                 }
 843
 844 /*=========================================================================*/
 845 /*      Reset Tx RING                                                      */
 846 /*=========================================================================*/
 847                 do
 848                 {
 849                         RTUSBCancelPendingBulkOutIRP(pAd);
 850                 } while (FALSE);
 851
 852 /*=========================================================================*/
 853                 // Enable auto responder.
 854                 RTMP_IO_READ32(pAd, AUTO_RSP_CFG, &temp);
 855                 temp = temp | (0x01);
 856                 RTMP_IO_WRITE32(pAd, AUTO_RSP_CFG, temp);
 857
 858 /*================================================*/
 859                 AsicEnableBssSync(pAd);
 860
 861                 /* Soft reset BBP.*/
 862                 /* In 2870 chipset, ATE_BBP_IO_READ8_BY_REG_ID() == RTMP_BBP_IO_READ8_BY_REG_ID() */
 863                 /* Both rt2870ap and rt2870sta use BbpSoftReset(pAd) to do BBP soft reset */
 864                 BbpSoftReset(pAd);
 865 /*================================================*/
 866                 {
 867 #ifdef CONFIG_STA_SUPPORT
 868                         // Set all state machines back IDLE
 869                         pAd->Mlme.CntlMachine.CurrState    = CNTL_IDLE;
 870                         pAd->Mlme.AssocMachine.CurrState   = ASSOC_IDLE;
 871                         pAd->Mlme.AuthMachine.CurrState    = AUTH_REQ_IDLE;
 872                         pAd->Mlme.AuthRspMachine.CurrState = AUTH_RSP_IDLE;
 873                         pAd->Mlme.SyncMachine.CurrState    = SYNC_IDLE;
 874                         pAd->Mlme.ActMachine.CurrState    = ACT_IDLE;
 875 #endif // CONFIG_STA_SUPPORT //
 876
 877                         //
 878                         // ===> refer to MlmeRestartStateMachine().
 879                         // When we entered ATE_START mode, PeriodicTimer was not cancelled.
 880                         // So we don't have to set it here.
 881                         //
 882                         //RTMPSetTimer(pAd, &pAd->Mlme.PeriodicTimer, MLME_TASK_EXEC_INTV);
 883
 884                         ASSERT(pAd->CommonCfg.Channel != 0);
 885
 886                         AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
 887                         AsicLockChannel(pAd, pAd->CommonCfg.Channel);
 888
 889
 890 #ifdef CONFIG_STA_SUPPORT
 891                     RTMPStationStart(pAd);
 892 #endif // CONFIG_STA_SUPPORT //
 893                 }
 894 //
 895 // These two steps have been done when entering ATE_STOP mode.
 896 //
 897 #if 0
 898             RTUSBWriteBBPRegister(pAd, BBP_R22, BbpData);
 899                 RTUSBWriteMACRegister(pAd, MAC_SYS_CTRL, MacData);
 900 #endif
 901                 // Clean ATE Bulk in/out counter and continue setup.
 902                 InterlockedExchange(&pAd->BulkOutRemained, 0);
 903                 NdisAcquireSpinLock(&pAd->GenericLock);
 904                 pAd->ContinBulkOut = FALSE;
 905                 pAd->ContinBulkIn = FALSE;
 906                 NdisReleaseSpinLock(&pAd->GenericLock);
 907
 908                 /* Wait 50ms to prevent next URB to bulkout during HW reset. */
 909                 /* todo : remove this if not necessary */
 910                 NdisMSleep(50000);
 911
 912                 pAd->ate.Mode = ATE_STOP;
 913
 914                 // Enable Tx
 915                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 916                 Value |= (1 << 2);
 917                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 918
 919 /*=========================================================================*/
 920                 /* restore RX_FILTR_CFG */
 921 #ifdef CONFIG_STA_SUPPORT
 922                 /* restore RX_FILTR_CFG in order that QA maybe set it to 0x3 */
 923                 RTMP_IO_WRITE32(pAd, RX_FILTR_CFG, STANORMAL);
 924 #endif // CONFIG_STA_SUPPORT //
 925 /*=========================================================================*/
 926
 927                 // Enable Tx, RX DMA.
 928                 RtmpDmaEnable(pAd, 1);
 929
 930                 // Enable Rx
 931                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 932                 Value |= (1 << 3);
 933                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 934
 935                 // Wait 10ms to wait all of the bulk-in URBs to complete.
 936                 /* todo : remove this if not necessary */
 937                 NdisMSleep(10000);
 938
 939                 // Everything is ready to start normal Tx/Rx.
 940                 RTUSBBulkReceive(pAd);
 941                 netif_start_queue(pAd->net_dev);
 942
 943                 ATEDBGPRINT(RT_DEBUG_TRACE, ("<=== ATE : ATESTOP \n"));
 944         }
 945         else if (!strcmp(arg, "TXCARR"))        // Tx Carrier
 946         {
 947                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: TXCARR\n"));
 948                 pAd->ate.Mode |= ATE_TXCARR;
 949
 950                 // Disable Rx
 951                 // May be we need not to do this, because these have been done in ATE_START mode ???
 952                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 953                 Value &= ~(1 << 3);
 954                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 955
 956                 // QA has done the following steps if it is used.
 957                 if (pAd->ate.bQATxStart == FALSE)
 958                 {
 959                         // Soft reset BBP.
 960                         BbpSoftReset(pAd);
 961
 962                         // Carrier Test set BBP R22 bit7=1, bit6=1, bit[5~0]=0x01
 963                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
 964                         BbpData &= 0xFFFFFF00; //clear bit7, bit6, bit[5~0]
 965                         BbpData |= 0x000000C1; //set bit7=1, bit6=1, bit[5~0]=0x01
 966                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 967
 968                         // set MAC_SYS_CTRL(0x1004) Continuous Tx Production Test (bit4) = 1
 969                         RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
 970                         Value = Value | 0x00000010;
 971                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
 972                 }
 973         }
 974         else if (!strcmp(arg, "TXCONT"))        // Tx Continue
 975         {
 976                 if (pAd->ate.bQATxStart == TRUE)
 977                 {
 978                         /* set MAC_SYS_CTRL(0x1004) bit4(Continuous Tx Production Test)
 979                            and bit2(MAC TX enable) back to zero. */
 980                         RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
 981                         MacData &= 0xFFFFFFEB;
 982                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);
 983
 984                         // set BBP R22 bit7=0
 985                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
 986                         BbpData &= 0xFFFFFF7F; //set bit7=0
 987                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
 988                 }
 989
 990                 /* for TxCont mode.
 991                 ** Step 1: Send 50 packets first then wait for a moment.
 992                 ** Step 2: Send more 50 packet then start continue mode.
 993                 */
 994                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: TXCONT\n"));
 995                 // Step 1: send 50 packets first.
 996                 pAd->ate.Mode |= ATE_TXCONT;
 997                 pAd->ate.TxCount = 50;
 998                 pAd->ate.TxDoneCount = 0;
 999
1000                 // Soft reset BBP.
1001                 BbpSoftReset(pAd);
1002
1003                 // Abort Tx, RX DMA.
1004                 RtmpDmaEnable(pAd, 0);
1005
1006
1007                 /* Only needed if we have to send some normal frames. */
1008                 SetJapanFilter(pAd);
1009
1010                 // Setup frame format.
1011                 ATESetUpFrame(pAd, 0);
1012
1013                 // Enable Tx
1014                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1015                 Value |= (1 << 2);
1016                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1017
1018                 // Disable Rx
1019                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1020                 Value &= ~(1 << 3);
1021                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1022
1023                 // Start Tx, RX DMA.
1024                 RtmpDmaEnable(pAd, 1);
1025
1026                 InterlockedExchange(&pAd->BulkOutRemained, pAd->ate.TxCount);
1027
1028 #ifdef  RALINK_28xx_QA
1029                 if (pAd->ate.bQATxStart == TRUE)
1030                 {
1031                         pAd->ate.TxStatus = 1;
1032                         //pAd->ate.Repeat = 0;
1033                 }
1034 #endif  // RALINK_28xx_QA //
1035
1036                 NdisAcquireSpinLock(&pAd->GenericLock);//0820
1037                 pAd->ContinBulkOut = FALSE;
1038                 NdisReleaseSpinLock(&pAd->GenericLock);
1039
1040                 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
1041
1042                 // Kick bulk out
1043                 RTUSBKickBulkOut(pAd);
1044
1045                 /* To make sure all the 50 frames have been bulk out before executing step 2 */
1046                 while (atomic_read(&pAd->BulkOutRemained) > 0)
1047                 {
1048                         RTMPusecDelay(5000);
1049                 }
1050
1051                 // Step 2: send more 50 packets then start continue mode.
1052                 // Abort Tx, RX DMA.
1053                 RtmpDmaEnable(pAd, 0);
1054
1055                 // Cont. TX set BBP R22 bit7=1
1056                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
1057                 BbpData |= 0x00000080; //set bit7=1
1058                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
1059
1060                 pAd->ate.TxCount = 50;
1061                 pAd->ate.TxDoneCount = 0;
1062
1063                 SetJapanFilter(pAd);
1064
1065                 // Setup frame format.
1066                 ATESetUpFrame(pAd, 0);
1067
1068                 // Enable Tx
1069                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1070                 Value |= (1 << 2);
1071                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1072
1073                 // Disable Rx
1074                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1075                 Value &= ~(1 << 3);
1076
1077                 // Start Tx, RX DMA.
1078                 RtmpDmaEnable(pAd, 1);
1079
1080                 InterlockedExchange(&pAd->BulkOutRemained, pAd->ate.TxCount);
1081
1082 #ifdef  RALINK_28xx_QA
1083                 if (pAd->ate.bQATxStart == TRUE)
1084                 {
1085                         pAd->ate.TxStatus = 1;
1086                         //pAd->ate.Repeat = 0;
1087                 }
1088 #endif  // RALINK_28xx_QA //
1089
1090                 NdisAcquireSpinLock(&pAd->GenericLock);//0820
1091                 pAd->ContinBulkOut = FALSE;
1092                 NdisReleaseSpinLock(&pAd->GenericLock);
1093
1094                 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
1095                 // Kick bulk out
1096                 RTUSBKickBulkOut(pAd);
1097
1098 #if 1
1099                 RTMPusecDelay(500);
1100 #else
1101                 while (atomic_read(&pAd->BulkOutRemained) > 0)
1102                 {
1103                         RTMPusecDelay(5000);
1104                 }
1105 #endif // 1 //
1106
1107                 // Set MAC_SYS_CTRL(0x1004) Continuous Tx Production Test (bit4) = 1.
1108                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
1109                 MacData |= 0x00000010;
1110                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);
1111         }
1112         else if (!strcmp(arg, "TXFRAME"))       // Tx Frames
1113         {
1114                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: TXFRAME(Count=0x%08x)\n", pAd->ate.TxCount));
1115                 pAd->ate.Mode |= ATE_TXFRAME;
1116
1117                 // Soft reset BBP.
1118                 BbpSoftReset(pAd);
1119
1120                 // Default value in BBP R22 is 0x0.
1121                 BbpData = 0;
1122
1123                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
1124
1125                 // Clean bit4 to stop continuous Tx production test.
1126                 MacData &= 0xFFFFFFEF;
1127
1128                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
1129                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);
1130
1131 #ifdef RALINK_28xx_QA
1132                 // add this for LoopBack mode
1133                 if (pAd->ate.bQARxStart == FALSE)
1134                 {
1135                         // Disable Rx
1136                         RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1137                         Value &= ~(1 << 3);
1138                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1139                 }
1140
1141                 if (pAd->ate.bQATxStart == TRUE)
1142                 {
1143                         pAd->ate.TxStatus = 1;
1144                         //pAd->ate.Repeat = 0;
1145                 }
1146 #else
1147                 // Disable Rx
1148                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1149                 Value &= ~(1 << 3);
1150                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1151 #endif // RALINK_28xx_QA //
1152
1153                 // Enable Tx
1154                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1155                 Value |= (1 << 2);
1156                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1157
1158         SetJapanFilter(pAd);
1159
1160                 // Abort Tx, RX DMA.
1161                 RtmpDmaEnable(pAd, 0);
1162
1163                 pAd->ate.TxDoneCount = 0;
1164
1165         // Setup frame format
1166                 ATESetUpFrame(pAd, 0);
1167
1168                 // Start Tx, RX DMA.
1169                 RtmpDmaEnable(pAd, 1);
1170
1171                 // Check count is continuous or not yet.
1172                 //
1173                 // Due to the type mismatch between "pAd->BulkOutRemained"(atomic_t) and "pAd->ate.TxCount"(UINT32)
1174                 //
1175                 if (pAd->ate.TxCount == 0)
1176                 {
1177                         InterlockedExchange(&pAd->BulkOutRemained, 0);
1178                 }
1179                 else
1180                 {
1181                         InterlockedExchange(&pAd->BulkOutRemained, pAd->ate.TxCount);
1182                 }
1183                 ATEDBGPRINT(RT_DEBUG_TRACE, ("bulk out count = %d\n", atomic_read(&pAd->BulkOutRemained)));
1184                 ASSERT((atomic_read(&pAd->BulkOutRemained) >= 0));
1185
1186                 if (atomic_read(&pAd->BulkOutRemained) == 0)
1187                 {
1188                         ATEDBGPRINT(RT_DEBUG_TRACE, ("Send packet countinuously\n"));
1189
1190                         /* In 28xx, NdisAcquireSpinLock() == spin_lock_bh() */
1191                         /* NdisAcquireSpinLock only need one argument in 28xx. */
1192                         NdisAcquireSpinLock(&pAd->GenericLock);
1193                         pAd->ContinBulkOut = TRUE;
1194                         NdisReleaseSpinLock(&pAd->GenericLock);
1195
1196                         /* In 28xx, BULK_OUT_LOCK() == spin_lock_irqsave() */
1197                         BULK_OUT_LOCK(&pAd->BulkOutLock[0], IrqFlags);// peter : NdisAcquireSpinLock ==> BULK_OUT_LOCK
1198                         pAd->BulkOutPending[0] = FALSE;
1199                         BULK_OUT_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);// peter : NdisAcquireSpinLock ==> BULK_OUT_LOCK
1200                 }
1201                 else
1202                 {
1203                         ATEDBGPRINT(RT_DEBUG_TRACE, ("Send packets depend on counter\n"));
1204
1205                         NdisAcquireSpinLock(&pAd->GenericLock);
1206                         pAd->ContinBulkOut = FALSE;
1207                         NdisReleaseSpinLock(&pAd->GenericLock);
1208
1209                         BULK_OUT_LOCK(&pAd->BulkOutLock[0], IrqFlags);
1210                         pAd->BulkOutPending[0] = FALSE;
1211                         BULK_OUT_UNLOCK(&pAd->BulkOutLock[0], IrqFlags);
1212                 }
1213
1214                 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
1215
1216                 // Kick bulk out
1217                 RTUSBKickBulkOut(pAd);
1218         }
1219 #ifdef RALINK_28xx_QA
1220         else if (!strcmp(arg, "TXSTOP"))                //Enter ATE mode and set Tx/Rx Idle
1221         {
1222                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: TXSTOP\n"));
1223
1224                 atemode = pAd->ate.Mode;
1225                 pAd->ate.Mode &= ATE_TXSTOP;
1226                 pAd->ate.bQATxStart = FALSE;
1227 //              pAd->ate.TxDoneCount = pAd->ate.TxCount;
1228
1229 /*=========================================================================*/
1230                 if (atemode & ATE_TXCARR)
1231                 {
1232                         // No Carrier Test set BBP R22 bit7=0, bit6=0, bit[5~0]=0x0
1233                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
1234                         BbpData &= 0xFFFFFF00; //clear bit7, bit6, bit[5~0]
1235                     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
1236                 }
1237                 else if (atemode & ATE_TXCARRSUPP)
1238                 {
1239                         // No Cont. TX set BBP R22 bit7=0
1240                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
1241                         BbpData &= ~(1 << 7); //set bit7=0
1242                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
1243
1244                         // No Carrier Suppression set BBP R24 bit0=0
1245                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R24, &BbpData);
1246                         BbpData &= 0xFFFFFFFE; //clear bit0
1247                     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R24, BbpData);
1248                 }
1249                 else if ((atemode & ATE_TXFRAME) || (atemode == ATE_STOP))
1250                 {
1251                         if (atemode & ATE_TXCONT)
1252                         {
1253                                 // No Cont. TX set BBP R22 bit7=0
1254                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R22, &BbpData);
1255                                 BbpData &= ~(1 << 7); //set bit7=0
1256                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
1257                         }
1258                 }
1259
1260 /*=========================================================================*/
1261                 RTUSBRejectPendingPackets(pAd);
1262                 RTUSBCleanUpDataBulkOutQueue(pAd);
1263
1264                 /* not used in RT28xx */
1265                 //RTUSBCleanUpMLMEWaitQueue(pAd);
1266                 /* empty function so far */
1267                 RTUSBCleanUpMLMEBulkOutQueue(pAd);
1268 /*=========================================================================*/
1269                 // Abort Tx, RX DMA.
1270                 RtmpDmaEnable(pAd, 0);
1271 /*=========================================================================*/
1272
1273                 /* In 28xx, pAd->PendingRx is not of type atomic_t anymore */
1274 //              while ((atomic_read(&pAd->PendingRx) > 0))      //pAd->BulkFlags != 0 wait bulk out finish
1275                 /* peter todo : BulkInLock */
1276                 while (pAd->PendingRx > 0)
1277                 {
1278 #if 1
1279                         ATE_RTUSBCancelPendingBulkInIRP(pAd);
1280 #else
1281 //                      NdisInterlockedDecrement(&pAd->PendingRx);
1282                         pAd->PendingRx--;
1283 #endif
1284                         RTMPusecDelay(500000);
1285                 }
1286
1287                 while (((pAd->BulkOutPending[0] == TRUE) ||
1288                                 (pAd->BulkOutPending[1] == TRUE) ||
1289                                 (pAd->BulkOutPending[2] == TRUE) ||
1290                                 (pAd->BulkOutPending[3] == TRUE)) && (pAd->BulkFlags != 0))     //pAd->BulkFlags != 0 wait bulk out finish
1291                 {
1292                         do
1293                         {
1294                                 RTUSBCancelPendingBulkOutIRP(pAd);
1295                         } while (FALSE);
1296
1297                         RTMPusecDelay(500000);
1298                 }
1299
1300                 ASSERT(pAd->PendingRx == 0);
1301 /*=========================================================================*/
1302                 // Enable Tx, Rx DMA.
1303                 RtmpDmaEnable(pAd, 1);
1304
1305                 /* task Tx status : 0 --> task is idle, 1 --> task is running */
1306                 pAd->ate.TxStatus = 0;
1307
1308                 // Soft reset BBP.
1309                 BbpSoftReset(pAd);
1310
1311                 // Disable Tx
1312                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
1313                 MacData &= (0xfffffffb);
1314                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);
1315
1316                 //Clean ATE Bulk in/out counter and continue setup
1317                 InterlockedExchange(&pAd->BulkOutRemained, 0);
1318
1319                 pAd->ContinBulkOut = FALSE;
1320         }
1321         else if (!strcmp(arg, "RXSTOP"))
1322         {
1323                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: RXSTOP\n"));
1324                 atemode = pAd->ate.Mode;
1325
1326                 // Disable Rx
1327                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1328                 Value &= ~(1 << 3);
1329                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1330
1331                 pAd->ate.Mode &= ATE_RXSTOP;
1332                 pAd->ate.bQARxStart = FALSE;
1333 //              pAd->ate.TxDoneCount = pAd->ate.TxCount;
1334
1335 /*=========================================================================*/
1336                 RTUSBRejectPendingPackets(pAd);
1337                 RTUSBCleanUpDataBulkOutQueue(pAd);
1338
1339                 /* not used in RT28xx */
1340                 //RTUSBCleanUpMLMEWaitQueue(pAd);
1341                 RTUSBCleanUpMLMEBulkOutQueue(pAd);
1342 /*=========================================================================*/
1343
1344                 // Abort Tx, RX DMA.
1345                 RtmpDmaEnable(pAd, 0);
1346 /*=========================================================================*/
1347 //              while ((atomic_read(&pAd->PendingRx) > 0))
1348                 while (pAd->PendingRx > 0)
1349                 {
1350 #if 1
1351                         ATE_RTUSBCancelPendingBulkInIRP(pAd);
1352 #else
1353 //                      NdisInterlockedDecrement(&pAd->PendingRx);
1354                         pAd->PendingRx--;
1355 #endif
1356                         RTMPusecDelay(500000);
1357                 }
1358
1359                 while (((pAd->BulkOutPending[0] == TRUE) ||
1360                                 (pAd->BulkOutPending[1] == TRUE) ||
1361                                 (pAd->BulkOutPending[2] == TRUE) ||
1362                                 (pAd->BulkOutPending[3] == TRUE)) && (pAd->BulkFlags != 0))     //pAd->BulkFlags != 0 wait bulk out finish
1363                 {
1364                         do
1365                         {
1366                                 RTUSBCancelPendingBulkOutIRP(pAd);
1367                         } while (FALSE);
1368
1369                         RTMPusecDelay(500000);
1370                 }
1371
1372                 ASSERT(pAd->PendingRx == 0);
1373 /*=========================================================================*/
1374
1375                 // Soft reset BBP.
1376                 BbpSoftReset(pAd);
1377                 pAd->ContinBulkIn = FALSE;
1378         }
1379 #endif // RALINK_28xx_QA //
1380         else if (!strcmp(arg, "RXFRAME")) // Rx Frames
1381         {
1382                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: RXFRAME\n"));
1383
1384                 // Disable Rx of MAC block
1385                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1386                 Value &= ~(1 << 3);
1387                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1388
1389                 // Default value in BBP R22 is 0x0.
1390                 BbpData = 0;
1391
1392                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &MacData);
1393                 // Clean bit4 to stop continuous Tx production test.
1394                 MacData &= 0xFFFFFFEF;
1395
1396                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R22, BbpData);
1397                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, MacData);
1398
1399                 pAd->ate.Mode |= ATE_RXFRAME;
1400
1401                 // Abort Tx, RX DMA.
1402                 RtmpDmaEnable(pAd, 0);
1403
1404                 // Disable TX of MAC block
1405                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1406                 Value &= ~(1 << 2);
1407                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1408
1409         // Reset Rx RING.
1410                 for ( i = 0; i < (RX_RING_SIZE); i++)
1411                 {
1412                         PRX_CONTEXT  pRxContext = &(pAd->RxContext[i]);
1413
1414                         pRxContext->InUse = FALSE;
1415                         pRxContext->IRPPending = FALSE;
1416                         pRxContext->Readable = FALSE;
1417
1418                         //
1419                         // Get the urb from kernel back to driver.
1420                         //
1421                         RTUSB_UNLINK_URB(pRxContext->pUrb);
1422
1423                         /* Sleep 200 microsecs to give cancellation time to work. */
1424                         NdisMSleep(200);
1425                         pAd->BulkInReq = 0;
1426
1427 //                      InterlockedExchange(&pAd->PendingRx, 0);
1428                         pAd->PendingRx = 0;
1429                         pAd->NextRxBulkInReadIndex = 0; // Next Rx Read index
1430                         pAd->NextRxBulkInIndex          = RX_RING_SIZE - 1;     // Rx Bulk pointer
1431                         pAd->NextRxBulkInPosition = 0;
1432                 }
1433
1434                 // read to clear counters
1435                 RTUSBReadMACRegister(pAd, RX_STA_CNT0, &temp); //RX PHY & RX CRC count
1436                 RTUSBReadMACRegister(pAd, RX_STA_CNT1, &temp); //RX PLCP error count & CCA false alarm count
1437                 RTUSBReadMACRegister(pAd, RX_STA_CNT2, &temp); //RX FIFO overflow frame count & RX duplicated filtered frame count
1438
1439                 pAd->ContinBulkIn = TRUE;
1440
1441                 // Enable Tx, RX DMA.
1442                 RtmpDmaEnable(pAd, 1);
1443
1444                 // Enable RX of MAC block
1445                 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
1446                 Value |= (1 << 3);
1447                 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
1448
1449                 // Kick bulk in
1450                 RTUSBBulkReceive(pAd);
1451         }
1452         else
1453         {
1454                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ATE: Invalid arg!\n"));
1455                 return FALSE;
1456         }
1457         RTMPusecDelay(5000);
1458
1459         ATEDBGPRINT(RT_DEBUG_TRACE, ("<=== ATECmdHandler()\n"));
1460
1461         return TRUE;
1462 }
1463 #endif // RT2870 //
1464
1465 INT     Set_ATE_Proc(
1466         IN      PRTMP_ADAPTER   pAd,
1467         IN      PUCHAR                  arg)
1468 {
1469         if (ATECmdHandler(pAd, arg))
1470         {
1471                 ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_Proc Success\n"));
1472
1473
1474                 return TRUE;
1475         }
1476         else
1477         {
1478                 ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_Proc Failed\n"));
1479                 return FALSE;
1480         }
1481 }
1482
1483 /*
1484     ==========================================================================
1485     Description:
1486         Set ATE ADDR1=DA for TxFrame(AP  : To DS = 0 ; From DS = 1)
1487         or
1488         Set ATE ADDR3=DA for TxFrame(STA : To DS = 1 ; From DS = 0)
1489
1490     Return:
1491         TRUE if all parameters are OK, FALSE otherwise
1492     ==========================================================================
1493 */
1494 INT     Set_ATE_DA_Proc(
1495         IN      PRTMP_ADAPTER   pAd,
1496         IN      PUCHAR                  arg)
1497 {
1498         CHAR                            *value;
1499         INT                                     i;
1500
1501         if(strlen(arg) != 17)  //Mac address acceptable format 01:02:03:04:05:06 length 17
1502                 return FALSE;
1503
1504     for (i=0, value = rstrtok(arg, ":"); value; value = rstrtok(NULL, ":"))
1505         {
1506                 if((strlen(value) != 2) || (!isxdigit(*value)) || (!isxdigit(*(value+1))) )
1507                         return FALSE;  //Invalid
1508
1509
1510 #ifdef CONFIG_STA_SUPPORT
1511                 AtoH(value, &pAd->ate.Addr3[i++], 1);
1512 #endif // CONFIG_STA_SUPPORT //
1513         }
1514
1515         if(i != 6)
1516                 return FALSE;  //Invalid
1517
1518
1519 #ifdef CONFIG_STA_SUPPORT
1520         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_DA_Proc (DA = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAd->ate.Addr3[0],
1521                 pAd->ate.Addr3[1], pAd->ate.Addr3[2], pAd->ate.Addr3[3], pAd->ate.Addr3[4], pAd->ate.Addr3[5]));
1522 #endif // CONFIG_STA_SUPPORT //
1523
1524         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_DA_Proc Success\n"));
1525
1526         return TRUE;
1527 }
1528
1529 /*
1530     ==========================================================================
1531     Description:
1532         Set ATE ADDR3=SA for TxFrame(AP  : To DS = 0 ; From DS = 1)
1533         or
1534         Set ATE ADDR2=SA for TxFrame(STA : To DS = 1 ; From DS = 0)
1535
1536     Return:
1537         TRUE if all parameters are OK, FALSE otherwise
1538     ==========================================================================
1539 */
1540 INT     Set_ATE_SA_Proc(
1541         IN      PRTMP_ADAPTER   pAd,
1542         IN      PUCHAR                  arg)
1543 {
1544         CHAR                            *value;
1545         INT                                     i;
1546
1547         if(strlen(arg) != 17)  //Mac address acceptable format 01:02:03:04:05:06 length 17
1548                 return FALSE;
1549
1550     for (i=0, value = rstrtok(arg, ":"); value; value = rstrtok(NULL, ":"))
1551         {
1552                 if((strlen(value) != 2) || (!isxdigit(*value)) || (!isxdigit(*(value+1))) )
1553                         return FALSE;  //Invalid
1554
1555
1556 #ifdef CONFIG_STA_SUPPORT
1557                 AtoH(value, &pAd->ate.Addr2[i++], 1);
1558 #endif // CONFIG_STA_SUPPORT //
1559         }
1560
1561         if(i != 6)
1562                 return FALSE;  //Invalid
1563
1564
1565 #ifdef CONFIG_STA_SUPPORT
1566         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_SA_Proc (SA = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAd->ate.Addr2[0],
1567                 pAd->ate.Addr2[1], pAd->ate.Addr2[2], pAd->ate.Addr2[3], pAd->ate.Addr2[4], pAd->ate.Addr2[5]));
1568 #endif // CONFIG_STA_SUPPORT //
1569
1570         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_SA_Proc Success\n"));
1571
1572         return TRUE;
1573 }
1574
1575 /*
1576     ==========================================================================
1577     Description:
1578         Set ATE ADDR2=BSSID for TxFrame(AP  : To DS = 0 ; From DS = 1)
1579         or
1580         Set ATE ADDR1=BSSID for TxFrame(STA : To DS = 1 ; From DS = 0)
1581
1582     Return:
1583         TRUE if all parameters are OK, FALSE otherwise
1584     ==========================================================================
1585 */
1586 INT     Set_ATE_BSSID_Proc(
1587         IN      PRTMP_ADAPTER   pAd,
1588         IN      PUCHAR                  arg)
1589 {
1590         CHAR                            *value;
1591         INT                                     i;
1592
1593         if(strlen(arg) != 17)  //Mac address acceptable format 01:02:03:04:05:06 length 17
1594                 return FALSE;
1595
1596     for (i=0, value = rstrtok(arg, ":"); value; value = rstrtok(NULL, ":"))
1597         {
1598                 if((strlen(value) != 2) || (!isxdigit(*value)) || (!isxdigit(*(value+1))) )
1599                         return FALSE;  //Invalid
1600
1601
1602 #ifdef CONFIG_STA_SUPPORT
1603                 AtoH(value, &pAd->ate.Addr1[i++], 1);
1604 #endif // CONFIG_STA_SUPPORT //
1605         }
1606
1607         if(i != 6)
1608                 return FALSE;  //Invalid
1609
1610
1611 #ifdef CONFIG_STA_SUPPORT
1612         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_BSSID_Proc (BSSID = %2X:%2X:%2X:%2X:%2X:%2X)\n",  pAd->ate.Addr1[0],
1613                 pAd->ate.Addr1[1], pAd->ate.Addr1[2], pAd->ate.Addr1[3], pAd->ate.Addr1[4], pAd->ate.Addr1[5]));
1614 #endif // CONFIG_STA_SUPPORT //
1615
1616         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_BSSID_Proc Success\n"));
1617
1618         return TRUE;
1619 }
1620
1621 /*
1622     ==========================================================================
1623     Description:
1624         Set ATE Tx Channel
1625
1626     Return:
1627         TRUE if all parameters are OK, FALSE otherwise
1628     ==========================================================================
1629 */
1630 INT     Set_ATE_CHANNEL_Proc(
1631         IN      PRTMP_ADAPTER   pAd,
1632         IN      PUCHAR                  arg)
1633 {
1634         UCHAR channel;
1635
1636         channel = simple_strtol(arg, 0, 10);
1637
1638         if ((channel < 1) || (channel > 216))// to allow A band channel : ((channel < 1) || (channel > 14))
1639         {
1640                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_CHANNEL_Proc::Out of range, it should be in range of 1~14.\n"));
1641                 return FALSE;
1642         }
1643         pAd->ate.Channel = channel;
1644
1645         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_CHANNEL_Proc (ATE Channel = %d)\n", pAd->ate.Channel));
1646         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_CHANNEL_Proc Success\n"));
1647
1648
1649         return TRUE;
1650 }
1651
1652 /*
1653     ==========================================================================
1654     Description:
1655         Set ATE Tx Power0
1656
1657     Return:
1658         TRUE if all parameters are OK, FALSE otherwise
1659     ==========================================================================
1660 */
1661 INT     Set_ATE_TX_POWER0_Proc(
1662         IN      PRTMP_ADAPTER   pAd,
1663         IN      PUCHAR                  arg)
1664 {
1665         CHAR TxPower;
1666
1667         TxPower = simple_strtol(arg, 0, 10);
1668
1669         if (pAd->ate.Channel <= 14)
1670         {
1671                 if ((TxPower > 31) || (TxPower < 0))
1672                 {
1673                         ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_POWER0_Proc::Out of range (Value=%d)\n", TxPower));
1674                         return FALSE;
1675                 }
1676         }
1677         else// 5.5GHz
1678         {
1679                 if ((TxPower > 15) || (TxPower < -7))
1680                 {
1681                         ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_POWER0_Proc::Out of range (Value=%d)\n", TxPower));
1682                         return FALSE;
1683                 }
1684         }
1685
1686         pAd->ate.TxPower0 = TxPower;
1687         ATETxPwrHandler(pAd, 0);
1688         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_POWER0_Proc Success\n"));
1689
1690
1691         return TRUE;
1692 }
1693
1694 /*
1695     ==========================================================================
1696     Description:
1697         Set ATE Tx Power1
1698
1699     Return:
1700         TRUE if all parameters are OK, FALSE otherwise
1701     ==========================================================================
1702 */
1703 INT     Set_ATE_TX_POWER1_Proc(
1704         IN      PRTMP_ADAPTER   pAd,
1705         IN      PUCHAR                  arg)
1706 {
1707         CHAR TxPower;
1708
1709         TxPower = simple_strtol(arg, 0, 10);
1710
1711         if (pAd->ate.Channel <= 14)
1712         {
1713         if ((TxPower > 31) || (TxPower < 0))
1714         {
1715                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_POWER1_Proc::Out of range (Value=%d)\n", TxPower));
1716                 return FALSE;
1717         }
1718         }
1719         else
1720         {
1721                 if ((TxPower > 15) || (TxPower < -7))
1722                 {
1723                         ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_POWER1_Proc::Out of range (Value=%d)\n", TxPower));
1724                         return FALSE;
1725                 }
1726         }
1727
1728         pAd->ate.TxPower1 = TxPower;
1729         ATETxPwrHandler(pAd, 1);
1730         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_POWER1_Proc Success\n"));
1731
1732
1733         return TRUE;
1734 }
1735
1736 /*
1737     ==========================================================================
1738     Description:
1739         Set ATE Tx Antenna
1740
1741     Return:
1742         TRUE if all parameters are OK, FALSE otherwise
1743     ==========================================================================
1744 */
1745 INT     Set_ATE_TX_Antenna_Proc(
1746         IN      PRTMP_ADAPTER   pAd,
1747         IN      PUCHAR                  arg)
1748 {
1749         CHAR value;
1750
1751         value = simple_strtol(arg, 0, 10);
1752
1753         if ((value > 2) || (value < 0))
1754         {
1755                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_Antenna_Proc::Out of range (Value=%d)\n", value));
1756                 return FALSE;
1757         }
1758
1759         pAd->ate.TxAntennaSel = value;
1760
1761         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_Antenna_Proc (Antenna = %d)\n", pAd->ate.TxAntennaSel));
1762         ATEDBGPRINT(RT_DEBUG_TRACE,("Ralink: Set_ATE_TX_Antenna_Proc Success\n"));
1763
1764
1765         return TRUE;
1766 }
1767
1768 /*
1769     ==========================================================================
1770     Description:
1771         Set ATE Rx Antenna
1772
1773     Return:
1774         TRUE if all parameters are OK, FALSE otherwise
1775     ==========================================================================
1776 */
1777 INT     Set_ATE_RX_Antenna_Proc(
1778         IN      PRTMP_ADAPTER   pAd,
1779         IN      PUCHAR                  arg)
1780 {
1781         CHAR value;
1782
1783         value = simple_strtol(arg, 0, 10);
1784
1785         if ((value > 3) || (value < 0))
1786         {
1787                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_RX_Antenna_Proc::Out of range (Value=%d)\n", value));
1788                 return FALSE;
1789         }
1790
1791         pAd->ate.RxAntennaSel = value;
1792
1793         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_RX_Antenna_Proc (Antenna = %d)\n", pAd->ate.RxAntennaSel));
1794         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_RX_Antenna_Proc Success\n"));
1795
1796
1797         return TRUE;
1798 }
1799
1800 /*
1801     ==========================================================================
1802     Description:
1803         Set ATE RF frequence offset
1804
1805     Return:
1806         TRUE if all parameters are OK, FALSE otherwise
1807     ==========================================================================
1808 */
1809 INT     Set_ATE_TX_FREQOFFSET_Proc(
1810         IN      PRTMP_ADAPTER   pAd,
1811         IN      PUCHAR                  arg)
1812 {
1813         UCHAR RFFreqOffset;
1814         ULONG R4;
1815
1816         RFFreqOffset = simple_strtol(arg, 0, 10);
1817
1818         if(RFFreqOffset >= 64)
1819         {
1820                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_FREQOFFSET_Proc::Out of range, it should be in range of 0~63.\n"));
1821                 return FALSE;
1822         }
1823
1824         pAd->ate.RFFreqOffset = RFFreqOffset;
1825         R4 = pAd->ate.RFFreqOffset << 15;               // shift TX power control to correct RF register bit position
1826         R4 |= (pAd->LatchRfRegs.R4 & ((~0x001f8000)));
1827         pAd->LatchRfRegs.R4 = R4;
1828
1829         RtmpRfIoWrite(pAd);
1830
1831         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_FREQOFFSET_Proc (RFFreqOffset = %d)\n", pAd->ate.RFFreqOffset));
1832         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_FREQOFFSET_Proc Success\n"));
1833
1834
1835         return TRUE;
1836 }
1837
1838 /*
1839     ==========================================================================
1840     Description:
1841         Set ATE RF BW
1842
1843     Return:
1844         TRUE if all parameters are OK, FALSE otherwise
1845     ==========================================================================
1846 */
1847 INT     Set_ATE_TX_BW_Proc(
1848         IN      PRTMP_ADAPTER   pAd,
1849         IN      PUCHAR                  arg)
1850 {
1851         int i;
1852         UCHAR value = 0;
1853         UCHAR BBPCurrentBW;
1854
1855         BBPCurrentBW = simple_strtol(arg, 0, 10);
1856
1857         if(BBPCurrentBW == 0)
1858                 pAd->ate.TxWI.BW = BW_20;
1859         else
1860                 pAd->ate.TxWI.BW = BW_40;
1861
1862         if(pAd->ate.TxWI.BW == BW_20)
1863         {
1864                 if(pAd->ate.Channel <= 14)
1865                 {
1866                 for (i=0; i<5; i++)
1867                 {
1868                                 if (pAd->Tx20MPwrCfgGBand[i] != 0xffffffff)
1869                                 {
1870                                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, pAd->Tx20MPwrCfgGBand[i]);
1871                                         RTMPusecDelay(5000);
1872                                 }
1873                         }
1874                 }
1875                 else
1876                 {
1877                         for (i=0; i<5; i++)
1878                         {
1879                                 if (pAd->Tx20MPwrCfgABand[i] != 0xffffffff)
1880                         {
1881                                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, pAd->Tx20MPwrCfgABand[i]);
1882                                 RTMPusecDelay(5000);
1883                         }
1884                 }
1885                 }
1886
1887                 //Set BBP R4 bit[4:3]=0:0
1888                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &value);
1889                 value &= (~0x18);
1890                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, value);
1891
1892                 //Set BBP R66=0x3C
1893                 value = 0x3C;
1894                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, value);
1895                 //Set BBP R68=0x0B
1896                 //to improve Rx sensitivity.
1897                 value = 0x0B;
1898                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R68, value);
1899                 //Set BBP R69=0x16
1900                 value = 0x16;
1901                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, value);
1902                 //Set BBP R70=0x08
1903                 value = 0x08;
1904                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, value);
1905                 //Set BBP R73=0x11
1906                 value = 0x11;
1907                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R73, value);
1908
1909             // If Channel=14, Bandwidth=20M and Mode=CCK, Set BBP R4 bit5=1
1910             // (Japan filter coefficients)
1911             // This segment of code will only works when ATETXMODE and ATECHANNEL
1912             // were set to MODE_CCK and 14 respectively before ATETXBW is set to 0.
1913             //=====================================================================
1914                 if (pAd->ate.Channel == 14)
1915                 {
1916                         int TxMode = pAd->ate.TxWI.PHYMODE;
1917                         if (TxMode == MODE_CCK)
1918                         {
1919                                 // when Channel==14 && Mode==CCK && BandWidth==20M, BBP R4 bit5=1
1920                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &value);
1921                                 value |= 0x20; //set bit5=1
1922                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, value);
1923                         }
1924                 }
1925
1926             //=====================================================================
1927                 // If bandwidth != 40M, RF Reg4 bit 21 = 0.
1928                 pAd->LatchRfRegs.R4 &= ~0x00200000;
1929                 RtmpRfIoWrite(pAd);
1930         }
1931         else if(pAd->ate.TxWI.BW == BW_40)
1932         {
1933                 if(pAd->ate.Channel <= 14)
1934                 {
1935                         for (i=0; i<5; i++)
1936                         {
1937                                 if (pAd->Tx40MPwrCfgGBand[i] != 0xffffffff)
1938                                 {
1939                                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, pAd->Tx40MPwrCfgGBand[i]);
1940                                         RTMPusecDelay(5000);
1941                                 }
1942                         }
1943                 }
1944                 else
1945                 {
1946                         for (i=0; i<5; i++)
1947                         {
1948                                 if (pAd->Tx40MPwrCfgABand[i] != 0xffffffff)
1949                                 {
1950                                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, pAd->Tx40MPwrCfgABand[i]);
1951                                         RTMPusecDelay(5000);
1952                                 }
1953                         }
1954 #ifdef DOT11_N_SUPPORT
1955                         if ((pAd->ate.TxWI.PHYMODE >= MODE_HTMIX) && (pAd->ate.TxWI.MCS == 7))
1956                         {
1957                         value = 0x28;
1958                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R67, value);
1959                         }
1960 #endif // DOT11_N_SUPPORT //
1961                 }
1962
1963                 //Set BBP R4 bit[4:3]=1:0
1964                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &value);
1965                 value &= (~0x18);
1966                 value |= 0x10;
1967                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, value);
1968
1969                 //Set BBP R66=0x3C
1970                 value = 0x3C;
1971                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, value);
1972                 //Set BBP R68=0x0C
1973                 //to improve Rx sensitivity.
1974                 value = 0x0C;
1975                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R68, value);
1976                 //Set BBP R69=0x1A
1977                 value = 0x1A;
1978                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, value);
1979                 //Set BBP R70=0x0A
1980                 value = 0x0A;
1981                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, value);
1982                 //Set BBP R73=0x16
1983                 value = 0x16;
1984                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R73, value);
1985
1986                 // If bandwidth = 40M, set RF Reg4 bit 21 = 1.
1987                 pAd->LatchRfRegs.R4 |= 0x00200000;
1988                 RtmpRfIoWrite(pAd);
1989         }
1990
1991         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_BW_Proc (BBPCurrentBW = %d)\n", pAd->ate.TxWI.BW));
1992         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_BW_Proc Success\n"));
1993
1994
1995         return TRUE;
1996 }
1997
1998 /*
1999     ==========================================================================
2000     Description:
2001         Set ATE Tx frame length
2002
2003     Return:
2004         TRUE if all parameters are OK, FALSE otherwise
2005     ==========================================================================
2006 */
2007 INT     Set_ATE_TX_LENGTH_Proc(
2008         IN      PRTMP_ADAPTER   pAd,
2009         IN      PUCHAR                  arg)
2010 {
2011         pAd->ate.TxLength = simple_strtol(arg, 0, 10);
2012
2013         if((pAd->ate.TxLength < 24) || (pAd->ate.TxLength > (MAX_FRAME_SIZE - 34/* == 2312 */)))
2014         {
2015                 pAd->ate.TxLength = (MAX_FRAME_SIZE - 34/* == 2312 */);
2016                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_LENGTH_Proc::Out of range, it should be in range of 24~%d.\n", (MAX_FRAME_SIZE - 34/* == 2312 */)));
2017                 return FALSE;
2018         }
2019
2020         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_LENGTH_Proc (TxLength = %d)\n", pAd->ate.TxLength));
2021         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_LENGTH_Proc Success\n"));
2022
2023
2024         return TRUE;
2025 }
2026
2027 /*
2028     ==========================================================================
2029     Description:
2030         Set ATE Tx frame count
2031
2032     Return:
2033         TRUE if all parameters are OK, FALSE otherwise
2034     ==========================================================================
2035 */
2036 INT     Set_ATE_TX_COUNT_Proc(
2037         IN      PRTMP_ADAPTER   pAd,
2038         IN      PUCHAR                  arg)
2039 {
2040         pAd->ate.TxCount = simple_strtol(arg, 0, 10);
2041
2042         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_COUNT_Proc (TxCount = %d)\n", pAd->ate.TxCount));
2043         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_COUNT_Proc Success\n"));
2044
2045
2046         return TRUE;
2047 }
2048
2049 /*
2050     ==========================================================================
2051     Description:
2052         Set ATE Tx frame MCS
2053
2054         Return:
2055                 TRUE if all parameters are OK, FALSE otherwise
2056     ==========================================================================
2057 */
2058 INT     Set_ATE_TX_MCS_Proc(
2059         IN      PRTMP_ADAPTER   pAd,
2060         IN      PUCHAR                  arg)
2061 {
2062         UCHAR MCS;
2063         int result;
2064
2065         MCS = simple_strtol(arg, 0, 10);
2066         result = CheckMCSValid(pAd->ate.TxWI.PHYMODE, MCS);
2067
2068         if (result != -1)
2069         {
2070                 pAd->ate.TxWI.MCS = (UCHAR)MCS;
2071         }
2072         else
2073         {
2074                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_MCS_Proc::Out of range, refer to rate table.\n"));
2075                 return FALSE;
2076         }
2077
2078         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_MCS_Proc (MCS = %d)\n", pAd->ate.TxWI.MCS));
2079         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_MCS_Proc Success\n"));
2080
2081
2082         return TRUE;
2083 }
2084
2085 /*
2086     ==========================================================================
2087     Description:
2088         Set ATE Tx frame Mode
2089         0: MODE_CCK
2090         1: MODE_OFDM
2091         2: MODE_HTMIX
2092         3: MODE_HTGREENFIELD
2093
2094         Return:
2095                 TRUE if all parameters are OK, FALSE otherwise
2096     ==========================================================================
2097 */
2098 INT     Set_ATE_TX_MODE_Proc(
2099         IN      PRTMP_ADAPTER   pAd,
2100         IN      PUCHAR                  arg)
2101 {
2102         pAd->ate.TxWI.PHYMODE = simple_strtol(arg, 0, 10);
2103
2104         if(pAd->ate.TxWI.PHYMODE > 3)
2105         {
2106                 pAd->ate.TxWI.PHYMODE = 0;
2107                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_MODE_Proc::Out of range. it should be in range of 0~3\n"));
2108                 ATEDBGPRINT(RT_DEBUG_ERROR, ("0: CCK, 1: OFDM, 2: HT_MIX, 3: HT_GREEN_FIELD.\n"));
2109                 return FALSE;
2110         }
2111
2112         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_MODE_Proc (TxMode = %d)\n", pAd->ate.TxWI.PHYMODE));
2113         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_MODE_Proc Success\n"));
2114
2115
2116         return TRUE;
2117 }
2118
2119 /*
2120     ==========================================================================
2121     Description:
2122         Set ATE Tx frame GI
2123
2124         Return:
2125                 TRUE if all parameters are OK, FALSE otherwise
2126     ==========================================================================
2127 */
2128 INT     Set_ATE_TX_GI_Proc(
2129         IN      PRTMP_ADAPTER   pAd,
2130         IN      PUCHAR                  arg)
2131 {
2132         pAd->ate.TxWI.ShortGI = simple_strtol(arg, 0, 10);
2133
2134         if(pAd->ate.TxWI.ShortGI > 1)
2135         {
2136                 pAd->ate.TxWI.ShortGI = 0;
2137                 ATEDBGPRINT(RT_DEBUG_ERROR, ("Set_ATE_TX_GI_Proc::Out of range\n"));
2138                 return FALSE;
2139         }
2140
2141         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_TX_GI_Proc (GI = %d)\n", pAd->ate.TxWI.ShortGI));
2142         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_TX_GI_Proc Success\n"));
2143
2144
2145         return TRUE;
2146 }
2147
2148 /*
2149     ==========================================================================
2150     Description:
2151     ==========================================================================
2152  */
2153 INT     Set_ATE_RX_FER_Proc(
2154         IN      PRTMP_ADAPTER   pAd,
2155         IN      PUCHAR                  arg)
2156 {
2157         pAd->ate.bRxFer = simple_strtol(arg, 0, 10);
2158
2159         if (pAd->ate.bRxFer == 1)
2160         {
2161                 pAd->ate.RxCntPerSec = 0;
2162                 pAd->ate.RxTotalCnt = 0;
2163         }
2164
2165         ATEDBGPRINT(RT_DEBUG_TRACE, ("Set_ATE_RX_FER_Proc (bRxFer = %d)\n", pAd->ate.bRxFer));
2166         ATEDBGPRINT(RT_DEBUG_TRACE, ("Ralink: Set_ATE_RX_FER_Proc Success\n"));
2167
2168
2169         return TRUE;
2170 }
2171
2172 INT Set_ATE_Read_RF_Proc(
2173         IN      PRTMP_ADAPTER   pAd,
2174         IN      PUCHAR                  arg)
2175 {
2176         ate_print(KERN_EMERG "R1 = %lx\n", pAd->LatchRfRegs.R1);
2177         ate_print(KERN_EMERG "R2 = %lx\n", pAd->LatchRfRegs.R2);
2178         ate_print(KERN_EMERG "R3 = %lx\n", pAd->LatchRfRegs.R3);
2179         ate_print(KERN_EMERG "R4 = %lx\n", pAd->LatchRfRegs.R4);
2180
2181         return TRUE;
2182 }
2183
2184 INT Set_ATE_Write_RF1_Proc(
2185         IN      PRTMP_ADAPTER   pAd,
2186         IN      PUCHAR                  arg)
2187 {
2188         UINT32 value = simple_strtol(arg, 0, 16);
2189
2190         pAd->LatchRfRegs.R1 = value;
2191         RtmpRfIoWrite(pAd);
2192
2193         return TRUE;
2194 }
2195
2196 INT Set_ATE_Write_RF2_Proc(
2197         IN      PRTMP_ADAPTER   pAd,
2198         IN      PUCHAR                  arg)
2199 {
2200         UINT32 value = simple_strtol(arg, 0, 16);
2201
2202         pAd->LatchRfRegs.R2 = value;
2203         RtmpRfIoWrite(pAd);
2204
2205         return TRUE;
2206 }
2207
2208 INT Set_ATE_Write_RF3_Proc(
2209         IN      PRTMP_ADAPTER   pAd,
2210         IN      PUCHAR                  arg)
2211 {
2212         UINT32 value = simple_strtol(arg, 0, 16);
2213
2214         pAd->LatchRfRegs.R3 = value;
2215         RtmpRfIoWrite(pAd);
2216
2217         return TRUE;
2218 }
2219
2220 INT Set_ATE_Write_RF4_Proc(
2221         IN      PRTMP_ADAPTER   pAd,
2222         IN      PUCHAR                  arg)
2223 {
2224         UINT32 value = simple_strtol(arg, 0, 16);
2225
2226         pAd->LatchRfRegs.R4 = value;
2227         RtmpRfIoWrite(pAd);
2228
2229         return TRUE;
2230 }
2231
2232 /*
2233     ==========================================================================
2234     Description:
2235         Load and Write EEPROM from a binary file prepared in advance.
2236
2237         Return:
2238                 TRUE if all parameters are OK, FALSE otherwise
2239     ==========================================================================
2240 */
2241 INT Set_ATE_Load_E2P_Proc(
2242         IN      PRTMP_ADAPTER   pAd,
2243         IN      PUCHAR                  arg)
2244 {
2245         BOOLEAN             ret = FALSE;
2246         PUCHAR                  src = EEPROM_BIN_FILE_NAME;
2247         struct file             *srcf;
2248         INT32                   retval, orgfsuid, orgfsgid;
2249         mm_segment_t    orgfs;
2250         USHORT                  WriteEEPROM[(EEPROM_SIZE/2)];
2251         UINT32                  FileLength = 0;
2252         UINT32                  value = simple_strtol(arg, 0, 10);
2253
2254         ATEDBGPRINT(RT_DEBUG_ERROR, ("===> %s (value=%d)\n\n", __func__, value));
2255
2256         if (value > 0)
2257         {
2258                 /* zero the e2p buffer */
2259                 NdisZeroMemory((PUCHAR)WriteEEPROM, EEPROM_SIZE);
2260
2261                 /* save uid and gid used for filesystem access.
2262             ** set user and group to 0 (root)
2263             */
2264                 orgfsuid = current->fsuid;
2265                 orgfsgid = current->fsgid;
2266                 /* as root */
2267                 current->fsuid = current->fsgid = 0;
2268         orgfs = get_fs();
2269         set_fs(KERNEL_DS);
2270
2271                 do
2272                 {
2273                         /* open the bin file */
2274                         srcf = filp_open(src, O_RDONLY, 0);
2275
2276                         if (IS_ERR(srcf))
2277                         {
2278                                 ate_print("%s - Error %ld opening %s\n", __func__, -PTR_ERR(srcf), src);
2279                                 break;
2280                         }
2281
2282                         /* the object must have a read method */
2283                         if ((srcf->f_op == NULL) || (srcf->f_op->read == NULL))
2284                         {
2285                                 ate_print("%s - %s does not have a read method\n", __func__, src);
2286                                 break;
2287                         }
2288
2289                         /* read the firmware from the file *.bin */
2290                         FileLength = srcf->f_op->read(srcf,
2291                                                                                   (PUCHAR)WriteEEPROM,
2292                                                                                   EEPROM_SIZE,
2293                                                                                   &srcf->f_pos);
2294
2295                         if (FileLength != EEPROM_SIZE)
2296                         {
2297                                 ate_print("%s: error file length (=%d) in e2p.bin\n",
2298                                            __func__, FileLength);
2299                                 break;
2300                         }
2301                         else
2302                         {
2303                                 /* write the content of .bin file to EEPROM */
2304                                 rt_ee_write_all(pAd, WriteEEPROM);
2305                                 ret = TRUE;
2306                         }
2307                         break;
2308                 } while(TRUE);
2309
2310                 /* close firmware file */
2311                 if (IS_ERR(srcf))
2312                 {
2313                                 ;
2314                 }
2315                 else
2316                 {
2317                         retval = filp_close(srcf, NULL);
2318                         if (retval)
2319                         {
2320                                 ATEDBGPRINT(RT_DEBUG_ERROR, ("--> Error %d closing %s\n", -retval, src));
2321
2322                         }
2323                 }
2324
2325                 /* restore */
2326                 set_fs(orgfs);
2327                 current->fsuid = orgfsuid;
2328                 current->fsgid = orgfsgid;
2329         }
2330     ATEDBGPRINT(RT_DEBUG_ERROR, ("<=== %s (ret=%d)\n", __func__, ret));
2331
2332     return ret;
2333
2334 }
2335
2336 INT Set_ATE_Read_E2P_Proc(
2337         IN      PRTMP_ADAPTER   pAd,
2338         IN      PUCHAR                  arg)
2339 {
2340         USHORT buffer[EEPROM_SIZE/2];
2341         USHORT *p;
2342         int i;
2343
2344         rt_ee_read_all(pAd, (USHORT *)buffer);
2345         p = buffer;
2346         for (i = 0; i < (EEPROM_SIZE/2); i++)
2347         {
2348                 ate_print("%4.4x ", *p);
2349                 if (((i+1) % 16) == 0)
2350                         ate_print("\n");
2351                 p++;
2352         }
2353         return TRUE;
2354 }
2355
2356 INT     Set_ATE_Show_Proc(
2357         IN      PRTMP_ADAPTER   pAd,
2358         IN      PUCHAR                  arg)
2359 {
2360         ate_print("Mode=%d\n", pAd->ate.Mode);
2361         ate_print("TxPower0=%d\n", pAd->ate.TxPower0);
2362         ate_print("TxPower1=%d\n", pAd->ate.TxPower1);
2363         ate_print("TxAntennaSel=%d\n", pAd->ate.TxAntennaSel);
2364         ate_print("RxAntennaSel=%d\n", pAd->ate.RxAntennaSel);
2365         ate_print("BBPCurrentBW=%d\n", pAd->ate.TxWI.BW);
2366         ate_print("GI=%d\n", pAd->ate.TxWI.ShortGI);
2367         ate_print("MCS=%d\n", pAd->ate.TxWI.MCS);
2368         ate_print("TxMode=%d\n", pAd->ate.TxWI.PHYMODE);
2369         ate_print("Addr1=%02x:%02x:%02x:%02x:%02x:%02x\n",
2370                 pAd->ate.Addr1[0], pAd->ate.Addr1[1], pAd->ate.Addr1[2], pAd->ate.Addr1[3], pAd->ate.Addr1[4], pAd->ate.Addr1[5]);
2371         ate_print("Addr2=%02x:%02x:%02x:%02x:%02x:%02x\n",
2372                 pAd->ate.Addr2[0], pAd->ate.Addr2[1], pAd->ate.Addr2[2], pAd->ate.Addr2[3], pAd->ate.Addr2[4], pAd->ate.Addr2[5]);
2373         ate_print("Addr3=%02x:%02x:%02x:%02x:%02x:%02x\n",
2374                 pAd->ate.Addr3[0], pAd->ate.Addr3[1], pAd->ate.Addr3[2], pAd->ate.Addr3[3], pAd->ate.Addr3[4], pAd->ate.Addr3[5]);
2375         ate_print("Channel=%d\n", pAd->ate.Channel);
2376         ate_print("TxLength=%d\n", pAd->ate.TxLength);
2377         ate_print("TxCount=%u\n", pAd->ate.TxCount);
2378         ate_print("RFFreqOffset=%d\n", pAd->ate.RFFreqOffset);
2379         ate_print(KERN_EMERG "Set_ATE_Show_Proc Success\n");
2380         return TRUE;
2381 }
2382
2383 INT     Set_ATE_Help_Proc(
2384         IN      PRTMP_ADAPTER   pAd,
2385         IN      PUCHAR                  arg)
2386 {
2387         ate_print("ATE=ATESTART, ATESTOP, TXCONT, TXCARR, TXFRAME, RXFRAME\n");
2388         ate_print("ATEDA\n");
2389         ate_print("ATESA\n");
2390         ate_print("ATEBSSID\n");
2391         ate_print("ATECHANNEL, range:0~14(unless A band !)\n");
2392         ate_print("ATETXPOW0, set power level of antenna 1.\n");
2393         ate_print("ATETXPOW1, set power level of antenna 2.\n");
2394         ate_print("ATETXANT, set TX antenna. 0:all, 1:antenna one, 2:antenna two.\n");
2395         ate_print("ATERXANT, set RX antenna.0:all, 1:antenna one, 2:antenna two, 3:antenna three.\n");
2396         ate_print("ATETXFREQOFFSET, set frequency offset, range 0~63\n");
2397         ate_print("ATETXBW, set BandWidth, 0:20MHz, 1:40MHz.\n");
2398         ate_print("ATETXLEN, set Frame length, range 24~%d\n", (MAX_FRAME_SIZE - 34/* == 2312 */));
2399         ate_print("ATETXCNT, set how many frame going to transmit.\n");
2400         ate_print("ATETXMCS, set MCS, reference to rate table.\n");
2401         ate_print("ATETXMODE, set Mode 0:CCK, 1:OFDM, 2:HT-Mix, 3:GreenField, reference to rate table.\n");
2402         ate_print("ATETXGI, set GI interval, 0:Long, 1:Short\n");
2403         ate_print("ATERXFER, 0:disable Rx Frame error rate. 1:enable Rx Frame error rate.\n");
2404         ate_print("ATERRF, show all RF registers.\n");
2405         ate_print("ATEWRF1, set RF1 register.\n");
2406         ate_print("ATEWRF2, set RF2 register.\n");
2407         ate_print("ATEWRF3, set RF3 register.\n");
2408         ate_print("ATEWRF4, set RF4 register.\n");
2409         ate_print("ATELDE2P, load EEPROM from .bin file.\n");
2410         ate_print("ATERE2P, display all EEPROM content.\n");
2411         ate_print("ATESHOW, display all parameters of ATE.\n");
2412         ate_print("ATEHELP, online help.\n");
2413
2414         return TRUE;
2415 }
2416
2417 /*
2418     ==========================================================================
2419     Description:
2420
2421         AsicSwitchChannel() dedicated for ATE.
2422
2423     ==========================================================================
2424 */
2425 VOID ATEAsicSwitchChannel(
2426     IN PRTMP_ADAPTER pAd)
2427 {
2428         UINT32 R2 = 0, R3 = DEFAULT_RF_TX_POWER, R4 = 0, Value = 0;
2429         CHAR TxPwer = 0, TxPwer2 = 0;
2430         UCHAR index, BbpValue = 0, R66 = 0x30;
2431         RTMP_RF_REGS *RFRegTable;
2432         UCHAR Channel;
2433
2434 #ifdef RALINK_28xx_QA
2435         if ((pAd->ate.bQATxStart == TRUE) || (pAd->ate.bQARxStart == TRUE))
2436         {
2437                 if (pAd->ate.Channel != pAd->LatchRfRegs.Channel)
2438                 {
2439                         pAd->ate.Channel = pAd->LatchRfRegs.Channel;
2440                 }
2441                 return;
2442         }
2443         else
2444 #endif // RALINK_28xx_QA //
2445         Channel = pAd->ate.Channel;
2446
2447         // Select antenna
2448         AsicAntennaSelect(pAd, Channel);
2449
2450         // fill Tx power value
2451         TxPwer = pAd->ate.TxPower0;
2452         TxPwer2 = pAd->ate.TxPower1;
2453
2454         RFRegTable = RF2850RegTable;
2455
2456         switch (pAd->RfIcType)
2457         {
2458                 /* But only 2850 and 2750 support 5.5GHz band... */
2459                 case RFIC_2820:
2460                 case RFIC_2850:
2461                 case RFIC_2720:
2462                 case RFIC_2750:
2463
2464                         for (index = 0; index < NUM_OF_2850_CHNL; index++)
2465                         {
2466                                 if (Channel == RFRegTable[index].Channel)
2467                                 {
2468                                         R2 = RFRegTable[index].R2;
2469                                         if (pAd->Antenna.field.TxPath == 1)
2470                                         {
2471                                                 R2 |= 0x4000;   // If TXpath is 1, bit 14 = 1;
2472                                         }
2473
2474                                         if (pAd->Antenna.field.RxPath == 2)
2475                                         {
2476                                                 switch (pAd->ate.RxAntennaSel)
2477                                                 {
2478                                                         case 1:
2479                                                                 R2 |= 0x20040;
2480                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2481                                                                 BbpValue &= 0xE4;
2482                                                                 BbpValue |= 0x00;
2483                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2484                                                                 break;
2485                                                         case 2:
2486                                                                 R2 |= 0x10040;
2487                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2488                                                                 BbpValue &= 0xE4;
2489                                                                 BbpValue |= 0x01;
2490                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2491                                                                 break;
2492                                                         default:
2493                                                                 R2 |= 0x40;
2494                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2495                                                                 BbpValue &= 0xE4;
2496                                                                 /* Only enable two Antenna to receive. */
2497                                                                 BbpValue |= 0x08;
2498                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2499                                                                 break;
2500                                                 }
2501                                         }
2502                                         else if (pAd->Antenna.field.RxPath == 1)
2503                                         {
2504                                                 R2 |= 0x20040;  // write 1 to off RxPath
2505                                         }
2506
2507                                         if (pAd->Antenna.field.TxPath == 2)
2508                                         {
2509                                                 if (pAd->ate.TxAntennaSel == 1)
2510                                                 {
2511                                                         R2 |= 0x4000;   // If TX Antenna select is 1 , bit 14 = 1; Disable Ant 2
2512                                                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R1, &BbpValue);
2513                                                         BbpValue &= 0xE7;               //11100111B
2514                                                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R1, BbpValue);
2515                                                 }
2516                                                 else if (pAd->ate.TxAntennaSel == 2)
2517                                                 {
2518                                                         R2 |= 0x8000;   // If TX Antenna select is 2 , bit 15 = 1; Disable Ant 1
2519                                                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R1, &BbpValue);
2520                                                         BbpValue &= 0xE7;
2521                                                         BbpValue |= 0x08;
2522                                                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R1, BbpValue);
2523                                                 }
2524                                                 else
2525                                                 {
2526                                                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R1, &BbpValue);
2527                                                         BbpValue &= 0xE7;
2528                                                         BbpValue |= 0x10;
2529                                                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R1, BbpValue);
2530                                                 }
2531                                         }
2532                                         if (pAd->Antenna.field.RxPath == 3)
2533                                         {
2534                                                 switch (pAd->ate.RxAntennaSel)
2535                                                 {
2536                                                         case 1:
2537                                                                 R2 |= 0x20040;
2538                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2539                                                                 BbpValue &= 0xE4;
2540                                                                 BbpValue |= 0x00;
2541                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2542                                                                 break;
2543                                                         case 2:
2544                                                                 R2 |= 0x10040;
2545                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2546                                                                 BbpValue &= 0xE4;
2547                                                                 BbpValue |= 0x01;
2548                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2549                                                                 break;
2550                                                         case 3:
2551                                                                 R2 |= 0x30000;
2552                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2553                                                                 BbpValue &= 0xE4;
2554                                                                 BbpValue |= 0x02;
2555                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2556                                                                 break;
2557                                                         default:
2558                                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BbpValue);
2559                                                                 BbpValue &= 0xE4;
2560                                                                 BbpValue |= 0x10;
2561                                                                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BbpValue);
2562                                                                 break;
2563                                                 }
2564                                         }
2565
2566                                         if (Channel > 14)
2567                                         {
2568                                                 // initialize R3, R4
2569                                                 R3 = (RFRegTable[index].R3 & 0xffffc1ff);
2570                                                 R4 = (RFRegTable[index].R4 & (~0x001f87c0)) | (pAd->ate.RFFreqOffset << 15);
2571
2572                         // According the Rory's suggestion to solve the middle range issue.
2573                                                 // 5.5G band power range: 0xF9~0X0F, TX0 Reg3 bit9/TX1 Reg4 bit6="0" means the TX power reduce 7dB
2574                                                 // R3
2575                                                 if ((TxPwer >= -7) && (TxPwer < 0))
2576                                                 {
2577                                                         TxPwer = (7+TxPwer);
2578                                                         TxPwer = (TxPwer > 0xF) ? (0xF) : (TxPwer);
2579                                                         R3 |= (TxPwer << 10);
2580                                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("ATEAsicSwitchChannel: TxPwer=%d \n", TxPwer));
2581                                                 }
2582                                                 else
2583                                                 {
2584                                                         TxPwer = (TxPwer > 0xF) ? (0xF) : (TxPwer);
2585                                                         R3 |= (TxPwer << 10) | (1 << 9);
2586                                                 }
2587
2588                                                 // R4
2589                                                 if ((TxPwer2 >= -7) && (TxPwer2 < 0))
2590                                                 {
2591                                                         TxPwer2 = (7+TxPwer2);
2592                                                         TxPwer2 = (TxPwer2 > 0xF) ? (0xF) : (TxPwer2);
2593                                                         R4 |= (TxPwer2 << 7);
2594                                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("ATEAsicSwitchChannel: TxPwer2=%d \n", TxPwer2));
2595                                                 }
2596                                                 else
2597                                                 {
2598                                                         TxPwer2 = (TxPwer2 > 0xF) ? (0xF) : (TxPwer2);
2599                                                         R4 |= (TxPwer2 << 7) | (1 << 6);
2600                                                 }
2601                                         }
2602                                         else
2603                                         {
2604                                                 R3 = (RFRegTable[index].R3 & 0xffffc1ff) | (TxPwer << 9); // set TX power0
2605                                                 R4 = (RFRegTable[index].R4 & (~0x001f87c0)) | (pAd->ate.RFFreqOffset << 15) | (TxPwer2 <<6);// Set freq offset & TxPwr1
2606                                         }
2607
2608                                         // Based on BBP current mode before changing RF channel.
2609                                         if (pAd->ate.TxWI.BW == BW_40)
2610                                         {
2611                                                 R4 |=0x200000;
2612                                         }
2613
2614                                         // Update variables
2615                                         pAd->LatchRfRegs.Channel = Channel;
2616                                         pAd->LatchRfRegs.R1 = RFRegTable[index].R1;
2617                                         pAd->LatchRfRegs.R2 = R2;
2618                                         pAd->LatchRfRegs.R3 = R3;
2619                                         pAd->LatchRfRegs.R4 = R4;
2620
2621                                         RtmpRfIoWrite(pAd);
2622
2623                                         break;
2624                                 }
2625                         }
2626                         break;
2627
2628                 default:
2629                         break;
2630         }
2631
2632         // Change BBP setting during switch from a->g, g->a
2633         if (Channel <= 14)
2634         {
2635             ULONG       TxPinCfg = 0x00050F0A;// 2007.10.09 by Brian : 0x0005050A ==> 0x00050F0A
2636
2637                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R62, (0x37 - GET_LNA_GAIN(pAd)));
2638                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R63, (0x37 - GET_LNA_GAIN(pAd)));
2639                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R64, (0x37 - GET_LNA_GAIN(pAd)));
2640
2641                 /* For 1T/2R chip only... */
2642             if (pAd->NicConfig2.field.ExternalLNAForG)
2643             {
2644                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0x62);
2645             }
2646             else
2647             {
2648                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0x84);
2649             }
2650
2651         // According the Rory's suggestion to solve the middle range issue.
2652                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R86, &BbpValue);
2653                 ASSERT((BbpValue == 0x00));
2654                 if ((BbpValue != 0x00))
2655                 {
2656                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R86, 0x00);
2657                 }
2658
2659                 // 5.5GHz band selection PIN, bit1 and bit2 are complement
2660                 RTMP_IO_READ32(pAd, TX_BAND_CFG, &Value);
2661                 Value &= (~0x6);
2662                 Value |= (0x04);
2663                 RTMP_IO_WRITE32(pAd, TX_BAND_CFG, Value);
2664
2665         // Turn off unused PA or LNA when only 1T or 1R.
2666                 if (pAd->Antenna.field.TxPath == 1)
2667                 {
2668                         TxPinCfg &= 0xFFFFFFF3;
2669                 }
2670                 if (pAd->Antenna.field.RxPath == 1)
2671                 {
2672                         TxPinCfg &= 0xFFFFF3FF;
2673                 }
2674
2675                 RTMP_IO_WRITE32(pAd, TX_PIN_CFG, TxPinCfg);
2676         }
2677         else
2678         {
2679             ULONG       TxPinCfg = 0x00050F05;//2007.10.09 by Brian : 0x00050505 ==> 0x00050F05
2680
2681                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R62, (0x37 - GET_LNA_GAIN(pAd)));
2682                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R63, (0x37 - GET_LNA_GAIN(pAd)));
2683                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R64, (0x37 - GET_LNA_GAIN(pAd)));
2684                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0xF2);
2685
2686         // According the Rory's suggestion to solve the middle range issue.
2687                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R86, &BbpValue);
2688                 ASSERT((BbpValue == 0x00));
2689                 if ((BbpValue != 0x00))
2690                 {
2691                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R86, 0x00);
2692                 }
2693                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R91, &BbpValue);
2694                 ASSERT((BbpValue == 0x04));
2695
2696                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R92, &BbpValue);
2697                 ASSERT((BbpValue == 0x00));
2698
2699                 // 5.5GHz band selection PIN, bit1 and bit2 are complement
2700                 RTMP_IO_READ32(pAd, TX_BAND_CFG, &Value);
2701                 Value &= (~0x6);
2702                 Value |= (0x02);
2703                 RTMP_IO_WRITE32(pAd, TX_BAND_CFG, Value);
2704
2705         // Turn off unused PA or LNA when only 1T or 1R.
2706                 if (pAd->Antenna.field.TxPath == 1)
2707                 {
2708                         TxPinCfg &= 0xFFFFFFF3;
2709             }
2710                 if (pAd->Antenna.field.RxPath == 1)
2711                 {
2712                         TxPinCfg &= 0xFFFFF3FF;
2713                 }
2714
2715                 RTMP_IO_WRITE32(pAd, TX_PIN_CFG, TxPinCfg);
2716         }
2717
2718     // R66 should be set according to Channel and use 20MHz when scanning
2719         if (Channel <= 14)
2720         {
2721                 // BG band
2722                 R66 = 0x2E + GET_LNA_GAIN(pAd);
2723                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
2724         }
2725         else
2726         {
2727                 // 5.5 GHz band
2728                 if (pAd->ate.TxWI.BW == BW_20)
2729                 {
2730                         R66 = (UCHAR)(0x32 + (GET_LNA_GAIN(pAd)*5)/3);
2731                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
2732                 }
2733                 else
2734                 {
2735                         R66 = (UCHAR)(0x3A + (GET_LNA_GAIN(pAd)*5)/3);
2736                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
2737                 }
2738         }
2739
2740         //
2741         // On 11A, We should delay and wait RF/BBP to be stable
2742         // and the appropriate time should be 1000 micro seconds
2743         // 2005/06/05 - On 11G, We also need this delay time. Otherwise it's difficult to pass the WHQL.
2744         //
2745         RTMPusecDelay(1000);
2746
2747         if (Channel > 14)
2748         {
2749                 // When 5.5GHz band the LSB of TxPwr will be used to reduced 7dB or not.
2750                 ATEDBGPRINT(RT_DEBUG_TRACE, ("SwitchChannel#%d(RF=%d, %dT) to , R1=0x%08lx, R2=0x%08lx, R3=0x%08lx, R4=0x%08lx\n",
2751                                                                   Channel,
2752                                                                   pAd->RfIcType,
2753                                                                   pAd->Antenna.field.TxPath,
2754                                                                   pAd->LatchRfRegs.R1,
2755                                                                   pAd->LatchRfRegs.R2,
2756                                                                   pAd->LatchRfRegs.R3,
2757                                                                   pAd->LatchRfRegs.R4));
2758         }
2759         else
2760         {
2761                 ATEDBGPRINT(RT_DEBUG_TRACE, ("SwitchChannel#%d(RF=%d, Pwr0=%u, Pwr1=%u, %dT) to , R1=0x%08lx, R2=0x%08lx, R3=0x%08lx, R4=0x%08lx\n",
2762                                                                   Channel,
2763                                                                   pAd->RfIcType,
2764                                                                   (R3 & 0x00003e00) >> 9,
2765                                                                   (R4 & 0x000007c0) >> 6,
2766                                                                   pAd->Antenna.field.TxPath,
2767                                                                   pAd->LatchRfRegs.R1,
2768                                                                   pAd->LatchRfRegs.R2,
2769                                                                   pAd->LatchRfRegs.R3,
2770                                                                   pAd->LatchRfRegs.R4));
2771     }
2772 }
2773
2774 //
2775 // In fact, no one will call this routine so far !
2776 //
2777 /*
2778         ==========================================================================
2779         Description:
2780                 Gives CCK TX rate 2 more dB TX power.
2781                 This routine works only in ATE mode.
2782
2783                 calculate desired Tx power in RF R3.Tx0~5,      should consider -
2784                 0. if current radio is a noisy environment (pAd->DrsCounters.fNoisyEnvironment)
2785                 1. TxPowerPercentage
2786                 2. auto calibration based on TSSI feedback
2787                 3. extra 2 db for CCK
2788                 4. -10 db upon very-short distance (AvgRSSI >= -40db) to AP
2789
2790         NOTE: Since this routine requires the value of (pAd->DrsCounters.fNoisyEnvironment),
2791                 it should be called AFTER MlmeDynamicTxRateSwitching()
2792         ==========================================================================
2793  */
2794 VOID ATEAsicAdjustTxPower(
2795         IN PRTMP_ADAPTER pAd)
2796 {
2797         INT                     i, j;
2798         CHAR            DeltaPwr = 0;
2799         BOOLEAN         bAutoTxAgc = FALSE;
2800         UCHAR           TssiRef, *pTssiMinusBoundary, *pTssiPlusBoundary, TxAgcStep;
2801         UCHAR           BbpR49 = 0, idx;
2802         PCHAR           pTxAgcCompensate;
2803         ULONG           TxPwr[5];
2804         CHAR            Value;
2805
2806         /* no one calls this procedure so far */
2807         if (pAd->ate.TxWI.BW == BW_40)
2808         {
2809                 if (pAd->ate.Channel > 14)
2810                 {
2811                         TxPwr[0] = pAd->Tx40MPwrCfgABand[0];
2812                         TxPwr[1] = pAd->Tx40MPwrCfgABand[1];
2813                         TxPwr[2] = pAd->Tx40MPwrCfgABand[2];
2814                         TxPwr[3] = pAd->Tx40MPwrCfgABand[3];
2815                         TxPwr[4] = pAd->Tx40MPwrCfgABand[4];
2816                 }
2817                 else
2818                 {
2819                         TxPwr[0] = pAd->Tx40MPwrCfgGBand[0];
2820                         TxPwr[1] = pAd->Tx40MPwrCfgGBand[1];
2821                         TxPwr[2] = pAd->Tx40MPwrCfgGBand[2];
2822                         TxPwr[3] = pAd->Tx40MPwrCfgGBand[3];
2823                         TxPwr[4] = pAd->Tx40MPwrCfgGBand[4];
2824                 }
2825         }
2826         else
2827         {
2828                 if (pAd->ate.Channel > 14)
2829                 {
2830                         TxPwr[0] = pAd->Tx20MPwrCfgABand[0];
2831                         TxPwr[1] = pAd->Tx20MPwrCfgABand[1];
2832                         TxPwr[2] = pAd->Tx20MPwrCfgABand[2];
2833                         TxPwr[3] = pAd->Tx20MPwrCfgABand[3];
2834                         TxPwr[4] = pAd->Tx20MPwrCfgABand[4];
2835                 }
2836                 else
2837                 {
2838                         TxPwr[0] = pAd->Tx20MPwrCfgGBand[0];
2839                         TxPwr[1] = pAd->Tx20MPwrCfgGBand[1];
2840                         TxPwr[2] = pAd->Tx20MPwrCfgGBand[2];
2841                         TxPwr[3] = pAd->Tx20MPwrCfgGBand[3];
2842                         TxPwr[4] = pAd->Tx20MPwrCfgGBand[4];
2843                 }
2844         }
2845
2846         // TX power compensation for temperature variation based on TSSI.
2847         // Do it per 4 seconds.
2848         if (pAd->Mlme.OneSecPeriodicRound % 4 == 0)
2849         {
2850                 if (pAd->ate.Channel <= 14)
2851                 {
2852                         /* bg channel */
2853                         bAutoTxAgc         = pAd->bAutoTxAgcG;
2854                         TssiRef            = pAd->TssiRefG;
2855                         pTssiMinusBoundary = &pAd->TssiMinusBoundaryG[0];
2856                         pTssiPlusBoundary  = &pAd->TssiPlusBoundaryG[0];
2857                         TxAgcStep          = pAd->TxAgcStepG;
2858                         pTxAgcCompensate   = &pAd->TxAgcCompensateG;
2859                 }
2860                 else
2861                 {
2862                         /* a channel */
2863                         bAutoTxAgc         = pAd->bAutoTxAgcA;
2864                         TssiRef            = pAd->TssiRefA;
2865                         pTssiMinusBoundary = &pAd->TssiMinusBoundaryA[0];
2866                         pTssiPlusBoundary  = &pAd->TssiPlusBoundaryA[0];
2867                         TxAgcStep          = pAd->TxAgcStepA;
2868                         pTxAgcCompensate   = &pAd->TxAgcCompensateA;
2869                 }
2870
2871                 if (bAutoTxAgc)
2872                 {
2873                         /* BbpR49 is unsigned char */
2874                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R49, &BbpR49);
2875
2876                         /* (p) TssiPlusBoundaryG[0] = 0 = (m) TssiMinusBoundaryG[0] */
2877                         /* compensate: +4     +3   +2   +1    0   -1   -2   -3   -4 * steps */
2878                         /* step value is defined in pAd->TxAgcStepG for tx power value */
2879
2880                         /* [4]+1+[4]   p4     p3   p2   p1   o1   m1   m2   m3   m4 */
2881                         /* ex:         0x00 0x15 0x25 0x45 0x88 0xA0 0xB5 0xD0 0xF0
2882                            above value are examined in mass factory production */
2883                         /*             [4]    [3]  [2]  [1]  [0]  [1]  [2]  [3]  [4] */
2884
2885                         /* plus is 0x10 ~ 0x40, minus is 0x60 ~ 0x90 */
2886                         /* if value is between p1 ~ o1 or o1 ~ s1, no need to adjust tx power */
2887                         /* if value is 0x65, tx power will be -= TxAgcStep*(2-1) */
2888
2889                         if (BbpR49 > pTssiMinusBoundary[1])
2890                         {
2891                                 // Reading is larger than the reference value.
2892                                 // Check for how large we need to decrease the Tx power.
2893                                 for (idx = 1; idx < 5; idx++)
2894                                 {
2895                                         if (BbpR49 <= pTssiMinusBoundary[idx])  // Found the range
2896                                                 break;
2897                                 }
2898                                 // The index is the step we should decrease, idx = 0 means there is nothing to compensate
2899 //                              if (R3 > (ULONG) (TxAgcStep * (idx-1)))
2900                                         *pTxAgcCompensate = -(TxAgcStep * (idx-1));
2901 //                              else
2902 //                                      *pTxAgcCompensate = -((UCHAR)R3);
2903
2904                                 DeltaPwr += (*pTxAgcCompensate);
2905                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("-- Tx Power, BBP R1=%x, TssiRef=%x, TxAgcStep=%x, step = -%d\n",
2906                                         BbpR49, TssiRef, TxAgcStep, idx-1));
2907                         }
2908                         else if (BbpR49 < pTssiPlusBoundary[1])
2909                         {
2910                                 // Reading is smaller than the reference value
2911                                 // check for how large we need to increase the Tx power
2912                                 for (idx = 1; idx < 5; idx++)
2913                                 {
2914                                         if (BbpR49 >= pTssiPlusBoundary[idx])   // Found the range
2915                                                 break;
2916                                 }
2917                                 // The index is the step we should increase, idx = 0 means there is nothing to compensate
2918                                 *pTxAgcCompensate = TxAgcStep * (idx-1);
2919                                 DeltaPwr += (*pTxAgcCompensate);
2920                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("++ Tx Power, BBP R1=%x, TssiRef=%x, TxAgcStep=%x, step = +%d\n",
2921                                         BbpR49, TssiRef, TxAgcStep, idx-1));
2922                         }
2923                         else
2924                         {
2925                                 *pTxAgcCompensate = 0;
2926                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("   Tx Power, BBP R1=%x, TssiRef=%x, TxAgcStep=%x, step = +%d\n",
2927                                         BbpR49, TssiRef, TxAgcStep, 0));
2928                         }
2929                 }
2930         }
2931         else
2932         {
2933                 if (pAd->ate.Channel <= 14)
2934                 {
2935                         bAutoTxAgc         = pAd->bAutoTxAgcG;
2936                         pTxAgcCompensate   = &pAd->TxAgcCompensateG;
2937                 }
2938                 else
2939                 {
2940                         bAutoTxAgc         = pAd->bAutoTxAgcA;
2941                         pTxAgcCompensate   = &pAd->TxAgcCompensateA;
2942                 }
2943
2944                 if (bAutoTxAgc)
2945                         DeltaPwr += (*pTxAgcCompensate);
2946         }
2947
2948         /* calculate delta power based on the percentage specified from UI */
2949         // E2PROM setting is calibrated for maximum TX power (i.e. 100%)
2950         // We lower TX power here according to the percentage specified from UI
2951         if (pAd->CommonCfg.TxPowerPercentage == 0xffffffff)       // AUTO TX POWER control
2952                 ;
2953         else if (pAd->CommonCfg.TxPowerPercentage > 90)  // 91 ~ 100% & AUTO, treat as 100% in terms of mW
2954                 ;
2955         else if (pAd->CommonCfg.TxPowerPercentage > 60)  // 61 ~ 90%, treat as 75% in terms of mW
2956         {
2957                 DeltaPwr -= 1;
2958         }
2959         else if (pAd->CommonCfg.TxPowerPercentage > 30)  // 31 ~ 60%, treat as 50% in terms of mW
2960         {
2961                 DeltaPwr -= 3;
2962         }
2963         else if (pAd->CommonCfg.TxPowerPercentage > 15)  // 16 ~ 30%, treat as 25% in terms of mW
2964         {
2965                 DeltaPwr -= 6;
2966         }
2967         else if (pAd->CommonCfg.TxPowerPercentage > 9)   // 10 ~ 15%, treat as 12.5% in terms of mW
2968         {
2969                 DeltaPwr -= 9;
2970         }
2971         else                                           // 0 ~ 9 %, treat as MIN(~3%) in terms of mW
2972         {
2973                 DeltaPwr -= 12;
2974         }
2975
2976         /* reset different new tx power for different TX rate */
2977         for(i=0; i<5; i++)
2978         {
2979                 if (TxPwr[i] != 0xffffffff)
2980                 {
2981                         for (j=0; j<8; j++)
2982                         {
2983                                 Value = (CHAR)((TxPwr[i] >> j*4) & 0x0F); /* 0 ~ 15 */
2984
2985                                 if ((Value + DeltaPwr) < 0)
2986                                 {
2987                                         Value = 0; /* min */
2988                                 }
2989                                 else if ((Value + DeltaPwr) > 0xF)
2990                                 {
2991                                         Value = 0xF; /* max */
2992                                 }
2993                                 else
2994                                 {
2995                                         Value += DeltaPwr; /* temperature compensation */
2996                                 }
2997
2998                                 /* fill new value to CSR offset */
2999                                 TxPwr[i] = (TxPwr[i] & ~(0x0000000F << j*4)) | (Value << j*4);
3000                         }
3001
3002                         /* write tx power value to CSR */
3003                         /* TX_PWR_CFG_0 (8 tx rate) for TX power for OFDM 12M/18M
3004                                                                                         TX power for OFDM 6M/9M
3005                                                                                         TX power for CCK5.5M/11M
3006                                                                                         TX power for CCK1M/2M */
3007                         /* TX_PWR_CFG_1 ~ TX_PWR_CFG_4 */
3008                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, TxPwr[i]);
3009
3010
3011                 }
3012         }
3013
3014 }
3015
3016 /*
3017         ========================================================================
3018         Routine Description:
3019                 Write TxWI for ATE mode.
3020
3021         Return Value:
3022                 None
3023         ========================================================================
3024 */
3025
3026 #ifdef RT2870
3027 static VOID ATEWriteTxWI(
3028         IN      PRTMP_ADAPTER   pAd,
3029         IN      PTXWI_STRUC     pTxWI,
3030         IN      BOOLEAN                 FRAG,
3031         IN      BOOLEAN                 InsTimestamp,
3032         IN      BOOLEAN                 AMPDU,
3033         IN      BOOLEAN                 Ack,
3034         IN      BOOLEAN                 NSeq,           // HW new a sequence.
3035         IN      UCHAR                   BASize,
3036         IN      UCHAR                   WCID,
3037         IN      ULONG                   Length,
3038         IN      UCHAR                   PID,
3039         IN      UCHAR                   MIMOps,
3040         IN      UCHAR                   Txopmode,
3041         IN      BOOLEAN                 CfAck,
3042         IN      HTTRANSMIT_SETTING      Transmit)
3043 {
3044         //
3045         // Always use Long preamble before verifiation short preamble functionality works well.
3046         // Todo: remove the following line if short preamble functionality works
3047         //
3048         OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);
3049         pTxWI->FRAG= FRAG;
3050         pTxWI->TS= InsTimestamp;
3051         pTxWI->AMPDU = AMPDU;
3052
3053         pTxWI->MIMOps = PWR_ACTIVE;
3054         pTxWI->MpduDensity = 4;
3055         pTxWI->ACK = Ack;
3056         pTxWI->txop = Txopmode;
3057         pTxWI->NSEQ = NSeq;
3058         pTxWI->BAWinSize = BASize;
3059
3060         pTxWI->WirelessCliID = WCID;
3061         pTxWI->MPDUtotalByteCount = Length;
3062         pTxWI->PacketId = PID;
3063
3064         pTxWI->BW = Transmit.field.BW;
3065         pTxWI->ShortGI = Transmit.field.ShortGI;
3066         pTxWI->STBC= Transmit.field.STBC;
3067
3068         pTxWI->MCS = Transmit.field.MCS;
3069         pTxWI->PHYMODE= Transmit.field.MODE;
3070
3071 #ifdef DOT11_N_SUPPORT
3072         //
3073         // MMPS is 802.11n features. Because TxWI->MCS > 7 must be HT mode,
3074         // so need not check if it's HT rate.
3075         //
3076         if ((MIMOps == MMPS_STATIC) && (pTxWI->MCS > 7))
3077                 pTxWI->MCS = 7;
3078
3079         if ((MIMOps == MMPS_DYNAMIC) && (pTxWI->MCS > 7)) // SMPS protect 2 spatial.
3080                 pTxWI->MIMOps = 1;
3081 #endif // DOT11_N_SUPPORT //
3082
3083         pTxWI->CFACK = CfAck;
3084
3085         return;
3086 }
3087 #endif // RT2870 //
3088 /*
3089         ========================================================================
3090
3091         Routine Description:
3092                 Disable protection for ATE.
3093         ========================================================================
3094 */
3095 VOID ATEDisableAsicProtect(
3096         IN              PRTMP_ADAPTER   pAd)
3097 {
3098         PROT_CFG_STRUC  ProtCfg, ProtCfg4;
3099         UINT32 Protect[6];
3100         USHORT                  offset;
3101         UCHAR                   i;
3102         UINT32 MacReg = 0;
3103
3104         // Config ASIC RTS threshold register
3105         RTMP_IO_READ32(pAd, TX_RTS_CFG, &MacReg);
3106         MacReg &= 0xFF0000FF;
3107         MacReg |= (pAd->CommonCfg.RtsThreshold << 8);
3108         RTMP_IO_WRITE32(pAd, TX_RTS_CFG, MacReg);
3109
3110         // Initial common protection settings
3111         RTMPZeroMemory(Protect, sizeof(Protect));
3112         ProtCfg4.word = 0;
3113         ProtCfg.word = 0;
3114         ProtCfg.field.TxopAllowGF40 = 1;
3115         ProtCfg.field.TxopAllowGF20 = 1;
3116         ProtCfg.field.TxopAllowMM40 = 1;
3117         ProtCfg.field.TxopAllowMM20 = 1;
3118         ProtCfg.field.TxopAllowOfdm = 1;
3119         ProtCfg.field.TxopAllowCck = 1;
3120         ProtCfg.field.RTSThEn = 1;
3121         ProtCfg.field.ProtectNav = ASIC_SHORTNAV;
3122
3123         // Handle legacy(B/G) protection
3124         ProtCfg.field.ProtectRate = pAd->CommonCfg.RtsRate;
3125         ProtCfg.field.ProtectCtrl = 0;
3126         Protect[0] = ProtCfg.word;
3127         Protect[1] = ProtCfg.word;
3128
3129         // NO PROTECT
3130         // 1.All STAs in the BSS are 20/40 MHz HT
3131         // 2. in ai 20/40MHz BSS
3132         // 3. all STAs are 20MHz in a 20MHz BSS
3133         // Pure HT. no protection.
3134
3135         // MM20_PROT_CFG
3136         //      Reserved (31:27)
3137         //      PROT_TXOP(25:20) -- 010111
3138         //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
3139         //  PROT_CTRL(17:16) -- 00 (None)
3140         //      PROT_RATE(15:0)  -- 0x4004 (OFDM 24M)
3141         Protect[2] = 0x01744004;
3142
3143         // MM40_PROT_CFG
3144         //      Reserved (31:27)
3145         //      PROT_TXOP(25:20) -- 111111
3146         //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
3147         //  PROT_CTRL(17:16) -- 00 (None)
3148         //      PROT_RATE(15:0)  -- 0x4084 (duplicate OFDM 24M)
3149         Protect[3] = 0x03f44084;
3150
3151         // CF20_PROT_CFG
3152         //      Reserved (31:27)
3153         //      PROT_TXOP(25:20) -- 010111
3154         //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
3155         //  PROT_CTRL(17:16) -- 00 (None)
3156         //      PROT_RATE(15:0)  -- 0x4004 (OFDM 24M)
3157         Protect[4] = 0x01744004;
3158
3159         // CF40_PROT_CFG
3160         //      Reserved (31:27)
3161         //      PROT_TXOP(25:20) -- 111111
3162         //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
3163         //  PROT_CTRL(17:16) -- 00 (None)
3164         //      PROT_RATE(15:0)  -- 0x4084 (duplicate OFDM 24M)
3165         Protect[5] = 0x03f44084;
3166
3167         pAd->CommonCfg.IOTestParm.bRTSLongProtOn = FALSE;
3168
3169         offset = CCK_PROT_CFG;
3170         for (i = 0;i < 6;i++)
3171                 RTMP_IO_WRITE32(pAd, offset + i*4, Protect[i]);
3172
3173 }
3174
3175 #ifdef RT2870
3176 /*
3177         ========================================================================
3178         Routine Description:
3179                 Write TxInfo for ATE mode.
3180
3181         Return Value:
3182                 None
3183         ========================================================================
3184 */
3185 static VOID ATEWriteTxInfo(
3186         IN      PRTMP_ADAPTER   pAd,
3187         IN      PTXINFO_STRUC   pTxInfo,
3188         IN      USHORT          USBDMApktLen,
3189         IN      BOOLEAN         bWiv,
3190         IN      UCHAR                   QueueSel,
3191         IN      UCHAR                   NextValid,
3192         IN      UCHAR                   TxBurst)
3193 {
3194         pTxInfo->USBDMATxPktLen = USBDMApktLen;
3195         pTxInfo->QSEL = QueueSel;
3196
3197         if (QueueSel != FIFO_EDCA)
3198                 ATEDBGPRINT(RT_DEBUG_TRACE, ("=======> QueueSel != FIFO_EDCA<=======\n"));
3199
3200         pTxInfo->USBDMANextVLD = NextValid;
3201         pTxInfo->USBDMATxburst = TxBurst;
3202         pTxInfo->WIV = bWiv;
3203         pTxInfo->SwUseLastRound = 0;
3204         pTxInfo->rsv = 0;
3205         pTxInfo->rsv2 = 0;
3206
3207         return;
3208 }
3209 #endif // RT2870 //
3210
3211 /* There are two ways to convert Rssi */
3212 #if 1
3213 //
3214 // The way used with GET_LNA_GAIN().
3215 //
3216 CHAR ATEConvertToRssi(
3217         IN PRTMP_ADAPTER pAd,
3218         IN      CHAR    Rssi,
3219         IN  UCHAR   RssiNumber)
3220 {
3221         UCHAR   RssiOffset, LNAGain;
3222
3223         // Rssi equals to zero should be an invalid value
3224         if (Rssi == 0)
3225                 return -99;
3226
3227         LNAGain = GET_LNA_GAIN(pAd);
3228         if (pAd->LatchRfRegs.Channel > 14)
3229         {
3230                 if (RssiNumber == 0)
3231                         RssiOffset = pAd->ARssiOffset0;
3232                 else if (RssiNumber == 1)
3233                         RssiOffset = pAd->ARssiOffset1;
3234                 else
3235                         RssiOffset = pAd->ARssiOffset2;
3236         }
3237         else
3238         {
3239                 if (RssiNumber == 0)
3240                         RssiOffset = pAd->BGRssiOffset0;
3241                 else if (RssiNumber == 1)
3242                         RssiOffset = pAd->BGRssiOffset1;
3243                 else
3244                         RssiOffset = pAd->BGRssiOffset2;
3245         }
3246
3247         return (-12 - RssiOffset - LNAGain - Rssi);
3248 }
3249 #else
3250 //
3251 // The way originally used in ATE of rt2860ap.
3252 //
3253 CHAR ATEConvertToRssi(
3254         IN PRTMP_ADAPTER pAd,
3255         IN      CHAR                    Rssi,
3256         IN  UCHAR   RssiNumber)
3257 {
3258         UCHAR   RssiOffset, LNAGain;
3259
3260         // Rssi equals to zero should be an invalid value
3261         if (Rssi == 0)
3262                 return -99;
3263
3264     if (pAd->LatchRfRegs.Channel > 14)
3265     {
3266         LNAGain = pAd->ALNAGain;
3267         if (RssiNumber == 0)
3268                         RssiOffset = pAd->ARssiOffset0;
3269                 else if (RssiNumber == 1)
3270                         RssiOffset = pAd->ARssiOffset1;
3271                 else
3272                         RssiOffset = pAd->ARssiOffset2;
3273     }
3274     else
3275     {
3276         LNAGain = pAd->BLNAGain;
3277         if (RssiNumber == 0)
3278                         RssiOffset = pAd->BGRssiOffset0;
3279                 else if (RssiNumber == 1)
3280                         RssiOffset = pAd->BGRssiOffset1;
3281                 else
3282                         RssiOffset = pAd->BGRssiOffset2;
3283     }
3284
3285     return (-32 - RssiOffset + LNAGain - Rssi);
3286 }
3287 #endif /* end of #if 1 */
3288
3289 /*
3290         ========================================================================
3291
3292         Routine Description:
3293                 Set Japan filter coefficients if needed.
3294         Note:
3295                 This routine should only be called when
3296                 entering TXFRAME mode or TXCONT mode.
3297
3298         ========================================================================
3299 */
3300 static VOID SetJapanFilter(
3301         IN              PRTMP_ADAPTER   pAd)
3302 {
3303         UCHAR                   BbpData = 0;
3304
3305         //
3306         // If Channel=14 and Bandwidth=20M and Mode=CCK, set BBP R4 bit5=1
3307         // (Japan Tx filter coefficients)when (TXFRAME or TXCONT).
3308         //
3309         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R4, &BbpData);
3310
3311     if ((pAd->ate.TxWI.PHYMODE == MODE_CCK) && (pAd->ate.Channel == 14) && (pAd->ate.TxWI.BW == BW_20))
3312     {
3313         BbpData |= 0x20;    // turn on
3314         ATEDBGPRINT(RT_DEBUG_TRACE, ("SetJapanFilter!!!\n"));
3315     }
3316     else
3317     {
3318                 BbpData &= 0xdf;    // turn off
3319                 ATEDBGPRINT(RT_DEBUG_TRACE, ("ClearJapanFilter!!!\n"));
3320     }
3321
3322         ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R4, BbpData);
3323 }
3324
3325 VOID ATESampleRssi(
3326         IN PRTMP_ADAPTER        pAd,
3327         IN PRXWI_STRUC          pRxWI)
3328 {
3329         /* There are two ways to collect RSSI. */
3330 #if 1
3331         //pAd->LastRxRate = (USHORT)((pRxWI->MCS) + (pRxWI->BW <<7) + (pRxWI->ShortGI <<8)+ (pRxWI->PHYMODE <<14)) ;
3332         if (pRxWI->RSSI0 != 0)
3333         {
3334                 pAd->ate.LastRssi0      = ATEConvertToRssi(pAd, (CHAR) pRxWI->RSSI0, RSSI_0);
3335                 pAd->ate.AvgRssi0X8     = (pAd->ate.AvgRssi0X8 - pAd->ate.AvgRssi0) + pAd->ate.LastRssi0;
3336                 pAd->ate.AvgRssi0       = pAd->ate.AvgRssi0X8 >> 3;
3337         }
3338         if (pRxWI->RSSI1 != 0)
3339         {
3340                 pAd->ate.LastRssi1      = ATEConvertToRssi(pAd, (CHAR) pRxWI->RSSI1, RSSI_1);
3341                 pAd->ate.AvgRssi1X8     = (pAd->ate.AvgRssi1X8 - pAd->ate.AvgRssi1) + pAd->ate.LastRssi1;
3342                 pAd->ate.AvgRssi1       = pAd->ate.AvgRssi1X8 >> 3;
3343         }
3344         if (pRxWI->RSSI2 != 0)
3345         {
3346                 pAd->ate.LastRssi2      = ATEConvertToRssi(pAd, (CHAR) pRxWI->RSSI2, RSSI_2);
3347                 pAd->ate.AvgRssi2X8     = (pAd->ate.AvgRssi2X8 - pAd->ate.AvgRssi2) + pAd->ate.LastRssi2;
3348                 pAd->ate.AvgRssi2       = pAd->ate.AvgRssi2X8 >> 3;
3349         }
3350
3351         pAd->ate.LastSNR0 = (CHAR)(pRxWI->SNR0);// CHAR ==> UCHAR ?
3352         pAd->ate.LastSNR1 = (CHAR)(pRxWI->SNR1);// CHAR ==> UCHAR ?
3353
3354         pAd->ate.NumOfAvgRssiSample ++;
3355 #else
3356         pAd->ate.LastSNR0 = (CHAR)(pRxWI->SNR0);
3357         pAd->ate.LastSNR1 = (CHAR)(pRxWI->SNR1);
3358         pAd->ate.RxCntPerSec++;
3359         pAd->ate.LastRssi0 = ATEConvertToRssi(pAd, (CHAR) pRxWI->RSSI0, RSSI_0);
3360         pAd->ate.LastRssi1 = ATEConvertToRssi(pAd, (CHAR) pRxWI->RSSI1, RSSI_1);
3361         pAd->ate.LastRssi2 = ATEConvertToRssi(pAd, (CHAR) pRxWI->RSSI2, RSSI_2);
3362         pAd->ate.AvgRssi0X8 = (pAd->ate.AvgRssi0X8 - pAd->ate.AvgRssi0) + pAd->ate.LastRssi0;
3363         pAd->ate.AvgRssi0 = pAd->ate.AvgRssi0X8 >> 3;
3364         pAd->ate.AvgRssi1X8 = (pAd->ate.AvgRssi1X8 - pAd->ate.AvgRssi1) + pAd->ate.LastRssi1;
3365         pAd->ate.AvgRssi1 = pAd->ate.AvgRssi1X8 >> 3;
3366         pAd->ate.AvgRssi2X8 = (pAd->ate.AvgRssi2X8 - pAd->ate.AvgRssi2) + pAd->ate.LastRssi2;
3367         pAd->ate.AvgRssi2 = pAd->ate.AvgRssi2X8 >> 3;
3368         pAd->ate.NumOfAvgRssiSample ++;
3369 #endif
3370 }
3371
3372 #ifdef CONFIG_STA_SUPPORT
3373 VOID RTMPStationStop(
3374     IN  PRTMP_ADAPTER   pAd)
3375 {
3376 //      BOOLEAN       Cancelled;
3377
3378     ATEDBGPRINT(RT_DEBUG_TRACE, ("==> RTMPStationStop\n"));
3379
3380 #if 0
3381         RTMPCancelTimer(&pAd->MlmeAux.AssocTimer,      &Cancelled);
3382         RTMPCancelTimer(&pAd->MlmeAux.ReassocTimer,    &Cancelled);
3383         RTMPCancelTimer(&pAd->MlmeAux.DisassocTimer,   &Cancelled);
3384         RTMPCancelTimer(&pAd->MlmeAux.AuthTimer,       &Cancelled);
3385         RTMPCancelTimer(&pAd->MlmeAux.BeaconTimer,     &Cancelled);
3386         RTMPCancelTimer(&pAd->MlmeAux.ScanTimer,       &Cancelled);
3387 #endif
3388         // For rx statistics, we need to keep this timer running.
3389 //      RTMPCancelTimer(&pAd->Mlme.PeriodicTimer,      &Cancelled);
3390
3391     ATEDBGPRINT(RT_DEBUG_TRACE, ("<== RTMPStationStop\n"));
3392 }
3393
3394 VOID RTMPStationStart(
3395     IN  PRTMP_ADAPTER   pAd)
3396 {
3397     ATEDBGPRINT(RT_DEBUG_TRACE, ("==> RTMPStationStart\n"));
3398         ATEDBGPRINT(RT_DEBUG_TRACE, ("<== RTMPStationStart\n"));
3399 }
3400 #endif // CONFIG_STA_SUPPORT //
3401
3402 /*
3403         ==========================================================================
3404         Description:
3405                 Setup Frame format.
3406         NOTE:
3407                 This routine should only be used in ATE mode.
3408         ==========================================================================
3409  */
3410
3411 #ifdef RT2870
3412 /*======================Start of RT2870======================*/
3413 /*                                                           */
3414 /*                                                           */
3415 static INT ATESetUpFrame(
3416         IN PRTMP_ADAPTER pAd,
3417         IN UINT32 TxIdx)
3418 {
3419         UINT j;
3420         PTX_CONTEXT     pNullContext;
3421         PUCHAR                  pDest;
3422         HTTRANSMIT_SETTING      TxHTPhyMode;
3423         PTXWI_STRUC             pTxWI;
3424         PTXINFO_STRUC           pTxInfo;
3425         UINT32                  TransferBufferLength, OrgBufferLength = 0;
3426         UCHAR                   padLen = 0;
3427 #ifdef RALINK_28xx_QA
3428         PHEADER_802_11  pHeader80211 = NULL;
3429 #endif // RALINK_28xx_QA //
3430
3431         if ((RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) ||
3432                 (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)) ||
3433                 (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) ||
3434                 (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
3435         {
3436                 return -1;
3437         }
3438
3439         /* We always use QID_AC_BE and FIFO_EDCA in ATE mode. */
3440
3441         pNullContext = &(pAd->NullContext);
3442         ASSERT(pNullContext != NULL);
3443
3444         if (pNullContext->InUse == FALSE)
3445         {
3446                 // Set the in use bit
3447                 pNullContext->InUse = TRUE;
3448                 NdisZeroMemory(&(pAd->NullFrame), sizeof(HEADER_802_11));
3449
3450                 // Fill 802.11 header.
3451 #ifdef RALINK_28xx_QA
3452                 if (pAd->ate.bQATxStart == TRUE)
3453                 {
3454                         pHeader80211 = NdisMoveMemory(&(pAd->NullFrame), pAd->ate.Header, pAd->ate.HLen);
3455 //                      pDest = NdisMoveMemory(&(pAd->NullFrame), pAd->ate.Header, pAd->ate.HLen);
3456 //                      pHeader80211 = (PHEADER_802_11)pDest;
3457                 }
3458                 else
3459 #endif // RALINK_28xx_QA //
3460                 {
3461                         // Fill 802.11 header.
3462                         NdisMoveMemory(&(pAd->NullFrame), TemplateFrame, sizeof(HEADER_802_11));
3463                 }
3464 #ifdef RT_BIG_ENDIAN
3465                 RTMPFrameEndianChange(pAd, (PUCHAR)&(pAd->NullFrame), DIR_READ, FALSE);
3466 #endif // RT_BIG_ENDIAN //
3467
3468 #ifdef RALINK_28xx_QA
3469                 if (pAd->ate.bQATxStart == TRUE)
3470                 {
3471                         /* modify sequence number.... */
3472                         if (pAd->ate.TxDoneCount == 0)
3473                         {
3474                                 pAd->ate.seq = pHeader80211->Sequence;
3475                         }
3476                         else
3477                         {
3478                                 pHeader80211->Sequence = ++pAd->ate.seq;
3479                         }
3480                         /* We already got all the addr. fields from QA GUI. */
3481                 }
3482                 else
3483 #endif // RALINK_28xx_QA //
3484                 {
3485                         COPY_MAC_ADDR(pAd->NullFrame.Addr1, pAd->ate.Addr1);
3486                         COPY_MAC_ADDR(pAd->NullFrame.Addr2, pAd->ate.Addr2);
3487                         COPY_MAC_ADDR(pAd->NullFrame.Addr3, pAd->ate.Addr3);
3488                 }
3489
3490                 RTMPZeroMemory(&pAd->NullContext.TransferBuffer->field.WirelessPacket[0], TX_BUFFER_NORMSIZE);//???
3491                 pTxInfo = (PTXINFO_STRUC)&pAd->NullContext.TransferBuffer->field.WirelessPacket[0];
3492
3493 #ifdef RALINK_28xx_QA
3494                 if (pAd->ate.bQATxStart == TRUE)
3495                 {
3496                         // Avoid to exceed the range of WirelessPacket[].
3497                         ASSERT(pAd->ate.TxInfo.USBDMATxPktLen <= (MAX_FRAME_SIZE - 34/* == 2312 */));
3498                         NdisMoveMemory(pTxInfo, &(pAd->ate.TxInfo), sizeof(pAd->ate.TxInfo));
3499                 }
3500                 else
3501 #endif // RALINK_28xx_QA //
3502                 {
3503                         // Avoid to exceed the range of WirelessPacket[].
3504                         ASSERT(pAd->ate.TxLength <= (MAX_FRAME_SIZE - 34/* == 2312 */));
3505
3506                         // pTxInfo->USBDMATxPktLen will be updated to include padding later.
3507                         ATEWriteTxInfo(pAd, pTxInfo, (USHORT)(TXWI_SIZE + pAd->ate.TxLength), TRUE, EpToQueue[MGMTPIPEIDX], FALSE,  FALSE);
3508                         pTxInfo->QSEL = FIFO_EDCA;
3509                 }
3510
3511                 pTxWI = (PTXWI_STRUC)&pAd->NullContext.TransferBuffer->field.WirelessPacket[TXINFO_SIZE];
3512
3513                 // Fill TxWI.
3514                 if (pAd->ate.bQATxStart == TRUE)
3515                 {
3516                         TxHTPhyMode.field.BW = pAd->ate.TxWI.BW;
3517                         TxHTPhyMode.field.ShortGI = pAd->ate.TxWI.ShortGI;
3518                         TxHTPhyMode.field.STBC = pAd->ate.TxWI.STBC;
3519                         TxHTPhyMode.field.MCS = pAd->ate.TxWI.MCS;
3520                         TxHTPhyMode.field.MODE = pAd->ate.TxWI.PHYMODE;
3521                         ATEWriteTxWI(pAd, pTxWI, pAd->ate.TxWI.FRAG, pAd->ate.TxWI.TS, pAd->ate.TxWI.AMPDU, pAd->ate.TxWI.ACK, pAd->ate.TxWI.NSEQ,
3522                                 pAd->ate.TxWI.BAWinSize, BSSID_WCID, pAd->ate.TxWI.MPDUtotalByteCount/* include 802.11 header */, pAd->ate.TxWI.PacketId, 0, pAd->ate.TxWI.txop/*IFS_HTTXOP*/, pAd->ate.TxWI.CFACK/*FALSE*/, TxHTPhyMode);
3523                 }
3524                 else
3525                 {
3526                         TxHTPhyMode.field.BW = pAd->ate.TxWI.BW;
3527                         TxHTPhyMode.field.ShortGI = pAd->ate.TxWI.ShortGI;
3528                         TxHTPhyMode.field.STBC = 0;
3529                         TxHTPhyMode.field.MCS = pAd->ate.TxWI.MCS;
3530                         TxHTPhyMode.field.MODE = pAd->ate.TxWI.PHYMODE;
3531
3532                         ATEWriteTxWI(pAd, pTxWI,  FALSE, FALSE, FALSE, FALSE/* No ack required. */, FALSE, 0, BSSID_WCID, pAd->ate.TxLength,
3533                                 0, 0, IFS_HTTXOP, FALSE, TxHTPhyMode);// "MMPS_STATIC" instead of "MMPS_DYNAMIC" ???
3534                 }
3535
3536                 RTMPMoveMemory(&pAd->NullContext.TransferBuffer->field.WirelessPacket[TXINFO_SIZE+TXWI_SIZE], &pAd->NullFrame, sizeof(HEADER_802_11));
3537
3538                 pDest = &(pAd->NullContext.TransferBuffer->field.WirelessPacket[TXINFO_SIZE+TXWI_SIZE+sizeof(HEADER_802_11)]);
3539
3540                 // Prepare frame payload
3541 #ifdef RALINK_28xx_QA
3542                 if (pAd->ate.bQATxStart == TRUE)
3543                 {
3544                         // copy pattern
3545                         if ((pAd->ate.PLen != 0))
3546                         {
3547                                 for (j = 0; j < pAd->ate.DLen; j+=pAd->ate.PLen)
3548                                 {
3549                                         RTMPMoveMemory(pDest, pAd->ate.Pattern, pAd->ate.PLen);
3550                                         pDest += pAd->ate.PLen;
3551                                 }
3552                         }
3553                         TransferBufferLength = TXINFO_SIZE + TXWI_SIZE + pAd->ate.TxWI.MPDUtotalByteCount;
3554                 }
3555                 else
3556 #endif // RALINK_28xx_QA //
3557                 {
3558                     for (j = 0; j < (pAd->ate.TxLength - sizeof(HEADER_802_11)); j++)
3559                     {
3560                                 *pDest = 0xA5;
3561                                 pDest += 1;
3562                     }
3563                         TransferBufferLength = TXINFO_SIZE + TXWI_SIZE + pAd->ate.TxLength;
3564                 }
3565
3566 #if 1
3567                 OrgBufferLength = TransferBufferLength;
3568                 TransferBufferLength = (TransferBufferLength + 3) & (~3);
3569
3570                 // Always add 4 extra bytes at every packet.
3571                 padLen = TransferBufferLength - OrgBufferLength + 4;/* 4 == last packet padding */
3572                 ASSERT((padLen <= (RTMP_PKT_TAIL_PADDING - 4/* 4 == MaxBulkOutsize alignment padding */)));
3573
3574                 /* Now memzero all extra padding bytes. */
3575                 NdisZeroMemory(pDest, padLen);
3576                 pDest += padLen;
3577 #else
3578                 if ((TransferBufferLength % 4) == 1)
3579                 {
3580                         NdisZeroMemory(pDest, 7);
3581                         pDest += 7;
3582                         TransferBufferLength  += 3;
3583                 }
3584                 else if ((TransferBufferLength % 4) == 2)
3585                 {
3586                         NdisZeroMemory(pDest, 6);
3587                         pDest += 6;
3588                         TransferBufferLength  += 2;
3589                 }
3590                 else if ((TransferBufferLength % 4) == 3)
3591                 {
3592                         NdisZeroMemory(pDest, 5);
3593                         pDest += 5;
3594                         TransferBufferLength  += 1;
3595                 }
3596 #endif // 1 //
3597
3598                 // Update pTxInfo->USBDMATxPktLen to include padding.
3599                 pTxInfo->USBDMATxPktLen = TransferBufferLength - TXINFO_SIZE;
3600
3601                 TransferBufferLength += 4;
3602
3603                 // If TransferBufferLength is multiple of 64, add extra 4 bytes again.
3604                 if ((TransferBufferLength % pAd->BulkOutMaxPacketSize) == 0)
3605                 {
3606                         NdisZeroMemory(pDest, 4);
3607                         TransferBufferLength += 4;
3608                 }
3609
3610                 // Fill out frame length information for global Bulk out arbitor
3611                 pAd->NullContext.BulkOutSize = TransferBufferLength;
3612         }
3613 #ifdef RT_BIG_ENDIAN
3614         RTMPWIEndianChange((PUCHAR)pTxWI, TYPE_TXWI);
3615         RTMPFrameEndianChange(pAd, (((PUCHAR)pTxInfo)+TXWI_SIZE+TXINFO_SIZE), DIR_WRITE, FALSE);
3616     RTMPDescriptorEndianChange((PUCHAR)pTxInfo, TYPE_TXINFO);
3617 #endif // RT_BIG_ENDIAN //
3618         return 0;
3619 }
3620
3621 VOID ATE_RTUSBBulkOutDataPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs)
3622 {
3623         PRTMP_ADAPTER           pAd;
3624         PTX_CONTEXT                 pNullContext;
3625         UCHAR                           BulkOutPipeId;
3626         NTSTATUS                        Status;
3627         unsigned long           IrqFlags;
3628         ULONG                       OldValue;
3629
3630         pNullContext = (PTX_CONTEXT)pUrb->context;
3631         pAd = pNullContext->pAd;
3632
3633
3634         // Reset Null frame context flags
3635         pNullContext->IRPPending = FALSE;
3636         pNullContext->InUse = FALSE;
3637         Status = pUrb->status;
3638
3639         // Store BulkOut PipeId
3640         BulkOutPipeId = pNullContext->BulkOutPipeId;
3641         pAd->BulkOutDataOneSecCount++;
3642
3643         if (Status == USB_ST_NOERROR)
3644         {
3645 #ifdef RALINK_28xx_QA
3646                 if ((ATE_ON(pAd)) && (pAd->ate.bQATxStart == TRUE))
3647                 {
3648                         if (pAd->ate.QID == BulkOutPipeId)
3649                         {
3650                                 // Let Rx can have a chance to break in during Tx process,
3651                                 // especially for loopback mode in QA ATE.
3652                                 // To trade off between tx performance and loopback mode integrity.
3653                                 /* Q   : Now Rx is handled by tasklet, do we still need this delay ? */
3654                                 /* Ans : Even tasklet is used, Rx/Tx < 1 if we do not delay for a while right here. */
3655                                 RTMPusecDelay(500);
3656                                 pAd->ate.TxDoneCount++;
3657                                 pAd->RalinkCounters.KickTxCount++;
3658                                 ASSERT(pAd->ate.QID == 0);
3659                                 pAd->ate.TxAc0++;
3660                         }
3661                 }
3662 #endif // RALINK_28xx_QA //
3663                 pAd->BulkOutComplete++;
3664
3665                 pAd->Counters8023.GoodTransmits++;
3666
3667                 /* Don't worry about the queue is empty or not. This function will check itself. */
3668                 RTMPDeQueuePacket(pAd, TRUE, BulkOutPipeId, MAX_TX_PROCESS);
3669
3670                 /* In 28xx, SendTxWaitQueue ==> TxSwQueue  */
3671 /*
3672                 if (pAd->SendTxWaitQueue[BulkOutPipeId].Number > 0)
3673                 {
3674                         RTMPDeQueuePacket(pAd, BulkOutPipeId);
3675                 }
3676 */
3677         }
3678         else    // STATUS_OTHER
3679         {
3680                 pAd->BulkOutCompleteOther++;
3681
3682                 ATEDBGPRINT(RT_DEBUG_ERROR, ("BulkOutDataPacket Failed STATUS_OTHER = 0x%x . \n", Status));
3683                 ATEDBGPRINT(RT_DEBUG_ERROR, (">>BulkOutReq=0x%lx, BulkOutComplete=0x%lx\n", pAd->BulkOutReq, pAd->BulkOutComplete));
3684
3685                 if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)) &&
3686                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
3687                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
3688                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET)))
3689                 {
3690                         RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_BULKOUT_RESET);
3691                         /* In 28xx, RT_OID_USB_RESET_BULK_OUT ==> CMDTHREAD_RESET_BULK_OUT */
3692                         RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_RESET_BULK_OUT, NULL, 0);
3693                         // Check
3694                         BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3695                         pAd->BulkOutPending[BulkOutPipeId] = FALSE;
3696                         pAd->bulkResetPipeid = BulkOutPipeId;
3697                         BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3698                         return;
3699                 }
3700         }
3701
3702
3703
3704         if (atomic_read(&pAd->BulkOutRemained) > 0)
3705         {
3706                 atomic_dec(&pAd->BulkOutRemained);
3707         }
3708
3709         // 1st - Transmit Success
3710         OldValue = pAd->WlanCounters.TransmittedFragmentCount.u.LowPart;
3711         pAd->WlanCounters.TransmittedFragmentCount.u.LowPart++;
3712
3713         if (pAd->WlanCounters.TransmittedFragmentCount.u.LowPart < OldValue)
3714         {
3715                 pAd->WlanCounters.TransmittedFragmentCount.u.HighPart++;
3716         }
3717
3718         if(((pAd->ContinBulkOut == TRUE ) ||(atomic_read(&pAd->BulkOutRemained) > 0)) && (pAd->ate.Mode & ATE_TXFRAME))
3719         {
3720                 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
3721         }
3722         else
3723         {
3724                 RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
3725 #ifdef RALINK_28xx_QA
3726                 pAd->ate.TxStatus = 0;
3727 #endif // RALINK_28xx_QA //
3728         }
3729
3730         BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3731         pAd->BulkOutPending[BulkOutPipeId] = FALSE;
3732         BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3733
3734         // Always call Bulk routine, even reset bulk.
3735         // The protection of rest bulk should be in BulkOut routine.
3736         RTUSBKickBulkOut(pAd);
3737 }
3738
3739 /*
3740         ========================================================================
3741
3742         Routine Description:
3743
3744         Arguments:
3745
3746         Return Value:
3747
3748         Note:
3749
3750         ========================================================================
3751 */
3752 VOID    ATE_RTUSBBulkOutDataPacket(
3753         IN      PRTMP_ADAPTER   pAd,
3754         IN      UCHAR                   BulkOutPipeId)
3755 {
3756         PTX_CONTEXT             pNullContext = &(pAd->NullContext);
3757         PURB                    pUrb;
3758         int                             ret = 0;
3759         unsigned long   IrqFlags;
3760
3761
3762         ASSERT(BulkOutPipeId == 0);
3763
3764         /* Build up the frame first. */
3765 //      ATESetUpFrame(pAd, 0);
3766
3767         BULK_OUT_LOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3768
3769         if (pAd->BulkOutPending[BulkOutPipeId] == TRUE)
3770         {
3771                 BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3772                 return;
3773         }
3774
3775         pAd->BulkOutPending[BulkOutPipeId] = TRUE;
3776         BULK_OUT_UNLOCK(&pAd->BulkOutLock[BulkOutPipeId], IrqFlags);
3777
3778         // Increase Total transmit byte counter
3779         pAd->RalinkCounters.OneSecTransmittedByteCount +=  pNullContext->BulkOutSize;
3780         pAd->RalinkCounters.TransmittedByteCount +=  pNullContext->BulkOutSize;
3781
3782         // Clear ATE frame bulk out flag
3783         RTUSB_CLEAR_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_ATE);
3784
3785         // Init Tx context descriptor
3786         pNullContext->IRPPending = TRUE;
3787         RTUSBInitTxDesc(pAd, pNullContext, BulkOutPipeId, (usb_complete_t)ATE_RTUSBBulkOutDataPacketComplete);
3788         pUrb = pNullContext->pUrb;
3789
3790         if((ret = RTUSB_SUBMIT_URB(pUrb))!=0)
3791         {
3792                 ATEDBGPRINT(RT_DEBUG_ERROR, ("ATE_RTUSBBulkOutDataPacket: Submit Tx URB failed %d\n", ret));
3793                 return;
3794         }
3795
3796         pAd->BulkOutReq++;
3797         return;
3798
3799 }
3800
3801 /*
3802         ========================================================================
3803
3804         Routine Description:
3805
3806         Arguments:
3807
3808         Return Value:
3809
3810         Note:
3811
3812         ========================================================================
3813 */
3814 VOID    ATE_RTUSBCancelPendingBulkInIRP(
3815         IN      PRTMP_ADAPTER   pAd)
3816 {
3817         PRX_CONTEXT             pRxContext;
3818         UINT                    i;
3819
3820         ATEDBGPRINT(RT_DEBUG_TRACE, ("--->ATE_RTUSBCancelPendingBulkInIRP\n"));
3821 #if 1
3822         for ( i = 0; i < (RX_RING_SIZE); i++)
3823         {
3824                 pRxContext = &(pAd->RxContext[i]);
3825                 if(pRxContext->IRPPending == TRUE)
3826                 {
3827                         RTUSB_UNLINK_URB(pRxContext->pUrb);
3828                         pRxContext->IRPPending = FALSE;
3829                         pRxContext->InUse = FALSE;
3830                         //NdisInterlockedDecrement(&pAd->PendingRx);
3831                         //pAd->PendingRx--;
3832                 }
3833         }
3834 #else
3835         for ( i = 0; i < (RX_RING_SIZE); i++)
3836         {
3837                 pRxContext = &(pAd->RxContext[i]);
3838                 if(atomic_read(&pRxContext->IrpLock) == IRPLOCK_CANCELABLE)
3839                 {
3840                         RTUSB_UNLINK_URB(pRxContext->pUrb);
3841                 }
3842                 InterlockedExchange(&pRxContext->IrpLock, IRPLOCK_CANCE_START);
3843         }
3844 #endif // 1 //
3845         ATEDBGPRINT(RT_DEBUG_TRACE, ("<---ATE_RTUSBCancelPendingBulkInIRP\n"));
3846         return;
3847 }
3848 #endif // RT2870 //
3849
3850 VOID rt_ee_read_all(PRTMP_ADAPTER pAd, USHORT *Data)
3851 {
3852         USHORT i;
3853         USHORT value;
3854
3855         for (i = 0 ; i < EEPROM_SIZE/2 ; )
3856         {
3857                 /* "value" is expecially for some compilers... */
3858                 RT28xx_EEPROM_READ16(pAd, i*2, value);
3859                 Data[i] = value;
3860                 i++;
3861         }
3862 }
3863
3864 VOID rt_ee_write_all(PRTMP_ADAPTER pAd, USHORT *Data)
3865 {
3866         USHORT i;
3867         USHORT value;
3868
3869         for (i = 0 ; i < EEPROM_SIZE/2 ; )
3870         {
3871                 /* "value" is expecially for some compilers... */
3872                 value = Data[i];
3873                 RT28xx_EEPROM_WRITE16(pAd, i*2, value);
3874                 i ++;
3875         }
3876 }
3877 #ifdef RALINK_28xx_QA
3878 VOID ATE_QA_Statistics(
3879         IN PRTMP_ADAPTER                        pAd,
3880         IN PRXWI_STRUC                          pRxWI,
3881         IN PRT28XX_RXD_STRUC            pRxD,
3882         IN PHEADER_802_11                       pHeader)
3883 {
3884         // update counter first
3885         if (pHeader != NULL)
3886         {
3887                 if (pHeader->FC.Type == BTYPE_DATA)
3888                 {
3889                         if (pRxD->U2M)
3890                                 pAd->ate.U2M++;
3891                         else
3892                                 pAd->ate.OtherData++;
3893                 }
3894                 else if (pHeader->FC.Type == BTYPE_MGMT)
3895                 {
3896                         if (pHeader->FC.SubType == SUBTYPE_BEACON)
3897                                 pAd->ate.Beacon++;
3898                         else
3899                                 pAd->ate.OtherCount++;
3900                 }
3901                 else if (pHeader->FC.Type == BTYPE_CNTL)
3902                 {
3903                         pAd->ate.OtherCount++;
3904                 }
3905         }
3906         pAd->ate.RSSI0 = pRxWI->RSSI0;
3907         pAd->ate.RSSI1 = pRxWI->RSSI1;
3908         pAd->ate.RSSI2 = pRxWI->RSSI2;
3909         pAd->ate.SNR0 = pRxWI->SNR0;
3910         pAd->ate.SNR1 = pRxWI->SNR1;
3911 }
3912
3913 /* command id with Cmd Type == 0x0008(for 28xx)/0x0005(for iNIC) */
3914 #define RACFG_CMD_RF_WRITE_ALL          0x0000
3915 #define RACFG_CMD_E2PROM_READ16         0x0001
3916 #define RACFG_CMD_E2PROM_WRITE16        0x0002
3917 #define RACFG_CMD_E2PROM_READ_ALL       0x0003
3918 #define RACFG_CMD_E2PROM_WRITE_ALL      0x0004
3919 #define RACFG_CMD_IO_READ                       0x0005
3920 #define RACFG_CMD_IO_WRITE                      0x0006
3921 #define RACFG_CMD_IO_READ_BULK          0x0007
3922 #define RACFG_CMD_BBP_READ8                     0x0008
3923 #define RACFG_CMD_BBP_WRITE8            0x0009
3924 #define RACFG_CMD_BBP_READ_ALL          0x000a
3925 #define RACFG_CMD_GET_COUNTER           0x000b
3926 #define RACFG_CMD_CLEAR_COUNTER         0x000c
3927
3928 #define RACFG_CMD_RSV1                          0x000d
3929 #define RACFG_CMD_RSV2                          0x000e
3930 #define RACFG_CMD_RSV3                          0x000f
3931
3932 #define RACFG_CMD_TX_START                      0x0010
3933 #define RACFG_CMD_GET_TX_STATUS         0x0011
3934 #define RACFG_CMD_TX_STOP                       0x0012
3935 #define RACFG_CMD_RX_START                      0x0013
3936 #define RACFG_CMD_RX_STOP                       0x0014
3937 #define RACFG_CMD_GET_NOISE_LEVEL       0x0015
3938
3939 #define RACFG_CMD_ATE_START                     0x0080
3940 #define RACFG_CMD_ATE_STOP                      0x0081
3941
3942 #define RACFG_CMD_ATE_START_TX_CARRIER          0x0100
3943 #define RACFG_CMD_ATE_START_TX_CONT                     0x0101
3944 #define RACFG_CMD_ATE_START_TX_FRAME            0x0102
3945 #define RACFG_CMD_ATE_SET_BW                0x0103
3946 #define RACFG_CMD_ATE_SET_TX_POWER0             0x0104
3947 #define RACFG_CMD_ATE_SET_TX_POWER1                     0x0105
3948 #define RACFG_CMD_ATE_SET_FREQ_OFFSET           0x0106
3949 #define RACFG_CMD_ATE_GET_STATISTICS            0x0107
3950 #define RACFG_CMD_ATE_RESET_COUNTER                     0x0108
3951 #define RACFG_CMD_ATE_SEL_TX_ANTENNA            0x0109
3952 #define RACFG_CMD_ATE_SEL_RX_ANTENNA            0x010a
3953 #define RACFG_CMD_ATE_SET_PREAMBLE                      0x010b
3954 #define RACFG_CMD_ATE_SET_CHANNEL                       0x010c
3955 #define RACFG_CMD_ATE_SET_ADDR1                         0x010d
3956 #define RACFG_CMD_ATE_SET_ADDR2                         0x010e
3957 #define RACFG_CMD_ATE_SET_ADDR3                         0x010f
3958 #define RACFG_CMD_ATE_SET_RATE                          0x0110
3959 #define RACFG_CMD_ATE_SET_TX_FRAME_LEN          0x0111
3960 #define RACFG_CMD_ATE_SET_TX_FRAME_COUNT        0x0112
3961 #define RACFG_CMD_ATE_START_RX_FRAME            0x0113
3962 #define RACFG_CMD_ATE_E2PROM_READ_BULK  0x0114
3963 #define RACFG_CMD_ATE_E2PROM_WRITE_BULK 0x0115
3964 #define RACFG_CMD_ATE_IO_WRITE_BULK             0x0116
3965 #define RACFG_CMD_ATE_BBP_READ_BULK             0x0117
3966 #define RACFG_CMD_ATE_BBP_WRITE_BULK    0x0118
3967 #define RACFG_CMD_ATE_RF_READ_BULK              0x0119
3968 #define RACFG_CMD_ATE_RF_WRITE_BULK             0x011a
3969
3970
3971
3972 #define A2Hex(_X, _p)                           \
3973 {                                                                       \
3974         UCHAR *p;                                               \
3975         _X = 0;                                                 \
3976         p = _p;                                                 \
3977         while (((*p >= 'a') && (*p <= 'f')) || ((*p >= 'A') && (*p <= 'F')) || ((*p >= '0') && (*p <= '9')))            \
3978         {                                                                                               \
3979                 if ((*p >= 'a') && (*p <= 'f'))                         \
3980                         _X = _X * 16 + *p - 87;                                 \
3981                 else if ((*p >= 'A') && (*p <= 'F'))            \
3982                         _X = _X * 16 + *p - 55;                                 \
3983                 else if ((*p >= '0') && (*p <= '9'))            \
3984                         _X = _X * 16 + *p - 48;                                 \
3985                 p++;                                                                            \
3986         }                                                                                               \
3987 }
3988
3989
3990 static VOID memcpy_exl(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, ULONG len);
3991 static VOID memcpy_exs(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, ULONG len);
3992 static VOID RTMP_IO_READ_BULK(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, UINT32 len);
3993
3994 #define LEN_OF_ARG 16
3995
3996 VOID RtmpDoAte(
3997         IN      PRTMP_ADAPTER   pAdapter,
3998         IN      struct iwreq    *wrq)
3999 {
4000         unsigned short Command_Id;
4001         struct ate_racfghdr *pRaCfg;
4002         INT     Status = NDIS_STATUS_SUCCESS;
4003
4004
4005
4006         if((pRaCfg = kmalloc(sizeof(struct ate_racfghdr), GFP_KERNEL)) == NULL)
4007         {
4008                 Status = -EINVAL;
4009                 return;
4010         }
4011
4012         NdisZeroMemory(pRaCfg, sizeof(struct ate_racfghdr));
4013
4014     if (copy_from_user((PUCHAR)pRaCfg, wrq->u.data.pointer, wrq->u.data.length))
4015         {
4016                 Status = -EFAULT;
4017                 kfree(pRaCfg);
4018                 return;
4019         }
4020
4021
4022         Command_Id = ntohs(pRaCfg->command_id);
4023
4024         ATEDBGPRINT(RT_DEBUG_TRACE,("\n%s: Command_Id = 0x%04x !\n", __func__, Command_Id));
4025
4026         switch (Command_Id)
4027         {
4028                 // We will get this command when QA starts.
4029                 case RACFG_CMD_ATE_START:
4030                         {
4031                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START\n"));
4032
4033                                 // prepare feedback as soon as we can to avoid QA timeout.
4034                                 pRaCfg->length = htons(2);
4035                                 pRaCfg->status = htons(0);
4036
4037                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4038                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4039                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4040
4041                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
4042
4043                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4044                 {
4045                         ATEDBGPRINT(RT_DEBUG_TRACE, ("copy_to_user() fail in case RACFG_CMD_ATE_START\n"));
4046                     Status = -EFAULT;
4047                 }
4048                                 else
4049                                 {
4050                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START is done !\n"));
4051                                 }
4052                                 Set_ATE_Proc(pAdapter, "ATESTART");
4053                         }
4054                         break;
4055
4056                 // We will get this command either QA is closed or ated is killed by user.
4057                 case RACFG_CMD_ATE_STOP:
4058                         {
4059                                 INT32 ret;
4060
4061                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_STOP\n"));
4062
4063                                 // Distinguish this command came from QA(via ated)
4064                                 // or ate daemon according to the existence of pid in payload.
4065                                 // No need to prepare feedback if this cmd came directly from ate daemon.
4066                                 pRaCfg->length = ntohs(pRaCfg->length);
4067
4068                                 if (pRaCfg->length == sizeof(pAdapter->ate.AtePid))
4069                                 {
4070                                         // This command came from QA.
4071                                         // Get the pid of ATE daemon.
4072                                         memcpy((UCHAR *)&pAdapter->ate.AtePid,
4073                                                 (&pRaCfg->data[0]) - 2/* == &(pRaCfg->status) */,
4074                                                 sizeof(pAdapter->ate.AtePid));
4075
4076                                         // prepare feedback as soon as we can to avoid QA timeout.
4077                                         pRaCfg->length = htons(2);
4078                                         pRaCfg->status = htons(0);
4079
4080                                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4081                                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4082                                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4083
4084                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
4085
4086                         if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4087                         {
4088                                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_STOP\n"));
4089                             Status = -EFAULT;
4090                         }
4091
4092                                         //
4093                                         // kill ATE daemon when leaving ATE mode.
4094                                         // We must kill ATE daemon first before setting ATESTOP,
4095                                         // or Microsoft will report sth. wrong.
4096                                         ret = KILL_THREAD_PID(pAdapter->ate.AtePid, SIGTERM, 1);
4097                                         if (ret)
4098                                         {
4099                                                 ATEDBGPRINT(RT_DEBUG_ERROR, ("%s: unable to signal thread\n", pAdapter->net_dev->name));
4100                                         }
4101                                 }
4102
4103                                 // AP might have in ATE_STOP mode due to cmd from QA.
4104                                 if (ATE_ON(pAdapter))
4105                                 {
4106                                         // Someone has killed ate daemon while QA GUI is still open.
4107                                         Set_ATE_Proc(pAdapter, "ATESTOP");
4108                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_AP_START is done !\n"));
4109                                 }
4110                         }
4111                         break;
4112
4113                 case RACFG_CMD_RF_WRITE_ALL:
4114                         {
4115                                 UINT32 R1, R2, R3, R4;
4116                                 USHORT channel;
4117
4118                                 memcpy(&R1, pRaCfg->data-2, 4);
4119                                 memcpy(&R2, pRaCfg->data+2, 4);
4120                                 memcpy(&R3, pRaCfg->data+6, 4);
4121                                 memcpy(&R4, pRaCfg->data+10, 4);
4122                                 memcpy(&channel, pRaCfg->data+14, 2);
4123
4124                                 pAdapter->LatchRfRegs.R1 = ntohl(R1);
4125                                 pAdapter->LatchRfRegs.R2 = ntohl(R2);
4126                                 pAdapter->LatchRfRegs.R3 = ntohl(R3);
4127                                 pAdapter->LatchRfRegs.R4 = ntohl(R4);
4128                                 pAdapter->LatchRfRegs.Channel = ntohs(channel);
4129
4130                                 RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R1);
4131                                 RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R2);
4132                                 RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R3);
4133                                 RTMP_RF_IO_WRITE32(pAdapter, pAdapter->LatchRfRegs.R4);
4134
4135                                 // prepare feedback
4136                                 pRaCfg->length = htons(2);
4137                                 pRaCfg->status = htons(0);
4138
4139                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4140                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4141                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4142
4143                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
4144                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4145                 {
4146                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RF_WRITE_ALL\n"));
4147                     Status = -EFAULT;
4148                 }
4149                                 else
4150                                 {
4151                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RF_WRITE_ALL is done !\n"));
4152                                 }
4153                         }
4154             break;
4155
4156                 case RACFG_CMD_E2PROM_READ16:
4157                         {
4158                                 USHORT  offset, value, tmp;
4159
4160                                 offset = ntohs(pRaCfg->status);
4161                                 /* "tmp" is expecially for some compilers... */
4162                                 RT28xx_EEPROM_READ16(pAdapter, offset, tmp);
4163                                 value = tmp;
4164                                 value = htons(value);
4165
4166                                 ATEDBGPRINT(RT_DEBUG_TRACE,("EEPROM Read offset = 0x%04x, value = 0x%04x\n", offset, value));
4167
4168                                 // prepare feedback
4169                                 pRaCfg->length = htons(4);
4170                                 pRaCfg->status = htons(0);
4171                                 memcpy(pRaCfg->data, &value, 2);
4172
4173                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4174                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4175                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4176
4177                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("sizeof(struct ate_racfghdr) = %d\n", sizeof(struct ate_racfghdr)));
4178                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
4179
4180                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4181                 {
4182                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_READ16\n"));
4183                     Status = -EFAULT;
4184                 }
4185                                 else
4186                                 {
4187                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_E2PROM_READ16 is done !\n"));
4188                                 }
4189                 }
4190                         break;
4191
4192                 case RACFG_CMD_E2PROM_WRITE16:
4193                         {
4194                                 USHORT  offset, value;
4195
4196                                 offset = ntohs(pRaCfg->status);
4197                                 memcpy(&value, pRaCfg->data, 2);
4198                                 value = ntohs(value);
4199                                 RT28xx_EEPROM_WRITE16(pAdapter, offset, value);
4200
4201                                 // prepare feedback
4202                                 pRaCfg->length = htons(2);
4203                                 pRaCfg->status = htons(0);
4204                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4205                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4206                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4207
4208                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4209                 {
4210                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_WRITE16\n"));
4211                     Status = -EFAULT;
4212                 }
4213                                 else
4214                                 {
4215                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_E2PROM_WRITE16 is done !\n"));
4216                                 }
4217                         }
4218                         break;
4219
4220                 case RACFG_CMD_E2PROM_READ_ALL:
4221                         {
4222                                 USHORT buffer[EEPROM_SIZE/2];
4223
4224                                 rt_ee_read_all(pAdapter,(USHORT *)buffer);
4225                                 memcpy_exs(pAdapter, pRaCfg->data, (UCHAR *)buffer, EEPROM_SIZE);
4226
4227                                 // prepare feedback
4228                                 pRaCfg->length = htons(2+EEPROM_SIZE);
4229                                 pRaCfg->status = htons(0);
4230                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4231                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4232                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4233
4234                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4235                 {
4236                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_READ_ALL\n"));
4237                     Status = -EFAULT;
4238                 }
4239                                 else
4240                                 {
4241                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_E2PROM_READ_ALL is done !\n"));
4242                                 }
4243                         }
4244                         break;
4245
4246                 case RACFG_CMD_E2PROM_WRITE_ALL:
4247                         {
4248                                 USHORT buffer[EEPROM_SIZE/2];
4249
4250                                 NdisZeroMemory((UCHAR *)buffer, EEPROM_SIZE);
4251                                 memcpy_exs(pAdapter, (UCHAR *)buffer, (UCHAR *)&pRaCfg->status, EEPROM_SIZE);
4252                                 rt_ee_write_all(pAdapter,(USHORT *)buffer);
4253
4254                                 // prepare feedback
4255                                 pRaCfg->length = htons(2);
4256                                 pRaCfg->status = htons(0);
4257                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4258                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4259                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4260
4261                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4262                 {
4263                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_E2PROM_WRITE_ALL\n"));
4264                     Status = -EFAULT;
4265                 }
4266                                 else
4267                                 {
4268                         ATEDBGPRINT(RT_DEBUG_ERROR, ("RACFG_CMD_E2PROM_WRITE_ALL is done !\n"));
4269                                 }
4270
4271                         }
4272                         break;
4273
4274                 case RACFG_CMD_IO_READ:
4275                         {
4276                                 UINT32  offset;
4277                                 UINT32  value;
4278
4279                                 memcpy(&offset, &pRaCfg->status, 4);
4280                                 offset = ntohl(offset);
4281
4282                                 // We do not need the base address.
4283                                 // So just extract the offset out.
4284                                 offset &= 0x0000FFFF;
4285                                 RTMP_IO_READ32(pAdapter, offset, &value);
4286                                 value = htonl(value);
4287
4288                                 // prepare feedback
4289                                 pRaCfg->length = htons(6);
4290                                 pRaCfg->status = htons(0);
4291                                 memcpy(pRaCfg->data, &value, 4);
4292
4293                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4294                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4295                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4296
4297                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4298                 {
4299                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_IO_READ\n"));
4300                     Status = -EFAULT;
4301                 }
4302                                 else
4303                                 {
4304                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_IO_READ is done !\n"));
4305                                 }
4306                         }
4307                         break;
4308
4309                 case RACFG_CMD_IO_WRITE:
4310                         {
4311                                 UINT32  offset, value;
4312
4313                                 memcpy(&offset, pRaCfg->data-2, 4);
4314                                 memcpy(&value, pRaCfg->data+2, 4);
4315
4316                                 offset = ntohl(offset);
4317
4318                                 // We do not need the base address.
4319                                 // So just extract out the offset.
4320                                 offset &= 0x0000FFFF;
4321                                 value = ntohl(value);
4322                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_IO_WRITE: offset = %x, value = %x\n", offset, value));
4323                                 RTMP_IO_WRITE32(pAdapter, offset, value);
4324
4325                                 // prepare feedback
4326                                 pRaCfg->length = htons(2);
4327                                 pRaCfg->status = htons(0);
4328                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4329                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4330                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4331
4332                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4333                 {
4334                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_IO_WRITE\n"));
4335                     Status = -EFAULT;
4336                 }
4337                                 else
4338                                 {
4339                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_IO_WRITE is done !\n"));
4340                                 }
4341                         }
4342                         break;
4343
4344                 case RACFG_CMD_IO_READ_BULK:
4345                         {
4346                                 UINT32  offset;
4347                                 USHORT  len;
4348
4349                                 memcpy(&offset, &pRaCfg->status, 4);
4350                                 offset = ntohl(offset);
4351
4352                                 // We do not need the base address.
4353                                 // So just extract the offset.
4354                                 offset &= 0x0000FFFF;
4355                                 memcpy(&len, pRaCfg->data+2, 2);
4356                                 len = ntohs(len);
4357
4358                                 if (len > 371)
4359                                 {
4360                                         ATEDBGPRINT(RT_DEBUG_TRACE,("len is too large, make it smaller\n"));
4361                                         pRaCfg->length = htons(2);
4362                                         pRaCfg->status = htons(1);
4363                                         break;
4364                                 }
4365
4366                                 RTMP_IO_READ_BULK(pAdapter, pRaCfg->data, (UCHAR *)offset, len*4);// unit in four bytes
4367
4368                                 // prepare feedback
4369                                 pRaCfg->length = htons(2+len*4);// unit in four bytes
4370                                 pRaCfg->status = htons(0);
4371                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4372                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4373                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4374
4375                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4376                 {
4377                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_IO_READ_BULK\n"));
4378                     Status = -EFAULT;
4379                 }
4380                                 else
4381                                 {
4382                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_IO_READ_BULK is done !\n"));
4383                                 }
4384                         }
4385                         break;
4386
4387                 case RACFG_CMD_BBP_READ8:
4388                         {
4389                                 USHORT  offset;
4390                                 UCHAR   value;
4391
4392                                 value = 0;
4393                                 offset = ntohs(pRaCfg->status);
4394
4395                                 if (ATE_ON(pAdapter))
4396                                 {
4397                                         ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, offset,  &value);
4398                                 }
4399                                 else
4400                                 {
4401                                         RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, offset,  &value);
4402                                 }
4403                                 // prepare feedback
4404                                 pRaCfg->length = htons(3);
4405                                 pRaCfg->status = htons(0);
4406                                 pRaCfg->data[0] = value;
4407
4408                                 ATEDBGPRINT(RT_DEBUG_TRACE,("BBP value = %x\n", value));
4409
4410                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4411                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4412                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4413
4414                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4415                 {
4416                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_BBP_READ8\n"));
4417                     Status = -EFAULT;
4418                 }
4419                                 else
4420                                 {
4421                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_BBP_READ8 is done !\n"));
4422                                 }
4423                         }
4424                         break;
4425                 case RACFG_CMD_BBP_WRITE8:
4426                         {
4427                                 USHORT  offset;
4428                                 UCHAR   value;
4429
4430                                 offset = ntohs(pRaCfg->status);
4431                                 memcpy(&value, pRaCfg->data, 1);
4432
4433                                 if (ATE_ON(pAdapter))
4434                                 {
4435                                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAdapter, offset,  value);
4436                                 }
4437                                 else
4438                                 {
4439                                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, offset,  value);
4440                                 }
4441
4442                                 if ((offset == BBP_R1) || (offset == BBP_R3))
4443                                 {
4444                                         SyncTxRxConfig(pAdapter, offset, value);
4445                                 }
4446
4447                                 // prepare feedback
4448                                 pRaCfg->length = htons(2);
4449                                 pRaCfg->status = htons(0);
4450                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4451                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4452                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4453
4454                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4455                 {
4456                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_BBP_WRITE8\n"));
4457                     Status = -EFAULT;
4458                 }
4459                                 else
4460                                 {
4461                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_BBP_WRITE8 is done !\n"));
4462                                 }
4463                         }
4464                         break;
4465
4466                 case RACFG_CMD_BBP_READ_ALL:
4467                         {
4468                                 USHORT j;
4469
4470                                 for (j = 0; j < 137; j++)
4471                                 {
4472                                         pRaCfg->data[j] = 0;
4473
4474                                         if (ATE_ON(pAdapter))
4475                                         {
4476                                                 ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, j,  &pRaCfg->data[j]);
4477                                         }
4478                                         else
4479                                         {
4480                                                 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, j,  &pRaCfg->data[j]);
4481                                         }
4482                                 }
4483
4484                                 // prepare feedback
4485                                 pRaCfg->length = htons(2+137);
4486                                 pRaCfg->status = htons(0);
4487
4488                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4489                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4490                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4491
4492                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4493                 {
4494                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_BBP_READ_ALL\n"));
4495                     Status = -EFAULT;
4496                 }
4497                                 else
4498                                 {
4499                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_BBP_READ_ALL is done !\n"));
4500                                 }
4501                         }
4502
4503                         break;
4504
4505                 case RACFG_CMD_ATE_E2PROM_READ_BULK:
4506                 {
4507                         USHORT offset;
4508                         USHORT len;
4509                         USHORT buffer[EEPROM_SIZE/2];
4510
4511                         offset = ntohs(pRaCfg->status);
4512                         memcpy(&len, pRaCfg->data, 2);
4513                         len = ntohs(len);
4514
4515                         rt_ee_read_all(pAdapter,(USHORT *)buffer);
4516                         if (offset + len <= EEPROM_SIZE)
4517                                 memcpy_exs(pAdapter, pRaCfg->data, (UCHAR *)buffer+offset, len);
4518                         else
4519                                 ATEDBGPRINT(RT_DEBUG_ERROR, ("exceed EEPROM size\n"));
4520
4521                         // prepare feedback
4522                         pRaCfg->length = htons(2+len);
4523                         pRaCfg->status = htons(0);
4524                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4525                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4526                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4527
4528             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4529             {
4530                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_E2PROM_READ_BULK\n"));
4531                 Status = -EFAULT;
4532             }
4533                         else
4534                         {
4535                 ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_E2PROM_READ_BULK is done !\n"));
4536                         }
4537
4538                 }
4539                         break;
4540
4541                 case RACFG_CMD_ATE_E2PROM_WRITE_BULK:
4542                 {
4543                         USHORT offset;
4544                         USHORT len;
4545                         USHORT buffer[EEPROM_SIZE/2];
4546
4547                         offset = ntohs(pRaCfg->status);
4548                         memcpy(&len, pRaCfg->data, 2);
4549                         len = ntohs(len);
4550
4551                         rt_ee_read_all(pAdapter,(USHORT *)buffer);
4552                         memcpy_exs(pAdapter, (UCHAR *)buffer + offset, (UCHAR *)pRaCfg->data + 2, len);
4553                         rt_ee_write_all(pAdapter,(USHORT *)buffer);
4554
4555                         // prepare feedback
4556                         pRaCfg->length = htons(2);
4557                         pRaCfg->status = htons(0);
4558                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4559                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4560                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4561             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4562             {
4563                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_E2PROM_WRITE_BULK\n"));
4564                    Status = -EFAULT;
4565             }
4566                         else
4567                         {
4568                 ATEDBGPRINT(RT_DEBUG_ERROR, ("RACFG_CMD_ATE_E2PROM_WRITE_BULK is done !\n"));
4569                         }
4570
4571                 }
4572                         break;
4573
4574                 case RACFG_CMD_ATE_IO_WRITE_BULK:
4575                 {
4576                         UINT32 offset, i, value;
4577                         USHORT len;
4578
4579                         memcpy(&offset, &pRaCfg->status, 4);
4580                         offset = ntohl(offset);
4581                         memcpy(&len, pRaCfg->data+2, 2);
4582                         len = ntohs(len);
4583
4584                         for (i = 0; i < len; i += 4)
4585                         {
4586                                 memcpy_exl(pAdapter, (UCHAR *)&value, pRaCfg->data+4+i, 4);
4587                                 printk("Write %x %x\n", offset + i, value);
4588                                 RTMP_IO_WRITE32(pAdapter, (offset +i) & 0xffff, value);
4589                         }
4590
4591                         // prepare feedback
4592                         pRaCfg->length = htons(2);
4593                         pRaCfg->status = htons(0);
4594                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4595                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4596                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4597             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4598             {
4599                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_IO_WRITE_BULK\n"));
4600                    Status = -EFAULT;
4601             }
4602                         else
4603                         {
4604                 ATEDBGPRINT(RT_DEBUG_ERROR, ("RACFG_CMD_ATE_IO_WRITE_BULK is done !\n"));
4605                         }
4606
4607                 }
4608                         break;
4609
4610                 case RACFG_CMD_ATE_BBP_READ_BULK:
4611                 {
4612                         USHORT offset;
4613                         USHORT len;
4614                         USHORT j;
4615
4616                         offset = ntohs(pRaCfg->status);
4617                         memcpy(&len, pRaCfg->data, 2);
4618                         len = ntohs(len);
4619
4620
4621                         for (j = offset; j < (offset+len); j++)
4622                         {
4623                                 pRaCfg->data[j - offset] = 0;
4624
4625                                 if (pAdapter->ate.Mode == ATE_STOP)
4626                                 {
4627                                         RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, j,  &pRaCfg->data[j - offset]);
4628                                 }
4629                                 else
4630                                 {
4631                                         ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, j,  &pRaCfg->data[j - offset]);
4632                                 }
4633                         }
4634
4635                         // prepare feedback
4636                         pRaCfg->length = htons(2+len);
4637                         pRaCfg->status = htons(0);
4638                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4639                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4640                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4641
4642             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4643             {
4644                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_BBP_READ_BULK\n"));
4645                    Status = -EFAULT;
4646             }
4647                         else
4648                         {
4649                 ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_BBP_READ_BULK is done !\n"));
4650                         }
4651
4652                 }
4653                         break;
4654
4655                 case RACFG_CMD_ATE_BBP_WRITE_BULK:
4656                 {
4657                         USHORT offset;
4658                         USHORT len;
4659                         USHORT j;
4660                         UCHAR *value;
4661
4662                         offset = ntohs(pRaCfg->status);
4663                         memcpy(&len, pRaCfg->data, 2);
4664                         len = ntohs(len);
4665
4666                         for (j = offset; j < (offset+len); j++)
4667                         {
4668                                 value = pRaCfg->data + 2 + (j - offset);
4669                                 if (pAdapter->ate.Mode == ATE_STOP)
4670                                 {
4671                                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, j,  *value);
4672                                 }
4673                                 else
4674                                 {
4675                                         ATE_BBP_IO_WRITE8_BY_REG_ID(pAdapter, j,  *value);
4676                                 }
4677                         }
4678
4679                         // prepare feedback
4680                         pRaCfg->length = htons(2);
4681                         pRaCfg->status = htons(0);
4682                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4683                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4684                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4685
4686             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4687             {
4688                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_BBP_WRITE_BULK\n"));
4689                    Status = -EFAULT;
4690             }
4691                         else
4692                         {
4693                 ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_BBP_WRITE_BULK is done !\n"));
4694                         }
4695                 }
4696                         break;
4697
4698 #ifdef CONFIG_RALINK_RT3052
4699                 case RACFG_CMD_ATE_RF_READ_BULK:
4700                 {
4701                         USHORT offset;
4702                         USHORT len;
4703                         USHORT j;
4704
4705                         offset = ntohs(pRaCfg->status);
4706                         memcpy(&len, pRaCfg->data, 2);
4707                         len = ntohs(len);
4708
4709                         for (j = offset; j < (offset+len); j++)
4710                         {
4711                                 pRaCfg->data[j - offset] = 0;
4712                                 RT30xxReadRFRegister(pAdapter, j,  &pRaCfg->data[j - offset]);
4713                         }
4714
4715                         // prepare feedback
4716                         pRaCfg->length = htons(2+len);
4717                         pRaCfg->status = htons(0);
4718                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4719                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4720                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4721
4722             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4723             {
4724                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_RF_READ_BULK\n"));
4725                    Status = -EFAULT;
4726             }
4727                         else
4728                         {
4729                 ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_RF_READ_BULK is done !\n"));
4730                         }
4731
4732                 }
4733                         break;
4734
4735                 case RACFG_CMD_ATE_RF_WRITE_BULK:
4736                 {
4737                         USHORT offset;
4738                         USHORT len;
4739                         USHORT j;
4740                         UCHAR *value;
4741
4742                         offset = ntohs(pRaCfg->status);
4743                         memcpy(&len, pRaCfg->data, 2);
4744                         len = ntohs(len);
4745
4746                         for (j = offset; j < (offset+len); j++)
4747                         {
4748                                 value = pRaCfg->data + 2 + (j - offset);
4749                                 RT30xxWriteRFRegister(pAdapter, j,  *value);
4750                         }
4751
4752                         // prepare feedback
4753                         pRaCfg->length = htons(2);
4754                         pRaCfg->status = htons(0);
4755                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4756                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4757                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4758
4759             if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4760             {
4761                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_RF_WRITE_BULK\n"));
4762                    Status = -EFAULT;
4763             }
4764                         else
4765                         {
4766                 ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_RF_WRITE_BULK is done !\n"));
4767                         }
4768
4769                 }
4770                         break;
4771 #endif
4772
4773
4774                 case RACFG_CMD_GET_NOISE_LEVEL:
4775                         {
4776                                 UCHAR   channel;
4777                                 INT32   buffer[3][10];/* 3 : RxPath ; 10 : no. of per rssi samples */
4778
4779                                 channel = (ntohs(pRaCfg->status) & 0x00FF);
4780                                 CalNoiseLevel(pAdapter, channel, buffer);
4781                                 memcpy_exl(pAdapter, (UCHAR *)pRaCfg->data, (UCHAR *)&(buffer[0][0]), (sizeof(INT32)*3*10));
4782
4783                                 // prepare feedback
4784                                 pRaCfg->length = htons(2 + (sizeof(INT32)*3*10));
4785                                 pRaCfg->status = htons(0);
4786                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4787                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4788                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4789
4790                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4791                 {
4792                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_GET_NOISE_LEVEL\n"));
4793                     Status = -EFAULT;
4794                 }
4795                                 else
4796                                 {
4797                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_GET_NOISE_LEVEL is done !\n"));
4798                                 }
4799                         }
4800                         break;
4801
4802                 case RACFG_CMD_GET_COUNTER:
4803                         {
4804                                 memcpy_exl(pAdapter, &pRaCfg->data[0], (UCHAR *)&pAdapter->ate.U2M, 4);
4805                                 memcpy_exl(pAdapter, &pRaCfg->data[4], (UCHAR *)&pAdapter->ate.OtherData, 4);
4806                                 memcpy_exl(pAdapter, &pRaCfg->data[8], (UCHAR *)&pAdapter->ate.Beacon, 4);
4807                                 memcpy_exl(pAdapter, &pRaCfg->data[12], (UCHAR *)&pAdapter->ate.OtherCount, 4);
4808                                 memcpy_exl(pAdapter, &pRaCfg->data[16], (UCHAR *)&pAdapter->ate.TxAc0, 4);
4809                                 memcpy_exl(pAdapter, &pRaCfg->data[20], (UCHAR *)&pAdapter->ate.TxAc1, 4);
4810                                 memcpy_exl(pAdapter, &pRaCfg->data[24], (UCHAR *)&pAdapter->ate.TxAc2, 4);
4811                                 memcpy_exl(pAdapter, &pRaCfg->data[28], (UCHAR *)&pAdapter->ate.TxAc3, 4);
4812                                 memcpy_exl(pAdapter, &pRaCfg->data[32], (UCHAR *)&pAdapter->ate.TxHCCA, 4);
4813                                 memcpy_exl(pAdapter, &pRaCfg->data[36], (UCHAR *)&pAdapter->ate.TxMgmt, 4);
4814                                 memcpy_exl(pAdapter, &pRaCfg->data[40], (UCHAR *)&pAdapter->ate.RSSI0, 4);
4815                                 memcpy_exl(pAdapter, &pRaCfg->data[44], (UCHAR *)&pAdapter->ate.RSSI1, 4);
4816                                 memcpy_exl(pAdapter, &pRaCfg->data[48], (UCHAR *)&pAdapter->ate.RSSI2, 4);
4817                                 memcpy_exl(pAdapter, &pRaCfg->data[52], (UCHAR *)&pAdapter->ate.SNR0, 4);
4818                                 memcpy_exl(pAdapter, &pRaCfg->data[56], (UCHAR *)&pAdapter->ate.SNR1, 4);
4819
4820                                 pRaCfg->length = htons(2+60);
4821                                 pRaCfg->status = htons(0);
4822                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4823                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4824                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4825
4826                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4827                 {
4828                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_GET_COUNTER\n"));
4829                     Status = -EFAULT;
4830                 }
4831                                 else
4832                                 {
4833                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_GET_COUNTER is done !\n"));
4834                                 }
4835                         }
4836                         break;
4837
4838                 case RACFG_CMD_CLEAR_COUNTER:
4839                         {
4840                                 pAdapter->ate.U2M = 0;
4841                                 pAdapter->ate.OtherData = 0;
4842                                 pAdapter->ate.Beacon = 0;
4843                                 pAdapter->ate.OtherCount = 0;
4844                                 pAdapter->ate.TxAc0 = 0;
4845                                 pAdapter->ate.TxAc1 = 0;
4846                                 pAdapter->ate.TxAc2 = 0;
4847                                 pAdapter->ate.TxAc3 = 0;
4848                                 pAdapter->ate.TxHCCA = 0;
4849                                 pAdapter->ate.TxMgmt = 0;
4850                                 pAdapter->ate.TxDoneCount = 0;
4851
4852                                 pRaCfg->length = htons(2);
4853                                 pRaCfg->status = htons(0);
4854
4855                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
4856                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
4857                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
4858
4859                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
4860                 {
4861                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_CLEAR_COUNTER\n"));
4862                     Status = -EFAULT;
4863                 }
4864                                 else
4865                                 {
4866                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_CLEAR_COUNTER is done !\n"));
4867                                 }
4868                         }
4869
4870                         break;
4871
4872                 case RACFG_CMD_TX_START:
4873                         {
4874                                 USHORT *p;
4875                                 USHORT  err = 1;
4876                                 UCHAR   Bbp22Value = 0, Bbp24Value = 0;
4877
4878                                 if ((pAdapter->ate.TxStatus != 0) && (pAdapter->ate.Mode & ATE_TXFRAME))
4879                                 {
4880                                         ATEDBGPRINT(RT_DEBUG_TRACE,("Ate Tx is already running, to run next Tx, you must stop it first\n"));
4881                                         err = 2;
4882                                         goto TX_START_ERROR;
4883                                 }
4884                                 else if ((pAdapter->ate.TxStatus != 0) && !(pAdapter->ate.Mode & ATE_TXFRAME))
4885                                 {
4886                                         int i = 0;
4887
4888                                         while ((i++ < 10) && (pAdapter->ate.TxStatus != 0))
4889                                         {
4890                                                 RTMPusecDelay(5000);
4891                                         }
4892
4893                                         // force it to stop
4894                                         pAdapter->ate.TxStatus = 0;
4895                                         pAdapter->ate.TxDoneCount = 0;
4896                                         //pAdapter->ate.Repeat = 0;
4897                                         pAdapter->ate.bQATxStart = FALSE;
4898                                 }
4899
4900                                 // If pRaCfg->length == 0, this "RACFG_CMD_TX_START" is for Carrier test or Carrier Suppression.
4901                                 if (ntohs(pRaCfg->length) != 0)
4902                                 {
4903                                         // Get frame info
4904 #ifdef RT2870
4905                                         NdisMoveMemory(&pAdapter->ate.TxInfo, pRaCfg->data - 2, 4);
4906 #ifdef RT_BIG_ENDIAN
4907                                         RTMPDescriptorEndianChange((PUCHAR) &pAdapter->ate.TxInfo, TYPE_TXINFO);
4908 #endif // RT_BIG_ENDIAN //
4909 #endif // RT2870 //
4910
4911                                         NdisMoveMemory(&pAdapter->ate.TxWI, pRaCfg->data + 2, 16);
4912 #ifdef RT_BIG_ENDIAN
4913                                         RTMPWIEndianChange((PUCHAR)&pAdapter->ate.TxWI, TYPE_TXWI);
4914 #endif // RT_BIG_ENDIAN //
4915
4916                                         NdisMoveMemory(&pAdapter->ate.TxCount, pRaCfg->data + 18, 4);
4917                                         pAdapter->ate.TxCount = ntohl(pAdapter->ate.TxCount);
4918
4919                                         p = (USHORT *)(&pRaCfg->data[22]);
4920                                         //p = pRaCfg->data + 22;
4921                                         // always use QID_AC_BE
4922                                         pAdapter->ate.QID = 0;
4923                                         p = (USHORT *)(&pRaCfg->data[24]);
4924                                         //p = pRaCfg->data + 24;
4925                                         pAdapter->ate.HLen = ntohs(*p);
4926
4927                                         if (pAdapter->ate.HLen > 32)
4928                                         {
4929                                                 ATEDBGPRINT(RT_DEBUG_ERROR,("pAdapter->ate.HLen > 32\n"));
4930                                                 err = 3;
4931                                                 goto TX_START_ERROR;
4932                                         }
4933
4934                                         NdisMoveMemory(&pAdapter->ate.Header, pRaCfg->data + 26, pAdapter->ate.HLen);
4935
4936
4937                                         pAdapter->ate.PLen = ntohs(pRaCfg->length) - (pAdapter->ate.HLen + 28);
4938
4939                                         if (pAdapter->ate.PLen > 32)
4940                                         {
4941                                                 ATEDBGPRINT(RT_DEBUG_ERROR,("pAdapter->ate.PLen > 32\n"));
4942                                                 err = 4;
4943                                                 goto TX_START_ERROR;
4944                                         }
4945
4946                                         NdisMoveMemory(&pAdapter->ate.Pattern, pRaCfg->data + 26 + pAdapter->ate.HLen, pAdapter->ate.PLen);
4947                                         pAdapter->ate.DLen = pAdapter->ate.TxWI.MPDUtotalByteCount - pAdapter->ate.HLen;
4948                                 }
4949
4950                                 ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R22, &Bbp22Value);
4951
4952                                 switch (Bbp22Value)
4953                                 {
4954                                         case BBP22_TXFRAME:
4955                                                 {
4956                                                         if (pAdapter->ate.TxCount == 0)
4957                                                         {
4958                                                         }
4959                                                         ATEDBGPRINT(RT_DEBUG_TRACE,("START TXFRAME\n"));
4960                                                         pAdapter->ate.bQATxStart = TRUE;
4961                                                         Set_ATE_Proc(pAdapter, "TXFRAME");
4962                                                 }
4963                                                 break;
4964
4965                                         case BBP22_TXCONT_OR_CARRSUPP:
4966                                                 {
4967                                                         ATEDBGPRINT(RT_DEBUG_TRACE,("BBP22_TXCONT_OR_CARRSUPP\n"));
4968                                                         ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, 24, &Bbp24Value);
4969
4970                                                         switch (Bbp24Value)
4971                                                         {
4972                                                                 case BBP24_TXCONT:
4973                                                                         {
4974                                                                                 ATEDBGPRINT(RT_DEBUG_TRACE,("START TXCONT\n"));
4975                                                                                 pAdapter->ate.bQATxStart = TRUE;
4976                                                                                 Set_ATE_Proc(pAdapter, "TXCONT");
4977                                                                         }
4978                                                                         break;
4979
4980                                                                 case BBP24_CARRSUPP:
4981                                                                         {
4982                                                                                 ATEDBGPRINT(RT_DEBUG_TRACE,("START TXCARRSUPP\n"));
4983                                                                                 pAdapter->ate.bQATxStart = TRUE;
4984                                                                                 pAdapter->ate.Mode |= ATE_TXCARRSUPP;
4985                                                                         }
4986                                                                         break;
4987
4988                                                                 default:
4989                                                                         {
4990                                                                                 ATEDBGPRINT(RT_DEBUG_ERROR,("Unknown Start TX subtype !"));
4991                                                                         }
4992                                                                         break;
4993                                                         }
4994                                                 }
4995                                                 break;
4996
4997                                         case BBP22_TXCARR:
4998                                                 {
4999                                                         ATEDBGPRINT(RT_DEBUG_TRACE,("START TXCARR\n"));
5000                                                         pAdapter->ate.bQATxStart = TRUE;
5001                                                         Set_ATE_Proc(pAdapter, "TXCARR");
5002                                                 }
5003                                                 break;
5004
5005                                         default:
5006                                                 {
5007                                                         ATEDBGPRINT(RT_DEBUG_ERROR,("Unknown Start TX subtype !"));
5008                                                 }
5009                                                 break;
5010                                 }
5011
5012                                 if (pAdapter->ate.bQATxStart == TRUE)
5013                                 {
5014                                         // prepare feedback
5015                                         pRaCfg->length = htons(2);
5016                                         pRaCfg->status = htons(0);
5017
5018                                         wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5019                                                                                 + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5020                                                                                 + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5021
5022                         if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5023                         {
5024                                 ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() was failed in case RACFG_CMD_TX_START\n"));
5025                             Status = -EFAULT;
5026                         }
5027                                         else
5028                                         {
5029                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_TX_START is done !\n"));
5030                                         }
5031                                         break;
5032                                 }
5033
5034 TX_START_ERROR:
5035                                 // prepare feedback
5036                                 pRaCfg->length = htons(2);
5037                                 pRaCfg->status = htons(err);
5038
5039                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5040                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5041                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5042                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5043                 {
5044                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_TX_START\n"));
5045                     Status = -EFAULT;
5046                 }
5047                                 else
5048                                 {
5049                         ATEDBGPRINT(RT_DEBUG_TRACE, ("feedback of TX_START_ERROR is done !\n"));
5050                                 }
5051                         }
5052                         break;
5053
5054                 case RACFG_CMD_GET_TX_STATUS:
5055                         {
5056                                 UINT32 count;
5057
5058                                 // prepare feedback
5059                                 pRaCfg->length = htons(6);
5060                                 pRaCfg->status = htons(0);
5061                                 count = htonl(pAdapter->ate.TxDoneCount);
5062                                 NdisMoveMemory(pRaCfg->data, &count, 4);
5063                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5064                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5065                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5066
5067                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5068                 {
5069                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_GET_TX_STATUS\n"));
5070                     Status = -EFAULT;
5071                 }
5072                                 else
5073                                 {
5074                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_GET_TX_STATUS is done !\n"));
5075                                 }
5076                         }
5077                         break;
5078
5079                 case RACFG_CMD_TX_STOP:
5080                         {
5081                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_TX_STOP\n"));
5082
5083                                 Set_ATE_Proc(pAdapter, "TXSTOP");
5084
5085                                 // prepare feedback
5086                                 pRaCfg->length = htons(2);
5087                                 pRaCfg->status = htons(0);
5088                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5089                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5090                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5091
5092                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5093                 {
5094                         ATEDBGPRINT(RT_DEBUG_TRACE, ("copy_to_user() fail in case RACFG_CMD_TX_STOP\n"));
5095                     Status = -EFAULT;
5096                 }
5097                                 else
5098                                 {
5099                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_TX_STOP is done !\n"));
5100                                 }
5101                         }
5102                         break;
5103
5104                 case RACFG_CMD_RX_START:
5105                         {
5106                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_START\n"));
5107
5108                                 pAdapter->ate.bQARxStart = TRUE;
5109                                 Set_ATE_Proc(pAdapter, "RXFRAME");
5110
5111                                 // prepare feedback
5112                                 pRaCfg->length = htons(2);
5113                                 pRaCfg->status = htons(0);
5114                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5115                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5116                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5117
5118                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5119                 {
5120                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RX_START\n"));
5121                     Status = -EFAULT;
5122                 }
5123                                 else
5124                                 {
5125                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RX_START is done !\n"));
5126                                 }
5127                         }
5128                         break;
5129
5130                 case RACFG_CMD_RX_STOP:
5131                         {
5132                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_STOP\n"));
5133
5134                                 Set_ATE_Proc(pAdapter, "RXSTOP");
5135
5136                                 // prepare feedback
5137                                 pRaCfg->length = htons(2);
5138                                 pRaCfg->status = htons(0);
5139                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5140                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5141                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5142
5143                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5144                 {
5145                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RX_STOP\n"));
5146                     Status = -EFAULT;
5147                 }
5148                                 else
5149                                 {
5150                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RX_STOP is done !\n"));
5151                                 }
5152                         }
5153                         break;
5154
5155                 /* The following cases are for new ATE GUI(not QA). */
5156                 /*==================================================*/
5157                 case RACFG_CMD_ATE_START_TX_CARRIER:
5158                         {
5159                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_CARRIER\n"));
5160
5161                                 Set_ATE_Proc(pAdapter, "TXCARR");
5162
5163                                 pRaCfg->length = htons(2);
5164                                 pRaCfg->status = htons(0);
5165
5166                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5167                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5168                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5169
5170                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
5171
5172                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5173                 {
5174                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_START_TX_CARRIER\n"));
5175                     Status = -EFAULT;
5176                 }
5177                                 else
5178                                 {
5179                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START_TX_CARRIER is done !\n"));
5180                                 }
5181                         }
5182                         break;
5183
5184                 case RACFG_CMD_ATE_START_TX_CONT:
5185                         {
5186                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_CONT\n"));
5187
5188                                 Set_ATE_Proc(pAdapter, "TXCONT");
5189
5190                                 pRaCfg->length = htons(2);
5191                                 pRaCfg->status = htons(0);
5192
5193                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5194                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5195                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5196
5197                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
5198
5199                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5200                 {
5201                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_START_TX_CONT\n"));
5202                     Status = -EFAULT;
5203                 }
5204                                 else
5205                                 {
5206                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START_TX_CONT is done !\n"));
5207                                 }
5208                         }
5209                         break;
5210
5211                 case RACFG_CMD_ATE_START_TX_FRAME:
5212                         {
5213                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_FRAME\n"));
5214
5215                                 Set_ATE_Proc(pAdapter, "TXFRAME");
5216
5217                                 pRaCfg->length = htons(2);
5218                                 pRaCfg->status = htons(0);
5219
5220                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5221                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5222                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5223
5224                                 ATEDBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", wrq->u.data.length));
5225
5226                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5227                 {
5228                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_START_TX_FRAME\n"));
5229                     Status = -EFAULT;
5230                 }
5231                                 else
5232                                 {
5233                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_START_TX_FRAME is done !\n"));
5234                                 }
5235                         }
5236                         break;
5237
5238                 case RACFG_CMD_ATE_SET_BW:
5239                         {
5240                                 SHORT    value = 0;
5241                                 UCHAR    str[LEN_OF_ARG];
5242
5243                                 NdisZeroMemory(str, LEN_OF_ARG);
5244
5245                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_BW\n"));
5246
5247                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5248                                 value = ntohs(value);
5249                                 sprintf((PCHAR)str, "%d", value);
5250
5251                                 Set_ATE_TX_BW_Proc(pAdapter, str);
5252
5253                                 // prepare feedback
5254                                 pRaCfg->length = htons(2);
5255                                 pRaCfg->status = htons(0);
5256                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5257                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5258                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5259
5260                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5261                 {
5262                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_BW\n"));
5263                     Status = -EFAULT;
5264                 }
5265                                 else
5266                                 {
5267                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_BW is done !\n"));
5268                                 }
5269                         }
5270                         break;
5271
5272                 case RACFG_CMD_ATE_SET_TX_POWER0:
5273                         {
5274                                 SHORT    value = 0;
5275                                 UCHAR    str[LEN_OF_ARG];
5276
5277                                 NdisZeroMemory(str, LEN_OF_ARG);
5278
5279                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER0\n"));
5280
5281                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5282                                 value = ntohs(value);
5283                                 sprintf((PCHAR)str, "%d", value);
5284                                 Set_ATE_TX_POWER0_Proc(pAdapter, str);
5285
5286                                 // prepare feedback
5287                                 pRaCfg->length = htons(2);
5288                                 pRaCfg->status = htons(0);
5289                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5290                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5291                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5292
5293                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5294                 {
5295                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_POWER0\n"));
5296                     Status = -EFAULT;
5297                 }
5298                                 else
5299                                 {
5300                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_POWER0 is done !\n"));
5301                                 }
5302                         }
5303                         break;
5304
5305                 case RACFG_CMD_ATE_SET_TX_POWER1:
5306                         {
5307                                 SHORT    value = 0;
5308                                 UCHAR    str[LEN_OF_ARG];
5309
5310                                 NdisZeroMemory(str, LEN_OF_ARG);
5311
5312                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER1\n"));
5313
5314                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5315                                 value = ntohs(value);
5316                                 sprintf((PCHAR)str, "%d", value);
5317                                 Set_ATE_TX_POWER1_Proc(pAdapter, str);
5318
5319                                 // prepare feedback
5320                                 pRaCfg->length = htons(2);
5321                                 pRaCfg->status = htons(0);
5322                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5323                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5324                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5325
5326                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5327                 {
5328                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_POWER1\n"));
5329                     Status = -EFAULT;
5330                 }
5331                                 else
5332                                 {
5333                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_POWER1 is done !\n"));
5334                                 }
5335                         }
5336                         break;
5337
5338                 case RACFG_CMD_ATE_SET_FREQ_OFFSET:
5339                         {
5340                                 SHORT    value = 0;
5341                                 UCHAR    str[LEN_OF_ARG];
5342
5343                                 NdisZeroMemory(str, LEN_OF_ARG);
5344
5345                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_FREQ_OFFSET\n"));
5346
5347                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5348                                 value = ntohs(value);
5349                                 sprintf((PCHAR)str, "%d", value);
5350                                 Set_ATE_TX_FREQOFFSET_Proc(pAdapter, str);
5351
5352                                 // prepare feedback
5353                                 pRaCfg->length = htons(2);
5354                                 pRaCfg->status = htons(0);
5355                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5356                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5357                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5358
5359                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5360                 {
5361                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_FREQ_OFFSET\n"));
5362                     Status = -EFAULT;
5363                 }
5364                                 else
5365                                 {
5366                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_FREQ_OFFSET is done !\n"));
5367                                 }
5368                         }
5369                         break;
5370
5371                 case RACFG_CMD_ATE_GET_STATISTICS:
5372                         {
5373                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_GET_STATISTICS\n"));
5374
5375                                 memcpy_exl(pAdapter, &pRaCfg->data[0], (UCHAR *)&pAdapter->ate.TxDoneCount, 4);
5376                                 memcpy_exl(pAdapter, &pRaCfg->data[4], (UCHAR *)&pAdapter->WlanCounters.RetryCount.u.LowPart, 4);
5377                                 memcpy_exl(pAdapter, &pRaCfg->data[8], (UCHAR *)&pAdapter->WlanCounters.FailedCount.u.LowPart, 4);
5378                                 memcpy_exl(pAdapter, &pRaCfg->data[12], (UCHAR *)&pAdapter->WlanCounters.RTSSuccessCount.u.LowPart, 4);
5379                                 memcpy_exl(pAdapter, &pRaCfg->data[16], (UCHAR *)&pAdapter->WlanCounters.RTSFailureCount.u.LowPart, 4);
5380                                 memcpy_exl(pAdapter, &pRaCfg->data[20], (UCHAR *)&pAdapter->WlanCounters.ReceivedFragmentCount.QuadPart, 4);
5381                                 memcpy_exl(pAdapter, &pRaCfg->data[24], (UCHAR *)&pAdapter->WlanCounters.FCSErrorCount.u.LowPart, 4);
5382                                 memcpy_exl(pAdapter, &pRaCfg->data[28], (UCHAR *)&pAdapter->Counters8023.RxNoBuffer, 4);
5383                                 memcpy_exl(pAdapter, &pRaCfg->data[32], (UCHAR *)&pAdapter->WlanCounters.FrameDuplicateCount.u.LowPart, 4);
5384                                 memcpy_exl(pAdapter, &pRaCfg->data[36], (UCHAR *)&pAdapter->RalinkCounters.OneSecFalseCCACnt, 4);
5385
5386                                 if (pAdapter->ate.RxAntennaSel == 0)
5387                                 {
5388                                         INT32 RSSI0 = 0;
5389                                         INT32 RSSI1 = 0;
5390                                         INT32 RSSI2 = 0;
5391
5392                                         RSSI0 = (INT32)(pAdapter->ate.LastRssi0 - pAdapter->BbpRssiToDbmDelta);
5393                                         RSSI1 = (INT32)(pAdapter->ate.LastRssi1 - pAdapter->BbpRssiToDbmDelta);
5394                                         RSSI2 = (INT32)(pAdapter->ate.LastRssi2 - pAdapter->BbpRssiToDbmDelta);
5395                                         memcpy_exl(pAdapter, &pRaCfg->data[40], (UCHAR *)&RSSI0, 4);
5396                                         memcpy_exl(pAdapter, &pRaCfg->data[44], (UCHAR *)&RSSI1, 4);
5397                                         memcpy_exl(pAdapter, &pRaCfg->data[48], (UCHAR *)&RSSI2, 4);
5398                                         pRaCfg->length = htons(2+52);
5399                                 }
5400                                 else
5401                                 {
5402                                         INT32 RSSI0 = 0;
5403
5404                                         RSSI0 = (INT32)(pAdapter->ate.LastRssi0 - pAdapter->BbpRssiToDbmDelta);
5405                                         memcpy_exl(pAdapter, &pRaCfg->data[40], (UCHAR *)&RSSI0, 4);
5406                                         pRaCfg->length = htons(2+44);
5407                                 }
5408                                 pRaCfg->status = htons(0);
5409                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5410                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5411                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5412
5413                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5414                 {
5415                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_GET_STATISTICS\n"));
5416                     Status = -EFAULT;
5417                 }
5418                                 else
5419                                 {
5420                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_GET_STATISTICS is done !\n"));
5421                                 }
5422                         }
5423                         break;
5424
5425                 case RACFG_CMD_ATE_RESET_COUNTER:
5426                         {
5427                                 SHORT    value = 1;
5428                                 UCHAR    str[LEN_OF_ARG];
5429
5430                                 NdisZeroMemory(str, LEN_OF_ARG);
5431
5432                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_RESET_COUNTER\n"));
5433
5434                                 sprintf((PCHAR)str, "%d", value);
5435                                 Set_ResetStatCounter_Proc(pAdapter, str);
5436
5437                                 pAdapter->ate.TxDoneCount = 0;
5438
5439                                 pRaCfg->length = htons(2);
5440                                 pRaCfg->status = htons(0);
5441
5442                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5443                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5444                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5445
5446                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5447                 {
5448                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_RESET_COUNTER\n"));
5449                     Status = -EFAULT;
5450                 }
5451                                 else
5452                                 {
5453                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_RESET_COUNTER is done !\n"));
5454                                 }
5455                         }
5456
5457                         break;
5458
5459                 case RACFG_CMD_ATE_SEL_TX_ANTENNA:
5460                         {
5461                                 SHORT    value = 0;
5462                                 UCHAR    str[LEN_OF_ARG];
5463
5464                                 NdisZeroMemory(str, LEN_OF_ARG);
5465
5466                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SEL_TX_ANTENNA\n"));
5467
5468                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5469                                 value = ntohs(value);
5470                                 sprintf((PCHAR)str, "%d", value);
5471                                 Set_ATE_TX_Antenna_Proc(pAdapter, str);
5472
5473                                 // prepare feedback
5474                                 pRaCfg->length = htons(2);
5475                                 pRaCfg->status = htons(0);
5476                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5477                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5478                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5479
5480                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5481                 {
5482                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SEL_TX_ANTENNA\n"));
5483                     Status = -EFAULT;
5484                 }
5485                                 else
5486                                 {
5487                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SEL_TX_ANTENNA is done !\n"));
5488                                 }
5489                         }
5490                         break;
5491
5492                 case RACFG_CMD_ATE_SEL_RX_ANTENNA:
5493                         {
5494                                 SHORT    value = 0;
5495                                 UCHAR    str[LEN_OF_ARG];
5496
5497                                 NdisZeroMemory(str, LEN_OF_ARG);
5498
5499                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SEL_RX_ANTENNA\n"));
5500
5501                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5502                                 value = ntohs(value);
5503                                 sprintf((PCHAR)str, "%d", value);
5504                                 Set_ATE_RX_Antenna_Proc(pAdapter, str);
5505
5506                                 // prepare feedback
5507                                 pRaCfg->length = htons(2);
5508                                 pRaCfg->status = htons(0);
5509                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5510                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5511                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5512
5513                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5514                 {
5515                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SEL_RX_ANTENNA\n"));
5516                     Status = -EFAULT;
5517                 }
5518                                 else
5519                                 {
5520                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SEL_RX_ANTENNA is done !\n"));
5521                                 }
5522                         }
5523                         break;
5524
5525                 case RACFG_CMD_ATE_SET_PREAMBLE:
5526                         {
5527                                 SHORT    value = 0;
5528                                 UCHAR    str[LEN_OF_ARG];
5529
5530                                 NdisZeroMemory(str, LEN_OF_ARG);
5531
5532                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_PREAMBLE\n"));
5533
5534                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5535                                 value = ntohs(value);
5536                                 sprintf((PCHAR)str, "%d", value);
5537                                 Set_ATE_TX_MODE_Proc(pAdapter, str);
5538
5539                                 // prepare feedback
5540                                 pRaCfg->length = htons(2);
5541                                 pRaCfg->status = htons(0);
5542                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5543                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5544                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5545
5546                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5547                 {
5548                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_PREAMBLE\n"));
5549                     Status = -EFAULT;
5550                 }
5551                                 else
5552                                 {
5553                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_PREAMBLE is done !\n"));
5554                                 }
5555                         }
5556                         break;
5557
5558                 case RACFG_CMD_ATE_SET_CHANNEL:
5559                         {
5560                                 SHORT    value = 0;
5561                                 UCHAR    str[LEN_OF_ARG];
5562
5563                                 NdisZeroMemory(str, LEN_OF_ARG);
5564
5565                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_CHANNEL\n"));
5566
5567                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5568                                 value = ntohs(value);
5569                                 sprintf((PCHAR)str, "%d", value);
5570                                 Set_ATE_CHANNEL_Proc(pAdapter, str);
5571
5572                                 // prepare feedback
5573                                 pRaCfg->length = htons(2);
5574                                 pRaCfg->status = htons(0);
5575                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5576                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5577                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5578
5579                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5580                 {
5581                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_CHANNEL\n"));
5582                     Status = -EFAULT;
5583                 }
5584                                 else
5585                                 {
5586                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_CHANNEL is done !\n"));
5587                                 }
5588                         }
5589                         break;
5590
5591                 case RACFG_CMD_ATE_SET_ADDR1:
5592                         {
5593                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR1\n"));
5594
5595                                 // Addr is an array of UCHAR,
5596                                 // so no need to perform endian swap.
5597                                 memcpy(pAdapter->ate.Addr1, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
5598
5599                                 // prepare feedback
5600                                 pRaCfg->length = htons(2);
5601                                 pRaCfg->status = htons(0);
5602                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5603                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5604                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5605
5606                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5607                 {
5608                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_ADDR1\n"));
5609                     Status = -EFAULT;
5610                 }
5611                                 else
5612                                 {
5613                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_ADDR1 is done !\n (ADDR1 = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAdapter->ate.Addr1[0],
5614                                                 pAdapter->ate.Addr1[1], pAdapter->ate.Addr1[2], pAdapter->ate.Addr1[3], pAdapter->ate.Addr1[4], pAdapter->ate.Addr1[5]));
5615                                 }
5616                         }
5617                         break;
5618
5619                 case RACFG_CMD_ATE_SET_ADDR2:
5620                         {
5621                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR2\n"));
5622
5623                                 // Addr is an array of UCHAR,
5624                                 // so no need to perform endian swap.
5625                                 memcpy(pAdapter->ate.Addr2, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
5626
5627                                 // prepare feedback
5628                                 pRaCfg->length = htons(2);
5629                                 pRaCfg->status = htons(0);
5630                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5631                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5632                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5633
5634                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5635                 {
5636                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_ADDR2\n"));
5637                     Status = -EFAULT;
5638                 }
5639                                 else
5640                                 {
5641                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_ADDR2 is done !\n (ADDR2 = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAdapter->ate.Addr2[0],
5642                                                 pAdapter->ate.Addr2[1], pAdapter->ate.Addr2[2], pAdapter->ate.Addr2[3], pAdapter->ate.Addr2[4], pAdapter->ate.Addr2[5]));
5643                                 }
5644                         }
5645                         break;
5646
5647                 case RACFG_CMD_ATE_SET_ADDR3:
5648                         {
5649                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR3\n"));
5650
5651                                 // Addr is an array of UCHAR,
5652                                 // so no need to perform endian swap.
5653                                 memcpy(pAdapter->ate.Addr3, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
5654
5655                                 // prepare feedback
5656                                 pRaCfg->length = htons(2);
5657                                 pRaCfg->status = htons(0);
5658                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5659                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5660                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5661
5662                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5663                 {
5664                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_ADDR3\n"));
5665                     Status = -EFAULT;
5666                 }
5667                                 else
5668                                 {
5669                                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_ADDR3 is done !\n (ADDR3 = %2X:%2X:%2X:%2X:%2X:%2X)\n", pAdapter->ate.Addr3[0],
5670                                                 pAdapter->ate.Addr3[1], pAdapter->ate.Addr3[2], pAdapter->ate.Addr3[3], pAdapter->ate.Addr3[4], pAdapter->ate.Addr3[5]));
5671                                 }
5672                         }
5673                         break;
5674
5675                 case RACFG_CMD_ATE_SET_RATE:
5676                         {
5677                                 SHORT    value = 0;
5678                                 UCHAR    str[LEN_OF_ARG];
5679
5680                                 NdisZeroMemory(str, LEN_OF_ARG);
5681
5682                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_RATE\n"));
5683
5684                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5685                                 value = ntohs(value);
5686                                 sprintf((PCHAR)str, "%d", value);
5687                                 Set_ATE_TX_MCS_Proc(pAdapter, str);
5688
5689                                 // prepare feedback
5690                                 pRaCfg->length = htons(2);
5691                                 pRaCfg->status = htons(0);
5692                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5693                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5694                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5695
5696                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5697                 {
5698                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_RATE\n"));
5699                     Status = -EFAULT;
5700                 }
5701                                 else
5702                                 {
5703                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_RATE is done !\n"));
5704                                 }
5705                         }
5706                         break;
5707
5708                 case RACFG_CMD_ATE_SET_TX_FRAME_LEN:
5709                         {
5710                                 SHORT    value = 0;
5711                                 UCHAR    str[LEN_OF_ARG];
5712
5713                                 NdisZeroMemory(str, LEN_OF_ARG);
5714
5715                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_FRAME_LEN\n"));
5716
5717                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5718                                 value = ntohs(value);
5719                                 sprintf((PCHAR)str, "%d", value);
5720                                 Set_ATE_TX_LENGTH_Proc(pAdapter, str);
5721
5722                                 // prepare feedback
5723                                 pRaCfg->length = htons(2);
5724                                 pRaCfg->status = htons(0);
5725                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5726                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5727                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5728
5729                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5730                 {
5731                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_FRAME_LEN\n"));
5732                     Status = -EFAULT;
5733                 }
5734                                 else
5735                                 {
5736                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_FRAME_LEN is done !\n"));
5737                                 }
5738                         }
5739                         break;
5740
5741                 case RACFG_CMD_ATE_SET_TX_FRAME_COUNT:
5742                         {
5743                                 USHORT    value = 0;
5744                                 UCHAR    str[LEN_OF_ARG];
5745
5746                                 NdisZeroMemory(str, LEN_OF_ARG);
5747
5748                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_FRAME_COUNT\n"));
5749
5750                                 memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
5751                                 value = ntohs(value);
5752                                 {
5753                                         sprintf((PCHAR)str, "%d", value);
5754                                         Set_ATE_TX_COUNT_Proc(pAdapter, str);
5755                                 }
5756
5757                                 // prepare feedback
5758                                 pRaCfg->length = htons(2);
5759                                 pRaCfg->status = htons(0);
5760                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5761                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5762                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5763
5764                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5765                 {
5766                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_ATE_SET_TX_FRAME_COUNT\n"));
5767                     Status = -EFAULT;
5768                 }
5769                                 else
5770                                 {
5771                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_ATE_SET_TX_FRAME_COUNT is done !\n"));
5772                                 }
5773                         }
5774                         break;
5775
5776                 case RACFG_CMD_ATE_START_RX_FRAME:
5777                         {
5778                                 ATEDBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_START\n"));
5779
5780                                 Set_ATE_Proc(pAdapter, "RXFRAME");
5781
5782                                 // prepare feedback
5783                                 pRaCfg->length = htons(2);
5784                                 pRaCfg->status = htons(0);
5785                                 wrq->u.data.length = sizeof(pRaCfg->magic_no) + sizeof(pRaCfg->command_type)
5786                                                                         + sizeof(pRaCfg->command_id) + sizeof(pRaCfg->length)
5787                                                                         + sizeof(pRaCfg->sequence) + ntohs(pRaCfg->length);
5788
5789                 if (copy_to_user(wrq->u.data.pointer, pRaCfg, wrq->u.data.length))
5790                 {
5791                         ATEDBGPRINT(RT_DEBUG_ERROR, ("copy_to_user() fail in case RACFG_CMD_RX_START\n"));
5792                     Status = -EFAULT;
5793                 }
5794                                 else
5795                                 {
5796                         ATEDBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_RX_START is done !\n"));
5797                                 }
5798                         }
5799                         break;
5800                 default:
5801                         break;
5802         }
5803     ASSERT(pRaCfg != NULL);
5804     if (pRaCfg != NULL)
5805     {
5806     kfree(pRaCfg);
5807     }
5808         return;
5809 }
5810
5811 VOID BubbleSort(INT32 n, INT32 a[])
5812 {
5813         INT32 k, j, temp;
5814
5815         for (k = n-1;  k>0;  k--)
5816         {
5817                 for (j = 0; j<k; j++)
5818                 {
5819                         if(a[j] > a[j+1])
5820                         {
5821                                 temp = a[j];
5822                                 a[j]=a[j+1];
5823                                 a[j+1]=temp;
5824                         }
5825                 }
5826         }
5827 }
5828
5829 VOID CalNoiseLevel(PRTMP_ADAPTER pAd, UCHAR channel, INT32 RSSI[3][10])
5830 {
5831         INT32           RSSI0, RSSI1, RSSI2;
5832         CHAR            Rssi0Offset, Rssi1Offset, Rssi2Offset;
5833         UCHAR           BbpR50Rssi0 = 0, BbpR51Rssi1 = 0, BbpR52Rssi2 = 0;
5834         UCHAR           Org_BBP66value = 0, Org_BBP69value = 0, Org_BBP70value = 0, data = 0;
5835         USHORT          LNA_Gain = 0;
5836         INT32       j = 0;
5837         UCHAR           Org_Channel = pAd->ate.Channel;
5838         USHORT      GainValue = 0, OffsetValue = 0;
5839
5840         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R66, &Org_BBP66value);
5841         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R69, &Org_BBP69value);
5842         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R70, &Org_BBP70value);
5843
5844         //**********************************************************************
5845         // Read the value of LNA gain and Rssi offset
5846         //**********************************************************************
5847         RT28xx_EEPROM_READ16(pAd, EEPROM_LNA_OFFSET, GainValue);
5848
5849         // for Noise Level
5850         if (channel <= 14)
5851         {
5852                 LNA_Gain = GainValue & 0x00FF;
5853
5854                 RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_BG_OFFSET, OffsetValue);
5855                 Rssi0Offset = OffsetValue & 0x00FF;
5856                 Rssi1Offset = (OffsetValue & 0xFF00) >> 8;
5857                 RT28xx_EEPROM_READ16(pAd, (EEPROM_RSSI_BG_OFFSET + 2)/* 0x48 */, OffsetValue);
5858                 Rssi2Offset = OffsetValue & 0x00FF;
5859         }
5860         else
5861         {
5862                 LNA_Gain = (GainValue & 0xFF00) >> 8;
5863
5864                 RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_A_OFFSET, OffsetValue);
5865                 Rssi0Offset = OffsetValue & 0x00FF;
5866                 Rssi1Offset = (OffsetValue & 0xFF00) >> 8;
5867                 RT28xx_EEPROM_READ16(pAd, (EEPROM_RSSI_A_OFFSET + 2)/* 0x4C */, OffsetValue);
5868                 Rssi2Offset = OffsetValue & 0x00FF;
5869         }
5870         //**********************************************************************
5871         {
5872                 pAd->ate.Channel = channel;
5873                 ATEAsicSwitchChannel(pAd);
5874                 mdelay(5);
5875
5876                 data = 0x10;
5877                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, data);
5878                 data = 0x40;
5879                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, data);
5880                 data = 0x40;
5881                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, data);
5882                 mdelay(5);
5883
5884                 // Start Rx
5885                 pAd->ate.bQARxStart = TRUE;
5886                 Set_ATE_Proc(pAd, "RXFRAME");
5887
5888                 mdelay(5);
5889
5890                 for (j = 0; j < 10; j++)
5891                 {
5892                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R50, &BbpR50Rssi0);
5893                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R51, &BbpR51Rssi1);
5894                         ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R52, &BbpR52Rssi2);
5895
5896                         mdelay(10);
5897
5898                         // Calculate RSSI 0
5899                         if (BbpR50Rssi0 == 0)
5900                         {
5901                                 RSSI0 = -100;
5902                         }
5903                         else
5904                         {
5905                                 RSSI0 = (INT32)(-12 - BbpR50Rssi0 - LNA_Gain - Rssi0Offset);
5906                         }
5907                         RSSI[0][j] = RSSI0;
5908
5909                         if ( pAd->Antenna.field.RxPath >= 2 ) // 2R
5910                         {
5911                                 // Calculate RSSI 1
5912                                 if (BbpR51Rssi1 == 0)
5913                                 {
5914                                         RSSI1 = -100;
5915                                 }
5916                                 else
5917                                 {
5918                                         RSSI1 = (INT32)(-12 - BbpR51Rssi1 - LNA_Gain - Rssi1Offset);
5919                                 }
5920                                 RSSI[1][j] = RSSI1;
5921                         }
5922
5923                         if ( pAd->Antenna.field.RxPath >= 3 ) // 3R
5924                         {
5925                                 // Calculate RSSI 2
5926                                 if (BbpR52Rssi2 == 0)
5927                                         RSSI2 = -100;
5928                                 else
5929                                         RSSI2 = (INT32)(-12 - BbpR52Rssi2 - LNA_Gain - Rssi2Offset);
5930
5931                                 RSSI[2][j] = RSSI2;
5932                         }
5933                 }
5934
5935                 // Stop Rx
5936                 Set_ATE_Proc(pAd, "RXSTOP");
5937
5938                 mdelay(5);
5939
5940 #if 0// Debug Message................
5941                 ate_print("\n**********************************************************\n");
5942                 ate_print("Noise Level: Channel %d\n", channel);
5943                 ate_print("RSSI0 = %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
5944                         RSSI[0][0], RSSI[0][1], RSSI[0][2],
5945                         RSSI[0][3], RSSI[0][4], RSSI[0][5],
5946                         RSSI[0][6], RSSI[0][7], RSSI[0][8],
5947                         RSSI[0][9]);
5948                 if ( pAd->Antenna.field.RxPath >= 2 ) // 2R
5949                 {
5950                         ate_print("RSSI1 = %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
5951                                 RSSI[1][0], RSSI[1][1], RSSI[1][2],
5952                                 RSSI[1][3], RSSI[1][4], RSSI[1][5],
5953                                 RSSI[1][6], RSSI[1][7], RSSI[1][8],
5954                                 RSSI[1][9]);
5955                 }
5956                 if ( pAd->Antenna.field.RxPath >= 3 ) // 3R
5957                 {
5958                         ate_print("RSSI2 = %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
5959                                 RSSI[2][0], RSSI[2][1], RSSI[2][2],
5960                                 RSSI[2][3], RSSI[2][4], RSSI[2][5],
5961                                 RSSI[2][6], RSSI[2][7], RSSI[2][8],
5962                                 RSSI[2][9]);
5963                 }
5964 #endif // 0 //
5965                 BubbleSort(10, RSSI[0]);        // 1R
5966
5967                 if ( pAd->Antenna.field.RxPath >= 2 ) // 2R
5968                 {
5969                         BubbleSort(10, RSSI[1]);
5970                 }
5971
5972                 if ( pAd->Antenna.field.RxPath >= 3 ) // 3R
5973                 {
5974                         BubbleSort(10, RSSI[2]);
5975                 }
5976
5977 #if 0// Debug Message................
5978                 ate_print("\nAfter Sorting....Channel %d\n", channel);
5979                 ate_print("RSSI0 = %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
5980                         RSSI[0][0], RSSI[0][1], RSSI[0][2],
5981                         RSSI[0][3], RSSI[0][4], RSSI[0][5],
5982                         RSSI[0][6], RSSI[0][7], RSSI[0][8],
5983                         RSSI[0][9]);
5984                 if ( pAd->Antenna.field.RxPath >= 2 ) // 2R
5985                 {
5986                         ate_print("RSSI1 = %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
5987                                 RSSI[1][0], RSSI[1][1], RSSI[1][2],
5988                                 RSSI[1][3], RSSI[1][4], RSSI[1][5],
5989                                 RSSI[1][6], RSSI[1][7], RSSI[1][8],
5990                                 RSSI[1][9]);
5991                 }
5992                 if ( pAd->Antenna.field.RxPath >= 3 ) // 3R
5993                 {
5994                         ate_print("RSSI2 = %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
5995                                 RSSI[2][0], RSSI[2][1], RSSI[2][2],
5996                                 RSSI[2][3], RSSI[2][4], RSSI[2][5],
5997                                 RSSI[2][6], RSSI[2][7], RSSI[2][8],
5998                                 RSSI[2][9]);
5999                 }
6000                 ate_print("**********************************************************\n");
6001 #endif // 0 //
6002         }
6003
6004         pAd->ate.Channel = Org_Channel;
6005         ATEAsicSwitchChannel(pAd);
6006
6007         // Restore original value
6008     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, Org_BBP66value);
6009     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, Org_BBP69value);
6010     ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, Org_BBP70value);
6011
6012         return;
6013 }
6014
6015 BOOLEAN SyncTxRxConfig(PRTMP_ADAPTER pAd, USHORT offset, UCHAR value)
6016 {
6017         UCHAR tmp = 0, bbp_data = 0;
6018
6019         if (ATE_ON(pAd))
6020         {
6021                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, offset, &bbp_data);
6022         }
6023         else
6024         {
6025                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, offset, &bbp_data);
6026         }
6027
6028         /* confirm again */
6029         ASSERT(bbp_data == value);
6030
6031         switch(offset)
6032         {
6033                 case BBP_R1:
6034                         /* Need to sync. tx configuration with legacy ATE. */
6035                         tmp = (bbp_data & ((1 << 4) | (1 << 3))/* 0x18 */) >> 3;
6036                     switch(tmp)
6037                     {
6038                                 /* The BBP R1 bit[4:3] = 2 :: Both DACs will be used by QA. */
6039                         case 2:
6040                                         /* All */
6041                                         pAd->ate.TxAntennaSel = 0;
6042                             break;
6043                                 /* The BBP R1 bit[4:3] = 0 :: DAC 0 will be used by QA. */
6044                         case 0:
6045                                         /* Antenna one */
6046                                         pAd->ate.TxAntennaSel = 1;
6047                             break;
6048                                 /* The BBP R1 bit[4:3] = 1 :: DAC 1 will be used by QA. */
6049                         case 1:
6050                                         /* Antenna two */
6051                                         pAd->ate.TxAntennaSel = 2;
6052                             break;
6053                         default:
6054                             DBGPRINT(RT_DEBUG_TRACE, ("%s -- Sth. wrong!  : return FALSE; \n", __func__));
6055                             return FALSE;
6056                     }
6057                         break;/* case BBP_R1 */
6058
6059                 case BBP_R3:
6060                         /* Need to sync. rx configuration with legacy ATE. */
6061                         tmp = (bbp_data & ((1 << 1) | (1 << 0))/* 0x03 */);
6062                     switch(tmp)
6063                     {
6064                                 /* The BBP R3 bit[1:0] = 3 :: All ADCs will be used by QA. */
6065                         case 3:
6066                                         /* All */
6067                                         pAd->ate.RxAntennaSel = 0;
6068                             break;
6069                                 /* The BBP R3 bit[1:0] = 0 :: ADC 0 will be used by QA, */
6070                                 /* unless the BBP R3 bit[4:3] = 2 */
6071                         case 0:
6072                                         /* Antenna one */
6073                                         pAd->ate.RxAntennaSel = 1;
6074                                         tmp = ((bbp_data & ((1 << 4) | (1 << 3))/* 0x03 */) >> 3);
6075                                         if (tmp == 2)// 3R
6076                                         {
6077                                                 /* Default : All ADCs will be used by QA */
6078                                                 pAd->ate.RxAntennaSel = 0;
6079                                         }
6080                             break;
6081                                 /* The BBP R3 bit[1:0] = 1 :: ADC 1 will be used by QA. */
6082                         case 1:
6083                                         /* Antenna two */
6084                                         pAd->ate.RxAntennaSel = 2;
6085                             break;
6086                                 /* The BBP R3 bit[1:0] = 2 :: ADC 2 will be used by QA. */
6087                         case 2:
6088                                         /* Antenna three */
6089                                         pAd->ate.RxAntennaSel = 3;
6090                             break;
6091                         default:
6092                             DBGPRINT(RT_DEBUG_ERROR, ("%s -- Impossible!  : return FALSE; \n", __func__));
6093                             return FALSE;
6094                     }
6095                         break;/* case BBP_R3 */
6096
6097         default:
6098             DBGPRINT(RT_DEBUG_ERROR, ("%s -- Sth. wrong!  : return FALSE; \n", __func__));
6099             return FALSE;
6100
6101         }
6102         return TRUE;
6103 }
6104
6105 static VOID memcpy_exl(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, ULONG len)
6106 {
6107         ULONG i, Value = 0;
6108         ULONG *pDst, *pSrc;
6109         UCHAR *p8;
6110
6111         p8 = src;
6112         pDst = (ULONG *) dst;
6113         pSrc = (ULONG *) src;
6114
6115         for (i = 0 ; i < (len/4); i++)
6116         {
6117                 /* For alignment issue, we need a variable "Value". */
6118                 memmove(&Value, pSrc, 4);
6119                 Value = htonl(Value);
6120                 memmove(pDst, &Value, 4);
6121                 pDst++;
6122                 pSrc++;
6123         }
6124         if ((len % 4) != 0)
6125         {
6126                 /* wish that it will never reach here */
6127                 memmove(&Value, pSrc, (len % 4));
6128                 Value = htonl(Value);
6129                 memmove(pDst, &Value, (len % 4));
6130         }
6131 }
6132
6133 static VOID memcpy_exs(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, ULONG len)
6134 {
6135         ULONG i;
6136         UCHAR *pDst, *pSrc;
6137
6138         pDst = dst;
6139         pSrc = src;
6140
6141         for (i = 0; i < (len/2); i++)
6142         {
6143                 memmove(pDst, pSrc, 2);
6144                 *((USHORT *)pDst) = htons(*((USHORT *)pDst));
6145                 pDst+=2;
6146                 pSrc+=2;
6147         }
6148
6149         if ((len % 2) != 0)
6150         {
6151                 memmove(pDst, pSrc, 1);
6152         }
6153 }
6154
6155 static VOID RTMP_IO_READ_BULK(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, UINT32 len)
6156 {
6157         UINT32 i, Value;
6158         UINT32 *pDst, *pSrc;
6159
6160         pDst = (UINT32 *) dst;
6161         pSrc = (UINT32 *) src;
6162
6163         for (i = 0 ; i < (len/4); i++)
6164         {
6165                 RTMP_IO_READ32(pAd, (ULONG)pSrc, &Value);
6166                 Value = htonl(Value);
6167                 memmove(pDst, &Value, 4);
6168                 pDst++;
6169                 pSrc++;
6170         }
6171         return;
6172 }
6173
6174 // TODO:
6175 #if 0
6176 /* These work only when RALINK_ATE is defined */
6177 INT Set_TxStart_Proc(
6178         IN      PRTMP_ADAPTER   pAd,
6179         IN      PUCHAR                  arg)
6180 {
6181         ULONG value = simple_strtol(arg, 0, 10);
6182         UCHAR buffer[26] = {0x88, 0x02, 0x2c, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x00, 0x55, 0x44, 0x33, 0x22, 0x11, 0xc0, 0x22, 0x00, 0x00};
6183         POS_COOKIE pObj;
6184
6185         if (pAd->ate.TxStatus != 0)
6186                 return FALSE;
6187
6188         pAd->ate.TxInfo = 0x04000000;
6189         bzero(&pAd->ate.TxWI, sizeof(TXWI_STRUC));
6190         pAd->ate.TxWI.PHYMODE = 0;// MODE_CCK
6191         pAd->ate.TxWI.MPDUtotalByteCount = 1226;
6192         pAd->ate.TxWI.MCS = 3;
6193         //pAd->ate.Mode = ATE_START;
6194         pAd->ate.Mode |= ATE_TXFRAME;
6195         pAd->ate.TxCount = value;
6196         pAd->ate.QID = 0;
6197         pAd->ate.HLen = 26;
6198         pAd->ate.PLen = 0;
6199         pAd->ate.DLen = 1200;
6200         memcpy(pAd->ate.Header, buffer, 26);
6201         pAd->ate.bQATxStart = TRUE;
6202         //pObj = (POS_COOKIE) pAd->OS_Cookie;
6203         //tasklet_hi_schedule(&pObj->AteTxTask);
6204         return TRUE;
6205 }
6206 #endif  /* end of #if 0 */
6207
6208 INT Set_TxStop_Proc(
6209         IN      PRTMP_ADAPTER   pAd,
6210         IN      PUCHAR                  arg)
6211 {
6212         ATEDBGPRINT(RT_DEBUG_TRACE,("Set_TxStop_Proc\n"));
6213
6214         if (Set_ATE_Proc(pAd, "TXSTOP"))
6215         {
6216         return TRUE;
6217 }
6218         else
6219         {
6220                 return FALSE;
6221         }
6222 }
6223
6224 INT Set_RxStop_Proc(
6225         IN      PRTMP_ADAPTER   pAd,
6226         IN      PUCHAR                  arg)
6227 {
6228         ATEDBGPRINT(RT_DEBUG_TRACE,("Set_RxStop_Proc\n"));
6229
6230         if (Set_ATE_Proc(pAd, "RXSTOP"))
6231         {
6232         return TRUE;
6233 }
6234         else
6235         {
6236                 return FALSE;
6237         }
6238 }
6239
6240 #if 0
6241 INT Set_EEWrite_Proc(
6242         IN      PRTMP_ADAPTER   pAd,
6243         IN      PUCHAR                  arg)
6244 {
6245         USHORT offset = 0, value;
6246         PUCHAR p2 = arg;
6247
6248         while((*p2 != ':') && (*p2 != '\0'))
6249         {
6250                 p2++;
6251         }
6252
6253         if (*p2 == ':')
6254         {
6255                 A2Hex(offset, arg);
6256                 A2Hex(value, p2+ 1);
6257         }
6258         else
6259         {
6260                 A2Hex(value, arg);
6261         }
6262
6263         if (offset >= EEPROM_SIZE)
6264         {
6265                 ate_print("Offset can not exceed EEPROM_SIZE( == 0x%04x)\n", EEPROM_SIZE);
6266                 return FALSE;
6267         }
6268
6269         RTMP_EEPROM_WRITE16(pAd, offset, value);
6270
6271         return TRUE;
6272 }
6273
6274 INT Set_BBPRead_Proc(
6275         IN      PRTMP_ADAPTER   pAd,
6276         IN      PUCHAR                  arg)
6277 {
6278         UCHAR value = 0, offset;
6279
6280         A2Hex(offset, arg);
6281
6282         if (ATE_ON(pAd))
6283         {
6284                 ATE_BBP_IO_READ8_BY_REG_ID(pAd, offset,  &value);
6285         }
6286         else
6287         {
6288                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, offset,  &value);
6289         }
6290
6291         ate_print("%x\n", value);
6292
6293         return TRUE;
6294 }
6295
6296
6297 INT Set_BBPWrite_Proc(
6298         IN      PRTMP_ADAPTER   pAd,
6299         IN      PUCHAR                  arg)
6300 {
6301         USHORT offset = 0;
6302         PUCHAR p2 = arg;
6303         UCHAR value;
6304
6305         while((*p2 != ':') && (*p2 != '\0'))
6306         {
6307                 p2++;
6308         }
6309
6310         if (*p2 == ':')
6311         {
6312                 A2Hex(offset, arg);
6313                 A2Hex(value, p2+ 1);
6314         }
6315         else
6316         {
6317                 A2Hex(value, arg);
6318         }
6319
6320         if (ATE_ON(pAd))
6321         {
6322                 ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, offset,  value);
6323         }
6324         else
6325         {
6326                 RTNP_BBP_IO_WRITE8_BY_REG_ID(pAd, offset,  value);
6327         }
6328
6329         return TRUE;
6330 }
6331
6332 INT Set_RFWrite_Proc(
6333         IN      PRTMP_ADAPTER   pAd,
6334         IN      PUCHAR                  arg)
6335 {
6336         PUCHAR p2, p3, p4;
6337         ULONG R1, R2, R3, R4;
6338
6339         p2 = arg;
6340
6341         while((*p2 != ':') && (*p2 != '\0'))
6342         {
6343                 p2++;
6344         }
6345
6346         if (*p2 != ':')
6347                 return FALSE;
6348
6349         p3 = p2 + 1;
6350
6351         while((*p3 != ':') && (*p3 != '\0'))
6352         {
6353                 p3++;
6354         }
6355
6356         if (*p3 != ':')
6357                 return FALSE;
6358
6359         p4 = p3 + 1;
6360
6361         while((*p4 != ':') && (*p4 != '\0'))
6362         {
6363                 p4++;
6364         }
6365
6366         if (*p4 != ':')
6367                 return FALSE;
6368
6369
6370         A2Hex(R1, arg);
6371         A2Hex(R2, p2 + 1);
6372         A2Hex(R3, p3 + 1);
6373         A2Hex(R4, p4 + 1);
6374
6375         RTMP_RF_IO_WRITE32(pAd, R1);
6376         RTMP_RF_IO_WRITE32(pAd, R2);
6377         RTMP_RF_IO_WRITE32(pAd, R3);
6378         RTMP_RF_IO_WRITE32(pAd, R4);
6379
6380         return TRUE;
6381 }
6382 #endif  // end of #if 0 //
6383 #endif  // RALINK_28xx_QA //
6384
6385 #endif  // RALINK_ATE //
6386