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