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