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