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