drivers/staging/rt2860/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   WME_INFO_ELEM[]  = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01};
  47 UCHAR   WME_PARM_ELEM[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
  48 UCHAR   Ccx2QosInfo[] = {0x00, 0x40, 0x96, 0x04};
  49 UCHAR   RALINK_OUI[]  = {0x00, 0x0c, 0x43};
  50 UCHAR   BROADCOM_OUI[]  = {0x00, 0x90, 0x4c};
  51 UCHAR   WPS_OUI[] = {0x00, 0x50, 0xf2, 0x04};
  52 UCHAR   PRE_N_HT_OUI[]  = {0x00, 0x90, 0x4c};
  53
  54 UCHAR RateSwitchTable[] = {
  55 // 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)
  56     0x11, 0x00,  0,  0,  0,                                             // Initial used item after association
  57     0x00, 0x00,  0, 40, 101,
  58     0x01, 0x00,  1, 40, 50,
  59     0x02, 0x00,  2, 35, 45,
  60     0x03, 0x00,  3, 20, 45,
  61     0x04, 0x21,  0, 30, 50,
  62     0x05, 0x21,  1, 20, 50,
  63     0x06, 0x21,  2, 20, 50,
  64     0x07, 0x21,  3, 15, 50,
  65     0x08, 0x21,  4, 15, 30,
  66     0x09, 0x21,  5, 10, 25,
  67     0x0a, 0x21,  6,  8, 25,
  68     0x0b, 0x21,  7,  8, 25,
  69     0x0c, 0x20, 12,  15, 30,
  70     0x0d, 0x20, 13,  8, 20,
  71     0x0e, 0x20, 14,  8, 20,
  72     0x0f, 0x20, 15,  8, 25,
  73     0x10, 0x22, 15,  8, 25,
  74     0x11, 0x00,  0,  0,  0,
  75     0x12, 0x00,  0,  0,  0,
  76     0x13, 0x00,  0,  0,  0,
  77     0x14, 0x00,  0,  0,  0,
  78     0x15, 0x00,  0,  0,  0,
  79     0x16, 0x00,  0,  0,  0,
  80     0x17, 0x00,  0,  0,  0,
  81     0x18, 0x00,  0,  0,  0,
  82     0x19, 0x00,  0,  0,  0,
  83     0x1a, 0x00,  0,  0,  0,
  84     0x1b, 0x00,  0,  0,  0,
  85     0x1c, 0x00,  0,  0,  0,
  86     0x1d, 0x00,  0,  0,  0,
  87     0x1e, 0x00,  0,  0,  0,
  88     0x1f, 0x00,  0,  0,  0,
  89 };
  90
  91 UCHAR RateSwitchTable11B[] = {
  92 // 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)
  93     0x04, 0x03,  0,  0,  0,                                             // Initial used item after association
  94     0x00, 0x00,  0, 40, 101,
  95     0x01, 0x00,  1, 40, 50,
  96     0x02, 0x00,  2, 35, 45,
  97     0x03, 0x00,  3, 20, 45,
  98 };
  99
 100 UCHAR RateSwitchTable11BG[] = {
 101 // 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)
 102     0x0a, 0x00,  0,  0,  0,                                             // Initial used item after association
 103     0x00, 0x00,  0, 40, 101,
 104     0x01, 0x00,  1, 40, 50,
 105     0x02, 0x00,  2, 35, 45,
 106     0x03, 0x00,  3, 20, 45,
 107     0x04, 0x10,  2, 20, 35,
 108     0x05, 0x10,  3, 16, 35,
 109     0x06, 0x10,  4, 10, 25,
 110     0x07, 0x10,  5, 16, 25,
 111     0x08, 0x10,  6, 10, 25,
 112     0x09, 0x10,  7, 10, 13,
 113 };
 114
 115 UCHAR RateSwitchTable11G[] = {
 116 // 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)
 117     0x08, 0x00,  0,  0,  0,                                             // Initial used item after association
 118     0x00, 0x10,  0, 20, 101,
 119     0x01, 0x10,  1, 20, 35,
 120     0x02, 0x10,  2, 20, 35,
 121     0x03, 0x10,  3, 16, 35,
 122     0x04, 0x10,  4, 10, 25,
 123     0x05, 0x10,  5, 16, 25,
 124     0x06, 0x10,  6, 10, 25,
 125     0x07, 0x10,  7, 10, 13,
 126 };
 127
 128 UCHAR RateSwitchTable11N1S[] = {
 129 // 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)
 130     0x0c, 0x0a,  0,  0,  0,                                             // Initial used item after association
 131     0x00, 0x00,  0, 40, 101,
 132     0x01, 0x00,  1, 40, 50,
 133     0x02, 0x00,  2, 25, 45,
 134     0x03, 0x21,  0, 20, 35,
 135     0x04, 0x21,  1, 20, 35,
 136     0x05, 0x21,  2, 20, 35,
 137     0x06, 0x21,  3, 15, 35,
 138     0x07, 0x21,  4, 15, 30,
 139     0x08, 0x21,  5, 10, 25,
 140     0x09, 0x21,  6,  8, 14,
 141     0x0a, 0x21,  7,  8, 14,
 142     0x0b, 0x23,  7,  8, 14,
 143 };
 144
 145 UCHAR RateSwitchTable11N2S[] = {
 146 // 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)
 147     0x0e, 0x0c,  0,  0,  0,                                             // Initial used item after association
 148     0x00, 0x00,  0, 40, 101,
 149     0x01, 0x00,  1, 40, 50,
 150     0x02, 0x00,  2, 25, 45,
 151     0x03, 0x21,  0, 20, 35,
 152     0x04, 0x21,  1, 20, 35,
 153     0x05, 0x21,  2, 20, 35,
 154     0x06, 0x21,  3, 15, 35,
 155     0x07, 0x21,  4, 15, 30,
 156     0x08, 0x20, 11, 15, 30,
 157     0x09, 0x20, 12, 15, 30,
 158     0x0a, 0x20, 13,  8, 20,
 159     0x0b, 0x20, 14,  8, 20,
 160     0x0c, 0x20, 15,  8, 25,
 161     0x0d, 0x22, 15,  8, 15,
 162 };
 163
 164 UCHAR RateSwitchTable11N3S[] = {
 165 // 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)
 166     0x0b, 0x00,  0,  0,  0,     // 0x0a, 0x00,  0,  0,  0,      // Initial used item after association
 167     0x00, 0x21,  0, 30, 101,
 168     0x01, 0x21,  1, 20, 50,
 169     0x02, 0x21,  2, 20, 50,
 170     0x03, 0x21,  3, 15, 50,
 171     0x04, 0x21,  4, 15, 30,
 172     0x05, 0x20, 11, 15, 30,     // Required by System-Alan @ 20080812
 173     0x06, 0x20, 12, 15, 30,     // 0x05, 0x20, 12, 15, 30,
 174     0x07, 0x20, 13,  8, 20,     // 0x06, 0x20, 13,  8, 20,
 175     0x08, 0x20, 14,  8, 20,     // 0x07, 0x20, 14,  8, 20,
 176     0x09, 0x20, 15,  8, 25,     // 0x08, 0x20, 15,  8, 25,
 177     0x0a, 0x22, 15,  8, 25,     // 0x09, 0x22, 15,  8, 25,
 178 };
 179
 180 UCHAR RateSwitchTable11N2SForABand[] = {
 181 // 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)
 182     0x0b, 0x09,  0,  0,  0,                                             // Initial used item after association
 183     0x00, 0x21,  0, 30, 101,
 184     0x01, 0x21,  1, 20, 50,
 185     0x02, 0x21,  2, 20, 50,
 186     0x03, 0x21,  3, 15, 50,
 187     0x04, 0x21,  4, 15, 30,
 188     0x05, 0x21,  5, 15, 30,
 189     0x06, 0x20, 12,  15, 30,
 190     0x07, 0x20, 13,  8, 20,
 191     0x08, 0x20, 14,  8, 20,
 192     0x09, 0x20, 15,  8, 25,
 193     0x0a, 0x22, 15,  8, 25,
 194 };
 195
 196 UCHAR RateSwitchTable11N3SForABand[] = { // 3*3
 197 // 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)
 198     0x0b, 0x09,  0,  0,  0,                                             // Initial used item after association
 199     0x00, 0x21,  0, 30, 101,
 200     0x01, 0x21,  1, 20, 50,
 201     0x02, 0x21,  2, 20, 50,
 202     0x03, 0x21,  3, 15, 50,
 203     0x04, 0x21,  4, 15, 30,
 204     0x05, 0x21,  5, 15, 30,
 205     0x06, 0x20, 12,  15, 30,
 206     0x07, 0x20, 13,  8, 20,
 207     0x08, 0x20, 14,  8, 20,
 208     0x09, 0x20, 15,  8, 25,
 209     0x0a, 0x22, 15,  8, 25,
 210 };
 211
 212 UCHAR RateSwitchTable11BGN1S[] = {
 213 // 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)
 214     0x0c, 0x0a,  0,  0,  0,                                             // Initial used item after association
 215     0x00, 0x00,  0, 40, 101,
 216     0x01, 0x00,  1, 40, 50,
 217     0x02, 0x00,  2, 25, 45,
 218     0x03, 0x21,  0, 20, 35,
 219     0x04, 0x21,  1, 20, 35,
 220     0x05, 0x21,  2, 20, 35,
 221     0x06, 0x21,  3, 15, 35,
 222     0x07, 0x21,  4, 15, 30,
 223     0x08, 0x21,  5, 10, 25,
 224     0x09, 0x21,  6,  8, 14,
 225     0x0a, 0x21,  7,  8, 14,
 226     0x0b, 0x23,  7,  8, 14,
 227 };
 228
 229 UCHAR RateSwitchTable11BGN2S[] = {
 230 // 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)
 231     0x0e, 0x0c,  0,  0,  0,                                             // Initial used item after association
 232     0x00, 0x00,  0, 40, 101,
 233     0x01, 0x00,  1, 40, 50,
 234     0x02, 0x00,  2, 25, 45,
 235     0x03, 0x21,  0, 20, 35,
 236     0x04, 0x21,  1, 20, 35,
 237     0x05, 0x21,  2, 20, 35,
 238     0x06, 0x21,  3, 15, 35,
 239     0x07, 0x21,  4, 15, 30,
 240     0x08, 0x20, 11, 15, 30,
 241     0x09, 0x20, 12, 15, 30,
 242     0x0a, 0x20, 13,  8, 20,
 243     0x0b, 0x20, 14,  8, 20,
 244     0x0c, 0x20, 15,  8, 25,
 245     0x0d, 0x22, 15,  8, 15,
 246 };
 247
 248 UCHAR RateSwitchTable11BGN3S[] = { // 3*3
 249 // 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)
 250     0x0a, 0x00,  0,  0,  0,                                             // Initial used item after association
 251     0x00, 0x21,  0, 30,101,     //50
 252     0x01, 0x21,  1, 20, 50,
 253     0x02, 0x21,  2, 20, 50,
 254     0x03, 0x21,  3, 20, 50,
 255     0x04, 0x21,  4, 15, 50,
 256     0x05, 0x20, 20, 15, 30,
 257     0x06, 0x20, 21,  8, 20,
 258     0x07, 0x20, 22,  8, 20,
 259     0x08, 0x20, 23,  8, 25,
 260     0x09, 0x22, 23,  8, 25,
 261 };
 262
 263 UCHAR RateSwitchTable11BGN2SForABand[] = {
 264 // 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)
 265     0x0b, 0x09,  0,  0,  0,                                             // Initial used item after association
 266     0x00, 0x21,  0, 30,101,     //50
 267     0x01, 0x21,  1, 20, 50,
 268     0x02, 0x21,  2, 20, 50,
 269     0x03, 0x21,  3, 15, 50,
 270     0x04, 0x21,  4, 15, 30,
 271     0x05, 0x21,  5, 15, 30,
 272     0x06, 0x20, 12, 15, 30,
 273     0x07, 0x20, 13,  8, 20,
 274     0x08, 0x20, 14,  8, 20,
 275     0x09, 0x20, 15,  8, 25,
 276     0x0a, 0x22, 15,  8, 25,
 277 };
 278
 279 UCHAR RateSwitchTable11BGN3SForABand[] = { // 3*3
 280 // 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)
 281     0x0c, 0x09,  0,  0,  0,                                             // Initial used item after association
 282     0x00, 0x21,  0, 30,101,     //50
 283     0x01, 0x21,  1, 20, 50,
 284     0x02, 0x21,  2, 20, 50,
 285     0x03, 0x21,  3, 15, 50,
 286     0x04, 0x21,  4, 15, 30,
 287     0x05, 0x21,  5, 15, 30,
 288     0x06, 0x21, 12, 15, 30,
 289     0x07, 0x20, 20, 15, 30,
 290     0x08, 0x20, 21,  8, 20,
 291     0x09, 0x20, 22,  8, 20,
 292     0x0a, 0x20, 23,  8, 25,
 293     0x0b, 0x22, 23,  8, 25,
 294 };
 295
 296
 297 extern UCHAR     OfdmRateToRxwiMCS[];
 298 // since RT61 has better RX sensibility, we have to limit TX ACK rate not to exceed our normal data TX rate.
 299 // otherwise the WLAN peer may not be able to receive the ACK thus downgrade its data TX rate
 300 ULONG BasicRateMask[12]                         = {0xfffff001 /* 1-Mbps */, 0xfffff003 /* 2 Mbps */, 0xfffff007 /* 5.5 */, 0xfffff00f /* 11 */,
 301                                                                           0xfffff01f /* 6 */     , 0xfffff03f /* 9 */     , 0xfffff07f /* 12 */ , 0xfffff0ff /* 18 */,
 302                                                                           0xfffff1ff /* 24 */    , 0xfffff3ff /* 36 */    , 0xfffff7ff /* 48 */ , 0xffffffff /* 54 */};
 303
 304 UCHAR BROADCAST_ADDR[MAC_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 305 UCHAR ZERO_MAC_ADDR[MAC_ADDR_LEN]  = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 306
 307 // e.g. RssiSafeLevelForTxRate[RATE_36]" means if the current RSSI is greater than
 308 //              this value, then it's quaranteed capable of operating in 36 mbps TX rate in
 309 //              clean environment.
 310 //                                                                TxRate: 1   2   5.5   11       6        9    12       18       24   36   48   54       72  100
 311 CHAR RssiSafeLevelForTxRate[] ={  -92, -91, -90, -87, -88, -86, -85, -83, -81, -78, -72, -71, -40, -40 };
 312
 313 UCHAR  RateIdToMbps[]    = { 1, 2, 5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 72, 100};
 314 USHORT RateIdTo500Kbps[] = { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108, 144, 200};
 315
 316 UCHAR  SsidIe    = IE_SSID;
 317 UCHAR  SupRateIe = IE_SUPP_RATES;
 318 UCHAR  ExtRateIe = IE_EXT_SUPP_RATES;
 319 UCHAR  HtCapIe = IE_HT_CAP;
 320 UCHAR  AddHtInfoIe = IE_ADD_HT;
 321 UCHAR  NewExtChanIe = IE_SECONDARY_CH_OFFSET;
 322 UCHAR  ErpIe     = IE_ERP;
 323 UCHAR  DsIe      = IE_DS_PARM;
 324 UCHAR  TimIe     = IE_TIM;
 325 UCHAR  WpaIe     = IE_WPA;
 326 UCHAR  Wpa2Ie    = IE_WPA2;
 327 UCHAR  IbssIe    = IE_IBSS_PARM;
 328
 329 extern UCHAR    WPA_OUI[];
 330
 331 UCHAR   SES_OUI[] = {0x00, 0x90, 0x4c};
 332
 333 UCHAR   ZeroSsid[32] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 334         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 335
 336
 337 /*
 338         ==========================================================================
 339         Description:
 340                 initialize the MLME task and its data structure (queue, spinlock,
 341                 timer, state machines).
 342
 343         IRQL = PASSIVE_LEVEL
 344
 345         Return:
 346                 always return NDIS_STATUS_SUCCESS
 347
 348         ==========================================================================
 349 */
 350 NDIS_STATUS MlmeInit(
 351         IN PRTMP_ADAPTER pAd)
 352 {
 353         NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
 354
 355         DBGPRINT(RT_DEBUG_TRACE, ("--> MLME Initialize\n"));
 356
 357         do
 358         {
 359                 Status = MlmeQueueInit(&pAd->Mlme.Queue);
 360                 if(Status != NDIS_STATUS_SUCCESS)
 361                         break;
 362
 363                 pAd->Mlme.bRunning = FALSE;
 364                 NdisAllocateSpinLock(&pAd->Mlme.TaskLock);
 365
 366                 {
 367                         BssTableInit(&pAd->ScanTab);
 368
 369                         // init STA state machines
 370                         AssocStateMachineInit(pAd, &pAd->Mlme.AssocMachine, pAd->Mlme.AssocFunc);
 371                         AuthStateMachineInit(pAd, &pAd->Mlme.AuthMachine, pAd->Mlme.AuthFunc);
 372                         AuthRspStateMachineInit(pAd, &pAd->Mlme.AuthRspMachine, pAd->Mlme.AuthRspFunc);
 373                         SyncStateMachineInit(pAd, &pAd->Mlme.SyncMachine, pAd->Mlme.SyncFunc);
 374
 375
 376
 377
 378                         // Since we are using switch/case to implement it, the init is different from the above
 379                         // state machine init
 380                         MlmeCntlInit(pAd, &pAd->Mlme.CntlMachine, NULL);
 381                 }
 382
 383
 384                 WpaStateMachineInit(pAd, &pAd->Mlme.WpaMachine, pAd->Mlme.WpaFunc);
 385
 386
 387                 ActionStateMachineInit(pAd, &pAd->Mlme.ActMachine, pAd->Mlme.ActFunc);
 388
 389                 // Init mlme periodic timer
 390                 RTMPInitTimer(pAd, &pAd->Mlme.PeriodicTimer, GET_TIMER_FUNCTION(MlmePeriodicExec), pAd, TRUE);
 391
 392                 // Set mlme periodic timer
 393                 RTMPSetTimer(&pAd->Mlme.PeriodicTimer, MLME_TASK_EXEC_INTV);
 394
 395                 // software-based RX Antenna diversity
 396                 RTMPInitTimer(pAd, &pAd->Mlme.RxAntEvalTimer, GET_TIMER_FUNCTION(AsicRxAntEvalTimeout), pAd, FALSE);
 397
 398                 {
 399 #ifdef RTMP_PCI_SUPPORT
 400                 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_PCIE_DEVICE))
 401                 {
 402                     // only PCIe cards need these two timers
 403                         RTMPInitTimer(pAd, &pAd->Mlme.PsPollTimer, GET_TIMER_FUNCTION(PsPollWakeExec), pAd, FALSE);
 404                         RTMPInitTimer(pAd, &pAd->Mlme.RadioOnOffTimer, GET_TIMER_FUNCTION(RadioOnExec), pAd, FALSE);
 405                 }
 406 #endif // RTMP_PCI_SUPPORT //
 407
 408                         RTMPInitTimer(pAd, &pAd->Mlme.LinkDownTimer, GET_TIMER_FUNCTION(LinkDownExec), pAd, FALSE);
 409
 410 #ifdef RTMP_MAC_USB
 411                         RTMPInitTimer(pAd, &pAd->Mlme.AutoWakeupTimer, GET_TIMER_FUNCTION(RtmpUsbStaAsicForceWakeupTimeout), pAd, FALSE);
 412                         pAd->Mlme.AutoWakeupTimerRunning = FALSE;
 413 #endif // RTMP_MAC_USB //
 414                 }
 415
 416         } while (FALSE);
 417
 418         DBGPRINT(RT_DEBUG_TRACE, ("<-- MLME Initialize\n"));
 419
 420         return Status;
 421 }
 422
 423 /*
 424         ==========================================================================
 425         Description:
 426                 main loop of the MLME
 427         Pre:
 428                 Mlme has to be initialized, and there are something inside the queue
 429         Note:
 430                 This function is invoked from MPSetInformation and MPReceive;
 431                 This task guarantee only one MlmeHandler will run.
 432
 433         IRQL = DISPATCH_LEVEL
 434
 435         ==========================================================================
 436  */
 437 VOID MlmeHandler(
 438         IN PRTMP_ADAPTER pAd)
 439 {
 440         MLME_QUEUE_ELEM            *Elem = NULL;
 441
 442         // Only accept MLME and Frame from peer side, no other (control/data) frame should
 443         // get into this state machine
 444
 445         NdisAcquireSpinLock(&pAd->Mlme.TaskLock);
 446         if(pAd->Mlme.bRunning)
 447         {
 448                 NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
 449                 return;
 450         }
 451         else
 452         {
 453                 pAd->Mlme.bRunning = TRUE;
 454         }
 455         NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
 456
 457         while (!MlmeQueueEmpty(&pAd->Mlme.Queue))
 458         {
 459                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_MLME_RESET_IN_PROGRESS) ||
 460                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS) ||
 461                         RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
 462                 {
 463                         DBGPRINT(RT_DEBUG_TRACE, ("Device Halted or Removed or MlmeRest, exit MlmeHandler! (queue num = %ld)\n", pAd->Mlme.Queue.Num));
 464                         break;
 465                 }
 466
 467                 //From message type, determine which state machine I should drive
 468                 if (MlmeDequeue(&pAd->Mlme.Queue, &Elem))
 469                 {
 470 #ifdef RTMP_MAC_USB
 471                         if (Elem->MsgType == MT2_RESET_CONF)
 472                         {
 473                                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("!!! reset MLME state machine !!!\n"));
 474                                 MlmeRestartStateMachine(pAd);
 475                                 Elem->Occupied = FALSE;
 476                                 Elem->MsgLen = 0;
 477                                 continue;
 478                         }
 479 #endif // RTMP_MAC_USB //
 480
 481                         // if dequeue success
 482                         switch (Elem->Machine)
 483                         {
 484                                 // STA state machines
 485                                 case ASSOC_STATE_MACHINE:
 486                                         StateMachinePerformAction(pAd, &pAd->Mlme.AssocMachine, Elem);
 487                                         break;
 488                                 case AUTH_STATE_MACHINE:
 489                                         StateMachinePerformAction(pAd, &pAd->Mlme.AuthMachine, Elem);
 490                                         break;
 491                                 case AUTH_RSP_STATE_MACHINE:
 492                                         StateMachinePerformAction(pAd, &pAd->Mlme.AuthRspMachine, Elem);
 493                                         break;
 494                                 case SYNC_STATE_MACHINE:
 495                                         StateMachinePerformAction(pAd, &pAd->Mlme.SyncMachine, Elem);
 496                                         break;
 497                                 case MLME_CNTL_STATE_MACHINE:
 498                                         MlmeCntlMachinePerformAction(pAd, &pAd->Mlme.CntlMachine, Elem);
 499                                         break;
 500                                 case WPA_PSK_STATE_MACHINE:
 501                                         StateMachinePerformAction(pAd, &pAd->Mlme.WpaPskMachine, Elem);
 502                                         break;
 503
 504
 505
 506                                 case ACTION_STATE_MACHINE:
 507                                         StateMachinePerformAction(pAd, &pAd->Mlme.ActMachine, Elem);
 508                                         break;
 509
 510                                 case WPA_STATE_MACHINE:
 511                                         StateMachinePerformAction(pAd, &pAd->Mlme.WpaMachine, Elem);
 512                                         break;
 513
 514
 515                                 default:
 516                                         DBGPRINT(RT_DEBUG_TRACE, ("ERROR: Illegal machine %ld in MlmeHandler()\n", Elem->Machine));
 517                                         break;
 518                         } // end of switch
 519
 520                         // free MLME element
 521                         Elem->Occupied = FALSE;
 522                         Elem->MsgLen = 0;
 523
 524                 }
 525                 else {
 526                         DBGPRINT_ERR(("MlmeHandler: MlmeQueue empty\n"));
 527                 }
 528         }
 529
 530         NdisAcquireSpinLock(&pAd->Mlme.TaskLock);
 531         pAd->Mlme.bRunning = FALSE;
 532         NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
 533 }
 534
 535 /*
 536         ==========================================================================
 537         Description:
 538                 Destructor of MLME (Destroy queue, state machine, spin lock and timer)
 539         Parameters:
 540                 Adapter - NIC Adapter pointer
 541         Post:
 542                 The MLME task will no longer work properly
 543
 544         IRQL = PASSIVE_LEVEL
 545
 546         ==========================================================================
 547  */
 548 VOID MlmeHalt(
 549         IN PRTMP_ADAPTER pAd)
 550 {
 551         BOOLEAN           Cancelled;
 552
 553         DBGPRINT(RT_DEBUG_TRACE, ("==> MlmeHalt\n"));
 554
 555         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
 556         {
 557                 // disable BEACON generation and other BEACON related hardware timers
 558                 AsicDisableSync(pAd);
 559         }
 560
 561         {
 562                 // Cancel pending timers
 563                 RTMPCancelTimer(&pAd->MlmeAux.AssocTimer,               &Cancelled);
 564                 RTMPCancelTimer(&pAd->MlmeAux.ReassocTimer,             &Cancelled);
 565                 RTMPCancelTimer(&pAd->MlmeAux.DisassocTimer,    &Cancelled);
 566                 RTMPCancelTimer(&pAd->MlmeAux.AuthTimer,                &Cancelled);
 567                 RTMPCancelTimer(&pAd->MlmeAux.BeaconTimer,              &Cancelled);
 568                 RTMPCancelTimer(&pAd->MlmeAux.ScanTimer,                &Cancelled);
 569
 570
 571 #ifdef RTMP_MAC_PCI
 572             if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_PCIE_DEVICE)
 573                         &&(pAd->StaCfg.PSControl.field.EnableNewPS == TRUE))
 574             {
 575                     RTMPCancelTimer(&pAd->Mlme.PsPollTimer,             &Cancelled);
 576                     RTMPCancelTimer(&pAd->Mlme.RadioOnOffTimer,         &Cancelled);
 577                 }
 578 #endif // RTMP_MAC_PCI //
 579
 580                 RTMPCancelTimer(&pAd->Mlme.LinkDownTimer,               &Cancelled);
 581
 582 #ifdef RTMP_MAC_USB
 583                 RTMPCancelTimer(&pAd->Mlme.AutoWakeupTimer, &Cancelled);
 584 #endif // RTMP_MAC_USB //
 585         }
 586
 587         RTMPCancelTimer(&pAd->Mlme.PeriodicTimer,               &Cancelled);
 588         RTMPCancelTimer(&pAd->Mlme.RxAntEvalTimer,              &Cancelled);
 589
 590
 591
 592         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
 593         {
 594                 RTMP_CHIP_OP *pChipOps = &pAd->chipOps;
 595
 596                 // Set LED
 597                 RTMPSetLED(pAd, LED_HALT);
 598         RTMPSetSignalLED(pAd, -100);    // Force signal strength Led to be turned off, firmware is not done it.
 599 #ifdef RTMP_MAC_USB
 600         {
 601             LED_CFG_STRUC LedCfg;
 602             RTMP_IO_READ32(pAd, LED_CFG, &LedCfg.word);
 603             LedCfg.field.LedPolar = 0;
 604             LedCfg.field.RLedMode = 0;
 605             LedCfg.field.GLedMode = 0;
 606             LedCfg.field.YLedMode = 0;
 607             RTMP_IO_WRITE32(pAd, LED_CFG, LedCfg.word);
 608         }
 609 #endif // RTMP_MAC_USB //
 610
 611                 if (pChipOps->AsicHaltAction)
 612                         pChipOps->AsicHaltAction(pAd);
 613         }
 614
 615         RTMPusecDelay(5000);    //  5 msec to gurantee Ant Diversity timer canceled
 616
 617         MlmeQueueDestroy(&pAd->Mlme.Queue);
 618         NdisFreeSpinLock(&pAd->Mlme.TaskLock);
 619
 620         DBGPRINT(RT_DEBUG_TRACE, ("<== MlmeHalt\n"));
 621 }
 622
 623 VOID MlmeResetRalinkCounters(
 624         IN  PRTMP_ADAPTER   pAd)
 625 {
 626         pAd->RalinkCounters.LastOneSecRxOkDataCnt = pAd->RalinkCounters.OneSecRxOkDataCnt;
 627         // clear all OneSecxxx counters.
 628         pAd->RalinkCounters.OneSecBeaconSentCnt = 0;
 629         pAd->RalinkCounters.OneSecFalseCCACnt = 0;
 630         pAd->RalinkCounters.OneSecRxFcsErrCnt = 0;
 631         pAd->RalinkCounters.OneSecRxOkCnt = 0;
 632         pAd->RalinkCounters.OneSecTxFailCount = 0;
 633         pAd->RalinkCounters.OneSecTxNoRetryOkCount = 0;
 634         pAd->RalinkCounters.OneSecTxRetryOkCount = 0;
 635         pAd->RalinkCounters.OneSecRxOkDataCnt = 0;
 636         pAd->RalinkCounters.OneSecReceivedByteCount = 0;
 637         pAd->RalinkCounters.OneSecTransmittedByteCount = 0;
 638
 639         // TODO: for debug only. to be removed
 640         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_BE] = 0;
 641         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_BK] = 0;
 642         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_VI] = 0;
 643         pAd->RalinkCounters.OneSecOsTxCount[QID_AC_VO] = 0;
 644         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_BE] = 0;
 645         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_BK] = 0;
 646         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_VI] = 0;
 647         pAd->RalinkCounters.OneSecDmaDoneCount[QID_AC_VO] = 0;
 648         pAd->RalinkCounters.OneSecTxDoneCount = 0;
 649         pAd->RalinkCounters.OneSecRxCount = 0;
 650         pAd->RalinkCounters.OneSecTxAggregationCount = 0;
 651         pAd->RalinkCounters.OneSecRxAggregationCount = 0;
 652
 653         return;
 654 }
 655
 656
 657 /*
 658         ==========================================================================
 659         Description:
 660                 This routine is executed periodically to -
 661                 1. Decide if it's a right time to turn on PwrMgmt bit of all
 662                    outgoiing frames
 663                 2. Calculate ChannelQuality based on statistics of the last
 664                    period, so that TX rate won't toggling very frequently between a
 665                    successful TX and a failed TX.
 666                 3. If the calculated ChannelQuality indicated current connection not
 667                    healthy, then a ROAMing attempt is tried here.
 668
 669         IRQL = DISPATCH_LEVEL
 670
 671         ==========================================================================
 672  */
 673 #define ADHOC_BEACON_LOST_TIME          (8*OS_HZ)  // 8 sec
 674 VOID MlmePeriodicExec(
 675         IN PVOID SystemSpecific1,
 676         IN PVOID FunctionContext,
 677         IN PVOID SystemSpecific2,
 678         IN PVOID SystemSpecific3)
 679 {
 680         ULONG                   TxTotalCnt;
 681         PRTMP_ADAPTER   pAd = (RTMP_ADAPTER *)FunctionContext;
 682
 683 #ifdef RTMP_MAC_PCI
 684         {
 685             // If Hardware controlled Radio enabled, we have to check GPIO pin2 every 2 second.
 686                 // Move code to here, because following code will return when radio is off
 687                 if ((pAd->Mlme.PeriodicRound % (MLME_TASK_EXEC_MULTIPLE * 2) == 0) && (pAd->StaCfg.bHardwareRadio == TRUE) &&
 688                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)) &&
 689                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))
 690                         /*&&(pAd->bPCIclkOff == FALSE)*/)
 691                 {
 692                         UINT32                          data = 0;
 693
 694                         // Read GPIO pin2 as Hardware controlled radio state
 695 #ifndef RT3090
 696                         RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &data);
 697 #endif // RT3090 //
 698 //KH(PCIE PS):Added based on Jane<--
 699 #ifdef RT3090
 700 // Read GPIO pin2 as Hardware controlled radio state
 701 // We need to Read GPIO if HW said so no mater what advance power saving
 702 if ((pAd->OpMode == OPMODE_STA) && (IDLE_ON(pAd))
 703         && (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF))
 704         && (pAd->StaCfg.PSControl.field.EnablePSinIdle == TRUE))
 705         {
 706         // Want to make sure device goes to L0 state before reading register.
 707         RTMPPCIeLinkCtrlValueRestore(pAd, 0);
 708         RTMP_IO_FORCE_READ32(pAd, GPIO_CTRL_CFG, &data);
 709         RTMPPCIeLinkCtrlSetting(pAd, 3);
 710         }
 711 else
 712         RTMP_IO_FORCE_READ32(pAd, GPIO_CTRL_CFG, &data);
 713 #endif // RT3090 //
 714 //KH(PCIE PS):Added based on Jane-->
 715
 716                         if (data & 0x04)
 717                         {
 718                                 pAd->StaCfg.bHwRadio = TRUE;
 719                         }
 720                         else
 721                         {
 722                                 pAd->StaCfg.bHwRadio = FALSE;
 723                         }
 724                         if (pAd->StaCfg.bRadio != (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio))
 725                         {
 726                                 pAd->StaCfg.bRadio = (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio);
 727                                 if (pAd->StaCfg.bRadio == TRUE)
 728                                 {
 729                                         MlmeRadioOn(pAd);
 730                                         // Update extra information
 731                                         pAd->ExtraInfo = EXTRA_INFO_CLEAR;
 732                                 }
 733                                 else
 734                                 {
 735                                         MlmeRadioOff(pAd);
 736                                         // Update extra information
 737                                         pAd->ExtraInfo = HW_RADIO_OFF;
 738                                 }
 739                         }
 740                 }
 741         }
 742 #endif // RTMP_MAC_PCI //
 743
 744         // Do nothing if the driver is starting halt state.
 745         // This might happen when timer already been fired before cancel timer with mlmehalt
 746         if ((RTMP_TEST_FLAG(pAd, (fRTMP_ADAPTER_HALT_IN_PROGRESS |
 747                                                                 fRTMP_ADAPTER_RADIO_OFF |
 748                                                                 fRTMP_ADAPTER_RADIO_MEASUREMENT |
 749                                                                 fRTMP_ADAPTER_RESET_IN_PROGRESS))))
 750                 return;
 751
 752         RTMP_MLME_PRE_SANITY_CHECK(pAd);
 753
 754         {
 755                 // Do nothing if monitor mode is on
 756                 if (MONITOR_ON(pAd))
 757                         return;
 758
 759                 if (pAd->Mlme.PeriodicRound & 0x1)
 760                 {
 761                         // This is the fix for wifi 11n extension channel overlapping test case.  for 2860D
 762                         if (((pAd->MACVersion & 0xffff) == 0x0101) &&
 763                                 (STA_TGN_WIFI_ON(pAd)) &&
 764                                 (pAd->CommonCfg.IOTestParm.bToggle == FALSE))
 765
 766                                 {
 767                                         RTMP_IO_WRITE32(pAd, TXOP_CTRL_CFG, 0x24Bf);
 768                                         pAd->CommonCfg.IOTestParm.bToggle = TRUE;
 769                                 }
 770                                 else if ((STA_TGN_WIFI_ON(pAd)) &&
 771                                                 ((pAd->MACVersion & 0xffff) == 0x0101))
 772                                 {
 773                                         RTMP_IO_WRITE32(pAd, TXOP_CTRL_CFG, 0x243f);
 774                                         pAd->CommonCfg.IOTestParm.bToggle = FALSE;
 775                                 }
 776                 }
 777         }
 778
 779         pAd->bUpdateBcnCntDone = FALSE;
 780
 781 //      RECBATimerTimeout(SystemSpecific1,FunctionContext,SystemSpecific2,SystemSpecific3);
 782         pAd->Mlme.PeriodicRound ++;
 783
 784 #ifdef RTMP_MAC_USB
 785         // execute every 100ms, update the Tx FIFO Cnt for update Tx Rate.
 786         NICUpdateFifoStaCounters(pAd);
 787 #endif // RTMP_MAC_USB //
 788
 789         // execute every 500ms
 790         if ((pAd->Mlme.PeriodicRound % 5 == 0) && RTMPAutoRateSwitchCheck(pAd)/*(OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED))*/)
 791         {
 792                 // perform dynamic tx rate switching based on past TX history
 793                 {
 794                         if ((OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
 795                                         )
 796                                 && (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)))
 797                                 MlmeDynamicTxRateSwitching(pAd);
 798                 }
 799         }
 800
 801         // Normal 1 second Mlme PeriodicExec.
 802         if (pAd->Mlme.PeriodicRound %MLME_TASK_EXEC_MULTIPLE == 0)
 803         {
 804                 pAd->Mlme.OneSecPeriodicRound ++;
 805
 806
 807
 808
 809                 //ORIBATimerTimeout(pAd);
 810
 811                 // Media status changed, report to NDIS
 812                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_MEDIA_STATE_CHANGE))
 813                 {
 814                         RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_MEDIA_STATE_CHANGE);
 815                         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
 816                         {
 817                                 pAd->IndicateMediaState = NdisMediaStateConnected;
 818                                 RTMP_IndicateMediaState(pAd);
 819
 820                         }
 821                         else
 822                         {
 823                                 pAd->IndicateMediaState = NdisMediaStateDisconnected;
 824                                 RTMP_IndicateMediaState(pAd);
 825                         }
 826                 }
 827
 828                 NdisGetSystemUpTime(&pAd->Mlme.Now32);
 829
 830                 // add the most up-to-date h/w raw counters into software variable, so that
 831                 // the dynamic tuning mechanism below are based on most up-to-date information
 832                 NICUpdateRawCounters(pAd);
 833
 834 #ifdef RTMP_MAC_USB
 835                 RTUSBWatchDog(pAd);
 836 #endif // RTMP_MAC_USB //
 837
 838                 // Need statistics after read counter. So put after NICUpdateRawCounters
 839                 ORIBATimerTimeout(pAd);
 840
 841                 // if MGMT RING is full more than twice within 1 second, we consider there's
 842                 // a hardware problem stucking the TX path. In this case, try a hardware reset
 843                 // to recover the system
 844         //      if (pAd->RalinkCounters.MgmtRingFullCount >= 2)
 845         //              RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HARDWARE_ERROR);
 846         //      else
 847         //              pAd->RalinkCounters.MgmtRingFullCount = 0;
 848
 849                 // The time period for checking antenna is according to traffic
 850                 {
 851                 if (pAd->Mlme.bEnableAutoAntennaCheck)
 852                 {
 853                         TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
 854                                                          pAd->RalinkCounters.OneSecTxRetryOkCount +
 855                                                          pAd->RalinkCounters.OneSecTxFailCount;
 856
 857                         // dynamic adjust antenna evaluation period according to the traffic
 858                         if (TxTotalCnt > 50)
 859                         {
 860                                 if (pAd->Mlme.OneSecPeriodicRound % 10 == 0)
 861                                 {
 862                                         AsicEvaluateRxAnt(pAd);
 863                                 }
 864                         }
 865                         else
 866                         {
 867                                 if (pAd->Mlme.OneSecPeriodicRound % 3 == 0)
 868                                 {
 869                                         AsicEvaluateRxAnt(pAd);
 870                                 }
 871                         }
 872                 }
 873                 }
 874
 875                 STAMlmePeriodicExec(pAd);
 876
 877                 MlmeResetRalinkCounters(pAd);
 878
 879                 {
 880 #ifdef RTMP_MAC_PCI
 881                         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST) && (pAd->bPCIclkOff == FALSE))
 882 #endif // RTMP_MAC_PCI //
 883                         {
 884                                 // When Adhoc beacon is enabled and RTS/CTS is enabled, there is a chance that hardware MAC FSM will run into a deadlock
 885                                 // and sending CTS-to-self over and over.
 886                                 // Software Patch Solution:
 887                                 // 1. Polling debug state register 0x10F4 every one second.
 888                                 // 2. If in 0x10F4 the ((bit29==1) && (bit7==1)) OR ((bit29==1) && (bit5==1)), it means the deadlock has occurred.
 889                                 // 3. If the deadlock occurred, reset MAC/BBP by setting 0x1004 to 0x0001 for a while then setting it back to 0x000C again.
 890
 891                                 UINT32  MacReg = 0;
 892
 893                                 RTMP_IO_READ32(pAd, 0x10F4, &MacReg);
 894                                 if (((MacReg & 0x20000000) && (MacReg & 0x80)) || ((MacReg & 0x20000000) && (MacReg & 0x20)))
 895                                 {
 896                                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x1);
 897                                         RTMPusecDelay(1);
 898                                         RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0xC);
 899
 900                                         DBGPRINT(RT_DEBUG_WARN,("Warning, MAC specific condition occurs \n"));
 901                                 }
 902                         }
 903                 }
 904
 905                 RTMP_MLME_HANDLER(pAd);
 906         }
 907
 908
 909         pAd->bUpdateBcnCntDone = FALSE;
 910 }
 911
 912
 913 /*
 914         ==========================================================================
 915         Validate SSID for connection try and rescan purpose
 916         Valid SSID will have visible chars only.
 917         The valid length is from 0 to 32.
 918         IRQL = DISPATCH_LEVEL
 919         ==========================================================================
 920  */
 921 BOOLEAN MlmeValidateSSID(
 922         IN PUCHAR       pSsid,
 923         IN UCHAR        SsidLen)
 924 {
 925         int     index;
 926
 927         if (SsidLen > MAX_LEN_OF_SSID)
 928                 return (FALSE);
 929
 930         // Check each character value
 931         for (index = 0; index < SsidLen; index++)
 932     {
 933                 if (pSsid[index] < 0x20)
 934                         return (FALSE);
 935     }
 936
 937         // All checked
 938         return (TRUE);
 939 }
 940
 941 VOID MlmeSelectTxRateTable(
 942         IN PRTMP_ADAPTER                pAd,
 943         IN PMAC_TABLE_ENTRY             pEntry,
 944         IN PUCHAR                               *ppTable,
 945         IN PUCHAR                               pTableSize,
 946         IN PUCHAR                               pInitTxRateIdx)
 947 {
 948         do
 949         {
 950                 // decide the rate table for tuning
 951                 if (pAd->CommonCfg.TxRateTableSize > 0)
 952         {
 953                         *ppTable = RateSwitchTable;
 954                         *pTableSize = RateSwitchTable[0];
 955                         *pInitTxRateIdx = RateSwitchTable[1];
 956
 957                         break;
 958         }
 959
 960                 if ((pAd->OpMode == OPMODE_STA) && ADHOC_ON(pAd))
 961         {
 962                         if ((pAd->CommonCfg.PhyMode >= PHY_11ABGN_MIXED) &&
 963                                 (pEntry->HTCapability.MCSSet[0] == 0xff) &&
 964                                 ((pEntry->HTCapability.MCSSet[1] == 0x00) || (pAd->Antenna.field.TxPath == 1)))
 965                         {// 11N 1S Adhoc
 966                                 *ppTable = RateSwitchTable11N1S;
 967                                 *pTableSize = RateSwitchTable11N1S[0];
 968                                 *pInitTxRateIdx = RateSwitchTable11N1S[1];
 969
 970                         }
 971                         else if ((pAd->CommonCfg.PhyMode >= PHY_11ABGN_MIXED) &&
 972                                         (pEntry->HTCapability.MCSSet[0] == 0xff) &&
 973                                         (pEntry->HTCapability.MCSSet[1] == 0xff) &&
 974                                         (pAd->Antenna.field.TxPath == 2))
 975                         {// 11N 2S Adhoc
 976                                 if (pAd->LatchRfRegs.Channel <= 14)
 977                 {
 978                                         *ppTable = RateSwitchTable11N2S;
 979                                         *pTableSize = RateSwitchTable11N2S[0];
 980                                         *pInitTxRateIdx = RateSwitchTable11N2S[1];
 981                 }
 982                                 else
 983                                 {
 984                                         *ppTable = RateSwitchTable11N2SForABand;
 985                                         *pTableSize = RateSwitchTable11N2SForABand[0];
 986                                         *pInitTxRateIdx = RateSwitchTable11N2SForABand[1];
 987         }
 988
 989         }
 990                         else
 991                                 if ((pEntry->RateLen == 4)
 992                                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
 993                                         )
 994                         {
 995                                 *ppTable = RateSwitchTable11B;
 996                                 *pTableSize = RateSwitchTable11B[0];
 997                                 *pInitTxRateIdx = RateSwitchTable11B[1];
 998
 999                         }
1000                         else if (pAd->LatchRfRegs.Channel <= 14)
1001                         {
1002                                 *ppTable = RateSwitchTable11BG;
1003                                 *pTableSize = RateSwitchTable11BG[0];
1004                                 *pInitTxRateIdx = RateSwitchTable11BG[1];
1005
1006                         }
1007                         else
1008                         {
1009                                 *ppTable = RateSwitchTable11G;
1010                                 *pTableSize = RateSwitchTable11G[0];
1011                                 *pInitTxRateIdx = RateSwitchTable11G[1];
1012
1013                         }
1014                         break;
1015                 }
1016
1017                 //if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen == 12) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) &&
1018                 //      ((pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0x00) || (pAd->Antenna.field.TxPath == 1)))
1019                 if (((pEntry->RateLen == 12) || (pAd->OpMode == OPMODE_STA)) && (pEntry->HTCapability.MCSSet[0] == 0xff) &&
1020                         ((pEntry->HTCapability.MCSSet[1] == 0x00) || (pAd->CommonCfg.TxStream == 1)))
1021                 {// 11BGN 1S AP
1022                         *ppTable = RateSwitchTable11BGN1S;
1023                         *pTableSize = RateSwitchTable11BGN1S[0];
1024                         *pInitTxRateIdx = RateSwitchTable11BGN1S[1];
1025
1026                         break;
1027         }
1028
1029                 //else if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen == 12) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) &&
1030                 //      (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0xff) && (pAd->Antenna.field.TxPath == 2))
1031                 if (((pEntry->RateLen == 12) || (pAd->OpMode == OPMODE_STA)) && (pEntry->HTCapability.MCSSet[0] == 0xff) &&
1032                         (pEntry->HTCapability.MCSSet[1] == 0xff) && (pAd->CommonCfg.TxStream == 2))
1033                 {// 11BGN 2S AP
1034                         if (pAd->LatchRfRegs.Channel <= 14)
1035         {
1036                                 *ppTable = RateSwitchTable11BGN2S;
1037                                 *pTableSize = RateSwitchTable11BGN2S[0];
1038                                 *pInitTxRateIdx = RateSwitchTable11BGN2S[1];
1039
1040                         }
1041                         else
1042                         {
1043                                 *ppTable = RateSwitchTable11BGN2SForABand;
1044                                 *pTableSize = RateSwitchTable11BGN2SForABand[0];
1045                                 *pInitTxRateIdx = RateSwitchTable11BGN2SForABand[1];
1046
1047                         }
1048                         break;
1049                 }
1050
1051                 //else if ((pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) && ((pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0x00) || (pAd->Antenna.field.TxPath == 1)))
1052                 if ((pEntry->HTCapability.MCSSet[0] == 0xff) && ((pEntry->HTCapability.MCSSet[1] == 0x00) || (pAd->CommonCfg.TxStream == 1)))
1053                 {// 11N 1S AP
1054                         *ppTable = RateSwitchTable11N1S;
1055                         *pTableSize = RateSwitchTable11N1S[0];
1056                         *pInitTxRateIdx = RateSwitchTable11N1S[1];
1057
1058                         break;
1059                 }
1060
1061                 //else if ((pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0xff) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0xff) && (pAd->Antenna.field.TxPath == 2))
1062                 if ((pEntry->HTCapability.MCSSet[0] == 0xff) && (pEntry->HTCapability.MCSSet[1] == 0xff) && (pAd->CommonCfg.TxStream == 2))
1063                 {// 11N 2S AP
1064                         if (pAd->LatchRfRegs.Channel <= 14)
1065                         {
1066                         *ppTable = RateSwitchTable11N2S;
1067                         *pTableSize = RateSwitchTable11N2S[0];
1068                         *pInitTxRateIdx = RateSwitchTable11N2S[1];
1069                         }
1070                         else
1071                         {
1072                                 *ppTable = RateSwitchTable11N2SForABand;
1073                                 *pTableSize = RateSwitchTable11N2SForABand[0];
1074                                 *pInitTxRateIdx = RateSwitchTable11N2SForABand[1];
1075                         }
1076
1077                         break;
1078                 }
1079                 //else if ((pAd->StaActive.SupRateLen == 4) && (pAd->StaActive.ExtRateLen == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1080                 if ((pEntry->RateLen == 4 || pAd->CommonCfg.PhyMode==PHY_11B)
1081                 //Iverson mark for Adhoc b mode,sta will use rate 54  Mbps when connect with sta b/g/n mode
1082                 /* && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)*/
1083                         )
1084                 {// B only AP
1085                         *ppTable = RateSwitchTable11B;
1086                         *pTableSize = RateSwitchTable11B[0];
1087                         *pInitTxRateIdx = RateSwitchTable11B[1];
1088
1089                         break;
1090                 }
1091
1092                 //else if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen > 8) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1093                 if ((pEntry->RateLen > 8)
1094                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
1095                         )
1096                 {// B/G  mixed AP
1097                         *ppTable = RateSwitchTable11BG;
1098                         *pTableSize = RateSwitchTable11BG[0];
1099                         *pInitTxRateIdx = RateSwitchTable11BG[1];
1100
1101                         break;
1102                 }
1103
1104                 //else if ((pAd->StaActive.SupRateLen + pAd->StaActive.ExtRateLen == 8) && (pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1105                 if ((pEntry->RateLen == 8)
1106                         && (pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0)
1107                         )
1108                 {// G only AP
1109                         *ppTable = RateSwitchTable11G;
1110                         *pTableSize = RateSwitchTable11G[0];
1111                         *pInitTxRateIdx = RateSwitchTable11G[1];
1112
1113                         break;
1114                 }
1115
1116                 {
1117                         //else if ((pAd->StaActive.SupportedPhyInfo.MCSSet[0] == 0) && (pAd->StaActive.SupportedPhyInfo.MCSSet[1] == 0))
1118                         if ((pEntry->HTCapability.MCSSet[0] == 0) && (pEntry->HTCapability.MCSSet[1] == 0))
1119                         {       // Legacy mode
1120                                 if (pAd->CommonCfg.MaxTxRate <= RATE_11)
1121                                 {
1122                                         *ppTable = RateSwitchTable11B;
1123                                         *pTableSize = RateSwitchTable11B[0];
1124                                         *pInitTxRateIdx = RateSwitchTable11B[1];
1125                                 }
1126                                 else if ((pAd->CommonCfg.MaxTxRate > RATE_11) && (pAd->CommonCfg.MinTxRate > RATE_11))
1127                                 {
1128                                         *ppTable = RateSwitchTable11G;
1129                                         *pTableSize = RateSwitchTable11G[0];
1130                                         *pInitTxRateIdx = RateSwitchTable11G[1];
1131
1132                                 }
1133                                 else
1134                                 {
1135                                         *ppTable = RateSwitchTable11BG;
1136                                         *pTableSize = RateSwitchTable11BG[0];
1137                                         *pInitTxRateIdx = RateSwitchTable11BG[1];
1138                                 }
1139                                 break;
1140                         }
1141                         if (pAd->LatchRfRegs.Channel <= 14)
1142                         {
1143                                 if (pAd->CommonCfg.TxStream == 1)
1144                                 {
1145                                         *ppTable = RateSwitchTable11N1S;
1146                                         *pTableSize = RateSwitchTable11N1S[0];
1147                                         *pInitTxRateIdx = RateSwitchTable11N1S[1];
1148                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 1S AP \n"));
1149                                 }
1150                                 else
1151                                 {
1152                                         *ppTable = RateSwitchTable11N2S;
1153                                         *pTableSize = RateSwitchTable11N2S[0];
1154                                         *pInitTxRateIdx = RateSwitchTable11N2S[1];
1155                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 2S AP \n"));
1156                                 }
1157                         }
1158                         else
1159                         {
1160                                 if (pAd->CommonCfg.TxStream == 1)
1161                                 {
1162                                         *ppTable = RateSwitchTable11N1S;
1163                                         *pTableSize = RateSwitchTable11N1S[0];
1164                                         *pInitTxRateIdx = RateSwitchTable11N1S[1];
1165                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 1S AP \n"));
1166                                 }
1167                                 else
1168                                 {
1169                                         *ppTable = RateSwitchTable11N2SForABand;
1170                                         *pTableSize = RateSwitchTable11N2SForABand[0];
1171                                         *pInitTxRateIdx = RateSwitchTable11N2SForABand[1];
1172                                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode,default use 11N 2S AP \n"));
1173                                 }
1174                         }
1175                         DBGPRINT_RAW(RT_DEBUG_ERROR,("DRS: unkown mode (SupRateLen=%d, ExtRateLen=%d, MCSSet[0]=0x%x, MCSSet[1]=0x%x)\n",
1176                                 pAd->StaActive.SupRateLen, pAd->StaActive.ExtRateLen, pAd->StaActive.SupportedPhyInfo.MCSSet[0], pAd->StaActive.SupportedPhyInfo.MCSSet[1]));
1177                 }
1178         } while(FALSE);
1179 }
1180
1181
1182 VOID STAMlmePeriodicExec(
1183         PRTMP_ADAPTER pAd)
1184 {
1185         ULONG                       TxTotalCnt;
1186         int     i;
1187
1188         /*
1189                 We return here in ATE mode, because the statistics
1190                 that ATE need are not collected via this routine.
1191         */
1192 #if defined(RT305x)||defined(RT3070)
1193         // request by Gary, if Rssi0 > -42, BBP 82 need to be changed from 0x62 to 0x42, , bbp 67 need to be changed from 0x20 to 0x18
1194         if (!pAd->CommonCfg.HighPowerPatchDisabled)
1195         {
1196 #ifdef RT3070
1197                  if ( (IS_RT3070(pAd) && ((pAd->MACVersion & 0xffff) < 0x0201)))
1198 #endif // RT3070 //
1199                 {
1200                                 if ((pAd->StaCfg.RssiSample.AvgRssi0 != 0) && (pAd->StaCfg.RssiSample.AvgRssi0 > (pAd->BbpRssiToDbmDelta - 35)))
1201                                 {
1202                                          RT30xxWriteRFRegister(pAd, RF_R27, 0x20);
1203                                  }
1204                                 else
1205                                 {
1206                                         RT30xxWriteRFRegister(pAd, RF_R27, 0x23);
1207                                 }
1208                  }
1209         }
1210 #endif
1211 #ifdef PCIE_PS_SUPPORT
1212 // don't perform idle-power-save mechanism within 3 min after driver initialization.
1213 // This can make rebooter test more robust
1214 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_PCIE_DEVICE))
1215         {
1216         if ((pAd->OpMode == OPMODE_STA) && (IDLE_ON(pAd))
1217                 && (pAd->Mlme.SyncMachine.CurrState == SYNC_IDLE)
1218                 && (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1219                 && (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF)))
1220                 {
1221                 if (IS_RT3090(pAd)|| IS_RT3572(pAd) || IS_RT3390(pAd))
1222                         {
1223                         if (pAd->StaCfg.PSControl.field.EnableNewPS == TRUE)
1224         {
1225                                 DBGPRINT(RT_DEBUG_TRACE, ("%s\n", __func__));
1226                                 RT28xxPciAsicRadioOff(pAd, GUI_IDLE_POWER_SAVE, 0);
1227                                 }
1228                         else
1229                                 {
1230                                 AsicSendCommandToMcu(pAd, 0x30, PowerSafeCID, 0xff, 0x2);
1231                                 // Wait command success
1232                                 AsicCheckCommanOk(pAd, PowerSafeCID);
1233                                 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF);
1234                                 DBGPRINT(RT_DEBUG_TRACE, ("PSM - rt30xx Issue Sleep command)\n"));
1235                                 }
1236                         }
1237                 else if (pAd->Mlme.OneSecPeriodicRound > 180)
1238                 {
1239                         if (pAd->StaCfg.PSControl.field.EnableNewPS == TRUE)
1240                                 {
1241                                 DBGPRINT(RT_DEBUG_TRACE, ("%s\n", __func__));
1242                                 RT28xxPciAsicRadioOff(pAd, GUI_IDLE_POWER_SAVE, 0);
1243                                  }
1244                                 else
1245                                 {
1246                                 AsicSendCommandToMcu(pAd, 0x30, PowerSafeCID, 0xff, 0x02);
1247                                 // Wait command success
1248                                 AsicCheckCommanOk(pAd, PowerSafeCID);
1249                                 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF);
1250                                 DBGPRINT(RT_DEBUG_TRACE, ("PSM -  rt28xx Issue Sleep command)\n"));
1251                                 }
1252                  }
1253         }
1254         else
1255                 {
1256                 DBGPRINT(RT_DEBUG_TRACE,("STAMlmePeriodicExec MMCHK - CommonCfg.Ssid[%d]=%c%c%c%c... MlmeAux.Ssid[%d]=%c%c%c%c...\n",
1257                         pAd->CommonCfg.SsidLen, pAd->CommonCfg.Ssid[0], pAd->CommonCfg.Ssid[1], pAd->CommonCfg.Ssid[2], pAd->CommonCfg.Ssid[3],
1258                         pAd->MlmeAux.SsidLen, pAd->MlmeAux.Ssid[0], pAd->MlmeAux.Ssid[1], pAd->MlmeAux.Ssid[2], pAd->MlmeAux.Ssid[3]));
1259                 }
1260         }
1261 #endif // PCIE_PS_SUPPORT //
1262
1263     if (pAd->StaCfg.WpaSupplicantUP == WPA_SUPPLICANT_DISABLE)
1264     {
1265         // WPA MIC error should block association attempt for 60 seconds
1266                 if (pAd->StaCfg.bBlockAssoc &&
1267                         RTMP_TIME_AFTER(pAd->Mlme.Now32, pAd->StaCfg.LastMicErrorTime + (60*OS_HZ)))
1268                 pAd->StaCfg.bBlockAssoc = FALSE;
1269     }
1270
1271     if ((pAd->PreMediaState != pAd->IndicateMediaState) && (pAd->CommonCfg.bWirelessEvent))
1272         {
1273                 if (pAd->IndicateMediaState == NdisMediaStateConnected)
1274                 {
1275                         RTMPSendWirelessEvent(pAd, IW_STA_LINKUP_EVENT_FLAG, pAd->MacTab.Content[BSSID_WCID].Addr, BSS0, 0);
1276                 }
1277                 pAd->PreMediaState = pAd->IndicateMediaState;
1278         }
1279
1280
1281
1282
1283         if (pAd->CommonCfg.PSPXlink && ADHOC_ON(pAd))
1284         {
1285         }
1286         else
1287         {
1288         AsicStaBbpTuning(pAd);
1289         }
1290
1291         TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
1292                                          pAd->RalinkCounters.OneSecTxRetryOkCount +
1293                                          pAd->RalinkCounters.OneSecTxFailCount;
1294
1295         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1296         {
1297                 // update channel quality for Roaming and UI LinkQuality display
1298                 MlmeCalculateChannelQuality(pAd, NULL, pAd->Mlme.Now32);
1299         }
1300
1301         // must be AFTER MlmeDynamicTxRateSwitching() because it needs to know if
1302         // Radio is currently in noisy environment
1303         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
1304         AsicAdjustTxPower(pAd);
1305
1306         if (INFRA_ON(pAd))
1307         {
1308
1309                 // Is PSM bit consistent with user power management policy?
1310                 // This is the only place that will set PSM bit ON.
1311                 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
1312                 MlmeCheckPsmChange(pAd, pAd->Mlme.Now32);
1313
1314                 pAd->RalinkCounters.LastOneSecTotalTxCount = TxTotalCnt;
1315
1316                 if ((RTMP_TIME_AFTER(pAd->Mlme.Now32, pAd->StaCfg.LastBeaconRxTime + (1*OS_HZ))) &&
1317                         (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS)) &&
1318                         (((TxTotalCnt + pAd->RalinkCounters.OneSecRxOkCnt) < 600)))
1319                 {
1320                         RTMPSetAGCInitValue(pAd, BW_20);
1321                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - No BEACON. restore R66 to the low bound(%d) \n", (0x2E + GET_LNA_GAIN(pAd))));
1322                 }
1323
1324         //if ((pAd->RalinkCounters.OneSecTxNoRetryOkCount == 0) &&
1325         //    (pAd->RalinkCounters.OneSecTxRetryOkCount == 0))
1326         {
1327                 if (pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable)
1328                 {
1329                     // When APSD is enabled, the period changes as 20 sec
1330                         if ((pAd->Mlme.OneSecPeriodicRound % 20) == 8)
1331                                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
1332                 }
1333                 else
1334                 {
1335                     // Send out a NULL frame every 10 sec to inform AP that STA is still alive (Avoid being age out)
1336                         if ((pAd->Mlme.OneSecPeriodicRound % 10) == 8)
1337                 {
1338                     if (pAd->CommonCfg.bWmmCapable)
1339                                         RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
1340                     else
1341                                                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, FALSE);
1342                 }
1343                 }
1344         }
1345
1346                 if (CQI_IS_DEAD(pAd->Mlme.ChannelQuality))
1347                         {
1348                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - No BEACON. Dead CQI. Auto Recovery attempt #%ld\n", pAd->RalinkCounters.BadCQIAutoRecoveryCount));
1349
1350                         // Lost AP, send disconnect & link down event
1351                         LinkDown(pAd, FALSE);
1352
1353
1354                 RtmpOSWrielessEventSend(pAd, SIOCGIWAP, -1, NULL, NULL, 0);
1355
1356                         // RTMPPatchMacBbpBug(pAd);
1357                         MlmeAutoReconnectLastSSID(pAd);
1358                 }
1359                 else if (CQI_IS_BAD(pAd->Mlme.ChannelQuality))
1360                 {
1361                         pAd->RalinkCounters.BadCQIAutoRecoveryCount ++;
1362                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Bad CQI. Auto Recovery attempt #%ld\n", pAd->RalinkCounters.BadCQIAutoRecoveryCount));
1363                         MlmeAutoReconnectLastSSID(pAd);
1364                 }
1365
1366                 if (pAd->StaCfg.bAutoRoaming)
1367                 {
1368                         BOOLEAN rv = FALSE;
1369                         CHAR    dBmToRoam = pAd->StaCfg.dBmToRoam;
1370                         CHAR    MaxRssi = RTMPMaxRssi(pAd,
1371                                                                                   pAd->StaCfg.RssiSample.LastRssi0,
1372                                                                                   pAd->StaCfg.RssiSample.LastRssi1,
1373                                                                                   pAd->StaCfg.RssiSample.LastRssi2);
1374
1375                         // Scanning, ignore Roaming
1376                         if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS) &&
1377                                 (pAd->Mlme.SyncMachine.CurrState == SYNC_IDLE) &&
1378                                 (MaxRssi <= dBmToRoam))
1379         {
1380                                 DBGPRINT(RT_DEBUG_TRACE, ("Rssi=%d, dBmToRoam=%d\n", MaxRssi, (CHAR)dBmToRoam));
1381
1382
1383                                 // Add auto seamless roaming
1384                                 if (rv == FALSE)
1385                                         rv = MlmeCheckForFastRoaming(pAd);
1386
1387                                 if (rv == FALSE)
1388                 {
1389                                         if ((pAd->StaCfg.LastScanTime + 10 * OS_HZ) < pAd->Mlme.Now32)
1390                         {
1391                                                 DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Roaming, No eligable entry, try new scan!\n"));
1392                                                 pAd->StaCfg.ScanCnt = 2;
1393                                                 pAd->StaCfg.LastScanTime = pAd->Mlme.Now32;
1394                                                 MlmeAutoScan(pAd);
1395                         }
1396                         }
1397                 }
1398                 }
1399         }
1400         else if (ADHOC_ON(pAd))
1401         {
1402                 // If all peers leave, and this STA becomes the last one in this IBSS, then change MediaState
1403                 // to DISCONNECTED. But still holding this IBSS (i.e. sending BEACON) so that other STAs can
1404                 // join later.
1405                 if (RTMP_TIME_AFTER(pAd->Mlme.Now32, pAd->StaCfg.LastBeaconRxTime + ADHOC_BEACON_LOST_TIME) &&
1406                         OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
1407                 {
1408                         MLME_START_REQ_STRUCT     StartReq;
1409
1410                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - excessive BEACON lost, last STA in this IBSS, MediaState=Disconnected\n"));
1411                         LinkDown(pAd, FALSE);
1412
1413                         StartParmFill(pAd, &StartReq, (CHAR *)pAd->MlmeAux.Ssid, pAd->MlmeAux.SsidLen);
1414                         MlmeEnqueue(pAd, SYNC_STATE_MACHINE, MT2_MLME_START_REQ, sizeof(MLME_START_REQ_STRUCT), &StartReq);
1415                         pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_START;
1416                 }
1417
1418                 for (i = 1; i < MAX_LEN_OF_MAC_TABLE; i++)
1419                 {
1420                         MAC_TABLE_ENTRY *pEntry = &pAd->MacTab.Content[i];
1421
1422                         if (pEntry->ValidAsCLI == FALSE)
1423                                 continue;
1424
1425                         if (RTMP_TIME_AFTER(pAd->Mlme.Now32, pEntry->LastBeaconRxTime + ADHOC_BEACON_LOST_TIME))
1426                                 MacTableDeleteEntry(pAd, pEntry->Aid, pEntry->Addr);
1427                 }
1428         }
1429         else // no INFRA nor ADHOC connection
1430         {
1431
1432                 if (pAd->StaCfg.bScanReqIsFromWebUI &&
1433                         RTMP_TIME_BEFORE(pAd->Mlme.Now32, pAd->StaCfg.LastScanTime + (30 * OS_HZ)))
1434                         goto SKIP_AUTO_SCAN_CONN;
1435         else
1436             pAd->StaCfg.bScanReqIsFromWebUI = FALSE;
1437
1438                 if ((pAd->StaCfg.bAutoReconnect == TRUE)
1439                         && RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_START_UP)
1440                         && (MlmeValidateSSID(pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen) == TRUE))
1441                 {
1442                         if ((pAd->ScanTab.BssNr==0) && (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE))
1443                         {
1444                                 MLME_SCAN_REQ_STRUCT       ScanReq;
1445
1446                                 if (RTMP_TIME_AFTER(pAd->Mlme.Now32, pAd->StaCfg.LastScanTime + (10 * OS_HZ)))
1447                                 {
1448                                         DBGPRINT(RT_DEBUG_TRACE, ("STAMlmePeriodicExec():CNTL - ScanTab.BssNr==0, start a new ACTIVE scan SSID[%s]\n", pAd->MlmeAux.AutoReconnectSsid));
1449                                         ScanParmFill(pAd, &ScanReq, (PSTRING) pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen, BSS_ANY, SCAN_ACTIVE);
1450                                         MlmeEnqueue(pAd, SYNC_STATE_MACHINE, MT2_MLME_SCAN_REQ, sizeof(MLME_SCAN_REQ_STRUCT), &ScanReq);
1451                                         pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_OID_LIST_SCAN;
1452                                         // Reset Missed scan number
1453                                         pAd->StaCfg.LastScanTime = pAd->Mlme.Now32;
1454                                 }
1455                                 else if (pAd->StaCfg.BssType == BSS_ADHOC)      // Quit the forever scan when in a very clean room
1456                                         MlmeAutoReconnectLastSSID(pAd);
1457                         }
1458                         else if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1459                         {
1460                                 if ((pAd->Mlme.OneSecPeriodicRound % 7) == 0)
1461                                 {
1462                                         MlmeAutoScan(pAd);
1463                                         pAd->StaCfg.LastScanTime = pAd->Mlme.Now32;
1464                                 }
1465                                 else
1466                                 {
1467                                                 MlmeAutoReconnectLastSSID(pAd);
1468                                 }
1469                         }
1470                 }
1471         }
1472
1473 SKIP_AUTO_SCAN_CONN:
1474
1475     if ((pAd->MacTab.Content[BSSID_WCID].TXBAbitmap !=0) && (pAd->MacTab.fAnyBASession == FALSE))
1476         {
1477                 pAd->MacTab.fAnyBASession = TRUE;
1478                 AsicUpdateProtect(pAd, HT_FORCERTSCTS,  ALLN_SETPROTECT, FALSE, FALSE);
1479         }
1480         else if ((pAd->MacTab.Content[BSSID_WCID].TXBAbitmap ==0) && (pAd->MacTab.fAnyBASession == TRUE))
1481         {
1482                 pAd->MacTab.fAnyBASession = FALSE;
1483                 AsicUpdateProtect(pAd, pAd->MlmeAux.AddHtInfo.AddHtInfo2.OperaionMode,  ALLN_SETPROTECT, FALSE, FALSE);
1484         }
1485
1486         return;
1487 }
1488
1489 // Link down report
1490 VOID LinkDownExec(
1491         IN PVOID SystemSpecific1,
1492         IN PVOID FunctionContext,
1493         IN PVOID SystemSpecific2,
1494         IN PVOID SystemSpecific3)
1495 {
1496         RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)FunctionContext;
1497
1498         if (pAd != NULL)
1499         {
1500                 MLME_DISASSOC_REQ_STRUCT   DisassocReq;
1501
1502                 if ((pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED) &&
1503                         (INFRA_ON(pAd)))
1504                 {
1505                         DBGPRINT(RT_DEBUG_TRACE, ("LinkDownExec(): disassociate with current AP...\n"));
1506                         DisassocParmFill(pAd, &DisassocReq, pAd->CommonCfg.Bssid, REASON_DISASSOC_STA_LEAVING);
1507                         MlmeEnqueue(pAd, ASSOC_STATE_MACHINE, MT2_MLME_DISASSOC_REQ,
1508                                                 sizeof(MLME_DISASSOC_REQ_STRUCT), &DisassocReq);
1509                         pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_DISASSOC;
1510
1511         pAd->IndicateMediaState = NdisMediaStateDisconnected;
1512         RTMP_IndicateMediaState(pAd);
1513     pAd->ExtraInfo = GENERAL_LINK_DOWN;
1514                 }
1515         }
1516 }
1517
1518 // IRQL = DISPATCH_LEVEL
1519 VOID MlmeAutoScan(
1520         IN PRTMP_ADAPTER pAd)
1521 {
1522         // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1523         if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1524         {
1525                 DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Driver auto scan\n"));
1526                 MlmeEnqueue(pAd,
1527                                         MLME_CNTL_STATE_MACHINE,
1528                                         OID_802_11_BSSID_LIST_SCAN,
1529                                         pAd->MlmeAux.AutoReconnectSsidLen,
1530                                         pAd->MlmeAux.AutoReconnectSsid);
1531                 RTMP_MLME_HANDLER(pAd);
1532         }
1533 }
1534
1535 // IRQL = DISPATCH_LEVEL
1536 VOID MlmeAutoReconnectLastSSID(
1537         IN PRTMP_ADAPTER pAd)
1538 {
1539         if (pAd->StaCfg.bAutoConnectByBssid)
1540         {
1541                 DBGPRINT(RT_DEBUG_TRACE, ("Driver auto reconnect to last OID_802_11_BSSID setting - %02X:%02X:%02X:%02X:%02X:%02X\n",
1542                                                                         pAd->MlmeAux.Bssid[0],
1543                                                                         pAd->MlmeAux.Bssid[1],
1544                                                                         pAd->MlmeAux.Bssid[2],
1545                                                                         pAd->MlmeAux.Bssid[3],
1546                                                                         pAd->MlmeAux.Bssid[4],
1547                                                                         pAd->MlmeAux.Bssid[5]));
1548
1549                 pAd->MlmeAux.Channel = pAd->CommonCfg.Channel;
1550                 MlmeEnqueue(pAd,
1551                          MLME_CNTL_STATE_MACHINE,
1552                          OID_802_11_BSSID,
1553                          MAC_ADDR_LEN,
1554                          pAd->MlmeAux.Bssid);
1555
1556                 pAd->Mlme.CntlMachine.CurrState = CNTL_IDLE;
1557
1558                 RTMP_MLME_HANDLER(pAd);
1559         }
1560         // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1561         else if ((pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE) &&
1562                 (MlmeValidateSSID(pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen) == TRUE))
1563         {
1564                 NDIS_802_11_SSID OidSsid;
1565                 OidSsid.SsidLength = pAd->MlmeAux.AutoReconnectSsidLen;
1566                 NdisMoveMemory(OidSsid.Ssid, pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen);
1567
1568                 DBGPRINT(RT_DEBUG_TRACE, ("Driver auto reconnect to last OID_802_11_SSID setting - %s, len - %d\n", pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen));
1569                 MlmeEnqueue(pAd,
1570                                         MLME_CNTL_STATE_MACHINE,
1571                                         OID_802_11_SSID,
1572                                         sizeof(NDIS_802_11_SSID),
1573                                         &OidSsid);
1574                 RTMP_MLME_HANDLER(pAd);
1575         }
1576 }
1577
1578
1579 /*
1580         ==========================================================================
1581         Description:
1582                 This routine checks if there're other APs out there capable for
1583                 roaming. Caller should call this routine only when Link up in INFRA mode
1584                 and channel quality is below CQI_GOOD_THRESHOLD.
1585
1586         IRQL = DISPATCH_LEVEL
1587
1588         Output:
1589         ==========================================================================
1590  */
1591 VOID MlmeCheckForRoaming(
1592         IN PRTMP_ADAPTER pAd,
1593         IN ULONG        Now32)
1594 {
1595         USHORT     i;
1596         BSS_TABLE  *pRoamTab = &pAd->MlmeAux.RoamTab;
1597         BSS_ENTRY  *pBss;
1598
1599         DBGPRINT(RT_DEBUG_TRACE, ("==> MlmeCheckForRoaming\n"));
1600         // put all roaming candidates into RoamTab, and sort in RSSI order
1601         BssTableInit(pRoamTab);
1602         for (i = 0; i < pAd->ScanTab.BssNr; i++)
1603         {
1604                 pBss = &pAd->ScanTab.BssEntry[i];
1605
1606                 if ((pBss->LastBeaconRxTime + pAd->StaCfg.BeaconLostTime) < Now32)
1607                         continue;        // AP disappear
1608                 if (pBss->Rssi <= RSSI_THRESHOLD_FOR_ROAMING)
1609                         continue;        // RSSI too weak. forget it.
1610                 if (MAC_ADDR_EQUAL(pBss->Bssid, pAd->CommonCfg.Bssid))
1611                         continue;        // skip current AP
1612                 if (pBss->Rssi < (pAd->StaCfg.RssiSample.LastRssi0 + RSSI_DELTA))
1613                         continue;        // only AP with stronger RSSI is eligible for roaming
1614
1615                 // AP passing all above rules is put into roaming candidate table
1616                 NdisMoveMemory(&pRoamTab->BssEntry[pRoamTab->BssNr], pBss, sizeof(BSS_ENTRY));
1617                 pRoamTab->BssNr += 1;
1618         }
1619
1620         if (pRoamTab->BssNr > 0)
1621         {
1622                 // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1623                 if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1624                 {
1625                         pAd->RalinkCounters.PoorCQIRoamingCount ++;
1626                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Roaming attempt #%ld\n", pAd->RalinkCounters.PoorCQIRoamingCount));
1627                         MlmeEnqueue(pAd, MLME_CNTL_STATE_MACHINE, MT2_MLME_ROAMING_REQ, 0, NULL);
1628                         RTMP_MLME_HANDLER(pAd);
1629                 }
1630         }
1631         DBGPRINT(RT_DEBUG_TRACE, ("<== MlmeCheckForRoaming(# of candidate= %d)\n",pRoamTab->BssNr));
1632 }
1633
1634 /*
1635         ==========================================================================
1636         Description:
1637                 This routine checks if there're other APs out there capable for
1638                 roaming. Caller should call this routine only when link up in INFRA mode
1639                 and channel quality is below CQI_GOOD_THRESHOLD.
1640
1641         IRQL = DISPATCH_LEVEL
1642
1643         Output:
1644         ==========================================================================
1645  */
1646 BOOLEAN MlmeCheckForFastRoaming(
1647         IN      PRTMP_ADAPTER   pAd)
1648 {
1649         USHORT          i;
1650         BSS_TABLE       *pRoamTab = &pAd->MlmeAux.RoamTab;
1651         BSS_ENTRY       *pBss;
1652
1653         DBGPRINT(RT_DEBUG_TRACE, ("==> MlmeCheckForFastRoaming\n"));
1654         // put all roaming candidates into RoamTab, and sort in RSSI order
1655         BssTableInit(pRoamTab);
1656         for (i = 0; i < pAd->ScanTab.BssNr; i++)
1657                 {
1658                 pBss = &pAd->ScanTab.BssEntry[i];
1659
1660         if ((pBss->Rssi <= -50) && (pBss->Channel == pAd->CommonCfg.Channel))
1661                         continue;        // RSSI too weak. forget it.
1662                 if (MAC_ADDR_EQUAL(pBss->Bssid, pAd->CommonCfg.Bssid))
1663                         continue;        // skip current AP
1664                 if (!SSID_EQUAL(pBss->Ssid, pBss->SsidLen, pAd->CommonCfg.Ssid, pAd->CommonCfg.SsidLen))
1665                         continue;        // skip different SSID
1666         if (pBss->Rssi < (RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.LastRssi0, pAd->StaCfg.RssiSample.LastRssi1, pAd->StaCfg.RssiSample.LastRssi2) + RSSI_DELTA))
1667                         continue;        // skip AP without better RSSI
1668
1669         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));
1670                 // AP passing all above rules is put into roaming candidate table
1671                 NdisMoveMemory(&pRoamTab->BssEntry[pRoamTab->BssNr], pBss, sizeof(BSS_ENTRY));
1672                 pRoamTab->BssNr += 1;
1673                 }
1674
1675         DBGPRINT(RT_DEBUG_TRACE, ("<== MlmeCheckForFastRoaming (BssNr=%d)\n", pRoamTab->BssNr));
1676         if (pRoamTab->BssNr > 0)
1677                 {
1678                 // check CntlMachine.CurrState to avoid collision with NDIS SetOID request
1679                 if (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)
1680                                 {
1681                         pAd->RalinkCounters.PoorCQIRoamingCount ++;
1682                         DBGPRINT(RT_DEBUG_TRACE, ("MMCHK - Roaming attempt #%ld\n", pAd->RalinkCounters.PoorCQIRoamingCount));
1683                         MlmeEnqueue(pAd, MLME_CNTL_STATE_MACHINE, MT2_MLME_ROAMING_REQ, 0, NULL);
1684                         RTMP_MLME_HANDLER(pAd);
1685                         return TRUE;
1686                                 }
1687                                 }
1688
1689         return FALSE;
1690 }
1691
1692 VOID MlmeSetTxRate(
1693         IN PRTMP_ADAPTER                pAd,
1694         IN PMAC_TABLE_ENTRY             pEntry,
1695         IN PRTMP_TX_RATE_SWITCH pTxRate)
1696 {
1697         UCHAR   MaxMode = MODE_OFDM;
1698
1699         MaxMode = MODE_HTGREENFIELD;
1700
1701         if (pTxRate->STBC && (pAd->StaCfg.MaxHTPhyMode.field.STBC) && (pAd->Antenna.field.TxPath == 2))
1702                 pAd->StaCfg.HTPhyMode.field.STBC = STBC_USE;
1703                         else
1704                 pAd->StaCfg.HTPhyMode.field.STBC = STBC_NONE;
1705
1706         if (pTxRate->CurrMCS < MCS_AUTO)
1707                 pAd->StaCfg.HTPhyMode.field.MCS = pTxRate->CurrMCS;
1708
1709         if (pAd->StaCfg.HTPhyMode.field.MCS > 7)
1710                 pAd->StaCfg.HTPhyMode.field.STBC = STBC_NONE;
1711
1712         if (ADHOC_ON(pAd))
1713                         {
1714                 // If peer adhoc is b-only mode, we can't send 11g rate.
1715                 pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1716                 pEntry->HTPhyMode.field.STBC    = STBC_NONE;
1717
1718                 //
1719                 // For Adhoc MODE_CCK, driver will use AdhocBOnlyJoined flag to roll back to B only if necessary
1720                 //
1721                 pEntry->HTPhyMode.field.MODE    = pTxRate->Mode;
1722                 pEntry->HTPhyMode.field.ShortGI = pAd->StaCfg.HTPhyMode.field.ShortGI;
1723                 pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1724
1725                 // Patch speed error in status page
1726                 pAd->StaCfg.HTPhyMode.field.MODE = pEntry->HTPhyMode.field.MODE;
1727                         }
1728                         else
1729                         {
1730                 if (pTxRate->Mode <= MaxMode)
1731                 pAd->StaCfg.HTPhyMode.field.MODE = pTxRate->Mode;
1732
1733         if (pTxRate->ShortGI && (pAd->StaCfg.MaxHTPhyMode.field.ShortGI))
1734                         pAd->StaCfg.HTPhyMode.field.ShortGI = GI_400;
1735                 else
1736                         pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1737
1738                 // Reexam each bandwidth's SGI support.
1739                 if (pAd->StaCfg.HTPhyMode.field.ShortGI == GI_400)
1740                 {
1741                         if ((pEntry->HTPhyMode.field.BW == BW_20) && (!CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_SGI20_CAPABLE)))
1742                                 pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1743                         if ((pEntry->HTPhyMode.field.BW == BW_40) && (!CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_SGI40_CAPABLE)))
1744                                 pAd->StaCfg.HTPhyMode.field.ShortGI = GI_800;
1745                 }
1746
1747         // Turn RTS/CTS rate to 6Mbps.
1748                 if ((pEntry->HTPhyMode.field.MCS == 0) && (pAd->StaCfg.HTPhyMode.field.MCS != 0))
1749                         {
1750                         pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1751                         if (pAd->MacTab.fAnyBASession)
1752                         {
1753                                 AsicUpdateProtect(pAd, HT_FORCERTSCTS, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1754             }
1755                         else
1756                         {
1757                                 AsicUpdateProtect(pAd, pAd->MlmeAux.AddHtInfo.AddHtInfo2.OperaionMode, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1758                                 }
1759                         }
1760                 else if ((pEntry->HTPhyMode.field.MCS == 8) && (pAd->StaCfg.HTPhyMode.field.MCS != 8))
1761                         {
1762                         pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1763                         if (pAd->MacTab.fAnyBASession)
1764                                 {
1765                                 AsicUpdateProtect(pAd, HT_FORCERTSCTS, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1766                                 }
1767                                 else
1768                                 {
1769                                 AsicUpdateProtect(pAd, pAd->MlmeAux.AddHtInfo.AddHtInfo2.OperaionMode, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1770                                 }
1771                         }
1772                 else if ((pEntry->HTPhyMode.field.MCS != 0) && (pAd->StaCfg.HTPhyMode.field.MCS == 0))
1773                                 {
1774                         AsicUpdateProtect(pAd, HT_RTSCTS_6M, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1775
1776                                 }
1777                 else if ((pEntry->HTPhyMode.field.MCS != 8) && (pAd->StaCfg.HTPhyMode.field.MCS == 8))
1778                                 {
1779                         AsicUpdateProtect(pAd, HT_RTSCTS_6M, ALLN_SETPROTECT, TRUE, (BOOLEAN)pAd->MlmeAux.AddHtInfo.AddHtInfo2.NonGfPresent);
1780                         }
1781
1782                 pEntry->HTPhyMode.field.STBC    = pAd->StaCfg.HTPhyMode.field.STBC;
1783                 pEntry->HTPhyMode.field.ShortGI = pAd->StaCfg.HTPhyMode.field.ShortGI;
1784                 pEntry->HTPhyMode.field.MCS             = pAd->StaCfg.HTPhyMode.field.MCS;
1785                 pEntry->HTPhyMode.field.MODE    = pAd->StaCfg.HTPhyMode.field.MODE;
1786         if ((pAd->StaCfg.MaxHTPhyMode.field.MODE == MODE_HTGREENFIELD) &&
1787             pAd->WIFItestbed.bGreenField)
1788             pEntry->HTPhyMode.field.MODE = MODE_HTGREENFIELD;
1789                 }
1790
1791     pAd->LastTxRate = (USHORT)(pEntry->HTPhyMode.word);
1792 }
1793
1794 /*
1795         ==========================================================================
1796         Description:
1797                 This routine calculates the acumulated TxPER of eaxh TxRate. And
1798                 according to the calculation result, change CommonCfg.TxRate which
1799                 is the stable TX Rate we expect the Radio situation could sustained.
1800
1801                 CommonCfg.TxRate will change dynamically within {RATE_1/RATE_6, MaxTxRate}
1802         Output:
1803                 CommonCfg.TxRate -
1804
1805         IRQL = DISPATCH_LEVEL
1806
1807         NOTE:
1808                 call this routine every second
1809         ==========================================================================
1810  */
1811 VOID MlmeDynamicTxRateSwitching(
1812         IN PRTMP_ADAPTER pAd)
1813 {
1814         UCHAR                                   UpRateIdx = 0, DownRateIdx = 0, CurrRateIdx;
1815         ULONG                                   i, AccuTxTotalCnt = 0, TxTotalCnt;
1816         ULONG                                   TxErrorRatio = 0;
1817         BOOLEAN                                 bTxRateChanged = FALSE, bUpgradeQuality = FALSE;
1818         PRTMP_TX_RATE_SWITCH    pCurrTxRate, pNextTxRate = NULL;
1819         PUCHAR                                  pTable;
1820         UCHAR                                   TableSize = 0;
1821         UCHAR                                   InitTxRateIdx = 0, TrainUp, TrainDown;
1822         CHAR                                    Rssi, RssiOffset = 0;
1823         TX_STA_CNT1_STRUC               StaTx1;
1824         TX_STA_CNT0_STRUC               TxStaCnt0;
1825         ULONG                                   TxRetransmit = 0, TxSuccess = 0, TxFailCount = 0;
1826         MAC_TABLE_ENTRY                 *pEntry;
1827         RSSI_SAMPLE                             *pRssi = &pAd->StaCfg.RssiSample;
1828
1829
1830         //
1831         // walk through MAC table, see if need to change AP's TX rate toward each entry
1832         //
1833         for (i = 1; i < MAX_LEN_OF_MAC_TABLE; i++)
1834         {
1835                 pEntry = &pAd->MacTab.Content[i];
1836
1837         // check if this entry need to switch rate automatically
1838                 if (RTMPCheckEntryEnableAutoRateSwitch(pAd, pEntry) == FALSE)
1839                         continue;
1840
1841                 if ((pAd->MacTab.Size == 1) || (pEntry->ValidAsDls))
1842                 {
1843                         Rssi = RTMPMaxRssi(pAd,
1844                                                            pRssi->AvgRssi0,
1845                                                            pRssi->AvgRssi1,
1846                                                            pRssi->AvgRssi2);
1847
1848                         // Update statistic counter
1849                         RTMP_IO_READ32(pAd, TX_STA_CNT0, &TxStaCnt0.word);
1850                         RTMP_IO_READ32(pAd, TX_STA_CNT1, &StaTx1.word);
1851                         pAd->bUpdateBcnCntDone = TRUE;
1852                         TxRetransmit = StaTx1.field.TxRetransmit;
1853                         TxSuccess = StaTx1.field.TxSuccess;
1854                         TxFailCount = TxStaCnt0.field.TxFailCount;
1855                         TxTotalCnt = TxRetransmit + TxSuccess + TxFailCount;
1856
1857                         pAd->RalinkCounters.OneSecTxRetryOkCount += StaTx1.field.TxRetransmit;
1858                         pAd->RalinkCounters.OneSecTxNoRetryOkCount += StaTx1.field.TxSuccess;
1859                         pAd->RalinkCounters.OneSecTxFailCount += TxStaCnt0.field.TxFailCount;
1860                         pAd->WlanCounters.TransmittedFragmentCount.u.LowPart += StaTx1.field.TxSuccess;
1861                         pAd->WlanCounters.RetryCount.u.LowPart += StaTx1.field.TxRetransmit;
1862                         pAd->WlanCounters.FailedCount.u.LowPart += TxStaCnt0.field.TxFailCount;
1863
1864                         // if no traffic in the past 1-sec period, don't change TX rate,
1865                         // but clear all bad history. because the bad history may affect the next
1866                         // Chariot throughput test
1867                         AccuTxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
1868                                                  pAd->RalinkCounters.OneSecTxRetryOkCount +
1869                                                  pAd->RalinkCounters.OneSecTxFailCount;
1870
1871                         if (TxTotalCnt)
1872                                 TxErrorRatio = ((TxRetransmit + TxFailCount) * 100) / TxTotalCnt;
1873                 }
1874                 else
1875         {
1876                         if (INFRA_ON(pAd) && (i == 1))
1877                                 Rssi = RTMPMaxRssi(pAd,
1878                                                                    pRssi->AvgRssi0,
1879                                                                    pRssi->AvgRssi1,
1880                                                                    pRssi->AvgRssi2);
1881                         else
1882                                 Rssi = RTMPMaxRssi(pAd,
1883                                                                    pEntry->RssiSample.AvgRssi0,
1884                                                                    pEntry->RssiSample.AvgRssi1,
1885                                                                    pEntry->RssiSample.AvgRssi2);
1886
1887                         TxTotalCnt = pEntry->OneSecTxNoRetryOkCount +
1888                                  pEntry->OneSecTxRetryOkCount +
1889                                  pEntry->OneSecTxFailCount;
1890
1891                         if (TxTotalCnt)
1892                                 TxErrorRatio = ((pEntry->OneSecTxRetryOkCount + pEntry->OneSecTxFailCount) * 100) / TxTotalCnt;
1893         }
1894
1895                 if (TxTotalCnt)
1896                 {
1897                         /*
1898                                 Three AdHoc connections can not work normally if one AdHoc connection is disappeared from a heavy traffic environment generated by ping tool
1899                                 We force to set LongRtyLimit and ShortRtyLimit to 0 to stop retransmitting packet, after a while, resoring original settings
1900                         */
1901                         if (TxErrorRatio == 100)
1902                         {
1903                                 TX_RTY_CFG_STRUC        TxRtyCfg,TxRtyCfgtmp;
1904                                 ULONG   Index;
1905                                 ULONG   MACValue;
1906
1907                                 RTMP_IO_READ32(pAd, TX_RTY_CFG, &TxRtyCfg.word);
1908                                 TxRtyCfgtmp.word = TxRtyCfg.word;
1909                                 TxRtyCfg.field.LongRtyLimit = 0x0;
1910                                 TxRtyCfg.field.ShortRtyLimit = 0x0;
1911                                 RTMP_IO_WRITE32(pAd, TX_RTY_CFG, TxRtyCfg.word);
1912
1913                                 RTMPusecDelay(1);
1914
1915                                 Index = 0;
1916                                 MACValue = 0;
1917                                 do
1918                 {
1919                                         RTMP_IO_READ32(pAd, TXRXQ_PCNT, &MACValue);
1920                                         if ((MACValue & 0xffffff) == 0)
1921                                                 break;
1922                                         Index++;
1923                                         RTMPusecDelay(1000);
1924                                 }while((Index < 330)&&(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS)));
1925
1926                                 RTMP_IO_READ32(pAd, TX_RTY_CFG, &TxRtyCfg.word);
1927                                 TxRtyCfg.field.LongRtyLimit = TxRtyCfgtmp.field.LongRtyLimit;
1928                                 TxRtyCfg.field.ShortRtyLimit = TxRtyCfgtmp.field.ShortRtyLimit;
1929                                 RTMP_IO_WRITE32(pAd, TX_RTY_CFG, TxRtyCfg.word);
1930                 }
1931         }
1932
1933                 CurrRateIdx = pEntry->CurrTxRateIndex;
1934
1935                 MlmeSelectTxRateTable(pAd, pEntry, &pTable, &TableSize, &InitTxRateIdx);
1936
1937                 if (CurrRateIdx >= TableSize)
1938                 {
1939                         CurrRateIdx = TableSize - 1;
1940                 }
1941
1942                 // When switch from Fixed rate -> auto rate, the REAL TX rate might be different from pAd->CommonCfg.TxRateIndex.
1943                 // So need to sync here.
1944                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(CurrRateIdx+1)*5];
1945                 if ((pEntry->HTPhyMode.field.MCS != pCurrTxRate->CurrMCS)
1946                         //&& (pAd->StaCfg.bAutoTxRateSwitch == TRUE)
1947                         )
1948                 {
1949
1950                         // Need to sync Real Tx rate and our record.
1951                         // Then return for next DRS.
1952                         pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(InitTxRateIdx+1)*5];
1953                         pEntry->CurrTxRateIndex = InitTxRateIdx;
1954                         MlmeSetTxRate(pAd, pEntry, pCurrTxRate);
1955
1956                         // reset all OneSecTx counters
1957                         RESET_ONE_SEC_TX_CNT(pEntry);
1958                         continue;
1959                 }
1960
1961                 // decide the next upgrade rate and downgrade rate, if any
1962                 if ((CurrRateIdx > 0) && (CurrRateIdx < (TableSize - 1)))
1963         {
1964                         UpRateIdx = CurrRateIdx + 1;
1965                         DownRateIdx = CurrRateIdx -1;
1966         }
1967                 else if (CurrRateIdx == 0)
1968                 {
1969                         UpRateIdx = CurrRateIdx + 1;
1970                         DownRateIdx = CurrRateIdx;
1971                 }
1972                 else if (CurrRateIdx == (TableSize - 1))
1973         {
1974                         UpRateIdx = CurrRateIdx;
1975                         DownRateIdx = CurrRateIdx - 1;
1976         }
1977
1978                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(CurrRateIdx+1)*5];
1979
1980                 if ((Rssi > -65) && (pCurrTxRate->Mode >= MODE_HTMIX))
1981         {
1982                         TrainUp         = (pCurrTxRate->TrainUp + (pCurrTxRate->TrainUp >> 1));
1983                         TrainDown       = (pCurrTxRate->TrainDown + (pCurrTxRate->TrainDown >> 1));
1984         }
1985         else
1986         {
1987                         TrainUp         = pCurrTxRate->TrainUp;
1988                         TrainDown       = pCurrTxRate->TrainDown;
1989         }
1990
1991                 //pAd->DrsCounters.LastTimeTxRateChangeAction = pAd->DrsCounters.LastSecTxRateChangeAction;
1992
1993                 //
1994                 // Keep the last time TxRateChangeAction status.
1995                 //
1996                 pEntry->LastTimeTxRateChangeAction = pEntry->LastSecTxRateChangeAction;
1997
1998
1999
2000                 //
2001                 // CASE 1. when TX samples are fewer than 15, then decide TX rate solely on RSSI
2002                 //         (criteria copied from RT2500 for Netopia case)
2003                 //
2004                 if (TxTotalCnt <= 15)
2005         {
2006                         CHAR    idx = 0;
2007                         UCHAR   TxRateIdx;
2008                         UCHAR   MCS0 = 0, MCS1 = 0, MCS2 = 0, MCS3 = 0, MCS4 = 0,  MCS5 =0, MCS6 = 0, MCS7 = 0;
2009                 UCHAR   MCS12 = 0, MCS13 = 0, MCS14 = 0, MCS15 = 0;
2010                         UCHAR   MCS20 = 0, MCS21 = 0, MCS22 = 0, MCS23 = 0; // 3*3
2011
2012                         // check the existence and index of each needed MCS
2013                         while (idx < pTable[0])
2014                         {
2015                                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(idx+1)*5];
2016
2017                                 if (pCurrTxRate->CurrMCS == MCS_0)
2018                 {
2019                                         MCS0 = idx;
2020                 }
2021                                 else if (pCurrTxRate->CurrMCS == MCS_1)
2022                 {
2023                                         MCS1 = idx;
2024                                 }
2025                                 else if (pCurrTxRate->CurrMCS == MCS_2)
2026                         {
2027                                         MCS2 = idx;
2028                         }
2029                                 else if (pCurrTxRate->CurrMCS == MCS_3)
2030                         {
2031                                         MCS3 = idx;
2032                                 }
2033                                 else if (pCurrTxRate->CurrMCS == MCS_4)
2034                                 {
2035                                         MCS4 = idx;
2036                         }
2037                     else if (pCurrTxRate->CurrMCS == MCS_5)
2038                     {
2039                         MCS5 = idx;
2040                 }
2041                     else if (pCurrTxRate->CurrMCS == MCS_6)
2042                 {
2043                         MCS6 = idx;
2044                     }
2045                                 //else if (pCurrTxRate->CurrMCS == MCS_7)
2046                                 else if ((pCurrTxRate->CurrMCS == MCS_7) && (pCurrTxRate->ShortGI == GI_800))   // prevent the highest MCS using short GI when 1T and low throughput
2047                         {
2048                                         MCS7 = idx;
2049                         }
2050                                 else if (pCurrTxRate->CurrMCS == MCS_12)
2051                         {
2052                                         MCS12 = idx;
2053                         }
2054                                 else if (pCurrTxRate->CurrMCS == MCS_13)
2055                                 {
2056                                         MCS13 = idx;
2057                 }
2058                                 else if (pCurrTxRate->CurrMCS == MCS_14)
2059                 {
2060                                         MCS14 = idx;
2061                 }
2062                                 //else if ((pCurrTxRate->CurrMCS == MCS_15)/* && (pCurrTxRate->ShortGI == GI_800)*/)    //we hope to use ShortGI as initial rate
2063                                 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
2064                 {
2065                                         MCS15 = idx;
2066                 }
2067                                 else if (pCurrTxRate->CurrMCS == MCS_20) // 3*3
2068                                 {
2069                                         MCS20 = idx;
2070                                 }
2071                                 else if (pCurrTxRate->CurrMCS == MCS_21)
2072                                 {
2073                                         MCS21 = idx;
2074                                 }
2075                                 else if (pCurrTxRate->CurrMCS == MCS_22)
2076                                 {
2077                                         MCS22 = idx;
2078                                 }
2079                                 else if (pCurrTxRate->CurrMCS == MCS_23)
2080                                 {
2081                                         MCS23 = idx;
2082                                 }
2083                                 idx ++;
2084                         }
2085
2086                         if (pAd->LatchRfRegs.Channel <= 14)
2087                         {
2088                                 if (pAd->NicConfig2.field.ExternalLNAForG)
2089                                 {
2090                                         RssiOffset = 2;
2091                                 }
2092                                 else
2093                                 {
2094                                         RssiOffset = 5;
2095                                 }
2096                         }
2097                         else
2098                         {
2099                                 if (pAd->NicConfig2.field.ExternalLNAForA)
2100                                 {
2101                                         RssiOffset = 5;
2102                                 }
2103                                 else
2104                                 {
2105                                         RssiOffset = 8;
2106                                 }
2107                         }
2108
2109                         /*if (MCS15)*/
2110                         if ((pTable == RateSwitchTable11BGN3S) ||
2111                                 (pTable == RateSwitchTable11N3S) ||
2112                                 (pTable == RateSwitchTable))
2113                         {// N mode with 3 stream // 3*3
2114                                 if (MCS23 && (Rssi >= -70))
2115                                         TxRateIdx = MCS23;
2116                                 else if (MCS22 && (Rssi >= -72))
2117                                         TxRateIdx = MCS22;
2118                     else if (MCS21 && (Rssi >= -76))
2119                                         TxRateIdx = MCS21;
2120                                 else if (MCS20 && (Rssi >= -78))
2121                                         TxRateIdx = MCS20;
2122                         else if (MCS4 && (Rssi >= -82))
2123                                 TxRateIdx = MCS4;
2124                         else if (MCS3 && (Rssi >= -84))
2125                                 TxRateIdx = MCS3;
2126                         else if (MCS2 && (Rssi >= -86))
2127                                 TxRateIdx = MCS2;
2128                         else if (MCS1 && (Rssi >= -88))
2129                                 TxRateIdx = MCS1;
2130                         else
2131                                 TxRateIdx = MCS0;
2132                 }
2133 //              else if ((pTable == RateSwitchTable11BGN2S) || (pTable == RateSwitchTable11BGN2SForABand) ||(pTable == RateSwitchTable11N2S) ||(pTable == RateSwitchTable11N2SForABand) || (pTable == RateSwitchTable))
2134                 else if ((pTable == RateSwitchTable11BGN2S) || (pTable == RateSwitchTable11BGN2SForABand) ||(pTable == RateSwitchTable11N2S) ||(pTable == RateSwitchTable11N2SForABand)) // 3*3
2135                         {// N mode with 2 stream
2136                                 if (MCS15 && (Rssi >= (-70+RssiOffset)))
2137                                         TxRateIdx = MCS15;
2138                                 else if (MCS14 && (Rssi >= (-72+RssiOffset)))
2139                                         TxRateIdx = MCS14;
2140                                 else if (MCS13 && (Rssi >= (-76+RssiOffset)))
2141                                         TxRateIdx = MCS13;
2142                                 else if (MCS12 && (Rssi >= (-78+RssiOffset)))
2143                                         TxRateIdx = MCS12;
2144                                 else if (MCS4 && (Rssi >= (-82+RssiOffset)))
2145                                         TxRateIdx = MCS4;
2146                                 else if (MCS3 && (Rssi >= (-84+RssiOffset)))
2147                                         TxRateIdx = MCS3;
2148                                 else if (MCS2 && (Rssi >= (-86+RssiOffset)))
2149                                         TxRateIdx = MCS2;
2150                                 else if (MCS1 && (Rssi >= (-88+RssiOffset)))
2151                                         TxRateIdx = MCS1;
2152                                 else
2153                                         TxRateIdx = MCS0;
2154                         }
2155                         else if ((pTable == RateSwitchTable11BGN1S) || (pTable == RateSwitchTable11N1S))
2156                         {// N mode with 1 stream
2157                                 if (MCS7 && (Rssi > (-72+RssiOffset)))
2158                                         TxRateIdx = MCS7;
2159                                 else if (MCS6 && (Rssi > (-74+RssiOffset)))
2160                                         TxRateIdx = MCS6;
2161                                 else if (MCS5 && (Rssi > (-77+RssiOffset)))
2162                                         TxRateIdx = MCS5;
2163                                 else if (MCS4 && (Rssi > (-79+RssiOffset)))
2164                                         TxRateIdx = MCS4;
2165                                 else if (MCS3 && (Rssi > (-81+RssiOffset)))
2166                                         TxRateIdx = MCS3;
2167                                 else if (MCS2 && (Rssi > (-83+RssiOffset)))
2168                                         TxRateIdx = MCS2;
2169                                 else if (MCS1 && (Rssi > (-86+RssiOffset)))
2170                                         TxRateIdx = MCS1;
2171                                 else
2172                                         TxRateIdx = MCS0;
2173                         }
2174                         else
2175                         {// Legacy mode
2176                                 if (MCS7 && (Rssi > -70))
2177                                         TxRateIdx = MCS7;
2178                                 else if (MCS6 && (Rssi > -74))
2179                                         TxRateIdx = MCS6;
2180                                 else if (MCS5 && (Rssi > -78))
2181                                         TxRateIdx = MCS5;
2182                                 else if (MCS4 && (Rssi > -82))
2183                                         TxRateIdx = MCS4;
2184                                 else if (MCS4 == 0)     // for B-only mode
2185                                         TxRateIdx = MCS3;
2186                                 else if (MCS3 && (Rssi > -85))
2187                                         TxRateIdx = MCS3;
2188                                 else if (MCS2 && (Rssi > -87))
2189                                         TxRateIdx = MCS2;
2190                                 else if (MCS1 && (Rssi > -90))
2191                                         TxRateIdx = MCS1;
2192                                 else
2193                                         TxRateIdx = MCS0;
2194                         }
2195
2196         //              if (TxRateIdx != pAd->CommonCfg.TxRateIndex)
2197                         {
2198                                 pEntry->CurrTxRateIndex = TxRateIdx;
2199                                 pNextTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(pEntry->CurrTxRateIndex+1)*5];
2200                                 MlmeSetTxRate(pAd, pEntry, pNextTxRate);
2201                         }
2202
2203                         NdisZeroMemory(pEntry->TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2204                         NdisZeroMemory(pEntry->PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2205                         pEntry->fLastSecAccordingRSSI = TRUE;
2206                         // reset all OneSecTx counters
2207                         RESET_ONE_SEC_TX_CNT(pEntry);
2208
2209                         continue;
2210                 }
2211
2212                 if (pEntry->fLastSecAccordingRSSI == TRUE)
2213                 {
2214                         pEntry->fLastSecAccordingRSSI = FALSE;
2215                         pEntry->LastSecTxRateChangeAction = 0;
2216                         // reset all OneSecTx counters
2217                         RESET_ONE_SEC_TX_CNT(pEntry);
2218
2219                         continue;
2220                 }
2221
2222                 do
2223                 {
2224                         BOOLEAN bTrainUpDown = FALSE;
2225
2226                         pEntry->CurrTxRateStableTime ++;
2227
2228                         // downgrade TX quality if PER >= Rate-Down threshold
2229                         if (TxErrorRatio >= TrainDown)
2230                         {
2231                                 bTrainUpDown = TRUE;
2232                                 pEntry->TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2233                         }
2234                         // upgrade TX quality if PER <= Rate-Up threshold
2235                         else if (TxErrorRatio <= TrainUp)
2236                         {
2237                                 bTrainUpDown = TRUE;
2238                                 bUpgradeQuality = TRUE;
2239                                 if (pEntry->TxQuality[CurrRateIdx])
2240                                         pEntry->TxQuality[CurrRateIdx] --;  // quality very good in CurrRate
2241
2242                                 if (pEntry->TxRateUpPenalty)
2243                                         pEntry->TxRateUpPenalty --;
2244                                 else if (pEntry->TxQuality[UpRateIdx])
2245                                         pEntry->TxQuality[UpRateIdx] --;    // may improve next UP rate's quality
2246                         }
2247
2248                         pEntry->PER[CurrRateIdx] = (UCHAR)TxErrorRatio;
2249
2250                         if (bTrainUpDown)
2251                         {
2252                                 // perform DRS - consider TxRate Down first, then rate up.
2253                                 if ((CurrRateIdx != DownRateIdx) && (pEntry->TxQuality[CurrRateIdx] >= DRS_TX_QUALITY_WORST_BOUND))
2254                                 {
2255                                         pEntry->CurrTxRateIndex = DownRateIdx;
2256                                 }
2257                                 else if ((CurrRateIdx != UpRateIdx) && (pEntry->TxQuality[UpRateIdx] <= 0))
2258                                 {
2259                                         pEntry->CurrTxRateIndex = UpRateIdx;
2260                                 }
2261                         }
2262                 } while (FALSE);
2263
2264                 // if rate-up happen, clear all bad history of all TX rates
2265                 if (pEntry->CurrTxRateIndex > CurrRateIdx)
2266                 {
2267                         pEntry->CurrTxRateStableTime = 0;
2268                         pEntry->TxRateUpPenalty = 0;
2269                         pEntry->LastSecTxRateChangeAction = 1; // rate UP
2270                         NdisZeroMemory(pEntry->TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2271                         NdisZeroMemory(pEntry->PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2272
2273                         //
2274                         // For TxRate fast train up
2275                         //
2276                         if (!pAd->StaCfg.StaQuickResponeForRateUpTimerRunning)
2277                         {
2278                                 RTMPSetTimer(&pAd->StaCfg.StaQuickResponeForRateUpTimer, 100);
2279
2280                                 pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = TRUE;
2281                         }
2282                         bTxRateChanged = TRUE;
2283                 }
2284                 // if rate-down happen, only clear DownRate's bad history
2285                 else if (pEntry->CurrTxRateIndex < CurrRateIdx)
2286                 {
2287                         pEntry->CurrTxRateStableTime = 0;
2288                         pEntry->TxRateUpPenalty = 0;           // no penalty
2289                         pEntry->LastSecTxRateChangeAction = 2; // rate DOWN
2290                         pEntry->TxQuality[pEntry->CurrTxRateIndex] = 0;
2291                         pEntry->PER[pEntry->CurrTxRateIndex] = 0;
2292
2293                         //
2294                         // For TxRate fast train down
2295                         //
2296                         if (!pAd->StaCfg.StaQuickResponeForRateUpTimerRunning)
2297                         {
2298                                 RTMPSetTimer(&pAd->StaCfg.StaQuickResponeForRateUpTimer, 100);
2299
2300                                 pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = TRUE;
2301                         }
2302                         bTxRateChanged = TRUE;
2303                 }
2304                 else
2305                 {
2306                         pEntry->LastSecTxRateChangeAction = 0; // rate no change
2307                         bTxRateChanged = FALSE;
2308                 }
2309
2310                 pEntry->LastTxOkCount = TxSuccess;
2311                 {
2312                         UCHAR tmpTxRate;
2313
2314                         // to fix tcp ack issue
2315                         if (!bTxRateChanged && (pAd->RalinkCounters.OneSecReceivedByteCount > (pAd->RalinkCounters.OneSecTransmittedByteCount * 5)))
2316                         {
2317                                 tmpTxRate = DownRateIdx;
2318                                 DBGPRINT_RAW(RT_DEBUG_TRACE,("DRS: Rx(%d) is 5 times larger than Tx(%d), use low rate (curr=%d, tmp=%d)\n",
2319                                         pAd->RalinkCounters.OneSecReceivedByteCount, pAd->RalinkCounters.OneSecTransmittedByteCount, pEntry->CurrTxRateIndex, tmpTxRate));
2320                         }
2321                         else
2322                         {
2323                                 tmpTxRate = pEntry->CurrTxRateIndex;
2324                         }
2325
2326                         pNextTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(tmpTxRate+1)*5];
2327                 }
2328                 if (bTxRateChanged && pNextTxRate)
2329                 {
2330                         MlmeSetTxRate(pAd, pEntry, pNextTxRate);
2331                 }
2332                 // reset all OneSecTx counters
2333                 RESET_ONE_SEC_TX_CNT(pEntry);
2334         }
2335 }
2336
2337 /*
2338         ========================================================================
2339         Routine Description:
2340                 Station side, Auto TxRate faster train up timer call back function.
2341
2342         Arguments:
2343                 SystemSpecific1                 - Not used.
2344                 FunctionContext                 - Pointer to our Adapter context.
2345                 SystemSpecific2                 - Not used.
2346                 SystemSpecific3                 - Not used.
2347
2348         Return Value:
2349                 None
2350
2351         ========================================================================
2352 */
2353 VOID StaQuickResponeForRateUpExec(
2354         IN PVOID SystemSpecific1,
2355         IN PVOID FunctionContext,
2356         IN PVOID SystemSpecific2,
2357         IN PVOID SystemSpecific3)
2358 {
2359         PRTMP_ADAPTER                   pAd = (PRTMP_ADAPTER)FunctionContext;
2360         UCHAR                                   UpRateIdx = 0, DownRateIdx = 0, CurrRateIdx = 0;
2361         ULONG                                   TxTotalCnt;
2362         ULONG                                   TxErrorRatio = 0;
2363         BOOLEAN                                 bTxRateChanged; //, bUpgradeQuality = FALSE;
2364         PRTMP_TX_RATE_SWITCH    pCurrTxRate, pNextTxRate = NULL;
2365         PUCHAR                                  pTable;
2366         UCHAR                                   TableSize = 0;
2367         UCHAR                                   InitTxRateIdx = 0, TrainUp, TrainDown;
2368         TX_STA_CNT1_STRUC               StaTx1;
2369         TX_STA_CNT0_STRUC               TxStaCnt0;
2370         CHAR                                    Rssi, ratio;
2371         ULONG                                   TxRetransmit = 0, TxSuccess = 0, TxFailCount = 0;
2372         MAC_TABLE_ENTRY                 *pEntry;
2373         ULONG                                   i;
2374
2375         pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = FALSE;
2376
2377     //
2378     // walk through MAC table, see if need to change AP's TX rate toward each entry
2379     //
2380         for (i = 1; i < MAX_LEN_OF_MAC_TABLE; i++)
2381         {
2382                 pEntry = &pAd->MacTab.Content[i];
2383
2384                 // check if this entry need to switch rate automatically
2385                 if (RTMPCheckEntryEnableAutoRateSwitch(pAd, pEntry) == FALSE)
2386                         continue;
2387
2388                 if (INFRA_ON(pAd) && (i == 1))
2389                         Rssi = RTMPMaxRssi(pAd,
2390                                                            pAd->StaCfg.RssiSample.AvgRssi0,
2391                                                            pAd->StaCfg.RssiSample.AvgRssi1,
2392                                                            pAd->StaCfg.RssiSample.AvgRssi2);
2393                 else
2394                         Rssi = RTMPMaxRssi(pAd,
2395                                                            pEntry->RssiSample.AvgRssi0,
2396                                                            pEntry->RssiSample.AvgRssi1,
2397                                                            pEntry->RssiSample.AvgRssi2);
2398
2399                 CurrRateIdx = pAd->CommonCfg.TxRateIndex;
2400
2401                         MlmeSelectTxRateTable(pAd, pEntry, &pTable, &TableSize, &InitTxRateIdx);
2402
2403                 // decide the next upgrade rate and downgrade rate, if any
2404                 if ((CurrRateIdx > 0) && (CurrRateIdx < (TableSize - 1)))
2405                 {
2406                         UpRateIdx = CurrRateIdx + 1;
2407                         DownRateIdx = CurrRateIdx -1;
2408                 }
2409                 else if (CurrRateIdx == 0)
2410                 {
2411                         UpRateIdx = CurrRateIdx + 1;
2412                         DownRateIdx = CurrRateIdx;
2413                 }
2414                 else if (CurrRateIdx == (TableSize - 1))
2415                 {
2416                         UpRateIdx = CurrRateIdx;
2417                         DownRateIdx = CurrRateIdx - 1;
2418                 }
2419
2420                 pCurrTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(CurrRateIdx+1)*5];
2421
2422                 if ((Rssi > -65) && (pCurrTxRate->Mode >= MODE_HTMIX))
2423                 {
2424                         TrainUp         = (pCurrTxRate->TrainUp + (pCurrTxRate->TrainUp >> 1));
2425                         TrainDown       = (pCurrTxRate->TrainDown + (pCurrTxRate->TrainDown >> 1));
2426                 }
2427                 else
2428                 {
2429                         TrainUp         = pCurrTxRate->TrainUp;
2430                         TrainDown       = pCurrTxRate->TrainDown;
2431                 }
2432
2433                 if (pAd->MacTab.Size == 1)
2434                 {
2435                         // Update statistic counter
2436                         RTMP_IO_READ32(pAd, TX_STA_CNT0, &TxStaCnt0.word);
2437                         RTMP_IO_READ32(pAd, TX_STA_CNT1, &StaTx1.word);
2438
2439                         TxRetransmit = StaTx1.field.TxRetransmit;
2440                         TxSuccess = StaTx1.field.TxSuccess;
2441                         TxFailCount = TxStaCnt0.field.TxFailCount;
2442                         TxTotalCnt = TxRetransmit + TxSuccess + TxFailCount;
2443
2444                         pAd->RalinkCounters.OneSecTxRetryOkCount += StaTx1.field.TxRetransmit;
2445                         pAd->RalinkCounters.OneSecTxNoRetryOkCount += StaTx1.field.TxSuccess;
2446                         pAd->RalinkCounters.OneSecTxFailCount += TxStaCnt0.field.TxFailCount;
2447                         pAd->WlanCounters.TransmittedFragmentCount.u.LowPart += StaTx1.field.TxSuccess;
2448                         pAd->WlanCounters.RetryCount.u.LowPart += StaTx1.field.TxRetransmit;
2449                         pAd->WlanCounters.FailedCount.u.LowPart += TxStaCnt0.field.TxFailCount;
2450
2451                         if (TxTotalCnt)
2452                                 TxErrorRatio = ((TxRetransmit + TxFailCount) * 100) / TxTotalCnt;
2453                 }
2454                 else
2455                 {
2456                         TxTotalCnt = pEntry->OneSecTxNoRetryOkCount +
2457                                  pEntry->OneSecTxRetryOkCount +
2458                                  pEntry->OneSecTxFailCount;
2459
2460                         if (TxTotalCnt)
2461                                 TxErrorRatio = ((pEntry->OneSecTxRetryOkCount + pEntry->OneSecTxFailCount) * 100) / TxTotalCnt;
2462                 }
2463
2464
2465                 //
2466                 // CASE 1. when TX samples are fewer than 15, then decide TX rate solely on RSSI
2467                 //         (criteria copied from RT2500 for Netopia case)
2468                 //
2469                 if (TxTotalCnt <= 12)
2470                 {
2471                         NdisZeroMemory(pAd->DrsCounters.TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2472                         NdisZeroMemory(pAd->DrsCounters.PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2473
2474                         if ((pAd->DrsCounters.LastSecTxRateChangeAction == 1) && (CurrRateIdx != DownRateIdx))
2475                         {
2476                                 pAd->CommonCfg.TxRateIndex = DownRateIdx;
2477                                 pAd->DrsCounters.TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2478                         }
2479                         else if ((pAd->DrsCounters.LastSecTxRateChangeAction == 2) && (CurrRateIdx != UpRateIdx))
2480                         {
2481                                 pAd->CommonCfg.TxRateIndex = UpRateIdx;
2482                         }
2483
2484                         DBGPRINT_RAW(RT_DEBUG_TRACE,("QuickDRS: TxTotalCnt <= 15, train back to original rate \n"));
2485                         return;
2486                 }
2487
2488                 do
2489                 {
2490                         ULONG OneSecTxNoRetryOKRationCount;
2491
2492                         if (pAd->DrsCounters.LastTimeTxRateChangeAction == 0)
2493                                 ratio = 5;
2494                         else
2495                                 ratio = 4;
2496
2497                         // downgrade TX quality if PER >= Rate-Down threshold
2498                         if (TxErrorRatio >= TrainDown)
2499                         {
2500                                 pAd->DrsCounters.TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2501                         }
2502
2503                         pAd->DrsCounters.PER[CurrRateIdx] = (UCHAR)TxErrorRatio;
2504
2505                         OneSecTxNoRetryOKRationCount = (TxSuccess * ratio);
2506
2507                         // perform DRS - consider TxRate Down first, then rate up.
2508                         if ((pAd->DrsCounters.LastSecTxRateChangeAction == 1) && (CurrRateIdx != DownRateIdx))
2509                         {
2510                                 if ((pAd->DrsCounters.LastTxOkCount + 2) >= OneSecTxNoRetryOKRationCount)
2511                                 {
2512                                         pAd->CommonCfg.TxRateIndex = DownRateIdx;
2513                                         pAd->DrsCounters.TxQuality[CurrRateIdx] = DRS_TX_QUALITY_WORST_BOUND;
2514
2515                                 }
2516
2517                         }
2518                         else if ((pAd->DrsCounters.LastSecTxRateChangeAction == 2) && (CurrRateIdx != UpRateIdx))
2519                         {
2520                                 if ((TxErrorRatio >= 50) || (TxErrorRatio >= TrainDown))
2521                                 {
2522
2523                                 }
2524                                 else if ((pAd->DrsCounters.LastTxOkCount + 2) >= OneSecTxNoRetryOKRationCount)
2525                                 {
2526                                         pAd->CommonCfg.TxRateIndex = UpRateIdx;
2527                                 }
2528                         }
2529                 }while (FALSE);
2530
2531                 // if rate-up happen, clear all bad history of all TX rates
2532                 if (pAd->CommonCfg.TxRateIndex > CurrRateIdx)
2533                 {
2534                         pAd->DrsCounters.TxRateUpPenalty = 0;
2535                         NdisZeroMemory(pAd->DrsCounters.TxQuality, sizeof(USHORT) * MAX_STEP_OF_TX_RATE_SWITCH);
2536                         NdisZeroMemory(pAd->DrsCounters.PER, sizeof(UCHAR) * MAX_STEP_OF_TX_RATE_SWITCH);
2537                         bTxRateChanged = TRUE;
2538                 }
2539                 // if rate-down happen, only clear DownRate's bad history
2540                 else if (pAd->CommonCfg.TxRateIndex < CurrRateIdx)
2541                 {
2542                         DBGPRINT_RAW(RT_DEBUG_TRACE,("QuickDRS: --TX rate from %d to %d \n", CurrRateIdx, pAd->CommonCfg.TxRateIndex));
2543
2544                         pAd->DrsCounters.TxRateUpPenalty = 0;           // no penalty
2545                         pAd->DrsCounters.TxQuality[pAd->CommonCfg.TxRateIndex] = 0;
2546                         pAd->DrsCounters.PER[pAd->CommonCfg.TxRateIndex] = 0;
2547                         bTxRateChanged = TRUE;
2548                 }
2549                 else
2550                 {
2551                         bTxRateChanged = FALSE;
2552                 }
2553
2554                 pNextTxRate = (PRTMP_TX_RATE_SWITCH) &pTable[(pAd->CommonCfg.TxRateIndex+1)*5];
2555                 if (bTxRateChanged && pNextTxRate)
2556                 {
2557                         MlmeSetTxRate(pAd, pEntry, pNextTxRate);
2558                 }
2559         }
2560 }
2561
2562 /*
2563         ==========================================================================
2564         Description:
2565                 This routine is executed periodically inside MlmePeriodicExec() after
2566                 association with an AP.
2567                 It checks if StaCfg.Psm is consistent with user policy (recorded in
2568                 StaCfg.WindowsPowerMode). If not, enforce user policy. However,
2569                 there're some conditions to consider:
2570                 1. we don't support power-saving in ADHOC mode, so Psm=PWR_ACTIVE all
2571                    the time when Mibss==TRUE
2572                 2. When link up in INFRA mode, Psm should not be switch to PWR_SAVE
2573                    if outgoing traffic available in TxRing or MgmtRing.
2574         Output:
2575                 1. change pAd->StaCfg.Psm to PWR_SAVE or leave it untouched
2576
2577         IRQL = DISPATCH_LEVEL
2578
2579         ==========================================================================
2580  */
2581 VOID MlmeCheckPsmChange(
2582         IN PRTMP_ADAPTER pAd,
2583         IN ULONG        Now32)
2584 {
2585         ULONG   PowerMode;
2586
2587         // condition -
2588         // 1. Psm maybe ON only happen in INFRASTRUCTURE mode
2589         // 2. user wants either MAX_PSP or FAST_PSP
2590         // 3. but current psm is not in PWR_SAVE
2591         // 4. CNTL state machine is not doing SCANning
2592         // 5. no TX SUCCESS event for the past 1-sec period
2593                 PowerMode = pAd->StaCfg.WindowsPowerMode;
2594
2595         if (INFRA_ON(pAd) &&
2596                 (PowerMode != Ndis802_11PowerModeCAM) &&
2597                 (pAd->StaCfg.Psm == PWR_ACTIVE) &&
2598 //              (! RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
2599                 (pAd->Mlme.CntlMachine.CurrState == CNTL_IDLE)&&
2600                 RTMP_TEST_PSFLAG(pAd, fRTMP_PS_CAN_GO_SLEEP)
2601                  /*&&
2602                 (pAd->RalinkCounters.OneSecTxNoRetryOkCount == 0) &&
2603                 (pAd->RalinkCounters.OneSecTxRetryOkCount == 0)*/)
2604         {
2605                         NdisGetSystemUpTime(&pAd->Mlme.LastSendNULLpsmTime);
2606                         pAd->RalinkCounters.RxCountSinceLastNULL = 0;
2607                 RTMP_SET_PSM_BIT(pAd, PWR_SAVE);
2608                         if (!(pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable))
2609                         {
2610                                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, FALSE);
2611                         }
2612                         else
2613                         {
2614                                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
2615                         }
2616                 }
2617 }
2618
2619 // IRQL = PASSIVE_LEVEL
2620 // IRQL = DISPATCH_LEVEL
2621 VOID MlmeSetPsmBit(
2622         IN PRTMP_ADAPTER pAd,
2623         IN USHORT psm)
2624 {
2625         AUTO_RSP_CFG_STRUC csr4;
2626
2627         pAd->StaCfg.Psm = psm;
2628         RTMP_IO_READ32(pAd, AUTO_RSP_CFG, &csr4.word);
2629         csr4.field.AckCtsPsmBit = (psm == PWR_SAVE)? 1:0;
2630         RTMP_IO_WRITE32(pAd, AUTO_RSP_CFG, csr4.word);
2631
2632         DBGPRINT(RT_DEBUG_TRACE, ("MlmeSetPsmBit = %d\n", psm));
2633 }
2634
2635 /*
2636         ==========================================================================
2637         Description:
2638                 This routine calculates TxPER, RxPER of the past N-sec period. And
2639                 according to the calculation result, ChannelQuality is calculated here
2640                 to decide if current AP is still doing the job.
2641
2642                 If ChannelQuality is not good, a ROAMing attempt may be tried later.
2643         Output:
2644                 StaCfg.ChannelQuality - 0..100
2645
2646         IRQL = DISPATCH_LEVEL
2647
2648         NOTE: This routine decide channle quality based on RX CRC error ratio.
2649                 Caller should make sure a function call to NICUpdateRawCounters(pAd)
2650                 is performed right before this routine, so that this routine can decide
2651                 channel quality based on the most up-to-date information
2652         ==========================================================================
2653  */
2654 VOID MlmeCalculateChannelQuality(
2655         IN PRTMP_ADAPTER pAd,
2656         IN PMAC_TABLE_ENTRY pMacEntry,
2657         IN ULONG Now32)
2658 {
2659         ULONG TxOkCnt, TxCnt, TxPER, TxPRR;
2660         ULONG RxCnt, RxPER;
2661         UCHAR NorRssi;
2662         CHAR  MaxRssi;
2663         RSSI_SAMPLE *pRssiSample = NULL;
2664         UINT32 OneSecTxNoRetryOkCount = 0;
2665         UINT32 OneSecTxRetryOkCount = 0;
2666         UINT32 OneSecTxFailCount = 0;
2667         UINT32 OneSecRxOkCnt = 0;
2668         UINT32 OneSecRxFcsErrCnt = 0;
2669         ULONG ChannelQuality = 0;  // 0..100, Channel Quality Indication for Roaming
2670         ULONG BeaconLostTime = pAd->StaCfg.BeaconLostTime;
2671
2672
2673         if (pAd->OpMode == OPMODE_STA)
2674         {
2675                 pRssiSample = &pAd->StaCfg.RssiSample;
2676                 OneSecTxNoRetryOkCount = pAd->RalinkCounters.OneSecTxNoRetryOkCount;
2677                 OneSecTxRetryOkCount = pAd->RalinkCounters.OneSecTxRetryOkCount;
2678                 OneSecTxFailCount = pAd->RalinkCounters.OneSecTxFailCount;
2679                 OneSecRxOkCnt = pAd->RalinkCounters.OneSecRxOkCnt;
2680                 OneSecRxFcsErrCnt = pAd->RalinkCounters.OneSecRxFcsErrCnt;
2681         }
2682
2683         MaxRssi = RTMPMaxRssi(pAd, pRssiSample->LastRssi0,
2684                                                                 pRssiSample->LastRssi1,
2685                                                                 pRssiSample->LastRssi2);
2686
2687         //
2688         // calculate TX packet error ratio and TX retry ratio - if too few TX samples, skip TX related statistics
2689         //
2690         TxOkCnt = OneSecTxNoRetryOkCount + OneSecTxRetryOkCount;
2691         TxCnt = TxOkCnt + OneSecTxFailCount;
2692         if (TxCnt < 5)
2693         {
2694                 TxPER = 0;
2695                 TxPRR = 0;
2696         }
2697         else
2698         {
2699                 TxPER = (OneSecTxFailCount * 100) / TxCnt;
2700                 TxPRR = ((TxCnt - OneSecTxNoRetryOkCount) * 100) / TxCnt;
2701         }
2702
2703         //
2704         // calculate RX PER - don't take RxPER into consideration if too few sample
2705         //
2706         RxCnt = OneSecRxOkCnt + OneSecRxFcsErrCnt;
2707         if (RxCnt < 5)
2708                 RxPER = 0;
2709         else
2710                 RxPER = (OneSecRxFcsErrCnt * 100) / RxCnt;
2711
2712         //
2713         // decide ChannelQuality based on: 1)last BEACON received time, 2)last RSSI, 3)TxPER, and 4)RxPER
2714         //
2715         if ((pAd->OpMode == OPMODE_STA) &&
2716                 INFRA_ON(pAd) &&
2717                 (OneSecTxNoRetryOkCount < 2) && // no heavy traffic
2718                 ((pAd->StaCfg.LastBeaconRxTime + BeaconLostTime) < Now32))
2719         {
2720                 DBGPRINT(RT_DEBUG_TRACE, ("BEACON lost > %ld msec with TxOkCnt=%ld -> CQI=0\n", BeaconLostTime, TxOkCnt));
2721                 ChannelQuality = 0;
2722         }
2723         else
2724         {
2725                 // Normalize Rssi
2726                 if (MaxRssi > -40)
2727                         NorRssi = 100;
2728                 else if (MaxRssi < -90)
2729                         NorRssi = 0;
2730                 else
2731                         NorRssi = (MaxRssi + 90) * 2;
2732
2733                 // ChannelQuality = W1*RSSI + W2*TxPRR + W3*RxPER        (RSSI 0..100), (TxPER 100..0), (RxPER 100..0)
2734                 ChannelQuality = (RSSI_WEIGHTING * NorRssi +
2735                                                                    TX_WEIGHTING * (100 - TxPRR) +
2736                                                                    RX_WEIGHTING* (100 - RxPER)) / 100;
2737         }
2738
2739
2740         if (pAd->OpMode == OPMODE_STA)
2741                 pAd->Mlme.ChannelQuality = (ChannelQuality > 100) ? 100 : ChannelQuality;
2742
2743
2744 }
2745
2746
2747 // IRQL = DISPATCH_LEVEL
2748 VOID MlmeSetTxPreamble(
2749         IN PRTMP_ADAPTER pAd,
2750         IN USHORT TxPreamble)
2751 {
2752         AUTO_RSP_CFG_STRUC csr4;
2753
2754         //
2755         // Always use Long preamble before verifiation short preamble functionality works well.
2756         // Todo: remove the following line if short preamble functionality works
2757         //
2758         //TxPreamble = Rt802_11PreambleLong;
2759
2760         RTMP_IO_READ32(pAd, AUTO_RSP_CFG, &csr4.word);
2761         if (TxPreamble == Rt802_11PreambleLong)
2762         {
2763                 DBGPRINT(RT_DEBUG_TRACE, ("MlmeSetTxPreamble (= LONG PREAMBLE)\n"));
2764                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);
2765                 csr4.field.AutoResponderPreamble = 0;
2766         }
2767         else
2768         {
2769                 // NOTE: 1Mbps should always use long preamble
2770                 DBGPRINT(RT_DEBUG_TRACE, ("MlmeSetTxPreamble (= SHORT PREAMBLE)\n"));
2771                 OPSTATUS_SET_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED);
2772                 csr4.field.AutoResponderPreamble = 1;
2773         }
2774
2775         RTMP_IO_WRITE32(pAd, AUTO_RSP_CFG, csr4.word);
2776 }
2777
2778 /*
2779     ==========================================================================
2780     Description:
2781         Update basic rate bitmap
2782     ==========================================================================
2783  */
2784
2785 VOID UpdateBasicRateBitmap(
2786     IN  PRTMP_ADAPTER   pAdapter)
2787 {
2788     INT  i, j;
2789                   /* 1  2  5.5, 11,  6,  9, 12, 18, 24, 36, 48,  54 */
2790     UCHAR rate[] = { 2, 4,  11, 22, 12, 18, 24, 36, 48, 72, 96, 108 };
2791     UCHAR *sup_p = pAdapter->CommonCfg.SupRate;
2792     UCHAR *ext_p = pAdapter->CommonCfg.ExtRate;
2793     ULONG bitmap = pAdapter->CommonCfg.BasicRateBitmap;
2794
2795
2796     /* if A mode, always use fix BasicRateBitMap */
2797     //if (pAdapter->CommonCfg.Channel == PHY_11A)
2798         if (pAdapter->CommonCfg.Channel > 14)
2799         pAdapter->CommonCfg.BasicRateBitmap = 0x150; /* 6, 12, 24M */
2800     /* End of if */
2801
2802     if (pAdapter->CommonCfg.BasicRateBitmap > 4095)
2803     {
2804         /* (2 ^ MAX_LEN_OF_SUPPORTED_RATES) -1 */
2805         return;
2806     } /* End of if */
2807
2808     for(i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2809     {
2810         sup_p[i] &= 0x7f;
2811         ext_p[i] &= 0x7f;
2812     } /* End of for */
2813
2814     for(i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2815     {
2816         if (bitmap & (1 << i))
2817         {
2818             for(j=0; j<MAX_LEN_OF_SUPPORTED_RATES; j++)
2819             {
2820                 if (sup_p[j] == rate[i])
2821                     sup_p[j] |= 0x80;
2822                 /* End of if */
2823             } /* End of for */
2824
2825             for(j=0; j<MAX_LEN_OF_SUPPORTED_RATES; j++)
2826             {
2827                 if (ext_p[j] == rate[i])
2828                     ext_p[j] |= 0x80;
2829                 /* End of if */
2830             } /* End of for */
2831         } /* End of if */
2832     } /* End of for */
2833 } /* End of UpdateBasicRateBitmap */
2834
2835 // IRQL = PASSIVE_LEVEL
2836 // IRQL = DISPATCH_LEVEL
2837 // bLinkUp is to identify the inital link speed.
2838 // TRUE indicates the rate update at linkup, we should not try to set the rate at 54Mbps.
2839 VOID MlmeUpdateTxRates(
2840         IN PRTMP_ADAPTER                pAd,
2841         IN      BOOLEAN                         bLinkUp,
2842         IN      UCHAR                           apidx)
2843 {
2844         int i, num;
2845         UCHAR Rate = RATE_6, MaxDesire = RATE_1, MaxSupport = RATE_1;
2846         UCHAR MinSupport = RATE_54;
2847         ULONG BasicRateBitmap = 0;
2848         UCHAR CurrBasicRate = RATE_1;
2849         UCHAR *pSupRate, SupRateLen, *pExtRate, ExtRateLen;
2850         PHTTRANSMIT_SETTING             pHtPhy = NULL;
2851         PHTTRANSMIT_SETTING             pMaxHtPhy = NULL;
2852         PHTTRANSMIT_SETTING             pMinHtPhy = NULL;
2853         BOOLEAN                                 *auto_rate_cur_p;
2854         UCHAR                                   HtMcs = MCS_AUTO;
2855
2856         // find max desired rate
2857         UpdateBasicRateBitmap(pAd);
2858
2859         num = 0;
2860         auto_rate_cur_p = NULL;
2861         for (i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
2862         {
2863                 switch (pAd->CommonCfg.DesireRate[i] & 0x7f)
2864                 {
2865                         case 2:  Rate = RATE_1;   num++;   break;
2866                         case 4:  Rate = RATE_2;   num++;   break;
2867                         case 11: Rate = RATE_5_5; num++;   break;
2868                         case 22: Rate = RATE_11;  num++;   break;
2869                         case 12: Rate = RATE_6;   num++;   break;
2870                         case 18: Rate = RATE_9;   num++;   break;
2871                         case 24: Rate = RATE_12;  num++;   break;
2872                         case 36: Rate = RATE_18;  num++;   break;
2873                         case 48: Rate = RATE_24;  num++;   break;
2874                         case 72: Rate = RATE_36;  num++;   break;
2875                         case 96: Rate = RATE_48;  num++;   break;
2876                         case 108: Rate = RATE_54; num++;   break;
2877                         //default: Rate = RATE_1;   break;
2878                 }
2879                 if (MaxDesire < Rate)  MaxDesire = Rate;
2880         }
2881
2882 //===========================================================================
2883 //===========================================================================
2884         {
2885                 pHtPhy          = &pAd->StaCfg.HTPhyMode;
2886                 pMaxHtPhy       = &pAd->StaCfg.MaxHTPhyMode;
2887                 pMinHtPhy       = &pAd->StaCfg.MinHTPhyMode;
2888
2889                 auto_rate_cur_p = &pAd->StaCfg.bAutoTxRateSwitch;
2890                 HtMcs           = pAd->StaCfg.DesiredTransmitSetting.field.MCS;
2891
2892                 if ((pAd->StaCfg.BssType == BSS_ADHOC) &&
2893                         (pAd->CommonCfg.PhyMode == PHY_11B) &&
2894                         (MaxDesire > RATE_11))
2895                 {
2896                         MaxDesire = RATE_11;
2897                 }
2898         }
2899
2900         pAd->CommonCfg.MaxDesiredRate = MaxDesire;
2901         pMinHtPhy->word = 0;
2902         pMaxHtPhy->word = 0;
2903         pHtPhy->word = 0;
2904
2905         // Auto rate switching is enabled only if more than one DESIRED RATES are
2906         // specified; otherwise disabled
2907         if (num <= 1)
2908         {
2909                 //OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2910                 //pAd->CommonCfg.bAutoTxRateSwitch      = FALSE;
2911                 *auto_rate_cur_p = FALSE;
2912         }
2913         else
2914         {
2915                 //OPSTATUS_SET_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2916                 //pAd->CommonCfg.bAutoTxRateSwitch      = TRUE;
2917                 *auto_rate_cur_p = TRUE;
2918         }
2919
2920         if (HtMcs != MCS_AUTO)
2921         {
2922                 //OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2923                 //pAd->CommonCfg.bAutoTxRateSwitch      = FALSE;
2924                 *auto_rate_cur_p = FALSE;
2925         }
2926         else
2927         {
2928                 //OPSTATUS_SET_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED);
2929                 //pAd->CommonCfg.bAutoTxRateSwitch      = TRUE;
2930                 *auto_rate_cur_p = TRUE;
2931         }
2932
2933         if ((ADHOC_ON(pAd) || INFRA_ON(pAd)) && (pAd->OpMode == OPMODE_STA))
2934         {
2935                 pSupRate = &pAd->StaActive.SupRate[0];
2936                 pExtRate = &pAd->StaActive.ExtRate[0];
2937                 SupRateLen = pAd->StaActive.SupRateLen;
2938                 ExtRateLen = pAd->StaActive.ExtRateLen;
2939         }
2940         else
2941         {
2942                 pSupRate = &pAd->CommonCfg.SupRate[0];
2943                 pExtRate = &pAd->CommonCfg.ExtRate[0];
2944                 SupRateLen = pAd->CommonCfg.SupRateLen;
2945                 ExtRateLen = pAd->CommonCfg.ExtRateLen;
2946         }
2947
2948         // find max supported rate
2949         for (i=0; i<SupRateLen; i++)
2950         {
2951                 switch (pSupRate[i] & 0x7f)
2952                 {
2953                         case 2:   Rate = RATE_1;        if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0001;       break;
2954                         case 4:   Rate = RATE_2;        if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0002;       break;
2955                         case 11:  Rate = RATE_5_5;      if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0004;       break;
2956                         case 22:  Rate = RATE_11;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0008;       break;
2957                         case 12:  Rate = RATE_6;        /*if (pSupRate[i] & 0x80)*/  BasicRateBitmap |= 0x0010;  break;
2958                         case 18:  Rate = RATE_9;        if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0020;       break;
2959                         case 24:  Rate = RATE_12;       /*if (pSupRate[i] & 0x80)*/  BasicRateBitmap |= 0x0040;  break;
2960                         case 36:  Rate = RATE_18;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0080;       break;
2961                         case 48:  Rate = RATE_24;       /*if (pSupRate[i] & 0x80)*/  BasicRateBitmap |= 0x0100;  break;
2962                         case 72:  Rate = RATE_36;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0200;       break;
2963                         case 96:  Rate = RATE_48;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0400;       break;
2964                         case 108: Rate = RATE_54;       if (pSupRate[i] & 0x80) BasicRateBitmap |= 0x0800;       break;
2965                         default:  Rate = RATE_1;        break;
2966                 }
2967                 if (MaxSupport < Rate)  MaxSupport = Rate;
2968
2969                 if (MinSupport > Rate) MinSupport = Rate;
2970         }
2971
2972         for (i=0; i<ExtRateLen; i++)
2973         {
2974                 switch (pExtRate[i] & 0x7f)
2975                 {
2976                         case 2:   Rate = RATE_1;        if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0001;       break;
2977                         case 4:   Rate = RATE_2;        if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0002;       break;
2978                         case 11:  Rate = RATE_5_5;      if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0004;       break;
2979                         case 22:  Rate = RATE_11;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0008;       break;
2980                         case 12:  Rate = RATE_6;        /*if (pExtRate[i] & 0x80)*/  BasicRateBitmap |= 0x0010;  break;
2981                         case 18:  Rate = RATE_9;        if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0020;       break;
2982                         case 24:  Rate = RATE_12;       /*if (pExtRate[i] & 0x80)*/  BasicRateBitmap |= 0x0040;  break;
2983                         case 36:  Rate = RATE_18;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0080;       break;
2984                         case 48:  Rate = RATE_24;       /*if (pExtRate[i] & 0x80)*/  BasicRateBitmap |= 0x0100;  break;
2985                         case 72:  Rate = RATE_36;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0200;       break;
2986                         case 96:  Rate = RATE_48;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0400;       break;
2987                         case 108: Rate = RATE_54;       if (pExtRate[i] & 0x80) BasicRateBitmap |= 0x0800;       break;
2988                         default:  Rate = RATE_1;        break;
2989                 }
2990                 if (MaxSupport < Rate)  MaxSupport = Rate;
2991
2992                 if (MinSupport > Rate) MinSupport = Rate;
2993         }
2994
2995         RTMP_IO_WRITE32(pAd, LEGACY_BASIC_RATE, BasicRateBitmap);
2996
2997         // bug fix
2998         // pAd->CommonCfg.BasicRateBitmap = BasicRateBitmap;
2999
3000         // calculate the exptected ACK rate for each TX rate. This info is used to caculate
3001         // the DURATION field of outgoing uniicast DATA/MGMT frame
3002         for (i=0; i<MAX_LEN_OF_SUPPORTED_RATES; i++)
3003         {
3004                 if (BasicRateBitmap & (0x01 << i))
3005                         CurrBasicRate = (UCHAR)i;
3006                 pAd->CommonCfg.ExpectedACKRate[i] = CurrBasicRate;
3007         }
3008
3009         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateTxRates[MaxSupport = %d] = MaxDesire %d Mbps\n", RateIdToMbps[MaxSupport], RateIdToMbps[MaxDesire]));
3010         // max tx rate = min {max desire rate, max supported rate}
3011         if (MaxSupport < MaxDesire)
3012                 pAd->CommonCfg.MaxTxRate = MaxSupport;
3013         else
3014                 pAd->CommonCfg.MaxTxRate = MaxDesire;
3015
3016         pAd->CommonCfg.MinTxRate = MinSupport;
3017         // 2003-07-31 john - 2500 doesn't have good sensitivity at high OFDM rates. to increase the success
3018         // ratio of initial DHCP packet exchange, TX rate starts from a lower rate depending
3019         // on average RSSI
3020         //       1. RSSI >= -70db, start at 54 Mbps (short distance)
3021         //       2. -70 > RSSI >= -75, start at 24 Mbps (mid distance)
3022         //       3. -75 > RSSI, start at 11 Mbps (long distance)
3023         //if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED)/* &&
3024         //      OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)*/)
3025         if (*auto_rate_cur_p)
3026         {
3027                 short dbm = 0;
3028
3029                 dbm = pAd->StaCfg.RssiSample.AvgRssi0 - pAd->BbpRssiToDbmDelta;
3030
3031                 if (bLinkUp == TRUE)
3032                         pAd->CommonCfg.TxRate = RATE_24;
3033                 else
3034                         pAd->CommonCfg.TxRate = pAd->CommonCfg.MaxTxRate;
3035
3036                 if (dbm < -75)
3037                         pAd->CommonCfg.TxRate = RATE_11;
3038                 else if (dbm < -70)
3039                         pAd->CommonCfg.TxRate = RATE_24;
3040
3041                 // should never exceed MaxTxRate (consider 11B-only mode)
3042                 if (pAd->CommonCfg.TxRate > pAd->CommonCfg.MaxTxRate)
3043                         pAd->CommonCfg.TxRate = pAd->CommonCfg.MaxTxRate;
3044
3045                 pAd->CommonCfg.TxRateIndex = 0;
3046         }
3047         else
3048         {
3049                 pAd->CommonCfg.TxRate = pAd->CommonCfg.MaxTxRate;
3050                 pHtPhy->field.MCS       = (pAd->CommonCfg.MaxTxRate > 3) ? (pAd->CommonCfg.MaxTxRate - 4) : pAd->CommonCfg.MaxTxRate;
3051                 pHtPhy->field.MODE      = (pAd->CommonCfg.MaxTxRate > 3) ? MODE_OFDM : MODE_CCK;
3052
3053                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.STBC    = pHtPhy->field.STBC;
3054                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.ShortGI = pHtPhy->field.ShortGI;
3055                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MCS             = pHtPhy->field.MCS;
3056                 pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MODE    = pHtPhy->field.MODE;
3057         }
3058
3059         if (pAd->CommonCfg.TxRate <= RATE_11)
3060         {
3061                 pMaxHtPhy->field.MODE = MODE_CCK;
3062                 pMaxHtPhy->field.MCS = pAd->CommonCfg.TxRate;
3063                 pMinHtPhy->field.MCS = pAd->CommonCfg.MinTxRate;
3064         }
3065         else
3066         {
3067                 pMaxHtPhy->field.MODE = MODE_OFDM;
3068                 pMaxHtPhy->field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.TxRate];
3069                 if (pAd->CommonCfg.MinTxRate >= RATE_6 && (pAd->CommonCfg.MinTxRate <= RATE_54))
3070                         {pMinHtPhy->field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MinTxRate];}
3071                 else
3072                         {pMinHtPhy->field.MCS = pAd->CommonCfg.MinTxRate;}
3073         }
3074
3075         pHtPhy->word = (pMaxHtPhy->word);
3076         if (bLinkUp && (pAd->OpMode == OPMODE_STA))
3077         {
3078                         pAd->MacTab.Content[BSSID_WCID].HTPhyMode.word = pHtPhy->word;
3079                         pAd->MacTab.Content[BSSID_WCID].MaxHTPhyMode.word = pMaxHtPhy->word;
3080                         pAd->MacTab.Content[BSSID_WCID].MinHTPhyMode.word = pMinHtPhy->word;
3081         }
3082         else
3083         {
3084                 switch (pAd->CommonCfg.PhyMode)
3085                 {
3086                         case PHY_11BG_MIXED:
3087                         case PHY_11B:
3088                         case PHY_11BGN_MIXED:
3089                                 pAd->CommonCfg.MlmeRate = RATE_1;
3090                                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_CCK;
3091                                 pAd->CommonCfg.MlmeTransmit.field.MCS = RATE_1;
3092
3093 //#ifdef        WIFI_TEST
3094                                 pAd->CommonCfg.RtsRate = RATE_11;
3095 //#else
3096 //                              pAd->CommonCfg.RtsRate = RATE_1;
3097 //#endif
3098                                 break;
3099                         case PHY_11G:
3100                         case PHY_11A:
3101                         case PHY_11AGN_MIXED:
3102                         case PHY_11GN_MIXED:
3103                         case PHY_11N_2_4G:
3104                         case PHY_11AN_MIXED:
3105                         case PHY_11N_5G:
3106                                 pAd->CommonCfg.MlmeRate = RATE_6;
3107                                 pAd->CommonCfg.RtsRate = RATE_6;
3108                                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3109                                 pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
3110                                 break;
3111                         case PHY_11ABG_MIXED:
3112                         case PHY_11ABGN_MIXED:
3113                                 if (pAd->CommonCfg.Channel <= 14)
3114         {
3115                                         pAd->CommonCfg.MlmeRate = RATE_1;
3116                                         pAd->CommonCfg.RtsRate = RATE_1;
3117                                         pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_CCK;
3118                                         pAd->CommonCfg.MlmeTransmit.field.MCS = RATE_1;
3119         }
3120                                 else
3121         {
3122                                         pAd->CommonCfg.MlmeRate = RATE_6;
3123                                         pAd->CommonCfg.RtsRate = RATE_6;
3124                                         pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3125                                         pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
3126         }
3127                                 break;
3128                         default: // error
3129                                 pAd->CommonCfg.MlmeRate = RATE_6;
3130                                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3131                                 pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
3132                                 pAd->CommonCfg.RtsRate = RATE_1;
3133                                 break;
3134                 }
3135                 //
3136                 // Keep Basic Mlme Rate.
3137                 //
3138                 pAd->MacTab.Content[MCAST_WCID].HTPhyMode.word = pAd->CommonCfg.MlmeTransmit.word;
3139                 if (pAd->CommonCfg.MlmeTransmit.field.MODE == MODE_OFDM)
3140                         pAd->MacTab.Content[MCAST_WCID].HTPhyMode.field.MCS = OfdmRateToRxwiMCS[RATE_24];
3141                 else
3142                         pAd->MacTab.Content[MCAST_WCID].HTPhyMode.field.MCS = RATE_1;
3143                 pAd->CommonCfg.BasicMlmeRate = pAd->CommonCfg.MlmeRate;
3144         }
3145
3146         DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateTxRates (MaxDesire=%d, MaxSupport=%d, MaxTxRate=%d, MinRate=%d, Rate Switching =%d)\n",
3147                          RateIdToMbps[MaxDesire], RateIdToMbps[MaxSupport], RateIdToMbps[pAd->CommonCfg.MaxTxRate], RateIdToMbps[pAd->CommonCfg.MinTxRate],
3148                          /*OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED)*/*auto_rate_cur_p));
3149         DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateTxRates (TxRate=%d, RtsRate=%d, BasicRateBitmap=0x%04lx)\n",
3150                          RateIdToMbps[pAd->CommonCfg.TxRate], RateIdToMbps[pAd->CommonCfg.RtsRate], BasicRateBitmap));
3151         DBGPRINT(RT_DEBUG_TRACE, ("MlmeUpdateTxRates (MlmeTransmit=0x%x, MinHTPhyMode=%x, MaxHTPhyMode=0x%x, HTPhyMode=0x%x)\n",
3152                          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 ));
3153 }
3154
3155 /*
3156         ==========================================================================
3157         Description:
3158                 This function update HT Rate setting.
3159                 Input Wcid value is valid for 2 case :
3160                 1. it's used for Station in infra mode that copy AP rate to Mactable.
3161                 2. OR Station   in adhoc mode to copy peer's HT rate to Mactable.
3162
3163  IRQL = DISPATCH_LEVEL
3164
3165         ==========================================================================
3166  */
3167 VOID MlmeUpdateHtTxRates(
3168         IN      PRTMP_ADAPTER   pAd,
3169         IN      UCHAR                           apidx)
3170 {
3171         UCHAR   StbcMcs; //j, StbcMcs, bitmask;
3172         CHAR    i; // 3*3
3173         RT_HT_CAPABILITY        *pRtHtCap = NULL;
3174         RT_HT_PHY_INFO          *pActiveHtPhy = NULL;
3175         ULONG           BasicMCS;
3176         UCHAR j, bitmask;
3177         PRT_HT_PHY_INFO                 pDesireHtPhy = NULL;
3178         PHTTRANSMIT_SETTING             pHtPhy = NULL;
3179         PHTTRANSMIT_SETTING             pMaxHtPhy = NULL;
3180         PHTTRANSMIT_SETTING             pMinHtPhy = NULL;
3181         BOOLEAN                                 *auto_rate_cur_p;
3182
3183         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateHtTxRates===> \n"));
3184
3185         auto_rate_cur_p = NULL;
3186
3187         {
3188                 pDesireHtPhy    = &pAd->StaCfg.DesiredHtPhyInfo;
3189                 pActiveHtPhy    = &pAd->StaCfg.DesiredHtPhyInfo;
3190                 pHtPhy          = &pAd->StaCfg.HTPhyMode;
3191                 pMaxHtPhy       = &pAd->StaCfg.MaxHTPhyMode;
3192                 pMinHtPhy       = &pAd->StaCfg.MinHTPhyMode;
3193
3194                 auto_rate_cur_p = &pAd->StaCfg.bAutoTxRateSwitch;
3195         }
3196
3197         if ((ADHOC_ON(pAd) || INFRA_ON(pAd)) && (pAd->OpMode == OPMODE_STA))
3198         {
3199                 if (pAd->StaActive.SupportedPhyInfo.bHtEnable == FALSE)
3200                         return;
3201
3202                 pRtHtCap = &pAd->StaActive.SupportedHtPhy;
3203                 pActiveHtPhy = &pAd->StaActive.SupportedPhyInfo;
3204                 StbcMcs = (UCHAR)pAd->MlmeAux.AddHtInfo.AddHtInfo3.StbcMcs;
3205                 BasicMCS =pAd->MlmeAux.AddHtInfo.MCSSet[0]+(pAd->MlmeAux.AddHtInfo.MCSSet[1]<<8)+(StbcMcs<<16);
3206                 if ((pAd->CommonCfg.DesiredHtPhy.TxSTBC) && (pRtHtCap->RxSTBC) && (pAd->Antenna.field.TxPath == 2))
3207                         pMaxHtPhy->field.STBC = STBC_USE;
3208                 else
3209                         pMaxHtPhy->field.STBC = STBC_NONE;
3210         }
3211         else
3212         {
3213                 if (pDesireHtPhy->bHtEnable == FALSE)
3214                         return;
3215
3216                 pRtHtCap = &pAd->CommonCfg.DesiredHtPhy;
3217                 StbcMcs = (UCHAR)pAd->CommonCfg.AddHTInfo.AddHtInfo3.StbcMcs;
3218                 BasicMCS = pAd->CommonCfg.AddHTInfo.MCSSet[0]+(pAd->CommonCfg.AddHTInfo.MCSSet[1]<<8)+(StbcMcs<<16);
3219                 if ((pAd->CommonCfg.DesiredHtPhy.TxSTBC) && (pRtHtCap->RxSTBC) && (pAd->Antenna.field.TxPath == 2))
3220                         pMaxHtPhy->field.STBC = STBC_USE;
3221                 else
3222                         pMaxHtPhy->field.STBC = STBC_NONE;
3223         }
3224
3225         // Decide MAX ht rate.
3226         if ((pRtHtCap->GF) && (pAd->CommonCfg.DesiredHtPhy.GF))
3227                 pMaxHtPhy->field.MODE = MODE_HTGREENFIELD;
3228         else
3229                 pMaxHtPhy->field.MODE = MODE_HTMIX;
3230
3231     if ((pAd->CommonCfg.DesiredHtPhy.ChannelWidth) && (pRtHtCap->ChannelWidth))
3232                 pMaxHtPhy->field.BW = BW_40;
3233         else
3234                 pMaxHtPhy->field.BW = BW_20;
3235
3236     if (pMaxHtPhy->field.BW == BW_20)
3237                 pMaxHtPhy->field.ShortGI = (pAd->CommonCfg.DesiredHtPhy.ShortGIfor20 & pRtHtCap->ShortGIfor20);
3238         else
3239                 pMaxHtPhy->field.ShortGI = (pAd->CommonCfg.DesiredHtPhy.ShortGIfor40 & pRtHtCap->ShortGIfor40);
3240
3241         if (pDesireHtPhy->MCSSet[4] != 0)
3242         {
3243                 pMaxHtPhy->field.MCS = 32;
3244         }
3245
3246         for (i=23; i>=0; i--) // 3*3
3247         {
3248                 j = i/8;
3249                 bitmask = (1<<(i-(j*8)));
3250
3251                 if ((pActiveHtPhy->MCSSet[j] & bitmask) && (pDesireHtPhy->MCSSet[j] & bitmask))
3252         {
3253                         pMaxHtPhy->field.MCS = i;
3254                         break;
3255         }
3256
3257                 if (i==0)
3258                         break;
3259         }
3260
3261         // Copy MIN ht rate.  rt2860???
3262         pMinHtPhy->field.BW = BW_20;
3263         pMinHtPhy->field.MCS = 0;
3264         pMinHtPhy->field.STBC = 0;
3265         pMinHtPhy->field.ShortGI = 0;
3266         //If STA assigns fixed rate. update to fixed here.
3267         if ( (pAd->OpMode == OPMODE_STA) && (pDesireHtPhy->MCSSet[0] != 0xff))
3268         {
3269                 if (pDesireHtPhy->MCSSet[4] != 0)
3270         {
3271                         pMaxHtPhy->field.MCS = 32;
3272                         pMinHtPhy->field.MCS = 32;
3273                         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateHtTxRates<=== Use Fixed MCS = %d\n",pMinHtPhy->field.MCS));
3274         }
3275
3276                 for (i=23; (CHAR)i >= 0; i--) // 3*3
3277         {
3278                         j = i/8;
3279                         bitmask = (1<<(i-(j*8)));
3280                         if ( (pDesireHtPhy->MCSSet[j] & bitmask) && (pActiveHtPhy->MCSSet[j] & bitmask))
3281                 {
3282                                 pMaxHtPhy->field.MCS = i;
3283                                 pMinHtPhy->field.MCS = i;
3284                                 break;
3285                 }
3286                         if (i==0)
3287                                 break;
3288         }
3289         }
3290
3291
3292         // Decide ht rate
3293         pHtPhy->field.STBC = pMaxHtPhy->field.STBC;
3294         pHtPhy->field.BW = pMaxHtPhy->field.BW;
3295         pHtPhy->field.MODE = pMaxHtPhy->field.MODE;
3296         pHtPhy->field.MCS = pMaxHtPhy->field.MCS;
3297         pHtPhy->field.ShortGI = pMaxHtPhy->field.ShortGI;
3298
3299         // use default now. rt2860
3300         if (pDesireHtPhy->MCSSet[0] != 0xff)
3301                 *auto_rate_cur_p = FALSE;
3302         else
3303                 *auto_rate_cur_p = TRUE;
3304
3305         DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateHtTxRates<---.AMsduSize = %d  \n", pAd->CommonCfg.DesiredHtPhy.AmsduSize ));
3306         DBGPRINT(RT_DEBUG_TRACE,("TX: MCS[0] = %x (choose %d), BW = %d, ShortGI = %d, MODE = %d,  \n", pActiveHtPhy->MCSSet[0],pHtPhy->field.MCS,
3307                 pHtPhy->field.BW, pHtPhy->field.ShortGI, pHtPhy->field.MODE));
3308         DBGPRINT(RT_DEBUG_TRACE,("MlmeUpdateHtTxRates<=== \n"));
3309 }
3310
3311
3312 VOID BATableInit(
3313         IN PRTMP_ADAPTER pAd,
3314     IN BA_TABLE *Tab)
3315 {
3316         int i;
3317
3318         Tab->numAsOriginator = 0;
3319         Tab->numAsRecipient = 0;
3320         Tab->numDoneOriginator = 0;
3321         NdisAllocateSpinLock(&pAd->BATabLock);
3322         for (i = 0; i < MAX_LEN_OF_BA_REC_TABLE; i++)
3323         {
3324                 Tab->BARecEntry[i].REC_BA_Status = Recipient_NONE;
3325                 NdisAllocateSpinLock(&(Tab->BARecEntry[i].RxReRingLock));
3326         }
3327         for (i = 0; i < MAX_LEN_OF_BA_ORI_TABLE; i++)
3328         {
3329                 Tab->BAOriEntry[i].ORI_BA_Status = Originator_NONE;
3330         }
3331 }
3332
3333 // IRQL = DISPATCH_LEVEL
3334 VOID MlmeRadioOff(
3335         IN PRTMP_ADAPTER pAd)
3336 {
3337         RTMP_MLME_RADIO_OFF(pAd);
3338 }
3339
3340 // IRQL = DISPATCH_LEVEL
3341 VOID MlmeRadioOn(
3342         IN PRTMP_ADAPTER pAd)
3343 {
3344         RTMP_MLME_RADIO_ON(pAd);
3345 }
3346
3347 // ===========================================================================================
3348 // bss_table.c
3349 // ===========================================================================================
3350
3351
3352 /*! \brief initialize BSS table
3353  *      \param p_tab pointer to the table
3354  *      \return none
3355  *      \pre
3356  *      \post
3357
3358  IRQL = PASSIVE_LEVEL
3359  IRQL = DISPATCH_LEVEL
3360
3361  */
3362 VOID BssTableInit(
3363         IN BSS_TABLE *Tab)
3364 {
3365         int i;
3366
3367         Tab->BssNr = 0;
3368     Tab->BssOverlapNr = 0;
3369         for (i = 0; i < MAX_LEN_OF_BSS_TABLE; i++)
3370                         {
3371                 NdisZeroMemory(&Tab->BssEntry[i], sizeof(BSS_ENTRY));
3372                 Tab->BssEntry[i].Rssi = -127;   // initial the rssi as a minimum value
3373         }
3374 }
3375
3376
3377 /*! \brief search the BSS table by SSID
3378  *      \param p_tab pointer to the bss table
3379  *      \param ssid SSID string
3380  *      \return index of the table, BSS_NOT_FOUND if not in the table
3381  *      \pre
3382  *      \post
3383  *      \note search by sequential search
3384
3385  IRQL = DISPATCH_LEVEL
3386
3387  */
3388 ULONG BssTableSearch(
3389         IN BSS_TABLE *Tab,
3390         IN PUCHAR        pBssid,
3391         IN UCHAR         Channel)
3392 {
3393         UCHAR i;
3394
3395         for (i = 0; i < Tab->BssNr; i++)
3396         {
3397                 //
3398                 // Some AP that support A/B/G mode that may used the same BSSID on 11A and 11B/G.
3399                 // We should distinguish this case.
3400                 //
3401                 if ((((Tab->BssEntry[i].Channel <= 14) && (Channel <= 14)) ||
3402                          ((Tab->BssEntry[i].Channel > 14) && (Channel > 14))) &&
3403                         MAC_ADDR_EQUAL(Tab->BssEntry[i].Bssid, pBssid))
3404                 {
3405                         return i;
3406                 }
3407         }
3408         return (ULONG)BSS_NOT_FOUND;
3409 }
3410
3411 ULONG BssSsidTableSearch(
3412         IN BSS_TABLE *Tab,
3413         IN PUCHAR        pBssid,
3414         IN PUCHAR        pSsid,
3415         IN UCHAR         SsidLen,
3416         IN UCHAR         Channel)
3417 {
3418         UCHAR i;
3419
3420         for (i = 0; i < Tab->BssNr; i++)
3421         {
3422                 //
3423                 // Some AP that support A/B/G mode that may used the same BSSID on 11A and 11B/G.
3424                 // We should distinguish this case.
3425                 //
3426                 if ((((Tab->BssEntry[i].Channel <= 14) && (Channel <= 14)) ||
3427                          ((Tab->BssEntry[i].Channel > 14) && (Channel > 14))) &&
3428                         MAC_ADDR_EQUAL(Tab->BssEntry[i].Bssid, pBssid) &&
3429                         SSID_EQUAL(pSsid, SsidLen, Tab->BssEntry[i].Ssid, Tab->BssEntry[i].SsidLen))
3430                 {
3431                         return i;
3432                 }
3433         }
3434         return (ULONG)BSS_NOT_FOUND;
3435 }
3436
3437 ULONG BssTableSearchWithSSID(
3438         IN BSS_TABLE *Tab,
3439         IN PUCHAR        Bssid,
3440         IN PUCHAR        pSsid,
3441         IN UCHAR         SsidLen,
3442         IN UCHAR         Channel)
3443 {
3444         UCHAR i;
3445
3446         for (i = 0; i < Tab->BssNr; i++)
3447         {
3448                 if ((((Tab->BssEntry[i].Channel <= 14) && (Channel <= 14)) ||
3449                         ((Tab->BssEntry[i].Channel > 14) && (Channel > 14))) &&
3450                         MAC_ADDR_EQUAL(&(Tab->BssEntry[i].Bssid), Bssid) &&
3451                         (SSID_EQUAL(pSsid, SsidLen, Tab->BssEntry[i].Ssid, Tab->BssEntry[i].SsidLen) ||
3452                         (NdisEqualMemory(pSsid, ZeroSsid, SsidLen)) ||
3453                         (NdisEqualMemory(Tab->BssEntry[i].Ssid, ZeroSsid, Tab->BssEntry[i].SsidLen))))
3454                 {
3455                         return i;
3456                 }
3457         }
3458         return (ULONG)BSS_NOT_FOUND;
3459 }
3460
3461
3462 ULONG BssSsidTableSearchBySSID(
3463         IN BSS_TABLE *Tab,
3464         IN PUCHAR        pSsid,
3465         IN UCHAR         SsidLen)
3466 {
3467         UCHAR i;
3468
3469         for (i = 0; i < Tab->BssNr; i++)
3470         {
3471                 if (SSID_EQUAL(pSsid, SsidLen, Tab->BssEntry[i].Ssid, Tab->BssEntry[i].SsidLen))
3472                 {
3473                         return i;
3474         }
3475         }
3476         return (ULONG)BSS_NOT_FOUND;
3477 }
3478
3479
3480 // IRQL = DISPATCH_LEVEL
3481 VOID BssTableDeleteEntry(
3482         IN OUT  BSS_TABLE *Tab,
3483         IN              PUCHAR    pBssid,
3484         IN              UCHAR     Channel)
3485 {
3486         UCHAR i, j;
3487
3488         for (i = 0; i < Tab->BssNr; i++)
3489         {
3490                 if ((Tab->BssEntry[i].Channel == Channel) &&
3491                         (MAC_ADDR_EQUAL(Tab->BssEntry[i].Bssid, pBssid)))
3492                 {
3493                         for (j = i; j < Tab->BssNr - 1; j++)
3494                         {
3495                                 NdisMoveMemory(&(Tab->BssEntry[j]), &(Tab->BssEntry[j + 1]), sizeof(BSS_ENTRY));
3496                         }
3497                         NdisZeroMemory(&(Tab->BssEntry[Tab->BssNr - 1]), sizeof(BSS_ENTRY));
3498                         Tab->BssNr -= 1;
3499                         return;
3500                 }
3501         }
3502 }
3503
3504 /*
3505         ========================================================================
3506         Routine Description:
3507                 Delete the Originator Entry in BAtable. Or decrease numAs Originator by 1 if needed.
3508
3509         Arguments:
3510         // IRQL = DISPATCH_LEVEL
3511         ========================================================================
3512 */
3513 VOID BATableDeleteORIEntry(
3514         IN OUT  PRTMP_ADAPTER pAd,
3515         IN              BA_ORI_ENTRY    *pBAORIEntry)
3516 {
3517
3518         if (pBAORIEntry->ORI_BA_Status != Originator_NONE)
3519         {
3520                 NdisAcquireSpinLock(&pAd->BATabLock);
3521                 if (pBAORIEntry->ORI_BA_Status == Originator_Done)
3522                 {
3523                         pAd->BATable.numAsOriginator -= 1;
3524                         DBGPRINT(RT_DEBUG_TRACE, ("BATableDeleteORIEntry numAsOriginator= %ld\n", pAd->BATable.numAsRecipient));
3525                         // Erase Bitmap flag.
3526                 }
3527                 pAd->MacTab.Content[pBAORIEntry->Wcid].TXBAbitmap &= (~(1<<(pBAORIEntry->TID) ));       // If STA mode,  erase flag here
3528                 pAd->MacTab.Content[pBAORIEntry->Wcid].BAOriWcidArray[pBAORIEntry->TID] = 0;    // If STA mode,  erase flag here
3529                 pBAORIEntry->ORI_BA_Status = Originator_NONE;
3530                 pBAORIEntry->Token = 1;
3531                 // Not clear Sequence here.
3532                 NdisReleaseSpinLock(&pAd->BATabLock);
3533         }
3534 }
3535
3536 /*! \brief
3537  *      \param
3538  *      \return
3539  *      \pre
3540  *      \post
3541
3542  IRQL = DISPATCH_LEVEL
3543
3544  */
3545 VOID BssEntrySet(
3546         IN PRTMP_ADAPTER pAd,
3547         OUT BSS_ENTRY *pBss,
3548         IN PUCHAR pBssid,
3549         IN CHAR Ssid[],
3550         IN UCHAR SsidLen,
3551         IN UCHAR BssType,
3552         IN USHORT BeaconPeriod,
3553         IN PCF_PARM pCfParm,
3554         IN USHORT AtimWin,
3555         IN USHORT CapabilityInfo,
3556         IN UCHAR SupRate[],
3557         IN UCHAR SupRateLen,
3558         IN UCHAR ExtRate[],
3559         IN UCHAR ExtRateLen,
3560         IN HT_CAPABILITY_IE *pHtCapability,
3561         IN ADD_HT_INFO_IE *pAddHtInfo,  // AP might use this additional ht info IE
3562         IN UCHAR                        HtCapabilityLen,
3563         IN UCHAR                        AddHtInfoLen,
3564         IN UCHAR                        NewExtChanOffset,
3565         IN UCHAR Channel,
3566         IN CHAR Rssi,
3567         IN LARGE_INTEGER TimeStamp,
3568         IN UCHAR CkipFlag,
3569         IN PEDCA_PARM pEdcaParm,
3570         IN PQOS_CAPABILITY_PARM pQosCapability,
3571         IN PQBSS_LOAD_PARM pQbssLoad,
3572         IN USHORT LengthVIE,
3573         IN PNDIS_802_11_VARIABLE_IEs pVIE)
3574 {
3575         COPY_MAC_ADDR(pBss->Bssid, pBssid);
3576         // Default Hidden SSID to be TRUE, it will be turned to FALSE after coping SSID
3577         pBss->Hidden = 1;
3578         if (SsidLen > 0)
3579         {
3580                 // For hidden SSID AP, it might send beacon with SSID len equal to 0
3581                 // Or send beacon /probe response with SSID len matching real SSID length,
3582                 // but SSID is all zero. such as "00-00-00-00" with length 4.
3583                 // We have to prevent this case overwrite correct table
3584                 if (NdisEqualMemory(Ssid, ZeroSsid, SsidLen) == 0)
3585                 {
3586                     NdisZeroMemory(pBss->Ssid, MAX_LEN_OF_SSID);
3587                         NdisMoveMemory(pBss->Ssid, Ssid, SsidLen);
3588                         pBss->SsidLen = SsidLen;
3589                         pBss->Hidden = 0;
3590                 }
3591         }
3592         else
3593                 pBss->SsidLen = 0;
3594         pBss->BssType = BssType;
3595         pBss->BeaconPeriod = BeaconPeriod;
3596         if (BssType == BSS_INFRA)
3597         {
3598                 if (pCfParm->bValid)
3599                 {
3600                         pBss->CfpCount = pCfParm->CfpCount;
3601                         pBss->CfpPeriod = pCfParm->CfpPeriod;
3602                         pBss->CfpMaxDuration = pCfParm->CfpMaxDuration;
3603                         pBss->CfpDurRemaining = pCfParm->CfpDurRemaining;
3604                 }
3605         }
3606         else
3607         {
3608                 pBss->AtimWin = AtimWin;
3609         }
3610
3611         pBss->CapabilityInfo = CapabilityInfo;
3612         // The privacy bit indicate security is ON, it maight be WEP, TKIP or AES
3613         // Combine with AuthMode, they will decide the connection methods.
3614         pBss->Privacy = CAP_IS_PRIVACY_ON(pBss->CapabilityInfo);
3615         ASSERT(SupRateLen <= MAX_LEN_OF_SUPPORTED_RATES);
3616         if (SupRateLen <= MAX_LEN_OF_SUPPORTED_RATES)
3617                 NdisMoveMemory(pBss->SupRate, SupRate, SupRateLen);
3618         else
3619                 NdisMoveMemory(pBss->SupRate, SupRate, MAX_LEN_OF_SUPPORTED_RATES);
3620         pBss->SupRateLen = SupRateLen;
3621         ASSERT(ExtRateLen <= MAX_LEN_OF_SUPPORTED_RATES);
3622         NdisMoveMemory(pBss->ExtRate, ExtRate, ExtRateLen);
3623         pBss->NewExtChanOffset = NewExtChanOffset;
3624         pBss->ExtRateLen = ExtRateLen;
3625         pBss->Channel = Channel;
3626         pBss->CentralChannel = Channel;
3627         pBss->Rssi = Rssi;
3628         // Update CkipFlag. if not exists, the value is 0x0
3629         pBss->CkipFlag = CkipFlag;
3630
3631         // New for microsoft Fixed IEs
3632         NdisMoveMemory(pBss->FixIEs.Timestamp, &TimeStamp, 8);
3633         pBss->FixIEs.BeaconInterval = BeaconPeriod;
3634         pBss->FixIEs.Capabilities = CapabilityInfo;
3635
3636         // New for microsoft Variable IEs
3637         if (LengthVIE != 0)
3638         {
3639                 pBss->VarIELen = LengthVIE;
3640                 NdisMoveMemory(pBss->VarIEs, pVIE, pBss->VarIELen);
3641         }
3642         else
3643         {
3644                 pBss->VarIELen = 0;
3645         }
3646
3647         pBss->AddHtInfoLen = 0;
3648         pBss->HtCapabilityLen = 0;
3649         if (HtCapabilityLen> 0)
3650         {
3651                 pBss->HtCapabilityLen = HtCapabilityLen;
3652                 NdisMoveMemory(&pBss->HtCapability, pHtCapability, HtCapabilityLen);
3653                 if (AddHtInfoLen > 0)
3654                 {
3655                         pBss->AddHtInfoLen = AddHtInfoLen;
3656                         NdisMoveMemory(&pBss->AddHtInfo, pAddHtInfo, AddHtInfoLen);
3657
3658                                 if ((pAddHtInfo->ControlChan > 2)&& (pAddHtInfo->AddHtInfo.ExtChanOffset == EXTCHA_BELOW) && (pHtCapability->HtCapInfo.ChannelWidth == BW_40))
3659                                 {
3660                                         pBss->CentralChannel = pAddHtInfo->ControlChan - 2;
3661                 }
3662                                 else if ((pAddHtInfo->AddHtInfo.ExtChanOffset == EXTCHA_ABOVE) && (pHtCapability->HtCapInfo.ChannelWidth == BW_40))
3663                 {
3664                                                 pBss->CentralChannel = pAddHtInfo->ControlChan + 2;
3665                                 }
3666                 }
3667         }
3668
3669         BssCipherParse(pBss);
3670
3671         // new for QOS
3672         if (pEdcaParm)
3673                 NdisMoveMemory(&pBss->EdcaParm, pEdcaParm, sizeof(EDCA_PARM));
3674         else
3675                 pBss->EdcaParm.bValid = FALSE;
3676         if (pQosCapability)
3677                 NdisMoveMemory(&pBss->QosCapability, pQosCapability, sizeof(QOS_CAPABILITY_PARM));
3678         else
3679                 pBss->QosCapability.bValid = FALSE;
3680         if (pQbssLoad)
3681                 NdisMoveMemory(&pBss->QbssLoad, pQbssLoad, sizeof(QBSS_LOAD_PARM));
3682         else
3683                 pBss->QbssLoad.bValid = FALSE;
3684
3685         {
3686                 PEID_STRUCT     pEid;
3687                 USHORT          Length = 0;
3688
3689
3690                 NdisZeroMemory(&pBss->WpaIE.IE[0], MAX_CUSTOM_LEN);
3691                 NdisZeroMemory(&pBss->RsnIE.IE[0], MAX_CUSTOM_LEN);
3692                 pEid = (PEID_STRUCT) pVIE;
3693                 while ((Length + 2 + (USHORT)pEid->Len) <= LengthVIE)
3694         {
3695                         switch(pEid->Eid)
3696                 {
3697                                 case IE_WPA:
3698                                         if (NdisEqualMemory(pEid->Octet, WPA_OUI, 4))
3699                                 {
3700                                                 if ((pEid->Len + 2) > MAX_CUSTOM_LEN)
3701                                         {
3702                                                         pBss->WpaIE.IELen = 0;
3703                                                         break;
3704                                         }
3705                                                 pBss->WpaIE.IELen = pEid->Len + 2;
3706                                                 NdisMoveMemory(pBss->WpaIE.IE, pEid, pBss->WpaIE.IELen);
3707                                 }
3708                                 break;
3709                 case IE_RSN:
3710                     if (NdisEqualMemory(pEid->Octet + 2, RSN_OUI, 3))
3711                                         {
3712                                                 if ((pEid->Len + 2) > MAX_CUSTOM_LEN)
3713                                                 {
3714                                                         pBss->RsnIE.IELen = 0;
3715                                                                 break;
3716                                         }
3717                                                 pBss->RsnIE.IELen = pEid->Len + 2;
3718                                                 NdisMoveMemory(pBss->RsnIE.IE, pEid, pBss->RsnIE.IELen);
3719                                 }
3720                                 break;
3721                 }
3722                         Length = Length + 2 + (USHORT)pEid->Len;  // Eid[1] + Len[1]+ content[Len]
3723                         pEid = (PEID_STRUCT)((UCHAR*)pEid + 2 + pEid->Len);
3724                 }
3725         }
3726 }
3727
3728 /*!
3729  *      \brief insert an entry into the bss table
3730  *      \param p_tab The BSS table
3731  *      \param Bssid BSSID
3732  *      \param ssid SSID
3733  *      \param ssid_len Length of SSID
3734  *      \param bss_type
3735  *      \param beacon_period
3736  *      \param timestamp
3737  *      \param p_cf
3738  *      \param atim_win
3739  *      \param cap
3740  *      \param rates
3741  *      \param rates_len
3742  *      \param channel_idx
3743  *      \return none
3744  *      \pre
3745  *      \post
3746  *      \note If SSID is identical, the old entry will be replaced by the new one
3747
3748  IRQL = DISPATCH_LEVEL
3749
3750  */
3751 ULONG BssTableSetEntry(
3752         IN              PRTMP_ADAPTER   pAd,
3753         OUT BSS_TABLE *Tab,
3754         IN PUCHAR pBssid,
3755         IN CHAR Ssid[],
3756         IN UCHAR SsidLen,
3757         IN UCHAR BssType,
3758         IN USHORT BeaconPeriod,
3759         IN CF_PARM *CfParm,
3760         IN USHORT AtimWin,
3761         IN USHORT CapabilityInfo,
3762         IN UCHAR SupRate[],
3763         IN UCHAR SupRateLen,
3764         IN UCHAR ExtRate[],
3765         IN UCHAR ExtRateLen,
3766         IN HT_CAPABILITY_IE *pHtCapability,
3767         IN ADD_HT_INFO_IE *pAddHtInfo,  // AP might use this additional ht info IE
3768         IN UCHAR                        HtCapabilityLen,
3769         IN UCHAR                        AddHtInfoLen,
3770         IN UCHAR                        NewExtChanOffset,
3771         IN UCHAR ChannelNo,
3772         IN CHAR Rssi,
3773         IN LARGE_INTEGER TimeStamp,
3774         IN UCHAR CkipFlag,
3775         IN PEDCA_PARM pEdcaParm,
3776         IN PQOS_CAPABILITY_PARM pQosCapability,
3777         IN PQBSS_LOAD_PARM pQbssLoad,
3778         IN USHORT LengthVIE,
3779         IN PNDIS_802_11_VARIABLE_IEs pVIE)
3780 {
3781         ULONG   Idx;
3782
3783         Idx = BssTableSearchWithSSID(Tab, pBssid,  (UCHAR *)Ssid, SsidLen, ChannelNo);
3784         if (Idx == BSS_NOT_FOUND)
3785         {
3786                 if (Tab->BssNr >= MAX_LEN_OF_BSS_TABLE)
3787             {
3788                         //
3789                         // It may happen when BSS Table was full.
3790                         // The desired AP will not be added into BSS Table
3791                         // In this case, if we found the desired AP then overwrite BSS Table.
3792                         //
3793                         if(!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
3794         {
3795                                 if (MAC_ADDR_EQUAL(pAd->MlmeAux.Bssid, pBssid) ||
3796                                         SSID_EQUAL(pAd->MlmeAux.Ssid, pAd->MlmeAux.SsidLen, Ssid, SsidLen))
3797         {
3798                                         Idx = Tab->BssOverlapNr;
3799                                         BssEntrySet(pAd, &Tab->BssEntry[Idx], pBssid, Ssid, SsidLen, BssType, BeaconPeriod, CfParm, AtimWin,
3800                                                 CapabilityInfo, SupRate, SupRateLen, ExtRate, ExtRateLen,pHtCapability, pAddHtInfo,HtCapabilityLen, AddHtInfoLen,
3801                                                 NewExtChanOffset, ChannelNo, Rssi, TimeStamp, CkipFlag, pEdcaParm, pQosCapability, pQbssLoad, LengthVIE, pVIE);
3802                     Tab->BssOverlapNr = (Tab->BssOverlapNr++) % MAX_LEN_OF_BSS_TABLE;
3803                                 }
3804                                 return Idx;
3805                                 }
3806                         else
3807                                 {
3808                         return BSS_NOT_FOUND;
3809                                 }
3810                 }
3811                 Idx = Tab->BssNr;
3812                 BssEntrySet(pAd, &Tab->BssEntry[Idx], pBssid, Ssid, SsidLen, BssType, BeaconPeriod, CfParm, AtimWin,
3813                                         CapabilityInfo, SupRate, SupRateLen, ExtRate, ExtRateLen,pHtCapability, pAddHtInfo,HtCapabilityLen, AddHtInfoLen,
3814                                         NewExtChanOffset, ChannelNo, Rssi, TimeStamp, CkipFlag, pEdcaParm, pQosCapability, pQbssLoad, LengthVIE, pVIE);
3815                 Tab->BssNr++;
3816         }
3817         else
3818         {
3819                 /* avoid  Hidden SSID form beacon to overwirite correct SSID from probe response */
3820                 if ((SSID_EQUAL(Ssid, SsidLen, Tab->BssEntry[Idx].Ssid, Tab->BssEntry[Idx].SsidLen)) ||
3821                         (NdisEqualMemory(Tab->BssEntry[Idx].Ssid, ZeroSsid, Tab->BssEntry[Idx].SsidLen)))
3822                 {
3823                         BssEntrySet(pAd, &Tab->BssEntry[Idx], pBssid, Ssid, SsidLen, BssType, BeaconPeriod,CfParm, AtimWin,
3824                                                 CapabilityInfo, SupRate, SupRateLen, ExtRate, ExtRateLen,pHtCapability, pAddHtInfo,HtCapabilityLen, AddHtInfoLen,
3825                                                 NewExtChanOffset, ChannelNo, Rssi, TimeStamp, CkipFlag, pEdcaParm, pQosCapability, pQbssLoad, LengthVIE, pVIE);
3826                 }
3827         }
3828
3829         return Idx;
3830 }
3831
3832
3833 // IRQL = DISPATCH_LEVEL
3834 VOID BssTableSsidSort(
3835         IN      PRTMP_ADAPTER   pAd,
3836         OUT BSS_TABLE *OutTab,
3837         IN      CHAR Ssid[],
3838         IN      UCHAR SsidLen)
3839 {
3840         INT i;
3841         BssTableInit(OutTab);
3842
3843         for (i = 0; i < pAd->ScanTab.BssNr; i++)
3844         {
3845                 BSS_ENTRY *pInBss = &pAd->ScanTab.BssEntry[i];
3846                 BOOLEAN bIsHiddenApIncluded = FALSE;
3847
3848                 if (((pAd->CommonCfg.bIEEE80211H == 1) &&
3849             (pAd->MlmeAux.Channel > 14) &&
3850              RadarChannelCheck(pAd, pInBss->Channel))
3851             )
3852 {
3853                         if (pInBss->Hidden)
3854                                 bIsHiddenApIncluded = TRUE;
3855 }
3856
3857                 if ((pInBss->BssType == pAd->StaCfg.BssType) &&
3858                         (SSID_EQUAL(Ssid, SsidLen, pInBss->Ssid, pInBss->SsidLen) || bIsHiddenApIncluded))
3859                 {
3860                         BSS_ENTRY *pOutBss = &OutTab->BssEntry[OutTab->BssNr];
3861
3862
3863
3864                         // 2.4G/5G N only mode
3865                         if ((pInBss->HtCapabilityLen == 0) &&
3866                                 ((pAd->CommonCfg.PhyMode == PHY_11N_2_4G) || (pAd->CommonCfg.PhyMode == PHY_11N_5G)))
3867                         {
3868                                 DBGPRINT(RT_DEBUG_TRACE,("STA is in N-only Mode, this AP don't have Ht capability in Beacon.\n"));
3869                                 continue;
3870         }
3871                         // New for WPA2
3872                         // Check the Authmode first
3873                         if (pAd->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
3874                         {
3875                                 // Check AuthMode and AuthModeAux for matching, in case AP support dual-mode
3876                                 if ((pAd->StaCfg.AuthMode != pInBss->AuthMode) && (pAd->StaCfg.AuthMode != pInBss->AuthModeAux))
3877                                         // None matched
3878                                         continue;
3879
3880                                 // Check cipher suite, AP must have more secured cipher than station setting
3881                                 if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK))
3882                                 {
3883                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3884                                         if (pInBss->WPA.bMixMode == FALSE)
3885                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA.GroupCipher)
3886                                                         continue;
3887
3888                                         // check group cipher
3889                                         if ((pAd->StaCfg.WepStatus < pInBss->WPA.GroupCipher) &&
3890                                                 (pInBss->WPA.GroupCipher != Ndis802_11GroupWEP40Enabled) &&
3891                                                 (pInBss->WPA.GroupCipher != Ndis802_11GroupWEP104Enabled))
3892                                                 continue;
3893
3894                                         // check pairwise cipher, skip if none matched
3895                                         // If profile set to AES, let it pass without question.
3896                                         // If profile set to TKIP, we must find one mateched
3897                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
3898                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipher) &&
3899                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipherAux))
3900                                                 continue;
3901                                 }
3902                                 else if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK))
3903                                 {
3904                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3905                                         if (pInBss->WPA2.bMixMode == FALSE)
3906                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA2.GroupCipher)
3907                                                         continue;
3908
3909                                         // check group cipher
3910                                         if ((pAd->StaCfg.WepStatus < pInBss->WPA.GroupCipher) &&
3911                                                 (pInBss->WPA2.GroupCipher != Ndis802_11GroupWEP40Enabled) &&
3912                                                 (pInBss->WPA2.GroupCipher != Ndis802_11GroupWEP104Enabled))
3913                                                 continue;
3914
3915                                         // check pairwise cipher, skip if none matched
3916                                         // If profile set to AES, let it pass without question.
3917                                         // If profile set to TKIP, we must find one mateched
3918                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
3919                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipher) &&
3920                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipherAux))
3921                                                 continue;
3922                                 }
3923                         }
3924                         // Bss Type matched, SSID matched.
3925                         // We will check wepstatus for qualification Bss
3926                         else if (pAd->StaCfg.WepStatus != pInBss->WepStatus)
3927                         {
3928                                 DBGPRINT(RT_DEBUG_TRACE,("StaCfg.WepStatus=%d, while pInBss->WepStatus=%d\n", pAd->StaCfg.WepStatus, pInBss->WepStatus));
3929                                 //
3930                                 // For the SESv2 case, we will not qualify WepStatus.
3931         //
3932                                 if (!pInBss->bSES)
3933                                         continue;
3934                         }
3935
3936                         // Since the AP is using hidden SSID, and we are trying to connect to ANY
3937                         // It definitely will fail. So, skip it.
3938                         // CCX also require not even try to connect it!!
3939                         if (SsidLen == 0)
3940                                 continue;
3941
3942                         // If both station and AP use 40MHz, still need to check if the 40MHZ band's legality in my country region
3943                         // If this 40MHz wideband is not allowed in my country list, use bandwidth 20MHZ instead,
3944                         if ((pInBss->CentralChannel != pInBss->Channel) &&
3945                                 (pAd->CommonCfg.RegTransmitSetting.field.BW == BW_40))
3946         {
3947                                 if (RTMPCheckChannel(pAd, pInBss->CentralChannel, pInBss->Channel) == FALSE)
3948         {
3949                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_20;
3950                                         SetCommonHT(pAd);
3951                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_40;
3952                                 }
3953                                 else
3954                                 {
3955                                         if (pAd->CommonCfg.DesiredHtPhy.ChannelWidth == BAND_WIDTH_20)
3956                                         {
3957                                                 SetCommonHT(pAd);
3958                                         }
3959                 }
3960         }
3961
3962                         // copy matching BSS from InTab to OutTab
3963                         NdisMoveMemory(pOutBss, pInBss, sizeof(BSS_ENTRY));
3964
3965                         OutTab->BssNr++;
3966                 }
3967                 else if ((pInBss->BssType == pAd->StaCfg.BssType) && (SsidLen == 0))
3968         {
3969                         BSS_ENTRY *pOutBss = &OutTab->BssEntry[OutTab->BssNr];
3970
3971
3972                         // 2.4G/5G N only mode
3973                         if ((pInBss->HtCapabilityLen == 0) &&
3974                                 ((pAd->CommonCfg.PhyMode == PHY_11N_2_4G) || (pAd->CommonCfg.PhyMode == PHY_11N_5G)))
3975                 {
3976                                 DBGPRINT(RT_DEBUG_TRACE,("STA is in N-only Mode, this AP don't have Ht capability in Beacon.\n"));
3977                                 continue;
3978                         }
3979
3980                         // New for WPA2
3981                         // Check the Authmode first
3982                         if (pAd->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
3983                         {
3984                                 // Check AuthMode and AuthModeAux for matching, in case AP support dual-mode
3985                                 if ((pAd->StaCfg.AuthMode != pInBss->AuthMode) && (pAd->StaCfg.AuthMode != pInBss->AuthModeAux))
3986                                         // None matched
3987                                         continue;
3988
3989                                 // Check cipher suite, AP must have more secured cipher than station setting
3990                                 if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK))
3991                                 {
3992                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
3993                                         if (pInBss->WPA.bMixMode == FALSE)
3994                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA.GroupCipher)
3995                                                         continue;
3996
3997                                         // check group cipher
3998                                         if (pAd->StaCfg.WepStatus < pInBss->WPA.GroupCipher)
3999                                                 continue;
4000
4001                                         // check pairwise cipher, skip if none matched
4002                                         // If profile set to AES, let it pass without question.
4003                                         // If profile set to TKIP, we must find one mateched
4004                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
4005                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipher) &&
4006                                                 (pAd->StaCfg.WepStatus != pInBss->WPA.PairCipherAux))
4007                                                 continue;
4008                                 }
4009                                 else if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) || (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK))
4010                                 {
4011                                         // If it's not mixed mode, we should only let BSS pass with the same encryption
4012                                         if (pInBss->WPA2.bMixMode == FALSE)
4013                                                 if (pAd->StaCfg.WepStatus != pInBss->WPA2.GroupCipher)
4014                                                         continue;
4015
4016                                         // check group cipher
4017                                         if (pAd->StaCfg.WepStatus < pInBss->WPA2.GroupCipher)
4018                                                 continue;
4019
4020                                         // check pairwise cipher, skip if none matched
4021                                         // If profile set to AES, let it pass without question.
4022                                         // If profile set to TKIP, we must find one mateched
4023                                         if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) &&
4024                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipher) &&
4025                                                 (pAd->StaCfg.WepStatus != pInBss->WPA2.PairCipherAux))
4026                                                 continue;
4027                                 }
4028                         }
4029                         // Bss Type matched, SSID matched.
4030                         // We will check wepstatus for qualification Bss
4031                         else if (pAd->StaCfg.WepStatus != pInBss->WepStatus)
4032                                         continue;
4033
4034                         // If both station and AP use 40MHz, still need to check if the 40MHZ band's legality in my country region
4035                         // If this 40MHz wideband is not allowed in my country list, use bandwidth 20MHZ instead,
4036                         if ((pInBss->CentralChannel != pInBss->Channel) &&
4037                                 (pAd->CommonCfg.RegTransmitSetting.field.BW == BW_40))
4038                                 {
4039                                 if (RTMPCheckChannel(pAd, pInBss->CentralChannel, pInBss->Channel) == FALSE)
4040                                 {
4041                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_20;
4042                                         SetCommonHT(pAd);
4043                                         pAd->CommonCfg.RegTransmitSetting.field.BW = BW_40;
4044                                 }
4045                                 }
4046
4047                         // copy matching BSS from InTab to OutTab
4048                         NdisMoveMemory(pOutBss, pInBss, sizeof(BSS_ENTRY));
4049
4050                         OutTab->BssNr++;
4051                 }
4052
4053                 if (OutTab->BssNr >= MAX_LEN_OF_BSS_TABLE)
4054                                 break;
4055                         }
4056
4057         BssTableSortByRssi(OutTab);
4058 }
4059
4060
4061 // IRQL = DISPATCH_LEVEL
4062 VOID BssTableSortByRssi(
4063         IN OUT BSS_TABLE *OutTab)
4064 {
4065         INT       i, j;
4066         BSS_ENTRY TmpBss;
4067
4068         for (i = 0; i < OutTab->BssNr - 1; i++)
4069                         {
4070                 for (j = i+1; j < OutTab->BssNr; j++)
4071                                 {
4072                         if (OutTab->BssEntry[j].Rssi > OutTab->BssEntry[i].Rssi)
4073                                         {
4074                                 NdisMoveMemory(&TmpBss, &OutTab->BssEntry[j], sizeof(BSS_ENTRY));
4075                                 NdisMoveMemory(&OutTab->BssEntry[j], &OutTab->BssEntry[i], sizeof(BSS_ENTRY));
4076                                 NdisMoveMemory(&OutTab->BssEntry[i], &TmpBss, sizeof(BSS_ENTRY));
4077                                         }
4078                                         }
4079                                         }
4080 }
4081
4082
4083 VOID BssCipherParse(
4084         IN OUT  PBSS_ENTRY      pBss)
4085 {
4086         PEID_STRUCT              pEid;
4087         PUCHAR                          pTmp;
4088         PRSN_IE_HEADER_STRUCT                   pRsnHeader;
4089         PCIPHER_SUITE_STRUCT                    pCipher;
4090         PAKM_SUITE_STRUCT                               pAKM;
4091         USHORT                                                  Count;
4092         INT                                                             Length;
4093         NDIS_802_11_ENCRYPTION_STATUS   TmpCipher;
4094
4095         //
4096         // WepStatus will be reset later, if AP announce TKIP or AES on the beacon frame.
4097         //
4098         if (pBss->Privacy)
4099                                                 {
4100                 pBss->WepStatus         = Ndis802_11WEPEnabled;
4101                                         }
4102                                         else
4103                                         {
4104                 pBss->WepStatus         = Ndis802_11WEPDisabled;
4105                                         }
4106         // Set default to disable & open authentication before parsing variable IE
4107         pBss->AuthMode          = Ndis802_11AuthModeOpen;
4108         pBss->AuthModeAux       = Ndis802_11AuthModeOpen;
4109
4110         // Init WPA setting
4111         pBss->WPA.PairCipher    = Ndis802_11WEPDisabled;
4112         pBss->WPA.PairCipherAux = Ndis802_11WEPDisabled;
4113         pBss->WPA.GroupCipher   = Ndis802_11WEPDisabled;
4114         pBss->WPA.RsnCapability = 0;
4115         pBss->WPA.bMixMode              = FALSE;
4116
4117         // Init WPA2 setting
4118         pBss->WPA2.PairCipher    = Ndis802_11WEPDisabled;
4119         pBss->WPA2.PairCipherAux = Ndis802_11WEPDisabled;
4120         pBss->WPA2.GroupCipher   = Ndis802_11WEPDisabled;
4121         pBss->WPA2.RsnCapability = 0;
4122         pBss->WPA2.bMixMode      = FALSE;
4123
4124
4125         Length = (INT) pBss->VarIELen;
4126
4127         while (Length > 0)
4128             {
4129                 // Parse cipher suite base on WPA1 & WPA2, they should be parsed differently
4130                 pTmp = ((PUCHAR) pBss->VarIEs) + pBss->VarIELen - Length;
4131                 pEid = (PEID_STRUCT) pTmp;
4132                 switch (pEid->Eid)
4133             {
4134                         case IE_WPA:
4135                                 if (NdisEqualMemory(pEid->Octet, SES_OUI, 3) && (pEid->Len == 7))
4136                 {
4137                                         pBss->bSES = TRUE;
4138                                         break;
4139                 }
4140                                 else if (NdisEqualMemory(pEid->Octet, WPA_OUI, 4) != 1)
4141                 {
4142                                         // if unsupported vendor specific IE
4143                                         break;
4144                 }
4145                                 // Skip OUI, version, and multicast suite
4146                                 // This part should be improved in the future when AP supported multiple cipher suite.
4147                                 // For now, it's OK since almost all APs have fixed cipher suite supported.
4148                                 // pTmp = (PUCHAR) pEid->Octet;
4149                                 pTmp   += 11;
4150
4151                                 // Cipher Suite Selectors from Spec P802.11i/D3.2 P26.
4152                                 //      Value      Meaning
4153                                 //      0                       None
4154                                 //      1                       WEP-40
4155                                 //      2                       Tkip
4156                                 //      3                       WRAP
4157                                 //      4                       AES
4158                                 //      5                       WEP-104
4159                                 // Parse group cipher
4160                                 switch (*pTmp)
4161         {
4162                                         case 1:
4163                                                 pBss->WPA.GroupCipher = Ndis802_11GroupWEP40Enabled;
4164                                                 break;
4165                                         case 5:
4166                                                 pBss->WPA.GroupCipher = Ndis802_11GroupWEP104Enabled;
4167                                                 break;
4168                                         case 2:
4169                                                 pBss->WPA.GroupCipher = Ndis802_11Encryption2Enabled;
4170                                                 break;
4171                                         case 4:
4172                                                 pBss->WPA.GroupCipher = Ndis802_11Encryption3Enabled;
4173                                                 break;
4174                                         default:
4175                                                 break;
4176                                 }
4177                                 // number of unicast suite
4178                                 pTmp   += 1;
4179
4180                                 // skip all unicast cipher suites
4181                                 //Count = *(PUSHORT) pTmp;
4182                                 Count = (pTmp[1]<<8) + pTmp[0];
4183                                 pTmp   += sizeof(USHORT);
4184
4185                                 // Parsing all unicast cipher suite
4186                                 while (Count > 0)
4187                 {
4188                                         // Skip OUI
4189                                         pTmp += 3;
4190                                         TmpCipher = Ndis802_11WEPDisabled;
4191                                         switch (*pTmp)
4192                 {
4193                                                 case 1:
4194                                                 case 5: // Although WEP is not allowed in WPA related auth mode, we parse it anyway
4195                                                         TmpCipher = Ndis802_11Encryption1Enabled;
4196                                                         break;
4197                                                 case 2:
4198                                                         TmpCipher = Ndis802_11Encryption2Enabled;
4199                                                         break;
4200                                                 case 4:
4201                                                         TmpCipher = Ndis802_11Encryption3Enabled;
4202                                                         break;
4203                                                 default:
4204                                                         break;
4205                 }
4206                                         if (TmpCipher > pBss->WPA.PairCipher)
4207                 {
4208                                                 // Move the lower cipher suite to PairCipherAux
4209                                                 pBss->WPA.PairCipherAux = pBss->WPA.PairCipher;
4210                                                 pBss->WPA.PairCipher    = TmpCipher;
4211         }
4212                                         else
4213                 {
4214                                                 pBss->WPA.PairCipherAux = TmpCipher;
4215         }
4216                                         pTmp++;
4217                                         Count--;
4218         }
4219
4220                                 // 4. get AKM suite counts
4221                                 //Count = *(PUSHORT) pTmp;
4222                                 Count = (pTmp[1]<<8) + pTmp[0];
4223                                 pTmp   += sizeof(USHORT);
4224                                 pTmp   += 3;
4225
4226                                 switch (*pTmp)
4227                 {
4228                                         case 1:
4229                                                 // Set AP support WPA-enterprise mode
4230                                                 if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4231                                                         pBss->AuthMode = Ndis802_11AuthModeWPA;
4232         else
4233                                                         pBss->AuthModeAux = Ndis802_11AuthModeWPA;
4234                                                 break;
4235                                         case 2:
4236                                                 // Set AP support WPA-PSK mode
4237                                                 if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4238                                                         pBss->AuthMode = Ndis802_11AuthModeWPAPSK;
4239                 else
4240                                                         pBss->AuthModeAux = Ndis802_11AuthModeWPAPSK;
4241                                                 break;
4242                                         default:
4243                                                 break;
4244         }
4245                                 pTmp   += 1;
4246
4247                                 // Fixed for WPA-None
4248                                 if (pBss->BssType == BSS_ADHOC)
4249                 {
4250                                         pBss->AuthMode    = Ndis802_11AuthModeWPANone;
4251                                         pBss->AuthModeAux = Ndis802_11AuthModeWPANone;
4252                                         pBss->WepStatus   = pBss->WPA.GroupCipher;
4253                                         // Patched bugs for old driver
4254                                         if (pBss->WPA.PairCipherAux == Ndis802_11WEPDisabled)
4255                                                 pBss->WPA.PairCipherAux = pBss->WPA.GroupCipher;
4256                 }
4257                 else
4258                                         pBss->WepStatus   = pBss->WPA.PairCipher;
4259
4260                                 // Check the Pair & Group, if different, turn on mixed mode flag
4261                                 if (pBss->WPA.GroupCipher != pBss->WPA.PairCipher)
4262                                         pBss->WPA.bMixMode = TRUE;
4263
4264                                 break;
4265
4266                         case IE_RSN:
4267                                 pRsnHeader = (PRSN_IE_HEADER_STRUCT) pTmp;
4268
4269                                 // 0. Version must be 1
4270                                 if (le2cpu16(pRsnHeader->Version) != 1)
4271                                         break;
4272                                 pTmp   += sizeof(RSN_IE_HEADER_STRUCT);
4273
4274                                 // 1. Check group cipher
4275                                 pCipher = (PCIPHER_SUITE_STRUCT) pTmp;
4276                                 if (!RTMPEqualMemory(pTmp, RSN_OUI, 3))
4277                                                 break;
4278
4279                                 // Parse group cipher
4280                                 switch (pCipher->Type)
4281                                 {
4282                                         case 1:
4283                                                 pBss->WPA2.GroupCipher = Ndis802_11GroupWEP40Enabled;
4284                                                 break;
4285                                         case 5:
4286                                                 pBss->WPA2.GroupCipher = Ndis802_11GroupWEP104Enabled;
4287                                                 break;
4288                                         case 2:
4289                                                 pBss->WPA2.GroupCipher = Ndis802_11Encryption2Enabled;
4290                                                 break;
4291                                         case 4:
4292                                                 pBss->WPA2.GroupCipher = Ndis802_11Encryption3Enabled;
4293                                                 break;
4294                                         default:
4295                                                 break;
4296                                 }
4297                                 // set to correct offset for next parsing
4298                                 pTmp   += sizeof(CIPHER_SUITE_STRUCT);
4299
4300                                 // 2. Get pairwise cipher counts
4301                                 //Count = *(PUSHORT) pTmp;
4302                                 Count = (pTmp[1]<<8) + pTmp[0];
4303                                 pTmp   += sizeof(USHORT);
4304
4305                                 // 3. Get pairwise cipher
4306                                 // Parsing all unicast cipher suite
4307                                 while (Count > 0)
4308         {
4309                                         // Skip OUI
4310                                         pCipher = (PCIPHER_SUITE_STRUCT) pTmp;
4311                                         TmpCipher = Ndis802_11WEPDisabled;
4312                                         switch (pCipher->Type)
4313         {
4314                                                 case 1:
4315                                                 case 5: // Although WEP is not allowed in WPA related auth mode, we parse it anyway
4316                                                         TmpCipher = Ndis802_11Encryption1Enabled;
4317                                                         break;
4318                                                 case 2:
4319                                                         TmpCipher = Ndis802_11Encryption2Enabled;
4320                                                         break;
4321                                                 case 4:
4322                                                         TmpCipher = Ndis802_11Encryption3Enabled;
4323                                                         break;
4324                                                 default:
4325                                                         break;
4326         }
4327                                         if (TmpCipher > pBss->WPA2.PairCipher)
4328         {
4329                                                 // Move the lower cipher suite to PairCipherAux
4330                                                 pBss->WPA2.PairCipherAux = pBss->WPA2.PairCipher;
4331                                                 pBss->WPA2.PairCipher    = TmpCipher;
4332         }
4333                                         else
4334         {
4335                                                 pBss->WPA2.PairCipherAux = TmpCipher;
4336         }
4337                                         pTmp += sizeof(CIPHER_SUITE_STRUCT);
4338                                         Count--;
4339         }
4340
4341                                 // 4. get AKM suite counts
4342                                 //Count = *(PUSHORT) pTmp;
4343                                 Count = (pTmp[1]<<8) + pTmp[0];
4344                                 pTmp   += sizeof(USHORT);
4345
4346                                 // 5. Get AKM ciphers
4347                                 // Parsing all AKM ciphers
4348                                 while (Count > 0)
4349                         {
4350                                         pAKM = (PAKM_SUITE_STRUCT) pTmp;
4351                                         if (!RTMPEqualMemory(pTmp, RSN_OUI, 3))
4352                                                 break;
4353
4354                                         switch (pAKM->Type)
4355                                 {
4356                                                 case 1:
4357                                                         // Set AP support WPA-enterprise mode
4358                                                         if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4359                                                                 pBss->AuthMode = Ndis802_11AuthModeWPA2;
4360                                 else
4361                                                                 pBss->AuthModeAux = Ndis802_11AuthModeWPA2;
4362                                                         break;
4363                                                 case 2:
4364                                                         // Set AP support WPA-PSK mode
4365                                                         if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4366                                                                 pBss->AuthMode = Ndis802_11AuthModeWPA2PSK;
4367                                                         else
4368                                                                 pBss->AuthModeAux = Ndis802_11AuthModeWPA2PSK;
4369                                                         break;
4370                                                 default:
4371                                                         if (pBss->AuthMode == Ndis802_11AuthModeOpen)
4372                                                                 pBss->AuthMode = Ndis802_11AuthModeMax;
4373                                                         else
4374                                                                 pBss->AuthModeAux = Ndis802_11AuthModeMax;
4375                                                         break;
4376                                 }
4377                                         pTmp   += (Count * sizeof(AKM_SUITE_STRUCT));
4378                                         Count--;
4379                         }
4380
4381                                 // Fixed for WPA-None
4382                                 if (pBss->BssType == BSS_ADHOC)
4383                                 {
4384                                         pBss->AuthMode = Ndis802_11AuthModeWPANone;
4385                                         pBss->AuthModeAux = Ndis802_11AuthModeWPANone;
4386                                         pBss->WPA.PairCipherAux = pBss->WPA2.PairCipherAux;
4387                                         pBss->WPA.GroupCipher   = pBss->WPA2.GroupCipher;
4388                                         pBss->WepStatus                 = pBss->WPA.GroupCipher;
4389                                         // Patched bugs for old driver
4390                                         if (pBss->WPA.PairCipherAux == Ndis802_11WEPDisabled)
4391                                                 pBss->WPA.PairCipherAux = pBss->WPA.GroupCipher;
4392         }
4393                                 pBss->WepStatus   = pBss->WPA2.PairCipher;
4394
4395                                 // 6. Get RSN capability
4396                                 //pBss->WPA2.RsnCapability = *(PUSHORT) pTmp;
4397                                 pBss->WPA2.RsnCapability = (pTmp[1]<<8) + pTmp[0];
4398                                 pTmp += sizeof(USHORT);
4399
4400                                 // Check the Pair & Group, if different, turn on mixed mode flag
4401                                 if (pBss->WPA2.GroupCipher != pBss->WPA2.PairCipher)
4402                                         pBss->WPA2.bMixMode = TRUE;
4403
4404                                 break;
4405                         default:
4406                                 break;
4407                 }
4408                 Length -= (pEid->Len + 2);
4409         }
4410 }
4411
4412 // ===========================================================================================
4413 // mac_table.c
4414 // ===========================================================================================
4415
4416 /*! \brief generates a random mac address value for IBSS BSSID
4417  *      \param Addr the bssid location
4418  *      \return none
4419  *      \pre
4420  *      \post
4421  */
4422 VOID MacAddrRandomBssid(
4423         IN PRTMP_ADAPTER pAd,
4424         OUT PUCHAR pAddr)
4425 {
4426         INT i;
4427
4428         for (i = 0; i < MAC_ADDR_LEN; i++)
4429         {
4430                 pAddr[i] = RandomByte(pAd);
4431         }
4432
4433         pAddr[0] = (pAddr[0] & 0xfe) | 0x02;  // the first 2 bits must be 01xxxxxxxx
4434 }
4435
4436 /*! \brief init the management mac frame header
4437  *      \param p_hdr mac header
4438  *      \param subtype subtype of the frame
4439  *      \param p_ds destination address, don't care if it is a broadcast address
4440  *      \return none
4441  *      \pre the station has the following information in the pAd->StaCfg
4442  *       - bssid
4443  *       - station address
4444  *      \post
4445  *      \note this function initializes the following field
4446
4447         IRQL = PASSIVE_LEVEL
4448         IRQL = DISPATCH_LEVEL
4449
4450  */
4451 VOID MgtMacHeaderInit(
4452         IN      PRTMP_ADAPTER   pAd,
4453         IN OUT PHEADER_802_11 pHdr80211,
4454         IN UCHAR SubType,
4455         IN UCHAR ToDs,
4456         IN PUCHAR pDA,
4457         IN PUCHAR pBssid)
4458 {
4459         NdisZeroMemory(pHdr80211, sizeof(HEADER_802_11));
4460
4461         pHdr80211->FC.Type = BTYPE_MGMT;
4462         pHdr80211->FC.SubType = SubType;
4463 //      if (SubType == SUBTYPE_ACK)     // sample, no use, it will conflict with ACTION frame sub type
4464 //              pHdr80211->FC.Type = BTYPE_CNTL;
4465         pHdr80211->FC.ToDs = ToDs;
4466         COPY_MAC_ADDR(pHdr80211->Addr1, pDA);
4467                 COPY_MAC_ADDR(pHdr80211->Addr2, pAd->CurrentAddress);
4468         COPY_MAC_ADDR(pHdr80211->Addr3, pBssid);
4469 }
4470
4471 // ===========================================================================================
4472 // mem_mgmt.c
4473 // ===========================================================================================
4474
4475 /*!***************************************************************************
4476  * This routine build an outgoing frame, and fill all information specified
4477  * in argument list to the frame body. The actual frame size is the summation
4478  * of all arguments.
4479  * input params:
4480  *              Buffer - pointer to a pre-allocated memory segment
4481  *              args - a list of <int arg_size, arg> pairs.
4482  *              NOTE NOTE NOTE!!!! the last argument must be NULL, otherwise this
4483  *                                                 function will FAIL!!!
4484  * return:
4485  *              Size of the buffer
4486  * usage:
4487  *              MakeOutgoingFrame(Buffer, output_length, 2, &fc, 2, &dur, 6, p_addr1, 6,p_addr2, END_OF_ARGS);
4488
4489  IRQL = PASSIVE_LEVEL
4490         IRQL = DISPATCH_LEVEL
4491
4492  ****************************************************************************/
4493 ULONG MakeOutgoingFrame(
4494         OUT UCHAR *Buffer,
4495         OUT ULONG *FrameLen, ...)
4496 {
4497         UCHAR   *p;
4498         int     leng;
4499         ULONG   TotLeng;
4500         va_list Args;
4501
4502         // calculates the total length
4503         TotLeng = 0;
4504         va_start(Args, FrameLen);
4505         do
4506         {
4507                 leng = va_arg(Args, int);
4508                 if (leng == END_OF_ARGS)
4509                 {
4510                         break;
4511         }
4512                 p = va_arg(Args, PVOID);
4513                 NdisMoveMemory(&Buffer[TotLeng], p, leng);
4514                 TotLeng = TotLeng + leng;
4515         } while(TRUE);
4516
4517         va_end(Args); /* clean up */
4518         *FrameLen = TotLeng;
4519         return TotLeng;
4520 }
4521
4522 // ===========================================================================================
4523 // mlme_queue.c
4524 // ===========================================================================================
4525
4526 /*! \brief      Initialize The MLME Queue, used by MLME Functions
4527  *      \param  *Queue     The MLME Queue
4528  *      \return Always     Return NDIS_STATE_SUCCESS in this implementation
4529  *      \pre
4530  *      \post
4531  *      \note   Because this is done only once (at the init stage), no need to be locked
4532
4533  IRQL = PASSIVE_LEVEL
4534
4535  */
4536 NDIS_STATUS MlmeQueueInit(
4537         IN MLME_QUEUE *Queue)
4538 {
4539         INT i;
4540
4541         NdisAllocateSpinLock(&Queue->Lock);
4542
4543         Queue->Num      = 0;
4544         Queue->Head = 0;
4545         Queue->Tail = 0;
4546
4547         for (i = 0; i < MAX_LEN_OF_MLME_QUEUE; i++)
4548         {
4549                 Queue->Entry[i].Occupied = FALSE;
4550                 Queue->Entry[i].MsgLen = 0;
4551                 NdisZeroMemory(Queue->Entry[i].Msg, MGMT_DMA_BUFFER_SIZE);
4552         }
4553
4554         return NDIS_STATUS_SUCCESS;
4555 }
4556
4557 /*! \brief       Enqueue a message for other threads, if they want to send messages to MLME thread
4558  *      \param  *Queue    The MLME Queue
4559  *      \param   Machine  The State Machine Id
4560  *      \param   MsgType  The Message Type
4561  *      \param   MsgLen   The Message length
4562  *      \param  *Msg      The message pointer
4563  *      \return  TRUE if enqueue is successful, FALSE if the queue is full
4564  *      \pre
4565  *      \post
4566  *      \note    The message has to be initialized
4567
4568         IRQL = PASSIVE_LEVEL
4569         IRQL = DISPATCH_LEVEL
4570
4571  */
4572 BOOLEAN MlmeEnqueue(
4573         IN PRTMP_ADAPTER pAd,
4574         IN ULONG Machine,
4575         IN ULONG MsgType,
4576         IN ULONG MsgLen,
4577         IN VOID *Msg)
4578 {
4579         INT Tail;
4580         MLME_QUEUE      *Queue = (MLME_QUEUE *)&pAd->Mlme.Queue;
4581
4582         // Do nothing if the driver is starting halt state.
4583         // This might happen when timer already been fired before cancel timer with mlmehalt
4584         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST))
4585                 return FALSE;
4586
4587         // First check the size, it MUST not exceed the mlme queue size
4588         if (MsgLen > MGMT_DMA_BUFFER_SIZE)
4589                 {
4590                 DBGPRINT_ERR(("MlmeEnqueue: msg too large, size = %ld \n", MsgLen));
4591                 return FALSE;
4592         }
4593
4594         if (MlmeQueueFull(Queue))
4595                 {
4596                 return FALSE;
4597                         }
4598
4599         NdisAcquireSpinLock(&(Queue->Lock));
4600         Tail = Queue->Tail;
4601         Queue->Tail++;
4602         Queue->Num++;
4603         if (Queue->Tail == MAX_LEN_OF_MLME_QUEUE)
4604                         {
4605                 Queue->Tail = 0;
4606                 }
4607
4608         Queue->Entry[Tail].Wcid = RESERVED_WCID;
4609         Queue->Entry[Tail].Occupied = TRUE;
4610         Queue->Entry[Tail].Machine = Machine;
4611         Queue->Entry[Tail].MsgType = MsgType;
4612         Queue->Entry[Tail].MsgLen  = MsgLen;
4613
4614         if (Msg != NULL)
4615                         {
4616                 NdisMoveMemory(Queue->Entry[Tail].Msg, Msg, MsgLen);
4617                 }
4618
4619         NdisReleaseSpinLock(&(Queue->Lock));
4620         return TRUE;
4621 }
4622
4623 /*! \brief       This function is used when Recv gets a MLME message
4624  *      \param  *Queue                   The MLME Queue
4625  *      \param   TimeStampHigh   The upper 32 bit of timestamp
4626  *      \param   TimeStampLow    The lower 32 bit of timestamp
4627  *      \param   Rssi                    The receiving RSSI strength
4628  *      \param   MsgLen                  The length of the message
4629  *      \param  *Msg                     The message pointer
4630  *      \return  TRUE if everything ok, FALSE otherwise (like Queue Full)
4631  *      \pre
4632  *      \post
4633
4634  IRQL = DISPATCH_LEVEL
4635
4636  */
4637 BOOLEAN MlmeEnqueueForRecv(
4638         IN      PRTMP_ADAPTER   pAd,
4639         IN ULONG Wcid,
4640         IN ULONG TimeStampHigh,
4641         IN ULONG TimeStampLow,
4642         IN UCHAR Rssi0,
4643         IN UCHAR Rssi1,
4644         IN UCHAR Rssi2,
4645         IN ULONG MsgLen,
4646         IN VOID *Msg,
4647         IN UCHAR Signal)
4648 {
4649         INT              Tail, Machine;
4650         PFRAME_802_11 pFrame = (PFRAME_802_11)Msg;
4651         INT              MsgType;
4652         MLME_QUEUE      *Queue = (MLME_QUEUE *)&pAd->Mlme.Queue;
4653
4654
4655         // Do nothing if the driver is starting halt state.
4656         // This might happen when timer already been fired before cancel timer with mlmehalt
4657         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST))
4658         {
4659                 DBGPRINT_ERR(("MlmeEnqueueForRecv: fRTMP_ADAPTER_HALT_IN_PROGRESS\n"));
4660                 return FALSE;
4661         }
4662
4663         // First check the size, it MUST not exceed the mlme queue size
4664         if (MsgLen > MGMT_DMA_BUFFER_SIZE)
4665         {
4666                 DBGPRINT_ERR(("MlmeEnqueueForRecv: frame too large, size = %ld \n", MsgLen));
4667                 return FALSE;
4668         }
4669
4670         if (MlmeQueueFull(Queue))
4671                 {
4672                 return FALSE;
4673         }
4674
4675                         {
4676                 if (!MsgTypeSubst(pAd, pFrame, &Machine, &MsgType))
4677                 {
4678                         DBGPRINT_ERR(("MlmeEnqueueForRecv: un-recongnized mgmt->subtype=%d\n",pFrame->Hdr.FC.SubType));
4679                         return FALSE;
4680                         }
4681                 }
4682
4683         // OK, we got all the informations, it is time to put things into queue
4684         NdisAcquireSpinLock(&(Queue->Lock));
4685         Tail = Queue->Tail;
4686         Queue->Tail++;
4687         Queue->Num++;
4688         if (Queue->Tail == MAX_LEN_OF_MLME_QUEUE)
4689                 {
4690                 Queue->Tail = 0;
4691                 }
4692         Queue->Entry[Tail].Occupied = TRUE;
4693         Queue->Entry[Tail].Machine = Machine;
4694         Queue->Entry[Tail].MsgType = MsgType;
4695         Queue->Entry[Tail].MsgLen  = MsgLen;
4696         Queue->Entry[Tail].TimeStamp.u.LowPart = TimeStampLow;
4697         Queue->Entry[Tail].TimeStamp.u.HighPart = TimeStampHigh;
4698         Queue->Entry[Tail].Rssi0 = Rssi0;
4699         Queue->Entry[Tail].Rssi1 = Rssi1;
4700         Queue->Entry[Tail].Rssi2 = Rssi2;
4701         Queue->Entry[Tail].Signal = Signal;
4702         Queue->Entry[Tail].Wcid = (UCHAR)Wcid;
4703
4704         Queue->Entry[Tail].Channel = pAd->LatchRfRegs.Channel;
4705
4706         if (Msg != NULL)
4707         {
4708                 NdisMoveMemory(Queue->Entry[Tail].Msg, Msg, MsgLen);
4709         }
4710
4711         NdisReleaseSpinLock(&(Queue->Lock));
4712
4713         RTMP_MLME_HANDLER(pAd);
4714
4715         return TRUE;
4716 }
4717
4718
4719 /*! \brief       Dequeue a message from the MLME Queue
4720  *      \param  *Queue    The MLME Queue
4721  *      \param  *Elem     The message dequeued from MLME Queue
4722  *      \return  TRUE if the Elem contains something, FALSE otherwise
4723  *      \pre
4724  *      \post
4725
4726  IRQL = DISPATCH_LEVEL
4727
4728  */
4729 BOOLEAN MlmeDequeue(
4730         IN MLME_QUEUE *Queue,
4731         OUT MLME_QUEUE_ELEM **Elem)
4732 {
4733         NdisAcquireSpinLock(&(Queue->Lock));
4734         *Elem = &(Queue->Entry[Queue->Head]);
4735         Queue->Num--;
4736         Queue->Head++;
4737         if (Queue->Head == MAX_LEN_OF_MLME_QUEUE)
4738         {
4739                 Queue->Head = 0;
4740         }
4741         NdisReleaseSpinLock(&(Queue->Lock));
4742         return TRUE;
4743 }
4744
4745 // IRQL = DISPATCH_LEVEL
4746 VOID    MlmeRestartStateMachine(
4747         IN      PRTMP_ADAPTER   pAd)
4748 {
4749 #ifdef RTMP_MAC_PCI
4750         MLME_QUEUE_ELEM         *Elem = NULL;
4751 #endif // RTMP_MAC_PCI //
4752         BOOLEAN                         Cancelled;
4753
4754         DBGPRINT(RT_DEBUG_TRACE, ("MlmeRestartStateMachine \n"));
4755
4756 #ifdef RTMP_MAC_PCI
4757         NdisAcquireSpinLock(&pAd->Mlme.TaskLock);
4758         if(pAd->Mlme.bRunning)
4759         {
4760                 NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
4761                 return;
4762         }
4763         else
4764         {
4765                 pAd->Mlme.bRunning = TRUE;
4766         }
4767         NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
4768
4769         // Remove all Mlme queues elements
4770         while (!MlmeQueueEmpty(&pAd->Mlme.Queue))
4771         {
4772                 //From message type, determine which state machine I should drive
4773                 if (MlmeDequeue(&pAd->Mlme.Queue, &Elem))
4774                 {
4775                         // free MLME element
4776                         Elem->Occupied = FALSE;
4777                         Elem->MsgLen = 0;
4778
4779                 }
4780                 else {
4781                         DBGPRINT_ERR(("MlmeRestartStateMachine: MlmeQueue empty\n"));
4782         }
4783         }
4784 #endif // RTMP_MAC_PCI //
4785
4786         {
4787                 // Cancel all timer events
4788                 // Be careful to cancel new added timer
4789                 RTMPCancelTimer(&pAd->MlmeAux.AssocTimer,         &Cancelled);
4790                 RTMPCancelTimer(&pAd->MlmeAux.ReassocTimer,   &Cancelled);
4791                 RTMPCancelTimer(&pAd->MlmeAux.DisassocTimer,  &Cancelled);
4792                 RTMPCancelTimer(&pAd->MlmeAux.AuthTimer,           &Cancelled);
4793                 RTMPCancelTimer(&pAd->MlmeAux.BeaconTimer,         &Cancelled);
4794                 RTMPCancelTimer(&pAd->MlmeAux.ScanTimer,           &Cancelled);
4795
4796         }
4797
4798         // Change back to original channel in case of doing scan
4799         AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
4800         AsicLockChannel(pAd, pAd->CommonCfg.Channel);
4801
4802         // Resume MSDU which is turned off durning scan
4803         RTMPResumeMsduTransmission(pAd);
4804
4805         {
4806                 // Set all state machines back IDLE
4807                 pAd->Mlme.CntlMachine.CurrState    = CNTL_IDLE;
4808                 pAd->Mlme.AssocMachine.CurrState   = ASSOC_IDLE;
4809                 pAd->Mlme.AuthMachine.CurrState    = AUTH_REQ_IDLE;
4810                 pAd->Mlme.AuthRspMachine.CurrState = AUTH_RSP_IDLE;
4811                 pAd->Mlme.SyncMachine.CurrState    = SYNC_IDLE;
4812                 pAd->Mlme.ActMachine.CurrState    = ACT_IDLE;
4813         }
4814
4815 #ifdef RTMP_MAC_PCI
4816         // Remove running state
4817         NdisAcquireSpinLock(&pAd->Mlme.TaskLock);
4818         pAd->Mlme.bRunning = FALSE;
4819         NdisReleaseSpinLock(&pAd->Mlme.TaskLock);
4820 #endif // RTMP_MAC_PCI //
4821 }
4822
4823 /*! \brief      test if the MLME Queue is empty
4824  *      \param  *Queue    The MLME Queue
4825  *      \return TRUE if the Queue is empty, FALSE otherwise
4826  *      \pre
4827  *      \post
4828
4829  IRQL = DISPATCH_LEVEL
4830
4831  */
4832 BOOLEAN MlmeQueueEmpty(
4833         IN MLME_QUEUE *Queue)
4834 {
4835         BOOLEAN Ans;
4836
4837         NdisAcquireSpinLock(&(Queue->Lock));
4838         Ans = (Queue->Num == 0);
4839         NdisReleaseSpinLock(&(Queue->Lock));
4840
4841         return Ans;
4842 }
4843
4844 /*! \brief       test if the MLME Queue is full
4845  *      \param   *Queue          The MLME Queue
4846  *      \return  TRUE if the Queue is empty, FALSE otherwise
4847  *      \pre
4848  *      \post
4849
4850  IRQL = PASSIVE_LEVEL
4851  IRQL = DISPATCH_LEVEL
4852
4853  */
4854 BOOLEAN MlmeQueueFull(
4855         IN MLME_QUEUE *Queue)
4856 {
4857         BOOLEAN Ans;
4858
4859         NdisAcquireSpinLock(&(Queue->Lock));
4860         Ans = (Queue->Num == MAX_LEN_OF_MLME_QUEUE || Queue->Entry[Queue->Tail].Occupied);
4861         NdisReleaseSpinLock(&(Queue->Lock));
4862
4863         return Ans;
4864 }
4865
4866 /*! \brief       The destructor of MLME Queue
4867  *      \param
4868  *      \return
4869  *      \pre
4870  *      \post
4871  *      \note   Clear Mlme Queue, Set Queue->Num to Zero.
4872
4873  IRQL = PASSIVE_LEVEL
4874
4875  */
4876 VOID MlmeQueueDestroy(
4877         IN MLME_QUEUE *pQueue)
4878 {
4879         NdisAcquireSpinLock(&(pQueue->Lock));
4880         pQueue->Num  = 0;
4881         pQueue->Head = 0;
4882         pQueue->Tail = 0;
4883         NdisReleaseSpinLock(&(pQueue->Lock));
4884         NdisFreeSpinLock(&(pQueue->Lock));
4885 }
4886
4887
4888 /*! \brief       To substitute the message type if the message is coming from external
4889  *      \param  pFrame             The frame received
4890  *      \param  *Machine           The state machine
4891  *      \param  *MsgType           the message type for the state machine
4892  *      \return TRUE if the substitution is successful, FALSE otherwise
4893  *      \pre
4894  *      \post
4895
4896  IRQL = DISPATCH_LEVEL
4897
4898  */
4899 BOOLEAN MsgTypeSubst(
4900         IN PRTMP_ADAPTER  pAd,
4901         IN PFRAME_802_11 pFrame,
4902         OUT INT *Machine,
4903         OUT INT *MsgType)
4904 {
4905         USHORT  Seq, Alg;
4906         UCHAR   EAPType;
4907         PUCHAR  pData;
4908
4909         // Pointer to start of data frames including SNAP header
4910         pData = (PUCHAR) pFrame + LENGTH_802_11;
4911
4912         // The only data type will pass to this function is EAPOL frame
4913         if (pFrame->Hdr.FC.Type == BTYPE_DATA)
4914         {
4915                 {
4916                 *Machine = WPA_STATE_MACHINE;
4917                         EAPType = *((UCHAR*)pFrame + LENGTH_802_11 + LENGTH_802_1_H + 1);
4918                 return (WpaMsgTypeSubst(EAPType, (INT *) MsgType));
4919                 }
4920         }
4921
4922         switch (pFrame->Hdr.FC.SubType)
4923         {
4924                 case SUBTYPE_ASSOC_REQ:
4925                         *Machine = ASSOC_STATE_MACHINE;
4926                         *MsgType = MT2_PEER_ASSOC_REQ;
4927                         break;
4928                 case SUBTYPE_ASSOC_RSP:
4929                         *Machine = ASSOC_STATE_MACHINE;
4930                         *MsgType = MT2_PEER_ASSOC_RSP;
4931                         break;
4932                 case SUBTYPE_REASSOC_REQ:
4933                         *Machine = ASSOC_STATE_MACHINE;
4934                         *MsgType = MT2_PEER_REASSOC_REQ;
4935                         break;
4936                 case SUBTYPE_REASSOC_RSP:
4937                         *Machine = ASSOC_STATE_MACHINE;
4938                         *MsgType = MT2_PEER_REASSOC_RSP;
4939                         break;
4940                 case SUBTYPE_PROBE_REQ:
4941                         *Machine = SYNC_STATE_MACHINE;
4942                         *MsgType = MT2_PEER_PROBE_REQ;
4943                         break;
4944                 case SUBTYPE_PROBE_RSP:
4945                         *Machine = SYNC_STATE_MACHINE;
4946                         *MsgType = MT2_PEER_PROBE_RSP;
4947                         break;
4948                 case SUBTYPE_BEACON:
4949                         *Machine = SYNC_STATE_MACHINE;
4950                         *MsgType = MT2_PEER_BEACON;
4951                         break;
4952                 case SUBTYPE_ATIM:
4953                         *Machine = SYNC_STATE_MACHINE;
4954                         *MsgType = MT2_PEER_ATIM;
4955                         break;
4956                 case SUBTYPE_DISASSOC:
4957                         *Machine = ASSOC_STATE_MACHINE;
4958                         *MsgType = MT2_PEER_DISASSOC_REQ;
4959                         break;
4960                 case SUBTYPE_AUTH:
4961                         // get the sequence number from payload 24 Mac Header + 2 bytes algorithm
4962                         NdisMoveMemory(&Seq, &pFrame->Octet[2], sizeof(USHORT));
4963                         NdisMoveMemory(&Alg, &pFrame->Octet[0], sizeof(USHORT));
4964                         if (Seq == 1 || Seq == 3)
4965                 {
4966                                 *Machine = AUTH_RSP_STATE_MACHINE;
4967                                 *MsgType = MT2_PEER_AUTH_ODD;
4968         }
4969                         else if (Seq == 2 || Seq == 4)
4970         {
4971                                 if (Alg == AUTH_MODE_OPEN || Alg == AUTH_MODE_KEY)
4972                 {
4973                                         *Machine = AUTH_STATE_MACHINE;
4974                                         *MsgType = MT2_PEER_AUTH_EVEN;
4975                 }
4976         }
4977                         else
4978         {
4979                                 return FALSE;
4980                         }
4981                         break;
4982                 case SUBTYPE_DEAUTH:
4983                         *Machine = AUTH_RSP_STATE_MACHINE;
4984                         *MsgType = MT2_PEER_DEAUTH;
4985                         break;
4986                 case SUBTYPE_ACTION:
4987                         *Machine = ACTION_STATE_MACHINE;
4988                         //  Sometimes Sta will return with category bytes with MSB = 1, if they receive catogory out of their support
4989                         if ((pFrame->Octet[0]&0x7F) > MAX_PEER_CATE_MSG)
4990                 {
4991                                 *MsgType = MT2_ACT_INVALID;
4992                 }
4993                 else
4994                 {
4995                                 *MsgType = (pFrame->Octet[0]&0x7F);
4996                 }
4997                         break;
4998                 default:
4999                         return FALSE;
5000                         break;
5001         }
5002
5003         return TRUE;
5004 }
5005
5006 // ===========================================================================================
5007 // state_machine.c
5008 // ===========================================================================================
5009
5010 /*! \brief Initialize the state machine.
5011  *      \param *S                       pointer to the state machine
5012  *      \param  Trans           State machine transition function
5013  *      \param  StNr            number of states
5014  *      \param  MsgNr           number of messages
5015  *      \param  DefFunc         default function, when there is invalid state/message combination
5016  *      \param  InitState       initial state of the state machine
5017  *      \param  Base            StateMachine base, internal use only
5018  *      \pre p_sm should be a legal pointer
5019  *      \post
5020
5021  IRQL = PASSIVE_LEVEL
5022
5023  */
5024 VOID StateMachineInit(
5025         IN STATE_MACHINE *S,
5026         IN STATE_MACHINE_FUNC Trans[],
5027         IN ULONG StNr,
5028         IN ULONG MsgNr,
5029         IN STATE_MACHINE_FUNC DefFunc,
5030         IN ULONG InitState,
5031         IN ULONG Base)
5032 {
5033         ULONG i, j;
5034
5035         // set number of states and messages
5036         S->NrState = StNr;
5037         S->NrMsg   = MsgNr;
5038         S->Base    = Base;
5039
5040         S->TransFunc  = Trans;
5041
5042         // init all state transition to default function
5043         for (i = 0; i < StNr; i++)
5044         {
5045                 for (j = 0; j < MsgNr; j++)
5046                 {
5047                         S->TransFunc[i * MsgNr + j] = DefFunc;
5048                 }
5049         }
5050
5051         // set the starting state
5052         S->CurrState = InitState;
5053 }
5054
5055 /*! \brief This function fills in the function pointer into the cell in the state machine
5056  *      \param *S       pointer to the state machine
5057  *      \param St       state
5058  *      \param Msg      incoming message
5059  *      \param f        the function to be executed when (state, message) combination occurs at the state machine
5060  *      \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
5061  *      \post
5062
5063  IRQL = PASSIVE_LEVEL
5064
5065  */
5066 VOID StateMachineSetAction(
5067         IN STATE_MACHINE *S,
5068         IN ULONG St,
5069         IN ULONG Msg,
5070         IN STATE_MACHINE_FUNC Func)
5071 {
5072         ULONG MsgIdx;
5073
5074         MsgIdx = Msg - S->Base;
5075
5076         if (St < S->NrState && MsgIdx < S->NrMsg)
5077         {
5078                 // boundary checking before setting the action
5079                 S->TransFunc[St * S->NrMsg + MsgIdx] = Func;
5080         }
5081 }
5082
5083 /*! \brief       This function does the state transition
5084  *      \param   *Adapter the NIC adapter pointer
5085  *      \param   *S       the state machine
5086  *      \param   *Elem    the message to be executed
5087  *      \return   None
5088
5089  IRQL = DISPATCH_LEVEL
5090
5091  */
5092 VOID StateMachinePerformAction(
5093         IN      PRTMP_ADAPTER   pAd,
5094         IN STATE_MACHINE *S,
5095         IN MLME_QUEUE_ELEM *Elem)
5096 {
5097         (*(S->TransFunc[S->CurrState * S->NrMsg + Elem->MsgType - S->Base]))(pAd, Elem);
5098 }
5099
5100 /*
5101         ==========================================================================
5102         Description:
5103                 The drop function, when machine executes this, the message is simply
5104                 ignored. This function does nothing, the message is freed in
5105                 StateMachinePerformAction()
5106         ==========================================================================
5107  */
5108 VOID Drop(
5109         IN PRTMP_ADAPTER pAd,
5110         IN MLME_QUEUE_ELEM *Elem)
5111 {
5112 }
5113
5114 // ===========================================================================================
5115 // lfsr.c
5116 // ===========================================================================================
5117
5118 /*
5119         ==========================================================================
5120         Description:
5121
5122         IRQL = PASSIVE_LEVEL
5123
5124         ==========================================================================
5125  */
5126 VOID LfsrInit(
5127         IN PRTMP_ADAPTER pAd,
5128         IN ULONG Seed)
5129 {
5130         if (Seed == 0)
5131                 pAd->Mlme.ShiftReg = 1;
5132         else
5133                 pAd->Mlme.ShiftReg = Seed;
5134 }
5135
5136 /*
5137         ==========================================================================
5138         Description:
5139         ==========================================================================
5140  */
5141 UCHAR RandomByte(
5142         IN PRTMP_ADAPTER pAd)
5143 {
5144         ULONG i;
5145         UCHAR R, Result;
5146
5147         R = 0;
5148
5149         if (pAd->Mlme.ShiftReg == 0)
5150         NdisGetSystemUpTime((ULONG *)&pAd->Mlme.ShiftReg);
5151
5152         for (i = 0; i < 8; i++)
5153         {
5154                 if (pAd->Mlme.ShiftReg & 0x00000001)
5155                 {
5156                         pAd->Mlme.ShiftReg = ((pAd->Mlme.ShiftReg ^ LFSR_MASK) >> 1) | 0x80000000;
5157                         Result = 1;
5158         }
5159         else
5160         {
5161                         pAd->Mlme.ShiftReg = pAd->Mlme.ShiftReg >> 1;
5162                         Result = 0;
5163                 }
5164                 R = (R << 1) | Result;
5165         }
5166
5167         return R;
5168 }
5169
5170
5171 /*
5172         ========================================================================
5173
5174         Routine Description:
5175                 Verify the support rate for different PHY type
5176
5177         Arguments:
5178                 pAd                             Pointer to our adapter
5179
5180         Return Value:
5181                 None
5182
5183         IRQL = PASSIVE_LEVEL
5184
5185         ========================================================================
5186 */
5187 VOID    RTMPCheckRates(
5188         IN              PRTMP_ADAPTER   pAd,
5189         IN OUT  UCHAR                   SupRate[],
5190         IN OUT  UCHAR                   *SupRateLen)
5191 {
5192         UCHAR   RateIdx, i, j;
5193         UCHAR   NewRate[12], NewRateLen;
5194
5195         NewRateLen = 0;
5196
5197         if (pAd->CommonCfg.PhyMode == PHY_11B)
5198                 RateIdx = 4;
5199         else
5200                 RateIdx = 12;
5201
5202         // Check for support rates exclude basic rate bit
5203         for (i = 0; i < *SupRateLen; i++)
5204                 for (j = 0; j < RateIdx; j++)
5205                         if ((SupRate[i] & 0x7f) == RateIdTo500Kbps[j])
5206                                 NewRate[NewRateLen++] = SupRate[i];
5207
5208         *SupRateLen = NewRateLen;
5209         NdisMoveMemory(SupRate, NewRate, NewRateLen);
5210 }
5211
5212 BOOLEAN RTMPCheckChannel(
5213         IN PRTMP_ADAPTER pAd,
5214         IN UCHAR                CentralChannel,
5215         IN UCHAR                Channel)
5216 {
5217         UCHAR           k;
5218         UCHAR           UpperChannel = 0, LowerChannel = 0;
5219         UCHAR           NoEffectChannelinList = 0;
5220
5221         // Find upper and lower channel according to 40MHz current operation.
5222         if (CentralChannel < Channel)
5223         {
5224                 UpperChannel = Channel;
5225                 if (CentralChannel > 2)
5226                         LowerChannel = CentralChannel - 2;
5227                 else
5228                         return FALSE;
5229         }
5230         else if (CentralChannel > Channel)
5231         {
5232                 UpperChannel = CentralChannel + 2;
5233                 LowerChannel = Channel;
5234         }
5235
5236         for (k = 0;k < pAd->ChannelListNum;k++)
5237         {
5238                 if (pAd->ChannelList[k].Channel == UpperChannel)
5239                 {
5240                         NoEffectChannelinList ++;
5241                 }
5242                 if (pAd->ChannelList[k].Channel == LowerChannel)
5243                 {
5244                         NoEffectChannelinList ++;
5245                 }
5246         }
5247
5248         DBGPRINT(RT_DEBUG_TRACE,("Total Channel in Channel List = [%d]\n", NoEffectChannelinList));
5249         if (NoEffectChannelinList == 2)
5250                 return TRUE;
5251         else
5252                 return FALSE;
5253 }
5254
5255 /*
5256         ========================================================================
5257
5258         Routine Description:
5259                 Verify the support rate for HT phy type
5260
5261         Arguments:
5262                 pAd                             Pointer to our adapter
5263
5264         Return Value:
5265                 FALSE if pAd->CommonCfg.SupportedHtPhy doesn't accept the pHtCapability.  (AP Mode)
5266
5267         IRQL = PASSIVE_LEVEL
5268
5269         ========================================================================
5270 */
5271 BOOLEAN         RTMPCheckHt(
5272         IN      PRTMP_ADAPTER                   pAd,
5273         IN      UCHAR                                   Wcid,
5274         IN      HT_CAPABILITY_IE                *pHtCapability,
5275         IN      ADD_HT_INFO_IE                  *pAddHtInfo)
5276 {
5277         if (Wcid >= MAX_LEN_OF_MAC_TABLE)
5278                 return FALSE;
5279
5280         // If use AMSDU, set flag.
5281         if (pAd->CommonCfg.DesiredHtPhy.AmsduEnable)
5282                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_AMSDU_INUSED);
5283         // Save Peer Capability
5284         if (pHtCapability->HtCapInfo.ShortGIfor20)
5285                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_SGI20_CAPABLE);
5286         if (pHtCapability->HtCapInfo.ShortGIfor40)
5287                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_SGI40_CAPABLE);
5288         if (pHtCapability->HtCapInfo.TxSTBC)
5289                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_TxSTBC_CAPABLE);
5290         if (pHtCapability->HtCapInfo.RxSTBC)
5291                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_RxSTBC_CAPABLE);
5292         if (pAd->CommonCfg.bRdg && pHtCapability->ExtHtCapInfo.RDGSupport)
5293         {
5294                 CLIENT_STATUS_SET_FLAG(&pAd->MacTab.Content[Wcid], fCLIENT_STATUS_RDG_CAPABLE);
5295         }
5296
5297         if (Wcid < MAX_LEN_OF_MAC_TABLE)
5298         {
5299                 pAd->MacTab.Content[Wcid].MpduDensity = pHtCapability->HtCapParm.MpduDensity;
5300         }
5301
5302         // Will check ChannelWidth for MCSSet[4] below
5303         pAd->MlmeAux.HtCapability.MCSSet[4] = 0x1;
5304     switch (pAd->CommonCfg.RxStream)
5305         {
5306                 case 1:
5307                         pAd->MlmeAux.HtCapability.MCSSet[0] = 0xff;
5308                         pAd->MlmeAux.HtCapability.MCSSet[1] = 0x00;
5309             pAd->MlmeAux.HtCapability.MCSSet[2] = 0x00;
5310             pAd->MlmeAux.HtCapability.MCSSet[3] = 0x00;
5311                         break;
5312                 case 2:
5313                         pAd->MlmeAux.HtCapability.MCSSet[0] = 0xff;
5314                         pAd->MlmeAux.HtCapability.MCSSet[1] = 0xff;
5315             pAd->MlmeAux.HtCapability.MCSSet[2] = 0x00;
5316             pAd->MlmeAux.HtCapability.MCSSet[3] = 0x00;
5317                         break;
5318                 case 3:
5319                         pAd->MlmeAux.HtCapability.MCSSet[0] = 0xff;
5320                         pAd->MlmeAux.HtCapability.MCSSet[1] = 0xff;
5321             pAd->MlmeAux.HtCapability.MCSSet[2] = 0xff;
5322             pAd->MlmeAux.HtCapability.MCSSet[3] = 0x00;
5323                         break;
5324         }
5325
5326         pAd->MlmeAux.HtCapability.HtCapInfo.ChannelWidth = pAddHtInfo->AddHtInfo.RecomWidth & pAd->CommonCfg.DesiredHtPhy.ChannelWidth;
5327
5328     DBGPRINT(RT_DEBUG_TRACE, ("RTMPCheckHt:: HtCapInfo.ChannelWidth=%d, RecomWidth=%d, DesiredHtPhy.ChannelWidth=%d, BW40MAvailForA/G=%d/%d, PhyMode=%d \n",
5329                 pAd->MlmeAux.HtCapability.HtCapInfo.ChannelWidth, pAddHtInfo->AddHtInfo.RecomWidth, pAd->CommonCfg.DesiredHtPhy.ChannelWidth,
5330                 pAd->NicConfig2.field.BW40MAvailForA, pAd->NicConfig2.field.BW40MAvailForG, pAd->CommonCfg.PhyMode));
5331
5332         pAd->MlmeAux.HtCapability.HtCapInfo.GF =  pHtCapability->HtCapInfo.GF &pAd->CommonCfg.DesiredHtPhy.GF;
5333
5334         // Send Assoc Req with my HT capability.
5335         pAd->MlmeAux.HtCapability.HtCapInfo.AMsduSize =  pAd->CommonCfg.DesiredHtPhy.AmsduSize;
5336         pAd->MlmeAux.HtCapability.HtCapInfo.MimoPs =  pAd->CommonCfg.DesiredHtPhy.MimoPs;
5337         pAd->MlmeAux.HtCapability.HtCapInfo.ShortGIfor20 =  (pAd->CommonCfg.DesiredHtPhy.ShortGIfor20) & (pHtCapability->HtCapInfo.ShortGIfor20);
5338         pAd->MlmeAux.HtCapability.HtCapInfo.ShortGIfor40 =  (pAd->CommonCfg.DesiredHtPhy.ShortGIfor40) & (pHtCapability->HtCapInfo.ShortGIfor40);
5339         pAd->MlmeAux.HtCapability.HtCapInfo.TxSTBC =  (pAd->CommonCfg.DesiredHtPhy.TxSTBC)&(pHtCapability->HtCapInfo.RxSTBC);
5340         pAd->MlmeAux.HtCapability.HtCapInfo.RxSTBC =  (pAd->CommonCfg.DesiredHtPhy.RxSTBC)&(pHtCapability->HtCapInfo.TxSTBC);
5341         pAd->MlmeAux.HtCapability.HtCapParm.MaxRAmpduFactor = pAd->CommonCfg.DesiredHtPhy.MaxRAmpduFactor;
5342     pAd->MlmeAux.HtCapability.HtCapParm.MpduDensity = pAd->CommonCfg.HtCapability.HtCapParm.MpduDensity;
5343         pAd->MlmeAux.HtCapability.ExtHtCapInfo.PlusHTC = pHtCapability->ExtHtCapInfo.PlusHTC;
5344         pAd->MacTab.Content[Wcid].HTCapability.ExtHtCapInfo.PlusHTC = pHtCapability->ExtHtCapInfo.PlusHTC;
5345         if (pAd->CommonCfg.bRdg)
5346         {
5347                 pAd->MlmeAux.HtCapability.ExtHtCapInfo.RDGSupport = pHtCapability->ExtHtCapInfo.RDGSupport;
5348         pAd->MlmeAux.HtCapability.ExtHtCapInfo.PlusHTC = 1;
5349         }
5350
5351     if (pAd->MlmeAux.HtCapability.HtCapInfo.ChannelWidth == BW_20)
5352         pAd->MlmeAux.HtCapability.MCSSet[4] = 0x0;  // BW20 can't transmit MCS32
5353
5354         COPY_AP_HTSETTINGS_FROM_BEACON(pAd, pHtCapability);
5355         return TRUE;
5356 }
5357
5358 /*
5359         ========================================================================
5360
5361         Routine Description:
5362                 Verify the support rate for different PHY type
5363
5364         Arguments:
5365                 pAd                             Pointer to our adapter
5366
5367         Return Value:
5368                 None
5369
5370         IRQL = PASSIVE_LEVEL
5371
5372         ========================================================================
5373 */
5374 VOID RTMPUpdateMlmeRate(
5375         IN PRTMP_ADAPTER        pAd)
5376 {
5377         UCHAR   MinimumRate;
5378         UCHAR   ProperMlmeRate; //= RATE_54;
5379         UCHAR   i, j, RateIdx = 12; //1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54
5380         BOOLEAN bMatch = FALSE;
5381
5382         switch (pAd->CommonCfg.PhyMode)
5383         {
5384                 case PHY_11B:
5385                         ProperMlmeRate = RATE_11;
5386                         MinimumRate = RATE_1;
5387                         break;
5388                 case PHY_11BG_MIXED:
5389                 case PHY_11ABGN_MIXED:
5390                 case PHY_11BGN_MIXED:
5391                         if ((pAd->MlmeAux.SupRateLen == 4) &&
5392                                 (pAd->MlmeAux.ExtRateLen == 0))
5393                                 // B only AP
5394                                 ProperMlmeRate = RATE_11;
5395                         else
5396                                 ProperMlmeRate = RATE_24;
5397
5398                         if (pAd->MlmeAux.Channel <= 14)
5399                                 MinimumRate = RATE_1;
5400                         else
5401                                 MinimumRate = RATE_6;
5402                         break;
5403                 case PHY_11A:
5404                 case PHY_11N_2_4G:      // rt2860 need to check mlmerate for 802.11n
5405                 case PHY_11GN_MIXED:
5406                 case PHY_11AGN_MIXED:
5407                 case PHY_11AN_MIXED:
5408                 case PHY_11N_5G:
5409                         ProperMlmeRate = RATE_24;
5410                         MinimumRate = RATE_6;
5411                         break;
5412                 case PHY_11ABG_MIXED:
5413                         ProperMlmeRate = RATE_24;
5414                         if (pAd->MlmeAux.Channel <= 14)
5415                            MinimumRate = RATE_1;
5416                         else
5417                                 MinimumRate = RATE_6;
5418                         break;
5419                 default: // error
5420                         ProperMlmeRate = RATE_1;
5421                         MinimumRate = RATE_1;
5422                         break;
5423         }
5424
5425         for (i = 0; i < pAd->MlmeAux.SupRateLen; i++)
5426         {
5427                 for (j = 0; j < RateIdx; j++)
5428                 {
5429                         if ((pAd->MlmeAux.SupRate[i] & 0x7f) == RateIdTo500Kbps[j])
5430                         {
5431                                 if (j == ProperMlmeRate)
5432                                 {
5433                                         bMatch = TRUE;
5434                                         break;
5435                                 }
5436                         }
5437                 }
5438
5439                 if (bMatch)
5440                         break;
5441         }
5442
5443         if (bMatch == FALSE)
5444         {
5445                 for (i = 0; i < pAd->MlmeAux.ExtRateLen; i++)
5446                 {
5447                         for (j = 0; j < RateIdx; j++)
5448                         {
5449                                 if ((pAd->MlmeAux.ExtRate[i] & 0x7f) == RateIdTo500Kbps[j])
5450                                 {
5451                                         if (j == ProperMlmeRate)
5452                                         {
5453                                                 bMatch = TRUE;
5454                                                 break;
5455                                         }
5456                                 }
5457                         }
5458
5459                         if (bMatch)
5460                                 break;
5461                 }
5462         }
5463
5464         if (bMatch == FALSE)
5465         {
5466                 ProperMlmeRate = MinimumRate;
5467         }
5468
5469         pAd->CommonCfg.MlmeRate = MinimumRate;
5470         pAd->CommonCfg.RtsRate = ProperMlmeRate;
5471         if (pAd->CommonCfg.MlmeRate >= RATE_6)
5472         {
5473                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
5474                 pAd->CommonCfg.MlmeTransmit.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
5475                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MODE = MODE_OFDM;
5476                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MCS = OfdmRateToRxwiMCS[pAd->CommonCfg.MlmeRate];
5477         }
5478         else
5479         {
5480                 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_CCK;
5481                 pAd->CommonCfg.MlmeTransmit.field.MCS = pAd->CommonCfg.MlmeRate;
5482                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MODE = MODE_CCK;
5483                 pAd->MacTab.Content[BSS0Mcast_WCID].HTPhyMode.field.MCS = pAd->CommonCfg.MlmeRate;
5484         }
5485
5486         DBGPRINT(RT_DEBUG_TRACE, ("RTMPUpdateMlmeRate ==>   MlmeTransmit = 0x%x  \n" , pAd->CommonCfg.MlmeTransmit.word));
5487 }
5488
5489 CHAR RTMPMaxRssi(
5490         IN PRTMP_ADAPTER        pAd,
5491         IN CHAR                         Rssi0,
5492         IN CHAR                         Rssi1,
5493         IN CHAR                         Rssi2)
5494 {
5495         CHAR    larger = -127;
5496
5497         if ((pAd->Antenna.field.RxPath == 1) && (Rssi0 != 0))
5498         {
5499                 larger = Rssi0;
5500         }
5501
5502         if ((pAd->Antenna.field.RxPath >= 2) && (Rssi1 != 0))
5503         {
5504                 larger = max(Rssi0, Rssi1);
5505         }
5506
5507         if ((pAd->Antenna.field.RxPath == 3) && (Rssi2 != 0))
5508         {
5509                 larger = max(larger, Rssi2);
5510         }
5511
5512         if (larger == -127)
5513                 larger = 0;
5514
5515         return larger;
5516 }
5517
5518
5519 /*
5520     ========================================================================
5521     Routine Description:
5522         Periodic evaluate antenna link status
5523
5524     Arguments:
5525         pAd         - Adapter pointer
5526
5527     Return Value:
5528         None
5529
5530     ========================================================================
5531 */
5532 VOID AsicEvaluateRxAnt(
5533         IN PRTMP_ADAPTER        pAd)
5534 {
5535         UCHAR   BBPR3 = 0;
5536
5537         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS |
5538                                 fRTMP_ADAPTER_HALT_IN_PROGRESS |
5539                                 fRTMP_ADAPTER_RADIO_OFF |
5540                                 fRTMP_ADAPTER_NIC_NOT_EXIST |
5541                                                         fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS) ||
5542                                                         OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)
5543 #ifdef RT30xx
5544                                 || (pAd->EepromAccess)
5545 #endif // RT30xx //
5546 #ifdef RT3090
5547                                                         || (pAd->bPCIclkOff == TRUE)
5548 #endif // RT3090 //
5549                                 )
5550                         return;
5551
5552
5553         {
5554                 //if (pAd->StaCfg.Psm == PWR_SAVE)
5555                 //      return;
5556
5557         {
5558
5559                 if (pAd->StaCfg.Psm == PWR_SAVE)
5560                         return;
5561
5562                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BBPR3);
5563                 BBPR3 &= (~0x18);
5564                 if(pAd->Antenna.field.RxPath == 3)
5565                 {
5566                         BBPR3 |= (0x10);
5567                 }
5568                 else if(pAd->Antenna.field.RxPath == 2)
5569                 {
5570                         BBPR3 |= (0x8);
5571                 }
5572                 else if(pAd->Antenna.field.RxPath == 1)
5573                 {
5574                         BBPR3 |= (0x0);
5575                 }
5576                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BBPR3);
5577 #ifdef RTMP_MAC_PCI
5578                 pAd->StaCfg.BBPR3 = BBPR3;
5579 #endif // RTMP_MAC_PCI //
5580         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
5581                 )
5582         {
5583                 ULONG   TxTotalCnt = pAd->RalinkCounters.OneSecTxNoRetryOkCount +
5584                                                                 pAd->RalinkCounters.OneSecTxRetryOkCount +
5585                                                                 pAd->RalinkCounters.OneSecTxFailCount;
5586
5587                         // dynamic adjust antenna evaluation period according to the traffic
5588                 if (TxTotalCnt > 50)
5589                 {
5590                         RTMPSetTimer(&pAd->Mlme.RxAntEvalTimer, 20);
5591                         pAd->Mlme.bLowThroughput = FALSE;
5592                 }
5593                 else
5594                 {
5595                         RTMPSetTimer(&pAd->Mlme.RxAntEvalTimer, 300);
5596                         pAd->Mlme.bLowThroughput = TRUE;
5597                 }
5598         }
5599                 }
5600
5601         }
5602
5603
5604 }
5605
5606 /*
5607     ========================================================================
5608     Routine Description:
5609         After evaluation, check antenna link status
5610
5611     Arguments:
5612         pAd         - Adapter pointer
5613
5614     Return Value:
5615         None
5616
5617     ========================================================================
5618 */
5619 VOID AsicRxAntEvalTimeout(
5620         IN PVOID SystemSpecific1,
5621         IN PVOID FunctionContext,
5622         IN PVOID SystemSpecific2,
5623         IN PVOID SystemSpecific3)
5624 {
5625         RTMP_ADAPTER    *pAd = (RTMP_ADAPTER *)FunctionContext;
5626         UCHAR                   BBPR3 = 0;
5627         CHAR                    larger = -127, rssi0, rssi1, rssi2;
5628
5629         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS |
5630                                                         fRTMP_ADAPTER_HALT_IN_PROGRESS  |
5631                                                         fRTMP_ADAPTER_RADIO_OFF                 |
5632                                                         fRTMP_ADAPTER_NIC_NOT_EXIST) ||
5633                                                         OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)
5634 #ifdef RT30xx
5635                                                         || (pAd->EepromAccess)
5636 #endif // RT30xx //
5637 #ifdef RT3090
5638                                                         || (pAd->bPCIclkOff == TRUE)
5639 #endif // RT3090 //
5640                                                         )
5641                 return;
5642
5643         {
5644                 //if (pAd->StaCfg.Psm == PWR_SAVE)
5645                 //      return;
5646                 {
5647                         if (pAd->StaCfg.Psm == PWR_SAVE)
5648                                 return;
5649
5650                         // if the traffic is low, use average rssi as the criteria
5651                         if (pAd->Mlme.bLowThroughput == TRUE)
5652                         {
5653                                 rssi0 = pAd->StaCfg.RssiSample.LastRssi0;
5654                                 rssi1 = pAd->StaCfg.RssiSample.LastRssi1;
5655                                 rssi2 = pAd->StaCfg.RssiSample.LastRssi2;
5656                         }
5657                         else
5658                         {
5659                                 rssi0 = pAd->StaCfg.RssiSample.AvgRssi0;
5660                                 rssi1 = pAd->StaCfg.RssiSample.AvgRssi1;
5661                                 rssi2 = pAd->StaCfg.RssiSample.AvgRssi2;
5662                         }
5663
5664                         if(pAd->Antenna.field.RxPath == 3)
5665                         {
5666                                 larger = max(rssi0, rssi1);
5667
5668                                 if (larger > (rssi2 + 20))
5669                                         pAd->Mlme.RealRxPath = 2;
5670                                 else
5671                                         pAd->Mlme.RealRxPath = 3;
5672                         }
5673                         else if(pAd->Antenna.field.RxPath == 2)
5674                         {
5675                                 if (rssi0 > (rssi1 + 20))
5676                                         pAd->Mlme.RealRxPath = 1;
5677                                 else
5678                                         pAd->Mlme.RealRxPath = 2;
5679                         }
5680
5681                         RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BBPR3);
5682                         BBPR3 &= (~0x18);
5683                         if(pAd->Mlme.RealRxPath == 3)
5684                         {
5685                                 BBPR3 |= (0x10);
5686                         }
5687                         else if(pAd->Mlme.RealRxPath == 2)
5688                         {
5689                                 BBPR3 |= (0x8);
5690                         }
5691                         else if(pAd->Mlme.RealRxPath == 1)
5692                         {
5693                                 BBPR3 |= (0x0);
5694                         }
5695                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BBPR3);
5696 #ifdef RTMP_MAC_PCI
5697                         pAd->StaCfg.BBPR3 = BBPR3;
5698 #endif // RTMP_MAC_PCI //
5699                 }
5700         }
5701
5702
5703 }
5704
5705
5706 VOID APSDPeriodicExec(
5707         IN PVOID SystemSpecific1,
5708         IN PVOID FunctionContext,
5709         IN PVOID SystemSpecific2,
5710         IN PVOID SystemSpecific3)
5711 {
5712         RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)FunctionContext;
5713
5714         if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
5715                 return;
5716
5717         pAd->CommonCfg.TriggerTimerCount++;
5718
5719 // Driver should not send trigger frame, it should be send by application layer
5720 /*
5721         if (pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable
5722                 && (pAd->CommonCfg.bNeedSendTriggerFrame ||
5723                 (((pAd->CommonCfg.TriggerTimerCount%20) == 19) && (!pAd->CommonCfg.bAPSDAC_BE || !pAd->CommonCfg.bAPSDAC_BK || !pAd->CommonCfg.bAPSDAC_VI || !pAd->CommonCfg.bAPSDAC_VO))))
5724         {
5725                 DBGPRINT(RT_DEBUG_TRACE,("Sending trigger frame and enter service period when support APSD\n"));
5726                 RTMPSendNullFrame(pAd, pAd->CommonCfg.TxRate, TRUE);
5727                 pAd->CommonCfg.bNeedSendTriggerFrame = FALSE;
5728                 pAd->CommonCfg.TriggerTimerCount = 0;
5729                 pAd->CommonCfg.bInServicePeriod = TRUE;
5730         }*/
5731 }
5732
5733 /*
5734     ========================================================================
5735     Routine Description:
5736         Set/reset MAC registers according to bPiggyBack parameter
5737
5738     Arguments:
5739         pAd         - Adapter pointer
5740         bPiggyBack  - Enable / Disable Piggy-Back
5741
5742     Return Value:
5743         None
5744
5745     ========================================================================
5746 */
5747 VOID RTMPSetPiggyBack(
5748     IN PRTMP_ADAPTER    pAd,
5749     IN BOOLEAN          bPiggyBack)
5750 {
5751         TX_LINK_CFG_STRUC  TxLinkCfg;
5752
5753         RTMP_IO_READ32(pAd, TX_LINK_CFG, &TxLinkCfg.word);
5754
5755         TxLinkCfg.field.TxCFAckEn = bPiggyBack;
5756         RTMP_IO_WRITE32(pAd, TX_LINK_CFG, TxLinkCfg.word);
5757 }
5758
5759 /*
5760     ========================================================================
5761     Routine Description:
5762         check if this entry need to switch rate automatically
5763
5764     Arguments:
5765         pAd
5766         pEntry
5767
5768     Return Value:
5769         TURE
5770         FALSE
5771
5772     ========================================================================
5773 */
5774 BOOLEAN RTMPCheckEntryEnableAutoRateSwitch(
5775         IN PRTMP_ADAPTER    pAd,
5776         IN PMAC_TABLE_ENTRY     pEntry)
5777 {
5778         BOOLEAN         result = TRUE;
5779
5780         {
5781                 // only associated STA counts
5782                 if (pEntry && (pEntry->ValidAsCLI) && (pEntry->Sst == SST_ASSOC))
5783                 {
5784                         result = pAd->StaCfg.bAutoTxRateSwitch;
5785                 }
5786                 else
5787                         result = FALSE;
5788         }
5789
5790         return result;
5791 }
5792
5793
5794 BOOLEAN RTMPAutoRateSwitchCheck(
5795         IN PRTMP_ADAPTER    pAd)
5796 {
5797         {
5798         if (pAd->StaCfg.bAutoTxRateSwitch)
5799                 return TRUE;
5800         }
5801         return FALSE;
5802 }
5803
5804
5805 /*
5806     ========================================================================
5807     Routine Description:
5808         check if this entry need to fix tx legacy rate
5809
5810     Arguments:
5811         pAd
5812         pEntry
5813
5814     Return Value:
5815         TURE
5816         FALSE
5817
5818     ========================================================================
5819 */
5820 UCHAR RTMPStaFixedTxMode(
5821         IN PRTMP_ADAPTER    pAd,
5822         IN PMAC_TABLE_ENTRY     pEntry)
5823 {
5824         UCHAR   tx_mode = FIXED_TXMODE_HT;
5825
5826         {
5827         tx_mode = (UCHAR)pAd->StaCfg.DesiredTransmitSetting.field.FixedTxMode;
5828         }
5829
5830         return tx_mode;
5831 }
5832
5833 /*
5834     ========================================================================
5835     Routine Description:
5836         Overwrite HT Tx Mode by Fixed Legency Tx Mode, if specified.
5837
5838     Arguments:
5839         pAd
5840         pEntry
5841
5842     Return Value:
5843         TURE
5844         FALSE
5845
5846     ========================================================================
5847 */
5848 VOID RTMPUpdateLegacyTxSetting(
5849                 UCHAR                           fixed_tx_mode,
5850                 PMAC_TABLE_ENTRY        pEntry)
5851 {
5852         HTTRANSMIT_SETTING TransmitSetting;
5853
5854         if (fixed_tx_mode == FIXED_TXMODE_HT)
5855                 return;
5856
5857         TransmitSetting.word = 0;
5858
5859         TransmitSetting.field.MODE = pEntry->HTPhyMode.field.MODE;
5860         TransmitSetting.field.MCS = pEntry->HTPhyMode.field.MCS;
5861
5862         if (fixed_tx_mode == FIXED_TXMODE_CCK)
5863         {
5864                 TransmitSetting.field.MODE = MODE_CCK;
5865                 // CCK mode allow MCS 0~3
5866                 if (TransmitSetting.field.MCS > MCS_3)
5867                         TransmitSetting.field.MCS = MCS_3;
5868         }
5869         else
5870         {
5871                 TransmitSetting.field.MODE = MODE_OFDM;
5872                 // OFDM mode allow MCS 0~7
5873                 if (TransmitSetting.field.MCS > MCS_7)
5874                         TransmitSetting.field.MCS = MCS_7;
5875         }
5876
5877         if (pEntry->HTPhyMode.field.MODE >= TransmitSetting.field.MODE)
5878         {
5879                 pEntry->HTPhyMode.word = TransmitSetting.word;
5880                 DBGPRINT(RT_DEBUG_TRACE, ("RTMPUpdateLegacyTxSetting : wcid-%d, MODE=%s, MCS=%d \n",
5881                                 pEntry->Aid, GetPhyMode(pEntry->HTPhyMode.field.MODE), pEntry->HTPhyMode.field.MCS));
5882         }
5883 }
5884
5885 /*
5886         ==========================================================================
5887         Description:
5888                 dynamic tune BBP R66 to find a balance between sensibility and
5889                 noise isolation
5890
5891         IRQL = DISPATCH_LEVEL
5892
5893         ==========================================================================
5894  */
5895 VOID AsicStaBbpTuning(
5896         IN PRTMP_ADAPTER pAd)
5897 {
5898         UCHAR   OrigR66Value = 0, R66;//, R66UpperBound = 0x30, R66LowerBound = 0x30;
5899         CHAR    Rssi;
5900
5901         // 2860C did not support Fase CCA, therefore can't tune
5902         if (pAd->MACVersion == 0x28600100)
5903                 return;
5904
5905         //
5906         // work as a STA
5907         //
5908         if (pAd->Mlme.CntlMachine.CurrState != CNTL_IDLE)  // no R66 tuning when SCANNING
5909                 return;
5910
5911         if ((pAd->OpMode == OPMODE_STA)
5912                 && (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)
5913                         )
5914                 && !(OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
5915 #ifdef RTMP_MAC_PCI
5916                 && (pAd->bPCIclkOff == FALSE)
5917 #endif // RTMP_MAC_PCI //
5918                 )
5919         {
5920                 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R66, &OrigR66Value);
5921                 R66 = OrigR66Value;
5922
5923                 if (pAd->Antenna.field.RxPath > 1)
5924                         Rssi = (pAd->StaCfg.RssiSample.AvgRssi0 + pAd->StaCfg.RssiSample.AvgRssi1) >> 1;
5925                 else
5926                         Rssi = pAd->StaCfg.RssiSample.AvgRssi0;
5927
5928                 if (pAd->LatchRfRegs.Channel <= 14)
5929                 {       //BG band
5930 #ifdef RT30xx
5931                         // RT3070 is a no LNA solution, it should have different control regarding to AGC gain control
5932                         // Otherwise, it will have some throughput side effect when low RSSI
5933
5934                         if (IS_RT3070(pAd)||IS_RT3090(pAd) || IS_RT3572(pAd) || IS_RT3390(pAd))
5935                         {
5936                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
5937                                 {
5938                                         R66 = 0x1C + 2*GET_LNA_GAIN(pAd) + 0x20;
5939                                         if (OrigR66Value != R66)
5940                                         {
5941                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
5942                                 }
5943                                 }
5944                                 else
5945                                 {
5946                                         R66 = 0x1C + 2*GET_LNA_GAIN(pAd);
5947                                         if (OrigR66Value != R66)
5948                                         {
5949                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
5950                                 }
5951                         }
5952                         }
5953                         else
5954 #endif // RT30xx //
5955                         {
5956                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
5957                                 {
5958                                         R66 = (0x2E + GET_LNA_GAIN(pAd)) + 0x10;
5959                                         if (OrigR66Value != R66)
5960                                         {
5961                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
5962                                         }
5963                                 }
5964                                 else
5965                                 {
5966                                         R66 = 0x2E + GET_LNA_GAIN(pAd);
5967                                         if (OrigR66Value != R66)
5968                                         {
5969                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
5970                                         }
5971                                 }
5972                         }
5973                 }
5974                 else
5975                 {       //A band
5976                         if (pAd->CommonCfg.BBPCurrentBW == BW_20)
5977                         {
5978                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
5979                                 {
5980                                         R66 = 0x32 + (GET_LNA_GAIN(pAd)*5)/3 + 0x10;
5981                                         if (OrigR66Value != R66)
5982                                         {
5983                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
5984                                         }
5985                                 }
5986                                 else
5987                                 {
5988                                         R66 = 0x32 + (GET_LNA_GAIN(pAd)*5)/3;
5989                                         if (OrigR66Value != R66)
5990                                         {
5991                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
5992                                         }
5993                                 }
5994                         }
5995                         else
5996                         {
5997                                 if (Rssi > RSSI_FOR_MID_LOW_SENSIBILITY)
5998                                 {
5999                                         R66 = 0x3A + (GET_LNA_GAIN(pAd)*5)/3 + 0x10;
6000                                         if (OrigR66Value != R66)
6001                                         {
6002                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
6003                                         }
6004                                 }
6005                                 else
6006                                 {
6007                                         R66 = 0x3A + (GET_LNA_GAIN(pAd)*5)/3;
6008                                         if (OrigR66Value != R66)
6009                                         {
6010                                                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
6011                                         }
6012                                 }
6013                         }
6014                 }
6015
6016
6017         }
6018 }
6019
6020 VOID RTMPSetAGCInitValue(
6021         IN PRTMP_ADAPTER        pAd,
6022         IN UCHAR                        BandWidth)
6023 {
6024         UCHAR   R66 = 0x30;
6025
6026         if (pAd->LatchRfRegs.Channel <= 14)
6027         {       // BG band
6028 #ifdef RT30xx
6029                 /* Gary was verified Amazon AP and find that RT307x has BBP_R66 invalid default value */
6030
6031                 if (IS_RT3070(pAd)||IS_RT3090(pAd) || IS_RT3572(pAd) || IS_RT3390(pAd))
6032                 {
6033                         R66 = 0x1C + 2*GET_LNA_GAIN(pAd);
6034                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
6035                 }
6036                 else
6037 #endif // RT30xx //
6038                 {
6039                 R66 = 0x2E + GET_LNA_GAIN(pAd);
6040                 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
6041         }
6042         }
6043         else
6044         {       //A band
6045                 {
6046                 if (BandWidth == BW_20)
6047                 {
6048                         R66 = (UCHAR)(0x32 + (GET_LNA_GAIN(pAd)*5)/3);
6049                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
6050                 }
6051                 else
6052                 {
6053                         R66 = (UCHAR)(0x3A + (GET_LNA_GAIN(pAd)*5)/3);
6054                         RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
6055                 }
6056         }
6057         }
6058
6059 }
6060