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