git.oblomov.eu Git - linux-2.6/blob - drivers/staging/rt2870/common/mlme.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         mlme.c
  29
  30         Abstract:
  31
  32         Revision History:
  33         Who                     When                    What
  34         --------        ----------              ----------------------------------------------
  35         John Chang      2004-08-25              Modify from RT2500 code base
  36         John Chang      2004-09-06              modified for RT2600
  37 */
  38
  39 #include "../rt_config.h"
  40 #include <stdarg.h>
  41
  42 UCHAR   CISCO_OUI[] = {0x00, 0x40, 0x96};
  43
  44 UCHAR   WPA_OUI[] = {0x00, 0x50, 0xf2, 0x01};
  45 UCHAR   RSN_OUI[] = {0x00, 0x0f, 0xac};
  46 UCHAR   WAPI_OUI[] = {0x00, 0x14, 0x72};
  47 UCHAR   WME_INFO_ELEM[]  = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01};
  48 UCHAR   WME_PARM_ELEM[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
  49 UCHAR   Ccx2QosInfo[] = {0x00, 0x40, 0x96, 0x04};
  50 UCHAR   RALINK_OUI[]  = {0x00, 0x0c, 0x43};
  51 UCHAR   BROADCOM_OUI[]  = {0x00, 0x90, 0x4c};
  52 UCHAR   WPS_OUI[] = {0x00, 0x50, 0xf2, 0x04};
  53 #ifdef CONFIG_STA_SUPPORT
  54 #ifdef DOT11_N_SUPPORT
  55 UCHAR   PRE_N_HT_OUI[]  = {0x00, 0x90, 0x4c};
  56 #endif // DOT11_N_SUPPORT //
  57 #endif // CONFIG_STA_SUPPORT //
  58
  59 UCHAR RateSwitchTable[] = {
  60 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
  61     0x11, 0x00,  0,  0,  0,                                             // Initial used item after association
  62     0x00, 0x00,  0, 40, 101,
  63     0x01, 0x00,  1, 40, 50,
  64     0x02, 0x00,  2, 35, 45,
  65     0x03, 0x00,  3, 20, 45,
  66     0x04, 0x21,  0, 30, 50,
  67     0x05, 0x21,  1, 20, 50,
  68     0x06, 0x21,  2, 20, 50,
  69     0x07, 0x21,  3, 15, 50,
  70     0x08, 0x21,  4, 15, 30,
  71     0x09, 0x21,  5, 10, 25,
  72     0x0a, 0x21,  6,  8, 25,
  73     0x0b, 0x21,  7,  8, 25,
  74     0x0c, 0x20, 12,  15, 30,
  75     0x0d, 0x20, 13,  8, 20,
  76     0x0e, 0x20, 14,  8, 20,
  77     0x0f, 0x20, 15,  8, 25,
  78     0x10, 0x22, 15,  8, 25,
  79     0x11, 0x00,  0,  0,  0,
  80     0x12, 0x00,  0,  0,  0,
  81     0x13, 0x00,  0,  0,  0,
  82     0x14, 0x00,  0,  0,  0,
  83     0x15, 0x00,  0,  0,  0,
  84     0x16, 0x00,  0,  0,  0,
  85     0x17, 0x00,  0,  0,  0,
  86     0x18, 0x00,  0,  0,  0,
  87     0x19, 0x00,  0,  0,  0,
  88     0x1a, 0x00,  0,  0,  0,
  89     0x1b, 0x00,  0,  0,  0,
  90     0x1c, 0x00,  0,  0,  0,
  91     0x1d, 0x00,  0,  0,  0,
  92     0x1e, 0x00,  0,  0,  0,
  93     0x1f, 0x00,  0,  0,  0,
  94 };
  95
  96 UCHAR RateSwitchTable11B[] = {
  97 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
  98     0x04, 0x03,  0,  0,  0,                                             // Initial used item after association
  99     0x00, 0x00,  0, 40, 101,
 100     0x01, 0x00,  1, 40, 50,
 101     0x02, 0x00,  2, 35, 45,
 102     0x03, 0x00,  3, 20, 45,
 103 };
 104
 105 UCHAR RateSwitchTable11BG[] = {
 106 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 107     0x0a, 0x00,  0,  0,  0,                                             // Initial used item after association
 108     0x00, 0x00,  0, 40, 101,
 109     0x01, 0x00,  1, 40, 50,
 110     0x02, 0x00,  2, 35, 45,
 111     0x03, 0x00,  3, 20, 45,
 112     0x04, 0x10,  2, 20, 35,
 113     0x05, 0x10,  3, 16, 35,
 114     0x06, 0x10,  4, 10, 25,
 115     0x07, 0x10,  5, 16, 25,
 116     0x08, 0x10,  6, 10, 25,
 117     0x09, 0x10,  7, 10, 13,
 118 };
 119
 120 UCHAR RateSwitchTable11G[] = {
 121 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 122     0x08, 0x00,  0,  0,  0,                                             // Initial used item after association
 123     0x00, 0x10,  0, 20, 101,
 124     0x01, 0x10,  1, 20, 35,
 125     0x02, 0x10,  2, 20, 35,
 126     0x03, 0x10,  3, 16, 35,
 127     0x04, 0x10,  4, 10, 25,
 128     0x05, 0x10,  5, 16, 25,
 129     0x06, 0x10,  6, 10, 25,
 130     0x07, 0x10,  7, 10, 13,
 131 };
 132
 133 #ifdef DOT11_N_SUPPORT
 134 UCHAR RateSwitchTable11N1S[] = {
 135 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 136     0x09, 0x00,  0,  0,  0,                                             // Initial used item after association
 137     0x00, 0x21,  0, 30, 101,
 138     0x01, 0x21,  1, 20, 50,
 139     0x02, 0x21,  2, 20, 50,
 140     0x03, 0x21,  3, 15, 50,
 141     0x04, 0x21,  4, 15, 30,
 142     0x05, 0x21,  5, 10, 25,
 143     0x06, 0x21,  6,  8, 14,
 144     0x07, 0x21,  7,  8, 14,
 145     0x08, 0x23,  7,  8, 14,
 146 };
 147
 148 UCHAR RateSwitchTable11N2S[] = {
 149 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 150     0x0a, 0x00,  0,  0,  0,      // Initial used item after association
 151     0x00, 0x21,  0, 30, 101,
 152     0x01, 0x21,  1, 20, 50,
 153     0x02, 0x21,  2, 20, 50,
 154     0x03, 0x21,  3, 15, 50,
 155     0x04, 0x21,  4, 15, 30,
 156     0x05, 0x20, 12,  15, 30,
 157     0x06, 0x20, 13,  8, 20,
 158     0x07, 0x20, 14,  8, 20,
 159     0x08, 0x20, 15,  8, 25,
 160     0x09, 0x22, 15,  8, 25,
 161 };
 162
 163 UCHAR RateSwitchTable11N3S[] = {
 164 // Item No.     Mode    Curr-MCS        TrainUp TrainDown       // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 165     0x0a, 0x00,  0,  0,  0,      // Initial used item after association
 166     0x00, 0x21,  0, 30, 101,
 167     0x01, 0x21,  1, 20, 50,
 168     0x02, 0x21,  2, 20, 50,
 169     0x03, 0x21,  3, 15, 50,
 170     0x04, 0x21,  4, 15, 30,
 171     0x05, 0x20, 12,  15, 30,
 172     0x06, 0x20, 13,  8, 20,
 173     0x07, 0x20, 14,  8, 20,
 174     0x08, 0x20, 15,  8, 25,
 175     0x09, 0x22, 15,  8, 25,
 176 };
 177
 178 UCHAR RateSwitchTable11N2SForABand[] = {
 179 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 180     0x0b, 0x09,  0,  0,  0,                                             // Initial used item after association
 181     0x00, 0x21,  0, 30, 101,
 182     0x01, 0x21,  1, 20, 50,
 183     0x02, 0x21,  2, 20, 50,
 184     0x03, 0x21,  3, 15, 50,
 185     0x04, 0x21,  4, 15, 30,
 186     0x05, 0x21,  5, 15, 30,
 187     0x06, 0x20, 12,  15, 30,
 188     0x07, 0x20, 13,  8, 20,
 189     0x08, 0x20, 14,  8, 20,
 190     0x09, 0x20, 15,  8, 25,
 191     0x0a, 0x22, 15,  8, 25,
 192 };
 193
 194 UCHAR RateSwitchTable11N3SForABand[] = { // 3*3
 195 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 196     0x0b, 0x09,  0,  0,  0,                                             // Initial used item after association
 197     0x00, 0x21,  0, 30, 101,
 198     0x01, 0x21,  1, 20, 50,
 199     0x02, 0x21,  2, 20, 50,
 200     0x03, 0x21,  3, 15, 50,
 201     0x04, 0x21,  4, 15, 30,
 202     0x05, 0x21,  5, 15, 30,
 203     0x06, 0x20, 12,  15, 30,
 204     0x07, 0x20, 13,  8, 20,
 205     0x08, 0x20, 14,  8, 20,
 206     0x09, 0x20, 15,  8, 25,
 207     0x0a, 0x22, 15,  8, 25,
 208 };
 209
 210 UCHAR RateSwitchTable11BGN1S[] = {
 211 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 212     0x0d, 0x00,  0,  0,  0,                                             // Initial used item after association
 213     0x00, 0x00,  0, 40, 101,
 214     0x01, 0x00,  1, 40, 50,
 215     0x02, 0x00,  2, 35, 45,
 216     0x03, 0x00,  3, 20, 45,
 217     0x04, 0x21,  0, 30,101,     //50
 218     0x05, 0x21,  1, 20, 50,
 219     0x06, 0x21,  2, 20, 50,
 220     0x07, 0x21,  3, 15, 50,
 221     0x08, 0x21,  4, 15, 30,
 222     0x09, 0x21,  5, 10, 25,
 223     0x0a, 0x21,  6,  8, 14,
 224     0x0b, 0x21,  7,  8, 14,
 225         0x0c, 0x23,  7,  8, 14,
 226 };
 227
 228 UCHAR RateSwitchTable11BGN2S[] = {
 229 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 230     0x0a, 0x00,  0,  0,  0,                                             // Initial used item after association
 231     0x00, 0x21,  0, 30,101,     //50
 232     0x01, 0x21,  1, 20, 50,
 233     0x02, 0x21,  2, 20, 50,
 234     0x03, 0x21,  3, 15, 50,
 235     0x04, 0x21,  4, 15, 30,
 236     0x05, 0x20, 12, 15, 30,
 237     0x06, 0x20, 13,  8, 20,
 238     0x07, 0x20, 14,  8, 20,
 239     0x08, 0x20, 15,  8, 25,
 240     0x09, 0x22, 15,  8, 25,
 241 };
 242
 243 UCHAR RateSwitchTable11BGN3S[] = { // 3*3
 244 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 245     0x0a, 0x00,  0,  0,  0,                                             // Initial used item after association
 246     0x00, 0x21,  0, 30,101,     //50
 247     0x01, 0x21,  1, 20, 50,
 248     0x02, 0x21,  2, 20, 50,
 249     0x03, 0x21,  3, 20, 50,
 250     0x04, 0x21,  4, 15, 50,
 251 #if 1
 252     0x05, 0x20, 20, 15, 30,
 253     0x06, 0x20, 21,  8, 20,
 254     0x07, 0x20, 22,  8, 20,
 255     0x08, 0x20, 23,  8, 25,
 256     0x09, 0x22, 23,  8, 25,
 257 #else // for RT2860 2*3 test
 258     0x05, 0x20, 12, 15, 30,
 259     0x06, 0x20, 13,  8, 20,
 260     0x07, 0x20, 14,  8, 20,
 261     0x08, 0x20, 15,  8, 25,
 262     0x09, 0x22, 15,  8, 25,
 263 #endif
 264 };
 265
 266 UCHAR RateSwitchTable11BGN2SForABand[] = {
 267 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 268     0x0b, 0x09,  0,  0,  0,                                             // Initial used item after association
 269     0x00, 0x21,  0, 30,101,     //50
 270     0x01, 0x21,  1, 20, 50,
 271     0x02, 0x21,  2, 20, 50,
 272     0x03, 0x21,  3, 15, 50,
 273     0x04, 0x21,  4, 15, 30,
 274     0x05, 0x21,  5, 15, 30,
 275     0x06, 0x20, 12, 15, 30,
 276     0x07, 0x20, 13,  8, 20,
 277     0x08, 0x20, 14,  8, 20,
 278     0x09, 0x20, 15,  8, 25,
 279     0x0a, 0x22, 15,  8, 25,
 280 };
 281
 282 UCHAR RateSwitchTable11BGN3SForABand[] = { // 3*3
 283 // Item No.   Mode   Curr-MCS   TrainUp   TrainDown             // Mode- Bit0: STBC, Bit1: Short GI, Bit4,5: Mode(0:CCK, 1:OFDM, 2:HT Mix, 3:HT GF)
 284     0x0c, 0x09,  0,  0,  0,                                             // Initial used item after association
 285     0x00, 0x21,  0, 30,101,     //50
 286     0x01, 0x21,  1, 20, 50,
 287     0x02, 0x21,  2, 20, 50,
 288     0x03, 0x21,  3, 15, 50,
 289     0x04, 0x21,  4, 15, 30,
 290     0x05, 0x21,  5, 15, 30,
 291     0x06, 0x21, 12, 15, 30,
 292     0x07, 0x20, 20, 15, 30,
 293     0x08, 0x20, 21,  8, 20,
 294     0x09, 0x20, 22,  8, 20,
 295     0x0a, 0x20, 23,  8, 25,
 296     0x0b, 0x22, 23,  8, 25,
 297 };
 298 #endif // DOT11_N_SUPPORT //
 299
 300 PUCHAR ReasonString[] = {
 301         /* 0  */         "Reserved",
 302         /* 1  */         "Unspecified Reason",
 303         /* 2  */         "Previous Auth no longer valid",
 304         /* 3  */         "STA is leaving / has left",
 305         /* 4  */         "DIS-ASSOC due to inactivity",
 306         /* 5  */         "AP unable to hanle all associations",
 307         /* 6  */         "class 2 error",
 308         /* 7  */         "class 3 error",
 309         /* 8  */         "STA is leaving / has left",
 310         /* 9  */         "require auth before assoc/re-assoc",
 311         /* 10 */         "Reserved",
 312         /* 11 */         "Reserved",
 313         /* 12 */         "Reserved",
 314         /* 13 */         "invalid IE",
 315         /* 14 */         "MIC error",
 316         /* 15 */         "4-way handshake timeout",
 317         /* 16 */         "2-way (group key) handshake timeout",
 318         /* 17 */         "4-way handshake IE diff among AssosReq/Rsp/Beacon",
 319         /* 18 */
 320 };
 321
 322 extern UCHAR     OfdmRateToRxwiMCS[];
 323 // since RT61 has better RX sensibility, we have to limit TX ACK rate not to exceed our normal data TX rate.
 324 // otherwise the WLAN peer may not be able to receive the ACK thus downgrade its data TX rate
 325 ULONG BasicRateMask[12]                         = {0xfffff001 /* 1-Mbps */, 0xfffff003 /* 2 Mbps */, 0xfffff007 /* 5.5 */, 0xfffff00f /* 11 */,
 326                                                                           0xfffff01f /* 6 */     , 0xfffff03f /* 9 */     , 0xfffff07f /* 12 */ , 0xfffff0ff /* 18 */,
 327                                                                           0xfffff1ff /* 24 */    , 0xfffff3ff /* 36 */    , 0xfffff7ff /* 48 */ , 0xffffffff /* 54 */};
 328
 329 UCHAR MULTICAST_ADDR[MAC_ADDR_LEN] = {0x1,  0x00, 0x00, 0x00, 0x00, 0x00};
 330 UCHAR BROADCAST_ADDR[MAC_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 331 UCHAR ZERO_MAC_ADDR[MAC_ADDR_LEN]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 332
 333 // e.g. RssiSafeLevelForTxRate[RATE_36]" means if the current RSSI is greater than
 334 //              this value, then it's quaranteed capable of operating in 36 mbps TX rate in
 335 //              clean environment.
 336 //                                                                TxRate: 1   2   5.5   11       6        9    12       18       24   36   48   54       72  100
 337 CHAR RssiSafeLevelForTxRate[] ={  -92, -91, -90, -87, -88, -86, -85, -83, -81, -78, -72, -71, -40, -40 };
 338
 339 UCHAR  RateIdToMbps[]    = { 1, 2, 5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 72, 100};
 340 USHORT RateIdTo500Kbps[] = { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108, 144, 200};
 341
 342 UCHAR  SsidIe    = IE_SSID;
 343 UCHAR  SupRateIe = IE_SUPP_RATES;
 344 UCHAR  ExtRateIe = IE_EXT_SUPP_RATES;
 345 #ifdef DOT11_N_SUPPORT
 346 UCHAR  HtCapIe = IE_HT_CAP;
 347 UCHAR  AddHtInfoIe = IE_ADD_HT;
 348 UCHAR  NewExtChanIe = IE_SECONDARY_CH_OFFSET;
 349 #endif // DOT11_N_SUPPORT //
 350 UCHAR  ErpIe     = IE_ERP;
 351 UCHAR  DsIe      = IE_DS_PARM;
 352 UCHAR  TimIe     = IE_TIM;
 353 UCHAR  WpaIe     = IE_WPA;
 354 UCHAR  Wpa2Ie    = IE_WPA2;
 355 UCHAR  IbssIe    = IE_IBSS_PARM;
 356 UCHAR  Ccx2Ie    = IE_CCX_V2;
 357 UCHAR  WapiIe    = IE_WAPI;
 358
 359 extern UCHAR    WPA_OUI[];
 360
 361 UCHAR   SES_OUI[] = {0x00, 0x90, 0x4c};
 362
 363 UCHAR   ZeroSsid[32] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 364         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 365
 366 // Reset the RFIC setting to new series
 367 RTMP_RF_REGS RF2850RegTable[] = {
 368 //              ch       R1              R2              R3(TX0~4=0) R4
 369                 {1,  0x98402ecc, 0x984c0786, 0x9816b455, 0x9800510b},
 370                 {2,  0x98402ecc, 0x984c0786, 0x98168a55, 0x9800519f},
 371                 {3,  0x98402ecc, 0x984c078a, 0x98168a55, 0x9800518b},
 372                 {4,  0x98402ecc, 0x984c078a, 0x98168a55, 0x9800519f},
 373                 {5,  0x98402ecc, 0x984c078e, 0x98168a55, 0x9800518b},
 374                 {6,  0x98402ecc, 0x984c078e, 0x98168a55, 0x9800519f},
 375                 {7,  0x98402ecc, 0x984c0792, 0x98168a55, 0x9800518b},
 376                 {8,  0x98402ecc, 0x984c0792, 0x98168a55, 0x9800519f},
 377                 {9,  0x98402ecc, 0x984c0796, 0x98168a55, 0x9800518b},
 378                 {10, 0x98402ecc, 0x984c0796, 0x98168a55, 0x9800519f},
 379                 {11, 0x98402ecc, 0x984c079a, 0x98168a55, 0x9800518b},
 380                 {12, 0x98402ecc, 0x984c079a, 0x98168a55, 0x9800519f},
 381                 {13, 0x98402ecc, 0x984c079e, 0x98168a55, 0x9800518b},
 382                 {14, 0x98402ecc, 0x984c07a2, 0x98168a55, 0x98005193},
 383
 384                 // 802.11 UNI / HyperLan 2
 385                 {36, 0x98402ecc, 0x984c099a, 0x98158a55, 0x980ed1a3},
 386                 {38, 0x98402ecc, 0x984c099e, 0x98158a55, 0x980ed193},
 387                 {40, 0x98402ec8, 0x984c0682, 0x98158a55, 0x980ed183},
 388                 {44, 0x98402ec8, 0x984c0682, 0x98158a55, 0x980ed1a3},
 389                 {46, 0x98402ec8, 0x984c0686, 0x98158a55, 0x980ed18b},
 390                 {48, 0x98402ec8, 0x984c0686, 0x98158a55, 0x980ed19b},
 391                 {52, 0x98402ec8, 0x984c068a, 0x98158a55, 0x980ed193},
 392                 {54, 0x98402ec8, 0x984c068a, 0x98158a55, 0x980ed1a3},
 393                 {56, 0x98402ec8, 0x984c068e, 0x98158a55, 0x980ed18b},
 394                 {60, 0x98402ec8, 0x984c0692, 0x98158a55, 0x980ed183},
 395                 {62, 0x98402ec8, 0x984c0692, 0x98158a55, 0x980ed193},
 396                 {64, 0x98402ec8, 0x984c0692, 0x98158a55, 0x980ed1a3}, // Plugfest#4, Day4, change RFR3 left4th 9->5.
 397
 398                 // 802.11 HyperLan 2
 399                 {100, 0x98402ec8, 0x984c06b2, 0x98178a55, 0x980ed783},
 400
 401                 // 2008.04.30 modified
 402                 // The system team has AN to improve the EVM value
 403                 // for channel 102 to 108 for the RT2850/RT2750 dual band solution.
 404                 {102, 0x98402ec8, 0x985c06b2, 0x98578a55, 0x980ed793},
 405                 {104, 0x98402ec8, 0x985c06b2, 0x98578a55, 0x980ed1a3},
 406                 {108, 0x98402ecc, 0x985c0a32, 0x98578a55, 0x980ed193},
 407
 408                 {110, 0x98402ecc, 0x984c0a36, 0x98178a55, 0x980ed183},
 409                 {112, 0x98402ecc, 0x984c0a36, 0x98178a55, 0x980ed19b},
 410                 {116, 0x98402ecc, 0x984c0a3a, 0x98178a55, 0x980ed1a3},
 411                 {118, 0x98402ecc, 0x984c0a3e, 0x98178a55, 0x980ed193},
 412                 {120, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed183},
 413                 {124, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed193},
 414                 {126, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed15b}, // 0x980ed1bb->0x980ed15b required by Rory 20070927
 415                 {128, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed1a3},
 416                 {132, 0x98402ec4, 0x984c0386, 0x98178a55, 0x980ed18b},
 417                 {134, 0x98402ec4, 0x984c0386, 0x98178a55, 0x980ed193},
 418                 {136, 0x98402ec4, 0x984c0386, 0x98178a55, 0x980ed19b},
 419                 {140, 0x98402ec4, 0x984c038a, 0x98178a55, 0x980ed183},
 420
 421                 // 802.11 UNII
 422                 {149, 0x98402ec4, 0x984c038a, 0x98178a55, 0x980ed1a7},
 423                 {151, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed187},
 424                 {153, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed18f},
 425                 {157, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed19f},
 426                 {159, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed1a7},
 427                 {161, 0x98402ec4, 0x984c0392, 0x98178a55, 0x980ed187},
 428                 {165, 0x98402ec4, 0x984c0392, 0x98178a55, 0x980ed197},
 429
 430                 // Japan
 431                 {184, 0x95002ccc, 0x9500491e, 0x9509be55, 0x950c0a0b},
 432                 {188, 0x95002ccc, 0x95004922, 0x9509be55, 0x950c0a13},
 433                 {192, 0x95002ccc, 0x95004926, 0x9509be55, 0x950c0a1b},
 434                 {196, 0x95002ccc, 0x9500492a, 0x9509be55, 0x950c0a23},
 435                 {208, 0x95002ccc, 0x9500493a, 0x9509be55, 0x950c0a13},
 436                 {212, 0x95002ccc, 0x9500493e, 0x9509be55, 0x950c0a1b},
 437                 {216, 0x95002ccc, 0x95004982, 0x9509be55, 0x950c0a23},
 438
 439                 // still lack of MMAC(Japan) ch 34,38,42,46
 440 };
 441 UCHAR   NUM_OF_2850_CHNL = (sizeof(RF2850RegTable) / sizeof(RTMP_RF_REGS));
 442
 443 FREQUENCY_ITEM FreqItems3020[] =
 444 {
 445         /**************************************************/
 446         // ISM : 2.4 to 2.483 GHz                         //
 447         /**************************************************/
 448         // 11g
 449         /**************************************************/
 450         //-CH---N-------R---K-----------
 451         {1,    241,  2,  2},
 452         {2,    241,      2,  7},
 453         {3,    242,      2,  2},
 454         {4,    242,      2,  7},
 455         {5,    243,      2,  2},
 456         {6,    243,      2,  7},
 457         {7,    244,      2,  2},
 458         {8,    244,      2,  7},
 459         {9,    245,      2,  2},
 460         {10,   245,      2,  7},
 461         {11,   246,      2,  2},
 462         {12,   246,      2,  7},
 463         {13,   247,      2,  2},
 464         {14,   248,      2,  4},
 465 };
 466 #define NUM_OF_3020_CHNL        (sizeof(FreqItems3020) / sizeof(FREQUENCY_ITEM))
 467
 468 /*
 469         ==========================================================================
 470         Description:
 471                 initialize the MLME task and its data structure (queue, spinlock,
 472                 timer, state machines).
 473
 474         IRQL = PASSIVE_LEVEL
 475
 476         Return:
 477                 always return NDIS_STATUS_SUCCESS
 478
 479         ==========================================================================
 480 */
 481 NDIS_STATUS MlmeInit(
 482         IN PRTMP_ADAPTER pAd)
 483 {
 484         NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
 485
 486         DBGPRINT(RT_DEBUG_TRACE, ("--> MLME Initialize\n"));
 487
 488         do
 489         {
 490                 Status = MlmeQueueInit(&pAd->Mlme.Queue);
 491                 if(Status != NDIS_STATUS_SUCCESS)
 492                         break;
 493
 494                 pAd->Mlme.bRunning = FALSE;
 495                 NdisAllocateSpinLock(&pAd->Mlme.TaskLock);
 496
 497 #ifdef CONFIG_STA_SUPPORT
 498                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 499                 {
 500                         BssTableInit(&pAd->ScanTab);
 501
 502                         // init STA state machines
 503                         AssocStateMachineInit(pAd, &pAd->Mlme.AssocMachine, pAd->Mlme.AssocFunc);
 504                         AuthStateMachineInit(pAd, &pAd->Mlme.AuthMachine, pAd->Mlme.AuthFunc);
 505                         AuthRspStateMachineInit(pAd, &pAd->Mlme.AuthRspMachine, pAd->Mlme.AuthRspFunc);
 506                         SyncStateMachineInit(pAd, &pAd->Mlme.SyncMachine, pAd->Mlme.SyncFunc);
 507                         WpaPskStateMachineInit(pAd, &pAd->Mlme.WpaPskMachine, pAd->Mlme.WpaPskFunc);
 508                         AironetStateMachineInit(pAd, &pAd->Mlme.AironetMachine, pAd->Mlme.AironetFunc);
 509
 510                         // Since we are using switch/case to implement it, the init is different from the above
 511                         // state machine init
 512                         MlmeCntlInit(pAd, &pAd->Mlme.CntlMachine, NULL);
 513                 }
 514 #endif // CONFIG_STA_SUPPORT //
 515
 516
 517
 518                 ActionStateMachineInit(pAd, &pAd->Mlme.ActMachine, pAd->Mlme.ActFunc);
 519
 520                 // Init mlme periodic timer
 521                 RTMPInitTimer(pAd, &pAd->Mlme.PeriodicTimer, GET_TIMER_FUNCTION(MlmePeriodicExec), pAd, TRUE);
 522
 523                 // Set mlme periodic timer
 524                 RTMPSetTimer(&pAd->Mlme.PeriodicTimer, MLME_TASK_EXEC_INTV);
 525
 526                 // software-based RX Antenna diversity
 527                 RTMPInitTimer(pAd, &pAd->Mlme.RxAntEvalTimer, GET_TIMER_FUNCTION(AsicRxAntEvalTimeout), pAd, FALSE);
 528
 529         } while (FALSE);
 530
 531         DBGPRINT(RT_DEBUG_TRACE, ("<-- MLME Initialize\n"));
 532
 533         return Status;
 534 }
 535
 536 /*
 537         ==========================================================================
 538         Description:
 539                 main loop of the MLME
 540         Pre:
 541                 Mlme has to be initialized, and there are something inside the queue
 542         Note:
 543                 This function is invoked from MPSetInformation and MPReceive;
 544                 This task guarantee only one MlmeHandler will run.
 545
 546         IRQL = DISPATCH_LEVEL
 547
 548         ==========================================================================
 549  */
 550 VOID MlmeHandler(
 551         IN PRTMP_ADAPTER pAd)
 552 {
 553         MLME_QUEUE_ELEM            *Elem = NULL;
 554
 555         // Only accept MLME and Frame from peer side, no other (control/data) frame should
 556         // get into this state machine
 557
 558         NdisAcquireSpinLock(&pAd->Mlme.TaskLock);
 559         if(pAd->Mlme.bRunning)
 560         {
 561                 NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
 562                 return;
 563         }
 564         else
 565         {
 566                 pAd->Mlme.bRunning = TRUE;
 567         }
 568         NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
 569
 570         while (!MlmeQueueEmpty(&pAd->Mlme.Queue))
 571         {
 572                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_MLME_RESET_IN_PROGRESS) ||
 573                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS) ||
 574                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
 575                 {
 576                         DBGPRINT(RT_DEBUG_TRACE, ("Device Halted or Removed or MlmeRest, exit MlmeHandler! (queue num = %ld)\n", pAd->Mlme.Queue.Num));
 577                         break;
 578                 }
 579
 580                 //From message type, determine which state machine I should drive
 581                 if (MlmeDequeue(&pAd->Mlme.Queue, &Elem))
 582                 {
 583 #ifdef RT2870
 584                         if (Elem->MsgType == MT2_RESET_CONF)
 585                         {
 586                                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("!!! reset MLME state machine !!!\n"));
 587                                 MlmeRestartStateMachine(pAd);
 588                                 Elem->Occupied = FALSE;
 589                                 Elem->MsgLen = 0;
 590                                 continue;
 591                         }
 592 #endif // RT2870 //
 593
 594                         // if dequeue success
 595                         switch (Elem->Machine)
 596                         {
 597                                 // STA state machines
 598 #ifdef  CONFIG_STA_SUPPORT
 599                                 case ASSOC_STATE_MACHINE:
 600                                         StateMachinePerformAction(pAd, &pAd->Mlme.AssocMachine, Elem);
 601                                         break;
 602                                 case AUTH_STATE_MACHINE:
 603                                         StateMachinePerformAction(pAd, &pAd->Mlme.AuthMachine, Elem);
 604                                         break;
 605                                 case AUTH_RSP_STATE_MACHINE:
 606                                         StateMachinePerformAction(pAd, &pAd->Mlme.AuthRspMachine, Elem);
 607                                         break;
 608                                 case SYNC_STATE_MACHINE:
 609                                         StateMachinePerformAction(pAd, &pAd->Mlme.SyncMachine, Elem);
 610                                         break;
 611                                 case MLME_CNTL_STATE_MACHINE:
 612                                         MlmeCntlMachinePerformAction(pAd, &pAd->Mlme.CntlMachine, Elem);
 613                                         break;
 614                                 case WPA_PSK_STATE_MACHINE:
 615                                         StateMachinePerformAction(pAd, &pAd->Mlme.WpaPskMachine, Elem);
 616                                         break;
 617                                 case AIRONET_STATE_MACHINE:
 618                                         StateMachinePerformAction(pAd, &pAd->Mlme.AironetMachine, Elem);
 619                                         break;
 620 #endif // CONFIG_STA_SUPPORT //
 621
 622                                 case ACTION_STATE_MACHINE:
 623                                         StateMachinePerformAction(pAd, &pAd->Mlme.ActMachine, Elem);
 624                                         break;
 625
 626
 627
 628
 629                                 default:
 630                                         DBGPRINT(RT_DEBUG_TRACE, ("ERROR: Illegal machine %ld in MlmeHandler()\n", Elem->Machine));
 631                                         break;
 632                         } // end of switch
 633
 634                         // free MLME element
 635                         Elem->Occupied = FALSE;
 636                         Elem->MsgLen = 0;
 637
 638                 }
 639                 else {
 640                         DBGPRINT_ERR(("MlmeHandler: MlmeQueue empty\n"));
 641                 }
 642         }
 643
 644         NdisAcquireSpinLock(&pAd->Mlme.TaskLock);
 645         pAd->Mlme.bRunning = FALSE;
 646         NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
 647 }
 648
 649 /*
 650         ==========================================================================
 651         Description:
 652                 Destructor of MLME (Destroy queue, state machine, spin lock and timer)
 653         Parameters:
 654                 Adapter - NIC Adapter pointer
 655         Post:
 656                 The MLME task will no longer work properly
 657
 658         IRQL = PASSIVE_LEVEL
 659
 660         ==========================================================================
 661  */
 662 VOID MlmeHalt(
 663         IN PRTMP_ADAPTER pAd)
 664 {
 665         BOOLEAN           Cancelled;
 666
 667         DBGPRINT(RT_DEBUG_TRACE, ("==> MlmeHalt\n"));
 668
 669         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
 670         {
 671                 // disable BEACON generation and other BEACON related hardware timers
 672                 AsicDisableSync(pAd);
 673         }
 674
 675 #ifdef CONFIG_STA_SUPPORT
 676         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 677         {
 678                 // Cancel pending timers
 679                 RTMPCancelTimer(&pAd->MlmeAux.AssocTimer,               &Cancelled);
 680                 RTMPCancelTimer(&pAd->MlmeAux.ReassocTimer,             &Cancelled);
 681                 RTMPCancelTimer(&pAd->MlmeAux.DisassocTimer,    &Cancelled);
 682                 RTMPCancelTimer(&pAd->MlmeAux.AuthTimer,                &Cancelled);
 683                 RTMPCancelTimer(&pAd->MlmeAux.BeaconTimer,              &Cancelled);
 684                 RTMPCancelTimer(&pAd->MlmeAux.ScanTimer,                &Cancelled);
 685         }
 686 #endif // CONFIG_STA_SUPPORT //
 687
 688         RTMPCancelTimer(&pAd->Mlme.PeriodicTimer,               &Cancelled);
 689         RTMPCancelTimer(&pAd->Mlme.RxAntEvalTimer,              &Cancelled);
 690
 691
 692
 693         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
 694         {
 695                 // Set LED
 696                 RTMPSetLED(pAd, LED_HALT);
 697         RTMPSetSignalLED(pAd, -100);    // Force signal strength Led to be turned off, firmware is not done it.
 698 #ifdef RT2870
 699         {
 700             LED_CFG_STRUC LedCfg;
 701             RTMP_IO_READ32(pAd, LED_CFG, &LedCfg.word);
 702             LedCfg.field.LedPolar = 0;
 703             LedCfg.field.RLedMode = 0;
 704             LedCfg.field.GLedMode = 0;
 705             LedCfg.field.YLedMode = 0;
 706             RTMP_IO_WRITE32(pAd, LED_CFG, LedCfg.word);
 707         }
 708 #endif // RT2870 //
 709         }
 710
 711         RTMPusecDelay(5000);    //  5 msec to gurantee Ant Diversity timer canceled
 712
 713         MlmeQueueDestroy(&pAd->Mlme.Queue);
 714         NdisFreeSpinLock(&pAd->Mlme.TaskLock);
 715
 716         DBGPRINT(RT_DEBUG_TRACE, ("<== MlmeHalt\n"));
 717 }
 718
 719 VOID MlmeResetRalinkCounters(
 720         IN  PRTMP_ADAPTER   pAd)
 721 {
 722         pAd->RalinkCounters.LastOneSecRxOkDataCnt = pAd->RalinkCounters.OneSecRxOkDataCnt;
 723         // clear all OneSecxxx counters.
 724         pAd->RalinkCounters.OneSecBeaconSentCnt = 0;
 725         pAd->RalinkCounters.OneSecFalseCCACnt = 0;
 726         pAd->RalinkCounters.OneSecRxFcsErrCnt = 0;
 727         pAd->RalinkCounters.OneSecRxOkCnt = 0;
 728         pAd->RalinkCounters.OneSecTxFailCount = 0;
 729         pAd->RalinkCounters.OneSecTxNoRetryOkCount = 0;
 730         pAd->RalinkCounters.OneSecTxRetryOkCount = 0;
 731         pAd->RalinkCounters.OneSecRxOkDataCnt = 0;
 732
 733         // TODO: for debug only. to be removed
 734         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_BE] = 0;
 735         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_BK] = 0;
 736         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_VI] = 0;
 737         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_VO] = 0;
 738         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_BE] = 0;
 739         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_BK] = 0;
 740         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_VI] = 0;
 741         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_VO] = 0;
 742         pAd->RalinkCounters.OneSecTxDoneCount = 0;
 743         pAd->RalinkCounters.OneSecRxCount = 0;
 744         pAd->RalinkCounters.OneSecTxAggregationCount = 0;
 745         pAd->RalinkCounters.OneSecRxAggregationCount = 0;
 746
 747         return;
 748 }
 749
 750 unsigned long rx_AMSDU;
 751 unsigned long rx_Total;
 752
 753 /*
 754         ==========================================================================
 755         Description:
 756                 This routine is executed periodically to -
 757                 1. Decide if it's a right time to turn on PwrMgmt bit of all
 758                    outgoiing frames
 759                 2. Calculate ChannelQuality based on statistics of the last
 760                    period, so that TX rate won't toggling very frequently between a
 761                    successful TX and a failed TX.
 762                 3. If the calculated ChannelQuality indicated current connection not
 763                    healthy, then a ROAMing attempt is tried here.
 764
 765         IRQL = DISPATCH_LEVEL
 766
 767         ==========================================================================
 768  */
 769 #define ADHOC_BEACON_LOST_TIME          (8*OS_HZ)  // 8 sec
 770 VOID MlmePeriodicExec(
 771         IN PVOID SystemSpecific1,
 772         IN PVOID FunctionContext,
 773         IN PVOID SystemSpecific2,
 774         IN PVOID SystemSpecific3)
 775 {
 776         ULONG                   TxTotalCnt;
 777         PRTMP_ADAPTER   pAd = (RTMP_ADAPTER *)FunctionContext;
 778
 779         // Do nothing if the driver is starting halt state.
 780         // This might happen when timer already been fired before cancel timer with mlmehalt
 781         if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_HALT_IN_PROGRESS |
 782                                                                 fRTMP_ADAPTER_RADIO_OFF |
 783                                                                 fRTMP_ADAPTER_RADIO_MEASUREMENT |
 784                                                                 fRTMP_ADAPTER_RESET_IN_PROGRESS))))
 785                 return;
 786
 787         RT28XX_MLME_PRE_SANITY_CHECK(pAd);
 788
 789 #ifdef CONFIG_STA_SUPPORT
 790         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 791         {
 792                 // Do nothing if monitor mode is on
 793                 if (MONITOR_ON(pAd))
 794                         return;
 795
 796                 if (pAd->Mlme.PeriodicRound & 0x1)
 797                 {
 798                         // This is the fix for wifi 11n extension channel overlapping test case.  for 2860D
 799                         if (((pAd->MACVersion & 0xffff) == 0x0101) &&
 800                                 (STA_TGN_WIFI_ON(pAd)) &&
 801                                 (pAd->CommonCfg.IOTestParm.bToggle == FALSE))
 802
 803                                 {
 804                                         RTMP_IO_WRITE32(pAd, TXOP_CTRL_CFG, 0x24Bf);
 805                                         pAd->CommonCfg.IOTestParm.bToggle = TRUE;
 806                                 }
 807                                 else if ((STA_TGN_WIFI_ON(pAd)) &&
 808                                                 ((pAd->MACVersion & 0xffff) == 0x0101))
 809                                 {
 810                                         RTMP_IO_WRITE32(pAd, TXOP_CTRL_CFG, 0x243f);
 811                                         pAd->CommonCfg.IOTestParm.bToggle = FALSE;
 812                                 }
 813                 }
 814         }
 815 #endif // CONFIG_STA_SUPPORT //
 816
 817         pAd->bUpdateBcnCntDone = FALSE;
 818
 819 //      RECBATimerTimeout(SystemSpecific1,FunctionContext,SystemSpecific2,SystemSpecific3);
 820         pAd->Mlme.PeriodicRound ++;
 821
 822         // execute every 500ms
 823         if ((pAd->Mlme.PeriodicRound % 5 == 0) && RTMPAutoRateSwitchCheck(pAd)/*(OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED))*/)
 824         {
 825 #ifdef CONFIG_STA_SUPPORT
 826                 // perform dynamic tx rate switching based on past TX history
 827                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 828                 {
 829                         if ((OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
 830                                         )
 831                                 && (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)))
 832                                 MlmeDynamicTxRateSwitching(pAd);
 833                 }
 834 #endif // CONFIG_STA_SUPPORT //
 835         }
 836
 837         // Normal 1 second Mlme PeriodicExec.
 838         if (pAd->Mlme.PeriodicRound %MLME_TASK_EXEC_MULTIPLE == 0)
 839         {
 840                 pAd->Mlme.OneSecPeriodicRound ++;
 841
 842                 if (rx_Total)
 843                 {
 844
 845                         // reset counters
 846                         rx_AMSDU = 0;
 847                         rx_Total = 0;
 848                 }
 849
 850                 //ORIBATimerTimeout(pAd);
 851
 852                 // Media status changed, report to NDIS
 853                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_MEDIA_STATE_CHANGE))
 854                 {
 855                         RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_MEDIA_STATE_CHANGE);
 856                         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
 857                         {
 858                                 pAd->IndicateMediaState = NdisMediaStateConnected;
 859                                 RTMP_IndicateMediaState(pAd);
 860
 861                         }
 862                         else
 863                         {
 864                                 pAd->IndicateMediaState = NdisMediaStateDisconnected;
 865                                 RTMP_IndicateMediaState(pAd);
 866                         }
 867                 }
 868
 869                 NdisGetSystemUpTime(&pAd->Mlme.Now32);
 870
 871                 // add the most up-to-date h/w raw counters into software variable, so that
 872                 // the dynamic tuning mechanism below are based on most up-to-date information
 873                 NICUpdateRawCounters(pAd);
 874
 875 #ifdef RT2870
 876                 RT2870_WatchDog(pAd);
 877 #endif // RT2870 //
 878
 879 #ifdef DOT11_N_SUPPORT
 880                 // Need statistics after read counter. So put after NICUpdateRawCounters
 881                 ORIBATimerTimeout(pAd);
 882 #endif // DOT11_N_SUPPORT //
 883
 884                 // if MGMT RING is full more than twice within 1 second, we consider there's
 885                 // a hardware problem stucking the TX path. In this case, try a hardware reset
 886                 // to recover the system
 887         //      if (pAd->RalinkCounters.MgmtRingFullCount >= 2)
 888         //              RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HARDWARE_ERROR);
 889         //      else
 890         //              pAd->RalinkCounters.MgmtRingFullCount = 0;
 891
 892                 // The time period for checking antenna is according to traffic
 893                 if (pAd->Mlme.bEnableAutoAntennaCheck)
 894                 {
 895                         TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
 896                                                          pAd->RalinkCounters.OneSecTxRetryOkCount +
 897                                                          pAd->RalinkCounters.OneSecTxFailCount;
 898
 899                         if (TxTotalCnt > 50)
 900                         {
 901                                 if (pAd->Mlme.OneSecPeriodicRound % 10 == 0)
 902                                 {
 903                                         AsicEvaluateRxAnt(pAd);
 904                                 }
 905                         }
 906                         else
 907                         {
 908                                 if (pAd->Mlme.OneSecPeriodicRound % 3 == 0)
 909                                 {
 910                                         AsicEvaluateRxAnt(pAd);
 911                                 }
 912                         }
 913                 }
 914
 915 #ifdef CONFIG_STA_SUPPORT
 916                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 917                         STAMlmePeriodicExec(pAd);
 918 #endif // CONFIG_STA_SUPPORT //
 919
 920                 MlmeResetRalinkCounters(pAd);
 921
 922 #ifdef CONFIG_STA_SUPPORT
 923                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 924                 {
 925                         {
 926                                 // When Adhoc beacon is enabled and RTS/CTS is enabled, there is a chance that hardware MAC FSM will run into a deadlock
 927                                 // and sending CTS-to-self over and over.
 928                                 // Software Patch Solution:
 929                                 // 1. Polling debug state register 0x10F4 every one second.
 930                                 // 2. If in 0x10F4 the ((bit29==1) && (bit7==1)) OR ((bit29==1) && (bit5==1)), it means the deadlock has occurred.
 931                                 // 3. If the deadlock occurred, reset MAC/BBP by setting 0x1004 to 0x0001 for a while then setting it back to 0x000C again.
 932
 933                                 UINT32  MacReg = 0;
 934
 935                                 RTMP_IO_READ32(pAd, 0x10F4, &MacReg);
 936                                 if (((MacReg & 0x20000000) && (MacReg & 0x80)) || ((MacReg & 0x20000000) && (MacReg & 0x20)))
 937                                 {
 938                                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x1);
 939                                         RTMPusecDelay(1);
 940                                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0xC);
 941
 942                                         DBGPRINT(RT_DEBUG_WARN,("Warning, MAC specific condition occurs \n"));
 943                                 }
 944                         }
 945                 }
 946 #endif // CONFIG_STA_SUPPORT //
 947
 948                 RT28XX_MLME_HANDLER(pAd);
 949         }
 950
 951
 952         pAd->bUpdateBcnCntDone = FALSE;
 953 }
 954
 955 #ifdef CONFIG_STA_SUPPORT
 956 VOID STAMlmePeriodicExec(
 957         PRTMP_ADAPTER pAd)
 958 {
 959         ULONG   TxTotalCnt;
 960         int     i;
 961
 962 #ifdef WPA_SUPPLICANT_SUPPORT
 963     if (pAd->StaCfg.WpaSupplicantUP == WPA_SUPPLICANT_DISABLE)
 964 #endif // WPA_SUPPLICANT_SUPPORT //
 965     {
 966         // WPA MIC error should block association attempt for 60 seconds
 967         if (pAd->StaCfg.bBlockAssoc && (pAd->StaCfg.LastMicErrorTime + (60 * OS_HZ) < pAd->Mlme.Now32))
 968                 pAd->StaCfg.bBlockAssoc = FALSE;
 969     }
 970
 971     if ((pAd->PreMediaState != pAd->IndicateMediaState) && (pAd->CommonCfg.bWirelessEvent))
 972         {
 973                 if (pAd->IndicateMediaState == NdisMediaStateConnected)
 974                 {
 975                         RTMPSendWirelessEvent(pAd, IW_STA_LINKUP_EVENT_FLAG, pAd->MacTab.Content[BSSID_WCID].Addr, BSS0, 0);
 976                 }
 977                 pAd->PreMediaState = pAd->IndicateMediaState;
 978         }
 979
 980
 981
 982
 983         AsicStaBbpTuning(pAd);
 984
 985         TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
 986                                          pAd->RalinkCounters.OneSecTxRetryOkCount +
 987                                          pAd->RalinkCounters.OneSecTxFailCount;
 988
 989         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
 990         {
 991                 // update channel quality for Roaming and UI LinkQuality display
 992                 MlmeCalculateChannelQuality(pAd, pAd->Mlme.Now32);
 993         }
 994
 995         // must be AFTER MlmeDynamicTxRateSwitching() because it needs to know if
 996         // Radio is currently in noisy environment
 997         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
 998                 AsicAdjustTxPower(pAd);
 999
1000         if (INFRA_ON(pAd))
1001         {
1002                 // Is PSM bit consistent with user power management policy?
1003                 // This is the only place that will set PSM bit ON.
1004                 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
1005                 MlmeCheckPsmChange(pAd, pAd->Mlme.Now32);
1006
1007                 pAd->RalinkCounters.LastOneSecTotalTxCount = TxTotalCnt;
1008
1009                 if ((pAd->StaCfg.LastBeaconRxTime + 1*OS_HZ < pAd->Mlme.Now32) &&
1010                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) &&
1011                         ((TxTotalCnt + pAd->RalinkCounters.OneSecRxOkCnt < 600)))
1012                 {
1013                         RTMPSetAGCInitValue(pAd, BW_20);
1014                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - No BEACON. restore R66 to the low bound(%d) \n", (0x2E + GET_LNA_GAIN(pAd))));
1015                 }
1016
1017         //if ((pAd->RalinkCounters.OneSecTxNoRetryOkCount == 0) &&
1018         //    (pAd->RalinkCounters.OneSecTxRetryOkCount == 0))
1019         {
1020                 if (pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable)
1021                 {
1022                     // When APSD is enabled, the period changes as 20 sec
1023                         if ((pAd->Mlme.OneSecPeriodicRound % 20) == 8)
1024                                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
1025                 }
1026                 else
1027                 {
1028                     // Send out a NULL frame every 10 sec to inform AP that STA is still alive (Avoid being age out)
1029                         if ((pAd->Mlme.OneSecPeriodicRound % 10) == 8)
1030                 {
1031                     if (pAd->CommonCfg.bWmmCapable)
1032                                         RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
1033                     else
1034                                                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, FALSE);
1035                 }
1036                 }
1037         }
1038
1039                 if (CQI_IS_DEAD(pAd->Mlme.ChannelQuality))
1040                         {
1041                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - No BEACON. Dead CQI. Auto Recovery attempt #%ld\n", pAd->RalinkCounters.BadCQIAutoRecoveryCount));
1042                         pAd->StaCfg.CCXAdjacentAPReportFlag = TRUE;
1043                         pAd->StaCfg.CCXAdjacentAPLinkDownTime = pAd->StaCfg.LastBeaconRxTime;
1044
1045                         // Lost AP, send disconnect & link down event
1046                         LinkDown(pAd, FALSE);
1047
1048 #ifdef WPA_SUPPLICANT_SUPPORT
1049 #ifndef NATIVE_WPA_SUPPLICANT_SUPPORT
1050             if (pAd->StaCfg.WpaSupplicantUP)
1051                         {
1052                 union iwreq_data    wrqu;
1053                 //send disassociate event to wpa_supplicant
1054                 memset(&wrqu, 0, sizeof(wrqu));
1055                 wrqu.data.flags = RT_DISASSOC_EVENT_FLAG;
1056                 wireless_send_event(pAd->net_dev, IWEVCUSTOM, &wrqu, NULL);
1057             }
1058 #endif // NATIVE_WPA_SUPPLICANT_SUPPORT //
1059 #endif // WPA_SUPPLICANT_SUPPORT //
1060
1061 #ifdef NATIVE_WPA_SUPPLICANT_SUPPORT
1062             {
1063                 union iwreq_data    wrqu;
1064                 memset(wrqu.ap_addr.sa_data, 0, MAC_ADDR_LEN);
1065                 wireless_send_event(pAd->net_dev, SIOCGIWAP, &wrqu, NULL);
1066             }
1067 #endif // NATIVE_WPA_SUPPLICANT_SUPPORT //
1068
1069                         // RTMPPatchMacBbpBug(pAd);
1070                         MlmeAutoReconnectLastSSID(pAd);
1071                 }
1072                 else if (CQI_IS_BAD(pAd->Mlme.ChannelQuality))
1073                 {
1074                         pAd->RalinkCounters.BadCQIAutoRecoveryCount ++;
1075                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Bad CQI. Auto Recovery attempt #%ld\n", pAd->RalinkCounters.BadCQIAutoRecoveryCount));
1076                         MlmeAutoReconnectLastSSID(pAd);
1077                 }
1078
1079                 // Add auto seamless roaming
1080                 if (pAd->StaCfg.bFastRoaming)
1081                 {
1082                         SHORT   dBmToRoam = (SHORT)pAd->StaCfg.dBmToRoam;
1083
1084                         DBGPRINT(RT_DEBUG_TRACE, ("Rssi=%d, dBmToRoam=%d\n", RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.LastRssi0, pAd->StaCfg.RssiSample.LastRssi1, pAd->StaCfg.RssiSample.LastRssi2), (CHAR)dBmToRoam));
1085
1086                         if (RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.LastRssi0, pAd->StaCfg.RssiSample.LastRssi1, pAd->StaCfg.RssiSample.LastRssi2) <= (CHAR)dBmToRoam)
1087                         {
1088                                 MlmeCheckForFastRoaming(pAd, pAd->Mlme.Now32);
1089                         }
1090                 }
1091         }
1092         else if (ADHOC_ON(pAd))
1093         {
1094                 //radar detect
1095                 if ((pAd->CommonCfg.Channel > 14)
1096                         && (pAd->CommonCfg.bIEEE80211H == 1)
1097                         && RadarChannelCheck(pAd, pAd->CommonCfg.Channel))
1098                 {
1099                         RadarDetectPeriodic(pAd);
1100                 }
1101
1102                 // If all peers leave, and this STA becomes the last one in this IBSS, then change MediaState
1103                 // to DISCONNECTED. But still holding this IBSS (i.e. sending BEACON) so that other STAs can
1104                 // join later.
1105                 if ((pAd->StaCfg.LastBeaconRxTime + ADHOC_BEACON_LOST_TIME < pAd->Mlme.Now32) &&
1106                         OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1107                 {
1108                         MLME_START_REQ_STRUCT     StartReq;
1109
1110                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - excessive BEACON lost, last STA in this IBSS, MediaState=Disconnected\n"));
1111                         LinkDown(pAd, FALSE);
1112
1113                         StartParmFill(pAd, &StartReq, pAd->MlmeAux.Ssid, pAd->MlmeAux.SsidLen);
1114                         MlmeEnqueue(pAd, SYNC_STATE_MACHINE, MT2_MLME_START_REQ, sizeof(MLME_START_REQ_STRUCT), &StartReq);
1115                         pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_START;
1116                 }
1117
1118                 for (i = 1; i < MAX_LEN_OF_MAC_TABLE; i++)
1119                 {
1120                         MAC_TABLE_ENTRY *pEntry = &pAd->MacTab.Content[i];
1121
1122                         if (pEntry->ValidAsCLI == FALSE)
1123                                 continue;
1124
1125                         if (pEntry->LastBeaconRxTime + ADHOC_BEACON_LOST_TIME < pAd->Mlme.Now32)
1126                                 MacTableDeleteEntry(pAd, pEntry->Aid, pEntry->Addr);
1127                 }
1128         }
1129         else // no INFRA nor ADHOC connection
1130         {
1131
1132                 if (pAd->StaCfg.bScanReqIsFromWebUI &&
1133             ((pAd->StaCfg.LastScanTime + 30 * OS_HZ) > pAd->Mlme.Now32))
1134                         goto SKIP_AUTO_SCAN_CONN;
1135         else
1136             pAd->StaCfg.bScanReqIsFromWebUI = FALSE;
1137
1138                 if ((pAd->StaCfg.bAutoReconnect == TRUE)
1139                         && RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_START_UP)
1140                         && (MlmeValidateSSID(pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen) == TRUE))
1141                 {
1142                         if ((pAd->ScanTab.BssNr==0) && (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE))
1143                         {
1144                                 MLME_SCAN_REQ_STRUCT       ScanReq;
1145
1146                                 if ((pAd->StaCfg.LastScanTime + 10 * OS_HZ) < pAd->Mlme.Now32)
1147                                 {
1148                                         DBGPRINT(RT_DEBUG_TRACE, ("STAMlmePeriodicExec():CNTL - ScanTab.BssNr==0, start a new ACTIVE scan SSID[%s]\n", pAd->MlmeAux.AutoReconnectSsid));
1149                                         ScanParmFill(pAd, &ScanReq, pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen, BSS_ANY, SCAN_ACTIVE);
1150                                         MlmeEnqueue(pAd, SYNC_STATE_MACHINE, MT2_MLME_SCAN_REQ, sizeof(MLME_SCAN_REQ_STRUCT), &ScanReq);
1151                                         pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_OID_LIST_SCAN;
1152                                         // Reset Missed scan number
1153                                         pAd->StaCfg.LastScanTime = pAd->Mlme.Now32;
1154                                 }
1155                                 else if (pAd->StaCfg.BssType == BSS_ADHOC)      // Quit the forever scan when in a very clean room
1156                                         MlmeAutoReconnectLastSSID(pAd);
1157                         }
1158                         else if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1159                         {
1160                                 if ((pAd->Mlme.OneSecPeriodicRound % 7) == 0)
1161                                 {
1162                                         MlmeAutoScan(pAd);
1163                                         pAd->StaCfg.LastScanTime = pAd->Mlme.Now32;
1164                                 }
1165                                 else
1166                                 {
1167                                                 MlmeAutoReconnectLastSSID(pAd);
1168                                 }
1169                         }
1170                 }
1171         }
1172
1173 SKIP_AUTO_SCAN_CONN:
1174
1175 #ifdef DOT11_N_SUPPORT
1176     if ((pAd->MacTab.Content[BSSID_WCID].TXBAbitmap !=0) && (pAd->MacTab.fAnyBASession == FALSE))
1177         {
1178                 pAd->MacTab.fAnyBASession = TRUE;
1179                 AsicUpdateProtect(pAd, HT_FORCERTSCTS,  ALLN_SETPROTECT, FALSE, FALSE);
1180         }
1181         else if ((pAd->MacTab.Content[BSSID_WCID].TXBAbitmap ==0) && (pAd->MacTab.fAnyBASession == TRUE))
1182         {
1183                 pAd->MacTab.fAnyBASession = FALSE;
1184                 AsicUpdateProtect(pAd, pAd->MlmeAux.AddHtInfo.AddHtInfo2.OperaionMode,  ALLN_SETPROTECT, FALSE, FALSE);
1185         }
1186 #endif // DOT11_N_SUPPORT //
1187
1188         return;
1189 }
1190
1191 // Link down report
1192 VOID LinkDownExec(
1193         IN PVOID SystemSpecific1,
1194         IN PVOID FunctionContext,
1195         IN PVOID SystemSpecific2,
1196         IN PVOID SystemSpecific3)
1197 {
1198
1199         RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)FunctionContext;
1200
1201         pAd->IndicateMediaState = NdisMediaStateDisconnected;
1202         RTMP_IndicateMediaState(pAd);
1203     pAd->ExtraInfo = GENERAL_LINK_DOWN;
1204 }
1205
1206 // IRQL = DISPATCH_LEVEL
1207 VOID MlmeAutoScan(
1208         IN PRTMP_ADAPTER pAd)
1209 {
1210         // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1211         if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1212         {
1213                 DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Driver auto scan\n"));
1214                 MlmeEnqueue(pAd,
1215                                         MLME_CNTL_STATE_MACHINE,
1216                                         OID_802_11_BSSID_LIST_SCAN,
1217                                         0,
1218                                         NULL);
1219                 RT28XX_MLME_HANDLER(pAd);
1220         }
1221 }
1222
1223 // IRQL = DISPATCH_LEVEL
1224 VOID MlmeAutoReconnectLastSSID(
1225         IN PRTMP_ADAPTER pAd)
1226 {
1227
1228
1229         // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1230         if ((pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE) &&
1231                 (MlmeValidateSSID(pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen) == TRUE))
1232         {
1233                 NDIS_802_11_SSID OidSsid;
1234                 OidSsid.SsidLength = pAd->MlmeAux.AutoReconnectSsidLen;
1235                 NdisMoveMemory(OidSsid.Ssid, pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen);
1236
1237                 DBGPRINT(RT_DEBUG_TRACE, ("Driver auto reconnect to last OID_802_11_SSID setting - %s, len - %d\n", pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen));
1238                 MlmeEnqueue(pAd,
1239                                         MLME_CNTL_STATE_MACHINE,
1240                                         OID_802_11_SSID,
1241                                         sizeof(NDIS_802_11_SSID),
1242                                         &OidSsid);
1243                 RT28XX_MLME_HANDLER(pAd);
1244         }
1245 }
1246 #endif // CONFIG_STA_SUPPORT //
1247
1248 /*
1249         ==========================================================================
1250         Validate SSID for connection try and rescan purpose
1251         Valid SSID will have visible chars only.
1252         The valid length is from 0 to 32.
1253         IRQL = DISPATCH_LEVEL
1254         ==========================================================================
1255  */
1256 BOOLEAN MlmeValidateSSID(
1257         IN PUCHAR       pSsid,
1258         IN UCHAR        SsidLen)
1259 {
1260         int     index;
1261
1262         if (SsidLen > MAX_LEN_OF_SSID)
1263                 return (FALSE);
1264
1265         // Check each character value
1266         for (index = 0; index < SsidLen; index++)
1267         {
1268                 if (pSsid[index] < 0x20)
1269                         return (FALSE);
1270         }
1271
1272         // All checked
1273         return (TRUE);
1274 }
1275
1276 VOID MlmeSelectTxRateTable(
1277         IN PRTMP_ADAPTER                pAd,
1278         IN PMAC_TABLE_ENTRY             pEntry,
1279         IN PUCHAR                               *ppTable,
1280         IN PUCHAR                               pTableSize,
1281         IN PUCHAR                               pInitTxRateIdx)
1282 {
1283         do
1284         {
1285                 // decide the rate table for tuning
1286                 if (pAd->CommonCfg.TxRateTableSize > 0)
1287                 {
1288                         *ppTable = RateSwitchTable;
1289                         *pTableSize = RateSwitchTable[0];
1290                         *pInitTxRateIdx = RateSwitchTable[1];
1291
1292                         break;
1293                 }
1294
1295 #ifdef CONFIG_STA_SUPPORT
1296                 if ((pAd->OpMode == OPMODE_STA) && ADHOC_ON(pAd))
1297                 {
1298 #ifdef DOT11_N_SUPPORT
1299                         if ((pAd->CommonCfg.PhyMode >= PHY_11ABGN_MIXED) &&
1300                                 (pEntry->HTCapability.MCSSet[0] == 0xff) &&
1301                                 ((pEntry->HTCapability.MCSSet[1] == 0x00) || (pAd->Antenna.field.TxPath == 1)))
1302                         {// 11N 1S Adhoc
1303                                 *ppTable = RateSwitchTable11N1S;
1304                                 *pTableSize = RateSwitchTable11N1S[0];
1305                                 *pInitTxRateIdx = RateSwitchTable11N1S[1];
1306
1307                         }
1308                         else if ((pAd->CommonCfg.PhyMode >= PHY_11ABGN_MIXED) &&
1309                                         (pEntry->HTCapability.MCSSet[0] == 0xff) &&
1310                                         (pEntry->HTCapability.MCSSet[1] == 0xff) &&
1311                                         (pAd->Antenna.field.TxPath == 2))
1312                         {// 11N 2S Adhoc
1313                                 if (pAd->LatchRfRegs.Channel <= 14)
1314                                 {
1315                                         *ppTable = RateSwitchTable11N2S;
1316                                         *pTableSize = RateSwitchTable11N2S[0];
1317                                         *pInitTxRateIdx = RateSwitchTable11N2S[1];
1318                                 }
1319                                 else
1320                                 {
1321                                         *ppTable = RateSwitchTable11N2SForABand;
1322                                         *pTableSize = RateSwitchTable11N2SForABand[0];
1323                                         *pInitTxRateIdx = RateSwitchTable11N2SForABand[1];
1324                                 }
1325
1326                         }
1327                         else
1328 #endif // DOT11_N_SUPPORT //
1329                                 if ((pEntry->RateLen == 4)
1330 #ifdef DOT11_N_SUPPORT
1331                                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
1332 #endif // DOT11_N_SUPPORT //
1333                                         )
1334                         {
1335                                 *ppTable = RateSwitchTable11B;
1336                                 *pTableSize = RateSwitchTable11B[0];
1337                                 *pInitTxRateIdx = RateSwitchTable11B[1];
1338
1339                         }
1340                         else if (pAd->LatchRfRegs.Channel <= 14)
1341                         {
1342                                 *ppTable = RateSwitchTable11BG;
1343                                 *pTableSize = RateSwitchTable11BG[0];
1344                                 *pInitTxRateIdx = RateSwitchTable11BG[1];
1345
1346                         }
1347                         else
1348                         {
1349                                 *ppTable = RateSwitchTable11G;
1350                                 *pTableSize = RateSwitchTable11G[0];
1351                                 *pInitTxRateIdx = RateSwitchTable11G[1];
1352
1353                         }
1354                         break;
1355                 }
1356 #endif // CONFIG_STA_SUPPORT //
1357
1358 #ifdef DOT11_N_SUPPORT
1359                 //if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen == 12) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) &&
1360                 //      ((pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0x00) || (pAd->Antenna.field.TxPath == 1)))
1361                 if ((pEntry->RateLen == 12) && (pEntry->HTCapability.MCSSet[0] == 0xff) &&
1362                         ((pEntry->HTCapability.MCSSet[1] == 0x00) || (pAd->CommonCfg.TxStream == 1)))
1363                 {// 11BGN 1S AP
1364                         *ppTable = RateSwitchTable11BGN1S;
1365                         *pTableSize = RateSwitchTable11BGN1S[0];
1366                         *pInitTxRateIdx = RateSwitchTable11BGN1S[1];
1367
1368                         break;
1369                 }
1370
1371                 //else if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen == 12) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) &&
1372                 //      (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0xff) && (pAd->Antenna.field.TxPath == 2))
1373                 if ((pEntry->RateLen == 12) && (pEntry->HTCapability.MCSSet[0] == 0xff) &&
1374                         (pEntry->HTCapability.MCSSet[1] == 0xff) && (pAd->CommonCfg.TxStream == 2))
1375                 {// 11BGN 2S AP
1376                         if (pAd->LatchRfRegs.Channel <= 14)
1377                         {
1378                                 *ppTable = RateSwitchTable11BGN2S;
1379                                 *pTableSize = RateSwitchTable11BGN2S[0];
1380                                 *pInitTxRateIdx = RateSwitchTable11BGN2S[1];
1381
1382                         }
1383                         else
1384                         {
1385                                 *ppTable = RateSwitchTable11BGN2SForABand;
1386                                 *pTableSize = RateSwitchTable11BGN2SForABand[0];
1387                                 *pInitTxRateIdx = RateSwitchTable11BGN2SForABand[1];
1388
1389                         }
1390                         break;
1391                 }
1392
1393                 //else if ((pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) && ((pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0x00) || (pAd->Antenna.field.TxPath == 1)))
1394                 if ((pEntry->HTCapability.MCSSet[0] == 0xff) && ((pEntry->HTCapability.MCSSet[1] == 0x00) || (pAd->CommonCfg.TxStream == 1)))
1395                 {// 11N 1S AP
1396                         *ppTable = RateSwitchTable11N1S;
1397                         *pTableSize = RateSwitchTable11N1S[0];
1398                         *pInitTxRateIdx = RateSwitchTable11N1S[1];
1399
1400                         break;
1401                 }
1402
1403                 //else if ((pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0xff) && (pAd->Antenna.field.TxPath == 2))
1404                 if ((pEntry->HTCapability.MCSSet[0] == 0xff) && (pEntry->HTCapability.MCSSet[1] == 0xff) && (pAd->CommonCfg.TxStream == 2))
1405                 {// 11N 2S AP
1406                         if (pAd->LatchRfRegs.Channel <= 14)
1407                         {
1408                         *ppTable = RateSwitchTable11N2S;
1409                         *pTableSize = RateSwitchTable11N2S[0];
1410                         *pInitTxRateIdx = RateSwitchTable11N2S[1];
1411             }
1412                         else
1413                         {
1414                                 *ppTable = RateSwitchTable11N2SForABand;
1415                                 *pTableSize = RateSwitchTable11N2SForABand[0];
1416                                 *pInitTxRateIdx = RateSwitchTable11N2SForABand[1];
1417                         }
1418
1419                         break;
1420                 }
1421 #endif // DOT11_N_SUPPORT //
1422                 //else if ((pAd->StaActive.SupRateLen == 4) && (pAd->StaActive.ExtRateLen == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1423                 if ((pEntry->RateLen == 4)
1424 #ifdef DOT11_N_SUPPORT
1425                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
1426 #endif // DOT11_N_SUPPORT //
1427                         )
1428                 {// B only AP
1429                         *ppTable = RateSwitchTable11B;
1430                         *pTableSize = RateSwitchTable11B[0];
1431                         *pInitTxRateIdx = RateSwitchTable11B[1];
1432
1433                         break;
1434                 }
1435
1436                 //else if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen > 8) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1437                 if ((pEntry->RateLen > 8)
1438 #ifdef DOT11_N_SUPPORT
1439                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
1440 #endif // DOT11_N_SUPPORT //
1441                         )
1442                 {// B/G  mixed AP
1443                         *ppTable = RateSwitchTable11BG;
1444                         *pTableSize = RateSwitchTable11BG[0];
1445                         *pInitTxRateIdx = RateSwitchTable11BG[1];
1446
1447                         break;
1448                 }
1449
1450                 //else if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen == 8) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1451                 if ((pEntry->RateLen == 8)
1452 #ifdef DOT11_N_SUPPORT
1453                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
1454 #endif // DOT11_N_SUPPORT //
1455                         )
1456                 {// G only AP
1457                         *ppTable = RateSwitchTable11G;
1458                         *pTableSize = RateSwitchTable11G[0];
1459                         *pInitTxRateIdx = RateSwitchTable11G[1];
1460
1461                         break;
1462                 }
1463 #ifdef DOT11_N_SUPPORT
1464 #endif // DOT11_N_SUPPORT //
1465
1466 #ifdef CONFIG_STA_SUPPORT
1467                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1468                 {
1469 #ifdef DOT11_N_SUPPORT
1470                         //else if ((pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1471                         if ((pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0))
1472 #endif // DOT11_N_SUPPORT //
1473                         {       // Legacy mode
1474                                 if (pAd->CommonCfg.MaxTxRate <= RATE_11)
1475                                 {
1476                                         *ppTable = RateSwitchTable11B;
1477                                         *pTableSize = RateSwitchTable11B[0];
1478                                         *pInitTxRateIdx = RateSwitchTable11B[1];
1479                                 }
1480                                 else if ((pAd->CommonCfg.MaxTxRate > RATE_11) && (pAd->CommonCfg.MinTxRate > RATE_11))
1481                                 {
1482                                         *ppTable = RateSwitchTable11G;
1483                                         *pTableSize = RateSwitchTable11G[0];
1484                                         *pInitTxRateIdx = RateSwitchTable11G[1];
1485
1486                                 }
1487                                 else
1488                                 {
1489                                         *ppTable = RateSwitchTable11BG;
1490                                         *pTableSize = RateSwitchTable11BG[0];
1491                                         *pInitTxRateIdx = RateSwitchTable11BG[1];
1492                                 }
1493                                 break;
1494                         }
1495 #ifdef DOT11_N_SUPPORT
1496                         if (pAd->LatchRfRegs.Channel <= 14)
1497                         {
1498                                 if (pAd->CommonCfg.TxStream == 1)
1499                                 {
1500                                         *ppTable = RateSwitchTable11N1S;
1501                                         *pTableSize = RateSwitchTable11N1S[0];
1502                                         *pInitTxRateIdx = RateSwitchTable11N1S[1];
1503                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 1S AP \n"));
1504                                 }
1505                                 else
1506                                 {
1507                                         *ppTable = RateSwitchTable11N2S;
1508                                         *pTableSize = RateSwitchTable11N2S[0];
1509                                         *pInitTxRateIdx = RateSwitchTable11N2S[1];
1510                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 2S AP \n"));
1511                                 }
1512                         }
1513                         else
1514                         {
1515                                 if (pAd->CommonCfg.TxStream == 1)
1516                                 {
1517                                         *ppTable = RateSwitchTable11N1S;
1518                                         *pTableSize = RateSwitchTable11N1S[0];
1519                                         *pInitTxRateIdx = RateSwitchTable11N1S[1];
1520                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 1S AP \n"));
1521                                 }
1522                                 else
1523                                 {
1524                                         *ppTable = RateSwitchTable11N2SForABand;
1525                                         *pTableSize = RateSwitchTable11N2SForABand[0];
1526                                         *pInitTxRateIdx = RateSwitchTable11N2SForABand[1];
1527                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 2S AP \n"));
1528                                 }
1529                         }
1530 #endif // DOT11_N_SUPPORT //
1531                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode (SupRateLen=%d, ExtRateLen=%d, MCSSet[0]=0x%x, MCSSet[1]=0x%x)\n",
1532                                 pAd->StaActive.SupRateLen, pAd->StaActive.ExtRateLen, pAd->StaActive.SupportedPhyInfo.MCSSet[0], pAd->StaActive.SupportedPhyInfo.MCSSet[1]));
1533                 }
1534 #endif // CONFIG_STA_SUPPORT //
1535         } while(FALSE);
1536 }
1537
1538 #ifdef CONFIG_STA_SUPPORT
1539 /*
1540         ==========================================================================
1541         Description:
1542                 This routine checks if there're other APs out there capable for
1543                 roaming. Caller should call this routine only when Link up in INFRA mode
1544                 and channel quality is below CQI_GOOD_THRESHOLD.
1545
1546         IRQL = DISPATCH_LEVEL
1547
1548         Output:
1549         ==========================================================================
1550  */
1551 VOID MlmeCheckForRoaming(
1552         IN PRTMP_ADAPTER pAd,
1553         IN ULONG        Now32)
1554 {
1555         USHORT     i;
1556         BSS_TABLE  *pRoamTab = &pAd->MlmeAux.RoamTab;
1557         BSS_ENTRY  *pBss;
1558
1559         DBGPRINT(RT_DEBUG_TRACE, ("==> MlmeCheckForRoaming\n"));
1560         // put all roaming candidates into RoamTab, and sort in RSSI order
1561         BssTableInit(pRoamTab);
1562         for (i = 0; i < pAd->ScanTab.BssNr; i++)
1563         {
1564                 pBss = &pAd->ScanTab.BssEntry[i];
1565
1566                 if ((pBss->LastBeaconRxTime + BEACON_LOST_TIME) < Now32)
1567                         continue;        // AP disappear
1568                 if (pBss->Rssi <= RSSI_THRESHOLD_FOR_ROAMING)
1569                         continue;        // RSSI too weak. forget it.
1570                 if (MAC_ADDR_EQUAL(pBss->Bssid, pAd->CommonCfg.Bssid))
1571                         continue;        // skip current AP
1572                 if (pBss->Rssi < (pAd->StaCfg.RssiSample.LastRssi0 + RSSI_DELTA))
1573                         continue;        // only AP with stronger RSSI is eligible for roaming
1574
1575                 // AP passing all above rules is put into roaming candidate table
1576                 NdisMoveMemory(&pRoamTab->BssEntry[pRoamTab->BssNr], pBss, sizeof(BSS_ENTRY));
1577                 pRoamTab->BssNr += 1;
1578         }
1579
1580         if (pRoamTab->BssNr > 0)
1581         {
1582                 // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1583                 if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1584                 {
1585                         pAd->RalinkCounters.PoorCQIRoamingCount ++;
1586                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Roaming attempt #%ld\n", pAd->RalinkCounters.PoorCQIRoamingCount));
1587                         MlmeEnqueue(pAd, MLME_CNTL_STATE_MACHINE, MT2_MLME_ROAMING_REQ, 0, NULL);
1588                         RT28XX_MLME_HANDLER(pAd);
1589                 }
1590         }
1591         DBGPRINT(RT_DEBUG_TRACE, ("<== MlmeCheckForRoaming(# of candidate= %d)\n",pRoamTab->BssNr));
1592 }
1593
1594 /*
1595         ==========================================================================
1596         Description:
1597                 This routine checks if there're other APs out there capable for
1598                 roaming. Caller should call this routine only when link up in INFRA mode
1599                 and channel quality is below CQI_GOOD_THRESHOLD.
1600
1601         IRQL = DISPATCH_LEVEL
1602
1603         Output:
1604         ==========================================================================
1605  */
1606 VOID MlmeCheckForFastRoaming(
1607         IN      PRTMP_ADAPTER   pAd,
1608         IN      ULONG                   Now)
1609 {
1610         USHORT          i;
1611         BSS_TABLE       *pRoamTab = &pAd->MlmeAux.RoamTab;
1612         BSS_ENTRY       *pBss;
1613
1614         DBGPRINT(RT_DEBUG_TRACE, ("==> MlmeCheckForFastRoaming\n"));
1615         // put all roaming candidates into RoamTab, and sort in RSSI order
1616         BssTableInit(pRoamTab);
1617         for (i = 0; i < pAd->ScanTab.BssNr; i++)
1618         {
1619                 pBss = &pAd->ScanTab.BssEntry[i];
1620
1621         if ((pBss->Rssi <= -50) && (pBss->Channel == pAd->CommonCfg.Channel))
1622                         continue;        // RSSI too weak. forget it.
1623                 if (MAC_ADDR_EQUAL(pBss->Bssid, pAd->CommonCfg.Bssid))
1624                         continue;        // skip current AP
1625                 if (!SSID_EQUAL(pBss->Ssid, pBss->SsidLen, pAd->CommonCfg.Ssid, pAd->CommonCfg.SsidLen))
1626                         continue;        // skip different SSID
1627         if (pBss->Rssi < (RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.LastRssi0, pAd->StaCfg.RssiSample.LastRssi1, pAd->StaCfg.RssiSample.LastRssi2) + RSSI_DELTA))
1628                         continue;        // skip AP without better RSSI
1629
1630         DBGPRINT(RT_DEBUG_TRACE, ("LastRssi0 = %d, pBss->Rssi = %d\n", RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.LastRssi0, pAd->StaCfg.RssiSample.LastRssi1, pAd->StaCfg.RssiSample.LastRssi2), pBss->Rssi));
1631                 // AP passing all above rules is put into roaming candidate table
1632                 NdisMoveMemory(&pRoamTab->BssEntry[pRoamTab->BssNr], pBss, sizeof(BSS_ENTRY));
1633                 pRoamTab->BssNr += 1;
1634         }
1635
1636         if (pRoamTab->BssNr > 0)
1637         {
1638                 // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1639                 if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1640                 {
1641                         pAd->RalinkCounters.PoorCQIRoamingCount ++;
1642                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Roaming attempt #%ld\n", pAd->RalinkCounters.PoorCQIRoamingCount));
1643                         MlmeEnqueue(pAd, MLME_CNTL_STATE_MACHINE, MT2_MLME_ROAMING_REQ, 0, NULL);
1644                         RT28XX_MLME_HANDLER(pAd);
1645                 }
1646         }
1647         // Maybe site survey required
1648         else
1649         {
1650                 if ((pAd->StaCfg.LastScanTime + 10 * 1000) < Now)
1651                 {
1652                         // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1653                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Roaming, No eligable entry, try new scan!\n"));
1654                         pAd->StaCfg.ScanCnt = 2;
1655                         pAd->StaCfg.LastScanTime = Now;
1656                         MlmeAutoScan(pAd);
1657                 }
1658         }
1659
1660     DBGPRINT(RT_DEBUG_TRACE, ("<== MlmeCheckForFastRoaming (BssNr=%d)\n", pRoamTab->BssNr));
1661 }
1662
1663 /*
1664         ==========================================================================
1665         Description:
1666                 This routine calculates TxPER, RxPER of the past N-sec period. And
1667                 according to the calculation result, ChannelQuality is calculated here
1668                 to decide if current AP is still doing the job.
1669
1670                 If ChannelQuality is not good, a ROAMing attempt may be tried later.
1671         Output:
1672                 StaCfg.ChannelQuality - 0..100
1673
1674         IRQL = DISPATCH_LEVEL
1675
1676         NOTE: This routine decide channle quality based on RX CRC error ratio.
1677                 Caller should make sure a function call to NICUpdateRawCounters(pAd)
1678                 is performed right before this routine, so that this routine can decide
1679                 channel quality based on the most up-to-date information
1680         ==========================================================================
1681  */
1682 VOID MlmeCalculateChannelQuality(
1683         IN PRTMP_ADAPTER pAd,
1684         IN ULONG Now32)
1685 {
1686         ULONG TxOkCnt, TxCnt, TxPER, TxPRR;
1687         ULONG RxCnt, RxPER;
1688         UCHAR NorRssi;
1689         CHAR  MaxRssi;
1690         ULONG BeaconLostTime = BEACON_LOST_TIME;
1691
1692         MaxRssi = RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.LastRssi0, pAd->StaCfg.RssiSample.LastRssi1, pAd->StaCfg.RssiSample.LastRssi2);
1693
1694         //
1695         // calculate TX packet error ratio and TX retry ratio - if too few TX samples, skip TX related statistics
1696         //
1697         TxOkCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount + pAd->RalinkCounters.OneSecTxRetryOkCount;
1698         TxCnt = TxOkCnt + pAd->RalinkCounters.OneSecTxFailCount;
1699         if (TxCnt < 5)
1700         {
1701                 TxPER = 0;
1702                 TxPRR = 0;
1703         }
1704         else
1705         {
1706                 TxPER = (pAd->RalinkCounters.OneSecTxFailCount * 100) / TxCnt;
1707                 TxPRR = ((TxCnt - pAd->RalinkCounters.OneSecTxNoRetryOkCount) * 100) / TxCnt;
1708         }
1709
1710         //
1711         // calculate RX PER - don't take RxPER into consideration if too few sample
1712         //
1713         RxCnt = pAd->RalinkCounters.OneSecRxOkCnt + pAd->RalinkCounters.OneSecRxFcsErrCnt;
1714         if (RxCnt < 5)
1715                 RxPER = 0;
1716         else
1717                 RxPER = (pAd->RalinkCounters.OneSecRxFcsErrCnt * 100) / RxCnt;
1718
1719         //
1720         // decide ChannelQuality based on: 1)last BEACON received time, 2)last RSSI, 3)TxPER, and 4)RxPER
1721         //
1722         if (INFRA_ON(pAd) &&
1723                 (pAd->RalinkCounters.OneSecTxNoRetryOkCount < 2) && // no heavy traffic
1724                 (pAd->StaCfg.LastBeaconRxTime + BeaconLostTime < Now32))
1725         {
1726                 DBGPRINT(RT_DEBUG_TRACE, ("BEACON lost > %ld msec with TxOkCnt=%ld -> CQI=0\n", BeaconLostTime, TxOkCnt));
1727                 pAd->Mlme.ChannelQuality = 0;
1728         }
1729         else
1730         {
1731                 // Normalize Rssi
1732                 if (MaxRssi > -40)
1733                         NorRssi = 100;
1734                 else if (MaxRssi < -90)
1735                         NorRssi = 0;
1736                 else
1737                         NorRssi = (MaxRssi + 90) * 2;
1738
1739                 // ChannelQuality = W1*RSSI + W2*TxPRR + W3*RxPER        (RSSI 0..100), (TxPER 100..0), (RxPER 100..0)
1740                 pAd->Mlme.ChannelQuality = (RSSI_WEIGHTING * NorRssi +
1741                                                                    TX_WEIGHTING * (100 - TxPRR) +
1742                                                                    RX_WEIGHTING* (100 - RxPER)) / 100;
1743                 if (pAd->Mlme.ChannelQuality >= 100)
1744                         pAd->Mlme.ChannelQuality = 100;
1745         }
1746
1747 }
1748
1749 VOID MlmeSetTxRate(
1750         IN PRTMP_ADAPTER                pAd,
1751         IN PMAC_TABLE_ENTRY             pEntry,
1752         IN PRTMP_TX_RATE_SWITCH pTxRate)
1753 {
1754         UCHAR   MaxMode = MODE_OFDM;
1755
1756 #ifdef DOT11_N_SUPPORT
1757         MaxMode = MODE_HTGREENFIELD;
1758
1759         if (pTxRate->STBC && (pAd->StaCfg.MaxHTPhyMode.field.STBC) && (pAd->Antenna.field.TxPath == 2))
1760                 pAd->StaCfg.HTPhyMode.field.STBC = STBC_USE;
1761         else
1762 #endif // DOT11_N_SUPPORT //
1763                 pAd->StaCfg.HTPhyMode.field.STBC = STBC_NONE;
1764
1765         if (pTxRate->CurrMCS < MCS_AUTO)
1766                 pAd->StaCfg.HTPhyMode.field.MCS = pTxRate->CurrMCS;
1767
1768         if (pAd->StaCfg.HTPhyMode.field.MCS > 7)
1769                 pAd->StaCfg.HTPhyMode.field.STBC = STBC_NONE;
1770
1771         if (ADHOC_ON(pAd))
1772         {
1773                 // If peer adhoc is b-only mode, we can't send 11g rate.
1774                 pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1775                 pEntry->HTPhyMode.field.STBC    = STBC_NONE;
1776
1777                 //
1778                 // For Adhoc MODE_CCK, driver will use AdhocBOnlyJoined flag to roll back to B only if necessary
1779                 //
1780                 pEntry->HTPhyMode.field.MODE    = pTxRate->Mode;
1781                 pEntry->HTPhyMode.field.ShortGI = pAd->StaCfg.HTPhyMode.field.ShortGI;
1782                 pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1783
1784                 // Patch speed error in status page
1785                 pAd->StaCfg.HTPhyMode.field.MODE = pEntry->HTPhyMode.field.MODE;
1786         }
1787         else
1788         {
1789                 if (pTxRate->Mode <= MaxMode)
1790                         pAd->StaCfg.HTPhyMode.field.MODE = pTxRate->Mode;
1791
1792 #ifdef DOT11_N_SUPPORT
1793                 if (pTxRate->ShortGI && (pAd->StaCfg.MaxHTPhyMode.field.ShortGI))
1794                         pAd->StaCfg.HTPhyMode.field.ShortGI = GI_400;
1795                 else
1796 #endif // DOT11_N_SUPPORT //
1797                         pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1798
1799 #ifdef DOT11_N_SUPPORT
1800                 // Reexam each bandwidth's SGI support.
1801                 if (pAd->StaCfg.HTPhyMode.field.ShortGI == GI_400)
1802                 {
1803                         if ((pEntry->HTPhyMode.field.BW == BW_20) && (!CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_SGI20_CAPABLE)))
1804                                 pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1805                         if ((pEntry->HTPhyMode.field.BW == BW_40) && (!CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_SGI40_CAPABLE)))
1806                                 pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1807                 }
1808
1809                 // Turn RTS/CTS rate to 6Mbps.
1810                 if ((pEntry->HTPhyMode.field.MCS == 0) && (pAd->StaCfg.HTPhyMode.field.MCS != 0))
1811                 {
1812                         pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1813                         if (pAd->MacTab.fAnyBASession)
1814                         {
1815                                 AsicUpdateProtect(pAd, HT_FORCERTSCTS, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1816                         }
1817                         else
1818                         {
1819                                 AsicUpdateProtect(pAd, pAd->MlmeAux.AddHtInfo.AddHtInfo2.OperaionMode, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1820                         }
1821                 }
1822                 else if ((pEntry->HTPhyMode.field.MCS == 8) && (pAd->StaCfg.HTPhyMode.field.MCS != 8))
1823                 {
1824                         pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1825                         if (pAd->MacTab.fAnyBASession)
1826                         {
1827                                 AsicUpdateProtect(pAd, HT_FORCERTSCTS, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1828                         }
1829                         else
1830                         {
1831                                 AsicUpdateProtect(pAd, pAd->MlmeAux.AddHtInfo.AddHtInfo2.OperaionMode, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1832                         }
1833                 }
1834                 else if ((pEntry->HTPhyMode.field.MCS != 0) && (pAd->StaCfg.HTPhyMode.field.MCS == 0))
1835                 {
1836                         AsicUpdateProtect(pAd, HT_RTSCTS_6M, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1837
1838                 }
1839                 else if ((pEntry->HTPhyMode.field.MCS != 8) && (pAd->StaCfg.HTPhyMode.field.MCS == 8))
1840                 {
1841                         AsicUpdateProtect(pAd, HT_RTSCTS_6M, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1842                 }
1843 #endif // DOT11_N_SUPPORT //
1844
1845                 pEntry->HTPhyMode.field.STBC    = pAd->StaCfg.HTPhyMode.field.STBC;
1846                 pEntry->HTPhyMode.field.ShortGI = pAd->StaCfg.HTPhyMode.field.ShortGI;
1847                 pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1848                 pEntry->HTPhyMode.field.MODE    = pAd->StaCfg.HTPhyMode.field.MODE;
1849 #ifdef DOT11_N_SUPPORT
1850                 if ((pAd->StaCfg.MaxHTPhyMode.field.MODE == MODE_HTGREENFIELD) &&
1851                     pAd->WIFItestbed.bGreenField)
1852                     pEntry->HTPhyMode.field.MODE = MODE_HTGREENFIELD;
1853 #endif // DOT11_N_SUPPORT //
1854         }
1855
1856         pAd->LastTxRate = (USHORT)(pEntry->HTPhyMode.word);
1857 }
1858
1859 /*
1860         ==========================================================================
1861         Description:
1862                 This routine calculates the acumulated TxPER of eaxh TxRate. And
1863                 according to the calculation result, change CommonCfg.TxRate which
1864                 is the stable TX Rate we expect the Radio situation could sustained.
1865
1866                 CommonCfg.TxRate will change dynamically within {RATE_1/RATE_6, MaxTxRate}
1867         Output:
1868                 CommonCfg.TxRate -
1869
1870         IRQL = DISPATCH_LEVEL
1871
1872         NOTE:
1873                 call this routine every second
1874         ==========================================================================
1875  */
1876 VOID MlmeDynamicTxRateSwitching(
1877         IN PRTMP_ADAPTER pAd)
1878 {
1879         UCHAR                                   UpRateIdx = 0, DownRateIdx = 0, CurrRateIdx;
1880         ULONG                                   i, AccuTxTotalCnt = 0, TxTotalCnt;
1881         ULONG                                   TxErrorRatio = 0;
1882         BOOLEAN                                 bTxRateChanged, bUpgradeQuality = FALSE;
1883         PRTMP_TX_RATE_SWITCH    pCurrTxRate, pNextTxRate = NULL;
1884         PUCHAR                                  pTable;
1885         UCHAR                                   TableSize = 0;
1886         UCHAR                                   InitTxRateIdx = 0, TrainUp, TrainDown;
1887         CHAR                                    Rssi, RssiOffset = 0;
1888         TX_STA_CNT1_STRUC               StaTx1;
1889         TX_STA_CNT0_STRUC               TxStaCnt0;
1890         ULONG                                   TxRetransmit = 0, TxSuccess = 0, TxFailCount = 0;
1891         MAC_TABLE_ENTRY                 *pEntry;
1892
1893         //
1894         // walk through MAC table, see if need to change AP's TX rate toward each entry
1895         //
1896         for (i = 1; i < MAX_LEN_OF_MAC_TABLE; i++)
1897         {
1898                 pEntry = &pAd->MacTab.Content[i];
1899
1900                 // check if this entry need to switch rate automatically
1901                 if (RTMPCheckEntryEnableAutoRateSwitch(pAd, pEntry) == FALSE)
1902                         continue;
1903
1904                 if ((pAd->MacTab.Size == 1) || (pEntry->ValidAsDls))
1905                 {
1906                         Rssi = RTMPMaxRssi(pAd,
1907                                                            pAd->StaCfg.RssiSample.AvgRssi0,
1908                                                            pAd->StaCfg.RssiSample.AvgRssi1,
1909                                                            pAd->StaCfg.RssiSample.AvgRssi2);
1910
1911                         // Update statistic counter
1912                         RTMP_IO_READ32(pAd, TX_STA_CNT0, &TxStaCnt0.word);
1913                         RTMP_IO_READ32(pAd, TX_STA_CNT1, &StaTx1.word);
1914                         pAd->bUpdateBcnCntDone = TRUE;
1915                         TxRetransmit = StaTx1.field.TxRetransmit;
1916                         TxSuccess = StaTx1.field.TxSuccess;
1917                         TxFailCount = TxStaCnt0.field.TxFailCount;
1918                         TxTotalCnt = TxRetransmit + TxSuccess + TxFailCount;
1919
1920                         pAd->RalinkCounters.OneSecTxRetryOkCount += StaTx1.field.TxRetransmit;
1921                         pAd->RalinkCounters.OneSecTxNoRetryOkCount += StaTx1.field.TxSuccess;
1922                         pAd->RalinkCounters.OneSecTxFailCount += TxStaCnt0.field.TxFailCount;
1923                         pAd->WlanCounters.TransmittedFragmentCount.u.LowPart += StaTx1.field.TxSuccess;
1924                         pAd->WlanCounters.RetryCount.u.LowPart += StaTx1.field.TxRetransmit;
1925                         pAd->WlanCounters.FailedCount.u.LowPart += TxStaCnt0.field.TxFailCount;
1926
1927                         // if no traffic in the past 1-sec period, don't change TX rate,
1928                         // but clear all bad history. because the bad history may affect the next
1929                         // Chariot throughput test
1930                         AccuTxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
1931                                                  pAd->RalinkCounters.OneSecTxRetryOkCount +
1932                                                  pAd->RalinkCounters.OneSecTxFailCount;
1933
1934                         if (TxTotalCnt)
1935                                 TxErrorRatio = ((TxRetransmit + TxFailCount) * 100) / TxTotalCnt;
1936                 }
1937                 else
1938                 {
1939                         if (INFRA_ON(pAd) && (i == 1))
1940                                 Rssi = RTMPMaxRssi(pAd,
1941                                                                    pAd->StaCfg.RssiSample.AvgRssi0,
1942                                                                    pAd->StaCfg.RssiSample.AvgRssi1,
1943                                                                    pAd->StaCfg.RssiSample.AvgRssi2);
1944                         else
1945                                 Rssi = RTMPMaxRssi(pAd,
1946                                                                    pEntry->RssiSample.AvgRssi0,
1947                                                                    pEntry->RssiSample.AvgRssi1,
1948                                                                    pEntry->RssiSample.AvgRssi2);
1949
1950                         TxTotalCnt = pEntry->OneSecTxNoRetryOkCount +
1951                                  pEntry->OneSecTxRetryOkCount +
1952                                  pEntry->OneSecTxFailCount;
1953
1954                         if (TxTotalCnt)
1955                                 TxErrorRatio = ((pEntry->OneSecTxRetryOkCount + pEntry->OneSecTxFailCount) * 100) / TxTotalCnt;
1956                 }
1957
1958                 CurrRateIdx = pEntry->CurrTxRateIndex;
1959
1960                 MlmeSelectTxRateTable(pAd, pEntry, &pTable, &TableSize, &InitTxRateIdx);
1961
1962                 if (CurrRateIdx >= TableSize)
1963                 {
1964                         CurrRateIdx = TableSize - 1;
1965                 }
1966
1967                 // When switch from Fixed rate -> auto rate, the REAL TX rate might be different from pAd->CommonCfg.TxRateIndex.
1968                 // So need to sync here.
1969                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(CurrRateIdx+1)*5];
1970                 if ((pEntry->HTPhyMode.field.MCS != pCurrTxRate->CurrMCS)
1971                         //&& (pAd->StaCfg.bAutoTxRateSwitch == TRUE)
1972                         )
1973                 {
1974
1975                         // Need to sync Real Tx rate and our record.
1976                         // Then return for next DRS.
1977                         pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(InitTxRateIdx+1)*5];
1978                         pEntry->CurrTxRateIndex = InitTxRateIdx;
1979                         MlmeSetTxRate(pAd, pEntry, pCurrTxRate);
1980
1981                         // reset all OneSecTx counters
1982                         RESET_ONE_SEC_TX_CNT(pEntry);
1983                         continue;
1984                 }
1985
1986                 // decide the next upgrade rate and downgrade rate, if any
1987                 if ((CurrRateIdx > 0) && (CurrRateIdx < (TableSize - 1)))
1988                 {
1989                         UpRateIdx = CurrRateIdx + 1;
1990                         DownRateIdx = CurrRateIdx -1;
1991                 }
1992                 else if (CurrRateIdx == 0)
1993                 {
1994                         UpRateIdx = CurrRateIdx + 1;
1995                         DownRateIdx = CurrRateIdx;
1996                 }
1997                 else if (CurrRateIdx == (TableSize - 1))
1998                 {
1999                         UpRateIdx = CurrRateIdx;
2000                         DownRateIdx = CurrRateIdx - 1;
2001                 }
2002
2003                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(CurrRateIdx+1)*5];
2004
2005 #ifdef DOT11_N_SUPPORT
2006                 if ((Rssi > -65) && (pCurrTxRate->Mode >= MODE_HTMIX))
2007                 {
2008                         TrainUp         = (pCurrTxRate->TrainUp + (pCurrTxRate->TrainUp >> 1));
2009                         TrainDown       = (pCurrTxRate->TrainDown + (pCurrTxRate->TrainDown >> 1));
2010                 }
2011                 else
2012 #endif // DOT11_N_SUPPORT //
2013                 {
2014                         TrainUp         = pCurrTxRate->TrainUp;
2015                         TrainDown       = pCurrTxRate->TrainDown;
2016                 }
2017
2018                 //pAd->DrsCounters.LastTimeTxRateChangeAction = pAd->DrsCounters.LastSecTxRateChangeAction;
2019
2020                 //
2021                 // Keep the last time TxRateChangeAction status.
2022                 //
2023                 pEntry->LastTimeTxRateChangeAction = pEntry->LastSecTxRateChangeAction;
2024
2025
2026
2027                 //
2028                 // CASE 1. when TX samples are fewer than 15, then decide TX rate solely on RSSI
2029                 //         (criteria copied from RT2500 for Netopia case)
2030                 //
2031                 if (TxTotalCnt <= 15)
2032                 {
2033                         CHAR    idx = 0;
2034                         UCHAR   TxRateIdx;
2035                         //UCHAR MCS0 = 0, MCS1 = 0, MCS2 = 0, MCS3 = 0, MCS4 = 0, MCS7 = 0, MCS12 = 0, MCS13 = 0, MCS14 = 0, MCS15 = 0;
2036                         UCHAR   MCS0 = 0, MCS1 = 0, MCS2 = 0, MCS3 = 0, MCS4 = 0,  MCS5 =0, MCS6 = 0, MCS7 = 0;
2037                 UCHAR   MCS12 = 0, MCS13 = 0, MCS14 = 0, MCS15 = 0;
2038                         UCHAR   MCS20 = 0, MCS21 = 0, MCS22 = 0, MCS23 = 0; // 3*3
2039
2040                         // check the existence and index of each needed MCS
2041                         while (idx < pTable[0])
2042                         {
2043                                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(idx+1)*5];
2044
2045                                 if (pCurrTxRate->CurrMCS == MCS_0)
2046                                 {
2047                                         MCS0 = idx;
2048                                 }
2049                                 else if (pCurrTxRate->CurrMCS == MCS_1)
2050                                 {
2051                                         MCS1 = idx;
2052                                 }
2053                                 else if (pCurrTxRate->CurrMCS == MCS_2)
2054                                 {
2055                                         MCS2 = idx;
2056                                 }
2057                                 else if (pCurrTxRate->CurrMCS == MCS_3)
2058                                 {
2059                                         MCS3 = idx;
2060                                 }
2061                                 else if (pCurrTxRate->CurrMCS == MCS_4)
2062                                 {
2063                                         MCS4 = idx;
2064                                 }
2065                     else if (pCurrTxRate->CurrMCS == MCS_5)
2066                     {
2067                         MCS5 = idx;
2068                     }
2069                     else if (pCurrTxRate->CurrMCS == MCS_6)
2070                     {
2071                         MCS6 = idx;
2072                     }
2073                                 //else if (pCurrTxRate->CurrMCS == MCS_7)
2074                                 else if ((pCurrTxRate->CurrMCS == MCS_7) && (pCurrTxRate->ShortGI == GI_800))   // prevent the highest MCS using short GI when 1T and low throughput
2075                                 {
2076                                         MCS7 = idx;
2077                                 }
2078                                 else if (pCurrTxRate->CurrMCS == MCS_12)
2079                                 {
2080                                         MCS12 = idx;
2081                                 }
2082                                 else if (pCurrTxRate->CurrMCS == MCS_13)
2083                                 {
2084                                         MCS13 = idx;
2085                                 }
2086                                 else if (pCurrTxRate->CurrMCS == MCS_14)
2087                                 {
2088                                         MCS14 = idx;
2089                                 }
2090                                 //else if ((pCurrTxRate->CurrMCS == MCS_15)/* && (pCurrTxRate->ShortGI == GI_800)*/)    //we hope to use ShortGI as initial rate
2091                                 else if ((pCurrTxRate->CurrMCS == MCS_15) && (pCurrTxRate->ShortGI == GI_800))  //we hope to use ShortGI as initial rate, however Atheros's chip has bugs when short GI
2092                                 {
2093                                         MCS15 = idx;
2094                                 }
2095                                 else if (pCurrTxRate->CurrMCS == MCS_20) // 3*3
2096                                 {
2097                                         MCS20 = idx;
2098                                 }
2099                                 else if (pCurrTxRate->CurrMCS == MCS_21)
2100                                 {
2101                                         MCS21 = idx;
2102                                 }
2103                                 else if (pCurrTxRate->CurrMCS == MCS_22)
2104                                 {
2105                                         MCS22 = idx;
2106                                 }
2107                                 else if (pCurrTxRate->CurrMCS == MCS_23)
2108                                 {
2109                                         MCS23 = idx;
2110                                 }
2111                                 idx ++;
2112                         }
2113
2114                         if (pAd->LatchRfRegs.Channel <= 14)
2115                         {
2116                                 if (pAd->NicConfig2.field.ExternalLNAForG)
2117                                 {
2118                                         RssiOffset = 2;
2119                                 }
2120                                 else
2121                                 {
2122                                         RssiOffset = 5;
2123                                 }
2124                         }
2125                         else
2126                         {
2127                                 if (pAd->NicConfig2.field.ExternalLNAForA)
2128                                 {
2129                                         RssiOffset = 5;
2130                                 }
2131                                 else
2132                                 {
2133                                         RssiOffset = 8;
2134                                 }
2135                         }
2136 #ifdef DOT11_N_SUPPORT
2137                         /*if (MCS15)*/
2138                         if ((pTable == RateSwitchTable11BGN3S) ||
2139                                 (pTable == RateSwitchTable11N3S) ||
2140                                 (pTable == RateSwitchTable))
2141                         {// N mode with 3 stream // 3*3
2142                                 if (MCS23 && (Rssi >= -70))
2143                                         TxRateIdx = MCS15;
2144                                 else if (MCS22 && (Rssi >= -72))
2145                                         TxRateIdx = MCS14;
2146                     else if (MCS21 && (Rssi >= -76))
2147                                         TxRateIdx = MCS13;
2148                                 else if (MCS20 && (Rssi >= -78))
2149                                         TxRateIdx = MCS12;
2150                         else if (MCS4 && (Rssi >= -82))
2151                                 TxRateIdx = MCS4;
2152                         else if (MCS3 && (Rssi >= -84))
2153                                 TxRateIdx = MCS3;
2154                         else if (MCS2 && (Rssi >= -86))
2155                                 TxRateIdx = MCS2;
2156                         else if (MCS1 && (Rssi >= -88))
2157                                 TxRateIdx = MCS1;
2158                         else
2159                                 TxRateIdx = MCS0;
2160                 }
2161 //              else if ((pTable == RateSwitchTable11BGN2S) || (pTable == RateSwitchTable11BGN2SForABand) ||(pTable == RateSwitchTable11N2S) ||(pTable == RateSwitchTable11N2SForABand) || (pTable == RateSwitchTable))
2162                 else if ((pTable == RateSwitchTable11BGN2S) || (pTable == RateSwitchTable11BGN2SForABand) ||(pTable == RateSwitchTable11N2S) ||(pTable == RateSwitchTable11N2SForABand)) // 3*3
2163                         {// N mode with 2 stream
2164                                 if (MCS15 && (Rssi >= (-70+RssiOffset)))
2165                                         TxRateIdx = MCS15;
2166                                 else if (MCS14 && (Rssi >= (-72+RssiOffset)))
2167                                         TxRateIdx = MCS14;
2168                                 else if (MCS13 && (Rssi >= (-76+RssiOffset)))
2169                                         TxRateIdx = MCS13;
2170                                 else if (MCS12 && (Rssi >= (-78+RssiOffset)))
2171                                         TxRateIdx = MCS12;
2172                                 else if (MCS4 && (Rssi >= (-82+RssiOffset)))
2173                                         TxRateIdx = MCS4;
2174                                 else if (MCS3 && (Rssi >= (-84+RssiOffset)))
2175                                         TxRateIdx = MCS3;
2176                                 else if (MCS2 && (Rssi >= (-86+RssiOffset)))
2177                                         TxRateIdx = MCS2;
2178                                 else if (MCS1 && (Rssi >= (-88+RssiOffset)))
2179                                         TxRateIdx = MCS1;
2180                                 else
2181                                         TxRateIdx = MCS0;
2182                         }
2183                         else if ((pTable == RateSwitchTable11BGN1S) || (pTable == RateSwitchTable11N1S))
2184                         {// N mode with 1 stream
2185                                 if (MCS7 && (Rssi > (-72+RssiOffset)))
2186                                         TxRateIdx = MCS7;
2187                                 else if (MCS6 && (Rssi > (-74+RssiOffset)))
2188                                         TxRateIdx = MCS6;
2189                                 else if (MCS5 && (Rssi > (-77+RssiOffset)))
2190                                         TxRateIdx = MCS5;
2191                                 else if (MCS4 && (Rssi > (-79+RssiOffset)))
2192                                         TxRateIdx = MCS4;
2193                                 else if (MCS3 && (Rssi > (-81+RssiOffset)))
2194                                         TxRateIdx = MCS3;
2195                                 else if (MCS2 && (Rssi > (-83+RssiOffset)))
2196                                         TxRateIdx = MCS2;
2197                                 else if (MCS1 && (Rssi > (-86+RssiOffset)))
2198                                         TxRateIdx = MCS1;
2199                                 else
2200                                         TxRateIdx = MCS0;
2201                         }
2202                         else
2203 #endif // DOT11_N_SUPPORT //
2204                         {// Legacy mode
2205                                 if (MCS7 && (Rssi > -70))
2206                                         TxRateIdx = MCS7;
2207                                 else if (MCS6 && (Rssi > -74))
2208                                         TxRateIdx = MCS6;
2209                                 else if (MCS5 && (Rssi > -78))
2210                                         TxRateIdx = MCS5;
2211                                 else if (MCS4 && (Rssi > -82))
2212                                         TxRateIdx = MCS4;
2213                                 else if (MCS4 == 0)     // for B-only mode
2214                                         TxRateIdx = MCS3;
2215                                 else if (MCS3 && (Rssi > -85))
2216                                         TxRateIdx = MCS3;
2217                                 else if (MCS2 && (Rssi > -87))
2218                                         TxRateIdx = MCS2;
2219                                 else if (MCS1 && (Rssi > -90))
2220                                         TxRateIdx = MCS1;
2221                                 else
2222                                         TxRateIdx = MCS0;
2223                         }
2224
2225         //              if (TxRateIdx != pAd->CommonCfg.TxRateIndex)
2226                         {
2227                                 pEntry->CurrTxRateIndex = TxRateIdx;
2228                                 pNextTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(pEntry->CurrTxRateIndex+1)*5];
2229                                 MlmeSetTxRate(pAd, pEntry, pNextTxRate);
2230                         }
2231
2232                         NdisZeroMemory(pEntry->TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2233                         NdisZeroMemory(pEntry->PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2234                         pEntry->fLastSecAccordingRSSI = TRUE;
2235                         // reset all OneSecTx counters
2236                         RESET_ONE_SEC_TX_CNT(pEntry);
2237
2238                         continue;
2239                 }
2240
2241                 if (pEntry->fLastSecAccordingRSSI == TRUE)
2242                 {
2243                         pEntry->fLastSecAccordingRSSI = FALSE;
2244                         pEntry->LastSecTxRateChangeAction = 0;
2245                         // reset all OneSecTx counters
2246                         RESET_ONE_SEC_TX_CNT(pEntry);
2247
2248                         continue;
2249                 }
2250
2251                 do
2252                 {
2253                         BOOLEAN bTrainUpDown = FALSE;
2254
2255                         pEntry->CurrTxRateStableTime ++;
2256
2257                         // downgrade TX quality if PER >= Rate-Down threshold
2258                         if (TxErrorRatio >= TrainDown)
2259                         {
2260                                 bTrainUpDown = TRUE;
2261                                 pEntry->TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2262                         }
2263                         // upgrade TX quality if PER <= Rate-Up threshold
2264                         else if (TxErrorRatio <= TrainUp)
2265                         {
2266                                 bTrainUpDown = TRUE;
2267                                 bUpgradeQuality = TRUE;
2268                                 if (pEntry->TxQuality[CurrRateIdx])
2269                                         pEntry->TxQuality[CurrRateIdx] --;  // quality very good in CurrRate
2270
2271                                 if (pEntry->TxRateUpPenalty)
2272                                         pEntry->TxRateUpPenalty --;
2273                                 else if (pEntry->TxQuality[UpRateIdx])
2274                                         pEntry->TxQuality[UpRateIdx] --;    // may improve next UP rate's quality
2275                         }
2276
2277                         pEntry->PER[CurrRateIdx] = (UCHAR)TxErrorRatio;
2278
2279                         if (bTrainUpDown)
2280                         {
2281                                 // perform DRS - consider TxRate Down first, then rate up.
2282                                 if ((CurrRateIdx != DownRateIdx) && (pEntry->TxQuality[CurrRateIdx] >= DRS_TX_QUALITY_WORST_BOUND))
2283                                 {
2284                                         pEntry->CurrTxRateIndex = DownRateIdx;
2285                                 }
2286                                 else if ((CurrRateIdx != UpRateIdx) && (pEntry->TxQuality[UpRateIdx] <= 0))
2287                                 {
2288                                         pEntry->CurrTxRateIndex = UpRateIdx;
2289                                 }
2290                         }
2291                 } while (FALSE);
2292
2293                 // if rate-up happen, clear all bad history of all TX rates
2294                 if (pEntry->CurrTxRateIndex > CurrRateIdx)
2295                 {
2296                         pEntry->CurrTxRateStableTime = 0;
2297                         pEntry->TxRateUpPenalty = 0;
2298                         pEntry->LastSecTxRateChangeAction = 1; // rate UP
2299                         NdisZeroMemory(pEntry->TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2300                         NdisZeroMemory(pEntry->PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2301
2302                         //
2303                         // For TxRate fast train up
2304                         //
2305                         if (!pAd->StaCfg.StaQuickResponeForRateUpTimerRunning)
2306                         {
2307                                 RTMPSetTimer(&pAd->StaCfg.StaQuickResponeForRateUpTimer, 100);
2308
2309                                 pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = TRUE;
2310                         }
2311                         bTxRateChanged = TRUE;
2312                 }
2313                 // if rate-down happen, only clear DownRate's bad history
2314                 else if (pEntry->CurrTxRateIndex < CurrRateIdx)
2315                 {
2316                         pEntry->CurrTxRateStableTime = 0;
2317                         pEntry->TxRateUpPenalty = 0;           // no penalty
2318                         pEntry->LastSecTxRateChangeAction = 2; // rate DOWN
2319                         pEntry->TxQuality[pEntry->CurrTxRateIndex] = 0;
2320                         pEntry->PER[pEntry->CurrTxRateIndex] = 0;
2321
2322                         //
2323                         // For TxRate fast train down
2324                         //
2325                         if (!pAd->StaCfg.StaQuickResponeForRateUpTimerRunning)
2326                         {
2327                                 RTMPSetTimer(&pAd->StaCfg.StaQuickResponeForRateUpTimer, 100);
2328
2329                                 pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = TRUE;
2330                         }
2331                         bTxRateChanged = TRUE;
2332                 }
2333                 else
2334                 {
2335                         pEntry->LastSecTxRateChangeAction = 0; // rate no change
2336                         bTxRateChanged = FALSE;
2337                 }
2338
2339                 pEntry->LastTxOkCount = TxSuccess;
2340
2341                 // reset all OneSecTx counters
2342                 RESET_ONE_SEC_TX_CNT(pEntry);
2343
2344                 pNextTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(pEntry->CurrTxRateIndex+1)*5];
2345                 if (bTxRateChanged && pNextTxRate)
2346                 {
2347                         MlmeSetTxRate(pAd, pEntry, pNextTxRate);
2348                 }
2349         }
2350 }
2351
2352 /*
2353         ========================================================================
2354         Routine Description:
2355                 Station side, Auto TxRate faster train up timer call back function.
2356
2357         Arguments:
2358                 SystemSpecific1                 - Not used.
2359                 FunctionContext                 - Pointer to our Adapter context.
2360                 SystemSpecific2                 - Not used.
2361                 SystemSpecific3                 - Not used.
2362
2363         Return Value:
2364                 None
2365
2366         ========================================================================
2367 */
2368 VOID StaQuickResponeForRateUpExec(
2369         IN PVOID SystemSpecific1,
2370         IN PVOID FunctionContext,
2371         IN PVOID SystemSpecific2,
2372         IN PVOID SystemSpecific3)
2373 {
2374         PRTMP_ADAPTER                   pAd = (PRTMP_ADAPTER)FunctionContext;
2375         UCHAR                                   UpRateIdx = 0, DownRateIdx = 0, CurrRateIdx = 0;
2376         ULONG                                   TxTotalCnt;
2377         ULONG                                   TxErrorRatio = 0;
2378         BOOLEAN                                 bTxRateChanged; //, bUpgradeQuality = FALSE;
2379         PRTMP_TX_RATE_SWITCH    pCurrTxRate, pNextTxRate = NULL;
2380         PUCHAR                                  pTable;
2381         UCHAR                                   TableSize = 0;
2382         UCHAR                                   InitTxRateIdx = 0, TrainUp, TrainDown;
2383         TX_STA_CNT1_STRUC               StaTx1;
2384         TX_STA_CNT0_STRUC               TxStaCnt0;
2385         CHAR                                    Rssi, ratio;
2386         ULONG                                   TxRetransmit = 0, TxSuccess = 0, TxFailCount = 0;
2387         MAC_TABLE_ENTRY                 *pEntry;
2388         ULONG                                   i;
2389
2390         pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = FALSE;
2391
2392     //
2393     // walk through MAC table, see if need to change AP's TX rate toward each entry
2394     //
2395         for (i = 1; i < MAX_LEN_OF_MAC_TABLE; i++)
2396         {
2397                 pEntry = &pAd->MacTab.Content[i];
2398
2399                 // check if this entry need to switch rate automatically
2400                 if (RTMPCheckEntryEnableAutoRateSwitch(pAd, pEntry) == FALSE)
2401                         continue;
2402
2403                 if (INFRA_ON(pAd) && (i == 1))
2404                         Rssi = RTMPMaxRssi(pAd,
2405                                                            pAd->StaCfg.RssiSample.AvgRssi0,
2406                                                            pAd->StaCfg.RssiSample.AvgRssi1,
2407                                                            pAd->StaCfg.RssiSample.AvgRssi2);
2408                 else
2409                         Rssi = RTMPMaxRssi(pAd,
2410                                                            pEntry->RssiSample.AvgRssi0,
2411                                                            pEntry->RssiSample.AvgRssi1,
2412                                                            pEntry->RssiSample.AvgRssi2);
2413
2414                 CurrRateIdx = pAd->CommonCfg.TxRateIndex;
2415
2416                         MlmeSelectTxRateTable(pAd, pEntry, &pTable, &TableSize, &InitTxRateIdx);
2417
2418                 // decide the next upgrade rate and downgrade rate, if any
2419                 if ((CurrRateIdx > 0) && (CurrRateIdx < (TableSize - 1)))
2420                 {
2421                         UpRateIdx = CurrRateIdx + 1;
2422                         DownRateIdx = CurrRateIdx -1;
2423                 }
2424                 else if (CurrRateIdx == 0)
2425                 {
2426                         UpRateIdx = CurrRateIdx + 1;
2427                         DownRateIdx = CurrRateIdx;
2428                 }
2429                 else if (CurrRateIdx == (TableSize - 1))
2430                 {
2431                         UpRateIdx = CurrRateIdx;
2432                         DownRateIdx = CurrRateIdx - 1;
2433                 }
2434
2435                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(CurrRateIdx+1)*5];
2436
2437 #ifdef DOT11_N_SUPPORT
2438                 if ((Rssi > -65) && (pCurrTxRate->Mode >= MODE_HTMIX))
2439                 {
2440                         TrainUp         = (pCurrTxRate->TrainUp + (pCurrTxRate->TrainUp >> 1));
2441                         TrainDown       = (pCurrTxRate->TrainDown + (pCurrTxRate->TrainDown >> 1));
2442                 }
2443                 else
2444 #endif // DOT11_N_SUPPORT //
2445                 {
2446                         TrainUp         = pCurrTxRate->TrainUp;
2447                         TrainDown       = pCurrTxRate->TrainDown;
2448                 }
2449
2450                 if (pAd->MacTab.Size == 1)
2451                 {
2452                         // Update statistic counter
2453                         RTMP_IO_READ32(pAd, TX_STA_CNT0, &TxStaCnt0.word);
2454                         RTMP_IO_READ32(pAd, TX_STA_CNT1, &StaTx1.word);
2455
2456                         TxRetransmit = StaTx1.field.TxRetransmit;
2457                         TxSuccess = StaTx1.field.TxSuccess;
2458                         TxFailCount = TxStaCnt0.field.TxFailCount;
2459                         TxTotalCnt = TxRetransmit + TxSuccess + TxFailCount;
2460
2461                         pAd->RalinkCounters.OneSecTxRetryOkCount += StaTx1.field.TxRetransmit;
2462                         pAd->RalinkCounters.OneSecTxNoRetryOkCount += StaTx1.field.TxSuccess;
2463                         pAd->RalinkCounters.OneSecTxFailCount += TxStaCnt0.field.TxFailCount;
2464                         pAd->WlanCounters.TransmittedFragmentCount.u.LowPart += StaTx1.field.TxSuccess;
2465                         pAd->WlanCounters.RetryCount.u.LowPart += StaTx1.field.TxRetransmit;
2466                         pAd->WlanCounters.FailedCount.u.LowPart += TxStaCnt0.field.TxFailCount;
2467
2468 #if 0 // test by Gary.
2469                         // if no traffic in the past 1-sec period, don't change TX rate,
2470                         // but clear all bad history. because the bad history may affect the next
2471                         // Chariot throughput test
2472                         TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
2473                                                  pAd->RalinkCounters.OneSecTxRetryOkCount +
2474                                                  pAd->RalinkCounters.OneSecTxFailCount;
2475 #endif
2476                         if (TxTotalCnt)
2477                                 TxErrorRatio = ((TxRetransmit + TxFailCount) * 100) / TxTotalCnt;
2478                 }
2479                 else
2480                 {
2481                         TxTotalCnt = pEntry->OneSecTxNoRetryOkCount +
2482                                  pEntry->OneSecTxRetryOkCount +
2483                                  pEntry->OneSecTxFailCount;
2484
2485                         if (TxTotalCnt)
2486                                 TxErrorRatio = ((pEntry->OneSecTxRetryOkCount + pEntry->OneSecTxFailCount) * 100) / TxTotalCnt;
2487                 }
2488
2489
2490                 //
2491                 // CASE 1. when TX samples are fewer than 15, then decide TX rate solely on RSSI
2492                 //         (criteria copied from RT2500 for Netopia case)
2493                 //
2494                 if (TxTotalCnt <= 12)
2495                 {
2496                         NdisZeroMemory(pAd->DrsCounters.TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2497                         NdisZeroMemory(pAd->DrsCounters.PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2498
2499                         if ((pAd->DrsCounters.LastSecTxRateChangeAction == 1) && (CurrRateIdx != DownRateIdx))
2500                         {
2501                                 pAd->CommonCfg.TxRateIndex = DownRateIdx;
2502                                 pAd->DrsCounters.TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2503                         }
2504                         else if ((pAd->DrsCounters.LastSecTxRateChangeAction == 2) && (CurrRateIdx != UpRateIdx))
2505                         {
2506                                 pAd->CommonCfg.TxRateIndex = UpRateIdx;
2507                         }
2508
2509                         DBGPRINT_RAW(RT_DEBUG_TRACE,("QuickDRS: TxTotalCnt <= 15, train back to original rate \n"));
2510                         return;
2511                 }
2512
2513                 do
2514                 {
2515                         ULONG OneSecTxNoRetryOKRationCount;
2516
2517                         if (pAd->DrsCounters.LastTimeTxRateChangeAction == 0)
2518                                 ratio = 5;
2519                         else
2520                                 ratio = 4;
2521
2522                         // downgrade TX quality if PER >= Rate-Down threshold
2523                         if (TxErrorRatio >= TrainDown)
2524                         {
2525                                 pAd->DrsCounters.TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2526                         }
2527
2528                         pAd->DrsCounters.PER[CurrRateIdx] = (UCHAR)TxErrorRatio;
2529
2530                         OneSecTxNoRetryOKRationCount = (TxSuccess * ratio);
2531
2532                         // perform DRS - consider TxRate Down first, then rate up.
2533                         if ((pAd->DrsCounters.LastSecTxRateChangeAction == 1) && (CurrRateIdx != DownRateIdx))
2534                         {
2535                                 if ((pAd->DrsCounters.LastTxOkCount + 2) >= OneSecTxNoRetryOKRationCount)
2536                                 {
2537                                         pAd->CommonCfg.TxRateIndex = DownRateIdx;
2538                                         pAd->DrsCounters.TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2539
2540                                 }
2541
2542                         }
2543                         else if ((pAd->DrsCounters.LastSecTxRateChangeAction == 2) && (CurrRateIdx != UpRateIdx))
2544                         {
2545                                 if ((TxErrorRatio >= 50) || (TxErrorRatio >= TrainDown))
2546                                 {
2547
2548                                 }
2549                                 else if ((pAd->DrsCounters.LastTxOkCount + 2) >= OneSecTxNoRetryOKRationCount)
2550                                 {
2551                                         pAd->CommonCfg.TxRateIndex = UpRateIdx;
2552                                 }
2553                         }
2554                 }while (FALSE);
2555
2556                 // if rate-up happen, clear all bad history of all TX rates
2557                 if (pAd->CommonCfg.TxRateIndex > CurrRateIdx)
2558                 {
2559                         pAd->DrsCounters.TxRateUpPenalty = 0;
2560                         NdisZeroMemory(pAd->DrsCounters.TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2561                         NdisZeroMemory(pAd->DrsCounters.PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2562                         bTxRateChanged = TRUE;
2563                 }
2564                 // if rate-down happen, only clear DownRate's bad history
2565                 else if (pAd->CommonCfg.TxRateIndex < CurrRateIdx)
2566                 {
2567                         DBGPRINT_RAW(RT_DEBUG_TRACE,("QuickDRS: --TX rate from %d to %d \n", CurrRateIdx, pAd->CommonCfg.TxRateIndex));
2568
2569                         pAd->DrsCounters.TxRateUpPenalty = 0;           // no penalty
2570                         pAd->DrsCounters.TxQuality[pAd->CommonCfg.TxRateIndex] = 0;
2571                         pAd->DrsCounters.PER[pAd->CommonCfg.TxRateIndex] = 0;
2572                         bTxRateChanged = TRUE;
2573                 }
2574                 else
2575                 {
2576                         bTxRateChanged = FALSE;
2577                 }
2578
2579                 pNextTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(pAd->CommonCfg.TxRateIndex+1)*5];
2580                 if (bTxRateChanged && pNextTxRate)
2581                 {
2582                         MlmeSetTxRate(pAd, pEntry, pNextTxRate);
2583                 }
2584         }
2585 }
2586
2587 /*
2588         ==========================================================================
2589         Description:
2590                 This routine is executed periodically inside MlmePeriodicExec() after
2591                 association with an AP.
2592                 It checks if StaCfg.Psm is consistent with user policy (recorded in
2593                 StaCfg.WindowsPowerMode). If not, enforce user policy. However,
2594                 there're some conditions to consider:
2595                 1. we don't support power-saving in ADHOC mode, so Psm=PWR_ACTIVE all
2596                    the time when Mibss==TRUE
2597                 2. When link up in INFRA mode, Psm should not be switch to PWR_SAVE
2598                    if outgoing traffic available in TxRing or MgmtRing.
2599         Output:
2600                 1. change pAd->StaCfg.Psm to PWR_SAVE or leave it untouched
2601
2602         IRQL = DISPATCH_LEVEL
2603
2604         ==========================================================================
2605  */
2606 VOID MlmeCheckPsmChange(
2607         IN PRTMP_ADAPTER pAd,
2608         IN ULONG        Now32)
2609 {
2610         ULONG   PowerMode;
2611
2612         // condition -
2613         // 1. Psm maybe ON only happen in INFRASTRUCTURE mode
2614         // 2. user wants either MAX_PSP or FAST_PSP
2615         // 3. but current psm is not in PWR_SAVE
2616         // 4. CNTL state machine is not doing SCANning
2617         // 5. no TX SUCCESS event for the past 1-sec period
2618 #ifdef NDIS51_MINIPORT
2619         if (pAd->StaCfg.WindowsPowerProfile == NdisPowerProfileBattery)
2620                 PowerMode = pAd->StaCfg.WindowsBatteryPowerMode;
2621         else
2622 #endif
2623                 PowerMode = pAd->StaCfg.WindowsPowerMode;
2624
2625         if (INFRA_ON(pAd) &&
2626                 (PowerMode != Ndis802_11PowerModeCAM) &&
2627                 (pAd->StaCfg.Psm == PWR_ACTIVE) &&
2628 //              (! RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
2629                 (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE) /*&&
2630                 (pAd->RalinkCounters.OneSecTxNoRetryOkCount == 0) &&
2631                 (pAd->RalinkCounters.OneSecTxRetryOkCount == 0)*/)
2632         {
2633                 NdisGetSystemUpTime(&pAd->Mlme.LastSendNULLpsmTime);
2634                 pAd->RalinkCounters.RxCountSinceLastNULL = 0;
2635                 MlmeSetPsmBit(pAd, PWR_SAVE);
2636                 if (!(pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable))
2637                 {
2638                         RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, FALSE);
2639                 }
2640                 else
2641                 {
2642                         RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
2643                 }
2644         }
2645 }
2646
2647 // IRQL = PASSIVE_LEVEL
2648 // IRQL = DISPATCH_LEVEL
2649 VOID MlmeSetPsmBit(
2650         IN PRTMP_ADAPTER pAd,
2651         IN USHORT psm)
2652 {
2653         AUTO_RSP_CFG_STRUC csr4;
2654
2655         pAd->StaCfg.Psm = psm;
2656         RTMP_IO_READ32(pAd, AUTO_RSP_CFG, &csr4.word);
2657         csr4.field.AckCtsPsmBit = (psm == PWR_SAVE)? 1:0;
2658         RTMP_IO_WRITE32(pAd, AUTO_RSP_CFG, csr4.word);
2659         DBGPRINT(RT_DEBUG_TRACE, ("MlmeSetPsmBit = %d\n", psm));
2660 }
2661 #endif // CONFIG_STA_SUPPORT //
2662
2663
2664 // IRQL = DISPATCH_LEVEL
2665 VOID MlmeSetTxPreamble(
2666         IN PRTMP_ADAPTER pAd,
2667         IN USHORT TxPreamble)
2668 {
2669         AUTO_RSP_CFG_STRUC csr4;
2670
2671         //
2672         // Always use Long preamble before verifiation short preamble functionality works well.
2673         // Todo: remove the following line if short preamble functionality works
2674         //
2675         //TxPreamble = Rt802_11PreambleLong;
2676
2677         RTMP_IO_READ32(pAd, AUTO_RSP_CFG, &csr4.word);
2678         if (TxPreamble == Rt802_11PreambleLong)
2679         {
2680                 DBGPRINT(RT_DEBUG_TRACE, ("MlmeSetTxPreamble (= LONG PREAMBLE)\n"));
2681                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);
2682                 csr4.field.AutoResponderPreamble = 0;
2683         }
2684         else
2685         {
2686                 // NOTE: 1Mbps should always use long preamble
2687                 DBGPRINT(RT_DEBUG_TRACE, ("MlmeSetTxPreamble (= SHORT PREAMBLE)\n"));
2688                 OPSTATUS_SET_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);
2689                 csr4.field.AutoResponderPreamble = 1;
2690         }
2691
2692         RTMP_IO_WRITE32(pAd, AUTO_RSP_CFG, csr4.word);
2693 }
2694
2695 /*
2696     ==========================================================================
2697     Description:
2698         Update basic rate bitmap
2699     ==========================================================================
2700  */
2701
2702 VOID UpdateBasicRateBitmap(
2703     IN  PRTMP_ADAPTER   pAdapter)
2704 {
2705     INT  i, j;
2706                   /* 1  2  5.5, 11,  6,  9, 12, 18, 24, 36, 48,  54 */
2707     UCHAR rate[] = { 2, 4,  11, 22, 12, 18, 24, 36, 48, 72, 96, 108 };
2708     UCHAR *sup_p = pAdapter->CommonCfg.SupRate;
2709     UCHAR *ext_p = pAdapter->CommonCfg.ExtRate;
2710     ULONG bitmap = pAdapter->CommonCfg.BasicRateBitmap;
2711
2712
2713     /* if A mode, always use fix BasicRateBitMap */
2714     //if (pAdapter->CommonCfg.Channel == PHY_11A)
2715         if (pAdapter->CommonCfg.Channel > 14)
2716         pAdapter->CommonCfg.BasicRateBitmap = 0x150; /* 6, 12, 24M */
2717     /* End of if */
2718
2719     if (pAdapter->CommonCfg.BasicRateBitmap > 4095)
2720     {
2721         /* (2 ^ MAX_LEN_OF_SUPPORTED_RATES) -1 */
2722         return;
2723     } /* End of if */
2724
2725     for(i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2726     {
2727         sup_p[i] &= 0x7f;
2728         ext_p[i] &= 0x7f;
2729     } /* End of for */
2730
2731     for(i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2732     {
2733         if (bitmap & (1 << i))
2734         {
2735             for(j=0; j<MAX_LEN_OF_SUPPORTED_RATES; j++)
2736             {
2737                 if (sup_p[j] == rate[i])
2738                     sup_p[j] |= 0x80;
2739                 /* End of if */
2740             } /* End of for */
2741
2742             for(j=0; j<MAX_LEN_OF_SUPPORTED_RATES; j++)
2743             {
2744                 if (ext_p[j] == rate[i])
2745                     ext_p[j] |= 0x80;
2746                 /* End of if */
2747             } /* End of for */
2748         } /* End of if */
2749     } /* End of for */
2750 } /* End of UpdateBasicRateBitmap */
2751
2752 // IRQL = PASSIVE_LEVEL
2753 // IRQL = DISPATCH_LEVEL
2754 // bLinkUp is to identify the inital link speed.
2755 // TRUE indicates the rate update at linkup, we should not try to set the rate at 54Mbps.
2756 VOID MlmeUpdateTxRates(
2757         IN PRTMP_ADAPTER                pAd,
2758         IN      BOOLEAN                         bLinkUp,
2759         IN      UCHAR                           apidx)
2760 {
2761         int i, num;
2762         UCHAR Rate = RATE_6, MaxDesire = RATE_1, MaxSupport = RATE_1;
2763         UCHAR MinSupport = RATE_54;
2764         ULONG BasicRateBitmap = 0;
2765         UCHAR CurrBasicRate = RATE_1;
2766         UCHAR *pSupRate, SupRateLen, *pExtRate, ExtRateLen;
2767         PHTTRANSMIT_SETTING             pHtPhy = NULL;
2768         PHTTRANSMIT_SETTING             pMaxHtPhy = NULL;
2769         PHTTRANSMIT_SETTING             pMinHtPhy = NULL;
2770         BOOLEAN                                 *auto_rate_cur_p;
2771         UCHAR                                   HtMcs = MCS_AUTO;
2772
2773         // find max desired rate
2774         UpdateBasicRateBitmap(pAd);
2775
2776         num = 0;
2777         auto_rate_cur_p = NULL;
2778         for (i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2779         {
2780                 switch (pAd->CommonCfg.DesireRate[i] & 0x7f)
2781                 {
2782                         case 2:  Rate = RATE_1;   num++;   break;
2783                         case 4:  Rate = RATE_2;   num++;   break;
2784                         case 11: Rate = RATE_5_5; num++;   break;
2785                         case 22: Rate = RATE_11;  num++;   break;
2786                         case 12: Rate = RATE_6;   num++;   break;
2787                         case 18: Rate = RATE_9;   num++;   break;
2788                         case 24: Rate = RATE_12;  num++;   break;
2789                         case 36: Rate = RATE_18;  num++;   break;
2790                         case 48: Rate = RATE_24;  num++;   break;
2791                         case 72: Rate = RATE_36;  num++;   break;
2792                         case 96: Rate = RATE_48;  num++;   break;
2793                         case 108: Rate = RATE_54; num++;   break;
2794                         //default: Rate = RATE_1;   break;
2795                 }
2796                 if (MaxDesire < Rate)  MaxDesire = Rate;
2797         }
2798
2799 //===========================================================================
2800 //===========================================================================
2801
2802 #ifdef CONFIG_STA_SUPPORT
2803         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2804         {
2805                 pHtPhy          = &pAd->StaCfg.HTPhyMode;
2806                 pMaxHtPhy       = &pAd->StaCfg.MaxHTPhyMode;
2807                 pMinHtPhy       = &pAd->StaCfg.MinHTPhyMode;
2808
2809                 auto_rate_cur_p = &pAd->StaCfg.bAutoTxRateSwitch;
2810                 HtMcs           = pAd->StaCfg.DesiredTransmitSetting.field.MCS;
2811
2812                 if ((pAd->StaCfg.BssType == BSS_ADHOC) &&
2813                         (pAd->CommonCfg.PhyMode == PHY_11B) &&
2814                         (MaxDesire > RATE_11))
2815                 {
2816                         MaxDesire = RATE_11;
2817                 }
2818         }
2819 #endif // CONFIG_STA_SUPPORT //
2820
2821         pAd->CommonCfg.MaxDesiredRate = MaxDesire;
2822         pMinHtPhy->word = 0;
2823         pMaxHtPhy->word = 0;
2824         pHtPhy->word = 0;
2825
2826         // Auto rate switching is enabled only if more than one DESIRED RATES are
2827         // specified; otherwise disabled
2828         if (num <= 1)
2829         {
2830                 //OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2831                 //pAd->CommonCfg.bAutoTxRateSwitch      = FALSE;
2832                 *auto_rate_cur_p = FALSE;
2833         }
2834         else
2835         {
2836                 //OPSTATUS_SET_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2837                 //pAd->CommonCfg.bAutoTxRateSwitch      = TRUE;
2838                 *auto_rate_cur_p = TRUE;
2839         }
2840
2841 #if 1
2842         if (HtMcs != MCS_AUTO)
2843         {
2844                 //OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2845                 //pAd->CommonCfg.bAutoTxRateSwitch      = FALSE;
2846                 *auto_rate_cur_p = FALSE;
2847         }
2848         else
2849         {
2850                 //OPSTATUS_SET_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2851                 //pAd->CommonCfg.bAutoTxRateSwitch      = TRUE;
2852                 *auto_rate_cur_p = TRUE;
2853         }
2854 #endif
2855
2856 #ifdef CONFIG_STA_SUPPORT
2857         if ((ADHOC_ON(pAd) || INFRA_ON(pAd)) && (pAd->OpMode == OPMODE_STA))
2858         {
2859                 pSupRate = &pAd->StaActive.SupRate[0];
2860                 pExtRate = &pAd->StaActive.ExtRate[0];
2861                 SupRateLen = pAd->StaActive.SupRateLen;
2862                 ExtRateLen = pAd->StaActive.ExtRateLen;
2863         }
2864         else
2865 #endif // CONFIG_STA_SUPPORT //
2866         {
2867                 pSupRate = &pAd->CommonCfg.SupRate[0];
2868                 pExtRate = &pAd->CommonCfg.ExtRate[0];
2869                 SupRateLen = pAd->CommonCfg.SupRateLen;
2870                 ExtRateLen = pAd->CommonCfg.ExtRateLen;
2871         }
2872
2873         // find max supported rate
2874         for (i=0; i<SupRateLen; i++)
2875         {
2876                 switch (pSupRate[i] & 0x7f)
2877                 {
2878                         case 2:   Rate = RATE_1;        if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0001;       break;
2879                         case 4:   Rate = RATE_2;        if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0002;       break;
2880                         case 11:  Rate = RATE_5_5;      if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0004;       break;
2881                         case 22:  Rate = RATE_11;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0008;       break;
2882                         case 12:  Rate = RATE_6;        /*if (pSupRate[i] & 0x80)*/  BasicRateBitmap |= 0x0010;  break;
2883                         case 18:  Rate = RATE_9;        if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0020;       break;
2884                         case 24:  Rate = RATE_12;       /*if (pSupRate[i] & 0x80)*/  BasicRateBitmap |= 0x0040;  break;
2885                         case 36:  Rate = RATE_18;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0080;       break;
2886                         case 48:  Rate = RATE_24;       /*if (pSupRate[i] & 0x80)*/  BasicRateBitmap |= 0x0100;  break;
2887                         case 72:  Rate = RATE_36;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0200;       break;
2888                         case 96:  Rate = RATE_48;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0400;       break;
2889                         case 108: Rate = RATE_54;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0800;       break;
2890                         default:  Rate = RATE_1;        break;
2891                 }
2892                 if (MaxSupport < Rate)  MaxSupport = Rate;
2893
2894                 if (MinSupport > Rate) MinSupport = Rate;
2895         }
2896
2897         for (i=0; i<ExtRateLen; i++)
2898         {
2899                 switch (pExtRate[i] & 0x7f)
2900                 {
2901                         case 2:   Rate = RATE_1;        if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0001;       break;
2902                         case 4:   Rate = RATE_2;        if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0002;       break;
2903                         case 11:  Rate = RATE_5_5;      if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0004;       break;
2904                         case 22:  Rate = RATE_11;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0008;       break;
2905                         case 12:  Rate = RATE_6;        /*if (pExtRate[i] & 0x80)*/  BasicRateBitmap |= 0x0010;  break;
2906                         case 18:  Rate = RATE_9;        if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0020;       break;
2907                         case 24:  Rate = RATE_12;       /*if (pExtRate[i] & 0x80)*/  BasicRateBitmap |= 0x0040;  break;
2908                         case 36:  Rate = RATE_18;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0080;       break;
2909                         case 48:  Rate = RATE_24;       /*if (pExtRate[i] & 0x80)*/  BasicRateBitmap |= 0x0100;  break;
2910                         case 72:  Rate = RATE_36;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0200;       break;
2911                         case 96:  Rate = RATE_48;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0400;       break;
2912                         case 108: Rate = RATE_54;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0800;       break;
2913                         default:  Rate = RATE_1;        break;
2914                 }
2915                 if (MaxSupport < Rate)  MaxSupport = Rate;
2916
2917                 if (MinSupport > Rate) MinSupport = Rate;
2918         }
2919
2920         RTMP_IO_WRITE32(pAd, LEGACY_BASIC_RATE, BasicRateBitmap);
2921
2922         // bug fix
2923         // pAd->CommonCfg.BasicRateBitmap = BasicRateBitmap;
2924
2925         // calculate the exptected ACK rate for each TX rate. This info is used to caculate
2926         // the DURATION field of outgoing uniicast DATA/MGMT frame
2927         for (i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2928         {
2929                 if (BasicRateBitmap & (0x01 << i))
2930                         CurrBasicRate = (UCHAR)i;
2931                 pAd->CommonCfg.ExpectedACKRate[i] = CurrBasicRate;
2932         }
2933
2934         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateTxRates[MaxSupport = %d] = MaxDesire %d Mbps\n", RateIdToMbps[MaxSupport], RateIdToMbps[MaxDesire]));
2935         // max tx rate = min {max desire rate, max supported rate}
2936         if (MaxSupport < MaxDesire)
2937                 pAd->CommonCfg.MaxTxRate = MaxSupport;
2938         else
2939                 pAd->CommonCfg.MaxTxRate = MaxDesire;
2940
2941         pAd->CommonCfg.MinTxRate = MinSupport;
2942         // 2003-07-31 john - 2500 doesn't have good sensitivity at high OFDM rates. to increase the success
2943         // ratio of initial DHCP packet exchange, TX rate starts from a lower rate depending
2944         // on average RSSI
2945         //       1. RSSI >= -70db, start at 54 Mbps (short distance)
2946         //       2. -70 > RSSI >= -75, start at 24 Mbps (mid distance)
2947         //       3. -75 > RSSI, start at 11 Mbps (long distance)
2948         //if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED)/* &&
2949         //      OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)*/)
2950         if (*auto_rate_cur_p)
2951         {
2952                 short dbm = 0;
2953 #ifdef CONFIG_STA_SUPPORT
2954                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2955                         dbm = pAd->StaCfg.RssiSample.AvgRssi0 - pAd->BbpRssiToDbmDelta;
2956 #endif // CONFIG_STA_SUPPORT //
2957                 if (bLinkUp == TRUE)
2958                         pAd->CommonCfg.TxRate = RATE_24;
2959                 else
2960                         pAd->CommonCfg.TxRate = pAd->CommonCfg.MaxTxRate;
2961
2962                 if (dbm < -75)
2963                         pAd->CommonCfg.TxRate = RATE_11;
2964                 else if (dbm < -70)
2965                         pAd->CommonCfg.TxRate = RATE_24;
2966
2967                 // should never exceed MaxTxRate (consider 11B-only mode)
2968                 if (pAd->CommonCfg.TxRate > pAd->CommonCfg.MaxTxRate)
2969                         pAd->CommonCfg.TxRate = pAd->CommonCfg.MaxTxRate;
2970
2971                 pAd->CommonCfg.TxRateIndex = 0;
2972         }
2973         else
2974         {
2975                 pAd->CommonCfg.TxRate = pAd->CommonCfg.MaxTxRate;
2976                 pHtPhy->field.MCS       = (pAd->CommonCfg.MaxTxRate > 3) ? (pAd->CommonCfg.MaxTxRate - 4) : pAd->CommonCfg.MaxTxRate;
2977                 pHtPhy->field.MODE      = (pAd->CommonCfg.MaxTxRate > 3) ? MODE_OFDM : MODE_CCK;
2978
2979                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.STBC    = pHtPhy->field.STBC;
2980                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.ShortGI = pHtPhy->field.ShortGI;
2981                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MCS             = pHtPhy->field.MCS;
2982                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MODE    = pHtPhy->field.MODE;
2983         }
2984
2985         if (pAd->CommonCfg.TxRate <= RATE_11)
2986         {
2987                 pMaxHtPhy->field.MODE = MODE_CCK;
2988                 pMaxHtPhy->field.MCS = pAd->CommonCfg.TxRate;
2989                 pMinHtPhy->field.MCS = pAd->CommonCfg.MinTxRate;
2990         }
2991         else
2992         {
2993                 pMaxHtPhy->field.MODE = MODE_OFDM;
2994                 pMaxHtPhy->field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.TxRate];
2995                 if (pAd->CommonCfg.MinTxRate >= RATE_6 && (pAd->CommonCfg.MinTxRate <= RATE_54))
2996                         {pMinHtPhy->field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MinTxRate];}
2997                 else
2998                         {pMinHtPhy->field.MCS = pAd->CommonCfg.MinTxRate;}
2999         }
3000
3001         pHtPhy->word = (pMaxHtPhy->word);
3002         if (bLinkUp && (pAd->OpMode == OPMODE_STA))
3003         {
3004                         pAd->MacTab.Content[BSSID_WCID].HTPhyMode.word = pHtPhy->word;
3005                         pAd->MacTab.Content[BSSID_WCID].MaxHTPhyMode.word = pMaxHtPhy->word;
3006                         pAd->MacTab.Content[BSSID_WCID].MinHTPhyMode.word = pMinHtPhy->word;
3007         }
3008         else
3009         {
3010                 switch (pAd->CommonCfg.PhyMode)
3011                 {
3012                         case PHY_11BG_MIXED:
3013                         case PHY_11B:
3014 #ifdef DOT11_N_SUPPORT
3015                         case PHY_11BGN_MIXED:
3016 #endif // DOT11_N_SUPPORT //
3017                                 pAd->CommonCfg.MlmeRate = RATE_1;
3018                                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_CCK;
3019                                 pAd->CommonCfg.MlmeTransmit.field.MCS = RATE_1;
3020
3021 //#ifdef        WIFI_TEST
3022                                 pAd->CommonCfg.RtsRate = RATE_11;
3023 //#else
3024 //                              pAd->CommonCfg.RtsRate = RATE_1;
3025 //#endif
3026                                 break;
3027                         case PHY_11G:
3028                         case PHY_11A:
3029 #ifdef DOT11_N_SUPPORT
3030                         case PHY_11AGN_MIXED:
3031                         case PHY_11GN_MIXED:
3032                         case PHY_11N_2_4G:
3033                         case PHY_11AN_MIXED:
3034                         case PHY_11N_5G:
3035 #endif // DOT11_N_SUPPORT //
3036                                 pAd->CommonCfg.MlmeRate = RATE_6;
3037                                 pAd->CommonCfg.RtsRate = RATE_6;
3038                                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3039                                 pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
3040                                 break;
3041                         case PHY_11ABG_MIXED:
3042 #ifdef DOT11_N_SUPPORT
3043                         case PHY_11ABGN_MIXED:
3044 #endif // DOT11_N_SUPPORT //
3045                                 if (pAd->CommonCfg.Channel <= 14)
3046                                 {
3047                                         pAd->CommonCfg.MlmeRate = RATE_1;
3048                                         pAd->CommonCfg.RtsRate = RATE_1;
3049                                         pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_CCK;
3050                                         pAd->CommonCfg.MlmeTransmit.field.MCS = RATE_1;
3051                                 }
3052                                 else
3053                                 {
3054                                         pAd->CommonCfg.MlmeRate = RATE_6;
3055                                         pAd->CommonCfg.RtsRate = RATE_6;
3056                                         pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3057                                         pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
3058                                 }
3059                                 break;
3060                         default: // error
3061                                 pAd->CommonCfg.MlmeRate = RATE_6;
3062                                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3063                                 pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
3064                                 pAd->CommonCfg.RtsRate = RATE_1;
3065                                 break;
3066                 }
3067                 //
3068                 // Keep Basic Mlme Rate.
3069                 //
3070                 pAd->MacTab.Content[MCAST_WCID].HTPhyMode.word = pAd->CommonCfg.MlmeTransmit.word;
3071                 if (pAd->CommonCfg.MlmeTransmit.field.MODE == MODE_OFDM)
3072                         pAd->MacTab.Content[MCAST_WCID].HTPhyMode.field.MCS = OfdmRateToRxwiMCS[RATE_24];
3073                 else
3074                         pAd->MacTab.Content[MCAST_WCID].HTPhyMode.field.MCS = RATE_1;
3075                 pAd->CommonCfg.BasicMlmeRate = pAd->CommonCfg.MlmeRate;
3076         }
3077
3078         DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateTxRates (MaxDesire=%d, MaxSupport=%d, MaxTxRate=%d, MinRate=%d, Rate Switching =%d)\n",
3079                          RateIdToMbps[MaxDesire], RateIdToMbps[MaxSupport], RateIdToMbps[pAd->CommonCfg.MaxTxRate], RateIdToMbps[pAd->CommonCfg.MinTxRate],
3080                          /*OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED)*/*auto_rate_cur_p));
3081         DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateTxRates (TxRate=%d, RtsRate=%d, BasicRateBitmap=0x%04lx)\n",
3082                          RateIdToMbps[pAd->CommonCfg.TxRate], RateIdToMbps[pAd->CommonCfg.RtsRate], BasicRateBitmap));
3083         DBGPRINT(RT_DEBUG_TRACE, ("MlmeUpdateTxRates (MlmeTransmit=0x%x, MinHTPhyMode=%x, MaxHTPhyMode=0x%x, HTPhyMode=0x%x)\n",
3084                          pAd->CommonCfg.MlmeTransmit.word, pAd->MacTab.Content[BSSID_WCID].MinHTPhyMode.word ,pAd->MacTab.Content[BSSID_WCID].MaxHTPhyMode.word ,pAd->MacTab.Content[BSSID_WCID].HTPhyMode.word ));
3085 }
3086
3087 #ifdef DOT11_N_SUPPORT
3088 /*
3089         ==========================================================================
3090         Description:
3091                 This function update HT Rate setting.
3092                 Input Wcid value is valid for 2 case :
3093                 1. it's used for Station in infra mode that copy AP rate to Mactable.
3094                 2. OR Station   in adhoc mode to copy peer's HT rate to Mactable.
3095
3096         IRQL = DISPATCH_LEVEL
3097
3098         ==========================================================================
3099  */
3100 VOID MlmeUpdateHtTxRates(
3101         IN PRTMP_ADAPTER                pAd,
3102         IN      UCHAR                           apidx)
3103 {
3104         UCHAR   StbcMcs; //j, StbcMcs, bitmask;
3105         CHAR    i; // 3*3
3106         RT_HT_CAPABILITY        *pRtHtCap = NULL;
3107         RT_HT_PHY_INFO          *pActiveHtPhy = NULL;
3108         ULONG           BasicMCS;
3109         UCHAR j, bitmask;
3110         PRT_HT_PHY_INFO                 pDesireHtPhy = NULL;
3111         PHTTRANSMIT_SETTING             pHtPhy = NULL;
3112         PHTTRANSMIT_SETTING             pMaxHtPhy = NULL;
3113         PHTTRANSMIT_SETTING             pMinHtPhy = NULL;
3114         BOOLEAN                                 *auto_rate_cur_p;
3115
3116         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateHtTxRates===> \n"));
3117
3118         auto_rate_cur_p = NULL;
3119
3120 #ifdef CONFIG_STA_SUPPORT
3121         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
3122         {
3123                 pDesireHtPhy    = &pAd->StaCfg.DesiredHtPhyInfo;
3124                 pActiveHtPhy    = &pAd->StaCfg.DesiredHtPhyInfo;
3125                 pHtPhy          = &pAd->StaCfg.HTPhyMode;
3126                 pMaxHtPhy       = &pAd->StaCfg.MaxHTPhyMode;
3127                 pMinHtPhy       = &pAd->StaCfg.MinHTPhyMode;
3128
3129                 auto_rate_cur_p = &pAd->StaCfg.bAutoTxRateSwitch;
3130         }
3131 #endif // CONFIG_STA_SUPPORT //
3132
3133 #ifdef CONFIG_STA_SUPPORT
3134         if ((ADHOC_ON(pAd) || INFRA_ON(pAd)) && (pAd->OpMode == OPMODE_STA))
3135         {
3136                 if (pAd->StaActive.SupportedPhyInfo.bHtEnable == FALSE)
3137                         return;
3138
3139                 pRtHtCap = &pAd->StaActive.SupportedHtPhy;
3140                 pActiveHtPhy = &pAd->StaActive.SupportedPhyInfo;
3141                 StbcMcs = (UCHAR)pAd->MlmeAux.AddHtInfo.AddHtInfo3.StbcMcs;
3142                 BasicMCS =pAd->MlmeAux.AddHtInfo.MCSSet[0]+(pAd->MlmeAux.AddHtInfo.MCSSet[1]<<8)+(StbcMcs<<16);
3143                 if ((pAd->CommonCfg.DesiredHtPhy.TxSTBC) && (pRtHtCap->RxSTBC) && (pAd->Antenna.field.TxPath == 2))
3144                         pMaxHtPhy->field.STBC = STBC_USE;
3145                 else
3146                         pMaxHtPhy->field.STBC = STBC_NONE;
3147         }
3148         else
3149 #endif // CONFIG_STA_SUPPORT //
3150         {
3151                 if (pDesireHtPhy->bHtEnable == FALSE)
3152                         return;
3153
3154                 pRtHtCap = &pAd->CommonCfg.DesiredHtPhy;
3155                 StbcMcs = (UCHAR)pAd->CommonCfg.AddHTInfo.AddHtInfo3.StbcMcs;
3156                 BasicMCS = pAd->CommonCfg.AddHTInfo.MCSSet[0]+(pAd->CommonCfg.AddHTInfo.MCSSet[1]<<8)+(StbcMcs<<16);
3157                 if ((pAd->CommonCfg.DesiredHtPhy.TxSTBC) && (pRtHtCap->RxSTBC) && (pAd->Antenna.field.TxPath == 2))
3158                         pMaxHtPhy->field.STBC = STBC_USE;
3159                 else
3160                         pMaxHtPhy->field.STBC = STBC_NONE;
3161         }
3162
3163         // Decide MAX ht rate.
3164         if ((pRtHtCap->GF) && (pAd->CommonCfg.DesiredHtPhy.GF))
3165                 pMaxHtPhy->field.MODE = MODE_HTGREENFIELD;
3166         else
3167                 pMaxHtPhy->field.MODE = MODE_HTMIX;
3168
3169     if ((pAd->CommonCfg.DesiredHtPhy.ChannelWidth) && (pRtHtCap->ChannelWidth))
3170                 pMaxHtPhy->field.BW = BW_40;
3171         else
3172                 pMaxHtPhy->field.BW = BW_20;
3173
3174     if (pMaxHtPhy->field.BW == BW_20)
3175                 pMaxHtPhy->field.ShortGI = (pAd->CommonCfg.DesiredHtPhy.ShortGIfor20 & pRtHtCap->ShortGIfor20);
3176         else
3177                 pMaxHtPhy->field.ShortGI = (pAd->CommonCfg.DesiredHtPhy.ShortGIfor40 & pRtHtCap->ShortGIfor40);
3178
3179         for (i=23; i>=0; i--) // 3*3
3180         {
3181                 j = i/8;
3182                 bitmask = (1<<(i-(j*8)));
3183
3184                 if ((pActiveHtPhy->MCSSet[j] & bitmask) && (pDesireHtPhy->MCSSet[j] & bitmask))
3185                 {
3186                         pMaxHtPhy->field.MCS = i;
3187                         break;
3188                 }
3189
3190                 if (i==0)
3191                         break;
3192         }
3193
3194         // Copy MIN ht rate.  rt2860???
3195         pMinHtPhy->field.BW = BW_20;
3196         pMinHtPhy->field.MCS = 0;
3197         pMinHtPhy->field.STBC = 0;
3198         pMinHtPhy->field.ShortGI = 0;
3199         //If STA assigns fixed rate. update to fixed here.
3200 #ifdef CONFIG_STA_SUPPORT
3201         if ( (pAd->OpMode == OPMODE_STA) && (pDesireHtPhy->MCSSet[0] != 0xff))
3202         {
3203                 if (pDesireHtPhy->MCSSet[4] != 0)
3204                 {
3205                         pMaxHtPhy->field.MCS = 32;
3206                         pMinHtPhy->field.MCS = 32;
3207                         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateHtTxRates<=== Use Fixed MCS = %d\n",pMinHtPhy->field.MCS));
3208                 }
3209
3210                 for (i=23; (CHAR)i >= 0; i--) // 3*3
3211                 {
3212                         j = i/8;
3213                         bitmask = (1<<(i-(j*8)));
3214                         if ( (pDesireHtPhy->MCSSet[j] & bitmask) && (pActiveHtPhy->MCSSet[j] & bitmask))
3215                         {
3216                                 pMaxHtPhy->field.MCS = i;
3217                                 pMinHtPhy->field.MCS = i;
3218                                 break;
3219                         }
3220                         if (i==0)
3221                                 break;
3222                 }
3223         }
3224 #endif // CONFIG_STA_SUPPORT //
3225
3226
3227         // Decide ht rate
3228         pHtPhy->field.STBC = pMaxHtPhy->field.STBC;
3229         pHtPhy->field.BW = pMaxHtPhy->field.BW;
3230         pHtPhy->field.MODE = pMaxHtPhy->field.MODE;
3231         pHtPhy->field.MCS = pMaxHtPhy->field.MCS;
3232         pHtPhy->field.ShortGI = pMaxHtPhy->field.ShortGI;
3233
3234         // use default now. rt2860
3235         if (pDesireHtPhy->MCSSet[0] != 0xff)
3236                 *auto_rate_cur_p = FALSE;
3237         else
3238                 *auto_rate_cur_p = TRUE;
3239
3240         DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateHtTxRates<---.AMsduSize = %d  \n", pAd->CommonCfg.DesiredHtPhy.AmsduSize ));
3241         DBGPRINT(RT_DEBUG_TRACE,("TX: MCS[0] = %x (choose %d), BW = %d, ShortGI = %d, MODE = %d,  \n", pActiveHtPhy->MCSSet[0],pHtPhy->field.MCS,
3242                 pHtPhy->field.BW, pHtPhy->field.ShortGI, pHtPhy->field.MODE));
3243         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateHtTxRates<=== \n"));
3244 }
3245 #endif // DOT11_N_SUPPORT //
3246
3247 // IRQL = DISPATCH_LEVEL
3248 VOID MlmeRadioOff(
3249         IN PRTMP_ADAPTER pAd)
3250 {
3251         RT28XX_MLME_RADIO_OFF(pAd);
3252 }
3253
3254 // IRQL = DISPATCH_LEVEL
3255 VOID MlmeRadioOn(
3256         IN PRTMP_ADAPTER pAd)
3257 {
3258         RT28XX_MLME_RADIO_ON(pAd);
3259 }
3260
3261 // ===========================================================================================
3262 // bss_table.c
3263 // ===========================================================================================
3264
3265
3266 /*! \brief initialize BSS table
3267  *      \param p_tab pointer to the table
3268  *      \return none
3269  *      \pre
3270  *      \post
3271
3272  IRQL = PASSIVE_LEVEL
3273  IRQL = DISPATCH_LEVEL
3274
3275  */
3276 VOID BssTableInit(
3277         IN BSS_TABLE *Tab)
3278 {
3279         int i;
3280
3281         Tab->BssNr = 0;
3282     Tab->BssOverlapNr = 0;
3283         for (i = 0; i < MAX_LEN_OF_BSS_TABLE; i++)
3284         {
3285                 NdisZeroMemory(&Tab->BssEntry[i], sizeof(BSS_ENTRY));
3286                 Tab->BssEntry[i].Rssi = -127;   // initial the rssi as a minimum value
3287         }
3288 }
3289
3290 #ifdef DOT11_N_SUPPORT
3291 VOID BATableInit(
3292         IN PRTMP_ADAPTER pAd,
3293     IN BA_TABLE *Tab)
3294 {
3295         int i;
3296
3297         Tab->numAsOriginator = 0;
3298         Tab->numAsRecipient = 0;
3299         NdisAllocateSpinLock(&pAd->BATabLock);
3300         for (i = 0; i < MAX_LEN_OF_BA_REC_TABLE; i++)
3301         {
3302                 Tab->BARecEntry[i].REC_BA_Status = Recipient_NONE;
3303                 NdisAllocateSpinLock(&(Tab->BARecEntry[i].RxReRingLock));
3304         }
3305         for (i = 0; i < MAX_LEN_OF_BA_ORI_TABLE; i++)
3306         {
3307                 Tab->BAOriEntry[i].ORI_BA_Status = Originator_NONE;
3308         }
3309 }
3310 #endif // DOT11_N_SUPPORT //
3311
3312 /*! \brief search the BSS table by SSID
3313  *      \param p_tab pointer to the bss table
3314  *      \param ssid SSID string
3315  *      \return index of the table, BSS_NOT_FOUND if not in the table
3316  *      \pre
3317  *      \post
3318  *      \note search by sequential search
3319
3320  IRQL = DISPATCH_LEVEL
3321
3322  */
3323 ULONG BssTableSearch(
3324         IN BSS_TABLE *Tab,
3325         IN PUCHAR        pBssid,
3326         IN UCHAR         Channel)
3327 {
3328         UCHAR i;
3329
3330         for (i = 0; i < Tab->BssNr; i++)
3331         {
3332                 //
3333                 // Some AP that support A/B/G mode that may used the same BSSID on 11A and 11B/G.
3334                 // We should distinguish this case.
3335                 //
3336                 if ((((Tab->BssEntry[i].Channel <= 14) && (Channel <= 14)) ||
3337                          ((Tab->BssEntry[i].Channel > 14) && (Channel > 14))) &&
3338                         MAC_ADDR_EQUAL(Tab->BssEntry[i].Bssid, pBssid))
3339                 {
3340                         return i;
3341                 }
3342         }
3343         return (ULONG)BSS_NOT_FOUND;
3344 }
3345
3346 ULONG BssSsidTableSearch(
3347         IN BSS_TABLE *Tab,
3348         IN PUCHAR        pBssid,
3349         IN PUCHAR        pSsid,
3350         IN UCHAR         SsidLen,
3351         IN UCHAR         Channel)
3352 {
3353         UCHAR i;
3354
3355         for (i = 0; i < Tab->BssNr; i++)
3356         {
3357                 //
3358                 // Some AP that support A/B/G mode that may used the same BSSID on 11A and 11B/G.
3359                 // We should distinguish this case.
3360                 //
3361                 if ((((Tab->BssEntry[i].Channel <= 14) && (Channel <= 14)) ||
3362                          ((Tab->BssEntry[i].Channel > 14) && (Channel > 14))) &&
3363                         MAC_ADDR_EQUAL(Tab->BssEntry[i].Bssid, pBssid) &&
3364                         SSID_EQUAL(pSsid, SsidLen, Tab->BssEntry[i].Ssid, Tab->BssEntry[i].SsidLen))
3365                 {
3366                         return i;
3367                 }
3368         }
3369         return (ULONG)BSS_NOT_FOUND;
3370 }
3371
3372 ULONG BssTableSearchWithSSID(
3373         IN BSS_TABLE *Tab,
3374         IN PUCHAR        Bssid,
3375         IN PUCHAR        pSsid,
3376         IN UCHAR         SsidLen,
3377         IN UCHAR         Channel)
3378 {
3379         UCHAR i;
3380
3381         for (i = 0; i < Tab->BssNr; i++)
3382         {
3383                 if ((((Tab->BssEntry[i].Channel <= 14) && (Channel <= 14)) ||
3384                         ((Tab->BssEntry[i].Channel > 14) && (Channel > 14))) &&
3385                         MAC_ADDR_EQUAL(&(Tab->BssEntry[i].Bssid), Bssid) &&
3386                         (SSID_EQUAL(pSsid, SsidLen, Tab->BssEntry[i].Ssid, Tab->BssEntry[i].SsidLen) ||
3387                         (NdisEqualMemory(pSsid, ZeroSsid, SsidLen)) ||
3388                         (NdisEqualMemory(Tab->BssEntry[i].Ssid, ZeroSsid, Tab->BssEntry[i].SsidLen))))
3389                 {
3390                         return i;
3391                 }
3392         }
3393         return (ULONG)BSS_NOT_FOUND;
3394 }
3395
3396 // IRQL = DISPATCH_LEVEL
3397 VOID BssTableDeleteEntry(
3398         IN OUT  BSS_TABLE *Tab,
3399         IN              PUCHAR    pBssid,
3400         IN              UCHAR     Channel)
3401 {
3402         UCHAR i, j;
3403
3404         for (i = 0; i < Tab->BssNr; i++)
3405         {
3406                 if ((Tab->BssEntry[i].Channel == Channel) &&
3407                         (MAC_ADDR_EQUAL(Tab->BssEntry[i].Bssid, pBssid)))
3408                 {
3409                         for (j = i; j < Tab->BssNr - 1; j++)
3410                         {
3411                                 NdisMoveMemory(&(Tab->BssEntry[j]), &(Tab->BssEntry[j + 1]), sizeof(BSS_ENTRY));
3412                         }
3413                         NdisZeroMemory(&(Tab->BssEntry[Tab->BssNr - 1]), sizeof(BSS_ENTRY));
3414                         Tab->BssNr -= 1;
3415                         return;
3416                 }
3417         }
3418 }
3419
3420 #ifdef DOT11_N_SUPPORT
3421 /*
3422         ========================================================================
3423         Routine Description:
3424                 Delete the Originator Entry in BAtable. Or decrease numAs Originator by 1 if needed.
3425
3426         Arguments:
3427         // IRQL = DISPATCH_LEVEL
3428         ========================================================================
3429 */
3430 VOID BATableDeleteORIEntry(
3431         IN OUT  PRTMP_ADAPTER pAd,
3432         IN              BA_ORI_ENTRY    *pBAORIEntry)
3433 {
3434
3435         if (pBAORIEntry->ORI_BA_Status != Originator_NONE)
3436         {
3437                 NdisAcquireSpinLock(&pAd->BATabLock);
3438                 if (pBAORIEntry->ORI_BA_Status == Originator_Done)
3439                 {
3440                         pAd->BATable.numAsOriginator -= 1;
3441                         DBGPRINT(RT_DEBUG_TRACE, ("BATableDeleteORIEntry numAsOriginator= %ld\n", pAd->BATable.numAsRecipient));
3442                         // Erase Bitmap flag.
3443                 }
3444                 pAd->MacTab.Content[pBAORIEntry->Wcid].TXBAbitmap &= (~(1<<(pBAORIEntry->TID) ));       // If STA mode,  erase flag here
3445                 pAd->MacTab.Content[pBAORIEntry->Wcid].BAOriWcidArray[pBAORIEntry->TID] = 0;    // If STA mode,  erase flag here
3446                 pBAORIEntry->ORI_BA_Status = Originator_NONE;
3447                 pBAORIEntry->Token = 1;
3448                 // Not clear Sequence here.
3449                 NdisReleaseSpinLock(&pAd->BATabLock);
3450         }
3451 }
3452 #endif // DOT11_N_SUPPORT //
3453
3454 /*! \brief
3455  *      \param
3456  *      \return
3457  *      \pre
3458  *      \post
3459
3460  IRQL = DISPATCH_LEVEL
3461
3462  */
3463 VOID BssEntrySet(
3464         IN PRTMP_ADAPTER        pAd,
3465         OUT BSS_ENTRY *pBss,
3466         IN PUCHAR pBssid,
3467         IN CHAR Ssid[],
3468         IN UCHAR SsidLen,
3469         IN UCHAR BssType,
3470         IN USHORT BeaconPeriod,
3471         IN PCF_PARM pCfParm,
3472         IN USHORT AtimWin,
3473         IN USHORT CapabilityInfo,
3474         IN UCHAR SupRate[],
3475         IN UCHAR SupRateLen,
3476         IN UCHAR ExtRate[],
3477         IN UCHAR ExtRateLen,
3478         IN HT_CAPABILITY_IE *pHtCapability,
3479         IN ADD_HT_INFO_IE *pAddHtInfo,  // AP might use this additional ht info IE
3480         IN UCHAR                        HtCapabilityLen,
3481         IN UCHAR                        AddHtInfoLen,
3482         IN UCHAR                        NewExtChanOffset,
3483         IN UCHAR Channel,
3484         IN CHAR Rssi,
3485         IN LARGE_INTEGER TimeStamp,
3486         IN UCHAR CkipFlag,
3487         IN PEDCA_PARM pEdcaParm,
3488         IN PQOS_CAPABILITY_PARM pQosCapability,
3489         IN PQBSS_LOAD_PARM pQbssLoad,
3490         IN USHORT LengthVIE,
3491         IN PNDIS_802_11_VARIABLE_IEs pVIE)
3492 {
3493         COPY_MAC_ADDR(pBss->Bssid, pBssid);
3494         // Default Hidden SSID to be TRUE, it will be turned to FALSE after coping SSID
3495         pBss->Hidden = 1;
3496         if (SsidLen > 0)
3497         {
3498                 // For hidden SSID AP, it might send beacon with SSID len equal to 0
3499                 // Or send beacon /probe response with SSID len matching real SSID length,
3500                 // but SSID is all zero. such as "00-00-00-00" with length 4.
3501                 // We have to prevent this case overwrite correct table
3502                 if (NdisEqualMemory(Ssid, ZeroSsid, SsidLen) == 0)
3503                 {
3504                     NdisZeroMemory(pBss->Ssid, MAX_LEN_OF_SSID);
3505                         NdisMoveMemory(pBss->Ssid, Ssid, SsidLen);
3506                         pBss->SsidLen = SsidLen;
3507                         pBss->Hidden = 0;
3508                 }
3509         }
3510         else
3511                 pBss->SsidLen = 0;
3512         pBss->BssType = BssType;
3513         pBss->BeaconPeriod = BeaconPeriod;
3514         if (BssType == BSS_INFRA)
3515         {
3516                 if (pCfParm->bValid)
3517                 {
3518                         pBss->CfpCount = pCfParm->CfpCount;
3519                         pBss->CfpPeriod = pCfParm->CfpPeriod;
3520                         pBss->CfpMaxDuration = pCfParm->CfpMaxDuration;
3521                         pBss->CfpDurRemaining = pCfParm->CfpDurRemaining;
3522                 }
3523         }
3524         else
3525         {
3526                 pBss->AtimWin = AtimWin;
3527         }
3528
3529         pBss->CapabilityInfo = CapabilityInfo;
3530         // The privacy bit indicate security is ON, it maight be WEP, TKIP or AES
3531         // Combine with AuthMode, they will decide the connection methods.
3532         pBss->Privacy = CAP_IS_PRIVACY_ON(pBss->CapabilityInfo);
3533         ASSERT(SupRateLen <= MAX_LEN_OF_SUPPORTED_RATES);
3534         if (SupRateLen <= MAX_LEN_OF_SUPPORTED_RATES)
3535                 NdisMoveMemory(pBss->SupRate, SupRate, SupRateLen);
3536         else
3537                 NdisMoveMemory(pBss->SupRate, SupRate, MAX_LEN_OF_SUPPORTED_RATES);
3538         pBss->SupRateLen = SupRateLen;
3539         ASSERT(ExtRateLen <= MAX_LEN_OF_SUPPORTED_RATES);
3540         NdisMoveMemory(pBss->ExtRate, ExtRate, ExtRateLen);
3541         NdisMoveMemory(&pBss->HtCapability, pHtCapability, HtCapabilityLen);
3542         NdisMoveMemory(&pBss->AddHtInfo, pAddHtInfo, AddHtInfoLen);
3543         pBss->NewExtChanOffset = NewExtChanOffset;
3544         pBss->ExtRateLen = ExtRateLen;
3545         pBss->Channel = Channel;
3546         pBss->CentralChannel = Channel;
3547         pBss->Rssi = Rssi;
3548         // Update CkipFlag. if not exists, the value is 0x0
3549         pBss->CkipFlag = CkipFlag;
3550
3551         // New for microsoft Fixed IEs
3552         NdisMoveMemory(pBss->FixIEs.Timestamp, &TimeStamp, 8);
3553         pBss->FixIEs.BeaconInterval = BeaconPeriod;
3554         pBss->FixIEs.Capabilities = CapabilityInfo;
3555
3556         // New for microsoft Variable IEs
3557         if (LengthVIE != 0)
3558         {
3559                 pBss->VarIELen = LengthVIE;
3560                 NdisMoveMemory(pBss->VarIEs, pVIE, pBss->VarIELen);
3561         }
3562         else
3563         {
3564                 pBss->VarIELen = 0;
3565         }
3566
3567         pBss->AddHtInfoLen = 0;
3568         pBss->HtCapabilityLen = 0;
3569 #ifdef DOT11_N_SUPPORT
3570         if (HtCapabilityLen> 0)
3571         {
3572                 pBss->HtCapabilityLen = HtCapabilityLen;
3573                 NdisMoveMemory(&pBss->HtCapability, pHtCapability, HtCapabilityLen);
3574                 if (AddHtInfoLen > 0)
3575                 {
3576                         pBss->AddHtInfoLen = AddHtInfoLen;
3577                         NdisMoveMemory(&pBss->AddHtInfo, pAddHtInfo, AddHtInfoLen);
3578
3579                                 if ((pAddHtInfo->ControlChan > 2)&& (pAddHtInfo->AddHtInfo.ExtChanOffset == EXTCHA_BELOW) && (pHtCapability->HtCapInfo.ChannelWidth == BW_40))
3580                                 {
3581                                         pBss->CentralChannel = pAddHtInfo->ControlChan - 2;
3582                                 }
3583                                 else if ((pAddHtInfo->AddHtInfo.ExtChanOffset == EXTCHA_ABOVE) && (pHtCapability->HtCapInfo.ChannelWidth == BW_40))
3584                                 {
3585                                                 pBss->CentralChannel = pAddHtInfo->ControlChan + 2;
3586                                 }
3587                 }
3588         }
3589 #endif // DOT11_N_SUPPORT //
3590
3591         BssCipherParse(pBss);
3592
3593         // new for QOS
3594         if (pEdcaParm)
3595                 NdisMoveMemory(&pBss->EdcaParm, pEdcaParm, sizeof(EDCA_PARM));
3596         else
3597                 pBss->EdcaParm.bValid = FALSE;
3598         if (pQosCapability)
3599                 NdisMoveMemory(&pBss->QosCapability, pQosCapability, sizeof(QOS_CAPABILITY_PARM));
3600         else
3601                 pBss->QosCapability.bValid = FALSE;
3602         if (pQbssLoad)
3603                 NdisMoveMemory(&pBss->QbssLoad, pQbssLoad, sizeof(QBSS_LOAD_PARM));
3604         else
3605                 pBss->QbssLoad.bValid = FALSE;
3606
3607 #ifdef CONFIG_STA_SUPPORT
3608         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
3609         {
3610                 PEID_STRUCT     pEid;
3611                 USHORT          Length = 0;
3612
3613
3614                 NdisZeroMemory(&pBss->WpaIE.IE[0], MAX_CUSTOM_LEN);
3615                 NdisZeroMemory(&pBss->RsnIE.IE[0], MAX_CUSTOM_LEN);
3616
3617                 pEid = (PEID_STRUCT) pVIE;
3618
3619                 while ((Length + 2 + (USHORT)pEid->Len) <= LengthVIE)
3620                 {
3621                         switch(pEid->Eid)
3622                         {
3623                                 case IE_WPA:
3624                                         if (NdisEqualMemory(pEid->Octet, WPA_OUI, 4))
3625                                         {
3626                                                 if ((pEid->Len + 2) > MAX_CUSTOM_LEN)
3627                                                 {
3628                                                         pBss->WpaIE.IELen = 0;
3629                                                         break;
3630                                                 }
3631                                                 pBss->WpaIE.IELen = pEid->Len + 2;
3632                                                 NdisMoveMemory(pBss->WpaIE.IE, pEid, pBss->WpaIE.IELen);
3633                                         }
3634                                         break;
3635                 case IE_RSN:
3636                     if (NdisEqualMemory(pEid->Octet + 2, RSN_OUI, 3))
3637                                         {
3638                                                 if ((pEid->Len + 2) > MAX_CUSTOM_LEN)
3639                                                 {
3640                                                         pBss->RsnIE.IELen = 0;
3641                                                         break;
3642                                                 }
3643                                                 pBss->RsnIE.IELen = pEid->Len + 2;
3644                                                 NdisMoveMemory(pBss->RsnIE.IE, pEid, pBss->RsnIE.IELen);
3645                         }
3646                                 break;
3647             }
3648                         Length = Length + 2 + (USHORT)pEid->Len;  // Eid[1] + Len[1]+ content[Len]
3649                         pEid = (PEID_STRUCT)((UCHAR*)pEid + 2 + pEid->Len);
3650                 }
3651         }
3652 #endif // CONFIG_STA_SUPPORT //
3653 }
3654
3655 /*!
3656  *      \brief insert an entry into the bss table
3657  *      \param p_tab The BSS table
3658  *      \param Bssid BSSID
3659  *      \param ssid SSID
3660  *      \param ssid_len Length of SSID
3661  *      \param bss_type
3662  *      \param beacon_period
3663  *      \param timestamp
3664  *      \param p_cf
3665  *      \param atim_win
3666  *      \param cap
3667  *      \param rates
3668  *      \param rates_len
3669  *      \param channel_idx
3670  *      \return none
3671  *      \pre
3672  *      \post
3673  *      \note If SSID is identical, the old entry will be replaced by the new one
3674
3675  IRQL = DISPATCH_LEVEL
3676
3677  */
3678 ULONG BssTableSetEntry(
3679         IN      PRTMP_ADAPTER   pAd,
3680         OUT BSS_TABLE *Tab,
3681         IN PUCHAR pBssid,
3682         IN CHAR Ssid[],
3683         IN UCHAR SsidLen,
3684         IN UCHAR BssType,
3685         IN USHORT BeaconPeriod,
3686         IN CF_PARM *CfParm,
3687         IN USHORT AtimWin,
3688         IN USHORT CapabilityInfo,
3689         IN UCHAR SupRate[],
3690         IN UCHAR SupRateLen,
3691         IN UCHAR ExtRate[],
3692         IN UCHAR ExtRateLen,
3693         IN HT_CAPABILITY_IE *pHtCapability,
3694         IN ADD_HT_INFO_IE *pAddHtInfo,  // AP might use this additional ht info IE
3695         IN UCHAR                        HtCapabilityLen,
3696         IN UCHAR                        AddHtInfoLen,
3697         IN UCHAR                        NewExtChanOffset,
3698         IN UCHAR ChannelNo,
3699         IN CHAR Rssi,
3700         IN LARGE_INTEGER TimeStamp,
3701         IN UCHAR CkipFlag,
3702         IN PEDCA_PARM pEdcaParm,
3703         IN PQOS_CAPABILITY_PARM pQosCapability,
3704         IN PQBSS_LOAD_PARM pQbssLoad,
3705         IN USHORT LengthVIE,
3706         IN PNDIS_802_11_VARIABLE_IEs pVIE)
3707 {
3708         ULONG   Idx;
3709
3710         Idx = BssTableSearchWithSSID(Tab, pBssid,  Ssid, SsidLen, ChannelNo);
3711         if (Idx == BSS_NOT_FOUND)
3712         {
3713                 if (Tab->BssNr >= MAX_LEN_OF_BSS_TABLE)
3714             {
3715                         //
3716                         // It may happen when BSS Table was full.
3717                         // The desired AP will not be added into BSS Table
3718                         // In this case, if we found the desired AP then overwrite BSS Table.
3719                         //
3720                         if(!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
3721                         {
3722                                 if (MAC_ADDR_EQUAL(pAd->MlmeAux.Bssid, pBssid) ||
3723                                         SSID_EQUAL(pAd->MlmeAux.Ssid, pAd->MlmeAux.SsidLen, Ssid, SsidLen))
3724                                 {
3725                                         Idx = Tab->BssOverlapNr;
3726                                         BssEntrySet(pAd, &Tab->BssEntry[Idx], pBssid, Ssid, SsidLen, BssType, BeaconPeriod, CfParm, AtimWin,
3727                                                 CapabilityInfo, SupRate, SupRateLen, ExtRate, ExtRateLen,pHtCapability, pAddHtInfo,HtCapabilityLen, AddHtInfoLen,
3728                                                 NewExtChanOffset, ChannelNo, Rssi, TimeStamp, CkipFlag, pEdcaParm, pQosCapability, pQbssLoad, LengthVIE, pVIE);
3729                     Tab->BssOverlapNr = (Tab->BssOverlapNr++) % MAX_LEN_OF_BSS_TABLE;
3730                                 }
3731                                 return Idx;
3732                         }
3733                         else
3734                         {
3735                         return BSS_NOT_FOUND;
3736                         }
3737                 }
3738                 Idx = Tab->BssNr;
3739                 BssEntrySet(pAd, &Tab->BssEntry[Idx], pBssid, Ssid, SsidLen, BssType, BeaconPeriod, CfParm, AtimWin,
3740                                         CapabilityInfo, SupRate, SupRateLen, ExtRate, ExtRateLen,pHtCapability, pAddHtInfo,HtCapabilityLen, AddHtInfoLen,
3741                                         NewExtChanOffset, ChannelNo, Rssi, TimeStamp, CkipFlag, pEdcaParm, pQosCapability, pQbssLoad, LengthVIE, pVIE);
3742                 Tab->BssNr++;
3743         }
3744         else
3745         {
3746                 BssEntrySet(pAd, &Tab->BssEntry[Idx], pBssid, Ssid, SsidLen, BssType, BeaconPeriod,CfParm, AtimWin,
3747                                         CapabilityInfo, SupRate, SupRateLen, ExtRate, ExtRateLen,pHtCapability, pAddHtInfo,HtCapabilityLen, AddHtInfoLen,
3748                                         NewExtChanOffset, ChannelNo, Rssi, TimeStamp, CkipFlag, pEdcaParm, pQosCapability, pQbssLoad, LengthVIE, pVIE);
3749         }
3750
3751         return Idx;
3752 }
3753
3754 #ifdef CONFIG_STA_SUPPORT
3755 // IRQL = DISPATCH_LEVEL
3756 VOID BssTableSsidSort(
3757         IN      PRTMP_ADAPTER   pAd,
3758         OUT BSS_TABLE *OutTab,
3759         IN      CHAR Ssid[],
3760         IN      UCHAR SsidLen)
3761 {
3762         INT i;
3763         BssTableInit(OutTab);
3764
3765         for (i = 0; i < pAd->ScanTab.BssNr; i++)
3766         {
3767                 BSS_ENTRY *pInBss = &pAd->ScanTab.BssEntry[i];
3768                 BOOLEAN bIsHiddenApIncluded = FALSE;
3769
3770                 if (((pAd->CommonCfg.bIEEE80211H == 1) &&
3771             (pAd->MlmeAux.Channel > 14) &&
3772              RadarChannelCheck(pAd, pInBss->Channel))
3773             )
3774                 {
3775                         if (pInBss->Hidden)
3776                                 bIsHiddenApIncluded = TRUE;
3777                 }
3778
3779                 if ((pInBss->BssType == pAd->StaCfg.BssType) &&
3780                         (SSID_EQUAL(Ssid, SsidLen, pInBss->Ssid, pInBss->SsidLen) || bIsHiddenApIncluded))
3781                 {
3782                         BSS_ENTRY *pOutBss = &OutTab->BssEntry[OutTab->BssNr];
3783 #ifdef DOT11_N_SUPPORT
3784                         // 2.4G/5G N only mode
3785                         if ((pInBss->HtCapabilityLen == 0) &&
3786                                 ((pAd->CommonCfg.PhyMode == PHY_11N_2_4G) || (pAd->CommonCfg.PhyMode == PHY_11N_5G)))
3787                         {
3788                                 DBGPRINT(RT_DEBUG_TRACE,("STA is in N-only Mode, this AP don't have Ht capability in Beacon.\n"));
3789                                 continue;
3790                         }
3791 #endif // DOT11_N_SUPPORT //
3792
3793                         // New for WPA2
3794                         // Check the Authmode first
3795                         if (pAd->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
3796                         {
3797                                 // Check AuthMode and AuthModeAux for matching, in case AP support dual-mode
3798                                 if ((pAd->StaCfg.AuthMode != pInBss->AuthMode) && (pAd->StaCfg.AuthMode != pInBss->AuthModeAux))
3799                                         // None matched
3800                                         continue;
3801
3802                                 // Check cipher suite, AP must have more secured cipher than station setting
3803                                 if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK))
3804                                 {
3805                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3806                                         if (pInBss->WPA.bMixMode == FALSE)
3807                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA.GroupCipher)
3808                                                         continue;
3809
3810                                         // check group cipher
3811                                         if ((pAd->StaCfg.WepStatus < pInBss->WPA.GroupCipher) &&
3812                                                 (pInBss->WPA.GroupCipher != Ndis802_11GroupWEP40Enabled) &&
3813                                                 (pInBss->WPA.GroupCipher != Ndis802_11GroupWEP104Enabled))
3814                                                 continue;
3815
3816                                         // check pairwise cipher, skip if none matched
3817                                         // If profile set to AES, let it pass without question.
3818                                         // If profile set to TKIP, we must find one mateched
3819                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
3820                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipher) &&
3821                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipherAux))
3822                                                 continue;
3823                                 }
3824                                 else if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK))
3825                                 {
3826                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3827                                         if (pInBss->WPA2.bMixMode == FALSE)
3828                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA2.GroupCipher)
3829                                                         continue;
3830
3831                                         // check group cipher
3832                                         if ((pAd->StaCfg.WepStatus < pInBss->WPA.GroupCipher) &&
3833                                                 (pInBss->WPA2.GroupCipher != Ndis802_11GroupWEP40Enabled) &&
3834                                                 (pInBss->WPA2.GroupCipher != Ndis802_11GroupWEP104Enabled))
3835                                                 continue;
3836
3837                                         // check pairwise cipher, skip if none matched
3838                                         // If profile set to AES, let it pass without question.
3839                                         // If profile set to TKIP, we must find one mateched
3840                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
3841                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipher) &&
3842                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipherAux))
3843                                                 continue;
3844                                 }
3845                         }
3846                         // Bss Type matched, SSID matched.
3847                         // We will check wepstatus for qualification Bss
3848                         else if (pAd->StaCfg.WepStatus != pInBss->WepStatus)
3849                         {
3850                                 DBGPRINT(RT_DEBUG_TRACE,("StaCfg.WepStatus=%d, while pInBss->WepStatus=%d\n", pAd->StaCfg.WepStatus, pInBss->WepStatus));
3851                                 //
3852                                 // For the SESv2 case, we will not qualify WepStatus.
3853                                 //
3854                                 if (!pInBss->bSES)
3855                                         continue;
3856                         }
3857
3858                         // Since the AP is using hidden SSID, and we are trying to connect to ANY
3859                         // It definitely will fail. So, skip it.
3860                         // CCX also require not even try to connect it!!
3861                         if (SsidLen == 0)
3862                                 continue;
3863
3864 #ifdef DOT11_N_SUPPORT
3865                         // If both station and AP use 40MHz, still need to check if the 40MHZ band's legality in my country region
3866                         // If this 40MHz wideband is not allowed in my country list, use bandwidth 20MHZ instead,
3867                         if ((pInBss->CentralChannel != pInBss->Channel) &&
3868                                 (pAd->CommonCfg.RegTransmitSetting.field.BW == BW_40))
3869                         {
3870                                 if (RTMPCheckChannel(pAd, pInBss->CentralChannel, pInBss->Channel) == FALSE)
3871                                 {
3872                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_20;
3873                                         SetCommonHT(pAd);
3874                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_40;
3875                                 }
3876                                 else
3877                                 {
3878                                         if (pAd->CommonCfg.DesiredHtPhy.ChannelWidth == BAND_WIDTH_20)
3879                                         {
3880                                                 SetCommonHT(pAd);
3881                                         }
3882                                 }
3883                         }
3884 #endif // DOT11_N_SUPPORT //
3885
3886                         // copy matching BSS from InTab to OutTab
3887                         NdisMoveMemory(pOutBss, pInBss, sizeof(BSS_ENTRY));
3888
3889                         OutTab->BssNr++;
3890                 }
3891                 else if ((pInBss->BssType == pAd->StaCfg.BssType) && (SsidLen == 0))
3892                 {
3893                         BSS_ENTRY *pOutBss = &OutTab->BssEntry[OutTab->BssNr];
3894
3895
3896 #ifdef DOT11_N_SUPPORT
3897                         // 2.4G/5G N only mode
3898                         if ((pInBss->HtCapabilityLen == 0) &&
3899                                 ((pAd->CommonCfg.PhyMode == PHY_11N_2_4G) || (pAd->CommonCfg.PhyMode == PHY_11N_5G)))
3900                         {
3901                                 DBGPRINT(RT_DEBUG_TRACE,("STA is in N-only Mode, this AP don't have Ht capability in Beacon.\n"));
3902                                 continue;
3903                         }
3904 #endif // DOT11_N_SUPPORT //
3905
3906                         // New for WPA2
3907                         // Check the Authmode first
3908                         if (pAd->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
3909                         {
3910                                 // Check AuthMode and AuthModeAux for matching, in case AP support dual-mode
3911                                 if ((pAd->StaCfg.AuthMode != pInBss->AuthMode) && (pAd->StaCfg.AuthMode != pInBss->AuthModeAux))
3912                                         // None matched
3913                                         continue;
3914
3915                                 // Check cipher suite, AP must have more secured cipher than station setting
3916                                 if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK))
3917                                 {
3918                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3919                                         if (pInBss->WPA.bMixMode == FALSE)
3920                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA.GroupCipher)
3921                                                         continue;
3922
3923                                         // check group cipher
3924                                         if (pAd->StaCfg.WepStatus < pInBss->WPA.GroupCipher)
3925                                                 continue;
3926
3927                                         // check pairwise cipher, skip if none matched
3928                                         // If profile set to AES, let it pass without question.
3929                                         // If profile set to TKIP, we must find one mateched
3930                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
3931                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipher) &&
3932                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipherAux))
3933                                                 continue;
3934                                 }
3935                                 else if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK))
3936                                 {
3937                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3938                                         if (pInBss->WPA2.bMixMode == FALSE)
3939                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA2.GroupCipher)
3940                                                         continue;
3941
3942                                         // check group cipher
3943                                         if (pAd->StaCfg.WepStatus < pInBss->WPA2.GroupCipher)
3944                                                 continue;
3945
3946                                         // check pairwise cipher, skip if none matched
3947                                         // If profile set to AES, let it pass without question.
3948                                         // If profile set to TKIP, we must find one mateched
3949                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
3950                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipher) &&
3951                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipherAux))
3952                                                 continue;
3953                                 }
3954                         }
3955                         // Bss Type matched, SSID matched.
3956                         // We will check wepstatus for qualification Bss
3957                         else if (pAd->StaCfg.WepStatus != pInBss->WepStatus)
3958                                         continue;
3959
3960 #ifdef DOT11_N_SUPPORT
3961                         // If both station and AP use 40MHz, still need to check if the 40MHZ band's legality in my country region
3962                         // If this 40MHz wideband is not allowed in my country list, use bandwidth 20MHZ instead,
3963                         if ((pInBss->CentralChannel != pInBss->Channel) &&
3964                                 (pAd->CommonCfg.RegTransmitSetting.field.BW == BW_40))
3965                         {
3966                                 if (RTMPCheckChannel(pAd, pInBss->CentralChannel, pInBss->Channel) == FALSE)
3967                                 {
3968                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_20;
3969                                         SetCommonHT(pAd);
3970                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_40;
3971                                 }
3972                         }
3973 #endif // DOT11_N_SUPPORT //
3974
3975                         // copy matching BSS from InTab to OutTab
3976                         NdisMoveMemory(pOutBss, pInBss, sizeof(BSS_ENTRY));
3977
3978                         OutTab->BssNr++;
3979                 }
3980
3981                 if (OutTab->BssNr >= MAX_LEN_OF_BSS_TABLE)
3982                         break;
3983         }
3984
3985         BssTableSortByRssi(OutTab);
3986 }
3987
3988
3989 // IRQL = DISPATCH_LEVEL
3990 VOID BssTableSortByRssi(
3991         IN OUT BSS_TABLE *OutTab)
3992 {
3993         INT       i, j;
3994         BSS_ENTRY TmpBss;
3995
3996         for (i = 0; i < OutTab->BssNr - 1; i++)
3997         {
3998                 for (j = i+1; j < OutTab->BssNr; j++)
3999                 {
4000                         if (OutTab->BssEntry[j].Rssi > OutTab->BssEntry[i].Rssi)
4001                         {
4002                                 NdisMoveMemory(&TmpBss, &OutTab->BssEntry[j], sizeof(BSS_ENTRY));
4003                                 NdisMoveMemory(&OutTab->BssEntry[j], &OutTab->BssEntry[i], sizeof(BSS_ENTRY));
4004                                 NdisMoveMemory(&OutTab->BssEntry[i], &TmpBss, sizeof(BSS_ENTRY));
4005                         }
4006                 }
4007         }
4008 }
4009 #endif // CONFIG_STA_SUPPORT //
4010
4011
4012 VOID BssCipherParse(
4013         IN OUT  PBSS_ENTRY      pBss)
4014 {
4015         PEID_STRUCT              pEid;
4016         PUCHAR                          pTmp;
4017         PRSN_IE_HEADER_STRUCT                   pRsnHeader;
4018         PCIPHER_SUITE_STRUCT                    pCipher;
4019         PAKM_SUITE_STRUCT                               pAKM;
4020         USHORT                                                  Count;
4021         INT                                                             Length;
4022         NDIS_802_11_ENCRYPTION_STATUS   TmpCipher;
4023
4024         //
4025         // WepStatus will be reset later, if AP announce TKIP or AES on the beacon frame.
4026         //
4027         if (pBss->Privacy)
4028         {
4029                 pBss->WepStatus         = Ndis802_11WEPEnabled;
4030         }
4031         else
4032         {
4033                 pBss->WepStatus         = Ndis802_11WEPDisabled;
4034         }
4035         // Set default to disable & open authentication before parsing variable IE
4036         pBss->AuthMode          = Ndis802_11AuthModeOpen;
4037         pBss->AuthModeAux       = Ndis802_11AuthModeOpen;
4038
4039         // Init WPA setting
4040         pBss->WPA.PairCipher    = Ndis802_11WEPDisabled;
4041         pBss->WPA.PairCipherAux = Ndis802_11WEPDisabled;
4042         pBss->WPA.GroupCipher   = Ndis802_11WEPDisabled;
4043         pBss->WPA.RsnCapability = 0;
4044         pBss->WPA.bMixMode              = FALSE;
4045
4046         // Init WPA2 setting
4047         pBss->WPA2.PairCipher    = Ndis802_11WEPDisabled;
4048         pBss->WPA2.PairCipherAux = Ndis802_11WEPDisabled;
4049         pBss->WPA2.GroupCipher   = Ndis802_11WEPDisabled;
4050         pBss->WPA2.RsnCapability = 0;
4051         pBss->WPA2.bMixMode      = FALSE;
4052
4053
4054         Length = (INT) pBss->VarIELen;
4055
4056         while (Length > 0)
4057         {
4058                 // Parse cipher suite base on WPA1 & WPA2, they should be parsed differently
4059                 pTmp = ((PUCHAR) pBss->VarIEs) + pBss->VarIELen - Length;
4060                 pEid = (PEID_STRUCT) pTmp;
4061                 switch (pEid->Eid)
4062                 {
4063                         case IE_WPA:
4064                                 //Parse Cisco IE_WPA (LEAP, CCKM, etc.)
4065                                 if ( NdisEqualMemory((pTmp+8), CISCO_OUI, 3))
4066                                 {
4067                                         pTmp   += 11;
4068                                         switch (*pTmp)
4069                                         {
4070                                                 case 1:
4071                                                 case 5: // Although WEP is not allowed in WPA related auth mode, we parse it anyway
4072                                                         pBss->WepStatus = Ndis802_11Encryption1Enabled;
4073                                                         pBss->WPA.PairCipher = Ndis802_11Encryption1Enabled;
4074                                                         pBss->WPA.GroupCipher = Ndis802_11Encryption1Enabled;
4075                                                         break;
4076                                                 case 2:
4077                                                         pBss->WepStatus = Ndis802_11Encryption2Enabled;
4078                                                         pBss->WPA.PairCipher = Ndis802_11Encryption1Enabled;
4079                                                         pBss->WPA.GroupCipher = Ndis802_11Encryption1Enabled;
4080                                                         break;
4081                                                 case 4:
4082                                                         pBss->WepStatus = Ndis802_11Encryption3Enabled;
4083                                                         pBss->WPA.PairCipher = Ndis802_11Encryption1Enabled;
4084                                                         pBss->WPA.GroupCipher = Ndis802_11Encryption1Enabled;
4085                                                         break;
4086                                                 default:
4087                                                         break;
4088                                         }
4089
4090                                         // if Cisco IE_WPA, break
4091                                         break;
4092                                 }
4093                                 else if (NdisEqualMemory(pEid->Octet, SES_OUI, 3) && (pEid->Len == 7))
4094                                 {
4095                                         pBss->bSES = TRUE;
4096                                         break;
4097                                 }
4098                                 else if (NdisEqualMemory(pEid->Octet, WPA_OUI, 4) != 1)
4099                                 {
4100                                         // if unsupported vendor specific IE
4101                                         break;
4102                                 }
4103                                 // Skip OUI, version, and multicast suite
4104                                 // This part should be improved in the future when AP supported multiple cipher suite.
4105                                 // For now, it's OK since almost all APs have fixed cipher suite supported.
4106                                 // pTmp = (PUCHAR) pEid->Octet;
4107                                 pTmp   += 11;
4108
4109                                 // Cipher Suite Selectors from Spec P802.11i/D3.2 P26.
4110                                 //      Value      Meaning
4111                                 //      0                       None
4112                                 //      1                       WEP-40
4113                                 //      2                       Tkip
4114                                 //      3                       WRAP
4115                                 //      4                       AES
4116                                 //      5                       WEP-104
4117                                 // Parse group cipher
4118                                 switch (*pTmp)
4119                                 {
4120                                         case 1:
4121                                                 pBss->WPA.GroupCipher = Ndis802_11GroupWEP40Enabled;
4122                                                 break;
4123                                         case 5:
4124                                                 pBss->WPA.GroupCipher = Ndis802_11GroupWEP104Enabled;
4125                                                 break;
4126                                         case 2:
4127                                                 pBss->WPA.GroupCipher = Ndis802_11Encryption2Enabled;
4128                                                 break;
4129                                         case 4:
4130                                                 pBss->WPA.GroupCipher = Ndis802_11Encryption3Enabled;
4131                                                 break;
4132                                         default:
4133                                                 break;
4134                                 }
4135                                 // number of unicast suite
4136                                 pTmp   += 1;
4137
4138                                 // skip all unicast cipher suites
4139                                 //Count = *(PUSHORT) pTmp;
4140                                 Count = (pTmp[1]<<8) + pTmp[0];
4141                                 pTmp   += sizeof(USHORT);
4142
4143                                 // Parsing all unicast cipher suite
4144                                 while (Count > 0)
4145                                 {
4146                                         // Skip OUI
4147                                         pTmp += 3;
4148                                         TmpCipher = Ndis802_11WEPDisabled;
4149                                         switch (*pTmp)
4150                                         {
4151                                                 case 1:
4152                                                 case 5: // Although WEP is not allowed in WPA related auth mode, we parse it anyway
4153                                                         TmpCipher = Ndis802_11Encryption1Enabled;
4154                                                         break;
4155                                                 case 2:
4156                                                         TmpCipher = Ndis802_11Encryption2Enabled;
4157                                                         break;
4158                                                 case 4:
4159                                                         TmpCipher = Ndis802_11Encryption3Enabled;
4160                                                         break;
4161                                                 default:
4162                                                         break;
4163                                         }
4164                                         if (TmpCipher > pBss->WPA.PairCipher)
4165                                         {
4166                                                 // Move the lower cipher suite to PairCipherAux
4167                                                 pBss->WPA.PairCipherAux = pBss->WPA.PairCipher;
4168                                                 pBss->WPA.PairCipher    = TmpCipher;
4169                                         }
4170                                         else
4171                                         {
4172                                                 pBss->WPA.PairCipherAux = TmpCipher;
4173                                         }
4174                                         pTmp++;
4175                                         Count--;
4176                                 }
4177
4178                                 // 4. get AKM suite counts
4179                                 //Count = *(PUSHORT) pTmp;
4180                                 Count = (pTmp[1]<<8) + pTmp[0];
4181                                 pTmp   += sizeof(USHORT);
4182                                 pTmp   += 3;
4183
4184                                 switch (*pTmp)
4185                                 {
4186                                         case 1:
4187                                                 // Set AP support WPA mode
4188                                                 if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4189                                                         pBss->AuthMode = Ndis802_11AuthModeWPA;
4190                                                 else
4191                                                         pBss->AuthModeAux = Ndis802_11AuthModeWPA;
4192                                                 break;
4193                                         case 2:
4194                                                 // Set AP support WPA mode
4195                                                 if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4196                                                         pBss->AuthMode = Ndis802_11AuthModeWPAPSK;
4197                                                 else
4198                                                         pBss->AuthModeAux = Ndis802_11AuthModeWPAPSK;
4199                                                 break;
4200                                         default:
4201                                                 break;
4202                                 }
4203                                 pTmp   += 1;
4204
4205                                 // Fixed for WPA-None
4206                                 if (pBss->BssType == BSS_ADHOC)
4207                                 {
4208                                         pBss->AuthMode    = Ndis802_11AuthModeWPANone;
4209                                         pBss->AuthModeAux = Ndis802_11AuthModeWPANone;
4210                                         pBss->WepStatus   = pBss->WPA.GroupCipher;
4211                                         // Patched bugs for old driver
4212                                         if (pBss->WPA.PairCipherAux == Ndis802_11WEPDisabled)
4213                                                 pBss->WPA.PairCipherAux = pBss->WPA.GroupCipher;
4214                                 }
4215                                 else
4216                                         pBss->WepStatus   = pBss->WPA.PairCipher;
4217
4218                                 // Check the Pair & Group, if different, turn on mixed mode flag
4219                                 if (pBss->WPA.GroupCipher != pBss->WPA.PairCipher)
4220                                         pBss->WPA.bMixMode = TRUE;
4221
4222                                 break;
4223
4224                         case IE_RSN:
4225                                 pRsnHeader = (PRSN_IE_HEADER_STRUCT) pTmp;
4226
4227                                 // 0. Version must be 1
4228                                 if (le2cpu16(pRsnHeader->Version) != 1)
4229                                         break;
4230                                 pTmp   += sizeof(RSN_IE_HEADER_STRUCT);
4231
4232                                 // 1. Check group cipher
4233                                 pCipher = (PCIPHER_SUITE_STRUCT) pTmp;
4234                                 if (!RTMPEqualMemory(pTmp, RSN_OUI, 3))
4235                                         break;
4236
4237                                 // Parse group cipher
4238                                 switch (pCipher->Type)
4239                                 {
4240                                         case 1:
4241                                                 pBss->WPA2.GroupCipher = Ndis802_11GroupWEP40Enabled;
4242                                                 break;
4243                                         case 5:
4244                                                 pBss->WPA2.GroupCipher = Ndis802_11GroupWEP104Enabled;
4245                                                 break;
4246                                         case 2:
4247                                                 pBss->WPA2.GroupCipher = Ndis802_11Encryption2Enabled;
4248                                                 break;
4249                                         case 4:
4250                                                 pBss->WPA2.GroupCipher = Ndis802_11Encryption3Enabled;
4251                                                 break;
4252                                         default:
4253                                                 break;
4254                                 }
4255                                 // set to correct offset for next parsing
4256                                 pTmp   += sizeof(CIPHER_SUITE_STRUCT);
4257
4258                                 // 2. Get pairwise cipher counts
4259                                 //Count = *(PUSHORT) pTmp;
4260                                 Count = (pTmp[1]<<8) + pTmp[0];
4261                                 pTmp   += sizeof(USHORT);
4262
4263                                 // 3. Get pairwise cipher
4264                                 // Parsing all unicast cipher suite
4265                                 while (Count > 0)
4266                                 {
4267                                         // Skip OUI
4268                                         pCipher = (PCIPHER_SUITE_STRUCT) pTmp;
4269                                         TmpCipher = Ndis802_11WEPDisabled;
4270                                         switch (pCipher->Type)
4271                                         {
4272                                                 case 1:
4273                                                 case 5: // Although WEP is not allowed in WPA related auth mode, we parse it anyway
4274                                                         TmpCipher = Ndis802_11Encryption1Enabled;
4275                                                         break;
4276                                                 case 2:
4277                                                         TmpCipher = Ndis802_11Encryption2Enabled;
4278                                                         break;
4279                                                 case 4:
4280                                                         TmpCipher = Ndis802_11Encryption3Enabled;
4281                                                         break;
4282                                                 default:
4283                                                         break;
4284                                         }
4285                                         if (TmpCipher > pBss->WPA2.PairCipher)
4286                                         {
4287                                                 // Move the lower cipher suite to PairCipherAux
4288                                                 pBss->WPA2.PairCipherAux = pBss->WPA2.PairCipher;
4289                                                 pBss->WPA2.PairCipher    = TmpCipher;
4290                                         }
4291                                         else
4292                                         {
4293                                                 pBss->WPA2.PairCipherAux = TmpCipher;
4294                                         }
4295                                         pTmp += sizeof(CIPHER_SUITE_STRUCT);
4296                                         Count--;
4297                                 }
4298
4299                                 // 4. get AKM suite counts
4300                                 //Count = *(PUSHORT) pTmp;
4301                                 Count = (pTmp[1]<<8) + pTmp[0];
4302                                 pTmp   += sizeof(USHORT);
4303
4304                                 // 5. Get AKM ciphers
4305                                 pAKM = (PAKM_SUITE_STRUCT) pTmp;
4306                                 if (!RTMPEqualMemory(pTmp, RSN_OUI, 3))
4307                                         break;
4308
4309                                 switch (pAKM->Type)
4310                                 {
4311                                         case 1:
4312                                                 // Set AP support WPA mode
4313                                                 if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4314                                                         pBss->AuthMode = Ndis802_11AuthModeWPA2;
4315                                                 else
4316                                                         pBss->AuthModeAux = Ndis802_11AuthModeWPA2;
4317                                                 break;
4318                                         case 2:
4319                                                 // Set AP support WPA mode
4320                                                 if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4321                                                         pBss->AuthMode = Ndis802_11AuthModeWPA2PSK;
4322                                                 else
4323                                                         pBss->AuthModeAux = Ndis802_11AuthModeWPA2PSK;
4324                                                 break;
4325                                         default:
4326                                                 break;
4327                                 }
4328                                 pTmp   += (Count * sizeof(AKM_SUITE_STRUCT));
4329
4330                                 // Fixed for WPA-None
4331                                 if (pBss->BssType == BSS_ADHOC)
4332                                 {
4333                                         pBss->AuthMode = Ndis802_11AuthModeWPANone;
4334                                         pBss->AuthModeAux = Ndis802_11AuthModeWPANone;
4335                                         pBss->WPA.PairCipherAux = pBss->WPA2.PairCipherAux;
4336                                         pBss->WPA.GroupCipher   = pBss->WPA2.GroupCipher;
4337                                         pBss->WepStatus                 = pBss->WPA.GroupCipher;
4338                                         // Patched bugs for old driver
4339                                         if (pBss->WPA.PairCipherAux == Ndis802_11WEPDisabled)
4340                                                 pBss->WPA.PairCipherAux = pBss->WPA.GroupCipher;
4341                                 }
4342                                 pBss->WepStatus   = pBss->WPA2.PairCipher;
4343
4344                                 // 6. Get RSN capability
4345                                 //pBss->WPA2.RsnCapability = *(PUSHORT) pTmp;
4346                                 pBss->WPA2.RsnCapability = (pTmp[1]<<8) + pTmp[0];
4347                                 pTmp += sizeof(USHORT);
4348
4349                                 // Check the Pair & Group, if different, turn on mixed mode flag
4350                                 if (pBss->WPA2.GroupCipher != pBss->WPA2.PairCipher)
4351                                         pBss->WPA2.bMixMode = TRUE;
4352
4353                                 break;
4354                         default:
4355                                 break;
4356                 }
4357                 Length -= (pEid->Len + 2);
4358         }
4359 }
4360
4361 // ===========================================================================================
4362 // mac_table.c
4363 // ===========================================================================================
4364
4365 /*! \brief generates a random mac address value for IBSS BSSID
4366  *      \param Addr the bssid location
4367  *      \return none
4368  *      \pre
4369  *      \post
4370  */
4371 VOID MacAddrRandomBssid(
4372         IN PRTMP_ADAPTER pAd,
4373         OUT PUCHAR pAddr)
4374 {
4375         INT i;
4376
4377         for (i = 0; i < MAC_ADDR_LEN; i++)
4378         {
4379                 pAddr[i] = RandomByte(pAd);
4380         }
4381
4382         pAddr[0] = (pAddr[0] & 0xfe) | 0x02;  // the first 2 bits must be 01xxxxxxxx
4383 }
4384
4385 /*! \brief init the management mac frame header
4386  *      \param p_hdr mac header
4387  *      \param subtype subtype of the frame
4388  *      \param p_ds destination address, don't care if it is a broadcast address
4389  *      \return none
4390  *      \pre the station has the following information in the pAd->StaCfg
4391  *       - bssid
4392  *       - station address
4393  *      \post
4394  *      \note this function initializes the following field
4395
4396  IRQL = PASSIVE_LEVEL
4397  IRQL = DISPATCH_LEVEL
4398
4399  */
4400 VOID MgtMacHeaderInit(
4401         IN      PRTMP_ADAPTER   pAd,
4402         IN OUT PHEADER_802_11 pHdr80211,
4403         IN UCHAR SubType,
4404         IN UCHAR ToDs,
4405         IN PUCHAR pDA,
4406         IN PUCHAR pBssid)
4407 {
4408         NdisZeroMemory(pHdr80211, sizeof(HEADER_802_11));
4409
4410         pHdr80211->FC.Type = BTYPE_MGMT;
4411         pHdr80211->FC.SubType = SubType;
4412 //      if (SubType == SUBTYPE_ACK)     // sample, no use, it will conflict with ACTION frame sub type
4413 //              pHdr80211->FC.Type = BTYPE_CNTL;
4414         pHdr80211->FC.ToDs = ToDs;
4415         COPY_MAC_ADDR(pHdr80211->Addr1, pDA);
4416 #ifdef CONFIG_STA_SUPPORT
4417         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
4418                 COPY_MAC_ADDR(pHdr80211->Addr2, pAd->CurrentAddress);
4419 #endif // CONFIG_STA_SUPPORT //
4420         COPY_MAC_ADDR(pHdr80211->Addr3, pBssid);
4421 }
4422
4423 // ===========================================================================================
4424 // mem_mgmt.c
4425 // ===========================================================================================
4426
4427 /*!***************************************************************************
4428  * This routine build an outgoing frame, and fill all information specified
4429  * in argument list to the frame body. The actual frame size is the summation
4430  * of all arguments.
4431  * input params:
4432  *              Buffer - pointer to a pre-allocated memory segment
4433  *              args - a list of <int arg_size, arg> pairs.
4434  *              NOTE NOTE NOTE!!!! the last argument must be NULL, otherwise this
4435  *                                                 function will FAIL!!!
4436  * return:
4437  *              Size of the buffer
4438  * usage:
4439  *              MakeOutgoingFrame(Buffer, output_length, 2, &fc, 2, &dur, 6, p_addr1, 6,p_addr2, END_OF_ARGS);
4440
4441  IRQL = PASSIVE_LEVEL
4442  IRQL = DISPATCH_LEVEL
4443
4444  ****************************************************************************/
4445 ULONG MakeOutgoingFrame(
4446         OUT CHAR *Buffer,
4447         OUT ULONG *FrameLen, ...)
4448 {
4449         CHAR   *p;
4450         int     leng;
4451         ULONG   TotLeng;
4452         va_list Args;
4453
4454         // calculates the total length
4455         TotLeng = 0;
4456         va_start(Args, FrameLen);
4457         do
4458         {
4459                 leng = va_arg(Args, int);
4460                 if (leng == END_OF_ARGS)
4461                 {
4462                         break;
4463                 }
4464                 p = va_arg(Args, PVOID);
4465                 NdisMoveMemory(&Buffer[TotLeng], p, leng);
4466                 TotLeng = TotLeng + leng;
4467         } while(TRUE);
4468
4469         va_end(Args); /* clean up */
4470         *FrameLen = TotLeng;
4471         return TotLeng;
4472 }
4473
4474 // ===========================================================================================
4475 // mlme_queue.c
4476 // ===========================================================================================
4477
4478 /*! \brief      Initialize The MLME Queue, used by MLME Functions
4479  *      \param  *Queue     The MLME Queue
4480  *      \return Always     Return NDIS_STATE_SUCCESS in this implementation
4481  *      \pre
4482  *      \post
4483  *      \note   Because this is done only once (at the init stage), no need to be locked
4484
4485  IRQL = PASSIVE_LEVEL
4486
4487  */
4488 NDIS_STATUS MlmeQueueInit(
4489         IN MLME_QUEUE *Queue)
4490 {
4491         INT i;
4492
4493         NdisAllocateSpinLock(&Queue->Lock);
4494
4495         Queue->Num      = 0;
4496         Queue->Head = 0;
4497         Queue->Tail = 0;
4498
4499         for (i = 0; i < MAX_LEN_OF_MLME_QUEUE; i++)
4500         {
4501                 Queue->Entry[i].Occupied = FALSE;
4502                 Queue->Entry[i].MsgLen = 0;
4503                 NdisZeroMemory(Queue->Entry[i].Msg, MGMT_DMA_BUFFER_SIZE);
4504         }
4505
4506         return NDIS_STATUS_SUCCESS;
4507 }
4508
4509 /*! \brief       Enqueue a message for other threads, if they want to send messages to MLME thread
4510  *      \param  *Queue    The MLME Queue
4511  *      \param   Machine  The State Machine Id
4512  *      \param   MsgType  The Message Type
4513  *      \param   MsgLen   The Message length
4514  *      \param  *Msg      The message pointer
4515  *      \return  TRUE if enqueue is successful, FALSE if the queue is full
4516  *      \pre
4517  *      \post
4518  *      \note    The message has to be initialized
4519
4520  IRQL = PASSIVE_LEVEL
4521  IRQL = DISPATCH_LEVEL
4522
4523  */
4524 BOOLEAN MlmeEnqueue(
4525         IN      PRTMP_ADAPTER   pAd,
4526         IN ULONG Machine,
4527         IN ULONG MsgType,
4528         IN ULONG MsgLen,
4529         IN VOID *Msg)
4530 {
4531         INT Tail;
4532         MLME_QUEUE      *Queue = (MLME_QUEUE *)&pAd->Mlme.Queue;
4533
4534         // Do nothing if the driver is starting halt state.
4535         // This might happen when timer already been fired before cancel timer with mlmehalt
4536         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST))
4537                 return FALSE;
4538
4539         // First check the size, it MUST not exceed the mlme queue size
4540         if (MsgLen > MGMT_DMA_BUFFER_SIZE)
4541         {
4542                 DBGPRINT_ERR(("MlmeEnqueue: msg too large, size = %ld \n", MsgLen));
4543                 return FALSE;
4544         }
4545
4546         if (MlmeQueueFull(Queue))
4547         {
4548                 return FALSE;
4549         }
4550
4551         NdisAcquireSpinLock(&(Queue->Lock));
4552         Tail = Queue->Tail;
4553         Queue->Tail++;
4554         Queue->Num++;
4555         if (Queue->Tail == MAX_LEN_OF_MLME_QUEUE)
4556         {
4557                 Queue->Tail = 0;
4558         }
4559
4560         Queue->Entry[Tail].Wcid = RESERVED_WCID;
4561         Queue->Entry[Tail].Occupied = TRUE;
4562         Queue->Entry[Tail].Machine = Machine;
4563         Queue->Entry[Tail].MsgType = MsgType;
4564         Queue->Entry[Tail].MsgLen  = MsgLen;
4565
4566         if (Msg != NULL)
4567         {
4568                 NdisMoveMemory(Queue->Entry[Tail].Msg, Msg, MsgLen);
4569         }
4570
4571         NdisReleaseSpinLock(&(Queue->Lock));
4572         return TRUE;
4573 }
4574
4575 /*! \brief       This function is used when Recv gets a MLME message
4576  *      \param  *Queue                   The MLME Queue
4577  *      \param   TimeStampHigh   The upper 32 bit of timestamp
4578  *      \param   TimeStampLow    The lower 32 bit of timestamp
4579  *      \param   Rssi                    The receiving RSSI strength
4580  *      \param   MsgLen                  The length of the message
4581  *      \param  *Msg                     The message pointer
4582  *      \return  TRUE if everything ok, FALSE otherwise (like Queue Full)
4583  *      \pre
4584  *      \post
4585
4586  IRQL = DISPATCH_LEVEL
4587
4588  */
4589 BOOLEAN MlmeEnqueueForRecv(
4590         IN      PRTMP_ADAPTER   pAd,
4591         IN ULONG Wcid,
4592         IN ULONG TimeStampHigh,
4593         IN ULONG TimeStampLow,
4594         IN UCHAR Rssi0,
4595         IN UCHAR Rssi1,
4596         IN UCHAR Rssi2,
4597         IN ULONG MsgLen,
4598         IN VOID *Msg,
4599         IN UCHAR Signal)
4600 {
4601         INT              Tail, Machine;
4602         PFRAME_802_11 pFrame = (PFRAME_802_11)Msg;
4603         INT              MsgType;
4604         MLME_QUEUE      *Queue = (MLME_QUEUE *)&pAd->Mlme.Queue;
4605
4606         // Do nothing if the driver is starting halt state.
4607         // This might happen when timer already been fired before cancel timer with mlmehalt
4608         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST))
4609         {
4610                 DBGPRINT_ERR(("MlmeEnqueueForRecv: fRTMP_ADAPTER_HALT_IN_PROGRESS\n"));
4611                 return FALSE;
4612         }
4613
4614         // First check the size, it MUST not exceed the mlme queue size
4615         if (MsgLen > MGMT_DMA_BUFFER_SIZE)
4616         {
4617                 DBGPRINT_ERR(("MlmeEnqueueForRecv: frame too large, size = %ld \n", MsgLen));
4618                 return FALSE;
4619         }
4620
4621         if (MlmeQueueFull(Queue))
4622         {
4623                 return FALSE;
4624         }
4625
4626 #ifdef CONFIG_STA_SUPPORT
4627         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
4628         {
4629                 if (!MsgTypeSubst(pAd, pFrame, &Machine, &MsgType))
4630                 {
4631                         DBGPRINT_ERR(("MlmeEnqueueForRecv: un-recongnized mgmt->subtype=%d\n",pFrame->Hdr.FC.SubType));
4632                         return FALSE;
4633                 }
4634         }
4635 #endif // CONFIG_STA_SUPPORT //
4636
4637         // OK, we got all the informations, it is time to put things into queue
4638         NdisAcquireSpinLock(&(Queue->Lock));
4639         Tail = Queue->Tail;
4640         Queue->Tail++;
4641         Queue->Num++;
4642         if (Queue->Tail == MAX_LEN_OF_MLME_QUEUE)
4643         {
4644                 Queue->Tail = 0;
4645         }
4646         Queue->Entry[Tail].Occupied = TRUE;
4647         Queue->Entry[Tail].Machine = Machine;
4648         Queue->Entry[Tail].MsgType = MsgType;
4649         Queue->Entry[Tail].MsgLen  = MsgLen;
4650         Queue->Entry[Tail].TimeStamp.u.LowPart = TimeStampLow;
4651         Queue->Entry[Tail].TimeStamp.u.HighPart = TimeStampHigh;
4652         Queue->Entry[Tail].Rssi0 = Rssi0;
4653         Queue->Entry[Tail].Rssi1 = Rssi1;
4654         Queue->Entry[Tail].Rssi2 = Rssi2;
4655         Queue->Entry[Tail].Signal = Signal;
4656         Queue->Entry[Tail].Wcid = (UCHAR)Wcid;
4657
4658         Queue->Entry[Tail].Channel = pAd->LatchRfRegs.Channel;
4659
4660         if (Msg != NULL)
4661         {
4662                 NdisMoveMemory(Queue->Entry[Tail].Msg, Msg, MsgLen);
4663         }
4664
4665         NdisReleaseSpinLock(&(Queue->Lock));
4666
4667         RT28XX_MLME_HANDLER(pAd);
4668
4669         return TRUE;
4670 }
4671
4672
4673 /*! \brief       Dequeue a message from the MLME Queue
4674  *      \param  *Queue    The MLME Queue
4675  *      \param  *Elem     The message dequeued from MLME Queue
4676  *      \return  TRUE if the Elem contains something, FALSE otherwise
4677  *      \pre
4678  *      \post
4679
4680  IRQL = DISPATCH_LEVEL
4681
4682  */
4683 BOOLEAN MlmeDequeue(
4684         IN MLME_QUEUE *Queue,
4685         OUT MLME_QUEUE_ELEM **Elem)
4686 {
4687         NdisAcquireSpinLock(&(Queue->Lock));
4688         *Elem = &(Queue->Entry[Queue->Head]);
4689         Queue->Num--;
4690         Queue->Head++;
4691         if (Queue->Head == MAX_LEN_OF_MLME_QUEUE)
4692         {
4693                 Queue->Head = 0;
4694         }
4695         NdisReleaseSpinLock(&(Queue->Lock));
4696         return TRUE;
4697 }
4698
4699 // IRQL = DISPATCH_LEVEL
4700 VOID    MlmeRestartStateMachine(
4701         IN      PRTMP_ADAPTER   pAd)
4702 {
4703 #ifdef CONFIG_STA_SUPPORT
4704         BOOLEAN                         Cancelled;
4705 #endif // CONFIG_STA_SUPPORT //
4706
4707         DBGPRINT(RT_DEBUG_TRACE, ("MlmeRestartStateMachine \n"));
4708
4709
4710 #ifdef CONFIG_STA_SUPPORT
4711         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
4712         {
4713                 // Cancel all timer events
4714                 // Be careful to cancel new added timer
4715                 RTMPCancelTimer(&pAd->MlmeAux.AssocTimer,         &Cancelled);
4716                 RTMPCancelTimer(&pAd->MlmeAux.ReassocTimer,   &Cancelled);
4717                 RTMPCancelTimer(&pAd->MlmeAux.DisassocTimer,  &Cancelled);
4718                 RTMPCancelTimer(&pAd->MlmeAux.AuthTimer,           &Cancelled);
4719                 RTMPCancelTimer(&pAd->MlmeAux.BeaconTimer,         &Cancelled);
4720                 RTMPCancelTimer(&pAd->MlmeAux.ScanTimer,           &Cancelled);
4721         }
4722 #endif // CONFIG_STA_SUPPORT //
4723
4724         // Change back to original channel in case of doing scan
4725         AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
4726         AsicLockChannel(pAd, pAd->CommonCfg.Channel);
4727
4728         // Resume MSDU which is turned off durning scan
4729         RTMPResumeMsduTransmission(pAd);
4730
4731 #ifdef CONFIG_STA_SUPPORT
4732         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
4733         {
4734                 // Set all state machines back IDLE
4735                 pAd->Mlme.CntlMachine.CurrState    = CNTL_IDLE;
4736                 pAd->Mlme.AssocMachine.CurrState   = ASSOC_IDLE;
4737                 pAd->Mlme.AuthMachine.CurrState    = AUTH_REQ_IDLE;
4738                 pAd->Mlme.AuthRspMachine.CurrState = AUTH_RSP_IDLE;
4739                 pAd->Mlme.SyncMachine.CurrState    = SYNC_IDLE;
4740                 pAd->Mlme.ActMachine.CurrState    = ACT_IDLE;
4741         }
4742 #endif // CONFIG_STA_SUPPORT //
4743
4744 }
4745
4746 /*! \brief      test if the MLME Queue is empty
4747  *      \param  *Queue    The MLME Queue
4748  *      \return TRUE if the Queue is empty, FALSE otherwise
4749  *      \pre
4750  *      \post
4751
4752  IRQL = DISPATCH_LEVEL
4753
4754  */
4755 BOOLEAN MlmeQueueEmpty(
4756         IN MLME_QUEUE *Queue)
4757 {
4758         BOOLEAN Ans;
4759
4760         NdisAcquireSpinLock(&(Queue->Lock));
4761         Ans = (Queue->Num == 0);
4762         NdisReleaseSpinLock(&(Queue->Lock));
4763
4764         return Ans;
4765 }
4766
4767 /*! \brief       test if the MLME Queue is full
4768  *      \param   *Queue          The MLME Queue
4769  *      \return  TRUE if the Queue is empty, FALSE otherwise
4770  *      \pre
4771  *      \post
4772
4773  IRQL = PASSIVE_LEVEL
4774  IRQL = DISPATCH_LEVEL
4775
4776  */
4777 BOOLEAN MlmeQueueFull(
4778         IN MLME_QUEUE *Queue)
4779 {
4780         BOOLEAN Ans;
4781
4782         NdisAcquireSpinLock(&(Queue->Lock));
4783         Ans = (Queue->Num == MAX_LEN_OF_MLME_QUEUE || Queue->Entry[Queue->Tail].Occupied);
4784         NdisReleaseSpinLock(&(Queue->Lock));
4785
4786         return Ans;
4787 }
4788
4789 /*! \brief       The destructor of MLME Queue
4790  *      \param
4791  *      \return
4792  *      \pre
4793  *      \post
4794  *      \note   Clear Mlme Queue, Set Queue->Num to Zero.
4795
4796  IRQL = PASSIVE_LEVEL
4797
4798  */
4799 VOID MlmeQueueDestroy(
4800         IN MLME_QUEUE *pQueue)
4801 {
4802         NdisAcquireSpinLock(&(pQueue->Lock));
4803         pQueue->Num  = 0;
4804         pQueue->Head = 0;
4805         pQueue->Tail = 0;
4806         NdisReleaseSpinLock(&(pQueue->Lock));
4807         NdisFreeSpinLock(&(pQueue->Lock));
4808 }
4809
4810 /*! \brief       To substitute the message type if the message is coming from external
4811  *      \param  pFrame             The frame received
4812  *      \param  *Machine           The state machine
4813  *      \param  *MsgType           the message type for the state machine
4814  *      \return TRUE if the substitution is successful, FALSE otherwise
4815  *      \pre
4816  *      \post
4817
4818  IRQL = DISPATCH_LEVEL
4819
4820  */
4821 #ifdef CONFIG_STA_SUPPORT
4822 BOOLEAN MsgTypeSubst(
4823         IN PRTMP_ADAPTER  pAd,
4824         IN PFRAME_802_11 pFrame,
4825         OUT INT *Machine,
4826         OUT INT *MsgType)
4827 {
4828         USHORT  Seq;
4829         UCHAR   EAPType;
4830         PUCHAR  pData;
4831
4832         // Pointer to start of data frames including SNAP header
4833         pData = (PUCHAR) pFrame + LENGTH_802_11;
4834
4835         // The only data type will pass to this function is EAPOL frame
4836         if (pFrame->Hdr.FC.Type == BTYPE_DATA)
4837         {
4838                 if (NdisEqualMemory(SNAP_AIRONET, pData, LENGTH_802_1_H))
4839                 {
4840                         // Cisco Aironet SNAP header
4841                         *Machine = AIRONET_STATE_MACHINE;
4842                         *MsgType = MT2_AIRONET_MSG;
4843                         return (TRUE);
4844                 }
4845                 {
4846                         *Machine = WPA_PSK_STATE_MACHINE;
4847                         EAPType = *((UCHAR*)pFrame + LENGTH_802_11 + LENGTH_802_1_H + 1);
4848                         return(WpaMsgTypeSubst(EAPType, MsgType));
4849                 }
4850         }
4851
4852         switch (pFrame->Hdr.FC.SubType)
4853         {
4854                 case SUBTYPE_ASSOC_REQ:
4855                         *Machine = ASSOC_STATE_MACHINE;
4856                         *MsgType = MT2_PEER_ASSOC_REQ;
4857                         break;
4858                 case SUBTYPE_ASSOC_RSP:
4859                         *Machine = ASSOC_STATE_MACHINE;
4860                         *MsgType = MT2_PEER_ASSOC_RSP;
4861                         break;
4862                 case SUBTYPE_REASSOC_REQ:
4863                         *Machine = ASSOC_STATE_MACHINE;
4864                         *MsgType = MT2_PEER_REASSOC_REQ;
4865                         break;
4866                 case SUBTYPE_REASSOC_RSP:
4867                         *Machine = ASSOC_STATE_MACHINE;
4868                         *MsgType = MT2_PEER_REASSOC_RSP;
4869                         break;
4870                 case SUBTYPE_PROBE_REQ:
4871                         *Machine = SYNC_STATE_MACHINE;
4872                         *MsgType = MT2_PEER_PROBE_REQ;
4873                         break;
4874                 case SUBTYPE_PROBE_RSP:
4875                         *Machine = SYNC_STATE_MACHINE;
4876                         *MsgType = MT2_PEER_PROBE_RSP;
4877                         break;
4878                 case SUBTYPE_BEACON:
4879                         *Machine = SYNC_STATE_MACHINE;
4880                         *MsgType = MT2_PEER_BEACON;
4881                         break;
4882                 case SUBTYPE_ATIM:
4883                         *Machine = SYNC_STATE_MACHINE;
4884                         *MsgType = MT2_PEER_ATIM;
4885                         break;
4886                 case SUBTYPE_DISASSOC:
4887                         *Machine = ASSOC_STATE_MACHINE;
4888                         *MsgType = MT2_PEER_DISASSOC_REQ;
4889                         break;
4890                 case SUBTYPE_AUTH:
4891                         // get the sequence number from payload 24 Mac Header + 2 bytes algorithm
4892                         NdisMoveMemory(&Seq, &pFrame->Octet[2], sizeof(USHORT));
4893                         if (Seq == 1 || Seq == 3)
4894                         {
4895                                 *Machine = AUTH_RSP_STATE_MACHINE;
4896                                 *MsgType = MT2_PEER_AUTH_ODD;
4897                         }
4898                         else if (Seq == 2 || Seq == 4)
4899                         {
4900                                 *Machine = AUTH_STATE_MACHINE;
4901                                 *MsgType = MT2_PEER_AUTH_EVEN;
4902                         }
4903                         else
4904                         {
4905                                 return FALSE;
4906                         }
4907                         break;
4908                 case SUBTYPE_DEAUTH:
4909                         *Machine = AUTH_RSP_STATE_MACHINE;
4910                         *MsgType = MT2_PEER_DEAUTH;
4911                         break;
4912                 case SUBTYPE_ACTION:
4913                         *Machine = ACTION_STATE_MACHINE;
4914                         //  Sometimes Sta will return with category bytes with MSB = 1, if they receive catogory out of their support
4915                         if ((pFrame->Octet[0]&0x7F) > MAX_PEER_CATE_MSG)
4916                         {
4917                                 *MsgType = MT2_ACT_INVALID;
4918                         }
4919                         else
4920                         {
4921                                 *MsgType = (pFrame->Octet[0]&0x7F);
4922                         }
4923                         break;
4924                 default:
4925                         return FALSE;
4926                         break;
4927         }
4928
4929         return TRUE;
4930 }
4931 #endif // CONFIG_STA_SUPPORT //
4932
4933 // ===========================================================================================
4934 // state_machine.c
4935 // ===========================================================================================
4936
4937 /*! \brief Initialize the state machine.
4938  *      \param *S                       pointer to the state machine
4939  *      \param  Trans           State machine transition function
4940  *      \param  StNr            number of states
4941  *      \param  MsgNr           number of messages
4942  *      \param  DefFunc         default function, when there is invalid state/message combination
4943  *      \param  InitState       initial state of the state machine
4944  *      \param  Base            StateMachine base, internal use only
4945  *      \pre p_sm should be a legal pointer
4946  *      \post
4947
4948  IRQL = PASSIVE_LEVEL
4949
4950  */
4951 VOID StateMachineInit(
4952         IN STATE_MACHINE *S,
4953         IN STATE_MACHINE_FUNC Trans[],
4954         IN ULONG StNr,
4955         IN ULONG MsgNr,
4956         IN STATE_MACHINE_FUNC DefFunc,
4957         IN ULONG InitState,
4958         IN ULONG Base)
4959 {
4960         ULONG i, j;
4961
4962         // set number of states and messages
4963         S->NrState = StNr;
4964         S->NrMsg   = MsgNr;
4965         S->Base    = Base;
4966
4967         S->TransFunc  = Trans;
4968
4969         // init all state transition to default function
4970         for (i = 0; i < StNr; i++)
4971         {
4972                 for (j = 0; j < MsgNr; j++)
4973                 {
4974                         S->TransFunc[i * MsgNr + j] = DefFunc;
4975                 }
4976         }
4977
4978         // set the starting state
4979         S->CurrState = InitState;
4980 }
4981
4982 /*! \brief This function fills in the function pointer into the cell in the state machine
4983  *      \param *S       pointer to the state machine
4984  *      \param St       state
4985  *      \param Msg      incoming message
4986  *      \param f        the function to be executed when (state, message) combination occurs at the state machine
4987  *      \pre *S should be a legal pointer to the state machine, st, msg, should be all within the range, Base should be set in the initial state
4988  *      \post
4989
4990  IRQL = PASSIVE_LEVEL
4991
4992  */
4993 VOID StateMachineSetAction(
4994         IN STATE_MACHINE *S,
4995         IN ULONG St,
4996         IN ULONG Msg,
4997         IN STATE_MACHINE_FUNC Func)
4998 {
4999         ULONG MsgIdx;
5000
5001         MsgIdx = Msg - S->Base;
5002
5003         if (St < S->NrState && MsgIdx < S->NrMsg)
5004         {
5005                 // boundary checking before setting the action
5006                 S->TransFunc[St * S->NrMsg + MsgIdx] = Func;
5007         }
5008 }
5009
5010 /*! \brief       This function does the state transition
5011  *      \param   *Adapter the NIC adapter pointer
5012  *      \param   *S       the state machine
5013  *      \param   *Elem    the message to be executed
5014  *      \return   None
5015
5016  IRQL = DISPATCH_LEVEL
5017
5018  */
5019 VOID StateMachinePerformAction(
5020         IN      PRTMP_ADAPTER   pAd,
5021         IN STATE_MACHINE *S,
5022         IN MLME_QUEUE_ELEM *Elem)
5023 {
5024         (*(S->TransFunc[S->CurrState * S->NrMsg + Elem->MsgType - S->Base]))(pAd, Elem);
5025 }
5026
5027 /*
5028         ==========================================================================
5029         Description:
5030                 The drop function, when machine executes this, the message is simply
5031                 ignored. This function does nothing, the message is freed in
5032                 StateMachinePerformAction()
5033         ==========================================================================
5034  */
5035 VOID Drop(
5036         IN PRTMP_ADAPTER pAd,
5037         IN MLME_QUEUE_ELEM *Elem)
5038 {
5039 }
5040
5041 // ===========================================================================================
5042 // lfsr.c
5043 // ===========================================================================================
5044
5045 /*
5046         ==========================================================================
5047         Description:
5048
5049         IRQL = PASSIVE_LEVEL
5050
5051         ==========================================================================
5052  */
5053 VOID LfsrInit(
5054         IN PRTMP_ADAPTER pAd,
5055         IN ULONG Seed)
5056 {
5057         if (Seed == 0)
5058                 pAd->Mlme.ShiftReg = 1;
5059         else
5060                 pAd->Mlme.ShiftReg = Seed;
5061 }
5062
5063 /*
5064         ==========================================================================
5065         Description:
5066         ==========================================================================
5067  */
5068 UCHAR RandomByte(
5069         IN PRTMP_ADAPTER pAd)
5070 {
5071         ULONG i;
5072         UCHAR R, Result;
5073
5074         R = 0;
5075
5076         if (pAd->Mlme.ShiftReg == 0)
5077         NdisGetSystemUpTime((ULONG *)&pAd->Mlme.ShiftReg);
5078
5079         for (i = 0; i < 8; i++)
5080         {
5081                 if (pAd->Mlme.ShiftReg & 0x00000001)
5082                 {
5083                         pAd->Mlme.ShiftReg = ((pAd->Mlme.ShiftReg ^ LFSR_MASK) >> 1) | 0x80000000;
5084                         Result = 1;
5085                 }
5086                 else
5087                 {
5088                         pAd->Mlme.ShiftReg = pAd->Mlme.ShiftReg >> 1;
5089                         Result = 0;
5090                 }
5091                 R = (R << 1) | Result;
5092         }
5093
5094         return R;
5095 }
5096
5097 VOID AsicUpdateAutoFallBackTable(
5098         IN      PRTMP_ADAPTER   pAd,
5099         IN      PUCHAR                  pRateTable)
5100 {
5101         UCHAR                                   i;
5102         HT_FBK_CFG0_STRUC               HtCfg0;
5103         HT_FBK_CFG1_STRUC               HtCfg1;
5104         LG_FBK_CFG0_STRUC               LgCfg0;
5105         LG_FBK_CFG1_STRUC               LgCfg1;
5106         PRTMP_TX_RATE_SWITCH    pCurrTxRate, pNextTxRate;
5107
5108         // set to initial value
5109         HtCfg0.word = 0x65432100;
5110         HtCfg1.word = 0xedcba988;
5111         LgCfg0.word = 0xedcba988;
5112         LgCfg1.word = 0x00002100;
5113
5114         pNextTxRate = (PRTMP_TX_RATE_SWITCH)pRateTable+1;
5115         for (i = 1; i < *((PUCHAR) pRateTable); i++)
5116         {
5117                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH)pRateTable+1+i;
5118                 switch (pCurrTxRate->Mode)
5119                 {
5120                         case 0:         //CCK
5121                                 break;
5122                         case 1:         //OFDM
5123                                 {
5124                                         switch(pCurrTxRate->CurrMCS)
5125                                         {
5126                                                 case 0:
5127                                                         LgCfg0.field.OFDMMCS0FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5128                                                         break;
5129                                                 case 1:
5130                                                         LgCfg0.field.OFDMMCS1FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5131                                                         break;
5132                                                 case 2:
5133                                                         LgCfg0.field.OFDMMCS2FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5134                                                         break;
5135                                                 case 3:
5136                                                         LgCfg0.field.OFDMMCS3FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5137                                                         break;
5138                                                 case 4:
5139                                                         LgCfg0.field.OFDMMCS4FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5140                                                         break;
5141                                                 case 5:
5142                                                         LgCfg0.field.OFDMMCS5FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5143                                                         break;
5144                                                 case 6:
5145                                                         LgCfg0.field.OFDMMCS6FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5146                                                         break;
5147                                                 case 7:
5148                                                         LgCfg0.field.OFDMMCS7FBK = (pNextTxRate->Mode == MODE_OFDM) ? (pNextTxRate->CurrMCS+8): pNextTxRate->CurrMCS;
5149                                                         break;
5150                                         }
5151                                 }
5152                                 break;
5153 #ifdef DOT11_N_SUPPORT
5154                         case 2:         //HT-MIX
5155                         case 3:         //HT-GF
5156                                 {
5157                                         if ((pNextTxRate->Mode >= MODE_HTMIX) && (pCurrTxRate->CurrMCS != pNextTxRate->CurrMCS))
5158                                         {
5159                                                 switch(pCurrTxRate->CurrMCS)
5160                                                 {
5161                                                         case 0:
5162                                                                 HtCfg0.field.HTMCS0FBK = pNextTxRate->CurrMCS;
5163                                                                 break;
5164                                                         case 1:
5165                                                                 HtCfg0.field.HTMCS1FBK = pNextTxRate->CurrMCS;
5166                                                                 break;
5167                                                         case 2:
5168                                                                 HtCfg0.field.HTMCS2FBK = pNextTxRate->CurrMCS;
5169                                                                 break;
5170                                                         case 3:
5171                                                                 HtCfg0.field.HTMCS3FBK = pNextTxRate->CurrMCS;
5172                                                                 break;
5173                                                         case 4:
5174                                                                 HtCfg0.field.HTMCS4FBK = pNextTxRate->CurrMCS;
5175                                                                 break;
5176                                                         case 5:
5177                                                                 HtCfg0.field.HTMCS5FBK = pNextTxRate->CurrMCS;
5178                                                                 break;
5179                                                         case 6:
5180                                                                 HtCfg0.field.HTMCS6FBK = pNextTxRate->CurrMCS;
5181                                                                 break;
5182                                                         case 7:
5183                                                                 HtCfg0.field.HTMCS7FBK = pNextTxRate->CurrMCS;
5184                                                                 break;
5185                                                         case 8:
5186                                                                 HtCfg1.field.HTMCS8FBK = pNextTxRate->CurrMCS;
5187                                                                 break;
5188                                                         case 9:
5189                                                                 HtCfg1.field.HTMCS9FBK = pNextTxRate->CurrMCS;
5190                                                                 break;
5191                                                         case 10:
5192                                                                 HtCfg1.field.HTMCS10FBK = pNextTxRate->CurrMCS;
5193                                                                 break;
5194                                                         case 11:
5195                                                                 HtCfg1.field.HTMCS11FBK = pNextTxRate->CurrMCS;
5196                                                                 break;
5197                                                         case 12:
5198                                                                 HtCfg1.field.HTMCS12FBK = pNextTxRate->CurrMCS;
5199                                                                 break;
5200                                                         case 13:
5201                                                                 HtCfg1.field.HTMCS13FBK = pNextTxRate->CurrMCS;
5202                                                                 break;
5203                                                         case 14:
5204                                                                 HtCfg1.field.HTMCS14FBK = pNextTxRate->CurrMCS;
5205                                                                 break;
5206                                                         case 15:
5207                                                                 HtCfg1.field.HTMCS15FBK = pNextTxRate->CurrMCS;
5208                                                                 break;
5209                                                         default:
5210                                                                 DBGPRINT(RT_DEBUG_ERROR, ("AsicUpdateAutoFallBackTable: not support CurrMCS=%d\n", pCurrTxRate->CurrMCS));
5211                                                 }
5212                                         }
5213                                 }
5214                                 break;
5215 #endif // DOT11_N_SUPPORT //
5216                 }
5217
5218                 pNextTxRate = pCurrTxRate;
5219         }
5220
5221         RTMP_IO_WRITE32(pAd, HT_FBK_CFG0, HtCfg0.word);
5222         RTMP_IO_WRITE32(pAd, HT_FBK_CFG1, HtCfg1.word);
5223         RTMP_IO_WRITE32(pAd, LG_FBK_CFG0, LgCfg0.word);
5224         RTMP_IO_WRITE32(pAd, LG_FBK_CFG1, LgCfg1.word);
5225 }
5226
5227 /*
5228         ========================================================================
5229
5230         Routine Description:
5231                 Set MAC register value according operation mode.
5232                 OperationMode AND bNonGFExist are for MM and GF Proteciton.
5233                 If MM or GF mask is not set, those passing argument doesn't not take effect.
5234
5235                 Operation mode meaning:
5236                 = 0 : Pure HT, no preotection.
5237                 = 0x01; there may be non-HT devices in both the control and extension channel, protection is optional in BSS.
5238                 = 0x10: No Transmission in 40M is protected.
5239                 = 0x11: Transmission in both 40M and 20M shall be protected
5240                 if (bNonGFExist)
5241                         we should choose not to use GF. But still set correct ASIC registers.
5242         ========================================================================
5243 */
5244 VOID    AsicUpdateProtect(
5245         IN              PRTMP_ADAPTER   pAd,
5246         IN              USHORT                  OperationMode,
5247         IN              UCHAR                   SetMask,
5248         IN              BOOLEAN                 bDisableBGProtect,
5249         IN              BOOLEAN                 bNonGFExist)
5250 {
5251         PROT_CFG_STRUC  ProtCfg, ProtCfg4;
5252         UINT32 Protect[6];
5253         USHORT                  offset;
5254         UCHAR                   i;
5255         UINT32 MacReg = 0;
5256
5257 #ifdef DOT11_N_SUPPORT
5258         if (!(pAd->CommonCfg.bHTProtect) && (OperationMode != 8))
5259         {
5260                 return;
5261         }
5262
5263         if (pAd->BATable.numAsOriginator)
5264         {
5265                 //
5266                 // enable the RTS/CTS to avoid channel collision
5267                 //
5268                 SetMask = ALLN_SETPROTECT;
5269                 OperationMode = 8;
5270         }
5271 #endif // DOT11_N_SUPPORT //
5272
5273         // Config ASIC RTS threshold register
5274         RTMP_IO_READ32(pAd, TX_RTS_CFG, &MacReg);
5275         MacReg &= 0xFF0000FF;
5276 #if 0
5277         MacReg |= (pAd->CommonCfg.RtsThreshold << 8);
5278 #else
5279         // If the user want disable RtsThreshold and enable Amsdu/Ralink-Aggregation, set the RtsThreshold as 4096
5280         if ((
5281 #ifdef DOT11_N_SUPPORT
5282                         (pAd->CommonCfg.BACapability.field.AmsduEnable) ||
5283 #endif // DOT11_N_SUPPORT //
5284                         (pAd->CommonCfg.bAggregationCapable == TRUE))
5285             && pAd->CommonCfg.RtsThreshold == MAX_RTS_THRESHOLD)
5286         {
5287                         MacReg |= (0x1000 << 8);
5288         }
5289         else
5290         {
5291                         MacReg |= (pAd->CommonCfg.RtsThreshold << 8);
5292         }
5293 #endif
5294
5295         RTMP_IO_WRITE32(pAd, TX_RTS_CFG, MacReg);
5296
5297         // Initial common protection settings
5298         RTMPZeroMemory(Protect, sizeof(Protect));
5299         ProtCfg4.word = 0;
5300         ProtCfg.word = 0;
5301         ProtCfg.field.TxopAllowGF40 = 1;
5302         ProtCfg.field.TxopAllowGF20 = 1;
5303         ProtCfg.field.TxopAllowMM40 = 1;
5304         ProtCfg.field.TxopAllowMM20 = 1;
5305         ProtCfg.field.TxopAllowOfdm = 1;
5306         ProtCfg.field.TxopAllowCck = 1;
5307         ProtCfg.field.RTSThEn = 1;
5308         ProtCfg.field.ProtectNav = ASIC_SHORTNAV;
5309
5310         // update PHY mode and rate
5311         if (pAd->CommonCfg.Channel > 14)
5312                 ProtCfg.field.ProtectRate = 0x4000;
5313         ProtCfg.field.ProtectRate |= pAd->CommonCfg.RtsRate;
5314
5315         // Handle legacy(B/G) protection
5316         if (bDisableBGProtect)
5317         {
5318                 //ProtCfg.field.ProtectRate = pAd->CommonCfg.RtsRate;
5319                 ProtCfg.field.ProtectCtrl = 0;
5320                 Protect[0] = ProtCfg.word;
5321                 Protect[1] = ProtCfg.word;
5322         }
5323         else
5324         {
5325                 //ProtCfg.field.ProtectRate = pAd->CommonCfg.RtsRate;
5326                 ProtCfg.field.ProtectCtrl = 0;                  // CCK do not need to be protected
5327                 Protect[0] = ProtCfg.word;
5328                 ProtCfg.field.ProtectCtrl = ASIC_CTS;   // OFDM needs using CCK to protect
5329                 Protect[1] = ProtCfg.word;
5330         }
5331
5332 #ifdef DOT11_N_SUPPORT
5333         // Decide HT frame protection.
5334         if ((SetMask & ALLN_SETPROTECT) != 0)
5335         {
5336                 switch(OperationMode)
5337                 {
5338                         case 0x0:
5339                                 // NO PROTECT
5340                                 // 1.All STAs in the BSS are 20/40 MHz HT
5341                                 // 2. in ai 20/40MHz BSS
5342                                 // 3. all STAs are 20MHz in a 20MHz BSS
5343                                 // Pure HT. no protection.
5344
5345                                 // MM20_PROT_CFG
5346                                 //      Reserved (31:27)
5347                                 //      PROT_TXOP(25:20) -- 010111
5348                                 //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
5349                                 //  PROT_CTRL(17:16) -- 00 (None)
5350                                 //      PROT_RATE(15:0)  -- 0x4004 (OFDM 24M)
5351                                 Protect[2] = 0x01744004;
5352
5353                                 // MM40_PROT_CFG
5354                                 //      Reserved (31:27)
5355                                 //      PROT_TXOP(25:20) -- 111111
5356                                 //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
5357                                 //  PROT_CTRL(17:16) -- 00 (None)
5358                                 //      PROT_RATE(15:0)  -- 0x4084 (duplicate OFDM 24M)
5359                                 Protect[3] = 0x03f44084;
5360
5361                                 // CF20_PROT_CFG
5362                                 //      Reserved (31:27)
5363                                 //      PROT_TXOP(25:20) -- 010111
5364                                 //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
5365                                 //  PROT_CTRL(17:16) -- 00 (None)
5366                                 //      PROT_RATE(15:0)  -- 0x4004 (OFDM 24M)
5367                                 Protect[4] = 0x01744004;
5368
5369                                 // CF40_PROT_CFG
5370                                 //      Reserved (31:27)
5371                                 //      PROT_TXOP(25:20) -- 111111
5372                                 //      PROT_NAV(19:18)  -- 01 (Short NAV protection)
5373                                 //  PROT_CTRL(17:16) -- 00 (None)
5374                                 //      PROT_RATE(15:0)  -- 0x4084 (duplicate OFDM 24M)
5375                                 Protect[5] = 0x03f44084;
5376
5377                                 if (bNonGFExist)
5378                                 {
5379                                         // PROT_NAV(19:18)  -- 01 (Short NAV protectiion)
5380                                         // PROT_CTRL(17:16) -- 01 (RTS/CTS)
5381                                         Protect[4] = 0x01754004;
5382                                         Protect[5] = 0x03f54084;
5383                                 }
5384                                 pAd->CommonCfg.IOTestParm.bRTSLongProtOn = FALSE;
5385                                 break;
5386
5387                         case 1:
5388                                 // This is "HT non-member protection mode."
5389                                 // If there may be non-HT STAs my BSS
5390                                 ProtCfg.word = 0x01744004;      // PROT_CTRL(17:16) : 0 (None)
5391                                 ProtCfg4.word = 0x03f44084; // duplicaet legacy 24M. BW set 1.
5392                                 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_BG_PROTECTION_INUSED))
5393                                 {
5394                                         ProtCfg.word = 0x01740003;      //ERP use Protection bit is set, use protection rate at Clause 18..
5395                                         ProtCfg4.word = 0x03f40003; // Don't duplicate RTS/CTS in CCK mode. 0x03f40083;
5396                                 }
5397                                 //Assign Protection method for 20&40 MHz packets
5398                                 ProtCfg.field.ProtectCtrl = ASIC_RTS;
5399                                 ProtCfg.field.ProtectNav = ASIC_SHORTNAV;
5400                                 ProtCfg4.field.ProtectCtrl = ASIC_RTS;
5401                                 ProtCfg4.field.ProtectNav = ASIC_SHORTNAV;
5402                                 Protect[2] = ProtCfg.word;
5403                                 Protect[3] = ProtCfg4.word;
5404                                 Protect[4] = ProtCfg.word;
5405                                 Protect[5] = ProtCfg4.word;
5406                                 pAd->CommonCfg.IOTestParm.bRTSLongProtOn = TRUE;
5407                                 break;
5408
5409                         case 2:
5410                                 // If only HT STAs are in BSS. at least one is 20MHz. Only protect 40MHz packets
5411                                 ProtCfg.word = 0x01744004;  // PROT_CTRL(17:16) : 0 (None)
5412                                 ProtCfg4.word = 0x03f44084; // duplicaet legacy 24M. BW set 1.
5413
5414                                 //Assign Protection method for 40MHz packets
5415                                 ProtCfg4.field.ProtectCtrl = ASIC_RTS;
5416                                 ProtCfg4.field.ProtectNav = ASIC_SHORTNAV;
5417                                 Protect[2] = ProtCfg.word;
5418                                 Protect[3] = ProtCfg4.word;
5419                                 if (bNonGFExist)
5420                                 {
5421                                         ProtCfg.field.ProtectCtrl = ASIC_RTS;
5422                                         ProtCfg.field.ProtectNav = ASIC_SHORTNAV;
5423                                 }
5424                                 Protect[4] = ProtCfg.word;
5425                                 Protect[5] = ProtCfg4.word;
5426
5427                                 pAd->CommonCfg.IOTestParm.bRTSLongProtOn = FALSE;
5428                                 break;
5429
5430                         case 3:
5431                                 // HT mixed mode.        PROTECT ALL!
5432                                 // Assign Rate
5433                                 ProtCfg.word = 0x01744004;      //duplicaet legacy 24M. BW set 1.
5434                                 ProtCfg4.word = 0x03f44084;
5435                                 // both 20MHz and 40MHz are protected. Whether use RTS or CTS-to-self depends on the
5436                                 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_BG_PROTECTION_INUSED))
5437                                 {
5438                                         ProtCfg.word = 0x01740003;      //ERP use Protection bit is set, use protection rate at Clause 18..
5439                                         ProtCfg4.word = 0x03f40003; // Don't duplicate RTS/CTS in CCK mode. 0x03f40083
5440                                 }
5441                                 //Assign Protection method for 20&40 MHz packets
5442                                 ProtCfg.field.ProtectCtrl = ASIC_RTS;
5443                                 ProtCfg.field.ProtectNav = ASIC_SHORTNAV;
5444                                 ProtCfg4.field.ProtectCtrl = ASIC_RTS;
5445                                 ProtCfg4.field.ProtectNav = ASIC_SHORTNAV;
5446                                 Protect[2] = ProtCfg.word;
5447                                 Protect[3] = ProtCfg4.word;
5448                                 Protect[4] = ProtCfg.word;
5449                                 Protect[5] = ProtCfg4.word;
5450                                 pAd->CommonCfg.IOTestParm.bRTSLongProtOn = TRUE;
5451                                 break;
5452
5453                         case 8:
5454                                 // Special on for Atheros problem n chip.
5455                                 Protect[2] = 0x01754004;
5456                                 Protect[3] = 0x03f54084;
5457                                 Protect[4] = 0x01754004;
5458                                 Protect[5] = 0x03f54084;
5459                                 pAd->CommonCfg.IOTestParm.bRTSLongProtOn = TRUE;
5460                                 break;
5461                 }
5462         }
5463 #endif // DOT11_N_SUPPORT //
5464
5465         offset = CCK_PROT_CFG;
5466         for (i = 0;i < 6;i++)
5467         {
5468                 if ((SetMask & (1<< i)))
5469                 {
5470                         RTMP_IO_WRITE32(pAd, offset + i*4, Protect[i]);
5471                 }
5472         }
5473 }
5474
5475 /*
5476         ==========================================================================
5477         Description:
5478
5479         IRQL = PASSIVE_LEVEL
5480         IRQL = DISPATCH_LEVEL
5481
5482         ==========================================================================
5483  */
5484 VOID AsicSwitchChannel(
5485                                           IN PRTMP_ADAPTER pAd,
5486         IN      UCHAR                   Channel,
5487         IN      BOOLEAN                 bScan)
5488 {
5489         ULONG                   R2 = 0, R3 = DEFAULT_RF_TX_POWER, R4 = 0;
5490         CHAR    TxPwer = 0, TxPwer2 = DEFAULT_RF_TX_POWER; //Bbp94 = BBPR94_DEFAULT, TxPwer2 = DEFAULT_RF_TX_POWER;
5491         UCHAR   index;
5492         UINT32  Value = 0; //BbpReg, Value;
5493         RTMP_RF_REGS *RFRegTable;
5494
5495         // Search Tx power value
5496         for (index = 0; index < pAd->ChannelListNum; index++)
5497         {
5498                 if (Channel == pAd->ChannelList[index].Channel)
5499                 {
5500                         TxPwer = pAd->ChannelList[index].Power;
5501                         TxPwer2 = pAd->ChannelList[index].Power2;
5502                         break;
5503                 }
5504         }
5505
5506         if (index == MAX_NUM_OF_CHANNELS)
5507         {
5508                 DBGPRINT(RT_DEBUG_ERROR, ("AsicSwitchChannel: Cant find the Channel#%d \n", Channel));
5509         }
5510
5511 #ifdef RT2870
5512         // The RF programming sequence is difference between 3xxx and 2xxx
5513         if (IS_RT3070(pAd) && ((pAd->RfIcType == RFIC_3020) || (pAd->RfIcType == RFIC_2020)))
5514         {
5515                 /* modify by WY for Read RF Reg. error */
5516                 UCHAR RFValue;
5517
5518                 for (index = 0; index < NUM_OF_3020_CHNL; index++)
5519                 {
5520                         if (Channel == FreqItems3020[index].Channel)
5521                         {
5522                                 // Programming channel parameters
5523                                 RT30xxWriteRFRegister(pAd, RF_R02, FreqItems3020[index].N);
5524                                 RT30xxWriteRFRegister(pAd, RF_R03, FreqItems3020[index].K);
5525
5526                                 RT30xxReadRFRegister(pAd, RF_R06, (PUCHAR)&RFValue);
5527                                 RFValue = (RFValue & 0xFC) | FreqItems3020[index].R;
5528                                 RT30xxWriteRFRegister(pAd, RF_R06, (UCHAR)RFValue);
5529
5530                                 // Set Tx Power
5531                                 RT30xxReadRFRegister(pAd, RF_R12, (PUCHAR)&RFValue);
5532                                 RFValue = (RFValue & 0xE0) | TxPwer;
5533                                 RT30xxWriteRFRegister(pAd, RF_R12, (UCHAR)RFValue);
5534
5535                                 // Set RF offset
5536                                 RT30xxReadRFRegister(pAd, RF_R23, (PUCHAR)&RFValue);
5537                                 RFValue = (RFValue & 0x80) | pAd->RfFreqOffset;
5538                                 RT30xxWriteRFRegister(pAd, RF_R23, (UCHAR)RFValue);
5539
5540                                 // Set BW
5541                                 if (!bScan && (pAd->CommonCfg.BBPCurrentBW == BW_40))
5542                                 {
5543                                         RFValue = pAd->Mlme.CaliBW40RfR24;
5544                                         //DISABLE_11N_CHECK(pAd);
5545                                 }
5546                                 else
5547                                 {
5548                                         RFValue = pAd->Mlme.CaliBW20RfR24;
5549                                 }
5550                                 RT30xxWriteRFRegister(pAd, RF_R24, (UCHAR)RFValue);
5551
5552                                 // Enable RF tuning
5553                                 RT30xxReadRFRegister(pAd, RF_R07, (PUCHAR)&RFValue);
5554                                 RFValue = RFValue | 0x1;
5555                                 RT30xxWriteRFRegister(pAd, RF_R07, (UCHAR)RFValue);
5556
5557                                 // latch channel for future usage.
5558                                 pAd->LatchRfRegs.Channel = Channel;
5559
5560                                 break;
5561                         }
5562                 }
5563
5564                 DBGPRINT(RT_DEBUG_TRACE, ("SwitchChannel#%d(RF=%d, Pwr0=%d, Pwr1=%d, %dT), N=0x%02X, K=0x%02X, R=0x%02X\n",
5565                         Channel,
5566                         pAd->RfIcType,
5567                         TxPwer,
5568                         TxPwer2,
5569                         pAd->Antenna.field.TxPath,
5570                         FreqItems3020[index].N,
5571                         FreqItems3020[index].K,
5572                         FreqItems3020[index].R));
5573         }
5574         else
5575 #endif // RT2870 //
5576         {
5577                 RFRegTable = RF2850RegTable;
5578
5579                 switch (pAd->RfIcType)
5580                 {
5581                         case RFIC_2820:
5582                         case RFIC_2850:
5583                         case RFIC_2720:
5584                         case RFIC_2750:
5585
5586                         for (index = 0; index < NUM_OF_2850_CHNL; index++)
5587                         {
5588                                 if (Channel == RFRegTable[index].Channel)
5589                                 {
5590                                         R2 = RFRegTable[index].R2;
5591                                         if (pAd->Antenna.field.TxPath == 1)
5592                                         {
5593                                                 R2 |= 0x4000;   // If TXpath is 1, bit 14 = 1;
5594                                         }
5595
5596                                         if (pAd->Antenna.field.RxPath == 2)
5597                                         {
5598                                                 R2 |= 0x40;     // write 1 to off Rxpath.
5599                                         }
5600                                         else if (pAd->Antenna.field.RxPath == 1)
5601                                         {
5602                                                 R2 |= 0x20040;  // write 1 to off RxPath
5603                                         }
5604
5605                                         if (Channel > 14)
5606                                         {
5607                                                 // initialize R3, R4
5608                                                 R3 = (RFRegTable[index].R3 & 0xffffc1ff);
5609                                                 R4 = (RFRegTable[index].R4 & (~0x001f87c0)) | (pAd->RfFreqOffset << 15);
5610
5611                                                 // 5G band power range: 0xF9~0X0F, TX0 Reg3 bit9/TX1 Reg4 bit6="0" means the TX power reduce 7dB
5612                                                 // R3
5613                                                 if ((TxPwer >= -7) && (TxPwer < 0))
5614                                                 {
5615                                                         TxPwer = (7+TxPwer);
5616                                                         TxPwer = (TxPwer > 0xF) ? (0xF) : (TxPwer);
5617                                                         R3 |= (TxPwer << 10);
5618                                                         DBGPRINT(RT_DEBUG_ERROR, ("AsicSwitchChannel: TxPwer=%d \n", TxPwer));
5619                                                 }
5620                                                 else
5621                                                 {
5622                                                         TxPwer = (TxPwer > 0xF) ? (0xF) : (TxPwer);
5623                                                         R3 |= (TxPwer << 10) | (1 << 9);
5624                                                 }
5625
5626                                                 // R4
5627                                                 if ((TxPwer2 >= -7) && (TxPwer2 < 0))
5628                                                 {
5629                                                         TxPwer2 = (7+TxPwer2);
5630                                                         TxPwer2 = (TxPwer2 > 0xF) ? (0xF) : (TxPwer2);
5631                                                         R4 |= (TxPwer2 << 7);
5632                                                         DBGPRINT(RT_DEBUG_ERROR, ("AsicSwitchChannel: TxPwer2=%d \n", TxPwer2));
5633                                                 }
5634                                                 else
5635                                                 {
5636                                                         TxPwer2 = (TxPwer2 > 0xF) ? (0xF) : (TxPwer2);
5637                                                         R4 |= (TxPwer2 << 7) | (1 << 6);
5638                                                 }
5639                                         }
5640                                         else
5641                                         {
5642                                                 R3 = (RFRegTable[index].R3 & 0xffffc1ff) | (TxPwer << 9); // set TX power0
5643                                         R4 = (RFRegTable[index].R4 & (~0x001f87c0)) | (pAd->RfFreqOffset << 15) | (TxPwer2 <<6);// Set freq Offset & TxPwr1
5644                                         }
5645
5646                                         // Based on BBP current mode before changing RF channel.
5647                                         if (!bScan && (pAd->CommonCfg.BBPCurrentBW == BW_40))
5648                                         {
5649                                                 R4 |=0x200000;
5650                                         }
5651
5652                                         // Update variables
5653                                         pAd->LatchRfRegs.Channel = Channel;
5654                                         pAd->LatchRfRegs.R1 = RFRegTable[index].R1;
5655                                         pAd->LatchRfRegs.R2 = R2;
5656                                         pAd->LatchRfRegs.R3 = R3;
5657                                         pAd->LatchRfRegs.R4 = R4;
5658
5659                                         // Set RF value 1's set R3[bit2] = [0]
5660                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
5661                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
5662                                         RTMP_RF_IO_WRITE32(pAd, (pAd->LatchRfRegs.R3 & (~0x04)));
5663                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
5664
5665                                         RTMPusecDelay(200);
5666
5667                                         // Set RF value 2's set R3[bit2] = [1]
5668                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
5669                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
5670                                         RTMP_RF_IO_WRITE32(pAd, (pAd->LatchRfRegs.R3 | 0x04));
5671                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
5672
5673                                         RTMPusecDelay(200);
5674
5675                                         // Set RF value 3's set R3[bit2] = [0]
5676                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
5677                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
5678                                         RTMP_RF_IO_WRITE32(pAd, (pAd->LatchRfRegs.R3 & (~0x04)));
5679                                         RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
5680
5681                                         break;
5682                                 }
5683                         }
5684                         break;
5685
5686                         default:
5687                         break;
5688                 }
5689         }
5690
5691         // Change BBP setting during siwtch from a->g, g->a
5692         if (Channel <= 14)
5693         {
5694             ULONG       TxPinCfg = 0x00050F0A;//Gary 2007/08/09 0x050A0A
5695
5696                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R62, (0x37 - GET_LNA_GAIN(pAd)));
5697                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R63, (0x37 - GET_LNA_GAIN(pAd)));
5698                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R64, (0x37 - GET_LNA_GAIN(pAd)));
5699                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R86, 0);//(0x44 - GET_LNA_GAIN(pAd)));    // According the Rory's suggestion to solve the middle range issue.
5700                 //RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0x62);
5701
5702                 // Rx High power VGA offset for LNA select
5703             if (pAd->NicConfig2.field.ExternalLNAForG)
5704             {
5705                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0x62);
5706                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R75, 0x46);
5707             }
5708             else
5709             {
5710                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0x84);
5711                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R75, 0x50);
5712             }
5713
5714                 // 5G band selection PIN, bit1 and bit2 are complement
5715                 RTMP_IO_READ32(pAd, TX_BAND_CFG, &Value);
5716                 Value &= (~0x6);
5717                 Value |= (0x04);
5718                 RTMP_IO_WRITE32(pAd, TX_BAND_CFG, Value);
5719
5720         // Turn off unused PA or LNA when only 1T or 1R
5721                 if (pAd->Antenna.field.TxPath == 1)
5722                 {
5723                         TxPinCfg &= 0xFFFFFFF3;
5724                 }
5725                 if (pAd->Antenna.field.RxPath == 1)
5726                 {
5727                         TxPinCfg &= 0xFFFFF3FF;
5728                 }
5729
5730                 RTMP_IO_WRITE32(pAd, TX_PIN_CFG, TxPinCfg);
5731         }
5732         else
5733         {
5734             ULONG       TxPinCfg = 0x00050F05;//Gary 2007/8/9 0x050505
5735
5736                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R62, (0x37 - GET_LNA_GAIN(pAd)));
5737                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R63, (0x37 - GET_LNA_GAIN(pAd)));
5738                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R64, (0x37 - GET_LNA_GAIN(pAd)));
5739                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R86, 0);//(0x44 - GET_LNA_GAIN(pAd)));   // According the Rory's suggestion to solve the middle range issue.
5740                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R82, 0xF2);
5741
5742                 // Rx High power VGA offset for LNA select
5743                 if (pAd->NicConfig2.field.ExternalLNAForA)
5744                 {
5745                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R75, 0x46);
5746                 }
5747                 else
5748                 {
5749                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R75, 0x50);
5750                 }
5751
5752                 // 5G band selection PIN, bit1 and bit2 are complement
5753                 RTMP_IO_READ32(pAd, TX_BAND_CFG, &Value);
5754                 Value &= (~0x6);
5755                 Value |= (0x02);
5756                 RTMP_IO_WRITE32(pAd, TX_BAND_CFG, Value);
5757
5758         // Turn off unused PA or LNA when only 1T or 1R
5759                 if (pAd->Antenna.field.TxPath == 1)
5760                 {
5761                         TxPinCfg &= 0xFFFFFFF3;
5762         }
5763                 if (pAd->Antenna.field.RxPath == 1)
5764                 {
5765                         TxPinCfg &= 0xFFFFF3FF;
5766         }
5767
5768                 RTMP_IO_WRITE32(pAd, TX_PIN_CFG, TxPinCfg);
5769         }
5770
5771     // R66 should be set according to Channel and use 20MHz when scanning
5772         //RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, (0x2E + GET_LNA_GAIN(pAd)));
5773         if (bScan)
5774                 RTMPSetAGCInitValue(pAd, BW_20);
5775         else
5776                 RTMPSetAGCInitValue(pAd, pAd->CommonCfg.BBPCurrentBW);
5777
5778         //
5779         // On 11A, We should delay and wait RF/BBP to be stable
5780         // and the appropriate time should be 1000 micro seconds
5781         // 2005/06/05 - On 11G, We also need this delay time. Otherwise it's difficult to pass the WHQL.
5782         //
5783         RTMPusecDelay(1000);
5784
5785         DBGPRINT(RT_DEBUG_TRACE, ("SwitchChannel#%d(RF=%d, Pwr0=%lu, Pwr1=%lu, %dT) to , R1=0x%08lx, R2=0x%08lx, R3=0x%08lx, R4=0x%08lx\n",
5786                                                           Channel,
5787                                                           pAd->RfIcType,
5788                                                           (R3 & 0x00003e00) >> 9,
5789                                                           (R4 & 0x000007c0) >> 6,
5790                                                           pAd->Antenna.field.TxPath,
5791                                                           pAd->LatchRfRegs.R1,
5792                                                           pAd->LatchRfRegs.R2,
5793                                                           pAd->LatchRfRegs.R3,
5794                                                           pAd->LatchRfRegs.R4));
5795 }
5796
5797 /*
5798         ==========================================================================
5799         Description:
5800                 This function is required for 2421 only, and should not be used during
5801                 site survey. It's only required after NIC decided to stay at a channel
5802                 for a longer period.
5803                 When this function is called, it's always after AsicSwitchChannel().
5804
5805         IRQL = PASSIVE_LEVEL
5806         IRQL = DISPATCH_LEVEL
5807
5808         ==========================================================================
5809  */
5810 VOID AsicLockChannel(
5811         IN PRTMP_ADAPTER pAd,
5812         IN UCHAR Channel)
5813 {
5814 }
5815
5816 /*
5817         ==========================================================================
5818         Description:
5819
5820         IRQL = PASSIVE_LEVEL
5821         IRQL = DISPATCH_LEVEL
5822
5823         ==========================================================================
5824  */
5825 VOID    AsicAntennaSelect(
5826         IN      PRTMP_ADAPTER   pAd,
5827         IN      UCHAR                   Channel)
5828 {
5829 }
5830
5831 /*
5832         ========================================================================
5833
5834         Routine Description:
5835                 Antenna miscellaneous setting.
5836
5837         Arguments:
5838                 pAd                                             Pointer to our adapter
5839                 BandState                               Indicate current Band State.
5840
5841         Return Value:
5842                 None
5843
5844         IRQL <= DISPATCH_LEVEL
5845
5846         Note:
5847                 1.) Frame End type control
5848                         only valid for G only (RF_2527 & RF_2529)
5849                         0: means DPDT, set BBP R4 bit 5 to 1
5850                         1: means SPDT, set BBP R4 bit 5 to 0
5851
5852
5853         ========================================================================
5854 */
5855 VOID    AsicAntennaSetting(
5856         IN      PRTMP_ADAPTER   pAd,
5857         IN      ABGBAND_STATE   BandState)
5858 {
5859 }
5860
5861 VOID AsicRfTuningExec(
5862         IN PVOID SystemSpecific1,
5863         IN PVOID FunctionContext,
5864         IN PVOID SystemSpecific2,
5865         IN PVOID SystemSpecific3)
5866 {
5867 }
5868
5869 /*
5870         ==========================================================================
5871         Description:
5872                 Gives CCK TX rate 2 more dB TX power.
5873                 This routine works only in LINK UP in INFRASTRUCTURE mode.
5874
5875                 calculate desired Tx power in RF R3.Tx0~5,      should consider -
5876                 0. if current radio is a noisy environment (pAd->DrsCounters.fNoisyEnvironment)
5877                 1. TxPowerPercentage
5878                 2. auto calibration based on TSSI feedback
5879                 3. extra 2 db for CCK
5880                 4. -10 db upon very-short distance (AvgRSSI >= -40db) to AP
5881
5882         NOTE: Since this routine requires the value of (pAd->DrsCounters.fNoisyEnvironment),
5883                 it should be called AFTER MlmeDynamicTxRatSwitching()
5884         ==========================================================================
5885  */
5886 VOID AsicAdjustTxPower(
5887         IN PRTMP_ADAPTER pAd)
5888 {
5889         INT                     i, j;
5890         CHAR            DeltaPwr = 0;
5891         BOOLEAN         bAutoTxAgc = FALSE;
5892         UCHAR           TssiRef, *pTssiMinusBoundary, *pTssiPlusBoundary, TxAgcStep;
5893         UCHAR           BbpR1 = 0, BbpR49 = 0, idx;
5894         PCHAR           pTxAgcCompensate;
5895         ULONG           TxPwr[5];
5896         CHAR            Value;
5897
5898         if (pAd->CommonCfg.BBPCurrentBW == BW_40)
5899         {
5900                 if (pAd->CommonCfg.CentralChannel > 14)
5901                 {
5902                         TxPwr[0] = pAd->Tx40MPwrCfgABand[0];
5903                         TxPwr[1] = pAd->Tx40MPwrCfgABand[1];
5904                         TxPwr[2] = pAd->Tx40MPwrCfgABand[2];
5905                         TxPwr[3] = pAd->Tx40MPwrCfgABand[3];
5906                         TxPwr[4] = pAd->Tx40MPwrCfgABand[4];
5907                 }
5908                 else
5909                 {
5910                         TxPwr[0] = pAd->Tx40MPwrCfgGBand[0];
5911                         TxPwr[1] = pAd->Tx40MPwrCfgGBand[1];
5912                         TxPwr[2] = pAd->Tx40MPwrCfgGBand[2];
5913                         TxPwr[3] = pAd->Tx40MPwrCfgGBand[3];
5914                         TxPwr[4] = pAd->Tx40MPwrCfgGBand[4];
5915                 }
5916         }
5917         else
5918         {
5919                 if (pAd->CommonCfg.Channel > 14)
5920                 {
5921                         TxPwr[0] = pAd->Tx20MPwrCfgABand[0];
5922                         TxPwr[1] = pAd->Tx20MPwrCfgABand[1];
5923                         TxPwr[2] = pAd->Tx20MPwrCfgABand[2];
5924                         TxPwr[3] = pAd->Tx20MPwrCfgABand[3];
5925                         TxPwr[4] = pAd->Tx20MPwrCfgABand[4];
5926                 }
5927                 else
5928                 {
5929                         TxPwr[0] = pAd->Tx20MPwrCfgGBand[0];
5930                         TxPwr[1] = pAd->Tx20MPwrCfgGBand[1];
5931                         TxPwr[2] = pAd->Tx20MPwrCfgGBand[2];
5932                         TxPwr[3] = pAd->Tx20MPwrCfgGBand[3];
5933                         TxPwr[4] = pAd->Tx20MPwrCfgGBand[4];
5934                 }
5935         }
5936
5937         // TX power compensation for temperature variation based on TSSI. try every 4 second
5938         if (pAd->Mlme.OneSecPeriodicRound % 4 == 0)
5939         {
5940                 if (pAd->CommonCfg.Channel <= 14)
5941                 {
5942                         /* bg channel */
5943                         bAutoTxAgc         = pAd->bAutoTxAgcG;
5944                         TssiRef            = pAd->TssiRefG;
5945                         pTssiMinusBoundary = &pAd->TssiMinusBoundaryG[0];
5946                         pTssiPlusBoundary  = &pAd->TssiPlusBoundaryG[0];
5947                         TxAgcStep          = pAd->TxAgcStepG;
5948                         pTxAgcCompensate   = &pAd->TxAgcCompensateG;
5949                 }
5950                 else
5951                 {
5952                         /* a channel */
5953                         bAutoTxAgc         = pAd->bAutoTxAgcA;
5954                         TssiRef            = pAd->TssiRefA;
5955                         pTssiMinusBoundary = &pAd->TssiMinusBoundaryA[0];
5956                         pTssiPlusBoundary  = &pAd->TssiPlusBoundaryA[0];
5957                         TxAgcStep          = pAd->TxAgcStepA;
5958                         pTxAgcCompensate   = &pAd->TxAgcCompensateA;
5959                 }
5960
5961                 if (bAutoTxAgc)
5962                 {
5963                         /* BbpR1 is unsigned char */
5964                         RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R49, &BbpR49);
5965
5966                         /* (p) TssiPlusBoundaryG[0] = 0 = (m) TssiMinusBoundaryG[0] */
5967                         /* compensate: +4     +3   +2   +1    0   -1   -2   -3   -4 * steps */
5968                         /* step value is defined in pAd->TxAgcStepG for tx power value */
5969
5970                         /* [4]+1+[4]   p4     p3   p2   p1   o1   m1   m2   m3   m4 */
5971                         /* ex:         0x00 0x15 0x25 0x45 0x88 0xA0 0xB5 0xD0 0xF0
5972                            above value are examined in mass factory production */
5973                         /*             [4]    [3]  [2]  [1]  [0]  [1]  [2]  [3]  [4] */
5974
5975                         /* plus (+) is 0x00 ~ 0x45, minus (-) is 0xa0 ~ 0xf0 */
5976                         /* if value is between p1 ~ o1 or o1 ~ s1, no need to adjust tx power */
5977                         /* if value is 0xa5, tx power will be -= TxAgcStep*(2-1) */
5978
5979                         if (BbpR49 > pTssiMinusBoundary[1])
5980                         {
5981                                 // Reading is larger than the reference value
5982                                 // check for how large we need to decrease the Tx power
5983                                 for (idx = 1; idx < 5; idx++)
5984                                 {
5985                                         if (BbpR49 <= pTssiMinusBoundary[idx])  // Found the range
5986                                                 break;
5987                                 }
5988                                 // The index is the step we should decrease, idx = 0 means there is nothing to compensate
5989 //                              if (R3 > (ULONG) (TxAgcStep * (idx-1)))
5990                                         *pTxAgcCompensate = -(TxAgcStep * (idx-1));
5991 //                              else
5992 //                                      *pTxAgcCompensate = -((UCHAR)R3);
5993
5994                                 DeltaPwr += (*pTxAgcCompensate);
5995                                 DBGPRINT(RT_DEBUG_TRACE, ("-- Tx Power, BBP R1=%x, TssiRef=%x, TxAgcStep=%x, step = -%d\n",
5996                                         BbpR49, TssiRef, TxAgcStep, idx-1));
5997                         }
5998                         else if (BbpR49 < pTssiPlusBoundary[1])
5999                         {
6000                                 // Reading is smaller than the reference value
6001                                 // check for how large we need to increase the Tx power
6002                                 for (idx = 1; idx < 5; idx++)
6003                                 {
6004                                         if (BbpR49 >= pTssiPlusBoundary[idx])   // Found the range
6005                                                 break;
6006                                 }
6007                                 // The index is the step we should increase, idx = 0 means there is nothing to compensate
6008                                 *pTxAgcCompensate = TxAgcStep * (idx-1);
6009                                 DeltaPwr += (*pTxAgcCompensate);
6010                                 DBGPRINT(RT_DEBUG_TRACE, ("++ Tx Power, BBP R1=%x, TssiRef=%x, TxAgcStep=%x, step = +%d\n",
6011                                         BbpR49, TssiRef, TxAgcStep, idx-1));
6012                         }
6013                         else
6014                         {
6015                                 *pTxAgcCompensate = 0;
6016                                 DBGPRINT(RT_DEBUG_TRACE, ("   Tx Power, BBP R49=%x, TssiRef=%x, TxAgcStep=%x, step = +%d\n",
6017                                         BbpR49, TssiRef, TxAgcStep, 0));
6018                         }
6019                 }
6020         }
6021         else
6022         {
6023                 if (pAd->CommonCfg.Channel <= 14)
6024                 {
6025                         bAutoTxAgc         = pAd->bAutoTxAgcG;
6026                         pTxAgcCompensate   = &pAd->TxAgcCompensateG;
6027                 }
6028                 else
6029                 {
6030                         bAutoTxAgc         = pAd->bAutoTxAgcA;
6031                         pTxAgcCompensate   = &pAd->TxAgcCompensateA;
6032                 }
6033
6034                 if (bAutoTxAgc)
6035                         DeltaPwr += (*pTxAgcCompensate);
6036         }
6037
6038         RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R1, &BbpR1);
6039         BbpR1 &= 0xFC;
6040
6041         /* calculate delta power based on the percentage specified from UI */
6042         // E2PROM setting is calibrated for maximum TX power (i.e. 100%)
6043         // We lower TX power here according to the percentage specified from UI
6044         if (pAd->CommonCfg.TxPowerPercentage == 0xffffffff)       // AUTO TX POWER control
6045                 ;
6046         else if (pAd->CommonCfg.TxPowerPercentage > 90)  // 91 ~ 100% & AUTO, treat as 100% in terms of mW
6047                 ;
6048         else if (pAd->CommonCfg.TxPowerPercentage > 60)  // 61 ~ 90%, treat as 75% in terms of mW               // DeltaPwr -= 1;
6049         {
6050                 DeltaPwr -= 1;
6051         }
6052         else if (pAd->CommonCfg.TxPowerPercentage > 30)  // 31 ~ 60%, treat as 50% in terms of mW               // DeltaPwr -= 3;
6053         {
6054                 DeltaPwr -= 3;
6055         }
6056         else if (pAd->CommonCfg.TxPowerPercentage > 15)  // 16 ~ 30%, treat as 25% in terms of mW               // DeltaPwr -= 6;
6057         {
6058                 BbpR1 |= 0x01;
6059         }
6060         else if (pAd->CommonCfg.TxPowerPercentage > 9)   // 10 ~ 15%, treat as 12.5% in terms of mW             // DeltaPwr -= 9;
6061         {
6062                 BbpR1 |= 0x01;
6063                 DeltaPwr -= 3;
6064         }
6065         else                                           // 0 ~ 9 %, treat as MIN(~3%) in terms of mW             // DeltaPwr -= 12;
6066         {
6067                 BbpR1 |= 0x02;
6068         }
6069
6070         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R1, BbpR1);
6071
6072         /* reset different new tx power for different TX rate */
6073         for(i=0; i<5; i++)
6074         {
6075                 if (TxPwr[i] != 0xffffffff)
6076                 {
6077                         for (j=0; j<8; j++)
6078                         {
6079                                 Value = (CHAR)((TxPwr[i] >> j*4) & 0x0F); /* 0 ~ 15 */
6080
6081                                 if ((Value + DeltaPwr) < 0)
6082                                 {
6083                                         Value = 0; /* min */
6084                                 }
6085                                 else if ((Value + DeltaPwr) > 0xF)
6086                                 {
6087                                         Value = 0xF; /* max */
6088                                 }
6089                                 else
6090                                 {
6091                                         Value += DeltaPwr; /* temperature compensation */
6092                                 }
6093
6094                                 /* fill new value to CSR offset */
6095                                 TxPwr[i] = (TxPwr[i] & ~(0x0000000F << j*4)) | (Value << j*4);
6096                         }
6097
6098                         /* write tx power value to CSR */
6099                         /* TX_PWR_CFG_0 (8 tx rate) for TX power for OFDM 12M/18M
6100                                                                                         TX power for OFDM 6M/9M
6101                                                                                         TX power for CCK5.5M/11M
6102                                                                                         TX power for CCK1M/2M */
6103                         /* TX_PWR_CFG_1 ~ TX_PWR_CFG_4 */
6104                         RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, TxPwr[i]);
6105                 }
6106         }
6107
6108 }
6109
6110 #ifdef CONFIG_STA_SUPPORT
6111 /*
6112         ==========================================================================
6113         Description:
6114                 put PHY to sleep here, and set next wakeup timer. PHY doesn't not wakeup
6115                 automatically. Instead, MCU will issue a TwakeUpInterrupt to host after
6116                 the wakeup timer timeout. Driver has to issue a separate command to wake
6117                 PHY up.
6118
6119         IRQL = DISPATCH_LEVEL
6120
6121         ==========================================================================
6122  */
6123 VOID AsicSleepThenAutoWakeup(
6124         IN PRTMP_ADAPTER pAd,
6125         IN USHORT TbttNumToNextWakeUp)
6126 {
6127     RT28XX_STA_SLEEP_THEN_AUTO_WAKEUP(pAd, TbttNumToNextWakeUp);
6128 }
6129
6130 /*
6131         ==========================================================================
6132         Description:
6133                 AsicForceWakeup() is used whenever manual wakeup is required
6134                 AsicForceSleep() should only be used when not in INFRA BSS. When
6135                 in INFRA BSS, we should use AsicSleepThenAutoWakeup() instead.
6136         ==========================================================================
6137  */
6138 VOID AsicForceSleep(
6139         IN PRTMP_ADAPTER pAd)
6140 {
6141
6142 }
6143
6144 /*
6145         ==========================================================================
6146         Description:
6147                 AsicForceWakeup() is used whenever Twakeup timer (set via AsicSleepThenAutoWakeup)
6148                 expired.
6149
6150         IRQL = PASSIVE_LEVEL
6151         IRQL = DISPATCH_LEVEL
6152         ==========================================================================
6153  */
6154 VOID AsicForceWakeup(
6155         IN PRTMP_ADAPTER pAd,
6156         IN BOOLEAN    bFromTx)
6157 {
6158     DBGPRINT(RT_DEBUG_TRACE, ("--> AsicForceWakeup \n"));
6159     RT28XX_STA_FORCE_WAKEUP(pAd, bFromTx);
6160 }
6161 #endif // CONFIG_STA_SUPPORT //
6162 /*
6163         ==========================================================================
6164         Description:
6165                 Set My BSSID
6166
6167         IRQL = DISPATCH_LEVEL
6168
6169         ==========================================================================
6170  */
6171 VOID AsicSetBssid(
6172         IN PRTMP_ADAPTER pAd,
6173         IN PUCHAR pBssid)
6174 {
6175         ULONG             Addr4;
6176         DBGPRINT(RT_DEBUG_TRACE, ("==============> AsicSetBssid %x:%x:%x:%x:%x:%x\n",
6177                 pBssid[0],pBssid[1],pBssid[2],pBssid[3], pBssid[4],pBssid[5]));
6178
6179         Addr4 = (ULONG)(pBssid[0])               |
6180                         (ULONG)(pBssid[1] << 8)  |
6181                         (ULONG)(pBssid[2] << 16) |
6182                         (ULONG)(pBssid[3] << 24);
6183         RTMP_IO_WRITE32(pAd, MAC_BSSID_DW0, Addr4);
6184
6185         Addr4 = 0;
6186         // always one BSSID in STA mode
6187         Addr4 = (ULONG)(pBssid[4]) | (ULONG)(pBssid[5] << 8);
6188
6189         RTMP_IO_WRITE32(pAd, MAC_BSSID_DW1, Addr4);
6190 }
6191
6192 VOID AsicSetMcastWC(
6193         IN PRTMP_ADAPTER pAd)
6194 {
6195         MAC_TABLE_ENTRY *pEntry = &pAd->MacTab.Content[MCAST_WCID];
6196         USHORT          offset;
6197
6198         pEntry->Sst        = SST_ASSOC;
6199         pEntry->Aid        = MCAST_WCID;        // Softap supports 1 BSSID and use WCID=0 as multicast Wcid index
6200         pEntry->PsMode     = PWR_ACTIVE;
6201         pEntry->CurrTxRate = pAd->CommonCfg.MlmeRate;
6202         offset = MAC_WCID_BASE + BSS0Mcast_WCID * HW_WCID_ENTRY_SIZE;
6203 }
6204
6205 /*
6206         ==========================================================================
6207         Description:
6208
6209         IRQL = DISPATCH_LEVEL
6210
6211         ==========================================================================
6212  */
6213 VOID AsicDelWcidTab(
6214         IN PRTMP_ADAPTER pAd,
6215         IN UCHAR        Wcid)
6216 {
6217         ULONG             Addr0 = 0x0, Addr1 = 0x0;
6218         ULONG           offset;
6219
6220         DBGPRINT(RT_DEBUG_TRACE, ("AsicDelWcidTab==>Wcid = 0x%x\n",Wcid));
6221         offset = MAC_WCID_BASE + Wcid * HW_WCID_ENTRY_SIZE;
6222         RTMP_IO_WRITE32(pAd, offset, Addr0);
6223         offset += 4;
6224         RTMP_IO_WRITE32(pAd, offset, Addr1);
6225 }
6226
6227 /*
6228         ==========================================================================
6229         Description:
6230
6231         IRQL = DISPATCH_LEVEL
6232
6233         ==========================================================================
6234  */
6235 VOID AsicEnableRDG(
6236         IN PRTMP_ADAPTER pAd)
6237 {
6238         TX_LINK_CFG_STRUC       TxLinkCfg;
6239         UINT32                          Data = 0;
6240
6241         RTMP_IO_READ32(pAd, TX_LINK_CFG, &TxLinkCfg.word);
6242         TxLinkCfg.field.TxRDGEn = 1;
6243         RTMP_IO_WRITE32(pAd, TX_LINK_CFG, TxLinkCfg.word);
6244
6245         RTMP_IO_READ32(pAd, EDCA_AC0_CFG, &Data);
6246         Data  &= 0xFFFFFF00;
6247         Data  |= 0x80;
6248         RTMP_IO_WRITE32(pAd, EDCA_AC0_CFG, Data);
6249
6250         //OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_AGGREGATION_INUSED);
6251 }
6252
6253 /*
6254         ==========================================================================
6255         Description:
6256
6257         IRQL = DISPATCH_LEVEL
6258
6259         ==========================================================================
6260  */
6261 VOID AsicDisableRDG(
6262         IN PRTMP_ADAPTER pAd)
6263 {
6264         TX_LINK_CFG_STRUC       TxLinkCfg;
6265         UINT32                          Data = 0;
6266
6267
6268         RTMP_IO_READ32(pAd, TX_LINK_CFG, &TxLinkCfg.word);
6269         TxLinkCfg.field.TxRDGEn = 0;
6270         RTMP_IO_WRITE32(pAd, TX_LINK_CFG, TxLinkCfg.word);
6271
6272         RTMP_IO_READ32(pAd, EDCA_AC0_CFG, &Data);
6273
6274         Data  &= 0xFFFFFF00;
6275         //Data  |= 0x20;
6276 #ifndef WIFI_TEST
6277         //if ( pAd->CommonCfg.bEnableTxBurst )
6278         //      Data |= 0x60; // for performance issue not set the TXOP to 0
6279 #endif
6280         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_DYNAMIC_BE_TXOP_ACTIVE)
6281 #ifdef DOT11_N_SUPPORT
6282                 && (pAd->MacTab.fAnyStationMIMOPSDynamic == FALSE)
6283 #endif // DOT11_N_SUPPORT //
6284         )
6285         {
6286                 // For CWC test, change txop from 0x30 to 0x20 in TxBurst mode
6287                 if (pAd->CommonCfg.bEnableTxBurst)
6288                         Data |= 0x20;
6289         }
6290         RTMP_IO_WRITE32(pAd, EDCA_AC0_CFG, Data);
6291 }
6292
6293 /*
6294         ==========================================================================
6295         Description:
6296
6297         IRQL = PASSIVE_LEVEL
6298         IRQL = DISPATCH_LEVEL
6299
6300         ==========================================================================
6301  */
6302 VOID AsicDisableSync(
6303         IN PRTMP_ADAPTER pAd)
6304 {
6305         BCN_TIME_CFG_STRUC csr;
6306
6307         DBGPRINT(RT_DEBUG_TRACE, ("--->Disable TSF synchronization\n"));
6308
6309         // 2003-12-20 disable TSF and TBTT while NIC in power-saving have side effect
6310         //                        that NIC will never wakes up because TSF stops and no more
6311         //                        TBTT interrupts
6312         pAd->TbttTickCount = 0;
6313         RTMP_IO_READ32(pAd, BCN_TIME_CFG, &csr.word);
6314         csr.field.bBeaconGen = 0;
6315         csr.field.bTBTTEnable = 0;
6316         csr.field.TsfSyncMode = 0;
6317         csr.field.bTsfTicking = 0;
6318         RTMP_IO_WRITE32(pAd, BCN_TIME_CFG, csr.word);
6319
6320 }
6321
6322 /*
6323         ==========================================================================
6324         Description:
6325
6326         IRQL = DISPATCH_LEVEL
6327
6328         ==========================================================================
6329  */
6330 VOID AsicEnableBssSync(
6331         IN PRTMP_ADAPTER pAd)
6332 {
6333         BCN_TIME_CFG_STRUC csr;
6334
6335         DBGPRINT(RT_DEBUG_TRACE, ("--->AsicEnableBssSync(INFRA mode)\n"));
6336
6337         RTMP_IO_READ32(pAd, BCN_TIME_CFG, &csr.word);
6338 //      RTMP_IO_WRITE32(pAd, BCN_TIME_CFG, 0x00000000);
6339 #ifdef CONFIG_STA_SUPPORT
6340         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6341         {
6342                 csr.field.BeaconInterval = pAd->CommonCfg.BeaconPeriod << 4; // ASIC register in units of 1/16 TU
6343                 csr.field.bTsfTicking = 1;
6344                 csr.field.TsfSyncMode = 1; // sync TSF in INFRASTRUCTURE mode
6345                 csr.field.bBeaconGen  = 0; // do NOT generate BEACON
6346                 csr.field.bTBTTEnable = 1;
6347         }
6348 #endif // CONFIG_STA_SUPPORT //
6349         RTMP_IO_WRITE32(pAd, BCN_TIME_CFG, csr.word);
6350 }
6351
6352 /*
6353         ==========================================================================
6354         Description:
6355         Note:
6356                 BEACON frame in shared memory should be built ok before this routine
6357                 can be called. Otherwise, a garbage frame maybe transmitted out every
6358                 Beacon period.
6359
6360         IRQL = DISPATCH_LEVEL
6361
6362         ==========================================================================
6363  */
6364 VOID AsicEnableIbssSync(
6365         IN PRTMP_ADAPTER pAd)
6366 {
6367         BCN_TIME_CFG_STRUC csr9;
6368         PUCHAR                  ptr;
6369         UINT i;
6370
6371         DBGPRINT(RT_DEBUG_TRACE, ("--->AsicEnableIbssSync(ADHOC mode. MPDUtotalByteCount = %d)\n", pAd->BeaconTxWI.MPDUtotalByteCount));
6372
6373         RTMP_IO_READ32(pAd, BCN_TIME_CFG, &csr9.word);
6374         csr9.field.bBeaconGen = 0;
6375         csr9.field.bTBTTEnable = 0;
6376         csr9.field.bTsfTicking = 0;
6377         RTMP_IO_WRITE32(pAd, BCN_TIME_CFG, csr9.word);
6378
6379
6380 #ifdef RT2870
6381         // move BEACON TXD and frame content to on-chip memory
6382         ptr = (PUCHAR)&pAd->BeaconTxWI;
6383         for (i=0; i<TXWI_SIZE; i+=2)  // 16-byte TXWI field
6384         {
6385                 //UINT32 longptr =  *ptr + (*(ptr+1)<<8) + (*(ptr+2)<<16) + (*(ptr+3)<<24);
6386                 //RTMP_IO_WRITE32(pAd, HW_BEACON_BASE0 + i, longptr);
6387                 RTUSBMultiWrite(pAd, HW_BEACON_BASE0 + i, ptr, 2);
6388                 ptr += 2;
6389         }
6390
6391         // start right after the 16-byte TXWI field
6392         ptr = pAd->BeaconBuf;
6393         for (i=0; i< pAd->BeaconTxWI.MPDUtotalByteCount; i+=2)
6394         {
6395                 //UINT32 longptr =  *ptr + (*(ptr+1)<<8) + (*(ptr+2)<<16) + (*(ptr+3)<<24);
6396                 //RTMP_IO_WRITE32(pAd, HW_BEACON_BASE0 + TXWI_SIZE + i, longptr);
6397                 RTUSBMultiWrite(pAd, HW_BEACON_BASE0 + TXWI_SIZE + i, ptr, 2);
6398                 ptr +=2;
6399         }
6400 #endif // RT2870 //
6401
6402         //
6403         // For Wi-Fi faily generated beacons between participating stations.
6404         // Set TBTT phase adaptive adjustment step to 8us (default 16us)
6405         // don't change settings 2006-5- by Jerry
6406         //RTMP_IO_WRITE32(pAd, TBTT_SYNC_CFG, 0x00001010);
6407
6408         // start sending BEACON
6409         csr9.field.BeaconInterval = pAd->CommonCfg.BeaconPeriod << 4; // ASIC register in units of 1/16 TU
6410         csr9.field.bTsfTicking = 1;
6411         csr9.field.TsfSyncMode = 2; // sync TSF in IBSS mode
6412         csr9.field.bTBTTEnable = 1;
6413         csr9.field.bBeaconGen = 1;
6414         RTMP_IO_WRITE32(pAd, BCN_TIME_CFG, csr9.word);
6415 }
6416
6417 /*
6418         ==========================================================================
6419         Description:
6420
6421         IRQL = PASSIVE_LEVEL
6422         IRQL = DISPATCH_LEVEL
6423
6424         ==========================================================================
6425  */
6426 VOID AsicSetEdcaParm(
6427         IN PRTMP_ADAPTER pAd,
6428         IN PEDCA_PARM    pEdcaParm)
6429 {
6430         EDCA_AC_CFG_STRUC   Ac0Cfg, Ac1Cfg, Ac2Cfg, Ac3Cfg;
6431         AC_TXOP_CSR0_STRUC csr0;
6432         AC_TXOP_CSR1_STRUC csr1;
6433         AIFSN_CSR_STRUC    AifsnCsr;
6434         CWMIN_CSR_STRUC    CwminCsr;
6435         CWMAX_CSR_STRUC    CwmaxCsr;
6436         int i;
6437
6438         Ac0Cfg.word = 0;
6439         Ac1Cfg.word = 0;
6440         Ac2Cfg.word = 0;
6441         Ac3Cfg.word = 0;
6442         if ((pEdcaParm == NULL) || (pEdcaParm->bValid == FALSE))
6443         {
6444                 DBGPRINT(RT_DEBUG_TRACE,("AsicSetEdcaParm\n"));
6445                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_WMM_INUSED);
6446                 for (i=0; i<MAX_LEN_OF_MAC_TABLE; i++)
6447                 {
6448                         if (pAd->MacTab.Content[i].ValidAsCLI || pAd->MacTab.Content[i].ValidAsApCli)
6449                                 CLIENT_STATUS_CLEAR_FLAG(&pAd->MacTab.Content[i], fCLIENT_STATUS_WMM_CAPABLE);
6450                 }
6451
6452                 //========================================================
6453                 //      MAC Register has a copy .
6454                 //========================================================
6455 //#ifndef WIFI_TEST
6456                 if( pAd->CommonCfg.bEnableTxBurst )
6457                 {
6458                         // For CWC test, change txop from 0x30 to 0x20 in TxBurst mode
6459                         Ac0Cfg.field.AcTxop = 0x20; // Suggest by John for TxBurst in HT Mode
6460                 }
6461                 else
6462                         Ac0Cfg.field.AcTxop = 0;        // QID_AC_BE
6463 //#else
6464 //              Ac0Cfg.field.AcTxop = 0;        // QID_AC_BE
6465 //#endif
6466                 Ac0Cfg.field.Cwmin = CW_MIN_IN_BITS;
6467                 Ac0Cfg.field.Cwmax = CW_MAX_IN_BITS;
6468                 Ac0Cfg.field.Aifsn = 2;
6469                 RTMP_IO_WRITE32(pAd, EDCA_AC0_CFG, Ac0Cfg.word);
6470
6471                 Ac1Cfg.field.AcTxop = 0;        // QID_AC_BK
6472                 Ac1Cfg.field.Cwmin = CW_MIN_IN_BITS;
6473                 Ac1Cfg.field.Cwmax = CW_MAX_IN_BITS;
6474                 Ac1Cfg.field.Aifsn = 2;
6475                 RTMP_IO_WRITE32(pAd, EDCA_AC1_CFG, Ac1Cfg.word);
6476
6477                 if (pAd->CommonCfg.PhyMode == PHY_11B)
6478                 {
6479                         Ac2Cfg.field.AcTxop = 192;      // AC_VI: 192*32us ~= 6ms
6480                         Ac3Cfg.field.AcTxop = 96;       // AC_VO: 96*32us  ~= 3ms
6481                 }
6482                 else
6483                 {
6484                         Ac2Cfg.field.AcTxop = 96;       // AC_VI: 96*32us ~= 3ms
6485                         Ac3Cfg.field.AcTxop = 48;       // AC_VO: 48*32us ~= 1.5ms
6486                 }
6487                 Ac2Cfg.field.Cwmin = CW_MIN_IN_BITS;
6488                 Ac2Cfg.field.Cwmax = CW_MAX_IN_BITS;
6489                 Ac2Cfg.field.Aifsn = 2;
6490                 RTMP_IO_WRITE32(pAd, EDCA_AC2_CFG, Ac2Cfg.word);
6491                 Ac3Cfg.field.Cwmin = CW_MIN_IN_BITS;
6492                 Ac3Cfg.field.Cwmax = CW_MAX_IN_BITS;
6493                 Ac3Cfg.field.Aifsn = 2;
6494                 RTMP_IO_WRITE32(pAd, EDCA_AC3_CFG, Ac3Cfg.word);
6495
6496                 //========================================================
6497                 //      DMA Register has a copy too.
6498                 //========================================================
6499                 csr0.field.Ac0Txop = 0;         // QID_AC_BE
6500                 csr0.field.Ac1Txop = 0;         // QID_AC_BK
6501                 RTMP_IO_WRITE32(pAd, WMM_TXOP0_CFG, csr0.word);
6502                 if (pAd->CommonCfg.PhyMode == PHY_11B)
6503                 {
6504                         csr1.field.Ac2Txop = 192;               // AC_VI: 192*32us ~= 6ms
6505                         csr1.field.Ac3Txop = 96;                // AC_VO: 96*32us  ~= 3ms
6506                 }
6507                 else
6508                 {
6509                         csr1.field.Ac2Txop = 96;                // AC_VI: 96*32us ~= 3ms
6510                         csr1.field.Ac3Txop = 48;                // AC_VO: 48*32us ~= 1.5ms
6511                 }
6512                 RTMP_IO_WRITE32(pAd, WMM_TXOP1_CFG, csr1.word);
6513
6514                 CwminCsr.word = 0;
6515                 CwminCsr.field.Cwmin0 = CW_MIN_IN_BITS;
6516                 CwminCsr.field.Cwmin1 = CW_MIN_IN_BITS;
6517                 CwminCsr.field.Cwmin2 = CW_MIN_IN_BITS;
6518                 CwminCsr.field.Cwmin3 = CW_MIN_IN_BITS;
6519                 RTMP_IO_WRITE32(pAd, WMM_CWMIN_CFG, CwminCsr.word);
6520
6521                 CwmaxCsr.word = 0;
6522                 CwmaxCsr.field.Cwmax0 = CW_MAX_IN_BITS;
6523                 CwmaxCsr.field.Cwmax1 = CW_MAX_IN_BITS;
6524                 CwmaxCsr.field.Cwmax2 = CW_MAX_IN_BITS;
6525                 CwmaxCsr.field.Cwmax3 = CW_MAX_IN_BITS;
6526                 RTMP_IO_WRITE32(pAd, WMM_CWMAX_CFG, CwmaxCsr.word);
6527
6528                 RTMP_IO_WRITE32(pAd, WMM_AIFSN_CFG, 0x00002222);
6529
6530                 NdisZeroMemory(&pAd->CommonCfg.APEdcaParm, sizeof(EDCA_PARM));
6531         }
6532         else
6533         {
6534                 OPSTATUS_SET_FLAG(pAd, fOP_STATUS_WMM_INUSED);
6535                 //========================================================
6536                 //      MAC Register has a copy.
6537                 //========================================================
6538                 //
6539                 // Modify Cwmin/Cwmax/Txop on queue[QID_AC_VI], Recommend by Jerry 2005/07/27
6540                 // To degrade our VIDO Queue's throughput for WiFi WMM S3T07 Issue.
6541                 //
6542                 //pEdcaParm->Txop[QID_AC_VI] = pEdcaParm->Txop[QID_AC_VI] * 7 / 10; // rt2860c need this
6543
6544                 Ac0Cfg.field.AcTxop =  pEdcaParm->Txop[QID_AC_BE];
6545                 Ac0Cfg.field.Cwmin= pEdcaParm->Cwmin[QID_AC_BE];
6546                 Ac0Cfg.field.Cwmax = pEdcaParm->Cwmax[QID_AC_BE];
6547                 Ac0Cfg.field.Aifsn = pEdcaParm->Aifsn[QID_AC_BE]; //+1;
6548
6549                 Ac1Cfg.field.AcTxop =  pEdcaParm->Txop[QID_AC_BK];
6550                 Ac1Cfg.field.Cwmin = pEdcaParm->Cwmin[QID_AC_BK]; //+2;
6551                 Ac1Cfg.field.Cwmax = pEdcaParm->Cwmax[QID_AC_BK];
6552                 Ac1Cfg.field.Aifsn = pEdcaParm->Aifsn[QID_AC_BK]; //+1;
6553
6554                 Ac2Cfg.field.AcTxop = (pEdcaParm->Txop[QID_AC_VI] * 6) / 10;
6555                 Ac2Cfg.field.Cwmin = pEdcaParm->Cwmin[QID_AC_VI];
6556                 Ac2Cfg.field.Cwmax = pEdcaParm->Cwmax[QID_AC_VI];
6557                 Ac2Cfg.field.Aifsn = pEdcaParm->Aifsn[QID_AC_VI];
6558 #ifdef CONFIG_STA_SUPPORT
6559                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6560                 {
6561                         // Tuning for Wi-Fi WMM S06
6562                         if (pAd->CommonCfg.bWiFiTest &&
6563                                 pEdcaParm->Aifsn[QID_AC_VI] == 10)
6564                                 Ac2Cfg.field.Aifsn -= 1;
6565
6566                         // Tuning for TGn Wi-Fi 5.2.32
6567                         // STA TestBed changes in this item: conexant legacy sta ==> broadcom 11n sta
6568                         if (STA_TGN_WIFI_ON(pAd) &&
6569                                 pEdcaParm->Aifsn[QID_AC_VI] == 10)
6570                         {
6571                                 Ac0Cfg.field.Aifsn = 3;
6572                                 Ac2Cfg.field.AcTxop = 5;
6573                         }
6574                 }
6575 #endif // CONFIG_STA_SUPPORT //
6576
6577                 Ac3Cfg.field.AcTxop = pEdcaParm->Txop[QID_AC_VO];
6578                 Ac3Cfg.field.Cwmin = pEdcaParm->Cwmin[QID_AC_VO];
6579                 Ac3Cfg.field.Cwmax = pEdcaParm->Cwmax[QID_AC_VO];
6580                 Ac3Cfg.field.Aifsn = pEdcaParm->Aifsn[QID_AC_VO];
6581
6582 //#ifdef WIFI_TEST
6583                 if (pAd->CommonCfg.bWiFiTest)
6584                 {
6585                         if (Ac3Cfg.field.AcTxop == 102)
6586                         {
6587                         Ac0Cfg.field.AcTxop = pEdcaParm->Txop[QID_AC_BE] ? pEdcaParm->Txop[QID_AC_BE] : 10;
6588                                 Ac0Cfg.field.Aifsn  = pEdcaParm->Aifsn[QID_AC_BE]-1; /* AIFSN must >= 1 */
6589                         Ac1Cfg.field.AcTxop = pEdcaParm->Txop[QID_AC_BK];
6590                                 Ac1Cfg.field.Aifsn  = pEdcaParm->Aifsn[QID_AC_BK];
6591                         Ac2Cfg.field.AcTxop = pEdcaParm->Txop[QID_AC_VI];
6592                         } /* End of if */
6593                 }
6594 //#endif // WIFI_TEST //
6595
6596                 RTMP_IO_WRITE32(pAd, EDCA_AC0_CFG, Ac0Cfg.word);
6597                 RTMP_IO_WRITE32(pAd, EDCA_AC1_CFG, Ac1Cfg.word);
6598                 RTMP_IO_WRITE32(pAd, EDCA_AC2_CFG, Ac2Cfg.word);
6599                 RTMP_IO_WRITE32(pAd, EDCA_AC3_CFG, Ac3Cfg.word);
6600
6601
6602                 //========================================================
6603                 //      DMA Register has a copy too.
6604                 //========================================================
6605                 csr0.field.Ac0Txop = Ac0Cfg.field.AcTxop;
6606                 csr0.field.Ac1Txop = Ac1Cfg.field.AcTxop;
6607                 RTMP_IO_WRITE32(pAd, WMM_TXOP0_CFG, csr0.word);
6608
6609                 csr1.field.Ac2Txop = Ac2Cfg.field.AcTxop;
6610                 csr1.field.Ac3Txop = Ac3Cfg.field.AcTxop;
6611                 RTMP_IO_WRITE32(pAd, WMM_TXOP1_CFG, csr1.word);
6612
6613                 CwminCsr.word = 0;
6614                 CwminCsr.field.Cwmin0 = pEdcaParm->Cwmin[QID_AC_BE];
6615                 CwminCsr.field.Cwmin1 = pEdcaParm->Cwmin[QID_AC_BK];
6616                 CwminCsr.field.Cwmin2 = pEdcaParm->Cwmin[QID_AC_VI];
6617 #ifdef CONFIG_STA_SUPPORT
6618                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6619                         CwminCsr.field.Cwmin3 = pEdcaParm->Cwmin[QID_AC_VO] - 1; //for TGn wifi test
6620 #endif // CONFIG_STA_SUPPORT //
6621                 RTMP_IO_WRITE32(pAd, WMM_CWMIN_CFG, CwminCsr.word);
6622
6623                 CwmaxCsr.word = 0;
6624                 CwmaxCsr.field.Cwmax0 = pEdcaParm->Cwmax[QID_AC_BE];
6625                 CwmaxCsr.field.Cwmax1 = pEdcaParm->Cwmax[QID_AC_BK];
6626                 CwmaxCsr.field.Cwmax2 = pEdcaParm->Cwmax[QID_AC_VI];
6627                 CwmaxCsr.field.Cwmax3 = pEdcaParm->Cwmax[QID_AC_VO];
6628                 RTMP_IO_WRITE32(pAd, WMM_CWMAX_CFG, CwmaxCsr.word);
6629
6630                 AifsnCsr.word = 0;
6631                 AifsnCsr.field.Aifsn0 = Ac0Cfg.field.Aifsn; //pEdcaParm->Aifsn[QID_AC_BE];
6632                 AifsnCsr.field.Aifsn1 = Ac1Cfg.field.Aifsn; //pEdcaParm->Aifsn[QID_AC_BK];
6633                 AifsnCsr.field.Aifsn2 = Ac2Cfg.field.Aifsn; //pEdcaParm->Aifsn[QID_AC_VI];
6634 #ifdef CONFIG_STA_SUPPORT
6635                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6636                 {
6637                         // Tuning for Wi-Fi WMM S06
6638                         if (pAd->CommonCfg.bWiFiTest &&
6639                                 pEdcaParm->Aifsn[QID_AC_VI] == 10)
6640                                 AifsnCsr.field.Aifsn2 = Ac2Cfg.field.Aifsn - 4;
6641
6642                         // Tuning for TGn Wi-Fi 5.2.32
6643                         // STA TestBed changes in this item: conexant legacy sta ==> broadcom 11n sta
6644                         if (STA_TGN_WIFI_ON(pAd) &&
6645                                 pEdcaParm->Aifsn[QID_AC_VI] == 10)
6646                         {
6647                                 AifsnCsr.field.Aifsn0 = 3;
6648                                 AifsnCsr.field.Aifsn2 = 7;
6649                         }
6650
6651                         if (INFRA_ON(pAd))
6652                                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[BSSID_WCID], fCLIENT_STATUS_WMM_CAPABLE);
6653                 }
6654 #endif // CONFIG_STA_SUPPORT //
6655
6656 #ifdef CONFIG_STA_SUPPORT
6657                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6658                         AifsnCsr.field.Aifsn3 = Ac3Cfg.field.Aifsn - 1; //pEdcaParm->Aifsn[QID_AC_VO]; //for TGn wifi test
6659 #endif // CONFIG_STA_SUPPORT //
6660                 RTMP_IO_WRITE32(pAd, WMM_AIFSN_CFG, AifsnCsr.word);
6661
6662                 NdisMoveMemory(&pAd->CommonCfg.APEdcaParm, pEdcaParm, sizeof(EDCA_PARM));
6663                 if (!ADHOC_ON(pAd))
6664                 {
6665                         DBGPRINT(RT_DEBUG_TRACE,("EDCA [#%d]: AIFSN CWmin CWmax  TXOP(us)  ACM\n", pEdcaParm->EdcaUpdateCount));
6666                         DBGPRINT(RT_DEBUG_TRACE,("     AC_BE      %2d     %2d     %2d      %4d     %d\n",
6667                                                                          pEdcaParm->Aifsn[0],
6668                                                                          pEdcaParm->Cwmin[0],
6669                                                                          pEdcaParm->Cwmax[0],
6670                                                                          pEdcaParm->Txop[0]<<5,
6671                                                                          pEdcaParm->bACM[0]));
6672                         DBGPRINT(RT_DEBUG_TRACE,("     AC_BK      %2d     %2d     %2d      %4d     %d\n",
6673                                                                          pEdcaParm->Aifsn[1],
6674                                                                          pEdcaParm->Cwmin[1],
6675                                                                          pEdcaParm->Cwmax[1],
6676                                                                          pEdcaParm->Txop[1]<<5,
6677                                                                          pEdcaParm->bACM[1]));
6678                         DBGPRINT(RT_DEBUG_TRACE,("     AC_VI      %2d     %2d     %2d      %4d     %d\n",
6679                                                                          pEdcaParm->Aifsn[2],
6680                                                                          pEdcaParm->Cwmin[2],
6681                                                                          pEdcaParm->Cwmax[2],
6682                                                                          pEdcaParm->Txop[2]<<5,
6683                                                                          pEdcaParm->bACM[2]));
6684                         DBGPRINT(RT_DEBUG_TRACE,("     AC_VO      %2d     %2d     %2d      %4d     %d\n",
6685                                                                          pEdcaParm->Aifsn[3],
6686                                                                          pEdcaParm->Cwmin[3],
6687                                                                          pEdcaParm->Cwmax[3],
6688                                                                          pEdcaParm->Txop[3]<<5,
6689                                                                          pEdcaParm->bACM[3]));
6690                 }
6691         }
6692 }
6693
6694 /*
6695         ==========================================================================
6696         Description:
6697
6698         IRQL = PASSIVE_LEVEL
6699         IRQL = DISPATCH_LEVEL
6700
6701         ==========================================================================
6702  */
6703 VOID    AsicSetSlotTime(
6704         IN PRTMP_ADAPTER pAd,
6705         IN BOOLEAN bUseShortSlotTime)
6706 {
6707         ULONG   SlotTime;
6708         UINT32  RegValue = 0;
6709
6710 #ifdef CONFIG_STA_SUPPORT
6711         if (pAd->CommonCfg.Channel > 14)
6712                 bUseShortSlotTime = TRUE;
6713 #endif // CONFIG_STA_SUPPORT //
6714
6715         if (bUseShortSlotTime)
6716                 OPSTATUS_SET_FLAG(pAd, fOP_STATUS_SHORT_SLOT_INUSED);
6717         else
6718                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_SLOT_INUSED);
6719
6720         SlotTime = (bUseShortSlotTime)? 9 : 20;
6721
6722 #ifdef CONFIG_STA_SUPPORT
6723         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6724         {
6725                 // force using short SLOT time for FAE to demo performance when TxBurst is ON
6726                 if (((pAd->StaActive.SupportedPhyInfo.bHtEnable == FALSE) && (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_WMM_INUSED)))
6727 #ifdef DOT11_N_SUPPORT
6728                         || ((pAd->StaActive.SupportedPhyInfo.bHtEnable == TRUE) && (pAd->CommonCfg.BACapability.field.Policy == BA_NOTUSE))
6729 #endif // DOT11_N_SUPPORT //
6730                         )
6731                 {
6732                         // In this case, we will think it is doing Wi-Fi test
6733                         // And we will not set to short slot when bEnableTxBurst is TRUE.
6734                 }
6735                 else if (pAd->CommonCfg.bEnableTxBurst)
6736                         SlotTime = 9;
6737         }
6738 #endif // CONFIG_STA_SUPPORT //
6739
6740         //
6741         // For some reasons, always set it to short slot time.
6742         //
6743         // ToDo: Should consider capability with 11B
6744         //
6745 #ifdef CONFIG_STA_SUPPORT
6746         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
6747         {
6748                 if (pAd->StaCfg.BssType == BSS_ADHOC)
6749                         SlotTime = 20;
6750         }
6751 #endif // CONFIG_STA_SUPPORT //
6752
6753         RTMP_IO_READ32(pAd, BKOFF_SLOT_CFG, &RegValue);
6754         RegValue = RegValue & 0xFFFFFF00;
6755
6756         RegValue |= SlotTime;
6757
6758         RTMP_IO_WRITE32(pAd, BKOFF_SLOT_CFG, RegValue);
6759 }
6760
6761 /*
6762         ========================================================================
6763         Description:
6764                 Add Shared key information into ASIC.
6765                 Update shared key, TxMic and RxMic to Asic Shared key table
6766                 Update its cipherAlg to Asic Shared key Mode.
6767
6768     Return:
6769         ========================================================================
6770 */
6771 VOID AsicAddSharedKeyEntry(
6772         IN PRTMP_ADAPTER pAd,
6773         IN UCHAR                 BssIndex,
6774         IN UCHAR                 KeyIdx,
6775         IN UCHAR                 CipherAlg,
6776         IN PUCHAR                pKey,
6777         IN PUCHAR                pTxMic,
6778         IN PUCHAR                pRxMic)
6779 {
6780         ULONG offset; //, csr0;
6781         SHAREDKEY_MODE_STRUC csr1;
6782
6783         DBGPRINT(RT_DEBUG_TRACE, ("AsicAddSharedKeyEntry BssIndex=%d, KeyIdx=%d\n", BssIndex,KeyIdx));
6784 //============================================================================================
6785
6786         DBGPRINT(RT_DEBUG_TRACE,("AsicAddSharedKeyEntry: %s key #%d\n", CipherName[CipherAlg], BssIndex*4 + KeyIdx));
6787         DBGPRINT_RAW(RT_DEBUG_TRACE, ("         Key = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
6788                 pKey[0],pKey[1],pKey[2],pKey[3],pKey[4],pKey[5],pKey[6],pKey[7],pKey[8],pKey[9],pKey[10],pKey[11],pKey[12],pKey[13],pKey[14],pKey[15]));
6789         if (pRxMic)
6790         {
6791                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("         Rx MIC Key = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
6792                         pRxMic[0],pRxMic[1],pRxMic[2],pRxMic[3],pRxMic[4],pRxMic[5],pRxMic[6],pRxMic[7]));
6793         }
6794         if (pTxMic)
6795         {
6796                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("         Tx MIC Key = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
6797                         pTxMic[0],pTxMic[1],pTxMic[2],pTxMic[3],pTxMic[4],pTxMic[5],pTxMic[6],pTxMic[7]));
6798         }
6799 //============================================================================================
6800         //
6801         // fill key material - key + TX MIC + RX MIC
6802         //
6803
6804 #ifdef RT2870
6805 {
6806         offset = SHARED_KEY_TABLE_BASE + (4*BssIndex + KeyIdx)*HW_KEY_ENTRY_SIZE;
6807         RTUSBMultiWrite(pAd, offset, pKey, MAX_LEN_OF_SHARE_KEY);
6808
6809         offset += MAX_LEN_OF_SHARE_KEY;
6810         if (pTxMic)
6811         {
6812                 RTUSBMultiWrite(pAd, offset, pTxMic, 8);
6813         }
6814
6815         offset += 8;
6816         if (pRxMic)
6817         {
6818                 RTUSBMultiWrite(pAd, offset, pRxMic, 8);
6819         }
6820 }
6821 #endif // RT2870 //
6822
6823         //
6824         // Update cipher algorithm. WSTA always use BSS0
6825         //
6826         RTMP_IO_READ32(pAd, SHARED_KEY_MODE_BASE+4*(BssIndex/2), &csr1.word);
6827         DBGPRINT(RT_DEBUG_TRACE,("Read: SHARED_KEY_MODE_BASE at this Bss[%d] KeyIdx[%d]= 0x%x \n", BssIndex,KeyIdx, csr1.word));
6828         if ((BssIndex%2) == 0)
6829         {
6830                 if (KeyIdx == 0)
6831                         csr1.field.Bss0Key0CipherAlg = CipherAlg;
6832                 else if (KeyIdx == 1)
6833                         csr1.field.Bss0Key1CipherAlg = CipherAlg;
6834                 else if (KeyIdx == 2)
6835                         csr1.field.Bss0Key2CipherAlg = CipherAlg;
6836                 else
6837                         csr1.field.Bss0Key3CipherAlg = CipherAlg;
6838         }
6839         else
6840         {
6841                 if (KeyIdx == 0)
6842                         csr1.field.Bss1Key0CipherAlg = CipherAlg;
6843                 else if (KeyIdx == 1)
6844                         csr1.field.Bss1Key1CipherAlg = CipherAlg;
6845                 else if (KeyIdx == 2)
6846                         csr1.field.Bss1Key2CipherAlg = CipherAlg;
6847                 else
6848                         csr1.field.Bss1Key3CipherAlg = CipherAlg;
6849         }
6850         DBGPRINT(RT_DEBUG_TRACE,("Write: SHARED_KEY_MODE_BASE at this Bss[%d] = 0x%x \n", BssIndex, csr1.word));
6851         RTMP_IO_WRITE32(pAd, SHARED_KEY_MODE_BASE+4*(BssIndex/2), csr1.word);
6852
6853 }
6854
6855 //      IRQL = DISPATCH_LEVEL
6856 VOID AsicRemoveSharedKeyEntry(
6857         IN PRTMP_ADAPTER pAd,
6858         IN UCHAR                 BssIndex,
6859         IN UCHAR                 KeyIdx)
6860 {
6861         //ULONG SecCsr0;
6862         SHAREDKEY_MODE_STRUC csr1;
6863
6864         DBGPRINT(RT_DEBUG_TRACE,("AsicRemoveSharedKeyEntry: #%d \n", BssIndex*4 + KeyIdx));
6865
6866         RTMP_IO_READ32(pAd, SHARED_KEY_MODE_BASE+4*(BssIndex/2), &csr1.word);
6867         if ((BssIndex%2) == 0)
6868         {
6869                 if (KeyIdx == 0)
6870                         csr1.field.Bss0Key0CipherAlg = 0;
6871                 else if (KeyIdx == 1)
6872                         csr1.field.Bss0Key1CipherAlg = 0;
6873                 else if (KeyIdx == 2)
6874                         csr1.field.Bss0Key2CipherAlg = 0;
6875                 else
6876                         csr1.field.Bss0Key3CipherAlg = 0;
6877         }
6878         else
6879         {
6880                 if (KeyIdx == 0)
6881                         csr1.field.Bss1Key0CipherAlg = 0;
6882                 else if (KeyIdx == 1)
6883                         csr1.field.Bss1Key1CipherAlg = 0;
6884                 else if (KeyIdx == 2)
6885                         csr1.field.Bss1Key2CipherAlg = 0;
6886                 else
6887                         csr1.field.Bss1Key3CipherAlg = 0;
6888         }
6889         DBGPRINT(RT_DEBUG_TRACE,("Write: SHARED_KEY_MODE_BASE at this Bss[%d] = 0x%x \n", BssIndex, csr1.word));
6890         RTMP_IO_WRITE32(pAd, SHARED_KEY_MODE_BASE+4*(BssIndex/2), csr1.word);
6891         ASSERT(BssIndex < 4);
6892         ASSERT(KeyIdx < 4);
6893
6894 }
6895
6896
6897 VOID AsicUpdateWCIDAttribute(
6898         IN PRTMP_ADAPTER pAd,
6899         IN USHORT               WCID,
6900         IN UCHAR                BssIndex,
6901         IN UCHAR        CipherAlg,
6902         IN BOOLEAN              bUsePairewiseKeyTable)
6903 {
6904         ULONG   WCIDAttri = 0, offset;
6905
6906         //
6907         // Update WCID attribute.
6908         // Only TxKey could update WCID attribute.
6909         //
6910         offset = MAC_WCID_ATTRIBUTE_BASE + (WCID * HW_WCID_ATTRI_SIZE);
6911         WCIDAttri = (BssIndex << 4) | (CipherAlg << 1) | (bUsePairewiseKeyTable);
6912         RTMP_IO_WRITE32(pAd, offset, WCIDAttri);
6913 }
6914
6915 VOID AsicUpdateWCIDIVEIV(
6916         IN PRTMP_ADAPTER pAd,
6917         IN USHORT               WCID,
6918         IN ULONG        uIV,
6919         IN ULONG        uEIV)
6920 {
6921         ULONG   offset;
6922
6923         offset = MAC_IVEIV_TABLE_BASE + (WCID * HW_IVEIV_ENTRY_SIZE);
6924
6925         RTMP_IO_WRITE32(pAd, offset, uIV);
6926         RTMP_IO_WRITE32(pAd, offset + 4, uEIV);
6927 }
6928
6929 VOID AsicUpdateRxWCIDTable(
6930         IN PRTMP_ADAPTER pAd,
6931         IN USHORT               WCID,
6932         IN PUCHAR        pAddr)
6933 {
6934         ULONG offset;
6935         ULONG Addr;
6936
6937         offset = MAC_WCID_BASE + (WCID * HW_WCID_ENTRY_SIZE);
6938         Addr = pAddr[0] + (pAddr[1] << 8) +(pAddr[2] << 16) +(pAddr[3] << 24);
6939         RTMP_IO_WRITE32(pAd, offset, Addr);
6940         Addr = pAddr[4] + (pAddr[5] << 8);
6941         RTMP_IO_WRITE32(pAd, offset + 4, Addr);
6942 }
6943
6944
6945 /*
6946     ========================================================================
6947
6948     Routine Description:
6949         Set Cipher Key, Cipher algorithm, IV/EIV to Asic
6950
6951     Arguments:
6952         pAd                     Pointer to our adapter
6953         WCID                    WCID Entry number.
6954         BssIndex                BSSID index, station or none multiple BSSID support
6955                                 this value should be 0.
6956         KeyIdx                  This KeyIdx will set to IV's KeyID if bTxKey enabled
6957         pCipherKey              Pointer to Cipher Key.
6958         bUsePairewiseKeyTable   TRUE means saved the key in SharedKey table,
6959                                 otherwise PairewiseKey table
6960         bTxKey                  This is the transmit key if enabled.
6961
6962     Return Value:
6963         None
6964
6965     Note:
6966         This routine will set the relative key stuff to Asic including WCID attribute,
6967         Cipher Key, Cipher algorithm and IV/EIV.
6968
6969         IV/EIV will be update if this CipherKey is the transmission key because
6970         ASIC will base on IV's KeyID value to select Cipher Key.
6971
6972         If bTxKey sets to FALSE, this is not the TX key, but it could be
6973         RX key
6974
6975         For AP mode bTxKey must be always set to TRUE.
6976     ========================================================================
6977 */
6978 VOID AsicAddKeyEntry(
6979         IN PRTMP_ADAPTER pAd,
6980         IN USHORT               WCID,
6981         IN UCHAR                BssIndex,
6982         IN UCHAR                KeyIdx,
6983         IN PCIPHER_KEY  pCipherKey,
6984         IN BOOLEAN              bUsePairewiseKeyTable,
6985         IN BOOLEAN              bTxKey)
6986 {
6987         ULONG   offset;
6988 //      ULONG   WCIDAttri = 0;
6989         UCHAR   IV4 = 0;
6990         PUCHAR          pKey = pCipherKey->Key;
6991 //      ULONG           KeyLen = pCipherKey->KeyLen;
6992         PUCHAR          pTxMic = pCipherKey->TxMic;
6993         PUCHAR          pRxMic = pCipherKey->RxMic;
6994         PUCHAR          pTxtsc = pCipherKey->TxTsc;
6995         UCHAR           CipherAlg = pCipherKey->CipherAlg;
6996         SHAREDKEY_MODE_STRUC csr1;
6997
6998 //      ASSERT(KeyLen <= MAX_LEN_OF_PEER_KEY);
6999
7000         DBGPRINT(RT_DEBUG_TRACE, ("==> AsicAddKeyEntry\n"));
7001         //
7002         // 1.) decide key table offset
7003         //
7004         if (bUsePairewiseKeyTable)
7005                 offset = PAIRWISE_KEY_TABLE_BASE + (WCID * HW_KEY_ENTRY_SIZE);
7006         else
7007                 offset = SHARED_KEY_TABLE_BASE + (4 * BssIndex + KeyIdx) * HW_KEY_ENTRY_SIZE;
7008
7009         //
7010         // 2.) Set Key to Asic
7011         //
7012         //for (i = 0; i < KeyLen; i++)
7013
7014 #ifdef RT2870
7015         RTUSBMultiWrite(pAd, offset, pKey, MAX_LEN_OF_PEER_KEY);
7016         offset += MAX_LEN_OF_PEER_KEY;
7017
7018         //
7019         // 3.) Set MIC key if available
7020         //
7021         if (pTxMic)
7022         {
7023                 RTUSBMultiWrite(pAd, offset, pTxMic, 8);
7024         }
7025         offset += LEN_TKIP_TXMICK;
7026
7027         if (pRxMic)
7028         {
7029                 RTUSBMultiWrite(pAd, offset, pRxMic, 8);
7030         }
7031 #endif // RT2870 //
7032
7033         //
7034         // 4.) Modify IV/EIV if needs
7035         //     This will force Asic to use this key ID by setting IV.
7036         //
7037         if (bTxKey)
7038         {
7039
7040 #ifdef RT2870
7041                 UINT32 tmpVal;
7042
7043                 //
7044                 // Write IV
7045                 //
7046                 IV4 = (KeyIdx << 6);
7047                 if ((CipherAlg == CIPHER_TKIP) || (CipherAlg == CIPHER_TKIP_NO_MIC) ||(CipherAlg == CIPHER_AES))
7048                         IV4 |= 0x20;  // turn on extension bit means EIV existence
7049
7050                 tmpVal = pTxtsc[1] + (((pTxtsc[1] | 0x20) & 0x7f) << 8) + (pTxtsc[0] << 16) + (IV4 << 24);
7051                 RTMP_IO_WRITE32(pAd, offset, tmpVal);
7052
7053                 //
7054                 // Write EIV
7055                 //
7056                 offset += 4;
7057                 RTMP_IO_WRITE32(pAd, offset, *(PUINT32)&pCipherKey->TxTsc[2]);
7058 #endif // RT2870 //
7059                 AsicUpdateWCIDAttribute(pAd, WCID, BssIndex, CipherAlg, bUsePairewiseKeyTable);
7060         }
7061
7062         if (!bUsePairewiseKeyTable)
7063         {
7064                 //
7065                 // Only update the shared key security mode
7066                 //
7067                 RTMP_IO_READ32(pAd, SHARED_KEY_MODE_BASE + 4 * (BssIndex / 2), &csr1.word);
7068                 if ((BssIndex % 2) == 0)
7069                 {
7070                         if (KeyIdx == 0)
7071                                 csr1.field.Bss0Key0CipherAlg = CipherAlg;
7072                         else if (KeyIdx == 1)
7073                                 csr1.field.Bss0Key1CipherAlg = CipherAlg;
7074                         else if (KeyIdx == 2)
7075                                 csr1.field.Bss0Key2CipherAlg = CipherAlg;
7076                         else
7077                                 csr1.field.Bss0Key3CipherAlg = CipherAlg;
7078                 }
7079                 else
7080                 {
7081                         if (KeyIdx == 0)
7082                                 csr1.field.Bss1Key0CipherAlg = CipherAlg;
7083                         else if (KeyIdx == 1)
7084                                 csr1.field.Bss1Key1CipherAlg = CipherAlg;
7085                         else if (KeyIdx == 2)
7086                                 csr1.field.Bss1Key2CipherAlg = CipherAlg;
7087                         else
7088                                 csr1.field.Bss1Key3CipherAlg = CipherAlg;
7089                 }
7090                 RTMP_IO_WRITE32(pAd, SHARED_KEY_MODE_BASE + 4 * (BssIndex / 2), csr1.word);
7091         }
7092
7093         DBGPRINT(RT_DEBUG_TRACE, ("<== AsicAddKeyEntry\n"));
7094 }
7095
7096
7097 /*
7098         ========================================================================
7099         Description:
7100                 Add Pair-wise key material into ASIC.
7101                 Update pairwise key, TxMic and RxMic to Asic Pair-wise key table
7102
7103     Return:
7104         ========================================================================
7105 */
7106 VOID AsicAddPairwiseKeyEntry(
7107         IN PRTMP_ADAPTER pAd,
7108         IN PUCHAR        pAddr,
7109         IN UCHAR                WCID,
7110         IN CIPHER_KEY            *pCipherKey)
7111 {
7112         INT i;
7113         ULONG           offset;
7114         PUCHAR           pKey = pCipherKey->Key;
7115         PUCHAR           pTxMic = pCipherKey->TxMic;
7116         PUCHAR           pRxMic = pCipherKey->RxMic;
7117 #ifdef DBG
7118         UCHAR           CipherAlg = pCipherKey->CipherAlg;
7119 #endif // DBG //
7120
7121         // EKEY
7122         offset = PAIRWISE_KEY_TABLE_BASE + (WCID * HW_KEY_ENTRY_SIZE);
7123 #ifdef RT2870
7124         RTUSBMultiWrite(pAd, offset, &pCipherKey->Key[0], MAX_LEN_OF_PEER_KEY);
7125 #endif // RT2870 //
7126         for (i=0; i<MAX_LEN_OF_PEER_KEY; i+=4)
7127         {
7128                 UINT32 Value;
7129                 RTMP_IO_READ32(pAd, offset + i, &Value);
7130         }
7131
7132         offset += MAX_LEN_OF_PEER_KEY;
7133
7134         //  MIC KEY
7135         if (pTxMic)
7136         {
7137 #ifdef RT2870
7138                 RTUSBMultiWrite(pAd, offset, &pCipherKey->TxMic[0], 8);
7139 #endif // RT2870 //
7140         }
7141         offset += 8;
7142         if (pRxMic)
7143         {
7144 #ifdef RT2870
7145                 RTUSBMultiWrite(pAd, offset, &pCipherKey->RxMic[0], 8);
7146 #endif // RT2870 //
7147         }
7148
7149         DBGPRINT(RT_DEBUG_TRACE,("AsicAddPairwiseKeyEntry: WCID #%d Alg=%s\n",WCID, CipherName[CipherAlg]));
7150         DBGPRINT(RT_DEBUG_TRACE,("      Key = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
7151                 pKey[0],pKey[1],pKey[2],pKey[3],pKey[4],pKey[5],pKey[6],pKey[7],pKey[8],pKey[9],pKey[10],pKey[11],pKey[12],pKey[13],pKey[14],pKey[15]));
7152         if (pRxMic)
7153         {
7154                 DBGPRINT(RT_DEBUG_TRACE, ("     Rx MIC Key = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
7155                         pRxMic[0],pRxMic[1],pRxMic[2],pRxMic[3],pRxMic[4],pRxMic[5],pRxMic[6],pRxMic[7]));
7156         }
7157         if (pTxMic)
7158         {
7159                 DBGPRINT(RT_DEBUG_TRACE, ("     Tx MIC Key = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
7160                         pTxMic[0],pTxMic[1],pTxMic[2],pTxMic[3],pTxMic[4],pTxMic[5],pTxMic[6],pTxMic[7]));
7161         }
7162 }
7163 /*
7164         ========================================================================
7165         Description:
7166                 Remove Pair-wise key material from ASIC.
7167
7168     Return:
7169         ========================================================================
7170 */
7171 VOID AsicRemovePairwiseKeyEntry(
7172         IN PRTMP_ADAPTER pAd,
7173         IN UCHAR                 BssIdx,
7174         IN UCHAR                 Wcid)
7175 {
7176         ULONG           WCIDAttri;
7177         USHORT          offset;
7178
7179         // re-set the entry's WCID attribute as OPEN-NONE.
7180         offset = MAC_WCID_ATTRIBUTE_BASE + (Wcid * HW_WCID_ATTRI_SIZE);
7181         WCIDAttri = (BssIdx<<4) | PAIRWISEKEYTABLE;
7182         RTMP_IO_WRITE32(pAd, offset, WCIDAttri);
7183 }
7184
7185 BOOLEAN AsicSendCommandToMcu(
7186         IN PRTMP_ADAPTER pAd,
7187         IN UCHAR                 Command,
7188         IN UCHAR                 Token,
7189         IN UCHAR                 Arg0,
7190         IN UCHAR                 Arg1)
7191 {
7192         HOST_CMD_CSR_STRUC      H2MCmd;
7193         H2M_MAILBOX_STRUC       H2MMailbox;
7194         ULONG                           i = 0;
7195         do
7196         {
7197                 RTMP_IO_READ32(pAd, H2M_MAILBOX_CSR, &H2MMailbox.word);
7198                 if (H2MMailbox.field.Owner == 0)
7199                         break;
7200
7201                 RTMPusecDelay(2);
7202         } while(i++ < 100);
7203
7204         if (i >= 100)
7205         {
7206                 {
7207                 DBGPRINT_ERR(("H2M_MAILBOX still hold by MCU. command fail\n"));
7208                 }
7209                 return FALSE;
7210         }
7211
7212
7213         H2MMailbox.field.Owner    = 1;     // pass ownership to MCU
7214         H2MMailbox.field.CmdToken = Token;
7215         H2MMailbox.field.HighByte = Arg1;
7216         H2MMailbox.field.LowByte  = Arg0;
7217         RTMP_IO_WRITE32(pAd, H2M_MAILBOX_CSR, H2MMailbox.word);
7218
7219         H2MCmd.word                       = 0;
7220         H2MCmd.field.HostCommand  = Command;
7221         RTMP_IO_WRITE32(pAd, HOST_CMD_CSR, H2MCmd.word);
7222
7223         if (Command != 0x80)
7224         {
7225         }
7226
7227         return TRUE;
7228 }
7229
7230
7231 /*
7232         ========================================================================
7233
7234         Routine Description:
7235                 Verify the support rate for different PHY type
7236
7237         Arguments:
7238                 pAd                             Pointer to our adapter
7239
7240         Return Value:
7241                 None
7242
7243         IRQL = PASSIVE_LEVEL
7244
7245         ========================================================================
7246 */
7247 VOID    RTMPCheckRates(
7248         IN              PRTMP_ADAPTER   pAd,
7249         IN OUT  UCHAR                   SupRate[],
7250         IN OUT  UCHAR                   *SupRateLen)
7251 {
7252         UCHAR   RateIdx, i, j;
7253         UCHAR   NewRate[12], NewRateLen;
7254
7255         NewRateLen = 0;
7256
7257         if (pAd->CommonCfg.PhyMode == PHY_11B)
7258                 RateIdx = 4;
7259         else
7260                 RateIdx = 12;
7261
7262         // Check for support rates exclude basic rate bit
7263         for (i = 0; i < *SupRateLen; i++)
7264                 for (j = 0; j < RateIdx; j++)
7265                         if ((SupRate[i] & 0x7f) == RateIdTo500Kbps[j])
7266                                 NewRate[NewRateLen++] = SupRate[i];
7267
7268         *SupRateLen = NewRateLen;
7269         NdisMoveMemory(SupRate, NewRate, NewRateLen);
7270 }
7271
7272 #ifdef CONFIG_STA_SUPPORT
7273 #ifdef DOT11_N_SUPPORT
7274 BOOLEAN RTMPCheckChannel(
7275         IN PRTMP_ADAPTER pAd,
7276         IN UCHAR                CentralChannel,
7277         IN UCHAR                Channel)
7278 {
7279         UCHAR           k;
7280         UCHAR           UpperChannel = 0, LowerChannel = 0;
7281         UCHAR           NoEffectChannelinList = 0;
7282
7283         // Find upper and lower channel according to 40MHz current operation.
7284         if (CentralChannel < Channel)
7285         {
7286                 UpperChannel = Channel;
7287                 if (CentralChannel > 2)
7288                         LowerChannel = CentralChannel - 2;
7289                 else
7290                         return FALSE;
7291         }
7292         else if (CentralChannel > Channel)
7293         {
7294                 UpperChannel = CentralChannel + 2;
7295                 LowerChannel = Channel;
7296         }
7297
7298         for (k = 0;k < pAd->ChannelListNum;k++)
7299         {
7300                 if (pAd->ChannelList[k].Channel == UpperChannel)
7301                 {
7302                         NoEffectChannelinList ++;
7303                 }
7304                 if (pAd->ChannelList[k].Channel == LowerChannel)
7305                 {
7306                         NoEffectChannelinList ++;
7307                 }
7308         }
7309
7310         DBGPRINT(RT_DEBUG_TRACE,("Total Channel in Channel List = [%d]\n", NoEffectChannelinList));
7311         if (NoEffectChannelinList == 2)
7312                 return TRUE;
7313         else
7314                 return FALSE;
7315 }
7316
7317 /*
7318         ========================================================================
7319
7320         Routine Description:
7321                 Verify the support rate for HT phy type
7322
7323         Arguments:
7324                 pAd                             Pointer to our adapter
7325
7326         Return Value:
7327                 FALSE if pAd->CommonCfg.SupportedHtPhy doesn't accept the pHtCapability.  (AP Mode)
7328
7329         IRQL = PASSIVE_LEVEL
7330
7331         ========================================================================
7332 */
7333 BOOLEAN         RTMPCheckHt(
7334         IN      PRTMP_ADAPTER                   pAd,
7335         IN      UCHAR                                   Wcid,
7336         IN      HT_CAPABILITY_IE                *pHtCapability,
7337         IN      ADD_HT_INFO_IE                  *pAddHtInfo)
7338 {
7339         if (Wcid >= MAX_LEN_OF_MAC_TABLE)
7340                 return FALSE;
7341
7342         // If use AMSDU, set flag.
7343         if (pAd->CommonCfg.DesiredHtPhy.AmsduEnable)
7344                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_AMSDU_INUSED);
7345         // Save Peer Capability
7346         if (pHtCapability->HtCapInfo.ShortGIfor20)
7347                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_SGI20_CAPABLE);
7348         if (pHtCapability->HtCapInfo.ShortGIfor40)
7349                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_SGI40_CAPABLE);
7350         if (pHtCapability->HtCapInfo.TxSTBC)
7351                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_TxSTBC_CAPABLE);
7352         if (pHtCapability->HtCapInfo.RxSTBC)
7353                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_RxSTBC_CAPABLE);
7354         if (pAd->CommonCfg.bRdg && pHtCapability->ExtHtCapInfo.RDGSupport)
7355         {
7356                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_RDG_CAPABLE);
7357         }
7358
7359         if (Wcid < MAX_LEN_OF_MAC_TABLE)
7360         {
7361                 pAd->MacTab.Content[Wcid].MpduDensity = pHtCapability->HtCapParm.MpduDensity;
7362         }
7363
7364         // Will check ChannelWidth for MCSSet[4] below
7365         pAd->MlmeAux.HtCapability.MCSSet[4] = 0x1;
7366     switch (pAd->CommonCfg.RxStream)
7367         {
7368                 case 1:
7369                         pAd->MlmeAux.HtCapability.MCSSet[0] = 0xff;
7370                         pAd->MlmeAux.HtCapability.MCSSet[1] = 0x00;
7371             pAd->MlmeAux.HtCapability.MCSSet[2] = 0x00;
7372             pAd->MlmeAux.HtCapability.MCSSet[3] = 0x00;
7373                         break;
7374                 case 2:
7375                         pAd->MlmeAux.HtCapability.MCSSet[0] = 0xff;
7376                         pAd->MlmeAux.HtCapability.MCSSet[1] = 0xff;
7377             pAd->MlmeAux.HtCapability.MCSSet[2] = 0x00;
7378             pAd->MlmeAux.HtCapability.MCSSet[3] = 0x00;
7379                         break;
7380                 case 3:
7381                         pAd->MlmeAux.HtCapability.MCSSet[0] = 0xff;
7382                         pAd->MlmeAux.HtCapability.MCSSet[1] = 0xff;
7383             pAd->MlmeAux.HtCapability.MCSSet[2] = 0xff;
7384             pAd->MlmeAux.HtCapability.MCSSet[3] = 0x00;
7385                         break;
7386         }
7387
7388         pAd->MlmeAux.HtCapability.HtCapInfo.ChannelWidth = pAddHtInfo->AddHtInfo.RecomWidth & pAd->CommonCfg.DesiredHtPhy.ChannelWidth;
7389
7390     DBGPRINT(RT_DEBUG_TRACE, ("RTMPCheckHt:: HtCapInfo.ChannelWidth=%d, RecomWidth=%d, DesiredHtPhy.ChannelWidth=%d, BW40MAvailForA/G=%d/%d, PhyMode=%d \n",
7391                 pAd->MlmeAux.HtCapability.HtCapInfo.ChannelWidth, pAddHtInfo->AddHtInfo.RecomWidth, pAd->CommonCfg.DesiredHtPhy.ChannelWidth,
7392                 pAd->NicConfig2.field.BW40MAvailForA, pAd->NicConfig2.field.BW40MAvailForG, pAd->CommonCfg.PhyMode));
7393
7394         pAd->MlmeAux.HtCapability.HtCapInfo.GF =  pHtCapability->HtCapInfo.GF &pAd->CommonCfg.DesiredHtPhy.GF;
7395
7396         // Send Assoc Req with my HT capability.
7397         pAd->MlmeAux.HtCapability.HtCapInfo.AMsduSize =  pAd->CommonCfg.DesiredHtPhy.AmsduSize;
7398         pAd->MlmeAux.HtCapability.HtCapInfo.MimoPs =  pAd->CommonCfg.DesiredHtPhy.MimoPs;
7399         pAd->MlmeAux.HtCapability.HtCapInfo.ShortGIfor20 =  (pAd->CommonCfg.DesiredHtPhy.ShortGIfor20) & (pHtCapability->HtCapInfo.ShortGIfor20);
7400         pAd->MlmeAux.HtCapability.HtCapInfo.ShortGIfor40 =  (pAd->CommonCfg.DesiredHtPhy.ShortGIfor40) & (pHtCapability->HtCapInfo.ShortGIfor40);
7401         pAd->MlmeAux.HtCapability.HtCapInfo.TxSTBC =  (pAd->CommonCfg.DesiredHtPhy.TxSTBC)&(pHtCapability->HtCapInfo.RxSTBC);
7402         pAd->MlmeAux.HtCapability.HtCapInfo.RxSTBC =  (pAd->CommonCfg.DesiredHtPhy.RxSTBC)&(pHtCapability->HtCapInfo.TxSTBC);
7403         pAd->MlmeAux.HtCapability.HtCapParm.MaxRAmpduFactor = pAd->CommonCfg.DesiredHtPhy.MaxRAmpduFactor;
7404     pAd->MlmeAux.HtCapability.HtCapParm.MpduDensity = pAd->CommonCfg.HtCapability.HtCapParm.MpduDensity;
7405         pAd->MlmeAux.HtCapability.ExtHtCapInfo.PlusHTC = pHtCapability->ExtHtCapInfo.PlusHTC;
7406         pAd->MacTab.Content[Wcid].HTCapability.ExtHtCapInfo.PlusHTC = pHtCapability->ExtHtCapInfo.PlusHTC;
7407         if (pAd->CommonCfg.bRdg)
7408         {
7409                 pAd->MlmeAux.HtCapability.ExtHtCapInfo.RDGSupport = pHtCapability->ExtHtCapInfo.RDGSupport;
7410         pAd->MlmeAux.HtCapability.ExtHtCapInfo.PlusHTC = 1;
7411         }
7412
7413     if (pAd->MlmeAux.HtCapability.HtCapInfo.ChannelWidth == BW_20)
7414         pAd->MlmeAux.HtCapability.MCSSet[4] = 0x0;  // BW20 can't transmit MCS32
7415
7416         COPY_AP_HTSETTINGS_FROM_BEACON(pAd, pHtCapability);
7417         return TRUE;
7418 }
7419 #endif // DOT11_N_SUPPORT //
7420 #endif // CONFIG_STA_SUPPORT //
7421
7422 /*
7423         ========================================================================
7424
7425         Routine Description:
7426                 Verify the support rate for different PHY type
7427
7428         Arguments:
7429                 pAd                             Pointer to our adapter
7430
7431         Return Value:
7432                 None
7433
7434         IRQL = PASSIVE_LEVEL
7435
7436         ========================================================================
7437 */
7438 VOID RTMPUpdateMlmeRate(
7439         IN PRTMP_ADAPTER        pAd)
7440 {
7441         UCHAR   MinimumRate;
7442         UCHAR   ProperMlmeRate; //= RATE_54;
7443         UCHAR   i, j, RateIdx = 12; //1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54
7444         BOOLEAN bMatch = FALSE;
7445
7446         switch (pAd->CommonCfg.PhyMode)
7447         {
7448                 case PHY_11B:
7449                         ProperMlmeRate = RATE_11;
7450                         MinimumRate = RATE_1;
7451                         break;
7452                 case PHY_11BG_MIXED:
7453 #ifdef DOT11_N_SUPPORT
7454                 case PHY_11ABGN_MIXED:
7455                 case PHY_11BGN_MIXED:
7456 #endif // DOT11_N_SUPPORT //
7457                         if ((pAd->MlmeAux.SupRateLen == 4) &&
7458                                 (pAd->MlmeAux.ExtRateLen == 0))
7459                                 // B only AP
7460                                 ProperMlmeRate = RATE_11;
7461                         else
7462                                 ProperMlmeRate = RATE_24;
7463
7464                         if (pAd->MlmeAux.Channel <= 14)
7465                                 MinimumRate = RATE_1;
7466                         else
7467                                 MinimumRate = RATE_6;
7468                         break;
7469                 case PHY_11A:
7470 #ifdef DOT11_N_SUPPORT
7471                 case PHY_11N_2_4G:      // rt2860 need to check mlmerate for 802.11n
7472                 case PHY_11GN_MIXED:
7473                 case PHY_11AGN_MIXED:
7474                 case PHY_11AN_MIXED:
7475                 case PHY_11N_5G:
7476 #endif // DOT11_N_SUPPORT //
7477                         ProperMlmeRate = RATE_24;
7478                         MinimumRate = RATE_6;
7479                         break;
7480                 case PHY_11ABG_MIXED:
7481                         ProperMlmeRate = RATE_24;
7482                         if (pAd->MlmeAux.Channel <= 14)
7483                            MinimumRate = RATE_1;
7484                         else
7485                                 MinimumRate = RATE_6;
7486                         break;
7487                 default: // error
7488                         ProperMlmeRate = RATE_1;
7489                         MinimumRate = RATE_1;
7490                         break;
7491         }
7492
7493         for (i = 0; i < pAd->MlmeAux.SupRateLen; i++)
7494         {
7495                 for (j = 0; j < RateIdx; j++)
7496                 {
7497                         if ((pAd->MlmeAux.SupRate[i] & 0x7f) == RateIdTo500Kbps[j])
7498                         {
7499                                 if (j == ProperMlmeRate)
7500                                 {
7501                                         bMatch = TRUE;
7502                                         break;
7503                                 }
7504                         }
7505                 }
7506
7507                 if (bMatch)
7508                         break;
7509         }
7510
7511         if (bMatch == FALSE)
7512         {
7513                 for (i = 0; i < pAd->MlmeAux.ExtRateLen; i++)
7514                 {
7515                         for (j = 0; j < RateIdx; j++)
7516                         {
7517                                 if ((pAd->MlmeAux.ExtRate[i] & 0x7f) == RateIdTo500Kbps[j])
7518                                 {
7519                                         if (j == ProperMlmeRate)
7520                                         {
7521                                                 bMatch = TRUE;
7522                                                 break;
7523                                         }
7524                                 }
7525                         }
7526
7527                         if (bMatch)
7528                                 break;
7529                 }
7530         }
7531
7532         if (bMatch == FALSE)
7533         {
7534                 ProperMlmeRate = MinimumRate;
7535         }
7536
7537         pAd->CommonCfg.MlmeRate = MinimumRate;
7538         pAd->CommonCfg.RtsRate = ProperMlmeRate;
7539         if (pAd->CommonCfg.MlmeRate >= RATE_6)
7540         {
7541                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
7542                 pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
7543                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MODE = MODE_OFDM;
7544                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
7545         }
7546         else
7547         {
7548                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_CCK;
7549                 pAd->CommonCfg.MlmeTransmit.field.MCS = pAd->CommonCfg.MlmeRate;
7550                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MODE = MODE_CCK;
7551                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MCS = pAd->CommonCfg.MlmeRate;
7552         }
7553
7554         DBGPRINT(RT_DEBUG_TRACE, ("RTMPUpdateMlmeRate ==>   MlmeTransmit = 0x%x  \n" , pAd->CommonCfg.MlmeTransmit.word));
7555 }
7556
7557 CHAR RTMPMaxRssi(
7558         IN PRTMP_ADAPTER        pAd,
7559         IN CHAR                         Rssi0,
7560         IN CHAR                         Rssi1,
7561         IN CHAR                         Rssi2)
7562 {
7563         CHAR    larger = -127;
7564
7565         if ((pAd->Antenna.field.RxPath == 1) && (Rssi0 != 0))
7566         {
7567                 larger = Rssi0;
7568         }
7569
7570         if ((pAd->Antenna.field.RxPath >= 2) && (Rssi1 != 0))
7571         {
7572                 larger = max(Rssi0, Rssi1);
7573         }
7574
7575         if ((pAd->Antenna.field.RxPath == 3) && (Rssi2 != 0))
7576         {
7577                 larger = max(larger, Rssi2);
7578         }
7579
7580         if (larger == -127)
7581                 larger = 0;
7582
7583         return larger;
7584 }
7585
7586 /*
7587     ========================================================================
7588     Routine Description:
7589         Periodic evaluate antenna link status
7590
7591     Arguments:
7592         pAd         - Adapter pointer
7593
7594     Return Value:
7595         None
7596
7597     ========================================================================
7598 */
7599 VOID AsicEvaluateRxAnt(
7600         IN PRTMP_ADAPTER        pAd)
7601 {
7602         UCHAR   BBPR3 = 0;
7603
7604 #ifdef CONFIG_STA_SUPPORT
7605         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
7606         {
7607                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS |
7608                                                                 fRTMP_ADAPTER_HALT_IN_PROGRESS  |
7609                                                                 fRTMP_ADAPTER_RADIO_OFF                 |
7610                                                                 fRTMP_ADAPTER_NIC_NOT_EXIST             |
7611                                                                 fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
7612                         return;
7613
7614                 if (pAd->StaCfg.Psm == PWR_SAVE)
7615                         return;
7616         }
7617 #endif // CONFIG_STA_SUPPORT //
7618
7619         RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BBPR3);
7620         BBPR3 &= (~0x18);
7621         if(pAd->Antenna.field.RxPath == 3)
7622         {
7623                 BBPR3 |= (0x10);
7624         }
7625         else if(pAd->Antenna.field.RxPath == 2)
7626         {
7627                 BBPR3 |= (0x8);
7628         }
7629         else if(pAd->Antenna.field.RxPath == 1)
7630         {
7631                 BBPR3 |= (0x0);
7632         }
7633         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BBPR3);
7634 #ifdef CONFIG_STA_SUPPORT
7635 #endif // CONFIG_STA_SUPPORT //
7636         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
7637                 )
7638         {
7639                 ULONG   TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
7640                                                                 pAd->RalinkCounters.OneSecTxRetryOkCount +
7641                                                                 pAd->RalinkCounters.OneSecTxFailCount;
7642
7643                 if (TxTotalCnt > 50)
7644                 {
7645                         RTMPSetTimer(&pAd->Mlme.RxAntEvalTimer, 20);
7646                         pAd->Mlme.bLowThroughput = FALSE;
7647                 }
7648                 else
7649                 {
7650                         RTMPSetTimer(&pAd->Mlme.RxAntEvalTimer, 300);
7651                         pAd->Mlme.bLowThroughput = TRUE;
7652                 }
7653         }
7654 }
7655
7656 /*
7657     ========================================================================
7658     Routine Description:
7659         After evaluation, check antenna link status
7660
7661     Arguments:
7662         pAd         - Adapter pointer
7663
7664     Return Value:
7665         None
7666
7667     ========================================================================
7668 */
7669 VOID AsicRxAntEvalTimeout(
7670         IN PVOID SystemSpecific1,
7671         IN PVOID FunctionContext,
7672         IN PVOID SystemSpecific2,
7673         IN PVOID SystemSpecific3)
7674 {
7675         RTMP_ADAPTER    *pAd = (RTMP_ADAPTER *)FunctionContext;
7676 #ifdef CONFIG_STA_SUPPORT
7677         UCHAR                   BBPR3 = 0;
7678         CHAR                    larger = -127, rssi0, rssi1, rssi2;
7679 #endif // CONFIG_STA_SUPPORT //
7680
7681 #ifdef CONFIG_STA_SUPPORT
7682         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
7683         {
7684                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)        ||
7685                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)             ||
7686                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)                    ||
7687                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
7688                         return;
7689
7690                 if (pAd->StaCfg.Psm == PWR_SAVE)
7691                         return;
7692
7693
7694                 // if the traffic is low, use average rssi as the criteria
7695                 if (pAd->Mlme.bLowThroughput == TRUE)
7696                 {
7697                         rssi0 = pAd->StaCfg.RssiSample.LastRssi0;
7698                         rssi1 = pAd->StaCfg.RssiSample.LastRssi1;
7699                         rssi2 = pAd->StaCfg.RssiSample.LastRssi2;
7700                 }
7701                 else
7702                 {
7703                         rssi0 = pAd->StaCfg.RssiSample.AvgRssi0;
7704                         rssi1 = pAd->StaCfg.RssiSample.AvgRssi1;
7705                         rssi2 = pAd->StaCfg.RssiSample.AvgRssi2;
7706                 }
7707
7708                 if(pAd->Antenna.field.RxPath == 3)
7709                 {
7710                         larger = max(rssi0, rssi1);
7711
7712                         if (larger > (rssi2 + 20))
7713                                 pAd->Mlme.RealRxPath = 2;
7714                         else
7715                                 pAd->Mlme.RealRxPath = 3;
7716                 }
7717                 else if(pAd->Antenna.field.RxPath == 2)
7718                 {
7719                         if (rssi0 > (rssi1 + 20))
7720                                 pAd->Mlme.RealRxPath = 1;
7721                         else
7722                                 pAd->Mlme.RealRxPath = 2;
7723                 }
7724
7725                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BBPR3);
7726                 BBPR3 &= (~0x18);
7727                 if(pAd->Mlme.RealRxPath == 3)
7728                 {
7729                         BBPR3 |= (0x10);
7730                 }
7731                 else if(pAd->Mlme.RealRxPath == 2)
7732                 {
7733                         BBPR3 |= (0x8);
7734                 }
7735                 else if(pAd->Mlme.RealRxPath == 1)
7736                 {
7737                         BBPR3 |= (0x0);
7738                 }
7739                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BBPR3);
7740         }
7741
7742 #endif // CONFIG_STA_SUPPORT //
7743
7744 }
7745
7746
7747
7748 VOID APSDPeriodicExec(
7749         IN PVOID SystemSpecific1,
7750         IN PVOID FunctionContext,
7751         IN PVOID SystemSpecific2,
7752         IN PVOID SystemSpecific3)
7753 {
7754         RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)FunctionContext;
7755
7756         if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
7757                 return;
7758
7759         pAd->CommonCfg.TriggerTimerCount++;
7760
7761 // Driver should not send trigger frame, it should be send by application layer
7762 /*
7763         if (pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable
7764                 && (pAd->CommonCfg.bNeedSendTriggerFrame ||
7765                 (((pAd->CommonCfg.TriggerTimerCount%20) == 19) && (!pAd->CommonCfg.bAPSDAC_BE || !pAd->CommonCfg.bAPSDAC_BK || !pAd->CommonCfg.bAPSDAC_VI || !pAd->CommonCfg.bAPSDAC_VO))))
7766         {
7767                 DBGPRINT(RT_DEBUG_TRACE,("Sending trigger frame and enter service period when support APSD\n"));
7768                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
7769                 pAd->CommonCfg.bNeedSendTriggerFrame = FALSE;
7770                 pAd->CommonCfg.TriggerTimerCount = 0;
7771                 pAd->CommonCfg.bInServicePeriod = TRUE;
7772         }*/
7773 }
7774
7775 /*
7776     ========================================================================
7777     Routine Description:
7778         Set/reset MAC registers according to bPiggyBack parameter
7779
7780     Arguments:
7781         pAd         - Adapter pointer
7782         bPiggyBack  - Enable / Disable Piggy-Back
7783
7784     Return Value:
7785         None
7786
7787     ========================================================================
7788 */
7789 VOID RTMPSetPiggyBack(
7790     IN PRTMP_ADAPTER    pAd,
7791     IN BOOLEAN          bPiggyBack)
7792 {
7793         TX_LINK_CFG_STRUC  TxLinkCfg;
7794
7795         RTMP_IO_READ32(pAd, TX_LINK_CFG, &TxLinkCfg.word);
7796
7797         TxLinkCfg.field.TxCFAckEn = bPiggyBack;
7798         RTMP_IO_WRITE32(pAd, TX_LINK_CFG, TxLinkCfg.word);
7799 }
7800
7801 /*
7802     ========================================================================
7803     Routine Description:
7804         check if this entry need to switch rate automatically
7805
7806     Arguments:
7807         pAd
7808         pEntry
7809
7810     Return Value:
7811         TURE
7812         FALSE
7813
7814     ========================================================================
7815 */
7816 BOOLEAN RTMPCheckEntryEnableAutoRateSwitch(
7817         IN PRTMP_ADAPTER    pAd,
7818         IN PMAC_TABLE_ENTRY     pEntry)
7819 {
7820         BOOLEAN         result = TRUE;
7821
7822
7823 #ifdef CONFIG_STA_SUPPORT
7824         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
7825         {
7826                 // only associated STA counts
7827                 if (pEntry && (pEntry->ValidAsCLI) && (pEntry->Sst == SST_ASSOC))
7828                 {
7829                         result = pAd->StaCfg.bAutoTxRateSwitch;
7830                 }
7831                 else
7832                         result = FALSE;
7833         }
7834 #endif // CONFIG_STA_SUPPORT //
7835
7836
7837
7838         return result;
7839 }
7840
7841
7842 BOOLEAN RTMPAutoRateSwitchCheck(
7843         IN PRTMP_ADAPTER    pAd)
7844 {
7845
7846 #ifdef CONFIG_STA_SUPPORT
7847         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
7848         {
7849                 if (pAd->StaCfg.bAutoTxRateSwitch)
7850                         return TRUE;
7851         }
7852 #endif // CONFIG_STA_SUPPORT //
7853         return FALSE;
7854 }
7855
7856
7857 /*
7858     ========================================================================
7859     Routine Description:
7860         check if this entry need to fix tx legacy rate
7861
7862     Arguments:
7863         pAd
7864         pEntry
7865
7866     Return Value:
7867         TURE
7868         FALSE
7869
7870     ========================================================================
7871 */
7872 UCHAR RTMPStaFixedTxMode(
7873         IN PRTMP_ADAPTER    pAd,
7874         IN PMAC_TABLE_ENTRY     pEntry)
7875 {
7876         UCHAR   tx_mode = FIXED_TXMODE_HT;
7877
7878
7879 #ifdef CONFIG_STA_SUPPORT
7880         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
7881         {
7882                 tx_mode = (UCHAR)pAd->StaCfg.DesiredTransmitSetting.field.FixedTxMode;
7883         }
7884 #endif // CONFIG_STA_SUPPORT //
7885
7886         return tx_mode;
7887 }
7888
7889 /*
7890     ========================================================================
7891     Routine Description:
7892         Overwrite HT Tx Mode by Fixed Legency Tx Mode, if specified.
7893
7894     Arguments:
7895         pAd
7896         pEntry
7897
7898     Return Value:
7899         TURE
7900         FALSE
7901
7902     ========================================================================
7903 */
7904 VOID RTMPUpdateLegacyTxSetting(
7905                 UCHAR                           fixed_tx_mode,
7906                 PMAC_TABLE_ENTRY        pEntry)
7907 {
7908         HTTRANSMIT_SETTING TransmitSetting;
7909
7910         if (fixed_tx_mode == FIXED_TXMODE_HT)
7911                 return;
7912
7913         TransmitSetting.word = 0;
7914
7915         TransmitSetting.field.MODE = pEntry->HTPhyMode.field.MODE;
7916         TransmitSetting.field.MCS = pEntry->HTPhyMode.field.MCS;
7917
7918         if (fixed_tx_mode == FIXED_TXMODE_CCK)
7919         {
7920                 TransmitSetting.field.MODE = MODE_CCK;
7921                 // CCK mode allow MCS 0~3
7922                 if (TransmitSetting.field.MCS > MCS_3)
7923                         TransmitSetting.field.MCS = MCS_3;
7924         }
7925         else
7926         {
7927                 TransmitSetting.field.MODE = MODE_OFDM;
7928                 // OFDM mode allow MCS 0~7
7929                 if (TransmitSetting.field.MCS > MCS_7)
7930                         TransmitSetting.field.MCS = MCS_7;
7931         }
7932
7933         if (pEntry->HTPhyMode.field.MODE >= TransmitSetting.field.MODE)
7934         {
7935                 pEntry->HTPhyMode.word = TransmitSetting.word;
7936                 DBGPRINT(RT_DEBUG_TRACE, ("RTMPUpdateLegacyTxSetting : wcid-%d, MODE=%s, MCS=%d \n",
7937                                 pEntry->Aid, GetPhyMode(pEntry->HTPhyMode.field.MODE), pEntry->HTPhyMode.field.MCS));
7938         }
7939 }
7940
7941 #ifdef CONFIG_STA_SUPPORT
7942 /*
7943         ==========================================================================
7944         Description:
7945                 dynamic tune BBP R66 to find a balance between sensibility and
7946                 noise isolation
7947
7948         IRQL = DISPATCH_LEVEL
7949
7950         ==========================================================================
7951  */
7952 VOID AsicStaBbpTuning(
7953         IN PRTMP_ADAPTER pAd)
7954 {
7955         UCHAR   OrigR66Value = 0, R66;//, R66UpperBound = 0x30, R66LowerBound = 0x30;
7956         CHAR    Rssi;
7957
7958         // 2860C did not support Fase CCA, therefore can't tune
7959         if (pAd->MACVersion == 0x28600100)
7960                 return;
7961
7962         //
7963         // work as a STA
7964         //
7965         if (pAd->Mlme.CntlMachine.CurrState != CNTL_IDLE)  // no R66 tuning when SCANNING
7966                 return;
7967
7968         if ((pAd->OpMode == OPMODE_STA)
7969                 && (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
7970                         )
7971                 && !(OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
7972                 )
7973         {
7974                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R66, &OrigR66Value);
7975                 R66 = OrigR66Value;
7976
7977                 if (pAd->Antenna.field.RxPath > 1)
7978                         Rssi = (pAd->StaCfg.RssiSample.AvgRssi0 + pAd->StaCfg.RssiSample.AvgRssi1) >> 1;
7979                 else
7980                         Rssi = pAd->StaCfg.RssiSample.AvgRssi0;
7981
7982                 if (pAd->LatchRfRegs.Channel <= 14)
7983                 {       //BG band
7984 #ifdef RT2870
7985                         // RT3070 is a no LNA solution, it should have different control regarding to AGC gain control
7986                         // Otherwise, it will have some throughput side effect when low RSSI
7987                         if (IS_RT3070(pAd))
7988                         {
7989                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
7990                                 {
7991                                         R66 = 0x1C + 2*GET_LNA_GAIN(pAd) + 0x20;
7992                                         if (OrigR66Value != R66)
7993                                         {
7994                                                 RTUSBWriteBBPRegister(pAd, BBP_R66, R66);
7995                                         }
7996                                 }
7997                                 else
7998                                 {
7999                                         R66 = 0x1C + 2*GET_LNA_GAIN(pAd);
8000                                         if (OrigR66Value != R66)
8001                                         {
8002                                                 RTUSBWriteBBPRegister(pAd, BBP_R66, R66);
8003                                         }
8004                                 }
8005                         }
8006                         else
8007 #endif // RT2870 //
8008                         {
8009                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
8010                                 {
8011                                         R66 = (0x2E + GET_LNA_GAIN(pAd)) + 0x10;
8012                                         if (OrigR66Value != R66)
8013                                         {
8014                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8015                                         }
8016                                 }
8017                                 else
8018                                 {
8019                                         R66 = 0x2E + GET_LNA_GAIN(pAd);
8020                                         if (OrigR66Value != R66)
8021                                         {
8022                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8023                                         }
8024                                 }
8025                         }
8026                 }
8027                 else
8028                 {       //A band
8029                         if (pAd->CommonCfg.BBPCurrentBW == BW_20)
8030                         {
8031                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
8032                                 {
8033                                         R66 = 0x32 + (GET_LNA_GAIN(pAd)*5)/3 + 0x10;
8034                                         if (OrigR66Value != R66)
8035                                         {
8036                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8037                                         }
8038                                 }
8039                                 else
8040                                 {
8041                                         R66 = 0x32 + (GET_LNA_GAIN(pAd)*5)/3;
8042                                         if (OrigR66Value != R66)
8043                                         {
8044                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8045                                         }
8046                                 }
8047                         }
8048                         else
8049                         {
8050                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
8051                                 {
8052                                         R66 = 0x3A + (GET_LNA_GAIN(pAd)*5)/3 + 0x10;
8053                                         if (OrigR66Value != R66)
8054                                         {
8055                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8056                                         }
8057                                 }
8058                                 else
8059                                 {
8060                                         R66 = 0x3A + (GET_LNA_GAIN(pAd)*5)/3;
8061                                         if (OrigR66Value != R66)
8062                                         {
8063                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8064                                         }
8065                                 }
8066                         }
8067                 }
8068
8069
8070         }
8071 }
8072 #endif // CONFIG_STA_SUPPORT //
8073
8074 VOID RTMPSetAGCInitValue(
8075         IN PRTMP_ADAPTER        pAd,
8076         IN UCHAR                        BandWidth)
8077 {
8078         UCHAR   R66 = 0x30;
8079
8080         if (pAd->LatchRfRegs.Channel <= 14)
8081         {       // BG band
8082                 R66 = 0x2E + GET_LNA_GAIN(pAd);
8083                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8084         }
8085         else
8086         {       //A band
8087                 if (BandWidth == BW_20)
8088                 {
8089                         R66 = (UCHAR)(0x32 + (GET_LNA_GAIN(pAd)*5)/3);
8090                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8091                 }
8092 #ifdef DOT11_N_SUPPORT
8093                 else
8094                 {
8095                         R66 = (UCHAR)(0x3A + (GET_LNA_GAIN(pAd)*5)/3);
8096                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
8097                 }
8098 #endif // DOT11_N_SUPPORT //
8099         }
8100
8101 }
8102
8103 VOID AsicTurnOffRFClk(
8104         IN PRTMP_ADAPTER pAd,
8105         IN      UCHAR           Channel)
8106 {
8107
8108         // RF R2 bit 18 = 0
8109         UINT32                  R1 = 0, R2 = 0, R3 = 0;
8110         UCHAR                   index;
8111         RTMP_RF_REGS    *RFRegTable;
8112
8113         RFRegTable = RF2850RegTable;
8114
8115         switch (pAd->RfIcType)
8116         {
8117                 case RFIC_2820:
8118                 case RFIC_2850:
8119                 case RFIC_2720:
8120                 case RFIC_2750:
8121
8122                         for (index = 0; index < NUM_OF_2850_CHNL; index++)
8123                         {
8124                                 if (Channel == RFRegTable[index].Channel)
8125                                 {
8126                                         R1 = RFRegTable[index].R1 & 0xffffdfff;
8127                                         R2 = RFRegTable[index].R2 & 0xfffbffff;
8128                                         R3 = RFRegTable[index].R3 & 0xfff3ffff;
8129
8130                                         RTMP_RF_IO_WRITE32(pAd, R1);
8131                                         RTMP_RF_IO_WRITE32(pAd, R2);
8132
8133                                         // Program R1b13 to 1, R3/b18,19 to 0, R2b18 to 0.
8134                                         // Set RF R2 bit18=0, R3 bit[18:19]=0
8135                                         //if (pAd->StaCfg.bRadio == FALSE)
8136                                         if (1)
8137                                         {
8138                                                 RTMP_RF_IO_WRITE32(pAd, R3);
8139
8140                                                 DBGPRINT(RT_DEBUG_TRACE, ("AsicTurnOffRFClk#%d(RF=%d, ) , R2=0x%08x,  R3 = 0x%08x \n",
8141                                                         Channel, pAd->RfIcType, R2, R3));
8142                                         }
8143                                         else
8144                                                 DBGPRINT(RT_DEBUG_TRACE, ("AsicTurnOffRFClk#%d(RF=%d, ) , R2=0x%08x \n",
8145                                                         Channel, pAd->RfIcType, R2));
8146                                         break;
8147                                 }
8148                         }
8149                         break;
8150
8151                 default:
8152                         break;
8153         }
8154 }
8155
8156
8157 VOID AsicTurnOnRFClk(
8158         IN PRTMP_ADAPTER pAd,
8159         IN      UCHAR                   Channel)
8160 {
8161
8162         // RF R2 bit 18 = 0
8163         UINT32                  R1 = 0, R2 = 0, R3 = 0;
8164         UCHAR                   index;
8165         RTMP_RF_REGS    *RFRegTable;
8166
8167         RFRegTable = RF2850RegTable;
8168
8169         switch (pAd->RfIcType)
8170         {
8171                 case RFIC_2820:
8172                 case RFIC_2850:
8173                 case RFIC_2720:
8174                 case RFIC_2750:
8175
8176                         for (index = 0; index < NUM_OF_2850_CHNL; index++)
8177                         {
8178                                 if (Channel == RFRegTable[index].Channel)
8179                                 {
8180                                         R3 = pAd->LatchRfRegs.R3;
8181                                         R3 &= 0xfff3ffff;
8182                                         R3 |= 0x00080000;
8183                                         RTMP_RF_IO_WRITE32(pAd, R3);
8184
8185                                         R1 = RFRegTable[index].R1;
8186                                         RTMP_RF_IO_WRITE32(pAd, R1);
8187
8188                                         R2 = RFRegTable[index].R2;
8189                                         if (pAd->Antenna.field.TxPath == 1)
8190                                         {
8191                                                 R2 |= 0x4000;   // If TXpath is 1, bit 14 = 1;
8192                                         }
8193
8194                                         if (pAd->Antenna.field.RxPath == 2)
8195                                         {
8196                                                 R2 |= 0x40;     // write 1 to off Rxpath.
8197                                         }
8198                                         else if (pAd->Antenna.field.RxPath == 1)
8199                                         {
8200                                                 R2 |= 0x20040;  // write 1 to off RxPath
8201                                         }
8202                                         RTMP_RF_IO_WRITE32(pAd, R2);
8203
8204                                         break;
8205                                 }
8206                         }
8207                         break;
8208
8209                 default:
8210                         break;
8211         }
8212
8213         DBGPRINT(RT_DEBUG_TRACE, ("AsicTurnOnRFClk#%d(RF=%d, ) , R2=0x%08x\n",
8214                 Channel,
8215                 pAd->RfIcType,
8216                 R2));
8217 }
8218