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