drivers/staging/rt2870/common/rtmp_init.c

   1 /*
   2  *************************************************************************
   3  * Ralink Tech Inc.
   4  * 5F., No.36, Taiyuan St., Jhubei City,
   5  * Hsinchu County 302,
   6  * Taiwan, R.O.C.
   7  *
   8  * (c) Copyright 2002-2007, Ralink Technology, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify  *
  11  * it under the terms of the GNU General Public License as published by  *
  12  * the Free Software Foundation; either version 2 of the License, or     *
  13  * (at your option) any later version.                                   *
  14  *                                                                       *
  15  * This program is distributed in the hope that it will be useful,       *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  18  * GNU General Public License for more details.                          *
  19  *                                                                       *
  20  * You should have received a copy of the GNU General Public License     *
  21  * along with this program; if not, write to the                         *
  22  * Free Software Foundation, Inc.,                                       *
  23  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  24  *                                                                       *
  25  *************************************************************************
  26
  27         Module Name:
  28         rtmp_init.c
  29
  30         Abstract:
  31         Miniport generic portion header file
  32
  33         Revision History:
  34         Who         When          What
  35         --------    ----------    ----------------------------------------------
  36         Paul Lin    2002-08-01    created
  37     John Chang  2004-08-20    RT2561/2661 use scatter-gather scheme
  38     Jan Lee  2006-09-15    RT2860. Change for 802.11n , EEPROM, Led, BA, HT.
  39 */
  40 #include "../rt_config.h"
  41 #include "firmware.h"
  42
  43 UCHAR    BIT8[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
  44 ULONG    BIT32[] = {0x00000001, 0x00000002, 0x00000004, 0x00000008,
  45                                         0x00000010, 0x00000020, 0x00000040, 0x00000080,
  46                                         0x00000100, 0x00000200, 0x00000400, 0x00000800,
  47                                         0x00001000, 0x00002000, 0x00004000, 0x00008000,
  48                                         0x00010000, 0x00020000, 0x00040000, 0x00080000,
  49                                         0x00100000, 0x00200000, 0x00400000, 0x00800000,
  50                                         0x01000000, 0x02000000, 0x04000000, 0x08000000,
  51                                         0x10000000, 0x20000000, 0x40000000, 0x80000000};
  52
  53 char*   CipherName[] = {"none","wep64","wep128","TKIP","AES","CKIP64","CKIP128"};
  54
  55 const unsigned short ccitt_16Table[] = {
  56         0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
  57         0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
  58         0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
  59         0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
  60         0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
  61         0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
  62         0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
  63         0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
  64         0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
  65         0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
  66         0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
  67         0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
  68         0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
  69         0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
  70         0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
  71         0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
  72         0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
  73         0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
  74         0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
  75         0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
  76         0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
  77         0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  78         0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
  79         0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
  80         0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
  81         0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
  82         0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
  83         0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
  84         0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
  85         0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
  86         0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
  87         0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
  88 };
  89 #define ByteCRC16(v, crc) \
  90         (unsigned short)((crc << 8) ^  ccitt_16Table[((crc >> 8) ^ (v)) & 255])
  91
  92 unsigned char BitReverse(unsigned char x)
  93 {
  94         int i;
  95         unsigned char Temp=0;
  96         for(i=0; ; i++)
  97         {
  98                 if(x & 0x80)    Temp |= 0x80;
  99                 if(i==7)                break;
 100                 x       <<= 1;
 101                 Temp >>= 1;
 102         }
 103         return Temp;
 104 }
 105
 106 //
 107 // BBP register initialization set
 108 //
 109 REG_PAIR   BBPRegTable[] = {
 110         {BBP_R65,               0x2C},          // fix rssi issue
 111         {BBP_R66,               0x38},  // Also set this default value to pAd->BbpTuning.R66CurrentValue at initial
 112         {BBP_R69,               0x12},
 113         {BBP_R70,               0xa},   // BBP_R70 will change to 0x8 in ApStartUp and LinkUp for rt2860C, otherwise value is 0xa
 114         {BBP_R73,               0x10},
 115         {BBP_R81,               0x37},
 116         {BBP_R82,               0x62},
 117         {BBP_R83,               0x6A},
 118         {BBP_R84,               0x99},  // 0x19 is for rt2860E and after. This is for extension channel overlapping IOT. 0x99 is for rt2860D and before
 119         {BBP_R86,               0x00},  // middle range issue, Rory @2008-01-28
 120         {BBP_R91,               0x04},  // middle range issue, Rory @2008-01-28
 121         {BBP_R92,               0x00},  // middle range issue, Rory @2008-01-28
 122         {BBP_R103,      0x00},  // near range high-power issue, requested from Gary @2008-0528
 123         {BBP_R105,              0x05},  // 0x05 is for rt2860E to turn on FEQ control. It is safe for rt2860D and before, because Bit 7:2 are reserved in rt2860D and before.
 124 };
 125 #define NUM_BBP_REG_PARMS       (sizeof(BBPRegTable) / sizeof(REG_PAIR))
 126
 127 //
 128 // RF register initialization set
 129 //
 130 #ifdef RT2870
 131 REG_PAIR   RT30xx_RFRegTable[] = {
 132         {RF_R04,          0x40},
 133         {RF_R05,          0x03},
 134         {RF_R06,          0x02},
 135         {RF_R07,          0x70},
 136         {RF_R09,          0x0F},
 137         {RF_R10,          0x71},
 138         {RF_R11,          0x21},
 139         {RF_R12,          0x7B},
 140         {RF_R14,          0x90},
 141         {RF_R15,          0x58},
 142         {RF_R16,          0xB3},
 143         {RF_R17,          0x92},
 144         {RF_R18,          0x2C},
 145         {RF_R19,          0x02},
 146         {RF_R20,          0xBA},
 147         {RF_R21,          0xDB},
 148         {RF_R24,          0x16},
 149         {RF_R25,          0x01},
 150         {RF_R27,          0x03},
 151         {RF_R29,          0x1F},
 152 };
 153 #define NUM_RF_REG_PARMS        (sizeof(RT30xx_RFRegTable) / sizeof(REG_PAIR))
 154 #endif // RT2870 //
 155
 156 //
 157 // ASIC register initialization sets
 158 //
 159
 160 RTMP_REG_PAIR   MACRegTable[] = {
 161 #if defined(HW_BEACON_OFFSET) && (HW_BEACON_OFFSET == 0x200)
 162         {BCN_OFFSET0,                   0xf8f0e8e0}, /* 0x3800(e0), 0x3A00(e8), 0x3C00(f0), 0x3E00(f8), 512B for each beacon */
 163         {BCN_OFFSET1,                   0x6f77d0c8}, /* 0x3200(c8), 0x3400(d0), 0x1DC0(77), 0x1BC0(6f), 512B for each beacon */
 164 #elif defined(HW_BEACON_OFFSET) && (HW_BEACON_OFFSET == 0x100)
 165         {BCN_OFFSET0,                   0xece8e4e0}, /* 0x3800, 0x3A00, 0x3C00, 0x3E00, 512B for each beacon */
 166         {BCN_OFFSET1,                   0xfcf8f4f0}, /* 0x3800, 0x3A00, 0x3C00, 0x3E00, 512B for each beacon */
 167 #else
 168     #error You must re-calculate new value for BCN_OFFSET0 & BCN_OFFSET1 in MACRegTable[]!!!
 169 #endif // HW_BEACON_OFFSET //
 170
 171         {LEGACY_BASIC_RATE,             0x0000013f}, //  Basic rate set bitmap
 172         {HT_BASIC_RATE,         0x00008003}, // Basic HT rate set , 20M, MCS=3, MM. Format is the same as in TXWI.
 173         {MAC_SYS_CTRL,          0x00}, // 0x1004, , default Disable RX
 174         {RX_FILTR_CFG,          0x17f97}, //0x1400  , RX filter control,
 175         {BKOFF_SLOT_CFG,        0x209}, // default set short slot time, CC_DELAY_TIME should be 2
 176         {TX_SW_CFG0,            0x0},           // Gary,2008-05-21 for CWC test
 177         {TX_SW_CFG1,            0x80606}, // Gary,2006-08-23
 178         {TX_LINK_CFG,           0x1020},                // Gary,2006-08-23
 179         //{TX_TIMEOUT_CFG,      0x00182090},    // CCK has some problem. So increase timieout value. 2006-10-09// MArvek RT
 180         {TX_TIMEOUT_CFG,        0x000a2090},    // CCK has some problem. So increase timieout value. 2006-10-09// MArvek RT , Modify for 2860E ,2007-08-01
 181         {MAX_LEN_CFG,           MAX_AGGREGATION_SIZE | 0x00001000},     // 0x3018, MAX frame length. Max PSDU = 16kbytes.
 182         {LED_CFG,               0x7f031e46}, // Gary, 2006-08-23
 183         {PBF_MAX_PCNT,                  0x1F3FBF9F},    //0x1F3f7f9f},          //Jan, 2006/04/20
 184         //{TX_RTY_CFG,                  0x6bb80408},    // Jan, 2006/11/16
 185         {TX_RTY_CFG,                    0x47d01f0f},    // Jan, 2006/11/16, Set TxWI->ACK =0 in Probe Rsp Modify for 2860E ,2007-08-03
 186         {AUTO_RSP_CFG,                  0x00000013},    // Initial Auto_Responder, because QA will turn off Auto-Responder
 187         {CCK_PROT_CFG,                  0x05740003 /*0x01740003*/},     // Initial Auto_Responder, because QA will turn off Auto-Responder. And RTS threshold is enabled.
 188         {OFDM_PROT_CFG,                 0x05740003 /*0x01740003*/},     // Initial Auto_Responder, because QA will turn off Auto-Responder. And RTS threshold is enabled.
 189 #ifdef RT2870
 190         {PBF_CFG,                               0xf40006},              // Only enable Queue 2
 191         {MM40_PROT_CFG,                 0x3F44084},             // Initial Auto_Responder, because QA will turn off Auto-Responder
 192         {WPDMA_GLO_CFG,                 0x00000030},
 193 #endif // RT2870 //
 194         {GF20_PROT_CFG,                 0x01744004},    // set 19:18 --> Short NAV for MIMO PS
 195         {GF40_PROT_CFG,                 0x03F44084},
 196         {MM20_PROT_CFG,                 0x01744004},
 197         {TXOP_CTRL_CFG,                 0x0000583f, /*0x0000243f*/ /*0x000024bf*/},     //Extension channel backoff.
 198         {TX_RTS_CFG,                    0x00092b20},
 199 //#ifdef WIFI_TEST
 200         {EXP_ACK_TIME,                  0x002400ca},    // default value
 201 //#else
 202 //      {EXP_ACK_TIME,                  0x005400ca},    // suggested by Gray @ 20070323 for 11n intel-sta throughput
 203 //#endif // end - WIFI_TEST //
 204         {TXOP_HLDR_ET,                  0x00000002},
 205
 206         /* Jerry comments 2008/01/16: we use SIFS = 10us in CCK defaultly, but it seems that 10us
 207                 is too small for INTEL 2200bg card, so in MBSS mode, the delta time between beacon0
 208                 and beacon1 is SIFS (10us), so if INTEL 2200bg card connects to BSS0, the ping
 209                 will always lost. So we change the SIFS of CCK from 10us to 16us. */
 210         {XIFS_TIME_CFG,                 0x33a41010},
 211         {PWR_PIN_CFG,                   0x00000003},    // patch for 2880-E
 212 };
 213
 214
 215 #ifdef CONFIG_STA_SUPPORT
 216 RTMP_REG_PAIR   STAMACRegTable[] =      {
 217         {WMM_AIFSN_CFG,         0x00002273},
 218         {WMM_CWMIN_CFG, 0x00002344},
 219         {WMM_CWMAX_CFG, 0x000034aa},
 220 };
 221 #endif // CONFIG_STA_SUPPORT //
 222
 223 #define NUM_MAC_REG_PARMS               (sizeof(MACRegTable) / sizeof(RTMP_REG_PAIR))
 224 #ifdef CONFIG_STA_SUPPORT
 225 #define NUM_STA_MAC_REG_PARMS   (sizeof(STAMACRegTable) / sizeof(RTMP_REG_PAIR))
 226 #endif // CONFIG_STA_SUPPORT //
 227
 228 #ifdef RT2870
 229 //
 230 // RT2870 Firmware Spec only used 1 oct for version expression
 231 //
 232 #define FIRMWARE_MINOR_VERSION  7
 233
 234 #endif // RT2870 //
 235
 236 // New 8k byte firmware size for RT3071/RT3072
 237 #define FIRMWAREIMAGE_MAX_LENGTH        0x2000
 238 #define FIRMWAREIMAGE_LENGTH            (sizeof (FirmwareImage) / sizeof(UCHAR))
 239 #define FIRMWARE_MAJOR_VERSION  0
 240
 241 #define FIRMWAREIMAGEV1_LENGTH  0x1000
 242 #define FIRMWAREIMAGEV2_LENGTH  0x1000
 243
 244
 245
 246 /*
 247         ========================================================================
 248
 249         Routine Description:
 250                 Allocate RTMP_ADAPTER data block and do some initialization
 251
 252         Arguments:
 253                 Adapter         Pointer to our adapter
 254
 255         Return Value:
 256                 NDIS_STATUS_SUCCESS
 257                 NDIS_STATUS_FAILURE
 258
 259         IRQL = PASSIVE_LEVEL
 260
 261         Note:
 262
 263         ========================================================================
 264 */
 265 NDIS_STATUS     RTMPAllocAdapterBlock(
 266         IN  PVOID       handle,
 267         OUT     PRTMP_ADAPTER   *ppAdapter)
 268 {
 269         PRTMP_ADAPTER   pAd;
 270         NDIS_STATUS             Status;
 271         INT                     index;
 272         UCHAR                   *pBeaconBuf = NULL;
 273
 274         DBGPRINT(RT_DEBUG_TRACE, ("--> RTMPAllocAdapterBlock\n"));
 275
 276         *ppAdapter = NULL;
 277
 278         do
 279         {
 280                 // Allocate RTMP_ADAPTER memory block
 281                 pBeaconBuf = kmalloc(MAX_BEACON_SIZE, MEM_ALLOC_FLAG);
 282                 if (pBeaconBuf == NULL)
 283                 {
 284                         Status = NDIS_STATUS_FAILURE;
 285                         DBGPRINT_ERR(("Failed to allocate memory - BeaconBuf!\n"));
 286                         break;
 287                 }
 288
 289                 Status = AdapterBlockAllocateMemory(handle, (PVOID *)&pAd);
 290                 if (Status != NDIS_STATUS_SUCCESS)
 291                 {
 292                         DBGPRINT_ERR(("Failed to allocate memory - ADAPTER\n"));
 293                         break;
 294                 }
 295                 pAd->BeaconBuf = pBeaconBuf;
 296                 printk("\n\n=== pAd = %p, size = %d ===\n\n", pAd, (UINT32)sizeof(RTMP_ADAPTER));
 297
 298
 299                 // Init spin locks
 300                 NdisAllocateSpinLock(&pAd->MgmtRingLock);
 301
 302                 for (index =0 ; index < NUM_OF_TX_RING; index++)
 303                 {
 304                         NdisAllocateSpinLock(&pAd->TxSwQueueLock[index]);
 305                         NdisAllocateSpinLock(&pAd->DeQueueLock[index]);
 306                         pAd->DeQueueRunning[index] = FALSE;
 307                 }
 308
 309                 NdisAllocateSpinLock(&pAd->irq_lock);
 310
 311         } while (FALSE);
 312
 313         if ((Status != NDIS_STATUS_SUCCESS) && (pBeaconBuf))
 314                 kfree(pBeaconBuf);
 315
 316         *ppAdapter = pAd;
 317
 318         DBGPRINT_S(Status, ("<-- RTMPAllocAdapterBlock, Status=%x\n", Status));
 319         return Status;
 320 }
 321
 322 /*
 323         ========================================================================
 324
 325         Routine Description:
 326                 Read initial Tx power per MCS and BW from EEPROM
 327
 328         Arguments:
 329                 Adapter                                         Pointer to our adapter
 330
 331         Return Value:
 332                 None
 333
 334         IRQL = PASSIVE_LEVEL
 335
 336         Note:
 337
 338         ========================================================================
 339 */
 340 VOID    RTMPReadTxPwrPerRate(
 341         IN      PRTMP_ADAPTER   pAd)
 342 {
 343         ULONG           data, Adata, Gdata;
 344         USHORT          i, value, value2;
 345         INT                     Apwrdelta, Gpwrdelta;
 346         UCHAR           t1,t2,t3,t4;
 347         BOOLEAN         bValid, bApwrdeltaMinus = TRUE, bGpwrdeltaMinus = TRUE;
 348
 349         //
 350         // Get power delta for 20MHz and 40MHz.
 351         //
 352         DBGPRINT(RT_DEBUG_TRACE, ("Txpower per Rate\n"));
 353         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_DELTA, value2);
 354         Apwrdelta = 0;
 355         Gpwrdelta = 0;
 356
 357         if ((value2 & 0xff) != 0xff)
 358         {
 359                 if ((value2 & 0x80))
 360                         Gpwrdelta = (value2&0xf);
 361
 362                 if ((value2 & 0x40))
 363                         bGpwrdeltaMinus = FALSE;
 364                 else
 365                         bGpwrdeltaMinus = TRUE;
 366         }
 367         if ((value2 & 0xff00) != 0xff00)
 368         {
 369                 if ((value2 & 0x8000))
 370                         Apwrdelta = ((value2&0xf00)>>8);
 371
 372                 if ((value2 & 0x4000))
 373                         bApwrdeltaMinus = FALSE;
 374                 else
 375                         bApwrdeltaMinus = TRUE;
 376         }
 377         DBGPRINT(RT_DEBUG_TRACE, ("Gpwrdelta = %x, Apwrdelta = %x .\n", Gpwrdelta, Apwrdelta));
 378
 379         //
 380         // Get Txpower per MCS for 20MHz in 2.4G.
 381         //
 382         for (i=0; i<5; i++)
 383         {
 384                 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_2_4G + i*4, value);
 385                 data = value;
 386                 if (bApwrdeltaMinus == FALSE)
 387                 {
 388                         t1 = (value&0xf)+(Apwrdelta);
 389                         if (t1 > 0xf)
 390                                 t1 = 0xf;
 391                         t2 = ((value&0xf0)>>4)+(Apwrdelta);
 392                         if (t2 > 0xf)
 393                                 t2 = 0xf;
 394                         t3 = ((value&0xf00)>>8)+(Apwrdelta);
 395                         if (t3 > 0xf)
 396                                 t3 = 0xf;
 397                         t4 = ((value&0xf000)>>12)+(Apwrdelta);
 398                         if (t4 > 0xf)
 399                                 t4 = 0xf;
 400                 }
 401                 else
 402                 {
 403                         if ((value&0xf) > Apwrdelta)
 404                                 t1 = (value&0xf)-(Apwrdelta);
 405                         else
 406                                 t1 = 0;
 407                         if (((value&0xf0)>>4) > Apwrdelta)
 408                                 t2 = ((value&0xf0)>>4)-(Apwrdelta);
 409                         else
 410                                 t2 = 0;
 411                         if (((value&0xf00)>>8) > Apwrdelta)
 412                                 t3 = ((value&0xf00)>>8)-(Apwrdelta);
 413                         else
 414                                 t3 = 0;
 415                         if (((value&0xf000)>>12) > Apwrdelta)
 416                                 t4 = ((value&0xf000)>>12)-(Apwrdelta);
 417                         else
 418                                 t4 = 0;
 419                 }
 420                 Adata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
 421                 if (bGpwrdeltaMinus == FALSE)
 422                 {
 423                         t1 = (value&0xf)+(Gpwrdelta);
 424                         if (t1 > 0xf)
 425                                 t1 = 0xf;
 426                         t2 = ((value&0xf0)>>4)+(Gpwrdelta);
 427                         if (t2 > 0xf)
 428                                 t2 = 0xf;
 429                         t3 = ((value&0xf00)>>8)+(Gpwrdelta);
 430                         if (t3 > 0xf)
 431                                 t3 = 0xf;
 432                         t4 = ((value&0xf000)>>12)+(Gpwrdelta);
 433                         if (t4 > 0xf)
 434                                 t4 = 0xf;
 435                 }
 436                 else
 437                 {
 438                         if ((value&0xf) > Gpwrdelta)
 439                                 t1 = (value&0xf)-(Gpwrdelta);
 440                         else
 441                                 t1 = 0;
 442                         if (((value&0xf0)>>4) > Gpwrdelta)
 443                                 t2 = ((value&0xf0)>>4)-(Gpwrdelta);
 444                         else
 445                                 t2 = 0;
 446                         if (((value&0xf00)>>8) > Gpwrdelta)
 447                                 t3 = ((value&0xf00)>>8)-(Gpwrdelta);
 448                         else
 449                                 t3 = 0;
 450                         if (((value&0xf000)>>12) > Gpwrdelta)
 451                                 t4 = ((value&0xf000)>>12)-(Gpwrdelta);
 452                         else
 453                                 t4 = 0;
 454                 }
 455                 Gdata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
 456
 457                 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_2_4G + i*4 + 2, value);
 458                 if (bApwrdeltaMinus == FALSE)
 459                 {
 460                         t1 = (value&0xf)+(Apwrdelta);
 461                         if (t1 > 0xf)
 462                                 t1 = 0xf;
 463                         t2 = ((value&0xf0)>>4)+(Apwrdelta);
 464                         if (t2 > 0xf)
 465                                 t2 = 0xf;
 466                         t3 = ((value&0xf00)>>8)+(Apwrdelta);
 467                         if (t3 > 0xf)
 468                                 t3 = 0xf;
 469                         t4 = ((value&0xf000)>>12)+(Apwrdelta);
 470                         if (t4 > 0xf)
 471                                 t4 = 0xf;
 472                 }
 473                 else
 474                 {
 475                         if ((value&0xf) > Apwrdelta)
 476                                 t1 = (value&0xf)-(Apwrdelta);
 477                         else
 478                                 t1 = 0;
 479                         if (((value&0xf0)>>4) > Apwrdelta)
 480                                 t2 = ((value&0xf0)>>4)-(Apwrdelta);
 481                         else
 482                                 t2 = 0;
 483                         if (((value&0xf00)>>8) > Apwrdelta)
 484                                 t3 = ((value&0xf00)>>8)-(Apwrdelta);
 485                         else
 486                                 t3 = 0;
 487                         if (((value&0xf000)>>12) > Apwrdelta)
 488                                 t4 = ((value&0xf000)>>12)-(Apwrdelta);
 489                         else
 490                                 t4 = 0;
 491                 }
 492                 Adata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
 493                 if (bGpwrdeltaMinus == FALSE)
 494                 {
 495                         t1 = (value&0xf)+(Gpwrdelta);
 496                         if (t1 > 0xf)
 497                                 t1 = 0xf;
 498                         t2 = ((value&0xf0)>>4)+(Gpwrdelta);
 499                         if (t2 > 0xf)
 500                                 t2 = 0xf;
 501                         t3 = ((value&0xf00)>>8)+(Gpwrdelta);
 502                         if (t3 > 0xf)
 503                                 t3 = 0xf;
 504                         t4 = ((value&0xf000)>>12)+(Gpwrdelta);
 505                         if (t4 > 0xf)
 506                                 t4 = 0xf;
 507                 }
 508                 else
 509                 {
 510                         if ((value&0xf) > Gpwrdelta)
 511                                 t1 = (value&0xf)-(Gpwrdelta);
 512                         else
 513                                 t1 = 0;
 514                         if (((value&0xf0)>>4) > Gpwrdelta)
 515                                 t2 = ((value&0xf0)>>4)-(Gpwrdelta);
 516                         else
 517                                 t2 = 0;
 518                         if (((value&0xf00)>>8) > Gpwrdelta)
 519                                 t3 = ((value&0xf00)>>8)-(Gpwrdelta);
 520                         else
 521                                 t3 = 0;
 522                         if (((value&0xf000)>>12) > Gpwrdelta)
 523                                 t4 = ((value&0xf000)>>12)-(Gpwrdelta);
 524                         else
 525                                 t4 = 0;
 526                 }
 527                 Gdata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
 528                 data |= (value<<16);
 529
 530                 pAd->Tx20MPwrCfgABand[i] = pAd->Tx40MPwrCfgABand[i] = Adata;
 531                 pAd->Tx20MPwrCfgGBand[i] = pAd->Tx40MPwrCfgGBand[i] = Gdata;
 532
 533                 if (data != 0xffffffff)
 534                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, data);
 535                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("20MHz BW, 2.4G band-%lx,  Adata = %lx,  Gdata = %lx \n", data, Adata, Gdata));
 536         }
 537
 538         //
 539         // Check this block is valid for 40MHz in 2.4G. If invalid, use parameter for 20MHz in 2.4G
 540         //
 541         bValid = TRUE;
 542         for (i=0; i<6; i++)
 543         {
 544                 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_2_4G + 2 + i*2, value);
 545                 if (((value & 0x00FF) == 0x00FF) || ((value & 0xFF00) == 0xFF00))
 546                 {
 547                         bValid = FALSE;
 548                         break;
 549                 }
 550         }
 551
 552         //
 553         // Get Txpower per MCS for 40MHz in 2.4G.
 554         //
 555         if (bValid)
 556         {
 557                 for (i=0; i<4; i++)
 558                 {
 559                         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_2_4G + i*4, value);
 560                         if (bGpwrdeltaMinus == FALSE)
 561                         {
 562                                 t1 = (value&0xf)+(Gpwrdelta);
 563                                 if (t1 > 0xf)
 564                                         t1 = 0xf;
 565                                 t2 = ((value&0xf0)>>4)+(Gpwrdelta);
 566                                 if (t2 > 0xf)
 567                                         t2 = 0xf;
 568                                 t3 = ((value&0xf00)>>8)+(Gpwrdelta);
 569                                 if (t3 > 0xf)
 570                                         t3 = 0xf;
 571                                 t4 = ((value&0xf000)>>12)+(Gpwrdelta);
 572                                 if (t4 > 0xf)
 573                                         t4 = 0xf;
 574                         }
 575                         else
 576                         {
 577                                 if ((value&0xf) > Gpwrdelta)
 578                                         t1 = (value&0xf)-(Gpwrdelta);
 579                                 else
 580                                         t1 = 0;
 581                                 if (((value&0xf0)>>4) > Gpwrdelta)
 582                                         t2 = ((value&0xf0)>>4)-(Gpwrdelta);
 583                                 else
 584                                         t2 = 0;
 585                                 if (((value&0xf00)>>8) > Gpwrdelta)
 586                                         t3 = ((value&0xf00)>>8)-(Gpwrdelta);
 587                                 else
 588                                         t3 = 0;
 589                                 if (((value&0xf000)>>12) > Gpwrdelta)
 590                                         t4 = ((value&0xf000)>>12)-(Gpwrdelta);
 591                                 else
 592                                         t4 = 0;
 593                         }
 594                         Gdata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
 595
 596                         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_2_4G + i*4 + 2, value);
 597                         if (bGpwrdeltaMinus == FALSE)
 598                         {
 599                                 t1 = (value&0xf)+(Gpwrdelta);
 600                                 if (t1 > 0xf)
 601                                         t1 = 0xf;
 602                                 t2 = ((value&0xf0)>>4)+(Gpwrdelta);
 603                                 if (t2 > 0xf)
 604                                         t2 = 0xf;
 605                                 t3 = ((value&0xf00)>>8)+(Gpwrdelta);
 606                                 if (t3 > 0xf)
 607                                         t3 = 0xf;
 608                                 t4 = ((value&0xf000)>>12)+(Gpwrdelta);
 609                                 if (t4 > 0xf)
 610                                         t4 = 0xf;
 611                         }
 612                         else
 613                         {
 614                                 if ((value&0xf) > Gpwrdelta)
 615                                         t1 = (value&0xf)-(Gpwrdelta);
 616                                 else
 617                                         t1 = 0;
 618                                 if (((value&0xf0)>>4) > Gpwrdelta)
 619                                         t2 = ((value&0xf0)>>4)-(Gpwrdelta);
 620                                 else
 621                                         t2 = 0;
 622                                 if (((value&0xf00)>>8) > Gpwrdelta)
 623                                         t3 = ((value&0xf00)>>8)-(Gpwrdelta);
 624                                 else
 625                                         t3 = 0;
 626                                 if (((value&0xf000)>>12) > Gpwrdelta)
 627                                         t4 = ((value&0xf000)>>12)-(Gpwrdelta);
 628                                 else
 629                                         t4 = 0;
 630                         }
 631                         Gdata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
 632
 633                         if (i == 0)
 634                                 pAd->Tx40MPwrCfgGBand[i+1] = (pAd->Tx40MPwrCfgGBand[i+1] & 0x0000FFFF) | (Gdata & 0xFFFF0000);
 635                         else
 636                                 pAd->Tx40MPwrCfgGBand[i+1] = Gdata;
 637
 638                         DBGPRINT_RAW(RT_DEBUG_TRACE, ("40MHz BW, 2.4G band, Gdata = %lx \n", Gdata));
 639                 }
 640         }
 641
 642         //
 643         // Check this block is valid for 20MHz in 5G. If invalid, use parameter for 20MHz in 2.4G
 644         //
 645         bValid = TRUE;
 646         for (i=0; i<8; i++)
 647         {
 648                 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_5G + 2 + i*2, value);
 649                 if (((value & 0x00FF) == 0x00FF) || ((value & 0xFF00) == 0xFF00))
 650                 {
 651                         bValid = FALSE;
 652                         break;
 653                 }
 654         }
 655
 656         //
 657         // Get Txpower per MCS for 20MHz in 5G.
 658         //
 659         if (bValid)
 660         {
 661                 for (i=0; i<5; i++)
 662                 {
 663                         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_5G + i*4, value);
 664                         if (bApwrdeltaMinus == FALSE)
 665                         {
 666                                 t1 = (value&0xf)+(Apwrdelta);
 667                                 if (t1 > 0xf)
 668                                         t1 = 0xf;
 669                                 t2 = ((value&0xf0)>>4)+(Apwrdelta);
 670                                 if (t2 > 0xf)
 671                                         t2 = 0xf;
 672                                 t3 = ((value&0xf00)>>8)+(Apwrdelta);
 673                                 if (t3 > 0xf)
 674                                         t3 = 0xf;
 675                                 t4 = ((value&0xf000)>>12)+(Apwrdelta);
 676                                 if (t4 > 0xf)
 677                                         t4 = 0xf;
 678                         }
 679                         else
 680                         {
 681                                 if ((value&0xf) > Apwrdelta)
 682                                         t1 = (value&0xf)-(Apwrdelta);
 683                                 else
 684                                         t1 = 0;
 685                                 if (((value&0xf0)>>4) > Apwrdelta)
 686                                         t2 = ((value&0xf0)>>4)-(Apwrdelta);
 687                                 else
 688                                         t2 = 0;
 689                                 if (((value&0xf00)>>8) > Apwrdelta)
 690                                         t3 = ((value&0xf00)>>8)-(Apwrdelta);
 691                                 else
 692                                         t3 = 0;
 693                                 if (((value&0xf000)>>12) > Apwrdelta)
 694                                         t4 = ((value&0xf000)>>12)-(Apwrdelta);
 695                                 else
 696                                         t4 = 0;
 697                         }
 698                         Adata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
 699
 700                         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_5G + i*4 + 2, value);
 701                         if (bApwrdeltaMinus == FALSE)
 702                         {
 703                                 t1 = (value&0xf)+(Apwrdelta);
 704                                 if (t1 > 0xf)
 705                                         t1 = 0xf;
 706                                 t2 = ((value&0xf0)>>4)+(Apwrdelta);
 707                                 if (t2 > 0xf)
 708                                         t2 = 0xf;
 709                                 t3 = ((value&0xf00)>>8)+(Apwrdelta);
 710                                 if (t3 > 0xf)
 711                                         t3 = 0xf;
 712                                 t4 = ((value&0xf000)>>12)+(Apwrdelta);
 713                                 if (t4 > 0xf)
 714                                         t4 = 0xf;
 715                         }
 716                         else
 717                         {
 718                                 if ((value&0xf) > Apwrdelta)
 719                                         t1 = (value&0xf)-(Apwrdelta);
 720                                 else
 721                                         t1 = 0;
 722                                 if (((value&0xf0)>>4) > Apwrdelta)
 723                                         t2 = ((value&0xf0)>>4)-(Apwrdelta);
 724                                 else
 725                                         t2 = 0;
 726                                 if (((value&0xf00)>>8) > Apwrdelta)
 727                                         t3 = ((value&0xf00)>>8)-(Apwrdelta);
 728                                 else
 729                                         t3 = 0;
 730                                 if (((value&0xf000)>>12) > Apwrdelta)
 731                                         t4 = ((value&0xf000)>>12)-(Apwrdelta);
 732                                 else
 733                                         t4 = 0;
 734                         }
 735                         Adata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
 736
 737                         if (i == 0)
 738                                 pAd->Tx20MPwrCfgABand[i] = (pAd->Tx20MPwrCfgABand[i] & 0x0000FFFF) | (Adata & 0xFFFF0000);
 739                         else
 740                                 pAd->Tx20MPwrCfgABand[i] = Adata;
 741
 742                         DBGPRINT_RAW(RT_DEBUG_TRACE, ("20MHz BW, 5GHz band, Adata = %lx \n", Adata));
 743                 }
 744         }
 745
 746         //
 747         // Check this block is valid for 40MHz in 5G. If invalid, use parameter for 20MHz in 2.4G
 748         //
 749         bValid = TRUE;
 750         for (i=0; i<6; i++)
 751         {
 752                 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_5G + 2 + i*2, value);
 753                 if (((value & 0x00FF) == 0x00FF) || ((value & 0xFF00) == 0xFF00))
 754                 {
 755                         bValid = FALSE;
 756                         break;
 757                 }
 758         }
 759
 760         //
 761         // Get Txpower per MCS for 40MHz in 5G.
 762         //
 763         if (bValid)
 764         {
 765                 for (i=0; i<4; i++)
 766                 {
 767                         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_5G + i*4, value);
 768                         if (bApwrdeltaMinus == FALSE)
 769                         {
 770                                 t1 = (value&0xf)+(Apwrdelta);
 771                                 if (t1 > 0xf)
 772                                         t1 = 0xf;
 773                                 t2 = ((value&0xf0)>>4)+(Apwrdelta);
 774                                 if (t2 > 0xf)
 775                                         t2 = 0xf;
 776                                 t3 = ((value&0xf00)>>8)+(Apwrdelta);
 777                                 if (t3 > 0xf)
 778                                         t3 = 0xf;
 779                                 t4 = ((value&0xf000)>>12)+(Apwrdelta);
 780                                 if (t4 > 0xf)
 781                                         t4 = 0xf;
 782                         }
 783                         else
 784                         {
 785                                 if ((value&0xf) > Apwrdelta)
 786                                         t1 = (value&0xf)-(Apwrdelta);
 787                                 else
 788                                         t1 = 0;
 789                                 if (((value&0xf0)>>4) > Apwrdelta)
 790                                         t2 = ((value&0xf0)>>4)-(Apwrdelta);
 791                                 else
 792                                         t2 = 0;
 793                                 if (((value&0xf00)>>8) > Apwrdelta)
 794                                         t3 = ((value&0xf00)>>8)-(Apwrdelta);
 795                                 else
 796                                         t3 = 0;
 797                                 if (((value&0xf000)>>12) > Apwrdelta)
 798                                         t4 = ((value&0xf000)>>12)-(Apwrdelta);
 799                                 else
 800                                         t4 = 0;
 801                         }
 802                         Adata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
 803
 804                         RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_5G + i*4 + 2, value);
 805                         if (bApwrdeltaMinus == FALSE)
 806                         {
 807                                 t1 = (value&0xf)+(Apwrdelta);
 808                                 if (t1 > 0xf)
 809                                         t1 = 0xf;
 810                                 t2 = ((value&0xf0)>>4)+(Apwrdelta);
 811                                 if (t2 > 0xf)
 812                                         t2 = 0xf;
 813                                 t3 = ((value&0xf00)>>8)+(Apwrdelta);
 814                                 if (t3 > 0xf)
 815                                         t3 = 0xf;
 816                                 t4 = ((value&0xf000)>>12)+(Apwrdelta);
 817                                 if (t4 > 0xf)
 818                                         t4 = 0xf;
 819                         }
 820                         else
 821                         {
 822                                 if ((value&0xf) > Apwrdelta)
 823                                         t1 = (value&0xf)-(Apwrdelta);
 824                                 else
 825                                         t1 = 0;
 826                                 if (((value&0xf0)>>4) > Apwrdelta)
 827                                         t2 = ((value&0xf0)>>4)-(Apwrdelta);
 828                                 else
 829                                         t2 = 0;
 830                                 if (((value&0xf00)>>8) > Apwrdelta)
 831                                         t3 = ((value&0xf00)>>8)-(Apwrdelta);
 832                                 else
 833                                         t3 = 0;
 834                                 if (((value&0xf000)>>12) > Apwrdelta)
 835                                         t4 = ((value&0xf000)>>12)-(Apwrdelta);
 836                                 else
 837                                         t4 = 0;
 838                         }
 839                         Adata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
 840
 841                         if (i == 0)
 842                                 pAd->Tx40MPwrCfgABand[i+1] = (pAd->Tx40MPwrCfgABand[i+1] & 0x0000FFFF) | (Adata & 0xFFFF0000);
 843                         else
 844                                 pAd->Tx40MPwrCfgABand[i+1] = Adata;
 845
 846                         DBGPRINT_RAW(RT_DEBUG_TRACE, ("40MHz BW, 5GHz band, Adata = %lx \n", Adata));
 847                 }
 848         }
 849 }
 850
 851
 852 /*
 853         ========================================================================
 854
 855         Routine Description:
 856                 Read initial channel power parameters from EEPROM
 857
 858         Arguments:
 859                 Adapter                                         Pointer to our adapter
 860
 861         Return Value:
 862                 None
 863
 864         IRQL = PASSIVE_LEVEL
 865
 866         Note:
 867
 868         ========================================================================
 869 */
 870 VOID    RTMPReadChannelPwr(
 871         IN      PRTMP_ADAPTER   pAd)
 872 {
 873         UCHAR                           i, choffset;
 874         EEPROM_TX_PWR_STRUC         Power;
 875         EEPROM_TX_PWR_STRUC         Power2;
 876
 877         // Read Tx power value for all channels
 878         // Value from 1 - 0x7f. Default value is 24.
 879         // Power value : 2.4G 0x00 (0) ~ 0x1F (31)
 880         //             : 5.5G 0xF9 (-7) ~ 0x0F (15)
 881
 882         // 0. 11b/g, ch1 - ch 14
 883         for (i = 0; i < 7; i++)
 884         {
 885 //              Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_G_TX_PWR_OFFSET + i * 2);
 886 //              Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_G_TX2_PWR_OFFSET + i * 2);
 887                 RT28xx_EEPROM_READ16(pAd, EEPROM_G_TX_PWR_OFFSET + i * 2, Power.word);
 888                 RT28xx_EEPROM_READ16(pAd, EEPROM_G_TX2_PWR_OFFSET + i * 2, Power2.word);
 889                 pAd->TxPower[i * 2].Channel = i * 2 + 1;
 890                 pAd->TxPower[i * 2 + 1].Channel = i * 2 + 2;
 891
 892                 if ((Power.field.Byte0 > 31) || (Power.field.Byte0 < 0))
 893                         pAd->TxPower[i * 2].Power = DEFAULT_RF_TX_POWER;
 894                 else
 895                         pAd->TxPower[i * 2].Power = Power.field.Byte0;
 896
 897                 if ((Power.field.Byte1 > 31) || (Power.field.Byte1 < 0))
 898                         pAd->TxPower[i * 2 + 1].Power = DEFAULT_RF_TX_POWER;
 899                 else
 900                         pAd->TxPower[i * 2 + 1].Power = Power.field.Byte1;
 901
 902                 if ((Power2.field.Byte0 > 31) || (Power2.field.Byte0 < 0))
 903                         pAd->TxPower[i * 2].Power2 = DEFAULT_RF_TX_POWER;
 904                 else
 905                         pAd->TxPower[i * 2].Power2 = Power2.field.Byte0;
 906
 907                 if ((Power2.field.Byte1 > 31) || (Power2.field.Byte1 < 0))
 908                         pAd->TxPower[i * 2 + 1].Power2 = DEFAULT_RF_TX_POWER;
 909                 else
 910                         pAd->TxPower[i * 2 + 1].Power2 = Power2.field.Byte1;
 911         }
 912
 913         // 1. U-NII lower/middle band: 36, 38, 40; 44, 46, 48; 52, 54, 56; 60, 62, 64 (including central frequency in BW 40MHz)
 914         // 1.1 Fill up channel
 915         choffset = 14;
 916         for (i = 0; i < 4; i++)
 917         {
 918                 pAd->TxPower[3 * i + choffset + 0].Channel      = 36 + i * 8 + 0;
 919                 pAd->TxPower[3 * i + choffset + 0].Power        = DEFAULT_RF_TX_POWER;
 920                 pAd->TxPower[3 * i + choffset + 0].Power2       = DEFAULT_RF_TX_POWER;
 921
 922                 pAd->TxPower[3 * i + choffset + 1].Channel      = 36 + i * 8 + 2;
 923                 pAd->TxPower[3 * i + choffset + 1].Power        = DEFAULT_RF_TX_POWER;
 924                 pAd->TxPower[3 * i + choffset + 1].Power2       = DEFAULT_RF_TX_POWER;
 925
 926                 pAd->TxPower[3 * i + choffset + 2].Channel      = 36 + i * 8 + 4;
 927                 pAd->TxPower[3 * i + choffset + 2].Power        = DEFAULT_RF_TX_POWER;
 928                 pAd->TxPower[3 * i + choffset + 2].Power2       = DEFAULT_RF_TX_POWER;
 929         }
 930
 931         // 1.2 Fill up power
 932         for (i = 0; i < 6; i++)
 933         {
 934 //              Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + i * 2);
 935 //              Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + i * 2);
 936                 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + i * 2, Power.word);
 937                 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + i * 2, Power2.word);
 938
 939                 if ((Power.field.Byte0 < 16) && (Power.field.Byte0 >= -7))
 940                         pAd->TxPower[i * 2 + choffset + 0].Power = Power.field.Byte0;
 941
 942                 if ((Power.field.Byte1 < 16) && (Power.field.Byte1 >= -7))
 943                         pAd->TxPower[i * 2 + choffset + 1].Power = Power.field.Byte1;
 944
 945                 if ((Power2.field.Byte0 < 16) && (Power2.field.Byte0 >= -7))
 946                         pAd->TxPower[i * 2 + choffset + 0].Power2 = Power2.field.Byte0;
 947
 948                 if ((Power2.field.Byte1 < 16) && (Power2.field.Byte1 >= -7))
 949                         pAd->TxPower[i * 2 + choffset + 1].Power2 = Power2.field.Byte1;
 950         }
 951
 952         // 2. HipperLAN 2 100, 102 ,104; 108, 110, 112; 116, 118, 120; 124, 126, 128; 132, 134, 136; 140 (including central frequency in BW 40MHz)
 953         // 2.1 Fill up channel
 954         choffset = 14 + 12;
 955         for (i = 0; i < 5; i++)
 956         {
 957                 pAd->TxPower[3 * i + choffset + 0].Channel      = 100 + i * 8 + 0;
 958                 pAd->TxPower[3 * i + choffset + 0].Power        = DEFAULT_RF_TX_POWER;
 959                 pAd->TxPower[3 * i + choffset + 0].Power2       = DEFAULT_RF_TX_POWER;
 960
 961                 pAd->TxPower[3 * i + choffset + 1].Channel      = 100 + i * 8 + 2;
 962                 pAd->TxPower[3 * i + choffset + 1].Power        = DEFAULT_RF_TX_POWER;
 963                 pAd->TxPower[3 * i + choffset + 1].Power2       = DEFAULT_RF_TX_POWER;
 964
 965                 pAd->TxPower[3 * i + choffset + 2].Channel      = 100 + i * 8 + 4;
 966                 pAd->TxPower[3 * i + choffset + 2].Power        = DEFAULT_RF_TX_POWER;
 967                 pAd->TxPower[3 * i + choffset + 2].Power2       = DEFAULT_RF_TX_POWER;
 968         }
 969         pAd->TxPower[3 * 5 + choffset + 0].Channel              = 140;
 970         pAd->TxPower[3 * 5 + choffset + 0].Power                = DEFAULT_RF_TX_POWER;
 971         pAd->TxPower[3 * 5 + choffset + 0].Power2               = DEFAULT_RF_TX_POWER;
 972
 973         // 2.2 Fill up power
 974         for (i = 0; i < 8; i++)
 975         {
 976 //              Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2);
 977 //              Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2);
 978                 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2, Power.word);
 979                 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2, Power2.word);
 980
 981                 if ((Power.field.Byte0 < 16) && (Power.field.Byte0 >= -7))
 982                         pAd->TxPower[i * 2 + choffset + 0].Power = Power.field.Byte0;
 983
 984                 if ((Power.field.Byte1 < 16) && (Power.field.Byte1 >= -7))
 985                         pAd->TxPower[i * 2 + choffset + 1].Power = Power.field.Byte1;
 986
 987                 if ((Power2.field.Byte0 < 16) && (Power2.field.Byte0 >= -7))
 988                         pAd->TxPower[i * 2 + choffset + 0].Power2 = Power2.field.Byte0;
 989
 990                 if ((Power2.field.Byte1 < 16) && (Power2.field.Byte1 >= -7))
 991                         pAd->TxPower[i * 2 + choffset + 1].Power2 = Power2.field.Byte1;
 992         }
 993
 994         // 3. U-NII upper band: 149, 151, 153; 157, 159, 161; 165 (including central frequency in BW 40MHz)
 995         // 3.1 Fill up channel
 996         choffset = 14 + 12 + 16;
 997         for (i = 0; i < 2; i++)
 998         {
 999                 pAd->TxPower[3 * i + choffset + 0].Channel      = 149 + i * 8 + 0;
1000                 pAd->TxPower[3 * i + choffset + 0].Power        = DEFAULT_RF_TX_POWER;
1001                 pAd->TxPower[3 * i + choffset + 0].Power2       = DEFAULT_RF_TX_POWER;
1002
1003                 pAd->TxPower[3 * i + choffset + 1].Channel      = 149 + i * 8 + 2;
1004                 pAd->TxPower[3 * i + choffset + 1].Power        = DEFAULT_RF_TX_POWER;
1005                 pAd->TxPower[3 * i + choffset + 1].Power2       = DEFAULT_RF_TX_POWER;
1006
1007                 pAd->TxPower[3 * i + choffset + 2].Channel      = 149 + i * 8 + 4;
1008                 pAd->TxPower[3 * i + choffset + 2].Power        = DEFAULT_RF_TX_POWER;
1009                 pAd->TxPower[3 * i + choffset + 2].Power2       = DEFAULT_RF_TX_POWER;
1010         }
1011         pAd->TxPower[3 * 2 + choffset + 0].Channel              = 165;
1012         pAd->TxPower[3 * 2 + choffset + 0].Power                = DEFAULT_RF_TX_POWER;
1013         pAd->TxPower[3 * 2 + choffset + 0].Power2               = DEFAULT_RF_TX_POWER;
1014
1015         // 3.2 Fill up power
1016         for (i = 0; i < 4; i++)
1017         {
1018 //              Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2);
1019 //              Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2);
1020                 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2, Power.word);
1021                 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2, Power2.word);
1022
1023                 if ((Power.field.Byte0 < 16) && (Power.field.Byte0 >= -7))
1024                         pAd->TxPower[i * 2 + choffset + 0].Power = Power.field.Byte0;
1025
1026                 if ((Power.field.Byte1 < 16) && (Power.field.Byte1 >= -7))
1027                         pAd->TxPower[i * 2 + choffset + 1].Power = Power.field.Byte1;
1028
1029                 if ((Power2.field.Byte0 < 16) && (Power2.field.Byte0 >= -7))
1030                         pAd->TxPower[i * 2 + choffset + 0].Power2 = Power2.field.Byte0;
1031
1032                 if ((Power2.field.Byte1 < 16) && (Power2.field.Byte1 >= -7))
1033                         pAd->TxPower[i * 2 + choffset + 1].Power2 = Power2.field.Byte1;
1034         }
1035
1036         // 4. Print and Debug
1037         choffset = 14 + 12 + 16 + 7;
1038
1039 }
1040
1041 /*
1042         ========================================================================
1043
1044         Routine Description:
1045                 Read the following from the registry
1046                 1. All the parameters
1047                 2. NetworkAddres
1048
1049         Arguments:
1050                 Adapter                                         Pointer to our adapter
1051                 WrapperConfigurationContext     For use by NdisOpenConfiguration
1052
1053         Return Value:
1054                 NDIS_STATUS_SUCCESS
1055                 NDIS_STATUS_FAILURE
1056                 NDIS_STATUS_RESOURCES
1057
1058         IRQL = PASSIVE_LEVEL
1059
1060         Note:
1061
1062         ========================================================================
1063 */
1064 NDIS_STATUS     NICReadRegParameters(
1065         IN      PRTMP_ADAPTER           pAd,
1066         IN      NDIS_HANDLE                     WrapperConfigurationContext
1067         )
1068 {
1069         NDIS_STATUS                                             Status = NDIS_STATUS_SUCCESS;
1070         DBGPRINT_S(Status, ("<-- NICReadRegParameters, Status=%x\n", Status));
1071         return Status;
1072 }
1073
1074
1075 #ifdef RT2870
1076 /*
1077         ========================================================================
1078
1079         Routine Description:
1080                 For RF filter calibration purpose
1081
1082         Arguments:
1083                 pAd                          Pointer to our adapter
1084
1085         Return Value:
1086                 None
1087
1088         IRQL = PASSIVE_LEVEL
1089
1090         ========================================================================
1091 */
1092 VOID RTUSBFilterCalibration(
1093         IN PRTMP_ADAPTER pAd)
1094 {
1095         UCHAR   R55x = 0, value, FilterTarget = 0x1E, BBPValue;
1096         UINT    loop = 0, count = 0, loopcnt = 0, ReTry = 0;
1097         UCHAR   RF_R24_Value = 0;
1098
1099         // Give bbp filter initial value
1100         pAd->Mlme.CaliBW20RfR24 = 0x16;
1101         pAd->Mlme.CaliBW40RfR24 = 0x36;  //Bit[5] must be 1 for BW 40
1102
1103         do
1104         {
1105                 if (loop == 1)  //BandWidth = 40 MHz
1106                 {
1107                         // Write 0x27 to RF_R24 to program filter
1108                         RF_R24_Value = 0x27;
1109                         RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1110                         FilterTarget = 0x19;
1111
1112                         // when calibrate BW40, BBP mask must set to BW40.
1113                         RTUSBReadBBPRegister(pAd, BBP_R4, &BBPValue);
1114                         BBPValue&= (~0x18);
1115                         BBPValue|= (0x10);
1116                         RTUSBWriteBBPRegister(pAd, BBP_R4, BBPValue);
1117                 }
1118                 else                    //BandWidth = 20 MHz
1119                 {
1120                         // Write 0x07 to RF_R24 to program filter
1121                         RF_R24_Value = 0x07;
1122                         RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1123                         FilterTarget = 0x16;
1124                 }
1125
1126                 // Write 0x01 to RF_R22 to enable baseband loopback mode
1127                 RT30xxReadRFRegister(pAd, RF_R22, &value);
1128                 value |= 0x01;
1129                 RT30xxWriteRFRegister(pAd, RF_R22, value);
1130
1131                 // Write 0x00 to BBP_R24 to set power & frequency of passband test tone
1132                 RTUSBWriteBBPRegister(pAd, BBP_R24, 0);
1133
1134                 do
1135                 {
1136                         // Write 0x90 to BBP_R25 to transmit test tone
1137                         RTUSBWriteBBPRegister(pAd, BBP_R25, 0x90);
1138
1139                         RTMPusecDelay(1000);
1140                         // Read BBP_R55[6:0] for received power, set R55x = BBP_R55[6:0]
1141                         RTUSBReadBBPRegister(pAd, BBP_R55, &value);
1142                         R55x = value & 0xFF;
1143
1144                 } while ((ReTry++ < 100) && (R55x == 0));
1145
1146                 // Write 0x06 to BBP_R24 to set power & frequency of stopband test tone
1147                 RTUSBWriteBBPRegister(pAd, BBP_R24, 0x06);
1148
1149                 while(TRUE)
1150                 {
1151                         // Write 0x90 to BBP_R25 to transmit test tone
1152                         RTUSBWriteBBPRegister(pAd, BBP_R25, 0x90);
1153
1154                         //We need to wait for calibration
1155                         RTMPusecDelay(1000);
1156                         RTUSBReadBBPRegister(pAd, BBP_R55, &value);
1157                         value &= 0xFF;
1158                         if ((R55x - value) < FilterTarget)
1159                         {
1160                                 RF_R24_Value ++;
1161                         }
1162                         else if ((R55x - value) == FilterTarget)
1163                         {
1164                                 RF_R24_Value ++;
1165                                 count ++;
1166                         }
1167                         else
1168                         {
1169                                 break;
1170                         }
1171
1172                         // prevent infinite loop cause driver hang.
1173                         if (loopcnt++ > 100)
1174                         {
1175                                 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBFilterCalibration - can't find a valid value, loopcnt=%d stop calibrating", loopcnt));
1176                                 break;
1177                         }
1178
1179                         // Write RF_R24 to program filter
1180                         RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1181                 }
1182
1183                 if (count > 0)
1184                 {
1185                         RF_R24_Value = RF_R24_Value - ((count) ? (1) : (0));
1186                 }
1187
1188                 // Store for future usage
1189                 if (loopcnt < 100)
1190                 {
1191                         if (loop++ == 0)
1192                         {
1193                                 //BandWidth = 20 MHz
1194                                 pAd->Mlme.CaliBW20RfR24 = (UCHAR)RF_R24_Value;
1195                         }
1196                         else
1197                         {
1198                                 //BandWidth = 40 MHz
1199                                 pAd->Mlme.CaliBW40RfR24 = (UCHAR)RF_R24_Value;
1200                                 break;
1201                         }
1202                 }
1203                 else
1204                         break;
1205
1206                 RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1207
1208                 // reset count
1209                 count = 0;
1210         } while(TRUE);
1211
1212         //
1213         // Set back to initial state
1214         //
1215         RTUSBWriteBBPRegister(pAd, BBP_R24, 0);
1216
1217         RT30xxReadRFRegister(pAd, RF_R22, &value);
1218         value &= ~(0x01);
1219         RT30xxWriteRFRegister(pAd, RF_R22, value);
1220
1221         // set BBP back to BW20
1222         RTUSBReadBBPRegister(pAd, BBP_R4, &BBPValue);
1223         BBPValue&= (~0x18);
1224         RTUSBWriteBBPRegister(pAd, BBP_R4, BBPValue);
1225
1226         DBGPRINT(RT_DEBUG_TRACE, ("RTUSBFilterCalibration - CaliBW20RfR24=0x%x, CaliBW40RfR24=0x%x\n", pAd->Mlme.CaliBW20RfR24, pAd->Mlme.CaliBW40RfR24));
1227 }
1228
1229
1230 VOID NICInitRT30xxRFRegisters(IN PRTMP_ADAPTER pAd)
1231 {
1232         INT i;
1233         // Driver must read EEPROM to get RfIcType before initial RF registers
1234         // Initialize RF register to default value
1235         if (IS_RT3070(pAd) && ((pAd->RfIcType == RFIC_3020) ||(pAd->RfIcType == RFIC_2020)))
1236         {
1237                 // Init RF calibration
1238                 // Driver should toggle RF R30 bit7 before init RF registers
1239                 ULONG RfReg = 0;
1240                 RT30xxReadRFRegister(pAd, RF_R30, (PUCHAR)&RfReg);
1241                 RfReg |= 0x80;
1242                 RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR)RfReg);
1243                 RTMPusecDelay(1000);
1244                 RfReg &= 0x7F;
1245                 RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR)RfReg);
1246
1247                 // Initialize RF register to default value
1248                 for (i = 0; i < NUM_RF_REG_PARMS; i++)
1249                 {
1250                         RT30xxWriteRFRegister(pAd, RT30xx_RFRegTable[i].Register, RT30xx_RFRegTable[i].Value);
1251                 }
1252
1253                 //For RF filter Calibration
1254                 RTUSBFilterCalibration(pAd);
1255         }
1256
1257 }
1258 #endif // RT2870 //
1259
1260
1261 /*
1262         ========================================================================
1263
1264         Routine Description:
1265                 Read initial parameters from EEPROM
1266
1267         Arguments:
1268                 Adapter                                         Pointer to our adapter
1269
1270         Return Value:
1271                 None
1272
1273         IRQL = PASSIVE_LEVEL
1274
1275         Note:
1276
1277         ========================================================================
1278 */
1279 VOID    NICReadEEPROMParameters(
1280         IN      PRTMP_ADAPTER   pAd,
1281         IN      PUCHAR                  mac_addr)
1282 {
1283         UINT32                  data = 0;
1284         USHORT                  i, value, value2;
1285         UCHAR                   TmpPhy;
1286         EEPROM_TX_PWR_STRUC         Power;
1287         EEPROM_VERSION_STRUC    Version;
1288         EEPROM_ANTENNA_STRUC    Antenna;
1289         EEPROM_NIC_CONFIG2_STRUC    NicConfig2;
1290
1291         DBGPRINT(RT_DEBUG_TRACE, ("--> NICReadEEPROMParameters\n"));
1292
1293         // Init EEPROM Address Number, before access EEPROM; if 93c46, EEPROMAddressNum=6, else if 93c66, EEPROMAddressNum=8
1294         RTMP_IO_READ32(pAd, E2PROM_CSR, &data);
1295         DBGPRINT(RT_DEBUG_TRACE, ("--> E2PROM_CSR = 0x%x\n", data));
1296
1297         if((data & 0x30) == 0)
1298                 pAd->EEPROMAddressNum = 6;              // 93C46
1299         else if((data & 0x30) == 0x10)
1300                 pAd->EEPROMAddressNum = 8;     // 93C66
1301         else
1302                 pAd->EEPROMAddressNum = 8;     // 93C86
1303         DBGPRINT(RT_DEBUG_TRACE, ("--> EEPROMAddressNum = %d\n", pAd->EEPROMAddressNum ));
1304
1305         // RT2860 MAC no longer auto load MAC address from E2PROM. Driver has to intialize
1306         // MAC address registers according to E2PROM setting
1307         if (mac_addr == NULL ||
1308                 strlen(mac_addr) != 17 ||
1309                 mac_addr[2] != ':'  || mac_addr[5] != ':'  || mac_addr[8] != ':' ||
1310                 mac_addr[11] != ':' || mac_addr[14] != ':')
1311         {
1312                 USHORT  Addr01,Addr23,Addr45 ;
1313
1314                 RT28xx_EEPROM_READ16(pAd, 0x04, Addr01);
1315                 RT28xx_EEPROM_READ16(pAd, 0x06, Addr23);
1316                 RT28xx_EEPROM_READ16(pAd, 0x08, Addr45);
1317
1318                 pAd->PermanentAddress[0] = (UCHAR)(Addr01 & 0xff);
1319                 pAd->PermanentAddress[1] = (UCHAR)(Addr01 >> 8);
1320                 pAd->PermanentAddress[2] = (UCHAR)(Addr23 & 0xff);
1321                 pAd->PermanentAddress[3] = (UCHAR)(Addr23 >> 8);
1322                 pAd->PermanentAddress[4] = (UCHAR)(Addr45 & 0xff);
1323                 pAd->PermanentAddress[5] = (UCHAR)(Addr45 >> 8);
1324
1325                 DBGPRINT(RT_DEBUG_TRACE, ("Initialize MAC Address from E2PROM \n"));
1326         }
1327         else
1328         {
1329                 INT             j;
1330                 PUCHAR  macptr;
1331
1332                 macptr = mac_addr;
1333
1334                 for (j=0; j<MAC_ADDR_LEN; j++)
1335                 {
1336                         AtoH(macptr, &pAd->PermanentAddress[j], 1);
1337                         macptr=macptr+3;
1338                 }
1339
1340                 DBGPRINT(RT_DEBUG_TRACE, ("Initialize MAC Address from module parameter \n"));
1341         }
1342
1343
1344         {
1345 #if 0
1346                 USHORT  Addr01,Addr23,Addr45 ;
1347
1348                 Addr01=RTMP_EEPROM_READ16(pAd, 0x04);
1349                 Addr23=RTMP_EEPROM_READ16(pAd, 0x06);
1350                 Addr45=RTMP_EEPROM_READ16(pAd, 0x08);
1351
1352                 pAd->PermanentAddress[0] = (UCHAR)(Addr01 & 0xff);
1353                 pAd->PermanentAddress[1] = (UCHAR)(Addr01 >> 8);
1354                 pAd->PermanentAddress[2] = (UCHAR)(Addr23 & 0xff);
1355                 pAd->PermanentAddress[3] = (UCHAR)(Addr23 >> 8);
1356                 pAd->PermanentAddress[4] = (UCHAR)(Addr45 & 0xff);
1357                 pAd->PermanentAddress[5] = (UCHAR)(Addr45 >> 8);
1358 #endif
1359                 //more conveninet to test mbssid, so ap's bssid &0xf1
1360                 if (pAd->PermanentAddress[0] == 0xff)
1361                         pAd->PermanentAddress[0] = RandomByte(pAd)&0xf8;
1362
1363                 //if (pAd->PermanentAddress[5] == 0xff)
1364                 //      pAd->PermanentAddress[5] = RandomByte(pAd)&0xf8;
1365
1366                 DBGPRINT_RAW(RT_DEBUG_TRACE,("E2PROM MAC: =%02x:%02x:%02x:%02x:%02x:%02x\n",
1367                         pAd->PermanentAddress[0], pAd->PermanentAddress[1],
1368                         pAd->PermanentAddress[2], pAd->PermanentAddress[3],
1369                         pAd->PermanentAddress[4], pAd->PermanentAddress[5]));
1370                 if (pAd->bLocalAdminMAC == FALSE)
1371                 {
1372                         MAC_DW0_STRUC csr2;
1373                         MAC_DW1_STRUC csr3;
1374                         COPY_MAC_ADDR(pAd->CurrentAddress, pAd->PermanentAddress);
1375                         csr2.field.Byte0 = pAd->CurrentAddress[0];
1376                         csr2.field.Byte1 = pAd->CurrentAddress[1];
1377                         csr2.field.Byte2 = pAd->CurrentAddress[2];
1378                         csr2.field.Byte3 = pAd->CurrentAddress[3];
1379                         RTMP_IO_WRITE32(pAd, MAC_ADDR_DW0, csr2.word);
1380                         csr3.word = 0;
1381                         csr3.field.Byte4 = pAd->CurrentAddress[4];
1382                         csr3.field.Byte5 = pAd->CurrentAddress[5];
1383                         csr3.field.U2MeMask = 0xff;
1384                         RTMP_IO_WRITE32(pAd, MAC_ADDR_DW1, csr3.word);
1385                         DBGPRINT_RAW(RT_DEBUG_TRACE,("E2PROM MAC: =%02x:%02x:%02x:%02x:%02x:%02x\n",
1386                                 pAd->PermanentAddress[0], pAd->PermanentAddress[1],
1387                                 pAd->PermanentAddress[2], pAd->PermanentAddress[3],
1388                                 pAd->PermanentAddress[4], pAd->PermanentAddress[5]));
1389                 }
1390         }
1391
1392         // if not return early. cause fail at emulation.
1393         // Init the channel number for TX channel power
1394         RTMPReadChannelPwr(pAd);
1395
1396         // if E2PROM version mismatch with driver's expectation, then skip
1397         // all subsequent E2RPOM retieval and set a system error bit to notify GUI
1398         RT28xx_EEPROM_READ16(pAd, EEPROM_VERSION_OFFSET, Version.word);
1399         pAd->EepromVersion = Version.field.Version + Version.field.FaeReleaseNumber * 256;
1400         DBGPRINT(RT_DEBUG_TRACE, ("E2PROM: Version = %d, FAE release #%d\n", Version.field.Version, Version.field.FaeReleaseNumber));
1401
1402         if (Version.field.Version > VALID_EEPROM_VERSION)
1403         {
1404                 DBGPRINT_ERR(("E2PROM: WRONG VERSION 0x%x, should be %d\n",Version.field.Version, VALID_EEPROM_VERSION));
1405                 /*pAd->SystemErrorBitmap |= 0x00000001;
1406
1407                 // hard-code default value when no proper E2PROM installed
1408                 pAd->bAutoTxAgcA = FALSE;
1409                 pAd->bAutoTxAgcG = FALSE;
1410
1411                 // Default the channel power
1412                 for (i = 0; i < MAX_NUM_OF_CHANNELS; i++)
1413                         pAd->TxPower[i].Power = DEFAULT_RF_TX_POWER;
1414
1415                 // Default the channel power
1416                 for (i = 0; i < MAX_NUM_OF_11JCHANNELS; i++)
1417                         pAd->TxPower11J[i].Power = DEFAULT_RF_TX_POWER;
1418
1419                 for(i = 0; i < NUM_EEPROM_BBP_PARMS; i++)
1420                         pAd->EEPROMDefaultValue[i] = 0xffff;
1421                 return;  */
1422         }
1423
1424         // Read BBP default value from EEPROM and store to array(EEPROMDefaultValue) in pAd
1425         RT28xx_EEPROM_READ16(pAd, EEPROM_NIC1_OFFSET, value);
1426         pAd->EEPROMDefaultValue[0] = value;
1427
1428         RT28xx_EEPROM_READ16(pAd, EEPROM_NIC2_OFFSET, value);
1429         pAd->EEPROMDefaultValue[1] = value;
1430
1431         RT28xx_EEPROM_READ16(pAd, 0x38, value); // Country Region
1432         pAd->EEPROMDefaultValue[2] = value;
1433
1434         for(i = 0; i < 8; i++)
1435         {
1436                 RT28xx_EEPROM_READ16(pAd, EEPROM_BBP_BASE_OFFSET + i*2, value);
1437                 pAd->EEPROMDefaultValue[i+3] = value;
1438         }
1439
1440         // We have to parse NIC configuration 0 at here.
1441         // If TSSI did not have preloaded value, it should reset the TxAutoAgc to false
1442         // Therefore, we have to read TxAutoAgc control beforehand.
1443         // Read Tx AGC control bit
1444         Antenna.word = pAd->EEPROMDefaultValue[0];
1445         if (Antenna.word == 0xFFFF)
1446         {
1447                 Antenna.word = 0;
1448                 Antenna.field.RfIcType = RFIC_2820;
1449                 Antenna.field.TxPath = 1;
1450                 Antenna.field.RxPath = 2;
1451                 DBGPRINT(RT_DEBUG_WARN, ("E2PROM error, hard code as 0x%04x\n", Antenna.word));
1452         }
1453
1454         // Choose the desired Tx&Rx stream.
1455         if ((pAd->CommonCfg.TxStream == 0) || (pAd->CommonCfg.TxStream > Antenna.field.TxPath))
1456                 pAd->CommonCfg.TxStream = Antenna.field.TxPath;
1457
1458         if ((pAd->CommonCfg.RxStream == 0) || (pAd->CommonCfg.RxStream > Antenna.field.RxPath))
1459         {
1460                 pAd->CommonCfg.RxStream = Antenna.field.RxPath;
1461
1462                 if ((pAd->MACVersion < RALINK_2883_VERSION) &&
1463                         (pAd->CommonCfg.RxStream > 2))
1464                 {
1465                         // only 2 Rx streams for RT2860 series
1466                         pAd->CommonCfg.RxStream = 2;
1467                 }
1468         }
1469
1470         // 3*3
1471         // read value from EEPROM and set them to CSR174 ~ 177 in chain0 ~ chain2
1472         // yet implement
1473         for(i=0; i<3; i++)
1474         {
1475         }
1476
1477         NicConfig2.word = pAd->EEPROMDefaultValue[1];
1478
1479
1480
1481 #ifdef CONFIG_STA_SUPPORT
1482         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1483         {
1484                 NicConfig2.word = 0;
1485                 if ((NicConfig2.word & 0x00ff) == 0xff)
1486                 {
1487                         NicConfig2.word &= 0xff00;
1488                 }
1489
1490                 if ((NicConfig2.word >> 8) == 0xff)
1491                 {
1492                         NicConfig2.word &= 0x00ff;
1493                 }
1494         }
1495 #endif // CONFIG_STA_SUPPORT //
1496
1497         if (NicConfig2.field.DynamicTxAgcControl == 1)
1498                 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = TRUE;
1499         else
1500                 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = FALSE;
1501
1502         DBGPRINT_RAW(RT_DEBUG_TRACE, ("NICReadEEPROMParameters: RxPath = %d, TxPath = %d\n", Antenna.field.RxPath, Antenna.field.TxPath));
1503
1504         // Save the antenna for future use
1505         pAd->Antenna.word = Antenna.word;
1506
1507         //
1508         // Reset PhyMode if we don't support 802.11a
1509         // Only RFIC_2850 & RFIC_2750 support 802.11a
1510         //
1511         if ((Antenna.field.RfIcType != RFIC_2850) && (Antenna.field.RfIcType != RFIC_2750))
1512         {
1513                 if ((pAd->CommonCfg.PhyMode == PHY_11ABG_MIXED) ||
1514                         (pAd->CommonCfg.PhyMode == PHY_11A))
1515                         pAd->CommonCfg.PhyMode = PHY_11BG_MIXED;
1516 #ifdef DOT11_N_SUPPORT
1517                 else if ((pAd->CommonCfg.PhyMode == PHY_11ABGN_MIXED)   ||
1518                                  (pAd->CommonCfg.PhyMode == PHY_11AN_MIXED)     ||
1519                                  (pAd->CommonCfg.PhyMode == PHY_11AGN_MIXED)    ||
1520                                  (pAd->CommonCfg.PhyMode == PHY_11N_5G))
1521                         pAd->CommonCfg.PhyMode = PHY_11BGN_MIXED;
1522 #endif // DOT11_N_SUPPORT //
1523         }
1524
1525         // Read TSSI reference and TSSI boundary for temperature compensation. This is ugly
1526         // 0. 11b/g
1527         {
1528                 /* these are tempature reference value (0x00 ~ 0xFE)
1529                    ex: 0x00 0x15 0x25 0x45 0x88 0xA0 0xB5 0xD0 0xF0
1530                    TssiPlusBoundaryG [4] [3] [2] [1] [0] (smaller) +
1531                    TssiMinusBoundaryG[0] [1] [2] [3] [4] (larger) */
1532                 RT28xx_EEPROM_READ16(pAd, 0x6E, Power.word);
1533                 pAd->TssiMinusBoundaryG[4] = Power.field.Byte0;
1534                 pAd->TssiMinusBoundaryG[3] = Power.field.Byte1;
1535                 RT28xx_EEPROM_READ16(pAd, 0x70, Power.word);
1536                 pAd->TssiMinusBoundaryG[2] = Power.field.Byte0;
1537                 pAd->TssiMinusBoundaryG[1] = Power.field.Byte1;
1538                 RT28xx_EEPROM_READ16(pAd, 0x72, Power.word);
1539                 pAd->TssiRefG   = Power.field.Byte0; /* reference value [0] */
1540                 pAd->TssiPlusBoundaryG[1] = Power.field.Byte1;
1541                 RT28xx_EEPROM_READ16(pAd, 0x74, Power.word);
1542                 pAd->TssiPlusBoundaryG[2] = Power.field.Byte0;
1543                 pAd->TssiPlusBoundaryG[3] = Power.field.Byte1;
1544                 RT28xx_EEPROM_READ16(pAd, 0x76, Power.word);
1545                 pAd->TssiPlusBoundaryG[4] = Power.field.Byte0;
1546                 pAd->TxAgcStepG = Power.field.Byte1;
1547                 pAd->TxAgcCompensateG = 0;
1548                 pAd->TssiMinusBoundaryG[0] = pAd->TssiRefG;
1549                 pAd->TssiPlusBoundaryG[0]  = pAd->TssiRefG;
1550
1551                 // Disable TxAgc if the based value is not right
1552                 if (pAd->TssiRefG == 0xff)
1553                         pAd->bAutoTxAgcG = FALSE;
1554
1555                 DBGPRINT(RT_DEBUG_TRACE,("E2PROM: G Tssi[-4 .. +4] = %d %d %d %d - %d -%d %d %d %d, step=%d, tuning=%d\n",
1556                         pAd->TssiMinusBoundaryG[4], pAd->TssiMinusBoundaryG[3], pAd->TssiMinusBoundaryG[2], pAd->TssiMinusBoundaryG[1],
1557                         pAd->TssiRefG,
1558                         pAd->TssiPlusBoundaryG[1], pAd->TssiPlusBoundaryG[2], pAd->TssiPlusBoundaryG[3], pAd->TssiPlusBoundaryG[4],
1559                         pAd->TxAgcStepG, pAd->bAutoTxAgcG));
1560         }
1561         // 1. 11a
1562         {
1563                 RT28xx_EEPROM_READ16(pAd, 0xD4, Power.word);
1564                 pAd->TssiMinusBoundaryA[4] = Power.field.Byte0;
1565                 pAd->TssiMinusBoundaryA[3] = Power.field.Byte1;
1566                 RT28xx_EEPROM_READ16(pAd, 0xD6, Power.word);
1567                 pAd->TssiMinusBoundaryA[2] = Power.field.Byte0;
1568                 pAd->TssiMinusBoundaryA[1] = Power.field.Byte1;
1569                 RT28xx_EEPROM_READ16(pAd, 0xD8, Power.word);
1570                 pAd->TssiRefA   = Power.field.Byte0;
1571                 pAd->TssiPlusBoundaryA[1] = Power.field.Byte1;
1572                 RT28xx_EEPROM_READ16(pAd, 0xDA, Power.word);
1573                 pAd->TssiPlusBoundaryA[2] = Power.field.Byte0;
1574                 pAd->TssiPlusBoundaryA[3] = Power.field.Byte1;
1575                 RT28xx_EEPROM_READ16(pAd, 0xDC, Power.word);
1576                 pAd->TssiPlusBoundaryA[4] = Power.field.Byte0;
1577                 pAd->TxAgcStepA = Power.field.Byte1;
1578                 pAd->TxAgcCompensateA = 0;
1579                 pAd->TssiMinusBoundaryA[0] = pAd->TssiRefA;
1580                 pAd->TssiPlusBoundaryA[0]  = pAd->TssiRefA;
1581
1582                 // Disable TxAgc if the based value is not right
1583                 if (pAd->TssiRefA == 0xff)
1584                         pAd->bAutoTxAgcA = FALSE;
1585
1586                 DBGPRINT(RT_DEBUG_TRACE,("E2PROM: A Tssi[-4 .. +4] = %d %d %d %d - %d -%d %d %d %d, step=%d, tuning=%d\n",
1587                         pAd->TssiMinusBoundaryA[4], pAd->TssiMinusBoundaryA[3], pAd->TssiMinusBoundaryA[2], pAd->TssiMinusBoundaryA[1],
1588                         pAd->TssiRefA,
1589                         pAd->TssiPlusBoundaryA[1], pAd->TssiPlusBoundaryA[2], pAd->TssiPlusBoundaryA[3], pAd->TssiPlusBoundaryA[4],
1590                         pAd->TxAgcStepA, pAd->bAutoTxAgcA));
1591         }
1592         pAd->BbpRssiToDbmDelta = 0x0;
1593
1594         // Read frequency offset setting for RF
1595         RT28xx_EEPROM_READ16(pAd, EEPROM_FREQ_OFFSET, value);
1596         if ((value & 0x00FF) != 0x00FF)
1597                 pAd->RfFreqOffset = (ULONG) (value & 0x00FF);
1598         else
1599                 pAd->RfFreqOffset = 0;
1600         DBGPRINT(RT_DEBUG_TRACE, ("E2PROM: RF FreqOffset=0x%lx \n", pAd->RfFreqOffset));
1601
1602         //CountryRegion byte offset (38h)
1603         value = pAd->EEPROMDefaultValue[2] >> 8;                // 2.4G band
1604         value2 = pAd->EEPROMDefaultValue[2] & 0x00FF;   // 5G band
1605
1606         if ((value <= REGION_MAXIMUM_BG_BAND) && (value2 <= REGION_MAXIMUM_A_BAND))
1607         {
1608                 pAd->CommonCfg.CountryRegion = ((UCHAR) value) | 0x80;
1609                 pAd->CommonCfg.CountryRegionForABand = ((UCHAR) value2) | 0x80;
1610                 TmpPhy = pAd->CommonCfg.PhyMode;
1611                 pAd->CommonCfg.PhyMode = 0xff;
1612                 RTMPSetPhyMode(pAd, TmpPhy);
1613 #ifdef DOT11_N_SUPPORT
1614                 SetCommonHT(pAd);
1615 #endif // DOT11_N_SUPPORT //
1616         }
1617
1618         //
1619         // Get RSSI Offset on EEPROM 0x9Ah & 0x9Ch.
1620         // The valid value are (-10 ~ 10)
1621         //
1622         RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_BG_OFFSET, value);
1623         pAd->BGRssiOffset0 = value & 0x00ff;
1624         pAd->BGRssiOffset1 = (value >> 8);
1625         RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_BG_OFFSET+2, value);
1626         pAd->BGRssiOffset2 = value & 0x00ff;
1627         pAd->ALNAGain1 = (value >> 8);
1628         RT28xx_EEPROM_READ16(pAd, EEPROM_LNA_OFFSET, value);
1629         pAd->BLNAGain = value & 0x00ff;
1630         pAd->ALNAGain0 = (value >> 8);
1631
1632         // Validate 11b/g RSSI_0 offset.
1633         if ((pAd->BGRssiOffset0 < -10) || (pAd->BGRssiOffset0 > 10))
1634                 pAd->BGRssiOffset0 = 0;
1635
1636         // Validate 11b/g RSSI_1 offset.
1637         if ((pAd->BGRssiOffset1 < -10) || (pAd->BGRssiOffset1 > 10))
1638                 pAd->BGRssiOffset1 = 0;
1639
1640         // Validate 11b/g RSSI_2 offset.
1641         if ((pAd->BGRssiOffset2 < -10) || (pAd->BGRssiOffset2 > 10))
1642                 pAd->BGRssiOffset2 = 0;
1643
1644         RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_A_OFFSET, value);
1645         pAd->ARssiOffset0 = value & 0x00ff;
1646         pAd->ARssiOffset1 = (value >> 8);
1647         RT28xx_EEPROM_READ16(pAd, (EEPROM_RSSI_A_OFFSET+2), value);
1648         pAd->ARssiOffset2 = value & 0x00ff;
1649         pAd->ALNAGain2 = (value >> 8);
1650
1651         if (((UCHAR)pAd->ALNAGain1 == 0xFF) || (pAd->ALNAGain1 == 0x00))
1652                 pAd->ALNAGain1 = pAd->ALNAGain0;
1653         if (((UCHAR)pAd->ALNAGain2 == 0xFF) || (pAd->ALNAGain2 == 0x00))
1654                 pAd->ALNAGain2 = pAd->ALNAGain0;
1655
1656         // Validate 11a RSSI_0 offset.
1657         if ((pAd->ARssiOffset0 < -10) || (pAd->ARssiOffset0 > 10))
1658                 pAd->ARssiOffset0 = 0;
1659
1660         // Validate 11a RSSI_1 offset.
1661         if ((pAd->ARssiOffset1 < -10) || (pAd->ARssiOffset1 > 10))
1662                 pAd->ARssiOffset1 = 0;
1663
1664         //Validate 11a RSSI_2 offset.
1665         if ((pAd->ARssiOffset2 < -10) || (pAd->ARssiOffset2 > 10))
1666                 pAd->ARssiOffset2 = 0;
1667
1668         //
1669         // Get LED Setting.
1670         //
1671         RT28xx_EEPROM_READ16(pAd, 0x3a, value);
1672         pAd->LedCntl.word = (value&0xff00) >> 8;
1673         RT28xx_EEPROM_READ16(pAd, EEPROM_LED1_OFFSET, value);
1674         pAd->Led1 = value;
1675         RT28xx_EEPROM_READ16(pAd, EEPROM_LED2_OFFSET, value);
1676         pAd->Led2 = value;
1677         RT28xx_EEPROM_READ16(pAd, EEPROM_LED3_OFFSET, value);
1678         pAd->Led3 = value;
1679
1680         RTMPReadTxPwrPerRate(pAd);
1681
1682 #ifdef SINGLE_SKU
1683         //pAd->CommonCfg.DefineMaxTxPwr = RTMP_EEPROM_READ16(pAd, EEPROM_DEFINE_MAX_TXPWR);
1684         RT28xx_EEPROM_READ16(pAd, EEPROM_DEFINE_MAX_TXPWR, pAd->CommonCfg.DefineMaxTxPwr);
1685 #endif // SINGLE_SKU //
1686
1687         DBGPRINT(RT_DEBUG_TRACE, ("<-- NICReadEEPROMParameters\n"));
1688 }
1689
1690 /*
1691         ========================================================================
1692
1693         Routine Description:
1694                 Set default value from EEPROM
1695
1696         Arguments:
1697                 Adapter                                         Pointer to our adapter
1698
1699         Return Value:
1700                 None
1701
1702         IRQL = PASSIVE_LEVEL
1703
1704         Note:
1705
1706         ========================================================================
1707 */
1708 VOID    NICInitAsicFromEEPROM(
1709         IN      PRTMP_ADAPTER   pAd)
1710 {
1711 #ifdef CONFIG_STA_SUPPORT
1712         UINT32                                  data = 0;
1713         UCHAR   BBPR1 = 0;
1714 #endif // CONFIG_STA_SUPPORT //
1715         USHORT                                  i;
1716         EEPROM_ANTENNA_STRUC    Antenna;
1717         EEPROM_NIC_CONFIG2_STRUC    NicConfig2;
1718         UCHAR   BBPR3 = 0;
1719
1720         DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitAsicFromEEPROM\n"));
1721         for(i = 3; i < NUM_EEPROM_BBP_PARMS; i++)
1722         {
1723                 UCHAR BbpRegIdx, BbpValue;
1724
1725                 if ((pAd->EEPROMDefaultValue[i] != 0xFFFF) && (pAd->EEPROMDefaultValue[i] != 0))
1726                 {
1727                         BbpRegIdx = (UCHAR)(pAd->EEPROMDefaultValue[i] >> 8);
1728                         BbpValue  = (UCHAR)(pAd->EEPROMDefaultValue[i] & 0xff);
1729                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BbpRegIdx, BbpValue);
1730                 }
1731         }
1732
1733         Antenna.word = pAd->Antenna.word;
1734         pAd->Mlme.RealRxPath = (UCHAR) Antenna.field.RxPath;
1735         pAd->RfIcType = (UCHAR) Antenna.field.RfIcType;
1736
1737         NicConfig2.word = pAd->EEPROMDefaultValue[1];
1738
1739
1740         // Save the antenna for future use
1741         pAd->NicConfig2.word = NicConfig2.word;
1742
1743         //
1744         // Send LED Setting to MCU.
1745         //
1746         if (pAd->LedCntl.word == 0xFF)
1747         {
1748                 pAd->LedCntl.word = 0x01;
1749                 pAd->Led1 = 0x5555;
1750                 pAd->Led2 = 0x2221;
1751
1752 #ifdef RT2870
1753                 pAd->Led3 = 0x5627;
1754 #endif // RT2870 //
1755         }
1756
1757         AsicSendCommandToMcu(pAd, 0x52, 0xff, (UCHAR)pAd->Led1, (UCHAR)(pAd->Led1 >> 8));
1758         AsicSendCommandToMcu(pAd, 0x53, 0xff, (UCHAR)pAd->Led2, (UCHAR)(pAd->Led2 >> 8));
1759         AsicSendCommandToMcu(pAd, 0x54, 0xff, (UCHAR)pAd->Led3, (UCHAR)(pAd->Led3 >> 8));
1760     pAd->LedIndicatorStregth = 0xFF;
1761     RTMPSetSignalLED(pAd, -100);        // Force signal strength Led to be turned off, before link up
1762
1763 #ifdef CONFIG_STA_SUPPORT
1764         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1765         {
1766                 // Read Hardware controlled Radio state enable bit
1767                 if (NicConfig2.field.HardwareRadioControl == 1)
1768                 {
1769                         pAd->StaCfg.bHardwareRadio = TRUE;
1770
1771                         // Read GPIO pin2 as Hardware controlled radio state
1772                         RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &data);
1773                         if ((data & 0x04) == 0)
1774                         {
1775                                 pAd->StaCfg.bHwRadio = FALSE;
1776                                 pAd->StaCfg.bRadio = FALSE;
1777 //                              RTMP_IO_WRITE32(pAd, PWR_PIN_CFG, 0x00001818);
1778                                 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
1779                         }
1780                 }
1781                 else
1782                         pAd->StaCfg.bHardwareRadio = FALSE;
1783
1784                 if (pAd->StaCfg.bRadio == FALSE)
1785                 {
1786                         RTMPSetLED(pAd, LED_RADIO_OFF);
1787                 }
1788                 else
1789                 {
1790                         RTMPSetLED(pAd, LED_RADIO_ON);
1791                 }
1792         }
1793 #endif // CONFIG_STA_SUPPORT //
1794
1795         // Turn off patching for cardbus controller
1796         if (NicConfig2.field.CardbusAcceleration == 1)
1797         {
1798 //              pAd->bTest1 = TRUE;
1799         }
1800
1801         if (NicConfig2.field.DynamicTxAgcControl == 1)
1802                 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = TRUE;
1803         else
1804                 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = FALSE;
1805         //
1806         // Since BBP has been progamed, to make sure BBP setting will be
1807         // upate inside of AsicAntennaSelect, so reset to UNKNOWN_BAND!!
1808         //
1809         pAd->CommonCfg.BandState = UNKNOWN_BAND;
1810
1811         RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BBPR3);
1812         BBPR3 &= (~0x18);
1813         if(pAd->Antenna.field.RxPath == 3)
1814         {
1815                 BBPR3 |= (0x10);
1816         }
1817         else if(pAd->Antenna.field.RxPath == 2)
1818         {
1819                 BBPR3 |= (0x8);
1820         }
1821         else if(pAd->Antenna.field.RxPath == 1)
1822         {
1823                 BBPR3 |= (0x0);
1824         }
1825         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BBPR3);
1826
1827 #ifdef CONFIG_STA_SUPPORT
1828         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1829         {
1830                 // Handle the difference when 1T
1831                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R1, &BBPR1);
1832                 if(pAd->Antenna.field.TxPath == 1)
1833                 {
1834                 BBPR1 &= (~0x18);
1835                 }
1836                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R1, BBPR1);
1837
1838                 DBGPRINT(RT_DEBUG_TRACE, ("Use Hw Radio Control Pin=%d; if used Pin=%d;\n", pAd->CommonCfg.bHardwareRadio, pAd->CommonCfg.bHardwareRadio));
1839         }
1840 #endif // CONFIG_STA_SUPPORT //
1841         DBGPRINT(RT_DEBUG_TRACE, ("TxPath = %d, RxPath = %d, RFIC=%d, Polar+LED mode=%x\n", pAd->Antenna.field.TxPath, pAd->Antenna.field.RxPath, pAd->RfIcType, pAd->LedCntl.word));
1842         DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitAsicFromEEPROM\n"));
1843 }
1844
1845 /*
1846         ========================================================================
1847
1848         Routine Description:
1849                 Initialize NIC hardware
1850
1851         Arguments:
1852                 Adapter                                         Pointer to our adapter
1853
1854         Return Value:
1855                 None
1856
1857         IRQL = PASSIVE_LEVEL
1858
1859         Note:
1860
1861         ========================================================================
1862 */
1863 NDIS_STATUS     NICInitializeAdapter(
1864         IN      PRTMP_ADAPTER   pAd,
1865         IN   BOOLEAN    bHardReset)
1866 {
1867         NDIS_STATUS     Status = NDIS_STATUS_SUCCESS;
1868         WPDMA_GLO_CFG_STRUC     GloCfg;
1869 //      INT_MASK_CSR_STRUC              IntMask;
1870         ULONG   i =0, j=0;
1871         AC_TXOP_CSR0_STRUC      csr0;
1872
1873         DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitializeAdapter\n"));
1874
1875         // 3. Set DMA global configuration except TX_DMA_EN and RX_DMA_EN bits:
1876 retry:
1877         i = 0;
1878         do
1879         {
1880                 RTMP_IO_READ32(pAd, WPDMA_GLO_CFG, &GloCfg.word);
1881                 if ((GloCfg.field.TxDMABusy == 0)  && (GloCfg.field.RxDMABusy == 0))
1882                         break;
1883
1884                 RTMPusecDelay(1000);
1885                 i++;
1886         }while ( i<100);
1887         DBGPRINT(RT_DEBUG_TRACE, ("<== DMA offset 0x208 = 0x%x\n", GloCfg.word));
1888         GloCfg.word &= 0xff0;
1889         GloCfg.field.EnTXWriteBackDDONE =1;
1890         RTMP_IO_WRITE32(pAd, WPDMA_GLO_CFG, GloCfg.word);
1891
1892         // Record HW Beacon offset
1893         pAd->BeaconOffset[0] = HW_BEACON_BASE0;
1894         pAd->BeaconOffset[1] = HW_BEACON_BASE1;
1895         pAd->BeaconOffset[2] = HW_BEACON_BASE2;
1896         pAd->BeaconOffset[3] = HW_BEACON_BASE3;
1897         pAd->BeaconOffset[4] = HW_BEACON_BASE4;
1898         pAd->BeaconOffset[5] = HW_BEACON_BASE5;
1899         pAd->BeaconOffset[6] = HW_BEACON_BASE6;
1900         pAd->BeaconOffset[7] = HW_BEACON_BASE7;
1901
1902         //
1903         // write all shared Ring's base address into ASIC
1904         //
1905
1906         // asic simulation sequence put this ahead before loading firmware.
1907         // pbf hardware reset
1908
1909         // Initialze ASIC for TX & Rx operation
1910         if (NICInitializeAsic(pAd , bHardReset) != NDIS_STATUS_SUCCESS)
1911         {
1912                 if (j++ == 0)
1913                 {
1914                         NICLoadFirmware(pAd);
1915                         goto retry;
1916                 }
1917                 return NDIS_STATUS_FAILURE;
1918         }
1919
1920
1921
1922
1923         // WMM parameter
1924         csr0.word = 0;
1925         RTMP_IO_WRITE32(pAd, WMM_TXOP0_CFG, csr0.word);
1926         if (pAd->CommonCfg.PhyMode == PHY_11B)
1927         {
1928                 csr0.field.Ac0Txop = 192;       // AC_VI: 192*32us ~= 6ms
1929                 csr0.field.Ac1Txop = 96;        // AC_VO: 96*32us  ~= 3ms
1930         }
1931         else
1932         {
1933                 csr0.field.Ac0Txop = 96;        // AC_VI: 96*32us ~= 3ms
1934                 csr0.field.Ac1Txop = 48;        // AC_VO: 48*32us ~= 1.5ms
1935         }
1936         RTMP_IO_WRITE32(pAd, WMM_TXOP1_CFG, csr0.word);
1937
1938
1939
1940
1941         // reset action
1942         // Load firmware
1943         //  Status = NICLoadFirmware(pAd);
1944
1945         DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitializeAdapter\n"));
1946         return Status;
1947 }
1948
1949 /*
1950         ========================================================================
1951
1952         Routine Description:
1953                 Initialize ASIC
1954
1955         Arguments:
1956                 Adapter                                         Pointer to our adapter
1957
1958         Return Value:
1959                 None
1960
1961         IRQL = PASSIVE_LEVEL
1962
1963         Note:
1964
1965         ========================================================================
1966 */
1967 NDIS_STATUS     NICInitializeAsic(
1968         IN      PRTMP_ADAPTER   pAd,
1969         IN  BOOLEAN             bHardReset)
1970 {
1971         ULONG                   Index = 0;
1972         UCHAR                   R0 = 0xff;
1973         UINT32                  MacCsr12 = 0, Counter = 0;
1974 #ifdef RT2870
1975         UINT32                  MacCsr0 = 0;
1976         NTSTATUS                Status;
1977         UCHAR                   Value = 0xff;
1978 #endif // RT2870 //
1979         USHORT                  KeyIdx;
1980         INT                             i,apidx;
1981
1982         DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitializeAsic\n"));
1983
1984
1985 #ifdef RT2870
1986         //
1987         // Make sure MAC gets ready after NICLoadFirmware().
1988         //
1989         Index = 0;
1990
1991         //To avoid hang-on issue when interface up in kernel 2.4,
1992         //we use a local variable "MacCsr0" instead of using "pAd->MACVersion" directly.
1993         do
1994         {
1995                 RTMP_IO_READ32(pAd, MAC_CSR0, &MacCsr0);
1996
1997                 if ((MacCsr0 != 0x00) && (MacCsr0 != 0xFFFFFFFF))
1998                         break;
1999
2000                 RTMPusecDelay(10);
2001         } while (Index++ < 100);
2002
2003         pAd->MACVersion = MacCsr0;
2004         DBGPRINT(RT_DEBUG_TRACE, ("MAC_CSR0  [ Ver:Rev=0x%08x]\n", pAd->MACVersion));
2005         // turn on bit13 (set to zero) after rt2860D. This is to solve high-current issue.
2006         RTMP_IO_READ32(pAd, PBF_SYS_CTRL, &MacCsr12);
2007         MacCsr12 &= (~0x2000);
2008         RTMP_IO_WRITE32(pAd, PBF_SYS_CTRL, MacCsr12);
2009
2010         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x3);
2011         RTMP_IO_WRITE32(pAd, USB_DMA_CFG, 0x0);
2012         Status = RTUSBVenderReset(pAd);
2013
2014         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x0);
2015
2016         // Initialize MAC register to default value
2017         for(Index=0; Index<NUM_MAC_REG_PARMS; Index++)
2018         {
2019                 RTMP_IO_WRITE32(pAd, (USHORT)MACRegTable[Index].Register, MACRegTable[Index].Value);
2020         }
2021
2022         if(IS_RT3070(pAd))
2023         {
2024                 // According to Frank Hsu (from Gary Tsao)
2025                 RTMP_IO_WRITE32(pAd, (USHORT)TX_SW_CFG0, 0x00000400);
2026
2027                 // Initialize RT3070 serial MAC registers which is different from RT2870 serial
2028                 RTUSBWriteMACRegister(pAd, TX_SW_CFG1, 0);
2029                 RTUSBWriteMACRegister(pAd, TX_SW_CFG2, 0);
2030         }
2031
2032
2033 #ifdef CONFIG_STA_SUPPORT
2034         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2035         {
2036                 for (Index = 0; Index < NUM_STA_MAC_REG_PARMS; Index++)
2037                 {
2038                         RTMP_IO_WRITE32(pAd, (USHORT)STAMACRegTable[Index].Register, STAMACRegTable[Index].Value);
2039                 }
2040         }
2041 #endif // CONFIG_STA_SUPPORT //
2042 #endif // RT2870 //
2043
2044         //
2045         // Before program BBP, we need to wait BBP/RF get wake up.
2046         //
2047         Index = 0;
2048         do
2049         {
2050                 RTMP_IO_READ32(pAd, MAC_STATUS_CFG, &MacCsr12);
2051
2052                 if ((MacCsr12 & 0x03) == 0)     // if BB.RF is stable
2053                         break;
2054
2055                 DBGPRINT(RT_DEBUG_TRACE, ("Check MAC_STATUS_CFG  = Busy = %x\n", MacCsr12));
2056                 RTMPusecDelay(1000);
2057         } while (Index++ < 100);
2058
2059     // The commands to firmware should be after these commands, these commands will init firmware
2060         // PCI and USB are not the same because PCI driver needs to wait for PCI bus ready
2061         RTMP_IO_WRITE32(pAd, H2M_BBP_AGENT, 0); // initialize BBP R/W access agent
2062         RTMP_IO_WRITE32(pAd, H2M_MAILBOX_CSR, 0);
2063         RTMPusecDelay(1000);
2064
2065         // Read BBP register, make sure BBP is up and running before write new data
2066         Index = 0;
2067         do
2068         {
2069                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R0, &R0);
2070                 DBGPRINT(RT_DEBUG_TRACE, ("BBP version = %x\n", R0));
2071         } while ((++Index < 20) && ((R0 == 0xff) || (R0 == 0x00)));
2072         //ASSERT(Index < 20); //this will cause BSOD on Check-build driver
2073
2074         if ((R0 == 0xff) || (R0 == 0x00))
2075                 return NDIS_STATUS_FAILURE;
2076
2077         // Initialize BBP register to default value
2078         for (Index = 0; Index < NUM_BBP_REG_PARMS; Index++)
2079         {
2080                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBPRegTable[Index].Register, BBPRegTable[Index].Value);
2081         }
2082
2083         // for rt2860E and after, init BBP_R84 with 0x19. This is for extension channel overlapping IOT.
2084         if ((pAd->MACVersion&0xffff) != 0x0101)
2085                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R84, 0x19);
2086
2087 #ifdef RT2870
2088         //write RT3070 BBP wchich different with 2870 after write RT2870 BBP
2089         if (IS_RT3070(pAd))
2090         {
2091                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, 0x0a);
2092                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R84, 0x99);
2093                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R105, 0x05);
2094         }
2095 #endif // RT2870 //
2096
2097         if (pAd->MACVersion == 0x28600100)
2098         {
2099                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, 0x16);
2100                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R73, 0x12);
2101     }
2102
2103         if (pAd->MACVersion >= RALINK_2880E_VERSION && pAd->MACVersion < RALINK_3070_VERSION) // 3*3
2104         {
2105                 // enlarge MAX_LEN_CFG
2106                 UINT32 csr;
2107                 RTMP_IO_READ32(pAd, MAX_LEN_CFG, &csr);
2108                 csr &= 0xFFF;
2109                 csr |= 0x2000;
2110                 RTMP_IO_WRITE32(pAd, MAX_LEN_CFG, csr);
2111         }
2112
2113 #ifdef RT2870
2114 {
2115         UCHAR   MAC_Value[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0,0};
2116
2117         //Initialize WCID table
2118         Value = 0xff;
2119         for(Index =0 ;Index < 254;Index++)
2120         {
2121                 RTUSBMultiWrite(pAd, (USHORT)(MAC_WCID_BASE + Index * 8), MAC_Value, 8);
2122         }
2123 }
2124 #endif // RT2870 //
2125
2126         // Add radio off control
2127 #ifdef CONFIG_STA_SUPPORT
2128         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2129         {
2130                 if (pAd->StaCfg.bRadio == FALSE)
2131                 {
2132 //                      RTMP_IO_WRITE32(pAd, PWR_PIN_CFG, 0x00001818);
2133                         RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
2134                         DBGPRINT(RT_DEBUG_TRACE, ("Set Radio Off\n"));
2135                 }
2136         }
2137 #endif // CONFIG_STA_SUPPORT //
2138
2139         // Clear raw counters
2140         RTMP_IO_READ32(pAd, RX_STA_CNT0, &Counter);
2141         RTMP_IO_READ32(pAd, RX_STA_CNT1, &Counter);
2142         RTMP_IO_READ32(pAd, RX_STA_CNT2, &Counter);
2143         RTMP_IO_READ32(pAd, TX_STA_CNT0, &Counter);
2144         RTMP_IO_READ32(pAd, TX_STA_CNT1, &Counter);
2145         RTMP_IO_READ32(pAd, TX_STA_CNT2, &Counter);
2146
2147         // ASIC will keep garbage value after boot
2148         // Clear all seared key table when initial
2149         // This routine can be ignored in radio-ON/OFF operation.
2150         if (bHardReset)
2151         {
2152                 for (KeyIdx = 0; KeyIdx < 4; KeyIdx++)
2153                 {
2154                         RTMP_IO_WRITE32(pAd, SHARED_KEY_MODE_BASE + 4*KeyIdx, 0);
2155                 }
2156
2157                 // Clear all pairwise key table when initial
2158                 for (KeyIdx = 0; KeyIdx < 256; KeyIdx++)
2159                 {
2160                         RTMP_IO_WRITE32(pAd, MAC_WCID_ATTRIBUTE_BASE + (KeyIdx * HW_WCID_ATTRI_SIZE), 1);
2161                 }
2162         }
2163
2164         // assert HOST ready bit
2165 //  RTMP_IO_WRITE32(pAd, MAC_CSR1, 0x0); // 2004-09-14 asked by Mark
2166 //  RTMP_IO_WRITE32(pAd, MAC_CSR1, 0x4);
2167
2168         // It isn't necessary to clear this space when not hard reset.
2169         if (bHardReset == TRUE)
2170         {
2171                 // clear all on-chip BEACON frame space
2172                 for (apidx = 0; apidx < HW_BEACON_MAX_COUNT; apidx++)
2173                 {
2174                         for (i = 0; i < HW_BEACON_OFFSET>>2; i+=4)
2175                                 RTMP_IO_WRITE32(pAd, pAd->BeaconOffset[apidx] + i, 0x00);
2176                 }
2177         }
2178 #ifdef RT2870
2179         AsicDisableSync(pAd);
2180         // Clear raw counters
2181         RTMP_IO_READ32(pAd, RX_STA_CNT0, &Counter);
2182         RTMP_IO_READ32(pAd, RX_STA_CNT1, &Counter);
2183         RTMP_IO_READ32(pAd, RX_STA_CNT2, &Counter);
2184         RTMP_IO_READ32(pAd, TX_STA_CNT0, &Counter);
2185         RTMP_IO_READ32(pAd, TX_STA_CNT1, &Counter);
2186         RTMP_IO_READ32(pAd, TX_STA_CNT2, &Counter);
2187         // Default PCI clock cycle per ms is different as default setting, which is based on PCI.
2188         RTMP_IO_READ32(pAd, USB_CYC_CFG, &Counter);
2189         Counter&=0xffffff00;
2190         Counter|=0x000001e;
2191         RTMP_IO_WRITE32(pAd, USB_CYC_CFG, Counter);
2192 #endif // RT2870 //
2193
2194 #ifdef CONFIG_STA_SUPPORT
2195         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2196         {
2197                 // for rt2860E and after, init TXOP_CTRL_CFG with 0x583f. This is for extension channel overlapping IOT.
2198                 if ((pAd->MACVersion&0xffff) != 0x0101)
2199                         RTMP_IO_WRITE32(pAd, TXOP_CTRL_CFG, 0x583f);
2200         }
2201 #endif // CONFIG_STA_SUPPORT //
2202
2203         DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitializeAsic\n"));
2204         return NDIS_STATUS_SUCCESS;
2205 }
2206
2207 /*
2208         ========================================================================
2209
2210         Routine Description:
2211                 Reset NIC Asics
2212
2213         Arguments:
2214                 Adapter                                         Pointer to our adapter
2215
2216         Return Value:
2217                 None
2218
2219         IRQL = PASSIVE_LEVEL
2220
2221         Note:
2222                 Reset NIC to initial state AS IS system boot up time.
2223
2224         ========================================================================
2225 */
2226 VOID    NICIssueReset(
2227         IN      PRTMP_ADAPTER   pAd)
2228 {
2229         UINT32  Value = 0;
2230         DBGPRINT(RT_DEBUG_TRACE, ("--> NICIssueReset\n"));
2231
2232         // Abort Tx, prevent ASIC from writing to Host memory
2233         //RTMP_IO_WRITE32(pAd, TX_CNTL_CSR, 0x001f0000);
2234
2235         // Disable Rx, register value supposed will remain after reset
2236         RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
2237         Value &= (0xfffffff3);
2238         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
2239
2240         // Issue reset and clear from reset state
2241         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x03); // 2004-09-17 change from 0x01
2242         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x00);
2243
2244         DBGPRINT(RT_DEBUG_TRACE, ("<-- NICIssueReset\n"));
2245 }
2246
2247 /*
2248         ========================================================================
2249
2250         Routine Description:
2251                 Check ASIC registers and find any reason the system might hang
2252
2253         Arguments:
2254                 Adapter                                         Pointer to our adapter
2255
2256         Return Value:
2257                 None
2258
2259         IRQL = DISPATCH_LEVEL
2260
2261         ========================================================================
2262 */
2263 BOOLEAN NICCheckForHang(
2264         IN      PRTMP_ADAPTER   pAd)
2265 {
2266         return (FALSE);
2267 }
2268
2269 VOID NICUpdateFifoStaCounters(
2270         IN PRTMP_ADAPTER pAd)
2271 {
2272         TX_STA_FIFO_STRUC       StaFifo;
2273         MAC_TABLE_ENTRY         *pEntry;
2274         UCHAR                           i = 0;
2275         UCHAR                   pid = 0, wcid = 0;
2276         CHAR                            reTry;
2277         UCHAR                           succMCS;
2278
2279 #ifdef RALINK_ATE
2280         /* Nothing to do in ATE mode */
2281         if (ATE_ON(pAd))
2282                 return;
2283 #endif // RALINK_ATE //
2284
2285                 do
2286                 {
2287                         RTMP_IO_READ32(pAd, TX_STA_FIFO, &StaFifo.word);
2288
2289                         if (StaFifo.field.bValid == 0)
2290                                 break;
2291
2292                         wcid = (UCHAR)StaFifo.field.wcid;
2293
2294
2295                 /* ignore NoACK and MGMT frame use 0xFF as WCID */
2296                         if ((StaFifo.field.TxAckRequired == 0) || (wcid >= MAX_LEN_OF_MAC_TABLE))
2297                         {
2298                                 i++;
2299                                 continue;
2300                         }
2301
2302                         /* PID store Tx MCS Rate */
2303                         pid = (UCHAR)StaFifo.field.PidType;
2304
2305                         pEntry = &pAd->MacTab.Content[wcid];
2306
2307                         pEntry->DebugFIFOCount++;
2308
2309 #ifdef DOT11_N_SUPPORT
2310                         if (StaFifo.field.TxBF) // 3*3
2311                                 pEntry->TxBFCount++;
2312 #endif // DOT11_N_SUPPORT //
2313
2314 #ifdef UAPSD_AP_SUPPORT
2315                         UAPSD_SP_AUE_Handle(pAd, pEntry, StaFifo.field.TxSuccess);
2316 #endif // UAPSD_AP_SUPPORT //
2317
2318                         if (!StaFifo.field.TxSuccess)
2319                         {
2320                                 pEntry->FIFOCount++;
2321                                 pEntry->OneSecTxFailCount++;
2322
2323                                 if (pEntry->FIFOCount >= 1)
2324                                 {
2325                                         DBGPRINT(RT_DEBUG_TRACE, ("#"));
2326 #if 0
2327                                         SendRefreshBAR(pAd, pEntry);
2328                                         pEntry->NoBADataCountDown = 64;
2329 #else
2330 #ifdef DOT11_N_SUPPORT
2331                                         pEntry->NoBADataCountDown = 64;
2332 #endif // DOT11_N_SUPPORT //
2333
2334                                         if(pEntry->PsMode == PWR_ACTIVE)
2335                                         {
2336 #ifdef DOT11_N_SUPPORT
2337                                                 int tid;
2338                                                 for (tid=0; tid<NUM_OF_TID; tid++)
2339                                                 {
2340                                                         BAOriSessionTearDown(pAd, pEntry->Aid,  tid, FALSE, FALSE);
2341                                                 }
2342 #endif // DOT11_N_SUPPORT //
2343
2344                                                 // Update the continuous transmission counter except PS mode
2345                                                 pEntry->ContinueTxFailCnt++;
2346                                         }
2347                                         else
2348                                         {
2349                                                 // Clear the FIFOCount when sta in Power Save mode. Basically we assume
2350                                                 //     this tx error happened due to sta just go to sleep.
2351                                                 pEntry->FIFOCount = 0;
2352                                                 pEntry->ContinueTxFailCnt = 0;
2353                                         }
2354 #endif
2355                                         //pEntry->FIFOCount = 0;
2356                                 }
2357                                 //pEntry->bSendBAR = TRUE;
2358                         }
2359                         else
2360                         {
2361 #ifdef DOT11_N_SUPPORT
2362                                 if ((pEntry->PsMode != PWR_SAVE) && (pEntry->NoBADataCountDown > 0))
2363                                 {
2364                                         pEntry->NoBADataCountDown--;
2365                                         if (pEntry->NoBADataCountDown==0)
2366                                         {
2367                                                 DBGPRINT(RT_DEBUG_TRACE, ("@\n"));
2368                                         }
2369                                 }
2370 #endif // DOT11_N_SUPPORT //
2371                                 pEntry->FIFOCount = 0;
2372                                 pEntry->OneSecTxNoRetryOkCount++;
2373                                 // update NoDataIdleCount when sucessful send packet to STA.
2374                                 pEntry->NoDataIdleCount = 0;
2375                                 pEntry->ContinueTxFailCnt = 0;
2376                         }
2377
2378                         succMCS = StaFifo.field.SuccessRate & 0x7F;
2379
2380                         reTry = pid - succMCS;
2381
2382                         if (StaFifo.field.TxSuccess)
2383                         {
2384                                 pEntry->TXMCSExpected[pid]++;
2385                                 if (pid == succMCS)
2386                                 {
2387                                         pEntry->TXMCSSuccessful[pid]++;
2388                                 }
2389                                 else
2390                                 {
2391                                         pEntry->TXMCSAutoFallBack[pid][succMCS]++;
2392                                 }
2393                         }
2394                         else
2395                         {
2396                                 pEntry->TXMCSFailed[pid]++;
2397                         }
2398
2399                         if (reTry > 0)
2400                         {
2401                                 if ((pid >= 12) && succMCS <=7)
2402                                 {
2403                                         reTry -= 4;
2404                                 }
2405                                 pEntry->OneSecTxRetryOkCount += reTry;
2406                         }
2407
2408                         i++;
2409                         // ASIC store 16 stack
2410                 } while ( i < (2*TX_RING_SIZE) );
2411
2412 }
2413
2414 /*
2415         ========================================================================
2416
2417         Routine Description:
2418                 Read statistical counters from hardware registers and record them
2419                 in software variables for later on query
2420
2421         Arguments:
2422                 pAd                                     Pointer to our adapter
2423
2424         Return Value:
2425                 None
2426
2427         IRQL = DISPATCH_LEVEL
2428
2429         ========================================================================
2430 */
2431 VOID NICUpdateRawCounters(
2432         IN PRTMP_ADAPTER pAd)
2433 {
2434         UINT32  OldValue;
2435         RX_STA_CNT0_STRUC        RxStaCnt0;
2436         RX_STA_CNT1_STRUC   RxStaCnt1;
2437         RX_STA_CNT2_STRUC   RxStaCnt2;
2438         TX_STA_CNT0_STRUC        TxStaCnt0;
2439         TX_STA_CNT1_STRUC        StaTx1;
2440         TX_STA_CNT2_STRUC        StaTx2;
2441         TX_AGG_CNT_STRUC        TxAggCnt;
2442         TX_AGG_CNT0_STRUC       TxAggCnt0;
2443         TX_AGG_CNT1_STRUC       TxAggCnt1;
2444         TX_AGG_CNT2_STRUC       TxAggCnt2;
2445         TX_AGG_CNT3_STRUC       TxAggCnt3;
2446         TX_AGG_CNT4_STRUC       TxAggCnt4;
2447         TX_AGG_CNT5_STRUC       TxAggCnt5;
2448         TX_AGG_CNT6_STRUC       TxAggCnt6;
2449         TX_AGG_CNT7_STRUC       TxAggCnt7;
2450
2451
2452         RTMP_IO_READ32(pAd, RX_STA_CNT0, &RxStaCnt0.word);
2453         RTMP_IO_READ32(pAd, RX_STA_CNT2, &RxStaCnt2.word);
2454
2455         {
2456                 RTMP_IO_READ32(pAd, RX_STA_CNT1, &RxStaCnt1.word);
2457             // Update RX PLCP error counter
2458             pAd->PrivateInfo.PhyRxErrCnt += RxStaCnt1.field.PlcpErr;
2459                 // Update False CCA counter
2460                 pAd->RalinkCounters.OneSecFalseCCACnt += RxStaCnt1.field.FalseCca;
2461         }
2462
2463         // Update FCS counters
2464         OldValue= pAd->WlanCounters.FCSErrorCount.u.LowPart;
2465         pAd->WlanCounters.FCSErrorCount.u.LowPart += (RxStaCnt0.field.CrcErr); // >> 7);
2466         if (pAd->WlanCounters.FCSErrorCount.u.LowPart < OldValue)
2467                 pAd->WlanCounters.FCSErrorCount.u.HighPart++;
2468
2469         // Add FCS error count to private counters
2470         pAd->RalinkCounters.OneSecRxFcsErrCnt += RxStaCnt0.field.CrcErr;
2471         OldValue = pAd->RalinkCounters.RealFcsErrCount.u.LowPart;
2472         pAd->RalinkCounters.RealFcsErrCount.u.LowPart += RxStaCnt0.field.CrcErr;
2473         if (pAd->RalinkCounters.RealFcsErrCount.u.LowPart < OldValue)
2474                 pAd->RalinkCounters.RealFcsErrCount.u.HighPart++;
2475
2476         // Update Duplicate Rcv check
2477         pAd->RalinkCounters.DuplicateRcv += RxStaCnt2.field.RxDupliCount;
2478         pAd->WlanCounters.FrameDuplicateCount.u.LowPart += RxStaCnt2.field.RxDupliCount;
2479         // Update RX Overflow counter
2480         pAd->Counters8023.RxNoBuffer += (RxStaCnt2.field.RxFifoOverflowCount);
2481
2482         //pAd->RalinkCounters.RxCount = 0;
2483 #ifdef RT2870
2484         if (pAd->RalinkCounters.RxCount != pAd->watchDogRxCnt)
2485         {
2486                 pAd->watchDogRxCnt = pAd->RalinkCounters.RxCount;
2487                 pAd->watchDogRxOverFlowCnt = 0;
2488         }
2489         else
2490         {
2491                 if (RxStaCnt2.field.RxFifoOverflowCount)
2492                         pAd->watchDogRxOverFlowCnt++;
2493                 else
2494                         pAd->watchDogRxOverFlowCnt = 0;
2495         }
2496 #endif // RT2870 //
2497
2498
2499         //if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED) ||
2500         //      (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED) && (pAd->MacTab.Size != 1)))
2501         if (!pAd->bUpdateBcnCntDone)
2502         {
2503         // Update BEACON sent count
2504         RTMP_IO_READ32(pAd, TX_STA_CNT0, &TxStaCnt0.word);
2505         RTMP_IO_READ32(pAd, TX_STA_CNT1, &StaTx1.word);
2506         RTMP_IO_READ32(pAd, TX_STA_CNT2, &StaTx2.word);
2507         pAd->RalinkCounters.OneSecBeaconSentCnt += TxStaCnt0.field.TxBeaconCount;
2508         pAd->RalinkCounters.OneSecTxRetryOkCount += StaTx1.field.TxRetransmit;
2509         pAd->RalinkCounters.OneSecTxNoRetryOkCount += StaTx1.field.TxSuccess;
2510         pAd->RalinkCounters.OneSecTxFailCount += TxStaCnt0.field.TxFailCount;
2511         pAd->WlanCounters.TransmittedFragmentCount.u.LowPart += StaTx1.field.TxSuccess;
2512         pAd->WlanCounters.RetryCount.u.LowPart += StaTx1.field.TxRetransmit;
2513         pAd->WlanCounters.FailedCount.u.LowPart += TxStaCnt0.field.TxFailCount;
2514         }
2515
2516 #if 0
2517         Retry = StaTx1.field.TxRetransmit;
2518         Fail = TxStaCnt0.field.TxFailCount;
2519         TxErrorRatio = 0;
2520         OneSecTransmitCount = pAd->WlanCounters.TransmittedFragmentCount.u.LowPart- pAd->WlanCounters.LastTransmittedFragmentCount.u.LowPart;
2521         if ((OneSecTransmitCount+Retry + Fail) > 0)
2522                 TxErrorRatio = (( Retry + Fail) *100) / (OneSecTransmitCount+Retry + Fail);
2523
2524         if ((OneSecTransmitCount+Retry + Fail) > 0)
2525                 TxErrorRatio = (( Retry + Fail) *100) / (OneSecTransmitCount+Retry + Fail);
2526         DBGPRINT(RT_DEBUG_INFO, ("TX ERROR Rate = %ld %%, Retry = %ld, Fail = %ld, Total = %ld  \n",TxErrorRatio, Retry, Fail, (OneSecTransmitCount+Retry + Fail)));
2527         pAd->WlanCounters.LastTransmittedFragmentCount.u.LowPart = pAd->WlanCounters.TransmittedFragmentCount.u.LowPart;
2528 #endif
2529
2530         //if (pAd->bStaFifoTest == TRUE)
2531         {
2532                 RTMP_IO_READ32(pAd, TX_AGG_CNT, &TxAggCnt.word);
2533                 RTMP_IO_READ32(pAd, TX_AGG_CNT0, &TxAggCnt0.word);
2534                 RTMP_IO_READ32(pAd, TX_AGG_CNT1, &TxAggCnt1.word);
2535                 RTMP_IO_READ32(pAd, TX_AGG_CNT2, &TxAggCnt2.word);
2536                 RTMP_IO_READ32(pAd, TX_AGG_CNT3, &TxAggCnt3.word);
2537                 RTMP_IO_READ32(pAd, TX_AGG_CNT4, &TxAggCnt4.word);
2538                 RTMP_IO_READ32(pAd, TX_AGG_CNT5, &TxAggCnt5.word);
2539                 RTMP_IO_READ32(pAd, TX_AGG_CNT6, &TxAggCnt6.word);
2540                 RTMP_IO_READ32(pAd, TX_AGG_CNT7, &TxAggCnt7.word);
2541                 pAd->RalinkCounters.TxAggCount += TxAggCnt.field.AggTxCount;
2542                 pAd->RalinkCounters.TxNonAggCount += TxAggCnt.field.NonAggTxCount;
2543                 pAd->RalinkCounters.TxAgg1MPDUCount += TxAggCnt0.field.AggSize1Count;
2544                 pAd->RalinkCounters.TxAgg2MPDUCount += TxAggCnt0.field.AggSize2Count;
2545
2546                 pAd->RalinkCounters.TxAgg3MPDUCount += TxAggCnt1.field.AggSize3Count;
2547                 pAd->RalinkCounters.TxAgg4MPDUCount += TxAggCnt1.field.AggSize4Count;
2548                 pAd->RalinkCounters.TxAgg5MPDUCount += TxAggCnt2.field.AggSize5Count;
2549                 pAd->RalinkCounters.TxAgg6MPDUCount += TxAggCnt2.field.AggSize6Count;
2550
2551                 pAd->RalinkCounters.TxAgg7MPDUCount += TxAggCnt3.field.AggSize7Count;
2552                 pAd->RalinkCounters.TxAgg8MPDUCount += TxAggCnt3.field.AggSize8Count;
2553                 pAd->RalinkCounters.TxAgg9MPDUCount += TxAggCnt4.field.AggSize9Count;
2554                 pAd->RalinkCounters.TxAgg10MPDUCount += TxAggCnt4.field.AggSize10Count;
2555
2556                 pAd->RalinkCounters.TxAgg11MPDUCount += TxAggCnt5.field.AggSize11Count;
2557                 pAd->RalinkCounters.TxAgg12MPDUCount += TxAggCnt5.field.AggSize12Count;
2558                 pAd->RalinkCounters.TxAgg13MPDUCount += TxAggCnt6.field.AggSize13Count;
2559                 pAd->RalinkCounters.TxAgg14MPDUCount += TxAggCnt6.field.AggSize14Count;
2560
2561                 pAd->RalinkCounters.TxAgg15MPDUCount += TxAggCnt7.field.AggSize15Count;
2562                 pAd->RalinkCounters.TxAgg16MPDUCount += TxAggCnt7.field.AggSize16Count;
2563
2564                 // Calculate the transmitted A-MPDU count
2565                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += TxAggCnt0.field.AggSize1Count;
2566                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt0.field.AggSize2Count / 2);
2567
2568                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt1.field.AggSize3Count / 3);
2569                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt1.field.AggSize4Count / 4);
2570
2571                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt2.field.AggSize5Count / 5);
2572                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt2.field.AggSize6Count / 6);
2573
2574                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt3.field.AggSize7Count / 7);
2575                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt3.field.AggSize8Count / 8);
2576
2577                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt4.field.AggSize9Count / 9);
2578                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt4.field.AggSize10Count / 10);
2579
2580                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt5.field.AggSize11Count / 11);
2581                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt5.field.AggSize12Count / 12);
2582
2583                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt6.field.AggSize13Count / 13);
2584                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt6.field.AggSize14Count / 14);
2585
2586                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt7.field.AggSize15Count / 15);
2587                 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt7.field.AggSize16Count / 16);
2588         }
2589
2590 #ifdef DBG_DIAGNOSE
2591         {
2592                 RtmpDiagStruct  *pDiag;
2593                 COUNTER_RALINK  *pRalinkCounters;
2594                 UCHAR                   ArrayCurIdx, i;
2595
2596                 pDiag = &pAd->DiagStruct;
2597                 pRalinkCounters = &pAd->RalinkCounters;
2598                 ArrayCurIdx = pDiag->ArrayCurIdx;
2599
2600                 if (pDiag->inited == 0)
2601                 {
2602                         NdisZeroMemory(pDiag, sizeof(struct _RtmpDiagStrcut_));
2603                         pDiag->ArrayStartIdx = pDiag->ArrayCurIdx = 0;
2604                         pDiag->inited = 1;
2605                 }
2606                 else
2607                 {
2608                         // Tx
2609                         pDiag->TxFailCnt[ArrayCurIdx] = TxStaCnt0.field.TxFailCount;
2610                         pDiag->TxAggCnt[ArrayCurIdx] = TxAggCnt.field.AggTxCount;
2611                         pDiag->TxNonAggCnt[ArrayCurIdx] = TxAggCnt.field.NonAggTxCount;
2612                         pDiag->TxAMPDUCnt[ArrayCurIdx][0] = TxAggCnt0.field.AggSize1Count;
2613                         pDiag->TxAMPDUCnt[ArrayCurIdx][1] = TxAggCnt0.field.AggSize2Count;
2614                         pDiag->TxAMPDUCnt[ArrayCurIdx][2] = TxAggCnt1.field.AggSize3Count;
2615                         pDiag->TxAMPDUCnt[ArrayCurIdx][3] = TxAggCnt1.field.AggSize4Count;
2616                         pDiag->TxAMPDUCnt[ArrayCurIdx][4] = TxAggCnt2.field.AggSize5Count;
2617                         pDiag->TxAMPDUCnt[ArrayCurIdx][5] = TxAggCnt2.field.AggSize6Count;
2618                         pDiag->TxAMPDUCnt[ArrayCurIdx][6] = TxAggCnt3.field.AggSize7Count;
2619                         pDiag->TxAMPDUCnt[ArrayCurIdx][7] = TxAggCnt3.field.AggSize8Count;
2620                         pDiag->TxAMPDUCnt[ArrayCurIdx][8] = TxAggCnt4.field.AggSize9Count;
2621                         pDiag->TxAMPDUCnt[ArrayCurIdx][9] = TxAggCnt4.field.AggSize10Count;
2622                         pDiag->TxAMPDUCnt[ArrayCurIdx][10] = TxAggCnt5.field.AggSize11Count;
2623                         pDiag->TxAMPDUCnt[ArrayCurIdx][11] = TxAggCnt5.field.AggSize12Count;
2624                         pDiag->TxAMPDUCnt[ArrayCurIdx][12] = TxAggCnt6.field.AggSize13Count;
2625                         pDiag->TxAMPDUCnt[ArrayCurIdx][13] = TxAggCnt6.field.AggSize14Count;
2626                         pDiag->TxAMPDUCnt[ArrayCurIdx][14] = TxAggCnt7.field.AggSize15Count;
2627                         pDiag->TxAMPDUCnt[ArrayCurIdx][15] = TxAggCnt7.field.AggSize16Count;
2628
2629                         pDiag->RxCrcErrCnt[ArrayCurIdx] = RxStaCnt0.field.CrcErr;
2630
2631                         INC_RING_INDEX(pDiag->ArrayCurIdx,  DIAGNOSE_TIME);
2632                         ArrayCurIdx = pDiag->ArrayCurIdx;
2633                         for (i =0; i < 9; i++)
2634                         {
2635                                 pDiag->TxDescCnt[ArrayCurIdx][i]= 0;
2636                                 pDiag->TxSWQueCnt[ArrayCurIdx][i] =0;
2637                                 pDiag->TxMcsCnt[ArrayCurIdx][i] = 0;
2638                                 pDiag->RxMcsCnt[ArrayCurIdx][i] = 0;
2639                         }
2640                         pDiag->TxDataCnt[ArrayCurIdx] = 0;
2641                         pDiag->TxFailCnt[ArrayCurIdx] = 0;
2642                         pDiag->RxDataCnt[ArrayCurIdx] = 0;
2643                         pDiag->RxCrcErrCnt[ArrayCurIdx]  = 0;
2644 //                      for (i = 9; i < 16; i++)
2645                         for (i = 9; i < 24; i++) // 3*3
2646                         {
2647                                 pDiag->TxDescCnt[ArrayCurIdx][i] = 0;
2648                                 pDiag->TxMcsCnt[ArrayCurIdx][i] = 0;
2649                                 pDiag->RxMcsCnt[ArrayCurIdx][i] = 0;
2650 }
2651
2652                         if (pDiag->ArrayCurIdx == pDiag->ArrayStartIdx)
2653                                 INC_RING_INDEX(pDiag->ArrayStartIdx,  DIAGNOSE_TIME);
2654                 }
2655
2656         }
2657 #endif // DBG_DIAGNOSE //
2658
2659
2660 }
2661
2662
2663 /*
2664         ========================================================================
2665
2666         Routine Description:
2667                 Reset NIC from error
2668
2669         Arguments:
2670                 Adapter                                         Pointer to our adapter
2671
2672         Return Value:
2673                 None
2674
2675         IRQL = PASSIVE_LEVEL
2676
2677         Note:
2678                 Reset NIC from error state
2679
2680         ========================================================================
2681 */
2682 VOID    NICResetFromError(
2683         IN      PRTMP_ADAPTER   pAd)
2684 {
2685         // Reset BBP (according to alex, reset ASIC will force reset BBP
2686         // Therefore, skip the reset BBP
2687         // RTMP_IO_WRITE32(pAd, MAC_CSR1, 0x2);
2688
2689         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x1);
2690         // Remove ASIC from reset state
2691         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x0);
2692
2693         NICInitializeAdapter(pAd, FALSE);
2694         NICInitAsicFromEEPROM(pAd);
2695
2696         // Switch to current channel, since during reset process, the connection should remains on.
2697         AsicSwitchChannel(pAd, pAd->CommonCfg.CentralChannel, FALSE);
2698         AsicLockChannel(pAd, pAd->CommonCfg.CentralChannel);
2699 }
2700
2701 /*
2702         ========================================================================
2703
2704         Routine Description:
2705                 erase 8051 firmware image in MAC ASIC
2706
2707         Arguments:
2708                 Adapter                                         Pointer to our adapter
2709
2710         IRQL = PASSIVE_LEVEL
2711
2712         ========================================================================
2713 */
2714 VOID NICEraseFirmware(
2715         IN PRTMP_ADAPTER pAd)
2716 {
2717         ULONG i;
2718
2719         for(i=0; i<MAX_FIRMWARE_IMAGE_SIZE; i+=4)
2720                 RTMP_IO_WRITE32(pAd, FIRMWARE_IMAGE_BASE + i, 0);
2721
2722 }/* End of NICEraseFirmware */
2723
2724 /*
2725         ========================================================================
2726
2727         Routine Description:
2728                 Load 8051 firmware RT2561.BIN file into MAC ASIC
2729
2730         Arguments:
2731                 Adapter                                         Pointer to our adapter
2732
2733         Return Value:
2734                 NDIS_STATUS_SUCCESS         firmware image load ok
2735                 NDIS_STATUS_FAILURE         image not found
2736
2737         IRQL = PASSIVE_LEVEL
2738
2739         ========================================================================
2740 */
2741 NDIS_STATUS NICLoadFirmware(
2742         IN PRTMP_ADAPTER pAd)
2743 {
2744         NDIS_STATUS             Status = NDIS_STATUS_SUCCESS;
2745         PUCHAR                  pFirmwareImage;
2746         ULONG                   FileLength, Index;
2747         //ULONG                 firm;
2748         UINT32                  MacReg = 0;
2749 #ifdef RT2870
2750         UINT32                  Version = (pAd->MACVersion >> 16);
2751 #endif // RT2870 //
2752
2753         pFirmwareImage = FirmwareImage;
2754         FileLength = sizeof(FirmwareImage);
2755 #ifdef RT2870
2756         // New 8k byte firmware size for RT3071/RT3072
2757         //printk("Usb Chip\n");
2758         if (FIRMWAREIMAGE_LENGTH == FIRMWAREIMAGE_MAX_LENGTH)
2759         //The firmware image consists of two parts. One is the origianl and the other is the new.
2760         //Use Second Part
2761         {
2762                 if ((Version != 0x2860) && (Version != 0x2872) && (Version != 0x3070))
2763                 {       // Use Firmware V2.
2764                         //printk("KH:Use New Version,part2\n");
2765                         pFirmwareImage = (PUCHAR)&FirmwareImage[FIRMWAREIMAGEV1_LENGTH];
2766                         FileLength = FIRMWAREIMAGEV2_LENGTH;
2767                 }
2768                 else
2769                 {
2770                         //printk("KH:Use New Version,part1\n");
2771                         pFirmwareImage = FirmwareImage;
2772                         FileLength = FIRMWAREIMAGEV1_LENGTH;
2773                 }
2774         }
2775         else
2776         {
2777                 DBGPRINT(RT_DEBUG_ERROR, ("KH: bin file should be 8KB.\n"));
2778                 Status = NDIS_STATUS_FAILURE;
2779         }
2780
2781 #endif // RT2870 //
2782
2783 #if 0
2784         /* enable Host program ram write selection */
2785         RT28XX_FIRMUD_INIT(pAd);
2786
2787         for(i=0; i<FileLength; i+=4)
2788         {
2789                 firm = pFirmwareImage[i] +
2790                            (pFirmwareImage[i+3] << 24) +
2791                            (pFirmwareImage[i+2] << 16) +
2792                            (pFirmwareImage[i+1] << 8);
2793
2794                 RTMP_IO_WRITE32(pAd, FIRMWARE_IMAGE_BASE + i, firm);
2795         } /* End of for */
2796
2797         RT28XX_FIRMUD_END(pAd);
2798 #else
2799         RT28XX_WRITE_FIRMWARE(pAd, pFirmwareImage, FileLength);
2800 #endif
2801
2802         /* check if MCU is ready */
2803         Index = 0;
2804         do
2805         {
2806                 RTMP_IO_READ32(pAd, PBF_SYS_CTRL, &MacReg);
2807
2808                 if (MacReg & 0x80)
2809                         break;
2810
2811                 RTMPusecDelay(1000);
2812         } while (Index++ < 1000);
2813
2814     if (Index >= 1000)
2815         {
2816                 Status = NDIS_STATUS_FAILURE;
2817                 DBGPRINT(RT_DEBUG_ERROR, ("NICLoadFirmware: MCU is not ready\n\n\n"));
2818         } /* End of if */
2819
2820 #if 0
2821     DBGPRINT(RT_DEBUG_TRACE,
2822                          ("<=== %s (src=%s, status=%d)\n", __func__, src, Status));
2823 #else
2824     DBGPRINT(RT_DEBUG_TRACE,
2825                          ("<=== %s (status=%d)\n", __func__, Status));
2826 #endif
2827     return Status;
2828 } /* End of NICLoadFirmware */
2829
2830
2831 /*
2832         ========================================================================
2833
2834         Routine Description:
2835                 Load Tx rate switching parameters
2836
2837         Arguments:
2838                 Adapter                                         Pointer to our adapter
2839
2840         Return Value:
2841                 NDIS_STATUS_SUCCESS         firmware image load ok
2842                 NDIS_STATUS_FAILURE         image not found
2843
2844         IRQL = PASSIVE_LEVEL
2845
2846         Rate Table Format:
2847                 1. (B0: Valid Item number) (B1:Initial item from zero)
2848                 2. Item Number(Dec)      Mode(Hex)     Current MCS(Dec)    TrainUp(Dec)    TrainDown(Dec)
2849
2850         ========================================================================
2851 */
2852 NDIS_STATUS NICLoadRateSwitchingParams(
2853         IN PRTMP_ADAPTER pAd)
2854 {
2855 #if 0
2856         NDIS_STATUS Status;
2857
2858         NDIS_HANDLE FileHandle;
2859         UINT FileLength = 0, i, j;
2860         PUCHAR pFirmwareImage;
2861         NDIS_STRING FileName;
2862         NDIS_PHYSICAL_ADDRESS HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
2863
2864         DBGPRINT(RT_DEBUG_TRACE,("===> NICLoadRateSwitchingParams \n"));
2865         pAd->CommonCfg.TxRateTableSize = 0;
2866
2867         if ((pAd->DeviceID == NIC2860_PCI_DEVICE_ID) || (pAd->DeviceID == NIC2860_PCIe_DEVICE_ID))
2868         {
2869                 NdisInitializeString(&FileName,"rate.bin");
2870                 DBGPRINT(RT_DEBUG_TRACE, ("NICLoadRateSwitchingParams: load file - rate.bin for tx rate switch \n"));
2871         }
2872         else
2873         {
2874                 DBGPRINT_ERR(("NICLoadRateSwitchingParams: wrong DeviceID = 0x%04x, can't find Tx rate switch parameters file\n", pAd->DeviceID));
2875                 return NDIS_STATUS_SUCCESS;
2876         }
2877         NdisOpenFile(&Status, &FileHandle, &FileLength, &FileName, HighestAcceptableMax);
2878         NdisFreeString(FileName);
2879
2880         if (Status != NDIS_STATUS_SUCCESS)
2881         {
2882                 DBGPRINT(RT_DEBUG_ERROR, ("NICLoadRateSwitchingParams: NdisOpenFile() failed, used RateSwitchTable instead\n"));
2883                 return NDIS_STATUS_SUCCESS;
2884         }
2885
2886         if ((FileLength == 0) || (FileLength > (MAX_STEP_OF_TX_RATE_SWITCH+1)*16))
2887         {
2888                 DBGPRINT(RT_DEBUG_ERROR, ("NICLoadRateSwitchingParams: file size is not reasonable, used RateSwitchTable instead\n"));
2889
2890                 NdisCloseFile(FileHandle);
2891                 return NDIS_STATUS_SUCCESS;
2892         }
2893         else
2894         {
2895                 //
2896                 // NDIS_STATUS_SUCCESS means
2897                 // The handle at FileHandle is valid for a subsequent call to NdisMapFile.
2898                 //
2899                 NdisMapFile(&Status, &pFirmwareImage, FileHandle);
2900                 DBGPRINT(RT_DEBUG_TRACE, ("NdisMapFile FileLength=%d\n", FileLength));
2901         }
2902
2903         for (i=0, j=0; i<FileLength; i++)
2904         {
2905                 if ((i%16) <= 4)        // trim reserved field
2906                 {
2907                         if (i%16 == 1)  // deal with DEC and HEX, only row0 is Hex, others are Dec
2908                         {
2909                                 RateSwitchTable[j] = *(pFirmwareImage + i);
2910                         }
2911                         else
2912                         {
2913                                 RateSwitchTable[j] = (*(pFirmwareImage + i)>>4) * 10 + (*(pFirmwareImage + i) & 0x0F);
2914                         }
2915
2916                         j++;
2917                 }
2918         }
2919
2920         pAd->CommonCfg.TxRateTableSize = RateSwitchTable[0];            // backup table size
2921
2922         if (Status == NDIS_STATUS_SUCCESS)
2923         {
2924                 NdisUnmapFile(FileHandle);
2925                 NdisCloseFile(FileHandle);
2926         }
2927
2928         DBGPRINT(RT_DEBUG_TRACE,("<=== NICLoadRateSwitchingParams(Valid TxRateTable item number=%d)\n", pAd->CommonCfg.TxRateTableSize));
2929 #endif
2930         return NDIS_STATUS_SUCCESS;
2931 }
2932
2933 /*
2934         ========================================================================
2935
2936         Routine Description:
2937                 if  pSrc1 all zero with length Length, return 0.
2938                 If not all zero, return 1
2939
2940         Arguments:
2941                 pSrc1
2942
2943         Return Value:
2944                 1:                      not all zero
2945                 0:                      all zero
2946
2947         IRQL = DISPATCH_LEVEL
2948
2949         Note:
2950
2951         ========================================================================
2952 */
2953 ULONG   RTMPNotAllZero(
2954         IN      PVOID   pSrc1,
2955         IN      ULONG   Length)
2956 {
2957         PUCHAR  pMem1;
2958         ULONG   Index = 0;
2959
2960         pMem1 = (PUCHAR) pSrc1;
2961
2962         for (Index = 0; Index < Length; Index++)
2963         {
2964                 if (pMem1[Index] != 0x0)
2965                 {
2966                         break;
2967                 }
2968         }
2969
2970         if (Index == Length)
2971         {
2972                 return (0);
2973         }
2974         else
2975         {
2976                 return (1);
2977         }
2978 }
2979
2980 /*
2981         ========================================================================
2982
2983         Routine Description:
2984                 Compare two memory block
2985
2986         Arguments:
2987                 pSrc1           Pointer to first memory address
2988                 pSrc2           Pointer to second memory address
2989
2990         Return Value:
2991                 0:                      memory is equal
2992                 1:                      pSrc1 memory is larger
2993                 2:                      pSrc2 memory is larger
2994
2995         IRQL = DISPATCH_LEVEL
2996
2997         Note:
2998
2999         ========================================================================
3000 */
3001 ULONG   RTMPCompareMemory(
3002         IN      PVOID   pSrc1,
3003         IN      PVOID   pSrc2,
3004         IN      ULONG   Length)
3005 {
3006         PUCHAR  pMem1;
3007         PUCHAR  pMem2;
3008         ULONG   Index = 0;
3009
3010         pMem1 = (PUCHAR) pSrc1;
3011         pMem2 = (PUCHAR) pSrc2;
3012
3013         for (Index = 0; Index < Length; Index++)
3014         {
3015                 if (pMem1[Index] > pMem2[Index])
3016                         return (1);
3017                 else if (pMem1[Index] < pMem2[Index])
3018                         return (2);
3019         }
3020
3021         // Equal
3022         return (0);
3023 }
3024
3025 /*
3026         ========================================================================
3027
3028         Routine Description:
3029                 Zero out memory block
3030
3031         Arguments:
3032                 pSrc1           Pointer to memory address
3033                 Length          Size
3034
3035         Return Value:
3036                 None
3037
3038         IRQL = PASSIVE_LEVEL
3039         IRQL = DISPATCH_LEVEL
3040
3041         Note:
3042
3043         ========================================================================
3044 */
3045 VOID    RTMPZeroMemory(
3046         IN      PVOID   pSrc,
3047         IN      ULONG   Length)
3048 {
3049         PUCHAR  pMem;
3050         ULONG   Index = 0;
3051
3052         pMem = (PUCHAR) pSrc;
3053
3054         for (Index = 0; Index < Length; Index++)
3055         {
3056                 pMem[Index] = 0x00;
3057         }
3058 }
3059
3060 VOID    RTMPFillMemory(
3061         IN      PVOID   pSrc,
3062         IN      ULONG   Length,
3063         IN      UCHAR   Fill)
3064 {
3065         PUCHAR  pMem;
3066         ULONG   Index = 0;
3067
3068         pMem = (PUCHAR) pSrc;
3069
3070         for (Index = 0; Index < Length; Index++)
3071         {
3072                 pMem[Index] = Fill;
3073         }
3074 }
3075
3076 /*
3077         ========================================================================
3078
3079         Routine Description:
3080                 Copy data from memory block 1 to memory block 2
3081
3082         Arguments:
3083                 pDest           Pointer to destination memory address
3084                 pSrc            Pointer to source memory address
3085                 Length          Copy size
3086
3087         Return Value:
3088                 None
3089
3090         IRQL = PASSIVE_LEVEL
3091         IRQL = DISPATCH_LEVEL
3092
3093         Note:
3094
3095         ========================================================================
3096 */
3097 VOID    RTMPMoveMemory(
3098         OUT     PVOID   pDest,
3099         IN      PVOID   pSrc,
3100         IN      ULONG   Length)
3101 {
3102         PUCHAR  pMem1;
3103         PUCHAR  pMem2;
3104         UINT    Index;
3105
3106         ASSERT((Length==0) || (pDest && pSrc));
3107
3108         pMem1 = (PUCHAR) pDest;
3109         pMem2 = (PUCHAR) pSrc;
3110
3111         for (Index = 0; Index < Length; Index++)
3112         {
3113                 pMem1[Index] = pMem2[Index];
3114         }
3115 }
3116
3117 /*
3118         ========================================================================
3119
3120         Routine Description:
3121                 Initialize port configuration structure
3122
3123         Arguments:
3124                 Adapter                                         Pointer to our adapter
3125
3126         Return Value:
3127                 None
3128
3129         IRQL = PASSIVE_LEVEL
3130
3131         Note:
3132
3133         ========================================================================
3134 */
3135 VOID    UserCfgInit(
3136         IN      PRTMP_ADAPTER pAd)
3137 {
3138 //      EDCA_PARM DefaultEdcaParm;
3139     UINT key_index, bss_index;
3140
3141         DBGPRINT(RT_DEBUG_TRACE, ("--> UserCfgInit\n"));
3142
3143         //
3144         //  part I. intialize common configuration
3145         //
3146 #ifdef RT2870
3147         pAd->BulkOutReq = 0;
3148
3149         pAd->BulkOutComplete = 0;
3150         pAd->BulkOutCompleteOther = 0;
3151         pAd->BulkOutCompleteCancel = 0;
3152         pAd->BulkInReq = 0;
3153         pAd->BulkInComplete = 0;
3154         pAd->BulkInCompleteFail = 0;
3155
3156         //pAd->QuickTimerP = 100;
3157         //pAd->TurnAggrBulkInCount = 0;
3158         pAd->bUsbTxBulkAggre = 0;
3159
3160         // init as unsed value to ensure driver will set to MCU once.
3161         pAd->LedIndicatorStregth = 0xFF;
3162
3163         pAd->CommonCfg.MaxPktOneTxBulk = 2;
3164         pAd->CommonCfg.TxBulkFactor = 1;
3165         pAd->CommonCfg.RxBulkFactor =1;
3166
3167         pAd->CommonCfg.TxPower = 100; //mW
3168
3169         NdisZeroMemory(&pAd->CommonCfg.IOTestParm, sizeof(pAd->CommonCfg.IOTestParm));
3170 #endif // RT2870 //
3171
3172         for(key_index=0; key_index<SHARE_KEY_NUM; key_index++)
3173         {
3174                 for(bss_index = 0; bss_index < MAX_MBSSID_NUM; bss_index++)
3175                 {
3176                         pAd->SharedKey[bss_index][key_index].KeyLen = 0;
3177                         pAd->SharedKey[bss_index][key_index].CipherAlg = CIPHER_NONE;
3178                 }
3179         }
3180
3181         pAd->Antenna.word = 0;
3182         pAd->CommonCfg.BBPCurrentBW = BW_20;
3183
3184         pAd->LedCntl.word = 0;
3185
3186         pAd->bAutoTxAgcA = FALSE;                       // Default is OFF
3187         pAd->bAutoTxAgcG = FALSE;                       // Default is OFF
3188         pAd->RfIcType = RFIC_2820;
3189
3190         // Init timer for reset complete event
3191         pAd->CommonCfg.CentralChannel = 1;
3192         pAd->bForcePrintTX = FALSE;
3193         pAd->bForcePrintRX = FALSE;
3194         pAd->bStaFifoTest = FALSE;
3195         pAd->bProtectionTest = FALSE;
3196         pAd->bHCCATest = FALSE;
3197         pAd->bGenOneHCCA = FALSE;
3198         pAd->CommonCfg.Dsifs = 10;      // in units of usec
3199         pAd->CommonCfg.TxPower = 100; //mW
3200         pAd->CommonCfg.TxPowerPercentage = 0xffffffff; // AUTO
3201         pAd->CommonCfg.TxPowerDefault = 0xffffffff; // AUTO
3202         pAd->CommonCfg.TxPreamble = Rt802_11PreambleAuto; // use Long preamble on TX by defaut
3203         pAd->CommonCfg.bUseZeroToDisableFragment = FALSE;
3204         pAd->CommonCfg.RtsThreshold = 2347;
3205         pAd->CommonCfg.FragmentThreshold = 2346;
3206         pAd->CommonCfg.UseBGProtection = 0;    // 0: AUTO
3207         pAd->CommonCfg.bEnableTxBurst = TRUE; //0;
3208         pAd->CommonCfg.PhyMode = 0xff;     // unknown
3209         pAd->CommonCfg.BandState = UNKNOWN_BAND;
3210         pAd->CommonCfg.RadarDetect.CSPeriod = 10;
3211         pAd->CommonCfg.RadarDetect.CSCount = 0;
3212         pAd->CommonCfg.RadarDetect.RDMode = RD_NORMAL_MODE;
3213         pAd->CommonCfg.RadarDetect.ChMovingTime = 65;
3214         pAd->CommonCfg.RadarDetect.LongPulseRadarTh = 3;
3215         pAd->CommonCfg.bAPSDCapable = FALSE;
3216         pAd->CommonCfg.bNeedSendTriggerFrame = FALSE;
3217         pAd->CommonCfg.TriggerTimerCount = 0;
3218         pAd->CommonCfg.bAPSDForcePowerSave = FALSE;
3219         pAd->CommonCfg.bCountryFlag = FALSE;
3220         pAd->CommonCfg.TxStream = 0;
3221         pAd->CommonCfg.RxStream = 0;
3222
3223         NdisZeroMemory(&pAd->BeaconTxWI, sizeof(pAd->BeaconTxWI));
3224
3225 #ifdef DOT11_N_SUPPORT
3226         NdisZeroMemory(&pAd->CommonCfg.HtCapability, sizeof(pAd->CommonCfg.HtCapability));
3227         pAd->HTCEnable = FALSE;
3228         pAd->bBroadComHT = FALSE;
3229         pAd->CommonCfg.bRdg = FALSE;
3230
3231 #ifdef DOT11N_DRAFT3
3232         pAd->CommonCfg.Dot11OBssScanPassiveDwell = dot11OBSSScanPassiveDwell;   // Unit : TU. 5~1000
3233         pAd->CommonCfg.Dot11OBssScanActiveDwell = dot11OBSSScanActiveDwell;     // Unit : TU. 10~1000
3234         pAd->CommonCfg.Dot11BssWidthTriggerScanInt = dot11BSSWidthTriggerScanInterval;  // Unit : Second
3235         pAd->CommonCfg.Dot11OBssScanPassiveTotalPerChannel = dot11OBSSScanPassiveTotalPerChannel;       // Unit : TU. 200~10000
3236         pAd->CommonCfg.Dot11OBssScanActiveTotalPerChannel = dot11OBSSScanActiveTotalPerChannel; // Unit : TU. 20~10000
3237         pAd->CommonCfg.Dot11BssWidthChanTranDelayFactor = dot11BSSWidthChannelTransactionDelayFactor;
3238         pAd->CommonCfg.Dot11OBssScanActivityThre = dot11BSSScanActivityThreshold;       // Unit : percentage
3239         pAd->CommonCfg.Dot11BssWidthChanTranDelay = (pAd->CommonCfg.Dot11BssWidthTriggerScanInt * pAd->CommonCfg.Dot11BssWidthChanTranDelayFactor);
3240 #endif  // DOT11N_DRAFT3 //
3241
3242         NdisZeroMemory(&pAd->CommonCfg.AddHTInfo, sizeof(pAd->CommonCfg.AddHTInfo));
3243         pAd->CommonCfg.BACapability.field.MMPSmode = MMPS_ENABLE;
3244         pAd->CommonCfg.BACapability.field.MpduDensity = 0;
3245         pAd->CommonCfg.BACapability.field.Policy = IMMED_BA;
3246         pAd->CommonCfg.BACapability.field.RxBAWinLimit = 64; //32;
3247         pAd->CommonCfg.BACapability.field.TxBAWinLimit = 64; //32;
3248         DBGPRINT(RT_DEBUG_TRACE, ("--> UserCfgInit. BACapability = 0x%x\n", pAd->CommonCfg.BACapability.word));
3249
3250         pAd->CommonCfg.BACapability.field.AutoBA = FALSE;
3251         BATableInit(pAd, &pAd->BATable);
3252
3253         pAd->CommonCfg.bExtChannelSwitchAnnouncement = 1;
3254         pAd->CommonCfg.bHTProtect = 1;
3255         pAd->CommonCfg.bMIMOPSEnable = TRUE;
3256         pAd->CommonCfg.bBADecline = FALSE;
3257         pAd->CommonCfg.bDisableReordering = FALSE;
3258
3259         pAd->CommonCfg.TxBASize = 7;
3260
3261         pAd->CommonCfg.REGBACapability.word = pAd->CommonCfg.BACapability.word;
3262 #endif // DOT11_N_SUPPORT //
3263
3264         //pAd->CommonCfg.HTPhyMode.field.BW = BW_20;
3265         //pAd->CommonCfg.HTPhyMode.field.MCS = MCS_AUTO;
3266         //pAd->CommonCfg.HTPhyMode.field.ShortGI = GI_800;
3267         //pAd->CommonCfg.HTPhyMode.field.STBC = STBC_NONE;
3268         pAd->CommonCfg.TxRate = RATE_6;
3269
3270         pAd->CommonCfg.MlmeTransmit.field.MCS = MCS_RATE_6;
3271         pAd->CommonCfg.MlmeTransmit.field.BW = BW_20;
3272         pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3273
3274         pAd->CommonCfg.BeaconPeriod = 100;     // in mSec
3275
3276         //
3277         // part II. intialize STA specific configuration
3278         //
3279 #ifdef CONFIG_STA_SUPPORT
3280         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
3281         {
3282                 RX_FILTER_SET_FLAG(pAd, fRX_FILTER_ACCEPT_DIRECT);
3283                 RX_FILTER_CLEAR_FLAG(pAd, fRX_FILTER_ACCEPT_MULTICAST);
3284                 RX_FILTER_SET_FLAG(pAd, fRX_FILTER_ACCEPT_BROADCAST);
3285                 RX_FILTER_SET_FLAG(pAd, fRX_FILTER_ACCEPT_ALL_MULTICAST);
3286
3287                 pAd->StaCfg.Psm = PWR_ACTIVE;
3288
3289                 pAd->StaCfg.OrigWepStatus = Ndis802_11EncryptionDisabled;
3290                 pAd->StaCfg.PairCipher = Ndis802_11EncryptionDisabled;
3291                 pAd->StaCfg.GroupCipher = Ndis802_11EncryptionDisabled;
3292                 pAd->StaCfg.bMixCipher = FALSE;
3293                 pAd->StaCfg.DefaultKeyId = 0;
3294
3295                 // 802.1x port control
3296                 pAd->StaCfg.PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
3297                 pAd->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
3298                 pAd->StaCfg.LastMicErrorTime = 0;
3299                 pAd->StaCfg.MicErrCnt        = 0;
3300                 pAd->StaCfg.bBlockAssoc      = FALSE;
3301                 pAd->StaCfg.WpaState         = SS_NOTUSE;
3302
3303                 pAd->CommonCfg.NdisRadioStateOff = FALSE;               // New to support microsoft disable radio with OID command
3304
3305                 pAd->StaCfg.RssiTrigger = 0;
3306                 NdisZeroMemory(&pAd->StaCfg.RssiSample, sizeof(RSSI_SAMPLE));
3307                 pAd->StaCfg.RssiTriggerMode = RSSI_TRIGGERED_UPON_BELOW_THRESHOLD;
3308                 pAd->StaCfg.AtimWin = 0;
3309                 pAd->StaCfg.DefaultListenCount = 3;//default listen count;
3310                 pAd->StaCfg.BssType = BSS_INFRA;  // BSS_INFRA or BSS_ADHOC or BSS_MONITOR
3311                 pAd->StaCfg.bScanReqIsFromWebUI = FALSE;
3312                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_DOZE);
3313                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_WAKEUP_NOW);
3314
3315                 pAd->StaCfg.bAutoTxRateSwitch = TRUE;
3316                 pAd->StaCfg.DesiredTransmitSetting.field.MCS = MCS_AUTO;
3317         }
3318
3319 #ifdef EXT_BUILD_CHANNEL_LIST
3320         pAd->StaCfg.IEEE80211dClientMode = Rt802_11_D_None;
3321 #endif // EXT_BUILD_CHANNEL_LIST //
3322 #endif // CONFIG_STA_SUPPORT //
3323
3324         // global variables mXXXX used in MAC protocol state machines
3325         OPSTATUS_SET_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM);
3326         OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_ADHOC_ON);
3327         OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_INFRA_ON);
3328
3329         // PHY specification
3330         pAd->CommonCfg.PhyMode = PHY_11BG_MIXED;                // default PHY mode
3331         OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);  // CCK use LONG preamble
3332
3333 #ifdef CONFIG_STA_SUPPORT
3334         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
3335         {
3336                 // user desired power mode
3337                 pAd->StaCfg.WindowsPowerMode = Ndis802_11PowerModeCAM;
3338                 pAd->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeCAM;
3339                 pAd->StaCfg.bWindowsACCAMEnable = FALSE;
3340
3341 #ifdef LEAP_SUPPORT
3342                 // CCX v1.0 releated init value
3343                 RTMPInitTimer(pAd, &pAd->StaCfg.LeapAuthTimer, GET_TIMER_FUNCTION(LeapAuthTimeout), pAd, FALSE);
3344                 pAd->StaCfg.LeapAuthMode = CISCO_AuthModeLEAPNone;
3345                 pAd->StaCfg.bCkipOn = FALSE;
3346 #endif // LEAP_SUPPORT //
3347
3348                 RTMPInitTimer(pAd, &pAd->StaCfg.StaQuickResponeForRateUpTimer, GET_TIMER_FUNCTION(StaQuickResponeForRateUpExec), pAd, FALSE);
3349                 pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = FALSE;
3350
3351                 // Patch for Ndtest
3352                 pAd->StaCfg.ScanCnt = 0;
3353
3354                 // CCX 2.0 control flag init
3355                 pAd->StaCfg.CCXEnable = FALSE;
3356                 pAd->StaCfg.CCXReqType = MSRN_TYPE_UNUSED;
3357                 pAd->StaCfg.CCXQosECWMin        = 4;
3358                 pAd->StaCfg.CCXQosECWMax        = 10;
3359
3360                 pAd->StaCfg.bHwRadio  = TRUE; // Default Hardware Radio status is On
3361                 pAd->StaCfg.bSwRadio  = TRUE; // Default Software Radio status is On
3362                 pAd->StaCfg.bRadio    = TRUE; // bHwRadio && bSwRadio
3363                 pAd->StaCfg.bHardwareRadio = FALSE;             // Default is OFF
3364                 pAd->StaCfg.bShowHiddenSSID = FALSE;            // Default no show
3365
3366                 // Nitro mode control
3367                 pAd->StaCfg.bAutoReconnect = TRUE;
3368
3369                 // Save the init time as last scan time, the system should do scan after 2 seconds.
3370                 // This patch is for driver wake up from standby mode, system will do scan right away.
3371                 pAd->StaCfg.LastScanTime = 0;
3372                 NdisZeroMemory(pAd->nickname, IW_ESSID_MAX_SIZE+1);
3373                 sprintf(pAd->nickname, "%s", STA_NIC_DEVICE_NAME);
3374                 RTMPInitTimer(pAd, &pAd->StaCfg.WpaDisassocAndBlockAssocTimer, GET_TIMER_FUNCTION(WpaDisassocApAndBlockAssoc), pAd, FALSE);
3375 #ifdef WPA_SUPPLICANT_SUPPORT
3376                 pAd->StaCfg.IEEE8021X = FALSE;
3377                 pAd->StaCfg.IEEE8021x_required_keys = FALSE;
3378                 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_DISABLE;
3379 #ifdef NATIVE_WPA_SUPPLICANT_SUPPORT
3380                 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_ENABLE;
3381 #endif // NATIVE_WPA_SUPPLICANT_SUPPORT //
3382 #endif // WPA_SUPPLICANT_SUPPORT //
3383
3384         }
3385 #endif // CONFIG_STA_SUPPORT //
3386
3387         // Default for extra information is not valid
3388         pAd->ExtraInfo = EXTRA_INFO_CLEAR;
3389
3390         // Default Config change flag
3391         pAd->bConfigChanged = FALSE;
3392
3393         //
3394         // part III. AP configurations
3395         //
3396
3397
3398         //
3399         // part IV. others
3400         //
3401         // dynamic BBP R66:sensibity tuning to overcome background noise
3402         pAd->BbpTuning.bEnable                = TRUE;
3403         pAd->BbpTuning.FalseCcaLowerThreshold = 100;
3404         pAd->BbpTuning.FalseCcaUpperThreshold = 512;
3405         pAd->BbpTuning.R66Delta               = 4;
3406         pAd->Mlme.bEnableAutoAntennaCheck = TRUE;
3407
3408         //
3409         // Also initial R66CurrentValue, RTUSBResumeMsduTransmission might use this value.
3410         // if not initial this value, the default value will be 0.
3411         //
3412         pAd->BbpTuning.R66CurrentValue = 0x38;
3413
3414         pAd->Bbp94 = BBPR94_DEFAULT;
3415         pAd->BbpForCCK = FALSE;
3416
3417         // Default is FALSE for test bit 1
3418         //pAd->bTest1 = FALSE;
3419
3420         // initialize MAC table and allocate spin lock
3421         NdisZeroMemory(&pAd->MacTab, sizeof(MAC_TABLE));
3422         InitializeQueueHeader(&pAd->MacTab.McastPsQueue);
3423         NdisAllocateSpinLock(&pAd->MacTabLock);
3424
3425         //RTMPInitTimer(pAd, &pAd->RECBATimer, RECBATimerTimeout, pAd, TRUE);
3426         //RTMPSetTimer(&pAd->RECBATimer, REORDER_EXEC_INTV);
3427
3428 #ifdef RALINK_ATE
3429         NdisZeroMemory(&pAd->ate, sizeof(ATE_INFO));
3430         pAd->ate.Mode = ATE_STOP;
3431         pAd->ate.TxCount = 200;/* to exceed TX_RING_SIZE ... */
3432         pAd->ate.TxLength = 1024;
3433         pAd->ate.TxWI.ShortGI = 0;// LONG GI : 800 ns
3434         pAd->ate.TxWI.PHYMODE = MODE_CCK;
3435         pAd->ate.TxWI.MCS = 3;
3436         pAd->ate.TxWI.BW = BW_20;
3437         pAd->ate.Channel = 1;
3438         pAd->ate.QID = QID_AC_BE;
3439         pAd->ate.Addr1[0] = 0x00;
3440         pAd->ate.Addr1[1] = 0x11;
3441         pAd->ate.Addr1[2] = 0x22;
3442         pAd->ate.Addr1[3] = 0xAA;
3443         pAd->ate.Addr1[4] = 0xBB;
3444         pAd->ate.Addr1[5] = 0xCC;
3445         NdisMoveMemory(pAd->ate.Addr2, pAd->ate.Addr1, ETH_LENGTH_OF_ADDRESS);
3446         NdisMoveMemory(pAd->ate.Addr3, pAd->ate.Addr1, ETH_LENGTH_OF_ADDRESS);
3447         pAd->ate.bRxFer = 0;
3448         pAd->ate.bQATxStart = FALSE;
3449         pAd->ate.bQARxStart = FALSE;
3450 #ifdef RALINK_28xx_QA
3451         //pAd->ate.Repeat = 0;
3452         pAd->ate.TxStatus = 0;
3453         pAd->ate.AtePid = NULL;
3454 #endif // RALINK_28xx_QA //
3455 #endif // RALINK_ATE //
3456
3457
3458         pAd->CommonCfg.bWiFiTest = FALSE;
3459
3460
3461         DBGPRINT(RT_DEBUG_TRACE, ("<-- UserCfgInit\n"));
3462 }
3463
3464 // IRQL = PASSIVE_LEVEL
3465 UCHAR BtoH(char ch)
3466 {
3467         if (ch >= '0' && ch <= '9') return (ch - '0');        // Handle numerals
3468         if (ch >= 'A' && ch <= 'F') return (ch - 'A' + 0xA);  // Handle capitol hex digits
3469         if (ch >= 'a' && ch <= 'f') return (ch - 'a' + 0xA);  // Handle small hex digits
3470         return(255);
3471 }
3472
3473 //
3474 //  FUNCTION: AtoH(char *, UCHAR *, int)
3475 //
3476 //  PURPOSE:  Converts ascii string to network order hex
3477 //
3478 //  PARAMETERS:
3479 //    src    - pointer to input ascii string
3480 //    dest   - pointer to output hex
3481 //    destlen - size of dest
3482 //
3483 //  COMMENTS:
3484 //
3485 //    2 ascii bytes make a hex byte so must put 1st ascii byte of pair
3486 //    into upper nibble and 2nd ascii byte of pair into lower nibble.
3487 //
3488 // IRQL = PASSIVE_LEVEL
3489
3490 void AtoH(char * src, UCHAR * dest, int destlen)
3491 {
3492         char * srcptr;
3493         PUCHAR destTemp;
3494
3495         srcptr = src;
3496         destTemp = (PUCHAR) dest;
3497
3498         while(destlen--)
3499         {
3500                 *destTemp = BtoH(*srcptr++) << 4;    // Put 1st ascii byte in upper nibble.
3501                 *destTemp += BtoH(*srcptr++);      // Add 2nd ascii byte to above.
3502                 destTemp++;
3503         }
3504 }
3505
3506 VOID    RTMPPatchMacBbpBug(
3507         IN      PRTMP_ADAPTER   pAd)
3508 {
3509         ULONG   Index;
3510
3511         // Initialize BBP register to default value
3512         for (Index = 0; Index < NUM_BBP_REG_PARMS; Index++)
3513         {
3514                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBPRegTable[Index].Register, (UCHAR)BBPRegTable[Index].Value);
3515         }
3516
3517         // Initialize RF register to default value
3518         AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
3519         AsicLockChannel(pAd, pAd->CommonCfg.Channel);
3520
3521         // Re-init BBP register from EEPROM value
3522         NICInitAsicFromEEPROM(pAd);
3523 }
3524
3525 /*
3526         ========================================================================
3527
3528         Routine Description:
3529                 Init timer objects
3530
3531         Arguments:
3532                 pAd                     Pointer to our adapter
3533                 pTimer                          Timer structure
3534                 pTimerFunc                      Function to execute when timer expired
3535                 Repeat                          Ture for period timer
3536
3537         Return Value:
3538                 None
3539
3540         Note:
3541
3542         ========================================================================
3543 */
3544 VOID    RTMPInitTimer(
3545         IN      PRTMP_ADAPTER                   pAd,
3546         IN      PRALINK_TIMER_STRUCT    pTimer,
3547         IN      PVOID                                   pTimerFunc,
3548         IN      PVOID                                   pData,
3549         IN      BOOLEAN                                 Repeat)
3550 {
3551         //
3552         // Set Valid to TRUE for later used.
3553         // It will crash if we cancel a timer or set a timer
3554         // that we haven't initialize before.
3555         //
3556         pTimer->Valid      = TRUE;
3557
3558         pTimer->PeriodicType = Repeat;
3559         pTimer->State      = FALSE;
3560         pTimer->cookie = (ULONG) pData;
3561
3562 #ifdef RT2870
3563         pTimer->pAd = pAd;
3564 #endif // RT2870 //
3565
3566         RTMP_OS_Init_Timer(pAd, &pTimer->TimerObj,      pTimerFunc, (PVOID) pTimer);
3567 }
3568
3569 /*
3570         ========================================================================
3571
3572         Routine Description:
3573                 Init timer objects
3574
3575         Arguments:
3576                 pTimer                          Timer structure
3577                 Value                           Timer value in milliseconds
3578
3579         Return Value:
3580                 None
3581
3582         Note:
3583                 To use this routine, must call RTMPInitTimer before.
3584
3585         ========================================================================
3586 */
3587 VOID    RTMPSetTimer(
3588         IN      PRALINK_TIMER_STRUCT    pTimer,
3589         IN      ULONG                                   Value)
3590 {
3591         if (pTimer->Valid)
3592         {
3593                 pTimer->TimerValue = Value;
3594                 pTimer->State      = FALSE;
3595                 if (pTimer->PeriodicType == TRUE)
3596                 {
3597                         pTimer->Repeat = TRUE;
3598                         RTMP_SetPeriodicTimer(&pTimer->TimerObj, Value);
3599                 }
3600                 else
3601                 {
3602                         pTimer->Repeat = FALSE;
3603                         RTMP_OS_Add_Timer(&pTimer->TimerObj, Value);
3604                 }
3605         }
3606         else
3607         {
3608                 DBGPRINT_ERR(("RTMPSetTimer failed, Timer hasn't been initialize!\n"));
3609         }
3610 }
3611
3612
3613 /*
3614         ========================================================================
3615
3616         Routine Description:
3617                 Init timer objects
3618
3619         Arguments:
3620                 pTimer                          Timer structure
3621                 Value                           Timer value in milliseconds
3622
3623         Return Value:
3624                 None
3625
3626         Note:
3627                 To use this routine, must call RTMPInitTimer before.
3628
3629         ========================================================================
3630 */
3631 VOID    RTMPModTimer(
3632         IN      PRALINK_TIMER_STRUCT    pTimer,
3633         IN      ULONG                                   Value)
3634 {
3635         BOOLEAN Cancel;
3636
3637         if (pTimer->Valid)
3638         {
3639                 pTimer->TimerValue = Value;
3640                 pTimer->State      = FALSE;
3641                 if (pTimer->PeriodicType == TRUE)
3642                 {
3643                         RTMPCancelTimer(pTimer, &Cancel);
3644                         RTMPSetTimer(pTimer, Value);
3645                 }
3646                 else
3647                 {
3648                         RTMP_OS_Mod_Timer(&pTimer->TimerObj, Value);
3649                 }
3650         }
3651         else
3652         {
3653                 DBGPRINT_ERR(("RTMPModTimer failed, Timer hasn't been initialize!\n"));
3654         }
3655 }
3656
3657 /*
3658         ========================================================================
3659
3660         Routine Description:
3661                 Cancel timer objects
3662
3663         Arguments:
3664                 Adapter                                         Pointer to our adapter
3665
3666         Return Value:
3667                 None
3668
3669         IRQL = PASSIVE_LEVEL
3670         IRQL = DISPATCH_LEVEL
3671
3672         Note:
3673                 1.) To use this routine, must call RTMPInitTimer before.
3674                 2.) Reset NIC to initial state AS IS system boot up time.
3675
3676         ========================================================================
3677 */
3678 VOID    RTMPCancelTimer(
3679         IN      PRALINK_TIMER_STRUCT    pTimer,
3680         OUT     BOOLEAN                                 *pCancelled)
3681 {
3682         if (pTimer->Valid)
3683         {
3684                 if (pTimer->State == FALSE)
3685                         pTimer->Repeat = FALSE;
3686                         RTMP_OS_Del_Timer(&pTimer->TimerObj, pCancelled);
3687
3688                 if (*pCancelled == TRUE)
3689                         pTimer->State = TRUE;
3690
3691 #ifdef RT2870
3692                 // We need to go-through the TimerQ to findout this timer handler and remove it if
3693                 //              it's still waiting for execution.
3694
3695                 RT2870_TimerQ_Remove(pTimer->pAd, pTimer);
3696 #endif // RT2870 //
3697         }
3698         else
3699         {
3700                 //
3701                 // NdisMCancelTimer just canced the timer and not mean release the timer.
3702                 // And don't set the "Valid" to False. So that we can use this timer again.
3703                 //
3704                 DBGPRINT_ERR(("RTMPCancelTimer failed, Timer hasn't been initialize!\n"));
3705         }
3706 }
3707
3708 /*
3709         ========================================================================
3710
3711         Routine Description:
3712                 Set LED Status
3713
3714         Arguments:
3715                 pAd                                             Pointer to our adapter
3716                 Status                                  LED Status
3717
3718         Return Value:
3719                 None
3720
3721         IRQL = PASSIVE_LEVEL
3722         IRQL = DISPATCH_LEVEL
3723
3724         Note:
3725
3726         ========================================================================
3727 */
3728 VOID RTMPSetLED(
3729         IN PRTMP_ADAPTER        pAd,
3730         IN UCHAR                        Status)
3731 {
3732         //ULONG                 data;
3733         UCHAR                   HighByte = 0;
3734         UCHAR                   LowByte;
3735
3736 // In ATE mode of RT2860 AP/STA, we have erased 8051 firmware.
3737 // So LED mode is not supported when ATE is running.
3738 #ifdef RALINK_ATE
3739         if (ATE_ON(pAd))
3740                 return;
3741 #endif // RALINK_ATE //
3742
3743         LowByte = pAd->LedCntl.field.LedMode&0x7f;
3744         switch (Status)
3745         {
3746                 case LED_LINK_DOWN:
3747                         HighByte = 0x20;
3748                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3749                         pAd->LedIndicatorStregth = 0;
3750                         break;
3751                 case LED_LINK_UP:
3752                         if (pAd->CommonCfg.Channel > 14)
3753                                 HighByte = 0xa0;
3754                         else
3755                                 HighByte = 0x60;
3756                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3757                         break;
3758                 case LED_RADIO_ON:
3759                         HighByte = 0x20;
3760                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3761                         break;
3762                 case LED_HALT:
3763                         LowByte = 0; // Driver sets MAC register and MAC controls LED
3764                 case LED_RADIO_OFF:
3765                         HighByte = 0;
3766                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3767                         break;
3768         case LED_WPS:
3769                         HighByte = 0x10;
3770                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3771                         break;
3772                 case LED_ON_SITE_SURVEY:
3773                         HighByte = 0x08;
3774                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3775                         break;
3776                 case LED_POWER_UP:
3777                         HighByte = 0x04;
3778                         AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3779                         break;
3780                 default:
3781                         DBGPRINT(RT_DEBUG_WARN, ("RTMPSetLED::Unknown Status %d\n", Status));
3782                         break;
3783         }
3784
3785     //
3786         // Keep LED status for LED SiteSurvey mode.
3787         // After SiteSurvey, we will set the LED mode to previous status.
3788         //
3789         if ((Status != LED_ON_SITE_SURVEY) && (Status != LED_POWER_UP))
3790                 pAd->LedStatus = Status;
3791
3792         DBGPRINT(RT_DEBUG_TRACE, ("RTMPSetLED::Mode=%d,HighByte=0x%02x,LowByte=0x%02x\n", pAd->LedCntl.field.LedMode, HighByte, LowByte));
3793 }
3794
3795 /*
3796         ========================================================================
3797
3798         Routine Description:
3799                 Set LED Signal Stregth
3800
3801         Arguments:
3802                 pAd                                             Pointer to our adapter
3803                 Dbm                                             Signal Stregth
3804
3805         Return Value:
3806                 None
3807
3808         IRQL = PASSIVE_LEVEL
3809
3810         Note:
3811                 Can be run on any IRQL level.
3812
3813                 According to Microsoft Zero Config Wireless Signal Stregth definition as belows.
3814                 <= -90  No Signal
3815                 <= -81  Very Low
3816                 <= -71  Low
3817                 <= -67  Good
3818                 <= -57  Very Good
3819                  > -57  Excellent
3820         ========================================================================
3821 */
3822 VOID RTMPSetSignalLED(
3823         IN PRTMP_ADAPTER        pAd,
3824         IN NDIS_802_11_RSSI Dbm)
3825 {
3826         UCHAR           nLed = 0;
3827
3828         //
3829         // if not Signal Stregth, then do nothing.
3830         //
3831         if (pAd->LedCntl.field.LedMode != LED_MODE_SIGNAL_STREGTH)
3832         {
3833                 return;
3834         }
3835
3836         if (Dbm <= -90)
3837                 nLed = 0;
3838         else if (Dbm <= -81)
3839                 nLed = 1;
3840         else if (Dbm <= -71)
3841                 nLed = 3;
3842         else if (Dbm <= -67)
3843                 nLed = 7;
3844         else if (Dbm <= -57)
3845                 nLed = 15;
3846         else
3847                 nLed = 31;
3848
3849         //
3850         // Update Signal Stregth to firmware if changed.
3851         //
3852         if (pAd->LedIndicatorStregth != nLed)
3853         {
3854                 AsicSendCommandToMcu(pAd, 0x51, 0xff, nLed, pAd->LedCntl.field.Polarity);
3855                 pAd->LedIndicatorStregth = nLed;
3856         }
3857 }
3858
3859 /*
3860         ========================================================================
3861
3862         Routine Description:
3863                 Enable RX
3864
3865         Arguments:
3866                 pAd                                             Pointer to our adapter
3867
3868         Return Value:
3869                 None
3870
3871         IRQL <= DISPATCH_LEVEL
3872
3873         Note:
3874                 Before Enable RX, make sure you have enabled Interrupt.
3875         ========================================================================
3876 */
3877 VOID RTMPEnableRxTx(
3878         IN PRTMP_ADAPTER        pAd)
3879 {
3880 //      WPDMA_GLO_CFG_STRUC     GloCfg;
3881 //      ULONG   i = 0;
3882
3883         DBGPRINT(RT_DEBUG_TRACE, ("==> RTMPEnableRxTx\n"));
3884
3885 #if 0
3886         // Enable Rx DMA.
3887         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x4);
3888         do
3889         {
3890                 RTMP_IO_READ32(pAd, WPDMA_GLO_CFG, &GloCfg.word);
3891                 if ((GloCfg.field.TxDMABusy == 0)  && (GloCfg.field.RxDMABusy == 0))
3892                         break;
3893
3894                 DBGPRINT(RT_DEBUG_TRACE, ("==>  DMABusy\n"));
3895                 RTMPusecDelay(1000);
3896                 i++;
3897         }while ( i <200);
3898
3899         RTMPusecDelay(50);
3900         RT28XX_DMA_WRITE_INIT(GloCfg);
3901         DBGPRINT(RT_DEBUG_TRACE, ("<== WRITE DMA offset 0x208 = 0x%x\n", GloCfg.word));
3902         RTMP_IO_WRITE32(pAd, WPDMA_GLO_CFG, GloCfg.word);
3903
3904         RT28XX_DMA_POST_WRITE(pAd);
3905 #else
3906         // Enable Rx DMA.
3907         RT28XXDMAEnable(pAd);
3908 #endif
3909
3910         // enable RX of MAC block
3911         if (pAd->OpMode == OPMODE_AP)
3912         {
3913                 UINT32 rx_filter_flag = APNORMAL;
3914
3915
3916                 RTMP_IO_WRITE32(pAd, RX_FILTR_CFG, rx_filter_flag);     // enable RX of DMA block
3917         }
3918         else
3919         {
3920                 RTMP_IO_WRITE32(pAd, RX_FILTR_CFG, STANORMAL);     // Staion not drop control frame will fail WiFi Certification.
3921         }
3922
3923         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0xc);
3924         DBGPRINT(RT_DEBUG_TRACE, ("<== RTMPEnableRxTx\n"));
3925 }
3926
3927