Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 53fefcdee04c4aec34e51db3bd74a632d7c3f5e9 / . / CORE / SME / src / csr / csrUtil.c
blob: b8ad98e33f94c12632eaccb03973196485274944 [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Gopichand Nakkala92f07d82013-01-08 21:16:34 -0800[diff] [blame]2 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21/*
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]22 * Copyright (c) 2012, The Linux Foundation. All rights reserved.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]23 *
24 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
25 *
26 *
27 * Permission to use, copy, modify, and/or distribute this software for
28 * any purpose with or without fee is hereby granted, provided that the
29 * above copyright notice and this permission notice appear in all
30 * copies.
31 *
32 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
33 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
34 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
35 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
36 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
37 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
38 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
39 * PERFORMANCE OF THIS SOFTWARE.
40 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]41/** ------------------------------------------------------------------------- *
42 ------------------------------------------------------------------------- *
43
44
45 \file csrUtil.c
46
47 Implementation supporting routines for CSR.
48
49
50 Copyright (C) 2006 Airgo Networks, Incorporated
51 ========================================================================== */
52
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]53
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]54#include "aniGlobal.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]55
56#include "palApi.h"
57#include "csrSupport.h"
58#include "csrInsideApi.h"
59#include "smsDebug.h"
60#include "smeQosInternal.h"
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]61#include "wlan_qct_wda.h"
62
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]63#ifdef FEATURE_WLAN_CCX
64#include "vos_utils.h"
65#include "csrCcx.h"
66#endif /* FEATURE_WLAN_CCX */
67
68tANI_U8 csrWpaOui[][ CSR_WPA_OUI_SIZE ] = {
69 { 0x00, 0x50, 0xf2, 0x00 },
70 { 0x00, 0x50, 0xf2, 0x01 },
71 { 0x00, 0x50, 0xf2, 0x02 },
72 { 0x00, 0x50, 0xf2, 0x03 },
73 { 0x00, 0x50, 0xf2, 0x04 },
74 { 0x00, 0x50, 0xf2, 0x05 },
75#ifdef FEATURE_WLAN_CCX
76 { 0x00, 0x40, 0x96, 0x00 }, // CCKM
77#endif /* FEATURE_WLAN_CCX */
78};
79
80tANI_U8 csrRSNOui[][ CSR_RSN_OUI_SIZE ] = {
81 { 0x00, 0x0F, 0xAC, 0x00 }, // group cipher
82 { 0x00, 0x0F, 0xAC, 0x01 }, // WEP-40 or RSN
83 { 0x00, 0x0F, 0xAC, 0x02 }, // TKIP or RSN-PSK
84 { 0x00, 0x0F, 0xAC, 0x03 }, // Reserved
85 { 0x00, 0x0F, 0xAC, 0x04 }, // AES-CCMP
86 { 0x00, 0x0F, 0xAC, 0x05 }, // WEP-104
87#ifdef WLAN_FEATURE_11W
88 { 0x00, 0x0F, 0xAC, 0x06 }, // BIP(encryption type) or (RSN-PSK-SHA256(authentication type)
89#endif
90#ifdef FEATURE_WLAN_CCX
91 { 0x00, 0x40, 0x96, 0x00 } // CCKM
92#endif /* FEATURE_WLAN_CCX */
93
94};
95
96#ifdef FEATURE_WLAN_WAPI
97tANI_U8 csrWapiOui[][ CSR_WAPI_OUI_SIZE ] = {
98 { 0x00, 0x14, 0x72, 0x00 }, // Reserved
99 { 0x00, 0x14, 0x72, 0x01 }, // WAI certificate or SMS4
100 { 0x00, 0x14, 0x72, 0x02 } // WAI PSK
101};
102#endif /* FEATURE_WLAN_WAPI */
103tANI_U8 csrWmeInfoOui[ CSR_WME_OUI_SIZE ] = { 0x00, 0x50, 0xf2, 0x02 };
104tANI_U8 csrWmeParmOui[ CSR_WME_OUI_SIZE ] = { 0x00, 0x50, 0xf2, 0x02 };
105
106static tCsrIELenInfo gCsrIELengthTable[] = {
107/* 000 */ { SIR_MAC_SSID_EID_MIN, SIR_MAC_SSID_EID_MAX },
108/* 001 */ { SIR_MAC_RATESET_EID_MIN, SIR_MAC_RATESET_EID_MAX },
109/* 002 */ { SIR_MAC_FH_PARAM_SET_EID_MIN, SIR_MAC_FH_PARAM_SET_EID_MAX },
110/* 003 */ { SIR_MAC_DS_PARAM_SET_EID_MIN, SIR_MAC_DS_PARAM_SET_EID_MAX },
111/* 004 */ { SIR_MAC_CF_PARAM_SET_EID_MIN, SIR_MAC_CF_PARAM_SET_EID_MAX },
112/* 005 */ { SIR_MAC_TIM_EID_MIN, SIR_MAC_TIM_EID_MAX },
113/* 006 */ { SIR_MAC_IBSS_PARAM_SET_EID_MIN, SIR_MAC_IBSS_PARAM_SET_EID_MAX },
114/* 007 */ { SIR_MAC_COUNTRY_EID_MIN, SIR_MAC_COUNTRY_EID_MAX },
115/* 008 */ { SIR_MAC_FH_PARAMS_EID_MIN, SIR_MAC_FH_PARAMS_EID_MAX },
116/* 009 */ { SIR_MAC_FH_PATTERN_EID_MIN, SIR_MAC_FH_PATTERN_EID_MAX },
117/* 010 */ { SIR_MAC_REQUEST_EID_MIN, SIR_MAC_REQUEST_EID_MAX },
118/* 011 */ { SIR_MAC_QBSS_LOAD_EID_MIN, SIR_MAC_QBSS_LOAD_EID_MAX },
119/* 012 */ { SIR_MAC_EDCA_PARAM_SET_EID_MIN, SIR_MAC_EDCA_PARAM_SET_EID_MAX },
120/* 013 */ { SIR_MAC_TSPEC_EID_MIN, SIR_MAC_TSPEC_EID_MAX },
121/* 014 */ { SIR_MAC_TCLAS_EID_MIN, SIR_MAC_TCLAS_EID_MAX },
122/* 015 */ { SIR_MAC_QOS_SCHEDULE_EID_MIN, SIR_MAC_QOS_SCHEDULE_EID_MAX },
123/* 016 */ { SIR_MAC_CHALLENGE_TEXT_EID_MIN, SIR_MAC_CHALLENGE_TEXT_EID_MAX },
124/* 017 */ { 0, 255 },
125/* 018 */ { 0, 255 },
126/* 019 */ { 0, 255 },
127/* 020 */ { 0, 255 },
128/* 021 */ { 0, 255 },
129/* 022 */ { 0, 255 },
130/* 023 */ { 0, 255 },
131/* 024 */ { 0, 255 },
132/* 025 */ { 0, 255 },
133/* 026 */ { 0, 255 },
134/* 027 */ { 0, 255 },
135/* 028 */ { 0, 255 },
136/* 029 */ { 0, 255 },
137/* 030 */ { 0, 255 },
138/* 031 */ { 0, 255 },
139/* 032 */ { SIR_MAC_PWR_CONSTRAINT_EID_MIN, SIR_MAC_PWR_CONSTRAINT_EID_MAX },
140/* 033 */ { SIR_MAC_PWR_CAPABILITY_EID_MIN, SIR_MAC_PWR_CAPABILITY_EID_MAX },
141/* 034 */ { SIR_MAC_TPC_REQ_EID_MIN, SIR_MAC_TPC_REQ_EID_MAX },
142/* 035 */ { SIR_MAC_TPC_RPT_EID_MIN, SIR_MAC_TPC_RPT_EID_MAX },
143/* 036 */ { SIR_MAC_SPRTD_CHNLS_EID_MIN, SIR_MAC_SPRTD_CHNLS_EID_MAX },
144/* 037 */ { SIR_MAC_CHNL_SWITCH_ANN_EID_MIN, SIR_MAC_CHNL_SWITCH_ANN_EID_MAX },
145/* 038 */ { SIR_MAC_MEAS_REQ_EID_MIN, SIR_MAC_MEAS_REQ_EID_MAX },
146/* 039 */ { SIR_MAC_MEAS_RPT_EID_MIN, SIR_MAC_MEAS_RPT_EID_MAX },
147/* 040 */ { SIR_MAC_QUIET_EID_MIN, SIR_MAC_QUIET_EID_MAX },
148/* 041 */ { SIR_MAC_IBSS_DFS_EID_MIN, SIR_MAC_IBSS_DFS_EID_MAX },
149/* 042 */ { SIR_MAC_ERP_INFO_EID_MIN, SIR_MAC_ERP_INFO_EID_MAX },
150/* 043 */ { SIR_MAC_TS_DELAY_EID_MIN, SIR_MAC_TS_DELAY_EID_MAX },
151/* 044 */ { SIR_MAC_TCLAS_PROC_EID_MIN, SIR_MAC_TCLAS_PROC_EID_MAX },
152/* 045 */ { SIR_MAC_QOS_ACTION_EID_MIN, SIR_MAC_QOS_ACTION_EID_MAX },
153/* 046 */ { SIR_MAC_QOS_CAPABILITY_EID_MIN, SIR_MAC_QOS_CAPABILITY_EID_MAX },
154/* 047 */ { 0, 255 },
155/* 048 */ { SIR_MAC_RSN_EID_MIN, SIR_MAC_RSN_EID_MAX },
156/* 049 */ { 0, 255 },
157/* 050 */ { SIR_MAC_EXTENDED_RATE_EID_MIN, SIR_MAC_EXTENDED_RATE_EID_MAX },
158/* 051 */ { 0, 255 },
159/* 052 */ { 0, 255 },
160/* 053 */ { 0, 255 },
161/* 054 */ { 0, 255 },
162/* 055 */ { 0, 255 },
163/* 056 */ { 0, 255 },
164/* 057 */ { 0, 255 },
165/* 058 */ { 0, 255 },
166/* 059 */ { 0, 255 },
167/* 060 */ { 0, 255 },
168/* 061 */ { 0, 255 },
169/* 062 */ { 0, 255 },
170/* 063 */ { 0, 255 },
171/* 064 */ { 0, 255 },
172/* 065 */ { 0, 255 },
173/* 066 */ { 0, 255 },
174/* 067 */ { 0, 255 },
175#ifdef FEATURE_WLAN_WAPI
176/* 068 */ { DOT11F_EID_WAPI, DOT11F_IE_WAPI_MAX_LEN },
177#else
178/* 068 */ { 0, 255 },
179#endif /* FEATURE_WLAN_WAPI */
180/* 069 */ { 0, 255 },
181/* 070 */ { 0, 255 },
182/* 071 */ { 0, 255 },
183/* 072 */ { 0, 255 },
184/* 073 */ { 0, 255 },
185/* 074 */ { 0, 255 },
186/* 075 */ { 0, 255 },
187/* 076 */ { 0, 255 },
188/* 077 */ { 0, 255 },
189/* 078 */ { 0, 255 },
190/* 079 */ { 0, 255 },
191/* 080 */ { 0, 255 },
192/* 081 */ { 0, 255 },
193/* 082 */ { 0, 255 },
194/* 083 */ { 0, 255 },
195/* 084 */ { 0, 255 },
196/* 085 */ { 0, 255 },
197/* 086 */ { 0, 255 },
198/* 087 */ { 0, 255 },
199/* 088 */ { 0, 255 },
200/* 089 */ { 0, 255 },
201/* 090 */ { 0, 255 },
202/* 091 */ { 0, 255 },
203/* 092 */ { 0, 255 },
204/* 093 */ { 0, 255 },
205/* 094 */ { 0, 255 },
206/* 095 */ { 0, 255 },
207/* 096 */ { 0, 255 },
208/* 097 */ { 0, 255 },
209/* 098 */ { 0, 255 },
210/* 099 */ { 0, 255 },
211/* 100 */ { 0, 255 },
212/* 101 */ { 0, 255 },
213/* 102 */ { 0, 255 },
214/* 103 */ { 0, 255 },
215/* 104 */ { 0, 255 },
216/* 105 */ { 0, 255 },
217/* 106 */ { 0, 255 },
218/* 107 */ { 0, 255 },
219/* 108 */ { 0, 255 },
220/* 109 */ { 0, 255 },
221/* 110 */ { 0, 255 },
222/* 111 */ { 0, 255 },
223/* 112 */ { 0, 255 },
224/* 113 */ { 0, 255 },
225/* 114 */ { 0, 255 },
226/* 115 */ { 0, 255 },
227/* 116 */ { 0, 255 },
228/* 117 */ { 0, 255 },
229/* 118 */ { 0, 255 },
230/* 119 */ { 0, 255 },
231/* 120 */ { 0, 255 },
232/* 121 */ { 0, 255 },
233/* 122 */ { 0, 255 },
234/* 123 */ { 0, 255 },
235/* 124 */ { 0, 255 },
236/* 125 */ { 0, 255 },
237/* 126 */ { 0, 255 },
238/* 127 */ { 0, 255 },
239/* 128 */ { 0, 255 },
240/* 129 */ { 0, 255 },
241/* 130 */ { 0, 255 },
242/* 131 */ { 0, 255 },
243/* 132 */ { 0, 255 },
244/* 133 */ { 0, 255 },
245/* 134 */ { 0, 255 },
246/* 135 */ { 0, 255 },
247/* 136 */ { 0, 255 },
248/* 137 */ { 0, 255 },
249/* 138 */ { 0, 255 },
250/* 139 */ { 0, 255 },
251/* 140 */ { 0, 255 },
252/* 141 */ { 0, 255 },
253/* 142 */ { 0, 255 },
254/* 143 */ { 0, 255 },
255/* 144 */ { 0, 255 },
256/* 145 */ { 0, 255 },
257/* 146 */ { 0, 255 },
258/* 147 */ { 0, 255 },
259/* 148 */ { 0, 255 },
260/* 149 */ { 0, 255 },
261/* 150 */ { 0, 255 },
262/* 151 */ { 0, 255 },
263/* 152 */ { 0, 255 },
264/* 153 */ { 0, 255 },
265/* 154 */ { 0, 255 },
266/* 155 */ { 0, 255 },
267/* 156 */ { 0, 255 },
268/* 157 */ { 0, 255 },
269/* 158 */ { 0, 255 },
270/* 159 */ { 0, 255 },
271/* 160 */ { 0, 255 },
272/* 161 */ { 0, 255 },
273/* 162 */ { 0, 255 },
274/* 163 */ { 0, 255 },
275/* 164 */ { 0, 255 },
276/* 165 */ { 0, 255 },
277/* 166 */ { 0, 255 },
278/* 167 */ { 0, 255 },
279/* 168 */ { 0, 255 },
280/* 169 */ { 0, 255 },
281/* 170 */ { 0, 255 },
282/* 171 */ { 0, 255 },
283/* 172 */ { 0, 255 },
284/* 173 */ { 0, 255 },
285/* 174 */ { 0, 255 },
286/* 175 */ { 0, 255 },
287/* 176 */ { 0, 255 },
288/* 177 */ { 0, 255 },
289/* 178 */ { 0, 255 },
290/* 179 */ { 0, 255 },
291/* 180 */ { 0, 255 },
292/* 181 */ { 0, 255 },
293/* 182 */ { 0, 255 },
294/* 183 */ { 0, 255 },
295/* 184 */ { 0, 255 },
296/* 185 */ { 0, 255 },
297/* 186 */ { 0, 255 },
298/* 187 */ { 0, 255 },
299/* 188 */ { 0, 255 },
300/* 189 */ { 0, 255 },
301/* 190 */ { 0, 255 },
302/* 191 */ { 0, 255 },
303/* 192 */ { 0, 255 },
304/* 193 */ { 0, 255 },
305/* 194 */ { 0, 255 },
306/* 195 */ { 0, 255 },
307/* 196 */ { 0, 255 },
308/* 197 */ { 0, 255 },
309/* 198 */ { 0, 255 },
310/* 199 */ { 0, 255 },
311/* 200 */ { 0, 255 },
312/* 201 */ { 0, 255 },
313/* 202 */ { 0, 255 },
314/* 203 */ { 0, 255 },
315/* 204 */ { 0, 255 },
316/* 205 */ { 0, 255 },
317/* 206 */ { 0, 255 },
318/* 207 */ { 0, 255 },
319/* 208 */ { 0, 255 },
320/* 209 */ { 0, 255 },
321/* 210 */ { 0, 255 },
322/* 211 */ { 0, 255 },
323/* 212 */ { 0, 255 },
324/* 213 */ { 0, 255 },
325/* 214 */ { 0, 255 },
326/* 215 */ { 0, 255 },
327/* 216 */ { 0, 255 },
328/* 217 */ { 0, 255 },
329/* 218 */ { 0, 255 },
330/* 219 */ { 0, 255 },
331/* 220 */ { 0, 255 },
332/* 221 */ { SIR_MAC_WPA_EID_MIN, SIR_MAC_WPA_EID_MAX },
333/* 222 */ { 0, 255 },
334/* 223 */ { 0, 255 },
335/* 224 */ { 0, 255 },
336/* 225 */ { 0, 255 },
337/* 226 */ { 0, 255 },
338/* 227 */ { 0, 255 },
339/* 228 */ { 0, 255 },
340/* 229 */ { 0, 255 },
341/* 230 */ { 0, 255 },
342/* 231 */ { 0, 255 },
343/* 232 */ { 0, 255 },
344/* 233 */ { 0, 255 },
345/* 234 */ { 0, 255 },
346/* 235 */ { 0, 255 },
347/* 236 */ { 0, 255 },
348/* 237 */ { 0, 255 },
349/* 238 */ { 0, 255 },
350/* 239 */ { 0, 255 },
351/* 240 */ { 0, 255 },
352/* 241 */ { 0, 255 },
353/* 242 */ { 0, 255 },
354/* 243 */ { 0, 255 },
355/* 244 */ { 0, 255 },
356/* 245 */ { 0, 255 },
357/* 246 */ { 0, 255 },
358/* 247 */ { 0, 255 },
359/* 248 */ { 0, 255 },
360/* 249 */ { 0, 255 },
361/* 250 */ { 0, 255 },
362/* 251 */ { 0, 255 },
363/* 252 */ { 0, 255 },
364/* 253 */ { 0, 255 },
365/* 254 */ { 0, 255 },
366/* 255 */ { SIR_MAC_ANI_WORKAROUND_EID_MIN, SIR_MAC_ANI_WORKAROUND_EID_MAX }
367};
368
369#if 0
370//Don't not insert entry into the table, put it to the end. If you have to insert, make sure it is also
371//reflected in eCsrCountryIndex
372static tCsrCountryInfo gCsrCountryInfo[eCSR_NUM_COUNTRY_INDEX] =
373{
374 {REG_DOMAIN_FCC, {'U', 'S', ' '}}, //USA/******The "US" MUST be at index 0*******/
375 {REG_DOMAIN_WORLD, {'A', 'D', ' '}}, //ANDORRA
376 {REG_DOMAIN_WORLD, {'A', 'E', ' '}}, //UAE
377 {REG_DOMAIN_WORLD, {'A', 'F', ' '}}, //AFGHANISTAN
378 {REG_DOMAIN_WORLD, {'A', 'G', ' '}}, //ANTIGUA AND BARBUDA
379 {REG_DOMAIN_WORLD, {'A', 'I', ' '}}, //ANGUILLA
380 {REG_DOMAIN_HI_5GHZ, {'A', 'L', ' '}}, //ALBANIA
381 {REG_DOMAIN_WORLD, {'A', 'M', ' '}}, //ARMENIA
382 {REG_DOMAIN_WORLD, {'A', 'N', ' '}}, //NETHERLANDS ANTILLES
383 {REG_DOMAIN_WORLD, {'A', 'O', ' '}}, //ANGOLA
384 {REG_DOMAIN_WORLD, {'A', 'Q', ' '}}, //ANTARCTICA
385 {REG_DOMAIN_HI_5GHZ, {'A', 'R', ' '}}, //ARGENTINA
386 {REG_DOMAIN_FCC, {'A', 'S', ' '}}, //AMERICAN SOMOA
387 {REG_DOMAIN_ETSI, {'A', 'T', ' '}}, //AUSTRIA
388 {REG_DOMAIN_ETSI, {'A', 'U', ' '}}, //AUSTRALIA
389 {REG_DOMAIN_WORLD, {'A', 'W', ' '}}, //ARUBA
390 {REG_DOMAIN_WORLD, {'A', 'X', ' '}}, //ALAND ISLANDS
391 {REG_DOMAIN_WORLD, {'A', 'Z', ' '}}, //AZERBAIJAN
392 {REG_DOMAIN_WORLD, {'B', 'A', ' '}}, //BOSNIA AND HERZEGOVINA
393 {REG_DOMAIN_WORLD, {'B', 'B', ' '}}, //BARBADOS
394 {REG_DOMAIN_WORLD, {'B', 'D', ' '}}, //BANGLADESH
395 {REG_DOMAIN_ETSI, {'B', 'E', ' '}}, //BELGIUM
396 {REG_DOMAIN_WORLD, {'B', 'F', ' '}}, //BURKINA FASO
397 {REG_DOMAIN_HI_5GHZ, {'B', 'G', ' '}}, //BULGARIA
398 {REG_DOMAIN_WORLD, {'B', 'H', ' '}}, //BAHRAIN
399 {REG_DOMAIN_WORLD, {'B', 'I', ' '}}, //BURUNDI
400 {REG_DOMAIN_WORLD, {'B', 'J', ' '}}, //BENIN
401 {REG_DOMAIN_WORLD, {'B', 'L', ' '}}, //SAINT BARTHELEMY
402 {REG_DOMAIN_ETSI, {'B', 'M', ' '}}, //BERMUDA
403 {REG_DOMAIN_WORLD, {'B', 'N', ' '}}, //BRUNEI DARUSSALAM
404 {REG_DOMAIN_WORLD, {'B', 'O', ' '}}, //BOLIVIA
405 {REG_DOMAIN_WORLD, {'B', 'R', ' '}}, //BRAZIL
406 {REG_DOMAIN_WORLD, {'B', 'S', ' '}}, //BAHAMAS
407 {REG_DOMAIN_WORLD, {'B', 'T', ' '}}, //BHUTAN
408 {REG_DOMAIN_WORLD, {'B', 'V', ' '}}, //BOUVET ISLAND
409 {REG_DOMAIN_WORLD, {'B', 'W', ' '}}, //BOTSWANA
410 {REG_DOMAIN_WORLD, {'B', 'Y', ' '}}, //BELARUS
411 {REG_DOMAIN_WORLD, {'B', 'Z', ' '}}, //BELIZE
412 {REG_DOMAIN_FCC, {'C', 'A', ' '}}, //CANADA
413 {REG_DOMAIN_WORLD, {'C', 'C', ' '}}, //COCOS (KEELING) ISLANDS
414 {REG_DOMAIN_WORLD, {'C', 'D', ' '}}, //CONGO, THE DEMOCRATIC REPUBLIC OF THE
415 {REG_DOMAIN_WORLD, {'C', 'F', ' '}}, //CENTRAL AFRICAN REPUBLIC
416 {REG_DOMAIN_WORLD, {'C', 'G', ' '}}, //CONGO
417 {REG_DOMAIN_ETSI, {'C', 'H', ' '}}, //SWITZERLAND
418 {REG_DOMAIN_WORLD, {'C', 'I', ' '}}, //COTE D'IVOIRE
419 {REG_DOMAIN_WORLD, {'C', 'K', ' '}}, //COOK ISLANDS
420 {REG_DOMAIN_WORLD, {'C', 'L', ' '}}, //CHILE
421 {REG_DOMAIN_WORLD, {'C', 'M', ' '}}, //CAMEROON
422 {REG_DOMAIN_HI_5GHZ, {'C', 'N', ' '}}, //CHINA
423 {REG_DOMAIN_WORLD, {'C', 'O', ' '}}, //COLOMBIA
424 {REG_DOMAIN_WORLD, {'C', 'R', ' '}}, //COSTA RICA
425 {REG_DOMAIN_WORLD, {'C', 'U', ' '}}, //CUBA
426 {REG_DOMAIN_WORLD, {'C', 'V', ' '}}, //CAPE VERDE
427 {REG_DOMAIN_WORLD, {'C', 'X', ' '}}, //CHRISTMAS ISLAND
428 {REG_DOMAIN_WORLD, {'C', 'Y', ' '}}, //CYPRUS
429 {REG_DOMAIN_HI_5GHZ, {'C', 'Z', ' '}}, //CZECH REPUBLIC
430 {REG_DOMAIN_ETSI, {'D', 'E', ' '}}, //GERMANY
431 {REG_DOMAIN_WORLD, {'D', 'J', ' '}}, //DJIBOUTI
432 {REG_DOMAIN_ETSI, {'D', 'K', ' '}}, //DENMARK
433 {REG_DOMAIN_WORLD, {'D', 'M', ' '}}, //DOMINICA
434 {REG_DOMAIN_WORLD, {'D', 'O', ' '}}, //DOMINICAN REPUBLIC
435 {REG_DOMAIN_WORLD, {'D', 'Z', ' '}}, //ALGERIA
436 {REG_DOMAIN_WORLD, {'E', 'C', ' '}}, //ECUADOR
437 {REG_DOMAIN_HI_5GHZ, {'E', 'E', ' '}}, //ESTONIA
438 {REG_DOMAIN_WORLD, {'E', 'G', ' '}}, //EGYPT
439 {REG_DOMAIN_WORLD, {'E', 'H', ' '}}, //WESTERN SAHARA
440 {REG_DOMAIN_WORLD, {'E', 'R', ' '}}, //ERITREA
441 {REG_DOMAIN_ETSI, {'E', 'S', ' '}}, //SPAIN
442 {REG_DOMAIN_WORLD, {'E', 'T', ' '}}, //ETHIOPIA
443 {REG_DOMAIN_WORLD, {'F', 'I', ' '}}, //FINLAND
444 {REG_DOMAIN_WORLD, {'F', 'J', ' '}}, //FIJI
445 {REG_DOMAIN_WORLD, {'F', 'K', ' '}}, //FALKLAND ISLANDS (MALVINAS)
446 {REG_DOMAIN_WORLD, {'F', 'M', ' '}}, //MICRONESIA, FEDERATED STATES OF
447 {REG_DOMAIN_WORLD, {'F', 'O', ' '}}, //FAROE ISLANDS
448 {REG_DOMAIN_ETSI, {'F', 'R', ' '}}, //FRANCE
449 {REG_DOMAIN_WORLD, {'G', 'A', ' '}}, //GABON
450 {REG_DOMAIN_ETSI, {'G', 'B', ' '}}, //UNITED KINGDOM
451 {REG_DOMAIN_WORLD, {'G', 'D', ' '}}, //GRENADA
452 {REG_DOMAIN_HI_5GHZ, {'G', 'E', ' '}}, //GEORGIA
453 {REG_DOMAIN_WORLD, {'G', 'F', ' '}}, //FRENCH GUIANA
454 {REG_DOMAIN_ETSI, {'G', 'G', ' '}}, //GUERNSEY
455 {REG_DOMAIN_WORLD, {'G', 'H', ' '}}, //GHANA
456 {REG_DOMAIN_WORLD, {'G', 'I', ' '}}, //GIBRALTAR
457 {REG_DOMAIN_WORLD, {'G', 'L', ' '}}, //GREENLAND
458 {REG_DOMAIN_WORLD, {'G', 'M', ' '}}, //GAMBIA
459 {REG_DOMAIN_WORLD, {'G', 'N', ' '}}, //GUINEA
460 {REG_DOMAIN_WORLD, {'G', 'P', ' '}}, //GUADELOUPE
461 {REG_DOMAIN_WORLD, {'G', 'Q', ' '}}, //EQUATORIAL GUINEA
462 {REG_DOMAIN_ETSI, {'G', 'R', ' '}}, //GREECE
463 {REG_DOMAIN_WORLD, {'G', 'S', ' '}}, //SOUTH GEORGIA AND THE SOUTH SANDWICH ISLANDS
464 {REG_DOMAIN_WORLD, {'G', 'T', ' '}}, //GUATEMALA
465 {REG_DOMAIN_WORLD, {'G', 'U', ' '}}, //GUAM
466 {REG_DOMAIN_WORLD, {'G', 'W', ' '}}, //GUINEA-BISSAU
467 {REG_DOMAIN_WORLD, {'G', 'Y', ' '}}, //GUYANA
468 {REG_DOMAIN_WORLD, {'H', 'K', ' '}}, //HONGKONG
469 {REG_DOMAIN_WORLD, {'H', 'M', ' '}}, //HEARD ISLAND AND MCDONALD ISLANDS
470 {REG_DOMAIN_WORLD, {'H', 'N', ' '}}, //HONDURAS
471 {REG_DOMAIN_HI_5GHZ, {'H', 'R', ' '}}, //CROATIA
472 {REG_DOMAIN_WORLD, {'H', 'T', ' '}}, //HAITI
473 {REG_DOMAIN_HI_5GHZ, {'H', 'U', ' '}}, //HUNGARY
474 {REG_DOMAIN_APAC, {'I', 'D', ' '}}, //INDONESIA
475 {REG_DOMAIN_ETSI, {'I', 'E', ' '}}, //IRELAND
476 {REG_DOMAIN_WORLD, {'I', 'L', ' '}}, //ISREAL
477 {REG_DOMAIN_ETSI, {'I', 'M', ' '}}, //ISLE OF MAN
478 {REG_DOMAIN_WORLD, {'I', 'N', ' '}}, //INDIA
479 {REG_DOMAIN_ETSI, {'I', 'O', ' '}}, //BRITISH INDIAN OCEAN TERRITORY
480 {REG_DOMAIN_WORLD, {'I', 'Q', ' '}}, //IRAQ
481 {REG_DOMAIN_WORLD, {'I', 'R', ' '}}, //IRAN, ISLAMIC REPUBLIC OF
482 {REG_DOMAIN_WORLD, {'I', 'S', ' '}}, //ICELAND
483 {REG_DOMAIN_ETSI, {'I', 'T', ' '}}, //ITALY
484 {REG_DOMAIN_ETSI, {'J', 'E', ' '}}, //JERSEY
485 {REG_DOMAIN_WORLD, {'J', 'M', ' '}}, //JAMAICA
486 {REG_DOMAIN_WORLD, {'J', 'O', ' '}}, //JORDAN
487 {REG_DOMAIN_JAPAN, {'J', 'P', ' '}}, //JAPAN
488 {REG_DOMAIN_WORLD, {'K', 'E', ' '}}, //KENYA
489 {REG_DOMAIN_WORLD, {'K', 'G', ' '}}, //KYRGYZSTAN
490 {REG_DOMAIN_WORLD, {'K', 'H', ' '}}, //CAMBODIA
491 {REG_DOMAIN_WORLD, {'K', 'I', ' '}}, //KIRIBATI
492 {REG_DOMAIN_WORLD, {'K', 'M', ' '}}, //COMOROS
493 {REG_DOMAIN_WORLD, {'K', 'N', ' '}}, //SAINT KITTS AND NEVIS
494 {REG_DOMAIN_KOREA, {'K', 'P', ' '}}, //KOREA, DEMOCRATIC PEOPLE'S REPUBLIC OF
495 {REG_DOMAIN_KOREA, {'K', 'R', ' '}}, //KOREA, REPUBLIC OF
496 {REG_DOMAIN_WORLD, {'K', 'W', ' '}}, //KUWAIT
497 {REG_DOMAIN_WORLD, {'K', 'Y', ' '}}, //CAYMAN ISLANDS
498 {REG_DOMAIN_WORLD, {'K', 'Z', ' '}}, //KAZAKHSTAN
499 {REG_DOMAIN_WORLD, {'L', 'A', ' '}}, //LAO PEOPLE'S DEMOCRATIC REPUBLIC
500 {REG_DOMAIN_WORLD, {'L', 'B', ' '}}, //LEBANON
501 {REG_DOMAIN_WORLD, {'L', 'C', ' '}}, //SAINT LUCIA
502 {REG_DOMAIN_ETSI, {'L', 'I', ' '}}, //LIECHTENSTEIN
503 {REG_DOMAIN_WORLD, {'L', 'K', ' '}}, //SRI LANKA
504 {REG_DOMAIN_WORLD, {'L', 'R', ' '}}, //LIBERIA
505 {REG_DOMAIN_WORLD, {'L', 'S', ' '}}, //LESOTHO
506 {REG_DOMAIN_HI_5GHZ, {'L', 'T', ' '}}, //LITHUANIA
507 {REG_DOMAIN_ETSI, {'L', 'U', ' '}}, //LUXEMBOURG
508 {REG_DOMAIN_HI_5GHZ, {'L', 'V', ' '}}, //LATVIA
509 {REG_DOMAIN_WORLD, {'L', 'Y', ' '}}, //LIBYAN ARAB JAMAHIRIYA
510 {REG_DOMAIN_WORLD, {'M', 'A', ' '}}, //MOROCCO
511 {REG_DOMAIN_ETSI, {'M', 'C', ' '}}, //MONACO
512 {REG_DOMAIN_WORLD, {'M', 'D', ' '}}, //MOLDOVA, REPUBLIC OF
513 {REG_DOMAIN_WORLD, {'M', 'E', ' '}}, //MONTENEGRO
514 {REG_DOMAIN_WORLD, {'M', 'G', ' '}}, //MADAGASCAR
515 {REG_DOMAIN_WORLD, {'M', 'H', ' '}}, //MARSHALL ISLANDS
516 {REG_DOMAIN_WORLD, {'M', 'K', ' '}}, //MACEDONIA, THE FORMER YUGOSLAV REPUBLIC OF
517 {REG_DOMAIN_WORLD, {'M', 'L', ' '}}, //MALI
518 {REG_DOMAIN_WORLD, {'M', 'M', ' '}}, //MYANMAR
519 {REG_DOMAIN_HI_5GHZ, {'M', 'N', ' '}}, //MONGOLIA
520 {REG_DOMAIN_WORLD, {'M', 'O', ' '}}, //MACAO
521 {REG_DOMAIN_WORLD, {'M', 'P', ' '}}, //NORTHERN MARIANA ISLANDS
522 {REG_DOMAIN_WORLD, {'M', 'Q', ' '}}, //MARTINIQUE
523 {REG_DOMAIN_WORLD, {'M', 'R', ' '}}, //MAURITANIA
524 {REG_DOMAIN_WORLD, {'M', 'S', ' '}}, //MONTSERRAT
525 {REG_DOMAIN_WORLD, {'M', 'T', ' '}}, //MALTA
526 {REG_DOMAIN_WORLD, {'M', 'U', ' '}}, //MAURITIUS
527 {REG_DOMAIN_WORLD, {'M', 'V', ' '}}, //MALDIVES
528 {REG_DOMAIN_WORLD, {'M', 'W', ' '}}, //MALAWI
529 {REG_DOMAIN_WORLD, {'M', 'X', ' '}}, //MEXICO
530 {REG_DOMAIN_HI_5GHZ, {'M', 'Y', ' '}}, //MALAYSIA
531 {REG_DOMAIN_WORLD, {'M', 'Z', ' '}}, //MOZAMBIQUE
532 {REG_DOMAIN_WORLD, {'N', 'A', ' '}}, //NAMIBIA
533 {REG_DOMAIN_WORLD, {'N', 'C', ' '}}, //NEW CALEDONIA
534 {REG_DOMAIN_WORLD, {'N', 'E', ' '}}, //NIGER
535 {REG_DOMAIN_WORLD, {'N', 'F', ' '}}, //NORFOLD ISLAND
536 {REG_DOMAIN_WORLD, {'N', 'G', ' '}}, //NIGERIA
537 {REG_DOMAIN_WORLD, {'N', 'I', ' '}}, //NICARAGUA
538 {REG_DOMAIN_ETSI, {'N', 'L', ' '}}, //NETHERLANDS
539 {REG_DOMAIN_WORLD, {'N', 'O', ' '}}, //NORWAY
540 {REG_DOMAIN_WORLD, {'N', 'P', ' '}}, //NEPAL
541 {REG_DOMAIN_WORLD, {'N', 'R', ' '}}, //NAURU
542 {REG_DOMAIN_WORLD, {'N', 'U', ' '}}, //NIUE
543 {REG_DOMAIN_ETSI, {'N', 'Z', ' '}}, //NEW ZEALAND
544 {REG_DOMAIN_WORLD, {'O', 'M', ' '}}, //OMAN
545 {REG_DOMAIN_WORLD, {'P', 'A', ' '}}, //PANAMA
546 {REG_DOMAIN_WORLD, {'P', 'E', ' '}}, //PERU
547 {REG_DOMAIN_WORLD, {'P', 'F', ' '}}, //FRENCH POLYNESIA
548 {REG_DOMAIN_WORLD, {'P', 'G', ' '}}, //PAPUA NEW GUINEA
549 {REG_DOMAIN_WORLD, {'P', 'H', ' '}}, //PHILIPPINES
550 {REG_DOMAIN_WORLD, {'P', 'K', ' '}}, //PAKISTAN
551 {REG_DOMAIN_WORLD, {'P', 'L', ' '}}, //POLAND
552 {REG_DOMAIN_WORLD, {'P', 'M', ' '}}, //SAINT PIERRE AND MIQUELON
553 {REG_DOMAIN_WORLD, {'P', 'N', ' '}}, //PITCAIRN
554 {REG_DOMAIN_FCC, {'P', 'R', ' '}}, //PUERTO RICO
555 {REG_DOMAIN_WORLD, {'P', 'S', ' '}}, //PALESTINIAN TERRITORY, OCCUPIED
556 {REG_DOMAIN_ETSI, {'P', 'T', ' '}}, //PORTUGAL
557 {REG_DOMAIN_WORLD, {'P', 'W', ' '}}, //PALAU
558 {REG_DOMAIN_WORLD, {'P', 'Y', ' '}}, //PARAGUAY
559 {REG_DOMAIN_WORLD, {'Q', 'A', ' '}}, //QATAR
560 {REG_DOMAIN_WORLD, {'R', 'E', ' '}}, //REUNION
561 {REG_DOMAIN_HI_5GHZ, {'R', 'O', ' '}}, //ROMANIA
562 {REG_DOMAIN_HI_5GHZ, {'R', 'S', ' '}}, //SERBIA
563 {REG_DOMAIN_WORLD, {'R', 'U', ' '}}, //RUSSIA
564 {REG_DOMAIN_WORLD, {'R', 'W', ' '}}, //RWANDA
565 {REG_DOMAIN_WORLD, {'S', 'A', ' '}}, //SAUDI ARABIA
566 {REG_DOMAIN_WORLD, {'S', 'B', ' '}}, //SOLOMON ISLANDS
567 {REG_DOMAIN_ETSI, {'S', 'C', ' '}}, //SEYCHELLES
568 {REG_DOMAIN_WORLD, {'S', 'D', ' '}}, //SUDAN
569 {REG_DOMAIN_ETSI, {'S', 'E', ' '}}, //SWEDEN
570 {REG_DOMAIN_APAC, {'S', 'G', ' '}}, //SINGAPORE
571 {REG_DOMAIN_WORLD, {'S', 'H', ' '}}, //SAINT HELENA
572 {REG_DOMAIN_HI_5GHZ, {'S', 'I', ' '}}, //SLOVENNIA
573 {REG_DOMAIN_WORLD, {'S', 'J', ' '}}, //SVALBARD AND JAN MAYEN
574 {REG_DOMAIN_HI_5GHZ, {'S', 'K', ' '}}, //SLOVAKIA
575 {REG_DOMAIN_WORLD, {'S', 'L', ' '}}, //SIERRA LEONE
576 {REG_DOMAIN_WORLD, {'S', 'M', ' '}}, //SAN MARINO
577 {REG_DOMAIN_WORLD, {'S', 'N', ' '}}, //SENEGAL
578 {REG_DOMAIN_WORLD, {'S', 'O', ' '}}, //SOMALIA
579 {REG_DOMAIN_WORLD, {'S', 'R', ' '}}, //SURINAME
580 {REG_DOMAIN_WORLD, {'S', 'T', ' '}}, //SAO TOME AND PRINCIPE
581 {REG_DOMAIN_WORLD, {'S', 'V', ' '}}, //EL SALVADOR
582 {REG_DOMAIN_WORLD, {'S', 'Y', ' '}}, //SYRIAN ARAB REPUBLIC
583 {REG_DOMAIN_WORLD, {'S', 'Z', ' '}}, //SWAZILAND
584 {REG_DOMAIN_WORLD, {'T', 'C', ' '}}, //TURKS AND CAICOS ISLANDS
585 {REG_DOMAIN_WORLD, {'T', 'D', ' '}}, //CHAD
586 {REG_DOMAIN_WORLD, {'T', 'F', ' '}}, //FRENCH SOUTHERN TERRITORIES
587 {REG_DOMAIN_WORLD, {'T', 'G', ' '}}, //TOGO
588 {REG_DOMAIN_WORLD, {'T', 'H', ' '}}, //THAILAND
589 {REG_DOMAIN_WORLD, {'T', 'J', ' '}}, //TAJIKISTAN
590 {REG_DOMAIN_WORLD, {'T', 'K', ' '}}, //TOKELAU
591 {REG_DOMAIN_WORLD, {'T', 'L', ' '}}, //TIMOR-LESTE
592 {REG_DOMAIN_WORLD, {'T', 'M', ' '}}, //TURKMENISTAN
593 {REG_DOMAIN_WORLD, {'T', 'N', ' '}}, //TUNISIA
594 {REG_DOMAIN_WORLD, {'T', 'O', ' '}}, //TONGA
595 {REG_DOMAIN_WORLD, {'T', 'R', ' '}}, //TURKEY
596 {REG_DOMAIN_WORLD, {'T', 'T', ' '}}, //TRINIDAD AND TOBAGO
597 {REG_DOMAIN_WORLD, {'T', 'V', ' '}}, //TUVALU
598 {REG_DOMAIN_HI_5GHZ, {'T', 'W', ' '}}, //TAIWAN, PROVINCE OF CHINA
599 {REG_DOMAIN_WORLD, {'T', 'Z', ' '}}, //TANZANIA, UNITED REPUBLIC OF
600 {REG_DOMAIN_HI_5GHZ, {'U', 'A', ' '}}, //UKRAINE
601 {REG_DOMAIN_WORLD, {'U', 'G', ' '}}, //UGANDA
602 {REG_DOMAIN_FCC, {'U', 'M', ' '}}, //UNITED STATES MINOR OUTLYING ISLANDS
603 {REG_DOMAIN_WORLD, {'U', 'Y', ' '}}, //URUGUAY
604 {REG_DOMAIN_HI_5GHZ, {'U', 'Z', ' '}}, //UZBEKISTAN
605 {REG_DOMAIN_ETSI, {'V', 'A', ' '}}, //HOLY SEE (VATICAN CITY STATE)
606 {REG_DOMAIN_WORLD, {'V', 'C', ' '}}, //SAINT VINCENT AND THE GRENADINES
607 {REG_DOMAIN_HI_5GHZ, {'V', 'E', ' '}}, //VENEZUELA
608 {REG_DOMAIN_ETSI, {'V', 'G', ' '}}, //VIRGIN ISLANDS, BRITISH
609 {REG_DOMAIN_FCC, {'V', 'I', ' '}}, //VIRGIN ISLANDS, US
610 {REG_DOMAIN_WORLD, {'V', 'N', ' '}}, //VIET NAM
611 {REG_DOMAIN_WORLD, {'V', 'U', ' '}}, //VANUATU
612 {REG_DOMAIN_WORLD, {'W', 'F', ' '}}, //WALLIS AND FUTUNA
613 {REG_DOMAIN_WORLD, {'W', 'S', ' '}}, //SOMOA
614 {REG_DOMAIN_WORLD, {'Y', 'E', ' '}}, //YEMEN
615 {REG_DOMAIN_WORLD, {'Y', 'T', ' '}}, //MAYOTTE
616 {REG_DOMAIN_WORLD, {'Z', 'A', ' '}}, //SOUTH AFRICA
617 {REG_DOMAIN_WORLD, {'Z', 'M', ' '}}, //ZAMBIA
618 {REG_DOMAIN_WORLD, {'Z', 'W', ' '}}, //ZIMBABWE
619
620 {REG_DOMAIN_KOREA, {'K', '1', ' '}}, //Korea alternate 1
621 {REG_DOMAIN_KOREA, {'K', '2', ' '}}, //Korea alternate 2
622 {REG_DOMAIN_KOREA, {'K', '3', ' '}}, //Korea alternate 3
623 {REG_DOMAIN_KOREA, {'K', '4', ' '}}, //Korea alternate 4
624};
625
626
627//The channels listed here doesn't mean they are valid channels for certain domain. They are here only to present
628//whether they should be passive scanned.
629tCsrDomainChnInfo gCsrDomainChnInfo[NUM_REG_DOMAINS] =
630{
631 //REG_DOMAIN_FCC
632 {
633 REG_DOMAIN_FCC,
634 45, //Num channels
635 //Channels
636 {
637 //5GHz
638 //5180 - 5240
639 {36, eSIR_ACTIVE_SCAN},
640 {40, eSIR_ACTIVE_SCAN},
641 {44, eSIR_ACTIVE_SCAN},
642 {48, eSIR_ACTIVE_SCAN},
643 //5250 to 5350
644 {52, eSIR_PASSIVE_SCAN},
645 {56, eSIR_PASSIVE_SCAN},
646 {60, eSIR_PASSIVE_SCAN},
647 {64, eSIR_PASSIVE_SCAN},
648 //5470 to 5725
649 {100, eSIR_PASSIVE_SCAN},
650 {104, eSIR_PASSIVE_SCAN},
651 {108, eSIR_PASSIVE_SCAN},
652 {112, eSIR_PASSIVE_SCAN},
653 {116, eSIR_PASSIVE_SCAN},
654 {120, eSIR_PASSIVE_SCAN},
655 {124, eSIR_PASSIVE_SCAN},
656 {128, eSIR_PASSIVE_SCAN},
657 {132, eSIR_PASSIVE_SCAN},
658 {136, eSIR_PASSIVE_SCAN},
659 {140, eSIR_PASSIVE_SCAN},
660 //5745 - 5825
661 {149, eSIR_ACTIVE_SCAN},
662 {153, eSIR_ACTIVE_SCAN},
663 {157, eSIR_ACTIVE_SCAN},
664 {161, eSIR_ACTIVE_SCAN},
665 {165, eSIR_ACTIVE_SCAN},
666 //4.9GHz
667 //4920 - 5080
668 {240, eSIR_ACTIVE_SCAN},
669 {244, eSIR_ACTIVE_SCAN},
670 {248, eSIR_ACTIVE_SCAN},
671 {252, eSIR_ACTIVE_SCAN},
672 {208, eSIR_ACTIVE_SCAN},
673 {212, eSIR_ACTIVE_SCAN},
674 {216, eSIR_ACTIVE_SCAN},
675 //2,4GHz
676 {1, eSIR_ACTIVE_SCAN},
677 {2, eSIR_ACTIVE_SCAN},
678 {3, eSIR_ACTIVE_SCAN},
679 {4, eSIR_ACTIVE_SCAN},
680 {5, eSIR_ACTIVE_SCAN},
681 {6, eSIR_ACTIVE_SCAN},
682 {7, eSIR_ACTIVE_SCAN},
683 {8, eSIR_ACTIVE_SCAN},
684 {9, eSIR_ACTIVE_SCAN},
685 {10, eSIR_ACTIVE_SCAN},
686 {11, eSIR_ACTIVE_SCAN},
687 {12, eSIR_ACTIVE_SCAN},
688 {13, eSIR_ACTIVE_SCAN},
689 {14, eSIR_ACTIVE_SCAN},
690 }
691 },
692 //REG_DOMAIN_ETSI
693 {
694 REG_DOMAIN_ETSI,
695 45, //Num channels
696 //Channels
697 {
698 //5GHz
699 //5180 - 5240
700 {36, eSIR_ACTIVE_SCAN},
701 {40, eSIR_ACTIVE_SCAN},
702 {44, eSIR_ACTIVE_SCAN},
703 {48, eSIR_ACTIVE_SCAN},
704 //5250 to 5350
705 {52, eSIR_PASSIVE_SCAN},
706 {56, eSIR_PASSIVE_SCAN},
707 {60, eSIR_PASSIVE_SCAN},
708 {64, eSIR_PASSIVE_SCAN},
709 //5470 to 5725
710 {100, eSIR_PASSIVE_SCAN},
711 {104, eSIR_PASSIVE_SCAN},
712 {108, eSIR_PASSIVE_SCAN},
713 {112, eSIR_PASSIVE_SCAN},
714 {116, eSIR_PASSIVE_SCAN},
715 {120, eSIR_PASSIVE_SCAN},
716 {124, eSIR_PASSIVE_SCAN},
717 {128, eSIR_PASSIVE_SCAN},
718 {132, eSIR_PASSIVE_SCAN},
719 {136, eSIR_PASSIVE_SCAN},
720 {140, eSIR_PASSIVE_SCAN},
721 //5745 - 5825
722 {149, eSIR_ACTIVE_SCAN},
723 {153, eSIR_ACTIVE_SCAN},
724 {157, eSIR_ACTIVE_SCAN},
725 {161, eSIR_ACTIVE_SCAN},
726 {165, eSIR_ACTIVE_SCAN},
727 //4.9GHz
728 //4920 - 5080
729 {240, eSIR_ACTIVE_SCAN},
730 {244, eSIR_ACTIVE_SCAN},
731 {248, eSIR_ACTIVE_SCAN},
732 {252, eSIR_ACTIVE_SCAN},
733 {208, eSIR_ACTIVE_SCAN},
734 {212, eSIR_ACTIVE_SCAN},
735 {216, eSIR_ACTIVE_SCAN},
736 //2,4GHz
737 {1, eSIR_ACTIVE_SCAN},
738 {2, eSIR_ACTIVE_SCAN},
739 {3, eSIR_ACTIVE_SCAN},
740 {4, eSIR_ACTIVE_SCAN},
741 {5, eSIR_ACTIVE_SCAN},
742 {6, eSIR_ACTIVE_SCAN},
743 {7, eSIR_ACTIVE_SCAN},
744 {8, eSIR_ACTIVE_SCAN},
745 {9, eSIR_ACTIVE_SCAN},
746 {10, eSIR_ACTIVE_SCAN},
747 {11, eSIR_ACTIVE_SCAN},
748 {12, eSIR_ACTIVE_SCAN},
749 {13, eSIR_ACTIVE_SCAN},
750 {14, eSIR_ACTIVE_SCAN},
751 }
752 },
753 //REG_DOMAIN_JAPAN
754 {
755 REG_DOMAIN_JAPAN,
756 45, //Num channels
757 //Channels
758 {
759 //5GHz
760 //5180 - 5240
761 {36, eSIR_ACTIVE_SCAN},
762 {40, eSIR_ACTIVE_SCAN},
763 {44, eSIR_ACTIVE_SCAN},
764 {48, eSIR_ACTIVE_SCAN},
765 //5250 to 5350
766 {52, eSIR_PASSIVE_SCAN},
767 {56, eSIR_PASSIVE_SCAN},
768 {60, eSIR_PASSIVE_SCAN},
769 {64, eSIR_PASSIVE_SCAN},
770 //5470 to 5725
771 {100, eSIR_PASSIVE_SCAN},
772 {104, eSIR_PASSIVE_SCAN},
773 {108, eSIR_PASSIVE_SCAN},
774 {112, eSIR_PASSIVE_SCAN},
775 {116, eSIR_PASSIVE_SCAN},
776 {120, eSIR_PASSIVE_SCAN},
777 {124, eSIR_PASSIVE_SCAN},
778 {128, eSIR_PASSIVE_SCAN},
779 {132, eSIR_PASSIVE_SCAN},
780 {136, eSIR_PASSIVE_SCAN},
781 {140, eSIR_PASSIVE_SCAN},
782 //5745 - 5825
783 {149, eSIR_ACTIVE_SCAN},
784 {153, eSIR_ACTIVE_SCAN},
785 {157, eSIR_ACTIVE_SCAN},
786 {161, eSIR_ACTIVE_SCAN},
787 {165, eSIR_ACTIVE_SCAN},
788 //4.9GHz
789 //4920 - 5080
790 {240, eSIR_ACTIVE_SCAN},
791 {244, eSIR_ACTIVE_SCAN},
792 {248, eSIR_ACTIVE_SCAN},
793 {252, eSIR_ACTIVE_SCAN},
794 {208, eSIR_ACTIVE_SCAN},
795 {212, eSIR_ACTIVE_SCAN},
796 {216, eSIR_ACTIVE_SCAN},
797 //2,4GHz
798 {1, eSIR_ACTIVE_SCAN},
799 {2, eSIR_ACTIVE_SCAN},
800 {3, eSIR_ACTIVE_SCAN},
801 {4, eSIR_ACTIVE_SCAN},
802 {5, eSIR_ACTIVE_SCAN},
803 {6, eSIR_ACTIVE_SCAN},
804 {7, eSIR_ACTIVE_SCAN},
805 {8, eSIR_ACTIVE_SCAN},
806 {9, eSIR_ACTIVE_SCAN},
807 {10, eSIR_ACTIVE_SCAN},
808 {11, eSIR_ACTIVE_SCAN},
809 {12, eSIR_ACTIVE_SCAN},
810 {13, eSIR_ACTIVE_SCAN},
811 {14, eSIR_ACTIVE_SCAN},
812 }
813 },
814 //REG_DOMAIN_WORLD
815 {
816 REG_DOMAIN_WORLD,
817 45, //Num channels
818 //Channels
819 {
820 //5GHz
821 //5180 - 5240
822 {36, eSIR_ACTIVE_SCAN},
823 {40, eSIR_ACTIVE_SCAN},
824 {44, eSIR_ACTIVE_SCAN},
825 {48, eSIR_ACTIVE_SCAN},
826 //5250 to 5350
827 {52, eSIR_ACTIVE_SCAN},
828 {56, eSIR_ACTIVE_SCAN},
829 {60, eSIR_ACTIVE_SCAN},
830 {64, eSIR_ACTIVE_SCAN},
831 //5470 to 5725
832 {100, eSIR_ACTIVE_SCAN},
833 {104, eSIR_ACTIVE_SCAN},
834 {108, eSIR_ACTIVE_SCAN},
835 {112, eSIR_ACTIVE_SCAN},
836 {116, eSIR_ACTIVE_SCAN},
837 {120, eSIR_ACTIVE_SCAN},
838 {124, eSIR_ACTIVE_SCAN},
839 {128, eSIR_ACTIVE_SCAN},
840 {132, eSIR_ACTIVE_SCAN},
841 {136, eSIR_ACTIVE_SCAN},
842 {140, eSIR_ACTIVE_SCAN},
843 //5745 - 5825
844 {149, eSIR_ACTIVE_SCAN},
845 {153, eSIR_ACTIVE_SCAN},
846 {157, eSIR_ACTIVE_SCAN},
847 {161, eSIR_ACTIVE_SCAN},
848 {165, eSIR_ACTIVE_SCAN},
849 //4.9GHz
850 //4920 - 5080
851 {240, eSIR_ACTIVE_SCAN},
852 {244, eSIR_ACTIVE_SCAN},
853 {248, eSIR_ACTIVE_SCAN},
854 {252, eSIR_ACTIVE_SCAN},
855 {208, eSIR_ACTIVE_SCAN},
856 {212, eSIR_ACTIVE_SCAN},
857 {216, eSIR_ACTIVE_SCAN},
858 //2,4GHz
859 {1, eSIR_ACTIVE_SCAN},
860 {2, eSIR_ACTIVE_SCAN},
861 {3, eSIR_ACTIVE_SCAN},
862 {4, eSIR_ACTIVE_SCAN},
863 {5, eSIR_ACTIVE_SCAN},
864 {6, eSIR_ACTIVE_SCAN},
865 {7, eSIR_ACTIVE_SCAN},
866 {8, eSIR_ACTIVE_SCAN},
867 {9, eSIR_ACTIVE_SCAN},
868 {10, eSIR_ACTIVE_SCAN},
869 {11, eSIR_ACTIVE_SCAN},
870 {12, eSIR_ACTIVE_SCAN},
871 {13, eSIR_ACTIVE_SCAN},
872 {14, eSIR_ACTIVE_SCAN},
873 }
874 },
875 //REG_DOMAIN_N_AMER_EXC_FCC
876 {
877 REG_DOMAIN_N_AMER_EXC_FCC,
878 45, //Num channels
879 //Channels
880 {
881 //5GHz
882 //5180 - 5240
883 {36, eSIR_ACTIVE_SCAN},
884 {40, eSIR_ACTIVE_SCAN},
885 {44, eSIR_ACTIVE_SCAN},
886 {48, eSIR_ACTIVE_SCAN},
887 //5250 to 5350
888 {52, eSIR_PASSIVE_SCAN},
889 {56, eSIR_PASSIVE_SCAN},
890 {60, eSIR_PASSIVE_SCAN},
891 {64, eSIR_PASSIVE_SCAN},
892 //5470 to 5725
893 {100, eSIR_ACTIVE_SCAN},
894 {104, eSIR_ACTIVE_SCAN},
895 {108, eSIR_ACTIVE_SCAN},
896 {112, eSIR_ACTIVE_SCAN},
897 {116, eSIR_ACTIVE_SCAN},
898 {120, eSIR_ACTIVE_SCAN},
899 {124, eSIR_ACTIVE_SCAN},
900 {128, eSIR_ACTIVE_SCAN},
901 {132, eSIR_ACTIVE_SCAN},
902 {136, eSIR_ACTIVE_SCAN},
903 {140, eSIR_ACTIVE_SCAN},
904 //5745 - 5825
905 {149, eSIR_ACTIVE_SCAN},
906 {153, eSIR_ACTIVE_SCAN},
907 {157, eSIR_ACTIVE_SCAN},
908 {161, eSIR_ACTIVE_SCAN},
909 {165, eSIR_ACTIVE_SCAN},
910 //4.9GHz
911 //4920 - 5080
912 {240, eSIR_ACTIVE_SCAN},
913 {244, eSIR_ACTIVE_SCAN},
914 {248, eSIR_ACTIVE_SCAN},
915 {252, eSIR_ACTIVE_SCAN},
916 {208, eSIR_ACTIVE_SCAN},
917 {212, eSIR_ACTIVE_SCAN},
918 {216, eSIR_ACTIVE_SCAN},
919 //2,4GHz
920 {1, eSIR_ACTIVE_SCAN},
921 {2, eSIR_ACTIVE_SCAN},
922 {3, eSIR_ACTIVE_SCAN},
923 {4, eSIR_ACTIVE_SCAN},
924 {5, eSIR_ACTIVE_SCAN},
925 {6, eSIR_ACTIVE_SCAN},
926 {7, eSIR_ACTIVE_SCAN},
927 {8, eSIR_ACTIVE_SCAN},
928 {9, eSIR_ACTIVE_SCAN},
929 {10, eSIR_ACTIVE_SCAN},
930 {11, eSIR_ACTIVE_SCAN},
931 {12, eSIR_ACTIVE_SCAN},
932 {13, eSIR_ACTIVE_SCAN},
933 {14, eSIR_ACTIVE_SCAN},
934 }
935 },
936 //REG_DOMAIN_APAC
937 {
938 REG_DOMAIN_APAC,
939 45, //Num channels
940 //Channels
941 {
942 //5GHz
943 //5180 - 5240
944 {36, eSIR_ACTIVE_SCAN},
945 {40, eSIR_ACTIVE_SCAN},
946 {44, eSIR_ACTIVE_SCAN},
947 {48, eSIR_ACTIVE_SCAN},
948 //5250 to 5350
949 {52, eSIR_PASSIVE_SCAN},
950 {56, eSIR_PASSIVE_SCAN},
951 {60, eSIR_PASSIVE_SCAN},
952 {64, eSIR_PASSIVE_SCAN},
953 //5470 to 5725
954 {100, eSIR_ACTIVE_SCAN},
955 {104, eSIR_ACTIVE_SCAN},
956 {108, eSIR_ACTIVE_SCAN},
957 {112, eSIR_ACTIVE_SCAN},
958 {116, eSIR_ACTIVE_SCAN},
959 {120, eSIR_ACTIVE_SCAN},
960 {124, eSIR_ACTIVE_SCAN},
961 {128, eSIR_ACTIVE_SCAN},
962 {132, eSIR_ACTIVE_SCAN},
963 {136, eSIR_ACTIVE_SCAN},
964 {140, eSIR_ACTIVE_SCAN},
965 //5745 - 5825
966 {149, eSIR_ACTIVE_SCAN},
967 {153, eSIR_ACTIVE_SCAN},
968 {157, eSIR_ACTIVE_SCAN},
969 {161, eSIR_ACTIVE_SCAN},
970 {165, eSIR_ACTIVE_SCAN},
971 //4.9GHz
972 //4920 - 5080
973 {240, eSIR_ACTIVE_SCAN},
974 {244, eSIR_ACTIVE_SCAN},
975 {248, eSIR_ACTIVE_SCAN},
976 {252, eSIR_ACTIVE_SCAN},
977 {208, eSIR_ACTIVE_SCAN},
978 {212, eSIR_ACTIVE_SCAN},
979 {216, eSIR_ACTIVE_SCAN},
980 //2,4GHz
981 {1, eSIR_ACTIVE_SCAN},
982 {2, eSIR_ACTIVE_SCAN},
983 {3, eSIR_ACTIVE_SCAN},
984 {4, eSIR_ACTIVE_SCAN},
985 {5, eSIR_ACTIVE_SCAN},
986 {6, eSIR_ACTIVE_SCAN},
987 {7, eSIR_ACTIVE_SCAN},
988 {8, eSIR_ACTIVE_SCAN},
989 {9, eSIR_ACTIVE_SCAN},
990 {10, eSIR_ACTIVE_SCAN},
991 {11, eSIR_ACTIVE_SCAN},
992 {12, eSIR_ACTIVE_SCAN},
993 {13, eSIR_ACTIVE_SCAN},
994 {14, eSIR_ACTIVE_SCAN},
995 }
996 },
997 //REG_DOMAIN_KOREA
998 {
999 REG_DOMAIN_KOREA,
1000 45, //Num channels
1001 //Channels
1002 {
1003 //5GHz
1004 //5180 - 5240
1005 {36, eSIR_ACTIVE_SCAN},
1006 {40, eSIR_ACTIVE_SCAN},
1007 {44, eSIR_ACTIVE_SCAN},
1008 {48, eSIR_ACTIVE_SCAN},
1009 //5250 to 5350
1010 {52, eSIR_PASSIVE_SCAN},
1011 {56, eSIR_PASSIVE_SCAN},
1012 {60, eSIR_PASSIVE_SCAN},
1013 {64, eSIR_PASSIVE_SCAN},
1014 //5470 to 5725
1015 {100, eSIR_PASSIVE_SCAN},
1016 {104, eSIR_PASSIVE_SCAN},
1017 {108, eSIR_PASSIVE_SCAN},
1018 {112, eSIR_PASSIVE_SCAN},
1019 {116, eSIR_PASSIVE_SCAN},
1020 {120, eSIR_PASSIVE_SCAN},
1021 {124, eSIR_PASSIVE_SCAN},
1022 {128, eSIR_PASSIVE_SCAN},
1023 {132, eSIR_PASSIVE_SCAN},
1024 {136, eSIR_PASSIVE_SCAN},
1025 {140, eSIR_PASSIVE_SCAN},
1026 //5745 - 5825
1027 {149, eSIR_ACTIVE_SCAN},
1028 {153, eSIR_ACTIVE_SCAN},
1029 {157, eSIR_ACTIVE_SCAN},
1030 {161, eSIR_ACTIVE_SCAN},
1031 {165, eSIR_ACTIVE_SCAN},
1032 //4.9GHz
1033 //4920 - 5080
1034 {240, eSIR_ACTIVE_SCAN},
1035 {244, eSIR_ACTIVE_SCAN},
1036 {248, eSIR_ACTIVE_SCAN},
1037 {252, eSIR_ACTIVE_SCAN},
1038 {208, eSIR_ACTIVE_SCAN},
1039 {212, eSIR_ACTIVE_SCAN},
1040 {216, eSIR_ACTIVE_SCAN},
1041 //2,4GHz
1042 {1, eSIR_ACTIVE_SCAN},
1043 {2, eSIR_ACTIVE_SCAN},
1044 {3, eSIR_ACTIVE_SCAN},
1045 {4, eSIR_ACTIVE_SCAN},
1046 {5, eSIR_ACTIVE_SCAN},
1047 {6, eSIR_ACTIVE_SCAN},
1048 {7, eSIR_ACTIVE_SCAN},
1049 {8, eSIR_ACTIVE_SCAN},
1050 {9, eSIR_ACTIVE_SCAN},
1051 {10, eSIR_ACTIVE_SCAN},
1052 {11, eSIR_ACTIVE_SCAN},
1053 {12, eSIR_ACTIVE_SCAN},
1054 {13, eSIR_ACTIVE_SCAN},
1055 {14, eSIR_ACTIVE_SCAN},
1056 }
1057 },
1058 //REG_DOMAIN_HI_5GHZ
1059 {
1060 REG_DOMAIN_HI_5GHZ,
1061 45, //Num channels
1062 //Channels
1063 {
1064 //5GHz
1065 //5180 - 5240
1066 {36, eSIR_ACTIVE_SCAN},
1067 {40, eSIR_ACTIVE_SCAN},
1068 {44, eSIR_ACTIVE_SCAN},
1069 {48, eSIR_ACTIVE_SCAN},
1070 //5250 to 5350
1071 {52, eSIR_ACTIVE_SCAN},
1072 {56, eSIR_ACTIVE_SCAN},
1073 {60, eSIR_ACTIVE_SCAN},
1074 {64, eSIR_ACTIVE_SCAN},
1075 //5470 to 5725
1076 {100, eSIR_ACTIVE_SCAN},
1077 {104, eSIR_ACTIVE_SCAN},
1078 {108, eSIR_ACTIVE_SCAN},
1079 {112, eSIR_ACTIVE_SCAN},
1080 {116, eSIR_ACTIVE_SCAN},
1081 {120, eSIR_ACTIVE_SCAN},
1082 {124, eSIR_ACTIVE_SCAN},
1083 {128, eSIR_ACTIVE_SCAN},
1084 {132, eSIR_ACTIVE_SCAN},
1085 {136, eSIR_ACTIVE_SCAN},
1086 {140, eSIR_ACTIVE_SCAN},
1087 //5745 - 5825
1088 {149, eSIR_ACTIVE_SCAN},
1089 {153, eSIR_ACTIVE_SCAN},
1090 {157, eSIR_ACTIVE_SCAN},
1091 {161, eSIR_ACTIVE_SCAN},
1092 {165, eSIR_ACTIVE_SCAN},
1093 //4.9GHz
1094 //4920 - 5080
1095 {240, eSIR_ACTIVE_SCAN},
1096 {244, eSIR_ACTIVE_SCAN},
1097 {248, eSIR_ACTIVE_SCAN},
1098 {252, eSIR_ACTIVE_SCAN},
1099 {208, eSIR_ACTIVE_SCAN},
1100 {212, eSIR_ACTIVE_SCAN},
1101 {216, eSIR_ACTIVE_SCAN},
1102 //2,4GHz
1103 {1, eSIR_ACTIVE_SCAN},
1104 {2, eSIR_ACTIVE_SCAN},
1105 {3, eSIR_ACTIVE_SCAN},
1106 {4, eSIR_ACTIVE_SCAN},
1107 {5, eSIR_ACTIVE_SCAN},
1108 {6, eSIR_ACTIVE_SCAN},
1109 {7, eSIR_ACTIVE_SCAN},
1110 {8, eSIR_ACTIVE_SCAN},
1111 {9, eSIR_ACTIVE_SCAN},
1112 {10, eSIR_ACTIVE_SCAN},
1113 {11, eSIR_ACTIVE_SCAN},
1114 {12, eSIR_ACTIVE_SCAN},
1115 {13, eSIR_ACTIVE_SCAN},
1116 {14, eSIR_ACTIVE_SCAN},
1117 }
1118 },
1119 //REG_DOMAIN_NO_5GHZ
1120 {
1121 REG_DOMAIN_NO_5GHZ,
1122 45, //Num channels
1123 //Channels
1124 {
1125 //5GHz
1126 //5180 - 5240
1127 {36, eSIR_ACTIVE_SCAN},
1128 {40, eSIR_ACTIVE_SCAN},
1129 {44, eSIR_ACTIVE_SCAN},
1130 {48, eSIR_ACTIVE_SCAN},
1131 //5250 to 5350
1132 {52, eSIR_ACTIVE_SCAN},
1133 {56, eSIR_ACTIVE_SCAN},
1134 {60, eSIR_ACTIVE_SCAN},
1135 {64, eSIR_ACTIVE_SCAN},
1136 //5470 to 5725
1137 {100, eSIR_ACTIVE_SCAN},
1138 {104, eSIR_ACTIVE_SCAN},
1139 {108, eSIR_ACTIVE_SCAN},
1140 {112, eSIR_ACTIVE_SCAN},
1141 {116, eSIR_ACTIVE_SCAN},
1142 {120, eSIR_ACTIVE_SCAN},
1143 {124, eSIR_ACTIVE_SCAN},
1144 {128, eSIR_ACTIVE_SCAN},
1145 {132, eSIR_ACTIVE_SCAN},
1146 {136, eSIR_ACTIVE_SCAN},
1147 {140, eSIR_ACTIVE_SCAN},
1148 //5745 - 5825
1149 {149, eSIR_ACTIVE_SCAN},
1150 {153, eSIR_ACTIVE_SCAN},
1151 {157, eSIR_ACTIVE_SCAN},
1152 {161, eSIR_ACTIVE_SCAN},
1153 {165, eSIR_ACTIVE_SCAN},
1154 //4.9GHz
1155 //4920 - 5080
1156 {240, eSIR_ACTIVE_SCAN},
1157 {244, eSIR_ACTIVE_SCAN},
1158 {248, eSIR_ACTIVE_SCAN},
1159 {252, eSIR_ACTIVE_SCAN},
1160 {208, eSIR_ACTIVE_SCAN},
1161 {212, eSIR_ACTIVE_SCAN},
1162 {216, eSIR_ACTIVE_SCAN},
1163 //2,4GHz
1164 {1, eSIR_ACTIVE_SCAN},
1165 {2, eSIR_ACTIVE_SCAN},
1166 {3, eSIR_ACTIVE_SCAN},
1167 {4, eSIR_ACTIVE_SCAN},
1168 {5, eSIR_ACTIVE_SCAN},
1169 {6, eSIR_ACTIVE_SCAN},
1170 {7, eSIR_ACTIVE_SCAN},
1171 {8, eSIR_ACTIVE_SCAN},
1172 {9, eSIR_ACTIVE_SCAN},
1173 {10, eSIR_ACTIVE_SCAN},
1174 {11, eSIR_ACTIVE_SCAN},
1175 {12, eSIR_ACTIVE_SCAN},
1176 {13, eSIR_ACTIVE_SCAN},
1177 {14, eSIR_ACTIVE_SCAN},
1178 }
1179 },
1180};
1181#endif
1182
1183extern const tRfChannelProps rfChannels[NUM_RF_CHANNELS];
1184
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1185////////////////////////////////////////////////////////////////////////
1186
1187/**
1188 * \var gPhyRatesSuppt
1189 *
1190 * \brief Rate support lookup table
1191 *
1192 *
1193 * This is a lookup table indexing rates & configuration parameters to
1194 * support. Given a rate (in unites of 0.5Mpbs) & three booleans (MIMO
1195 * Enabled, Channel Bonding Enabled, & Concatenation Enabled), one can
1196 * determine whether the given rate is supported by computing two
1197 * indices. The first maps the rate to table row as indicated below
1198 * (i.e. eHddSuppRate_6Mbps maps to row zero, eHddSuppRate_9Mbps to row
1199 * 1, and so on). Index two can be computed like so:
1200 *
1201 * \code
1202 idx2 = ( fEsf ? 0x4 : 0x0 ) |
1203 ( fCb ? 0x2 : 0x0 ) |
1204 ( fMimo ? 0x1 : 0x0 );
1205 * \endcode
1206 *
1207 *
1208 * Given that:
1209 *
1210 \code
1211 fSupported = gPhyRatesSuppt[idx1][idx2];
1212 \endcode
1213 *
1214 *
1215 * This table is based on the document "PHY Supported Rates.doc". This
1216 * table is permissive in that a rate is reflected as being supported
1217 * even when turning off an enabled feature would be required. For
1218 * instance, "PHY Supported Rates" lists 42Mpbs as unsupported when CB,
1219 * ESF, & MIMO are all on. However, if we turn off either of CB or
1220 * MIMO, it then becomes supported. Therefore, we mark it as supported
1221 * even in index 7 of this table.
1222 *
1223 *
1224 */
1225
1226static const tANI_BOOLEAN gPhyRatesSuppt[24][8] = {
1227
1228 // SSF SSF SSF SSF ESF ESF ESF ESF
1229 // SIMO MIMO SIMO MIMO SIMO MIMO SIMO MIMO
1230 // No CB No CB CB CB No CB No CB CB CB
1231 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 6Mbps
1232 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 9Mbps
1233 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 12Mbps
1234 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 18Mbps
1235 { FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE }, // 20Mbps
1236 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 24Mbps
1237 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 36Mbps
1238 { FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 40Mbps
1239 { FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 42Mbps
1240 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 48Mbps
1241 { TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE }, // 54Mbps
1242 { FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 72Mbps
1243 { FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 80Mbps
1244 { FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 84Mbps
1245 { FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 96Mbps
1246 { FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 108Mbps
1247 { FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 120Mbps
1248 { FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE }, // 126Mbps
1249 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 144Mbps
1250 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 160Mbps
1251 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 168Mbps
1252 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 192Mbps
1253 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 216Mbps
1254 { FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE }, // 240Mbps
1255
1256};
1257
1258#define CASE_RETURN_STR(n) case (n): return (#n)
1259
1260const char *
1261get_eRoamCmdStatus_str(eRoamCmdStatus val)
1262{
1263 switch (val)
1264 {
1265 CASE_RETURN_STR(eCSR_ROAM_CANCELLED);
1266 CASE_RETURN_STR(eCSR_ROAM_ROAMING_START);
1267 CASE_RETURN_STR(eCSR_ROAM_ROAMING_COMPLETION);
1268 CASE_RETURN_STR(eCSR_ROAM_ASSOCIATION_START);
1269 CASE_RETURN_STR(eCSR_ROAM_ASSOCIATION_COMPLETION);
1270 CASE_RETURN_STR(eCSR_ROAM_DISASSOCIATED);
1271 CASE_RETURN_STR(eCSR_ROAM_SHOULD_ROAM);
1272 CASE_RETURN_STR(eCSR_ROAM_SCAN_FOUND_NEW_BSS);
1273 CASE_RETURN_STR(eCSR_ROAM_LOSTLINK);
1274 default:
1275 return "unknown";
1276 }
1277}
1278
1279const char *
1280get_eCsrRoamResult_str(eCsrRoamResult val)
1281{
1282 switch (val)
1283 {
1284 CASE_RETURN_STR(eCSR_ROAM_RESULT_NONE);
1285 CASE_RETURN_STR(eCSR_ROAM_RESULT_FAILURE);
1286 CASE_RETURN_STR(eCSR_ROAM_RESULT_ASSOCIATED);
1287 CASE_RETURN_STR(eCSR_ROAM_RESULT_NOT_ASSOCIATED);
1288 CASE_RETURN_STR(eCSR_ROAM_RESULT_MIC_FAILURE);
1289 CASE_RETURN_STR(eCSR_ROAM_RESULT_FORCED);
1290 CASE_RETURN_STR(eCSR_ROAM_RESULT_DISASSOC_IND);
1291 CASE_RETURN_STR(eCSR_ROAM_RESULT_DEAUTH_IND);
1292 CASE_RETURN_STR(eCSR_ROAM_RESULT_CAP_CHANGED);
1293 CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_CONNECT);
1294 CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_INACTIVE);
1295 CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_NEW_PEER);
1296 CASE_RETURN_STR(eCSR_ROAM_RESULT_IBSS_COALESCED);
1297 default:
1298 return "unknown";
1299 }
1300}
1301
1302
1303
1304tANI_BOOLEAN csrGetBssIdBssDesc( tHalHandle hHal, tSirBssDescription *pSirBssDesc, tCsrBssid *pBssId )
1305{
1306 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1307 palCopyMemory( pMac->hHdd, pBssId, &pSirBssDesc->bssId[ 0 ], sizeof(tCsrBssid) );
1308 return( TRUE );
1309}
1310
1311
1312tANI_BOOLEAN csrIsBssIdEqual( tHalHandle hHal, tSirBssDescription *pSirBssDesc1, tSirBssDescription *pSirBssDesc2 )
1313{
1314 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1315 tANI_BOOLEAN fEqual = FALSE;
1316 tCsrBssid bssId1;
1317 tCsrBssid bssId2;
1318
1319 do {
1320 if ( !pSirBssDesc1 ) break;
1321 if ( !pSirBssDesc2 ) break;
1322
1323 if ( !csrGetBssIdBssDesc( pMac, pSirBssDesc1, &bssId1 ) ) break;
1324 if ( !csrGetBssIdBssDesc( pMac, pSirBssDesc2, &bssId2 ) ) break;
1325
1326 //sirCompareMacAddr
1327 fEqual = csrIsMacAddressEqual(pMac, &bssId1, &bssId2);
1328
1329 } while( 0 );
1330
1331 return( fEqual );
1332}
1333
1334tANI_BOOLEAN csrIsConnStateConnectedIbss( tpAniSirGlobal pMac, tANI_U32 sessionId )
1335{
1336 return( eCSR_ASSOC_STATE_TYPE_IBSS_CONNECTED == pMac->roam.roamSession[sessionId].connectState );
1337}
1338
1339tANI_BOOLEAN csrIsConnStateDisconnectedIbss( tpAniSirGlobal pMac, tANI_U32 sessionId )
1340{
1341 return( eCSR_ASSOC_STATE_TYPE_IBSS_DISCONNECTED == pMac->roam.roamSession[sessionId].connectState );
1342}
1343
1344tANI_BOOLEAN csrIsConnStateConnectedInfra( tpAniSirGlobal pMac, tANI_U32 sessionId )
1345{
1346 return( eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED == pMac->roam.roamSession[sessionId].connectState );
1347}
1348
1349tANI_BOOLEAN csrIsConnStateConnected( tpAniSirGlobal pMac, tANI_U32 sessionId )
1350{
1351 if( csrIsConnStateConnectedIbss( pMac, sessionId ) || csrIsConnStateConnectedInfra( pMac, sessionId ) || csrIsConnStateConnectedWds( pMac, sessionId) )
1352 return TRUE;
1353 else
1354 return FALSE;
1355}
1356
1357tANI_BOOLEAN csrIsConnStateInfra( tpAniSirGlobal pMac, tANI_U32 sessionId )
1358{
1359 return( csrIsConnStateConnectedInfra( pMac, sessionId ) );
1360}
1361
1362tANI_BOOLEAN csrIsConnStateIbss( tpAniSirGlobal pMac, tANI_U32 sessionId )
1363{
1364 return( csrIsConnStateConnectedIbss( pMac, sessionId ) || csrIsConnStateDisconnectedIbss( pMac, sessionId ) );
1365}
1366
1367
1368tANI_BOOLEAN csrIsConnStateConnectedWds( tpAniSirGlobal pMac, tANI_U32 sessionId )
1369{
1370 return( eCSR_ASSOC_STATE_TYPE_WDS_CONNECTED == pMac->roam.roamSession[sessionId].connectState );
1371}
1372
1373#ifdef WLAN_SOFTAP_FEATURE
1374tANI_BOOLEAN csrIsConnStateConnectedInfraAp( tpAniSirGlobal pMac, tANI_U32 sessionId )
1375{
1376 return( (eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED == pMac->roam.roamSession[sessionId].connectState) ||
1377 (eCSR_ASSOC_STATE_TYPE_INFRA_DISCONNECTED == pMac->roam.roamSession[sessionId].connectState ) );
1378}
1379#endif
1380
1381tANI_BOOLEAN csrIsConnStateDisconnectedWds( tpAniSirGlobal pMac, tANI_U32 sessionId )
1382{
1383 return( eCSR_ASSOC_STATE_TYPE_WDS_DISCONNECTED == pMac->roam.roamSession[sessionId].connectState );
1384}
1385
1386tANI_BOOLEAN csrIsConnStateWds( tpAniSirGlobal pMac, tANI_U32 sessionId )
1387{
1388 return( csrIsConnStateConnectedWds( pMac, sessionId ) ||
1389 csrIsConnStateDisconnectedWds( pMac, sessionId ) );
1390}
1391
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1392tANI_BOOLEAN csrIsConnStateAp( tpAniSirGlobal pMac, tANI_U32 sessionId )
1393{
1394 tCsrRoamSession *pSession;
1395 pSession = CSR_GET_SESSION(pMac, sessionId);
1396 if (!pSession)
1397 return eANI_BOOLEAN_FALSE;
1398 if ( CSR_IS_INFRA_AP(&pSession->connectedProfile) )
1399 {
1400 return eANI_BOOLEAN_TRUE;
1401 }
1402 return eANI_BOOLEAN_FALSE;
1403}
1404
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1405tANI_BOOLEAN csrIsAnySessionInConnectState( tpAniSirGlobal pMac )
1406{
1407 tANI_U32 i;
1408 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1409
1410 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1411 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1412 if( CSR_IS_SESSION_VALID( pMac, i ) &&
1413 ( csrIsConnStateInfra( pMac, i )
1414 || csrIsConnStateIbss( pMac, i )
1415 || csrIsConnStateAp( pMac, i) ) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1416 {
1417 fRc = eANI_BOOLEAN_TRUE;
1418 break;
1419 }
1420 }
1421
1422 return ( fRc );
1423}
1424
1425tANI_S8 csrGetInfraSessionId( tpAniSirGlobal pMac )
1426{
1427 tANI_U8 i;
1428 tANI_S8 sessionid = -1;
1429
1430 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1431 {
1432 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateInfra( pMac, i ) )
1433 {
1434 sessionid = i;
1435 break;
1436 }
1437 }
1438
1439 return ( sessionid );
1440}
1441
1442tANI_U8 csrGetInfraOperationChannel( tpAniSirGlobal pMac, tANI_U8 sessionId)
1443{
1444 tANI_U8 channel;
1445
1446 if( CSR_IS_SESSION_VALID( pMac, sessionId ))
1447 {
1448 channel = pMac->roam.roamSession[sessionId].connectedProfile.operationChannel;
1449 }
1450 else
1451 {
1452 channel = 0;
1453 }
1454 return channel;
1455}
1456
1457//This routine will return operating channel on FIRST BSS that is active/operating to be used for concurrency mode.
1458//If other BSS is not up or not connected it will return 0
1459
1460tANI_U8 csrGetConcurrentOperationChannel( tpAniSirGlobal pMac )
1461{
1462 tCsrRoamSession *pSession = NULL;
1463 tANI_U8 i = 0;
1464
1465 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1466 {
1467 if( CSR_IS_SESSION_VALID( pMac, i ) )
1468 {
1469 pSession = CSR_GET_SESSION( pMac, i );
1470
1471 if (NULL != pSession->pCurRoamProfile)
1472 {
1473 if (
1474 (((pSession->pCurRoamProfile->csrPersona == VOS_STA_MODE) ||
1475 (pSession->pCurRoamProfile->csrPersona == VOS_P2P_CLIENT_MODE)) &&
1476 (pSession->connectState == eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED))
1477 ||
1478 (((pSession->pCurRoamProfile->csrPersona == VOS_P2P_GO_MODE) ||
1479 (pSession->pCurRoamProfile->csrPersona == VOS_STA_SAP_MODE)) &&
1480 (pSession->connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
1481 )
1482 return (pSession->connectedProfile.operationChannel);
1483 }
1484
1485 }
1486 }
1487 return 0;
1488}
1489
1490tANI_BOOLEAN csrIsAllSessionDisconnected( tpAniSirGlobal pMac )
1491{
1492 tANI_U32 i;
1493 tANI_BOOLEAN fRc = eANI_BOOLEAN_TRUE;
1494
1495 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1496 {
1497 if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
1498 {
1499 fRc = eANI_BOOLEAN_FALSE;
1500 break;
1501 }
1502 }
1503
1504 return ( fRc );
1505}
1506
Madan Mohan Koyyalamudi48081ef2012-12-04 16:49:55 -0800[diff] [blame]1507tANI_BOOLEAN csrIsStaSessionConnected( tpAniSirGlobal pMac )
1508{
1509 tANI_U32 i;
1510 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1511 tCsrRoamSession *pSession = NULL;
1512 tANI_U32 countSta = 0;
1513
1514 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1515 {
1516 if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
1517 {
1518 pSession = CSR_GET_SESSION( pMac, i );
1519
1520 if (NULL != pSession->pCurRoamProfile)
1521 {
1522 if (pSession->pCurRoamProfile->csrPersona == VOS_STA_MODE) {
1523 countSta++;
1524 }
1525 }
1526 }
1527 }
1528
1529 /* return TRUE if one of the following conditions is TRUE:
1530 * - more than one STA session connected
1531 */
1532 if ( countSta > 0) {
1533 fRc = eANI_BOOLEAN_TRUE;
1534 }
1535
1536 return( fRc );
1537}
1538
1539tANI_BOOLEAN csrIsP2pSessionConnected( tpAniSirGlobal pMac )
1540{
1541 tANI_U32 i;
1542 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1543 tCsrRoamSession *pSession = NULL;
1544 tANI_U32 countP2pCli = 0;
1545 tANI_U32 countP2pGo = 0;
1546
1547 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1548 {
1549 if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
1550 {
1551 pSession = CSR_GET_SESSION( pMac, i );
1552
1553 if (NULL != pSession->pCurRoamProfile)
1554 {
1555 if (pSession->pCurRoamProfile->csrPersona == VOS_P2P_CLIENT_MODE) {
1556 countP2pCli++;
1557 }
1558
1559 if (pSession->pCurRoamProfile->csrPersona == VOS_P2P_GO_MODE) {
1560 countP2pGo++;
1561 }
1562 }
1563 }
1564 }
1565
1566 /* return TRUE if one of the following conditions is TRUE:
1567 * - at least one P2P CLI session is connected
1568 * - at least one P2P GO session is connected
1569 */
1570 if ( (countP2pCli > 0) || (countP2pGo > 0 ) ) {
1571 fRc = eANI_BOOLEAN_TRUE;
1572 }
1573
1574 return( fRc );
1575}
1576
Madan Mohan Koyyalamudid3d22592012-09-24 14:01:29 -0700[diff] [blame]1577tANI_BOOLEAN csrIsAnySessionConnected( tpAniSirGlobal pMac )
1578{
1579 tANI_U32 i, count;
1580 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1581
1582 count = 0;
1583 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1584 {
1585 if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
1586 {
1587 count++;
1588 }
1589 }
1590
1591 if (count > 0)
1592 {
1593 fRc = eANI_BOOLEAN_TRUE;
1594 }
1595 return( fRc );
1596}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1597
1598tANI_BOOLEAN csrIsInfraConnected( tpAniSirGlobal pMac )
1599{
1600 tANI_U32 i;
1601 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1602
1603 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1604 {
1605 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedInfra( pMac, i ) )
1606 {
1607 fRc = eANI_BOOLEAN_TRUE;
1608 break;
1609 }
1610 }
1611
1612 return ( fRc );
1613}
1614
1615tANI_BOOLEAN csrIsConcurrentInfraConnected( tpAniSirGlobal pMac )
1616{
1617 tANI_U32 i, noOfConnectedInfra = 0;
1618
1619 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1620
1621 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1622 {
1623 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedInfra( pMac, i ) )
1624 {
1625 ++noOfConnectedInfra;
1626 }
1627 }
1628
1629 // More than one Infra Sta Connected
1630 if(noOfConnectedInfra > 1)
1631 {
1632 fRc = eANI_BOOLEAN_TRUE;
1633 }
1634
1635 return ( fRc );
1636}
1637
1638tANI_BOOLEAN csrIsIBSSStarted( tpAniSirGlobal pMac )
1639{
1640 tANI_U32 i;
1641 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1642
1643 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1644 {
1645 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateIbss( pMac, i ) )
1646 {
1647 fRc = eANI_BOOLEAN_TRUE;
1648 break;
1649 }
1650 }
1651
1652 return ( fRc );
1653}
1654
1655
1656tANI_BOOLEAN csrIsBTAMPStarted( tpAniSirGlobal pMac )
1657{
1658 tANI_U32 i;
1659 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1660
1661 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1662 {
1663 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedWds( pMac, i ) )
1664 {
1665 fRc = eANI_BOOLEAN_TRUE;
1666 break;
1667 }
1668 }
1669
1670 return ( fRc );
1671}
1672
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1673tANI_BOOLEAN csrIsConcurrentSessionRunning( tpAniSirGlobal pMac )
1674{
1675 tANI_U32 sessionId, noOfCocurrentSession = 0;
1676 eCsrConnectState connectState;
1677
1678 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1679
1680 for( sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
1681 {
1682 if( CSR_IS_SESSION_VALID( pMac, sessionId ) )
1683 {
1684 connectState = pMac->roam.roamSession[sessionId].connectState;
1685 if( (eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED == connectState) ||
1686 (eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED == connectState) ||
1687 (eCSR_ASSOC_STATE_TYPE_INFRA_DISCONNECTED == connectState) )
1688 {
1689 ++noOfCocurrentSession;
1690 }
1691 }
1692 }
1693
1694 // More than one session is Up and Running
1695 if(noOfCocurrentSession > 1)
1696 {
1697 fRc = eANI_BOOLEAN_TRUE;
1698 }
1699
1700 return ( fRc );
1701}
1702
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1703tANI_BOOLEAN csrIsInfraApStarted( tpAniSirGlobal pMac )
1704{
1705 tANI_U32 sessionId;
1706 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1707
1708 for( sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
1709 {
1710 if( CSR_IS_SESSION_VALID( pMac, sessionId ) && (csrIsConnStateConnectedInfraAp(pMac, sessionId)) )
1711 {
1712 fRc = eANI_BOOLEAN_TRUE;
1713 break;
1714 }
1715 }
1716
1717 return ( fRc );
1718
1719}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1720
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1721tANI_BOOLEAN csrIsBTAMP( tpAniSirGlobal pMac, tANI_U32 sessionId )
1722{
1723 return ( csrIsConnStateConnectedWds( pMac, sessionId ) );
1724}
1725
1726
1727tANI_BOOLEAN csrIsConnStateDisconnected(tpAniSirGlobal pMac, tANI_U32 sessionId)
1728{
1729 return (eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED == pMac->roam.roamSession[sessionId].connectState);
1730}
1731
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1732tANI_BOOLEAN csrIsValidMcConcurrentSession(tpAniSirGlobal pMac, tANI_U32 sessionId,
1733 tSirBssDescription *pBssDesc)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1734{
1735 tCsrRoamSession *pSession = NULL;
1736 tANI_U8 Index = 0, ConnId = 0;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1737 eAniBoolean status = eANI_BOOLEAN_FALSE;
1738
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1739 tVOS_CON_MODE Mode[CSR_ROAM_SESSION_MAX];
1740
1741 //Check for MCC support
1742 if (!pMac->roam.configParam.fenableMCCMode)
1743 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1744 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1745 }
1746
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1747 for( Index = 0; Index < CSR_ROAM_SESSION_MAX; Index++ )
1748 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1749 Mode[Index] = VOS_MAX_NO_OF_MODE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1750 if( CSR_IS_SESSION_VALID( pMac, Index ) )
1751 {
1752 pSession = CSR_GET_SESSION( pMac, Index );
1753
1754 if (NULL != pSession->pCurRoamProfile)
1755 {
1756 Mode[ConnId] = pSession->pCurRoamProfile->csrPersona;
1757 ConnId++;
1758 }
1759 }
1760 }
1761
1762 Index = 0;
1763 if (Mode[Index] == VOS_STA_MODE && ConnId > Index)
1764 {
1765 switch (Mode[Index+1])
1766 {
1767 case VOS_P2P_CLIENT_MODE :
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1768 status = eANI_BOOLEAN_TRUE;
1769 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1770 case VOS_MAX_NO_OF_MODE :
1771 default :
1772 break;
1773 }
1774 }
1775 else if (Mode[Index] == VOS_P2P_CLIENT_MODE && ConnId > Index)
1776 {
1777 switch (Mode[Index +1])
1778 {
1779 case VOS_STA_MODE :
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1780 status = eANI_BOOLEAN_TRUE;
1781 break;
1782
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1783 case VOS_MAX_NO_OF_MODE :
1784 default :
1785 break;
1786 }
1787 }
1788
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1789 //Validate BeaconInterval
1790 if( CSR_IS_SESSION_VALID( pMac, sessionId ) )
1791 {
1792 pSession = CSR_GET_SESSION( pMac, sessionId );
1793 if (NULL != pSession->pCurRoamProfile)
1794 {
1795 if(csrIsconcurrentsessionValid (pMac, sessionId,
1796 pSession->pCurRoamProfile->csrPersona)
1797 == eHAL_STATUS_SUCCESS )
1798 {
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]1799 if(csrValidateMCCBeaconInterval( pMac, pBssDesc->channelId,
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1800 &pBssDesc->beaconInterval, sessionId,
1801 pSession->pCurRoamProfile->csrPersona)
1802 != eHAL_STATUS_SUCCESS)
1803 {
1804 status = eANI_BOOLEAN_FALSE;
1805 }
1806 else
1807 {
1808 status = eANI_BOOLEAN_TRUE;
1809 }
1810 }
1811 else
1812 {
1813 status = eANI_BOOLEAN_FALSE;
1814 }
1815 }
1816 }
1817 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1818}
1819
1820static tSirMacCapabilityInfo csrGetBssCapabilities( tSirBssDescription *pSirBssDesc )
1821{
1822 tSirMacCapabilityInfo dot11Caps;
1823
1824 //tSirMacCapabilityInfo is 16-bit
1825 pal_get_U16( (tANI_U8 *)&pSirBssDesc->capabilityInfo, (tANI_U16 *)&dot11Caps );
1826
1827 return( dot11Caps );
1828}
1829
1830tANI_BOOLEAN csrIsInfraBssDesc( tSirBssDescription *pSirBssDesc )
1831{
1832 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1833
1834 return( (tANI_BOOLEAN)dot11Caps.ess );
1835}
1836
1837
1838tANI_BOOLEAN csrIsIbssBssDesc( tSirBssDescription *pSirBssDesc )
1839{
1840 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1841
1842 return( (tANI_BOOLEAN)dot11Caps.ibss );
1843}
1844
1845tANI_BOOLEAN csrIsQoSBssDesc( tSirBssDescription *pSirBssDesc )
1846{
1847 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1848
1849 return( (tANI_BOOLEAN)dot11Caps.qos );
1850}
1851
1852tANI_BOOLEAN csrIsPrivacy( tSirBssDescription *pSirBssDesc )
1853{
1854 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1855
1856 return( (tANI_BOOLEAN)dot11Caps.privacy );
1857}
1858
1859
1860tANI_BOOLEAN csrIs11dSupported(tpAniSirGlobal pMac)
1861{
1862 return(pMac->roam.configParam.Is11dSupportEnabled);
1863}
1864
1865
1866tANI_BOOLEAN csrIs11hSupported(tpAniSirGlobal pMac)
1867{
1868 return(pMac->roam.configParam.Is11hSupportEnabled);
1869}
1870
1871
1872tANI_BOOLEAN csrIs11eSupported(tpAniSirGlobal pMac)
1873{
1874 return(pMac->roam.configParam.Is11eSupportEnabled);
1875}
1876
1877tANI_BOOLEAN csrIsMCCSupported ( tpAniSirGlobal pMac )
1878{
1879 return(pMac->roam.configParam.fenableMCCMode);
1880
1881}
1882
1883tANI_BOOLEAN csrIsWmmSupported(tpAniSirGlobal pMac)
1884{
1885 if(eCsrRoamWmmNoQos == pMac->roam.configParam.WMMSupportMode)
1886 {
1887 return eANI_BOOLEAN_FALSE;
1888 }
1889 else
1890 {
1891 return eANI_BOOLEAN_TRUE;
1892 }
1893}
1894
1895
1896
1897
1898//pIes is the IEs for pSirBssDesc2
1899tANI_BOOLEAN csrIsSsidEqual( tHalHandle hHal, tSirBssDescription *pSirBssDesc1,
1900 tSirBssDescription *pSirBssDesc2, tDot11fBeaconIEs *pIes2 )
1901{
1902 tANI_BOOLEAN fEqual = FALSE;
1903 tSirMacSSid Ssid1, Ssid2;
1904 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1905 tDot11fBeaconIEs *pIes1 = NULL;
1906 tDot11fBeaconIEs *pIesLocal = pIes2;
1907
1908 do {
1909 if( ( NULL == pSirBssDesc1 ) || ( NULL == pSirBssDesc2 ) ) break;
1910 if( !pIesLocal && !HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc2, &pIesLocal)) )
1911 {
1912 smsLog(pMac, LOGE, FL(" fail to parse IEs\n"));
1913 break;
1914 }
1915 if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc1, &pIes1)))
1916 {
1917 break;
1918 }
1919 if( ( !pIes1->SSID.present ) || ( !pIesLocal->SSID.present ) ) break;
1920 if ( pIes1->SSID.num_ssid != pIesLocal->SSID.num_ssid ) break;
1921 palCopyMemory(pMac->hHdd, Ssid1.ssId, pIes1->SSID.ssid, pIes1->SSID.num_ssid);
1922 palCopyMemory(pMac->hHdd, Ssid2.ssId, pIesLocal->SSID.ssid, pIesLocal->SSID.num_ssid);
1923
1924 fEqual = palEqualMemory(pMac->hHdd, Ssid1.ssId, Ssid2.ssId, pIesLocal->SSID.num_ssid );
1925
1926 } while( 0 );
1927 if(pIes1)
1928 {
1929 palFreeMemory(pMac->hHdd, pIes1);
1930 }
1931 if( pIesLocal && !pIes2 )
1932 {
1933 palFreeMemory(pMac->hHdd, pIesLocal);
1934 }
1935
1936 return( fEqual );
1937}
1938
1939tANI_BOOLEAN csrIsAniWmeSupported(tDot11fIEAirgo *pIeAirgo)
1940{
1941 tANI_BOOLEAN fRet = eANI_BOOLEAN_FALSE;
1942
1943 if(pIeAirgo && pIeAirgo->present && pIeAirgo->PropCapability.present)
1944 {
1945 fRet = (tANI_BOOLEAN)(PROP_CAPABILITY_GET( WME, pIeAirgo->PropCapability.capability ));
1946 }
1947
1948 return fRet;
1949}
1950
1951
1952
1953
1954//pIes can be passed in as NULL if the caller doesn't have one prepared
1955tANI_BOOLEAN csrIsBssDescriptionWme( tHalHandle hHal, tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes )
1956{
1957 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1958 // Assume that WME is found...
1959 tANI_BOOLEAN fWme = TRUE;
1960 tDot11fBeaconIEs *pIesTemp = pIes;
1961
1962 do
1963 {
1964 if(pIesTemp == NULL)
1965 {
1966 if( !HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesTemp)) )
1967 {
1968 fWme = FALSE;
1969 break;
1970 }
1971 }
1972 // if the AirgoProprietary indicator is found, then WME is supported...
1973 if ( csrIsAniWmeSupported(&pIesTemp->Airgo) ) break;
1974 // if the Wme Info IE is found, then WME is supported...
1975 if ( CSR_IS_QOS_BSS(pIesTemp) ) break;
1976 // if none of these are found, then WME is NOT supported...
1977 fWme = FALSE;
1978 } while( 0 );
1979 if( !csrIsWmmSupported( pMac ) && fWme)
1980 {
1981 if( !pIesTemp->HTCaps.present )
1982 {
1983 fWme = FALSE;
1984 }
1985 }
1986 if( ( pIes == NULL ) && ( NULL != pIesTemp ) )
1987 {
1988 //we allocate memory here so free it before returning
1989 palFreeMemory(pMac->hHdd, pIesTemp);
1990 }
1991
1992 return( fWme );
1993}
1994
1995tANI_BOOLEAN csrIsHcfEnabled( tDot11fIEAirgo *pIeAirgo )
1996{
1997 tANI_BOOLEAN fHcfSupported = FALSE;
1998
1999 fHcfSupported = ((tANI_BOOLEAN)(PROP_CAPABILITY_GET( WME, pIeAirgo->PropCapability.capability )) ||
2000 (pIeAirgo->present && pIeAirgo->HCF.present && pIeAirgo->HCF.enabled));
2001
2002 return( fHcfSupported );
2003}
2004
2005
2006eCsrMediaAccessType csrGetQoSFromBssDesc( tHalHandle hHal, tSirBssDescription *pSirBssDesc,
2007 tDot11fBeaconIEs *pIes )
2008{
2009 eCsrMediaAccessType qosType = eCSR_MEDIUM_ACCESS_DCF;
2010
2011#if defined(VOSS_ENABLED)
2012 VOS_ASSERT( pIes != NULL );
2013#endif
2014
2015 do
2016 {
2017 // if we find WMM in the Bss Description, then we let this
2018 // override and use WMM.
2019 if ( csrIsBssDescriptionWme( hHal, pSirBssDesc, pIes ) )
2020 {
2021 qosType = eCSR_MEDIUM_ACCESS_WMM_eDCF_DSCP;
2022 }
2023 else
2024 {
2025 // if the QoS bit is on, then the AP is advertising 11E QoS...
2026 if ( csrIsQoSBssDesc( pSirBssDesc ) )
2027 {
2028 // which could be HCF or eDCF.
2029 if ( csrIsHcfEnabled( &pIes->Airgo ) )
2030 {
2031 qosType = eCSR_MEDIUM_ACCESS_11e_HCF;
2032 }
2033 else
2034 {
2035 qosType = eCSR_MEDIUM_ACCESS_11e_eDCF;
2036 }
2037 }
2038 else
2039 {
2040 qosType = eCSR_MEDIUM_ACCESS_DCF;
2041 }
2042 // scale back based on the types turned on for the adapter...
2043 if ( eCSR_MEDIUM_ACCESS_11e_eDCF == qosType && !csrIs11eSupported( hHal ) )
2044 {
2045 qosType = eCSR_MEDIUM_ACCESS_DCF;
2046 }
2047 }
2048
2049 } while(0);
2050
2051 return( qosType );
2052}
2053
2054
2055
2056
2057//Caller allocates memory for pIEStruct
2058eHalStatus csrParseBssDescriptionIEs(tHalHandle hHal, tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIEStruct)
2059{
2060 eHalStatus status = eHAL_STATUS_FAILURE;
2061 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2062 int ieLen = (int)(pBssDesc->length + sizeof( pBssDesc->length ) - GET_FIELD_OFFSET( tSirBssDescription, ieFields ));
2063
2064 if(ieLen > 0 && pIEStruct)
2065 {
2066 if(!DOT11F_FAILED(dot11fUnpackBeaconIEs( pMac, (tANI_U8 *)pBssDesc->ieFields, ieLen, pIEStruct )))
2067 {
2068 status = eHAL_STATUS_SUCCESS;
2069 }
2070 }
2071
2072 return (status);
2073}
2074
2075
2076//This function will allocate memory for the parsed IEs to the caller. Caller must free the memory
2077//after it is done with the data only if this function succeeds
2078eHalStatus csrGetParsedBssDescriptionIEs(tHalHandle hHal, tSirBssDescription *pBssDesc, tDot11fBeaconIEs **ppIEStruct)
2079{
2080 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
2081 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2082
2083 if(pBssDesc && ppIEStruct)
2084 {
2085 status = palAllocateMemory(pMac->hHdd, (void **)ppIEStruct, sizeof(tDot11fBeaconIEs));
2086 if(HAL_STATUS_SUCCESS(status))
2087 {
2088 palZeroMemory(pMac->hHdd, (void *)*ppIEStruct, sizeof(tDot11fBeaconIEs));
2089 status = csrParseBssDescriptionIEs(hHal, pBssDesc, *ppIEStruct);
2090 if(!HAL_STATUS_SUCCESS(status))
2091 {
2092 palFreeMemory(pMac->hHdd, *ppIEStruct);
2093 *ppIEStruct = NULL;
2094 }
2095 }
2096 else
2097 {
2098 smsLog( pMac, LOGE, FL(" failed to allocate memory\n") );
2099 VOS_ASSERT( 0 );
2100 }
2101 }
2102
2103 return (status);
2104}
2105
2106
2107
2108
2109tANI_BOOLEAN csrIsNULLSSID( tANI_U8 *pBssSsid, tANI_U8 len )
2110{
2111 tANI_BOOLEAN fNullSsid = FALSE;
2112
2113 tANI_U32 SsidLength;
2114 tANI_U8 *pSsidStr;
2115
2116 do
2117 {
2118 if ( 0 == len )
2119 {
2120 fNullSsid = TRUE;
2121 break;
2122 }
2123
2124 //Consider 0 or space for hidden SSID
2125 if ( 0 == pBssSsid[0] )
2126 {
2127 fNullSsid = TRUE;
2128 break;
2129 }
2130
2131 SsidLength = len;
2132 pSsidStr = pBssSsid;
2133
2134 while ( SsidLength )
2135 {
2136 if( *pSsidStr )
2137 break;
2138
2139 pSsidStr++;
2140 SsidLength--;
2141 }
2142
2143 if( 0 == SsidLength )
2144 {
2145 fNullSsid = TRUE;
2146 break;
2147 }
2148 }
2149 while( 0 );
2150
2151 return fNullSsid;
2152}
2153
2154
2155tANI_U32 csrGetFragThresh( tHalHandle hHal )
2156{
2157 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2158
2159 return pMac->roam.configParam.FragmentationThreshold;
2160}
2161
2162tANI_U32 csrGetRTSThresh( tHalHandle hHal )
2163{
2164 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2165
2166 return pMac->roam.configParam.RTSThreshold;
2167}
2168
2169eCsrPhyMode csrTranslateToPhyModeFromBssDesc( tSirBssDescription *pSirBssDesc )
2170{
2171 eCsrPhyMode phyMode;
2172
2173 switch ( pSirBssDesc->nwType )
2174 {
2175 case eSIR_11A_NW_TYPE:
2176 phyMode = eCSR_DOT11_MODE_11a;
2177 break;
2178
2179 case eSIR_11B_NW_TYPE:
2180 phyMode = eCSR_DOT11_MODE_11b;
2181 break;
2182
2183 case eSIR_11G_NW_TYPE:
2184 phyMode = eCSR_DOT11_MODE_11g;
2185 break;
2186
2187 case eSIR_11N_NW_TYPE:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2188 phyMode = eCSR_DOT11_MODE_11n;
2189 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2190#ifdef WLAN_FEATURE_11AC
2191 case eSIR_11AC_NW_TYPE:
2192 default:
2193 phyMode = eCSR_DOT11_MODE_11ac;
2194#else
2195 default:
2196 phyMode = eCSR_DOT11_MODE_11n;
2197#endif
2198 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2200 return( phyMode );
2201}
2202
2203
2204tANI_U32 csrTranslateToWNICfgDot11Mode(tpAniSirGlobal pMac, eCsrCfgDot11Mode csrDot11Mode)
2205{
2206 tANI_U32 ret;
2207
2208 switch(csrDot11Mode)
2209 {
2210 case eCSR_CFG_DOT11_MODE_AUTO:
2211 smsLog(pMac, LOGW, FL(" Warning: sees eCSR_CFG_DOT11_MODE_AUTO \n"));
2212 //We cannot decide until now.
2213 if(pMac->roam.configParam.ProprietaryRatesEnabled)
2214 {
2215 ret = WNI_CFG_DOT11_MODE_TAURUS;
2216 }
2217 else
2218 {
2219 ret = WNI_CFG_DOT11_MODE_11N;
2220 }
2221 break;
2222 case eCSR_CFG_DOT11_MODE_TAURUS:
2223 ret = WNI_CFG_DOT11_MODE_TAURUS;
2224 break;
2225 case eCSR_CFG_DOT11_MODE_11A:
2226 ret = WNI_CFG_DOT11_MODE_11A;
2227 break;
2228 case eCSR_CFG_DOT11_MODE_11B:
2229 ret = WNI_CFG_DOT11_MODE_11B;
2230 break;
2231 case eCSR_CFG_DOT11_MODE_11G:
2232 ret = WNI_CFG_DOT11_MODE_11G;
2233 break;
2234 case eCSR_CFG_DOT11_MODE_11N:
2235 ret = WNI_CFG_DOT11_MODE_11N;
2236 break;
2237 case eCSR_CFG_DOT11_MODE_POLARIS:
2238 ret = WNI_CFG_DOT11_MODE_POLARIS;
2239 break;
2240 case eCSR_CFG_DOT11_MODE_TITAN:
2241 ret = WNI_CFG_DOT11_MODE_TITAN;
2242 break;
2243#ifdef WLAN_SOFTAP_FEATURE
2244 case eCSR_CFG_DOT11_MODE_11G_ONLY:
2245 ret = WNI_CFG_DOT11_MODE_11G_ONLY;
2246 break;
2247 case eCSR_CFG_DOT11_MODE_11N_ONLY:
2248 ret = WNI_CFG_DOT11_MODE_11N_ONLY;
2249 break;
2250#endif
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2251
2252#ifdef WLAN_FEATURE_11AC
2253 case eCSR_CFG_DOT11_MODE_11AC_ONLY:
2254 ret = WNI_CFG_DOT11_MODE_11AC_ONLY;
2255 break;
2256 case eCSR_CFG_DOT11_MODE_11AC:
2257 ret = WNI_CFG_DOT11_MODE_11AC;
2258 break;
2259#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2260 default:
2261 smsLog(pMac, LOGW, FL("doesn't expect %d as csrDo11Mode\n"), csrDot11Mode);
2262 if(eCSR_BAND_24 == pMac->roam.configParam.eBand)
2263 {
2264 ret = WNI_CFG_DOT11_MODE_11G;
2265 }
2266 else
2267 {
2268 ret = WNI_CFG_DOT11_MODE_11A;
2269 }
2270 break;
2271 }
2272
2273 return (ret);
2274}
2275
2276
2277//This function should only return the super set of supported modes. 11n implies 11b/g/a/n.
2278eHalStatus csrGetPhyModeFromBss(tpAniSirGlobal pMac, tSirBssDescription *pBSSDescription,
2279 eCsrPhyMode *pPhyMode, tDot11fBeaconIEs *pIes)
2280{
2281 eHalStatus status = eHAL_STATUS_SUCCESS;
2282 eCsrPhyMode phyMode = csrTranslateToPhyModeFromBssDesc(pBSSDescription);
2283
2284 if( pIes )
2285 {
2286 if(pIes->Airgo.present)
2287 {
2288 if(pIes->Airgo.PropCapability.present)
2289 {
2290 if( PROP_CAPABILITY_GET( TAURUS, pIes->Airgo.PropCapability.capability ))
2291 {
2292 phyMode = eCSR_DOT11_MODE_TAURUS;
2293 }
2294 }
2295 }
2296 if(pIes->HTCaps.present && (eCSR_DOT11_MODE_TAURUS != phyMode))
2297 {
2298 phyMode = eCSR_DOT11_MODE_11n;
2299 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2300
2301#ifdef WLAN_FEATURE_11AC
2302 if ( pIes->VHTCaps.present && (eCSR_DOT11_MODE_TAURUS != phyMode))
2303 {
2304 phyMode = eCSR_DOT11_MODE_11ac;
2305 }
2306#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2307 *pPhyMode = phyMode;
2308 }
2309
2310 return (status);
2311
2312}
2313
2314
2315//This function returns the correct eCSR_CFG_DOT11_MODE is the two phyModes matches
2316//bssPhyMode is the mode derived from the BSS description
2317//f5GhzBand is derived from the channel id of BSS description
2318tANI_BOOLEAN csrGetPhyModeInUse( eCsrPhyMode phyModeIn, eCsrPhyMode bssPhyMode, tANI_BOOLEAN f5GhzBand,
2319 eCsrCfgDot11Mode *pCfgDot11ModeToUse )
2320{
2321 tANI_BOOLEAN fMatch = FALSE;
2322 eCsrCfgDot11Mode cfgDot11Mode;
2323
2324 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; // to suppress compiler warning
2325
2326 switch( phyModeIn )
2327 {
2328 case eCSR_DOT11_MODE_abg: //11a or 11b or 11g
2329 if( f5GhzBand )
2330 {
2331 fMatch = TRUE;
2332 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2333 }
2334 else if( eCSR_DOT11_MODE_11b == bssPhyMode )
2335 {
2336 fMatch = TRUE;
2337 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2338 }
2339 else
2340 {
2341 fMatch = TRUE;
2342 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2343 }
2344 break;
2345
2346 case eCSR_DOT11_MODE_11a: //11a
2347 if( f5GhzBand )
2348 {
2349 fMatch = TRUE;
2350 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2351 }
2352 break;
2353
2354 case eCSR_DOT11_MODE_11a_ONLY: //11a
2355 if( eCSR_DOT11_MODE_11a == bssPhyMode )
2356 {
2357 fMatch = TRUE;
2358 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2359 }
2360 break;
2361
2362 case eCSR_DOT11_MODE_11g:
2363 if(!f5GhzBand)
2364 {
2365 if( eCSR_DOT11_MODE_11b == bssPhyMode )
2366 {
2367 fMatch = TRUE;
2368 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2369 }
2370 else
2371 {
2372 fMatch = TRUE;
2373 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2374 }
2375 }
2376 break;
2377
2378 case eCSR_DOT11_MODE_11g_ONLY:
2379 if( eCSR_DOT11_MODE_11g == bssPhyMode )
2380 {
2381 fMatch = TRUE;
2382 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2383 }
2384 break;
2385
2386 case eCSR_DOT11_MODE_11b:
2387 if( !f5GhzBand )
2388 {
2389 fMatch = TRUE;
2390 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2391 }
2392 break;
2393
2394 case eCSR_DOT11_MODE_11b_ONLY:
2395 if( eCSR_DOT11_MODE_11b == bssPhyMode )
2396 {
2397 fMatch = TRUE;
2398 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2399 }
2400 break;
2401
2402 case eCSR_DOT11_MODE_11n:
2403 fMatch = TRUE;
2404 switch(bssPhyMode)
2405 {
2406 case eCSR_DOT11_MODE_11g:
2407 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2408 break;
2409 case eCSR_DOT11_MODE_11b:
2410 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2411 break;
2412 case eCSR_DOT11_MODE_11a:
2413 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2414 break;
2415 case eCSR_DOT11_MODE_11n:
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2416#ifdef WLAN_FEATURE_11AC
2417 case eCSR_DOT11_MODE_11ac:
2418#endif
2419 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
2420 break;
2421
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2422 case eCSR_DOT11_MODE_TAURUS:
2423 default:
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2424#ifdef WLAN_FEATURE_11AC
2425 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2426#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2427 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2428#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2429 break;
2430 }
2431 break;
2432
2433 case eCSR_DOT11_MODE_11n_ONLY:
2434 if((eCSR_DOT11_MODE_11n == bssPhyMode) || (eCSR_DOT11_MODE_TAURUS == bssPhyMode))
2435 {
2436 fMatch = TRUE;
2437 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2438
2439 }
2440
2441 break;
2442#ifdef WLAN_FEATURE_11AC
2443 case eCSR_DOT11_MODE_11ac:
2444 fMatch = TRUE;
2445 switch(bssPhyMode)
2446 {
2447 case eCSR_DOT11_MODE_11g:
2448 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2449 break;
2450 case eCSR_DOT11_MODE_11b:
2451 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2452 break;
2453 case eCSR_DOT11_MODE_11a:
2454 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2455 break;
2456 case eCSR_DOT11_MODE_11n:
2457 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
2458 break;
2459 case eCSR_DOT11_MODE_11ac:
2460 case eCSR_DOT11_MODE_TAURUS:
2461 default:
2462 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2463 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2464 }
2465 break;
2466
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2467 case eCSR_DOT11_MODE_11ac_ONLY:
2468 if((eCSR_DOT11_MODE_11ac == bssPhyMode) || (eCSR_DOT11_MODE_TAURUS == bssPhyMode))
2469 {
2470 fMatch = TRUE;
2471 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2472 }
2473 break;
2474#endif
2475
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2476 case eCSR_DOT11_MODE_TAURUS:
2477 default:
2478 fMatch = TRUE;
2479 switch(bssPhyMode)
2480 {
2481 case eCSR_DOT11_MODE_11g:
2482 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2483 break;
2484 case eCSR_DOT11_MODE_11b:
2485 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2486 break;
2487 case eCSR_DOT11_MODE_11a:
2488 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2489 break;
2490 case eCSR_DOT11_MODE_11n:
2491 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
2492 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2493#ifdef WLAN_FEATURE_11AC
2494 case eCSR_DOT11_MODE_11ac:
2495 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2496 break;
2497#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2498 case eCSR_DOT11_MODE_TAURUS:
2499 default:
2500 cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
2501 break;
2502 }
2503 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2504 }
2505
2506 if ( fMatch && pCfgDot11ModeToUse )
2507 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2508#ifdef WLAN_FEATURE_11AC
Madan Mohan Koyyalamudief5dd972012-10-11 15:06:09 -0700[diff] [blame]2509 if(cfgDot11Mode == eCSR_CFG_DOT11_MODE_11AC && (!IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)))
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2510 {
2511 *pCfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
2512 }
2513 else
2514#endif
2515 {
2516 *pCfgDot11ModeToUse = cfgDot11Mode;
2517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2518 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2519 return( fMatch );
2520}
2521
2522
2523//This function decides whether the one of the bit of phyMode is matching the mode in the BSS and allowed by the user
2524//setting, pMac->roam.configParam.uCfgDot11Mode. It returns the mode that fits the criteria.
2525tANI_BOOLEAN csrIsPhyModeMatch( tpAniSirGlobal pMac, tANI_U32 phyMode,
2526 tSirBssDescription *pSirBssDesc, tCsrRoamProfile *pProfile,
2527 eCsrCfgDot11Mode *pReturnCfgDot11Mode,
2528 tDot11fBeaconIEs *pIes)
2529{
2530 tANI_BOOLEAN fMatch = FALSE;
2531 eCsrPhyMode phyModeInBssDesc, phyMode2;
2532 eCsrCfgDot11Mode cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_TAURUS;
2533 tANI_U32 bitMask, loopCount;
2534
2535 if(HAL_STATUS_SUCCESS(csrGetPhyModeFromBss(pMac, pSirBssDesc, &phyModeInBssDesc, pIes )))
2536 {
2537 //In case some change change eCSR_DOT11_MODE_TAURUS to non-0
2538 if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode))
2539 {
2540 //Taurus means anything
2541 if ( eCSR_CFG_DOT11_MODE_ABG == pMac->roam.configParam.uCfgDot11Mode )
2542 {
2543 phyMode = eCSR_DOT11_MODE_abg;
2544 }
2545 else if(eCSR_CFG_DOT11_MODE_AUTO == pMac->roam.configParam.uCfgDot11Mode)
2546 {
2547 if(pMac->roam.configParam.ProprietaryRatesEnabled)
2548 {
2549 phyMode = eCSR_DOT11_MODE_TAURUS;
2550 }
2551 else
2552 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2553
2554#ifdef WLAN_FEATURE_11AC
2555 phyMode = eCSR_DOT11_MODE_11ac;
2556#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2557 phyMode = eCSR_DOT11_MODE_11n;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2558#endif
2559
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2560 }
2561 }
2562 else
2563 {
2564 //user's pick
2565 phyMode = pMac->roam.configParam.phyMode;
2566 }
2567 }
2568 if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode) )
2569 {
2570 if(0 != phyMode)
2571 {
2572 if(eCSR_DOT11_MODE_AUTO & phyMode)
2573 {
2574 phyMode2 = eCSR_DOT11_MODE_AUTO & phyMode;
2575 }
2576 else
2577 {
2578 phyMode2 = eCSR_DOT11_MODE_TAURUS & phyMode;
2579 }
2580 }
2581 else
2582 {
2583 phyMode2 = phyMode;
2584 }
2585 fMatch = csrGetPhyModeInUse( phyMode2, phyModeInBssDesc, CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId),
2586 &cfgDot11ModeToUse );
2587 }
2588 else
2589 {
2590 bitMask = 1;
2591 loopCount = 0;
2592 while(loopCount < eCSR_NUM_PHY_MODE)
2593 {
2594 if(0 != ( phyMode2 = (phyMode & (bitMask << loopCount++)) ))
2595 {
2596 fMatch = csrGetPhyModeInUse( phyMode2, phyModeInBssDesc, CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId),
2597 &cfgDot11ModeToUse );
2598 if(fMatch) break;
2599 }
2600 }
2601 }
2602 if ( fMatch && pReturnCfgDot11Mode )
2603 {
2604 if( pProfile )
2605 {
2606 /* IEEE 11n spec (8.4.3): HT STA shall eliminate TKIP as a
2607 * choice for the pairwise cipher suite if CCMP is advertised
2608 * by the AP or if the AP included an HT capabilities element
2609 * in its Beacons and Probe Response.
2610 */
2611 if( (!CSR_IS_11n_ALLOWED( pProfile->negotiatedUCEncryptionType )) &&
2612 ((eCSR_CFG_DOT11_MODE_11N == cfgDot11ModeToUse) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2613#ifdef WLAN_FEATURE_11AC
2614 (eCSR_CFG_DOT11_MODE_11AC == cfgDot11ModeToUse) ||
2615#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2616 (eCSR_CFG_DOT11_MODE_TAURUS == cfgDot11ModeToUse)) )
2617 {
2618 //We cannot do 11n here
2619 if( !CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId) )
2620 {
2621 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
2622 }
2623 else
2624 {
2625 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
2626 }
2627 }
2628 }
2629 *pReturnCfgDot11Mode = cfgDot11ModeToUse;
2630 }
2631 }
2632
2633 return( fMatch );
2634}
2635
2636
2637eCsrCfgDot11Mode csrFindBestPhyMode( tpAniSirGlobal pMac, tANI_U32 phyMode )
2638{
2639 eCsrCfgDot11Mode cfgDot11ModeToUse;
2640 eCsrBand eBand = pMac->roam.configParam.eBand;
2641
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2642
2643#ifdef WLAN_FEATURE_11AC
Madan Mohan Koyyalamudief5dd972012-10-11 15:06:09 -0700[diff] [blame]2644 if ((0 == phyMode) || ((eCSR_DOT11_MODE_AUTO & phyMode) && (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)))
2645 || ((eCSR_DOT11_MODE_11ac & phyMode) && (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC))))
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2646 {
2647 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11AC;
2648 }
2649 else
2650#endif
2651
Madan Mohan Koyyalamudief5dd972012-10-11 15:06:09 -0700[diff] [blame]2652 if ((0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2653 {
2654 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
2655 }
2656 else
2657 {
2658 if( ( eCSR_DOT11_MODE_11n | eCSR_DOT11_MODE_11n_ONLY ) & phyMode )
2659 {
2660 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
2661 }
2662 else if ( eCSR_DOT11_MODE_abg & phyMode )
2663 {
2664 if( eCSR_BAND_24 != eBand )
2665 {
2666 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
2667 }
2668 else
2669 {
2670 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
2671 }
2672 }
2673 else if( ( eCSR_DOT11_MODE_11a | eCSR_DOT11_MODE_11a_ONLY ) & phyMode )
2674 {
2675 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
2676 }
2677 else if( ( eCSR_DOT11_MODE_11g | eCSR_DOT11_MODE_11g_ONLY ) & phyMode )
2678 {
2679 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
2680 }
2681 else
2682 {
2683 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11B;
2684 }
2685 }
2686
2687 return ( cfgDot11ModeToUse );
2688}
2689
2690
2691
2692
2693tANI_U32 csrGet11hPowerConstraint( tHalHandle hHal, tDot11fIEPowerConstraints *pPowerConstraint )
2694{
2695 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2696 tANI_U32 localPowerConstraint = 0;
2697
2698 // check if .11h support is enabled, if not, the power constraint is 0.
2699 if(pMac->roam.configParam.Is11hSupportEnabled && pPowerConstraint->present)
2700 {
2701 localPowerConstraint = pPowerConstraint->localPowerConstraints;
2702 }
2703
2704 return( localPowerConstraint );
2705}
2706
2707
2708tANI_BOOLEAN csrIsProfileWpa( tCsrRoamProfile *pProfile )
2709{
2710 tANI_BOOLEAN fWpaProfile = FALSE;
2711
2712 switch ( pProfile->negotiatedAuthType )
2713 {
2714 case eCSR_AUTH_TYPE_WPA:
2715 case eCSR_AUTH_TYPE_WPA_PSK:
2716 case eCSR_AUTH_TYPE_WPA_NONE:
2717#ifdef FEATURE_WLAN_CCX
2718 case eCSR_AUTH_TYPE_CCKM_WPA:
2719#endif
2720 fWpaProfile = TRUE;
2721 break;
2722
2723 default:
2724 fWpaProfile = FALSE;
2725 break;
2726 }
2727
2728 if ( fWpaProfile )
2729 {
2730 switch ( pProfile->negotiatedUCEncryptionType )
2731 {
2732 case eCSR_ENCRYPT_TYPE_WEP40:
2733 case eCSR_ENCRYPT_TYPE_WEP104:
2734 case eCSR_ENCRYPT_TYPE_TKIP:
2735 case eCSR_ENCRYPT_TYPE_AES:
2736 fWpaProfile = TRUE;
2737 break;
2738
2739 default:
2740 fWpaProfile = FALSE;
2741 break;
2742 }
2743 }
2744 return( fWpaProfile );
2745}
2746
2747tANI_BOOLEAN csrIsProfileRSN( tCsrRoamProfile *pProfile )
2748{
2749 tANI_BOOLEAN fRSNProfile = FALSE;
2750
2751 switch ( pProfile->negotiatedAuthType )
2752 {
2753 case eCSR_AUTH_TYPE_RSN:
2754 case eCSR_AUTH_TYPE_RSN_PSK:
2755#ifdef WLAN_FEATURE_VOWIFI_11R
2756 case eCSR_AUTH_TYPE_FT_RSN:
2757 case eCSR_AUTH_TYPE_FT_RSN_PSK:
2758#endif
2759#ifdef FEATURE_WLAN_CCX
2760 case eCSR_AUTH_TYPE_CCKM_RSN:
2761#endif
2762 fRSNProfile = TRUE;
2763 break;
2764
2765 default:
2766 fRSNProfile = FALSE;
2767 break;
2768 }
2769
2770 if ( fRSNProfile )
2771 {
2772 switch ( pProfile->negotiatedUCEncryptionType )
2773 {
2774 // !!REVIEW - For WPA2, use of RSN IE mandates
2775 // use of AES as encryption. Here, we qualify
2776 // even if encryption type is WEP or TKIP
2777 case eCSR_ENCRYPT_TYPE_WEP40:
2778 case eCSR_ENCRYPT_TYPE_WEP104:
2779 case eCSR_ENCRYPT_TYPE_TKIP:
2780 case eCSR_ENCRYPT_TYPE_AES:
2781 fRSNProfile = TRUE;
2782 break;
2783
2784 default:
2785 fRSNProfile = FALSE;
2786 break;
2787 }
2788 }
2789 return( fRSNProfile );
2790}
2791
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2792eHalStatus
2793csrIsconcurrentsessionValid(tpAniSirGlobal pMac,tANI_U32 cursessionId,
2794 tVOS_CON_MODE currBssPersona)
2795{
2796 tANI_U32 sessionId = 0;
2797
2798 for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
2799 {
2800 if (cursessionId != sessionId )
2801 {
2802 if (!CSR_IS_SESSION_VALID( pMac, sessionId ))
2803 {
2804 continue;
2805 }
2806
2807 switch (currBssPersona)
2808 {
2809 case VOS_STA_MODE:
2810 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2811 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2812 == VOS_STA_MODE)) //check for P2P client mode
2813 {
2814 smsLog(pMac, LOGE, FL(" ****STA mode already exists ****\n"));
2815 return eHAL_STATUS_FAILURE;
2816 }
2817 break;
2818
2819 case VOS_STA_SAP_MODE:
Gopichand Nakkala53fefcd2013-02-28 12:35:20 +0530[diff] [blame^]2820 if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
2821 == VOS_STA_SAP_MODE)&&
2822 (pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2823 {
2824 smsLog(pMac, LOGE, FL(" ****SoftAP mode already exists ****\n"));
2825 return eHAL_STATUS_FAILURE;
2826 }
2827
Gopichand Nakkala53fefcd2013-02-28 12:35:20 +0530[diff] [blame^]2828 else if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
2829 == VOS_P2P_GO_MODE) &&
2830 (pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2831 {
2832 smsLog(pMac, LOGE, FL(" ****Cannot start Multiple Beaconing Role ****\n"));
2833 return eHAL_STATUS_FAILURE;
2834 }
2835 break;
2836
2837 case VOS_P2P_CLIENT_MODE:
2838 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2839 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2840 == VOS_P2P_CLIENT_MODE)) //check for P2P client mode
2841 {
2842 smsLog(pMac, LOGE, FL(" ****CLIENT mode already exists ****\n"));
2843 return eHAL_STATUS_FAILURE;
2844 }
2845 break;
2846
2847 case VOS_P2P_GO_MODE:
Gopichand Nakkala53fefcd2013-02-28 12:35:20 +0530[diff] [blame^]2848 if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
2849 == VOS_P2P_GO_MODE) &&
2850 (pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2851 {
2852 smsLog(pMac, LOGE, FL(" ****P2P GO mode already exists ****\n"));
2853 return eHAL_STATUS_FAILURE;
2854 }
Gopichand Nakkala53fefcd2013-02-28 12:35:20 +0530[diff] [blame^]2855 else if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
2856 == VOS_STA_SAP_MODE) &&
2857 (pMac->roam.roamSession[sessionId].connectState != eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2858 {
2859 smsLog(pMac, LOGE, FL(" ****Cannot start Multiple Beaconing Role ****\n"));
2860 return eHAL_STATUS_FAILURE;
2861 }
2862 break;
2863
2864 default :
2865 smsLog(pMac, LOGE, FL("***Persona not handled = %d*****\n"),currBssPersona);
2866 break;
2867 }
2868 }
2869 }
2870 return eHAL_STATUS_SUCCESS;
2871
2872}
2873
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2874eHalStatus csrUpdateMCCp2pBeaconInterval(tpAniSirGlobal pMac)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2875{
2876 tANI_U32 sessionId = 0;
2877
2878 //If MCC is not supported just break and return SUCCESS
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2879 if ( !pMac->roam.configParam.fenableMCCMode){
2880 return eHAL_STATUS_FAILURE;
2881 }
2882
2883 for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
2884 {
2885 /* If GO in MCC support different beacon interval,
2886 * change the BI of the P2P-GO */
2887 if((pMac->roam.roamSession[sessionId].bssParams.bssPersona
2888 == VOS_P2P_GO_MODE) &&
2889 (pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval ))
2890 {
2891 return csrRoamCallCallback(pMac, sessionId, NULL, 0, eCSR_ROAM_DISCONNECT_ALL_P2P_CLIENTS, eCSR_ROAM_RESULT_NONE);
2892 }
2893 }
2894 return eHAL_STATUS_FAILURE;
2895}
2896
2897tANI_U16 csrCalculateMCCBeaconInterval(tpAniSirGlobal pMac, tANI_U16 sta_bi, tANI_U16 go_gbi)
2898{
2899 tANI_U8 num_beacons = 0;
2900 tANI_U8 is_multiple = 0;
2901 tANI_U16 go_cbi = 0;
2902 tANI_U16 go_fbi = 0;
2903 tANI_U16 sta_cbi = 0;
2904
2905 //If GO's given beacon Interval is less than 100
2906 if(go_gbi < 100)
2907 go_cbi = 100;
2908 //if GO's given beacon Interval is greater than or equal to 100
2909 else
2910 go_cbi = 100 + (go_gbi % 100);
2911
2912 // check, if either one is multiple of another
2913 if (sta_bi > go_cbi)
2914 {
2915 is_multiple = !(sta_bi % go_cbi);
2916 }
2917 else
2918 {
2919 is_multiple = !(go_cbi % sta_bi);
2920 }
Madan Mohan Koyyalamudi48081ef2012-12-04 16:49:55 -0800[diff] [blame]2921 // if it is multiple, then accept GO's beacon interval range [100,199] as it is
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2922 if(is_multiple)
2923 {
2924 return go_cbi;
2925 }
2926 //else , if it is not multiple, then then check for number of beacons to be
2927 //inserted based on sta BI
2928 num_beacons = sta_bi / 100;
2929 if(num_beacons)
2930 {
Madan Mohan Koyyalamudi48081ef2012-12-04 16:49:55 -0800[diff] [blame]2931 // GO's final beacon interval will be aligned to sta beacon interval, but
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2932 //in the range of [100, 199].
2933 sta_cbi = sta_bi / num_beacons;
2934 go_fbi = sta_cbi;
2935 }
2936 else
2937 {
Madan Mohan Koyyalamudi48081ef2012-12-04 16:49:55 -0800[diff] [blame]2938 // if STA beacon interval is less than 100, use GO's change bacon interval
2939 //instead of updating to STA's beacon interval.
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2940 go_fbi = go_cbi;
2941 }
2942 return go_fbi;
2943}
2944
2945eHalStatus csrValidateMCCBeaconInterval(tpAniSirGlobal pMac, tANI_U8 channelId,
2946 tANI_U16 *beaconInterval, tANI_U32 cursessionId,
2947 tVOS_CON_MODE currBssPersona)
2948{
2949 tANI_U32 sessionId = 0;
2950 tANI_U16 new_beaconInterval = 0;
2951
2952 //If MCC is not supported just break
2953 if (!pMac->roam.configParam.fenableMCCMode){
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2954 return eHAL_STATUS_FAILURE;
2955 }
2956
2957 for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
2958 {
2959 if (cursessionId != sessionId )
2960 {
2961 if (!CSR_IS_SESSION_VALID( pMac, sessionId ))
2962 {
2963 continue;
2964 }
2965
2966 switch (currBssPersona)
2967 {
2968 case VOS_STA_MODE:
2969 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2970 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2971 == VOS_P2P_CLIENT_MODE)) //check for P2P client mode
2972 {
2973 smsLog(pMac, LOG1, FL(" Beacon Interval Validation not required for STA/CLIENT\n"));
2974 }
2975 //IF SAP has started and STA wants to connect on different channel MCC should
2976 //MCC should not be enabled so making it false to enforce on same channel
2977 else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
2978 == VOS_STA_SAP_MODE)
2979 {
2980 if (pMac->roam.roamSession[sessionId].bssParams.operationChn
2981 != channelId )
2982 {
2983 smsLog(pMac, LOGE, FL("***MCC is not enabled for SAP +STA****\n"));
2984 return eHAL_STATUS_FAILURE;
2985 }
2986 }
2987 else if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2988 == VOS_P2P_GO_MODE) //Check for P2P go scenario
2989 {
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2990 /* if GO in MCC support different beacon interval,
2991 * change the BI of the P2P-GO */
2992 if ((pMac->roam.roamSession[sessionId].bssParams.operationChn
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2993 != channelId ) &&
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2994 (pMac->roam.roamSession[sessionId].bssParams.beaconInterval
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2995 != *beaconInterval))
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]2996 {
2997 /* if GO in MCC support different beacon interval, return success */
2998 if ( pMac->roam.configParam.fAllowMCCGODiffBI == 0x01)
2999 {
3000 return eHAL_STATUS_SUCCESS;
3001 }
3002 // Send only Broadcast disassoc and update beaconInterval
3003 else if(pMac->roam.configParam.fAllowMCCGODiffBI == 0x02)
3004 {
3005 //Check to pass the right beacon Interval
3006 new_beaconInterval = csrCalculateMCCBeaconInterval(pMac, *beaconInterval,
3007 pMac->roam.roamSession[sessionId].bssParams.beaconInterval);
3008 smsLog(pMac, LOG1, FL(" Peer AP BI : %d, new Beacon Interval: %d\n"),*beaconInterval,new_beaconInterval );
3009 //Update the becon Interval
3010 if(*beaconInterval != new_beaconInterval )
3011 {
3012 //Update the beaconInterval now
3013 smsLog(pMac, LOG1, FL(" Beacon Interval got changed\n"));
3014 pMac->roam.roamSession[sessionId].bssParams.beaconInterval = new_beaconInterval;
3015 pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval = eANI_BOOLEAN_TRUE;
3016 csrUpdateMCCp2pBeaconInterval(pMac);
3017 }
3018 return eHAL_STATUS_SUCCESS;
3019 }
3020 //Disconnect the P2P session
3021 else if(pMac->roam.configParam.fAllowMCCGODiffBI == 0x03)
3022 {
3023 pMac->roam.roamSession[sessionId].bssParams.updatebeaconInterval = eANI_BOOLEAN_FALSE;
3024 return csrRoamCallCallback(pMac, sessionId, NULL, 0, eCSR_ROAM_SEND_P2P_STOP_BSS, eCSR_ROAM_RESULT_NONE);
3025 }
3026 else
3027 {
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]3028 smsLog(pMac, LOGE, FL("BeaconInterval is different cannot connect to preferred AP...\n"));
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]3029 return eHAL_STATUS_FAILURE;
3030 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3031 }
3032 }
3033 break;
3034
3035 case VOS_P2P_CLIENT_MODE:
3036 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
3037 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
3038 == VOS_STA_MODE)) //check for P2P client mode
3039 {
3040 smsLog(pMac, LOG1, FL(" Ignore Beacon Interval Validation...\n"));
3041 }
3042 //IF SAP has started and STA wants to connect on different channel MCC should
3043 //MCC should not be enabled so making it false to enforce on same channel
3044 else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
3045 == VOS_STA_SAP_MODE)
3046 {
3047 if (pMac->roam.roamSession[sessionId].bssParams.operationChn
3048 != channelId )
3049 {
3050 smsLog(pMac, LOGE, FL("***MCC is not enabled for SAP + CLIENT****\n"));
3051 return eHAL_STATUS_FAILURE;
3052 }
3053 }
3054 else if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
3055 == VOS_P2P_GO_MODE) //Check for P2P go scenario
3056 {
3057 if ((pMac->roam.roamSession[sessionId].bssParams.operationChn
3058 != channelId ) &&
3059 (pMac->roam.roamSession[sessionId].bssParams.beaconInterval
3060 != *beaconInterval))
3061 {
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]3062 smsLog(pMac, LOGE, FL("BeaconInterval is different cannot connect to P2P_GO network ...\n"));
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3063 return eHAL_STATUS_FAILURE;
3064 }
3065 }
3066 break;
3067
3068 case VOS_P2P_GO_MODE :
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]3069 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3070 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
3071 ((pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]3072 == VOS_P2P_CLIENT_MODE) ||
3073 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3074 == VOS_STA_MODE))) //check for P2P_client scenario
3075 {
3076 if ((pMac->roam.roamSession[sessionId].connectedProfile.operationChannel
3077 == 0 )&&
3078 (pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval
3079 == 0))
3080 {
3081 continue;
3082 }
3083
3084
3085 if (csrIsConnStateConnectedInfra(pMac, sessionId) &&
3086 (pMac->roam.roamSession[sessionId].connectedProfile.operationChannel
3087 != channelId ) &&
3088 (pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval
3089 != *beaconInterval))
3090 {
3091 /*
3092 * Updated beaconInterval should be used only when we are starting a new BSS
3093 * not incase of client or STA case
3094 */
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]3095 //Calculate beacon Interval for P2P-GO incase of MCC
3096 new_beaconInterval = csrCalculateMCCBeaconInterval(pMac,
3097 pMac->roam.roamSession[sessionId].bssParams.beaconInterval,
3098 *beaconInterval );
3099 if(*beaconInterval != new_beaconInterval)
3100 *beaconInterval = new_beaconInterval;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3101 return eHAL_STATUS_SUCCESS;
3102 }
3103 }
Madan Mohan Koyyalamudi167b95e2012-11-27 15:53:38 -0800[diff] [blame]3104 }
3105 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3106
3107 default :
3108 smsLog(pMac, LOG1, FL(" Persona not supported : %d\n"),currBssPersona);
3109 return eHAL_STATUS_FAILURE;
3110 }
3111 }
3112 }
3113
3114 return eHAL_STATUS_SUCCESS;
3115}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3116
3117#ifdef WLAN_FEATURE_VOWIFI_11R
3118/* Function to return TRUE if the authtype is 11r */
Madan Mohan Koyyalamudi5e32b962012-11-28 16:07:55 -0800[diff] [blame]3119tANI_BOOLEAN csrIsAuthType11r( eCsrAuthType AuthType, tANI_U8 mdiePresent)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3120{
3121 switch ( AuthType )
3122 {
Madan Mohan Koyyalamudi5e32b962012-11-28 16:07:55 -0800[diff] [blame]3123 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
3124 if(mdiePresent)
3125 return TRUE;
3126 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3127 case eCSR_AUTH_TYPE_FT_RSN_PSK:
3128 case eCSR_AUTH_TYPE_FT_RSN:
3129 return TRUE;
3130 break;
3131 default:
3132 break;
3133 }
3134 return FALSE;
3135}
3136
3137/* Function to return TRUE if the profile is 11r */
3138tANI_BOOLEAN csrIsProfile11r( tCsrRoamProfile *pProfile )
3139{
Madan Mohan Koyyalamudi5e32b962012-11-28 16:07:55 -0800[diff] [blame]3140 return csrIsAuthType11r( pProfile->negotiatedAuthType, pProfile->MDID.mdiePresent );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3141}
3142
3143#endif
3144
3145#ifdef FEATURE_WLAN_CCX
3146
3147/* Function to return TRUE if the authtype is CCX */
3148tANI_BOOLEAN csrIsAuthTypeCCX( eCsrAuthType AuthType )
3149{
3150 switch ( AuthType )
3151 {
3152 case eCSR_AUTH_TYPE_CCKM_WPA:
3153 case eCSR_AUTH_TYPE_CCKM_RSN:
3154 return TRUE;
3155 break;
3156 default:
3157 break;
3158 }
3159 return FALSE;
3160}
3161
3162/* Function to return TRUE if the profile is CCX */
3163tANI_BOOLEAN csrIsProfileCCX( tCsrRoamProfile *pProfile )
3164{
3165 return (csrIsAuthTypeCCX( pProfile->negotiatedAuthType ));
3166}
3167
3168#endif
3169
3170#ifdef FEATURE_WLAN_WAPI
3171tANI_BOOLEAN csrIsProfileWapi( tCsrRoamProfile *pProfile )
3172{
3173 tANI_BOOLEAN fWapiProfile = FALSE;
3174
3175 switch ( pProfile->negotiatedAuthType )
3176 {
3177 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
3178 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
3179 fWapiProfile = TRUE;
3180 break;
3181
3182 default:
3183 fWapiProfile = FALSE;
3184 break;
3185 }
3186
3187 if ( fWapiProfile )
3188 {
3189 switch ( pProfile->negotiatedUCEncryptionType )
3190 {
3191 case eCSR_ENCRYPT_TYPE_WPI:
3192 fWapiProfile = TRUE;
3193 break;
3194
3195 default:
3196 fWapiProfile = FALSE;
3197 break;
3198 }
3199 }
3200 return( fWapiProfile );
3201}
3202
3203static tANI_BOOLEAN csrIsWapiOuiEqual( tpAniSirGlobal pMac, tANI_U8 *Oui1, tANI_U8 *Oui2 )
3204{
3205 return( palEqualMemory(pMac->hHdd, Oui1, Oui2, CSR_WAPI_OUI_SIZE ) );
3206}
3207
3208static tANI_BOOLEAN csrIsWapiOuiMatch( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WAPI_OUI_SIZE],
3209 tANI_U8 cAllCyphers,
3210 tANI_U8 Cypher[],
3211 tANI_U8 Oui[] )
3212{
3213 tANI_BOOLEAN fYes = FALSE;
3214 tANI_U8 idx;
3215
3216 for ( idx = 0; idx < cAllCyphers; idx++ )
3217 {
3218 if ( csrIsWapiOuiEqual( pMac, AllCyphers[ idx ], Cypher ) )
3219 {
3220 fYes = TRUE;
3221 break;
3222 }
3223 }
3224
3225 if ( fYes && Oui )
3226 {
3227 palCopyMemory( pMac->hHdd, Oui, AllCyphers[ idx ], CSR_WAPI_OUI_SIZE );
3228 }
3229
3230 return( fYes );
3231}
3232#endif /* FEATURE_WLAN_WAPI */
3233
3234static tANI_BOOLEAN csrIsWpaOuiEqual( tpAniSirGlobal pMac, tANI_U8 *Oui1, tANI_U8 *Oui2 )
3235{
3236 return( palEqualMemory(pMac->hHdd, Oui1, Oui2, CSR_WPA_OUI_SIZE ) );
3237}
3238
3239static tANI_BOOLEAN csrIsOuiMatch( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3240 tANI_U8 cAllCyphers,
3241 tANI_U8 Cypher[],
3242 tANI_U8 Oui[] )
3243{
3244 tANI_BOOLEAN fYes = FALSE;
3245 tANI_U8 idx;
3246
3247 for ( idx = 0; idx < cAllCyphers; idx++ )
3248 {
3249 if ( csrIsWpaOuiEqual( pMac, AllCyphers[ idx ], Cypher ) )
3250 {
3251 fYes = TRUE;
3252 break;
3253 }
3254 }
3255
3256 if ( fYes && Oui )
3257 {
3258 palCopyMemory( pMac->hHdd, Oui, AllCyphers[ idx ], CSR_WPA_OUI_SIZE );
3259 }
3260
3261 return( fYes );
3262}
3263
3264static tANI_BOOLEAN csrMatchRSNOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3265 tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
3266 tANI_U8 Oui[] )
3267{
3268 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui[ouiIndex], Oui ) );
3269
3270}
3271
3272#ifdef FEATURE_WLAN_WAPI
3273static tANI_BOOLEAN csrMatchWapiOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WAPI_OUI_SIZE],
3274 tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
3275 tANI_U8 Oui[] )
3276{
3277 return( csrIsWapiOuiMatch( pMac, AllCyphers, cAllCyphers, csrWapiOui[ouiIndex], Oui ) );
3278
3279}
3280#endif /* FEATURE_WLAN_WAPI */
3281
3282static tANI_BOOLEAN csrMatchWPAOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3283 tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
3284 tANI_U8 Oui[] )
3285{
3286 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui[ouiIndex], Oui ) );
3287
3288}
3289
3290#if 0
3291static tANI_BOOLEAN csrIsRSNUnicastNone( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3292 tANI_U8 cAllCyphers,
3293 tANI_U8 Oui[] )
3294{
3295 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui00, Oui ) );
3296}
3297
3298static tANI_BOOLEAN csrIsRSNMulticastWep( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3299 tANI_U8 cAllCyphers,
3300 tANI_U8 Oui[] )
3301{
3302 tANI_BOOLEAN fYes = FALSE;
3303
3304 // Check Wep 104 first, if fails, then check Wep40.
3305 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui05, Oui );
3306
3307 if ( !fYes )
3308 {
3309 // if not Wep-104, check Wep-40
3310 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui01, Oui );
3311 }
3312
3313 return( fYes );
3314}
3315
3316
3317static tANI_BOOLEAN csrIsRSNUnicastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3318 tANI_U8 cAllCyphers,
3319 tANI_U8 Oui[] )
3320{
3321 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui02, Oui ) );
3322}
3323
3324
3325static tANI_BOOLEAN csrIsRSNMulticastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3326 tANI_U8 cAllCyphers,
3327 tANI_U8 Oui[] )
3328{
3329 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui02, Oui ) );
3330}
3331
3332static tANI_BOOLEAN csrIsRSNUnicastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3333 tANI_U8 cAllCyphers,
3334 tANI_U8 Oui[] )
3335{
3336 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui04, Oui ) );
3337}
3338
3339static tANI_BOOLEAN csrIsRSNMulticastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3340 tANI_U8 cAllCyphers,
3341 tANI_U8 Oui[] )
3342{
3343 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui04, Oui ) );
3344}
3345#endif
3346#ifdef FEATURE_WLAN_WAPI
3347static tANI_BOOLEAN csrIsAuthWapiCert( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WAPI_OUI_SIZE],
3348 tANI_U8 cAllSuites,
3349 tANI_U8 Oui[] )
3350{
3351 return( csrIsWapiOuiMatch( pMac, AllSuites, cAllSuites, csrWapiOui[1], Oui ) );
3352}
3353static tANI_BOOLEAN csrIsAuthWapiPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WAPI_OUI_SIZE],
3354 tANI_U8 cAllSuites,
3355 tANI_U8 Oui[] )
3356{
3357 return( csrIsWapiOuiMatch( pMac, AllSuites, cAllSuites, csrWapiOui[2], Oui ) );
3358}
3359#endif /* FEATURE_WLAN_WAPI */
3360
3361#ifdef WLAN_FEATURE_VOWIFI_11R
3362
3363/*
3364 * Function for 11R FT Authentication. We match the FT Authentication Cipher suite
3365 * here. This matches for FT Auth with the 802.1X exchange.
3366 *
3367 */
3368static tANI_BOOLEAN csrIsFTAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3369 tANI_U8 cAllSuites,
3370 tANI_U8 Oui[] )
3371{
3372 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[03], Oui ) );
3373}
3374
3375/*
3376 * Function for 11R FT Authentication. We match the FT Authentication Cipher suite
3377 * here. This matches for FT Auth with the PSK.
3378 *
3379 */
3380static tANI_BOOLEAN csrIsFTAuthRSNPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3381 tANI_U8 cAllSuites,
3382 tANI_U8 Oui[] )
3383{
3384 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[04], Oui ) );
3385}
3386
3387#endif
3388
3389#ifdef FEATURE_WLAN_CCX
3390
3391/*
3392 * Function for CCX CCKM AKM Authentication. We match the CCKM AKM Authentication Key Management suite
3393 * here. This matches for CCKM AKM Auth with the 802.1X exchange.
3394 *
3395 */
3396static tANI_BOOLEAN csrIsCcxCckmAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3397 tANI_U8 cAllSuites,
3398 tANI_U8 Oui[] )
3399{
3400 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[06], Oui ) );
3401}
3402
3403static tANI_BOOLEAN csrIsCcxCckmAuthWpa( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3404 tANI_U8 cAllSuites,
3405 tANI_U8 Oui[] )
3406{
3407 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[06], Oui ) );
3408}
3409
3410#endif
3411
3412static tANI_BOOLEAN csrIsAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3413 tANI_U8 cAllSuites,
3414 tANI_U8 Oui[] )
3415{
3416#ifdef WLAN_FEATURE_11W
3417 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[01], Oui ) ||
3418 csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[05], Oui ));
3419#else
3420 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[01], Oui ) );
3421#endif
3422}
3423static tANI_BOOLEAN csrIsAuthRSNPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3424 tANI_U8 cAllSuites,
3425 tANI_U8 Oui[] )
3426{
3427#ifdef WLAN_FEATURE_11W
3428 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[02], Oui ) ||
3429 csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[06], Oui ) );
3430#else
3431 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[02], Oui ) );
3432#endif
3433}
3434
3435static tANI_BOOLEAN csrIsAuthWpa( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3436 tANI_U8 cAllSuites,
3437 tANI_U8 Oui[] )
3438{
3439 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[01], Oui ) );
3440}
3441
3442#ifdef NOT_CURRENTLY_USED
3443static tANI_BOOLEAN csrIsAuth802_1x( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3444 tANI_U8 cAllSuites,
3445 tANI_U8 Oui[] )
3446{
3447 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[00], Oui ) );
3448}
3449#endif // NOT_CURRENTLY_USED
3450
3451static tANI_BOOLEAN csrIsAuthWpaPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3452 tANI_U8 cAllSuites,
3453 tANI_U8 Oui[] )
3454{
3455 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[02], Oui ) );
3456}
3457#if 0
3458static tANI_BOOLEAN csrIsUnicastNone( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3459 tANI_U8 cAllCyphers,
3460 tANI_U8 Oui[] )
3461{
3462 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui00, Oui ) );
3463}
3464
3465static tANI_BOOLEAN csrIsUnicastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3466 tANI_U8 cAllCyphers,
3467 tANI_U8 Oui[] )
3468{
3469 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui02, Oui ) );
3470}
3471
3472static tANI_BOOLEAN csrIsUnicastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3473 tANI_U8 cAllCyphers,
3474 tANI_U8 Oui[] )
3475{
3476 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui04, Oui ) );
3477}
3478
3479
3480static tANI_BOOLEAN csrIsMulticastWep( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3481 tANI_U8 cAllCyphers,
3482 tANI_U8 Oui[] )
3483{
3484 tANI_BOOLEAN fYes = FALSE;
3485
3486 // Check Wep 104 first, if fails, then check Wep40.
3487 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui05, Oui );
3488
3489 if ( !fYes )
3490 {
3491 // if not Wep-104, check Wep-40
3492 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui01, Oui );
3493 }
3494
3495 return( fYes );
3496}
3497
3498
3499static tANI_BOOLEAN csrIsMulticastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3500 tANI_U8 cAllCyphers,
3501 tANI_U8 Oui[] )
3502{
3503 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui02, Oui ) );
3504}
3505
3506
3507static tANI_BOOLEAN csrIsMulticastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3508 tANI_U8 cAllCyphers,
3509 tANI_U8 Oui[] )
3510{
3511 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui04, Oui ) );
3512}
3513
3514#endif
3515
3516tANI_U8 csrGetOUIIndexFromCipher( eCsrEncryptionType enType )
3517{
3518 tANI_U8 OUIIndex;
3519
3520 switch ( enType )
3521 {
3522 case eCSR_ENCRYPT_TYPE_WEP40:
3523 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
3524 OUIIndex = CSR_OUI_WEP40_OR_1X_INDEX;
3525 break;
3526 case eCSR_ENCRYPT_TYPE_WEP104:
3527 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
3528 OUIIndex = CSR_OUI_WEP104_INDEX;
3529 break;
3530 case eCSR_ENCRYPT_TYPE_TKIP:
3531 OUIIndex = CSR_OUI_TKIP_OR_PSK_INDEX;
3532 break;
3533 case eCSR_ENCRYPT_TYPE_AES:
3534 OUIIndex = CSR_OUI_AES_INDEX;
3535 break;
3536 case eCSR_ENCRYPT_TYPE_NONE:
3537 OUIIndex = CSR_OUI_USE_GROUP_CIPHER_INDEX;
3538 break;
3539#ifdef FEATURE_WLAN_WAPI
3540 case eCSR_ENCRYPT_TYPE_WPI:
3541 OUIIndex = CSR_OUI_WAPI_WAI_CERT_OR_SMS4_INDEX;
3542 break;
3543#endif /* FEATURE_WLAN_WAPI */
3544 default: //HOWTO handle this?
3545 OUIIndex = CSR_OUI_RESERVED_INDEX;
3546 break;
3547 }//switch
3548
3549 return OUIIndex;
3550}
3551
3552tANI_BOOLEAN csrGetRSNInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
3553 tDot11fIERSN *pRSNIe,
3554 tANI_U8 *UnicastCypher,
3555 tANI_U8 *MulticastCypher,
3556 tANI_U8 *AuthSuite,
3557 tCsrRSNCapabilities *Capabilities,
3558 eCsrAuthType *pNegotiatedAuthtype,
3559 eCsrEncryptionType *pNegotiatedMCCipher )
3560{
3561 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3562 tANI_BOOLEAN fAcceptableCyphers = FALSE;
3563 tANI_U8 cUnicastCyphers = 0;
3564 tANI_U8 cMulticastCyphers = 0;
3565 tANI_U8 cAuthSuites = 0, i;
3566 tANI_U8 Unicast[ CSR_RSN_OUI_SIZE ];
3567 tANI_U8 Multicast[ CSR_RSN_OUI_SIZE ];
3568 tANI_U8 AuthSuites[ CSR_RSN_MAX_AUTH_SUITES ][ CSR_RSN_OUI_SIZE ];
3569 tANI_U8 Authentication[ CSR_RSN_OUI_SIZE ];
3570 tANI_U8 MulticastCyphers[ CSR_RSN_MAX_MULTICAST_CYPHERS ][ CSR_RSN_OUI_SIZE ];
3571 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3572
3573 do{
3574 if ( pRSNIe->present )
3575 {
3576 cMulticastCyphers++;
3577 palCopyMemory(pMac->hHdd, MulticastCyphers, pRSNIe->gp_cipher_suite, CSR_RSN_OUI_SIZE);
3578 cUnicastCyphers = (tANI_U8)(pRSNIe->pwise_cipher_suite_count);
3579 cAuthSuites = (tANI_U8)(pRSNIe->akm_suite_count);
3580 for(i = 0; i < cAuthSuites && i < CSR_RSN_MAX_AUTH_SUITES; i++)
3581 {
3582 palCopyMemory(pMac->hHdd, (void *)&AuthSuites[i],
3583 (void *)&pRSNIe->akm_suites[i], CSR_RSN_OUI_SIZE);
3584 }
3585
3586 //Check - Is requested Unicast Cipher supported by the BSS.
3587 fAcceptableCyphers = csrMatchRSNOUIIndex( pMac, pRSNIe->pwise_cipher_suites, cUnicastCyphers,
3588 csrGetOUIIndexFromCipher( enType ), Unicast );
3589
3590 if( !fAcceptableCyphers ) break;
3591
3592
3593 //Unicast is supported. Pick the first matching Group cipher, if any.
3594 for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
3595 {
3596 fAcceptableCyphers = csrMatchRSNOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
3597 csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i] ), Multicast );
3598 if(fAcceptableCyphers)
3599 {
3600 break;
3601 }
3602 }
3603 if( !fAcceptableCyphers ) break;
3604
3605 if( pNegotiatedMCCipher )
3606 *pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
3607
3608 /* Initializing with FALSE as it has TRUE value already */
3609 fAcceptableCyphers = FALSE;
3610 for (i = 0 ; i < pAuthType->numEntries; i++)
3611 {
3612 //Ciphers are supported, Match authentication algorithm and pick first matching authtype.
3613 #ifdef WLAN_FEATURE_VOWIFI_11R
3614 /* Changed the AKM suites according to order of preference */
3615 if ( csrIsFTAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
3616 {
3617 if (eCSR_AUTH_TYPE_FT_RSN == pAuthType->authType[i])
3618 negAuthType = eCSR_AUTH_TYPE_FT_RSN;
3619 }
3620 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsFTAuthRSNPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
3621 {
3622 if (eCSR_AUTH_TYPE_FT_RSN_PSK == pAuthType->authType[i])
3623 negAuthType = eCSR_AUTH_TYPE_FT_RSN_PSK;
3624 }
3625#endif
3626#ifdef FEATURE_WLAN_CCX
3627 /* CCX only supports 802.1X. No PSK. */
3628 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsCcxCckmAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
3629 {
3630 if (eCSR_AUTH_TYPE_CCKM_RSN == pAuthType->authType[i])
3631 negAuthType = eCSR_AUTH_TYPE_CCKM_RSN;
3632 }
3633#endif
3634 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
3635 {
3636 if (eCSR_AUTH_TYPE_RSN == pAuthType->authType[i])
3637 negAuthType = eCSR_AUTH_TYPE_RSN;
3638 }
3639 if ((negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSNPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
3640 {
3641 if (eCSR_AUTH_TYPE_RSN_PSK == pAuthType->authType[i])
3642 negAuthType = eCSR_AUTH_TYPE_RSN_PSK;
3643 }
3644
3645 // The 1st auth type in the APs RSN IE, to match stations connecting
3646 // profiles auth type will cause us to exit this loop
3647 // This is added as some APs advertise multiple akms in the RSN IE.
3648 if (eCSR_AUTH_TYPE_UNKNOWN != negAuthType)
3649 {
3650 fAcceptableCyphers = TRUE;
3651 break;
3652 }
3653 } // for
3654 }
3655
3656 }while (0);
3657
3658 if ( fAcceptableCyphers )
3659 {
3660 if ( MulticastCypher )
3661 {
3662 palCopyMemory( pMac->hHdd, MulticastCypher, Multicast, CSR_RSN_OUI_SIZE );
3663 }
3664
3665 if ( UnicastCypher )
3666 {
3667 palCopyMemory( pMac->hHdd, UnicastCypher, Unicast, CSR_RSN_OUI_SIZE );
3668 }
3669
3670 if ( AuthSuite )
3671 {
3672 palCopyMemory( pMac->hHdd, AuthSuite, Authentication, CSR_RSN_OUI_SIZE );
3673 }
3674
3675 if ( pNegotiatedAuthtype )
3676 {
3677 *pNegotiatedAuthtype = negAuthType;
3678 }
3679 if ( Capabilities )
3680 {
3681 Capabilities->PreAuthSupported = pRSNIe->preauth;
3682 Capabilities->NoPairwise = pRSNIe->no_pwise;
3683 Capabilities->PTKSAReplayCounter = pRSNIe->PTKSA_replay_counter;
3684 Capabilities->GTKSAReplayCounter = pRSNIe->GTKSA_replay_counter;
3685 Capabilities->Reserved = pRSNIe->reserved;
3686 }
3687 }
3688 return( fAcceptableCyphers );
3689}
3690
3691
3692tANI_BOOLEAN csrIsRSNMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
3693 tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
3694{
3695 tANI_BOOLEAN fRSNMatch = FALSE;
3696
3697 // See if the cyphers in the Bss description match with the settings in the profile.
3698 fRSNMatch = csrGetRSNInformation( hHal, pAuthType, enType, pEnMcType, &pIes->RSN, NULL, NULL, NULL, NULL,
3699 pNegotiatedAuthType, pNegotiatedMCCipher );
3700
3701 return( fRSNMatch );
3702}
3703
3704
3705tANI_BOOLEAN csrLookupPMKID( tpAniSirGlobal pMac, tANI_U32 sessionId, tANI_U8 *pBSSId, tANI_U8 *pPMKId )
3706{
3707 tANI_BOOLEAN fRC = FALSE, fMatchFound = FALSE;
3708 tANI_U32 Index;
3709 tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
3710
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]3711 if(!pSession)
3712 {
3713 smsLog(pMac, LOGE, FL(" session %d not found "), sessionId);
3714 return FALSE;
3715 }
Madan Mohan Koyyalamudiea22cdc2012-10-18 21:02:23 -0700[diff] [blame]3716 /* to force the AP initiate fresh 802.1x authentication after re-association should not
3717 * fill the PMKID from cache this is needed
3718 * by the HS 2.0 passpoint certification 5.2.a and b testcases */
3719
3720 if(pSession->fIgnorePMKIDCache)
3721 {
3722 pSession->fIgnorePMKIDCache = FALSE;
3723 return fRC;
3724 }
3725
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3726 do
3727 {
3728 for( Index=0; Index < pSession->NumPmkidCache; Index++ )
3729 {
3730 smsLog(pMac, LOGW, "match PMKID %02X-%02X-%02X-%02X-%02X-%02X to \n",
3731 pBSSId[0], pBSSId[1], pBSSId[2], pBSSId[3], pBSSId[4], pBSSId[5]);
3732 if( palEqualMemory( pMac->hHdd, pBSSId, pSession->PmkidCacheInfo[Index].BSSID, sizeof(tCsrBssid) ) )
3733 {
3734 // match found
3735 fMatchFound = TRUE;
3736 break;
3737 }
3738 }
3739
3740 if( !fMatchFound ) break;
3741
3742 palCopyMemory( pMac->hHdd, pPMKId, pSession->PmkidCacheInfo[Index].PMKID, CSR_RSN_PMKID_SIZE );
3743
3744 fRC = TRUE;
3745 }
3746 while( 0 );
3747 smsLog(pMac, LOGW, "csrLookupPMKID called return match = %d pMac->roam.NumPmkidCache = %d",
3748 fRC, pSession->NumPmkidCache);
3749
3750 return fRC;
3751}
3752
3753
3754tANI_U8 csrConstructRSNIe( tHalHandle hHal, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
3755 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrRSNIe *pRSNIe )
3756{
3757 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3758 tANI_BOOLEAN fRSNMatch;
3759 tANI_U8 cbRSNIe = 0;
3760 tANI_U8 UnicastCypher[ CSR_RSN_OUI_SIZE ];
3761 tANI_U8 MulticastCypher[ CSR_RSN_OUI_SIZE ];
3762 tANI_U8 AuthSuite[ CSR_RSN_OUI_SIZE ];
3763 tCsrRSNAuthIe *pAuthSuite;
3764 tCsrRSNCapabilities RSNCapabilities;
3765 tCsrRSNPMKIe *pPMK;
3766 tANI_U8 PMKId[CSR_RSN_PMKID_SIZE];
3767 tDot11fBeaconIEs *pIesLocal = pIes;
3768
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3769 smsLog(pMac, LOGW, "%s called...", __func__);
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]3770
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3771 do
3772 {
3773 if ( !csrIsProfileRSN( pProfile ) ) break;
3774
3775 if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
3776 {
3777 break;
3778 }
3779
3780 // See if the cyphers in the Bss description match with the settings in the profile.
3781 fRSNMatch = csrGetRSNInformation( hHal, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType,
3782 &pProfile->mcEncryptionType, &pIesLocal->RSN,
3783 UnicastCypher, MulticastCypher, AuthSuite, &RSNCapabilities, NULL, NULL );
3784 if ( !fRSNMatch ) break;
3785
3786 pRSNIe->IeHeader.ElementID = SIR_MAC_RSN_EID;
3787
3788 pRSNIe->Version = CSR_RSN_VERSION_SUPPORTED;
3789
3790 palCopyMemory( pMac->hHdd, pRSNIe->MulticastOui, MulticastCypher, sizeof( MulticastCypher ) );
3791
3792 pRSNIe->cUnicastCyphers = 1;
3793
3794 palCopyMemory( pMac->hHdd, &pRSNIe->UnicastOui[ 0 ], UnicastCypher, sizeof( UnicastCypher ) );
3795
3796 pAuthSuite = (tCsrRSNAuthIe *)( &pRSNIe->UnicastOui[ pRSNIe->cUnicastCyphers ] );
3797
3798 pAuthSuite->cAuthenticationSuites = 1;
3799 palCopyMemory( pMac->hHdd, &pAuthSuite->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
3800
3801 // RSN capabilities follows the Auth Suite (two octects)
3802 // !!REVIEW - What should STA put in RSN capabilities, currently
3803 // just putting back APs capabilities
3804 // For one, we shouldn't EVER be sending out "pre-auth supported". It is an AP only capability
3805 RSNCapabilities.PreAuthSupported = 0;
3806 *(tANI_U16 *)( &pAuthSuite->AuthOui[ 1 ] ) = *((tANI_U16 *)(&RSNCapabilities));
3807
3808 pPMK = (tCsrRSNPMKIe *)( ((tANI_U8 *)(&pAuthSuite->AuthOui[ 1 ])) + sizeof(tANI_U16) );
3809
3810 if( csrLookupPMKID( pMac, sessionId, pSirBssDesc->bssId, &(PMKId[0]) ) )
3811 {
3812 pPMK->cPMKIDs = 1;
3813
3814 palCopyMemory( pMac->hHdd, pPMK->PMKIDList[0].PMKID, PMKId, CSR_RSN_PMKID_SIZE );
3815 }
3816 else
3817 {
3818 pPMK->cPMKIDs = 0;
3819 }
3820
3821 // Add in the fixed fields plus 1 Unicast cypher, less the IE Header length
3822 // Add in the size of the Auth suite (count plus a single OUI)
3823 // Add in the RSN caps field.
3824 // Add PMKID count and PMKID (if any)
3825 pRSNIe->IeHeader.Length = (tANI_U8) (sizeof( *pRSNIe ) - sizeof ( pRSNIe->IeHeader ) +
3826 sizeof( *pAuthSuite ) +
3827 sizeof( tCsrRSNCapabilities ));
3828 if(pPMK->cPMKIDs)
3829 {
3830 pRSNIe->IeHeader.Length += (tANI_U8)(sizeof( tANI_U16 ) +
3831 (pPMK->cPMKIDs * CSR_RSN_PMKID_SIZE));
3832 }
3833 // return the size of the IE header (total) constructed...
3834 cbRSNIe = pRSNIe->IeHeader.Length + sizeof( pRSNIe->IeHeader );
3835
3836 } while( 0 );
3837
3838 if( !pIes && pIesLocal )
3839 {
3840 //locally allocated
3841 palFreeMemory(pMac->hHdd, pIesLocal);
3842 }
3843
3844 return( cbRSNIe );
3845}
3846
3847
3848#ifdef FEATURE_WLAN_WAPI
3849tANI_BOOLEAN csrGetWapiInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
3850 tDot11fIEWAPI *pWapiIe,
3851 tANI_U8 *UnicastCypher,
3852 tANI_U8 *MulticastCypher,
3853 tANI_U8 *AuthSuite,
3854 eCsrAuthType *pNegotiatedAuthtype,
3855 eCsrEncryptionType *pNegotiatedMCCipher )
3856{
3857 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3858 tANI_BOOLEAN fAcceptableCyphers = FALSE;
3859 tANI_U8 cUnicastCyphers = 0;
3860 tANI_U8 cMulticastCyphers = 0;
3861 tANI_U8 cAuthSuites = 0, i;
3862 tANI_U8 Unicast[ CSR_WAPI_OUI_SIZE ];
3863 tANI_U8 Multicast[ CSR_WAPI_OUI_SIZE ];
3864 tANI_U8 AuthSuites[ CSR_WAPI_MAX_AUTH_SUITES ][ CSR_WAPI_OUI_SIZE ];
3865 tANI_U8 Authentication[ CSR_WAPI_OUI_SIZE ];
3866 tANI_U8 MulticastCyphers[ CSR_WAPI_MAX_MULTICAST_CYPHERS ][ CSR_WAPI_OUI_SIZE ];
3867 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3868
3869 do{
3870 if ( pWapiIe->present )
3871 {
3872 cMulticastCyphers++;
3873 palCopyMemory(pMac->hHdd, MulticastCyphers, pWapiIe->multicast_cipher_suite, CSR_WAPI_OUI_SIZE);
3874 cUnicastCyphers = (tANI_U8)(pWapiIe->unicast_cipher_suite_count);
3875 cAuthSuites = (tANI_U8)(pWapiIe->akm_suite_count);
3876 for(i = 0; i < cAuthSuites && i < CSR_WAPI_MAX_AUTH_SUITES; i++)
3877 {
3878 palCopyMemory(pMac->hHdd, (void *)&AuthSuites[i],
3879 (void *)&pWapiIe->akm_suites[i], CSR_WAPI_OUI_SIZE);
3880 }
3881
3882 //Check - Is requested Unicast Cipher supported by the BSS.
3883 fAcceptableCyphers = csrMatchWapiOUIIndex( pMac, pWapiIe->unicast_cipher_suites, cUnicastCyphers,
3884 csrGetOUIIndexFromCipher( enType ), Unicast );
3885
3886 if( !fAcceptableCyphers ) break;
3887
3888
3889 //Unicast is supported. Pick the first matching Group cipher, if any.
3890 for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
3891 {
3892 fAcceptableCyphers = csrMatchWapiOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
3893 csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i] ), Multicast );
3894 if(fAcceptableCyphers)
3895 {
3896 break;
3897 }
3898 }
3899 if( !fAcceptableCyphers ) break;
3900
3901 if( pNegotiatedMCCipher )
3902 *pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
3903
3904 //Ciphers are supported, Match authentication algorithm and pick first matching authtype.
3905 if ( csrIsAuthWapiCert( pMac, AuthSuites, cAuthSuites, Authentication ) )
3906 {
3907 negAuthType = eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
3908 }
3909 else if ( csrIsAuthWapiPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
3910 {
3911 negAuthType = eCSR_AUTH_TYPE_WAPI_WAI_PSK;
3912 }
3913 else
3914 {
3915 fAcceptableCyphers = FALSE;
3916 negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3917 }
3918 if( ( 0 == pAuthType->numEntries ) || ( FALSE == fAcceptableCyphers ) )
3919 {
3920 //Caller doesn't care about auth type, or BSS doesn't match
3921 break;
3922 }
3923 fAcceptableCyphers = FALSE;
3924 for( i = 0 ; i < pAuthType->numEntries; i++ )
3925 {
3926 if( pAuthType->authType[i] == negAuthType )
3927 {
3928 fAcceptableCyphers = TRUE;
3929 break;
3930 }
3931 }
3932 }
3933 }while (0);
3934
3935 if ( fAcceptableCyphers )
3936 {
3937 if ( MulticastCypher )
3938 {
3939 palCopyMemory( pMac->hHdd, MulticastCypher, Multicast, CSR_WAPI_OUI_SIZE );
3940 }
3941
3942 if ( UnicastCypher )
3943 {
3944 palCopyMemory( pMac->hHdd, UnicastCypher, Unicast, CSR_WAPI_OUI_SIZE );
3945 }
3946
3947 if ( AuthSuite )
3948 {
3949 palCopyMemory( pMac->hHdd, AuthSuite, Authentication, CSR_WAPI_OUI_SIZE );
3950 }
3951
3952 if ( pNegotiatedAuthtype )
3953 {
3954 *pNegotiatedAuthtype = negAuthType;
3955 }
3956 }
3957 return( fAcceptableCyphers );
3958}
3959
3960tANI_BOOLEAN csrIsWapiMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
3961 tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
3962{
3963 tANI_BOOLEAN fWapiMatch = FALSE;
3964
3965 // See if the cyphers in the Bss description match with the settings in the profile.
3966 fWapiMatch = csrGetWapiInformation( hHal, pAuthType, enType, pEnMcType, &pIes->WAPI, NULL, NULL, NULL,
3967 pNegotiatedAuthType, pNegotiatedMCCipher );
3968
3969 return( fWapiMatch );
3970}
3971
3972tANI_BOOLEAN csrLookupBKID( tpAniSirGlobal pMac, tANI_U32 sessionId, tANI_U8 *pBSSId, tANI_U8 *pBKId )
3973{
3974 tANI_BOOLEAN fRC = FALSE, fMatchFound = FALSE;
3975 tANI_U32 Index;
3976 tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
3977
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]3978 if(!pSession)
3979 {
3980 smsLog(pMac, LOGE, FL(" session %d not found "), sessionId);
3981 return FALSE;
3982 }
3983
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3984 do
3985 {
3986 for( Index=0; Index < pSession->NumBkidCache; Index++ )
3987 {
3988 smsLog(pMac, LOGW, "match BKID %02X-%02X-%02X-%02X-%02X-%02X to \n",
3989 pBSSId[0], pBSSId[1], pBSSId[2], pBSSId[3], pBSSId[4], pBSSId[5]);
3990 if( palEqualMemory( pMac->hHdd, pBSSId, pSession->BkidCacheInfo[Index].BSSID, sizeof(tCsrBssid) ) )
3991 {
3992 // match found
3993 fMatchFound = TRUE;
3994 break;
3995 }
3996 }
3997
3998 if( !fMatchFound ) break;
3999
4000 palCopyMemory( pMac->hHdd, pBKId, pSession->BkidCacheInfo[Index].BKID, CSR_WAPI_BKID_SIZE );
4001
4002 fRC = TRUE;
4003 }
4004 while( 0 );
4005 smsLog(pMac, LOGW, "csrLookupBKID called return match = %d pMac->roam.NumBkidCache = %d", fRC, pSession->NumBkidCache);
4006
4007 return fRC;
4008}
4009
4010tANI_U8 csrConstructWapiIe( tpAniSirGlobal pMac, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
4011 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrWapiIe *pWapiIe )
4012{
4013 tANI_BOOLEAN fWapiMatch = FALSE;
4014 tANI_U8 cbWapiIe = 0;
4015 tANI_U8 UnicastCypher[ CSR_WAPI_OUI_SIZE ];
4016 tANI_U8 MulticastCypher[ CSR_WAPI_OUI_SIZE ];
4017 tANI_U8 AuthSuite[ CSR_WAPI_OUI_SIZE ];
4018 tANI_U8 BKId[CSR_WAPI_BKID_SIZE];
4019 tANI_U8 *pWapi = NULL;
4020 tANI_BOOLEAN fBKIDFound = FALSE;
4021 tDot11fBeaconIEs *pIesLocal = pIes;
4022
4023 do
4024 {
4025 if ( !csrIsProfileWapi( pProfile ) ) break;
4026
4027 if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
4028 {
4029 break;
4030 }
4031
4032 // See if the cyphers in the Bss description match with the settings in the profile.
4033 fWapiMatch = csrGetWapiInformation( pMac, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType,
4034 &pProfile->mcEncryptionType, &pIesLocal->WAPI,
4035 UnicastCypher, MulticastCypher, AuthSuite, NULL, NULL );
4036 if ( !fWapiMatch ) break;
4037
4038 palZeroMemory(pMac->hHdd, pWapiIe, sizeof(tCsrWapiIe));
4039
4040 pWapiIe->IeHeader.ElementID = DOT11F_EID_WAPI;
4041
4042 pWapiIe->Version = CSR_WAPI_VERSION_SUPPORTED;
4043
4044 pWapiIe->cAuthenticationSuites = 1;
4045 palCopyMemory( pMac->hHdd, &pWapiIe->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
4046
4047 pWapi = (tANI_U8 *) (&pWapiIe->AuthOui[ 1 ]);
4048
4049 *pWapi = (tANI_U16)1; //cUnicastCyphers
4050 pWapi+=2;
4051 palCopyMemory( pMac->hHdd, pWapi, UnicastCypher, sizeof( UnicastCypher ) );
4052 pWapi += sizeof( UnicastCypher );
4053
4054 palCopyMemory( pMac->hHdd, pWapi, MulticastCypher, sizeof( MulticastCypher ) );
4055 pWapi += sizeof( MulticastCypher );
4056
4057
4058 // WAPI capabilities follows the Auth Suite (two octects)
4059 // we shouldn't EVER be sending out "pre-auth supported". It is an AP only capability
4060 // & since we already did a memset pWapiIe to 0, skip these fields
4061 pWapi +=2;
4062
4063 fBKIDFound = csrLookupBKID( pMac, sessionId, pSirBssDesc->bssId, &(BKId[0]) );
4064
4065
4066 if( fBKIDFound )
4067 {
4068 /* Do we need to change the endianness here */
4069 *pWapi = (tANI_U16)1; //cBKIDs
4070 pWapi+=2;
4071 palCopyMemory( pMac->hHdd, pWapi, BKId, CSR_WAPI_BKID_SIZE );
4072 }
4073 else
4074 {
4075 *pWapi = 0;
4076 pWapi+=1;
4077 *pWapi = 0;
4078 pWapi+=1;
4079 }
4080
4081 // Add in the IE fields except the IE header
4082 // Add BKID count and BKID (if any)
4083 pWapiIe->IeHeader.Length = (tANI_U8) (sizeof( *pWapiIe ) - sizeof ( pWapiIe->IeHeader ));
4084
4085 /*2 bytes for BKID Count field*/
4086 pWapiIe->IeHeader.Length += sizeof( tANI_U16 );
4087
4088 if(fBKIDFound)
4089 {
4090 pWapiIe->IeHeader.Length += CSR_WAPI_BKID_SIZE;
4091 }
4092 // return the size of the IE header (total) constructed...
4093 cbWapiIe = pWapiIe->IeHeader.Length + sizeof( pWapiIe->IeHeader );
4094
4095 } while( 0 );
4096
4097 if( !pIes && pIesLocal )
4098 {
4099 //locally allocated
4100 palFreeMemory(pMac->hHdd, pIesLocal);
4101 }
4102
4103 return( cbWapiIe );
4104}
4105#endif /* FEATURE_WLAN_WAPI */
4106
4107tANI_BOOLEAN csrGetWpaCyphers( tpAniSirGlobal pMac, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
4108 tDot11fIEWPA *pWpaIe,
4109 tANI_U8 *UnicastCypher,
4110 tANI_U8 *MulticastCypher,
4111 tANI_U8 *AuthSuite,
4112 eCsrAuthType *pNegotiatedAuthtype,
4113 eCsrEncryptionType *pNegotiatedMCCipher )
4114{
4115 tANI_BOOLEAN fAcceptableCyphers = FALSE;
4116 tANI_U8 cUnicastCyphers = 0;
4117 tANI_U8 cMulticastCyphers = 0;
4118 tANI_U8 cAuthSuites = 0;
4119 tANI_U8 Unicast[ CSR_WPA_OUI_SIZE ];
4120 tANI_U8 Multicast[ CSR_WPA_OUI_SIZE ];
4121 tANI_U8 Authentication[ CSR_WPA_OUI_SIZE ];
4122 tANI_U8 MulticastCyphers[ 1 ][ CSR_WPA_OUI_SIZE ];
4123 tANI_U8 i;
4124 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
4125
4126 do
4127 {
4128 if ( pWpaIe->present )
4129 {
4130 cMulticastCyphers = 1;
4131 palCopyMemory(pMac->hHdd, MulticastCyphers, pWpaIe->multicast_cipher, CSR_WPA_OUI_SIZE);
4132 cUnicastCyphers = (tANI_U8)(pWpaIe->unicast_cipher_count);
4133 cAuthSuites = (tANI_U8)(pWpaIe->auth_suite_count);
4134
4135 //Check - Is requested Unicast Cipher supported by the BSS.
4136 fAcceptableCyphers = csrMatchWPAOUIIndex( pMac, pWpaIe->unicast_ciphers, cUnicastCyphers,
4137 csrGetOUIIndexFromCipher( enType ), Unicast );
4138
4139 if( !fAcceptableCyphers ) break;
4140
4141
4142 //Unicast is supported. Pick the first matching Group cipher, if any.
4143 for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
4144 {
4145 fAcceptableCyphers = csrMatchWPAOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
4146 csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i]), Multicast );
4147 if(fAcceptableCyphers)
4148 {
4149 break;
4150 }
4151 }
4152 if( !fAcceptableCyphers ) break;
4153
4154 if( pNegotiatedMCCipher )
4155 *pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
4156
4157 /* Initializing with FALSE as it has TRUE value already */
4158 fAcceptableCyphers = FALSE;
4159 for (i = 0 ; i < pAuthType->numEntries; i++)
4160 {
4161 //Ciphers are supported, Match authentication algorithm and pick first matching authtype.
4162 if ( csrIsAuthWpa( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
4163 {
4164 if (eCSR_AUTH_TYPE_WPA == pAuthType->authType[i])
4165 negAuthType = eCSR_AUTH_TYPE_WPA;
4166 }
4167 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthWpaPsk( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
4168 {
4169 if (eCSR_AUTH_TYPE_WPA_PSK == pAuthType->authType[i])
4170 negAuthType = eCSR_AUTH_TYPE_WPA_PSK;
4171 }
4172#ifdef FEATURE_WLAN_CCX
4173 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsCcxCckmAuthWpa( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
4174 {
4175 if (eCSR_AUTH_TYPE_CCKM_WPA == pAuthType->authType[i])
4176 negAuthType = eCSR_AUTH_TYPE_CCKM_WPA;
4177 }
4178#endif /* FEATURE_WLAN_CCX */
4179
4180 // The 1st auth type in the APs WPA IE, to match stations connecting
4181 // profiles auth type will cause us to exit this loop
4182 // This is added as some APs advertise multiple akms in the WPA IE.
4183 if (eCSR_AUTH_TYPE_UNKNOWN != negAuthType)
4184 {
4185 fAcceptableCyphers = TRUE;
4186 break;
4187 }
4188 } // for
4189 }
4190 }while(0);
4191
4192 if ( fAcceptableCyphers )
4193 {
4194 if ( MulticastCypher )
4195 {
4196 palCopyMemory( pMac->hHdd, (tANI_U8 **)MulticastCypher, Multicast, CSR_WPA_OUI_SIZE );
4197 }
4198
4199 if ( UnicastCypher )
4200 {
4201 palCopyMemory( pMac->hHdd, (tANI_U8 **)UnicastCypher, Unicast, CSR_WPA_OUI_SIZE );
4202 }
4203
4204 if ( AuthSuite )
4205 {
4206 palCopyMemory( pMac->hHdd, (tANI_U8 **)AuthSuite, Authentication, CSR_WPA_OUI_SIZE );
4207 }
4208
4209 if( pNegotiatedAuthtype )
4210 {
4211 *pNegotiatedAuthtype = negAuthType;
4212 }
4213 }
4214
4215 return( fAcceptableCyphers );
4216}
4217
4218
4219
4220tANI_BOOLEAN csrIsWpaEncryptionMatch( tpAniSirGlobal pMac, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
4221 tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthtype, eCsrEncryptionType *pNegotiatedMCCipher )
4222{
4223 tANI_BOOLEAN fWpaMatch = eANI_BOOLEAN_FALSE;
4224
4225 // See if the cyphers in the Bss description match with the settings in the profile.
4226 fWpaMatch = csrGetWpaCyphers( pMac, pAuthType, enType, pEnMcType, &pIes->WPA, NULL, NULL, NULL, pNegotiatedAuthtype, pNegotiatedMCCipher );
4227
4228 return( fWpaMatch );
4229}
4230
4231
4232tANI_U8 csrConstructWpaIe( tHalHandle hHal, tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
4233 tDot11fBeaconIEs *pIes, tCsrWpaIe *pWpaIe )
4234{
4235 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4236 tANI_BOOLEAN fWpaMatch;
4237 tANI_U8 cbWpaIe = 0;
4238 tANI_U8 UnicastCypher[ CSR_WPA_OUI_SIZE ];
4239 tANI_U8 MulticastCypher[ CSR_WPA_OUI_SIZE ];
4240 tANI_U8 AuthSuite[ CSR_WPA_OUI_SIZE ];
4241 tCsrWpaAuthIe *pAuthSuite;
4242 tDot11fBeaconIEs *pIesLocal = pIes;
4243
4244 do
4245 {
4246 if ( !csrIsProfileWpa( pProfile ) ) break;
4247
4248 if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
4249 {
4250 break;
4251 }
4252 // See if the cyphers in the Bss description match with the settings in the profile.
4253 fWpaMatch = csrGetWpaCyphers( hHal, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType, &pProfile->mcEncryptionType,
4254 &pIesLocal->WPA, UnicastCypher, MulticastCypher, AuthSuite, NULL, NULL );
4255 if ( !fWpaMatch ) break;
4256
4257 pWpaIe->IeHeader.ElementID = SIR_MAC_WPA_EID;
4258
4259 palCopyMemory( pMac->hHdd, pWpaIe->Oui, csrWpaOui[01], sizeof( pWpaIe->Oui ) );
4260
4261 pWpaIe->Version = CSR_WPA_VERSION_SUPPORTED;
4262
4263 palCopyMemory( pMac->hHdd, pWpaIe->MulticastOui, MulticastCypher, sizeof( MulticastCypher ) );
4264
4265 pWpaIe->cUnicastCyphers = 1;
4266
4267 palCopyMemory( pMac->hHdd, &pWpaIe->UnicastOui[ 0 ], UnicastCypher, sizeof( UnicastCypher ) );
4268
4269 pAuthSuite = (tCsrWpaAuthIe *)( &pWpaIe->UnicastOui[ pWpaIe->cUnicastCyphers ] );
4270
4271 pAuthSuite->cAuthenticationSuites = 1;
4272 palCopyMemory( pMac->hHdd, &pAuthSuite->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
4273
4274 // The WPA capabilities follows the Auth Suite (two octects)--
4275 // this field is optional, and we always "send" zero, so just
4276 // remove it. This is consistent with our assumptions in the
4277 // frames compiler; c.f. bug 15234:
4278 // http://gold.woodsidenet.com/bugzilla/show_bug.cgi?id=15234
4279
4280 // Add in the fixed fields plus 1 Unicast cypher, less the IE Header length
4281 // Add in the size of the Auth suite (count plus a single OUI)
4282 pWpaIe->IeHeader.Length = sizeof( *pWpaIe ) - sizeof ( pWpaIe->IeHeader ) +
4283 sizeof( *pAuthSuite );
4284
4285 // return the size of the IE header (total) constructed...
4286 cbWpaIe = pWpaIe->IeHeader.Length + sizeof( pWpaIe->IeHeader );
4287
4288 } while( 0 );
4289
4290 if( !pIes && pIesLocal )
4291 {
4292 //locally allocated
4293 palFreeMemory(pMac->hHdd, pIesLocal);
4294 }
4295
4296 return( cbWpaIe );
4297}
4298
4299
4300tANI_BOOLEAN csrGetWpaRsnIe( tHalHandle hHal, tANI_U8 *pIes, tANI_U32 len,
4301 tANI_U8 *pWpaIe, tANI_U8 *pcbWpaIe, tANI_U8 *pRSNIe, tANI_U8 *pcbRSNIe)
4302{
4303 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4304 tDot11IEHeader *pIEHeader;
4305 tSirMacPropIE *pSirMacPropIE;
4306 tANI_U32 cbParsed;
4307 tANI_U32 cbIE;
4308 int cExpectedIEs = 0;
4309 int cFoundIEs = 0;
4310 int cbPropIETotal;
4311
4312 pIEHeader = (tDot11IEHeader *)pIes;
4313 if(pWpaIe) cExpectedIEs++;
4314 if(pRSNIe) cExpectedIEs++;
4315
4316 // bss description length includes all fields other than the length itself
4317 cbParsed = 0;
4318
4319 // Loop as long as there is data left in the IE of the Bss Description
4320 // and the number of Expected IEs is NOT found yet.
4321 while( ( (cbParsed + sizeof( *pIEHeader )) <= len ) && ( cFoundIEs < cExpectedIEs ) )
4322 {
4323 cbIE = sizeof( *pIEHeader ) + pIEHeader->Length;
4324
4325 if ( ( cbIE + cbParsed ) > len ) break;
4326
4327 if ( ( pIEHeader->Length >= gCsrIELengthTable[ pIEHeader->ElementID ].min ) &&
4328 ( pIEHeader->Length <= gCsrIELengthTable[ pIEHeader->ElementID ].max ) )
4329 {
4330 switch( pIEHeader->ElementID )
4331 {
4332 // Parse the 221 (0xdd) Proprietary IEs here...
4333 // Note that the 221 IE is overloaded, containing the WPA IE, WMM/WME IE, and the
4334 // Airgo proprietary IE information.
4335 case SIR_MAC_WPA_EID:
4336 {
4337 tANI_U32 aniOUI;
4338 tANI_U8 *pOui = (tANI_U8 *)&aniOUI;
4339
4340 pOui++;
4341 aniOUI = ANI_OUI;
4342 aniOUI = i_ntohl( aniOUI );
4343
4344 pSirMacPropIE = ( tSirMacPropIE *)pIEHeader;
4345 cbPropIETotal = pSirMacPropIE->length;
4346
4347 // Validate the ANI OUI is in the OUI field in the proprietary IE...
4348 if ( ( pSirMacPropIE->length >= WNI_CFG_MANUFACTURER_OUI_LEN ) &&
4349 pOui[ 0 ] == pSirMacPropIE->oui[ 0 ] &&
4350 pOui[ 1 ] == pSirMacPropIE->oui[ 1 ] &&
4351 pOui[ 2 ] == pSirMacPropIE->oui[ 2 ] )
4352 {
4353 }
4354 else
4355 {
4356 tCsrWpaIe *pIe = ( tCsrWpaIe * )pIEHeader;
4357
4358 if(!pWpaIe || !pcbWpaIe) break;
4359 // Check if this is a valid WPA IE. Then check that the
4360 // WPA OUI is in place and the version is one that we support.
4361 if ( ( pIe->IeHeader.Length >= SIR_MAC_WPA_IE_MIN_LENGTH ) &&
4362 ( palEqualMemory(pMac->hHdd, pIe->Oui, (void *)csrWpaOui[1], sizeof( pIe->Oui ) ) ) &&
4363 ( pIe->Version <= CSR_WPA_VERSION_SUPPORTED ) )
4364 {
4365 palCopyMemory(pMac->hHdd, pWpaIe, pIe, pIe->IeHeader.Length + sizeof( pIe->IeHeader ) );
4366 *pcbWpaIe = pIe->IeHeader.Length + sizeof( pIe->IeHeader );
4367 cFoundIEs++;
4368
4369 break;
4370 }
4371 }
4372
4373 break;
4374 }
4375
4376 case SIR_MAC_RSN_EID:
4377 {
4378 tCsrRSNIe *pIe;
4379
4380 if(!pcbRSNIe || !pRSNIe) break;
4381 pIe = (tCsrRSNIe *)pIEHeader;
4382
4383 // Check the length of the RSN Ie to assure it is valid. Then check that the
4384 // version is one that we support.
4385
4386 if ( pIe->IeHeader.Length < SIR_MAC_RSN_IE_MIN_LENGTH ) break;
4387 if ( pIe->Version > CSR_RSN_VERSION_SUPPORTED ) break;
4388
4389 cFoundIEs++;
4390
4391 // if there is enough room in the WpaIE passed in, then copy the Wpa IE into
4392 // the buffer passed in.
4393 if ( *pcbRSNIe < pIe->IeHeader.Length + sizeof( pIe->IeHeader ) ) break;
4394 palCopyMemory(pMac->hHdd, pRSNIe, pIe, pIe->IeHeader.Length + sizeof( pIe->IeHeader ) );
4395 *pcbRSNIe = pIe->IeHeader.Length + sizeof( pIe->IeHeader );
4396
4397 break;
4398 }
4399
4400 // Add support for other IE here...
4401 default:
4402 break;
4403 }
4404 }
4405
4406 cbParsed += cbIE;
4407
4408 pIEHeader = (tDot11IEHeader *)( ((tANI_U8 *)pIEHeader) + cbIE );
4409
4410 }
4411
4412 // return a BOOL that tells if all of the IEs asked for were found...
4413 return( cFoundIEs == cExpectedIEs );
4414}
4415
4416
4417//If a WPAIE exists in the profile, just use it. Or else construct one from the BSS
4418//Caller allocated memory for pWpaIe and guarrantee it can contain a max length WPA IE
4419tANI_U8 csrRetrieveWpaIe( tHalHandle hHal, tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
4420 tDot11fBeaconIEs *pIes, tCsrWpaIe *pWpaIe )
4421{
4422 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4423 tANI_U8 cbWpaIe = 0;
4424
4425 do
4426 {
4427 if ( !csrIsProfileWpa( pProfile ) ) break;
4428 if(pProfile->nWPAReqIELength && pProfile->pWPAReqIE)
4429 {
4430 if(SIR_MAC_WPA_IE_MAX_LENGTH >= pProfile->nWPAReqIELength)
4431 {
4432 cbWpaIe = (tANI_U8)pProfile->nWPAReqIELength;
4433 palCopyMemory(pMac->hHdd, pWpaIe, pProfile->pWPAReqIE, cbWpaIe);
4434 }
4435 else
4436 {
4437 smsLog(pMac, LOGW, " csrRetrieveWpaIe detect invalid WPA IE length (%d) \n", pProfile->nWPAReqIELength);
4438 }
4439 }
4440 else
4441 {
4442 cbWpaIe = csrConstructWpaIe(pMac, pProfile, pSirBssDesc, pIes, pWpaIe);
4443 }
4444 }while(0);
4445
4446 return (cbWpaIe);
4447}
4448
4449
4450//If a RSNIE exists in the profile, just use it. Or else construct one from the BSS
4451//Caller allocated memory for pWpaIe and guarrantee it can contain a max length WPA IE
4452tANI_U8 csrRetrieveRsnIe( tHalHandle hHal, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
4453 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrRSNIe *pRsnIe )
4454{
4455 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4456 tANI_U8 cbRsnIe = 0;
4457
4458 do
4459 {
4460 if ( !csrIsProfileRSN( pProfile ) ) break;
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]4461#ifdef FEATURE_WLAN_LFR
Madan Mohan Koyyalamudi03aae5f2012-11-28 01:51:22 +0530[diff] [blame]4462 if (csrRoamIsFastRoamEnabled(pMac, sessionId))
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]4463 {
4464 // If "Legacy Fast Roaming" is enabled ALWAYS rebuild the RSN IE from
4465 // scratch. So it contains the current PMK-IDs
4466 cbRsnIe = csrConstructRSNIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pRsnIe);
4467 }
4468 else
4469#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4470 if(pProfile->nRSNReqIELength && pProfile->pRSNReqIE)
4471 {
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]4472 // If you have one started away, re-use it.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4473 if(SIR_MAC_WPA_IE_MAX_LENGTH >= pProfile->nRSNReqIELength)
4474 {
4475 cbRsnIe = (tANI_U8)pProfile->nRSNReqIELength;
4476 palCopyMemory(pMac->hHdd, pRsnIe, pProfile->pRSNReqIE, cbRsnIe);
4477 }
4478 else
4479 {
4480 smsLog(pMac, LOGW, " csrRetrieveRsnIe detect invalid RSN IE length (%d) \n", pProfile->nRSNReqIELength);
4481 }
4482 }
4483 else
4484 {
4485 cbRsnIe = csrConstructRSNIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pRsnIe);
4486 }
4487 }while(0);
4488
4489 return (cbRsnIe);
4490}
4491
4492
4493#ifdef FEATURE_WLAN_WAPI
4494//If a WAPI IE exists in the profile, just use it. Or else construct one from the BSS
4495//Caller allocated memory for pWapiIe and guarrantee it can contain a max length WAPI IE
4496tANI_U8 csrRetrieveWapiIe( tHalHandle hHal, tANI_U32 sessionId,
4497 tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
4498 tDot11fBeaconIEs *pIes, tCsrWapiIe *pWapiIe )
4499{
4500 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4501 tANI_U8 cbWapiIe = 0;
4502
4503 do
4504 {
4505 if ( !csrIsProfileWapi( pProfile ) ) break;
4506 if(pProfile->nWAPIReqIELength && pProfile->pWAPIReqIE)
4507 {
4508 if(DOT11F_IE_WAPI_MAX_LEN >= pProfile->nWAPIReqIELength)
4509 {
4510 cbWapiIe = (tANI_U8)pProfile->nWAPIReqIELength;
4511 palCopyMemory(pMac->hHdd, pWapiIe, pProfile->pWAPIReqIE, cbWapiIe);
4512 }
4513 else
4514 {
4515 smsLog(pMac, LOGW, " csrRetrieveWapiIe detect invalid WAPI IE length (%d) \n", pProfile->nWAPIReqIELength);
4516 }
4517 }
4518 else
4519 {
4520 cbWapiIe = csrConstructWapiIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pWapiIe);
4521 }
4522 }while(0);
4523
4524 return (cbWapiIe);
4525}
4526#endif /* FEATURE_WLAN_WAPI */
4527
4528tANI_BOOLEAN csrSearchChannelListForTxPower(tHalHandle hHal, tSirBssDescription *pBssDescription, tCsrChannelSet *returnChannelGroup)
4529{
4530 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4531 tListElem *pEntry;
4532 tANI_U16 i;
4533 tANI_U16 startingChannel;
4534 tANI_BOOLEAN found = FALSE;
4535 tCsrChannelSet *pChannelGroup;
4536
4537 pEntry = csrLLPeekHead( &pMac->roam.channelList5G, LL_ACCESS_LOCK );
4538
4539 while ( pEntry )
4540 {
4541 pChannelGroup = GET_BASE_ADDR( pEntry, tCsrChannelSet, channelListLink );
4542 startingChannel = pChannelGroup->firstChannel;
4543 for ( i = 0; i < pChannelGroup->numChannels; i++ )
4544 {
4545 if ( startingChannel + i * pChannelGroup->interChannelOffset == pBssDescription->channelId )
4546 {
4547 found = TRUE;
4548 break;
4549 }
4550 }
4551
4552 if ( found )
4553 {
4554 palCopyMemory(pMac->hHdd, returnChannelGroup, pChannelGroup, sizeof(tCsrChannelSet));
4555 break;
4556 }
4557 else
4558 {
4559 pEntry = csrLLNext( &pMac->roam.channelList5G, pEntry, LL_ACCESS_LOCK );
4560 }
4561 }
4562
4563 return( found );
4564}
4565
4566tANI_BOOLEAN csrRatesIsDot11Rate11bSupportedRate( tANI_U8 dot11Rate )
4567{
4568 tANI_BOOLEAN fSupported = FALSE;
4569 tANI_U16 nonBasicRate = (tANI_U16)( BITS_OFF( dot11Rate, CSR_DOT11_BASIC_RATE_MASK ) );
4570
4571 switch ( nonBasicRate )
4572 {
4573 case eCsrSuppRate_1Mbps:
4574 case eCsrSuppRate_2Mbps:
4575 case eCsrSuppRate_5_5Mbps:
4576 case eCsrSuppRate_11Mbps:
4577 fSupported = TRUE;
4578 break;
4579
4580 default:
4581 break;
4582 }
4583
4584 return( fSupported );
4585}
4586
4587tANI_BOOLEAN csrRatesIsDot11Rate11aSupportedRate( tANI_U8 dot11Rate )
4588{
4589 tANI_BOOLEAN fSupported = FALSE;
4590 tANI_U16 nonBasicRate = (tANI_U16)( BITS_OFF( dot11Rate, CSR_DOT11_BASIC_RATE_MASK ) );
4591
4592 switch ( nonBasicRate )
4593 {
4594 case eCsrSuppRate_6Mbps:
4595 case eCsrSuppRate_9Mbps:
4596 case eCsrSuppRate_12Mbps:
4597 case eCsrSuppRate_18Mbps:
4598 case eCsrSuppRate_24Mbps:
4599 case eCsrSuppRate_36Mbps:
4600 case eCsrSuppRate_48Mbps:
4601 case eCsrSuppRate_54Mbps:
4602 fSupported = TRUE;
4603 break;
4604
4605 default:
4606 break;
4607 }
4608
4609 return( fSupported );
4610}
4611
4612
4613
4614tAniEdType csrTranslateEncryptTypeToEdType( eCsrEncryptionType EncryptType )
4615{
4616 tAniEdType edType;
4617
4618 switch ( EncryptType )
4619 {
4620 default:
4621 case eCSR_ENCRYPT_TYPE_NONE:
4622 edType = eSIR_ED_NONE;
4623 break;
4624
4625 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
4626 case eCSR_ENCRYPT_TYPE_WEP40:
4627 edType = eSIR_ED_WEP40;
4628 break;
4629
4630 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
4631 case eCSR_ENCRYPT_TYPE_WEP104:
4632 edType = eSIR_ED_WEP104;
4633 break;
4634
4635 case eCSR_ENCRYPT_TYPE_TKIP:
4636 edType = eSIR_ED_TKIP;
4637 break;
4638
4639 case eCSR_ENCRYPT_TYPE_AES:
4640 edType = eSIR_ED_CCMP;
4641 break;
4642#ifdef FEATURE_WLAN_WAPI
4643 case eCSR_ENCRYPT_TYPE_WPI:
4644 edType = eSIR_ED_WPI;
4645#endif
4646#ifdef WLAN_FEATURE_11W
4647 //11w BIP
4648 case eCSR_ENCRYPT_TYPE_AES_CMAC:
4649 edType = eSIR_ED_AES_128_CMAC;
4650 break;
4651#endif
4652 }
4653
4654 return( edType );
4655}
4656
4657
4658//pIes can be NULL
4659tANI_BOOLEAN csrValidateWep( tpAniSirGlobal pMac, eCsrEncryptionType ucEncryptionType,
4660 tCsrAuthList *pAuthList, tCsrEncryptionList *pMCEncryptionList,
4661 eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCEncryption,
4662 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes )
4663{
4664 tANI_U32 idx;
4665 tANI_BOOLEAN fMatch = FALSE;
4666 eCsrAuthType negotiatedAuth = eCSR_AUTH_TYPE_OPEN_SYSTEM;
4667 eCsrEncryptionType negotiatedMCCipher = eCSR_ENCRYPT_TYPE_UNKNOWN;
4668
4669 //This function just checks whether HDD is giving correct values for Multicast cipher and Auth.
4670
4671 do
4672 {
4673 //If privacy bit is not set, consider no match
4674 if ( !csrIsPrivacy( pSirBssDesc ) ) break;
4675
4676 for( idx = 0; idx < pMCEncryptionList->numEntries; idx++ )
4677 {
4678 switch( pMCEncryptionList->encryptionType[idx] )
4679 {
4680 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
4681 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
4682 case eCSR_ENCRYPT_TYPE_WEP40:
4683 case eCSR_ENCRYPT_TYPE_WEP104:
4684 /* Multicast list may contain WEP40/WEP104. Check whether it matches UC.
4685 */
4686 if( ucEncryptionType == pMCEncryptionList->encryptionType[idx] )
4687 {
4688 fMatch = TRUE;
4689 negotiatedMCCipher = pMCEncryptionList->encryptionType[idx];
4690 }
4691 break;
4692 default:
4693 fMatch = FALSE;
4694 break;
4695 }
4696 if(fMatch) break;
4697 }
4698
4699 if(!fMatch) break;
4700
4701 for( idx = 0; idx < pAuthList->numEntries; idx++ )
4702 {
4703 switch( pAuthList->authType[idx] )
4704 {
4705 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
4706 case eCSR_AUTH_TYPE_SHARED_KEY:
4707 case eCSR_AUTH_TYPE_AUTOSWITCH:
4708 fMatch = TRUE;
4709 negotiatedAuth = pAuthList->authType[idx];
4710 break;
4711 default:
4712 fMatch = FALSE;
4713 }
4714 if (fMatch) break;
4715 }
4716
4717 if(!fMatch) break;
4718 //In case of WPA / WPA2, check whether it supports WEP as well
4719 if(pIes)
4720 {
4721 //Prepare the encryption type for WPA/WPA2 functions
4722 if( eCSR_ENCRYPT_TYPE_WEP40_STATICKEY == ucEncryptionType )
4723 {
4724 ucEncryptionType = eCSR_ENCRYPT_TYPE_WEP40;
4725 }
4726 else if( eCSR_ENCRYPT_TYPE_WEP104 == ucEncryptionType )
4727 {
4728 ucEncryptionType = eCSR_ENCRYPT_TYPE_WEP104;
4729 }
4730 //else we can use the encryption type directly
4731 if( pIes->WPA.present )
4732 {
4733 fMatch = palEqualMemory(pMac->hHdd, pIes->WPA.multicast_cipher,
4734 csrWpaOui[csrGetOUIIndexFromCipher( ucEncryptionType )], CSR_WPA_OUI_SIZE );
4735 if( fMatch ) break;
4736 }
4737 if( pIes->RSN.present )
4738 {
4739 fMatch = palEqualMemory(pMac->hHdd, pIes->RSN.gp_cipher_suite,
4740 csrRSNOui[csrGetOUIIndexFromCipher( ucEncryptionType )], CSR_RSN_OUI_SIZE );
4741 }
4742 }
4743
4744 }while(0);
4745
4746 if( fMatch )
4747 {
4748 if( pNegotiatedAuthType )
4749 *pNegotiatedAuthType = negotiatedAuth;
4750
4751 if( pNegotiatedMCEncryption )
4752 *pNegotiatedMCEncryption = negotiatedMCCipher;
4753 }
4754
4755
4756 return fMatch;
4757}
4758
4759
4760//pIes shall contain IEs from pSirBssDesc. It shall be returned from function csrGetParsedBssDescriptionIEs
4761tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEncryptionList *pUCEncryptionType, tCsrEncryptionList *pMCEncryptionType,
4762 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes,
4763 eCsrAuthType *negotiatedAuthtype, eCsrEncryptionType *negotiatedUCCipher, eCsrEncryptionType *negotiatedMCCipher )
4764{
4765 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4766 tANI_BOOLEAN fMatch = FALSE;
4767 tANI_U8 i,idx;
4768 eCsrEncryptionType mcCipher = eCSR_ENCRYPT_TYPE_UNKNOWN, ucCipher = eCSR_ENCRYPT_TYPE_UNKNOWN;
4769 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
4770
4771 for( i = 0 ; ((i < pUCEncryptionType->numEntries) && (!fMatch)) ; i++ )
4772 {
4773 ucCipher = pUCEncryptionType->encryptionType[i];
4774 // If the Bss description shows the Privacy bit is on, then we must have some sort of encryption configured
4775 // for the profile to work. Don't attempt to join networks with Privacy bit set when profiles say NONE for
4776 // encryption type.
4777 switch ( ucCipher )
4778 {
4779 case eCSR_ENCRYPT_TYPE_NONE:
4780 {
4781 // for NO encryption, if the Bss description has the Privacy bit turned on, then encryption is
4782 // required so we have to reject this Bss.
4783 if ( csrIsPrivacy( pSirBssDesc ) )
4784 {
4785 fMatch = FALSE;
4786 }
4787 else
4788 {
4789 fMatch = TRUE;
4790 }
4791
4792 if ( fMatch )
4793 {
4794 fMatch = FALSE;
4795 //Check Multicast cipher requested and Auth type requested.
4796 for( idx = 0 ; idx < pMCEncryptionType->numEntries ; idx++ )
4797 {
4798 if( eCSR_ENCRYPT_TYPE_NONE == pMCEncryptionType->encryptionType[idx] )
4799 {
4800 fMatch = TRUE; //Multicast can only be none.
4801 mcCipher = pMCEncryptionType->encryptionType[idx];
4802 break;
4803 }
4804 }
4805 if (!fMatch) break;
4806
4807 fMatch = FALSE;
4808 //Check Auth list. It should contain AuthOpen.
4809 for( idx = 0 ; idx < authType->numEntries ; idx++ )
4810 {
4811 if( eCSR_AUTH_TYPE_OPEN_SYSTEM == authType->authType[idx] )
4812 {
4813 fMatch = TRUE;
4814 negAuthType = eCSR_AUTH_TYPE_OPEN_SYSTEM;
4815 break;
4816 }
4817 }
4818 if (!fMatch) break;
4819
4820 }
4821 break;
4822 }
4823
4824 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
4825 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
4826 // !! might want to check for WEP keys set in the Profile.... ?
4827 // !! don't need to have the privacy bit in the Bss description. Many AP policies make legacy
4828 // encryption 'optional' so we don't know if we can associate or not. The AP will reject if
4829 // encryption is not allowed without the Privacy bit turned on.
4830 fMatch = csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes);
4831
4832 break;
4833
4834 // these are all of the WPA encryption types...
4835 case eCSR_ENCRYPT_TYPE_WEP40:
4836 case eCSR_ENCRYPT_TYPE_WEP104:
4837 fMatch = csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes);
4838 break;
4839
4840 case eCSR_ENCRYPT_TYPE_TKIP:
4841 case eCSR_ENCRYPT_TYPE_AES:
4842 {
4843 if(pIes)
4844 {
4845 // First check if there is a RSN match
4846 fMatch = csrIsRSNMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4847 if( !fMatch )
4848 {
4849 // If not RSN, then check if there is a WPA match
4850 fMatch = csrIsWpaEncryptionMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes,
4851 &negAuthType, &mcCipher );
4852 }
4853 }
4854 else
4855 {
4856 fMatch = FALSE;
4857 }
4858 break;
4859 }
4860#ifdef FEATURE_WLAN_WAPI
4861 case eCSR_ENCRYPT_TYPE_WPI://WAPI
4862 {
4863 if(pIes)
4864 {
4865 fMatch = csrIsWapiMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4866 }
4867 else
4868 {
4869 fMatch = FALSE;
4870 }
4871 break;
4872 }
4873#endif /* FEATURE_WLAN_WAPI */
4874 case eCSR_ENCRYPT_TYPE_ANY:
4875 default:
4876 {
4877 tANI_BOOLEAN fMatchAny = eANI_BOOLEAN_FALSE;
4878
4879 fMatch = eANI_BOOLEAN_TRUE;
4880 //It is allowed to match anything. Try the more secured ones first.
4881 if(pIes)
4882 {
4883 //Check AES first
4884 ucCipher = eCSR_ENCRYPT_TYPE_AES;
4885 fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4886 if(!fMatchAny)
4887 {
4888 //Check TKIP
4889 ucCipher = eCSR_ENCRYPT_TYPE_TKIP;
4890 fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4891 }
4892#ifdef FEATURE_WLAN_WAPI
4893 if(!fMatchAny)
4894 {
4895 //Check WAPI
4896 ucCipher = eCSR_ENCRYPT_TYPE_WPI;
4897 fMatchAny = csrIsWapiMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4898 }
4899#endif /* FEATURE_WLAN_WAPI */
4900 }
4901 if(!fMatchAny)
4902 {
4903 ucCipher = eCSR_ENCRYPT_TYPE_WEP104;
4904 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4905 {
4906 ucCipher = eCSR_ENCRYPT_TYPE_WEP40;
4907 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4908 {
4909 ucCipher = eCSR_ENCRYPT_TYPE_WEP104_STATICKEY;
4910 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4911 {
4912 ucCipher = eCSR_ENCRYPT_TYPE_WEP40_STATICKEY;
4913 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4914 {
4915 //It must be open and no encryption
4916 if ( csrIsPrivacy( pSirBssDesc ) )
4917 {
4918 //This is not right
4919 fMatch = eANI_BOOLEAN_FALSE;
4920 }
4921 else
4922 {
4923 negAuthType = eCSR_AUTH_TYPE_OPEN_SYSTEM;
4924 mcCipher = eCSR_ENCRYPT_TYPE_NONE;
4925 ucCipher = eCSR_ENCRYPT_TYPE_NONE;
4926 }
4927 }
4928 }
4929 }
4930 }
4931 }
4932 break;
4933 }
4934 }
4935
4936 }
4937
4938 if( fMatch )
4939 {
4940 if( negotiatedUCCipher )
4941 *negotiatedUCCipher = ucCipher;
4942
4943 if( negotiatedMCCipher )
4944 *negotiatedMCCipher = mcCipher;
4945
4946 if( negotiatedAuthtype )
4947 *negotiatedAuthtype = negAuthType;
4948 }
4949
4950 return( fMatch );
4951}
4952
4953
4954tANI_BOOLEAN csrIsSsidMatch( tpAniSirGlobal pMac, tANI_U8 *ssid1, tANI_U8 ssid1Len, tANI_U8 *bssSsid,
4955 tANI_U8 bssSsidLen, tANI_BOOLEAN fSsidRequired )
4956{
4957 tANI_BOOLEAN fMatch = FALSE;
4958
4959 do {
4960
4961 // There are a few special cases. If the Bss description has a Broadcast SSID,
4962 // then our Profile must have a single SSID without Wildcards so we can program
4963 // the SSID.
4964 // SSID could be suppressed in beacons. In that case SSID IE has valid length
4965 // but the SSID value is all NULL characters. That condition is trated same
4966 // as NULL SSID
4967 if ( csrIsNULLSSID( bssSsid, bssSsidLen ) )
4968 {
4969 if ( eANI_BOOLEAN_FALSE == fSsidRequired )
4970 {
4971 fMatch = TRUE;
4972 }
4973 break;
4974 }
4975
4976 // Check for the specification of the Broadcast SSID at the beginning of the list.
4977 // If specified, then all SSIDs are matches (broadcast SSID means accept all SSIDs).
4978 if ( ssid1Len == 0 )
4979 {
4980 fMatch = TRUE;
4981 break;
4982 }
4983
4984 if(ssid1Len != bssSsidLen) break;
4985 if(palEqualMemory(pMac->hHdd, bssSsid, ssid1, bssSsidLen))
4986 {
4987 fMatch = TRUE;
4988 break;
4989 }
4990
4991 } while( 0 );
4992
4993 return( fMatch );
4994}
4995
4996
4997//Null ssid means match
4998tANI_BOOLEAN csrIsSsidInList( tHalHandle hHal, tSirMacSSid *pSsid, tCsrSSIDs *pSsidList )
4999{
5000 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5001 tANI_BOOLEAN fMatch = FALSE;
5002 tANI_U32 i;
5003
5004 if ( pSsidList && pSsid )
5005 {
5006 for(i = 0; i < pSsidList->numOfSSIDs; i++)
5007 {
5008 if(csrIsNULLSSID(pSsidList->SSIDList[i].SSID.ssId, pSsidList->SSIDList[i].SSID.length) ||
5009 ((pSsidList->SSIDList[i].SSID.length == pSsid->length) &&
5010 palEqualMemory(pMac->hHdd, pSsid->ssId, pSsidList->SSIDList[i].SSID.ssId, pSsid->length)))
5011 {
5012 fMatch = TRUE;
5013 break;
5014 }
5015 }
5016 }
5017
5018 return (fMatch);
5019}
5020
5021//like to use sirCompareMacAddr
5022tANI_BOOLEAN csrIsMacAddressZero( tpAniSirGlobal pMac, tCsrBssid *pMacAddr )
5023{
5024 tANI_U8 bssid[WNI_CFG_BSSID_LEN] = {0, 0, 0, 0, 0, 0};
5025
5026 return( palEqualMemory(pMac->hHdd, bssid, pMacAddr, WNI_CFG_BSSID_LEN));
5027}
5028
5029//like to use sirCompareMacAddr
5030tANI_BOOLEAN csrIsMacAddressBroadcast( tpAniSirGlobal pMac, tCsrBssid *pMacAddr )
5031{
5032 tANI_U8 bssid[WNI_CFG_BSSID_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
5033
5034 return( palEqualMemory(pMac->hHdd, bssid, pMacAddr, WNI_CFG_BSSID_LEN));
5035}
5036
5037
5038//like to use sirCompareMacAddr
5039tANI_BOOLEAN csrIsMacAddressEqual( tpAniSirGlobal pMac, tCsrBssid *pMacAddr1, tCsrBssid *pMacAddr2 )
5040{
5041 return( palEqualMemory(pMac->hHdd, pMacAddr1, pMacAddr2, sizeof(tCsrBssid)) );
5042}
5043
5044
5045tANI_BOOLEAN csrIsBssidMatch( tHalHandle hHal, tCsrBssid *pProfBssid, tCsrBssid *BssBssid )
5046{
5047 tANI_BOOLEAN fMatch = FALSE;
5048 tCsrBssid ProfileBssid;
5049 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5050
5051 // for efficiency of the MAC_ADDRESS functions, move the
5052 // Bssid's into MAC_ADDRESS structs.
5053 palCopyMemory( pMac->hHdd, &ProfileBssid, pProfBssid, sizeof(tCsrBssid) );
5054
5055 do {
5056
5057 // Give the profile the benefit of the doubt... accept either all 0 or
5058 // the real broadcast Bssid (all 0xff) as broadcast Bssids (meaning to
5059 // match any Bssids).
5060 if ( csrIsMacAddressZero( pMac, &ProfileBssid ) ||
5061 csrIsMacAddressBroadcast( pMac, &ProfileBssid ) )
5062 {
5063 fMatch = TRUE;
5064 break;
5065 }
5066
5067 if ( csrIsMacAddressEqual( pMac, BssBssid, &ProfileBssid ) )
5068 {
5069 fMatch = TRUE;
5070 break;
5071 }
5072
5073 } while( 0 );
5074
5075 return( fMatch );
5076}
5077
5078
5079tANI_BOOLEAN csrIsBSSTypeMatch(eCsrRoamBssType bssType1, eCsrRoamBssType bssType2)
5080{
5081 if((eCSR_BSS_TYPE_ANY != bssType1 && eCSR_BSS_TYPE_ANY != bssType2) && (bssType1 != bssType2))
5082 return eANI_BOOLEAN_FALSE;
5083 else
5084 return eANI_BOOLEAN_TRUE;
5085}
5086
5087
5088tANI_BOOLEAN csrIsBssTypeIBSS(eCsrRoamBssType bssType)
5089{
5090 return((tANI_BOOLEAN)(eCSR_BSS_TYPE_START_IBSS == bssType || eCSR_BSS_TYPE_IBSS == bssType));
5091}
5092
5093tANI_BOOLEAN csrIsBssTypeWDS(eCsrRoamBssType bssType)
5094{
5095 return((tANI_BOOLEAN)(eCSR_BSS_TYPE_WDS_STA == bssType || eCSR_BSS_TYPE_WDS_AP == bssType));
5096}
5097
5098tANI_BOOLEAN csrIsBSSTypeCapsMatch( eCsrRoamBssType bssType, tSirBssDescription *pSirBssDesc )
5099{
5100 tANI_BOOLEAN fMatch = TRUE;
5101
5102 do
5103 {
5104 switch( bssType )
5105 {
5106 case eCSR_BSS_TYPE_ANY:
5107 break;
5108
5109 case eCSR_BSS_TYPE_INFRASTRUCTURE:
5110 case eCSR_BSS_TYPE_WDS_STA:
5111 if( !csrIsInfraBssDesc( pSirBssDesc ) )
5112 fMatch = FALSE;
5113
5114 break;
5115
5116 case eCSR_BSS_TYPE_IBSS:
5117 case eCSR_BSS_TYPE_START_IBSS:
5118 if( !csrIsIbssBssDesc( pSirBssDesc ) )
5119 fMatch = FALSE;
5120
5121 break;
5122
5123 case eCSR_BSS_TYPE_WDS_AP: //For WDS AP, no need to match anything
5124 default:
5125 fMatch = FALSE;
5126 break;
5127 }
5128 }
5129 while( 0 );
5130
5131
5132 return( fMatch );
5133}
5134
5135static tANI_BOOLEAN csrIsCapabilitiesMatch( tpAniSirGlobal pMac, eCsrRoamBssType bssType, tSirBssDescription *pSirBssDesc )
5136{
5137 return( csrIsBSSTypeCapsMatch( bssType, pSirBssDesc ) );
5138}
5139
5140
5141
5142static tANI_BOOLEAN csrIsSpecificChannelMatch( tpAniSirGlobal pMac, tSirBssDescription *pSirBssDesc, tANI_U8 Channel )
5143{
5144 tANI_BOOLEAN fMatch = TRUE;
5145
5146 do
5147 {
5148 // if the channel is ANY, then always match...
5149 if ( eCSR_OPERATING_CHANNEL_ANY == Channel ) break;
5150 if ( Channel == pSirBssDesc->channelId ) break;
5151
5152 // didn't match anything.. so return NO match
5153 fMatch = FALSE;
5154
5155 } while( 0 );
5156
5157 return( fMatch );
5158}
5159
5160
5161tANI_BOOLEAN csrIsChannelBandMatch( tpAniSirGlobal pMac, tANI_U8 channelId, tSirBssDescription *pSirBssDesc )
5162{
5163 tANI_BOOLEAN fMatch = TRUE;
5164
5165 do
5166 {
5167 // if the profile says Any channel AND the global settings says ANY channel, then we
5168 // always match...
5169 if ( eCSR_OPERATING_CHANNEL_ANY == channelId ) break;
5170
5171 if ( eCSR_OPERATING_CHANNEL_ANY != channelId )
5172 {
5173 fMatch = csrIsSpecificChannelMatch( pMac, pSirBssDesc, channelId );
5174 }
5175
5176 } while( 0 );
5177
5178 return( fMatch );
5179}
5180
5181
5182/**
5183 * \brief Enquire as to whether a given rate is supported by the
5184 * adapter as currently configured
5185 *
5186 *
5187 * \param nRate A rate in units of 500kbps
5188 *
5189 * \return TRUE if the adapter is currently capable of supporting this
5190 * rate, FALSE else
5191 *
5192 *
5193 * The rate encoding is just as in 802.11 Information Elements, except
5194 * that the high bit is \em not interpreted as indicating a Basic Rate,
5195 * and proprietary rates are allowed, too.
5196 *
5197 * Note that if the adapter's dot11Mode is g, we don't restrict the
5198 * rates. According to hwReadEepromParameters, this will happen when:
5199 *
5200 * ... the card is configured for ALL bands through the property
5201 * page. If this occurs, and the card is not an ABG card ,then this
5202 * code is setting the dot11Mode to assume the mode that the
5203 * hardware can support. For example, if the card is an 11BG card
5204 * and we are configured to support ALL bands, then we change the
5205 * dot11Mode to 11g because ALL in this case is only what the
5206 * hardware can support.
5207 *
5208 *
5209 */
5210
5211static tANI_BOOLEAN csrIsAggregateRateSupported( tpAniSirGlobal pMac, tANI_U16 rate )
5212{
5213 tANI_BOOLEAN fSupported = eANI_BOOLEAN_FALSE;
5214 tANI_U16 idx, newRate;
5215
5216 //In case basic rate flag is set
5217 newRate = BITS_OFF(rate, CSR_DOT11_BASIC_RATE_MASK);
5218 if ( eCSR_CFG_DOT11_MODE_11A == pMac->roam.configParam.uCfgDot11Mode )
5219 {
5220 switch ( newRate )
5221 {
5222 case eCsrSuppRate_6Mbps:
5223 case eCsrSuppRate_9Mbps:
5224 case eCsrSuppRate_12Mbps:
5225 case eCsrSuppRate_18Mbps:
5226 case eCsrSuppRate_24Mbps:
5227 case eCsrSuppRate_36Mbps:
5228 case eCsrSuppRate_48Mbps:
5229 case eCsrSuppRate_54Mbps:
5230 fSupported = TRUE;
5231 break;
5232 default:
5233 fSupported = FALSE;
5234 break;
5235 }
5236
5237 }
5238 else if( eCSR_CFG_DOT11_MODE_11B == pMac->roam.configParam.uCfgDot11Mode )
5239 {
5240 switch ( newRate )
5241 {
5242 case eCsrSuppRate_1Mbps:
5243 case eCsrSuppRate_2Mbps:
5244 case eCsrSuppRate_5_5Mbps:
5245 case eCsrSuppRate_11Mbps:
5246 fSupported = TRUE;
5247 break;
5248 default:
5249 fSupported = FALSE;
5250 break;
5251 }
5252 }
5253 else if ( !pMac->roam.configParam.ProprietaryRatesEnabled )
5254 {
5255
5256 switch ( newRate )
5257 {
5258 case eCsrSuppRate_1Mbps:
5259 case eCsrSuppRate_2Mbps:
5260 case eCsrSuppRate_5_5Mbps:
5261 case eCsrSuppRate_6Mbps:
5262 case eCsrSuppRate_9Mbps:
5263 case eCsrSuppRate_11Mbps:
5264 case eCsrSuppRate_12Mbps:
5265 case eCsrSuppRate_18Mbps:
5266 case eCsrSuppRate_24Mbps:
5267 case eCsrSuppRate_36Mbps:
5268 case eCsrSuppRate_48Mbps:
5269 case eCsrSuppRate_54Mbps:
5270 fSupported = TRUE;
5271 break;
5272 default:
5273 fSupported = FALSE;
5274 break;
5275 }
5276
5277 }
5278 else {
5279
5280 if ( eCsrSuppRate_1Mbps == newRate ||
5281 eCsrSuppRate_2Mbps == newRate ||
5282 eCsrSuppRate_5_5Mbps == newRate ||
5283 eCsrSuppRate_11Mbps == newRate )
5284 {
5285 fSupported = TRUE;
5286 }
5287 else {
5288 idx = 0x1;
5289
5290 switch ( newRate )
5291 {
5292 case eCsrSuppRate_6Mbps:
5293 fSupported = gPhyRatesSuppt[0][idx];
5294 break;
5295 case eCsrSuppRate_9Mbps:
5296 fSupported = gPhyRatesSuppt[1][idx];
5297 break;
5298 case eCsrSuppRate_12Mbps:
5299 fSupported = gPhyRatesSuppt[2][idx];
5300 break;
5301 case eCsrSuppRate_18Mbps:
5302 fSupported = gPhyRatesSuppt[3][idx];
5303 break;
5304 case eCsrSuppRate_20Mbps:
5305 fSupported = gPhyRatesSuppt[4][idx];
5306 break;
5307 case eCsrSuppRate_24Mbps:
5308 fSupported = gPhyRatesSuppt[5][idx];
5309 break;
5310 case eCsrSuppRate_36Mbps:
5311 fSupported = gPhyRatesSuppt[6][idx];
5312 break;
5313 case eCsrSuppRate_40Mbps:
5314 fSupported = gPhyRatesSuppt[7][idx];
5315 break;
5316 case eCsrSuppRate_42Mbps:
5317 fSupported = gPhyRatesSuppt[8][idx];
5318 break;
5319 case eCsrSuppRate_48Mbps:
5320 fSupported = gPhyRatesSuppt[9][idx];
5321 break;
5322 case eCsrSuppRate_54Mbps:
5323 fSupported = gPhyRatesSuppt[10][idx];
5324 break;
5325 case eCsrSuppRate_72Mbps:
5326 fSupported = gPhyRatesSuppt[11][idx];
5327 break;
5328 case eCsrSuppRate_80Mbps:
5329 fSupported = gPhyRatesSuppt[12][idx];
5330 break;
5331 case eCsrSuppRate_84Mbps:
5332 fSupported = gPhyRatesSuppt[13][idx];
5333 break;
5334 case eCsrSuppRate_96Mbps:
5335 fSupported = gPhyRatesSuppt[14][idx];
5336 break;
5337 case eCsrSuppRate_108Mbps:
5338 fSupported = gPhyRatesSuppt[15][idx];
5339 break;
5340 case eCsrSuppRate_120Mbps:
5341 fSupported = gPhyRatesSuppt[16][idx];
5342 break;
5343 case eCsrSuppRate_126Mbps:
5344 fSupported = gPhyRatesSuppt[17][idx];
5345 break;
5346 case eCsrSuppRate_144Mbps:
5347 fSupported = gPhyRatesSuppt[18][idx];
5348 break;
5349 case eCsrSuppRate_160Mbps:
5350 fSupported = gPhyRatesSuppt[19][idx];
5351 break;
5352 case eCsrSuppRate_168Mbps:
5353 fSupported = gPhyRatesSuppt[20][idx];
5354 break;
5355 case eCsrSuppRate_192Mbps:
5356 fSupported = gPhyRatesSuppt[21][idx];
5357 break;
5358 case eCsrSuppRate_216Mbps:
5359 fSupported = gPhyRatesSuppt[22][idx];
5360 break;
5361 case eCsrSuppRate_240Mbps:
5362 fSupported = gPhyRatesSuppt[23][idx];
5363 break;
5364 default:
5365 fSupported = FALSE;
5366 break;
5367 }
5368 }
5369 }
5370
5371 return fSupported;
5372}
5373
5374
5375
5376static tANI_BOOLEAN csrIsRateSetMatch( tpAniSirGlobal pMac,
5377 tDot11fIESuppRates *pBssSuppRates,
5378 tDot11fIEExtSuppRates *pBssExtSuppRates )
5379{
5380 tANI_BOOLEAN fMatch = TRUE;
5381 tANI_U32 i;
5382
5383
5384 // Validate that all of the Basic rates advertised in the Bss description are supported.
5385 if ( pBssSuppRates )
5386 {
5387 for( i = 0; i < pBssSuppRates->num_rates; i++ )
5388 {
5389 if ( CSR_IS_BASIC_RATE( pBssSuppRates->rates[ i ] ) )
5390 {
5391 if ( !csrIsAggregateRateSupported( pMac, pBssSuppRates->rates[ i ] ) )
5392 {
5393 fMatch = FALSE;
5394 break;
5395 }
5396 }
5397 }
5398 }
5399
5400 if ( fMatch && pBssExtSuppRates )
5401 {
5402 for( i = 0; i < pBssExtSuppRates->num_rates; i++ )
5403 {
5404 if ( CSR_IS_BASIC_RATE( pBssExtSuppRates->rates[ i ] ) )
5405 {
5406 if ( !csrIsAggregateRateSupported( pMac, pBssExtSuppRates->rates[ i ] ) )
5407 {
5408 fMatch = FALSE;
5409 break;
5410 }
5411 }
5412 }
5413 }
5414
5415 return( fMatch );
5416
5417}
5418
5419
5420//ppIes can be NULL. If caller want to get the *ppIes allocated by this function, pass in *ppIes = NULL
5421tANI_BOOLEAN csrMatchBSS( tHalHandle hHal, tSirBssDescription *pBssDesc, tCsrScanResultFilter *pFilter,
5422 eCsrAuthType *pNegAuth, eCsrEncryptionType *pNegUc, eCsrEncryptionType *pNegMc,
5423 tDot11fBeaconIEs **ppIes)
5424{
5425 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5426 tANI_BOOLEAN fRC = eANI_BOOLEAN_FALSE, fCheck;
5427 tANI_U32 i;
5428 tDot11fBeaconIEs *pIes = NULL;
5429 tANI_U8 *pb;
5430
5431 do {
5432 if( ( NULL == ppIes ) || ( *ppIes ) == NULL )
5433 {
5434 //If no IEs passed in, get our own.
5435 if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pBssDesc, &pIes)))
5436 {
5437 break;
5438 }
5439 }
5440 else
5441 {
5442 //Save the one pass in for local use
5443 pIes = *ppIes;
5444 }
5445
5446 //Check if caller wants P2P
5447 fCheck = (!pFilter->p2pResult || pIes->P2PBeaconProbeRes.present);
5448 if(!fCheck) break;
5449
5450 if(pIes->SSID.present)
5451 {
5452 for(i = 0; i < pFilter->SSIDs.numOfSSIDs; i++)
5453 {
5454 fCheck = csrIsSsidMatch( pMac, pFilter->SSIDs.SSIDList[i].SSID.ssId, pFilter->SSIDs.SSIDList[i].SSID.length,
5455 pIes->SSID.ssid,
5456 pIes->SSID.num_ssid, eANI_BOOLEAN_TRUE );
5457 if ( fCheck ) break;
5458 }
5459 if(!fCheck) break;
5460 }
5461 fCheck = eANI_BOOLEAN_TRUE;
5462 for(i = 0; i < pFilter->BSSIDs.numOfBSSIDs; i++)
5463 {
5464 fCheck = csrIsBssidMatch( pMac, (tCsrBssid *)&pFilter->BSSIDs.bssid[i], (tCsrBssid *)pBssDesc->bssId );
5465 if ( fCheck ) break;
5466
5467 if (pFilter->p2pResult && pIes->P2PBeaconProbeRes.present)
5468 {
5469 fCheck = csrIsBssidMatch( pMac, (tCsrBssid *)&pFilter->BSSIDs.bssid[i],
5470 (tCsrBssid *)pIes->P2PBeaconProbeRes.P2PDeviceInfo.P2PDeviceAddress );
5471
5472 if ( fCheck ) break;
5473 }
5474 }
5475 if(!fCheck) break;
5476
5477 fCheck = eANI_BOOLEAN_TRUE;
5478 for(i = 0; i < pFilter->ChannelInfo.numOfChannels; i++)
5479 {
5480 fCheck = csrIsChannelBandMatch( pMac, pFilter->ChannelInfo.ChannelList[i], pBssDesc );
5481 if ( fCheck ) break;
5482 }
5483 if(!fCheck)
5484 break;
5485#if defined WLAN_FEATURE_VOWIFI
5486 /* If this is for measurement filtering */
5487 if( pFilter->fMeasurement )
5488 {
5489 fRC = eANI_BOOLEAN_TRUE;
5490 break;
5491 }
5492#endif
5493 if ( !csrIsPhyModeMatch( pMac, pFilter->phyMode, pBssDesc, NULL, NULL, pIes ) ) break;
5494 if ( (!pFilter->bWPSAssociation) &&
5495 !csrIsSecurityMatch( pMac, &pFilter->authType, &pFilter->EncryptionType, &pFilter->mcEncryptionType,
5496 pBssDesc, pIes, pNegAuth, pNegUc, pNegMc ) ) break;
5497 if ( !csrIsCapabilitiesMatch( pMac, pFilter->BSSType, pBssDesc ) ) break;
5498 if ( !csrIsRateSetMatch( pMac, &pIes->SuppRates, &pIes->ExtSuppRates ) ) break;
5499 //Tush-QoS: validate first if asked for APSD or WMM association
5500 if ( (eCsrRoamWmmQbssOnly == pMac->roam.configParam.WMMSupportMode) &&
5501 !CSR_IS_QOS_BSS(pIes) )
5502 break;
5503 //Check country. check even when pb is NULL because we may want to make sure
5504 //AP has a country code in it if fEnforceCountryCodeMatch is set.
5505 pb = ( pFilter->countryCode[0] ) ? ( pFilter->countryCode) : NULL;
5506
5507 fCheck = csrMatchCountryCode( pMac, pb, pIes );
5508 if(!fCheck)
5509 break;
5510
5511#ifdef WLAN_FEATURE_VOWIFI_11R
5512 if (pFilter->MDID.mdiePresent)
5513 {
5514 if (pBssDesc->mdiePresent)
5515 {
5516 if (pFilter->MDID.mobilityDomain != (pBssDesc->mdie[1] << 8 | pBssDesc->mdie[0]))
5517 break;
5518 }
5519 else
5520 break;
5521 }
5522#endif
5523 fRC = eANI_BOOLEAN_TRUE;
5524
5525 } while( 0 );
5526 if( ppIes )
5527 {
5528 *ppIes = pIes;
5529 }
5530 else if( pIes )
5531 {
5532 palFreeMemory(pMac->hHdd, pIes);
5533 }
5534
5535 return( fRC );
5536}
5537
5538tANI_BOOLEAN csrMatchConnectedBSSSecurity( tpAniSirGlobal pMac, tCsrRoamConnectedProfile *pProfile,
5539 tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIes)
5540{
5541 tCsrEncryptionList ucEncryptionList, mcEncryptionList;
5542 tCsrAuthList authList;
5543
5544 ucEncryptionList.numEntries = 1;
5545 ucEncryptionList.encryptionType[0] = pProfile->EncryptionType;
5546
5547 mcEncryptionList.numEntries = 1;
5548 mcEncryptionList.encryptionType[0] = pProfile->mcEncryptionType;
5549
5550 authList.numEntries = 1;
5551 authList.authType[0] = pProfile->AuthType;
5552
5553 return( csrIsSecurityMatch( pMac, &authList, &ucEncryptionList, &mcEncryptionList, pBssDesc, pIes, NULL, NULL, NULL ));
5554
5555}
5556
5557
5558tANI_BOOLEAN csrMatchBSSToConnectProfile( tHalHandle hHal, tCsrRoamConnectedProfile *pProfile,
5559 tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIes )
5560{
5561 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5562 tANI_BOOLEAN fRC = eANI_BOOLEAN_FALSE, fCheck;
5563 tDot11fBeaconIEs *pIesLocal = pIes;
5564
5565 do {
5566 if( !pIes )
5567 {
5568 if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pBssDesc, &pIesLocal)))
5569 {
5570 break;
5571 }
5572 }
5573 fCheck = eANI_BOOLEAN_TRUE;
5574 if(pIesLocal->SSID.present)
5575 {
5576 tANI_BOOLEAN fCheckSsid = eANI_BOOLEAN_FALSE;
5577 if(pProfile->SSID.length)
5578 {
5579 fCheckSsid = eANI_BOOLEAN_TRUE;
5580 }
5581 fCheck = csrIsSsidMatch( pMac, pProfile->SSID.ssId, pProfile->SSID.length,
5582 pIesLocal->SSID.ssid, pIesLocal->SSID.num_ssid, fCheckSsid );
5583 if(!fCheck) break;
5584 }
5585 if ( !csrMatchConnectedBSSSecurity( pMac, pProfile, pBssDesc, pIesLocal) ) break;
5586 if ( !csrIsCapabilitiesMatch( pMac, pProfile->BSSType, pBssDesc ) ) break;
5587 if ( !csrIsRateSetMatch( pMac, &pIesLocal->SuppRates, &pIesLocal->ExtSuppRates ) ) break;
5588 fCheck = csrIsChannelBandMatch( pMac, pProfile->operationChannel, pBssDesc );
5589 if(!fCheck)
5590 break;
5591
5592 fRC = eANI_BOOLEAN_TRUE;
5593
5594 } while( 0 );
5595
5596 if( !pIes && pIesLocal )
5597 {
5598 //locally allocated
5599 palFreeMemory(pMac->hHdd, pIesLocal);
5600 }
5601
5602 return( fRC );
5603}
5604
5605
5606
5607tANI_BOOLEAN csrRatesIsDot11RateSupported( tHalHandle hHal, tANI_U8 rate )
5608{
5609 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5610 tANI_U16 n = BITS_OFF( rate, CSR_DOT11_BASIC_RATE_MASK );
5611
5612 return csrIsAggregateRateSupported( pMac, n );
5613}
5614
5615
5616tANI_U16 csrRatesMacPropToDot11( tANI_U16 Rate )
5617{
5618 tANI_U16 ConvertedRate = Rate;
5619
5620 switch( Rate )
5621 {
5622 case SIR_MAC_RATE_1:
5623 ConvertedRate = 2;
5624 break;
5625 case SIR_MAC_RATE_2:
5626 ConvertedRate = 4;
5627 break;
5628 case SIR_MAC_RATE_5_5:
5629 ConvertedRate = 11;
5630 break;
5631 case SIR_MAC_RATE_11:
5632 ConvertedRate = 22;
5633 break;
5634
5635 case SIR_MAC_RATE_6:
5636 ConvertedRate = 12;
5637 break;
5638 case SIR_MAC_RATE_9:
5639 ConvertedRate = 18;
5640 break;
5641 case SIR_MAC_RATE_12:
5642 ConvertedRate = 24;
5643 break;
5644 case SIR_MAC_RATE_18:
5645 ConvertedRate = 36;
5646 break;
5647 case SIR_MAC_RATE_24:
5648 ConvertedRate = 48;
5649 break;
5650 case SIR_MAC_RATE_36:
5651 ConvertedRate = 72;
5652 break;
5653 case SIR_MAC_RATE_42:
5654 ConvertedRate = 84;
5655 break;
5656 case SIR_MAC_RATE_48:
5657 ConvertedRate = 96;
5658 break;
5659 case SIR_MAC_RATE_54:
5660 ConvertedRate = 108;
5661 break;
5662
5663 case SIR_MAC_RATE_72:
5664 ConvertedRate = 144;
5665 break;
5666 case SIR_MAC_RATE_84:
5667 ConvertedRate = 168;
5668 break;
5669 case SIR_MAC_RATE_96:
5670 ConvertedRate = 192;
5671 break;
5672 case SIR_MAC_RATE_108:
5673 ConvertedRate = 216;
5674 break;
5675 case SIR_MAC_RATE_126:
5676 ConvertedRate = 252;
5677 break;
5678 case SIR_MAC_RATE_144:
5679 ConvertedRate = 288;
5680 break;
5681 case SIR_MAC_RATE_168:
5682 ConvertedRate = 336;
5683 break;
5684 case SIR_MAC_RATE_192:
5685 ConvertedRate = 384;
5686 break;
5687 case SIR_MAC_RATE_216:
5688 ConvertedRate = 432;
5689 break;
5690 case SIR_MAC_RATE_240:
5691 ConvertedRate = 480;
5692 break;
5693
5694 case 0xff:
5695 ConvertedRate = 0;
5696 break;
5697 }
5698
5699 return ConvertedRate;
5700}
5701
5702
5703tANI_U16 csrRatesFindBestRate( tSirMacRateSet *pSuppRates, tSirMacRateSet *pExtRates, tSirMacPropRateSet *pPropRates )
5704{
5705 tANI_U8 i;
5706 tANI_U16 nBest;
5707
5708 nBest = pSuppRates->rate[ 0 ] & ( ~CSR_DOT11_BASIC_RATE_MASK );
5709
5710 if(pSuppRates->numRates > SIR_MAC_RATESET_EID_MAX)
5711 {
5712 pSuppRates->numRates = SIR_MAC_RATESET_EID_MAX;
5713 }
5714
5715 for ( i = 1U; i < pSuppRates->numRates; ++i )
5716 {
5717 nBest = (tANI_U16)CSR_MAX( nBest, pSuppRates->rate[ i ] & ( ~CSR_DOT11_BASIC_RATE_MASK ) );
5718 }
5719
5720 if ( NULL != pExtRates )
5721 {
5722 for ( i = 0U; i < pExtRates->numRates; ++i )
5723 {
5724 nBest = (tANI_U16)CSR_MAX( nBest, pExtRates->rate[ i ] & ( ~CSR_DOT11_BASIC_RATE_MASK ) );
5725 }
5726 }
5727
5728 if ( NULL != pPropRates )
5729 {
5730 for ( i = 0U; i < pPropRates->numPropRates; ++i )
5731 {
5732 nBest = (tANI_U16)CSR_MAX( nBest, csrRatesMacPropToDot11( pPropRates->propRate[ i ] ) );
5733 }
5734 }
5735
5736 return nBest;
5737}
5738
5739
5740void csrReleaseProfile(tpAniSirGlobal pMac, tCsrRoamProfile *pProfile)
5741{
5742 if(pProfile)
5743 {
5744 if(pProfile->BSSIDs.bssid)
5745 {
5746 palFreeMemory(pMac->hHdd, pProfile->BSSIDs.bssid);
5747 pProfile->BSSIDs.bssid = NULL;
5748 }
5749 if(pProfile->SSIDs.SSIDList)
5750 {
5751 palFreeMemory(pMac->hHdd, pProfile->SSIDs.SSIDList);
5752 pProfile->SSIDs.SSIDList = NULL;
5753 }
5754 if(pProfile->pWPAReqIE)
5755 {
5756 palFreeMemory(pMac->hHdd, pProfile->pWPAReqIE);
5757 pProfile->pWPAReqIE = NULL;
5758 }
5759 if(pProfile->pRSNReqIE)
5760 {
5761 palFreeMemory(pMac->hHdd, pProfile->pRSNReqIE);
5762 pProfile->pRSNReqIE = NULL;
5763 }
5764#ifdef FEATURE_WLAN_WAPI
5765 if(pProfile->pWAPIReqIE)
5766 {
5767 palFreeMemory(pMac->hHdd, pProfile->pWAPIReqIE);
5768 pProfile->pWAPIReqIE = NULL;
5769 }
5770#endif /* FEATURE_WLAN_WAPI */
5771
5772 if(pProfile->pAddIEScan)
5773 {
5774 palFreeMemory(pMac->hHdd, pProfile->pAddIEScan);
5775 pProfile->pAddIEScan = NULL;
5776 }
5777
5778 if(pProfile->pAddIEAssoc)
5779 {
5780 palFreeMemory(pMac->hHdd, pProfile->pAddIEAssoc);
5781 pProfile->pAddIEAssoc = NULL;
5782 }
5783 {
5784 palFreeMemory(pMac->hHdd, pProfile->pAddIEAssoc);
5785 pProfile->pAddIEAssoc = NULL;
5786 }
5787
5788 if(pProfile->ChannelInfo.ChannelList)
5789 {
5790 palFreeMemory(pMac->hHdd, pProfile->ChannelInfo.ChannelList);
5791 pProfile->ChannelInfo.ChannelList = NULL;
5792 }
5793
5794
5795 palZeroMemory(pMac->hHdd, pProfile, sizeof(tCsrRoamProfile));
5796 }
5797}
5798
5799void csrFreeScanFilter(tpAniSirGlobal pMac, tCsrScanResultFilter *pScanFilter)
5800{
5801 if(pScanFilter->BSSIDs.bssid)
5802 {
5803 palFreeMemory(pMac->hHdd, pScanFilter->BSSIDs.bssid);
5804 pScanFilter->BSSIDs.bssid = NULL;
5805 }
5806 if(pScanFilter->ChannelInfo.ChannelList)
5807 {
5808 palFreeMemory(pMac->hHdd, pScanFilter->ChannelInfo.ChannelList);
5809 pScanFilter->ChannelInfo.ChannelList = NULL;
5810 }
5811 if(pScanFilter->SSIDs.SSIDList)
5812 {
5813 palFreeMemory(pMac->hHdd, pScanFilter->SSIDs.SSIDList);
5814 pScanFilter->SSIDs.SSIDList = NULL;
5815 }
5816}
5817
5818
5819void csrFreeRoamProfile(tpAniSirGlobal pMac, tANI_U32 sessionId)
5820{
5821 tCsrRoamSession *pSession = &pMac->roam.roamSession[sessionId];
5822
5823 if(pSession->pCurRoamProfile)
5824 {
5825 csrReleaseProfile(pMac, pSession->pCurRoamProfile);
5826 palFreeMemory(pMac->hHdd, pSession->pCurRoamProfile);
5827 pSession->pCurRoamProfile = NULL;
5828 }
5829}
5830
5831
5832void csrFreeConnectBssDesc(tpAniSirGlobal pMac, tANI_U32 sessionId)
5833{
5834 tCsrRoamSession *pSession = &pMac->roam.roamSession[sessionId];
5835
5836 if(pSession->pConnectBssDesc)
5837 {
5838 palFreeMemory(pMac->hHdd, pSession->pConnectBssDesc);
5839 pSession->pConnectBssDesc = NULL;
5840 }
5841}
5842
5843
5844
5845tSirResultCodes csrGetDisassocRspStatusCode( tSirSmeDisassocRsp *pSmeDisassocRsp )
5846{
5847 tANI_U8 *pBuffer = (tANI_U8 *)pSmeDisassocRsp;
5848 tANI_U32 ret;
5849
5850 pBuffer += (sizeof(tANI_U16) + sizeof(tANI_U16) + sizeof(tSirMacAddr));
5851 //tSirResultCodes is an enum, assuming is 32bit
5852 //If we cannot make this assumption, use copymemory
5853 pal_get_U32( pBuffer, &ret );
5854
5855 return( ( tSirResultCodes )ret );
5856}
5857
5858
5859tSirResultCodes csrGetDeAuthRspStatusCode( tSirSmeDeauthRsp *pSmeRsp )
5860{
5861 tANI_U8 *pBuffer = (tANI_U8 *)pSmeRsp;
5862 tANI_U32 ret;
5863
5864 pBuffer += (sizeof(tANI_U16) + sizeof(tANI_U16) + sizeof(tSirMacAddr));
5865 //tSirResultCodes is an enum, assuming is 32bit
5866 //If we cannot make this assumption, use copymemory
5867 pal_get_U32( pBuffer, &ret );
5868
5869 return( ( tSirResultCodes )ret );
5870}
5871
5872#if 0
5873tSirScanType csrGetScanType(tANI_U8 chnId, eRegDomainId domainId, tANI_U8 *countryCode)
5874{
5875 tSirScanType scanType = eSIR_PASSIVE_SCAN;
5876 tANI_U8 cc = 0;
5877
5878 while (cc++ < gCsrDomainChnInfo[domainId].numChannels)
5879 {
5880 if(chnId == gCsrDomainChnInfo[domainId].chnInfo[cc].chnId)
5881 {
5882 scanType = gCsrDomainChnInfo[domainId].chnInfo[cc].scanType;
5883 break;
5884 }
5885 }
5886
5887 return (scanType);
5888}
5889#endif
5890
5891tSirScanType csrGetScanType(tpAniSirGlobal pMac, tANI_U8 chnId)
5892{
5893 tSirScanType scanType = eSIR_PASSIVE_SCAN;
5894 eNVChannelEnabledType channelEnabledType;
5895
5896 channelEnabledType = vos_nv_getChannelEnabledState(chnId);
5897 if( NV_CHANNEL_ENABLE == channelEnabledType)
5898 {
5899 scanType = eSIR_ACTIVE_SCAN;
5900 }
5901 return (scanType);
5902}
5903
5904
5905tANI_U8 csrToUpper( tANI_U8 ch )
5906{
5907 tANI_U8 chOut;
5908
5909 if ( ch >= 'a' && ch <= 'z' )
5910 {
5911 chOut = ch - 'a' + 'A';
5912 }
5913 else
5914 {
5915 chOut = ch;
5916 }
5917 return( chOut );
5918}
5919
5920
5921tSirBssType csrTranslateBsstypeToMacType(eCsrRoamBssType csrtype)
5922{
5923 tSirBssType ret;
5924
5925 switch(csrtype)
5926 {
5927 case eCSR_BSS_TYPE_INFRASTRUCTURE:
5928 ret = eSIR_INFRASTRUCTURE_MODE;
5929 break;
5930 case eCSR_BSS_TYPE_IBSS:
5931 case eCSR_BSS_TYPE_START_IBSS:
5932 ret = eSIR_IBSS_MODE;
5933 break;
5934 case eCSR_BSS_TYPE_WDS_AP:
5935 ret = eSIR_BTAMP_AP_MODE;
5936 break;
5937 case eCSR_BSS_TYPE_WDS_STA:
5938 ret = eSIR_BTAMP_STA_MODE;
5939 break;
5940#ifdef WLAN_SOFTAP_FEATURE
5941 case eCSR_BSS_TYPE_INFRA_AP:
5942 ret = eSIR_INFRA_AP_MODE;
5943 break;
5944#endif
5945 case eCSR_BSS_TYPE_ANY:
5946 default:
5947 ret = eSIR_AUTO_MODE;
5948 break;
5949 }
5950
5951 return (ret);
5952}
5953
5954
5955//This function use the parameters to decide the CFG value.
5956//CSR never sets WNI_CFG_DOT11_MODE_ALL to the CFG
5957//So PE should not see WNI_CFG_DOT11_MODE_ALL when it gets the CFG value
5958#ifdef WLAN_SOFTAP_FEATURE
5959eCsrCfgDot11Mode csrGetCfgDot11ModeFromCsrPhyMode(tCsrRoamProfile *pProfile, eCsrPhyMode phyMode, tANI_BOOLEAN fProprietary)
5960#else
5961eCsrCfgDot11Mode csrGetCfgDot11ModeFromCsrPhyMode(eCsrPhyMode phyMode, tANI_BOOLEAN fProprietary)
5962#endif
5963{
5964 tANI_U32 cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG;
5965
5966 switch(phyMode)
5967 {
5968 case eCSR_DOT11_MODE_11a:
5969 case eCSR_DOT11_MODE_11a_ONLY:
5970 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
5971 break;
5972 case eCSR_DOT11_MODE_11b:
5973 case eCSR_DOT11_MODE_11b_ONLY:
5974 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
5975 break;
5976 case eCSR_DOT11_MODE_11g:
5977 case eCSR_DOT11_MODE_11g_ONLY:
5978#ifdef WLAN_SOFTAP_FEATURE
5979 if(pProfile && (CSR_IS_INFRA_AP(pProfile)) && (phyMode == eCSR_DOT11_MODE_11g_ONLY))
5980 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G_ONLY;
5981 else
5982#endif
5983 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
5984 break;
5985 case eCSR_DOT11_MODE_11n:
5986 if(fProprietary)
5987 {
5988 cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
5989 }
5990 else
5991 {
5992 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
5993 }
5994 break;
5995 case eCSR_DOT11_MODE_11n_ONLY:
5996#ifdef WLAN_SOFTAP_FEATURE
5997 if(pProfile && CSR_IS_INFRA_AP(pProfile))
5998 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N_ONLY;
5999 else
6000#endif
6001 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
6002 break;
6003 case eCSR_DOT11_MODE_TAURUS:
6004 cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
6005 break;
6006 case eCSR_DOT11_MODE_abg:
6007 cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG;
6008 break;
6009 case eCSR_DOT11_MODE_AUTO:
6010 cfgDot11Mode = eCSR_CFG_DOT11_MODE_AUTO;
6011 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6012
6013#ifdef WLAN_FEATURE_11AC
6014 case eCSR_DOT11_MODE_11ac:
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6015 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC))
6016 {
6017 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
6018 }
6019 else
6020 {
6021 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
6022 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6023 break;
6024 case eCSR_DOT11_MODE_11ac_ONLY:
6025 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC_ONLY;
6026 break;
6027#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6028 default:
6029 //No need to assign anything here
6030 break;
6031 }
6032
6033 return (cfgDot11Mode);
6034}
6035
6036
6037eHalStatus csrSetRegulatoryDomain(tpAniSirGlobal pMac, v_REGDOMAIN_t domainId, tANI_BOOLEAN *pfRestartNeeded)
6038{
6039 eHalStatus status = eHAL_STATUS_SUCCESS;
6040 tANI_BOOLEAN fRestart;
6041
6042 if(pMac->scan.domainIdCurrent == domainId)
6043 {
6044 //no change
6045 fRestart = eANI_BOOLEAN_FALSE;
6046 }
6047 else if( !pMac->roam.configParam.fEnforceDefaultDomain )
6048 {
6049 pMac->scan.domainIdCurrent = domainId;
6050 fRestart = eANI_BOOLEAN_TRUE;
6051 }
6052 else
6053 {
6054 //We cannot change the domain
6055 status = eHAL_STATUS_CSR_WRONG_STATE;
6056 fRestart = eANI_BOOLEAN_FALSE;
6057 }
6058 if(pfRestartNeeded)
6059 {
6060 *pfRestartNeeded = fRestart;
6061 }
6062
6063 return (status);
6064}
6065
6066
6067v_REGDOMAIN_t csrGetCurrentRegulatoryDomain(tpAniSirGlobal pMac)
6068{
6069 return (pMac->scan.domainIdCurrent);
6070}
6071
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6072
6073eHalStatus csrGetRegulatoryDomainForCountry(tpAniSirGlobal pMac, tANI_U8 *pCountry, v_REGDOMAIN_t *pDomainId)
6074{
6075 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
6076 VOS_STATUS vosStatus;
6077 v_COUNTRYCODE_t countryCode;
6078 v_REGDOMAIN_t domainId;
6079
6080 if(pCountry)
6081 {
6082 countryCode[0] = pCountry[0];
6083 countryCode[1] = pCountry[1];
6084 vosStatus = vos_nv_getRegDomainFromCountryCode( &domainId, countryCode );
6085 if( VOS_IS_STATUS_SUCCESS(vosStatus) )
6086 {
6087 if( pDomainId )
6088 {
6089 *pDomainId = domainId;
6090 }
6091 status = eHAL_STATUS_SUCCESS;
6092 }
6093 else
6094 {
6095 smsLog(pMac, LOGW, FL(" doesn't match country %c%c\n"), pCountry[0], pCountry[1]);
6096 status = eHAL_STATUS_INVALID_PARAMETER;
6097 }
6098 }
6099
6100 return (status);
6101}
6102
6103//To check whether a country code matches the one in the IE
6104//Only check the first two characters, ignoring in/outdoor
6105//pCountry -- caller allocated buffer contain the country code that is checking against
6106//the one in pIes. It can be NULL.
6107//caller must provide pIes, it cannot be NULL
6108//This function always return TRUE if 11d support is not turned on.
6109tANI_BOOLEAN csrMatchCountryCode( tpAniSirGlobal pMac, tANI_U8 *pCountry, tDot11fBeaconIEs *pIes )
6110{
6111 tANI_BOOLEAN fRet = eANI_BOOLEAN_TRUE;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6112 v_REGDOMAIN_t domainId = REGDOMAIN_COUNT; //This is init to invalid value
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6113 eHalStatus status;
6114
6115 do
6116 {
6117 if( !csrIs11dSupported( pMac) )
6118 {
6119 break;
6120 }
6121 if( !pIes )
6122 {
6123 smsLog(pMac, LOGE, FL(" No IEs\n"));
6124 break;
6125 }
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6126 if( pMac->roam.configParam.fEnforceDefaultDomain ||
6127 pMac->roam.configParam.fEnforceCountryCodeMatch )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6128 {
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6129 //Make sure this country is recognizable
6130 if( pIes->Country.present )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6131 {
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6132 status = csrGetRegulatoryDomainForCountry( pMac, pIes->Country.country, &domainId );
6133 if( !HAL_STATUS_SUCCESS( status ) )
6134 {
Gowri Deepthiff9adf92012-12-13 15:09:56 -0800[diff] [blame]6135 status = csrGetRegulatoryDomainForCountry( pMac, pMac->scan.countryCode11d,(v_REGDOMAIN_t *) &domainId );
6136 if( !HAL_STATUS_SUCCESS( status ) )
6137 {
6138 fRet = eANI_BOOLEAN_FALSE;
6139 break;
6140 }
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6141 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6142 }
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6143 //check whether it is needed to enforce to the default regulatory domain first
6144 if( pMac->roam.configParam.fEnforceDefaultDomain )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6145 {
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6146 if( domainId != pMac->scan.domainIdCurrent )
6147 {
6148 fRet = eANI_BOOLEAN_FALSE;
6149 break;
6150 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6151 }
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6152 if( pMac->roam.configParam.fEnforceCountryCodeMatch )
6153 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6154 if( domainId >= REGDOMAIN_COUNT )
Madan Mohan Koyyalamudi42af1782012-10-21 12:13:23 -0700[diff] [blame]6155 {
6156 fRet = eANI_BOOLEAN_FALSE;
6157 break;
6158 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6159 }
6160 }
6161 if( pCountry )
6162 {
6163 tANI_U32 i;
6164
6165 if( !pIes->Country.present )
6166 {
6167 fRet = eANI_BOOLEAN_FALSE;
6168 break;
6169 }
6170 // Convert the CountryCode characters to upper
6171 for ( i = 0; i < WNI_CFG_COUNTRY_CODE_LEN - 1; i++ )
6172 {
6173 pCountry[i] = csrToUpper( pCountry[i] );
6174 }
6175 if( !palEqualMemory(pMac->hHdd, pIes->Country.country, pCountry, WNI_CFG_COUNTRY_CODE_LEN - 1) )
6176 {
6177 fRet = eANI_BOOLEAN_FALSE;
6178 break;
6179 }
6180 }
6181 } while(0);
6182
6183 return (fRet);
6184}
6185
6186#if 0
6187eHalStatus csrSetCountryDomainMapping(tpAniSirGlobal pMac, tCsrCountryDomainMapping *pCountryDomainMapping)
6188{
6189 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
6190 tANI_U32 i, j;
6191 tANI_BOOLEAN fDomainChanged = eANI_BOOLEAN_FALSE;
6192 tANI_U8 countryCode[WNI_CFG_COUNTRY_CODE_LEN];
6193
6194 i = WNI_CFG_COUNTRY_CODE_LEN;
6195 //Get the currently used country code
6196 status = ccmCfgGetStr(pMac, WNI_CFG_COUNTRY_CODE, countryCode, &i);
6197 if(HAL_STATUS_SUCCESS(status))
6198 {
6199 if(pCountryDomainMapping && pCountryDomainMapping->numEntry)
6200 {
6201 for(i = 0; i < pCountryDomainMapping->numEntry; i++)
6202 {
6203 for(j = 0; j < eCSR_NUM_COUNTRY_INDEX; j++)
6204 {
6205 if(palEqualMemory(pMac->hHdd, gCsrCountryInfo[j].countryCode,
6206 pCountryDomainMapping->pCountryInfo[i].countryCode, 2))
6207 {
6208 if(gCsrCountryInfo[j].domainId != pCountryDomainMapping->pCountryInfo[i].domainId)
6209 {
6210 gCsrCountryInfo[j].domainId = pCountryDomainMapping->pCountryInfo[i].domainId;
6211 //Check whether it matches the currently used country code
6212 //If matching, need to update base on the new domain setting.
6213 if(palEqualMemory(pMac->hHdd, countryCode,
6214 pCountryDomainMapping->pCountryInfo[i].countryCode, 2))
6215 {
6216 fDomainChanged = eANI_BOOLEAN_TRUE;
6217 }
6218 }
6219 break;
6220 }
6221 }
6222 }
6223 status = eHAL_STATUS_SUCCESS;
6224 if(fDomainChanged)
6225 {
6226 tCsrChannel *pChannelList;
6227
6228 if(pMac->scan.f11dInfoApplied)
6229 {
6230 //11d info already applied. Let's reapply with the new domain setting
6231 if(pMac->scan.channels11d.numChannels)
6232 {
6233 pChannelList = &pMac->scan.channels11d;
6234 }
6235 else
6236 {
6237 pChannelList = &pMac->scan.base20MHzChannels;
6238 }
6239 }
6240 else
6241 {
6242 //no 11d so we use the base channelist from EEPROM
6243 pChannelList = &pMac->scan.base20MHzChannels;
6244 }
6245 //set the new domain's scan requirement to CFG
6246 csrSetCfgScanControlList(pMac, countryCode, pChannelList);
6247 }
6248 }
6249 }
6250
6251 return (status);
6252}
6253
6254eHalStatus csrSetDomainScanSetting(tpAniSirGlobal pMac, tCsrDomainFreqInfo *pDomainFreqInfo)
6255{
6256 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
6257 tANI_U32 i, j;
6258 tANI_U16 freq;
6259
6260 if(pDomainFreqInfo && pDomainFreqInfo->numEntry && (pDomainFreqInfo->domainId < NUM_REG_DOMAINS))
6261 {
6262 tCsrDomainChnInfo *pDomainChnInfo = &gCsrDomainChnInfo[pDomainFreqInfo->domainId];
6263
6264 for(j = 0; j < pDomainChnInfo->numChannels; j++)
6265 {
6266 if(HAL_STATUS_SUCCESS(halPhyChIdToFreqConversion(pDomainChnInfo->chnInfo[j].chnId, &freq)))
6267 {
6268 for(i = 0; i < pDomainFreqInfo->numEntry; i++)
6269 {
6270 if((pDomainFreqInfo->pCsrScanFreqInfo[i].nStartFreq <= freq) &&
6271 (freq <= pDomainFreqInfo->pCsrScanFreqInfo[i].nEndFreq))
6272 {
6273 pDomainChnInfo->chnInfo[j].scanType = pDomainFreqInfo->pCsrScanFreqInfo[i].scanType;
6274 break;
6275 }
6276 }
6277 }
6278 else
6279 {
6280 smsLog(pMac, LOGW, " Failed to get frequency of channel %d", pDomainChnInfo->chnInfo[j].chnId);
6281 }
6282 }
6283 status = eHAL_STATUS_SUCCESS;
6284 }
6285
6286 return (status);
6287}
6288#endif
6289
6290eHalStatus csrGetModifyProfileFields(tpAniSirGlobal pMac, tANI_U32 sessionId,
6291 tCsrRoamModifyProfileFields *pModifyProfileFields)
6292{
6293
6294 if(!pModifyProfileFields)
6295 {
6296 return eHAL_STATUS_FAILURE;
6297 }
6298
6299 palCopyMemory( pMac->hHdd, pModifyProfileFields,
6300 &pMac->roam.roamSession[sessionId].connectedProfile.modifyProfileFields,
6301 sizeof(tCsrRoamModifyProfileFields) );
6302
6303 return eHAL_STATUS_SUCCESS;
6304}
6305
6306eHalStatus csrSetModifyProfileFields(tpAniSirGlobal pMac, tANI_U32 sessionId,
6307 tCsrRoamModifyProfileFields *pModifyProfileFields)
6308{
6309 tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
6310
6311 palCopyMemory( pMac->hHdd, &pSession->connectedProfile.modifyProfileFields,
6312 pModifyProfileFields,
6313 sizeof(tCsrRoamModifyProfileFields) );
6314
6315 return eHAL_STATUS_SUCCESS;
6316}
6317
6318
6319#if 0
6320/* ---------------------------------------------------------------------------
6321 \fn csrGetSupportedCountryCode
6322 \brief this function is to get a list of the country code current being supported
6323 \param pBuf - Caller allocated buffer with at least 3 bytes, upon success return,
6324 this has the country code list. 3 bytes for each country code. This may be NULL if
6325 caller wants to know the needed bytes.
6326 \param pbLen - Caller allocated, as input, it indicates the length of pBuf. Upon success return,
6327 this contains the length of the data in pBuf
6328 \return eHalStatus
6329 -------------------------------------------------------------------------------*/
6330eHalStatus csrGetSupportedCountryCode(tpAniSirGlobal pMac, tANI_U8 *pBuf, tANI_U32 *pbLen)
6331{
6332 tANI_U32 numOfCountry = sizeof( gCsrCountryInfo ) / sizeof( gCsrCountryInfo[0] );
6333 tANI_U32 numBytes = 0;
6334 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
6335
6336 if( pbLen )
6337 {
6338 numBytes = *pbLen;
6339 //Consider it ok, at least we can return the number of bytes needed;
6340 *pbLen = numOfCountry * WNI_CFG_COUNTRY_CODE_LEN;
6341 status = eHAL_STATUS_SUCCESS;
6342 if( pBuf && ( numBytes >= *pbLen ) )
6343 {
6344 //The ugly part starts.
6345 //We may need to alter the data structure and find a way to make this faster.
6346 tANI_U32 i;
6347
6348 for( i = 0; i < numOfCountry; i++ )
6349 {
6350 palCopyMemory( pMac->hHdd, pBuf + ( i * WNI_CFG_COUNTRY_CODE_LEN ),
6351 gCsrCountryInfo[i].countryCode, WNI_CFG_COUNTRY_CODE_LEN );
6352 }
6353 }
6354 }
6355
6356 return ( status );
6357}
6358#endif
6359
6360/* ---------------------------------------------------------------------------
6361 \fn csrGetSupportedCountryCode
6362 \brief this function is to get a list of the country code current being supported
6363 \param pBuf - Caller allocated buffer with at least 3 bytes, upon success return,
6364 this has the country code list. 3 bytes for each country code. This may be NULL if
6365 caller wants to know the needed bytes.
6366 \param pbLen - Caller allocated, as input, it indicates the length of pBuf. Upon success return,
6367 this contains the length of the data in pBuf
6368 \return eHalStatus
6369 -------------------------------------------------------------------------------*/
6370eHalStatus csrGetSupportedCountryCode(tpAniSirGlobal pMac, tANI_U8 *pBuf, tANI_U32 *pbLen)
6371{
6372 eHalStatus status = eHAL_STATUS_SUCCESS;
6373 VOS_STATUS vosStatus;
6374 v_SIZE_t size = (v_SIZE_t)*pbLen;
6375
6376 vosStatus = vos_nv_getSupportedCountryCode( pBuf, &size, 1 );
6377 //eiter way, return the value back
6378 *pbLen = (tANI_U32)size;
6379
6380 //If pBuf is NULL, caller just want to get the size, consider it success
6381 if(pBuf)
6382 {
6383 if( VOS_IS_STATUS_SUCCESS( vosStatus ) )
6384 {
6385 tANI_U32 i, n = *pbLen / 3;
6386
6387 for( i = 0; i < n; i++ )
6388 {
6389 pBuf[i*3 + 2] = ' ';
6390 }
6391 }
6392 else
6393 {
6394 status = eHAL_STATUS_FAILURE;
6395 }
6396 }
6397
6398 return (status);
6399}
6400
6401
6402
6403//Upper layer to get the list of the base channels to scan for passively 11d info from csr
6404eHalStatus csrScanGetBaseChannels( tpAniSirGlobal pMac, tCsrChannelInfo * pChannelInfo )
6405{
6406 eHalStatus status = eHAL_STATUS_FAILURE;
6407
6408 do
6409 {
6410
6411 if(!pMac->scan.baseChannels.numChannels || !pChannelInfo)
6412 {
6413 break;
6414 }
6415 status = palAllocateMemory( pMac->hHdd, (void **)&pChannelInfo->ChannelList,
6416 pMac->scan.baseChannels.numChannels );
6417 if( !HAL_STATUS_SUCCESS( status ) )
6418 {
6419 smsLog( pMac, LOGE, FL("csrScanGetBaseChannels: fail to allocate memory\n") );
6420 break;
6421 }
6422 status = palCopyMemory( pMac->hHdd, pChannelInfo->ChannelList, pMac->scan.baseChannels.channelList,
6423 pMac->scan.baseChannels.numChannels );
6424 if( !HAL_STATUS_SUCCESS( status ) )
6425 {
6426 break;
6427 }
6428 pChannelInfo->numOfChannels = pMac->scan.baseChannels.numChannels;
6429
6430 }while(0);
6431
6432 return ( status );
6433}
6434
6435
6436tANI_BOOLEAN csrIsSetKeyAllowed(tpAniSirGlobal pMac, tANI_U32 sessionId)
6437{
6438 tANI_BOOLEAN fRet = eANI_BOOLEAN_TRUE;
6439#ifdef WLAN_SOFTAP_FEATURE
6440 tCsrRoamSession *pSession;
6441
6442 pSession =CSR_GET_SESSION(pMac, sessionId);
6443
6444 /*This condition is not working for infra state. When infra is in not-connected state
6445 * the pSession->pCurRoamProfile is NULL. And this function returns TRUE, that is incorrect.
6446 * Since SAP requires to set key without any BSS started, it needs this condition to be met.
6447 * In other words, this function is useless.
6448 * The current work-around is to process setcontext_rsp and removekey_rsp no matter what the
6449 * state is.
6450 */
Mohit Khanna23863762012-09-11 17:40:09 -0700[diff] [blame]6451 smsLog( pMac, LOG2, FL(" is not what it intends to. Must be revisit or removed\n") );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6452 if( (NULL == pSession) ||
6453 ( csrIsConnStateDisconnected( pMac, sessionId ) &&
6454 (pSession->pCurRoamProfile != NULL) &&
6455 (!(CSR_IS_INFRA_AP(pSession->pCurRoamProfile))) )
6456 )
6457 {
6458 fRet = eANI_BOOLEAN_FALSE;
6459 }
6460#else
6461 fRet = !( csrIsConnStateDisconnected( pMac, sessionId ) );
6462#endif
6463
6464 return ( fRet );
6465}
6466
6467//no need to acquire lock for this basic function
6468tANI_U16 sme_ChnToFreq(tANI_U8 chanNum)
6469{
6470 int i;
6471
6472 for (i = 0; i < NUM_RF_CHANNELS; i++)
6473 {
6474 if (rfChannels[i].channelNum == chanNum)
6475 {
6476 return rfChannels[i].targetFreq;
6477 }
6478 }
6479
6480 return (0);
6481}
6482
6483/* Disconnect all active sessions by sending disassoc. This is mainly used to disconnect the remaining session when we
6484 * transition from concurrent sessions to a single session. The use case is Infra STA and wifi direct multiple sessions are up and
6485 * P2P session is removed. The Infra STA session remains and should resume BMPS if BMPS is enabled by default. However, there
6486 * are some issues seen with BMPS resume during this transition and this is a workaround which will allow the Infra STA session to
6487 * disconnect and auto connect back and enter BMPS this giving the same effect as resuming BMPS
6488 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]6489
6490//Remove this code once SLM_Sessionization is supported
6491//BMPS_WORKAROUND_NOT_NEEDED
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6492void csrDisconnectAllActiveSessions(tpAniSirGlobal pMac)
6493{
6494 tANI_U8 i;
6495
6496 /* Disconnect all the active sessions */
6497 for (i=0; i<CSR_ROAM_SESSION_MAX; i++)
6498 {
6499 if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
6500 {
6501 csrRoamDisconnectInternal(pMac, i, eCSR_DISCONNECT_REASON_UNSPECIFIED);
6502 }
6503 }
6504}
Mohit Khanna349bc392012-09-11 17:24:52 -0700[diff] [blame]6505
Madan Mohan Koyyalamudi470d2cf2012-09-28 14:43:44 -0700[diff] [blame]6506#ifdef FEATURE_WLAN_LFR
6507tANI_BOOLEAN csrIsChannelPresentInList(
6508 tANI_U8 *pChannelList,
6509 int numChannels,
6510 tANI_U8 channel
6511 )
6512{
6513 int i = 0;
6514
6515 // Check for NULL pointer
Madan Mohan Koyyalamudidd3c9662012-11-09 17:39:30 -0800[diff] [blame]6516 if (!pChannelList || (numChannels == 0))
6517 {
6518 return FALSE;
6519 }
Madan Mohan Koyyalamudi470d2cf2012-09-28 14:43:44 -0700[diff] [blame]6520
6521 // Look for the channel in the list
6522 for (i = 0; i < numChannels; i++)
6523 {
6524 if (pChannelList[i] == channel)
6525 return TRUE;
6526 }
6527
6528 return FALSE;
6529}
6530
6531VOS_STATUS csrAddToChannelListFront(
6532 tANI_U8 *pChannelList,
6533 int numChannels,
6534 tANI_U8 channel
6535 )
6536{
6537 int i = 0;
6538
6539 // Check for NULL pointer
6540 if (!pChannelList) return eHAL_STATUS_E_NULL_VALUE;
6541
6542 // Make room for the addition. (Start moving from the back.)
6543 for (i = numChannels; i > 0; i--)
6544 {
6545 pChannelList[i] = pChannelList[i-1];
6546 }
6547
6548 // Now add the NEW channel...at the front
6549 pChannelList[0] = channel;
6550
6551 return eHAL_STATUS_SUCCESS;
6552}
6553#endif