Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / e7245744a820869678f8c470cf342df3fc81d9fa / . / CORE / SME / src / csr / csrUtil.c
blob: 079beccb7771e2956daa51c14b4e7751bdcbabc9 [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
2 * Copyright (c) 2012, Code Aurora Forum. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
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
1493
1494tANI_BOOLEAN csrIsInfraConnected( tpAniSirGlobal pMac )
1495{
1496 tANI_U32 i;
1497 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1498
1499 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1500 {
1501 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedInfra( pMac, i ) )
1502 {
1503 fRc = eANI_BOOLEAN_TRUE;
1504 break;
1505 }
1506 }
1507
1508 return ( fRc );
1509}
1510
1511tANI_BOOLEAN csrIsConcurrentInfraConnected( tpAniSirGlobal pMac )
1512{
1513 tANI_U32 i, noOfConnectedInfra = 0;
1514
1515 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1516
1517 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1518 {
1519 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedInfra( pMac, i ) )
1520 {
1521 ++noOfConnectedInfra;
1522 }
1523 }
1524
1525 // More than one Infra Sta Connected
1526 if(noOfConnectedInfra > 1)
1527 {
1528 fRc = eANI_BOOLEAN_TRUE;
1529 }
1530
1531 return ( fRc );
1532}
1533
1534tANI_BOOLEAN csrIsIBSSStarted( tpAniSirGlobal pMac )
1535{
1536 tANI_U32 i;
1537 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1538
1539 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1540 {
1541 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateIbss( pMac, i ) )
1542 {
1543 fRc = eANI_BOOLEAN_TRUE;
1544 break;
1545 }
1546 }
1547
1548 return ( fRc );
1549}
1550
1551
1552tANI_BOOLEAN csrIsBTAMPStarted( tpAniSirGlobal pMac )
1553{
1554 tANI_U32 i;
1555 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1556
1557 for( i = 0; i < CSR_ROAM_SESSION_MAX; i++ )
1558 {
1559 if( CSR_IS_SESSION_VALID( pMac, i ) && csrIsConnStateConnectedWds( pMac, i ) )
1560 {
1561 fRc = eANI_BOOLEAN_TRUE;
1562 break;
1563 }
1564 }
1565
1566 return ( fRc );
1567}
1568
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1569tANI_BOOLEAN csrIsConcurrentSessionRunning( tpAniSirGlobal pMac )
1570{
1571 tANI_U32 sessionId, noOfCocurrentSession = 0;
1572 eCsrConnectState connectState;
1573
1574 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1575
1576 for( sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
1577 {
1578 if( CSR_IS_SESSION_VALID( pMac, sessionId ) )
1579 {
1580 connectState = pMac->roam.roamSession[sessionId].connectState;
1581 if( (eCSR_ASSOC_STATE_TYPE_INFRA_ASSOCIATED == connectState) ||
1582 (eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED == connectState) ||
1583 (eCSR_ASSOC_STATE_TYPE_INFRA_DISCONNECTED == connectState) )
1584 {
1585 ++noOfCocurrentSession;
1586 }
1587 }
1588 }
1589
1590 // More than one session is Up and Running
1591 if(noOfCocurrentSession > 1)
1592 {
1593 fRc = eANI_BOOLEAN_TRUE;
1594 }
1595
1596 return ( fRc );
1597}
1598
1599#ifndef BMPS_WORKAROUND_NOT_NEEDED
1600tANI_BOOLEAN csrIsInfraApStarted( tpAniSirGlobal pMac )
1601{
1602 tANI_U32 sessionId;
1603 tANI_BOOLEAN fRc = eANI_BOOLEAN_FALSE;
1604
1605 for( sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
1606 {
1607 if( CSR_IS_SESSION_VALID( pMac, sessionId ) && (csrIsConnStateConnectedInfraAp(pMac, sessionId)) )
1608 {
1609 fRc = eANI_BOOLEAN_TRUE;
1610 break;
1611 }
1612 }
1613
1614 return ( fRc );
1615
1616}
1617#endif
1618
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1619tANI_BOOLEAN csrIsBTAMP( tpAniSirGlobal pMac, tANI_U32 sessionId )
1620{
1621 return ( csrIsConnStateConnectedWds( pMac, sessionId ) );
1622}
1623
1624
1625tANI_BOOLEAN csrIsConnStateDisconnected(tpAniSirGlobal pMac, tANI_U32 sessionId)
1626{
1627 return (eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED == pMac->roam.roamSession[sessionId].connectState);
1628}
1629
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1630tANI_BOOLEAN csrIsValidMcConcurrentSession(tpAniSirGlobal pMac, tANI_U32 sessionId,
1631 tSirBssDescription *pBssDesc)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1632{
1633 tCsrRoamSession *pSession = NULL;
1634 tANI_U8 Index = 0, ConnId = 0;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1635 eAniBoolean status = eANI_BOOLEAN_FALSE;
1636
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1637 tVOS_CON_MODE Mode[CSR_ROAM_SESSION_MAX];
1638
1639 //Check for MCC support
1640 if (!pMac->roam.configParam.fenableMCCMode)
1641 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1642 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1643 }
1644
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1645 for( Index = 0; Index < CSR_ROAM_SESSION_MAX; Index++ )
1646 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1647 Mode[Index] = VOS_MAX_NO_OF_MODE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1648 if( CSR_IS_SESSION_VALID( pMac, Index ) )
1649 {
1650 pSession = CSR_GET_SESSION( pMac, Index );
1651
1652 if (NULL != pSession->pCurRoamProfile)
1653 {
1654 Mode[ConnId] = pSession->pCurRoamProfile->csrPersona;
1655 ConnId++;
1656 }
1657 }
1658 }
1659
1660 Index = 0;
1661 if (Mode[Index] == VOS_STA_MODE && ConnId > Index)
1662 {
1663 switch (Mode[Index+1])
1664 {
1665 case VOS_P2P_CLIENT_MODE :
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1666 status = eANI_BOOLEAN_TRUE;
1667 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1668 case VOS_MAX_NO_OF_MODE :
1669 default :
1670 break;
1671 }
1672 }
1673 else if (Mode[Index] == VOS_P2P_CLIENT_MODE && ConnId > Index)
1674 {
1675 switch (Mode[Index +1])
1676 {
1677 case VOS_STA_MODE :
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1678 status = eANI_BOOLEAN_TRUE;
1679 break;
1680
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1681 case VOS_MAX_NO_OF_MODE :
1682 default :
1683 break;
1684 }
1685 }
1686
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]1687 //Validate BeaconInterval
1688 if( CSR_IS_SESSION_VALID( pMac, sessionId ) )
1689 {
1690 pSession = CSR_GET_SESSION( pMac, sessionId );
1691 if (NULL != pSession->pCurRoamProfile)
1692 {
1693 if(csrIsconcurrentsessionValid (pMac, sessionId,
1694 pSession->pCurRoamProfile->csrPersona)
1695 == eHAL_STATUS_SUCCESS )
1696 {
1697 if(csrValidateBeaconInterval( pMac, pBssDesc->channelId,
1698 &pBssDesc->beaconInterval, sessionId,
1699 pSession->pCurRoamProfile->csrPersona)
1700 != eHAL_STATUS_SUCCESS)
1701 {
1702 status = eANI_BOOLEAN_FALSE;
1703 }
1704 else
1705 {
1706 status = eANI_BOOLEAN_TRUE;
1707 }
1708 }
1709 else
1710 {
1711 status = eANI_BOOLEAN_FALSE;
1712 }
1713 }
1714 }
1715 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1716}
1717
1718static tSirMacCapabilityInfo csrGetBssCapabilities( tSirBssDescription *pSirBssDesc )
1719{
1720 tSirMacCapabilityInfo dot11Caps;
1721
1722 //tSirMacCapabilityInfo is 16-bit
1723 pal_get_U16( (tANI_U8 *)&pSirBssDesc->capabilityInfo, (tANI_U16 *)&dot11Caps );
1724
1725 return( dot11Caps );
1726}
1727
1728tANI_BOOLEAN csrIsInfraBssDesc( tSirBssDescription *pSirBssDesc )
1729{
1730 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1731
1732 return( (tANI_BOOLEAN)dot11Caps.ess );
1733}
1734
1735
1736tANI_BOOLEAN csrIsIbssBssDesc( tSirBssDescription *pSirBssDesc )
1737{
1738 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1739
1740 return( (tANI_BOOLEAN)dot11Caps.ibss );
1741}
1742
1743tANI_BOOLEAN csrIsQoSBssDesc( tSirBssDescription *pSirBssDesc )
1744{
1745 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1746
1747 return( (tANI_BOOLEAN)dot11Caps.qos );
1748}
1749
1750tANI_BOOLEAN csrIsPrivacy( tSirBssDescription *pSirBssDesc )
1751{
1752 tSirMacCapabilityInfo dot11Caps = csrGetBssCapabilities( pSirBssDesc );
1753
1754 return( (tANI_BOOLEAN)dot11Caps.privacy );
1755}
1756
1757
1758tANI_BOOLEAN csrIs11dSupported(tpAniSirGlobal pMac)
1759{
1760 return(pMac->roam.configParam.Is11dSupportEnabled);
1761}
1762
1763
1764tANI_BOOLEAN csrIs11hSupported(tpAniSirGlobal pMac)
1765{
1766 return(pMac->roam.configParam.Is11hSupportEnabled);
1767}
1768
1769
1770tANI_BOOLEAN csrIs11eSupported(tpAniSirGlobal pMac)
1771{
1772 return(pMac->roam.configParam.Is11eSupportEnabled);
1773}
1774
1775tANI_BOOLEAN csrIsMCCSupported ( tpAniSirGlobal pMac )
1776{
1777 return(pMac->roam.configParam.fenableMCCMode);
1778
1779}
1780
1781tANI_BOOLEAN csrIsWmmSupported(tpAniSirGlobal pMac)
1782{
1783 if(eCsrRoamWmmNoQos == pMac->roam.configParam.WMMSupportMode)
1784 {
1785 return eANI_BOOLEAN_FALSE;
1786 }
1787 else
1788 {
1789 return eANI_BOOLEAN_TRUE;
1790 }
1791}
1792
1793
1794
1795
1796//pIes is the IEs for pSirBssDesc2
1797tANI_BOOLEAN csrIsSsidEqual( tHalHandle hHal, tSirBssDescription *pSirBssDesc1,
1798 tSirBssDescription *pSirBssDesc2, tDot11fBeaconIEs *pIes2 )
1799{
1800 tANI_BOOLEAN fEqual = FALSE;
1801 tSirMacSSid Ssid1, Ssid2;
1802 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1803 tDot11fBeaconIEs *pIes1 = NULL;
1804 tDot11fBeaconIEs *pIesLocal = pIes2;
1805
1806 do {
1807 if( ( NULL == pSirBssDesc1 ) || ( NULL == pSirBssDesc2 ) ) break;
1808 if( !pIesLocal && !HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc2, &pIesLocal)) )
1809 {
1810 smsLog(pMac, LOGE, FL(" fail to parse IEs\n"));
1811 break;
1812 }
1813 if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc1, &pIes1)))
1814 {
1815 break;
1816 }
1817 if( ( !pIes1->SSID.present ) || ( !pIesLocal->SSID.present ) ) break;
1818 if ( pIes1->SSID.num_ssid != pIesLocal->SSID.num_ssid ) break;
1819 palCopyMemory(pMac->hHdd, Ssid1.ssId, pIes1->SSID.ssid, pIes1->SSID.num_ssid);
1820 palCopyMemory(pMac->hHdd, Ssid2.ssId, pIesLocal->SSID.ssid, pIesLocal->SSID.num_ssid);
1821
1822 fEqual = palEqualMemory(pMac->hHdd, Ssid1.ssId, Ssid2.ssId, pIesLocal->SSID.num_ssid );
1823
1824 } while( 0 );
1825 if(pIes1)
1826 {
1827 palFreeMemory(pMac->hHdd, pIes1);
1828 }
1829 if( pIesLocal && !pIes2 )
1830 {
1831 palFreeMemory(pMac->hHdd, pIesLocal);
1832 }
1833
1834 return( fEqual );
1835}
1836
1837tANI_BOOLEAN csrIsAniWmeSupported(tDot11fIEAirgo *pIeAirgo)
1838{
1839 tANI_BOOLEAN fRet = eANI_BOOLEAN_FALSE;
1840
1841 if(pIeAirgo && pIeAirgo->present && pIeAirgo->PropCapability.present)
1842 {
1843 fRet = (tANI_BOOLEAN)(PROP_CAPABILITY_GET( WME, pIeAirgo->PropCapability.capability ));
1844 }
1845
1846 return fRet;
1847}
1848
1849
1850
1851
1852//pIes can be passed in as NULL if the caller doesn't have one prepared
1853tANI_BOOLEAN csrIsBssDescriptionWme( tHalHandle hHal, tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes )
1854{
1855 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1856 // Assume that WME is found...
1857 tANI_BOOLEAN fWme = TRUE;
1858 tDot11fBeaconIEs *pIesTemp = pIes;
1859
1860 do
1861 {
1862 if(pIesTemp == NULL)
1863 {
1864 if( !HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesTemp)) )
1865 {
1866 fWme = FALSE;
1867 break;
1868 }
1869 }
1870 // if the AirgoProprietary indicator is found, then WME is supported...
1871 if ( csrIsAniWmeSupported(&pIesTemp->Airgo) ) break;
1872 // if the Wme Info IE is found, then WME is supported...
1873 if ( CSR_IS_QOS_BSS(pIesTemp) ) break;
1874 // if none of these are found, then WME is NOT supported...
1875 fWme = FALSE;
1876 } while( 0 );
1877 if( !csrIsWmmSupported( pMac ) && fWme)
1878 {
1879 if( !pIesTemp->HTCaps.present )
1880 {
1881 fWme = FALSE;
1882 }
1883 }
1884 if( ( pIes == NULL ) && ( NULL != pIesTemp ) )
1885 {
1886 //we allocate memory here so free it before returning
1887 palFreeMemory(pMac->hHdd, pIesTemp);
1888 }
1889
1890 return( fWme );
1891}
1892
1893tANI_BOOLEAN csrIsHcfEnabled( tDot11fIEAirgo *pIeAirgo )
1894{
1895 tANI_BOOLEAN fHcfSupported = FALSE;
1896
1897 fHcfSupported = ((tANI_BOOLEAN)(PROP_CAPABILITY_GET( WME, pIeAirgo->PropCapability.capability )) ||
1898 (pIeAirgo->present && pIeAirgo->HCF.present && pIeAirgo->HCF.enabled));
1899
1900 return( fHcfSupported );
1901}
1902
1903
1904eCsrMediaAccessType csrGetQoSFromBssDesc( tHalHandle hHal, tSirBssDescription *pSirBssDesc,
1905 tDot11fBeaconIEs *pIes )
1906{
1907 eCsrMediaAccessType qosType = eCSR_MEDIUM_ACCESS_DCF;
1908
1909#if defined(VOSS_ENABLED)
1910 VOS_ASSERT( pIes != NULL );
1911#endif
1912
1913 do
1914 {
1915 // if we find WMM in the Bss Description, then we let this
1916 // override and use WMM.
1917 if ( csrIsBssDescriptionWme( hHal, pSirBssDesc, pIes ) )
1918 {
1919 qosType = eCSR_MEDIUM_ACCESS_WMM_eDCF_DSCP;
1920 }
1921 else
1922 {
1923 // if the QoS bit is on, then the AP is advertising 11E QoS...
1924 if ( csrIsQoSBssDesc( pSirBssDesc ) )
1925 {
1926 // which could be HCF or eDCF.
1927 if ( csrIsHcfEnabled( &pIes->Airgo ) )
1928 {
1929 qosType = eCSR_MEDIUM_ACCESS_11e_HCF;
1930 }
1931 else
1932 {
1933 qosType = eCSR_MEDIUM_ACCESS_11e_eDCF;
1934 }
1935 }
1936 else
1937 {
1938 qosType = eCSR_MEDIUM_ACCESS_DCF;
1939 }
1940 // scale back based on the types turned on for the adapter...
1941 if ( eCSR_MEDIUM_ACCESS_11e_eDCF == qosType && !csrIs11eSupported( hHal ) )
1942 {
1943 qosType = eCSR_MEDIUM_ACCESS_DCF;
1944 }
1945 }
1946
1947 } while(0);
1948
1949 return( qosType );
1950}
1951
1952
1953
1954
1955//Caller allocates memory for pIEStruct
1956eHalStatus csrParseBssDescriptionIEs(tHalHandle hHal, tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIEStruct)
1957{
1958 eHalStatus status = eHAL_STATUS_FAILURE;
1959 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1960 int ieLen = (int)(pBssDesc->length + sizeof( pBssDesc->length ) - GET_FIELD_OFFSET( tSirBssDescription, ieFields ));
1961
1962 if(ieLen > 0 && pIEStruct)
1963 {
1964 if(!DOT11F_FAILED(dot11fUnpackBeaconIEs( pMac, (tANI_U8 *)pBssDesc->ieFields, ieLen, pIEStruct )))
1965 {
1966 status = eHAL_STATUS_SUCCESS;
1967 }
1968 }
1969
1970 return (status);
1971}
1972
1973
1974//This function will allocate memory for the parsed IEs to the caller. Caller must free the memory
1975//after it is done with the data only if this function succeeds
1976eHalStatus csrGetParsedBssDescriptionIEs(tHalHandle hHal, tSirBssDescription *pBssDesc, tDot11fBeaconIEs **ppIEStruct)
1977{
1978 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
1979 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
1980
1981 if(pBssDesc && ppIEStruct)
1982 {
1983 status = palAllocateMemory(pMac->hHdd, (void **)ppIEStruct, sizeof(tDot11fBeaconIEs));
1984 if(HAL_STATUS_SUCCESS(status))
1985 {
1986 palZeroMemory(pMac->hHdd, (void *)*ppIEStruct, sizeof(tDot11fBeaconIEs));
1987 status = csrParseBssDescriptionIEs(hHal, pBssDesc, *ppIEStruct);
1988 if(!HAL_STATUS_SUCCESS(status))
1989 {
1990 palFreeMemory(pMac->hHdd, *ppIEStruct);
1991 *ppIEStruct = NULL;
1992 }
1993 }
1994 else
1995 {
1996 smsLog( pMac, LOGE, FL(" failed to allocate memory\n") );
1997 VOS_ASSERT( 0 );
1998 }
1999 }
2000
2001 return (status);
2002}
2003
2004
2005
2006
2007tANI_BOOLEAN csrIsNULLSSID( tANI_U8 *pBssSsid, tANI_U8 len )
2008{
2009 tANI_BOOLEAN fNullSsid = FALSE;
2010
2011 tANI_U32 SsidLength;
2012 tANI_U8 *pSsidStr;
2013
2014 do
2015 {
2016 if ( 0 == len )
2017 {
2018 fNullSsid = TRUE;
2019 break;
2020 }
2021
2022 //Consider 0 or space for hidden SSID
2023 if ( 0 == pBssSsid[0] )
2024 {
2025 fNullSsid = TRUE;
2026 break;
2027 }
2028
2029 SsidLength = len;
2030 pSsidStr = pBssSsid;
2031
2032 while ( SsidLength )
2033 {
2034 if( *pSsidStr )
2035 break;
2036
2037 pSsidStr++;
2038 SsidLength--;
2039 }
2040
2041 if( 0 == SsidLength )
2042 {
2043 fNullSsid = TRUE;
2044 break;
2045 }
2046 }
2047 while( 0 );
2048
2049 return fNullSsid;
2050}
2051
2052
2053tANI_U32 csrGetFragThresh( tHalHandle hHal )
2054{
2055 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2056
2057 return pMac->roam.configParam.FragmentationThreshold;
2058}
2059
2060tANI_U32 csrGetRTSThresh( tHalHandle hHal )
2061{
2062 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2063
2064 return pMac->roam.configParam.RTSThreshold;
2065}
2066
2067eCsrPhyMode csrTranslateToPhyModeFromBssDesc( tSirBssDescription *pSirBssDesc )
2068{
2069 eCsrPhyMode phyMode;
2070
2071 switch ( pSirBssDesc->nwType )
2072 {
2073 case eSIR_11A_NW_TYPE:
2074 phyMode = eCSR_DOT11_MODE_11a;
2075 break;
2076
2077 case eSIR_11B_NW_TYPE:
2078 phyMode = eCSR_DOT11_MODE_11b;
2079 break;
2080
2081 case eSIR_11G_NW_TYPE:
2082 phyMode = eCSR_DOT11_MODE_11g;
2083 break;
2084
2085 case eSIR_11N_NW_TYPE:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2086 phyMode = eCSR_DOT11_MODE_11n;
2087 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2088#ifdef WLAN_FEATURE_11AC
2089 case eSIR_11AC_NW_TYPE:
2090 default:
2091 phyMode = eCSR_DOT11_MODE_11ac;
2092#else
2093 default:
2094 phyMode = eCSR_DOT11_MODE_11n;
2095#endif
2096 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2097 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2098 return( phyMode );
2099}
2100
2101
2102tANI_U32 csrTranslateToWNICfgDot11Mode(tpAniSirGlobal pMac, eCsrCfgDot11Mode csrDot11Mode)
2103{
2104 tANI_U32 ret;
2105
2106 switch(csrDot11Mode)
2107 {
2108 case eCSR_CFG_DOT11_MODE_AUTO:
2109 smsLog(pMac, LOGW, FL(" Warning: sees eCSR_CFG_DOT11_MODE_AUTO \n"));
2110 //We cannot decide until now.
2111 if(pMac->roam.configParam.ProprietaryRatesEnabled)
2112 {
2113 ret = WNI_CFG_DOT11_MODE_TAURUS;
2114 }
2115 else
2116 {
2117 ret = WNI_CFG_DOT11_MODE_11N;
2118 }
2119 break;
2120 case eCSR_CFG_DOT11_MODE_TAURUS:
2121 ret = WNI_CFG_DOT11_MODE_TAURUS;
2122 break;
2123 case eCSR_CFG_DOT11_MODE_11A:
2124 ret = WNI_CFG_DOT11_MODE_11A;
2125 break;
2126 case eCSR_CFG_DOT11_MODE_11B:
2127 ret = WNI_CFG_DOT11_MODE_11B;
2128 break;
2129 case eCSR_CFG_DOT11_MODE_11G:
2130 ret = WNI_CFG_DOT11_MODE_11G;
2131 break;
2132 case eCSR_CFG_DOT11_MODE_11N:
2133 ret = WNI_CFG_DOT11_MODE_11N;
2134 break;
2135 case eCSR_CFG_DOT11_MODE_POLARIS:
2136 ret = WNI_CFG_DOT11_MODE_POLARIS;
2137 break;
2138 case eCSR_CFG_DOT11_MODE_TITAN:
2139 ret = WNI_CFG_DOT11_MODE_TITAN;
2140 break;
2141#ifdef WLAN_SOFTAP_FEATURE
2142 case eCSR_CFG_DOT11_MODE_11G_ONLY:
2143 ret = WNI_CFG_DOT11_MODE_11G_ONLY;
2144 break;
2145 case eCSR_CFG_DOT11_MODE_11N_ONLY:
2146 ret = WNI_CFG_DOT11_MODE_11N_ONLY;
2147 break;
2148#endif
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2149
2150#ifdef WLAN_FEATURE_11AC
2151 case eCSR_CFG_DOT11_MODE_11AC_ONLY:
2152 ret = WNI_CFG_DOT11_MODE_11AC_ONLY;
2153 break;
2154 case eCSR_CFG_DOT11_MODE_11AC:
2155 ret = WNI_CFG_DOT11_MODE_11AC;
2156 break;
2157#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2158 default:
2159 smsLog(pMac, LOGW, FL("doesn't expect %d as csrDo11Mode\n"), csrDot11Mode);
2160 if(eCSR_BAND_24 == pMac->roam.configParam.eBand)
2161 {
2162 ret = WNI_CFG_DOT11_MODE_11G;
2163 }
2164 else
2165 {
2166 ret = WNI_CFG_DOT11_MODE_11A;
2167 }
2168 break;
2169 }
2170
2171 return (ret);
2172}
2173
2174
2175//This function should only return the super set of supported modes. 11n implies 11b/g/a/n.
2176eHalStatus csrGetPhyModeFromBss(tpAniSirGlobal pMac, tSirBssDescription *pBSSDescription,
2177 eCsrPhyMode *pPhyMode, tDot11fBeaconIEs *pIes)
2178{
2179 eHalStatus status = eHAL_STATUS_SUCCESS;
2180 eCsrPhyMode phyMode = csrTranslateToPhyModeFromBssDesc(pBSSDescription);
2181
2182 if( pIes )
2183 {
2184 if(pIes->Airgo.present)
2185 {
2186 if(pIes->Airgo.PropCapability.present)
2187 {
2188 if( PROP_CAPABILITY_GET( TAURUS, pIes->Airgo.PropCapability.capability ))
2189 {
2190 phyMode = eCSR_DOT11_MODE_TAURUS;
2191 }
2192 }
2193 }
2194 if(pIes->HTCaps.present && (eCSR_DOT11_MODE_TAURUS != phyMode))
2195 {
2196 phyMode = eCSR_DOT11_MODE_11n;
2197 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2198
2199#ifdef WLAN_FEATURE_11AC
2200 if ( pIes->VHTCaps.present && (eCSR_DOT11_MODE_TAURUS != phyMode))
2201 {
2202 phyMode = eCSR_DOT11_MODE_11ac;
2203 }
2204#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2205 *pPhyMode = phyMode;
2206 }
2207
2208 return (status);
2209
2210}
2211
2212
2213//This function returns the correct eCSR_CFG_DOT11_MODE is the two phyModes matches
2214//bssPhyMode is the mode derived from the BSS description
2215//f5GhzBand is derived from the channel id of BSS description
2216tANI_BOOLEAN csrGetPhyModeInUse( eCsrPhyMode phyModeIn, eCsrPhyMode bssPhyMode, tANI_BOOLEAN f5GhzBand,
2217 eCsrCfgDot11Mode *pCfgDot11ModeToUse )
2218{
2219 tANI_BOOLEAN fMatch = FALSE;
2220 eCsrCfgDot11Mode cfgDot11Mode;
2221
2222 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; // to suppress compiler warning
2223
2224 switch( phyModeIn )
2225 {
2226 case eCSR_DOT11_MODE_abg: //11a or 11b or 11g
2227 if( f5GhzBand )
2228 {
2229 fMatch = TRUE;
2230 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2231 }
2232 else if( eCSR_DOT11_MODE_11b == bssPhyMode )
2233 {
2234 fMatch = TRUE;
2235 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2236 }
2237 else
2238 {
2239 fMatch = TRUE;
2240 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2241 }
2242 break;
2243
2244 case eCSR_DOT11_MODE_11a: //11a
2245 if( f5GhzBand )
2246 {
2247 fMatch = TRUE;
2248 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2249 }
2250 break;
2251
2252 case eCSR_DOT11_MODE_11a_ONLY: //11a
2253 if( eCSR_DOT11_MODE_11a == bssPhyMode )
2254 {
2255 fMatch = TRUE;
2256 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2257 }
2258 break;
2259
2260 case eCSR_DOT11_MODE_11g:
2261 if(!f5GhzBand)
2262 {
2263 if( eCSR_DOT11_MODE_11b == bssPhyMode )
2264 {
2265 fMatch = TRUE;
2266 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2267 }
2268 else
2269 {
2270 fMatch = TRUE;
2271 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2272 }
2273 }
2274 break;
2275
2276 case eCSR_DOT11_MODE_11g_ONLY:
2277 if( eCSR_DOT11_MODE_11g == bssPhyMode )
2278 {
2279 fMatch = TRUE;
2280 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2281 }
2282 break;
2283
2284 case eCSR_DOT11_MODE_11b:
2285 if( !f5GhzBand )
2286 {
2287 fMatch = TRUE;
2288 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2289 }
2290 break;
2291
2292 case eCSR_DOT11_MODE_11b_ONLY:
2293 if( eCSR_DOT11_MODE_11b == bssPhyMode )
2294 {
2295 fMatch = TRUE;
2296 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2297 }
2298 break;
2299
2300 case eCSR_DOT11_MODE_11n:
2301 fMatch = TRUE;
2302 switch(bssPhyMode)
2303 {
2304 case eCSR_DOT11_MODE_11g:
2305 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2306 break;
2307 case eCSR_DOT11_MODE_11b:
2308 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2309 break;
2310 case eCSR_DOT11_MODE_11a:
2311 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2312 break;
2313 case eCSR_DOT11_MODE_11n:
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2314#ifdef WLAN_FEATURE_11AC
2315 case eCSR_DOT11_MODE_11ac:
2316#endif
2317 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
2318 break;
2319
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2320 case eCSR_DOT11_MODE_TAURUS:
2321 default:
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2322#ifdef WLAN_FEATURE_11AC
2323 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2324#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2325 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2326#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2327 break;
2328 }
2329 break;
2330
2331 case eCSR_DOT11_MODE_11n_ONLY:
2332 if((eCSR_DOT11_MODE_11n == bssPhyMode) || (eCSR_DOT11_MODE_TAURUS == bssPhyMode))
2333 {
2334 fMatch = TRUE;
2335 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2336
2337 }
2338
2339 break;
2340#ifdef WLAN_FEATURE_11AC
2341 case eCSR_DOT11_MODE_11ac:
2342 fMatch = TRUE;
2343 switch(bssPhyMode)
2344 {
2345 case eCSR_DOT11_MODE_11g:
2346 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2347 break;
2348 case eCSR_DOT11_MODE_11b:
2349 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2350 break;
2351 case eCSR_DOT11_MODE_11a:
2352 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2353 break;
2354 case eCSR_DOT11_MODE_11n:
2355 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
2356 break;
2357 case eCSR_DOT11_MODE_11ac:
2358 case eCSR_DOT11_MODE_TAURUS:
2359 default:
2360 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2361 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2362 }
2363 break;
2364
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2365 case eCSR_DOT11_MODE_11ac_ONLY:
2366 if((eCSR_DOT11_MODE_11ac == bssPhyMode) || (eCSR_DOT11_MODE_TAURUS == bssPhyMode))
2367 {
2368 fMatch = TRUE;
2369 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2370 }
2371 break;
2372#endif
2373
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2374 case eCSR_DOT11_MODE_TAURUS:
2375 default:
2376 fMatch = TRUE;
2377 switch(bssPhyMode)
2378 {
2379 case eCSR_DOT11_MODE_11g:
2380 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
2381 break;
2382 case eCSR_DOT11_MODE_11b:
2383 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
2384 break;
2385 case eCSR_DOT11_MODE_11a:
2386 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
2387 break;
2388 case eCSR_DOT11_MODE_11n:
2389 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
2390 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2391#ifdef WLAN_FEATURE_11AC
2392 case eCSR_DOT11_MODE_11ac:
2393 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
2394 break;
2395#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2396 case eCSR_DOT11_MODE_TAURUS:
2397 default:
2398 cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
2399 break;
2400 }
2401 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2402 }
2403
2404 if ( fMatch && pCfgDot11ModeToUse )
2405 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2406#ifdef WLAN_FEATURE_11AC
2407 if(cfgDot11Mode == eCSR_CFG_DOT11_MODE_11AC && !WDA_getFwWlanFeatCaps(DOT11AC))
2408 {
2409 *pCfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
2410 }
2411 else
2412#endif
2413 {
2414 *pCfgDot11ModeToUse = cfgDot11Mode;
2415 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2416 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2417 return( fMatch );
2418}
2419
2420
2421//This function decides whether the one of the bit of phyMode is matching the mode in the BSS and allowed by the user
2422//setting, pMac->roam.configParam.uCfgDot11Mode. It returns the mode that fits the criteria.
2423tANI_BOOLEAN csrIsPhyModeMatch( tpAniSirGlobal pMac, tANI_U32 phyMode,
2424 tSirBssDescription *pSirBssDesc, tCsrRoamProfile *pProfile,
2425 eCsrCfgDot11Mode *pReturnCfgDot11Mode,
2426 tDot11fBeaconIEs *pIes)
2427{
2428 tANI_BOOLEAN fMatch = FALSE;
2429 eCsrPhyMode phyModeInBssDesc, phyMode2;
2430 eCsrCfgDot11Mode cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_TAURUS;
2431 tANI_U32 bitMask, loopCount;
2432
2433 if(HAL_STATUS_SUCCESS(csrGetPhyModeFromBss(pMac, pSirBssDesc, &phyModeInBssDesc, pIes )))
2434 {
2435 //In case some change change eCSR_DOT11_MODE_TAURUS to non-0
2436 if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode))
2437 {
2438 //Taurus means anything
2439 if ( eCSR_CFG_DOT11_MODE_ABG == pMac->roam.configParam.uCfgDot11Mode )
2440 {
2441 phyMode = eCSR_DOT11_MODE_abg;
2442 }
2443 else if(eCSR_CFG_DOT11_MODE_AUTO == pMac->roam.configParam.uCfgDot11Mode)
2444 {
2445 if(pMac->roam.configParam.ProprietaryRatesEnabled)
2446 {
2447 phyMode = eCSR_DOT11_MODE_TAURUS;
2448 }
2449 else
2450 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2451
2452#ifdef WLAN_FEATURE_11AC
2453 phyMode = eCSR_DOT11_MODE_11ac;
2454#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2455 phyMode = eCSR_DOT11_MODE_11n;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2456#endif
2457
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458 }
2459 }
2460 else
2461 {
2462 //user's pick
2463 phyMode = pMac->roam.configParam.phyMode;
2464 }
2465 }
2466 if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode) )
2467 {
2468 if(0 != phyMode)
2469 {
2470 if(eCSR_DOT11_MODE_AUTO & phyMode)
2471 {
2472 phyMode2 = eCSR_DOT11_MODE_AUTO & phyMode;
2473 }
2474 else
2475 {
2476 phyMode2 = eCSR_DOT11_MODE_TAURUS & phyMode;
2477 }
2478 }
2479 else
2480 {
2481 phyMode2 = phyMode;
2482 }
2483 fMatch = csrGetPhyModeInUse( phyMode2, phyModeInBssDesc, CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId),
2484 &cfgDot11ModeToUse );
2485 }
2486 else
2487 {
2488 bitMask = 1;
2489 loopCount = 0;
2490 while(loopCount < eCSR_NUM_PHY_MODE)
2491 {
2492 if(0 != ( phyMode2 = (phyMode & (bitMask << loopCount++)) ))
2493 {
2494 fMatch = csrGetPhyModeInUse( phyMode2, phyModeInBssDesc, CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId),
2495 &cfgDot11ModeToUse );
2496 if(fMatch) break;
2497 }
2498 }
2499 }
2500 if ( fMatch && pReturnCfgDot11Mode )
2501 {
2502 if( pProfile )
2503 {
2504 /* IEEE 11n spec (8.4.3): HT STA shall eliminate TKIP as a
2505 * choice for the pairwise cipher suite if CCMP is advertised
2506 * by the AP or if the AP included an HT capabilities element
2507 * in its Beacons and Probe Response.
2508 */
2509 if( (!CSR_IS_11n_ALLOWED( pProfile->negotiatedUCEncryptionType )) &&
2510 ((eCSR_CFG_DOT11_MODE_11N == cfgDot11ModeToUse) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2511#ifdef WLAN_FEATURE_11AC
2512 (eCSR_CFG_DOT11_MODE_11AC == cfgDot11ModeToUse) ||
2513#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2514 (eCSR_CFG_DOT11_MODE_TAURUS == cfgDot11ModeToUse)) )
2515 {
2516 //We cannot do 11n here
2517 if( !CSR_IS_CHANNEL_5GHZ(pSirBssDesc->channelId) )
2518 {
2519 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
2520 }
2521 else
2522 {
2523 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
2524 }
2525 }
2526 }
2527 *pReturnCfgDot11Mode = cfgDot11ModeToUse;
2528 }
2529 }
2530
2531 return( fMatch );
2532}
2533
2534
2535eCsrCfgDot11Mode csrFindBestPhyMode( tpAniSirGlobal pMac, tANI_U32 phyMode )
2536{
2537 eCsrCfgDot11Mode cfgDot11ModeToUse;
2538 eCsrBand eBand = pMac->roam.configParam.eBand;
2539
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2540
2541#ifdef WLAN_FEATURE_11AC
2542 if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode)
2543 ||(eCSR_DOT11_MODE_11ac & phyMode))
2544 {
2545 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11AC;
2546 }
2547 else
2548#endif
2549
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2550 if ( (0 == phyMode) || (eCSR_DOT11_MODE_AUTO & phyMode) || (eCSR_DOT11_MODE_TAURUS & phyMode))
2551 {
2552 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
2553 }
2554 else
2555 {
2556 if( ( eCSR_DOT11_MODE_11n | eCSR_DOT11_MODE_11n_ONLY ) & phyMode )
2557 {
2558 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11N;
2559 }
2560 else if ( eCSR_DOT11_MODE_abg & phyMode )
2561 {
2562 if( eCSR_BAND_24 != eBand )
2563 {
2564 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
2565 }
2566 else
2567 {
2568 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
2569 }
2570 }
2571 else if( ( eCSR_DOT11_MODE_11a | eCSR_DOT11_MODE_11a_ONLY ) & phyMode )
2572 {
2573 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11A;
2574 }
2575 else if( ( eCSR_DOT11_MODE_11g | eCSR_DOT11_MODE_11g_ONLY ) & phyMode )
2576 {
2577 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11G;
2578 }
2579 else
2580 {
2581 cfgDot11ModeToUse = eCSR_CFG_DOT11_MODE_11B;
2582 }
2583 }
2584
2585 return ( cfgDot11ModeToUse );
2586}
2587
2588
2589
2590
2591tANI_U32 csrGet11hPowerConstraint( tHalHandle hHal, tDot11fIEPowerConstraints *pPowerConstraint )
2592{
2593 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
2594 tANI_U32 localPowerConstraint = 0;
2595
2596 // check if .11h support is enabled, if not, the power constraint is 0.
2597 if(pMac->roam.configParam.Is11hSupportEnabled && pPowerConstraint->present)
2598 {
2599 localPowerConstraint = pPowerConstraint->localPowerConstraints;
2600 }
2601
2602 return( localPowerConstraint );
2603}
2604
2605
2606tANI_BOOLEAN csrIsProfileWpa( tCsrRoamProfile *pProfile )
2607{
2608 tANI_BOOLEAN fWpaProfile = FALSE;
2609
2610 switch ( pProfile->negotiatedAuthType )
2611 {
2612 case eCSR_AUTH_TYPE_WPA:
2613 case eCSR_AUTH_TYPE_WPA_PSK:
2614 case eCSR_AUTH_TYPE_WPA_NONE:
2615#ifdef FEATURE_WLAN_CCX
2616 case eCSR_AUTH_TYPE_CCKM_WPA:
2617#endif
2618 fWpaProfile = TRUE;
2619 break;
2620
2621 default:
2622 fWpaProfile = FALSE;
2623 break;
2624 }
2625
2626 if ( fWpaProfile )
2627 {
2628 switch ( pProfile->negotiatedUCEncryptionType )
2629 {
2630 case eCSR_ENCRYPT_TYPE_WEP40:
2631 case eCSR_ENCRYPT_TYPE_WEP104:
2632 case eCSR_ENCRYPT_TYPE_TKIP:
2633 case eCSR_ENCRYPT_TYPE_AES:
2634 fWpaProfile = TRUE;
2635 break;
2636
2637 default:
2638 fWpaProfile = FALSE;
2639 break;
2640 }
2641 }
2642 return( fWpaProfile );
2643}
2644
2645tANI_BOOLEAN csrIsProfileRSN( tCsrRoamProfile *pProfile )
2646{
2647 tANI_BOOLEAN fRSNProfile = FALSE;
2648
2649 switch ( pProfile->negotiatedAuthType )
2650 {
2651 case eCSR_AUTH_TYPE_RSN:
2652 case eCSR_AUTH_TYPE_RSN_PSK:
2653#ifdef WLAN_FEATURE_VOWIFI_11R
2654 case eCSR_AUTH_TYPE_FT_RSN:
2655 case eCSR_AUTH_TYPE_FT_RSN_PSK:
2656#endif
2657#ifdef FEATURE_WLAN_CCX
2658 case eCSR_AUTH_TYPE_CCKM_RSN:
2659#endif
2660 fRSNProfile = TRUE;
2661 break;
2662
2663 default:
2664 fRSNProfile = FALSE;
2665 break;
2666 }
2667
2668 if ( fRSNProfile )
2669 {
2670 switch ( pProfile->negotiatedUCEncryptionType )
2671 {
2672 // !!REVIEW - For WPA2, use of RSN IE mandates
2673 // use of AES as encryption. Here, we qualify
2674 // even if encryption type is WEP or TKIP
2675 case eCSR_ENCRYPT_TYPE_WEP40:
2676 case eCSR_ENCRYPT_TYPE_WEP104:
2677 case eCSR_ENCRYPT_TYPE_TKIP:
2678 case eCSR_ENCRYPT_TYPE_AES:
2679 fRSNProfile = TRUE;
2680 break;
2681
2682 default:
2683 fRSNProfile = FALSE;
2684 break;
2685 }
2686 }
2687 return( fRSNProfile );
2688}
2689
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]2690eHalStatus
2691csrIsconcurrentsessionValid(tpAniSirGlobal pMac,tANI_U32 cursessionId,
2692 tVOS_CON_MODE currBssPersona)
2693{
2694 tANI_U32 sessionId = 0;
2695
2696 for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
2697 {
2698 if (cursessionId != sessionId )
2699 {
2700 if (!CSR_IS_SESSION_VALID( pMac, sessionId ))
2701 {
2702 continue;
2703 }
2704
2705 switch (currBssPersona)
2706 {
2707 case VOS_STA_MODE:
2708 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2709 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2710 == VOS_STA_MODE)) //check for P2P client mode
2711 {
2712 smsLog(pMac, LOGE, FL(" ****STA mode already exists ****\n"));
2713 return eHAL_STATUS_FAILURE;
2714 }
2715 break;
2716
2717 case VOS_STA_SAP_MODE:
2718 if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2719 == VOS_STA_SAP_MODE)
2720 {
2721 smsLog(pMac, LOGE, FL(" ****SoftAP mode already exists ****\n"));
2722 return eHAL_STATUS_FAILURE;
2723 }
2724
2725 else if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2726 == VOS_P2P_GO_MODE)
2727 {
2728 smsLog(pMac, LOGE, FL(" ****Cannot start Multiple Beaconing Role ****\n"));
2729 return eHAL_STATUS_FAILURE;
2730 }
2731 break;
2732
2733 case VOS_P2P_CLIENT_MODE:
2734 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2735 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2736 == VOS_P2P_CLIENT_MODE)) //check for P2P client mode
2737 {
2738 smsLog(pMac, LOGE, FL(" ****CLIENT mode already exists ****\n"));
2739 return eHAL_STATUS_FAILURE;
2740 }
2741 break;
2742
2743 case VOS_P2P_GO_MODE:
2744 if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2745 == VOS_P2P_GO_MODE)
2746 {
2747 smsLog(pMac, LOGE, FL(" ****P2P GO mode already exists ****\n"));
2748 return eHAL_STATUS_FAILURE;
2749 }
2750 else if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2751 == VOS_STA_SAP_MODE)
2752 {
2753 smsLog(pMac, LOGE, FL(" ****Cannot start Multiple Beaconing Role ****\n"));
2754 return eHAL_STATUS_FAILURE;
2755 }
2756 break;
2757
2758 default :
2759 smsLog(pMac, LOGE, FL("***Persona not handled = %d*****\n"),currBssPersona);
2760 break;
2761 }
2762 }
2763 }
2764 return eHAL_STATUS_SUCCESS;
2765
2766}
2767
2768eHalStatus csrValidateBeaconInterval(tpAniSirGlobal pMac, tANI_U8 channelId,
2769 tANI_U16 *beaconInterval, tANI_U32 cursessionId,
2770 tVOS_CON_MODE currBssPersona)
2771{
2772 tANI_U32 sessionId = 0;
2773
2774 //If MCC is not supported just break and return SUCCESS
2775 if ( !IS_MCC_SUPPORTED && !pMac->roam.configParam.fenableMCCMode){
2776 return eHAL_STATUS_FAILURE;
2777 }
2778
2779 for (sessionId = 0; sessionId < CSR_ROAM_SESSION_MAX; sessionId++ )
2780 {
2781 if (cursessionId != sessionId )
2782 {
2783 if (!CSR_IS_SESSION_VALID( pMac, sessionId ))
2784 {
2785 continue;
2786 }
2787
2788 switch (currBssPersona)
2789 {
2790 case VOS_STA_MODE:
2791 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2792 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2793 == VOS_P2P_CLIENT_MODE)) //check for P2P client mode
2794 {
2795 smsLog(pMac, LOG1, FL(" Beacon Interval Validation not required for STA/CLIENT\n"));
2796 }
2797 //IF SAP has started and STA wants to connect on different channel MCC should
2798 //MCC should not be enabled so making it false to enforce on same channel
2799 else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
2800 == VOS_STA_SAP_MODE)
2801 {
2802 if (pMac->roam.roamSession[sessionId].bssParams.operationChn
2803 != channelId )
2804 {
2805 smsLog(pMac, LOGE, FL("***MCC is not enabled for SAP +STA****\n"));
2806 return eHAL_STATUS_FAILURE;
2807 }
2808 }
2809 else if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2810 == VOS_P2P_GO_MODE) //Check for P2P go scenario
2811 {
2812 if ((pMac->roam.roamSession[sessionId].bssParams.operationChn
2813 != channelId ) &&
2814 (pMac->roam.roamSession[sessionId].bssParams.beaconInterval
2815 != *beaconInterval))
2816 {
2817 smsLog(pMac, LOGE, FL("BeaconInteval is different cannot connect to prefered AP...\n"));
2818 return eHAL_STATUS_FAILURE;
2819 }
2820 }
2821 break;
2822
2823 case VOS_P2P_CLIENT_MODE:
2824 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2825 (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2826 == VOS_STA_MODE)) //check for P2P client mode
2827 {
2828 smsLog(pMac, LOG1, FL(" Ignore Beacon Interval Validation...\n"));
2829 }
2830 //IF SAP has started and STA wants to connect on different channel MCC should
2831 //MCC should not be enabled so making it false to enforce on same channel
2832 else if (pMac->roam.roamSession[sessionId].bssParams.bssPersona
2833 == VOS_STA_SAP_MODE)
2834 {
2835 if (pMac->roam.roamSession[sessionId].bssParams.operationChn
2836 != channelId )
2837 {
2838 smsLog(pMac, LOGE, FL("***MCC is not enabled for SAP + CLIENT****\n"));
2839 return eHAL_STATUS_FAILURE;
2840 }
2841 }
2842 else if(pMac->roam.roamSession[sessionId].bssParams.bssPersona
2843 == VOS_P2P_GO_MODE) //Check for P2P go scenario
2844 {
2845 if ((pMac->roam.roamSession[sessionId].bssParams.operationChn
2846 != channelId ) &&
2847 (pMac->roam.roamSession[sessionId].bssParams.beaconInterval
2848 != *beaconInterval))
2849 {
2850 smsLog(pMac, LOGE, FL("BeaconInteval is different cannot connect to P2P_GO network ...\n"));
2851 return eHAL_STATUS_FAILURE;
2852 }
2853 }
2854 break;
2855
2856 case VOS_P2P_GO_MODE :
2857 if(pMac->roam.roamSession[sessionId].pCurRoamProfile &&
2858 ((pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2859 == VOS_P2P_CLIENT_MODE)
2860 || (pMac->roam.roamSession[sessionId].pCurRoamProfile->csrPersona
2861 == VOS_STA_MODE))) //check for P2P_client scenario
2862 {
2863 if ((pMac->roam.roamSession[sessionId].connectedProfile.operationChannel
2864 == 0 )&&
2865 (pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval
2866 == 0))
2867 {
2868 continue;
2869 }
2870
2871
2872 if (csrIsConnStateConnectedInfra(pMac, sessionId) &&
2873 (pMac->roam.roamSession[sessionId].connectedProfile.operationChannel
2874 != channelId ) &&
2875 (pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval
2876 != *beaconInterval))
2877 {
2878 /*
2879 * Updated beaconInterval should be used only when we are starting a new BSS
2880 * not incase of client or STA case
2881 */
2882 *beaconInterval =
2883 pMac->roam.roamSession[sessionId].connectedProfile.beaconInterval;
2884 return eHAL_STATUS_SUCCESS;
2885 }
2886 }
2887 break;
2888
2889 default :
2890 smsLog(pMac, LOG1, FL(" Persona not supported : %d\n"),currBssPersona);
2891 return eHAL_STATUS_FAILURE;
2892 }
2893 }
2894 }
2895
2896 return eHAL_STATUS_SUCCESS;
2897}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2898
2899#ifdef WLAN_FEATURE_VOWIFI_11R
2900/* Function to return TRUE if the authtype is 11r */
2901tANI_BOOLEAN csrIsAuthType11r( eCsrAuthType AuthType )
2902{
2903 switch ( AuthType )
2904 {
2905 case eCSR_AUTH_TYPE_FT_RSN_PSK:
2906 case eCSR_AUTH_TYPE_FT_RSN:
2907 return TRUE;
2908 break;
2909 default:
2910 break;
2911 }
2912 return FALSE;
2913}
2914
2915/* Function to return TRUE if the profile is 11r */
2916tANI_BOOLEAN csrIsProfile11r( tCsrRoamProfile *pProfile )
2917{
2918 return csrIsAuthType11r( pProfile->negotiatedAuthType );
2919}
2920
2921#endif
2922
2923#ifdef FEATURE_WLAN_CCX
2924
2925/* Function to return TRUE if the authtype is CCX */
2926tANI_BOOLEAN csrIsAuthTypeCCX( eCsrAuthType AuthType )
2927{
2928 switch ( AuthType )
2929 {
2930 case eCSR_AUTH_TYPE_CCKM_WPA:
2931 case eCSR_AUTH_TYPE_CCKM_RSN:
2932 return TRUE;
2933 break;
2934 default:
2935 break;
2936 }
2937 return FALSE;
2938}
2939
2940/* Function to return TRUE if the profile is CCX */
2941tANI_BOOLEAN csrIsProfileCCX( tCsrRoamProfile *pProfile )
2942{
2943 return (csrIsAuthTypeCCX( pProfile->negotiatedAuthType ));
2944}
2945
2946#endif
2947
2948#ifdef FEATURE_WLAN_WAPI
2949tANI_BOOLEAN csrIsProfileWapi( tCsrRoamProfile *pProfile )
2950{
2951 tANI_BOOLEAN fWapiProfile = FALSE;
2952
2953 switch ( pProfile->negotiatedAuthType )
2954 {
2955 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
2956 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
2957 fWapiProfile = TRUE;
2958 break;
2959
2960 default:
2961 fWapiProfile = FALSE;
2962 break;
2963 }
2964
2965 if ( fWapiProfile )
2966 {
2967 switch ( pProfile->negotiatedUCEncryptionType )
2968 {
2969 case eCSR_ENCRYPT_TYPE_WPI:
2970 fWapiProfile = TRUE;
2971 break;
2972
2973 default:
2974 fWapiProfile = FALSE;
2975 break;
2976 }
2977 }
2978 return( fWapiProfile );
2979}
2980
2981static tANI_BOOLEAN csrIsWapiOuiEqual( tpAniSirGlobal pMac, tANI_U8 *Oui1, tANI_U8 *Oui2 )
2982{
2983 return( palEqualMemory(pMac->hHdd, Oui1, Oui2, CSR_WAPI_OUI_SIZE ) );
2984}
2985
2986static tANI_BOOLEAN csrIsWapiOuiMatch( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WAPI_OUI_SIZE],
2987 tANI_U8 cAllCyphers,
2988 tANI_U8 Cypher[],
2989 tANI_U8 Oui[] )
2990{
2991 tANI_BOOLEAN fYes = FALSE;
2992 tANI_U8 idx;
2993
2994 for ( idx = 0; idx < cAllCyphers; idx++ )
2995 {
2996 if ( csrIsWapiOuiEqual( pMac, AllCyphers[ idx ], Cypher ) )
2997 {
2998 fYes = TRUE;
2999 break;
3000 }
3001 }
3002
3003 if ( fYes && Oui )
3004 {
3005 palCopyMemory( pMac->hHdd, Oui, AllCyphers[ idx ], CSR_WAPI_OUI_SIZE );
3006 }
3007
3008 return( fYes );
3009}
3010#endif /* FEATURE_WLAN_WAPI */
3011
3012static tANI_BOOLEAN csrIsWpaOuiEqual( tpAniSirGlobal pMac, tANI_U8 *Oui1, tANI_U8 *Oui2 )
3013{
3014 return( palEqualMemory(pMac->hHdd, Oui1, Oui2, CSR_WPA_OUI_SIZE ) );
3015}
3016
3017static tANI_BOOLEAN csrIsOuiMatch( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3018 tANI_U8 cAllCyphers,
3019 tANI_U8 Cypher[],
3020 tANI_U8 Oui[] )
3021{
3022 tANI_BOOLEAN fYes = FALSE;
3023 tANI_U8 idx;
3024
3025 for ( idx = 0; idx < cAllCyphers; idx++ )
3026 {
3027 if ( csrIsWpaOuiEqual( pMac, AllCyphers[ idx ], Cypher ) )
3028 {
3029 fYes = TRUE;
3030 break;
3031 }
3032 }
3033
3034 if ( fYes && Oui )
3035 {
3036 palCopyMemory( pMac->hHdd, Oui, AllCyphers[ idx ], CSR_WPA_OUI_SIZE );
3037 }
3038
3039 return( fYes );
3040}
3041
3042static tANI_BOOLEAN csrMatchRSNOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3043 tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
3044 tANI_U8 Oui[] )
3045{
3046 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui[ouiIndex], Oui ) );
3047
3048}
3049
3050#ifdef FEATURE_WLAN_WAPI
3051static tANI_BOOLEAN csrMatchWapiOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WAPI_OUI_SIZE],
3052 tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
3053 tANI_U8 Oui[] )
3054{
3055 return( csrIsWapiOuiMatch( pMac, AllCyphers, cAllCyphers, csrWapiOui[ouiIndex], Oui ) );
3056
3057}
3058#endif /* FEATURE_WLAN_WAPI */
3059
3060static tANI_BOOLEAN csrMatchWPAOUIIndex( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3061 tANI_U8 cAllCyphers, tANI_U8 ouiIndex,
3062 tANI_U8 Oui[] )
3063{
3064 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui[ouiIndex], Oui ) );
3065
3066}
3067
3068#if 0
3069static tANI_BOOLEAN csrIsRSNUnicastNone( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3070 tANI_U8 cAllCyphers,
3071 tANI_U8 Oui[] )
3072{
3073 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui00, Oui ) );
3074}
3075
3076static tANI_BOOLEAN csrIsRSNMulticastWep( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3077 tANI_U8 cAllCyphers,
3078 tANI_U8 Oui[] )
3079{
3080 tANI_BOOLEAN fYes = FALSE;
3081
3082 // Check Wep 104 first, if fails, then check Wep40.
3083 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui05, Oui );
3084
3085 if ( !fYes )
3086 {
3087 // if not Wep-104, check Wep-40
3088 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui01, Oui );
3089 }
3090
3091 return( fYes );
3092}
3093
3094
3095static tANI_BOOLEAN csrIsRSNUnicastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3096 tANI_U8 cAllCyphers,
3097 tANI_U8 Oui[] )
3098{
3099 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui02, Oui ) );
3100}
3101
3102
3103static tANI_BOOLEAN csrIsRSNMulticastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3104 tANI_U8 cAllCyphers,
3105 tANI_U8 Oui[] )
3106{
3107 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui02, Oui ) );
3108}
3109
3110static tANI_BOOLEAN csrIsRSNUnicastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3111 tANI_U8 cAllCyphers,
3112 tANI_U8 Oui[] )
3113{
3114 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui04, Oui ) );
3115}
3116
3117static tANI_BOOLEAN csrIsRSNMulticastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_RSN_OUI_SIZE],
3118 tANI_U8 cAllCyphers,
3119 tANI_U8 Oui[] )
3120{
3121 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrRSNOui04, Oui ) );
3122}
3123#endif
3124#ifdef FEATURE_WLAN_WAPI
3125static tANI_BOOLEAN csrIsAuthWapiCert( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WAPI_OUI_SIZE],
3126 tANI_U8 cAllSuites,
3127 tANI_U8 Oui[] )
3128{
3129 return( csrIsWapiOuiMatch( pMac, AllSuites, cAllSuites, csrWapiOui[1], Oui ) );
3130}
3131static tANI_BOOLEAN csrIsAuthWapiPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WAPI_OUI_SIZE],
3132 tANI_U8 cAllSuites,
3133 tANI_U8 Oui[] )
3134{
3135 return( csrIsWapiOuiMatch( pMac, AllSuites, cAllSuites, csrWapiOui[2], Oui ) );
3136}
3137#endif /* FEATURE_WLAN_WAPI */
3138
3139#ifdef WLAN_FEATURE_VOWIFI_11R
3140
3141/*
3142 * Function for 11R FT Authentication. We match the FT Authentication Cipher suite
3143 * here. This matches for FT Auth with the 802.1X exchange.
3144 *
3145 */
3146static tANI_BOOLEAN csrIsFTAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3147 tANI_U8 cAllSuites,
3148 tANI_U8 Oui[] )
3149{
3150 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[03], Oui ) );
3151}
3152
3153/*
3154 * Function for 11R FT Authentication. We match the FT Authentication Cipher suite
3155 * here. This matches for FT Auth with the PSK.
3156 *
3157 */
3158static tANI_BOOLEAN csrIsFTAuthRSNPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3159 tANI_U8 cAllSuites,
3160 tANI_U8 Oui[] )
3161{
3162 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[04], Oui ) );
3163}
3164
3165#endif
3166
3167#ifdef FEATURE_WLAN_CCX
3168
3169/*
3170 * Function for CCX CCKM AKM Authentication. We match the CCKM AKM Authentication Key Management suite
3171 * here. This matches for CCKM AKM Auth with the 802.1X exchange.
3172 *
3173 */
3174static tANI_BOOLEAN csrIsCcxCckmAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3175 tANI_U8 cAllSuites,
3176 tANI_U8 Oui[] )
3177{
3178 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[06], Oui ) );
3179}
3180
3181static tANI_BOOLEAN csrIsCcxCckmAuthWpa( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3182 tANI_U8 cAllSuites,
3183 tANI_U8 Oui[] )
3184{
3185 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[06], Oui ) );
3186}
3187
3188#endif
3189
3190static tANI_BOOLEAN csrIsAuthRSN( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3191 tANI_U8 cAllSuites,
3192 tANI_U8 Oui[] )
3193{
3194#ifdef WLAN_FEATURE_11W
3195 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[01], Oui ) ||
3196 csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[05], Oui ));
3197#else
3198 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[01], Oui ) );
3199#endif
3200}
3201static tANI_BOOLEAN csrIsAuthRSNPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_RSN_OUI_SIZE],
3202 tANI_U8 cAllSuites,
3203 tANI_U8 Oui[] )
3204{
3205#ifdef WLAN_FEATURE_11W
3206 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[02], Oui ) ||
3207 csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[06], Oui ) );
3208#else
3209 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrRSNOui[02], Oui ) );
3210#endif
3211}
3212
3213static tANI_BOOLEAN csrIsAuthWpa( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3214 tANI_U8 cAllSuites,
3215 tANI_U8 Oui[] )
3216{
3217 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[01], Oui ) );
3218}
3219
3220#ifdef NOT_CURRENTLY_USED
3221static tANI_BOOLEAN csrIsAuth802_1x( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3222 tANI_U8 cAllSuites,
3223 tANI_U8 Oui[] )
3224{
3225 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[00], Oui ) );
3226}
3227#endif // NOT_CURRENTLY_USED
3228
3229static tANI_BOOLEAN csrIsAuthWpaPsk( tpAniSirGlobal pMac, tANI_U8 AllSuites[][CSR_WPA_OUI_SIZE],
3230 tANI_U8 cAllSuites,
3231 tANI_U8 Oui[] )
3232{
3233 return( csrIsOuiMatch( pMac, AllSuites, cAllSuites, csrWpaOui[02], Oui ) );
3234}
3235#if 0
3236static tANI_BOOLEAN csrIsUnicastNone( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3237 tANI_U8 cAllCyphers,
3238 tANI_U8 Oui[] )
3239{
3240 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui00, Oui ) );
3241}
3242
3243static tANI_BOOLEAN csrIsUnicastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3244 tANI_U8 cAllCyphers,
3245 tANI_U8 Oui[] )
3246{
3247 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui02, Oui ) );
3248}
3249
3250static tANI_BOOLEAN csrIsUnicastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3251 tANI_U8 cAllCyphers,
3252 tANI_U8 Oui[] )
3253{
3254 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui04, Oui ) );
3255}
3256
3257
3258static tANI_BOOLEAN csrIsMulticastWep( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3259 tANI_U8 cAllCyphers,
3260 tANI_U8 Oui[] )
3261{
3262 tANI_BOOLEAN fYes = FALSE;
3263
3264 // Check Wep 104 first, if fails, then check Wep40.
3265 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui05, Oui );
3266
3267 if ( !fYes )
3268 {
3269 // if not Wep-104, check Wep-40
3270 fYes = csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui01, Oui );
3271 }
3272
3273 return( fYes );
3274}
3275
3276
3277static tANI_BOOLEAN csrIsMulticastTkip( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3278 tANI_U8 cAllCyphers,
3279 tANI_U8 Oui[] )
3280{
3281 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui02, Oui ) );
3282}
3283
3284
3285static tANI_BOOLEAN csrIsMulticastAes( tpAniSirGlobal pMac, tANI_U8 AllCyphers[][CSR_WPA_OUI_SIZE],
3286 tANI_U8 cAllCyphers,
3287 tANI_U8 Oui[] )
3288{
3289 return( csrIsOuiMatch( pMac, AllCyphers, cAllCyphers, csrWpaOui04, Oui ) );
3290}
3291
3292#endif
3293
3294tANI_U8 csrGetOUIIndexFromCipher( eCsrEncryptionType enType )
3295{
3296 tANI_U8 OUIIndex;
3297
3298 switch ( enType )
3299 {
3300 case eCSR_ENCRYPT_TYPE_WEP40:
3301 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
3302 OUIIndex = CSR_OUI_WEP40_OR_1X_INDEX;
3303 break;
3304 case eCSR_ENCRYPT_TYPE_WEP104:
3305 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
3306 OUIIndex = CSR_OUI_WEP104_INDEX;
3307 break;
3308 case eCSR_ENCRYPT_TYPE_TKIP:
3309 OUIIndex = CSR_OUI_TKIP_OR_PSK_INDEX;
3310 break;
3311 case eCSR_ENCRYPT_TYPE_AES:
3312 OUIIndex = CSR_OUI_AES_INDEX;
3313 break;
3314 case eCSR_ENCRYPT_TYPE_NONE:
3315 OUIIndex = CSR_OUI_USE_GROUP_CIPHER_INDEX;
3316 break;
3317#ifdef FEATURE_WLAN_WAPI
3318 case eCSR_ENCRYPT_TYPE_WPI:
3319 OUIIndex = CSR_OUI_WAPI_WAI_CERT_OR_SMS4_INDEX;
3320 break;
3321#endif /* FEATURE_WLAN_WAPI */
3322 default: //HOWTO handle this?
3323 OUIIndex = CSR_OUI_RESERVED_INDEX;
3324 break;
3325 }//switch
3326
3327 return OUIIndex;
3328}
3329
3330tANI_BOOLEAN csrGetRSNInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
3331 tDot11fIERSN *pRSNIe,
3332 tANI_U8 *UnicastCypher,
3333 tANI_U8 *MulticastCypher,
3334 tANI_U8 *AuthSuite,
3335 tCsrRSNCapabilities *Capabilities,
3336 eCsrAuthType *pNegotiatedAuthtype,
3337 eCsrEncryptionType *pNegotiatedMCCipher )
3338{
3339 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3340 tANI_BOOLEAN fAcceptableCyphers = FALSE;
3341 tANI_U8 cUnicastCyphers = 0;
3342 tANI_U8 cMulticastCyphers = 0;
3343 tANI_U8 cAuthSuites = 0, i;
3344 tANI_U8 Unicast[ CSR_RSN_OUI_SIZE ];
3345 tANI_U8 Multicast[ CSR_RSN_OUI_SIZE ];
3346 tANI_U8 AuthSuites[ CSR_RSN_MAX_AUTH_SUITES ][ CSR_RSN_OUI_SIZE ];
3347 tANI_U8 Authentication[ CSR_RSN_OUI_SIZE ];
3348 tANI_U8 MulticastCyphers[ CSR_RSN_MAX_MULTICAST_CYPHERS ][ CSR_RSN_OUI_SIZE ];
3349 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3350
3351 do{
3352 if ( pRSNIe->present )
3353 {
3354 cMulticastCyphers++;
3355 palCopyMemory(pMac->hHdd, MulticastCyphers, pRSNIe->gp_cipher_suite, CSR_RSN_OUI_SIZE);
3356 cUnicastCyphers = (tANI_U8)(pRSNIe->pwise_cipher_suite_count);
3357 cAuthSuites = (tANI_U8)(pRSNIe->akm_suite_count);
3358 for(i = 0; i < cAuthSuites && i < CSR_RSN_MAX_AUTH_SUITES; i++)
3359 {
3360 palCopyMemory(pMac->hHdd, (void *)&AuthSuites[i],
3361 (void *)&pRSNIe->akm_suites[i], CSR_RSN_OUI_SIZE);
3362 }
3363
3364 //Check - Is requested Unicast Cipher supported by the BSS.
3365 fAcceptableCyphers = csrMatchRSNOUIIndex( pMac, pRSNIe->pwise_cipher_suites, cUnicastCyphers,
3366 csrGetOUIIndexFromCipher( enType ), Unicast );
3367
3368 if( !fAcceptableCyphers ) break;
3369
3370
3371 //Unicast is supported. Pick the first matching Group cipher, if any.
3372 for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
3373 {
3374 fAcceptableCyphers = csrMatchRSNOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
3375 csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i] ), Multicast );
3376 if(fAcceptableCyphers)
3377 {
3378 break;
3379 }
3380 }
3381 if( !fAcceptableCyphers ) break;
3382
3383 if( pNegotiatedMCCipher )
3384 *pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
3385
3386 /* Initializing with FALSE as it has TRUE value already */
3387 fAcceptableCyphers = FALSE;
3388 for (i = 0 ; i < pAuthType->numEntries; i++)
3389 {
3390 //Ciphers are supported, Match authentication algorithm and pick first matching authtype.
3391 #ifdef WLAN_FEATURE_VOWIFI_11R
3392 /* Changed the AKM suites according to order of preference */
3393 if ( csrIsFTAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
3394 {
3395 if (eCSR_AUTH_TYPE_FT_RSN == pAuthType->authType[i])
3396 negAuthType = eCSR_AUTH_TYPE_FT_RSN;
3397 }
3398 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsFTAuthRSNPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
3399 {
3400 if (eCSR_AUTH_TYPE_FT_RSN_PSK == pAuthType->authType[i])
3401 negAuthType = eCSR_AUTH_TYPE_FT_RSN_PSK;
3402 }
3403#endif
3404#ifdef FEATURE_WLAN_CCX
3405 /* CCX only supports 802.1X. No PSK. */
3406 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsCcxCckmAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
3407 {
3408 if (eCSR_AUTH_TYPE_CCKM_RSN == pAuthType->authType[i])
3409 negAuthType = eCSR_AUTH_TYPE_CCKM_RSN;
3410 }
3411#endif
3412 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSN( pMac, AuthSuites, cAuthSuites, Authentication ) )
3413 {
3414 if (eCSR_AUTH_TYPE_RSN == pAuthType->authType[i])
3415 negAuthType = eCSR_AUTH_TYPE_RSN;
3416 }
3417 if ((negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthRSNPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
3418 {
3419 if (eCSR_AUTH_TYPE_RSN_PSK == pAuthType->authType[i])
3420 negAuthType = eCSR_AUTH_TYPE_RSN_PSK;
3421 }
3422
3423 // The 1st auth type in the APs RSN IE, to match stations connecting
3424 // profiles auth type will cause us to exit this loop
3425 // This is added as some APs advertise multiple akms in the RSN IE.
3426 if (eCSR_AUTH_TYPE_UNKNOWN != negAuthType)
3427 {
3428 fAcceptableCyphers = TRUE;
3429 break;
3430 }
3431 } // for
3432 }
3433
3434 }while (0);
3435
3436 if ( fAcceptableCyphers )
3437 {
3438 if ( MulticastCypher )
3439 {
3440 palCopyMemory( pMac->hHdd, MulticastCypher, Multicast, CSR_RSN_OUI_SIZE );
3441 }
3442
3443 if ( UnicastCypher )
3444 {
3445 palCopyMemory( pMac->hHdd, UnicastCypher, Unicast, CSR_RSN_OUI_SIZE );
3446 }
3447
3448 if ( AuthSuite )
3449 {
3450 palCopyMemory( pMac->hHdd, AuthSuite, Authentication, CSR_RSN_OUI_SIZE );
3451 }
3452
3453 if ( pNegotiatedAuthtype )
3454 {
3455 *pNegotiatedAuthtype = negAuthType;
3456 }
3457 if ( Capabilities )
3458 {
3459 Capabilities->PreAuthSupported = pRSNIe->preauth;
3460 Capabilities->NoPairwise = pRSNIe->no_pwise;
3461 Capabilities->PTKSAReplayCounter = pRSNIe->PTKSA_replay_counter;
3462 Capabilities->GTKSAReplayCounter = pRSNIe->GTKSA_replay_counter;
3463 Capabilities->Reserved = pRSNIe->reserved;
3464 }
3465 }
3466 return( fAcceptableCyphers );
3467}
3468
3469
3470tANI_BOOLEAN csrIsRSNMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
3471 tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
3472{
3473 tANI_BOOLEAN fRSNMatch = FALSE;
3474
3475 // See if the cyphers in the Bss description match with the settings in the profile.
3476 fRSNMatch = csrGetRSNInformation( hHal, pAuthType, enType, pEnMcType, &pIes->RSN, NULL, NULL, NULL, NULL,
3477 pNegotiatedAuthType, pNegotiatedMCCipher );
3478
3479 return( fRSNMatch );
3480}
3481
3482
3483tANI_BOOLEAN csrLookupPMKID( tpAniSirGlobal pMac, tANI_U32 sessionId, tANI_U8 *pBSSId, tANI_U8 *pPMKId )
3484{
3485 tANI_BOOLEAN fRC = FALSE, fMatchFound = FALSE;
3486 tANI_U32 Index;
3487 tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
3488
3489 do
3490 {
3491 for( Index=0; Index < pSession->NumPmkidCache; Index++ )
3492 {
3493 smsLog(pMac, LOGW, "match PMKID %02X-%02X-%02X-%02X-%02X-%02X to \n",
3494 pBSSId[0], pBSSId[1], pBSSId[2], pBSSId[3], pBSSId[4], pBSSId[5]);
3495 if( palEqualMemory( pMac->hHdd, pBSSId, pSession->PmkidCacheInfo[Index].BSSID, sizeof(tCsrBssid) ) )
3496 {
3497 // match found
3498 fMatchFound = TRUE;
3499 break;
3500 }
3501 }
3502
3503 if( !fMatchFound ) break;
3504
3505 palCopyMemory( pMac->hHdd, pPMKId, pSession->PmkidCacheInfo[Index].PMKID, CSR_RSN_PMKID_SIZE );
3506
3507 fRC = TRUE;
3508 }
3509 while( 0 );
3510 smsLog(pMac, LOGW, "csrLookupPMKID called return match = %d pMac->roam.NumPmkidCache = %d",
3511 fRC, pSession->NumPmkidCache);
3512
3513 return fRC;
3514}
3515
3516
3517tANI_U8 csrConstructRSNIe( tHalHandle hHal, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
3518 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrRSNIe *pRSNIe )
3519{
3520 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3521 tANI_BOOLEAN fRSNMatch;
3522 tANI_U8 cbRSNIe = 0;
3523 tANI_U8 UnicastCypher[ CSR_RSN_OUI_SIZE ];
3524 tANI_U8 MulticastCypher[ CSR_RSN_OUI_SIZE ];
3525 tANI_U8 AuthSuite[ CSR_RSN_OUI_SIZE ];
3526 tCsrRSNAuthIe *pAuthSuite;
3527 tCsrRSNCapabilities RSNCapabilities;
3528 tCsrRSNPMKIe *pPMK;
3529 tANI_U8 PMKId[CSR_RSN_PMKID_SIZE];
3530 tDot11fBeaconIEs *pIesLocal = pIes;
3531
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]3532 smsLog(pMac, LOGW, "%s called...", __FUNCTION__);
3533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3534 do
3535 {
3536 if ( !csrIsProfileRSN( pProfile ) ) break;
3537
3538 if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
3539 {
3540 break;
3541 }
3542
3543 // See if the cyphers in the Bss description match with the settings in the profile.
3544 fRSNMatch = csrGetRSNInformation( hHal, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType,
3545 &pProfile->mcEncryptionType, &pIesLocal->RSN,
3546 UnicastCypher, MulticastCypher, AuthSuite, &RSNCapabilities, NULL, NULL );
3547 if ( !fRSNMatch ) break;
3548
3549 pRSNIe->IeHeader.ElementID = SIR_MAC_RSN_EID;
3550
3551 pRSNIe->Version = CSR_RSN_VERSION_SUPPORTED;
3552
3553 palCopyMemory( pMac->hHdd, pRSNIe->MulticastOui, MulticastCypher, sizeof( MulticastCypher ) );
3554
3555 pRSNIe->cUnicastCyphers = 1;
3556
3557 palCopyMemory( pMac->hHdd, &pRSNIe->UnicastOui[ 0 ], UnicastCypher, sizeof( UnicastCypher ) );
3558
3559 pAuthSuite = (tCsrRSNAuthIe *)( &pRSNIe->UnicastOui[ pRSNIe->cUnicastCyphers ] );
3560
3561 pAuthSuite->cAuthenticationSuites = 1;
3562 palCopyMemory( pMac->hHdd, &pAuthSuite->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
3563
3564 // RSN capabilities follows the Auth Suite (two octects)
3565 // !!REVIEW - What should STA put in RSN capabilities, currently
3566 // just putting back APs capabilities
3567 // For one, we shouldn't EVER be sending out "pre-auth supported". It is an AP only capability
3568 RSNCapabilities.PreAuthSupported = 0;
3569 *(tANI_U16 *)( &pAuthSuite->AuthOui[ 1 ] ) = *((tANI_U16 *)(&RSNCapabilities));
3570
3571 pPMK = (tCsrRSNPMKIe *)( ((tANI_U8 *)(&pAuthSuite->AuthOui[ 1 ])) + sizeof(tANI_U16) );
3572
3573 if( csrLookupPMKID( pMac, sessionId, pSirBssDesc->bssId, &(PMKId[0]) ) )
3574 {
3575 pPMK->cPMKIDs = 1;
3576
3577 palCopyMemory( pMac->hHdd, pPMK->PMKIDList[0].PMKID, PMKId, CSR_RSN_PMKID_SIZE );
3578 }
3579 else
3580 {
3581 pPMK->cPMKIDs = 0;
3582 }
3583
3584 // Add in the fixed fields plus 1 Unicast cypher, less the IE Header length
3585 // Add in the size of the Auth suite (count plus a single OUI)
3586 // Add in the RSN caps field.
3587 // Add PMKID count and PMKID (if any)
3588 pRSNIe->IeHeader.Length = (tANI_U8) (sizeof( *pRSNIe ) - sizeof ( pRSNIe->IeHeader ) +
3589 sizeof( *pAuthSuite ) +
3590 sizeof( tCsrRSNCapabilities ));
3591 if(pPMK->cPMKIDs)
3592 {
3593 pRSNIe->IeHeader.Length += (tANI_U8)(sizeof( tANI_U16 ) +
3594 (pPMK->cPMKIDs * CSR_RSN_PMKID_SIZE));
3595 }
3596 // return the size of the IE header (total) constructed...
3597 cbRSNIe = pRSNIe->IeHeader.Length + sizeof( pRSNIe->IeHeader );
3598
3599 } while( 0 );
3600
3601 if( !pIes && pIesLocal )
3602 {
3603 //locally allocated
3604 palFreeMemory(pMac->hHdd, pIesLocal);
3605 }
3606
3607 return( cbRSNIe );
3608}
3609
3610
3611#ifdef FEATURE_WLAN_WAPI
3612tANI_BOOLEAN csrGetWapiInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
3613 tDot11fIEWAPI *pWapiIe,
3614 tANI_U8 *UnicastCypher,
3615 tANI_U8 *MulticastCypher,
3616 tANI_U8 *AuthSuite,
3617 eCsrAuthType *pNegotiatedAuthtype,
3618 eCsrEncryptionType *pNegotiatedMCCipher )
3619{
3620 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3621 tANI_BOOLEAN fAcceptableCyphers = FALSE;
3622 tANI_U8 cUnicastCyphers = 0;
3623 tANI_U8 cMulticastCyphers = 0;
3624 tANI_U8 cAuthSuites = 0, i;
3625 tANI_U8 Unicast[ CSR_WAPI_OUI_SIZE ];
3626 tANI_U8 Multicast[ CSR_WAPI_OUI_SIZE ];
3627 tANI_U8 AuthSuites[ CSR_WAPI_MAX_AUTH_SUITES ][ CSR_WAPI_OUI_SIZE ];
3628 tANI_U8 Authentication[ CSR_WAPI_OUI_SIZE ];
3629 tANI_U8 MulticastCyphers[ CSR_WAPI_MAX_MULTICAST_CYPHERS ][ CSR_WAPI_OUI_SIZE ];
3630 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3631
3632 do{
3633 if ( pWapiIe->present )
3634 {
3635 cMulticastCyphers++;
3636 palCopyMemory(pMac->hHdd, MulticastCyphers, pWapiIe->multicast_cipher_suite, CSR_WAPI_OUI_SIZE);
3637 cUnicastCyphers = (tANI_U8)(pWapiIe->unicast_cipher_suite_count);
3638 cAuthSuites = (tANI_U8)(pWapiIe->akm_suite_count);
3639 for(i = 0; i < cAuthSuites && i < CSR_WAPI_MAX_AUTH_SUITES; i++)
3640 {
3641 palCopyMemory(pMac->hHdd, (void *)&AuthSuites[i],
3642 (void *)&pWapiIe->akm_suites[i], CSR_WAPI_OUI_SIZE);
3643 }
3644
3645 //Check - Is requested Unicast Cipher supported by the BSS.
3646 fAcceptableCyphers = csrMatchWapiOUIIndex( pMac, pWapiIe->unicast_cipher_suites, cUnicastCyphers,
3647 csrGetOUIIndexFromCipher( enType ), Unicast );
3648
3649 if( !fAcceptableCyphers ) break;
3650
3651
3652 //Unicast is supported. Pick the first matching Group cipher, if any.
3653 for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
3654 {
3655 fAcceptableCyphers = csrMatchWapiOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
3656 csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i] ), Multicast );
3657 if(fAcceptableCyphers)
3658 {
3659 break;
3660 }
3661 }
3662 if( !fAcceptableCyphers ) break;
3663
3664 if( pNegotiatedMCCipher )
3665 *pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
3666
3667 //Ciphers are supported, Match authentication algorithm and pick first matching authtype.
3668 if ( csrIsAuthWapiCert( pMac, AuthSuites, cAuthSuites, Authentication ) )
3669 {
3670 negAuthType = eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
3671 }
3672 else if ( csrIsAuthWapiPsk( pMac, AuthSuites, cAuthSuites, Authentication ) )
3673 {
3674 negAuthType = eCSR_AUTH_TYPE_WAPI_WAI_PSK;
3675 }
3676 else
3677 {
3678 fAcceptableCyphers = FALSE;
3679 negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3680 }
3681 if( ( 0 == pAuthType->numEntries ) || ( FALSE == fAcceptableCyphers ) )
3682 {
3683 //Caller doesn't care about auth type, or BSS doesn't match
3684 break;
3685 }
3686 fAcceptableCyphers = FALSE;
3687 for( i = 0 ; i < pAuthType->numEntries; i++ )
3688 {
3689 if( pAuthType->authType[i] == negAuthType )
3690 {
3691 fAcceptableCyphers = TRUE;
3692 break;
3693 }
3694 }
3695 }
3696 }while (0);
3697
3698 if ( fAcceptableCyphers )
3699 {
3700 if ( MulticastCypher )
3701 {
3702 palCopyMemory( pMac->hHdd, MulticastCypher, Multicast, CSR_WAPI_OUI_SIZE );
3703 }
3704
3705 if ( UnicastCypher )
3706 {
3707 palCopyMemory( pMac->hHdd, UnicastCypher, Unicast, CSR_WAPI_OUI_SIZE );
3708 }
3709
3710 if ( AuthSuite )
3711 {
3712 palCopyMemory( pMac->hHdd, AuthSuite, Authentication, CSR_WAPI_OUI_SIZE );
3713 }
3714
3715 if ( pNegotiatedAuthtype )
3716 {
3717 *pNegotiatedAuthtype = negAuthType;
3718 }
3719 }
3720 return( fAcceptableCyphers );
3721}
3722
3723tANI_BOOLEAN csrIsWapiMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
3724 tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
3725{
3726 tANI_BOOLEAN fWapiMatch = FALSE;
3727
3728 // See if the cyphers in the Bss description match with the settings in the profile.
3729 fWapiMatch = csrGetWapiInformation( hHal, pAuthType, enType, pEnMcType, &pIes->WAPI, NULL, NULL, NULL,
3730 pNegotiatedAuthType, pNegotiatedMCCipher );
3731
3732 return( fWapiMatch );
3733}
3734
3735tANI_BOOLEAN csrLookupBKID( tpAniSirGlobal pMac, tANI_U32 sessionId, tANI_U8 *pBSSId, tANI_U8 *pBKId )
3736{
3737 tANI_BOOLEAN fRC = FALSE, fMatchFound = FALSE;
3738 tANI_U32 Index;
3739 tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
3740
3741 do
3742 {
3743 for( Index=0; Index < pSession->NumBkidCache; Index++ )
3744 {
3745 smsLog(pMac, LOGW, "match BKID %02X-%02X-%02X-%02X-%02X-%02X to \n",
3746 pBSSId[0], pBSSId[1], pBSSId[2], pBSSId[3], pBSSId[4], pBSSId[5]);
3747 if( palEqualMemory( pMac->hHdd, pBSSId, pSession->BkidCacheInfo[Index].BSSID, sizeof(tCsrBssid) ) )
3748 {
3749 // match found
3750 fMatchFound = TRUE;
3751 break;
3752 }
3753 }
3754
3755 if( !fMatchFound ) break;
3756
3757 palCopyMemory( pMac->hHdd, pBKId, pSession->BkidCacheInfo[Index].BKID, CSR_WAPI_BKID_SIZE );
3758
3759 fRC = TRUE;
3760 }
3761 while( 0 );
3762 smsLog(pMac, LOGW, "csrLookupBKID called return match = %d pMac->roam.NumBkidCache = %d", fRC, pSession->NumBkidCache);
3763
3764 return fRC;
3765}
3766
3767tANI_U8 csrConstructWapiIe( tpAniSirGlobal pMac, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
3768 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrWapiIe *pWapiIe )
3769{
3770 tANI_BOOLEAN fWapiMatch = FALSE;
3771 tANI_U8 cbWapiIe = 0;
3772 tANI_U8 UnicastCypher[ CSR_WAPI_OUI_SIZE ];
3773 tANI_U8 MulticastCypher[ CSR_WAPI_OUI_SIZE ];
3774 tANI_U8 AuthSuite[ CSR_WAPI_OUI_SIZE ];
3775 tANI_U8 BKId[CSR_WAPI_BKID_SIZE];
3776 tANI_U8 *pWapi = NULL;
3777 tANI_BOOLEAN fBKIDFound = FALSE;
3778 tDot11fBeaconIEs *pIesLocal = pIes;
3779
3780 do
3781 {
3782 if ( !csrIsProfileWapi( pProfile ) ) break;
3783
3784 if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
3785 {
3786 break;
3787 }
3788
3789 // See if the cyphers in the Bss description match with the settings in the profile.
3790 fWapiMatch = csrGetWapiInformation( pMac, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType,
3791 &pProfile->mcEncryptionType, &pIesLocal->WAPI,
3792 UnicastCypher, MulticastCypher, AuthSuite, NULL, NULL );
3793 if ( !fWapiMatch ) break;
3794
3795 palZeroMemory(pMac->hHdd, pWapiIe, sizeof(tCsrWapiIe));
3796
3797 pWapiIe->IeHeader.ElementID = DOT11F_EID_WAPI;
3798
3799 pWapiIe->Version = CSR_WAPI_VERSION_SUPPORTED;
3800
3801 pWapiIe->cAuthenticationSuites = 1;
3802 palCopyMemory( pMac->hHdd, &pWapiIe->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
3803
3804 pWapi = (tANI_U8 *) (&pWapiIe->AuthOui[ 1 ]);
3805
3806 *pWapi = (tANI_U16)1; //cUnicastCyphers
3807 pWapi+=2;
3808 palCopyMemory( pMac->hHdd, pWapi, UnicastCypher, sizeof( UnicastCypher ) );
3809 pWapi += sizeof( UnicastCypher );
3810
3811 palCopyMemory( pMac->hHdd, pWapi, MulticastCypher, sizeof( MulticastCypher ) );
3812 pWapi += sizeof( MulticastCypher );
3813
3814
3815 // WAPI capabilities follows the Auth Suite (two octects)
3816 // we shouldn't EVER be sending out "pre-auth supported". It is an AP only capability
3817 // & since we already did a memset pWapiIe to 0, skip these fields
3818 pWapi +=2;
3819
3820 fBKIDFound = csrLookupBKID( pMac, sessionId, pSirBssDesc->bssId, &(BKId[0]) );
3821
3822
3823 if( fBKIDFound )
3824 {
3825 /* Do we need to change the endianness here */
3826 *pWapi = (tANI_U16)1; //cBKIDs
3827 pWapi+=2;
3828 palCopyMemory( pMac->hHdd, pWapi, BKId, CSR_WAPI_BKID_SIZE );
3829 }
3830 else
3831 {
3832 *pWapi = 0;
3833 pWapi+=1;
3834 *pWapi = 0;
3835 pWapi+=1;
3836 }
3837
3838 // Add in the IE fields except the IE header
3839 // Add BKID count and BKID (if any)
3840 pWapiIe->IeHeader.Length = (tANI_U8) (sizeof( *pWapiIe ) - sizeof ( pWapiIe->IeHeader ));
3841
3842 /*2 bytes for BKID Count field*/
3843 pWapiIe->IeHeader.Length += sizeof( tANI_U16 );
3844
3845 if(fBKIDFound)
3846 {
3847 pWapiIe->IeHeader.Length += CSR_WAPI_BKID_SIZE;
3848 }
3849 // return the size of the IE header (total) constructed...
3850 cbWapiIe = pWapiIe->IeHeader.Length + sizeof( pWapiIe->IeHeader );
3851
3852 } while( 0 );
3853
3854 if( !pIes && pIesLocal )
3855 {
3856 //locally allocated
3857 palFreeMemory(pMac->hHdd, pIesLocal);
3858 }
3859
3860 return( cbWapiIe );
3861}
3862#endif /* FEATURE_WLAN_WAPI */
3863
3864tANI_BOOLEAN csrGetWpaCyphers( tpAniSirGlobal pMac, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pMCEncryption,
3865 tDot11fIEWPA *pWpaIe,
3866 tANI_U8 *UnicastCypher,
3867 tANI_U8 *MulticastCypher,
3868 tANI_U8 *AuthSuite,
3869 eCsrAuthType *pNegotiatedAuthtype,
3870 eCsrEncryptionType *pNegotiatedMCCipher )
3871{
3872 tANI_BOOLEAN fAcceptableCyphers = FALSE;
3873 tANI_U8 cUnicastCyphers = 0;
3874 tANI_U8 cMulticastCyphers = 0;
3875 tANI_U8 cAuthSuites = 0;
3876 tANI_U8 Unicast[ CSR_WPA_OUI_SIZE ];
3877 tANI_U8 Multicast[ CSR_WPA_OUI_SIZE ];
3878 tANI_U8 Authentication[ CSR_WPA_OUI_SIZE ];
3879 tANI_U8 MulticastCyphers[ 1 ][ CSR_WPA_OUI_SIZE ];
3880 tANI_U8 i;
3881 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
3882
3883 do
3884 {
3885 if ( pWpaIe->present )
3886 {
3887 cMulticastCyphers = 1;
3888 palCopyMemory(pMac->hHdd, MulticastCyphers, pWpaIe->multicast_cipher, CSR_WPA_OUI_SIZE);
3889 cUnicastCyphers = (tANI_U8)(pWpaIe->unicast_cipher_count);
3890 cAuthSuites = (tANI_U8)(pWpaIe->auth_suite_count);
3891
3892 //Check - Is requested Unicast Cipher supported by the BSS.
3893 fAcceptableCyphers = csrMatchWPAOUIIndex( pMac, pWpaIe->unicast_ciphers, cUnicastCyphers,
3894 csrGetOUIIndexFromCipher( enType ), Unicast );
3895
3896 if( !fAcceptableCyphers ) break;
3897
3898
3899 //Unicast is supported. Pick the first matching Group cipher, if any.
3900 for( i = 0 ; i < pMCEncryption->numEntries ; i++ )
3901 {
3902 fAcceptableCyphers = csrMatchWPAOUIIndex( pMac, MulticastCyphers, cMulticastCyphers,
3903 csrGetOUIIndexFromCipher( pMCEncryption->encryptionType[i]), Multicast );
3904 if(fAcceptableCyphers)
3905 {
3906 break;
3907 }
3908 }
3909 if( !fAcceptableCyphers ) break;
3910
3911 if( pNegotiatedMCCipher )
3912 *pNegotiatedMCCipher = pMCEncryption->encryptionType[i];
3913
3914 /* Initializing with FALSE as it has TRUE value already */
3915 fAcceptableCyphers = FALSE;
3916 for (i = 0 ; i < pAuthType->numEntries; i++)
3917 {
3918 //Ciphers are supported, Match authentication algorithm and pick first matching authtype.
3919 if ( csrIsAuthWpa( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
3920 {
3921 if (eCSR_AUTH_TYPE_WPA == pAuthType->authType[i])
3922 negAuthType = eCSR_AUTH_TYPE_WPA;
3923 }
3924 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsAuthWpaPsk( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
3925 {
3926 if (eCSR_AUTH_TYPE_WPA_PSK == pAuthType->authType[i])
3927 negAuthType = eCSR_AUTH_TYPE_WPA_PSK;
3928 }
3929#ifdef FEATURE_WLAN_CCX
3930 if ( (negAuthType == eCSR_AUTH_TYPE_UNKNOWN) && csrIsCcxCckmAuthWpa( pMac, pWpaIe->auth_suites, cAuthSuites, Authentication ) )
3931 {
3932 if (eCSR_AUTH_TYPE_CCKM_WPA == pAuthType->authType[i])
3933 negAuthType = eCSR_AUTH_TYPE_CCKM_WPA;
3934 }
3935#endif /* FEATURE_WLAN_CCX */
3936
3937 // The 1st auth type in the APs WPA IE, to match stations connecting
3938 // profiles auth type will cause us to exit this loop
3939 // This is added as some APs advertise multiple akms in the WPA IE.
3940 if (eCSR_AUTH_TYPE_UNKNOWN != negAuthType)
3941 {
3942 fAcceptableCyphers = TRUE;
3943 break;
3944 }
3945 } // for
3946 }
3947 }while(0);
3948
3949 if ( fAcceptableCyphers )
3950 {
3951 if ( MulticastCypher )
3952 {
3953 palCopyMemory( pMac->hHdd, (tANI_U8 **)MulticastCypher, Multicast, CSR_WPA_OUI_SIZE );
3954 }
3955
3956 if ( UnicastCypher )
3957 {
3958 palCopyMemory( pMac->hHdd, (tANI_U8 **)UnicastCypher, Unicast, CSR_WPA_OUI_SIZE );
3959 }
3960
3961 if ( AuthSuite )
3962 {
3963 palCopyMemory( pMac->hHdd, (tANI_U8 **)AuthSuite, Authentication, CSR_WPA_OUI_SIZE );
3964 }
3965
3966 if( pNegotiatedAuthtype )
3967 {
3968 *pNegotiatedAuthtype = negAuthType;
3969 }
3970 }
3971
3972 return( fAcceptableCyphers );
3973}
3974
3975
3976
3977tANI_BOOLEAN csrIsWpaEncryptionMatch( tpAniSirGlobal pMac, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
3978 tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthtype, eCsrEncryptionType *pNegotiatedMCCipher )
3979{
3980 tANI_BOOLEAN fWpaMatch = eANI_BOOLEAN_FALSE;
3981
3982 // See if the cyphers in the Bss description match with the settings in the profile.
3983 fWpaMatch = csrGetWpaCyphers( pMac, pAuthType, enType, pEnMcType, &pIes->WPA, NULL, NULL, NULL, pNegotiatedAuthtype, pNegotiatedMCCipher );
3984
3985 return( fWpaMatch );
3986}
3987
3988
3989tANI_U8 csrConstructWpaIe( tHalHandle hHal, tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
3990 tDot11fBeaconIEs *pIes, tCsrWpaIe *pWpaIe )
3991{
3992 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
3993 tANI_BOOLEAN fWpaMatch;
3994 tANI_U8 cbWpaIe = 0;
3995 tANI_U8 UnicastCypher[ CSR_WPA_OUI_SIZE ];
3996 tANI_U8 MulticastCypher[ CSR_WPA_OUI_SIZE ];
3997 tANI_U8 AuthSuite[ CSR_WPA_OUI_SIZE ];
3998 tCsrWpaAuthIe *pAuthSuite;
3999 tDot11fBeaconIEs *pIesLocal = pIes;
4000
4001 do
4002 {
4003 if ( !csrIsProfileWpa( pProfile ) ) break;
4004
4005 if( !pIesLocal && (!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pSirBssDesc, &pIesLocal))) )
4006 {
4007 break;
4008 }
4009 // See if the cyphers in the Bss description match with the settings in the profile.
4010 fWpaMatch = csrGetWpaCyphers( hHal, &pProfile->AuthType, pProfile->negotiatedUCEncryptionType, &pProfile->mcEncryptionType,
4011 &pIesLocal->WPA, UnicastCypher, MulticastCypher, AuthSuite, NULL, NULL );
4012 if ( !fWpaMatch ) break;
4013
4014 pWpaIe->IeHeader.ElementID = SIR_MAC_WPA_EID;
4015
4016 palCopyMemory( pMac->hHdd, pWpaIe->Oui, csrWpaOui[01], sizeof( pWpaIe->Oui ) );
4017
4018 pWpaIe->Version = CSR_WPA_VERSION_SUPPORTED;
4019
4020 palCopyMemory( pMac->hHdd, pWpaIe->MulticastOui, MulticastCypher, sizeof( MulticastCypher ) );
4021
4022 pWpaIe->cUnicastCyphers = 1;
4023
4024 palCopyMemory( pMac->hHdd, &pWpaIe->UnicastOui[ 0 ], UnicastCypher, sizeof( UnicastCypher ) );
4025
4026 pAuthSuite = (tCsrWpaAuthIe *)( &pWpaIe->UnicastOui[ pWpaIe->cUnicastCyphers ] );
4027
4028 pAuthSuite->cAuthenticationSuites = 1;
4029 palCopyMemory( pMac->hHdd, &pAuthSuite->AuthOui[ 0 ], AuthSuite, sizeof( AuthSuite ) );
4030
4031 // The WPA capabilities follows the Auth Suite (two octects)--
4032 // this field is optional, and we always "send" zero, so just
4033 // remove it. This is consistent with our assumptions in the
4034 // frames compiler; c.f. bug 15234:
4035 // http://gold.woodsidenet.com/bugzilla/show_bug.cgi?id=15234
4036
4037 // Add in the fixed fields plus 1 Unicast cypher, less the IE Header length
4038 // Add in the size of the Auth suite (count plus a single OUI)
4039 pWpaIe->IeHeader.Length = sizeof( *pWpaIe ) - sizeof ( pWpaIe->IeHeader ) +
4040 sizeof( *pAuthSuite );
4041
4042 // return the size of the IE header (total) constructed...
4043 cbWpaIe = pWpaIe->IeHeader.Length + sizeof( pWpaIe->IeHeader );
4044
4045 } while( 0 );
4046
4047 if( !pIes && pIesLocal )
4048 {
4049 //locally allocated
4050 palFreeMemory(pMac->hHdd, pIesLocal);
4051 }
4052
4053 return( cbWpaIe );
4054}
4055
4056
4057tANI_BOOLEAN csrGetWpaRsnIe( tHalHandle hHal, tANI_U8 *pIes, tANI_U32 len,
4058 tANI_U8 *pWpaIe, tANI_U8 *pcbWpaIe, tANI_U8 *pRSNIe, tANI_U8 *pcbRSNIe)
4059{
4060 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4061 tDot11IEHeader *pIEHeader;
4062 tSirMacPropIE *pSirMacPropIE;
4063 tANI_U32 cbParsed;
4064 tANI_U32 cbIE;
4065 int cExpectedIEs = 0;
4066 int cFoundIEs = 0;
4067 int cbPropIETotal;
4068
4069 pIEHeader = (tDot11IEHeader *)pIes;
4070 if(pWpaIe) cExpectedIEs++;
4071 if(pRSNIe) cExpectedIEs++;
4072
4073 // bss description length includes all fields other than the length itself
4074 cbParsed = 0;
4075
4076 // Loop as long as there is data left in the IE of the Bss Description
4077 // and the number of Expected IEs is NOT found yet.
4078 while( ( (cbParsed + sizeof( *pIEHeader )) <= len ) && ( cFoundIEs < cExpectedIEs ) )
4079 {
4080 cbIE = sizeof( *pIEHeader ) + pIEHeader->Length;
4081
4082 if ( ( cbIE + cbParsed ) > len ) break;
4083
4084 if ( ( pIEHeader->Length >= gCsrIELengthTable[ pIEHeader->ElementID ].min ) &&
4085 ( pIEHeader->Length <= gCsrIELengthTable[ pIEHeader->ElementID ].max ) )
4086 {
4087 switch( pIEHeader->ElementID )
4088 {
4089 // Parse the 221 (0xdd) Proprietary IEs here...
4090 // Note that the 221 IE is overloaded, containing the WPA IE, WMM/WME IE, and the
4091 // Airgo proprietary IE information.
4092 case SIR_MAC_WPA_EID:
4093 {
4094 tANI_U32 aniOUI;
4095 tANI_U8 *pOui = (tANI_U8 *)&aniOUI;
4096
4097 pOui++;
4098 aniOUI = ANI_OUI;
4099 aniOUI = i_ntohl( aniOUI );
4100
4101 pSirMacPropIE = ( tSirMacPropIE *)pIEHeader;
4102 cbPropIETotal = pSirMacPropIE->length;
4103
4104 // Validate the ANI OUI is in the OUI field in the proprietary IE...
4105 if ( ( pSirMacPropIE->length >= WNI_CFG_MANUFACTURER_OUI_LEN ) &&
4106 pOui[ 0 ] == pSirMacPropIE->oui[ 0 ] &&
4107 pOui[ 1 ] == pSirMacPropIE->oui[ 1 ] &&
4108 pOui[ 2 ] == pSirMacPropIE->oui[ 2 ] )
4109 {
4110 }
4111 else
4112 {
4113 tCsrWpaIe *pIe = ( tCsrWpaIe * )pIEHeader;
4114
4115 if(!pWpaIe || !pcbWpaIe) break;
4116 // Check if this is a valid WPA IE. Then check that the
4117 // WPA OUI is in place and the version is one that we support.
4118 if ( ( pIe->IeHeader.Length >= SIR_MAC_WPA_IE_MIN_LENGTH ) &&
4119 ( palEqualMemory(pMac->hHdd, pIe->Oui, (void *)csrWpaOui[1], sizeof( pIe->Oui ) ) ) &&
4120 ( pIe->Version <= CSR_WPA_VERSION_SUPPORTED ) )
4121 {
4122 palCopyMemory(pMac->hHdd, pWpaIe, pIe, pIe->IeHeader.Length + sizeof( pIe->IeHeader ) );
4123 *pcbWpaIe = pIe->IeHeader.Length + sizeof( pIe->IeHeader );
4124 cFoundIEs++;
4125
4126 break;
4127 }
4128 }
4129
4130 break;
4131 }
4132
4133 case SIR_MAC_RSN_EID:
4134 {
4135 tCsrRSNIe *pIe;
4136
4137 if(!pcbRSNIe || !pRSNIe) break;
4138 pIe = (tCsrRSNIe *)pIEHeader;
4139
4140 // Check the length of the RSN Ie to assure it is valid. Then check that the
4141 // version is one that we support.
4142
4143 if ( pIe->IeHeader.Length < SIR_MAC_RSN_IE_MIN_LENGTH ) break;
4144 if ( pIe->Version > CSR_RSN_VERSION_SUPPORTED ) break;
4145
4146 cFoundIEs++;
4147
4148 // if there is enough room in the WpaIE passed in, then copy the Wpa IE into
4149 // the buffer passed in.
4150 if ( *pcbRSNIe < pIe->IeHeader.Length + sizeof( pIe->IeHeader ) ) break;
4151 palCopyMemory(pMac->hHdd, pRSNIe, pIe, pIe->IeHeader.Length + sizeof( pIe->IeHeader ) );
4152 *pcbRSNIe = pIe->IeHeader.Length + sizeof( pIe->IeHeader );
4153
4154 break;
4155 }
4156
4157 // Add support for other IE here...
4158 default:
4159 break;
4160 }
4161 }
4162
4163 cbParsed += cbIE;
4164
4165 pIEHeader = (tDot11IEHeader *)( ((tANI_U8 *)pIEHeader) + cbIE );
4166
4167 }
4168
4169 // return a BOOL that tells if all of the IEs asked for were found...
4170 return( cFoundIEs == cExpectedIEs );
4171}
4172
4173
4174//If a WPAIE exists in the profile, just use it. Or else construct one from the BSS
4175//Caller allocated memory for pWpaIe and guarrantee it can contain a max length WPA IE
4176tANI_U8 csrRetrieveWpaIe( tHalHandle hHal, tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
4177 tDot11fBeaconIEs *pIes, tCsrWpaIe *pWpaIe )
4178{
4179 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4180 tANI_U8 cbWpaIe = 0;
4181
4182 do
4183 {
4184 if ( !csrIsProfileWpa( pProfile ) ) break;
4185 if(pProfile->nWPAReqIELength && pProfile->pWPAReqIE)
4186 {
4187 if(SIR_MAC_WPA_IE_MAX_LENGTH >= pProfile->nWPAReqIELength)
4188 {
4189 cbWpaIe = (tANI_U8)pProfile->nWPAReqIELength;
4190 palCopyMemory(pMac->hHdd, pWpaIe, pProfile->pWPAReqIE, cbWpaIe);
4191 }
4192 else
4193 {
4194 smsLog(pMac, LOGW, " csrRetrieveWpaIe detect invalid WPA IE length (%d) \n", pProfile->nWPAReqIELength);
4195 }
4196 }
4197 else
4198 {
4199 cbWpaIe = csrConstructWpaIe(pMac, pProfile, pSirBssDesc, pIes, pWpaIe);
4200 }
4201 }while(0);
4202
4203 return (cbWpaIe);
4204}
4205
4206
4207//If a RSNIE exists in the profile, just use it. Or else construct one from the BSS
4208//Caller allocated memory for pWpaIe and guarrantee it can contain a max length WPA IE
4209tANI_U8 csrRetrieveRsnIe( tHalHandle hHal, tANI_U32 sessionId, tCsrRoamProfile *pProfile,
4210 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes, tCsrRSNIe *pRsnIe )
4211{
4212 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4213 tANI_U8 cbRsnIe = 0;
4214
4215 do
4216 {
4217 if ( !csrIsProfileRSN( pProfile ) ) break;
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]4218#ifdef FEATURE_WLAN_LFR
4219 if (csrRoamIsFastRoamEnabled(pMac))
4220 {
4221 // If "Legacy Fast Roaming" is enabled ALWAYS rebuild the RSN IE from
4222 // scratch. So it contains the current PMK-IDs
4223 cbRsnIe = csrConstructRSNIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pRsnIe);
4224 }
4225 else
4226#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4227 if(pProfile->nRSNReqIELength && pProfile->pRSNReqIE)
4228 {
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]4229 // If you have one started away, re-use it.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4230 if(SIR_MAC_WPA_IE_MAX_LENGTH >= pProfile->nRSNReqIELength)
4231 {
4232 cbRsnIe = (tANI_U8)pProfile->nRSNReqIELength;
4233 palCopyMemory(pMac->hHdd, pRsnIe, pProfile->pRSNReqIE, cbRsnIe);
4234 }
4235 else
4236 {
4237 smsLog(pMac, LOGW, " csrRetrieveRsnIe detect invalid RSN IE length (%d) \n", pProfile->nRSNReqIELength);
4238 }
4239 }
4240 else
4241 {
4242 cbRsnIe = csrConstructRSNIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pRsnIe);
4243 }
4244 }while(0);
4245
4246 return (cbRsnIe);
4247}
4248
4249
4250#ifdef FEATURE_WLAN_WAPI
4251//If a WAPI IE exists in the profile, just use it. Or else construct one from the BSS
4252//Caller allocated memory for pWapiIe and guarrantee it can contain a max length WAPI IE
4253tANI_U8 csrRetrieveWapiIe( tHalHandle hHal, tANI_U32 sessionId,
4254 tCsrRoamProfile *pProfile, tSirBssDescription *pSirBssDesc,
4255 tDot11fBeaconIEs *pIes, tCsrWapiIe *pWapiIe )
4256{
4257 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4258 tANI_U8 cbWapiIe = 0;
4259
4260 do
4261 {
4262 if ( !csrIsProfileWapi( pProfile ) ) break;
4263 if(pProfile->nWAPIReqIELength && pProfile->pWAPIReqIE)
4264 {
4265 if(DOT11F_IE_WAPI_MAX_LEN >= pProfile->nWAPIReqIELength)
4266 {
4267 cbWapiIe = (tANI_U8)pProfile->nWAPIReqIELength;
4268 palCopyMemory(pMac->hHdd, pWapiIe, pProfile->pWAPIReqIE, cbWapiIe);
4269 }
4270 else
4271 {
4272 smsLog(pMac, LOGW, " csrRetrieveWapiIe detect invalid WAPI IE length (%d) \n", pProfile->nWAPIReqIELength);
4273 }
4274 }
4275 else
4276 {
4277 cbWapiIe = csrConstructWapiIe(pMac, sessionId, pProfile, pSirBssDesc, pIes, pWapiIe);
4278 }
4279 }while(0);
4280
4281 return (cbWapiIe);
4282}
4283#endif /* FEATURE_WLAN_WAPI */
4284
4285tANI_BOOLEAN csrSearchChannelListForTxPower(tHalHandle hHal, tSirBssDescription *pBssDescription, tCsrChannelSet *returnChannelGroup)
4286{
4287 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4288 tListElem *pEntry;
4289 tANI_U16 i;
4290 tANI_U16 startingChannel;
4291 tANI_BOOLEAN found = FALSE;
4292 tCsrChannelSet *pChannelGroup;
4293
4294 pEntry = csrLLPeekHead( &pMac->roam.channelList5G, LL_ACCESS_LOCK );
4295
4296 while ( pEntry )
4297 {
4298 pChannelGroup = GET_BASE_ADDR( pEntry, tCsrChannelSet, channelListLink );
4299 startingChannel = pChannelGroup->firstChannel;
4300 for ( i = 0; i < pChannelGroup->numChannels; i++ )
4301 {
4302 if ( startingChannel + i * pChannelGroup->interChannelOffset == pBssDescription->channelId )
4303 {
4304 found = TRUE;
4305 break;
4306 }
4307 }
4308
4309 if ( found )
4310 {
4311 palCopyMemory(pMac->hHdd, returnChannelGroup, pChannelGroup, sizeof(tCsrChannelSet));
4312 break;
4313 }
4314 else
4315 {
4316 pEntry = csrLLNext( &pMac->roam.channelList5G, pEntry, LL_ACCESS_LOCK );
4317 }
4318 }
4319
4320 return( found );
4321}
4322
4323tANI_BOOLEAN csrRatesIsDot11Rate11bSupportedRate( tANI_U8 dot11Rate )
4324{
4325 tANI_BOOLEAN fSupported = FALSE;
4326 tANI_U16 nonBasicRate = (tANI_U16)( BITS_OFF( dot11Rate, CSR_DOT11_BASIC_RATE_MASK ) );
4327
4328 switch ( nonBasicRate )
4329 {
4330 case eCsrSuppRate_1Mbps:
4331 case eCsrSuppRate_2Mbps:
4332 case eCsrSuppRate_5_5Mbps:
4333 case eCsrSuppRate_11Mbps:
4334 fSupported = TRUE;
4335 break;
4336
4337 default:
4338 break;
4339 }
4340
4341 return( fSupported );
4342}
4343
4344tANI_BOOLEAN csrRatesIsDot11Rate11aSupportedRate( tANI_U8 dot11Rate )
4345{
4346 tANI_BOOLEAN fSupported = FALSE;
4347 tANI_U16 nonBasicRate = (tANI_U16)( BITS_OFF( dot11Rate, CSR_DOT11_BASIC_RATE_MASK ) );
4348
4349 switch ( nonBasicRate )
4350 {
4351 case eCsrSuppRate_6Mbps:
4352 case eCsrSuppRate_9Mbps:
4353 case eCsrSuppRate_12Mbps:
4354 case eCsrSuppRate_18Mbps:
4355 case eCsrSuppRate_24Mbps:
4356 case eCsrSuppRate_36Mbps:
4357 case eCsrSuppRate_48Mbps:
4358 case eCsrSuppRate_54Mbps:
4359 fSupported = TRUE;
4360 break;
4361
4362 default:
4363 break;
4364 }
4365
4366 return( fSupported );
4367}
4368
4369
4370
4371tAniEdType csrTranslateEncryptTypeToEdType( eCsrEncryptionType EncryptType )
4372{
4373 tAniEdType edType;
4374
4375 switch ( EncryptType )
4376 {
4377 default:
4378 case eCSR_ENCRYPT_TYPE_NONE:
4379 edType = eSIR_ED_NONE;
4380 break;
4381
4382 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
4383 case eCSR_ENCRYPT_TYPE_WEP40:
4384 edType = eSIR_ED_WEP40;
4385 break;
4386
4387 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
4388 case eCSR_ENCRYPT_TYPE_WEP104:
4389 edType = eSIR_ED_WEP104;
4390 break;
4391
4392 case eCSR_ENCRYPT_TYPE_TKIP:
4393 edType = eSIR_ED_TKIP;
4394 break;
4395
4396 case eCSR_ENCRYPT_TYPE_AES:
4397 edType = eSIR_ED_CCMP;
4398 break;
4399#ifdef FEATURE_WLAN_WAPI
4400 case eCSR_ENCRYPT_TYPE_WPI:
4401 edType = eSIR_ED_WPI;
4402#endif
4403#ifdef WLAN_FEATURE_11W
4404 //11w BIP
4405 case eCSR_ENCRYPT_TYPE_AES_CMAC:
4406 edType = eSIR_ED_AES_128_CMAC;
4407 break;
4408#endif
4409 }
4410
4411 return( edType );
4412}
4413
4414
4415//pIes can be NULL
4416tANI_BOOLEAN csrValidateWep( tpAniSirGlobal pMac, eCsrEncryptionType ucEncryptionType,
4417 tCsrAuthList *pAuthList, tCsrEncryptionList *pMCEncryptionList,
4418 eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCEncryption,
4419 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes )
4420{
4421 tANI_U32 idx;
4422 tANI_BOOLEAN fMatch = FALSE;
4423 eCsrAuthType negotiatedAuth = eCSR_AUTH_TYPE_OPEN_SYSTEM;
4424 eCsrEncryptionType negotiatedMCCipher = eCSR_ENCRYPT_TYPE_UNKNOWN;
4425
4426 //This function just checks whether HDD is giving correct values for Multicast cipher and Auth.
4427
4428 do
4429 {
4430 //If privacy bit is not set, consider no match
4431 if ( !csrIsPrivacy( pSirBssDesc ) ) break;
4432
4433 for( idx = 0; idx < pMCEncryptionList->numEntries; idx++ )
4434 {
4435 switch( pMCEncryptionList->encryptionType[idx] )
4436 {
4437 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
4438 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
4439 case eCSR_ENCRYPT_TYPE_WEP40:
4440 case eCSR_ENCRYPT_TYPE_WEP104:
4441 /* Multicast list may contain WEP40/WEP104. Check whether it matches UC.
4442 */
4443 if( ucEncryptionType == pMCEncryptionList->encryptionType[idx] )
4444 {
4445 fMatch = TRUE;
4446 negotiatedMCCipher = pMCEncryptionList->encryptionType[idx];
4447 }
4448 break;
4449 default:
4450 fMatch = FALSE;
4451 break;
4452 }
4453 if(fMatch) break;
4454 }
4455
4456 if(!fMatch) break;
4457
4458 for( idx = 0; idx < pAuthList->numEntries; idx++ )
4459 {
4460 switch( pAuthList->authType[idx] )
4461 {
4462 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
4463 case eCSR_AUTH_TYPE_SHARED_KEY:
4464 case eCSR_AUTH_TYPE_AUTOSWITCH:
4465 fMatch = TRUE;
4466 negotiatedAuth = pAuthList->authType[idx];
4467 break;
4468 default:
4469 fMatch = FALSE;
4470 }
4471 if (fMatch) break;
4472 }
4473
4474 if(!fMatch) break;
4475 //In case of WPA / WPA2, check whether it supports WEP as well
4476 if(pIes)
4477 {
4478 //Prepare the encryption type for WPA/WPA2 functions
4479 if( eCSR_ENCRYPT_TYPE_WEP40_STATICKEY == ucEncryptionType )
4480 {
4481 ucEncryptionType = eCSR_ENCRYPT_TYPE_WEP40;
4482 }
4483 else if( eCSR_ENCRYPT_TYPE_WEP104 == ucEncryptionType )
4484 {
4485 ucEncryptionType = eCSR_ENCRYPT_TYPE_WEP104;
4486 }
4487 //else we can use the encryption type directly
4488 if( pIes->WPA.present )
4489 {
4490 fMatch = palEqualMemory(pMac->hHdd, pIes->WPA.multicast_cipher,
4491 csrWpaOui[csrGetOUIIndexFromCipher( ucEncryptionType )], CSR_WPA_OUI_SIZE );
4492 if( fMatch ) break;
4493 }
4494 if( pIes->RSN.present )
4495 {
4496 fMatch = palEqualMemory(pMac->hHdd, pIes->RSN.gp_cipher_suite,
4497 csrRSNOui[csrGetOUIIndexFromCipher( ucEncryptionType )], CSR_RSN_OUI_SIZE );
4498 }
4499 }
4500
4501 }while(0);
4502
4503 if( fMatch )
4504 {
4505 if( pNegotiatedAuthType )
4506 *pNegotiatedAuthType = negotiatedAuth;
4507
4508 if( pNegotiatedMCEncryption )
4509 *pNegotiatedMCEncryption = negotiatedMCCipher;
4510 }
4511
4512
4513 return fMatch;
4514}
4515
4516
4517//pIes shall contain IEs from pSirBssDesc. It shall be returned from function csrGetParsedBssDescriptionIEs
4518tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEncryptionList *pUCEncryptionType, tCsrEncryptionList *pMCEncryptionType,
4519 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes,
4520 eCsrAuthType *negotiatedAuthtype, eCsrEncryptionType *negotiatedUCCipher, eCsrEncryptionType *negotiatedMCCipher )
4521{
4522 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4523 tANI_BOOLEAN fMatch = FALSE;
4524 tANI_U8 i,idx;
4525 eCsrEncryptionType mcCipher = eCSR_ENCRYPT_TYPE_UNKNOWN, ucCipher = eCSR_ENCRYPT_TYPE_UNKNOWN;
4526 eCsrAuthType negAuthType = eCSR_AUTH_TYPE_UNKNOWN;
4527
4528 for( i = 0 ; ((i < pUCEncryptionType->numEntries) && (!fMatch)) ; i++ )
4529 {
4530 ucCipher = pUCEncryptionType->encryptionType[i];
4531 // If the Bss description shows the Privacy bit is on, then we must have some sort of encryption configured
4532 // for the profile to work. Don't attempt to join networks with Privacy bit set when profiles say NONE for
4533 // encryption type.
4534 switch ( ucCipher )
4535 {
4536 case eCSR_ENCRYPT_TYPE_NONE:
4537 {
4538 // for NO encryption, if the Bss description has the Privacy bit turned on, then encryption is
4539 // required so we have to reject this Bss.
4540 if ( csrIsPrivacy( pSirBssDesc ) )
4541 {
4542 fMatch = FALSE;
4543 }
4544 else
4545 {
4546 fMatch = TRUE;
4547 }
4548
4549 if ( fMatch )
4550 {
4551 fMatch = FALSE;
4552 //Check Multicast cipher requested and Auth type requested.
4553 for( idx = 0 ; idx < pMCEncryptionType->numEntries ; idx++ )
4554 {
4555 if( eCSR_ENCRYPT_TYPE_NONE == pMCEncryptionType->encryptionType[idx] )
4556 {
4557 fMatch = TRUE; //Multicast can only be none.
4558 mcCipher = pMCEncryptionType->encryptionType[idx];
4559 break;
4560 }
4561 }
4562 if (!fMatch) break;
4563
4564 fMatch = FALSE;
4565 //Check Auth list. It should contain AuthOpen.
4566 for( idx = 0 ; idx < authType->numEntries ; idx++ )
4567 {
4568 if( eCSR_AUTH_TYPE_OPEN_SYSTEM == authType->authType[idx] )
4569 {
4570 fMatch = TRUE;
4571 negAuthType = eCSR_AUTH_TYPE_OPEN_SYSTEM;
4572 break;
4573 }
4574 }
4575 if (!fMatch) break;
4576
4577 }
4578 break;
4579 }
4580
4581 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
4582 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
4583 // !! might want to check for WEP keys set in the Profile.... ?
4584 // !! don't need to have the privacy bit in the Bss description. Many AP policies make legacy
4585 // encryption 'optional' so we don't know if we can associate or not. The AP will reject if
4586 // encryption is not allowed without the Privacy bit turned on.
4587 fMatch = csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes);
4588
4589 break;
4590
4591 // these are all of the WPA encryption types...
4592 case eCSR_ENCRYPT_TYPE_WEP40:
4593 case eCSR_ENCRYPT_TYPE_WEP104:
4594 fMatch = csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes);
4595 break;
4596
4597 case eCSR_ENCRYPT_TYPE_TKIP:
4598 case eCSR_ENCRYPT_TYPE_AES:
4599 {
4600 if(pIes)
4601 {
4602 // First check if there is a RSN match
4603 fMatch = csrIsRSNMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4604 if( !fMatch )
4605 {
4606 // If not RSN, then check if there is a WPA match
4607 fMatch = csrIsWpaEncryptionMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes,
4608 &negAuthType, &mcCipher );
4609 }
4610 }
4611 else
4612 {
4613 fMatch = FALSE;
4614 }
4615 break;
4616 }
4617#ifdef FEATURE_WLAN_WAPI
4618 case eCSR_ENCRYPT_TYPE_WPI://WAPI
4619 {
4620 if(pIes)
4621 {
4622 fMatch = csrIsWapiMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4623 }
4624 else
4625 {
4626 fMatch = FALSE;
4627 }
4628 break;
4629 }
4630#endif /* FEATURE_WLAN_WAPI */
4631 case eCSR_ENCRYPT_TYPE_ANY:
4632 default:
4633 {
4634 tANI_BOOLEAN fMatchAny = eANI_BOOLEAN_FALSE;
4635
4636 fMatch = eANI_BOOLEAN_TRUE;
4637 //It is allowed to match anything. Try the more secured ones first.
4638 if(pIes)
4639 {
4640 //Check AES first
4641 ucCipher = eCSR_ENCRYPT_TYPE_AES;
4642 fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4643 if(!fMatchAny)
4644 {
4645 //Check TKIP
4646 ucCipher = eCSR_ENCRYPT_TYPE_TKIP;
4647 fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4648 }
4649#ifdef FEATURE_WLAN_WAPI
4650 if(!fMatchAny)
4651 {
4652 //Check WAPI
4653 ucCipher = eCSR_ENCRYPT_TYPE_WPI;
4654 fMatchAny = csrIsWapiMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
4655 }
4656#endif /* FEATURE_WLAN_WAPI */
4657 }
4658 if(!fMatchAny)
4659 {
4660 ucCipher = eCSR_ENCRYPT_TYPE_WEP104;
4661 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4662 {
4663 ucCipher = eCSR_ENCRYPT_TYPE_WEP40;
4664 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4665 {
4666 ucCipher = eCSR_ENCRYPT_TYPE_WEP104_STATICKEY;
4667 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4668 {
4669 ucCipher = eCSR_ENCRYPT_TYPE_WEP40_STATICKEY;
4670 if(!csrValidateWep( pMac, ucCipher, authType, pMCEncryptionType, &negAuthType, &mcCipher, pSirBssDesc, pIes))
4671 {
4672 //It must be open and no encryption
4673 if ( csrIsPrivacy( pSirBssDesc ) )
4674 {
4675 //This is not right
4676 fMatch = eANI_BOOLEAN_FALSE;
4677 }
4678 else
4679 {
4680 negAuthType = eCSR_AUTH_TYPE_OPEN_SYSTEM;
4681 mcCipher = eCSR_ENCRYPT_TYPE_NONE;
4682 ucCipher = eCSR_ENCRYPT_TYPE_NONE;
4683 }
4684 }
4685 }
4686 }
4687 }
4688 }
4689 break;
4690 }
4691 }
4692
4693 }
4694
4695 if( fMatch )
4696 {
4697 if( negotiatedUCCipher )
4698 *negotiatedUCCipher = ucCipher;
4699
4700 if( negotiatedMCCipher )
4701 *negotiatedMCCipher = mcCipher;
4702
4703 if( negotiatedAuthtype )
4704 *negotiatedAuthtype = negAuthType;
4705 }
4706
4707 return( fMatch );
4708}
4709
4710
4711tANI_BOOLEAN csrIsSsidMatch( tpAniSirGlobal pMac, tANI_U8 *ssid1, tANI_U8 ssid1Len, tANI_U8 *bssSsid,
4712 tANI_U8 bssSsidLen, tANI_BOOLEAN fSsidRequired )
4713{
4714 tANI_BOOLEAN fMatch = FALSE;
4715
4716 do {
4717
4718 // There are a few special cases. If the Bss description has a Broadcast SSID,
4719 // then our Profile must have a single SSID without Wildcards so we can program
4720 // the SSID.
4721 // SSID could be suppressed in beacons. In that case SSID IE has valid length
4722 // but the SSID value is all NULL characters. That condition is trated same
4723 // as NULL SSID
4724 if ( csrIsNULLSSID( bssSsid, bssSsidLen ) )
4725 {
4726 if ( eANI_BOOLEAN_FALSE == fSsidRequired )
4727 {
4728 fMatch = TRUE;
4729 }
4730 break;
4731 }
4732
4733 // Check for the specification of the Broadcast SSID at the beginning of the list.
4734 // If specified, then all SSIDs are matches (broadcast SSID means accept all SSIDs).
4735 if ( ssid1Len == 0 )
4736 {
4737 fMatch = TRUE;
4738 break;
4739 }
4740
4741 if(ssid1Len != bssSsidLen) break;
4742 if(palEqualMemory(pMac->hHdd, bssSsid, ssid1, bssSsidLen))
4743 {
4744 fMatch = TRUE;
4745 break;
4746 }
4747
4748 } while( 0 );
4749
4750 return( fMatch );
4751}
4752
4753
4754//Null ssid means match
4755tANI_BOOLEAN csrIsSsidInList( tHalHandle hHal, tSirMacSSid *pSsid, tCsrSSIDs *pSsidList )
4756{
4757 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4758 tANI_BOOLEAN fMatch = FALSE;
4759 tANI_U32 i;
4760
4761 if ( pSsidList && pSsid )
4762 {
4763 for(i = 0; i < pSsidList->numOfSSIDs; i++)
4764 {
4765 if(csrIsNULLSSID(pSsidList->SSIDList[i].SSID.ssId, pSsidList->SSIDList[i].SSID.length) ||
4766 ((pSsidList->SSIDList[i].SSID.length == pSsid->length) &&
4767 palEqualMemory(pMac->hHdd, pSsid->ssId, pSsidList->SSIDList[i].SSID.ssId, pSsid->length)))
4768 {
4769 fMatch = TRUE;
4770 break;
4771 }
4772 }
4773 }
4774
4775 return (fMatch);
4776}
4777
4778//like to use sirCompareMacAddr
4779tANI_BOOLEAN csrIsMacAddressZero( tpAniSirGlobal pMac, tCsrBssid *pMacAddr )
4780{
4781 tANI_U8 bssid[WNI_CFG_BSSID_LEN] = {0, 0, 0, 0, 0, 0};
4782
4783 return( palEqualMemory(pMac->hHdd, bssid, pMacAddr, WNI_CFG_BSSID_LEN));
4784}
4785
4786//like to use sirCompareMacAddr
4787tANI_BOOLEAN csrIsMacAddressBroadcast( tpAniSirGlobal pMac, tCsrBssid *pMacAddr )
4788{
4789 tANI_U8 bssid[WNI_CFG_BSSID_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
4790
4791 return( palEqualMemory(pMac->hHdd, bssid, pMacAddr, WNI_CFG_BSSID_LEN));
4792}
4793
4794
4795//like to use sirCompareMacAddr
4796tANI_BOOLEAN csrIsMacAddressEqual( tpAniSirGlobal pMac, tCsrBssid *pMacAddr1, tCsrBssid *pMacAddr2 )
4797{
4798 return( palEqualMemory(pMac->hHdd, pMacAddr1, pMacAddr2, sizeof(tCsrBssid)) );
4799}
4800
4801
4802tANI_BOOLEAN csrIsBssidMatch( tHalHandle hHal, tCsrBssid *pProfBssid, tCsrBssid *BssBssid )
4803{
4804 tANI_BOOLEAN fMatch = FALSE;
4805 tCsrBssid ProfileBssid;
4806 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
4807
4808 // for efficiency of the MAC_ADDRESS functions, move the
4809 // Bssid's into MAC_ADDRESS structs.
4810 palCopyMemory( pMac->hHdd, &ProfileBssid, pProfBssid, sizeof(tCsrBssid) );
4811
4812 do {
4813
4814 // Give the profile the benefit of the doubt... accept either all 0 or
4815 // the real broadcast Bssid (all 0xff) as broadcast Bssids (meaning to
4816 // match any Bssids).
4817 if ( csrIsMacAddressZero( pMac, &ProfileBssid ) ||
4818 csrIsMacAddressBroadcast( pMac, &ProfileBssid ) )
4819 {
4820 fMatch = TRUE;
4821 break;
4822 }
4823
4824 if ( csrIsMacAddressEqual( pMac, BssBssid, &ProfileBssid ) )
4825 {
4826 fMatch = TRUE;
4827 break;
4828 }
4829
4830 } while( 0 );
4831
4832 return( fMatch );
4833}
4834
4835
4836tANI_BOOLEAN csrIsBSSTypeMatch(eCsrRoamBssType bssType1, eCsrRoamBssType bssType2)
4837{
4838 if((eCSR_BSS_TYPE_ANY != bssType1 && eCSR_BSS_TYPE_ANY != bssType2) && (bssType1 != bssType2))
4839 return eANI_BOOLEAN_FALSE;
4840 else
4841 return eANI_BOOLEAN_TRUE;
4842}
4843
4844
4845tANI_BOOLEAN csrIsBssTypeIBSS(eCsrRoamBssType bssType)
4846{
4847 return((tANI_BOOLEAN)(eCSR_BSS_TYPE_START_IBSS == bssType || eCSR_BSS_TYPE_IBSS == bssType));
4848}
4849
4850tANI_BOOLEAN csrIsBssTypeWDS(eCsrRoamBssType bssType)
4851{
4852 return((tANI_BOOLEAN)(eCSR_BSS_TYPE_WDS_STA == bssType || eCSR_BSS_TYPE_WDS_AP == bssType));
4853}
4854
4855tANI_BOOLEAN csrIsBSSTypeCapsMatch( eCsrRoamBssType bssType, tSirBssDescription *pSirBssDesc )
4856{
4857 tANI_BOOLEAN fMatch = TRUE;
4858
4859 do
4860 {
4861 switch( bssType )
4862 {
4863 case eCSR_BSS_TYPE_ANY:
4864 break;
4865
4866 case eCSR_BSS_TYPE_INFRASTRUCTURE:
4867 case eCSR_BSS_TYPE_WDS_STA:
4868 if( !csrIsInfraBssDesc( pSirBssDesc ) )
4869 fMatch = FALSE;
4870
4871 break;
4872
4873 case eCSR_BSS_TYPE_IBSS:
4874 case eCSR_BSS_TYPE_START_IBSS:
4875 if( !csrIsIbssBssDesc( pSirBssDesc ) )
4876 fMatch = FALSE;
4877
4878 break;
4879
4880 case eCSR_BSS_TYPE_WDS_AP: //For WDS AP, no need to match anything
4881 default:
4882 fMatch = FALSE;
4883 break;
4884 }
4885 }
4886 while( 0 );
4887
4888
4889 return( fMatch );
4890}
4891
4892static tANI_BOOLEAN csrIsCapabilitiesMatch( tpAniSirGlobal pMac, eCsrRoamBssType bssType, tSirBssDescription *pSirBssDesc )
4893{
4894 return( csrIsBSSTypeCapsMatch( bssType, pSirBssDesc ) );
4895}
4896
4897
4898
4899static tANI_BOOLEAN csrIsSpecificChannelMatch( tpAniSirGlobal pMac, tSirBssDescription *pSirBssDesc, tANI_U8 Channel )
4900{
4901 tANI_BOOLEAN fMatch = TRUE;
4902
4903 do
4904 {
4905 // if the channel is ANY, then always match...
4906 if ( eCSR_OPERATING_CHANNEL_ANY == Channel ) break;
4907 if ( Channel == pSirBssDesc->channelId ) break;
4908
4909 // didn't match anything.. so return NO match
4910 fMatch = FALSE;
4911
4912 } while( 0 );
4913
4914 return( fMatch );
4915}
4916
4917
4918tANI_BOOLEAN csrIsChannelBandMatch( tpAniSirGlobal pMac, tANI_U8 channelId, tSirBssDescription *pSirBssDesc )
4919{
4920 tANI_BOOLEAN fMatch = TRUE;
4921
4922 do
4923 {
4924 // if the profile says Any channel AND the global settings says ANY channel, then we
4925 // always match...
4926 if ( eCSR_OPERATING_CHANNEL_ANY == channelId ) break;
4927
4928 if ( eCSR_OPERATING_CHANNEL_ANY != channelId )
4929 {
4930 fMatch = csrIsSpecificChannelMatch( pMac, pSirBssDesc, channelId );
4931 }
4932
4933 } while( 0 );
4934
4935 return( fMatch );
4936}
4937
4938
4939/**
4940 * \brief Enquire as to whether a given rate is supported by the
4941 * adapter as currently configured
4942 *
4943 *
4944 * \param nRate A rate in units of 500kbps
4945 *
4946 * \return TRUE if the adapter is currently capable of supporting this
4947 * rate, FALSE else
4948 *
4949 *
4950 * The rate encoding is just as in 802.11 Information Elements, except
4951 * that the high bit is \em not interpreted as indicating a Basic Rate,
4952 * and proprietary rates are allowed, too.
4953 *
4954 * Note that if the adapter's dot11Mode is g, we don't restrict the
4955 * rates. According to hwReadEepromParameters, this will happen when:
4956 *
4957 * ... the card is configured for ALL bands through the property
4958 * page. If this occurs, and the card is not an ABG card ,then this
4959 * code is setting the dot11Mode to assume the mode that the
4960 * hardware can support. For example, if the card is an 11BG card
4961 * and we are configured to support ALL bands, then we change the
4962 * dot11Mode to 11g because ALL in this case is only what the
4963 * hardware can support.
4964 *
4965 *
4966 */
4967
4968static tANI_BOOLEAN csrIsAggregateRateSupported( tpAniSirGlobal pMac, tANI_U16 rate )
4969{
4970 tANI_BOOLEAN fSupported = eANI_BOOLEAN_FALSE;
4971 tANI_U16 idx, newRate;
4972
4973 //In case basic rate flag is set
4974 newRate = BITS_OFF(rate, CSR_DOT11_BASIC_RATE_MASK);
4975 if ( eCSR_CFG_DOT11_MODE_11A == pMac->roam.configParam.uCfgDot11Mode )
4976 {
4977 switch ( newRate )
4978 {
4979 case eCsrSuppRate_6Mbps:
4980 case eCsrSuppRate_9Mbps:
4981 case eCsrSuppRate_12Mbps:
4982 case eCsrSuppRate_18Mbps:
4983 case eCsrSuppRate_24Mbps:
4984 case eCsrSuppRate_36Mbps:
4985 case eCsrSuppRate_48Mbps:
4986 case eCsrSuppRate_54Mbps:
4987 fSupported = TRUE;
4988 break;
4989 default:
4990 fSupported = FALSE;
4991 break;
4992 }
4993
4994 }
4995 else if( eCSR_CFG_DOT11_MODE_11B == pMac->roam.configParam.uCfgDot11Mode )
4996 {
4997 switch ( newRate )
4998 {
4999 case eCsrSuppRate_1Mbps:
5000 case eCsrSuppRate_2Mbps:
5001 case eCsrSuppRate_5_5Mbps:
5002 case eCsrSuppRate_11Mbps:
5003 fSupported = TRUE;
5004 break;
5005 default:
5006 fSupported = FALSE;
5007 break;
5008 }
5009 }
5010 else if ( !pMac->roam.configParam.ProprietaryRatesEnabled )
5011 {
5012
5013 switch ( newRate )
5014 {
5015 case eCsrSuppRate_1Mbps:
5016 case eCsrSuppRate_2Mbps:
5017 case eCsrSuppRate_5_5Mbps:
5018 case eCsrSuppRate_6Mbps:
5019 case eCsrSuppRate_9Mbps:
5020 case eCsrSuppRate_11Mbps:
5021 case eCsrSuppRate_12Mbps:
5022 case eCsrSuppRate_18Mbps:
5023 case eCsrSuppRate_24Mbps:
5024 case eCsrSuppRate_36Mbps:
5025 case eCsrSuppRate_48Mbps:
5026 case eCsrSuppRate_54Mbps:
5027 fSupported = TRUE;
5028 break;
5029 default:
5030 fSupported = FALSE;
5031 break;
5032 }
5033
5034 }
5035 else {
5036
5037 if ( eCsrSuppRate_1Mbps == newRate ||
5038 eCsrSuppRate_2Mbps == newRate ||
5039 eCsrSuppRate_5_5Mbps == newRate ||
5040 eCsrSuppRate_11Mbps == newRate )
5041 {
5042 fSupported = TRUE;
5043 }
5044 else {
5045 idx = 0x1;
5046
5047 switch ( newRate )
5048 {
5049 case eCsrSuppRate_6Mbps:
5050 fSupported = gPhyRatesSuppt[0][idx];
5051 break;
5052 case eCsrSuppRate_9Mbps:
5053 fSupported = gPhyRatesSuppt[1][idx];
5054 break;
5055 case eCsrSuppRate_12Mbps:
5056 fSupported = gPhyRatesSuppt[2][idx];
5057 break;
5058 case eCsrSuppRate_18Mbps:
5059 fSupported = gPhyRatesSuppt[3][idx];
5060 break;
5061 case eCsrSuppRate_20Mbps:
5062 fSupported = gPhyRatesSuppt[4][idx];
5063 break;
5064 case eCsrSuppRate_24Mbps:
5065 fSupported = gPhyRatesSuppt[5][idx];
5066 break;
5067 case eCsrSuppRate_36Mbps:
5068 fSupported = gPhyRatesSuppt[6][idx];
5069 break;
5070 case eCsrSuppRate_40Mbps:
5071 fSupported = gPhyRatesSuppt[7][idx];
5072 break;
5073 case eCsrSuppRate_42Mbps:
5074 fSupported = gPhyRatesSuppt[8][idx];
5075 break;
5076 case eCsrSuppRate_48Mbps:
5077 fSupported = gPhyRatesSuppt[9][idx];
5078 break;
5079 case eCsrSuppRate_54Mbps:
5080 fSupported = gPhyRatesSuppt[10][idx];
5081 break;
5082 case eCsrSuppRate_72Mbps:
5083 fSupported = gPhyRatesSuppt[11][idx];
5084 break;
5085 case eCsrSuppRate_80Mbps:
5086 fSupported = gPhyRatesSuppt[12][idx];
5087 break;
5088 case eCsrSuppRate_84Mbps:
5089 fSupported = gPhyRatesSuppt[13][idx];
5090 break;
5091 case eCsrSuppRate_96Mbps:
5092 fSupported = gPhyRatesSuppt[14][idx];
5093 break;
5094 case eCsrSuppRate_108Mbps:
5095 fSupported = gPhyRatesSuppt[15][idx];
5096 break;
5097 case eCsrSuppRate_120Mbps:
5098 fSupported = gPhyRatesSuppt[16][idx];
5099 break;
5100 case eCsrSuppRate_126Mbps:
5101 fSupported = gPhyRatesSuppt[17][idx];
5102 break;
5103 case eCsrSuppRate_144Mbps:
5104 fSupported = gPhyRatesSuppt[18][idx];
5105 break;
5106 case eCsrSuppRate_160Mbps:
5107 fSupported = gPhyRatesSuppt[19][idx];
5108 break;
5109 case eCsrSuppRate_168Mbps:
5110 fSupported = gPhyRatesSuppt[20][idx];
5111 break;
5112 case eCsrSuppRate_192Mbps:
5113 fSupported = gPhyRatesSuppt[21][idx];
5114 break;
5115 case eCsrSuppRate_216Mbps:
5116 fSupported = gPhyRatesSuppt[22][idx];
5117 break;
5118 case eCsrSuppRate_240Mbps:
5119 fSupported = gPhyRatesSuppt[23][idx];
5120 break;
5121 default:
5122 fSupported = FALSE;
5123 break;
5124 }
5125 }
5126 }
5127
5128 return fSupported;
5129}
5130
5131
5132
5133static tANI_BOOLEAN csrIsRateSetMatch( tpAniSirGlobal pMac,
5134 tDot11fIESuppRates *pBssSuppRates,
5135 tDot11fIEExtSuppRates *pBssExtSuppRates )
5136{
5137 tANI_BOOLEAN fMatch = TRUE;
5138 tANI_U32 i;
5139
5140
5141 // Validate that all of the Basic rates advertised in the Bss description are supported.
5142 if ( pBssSuppRates )
5143 {
5144 for( i = 0; i < pBssSuppRates->num_rates; i++ )
5145 {
5146 if ( CSR_IS_BASIC_RATE( pBssSuppRates->rates[ i ] ) )
5147 {
5148 if ( !csrIsAggregateRateSupported( pMac, pBssSuppRates->rates[ i ] ) )
5149 {
5150 fMatch = FALSE;
5151 break;
5152 }
5153 }
5154 }
5155 }
5156
5157 if ( fMatch && pBssExtSuppRates )
5158 {
5159 for( i = 0; i < pBssExtSuppRates->num_rates; i++ )
5160 {
5161 if ( CSR_IS_BASIC_RATE( pBssExtSuppRates->rates[ i ] ) )
5162 {
5163 if ( !csrIsAggregateRateSupported( pMac, pBssExtSuppRates->rates[ i ] ) )
5164 {
5165 fMatch = FALSE;
5166 break;
5167 }
5168 }
5169 }
5170 }
5171
5172 return( fMatch );
5173
5174}
5175
5176
5177//ppIes can be NULL. If caller want to get the *ppIes allocated by this function, pass in *ppIes = NULL
5178tANI_BOOLEAN csrMatchBSS( tHalHandle hHal, tSirBssDescription *pBssDesc, tCsrScanResultFilter *pFilter,
5179 eCsrAuthType *pNegAuth, eCsrEncryptionType *pNegUc, eCsrEncryptionType *pNegMc,
5180 tDot11fBeaconIEs **ppIes)
5181{
5182 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5183 tANI_BOOLEAN fRC = eANI_BOOLEAN_FALSE, fCheck;
5184 tANI_U32 i;
5185 tDot11fBeaconIEs *pIes = NULL;
5186 tANI_U8 *pb;
5187
5188 do {
5189 if( ( NULL == ppIes ) || ( *ppIes ) == NULL )
5190 {
5191 //If no IEs passed in, get our own.
5192 if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pBssDesc, &pIes)))
5193 {
5194 break;
5195 }
5196 }
5197 else
5198 {
5199 //Save the one pass in for local use
5200 pIes = *ppIes;
5201 }
5202
5203 //Check if caller wants P2P
5204 fCheck = (!pFilter->p2pResult || pIes->P2PBeaconProbeRes.present);
5205 if(!fCheck) break;
5206
5207 if(pIes->SSID.present)
5208 {
5209 for(i = 0; i < pFilter->SSIDs.numOfSSIDs; i++)
5210 {
5211 fCheck = csrIsSsidMatch( pMac, pFilter->SSIDs.SSIDList[i].SSID.ssId, pFilter->SSIDs.SSIDList[i].SSID.length,
5212 pIes->SSID.ssid,
5213 pIes->SSID.num_ssid, eANI_BOOLEAN_TRUE );
5214 if ( fCheck ) break;
5215 }
5216 if(!fCheck) break;
5217 }
5218 fCheck = eANI_BOOLEAN_TRUE;
5219 for(i = 0; i < pFilter->BSSIDs.numOfBSSIDs; i++)
5220 {
5221 fCheck = csrIsBssidMatch( pMac, (tCsrBssid *)&pFilter->BSSIDs.bssid[i], (tCsrBssid *)pBssDesc->bssId );
5222 if ( fCheck ) break;
5223
5224 if (pFilter->p2pResult && pIes->P2PBeaconProbeRes.present)
5225 {
5226 fCheck = csrIsBssidMatch( pMac, (tCsrBssid *)&pFilter->BSSIDs.bssid[i],
5227 (tCsrBssid *)pIes->P2PBeaconProbeRes.P2PDeviceInfo.P2PDeviceAddress );
5228
5229 if ( fCheck ) break;
5230 }
5231 }
5232 if(!fCheck) break;
5233
5234 fCheck = eANI_BOOLEAN_TRUE;
5235 for(i = 0; i < pFilter->ChannelInfo.numOfChannels; i++)
5236 {
5237 fCheck = csrIsChannelBandMatch( pMac, pFilter->ChannelInfo.ChannelList[i], pBssDesc );
5238 if ( fCheck ) break;
5239 }
5240 if(!fCheck)
5241 break;
5242#if defined WLAN_FEATURE_VOWIFI
5243 /* If this is for measurement filtering */
5244 if( pFilter->fMeasurement )
5245 {
5246 fRC = eANI_BOOLEAN_TRUE;
5247 break;
5248 }
5249#endif
5250 if ( !csrIsPhyModeMatch( pMac, pFilter->phyMode, pBssDesc, NULL, NULL, pIes ) ) break;
5251 if ( (!pFilter->bWPSAssociation) &&
5252 !csrIsSecurityMatch( pMac, &pFilter->authType, &pFilter->EncryptionType, &pFilter->mcEncryptionType,
5253 pBssDesc, pIes, pNegAuth, pNegUc, pNegMc ) ) break;
5254 if ( !csrIsCapabilitiesMatch( pMac, pFilter->BSSType, pBssDesc ) ) break;
5255 if ( !csrIsRateSetMatch( pMac, &pIes->SuppRates, &pIes->ExtSuppRates ) ) break;
5256 //Tush-QoS: validate first if asked for APSD or WMM association
5257 if ( (eCsrRoamWmmQbssOnly == pMac->roam.configParam.WMMSupportMode) &&
5258 !CSR_IS_QOS_BSS(pIes) )
5259 break;
5260 //Check country. check even when pb is NULL because we may want to make sure
5261 //AP has a country code in it if fEnforceCountryCodeMatch is set.
5262 pb = ( pFilter->countryCode[0] ) ? ( pFilter->countryCode) : NULL;
5263
5264 fCheck = csrMatchCountryCode( pMac, pb, pIes );
5265 if(!fCheck)
5266 break;
5267
5268#ifdef WLAN_FEATURE_VOWIFI_11R
5269 if (pFilter->MDID.mdiePresent)
5270 {
5271 if (pBssDesc->mdiePresent)
5272 {
5273 if (pFilter->MDID.mobilityDomain != (pBssDesc->mdie[1] << 8 | pBssDesc->mdie[0]))
5274 break;
5275 }
5276 else
5277 break;
5278 }
5279#endif
5280 fRC = eANI_BOOLEAN_TRUE;
5281
5282 } while( 0 );
5283 if( ppIes )
5284 {
5285 *ppIes = pIes;
5286 }
5287 else if( pIes )
5288 {
5289 palFreeMemory(pMac->hHdd, pIes);
5290 }
5291
5292 return( fRC );
5293}
5294
5295tANI_BOOLEAN csrMatchConnectedBSSSecurity( tpAniSirGlobal pMac, tCsrRoamConnectedProfile *pProfile,
5296 tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIes)
5297{
5298 tCsrEncryptionList ucEncryptionList, mcEncryptionList;
5299 tCsrAuthList authList;
5300
5301 ucEncryptionList.numEntries = 1;
5302 ucEncryptionList.encryptionType[0] = pProfile->EncryptionType;
5303
5304 mcEncryptionList.numEntries = 1;
5305 mcEncryptionList.encryptionType[0] = pProfile->mcEncryptionType;
5306
5307 authList.numEntries = 1;
5308 authList.authType[0] = pProfile->AuthType;
5309
5310 return( csrIsSecurityMatch( pMac, &authList, &ucEncryptionList, &mcEncryptionList, pBssDesc, pIes, NULL, NULL, NULL ));
5311
5312}
5313
5314
5315tANI_BOOLEAN csrMatchBSSToConnectProfile( tHalHandle hHal, tCsrRoamConnectedProfile *pProfile,
5316 tSirBssDescription *pBssDesc, tDot11fBeaconIEs *pIes )
5317{
5318 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5319 tANI_BOOLEAN fRC = eANI_BOOLEAN_FALSE, fCheck;
5320 tDot11fBeaconIEs *pIesLocal = pIes;
5321
5322 do {
5323 if( !pIes )
5324 {
5325 if(!HAL_STATUS_SUCCESS(csrGetParsedBssDescriptionIEs(pMac, pBssDesc, &pIesLocal)))
5326 {
5327 break;
5328 }
5329 }
5330 fCheck = eANI_BOOLEAN_TRUE;
5331 if(pIesLocal->SSID.present)
5332 {
5333 tANI_BOOLEAN fCheckSsid = eANI_BOOLEAN_FALSE;
5334 if(pProfile->SSID.length)
5335 {
5336 fCheckSsid = eANI_BOOLEAN_TRUE;
5337 }
5338 fCheck = csrIsSsidMatch( pMac, pProfile->SSID.ssId, pProfile->SSID.length,
5339 pIesLocal->SSID.ssid, pIesLocal->SSID.num_ssid, fCheckSsid );
5340 if(!fCheck) break;
5341 }
5342 if ( !csrMatchConnectedBSSSecurity( pMac, pProfile, pBssDesc, pIesLocal) ) break;
5343 if ( !csrIsCapabilitiesMatch( pMac, pProfile->BSSType, pBssDesc ) ) break;
5344 if ( !csrIsRateSetMatch( pMac, &pIesLocal->SuppRates, &pIesLocal->ExtSuppRates ) ) break;
5345 fCheck = csrIsChannelBandMatch( pMac, pProfile->operationChannel, pBssDesc );
5346 if(!fCheck)
5347 break;
5348
5349 fRC = eANI_BOOLEAN_TRUE;
5350
5351 } while( 0 );
5352
5353 if( !pIes && pIesLocal )
5354 {
5355 //locally allocated
5356 palFreeMemory(pMac->hHdd, pIesLocal);
5357 }
5358
5359 return( fRC );
5360}
5361
5362
5363
5364tANI_BOOLEAN csrRatesIsDot11RateSupported( tHalHandle hHal, tANI_U8 rate )
5365{
5366 tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
5367 tANI_U16 n = BITS_OFF( rate, CSR_DOT11_BASIC_RATE_MASK );
5368
5369 return csrIsAggregateRateSupported( pMac, n );
5370}
5371
5372
5373tANI_U16 csrRatesMacPropToDot11( tANI_U16 Rate )
5374{
5375 tANI_U16 ConvertedRate = Rate;
5376
5377 switch( Rate )
5378 {
5379 case SIR_MAC_RATE_1:
5380 ConvertedRate = 2;
5381 break;
5382 case SIR_MAC_RATE_2:
5383 ConvertedRate = 4;
5384 break;
5385 case SIR_MAC_RATE_5_5:
5386 ConvertedRate = 11;
5387 break;
5388 case SIR_MAC_RATE_11:
5389 ConvertedRate = 22;
5390 break;
5391
5392 case SIR_MAC_RATE_6:
5393 ConvertedRate = 12;
5394 break;
5395 case SIR_MAC_RATE_9:
5396 ConvertedRate = 18;
5397 break;
5398 case SIR_MAC_RATE_12:
5399 ConvertedRate = 24;
5400 break;
5401 case SIR_MAC_RATE_18:
5402 ConvertedRate = 36;
5403 break;
5404 case SIR_MAC_RATE_24:
5405 ConvertedRate = 48;
5406 break;
5407 case SIR_MAC_RATE_36:
5408 ConvertedRate = 72;
5409 break;
5410 case SIR_MAC_RATE_42:
5411 ConvertedRate = 84;
5412 break;
5413 case SIR_MAC_RATE_48:
5414 ConvertedRate = 96;
5415 break;
5416 case SIR_MAC_RATE_54:
5417 ConvertedRate = 108;
5418 break;
5419
5420 case SIR_MAC_RATE_72:
5421 ConvertedRate = 144;
5422 break;
5423 case SIR_MAC_RATE_84:
5424 ConvertedRate = 168;
5425 break;
5426 case SIR_MAC_RATE_96:
5427 ConvertedRate = 192;
5428 break;
5429 case SIR_MAC_RATE_108:
5430 ConvertedRate = 216;
5431 break;
5432 case SIR_MAC_RATE_126:
5433 ConvertedRate = 252;
5434 break;
5435 case SIR_MAC_RATE_144:
5436 ConvertedRate = 288;
5437 break;
5438 case SIR_MAC_RATE_168:
5439 ConvertedRate = 336;
5440 break;
5441 case SIR_MAC_RATE_192:
5442 ConvertedRate = 384;
5443 break;
5444 case SIR_MAC_RATE_216:
5445 ConvertedRate = 432;
5446 break;
5447 case SIR_MAC_RATE_240:
5448 ConvertedRate = 480;
5449 break;
5450
5451 case 0xff:
5452 ConvertedRate = 0;
5453 break;
5454 }
5455
5456 return ConvertedRate;
5457}
5458
5459
5460tANI_U16 csrRatesFindBestRate( tSirMacRateSet *pSuppRates, tSirMacRateSet *pExtRates, tSirMacPropRateSet *pPropRates )
5461{
5462 tANI_U8 i;
5463 tANI_U16 nBest;
5464
5465 nBest = pSuppRates->rate[ 0 ] & ( ~CSR_DOT11_BASIC_RATE_MASK );
5466
5467 if(pSuppRates->numRates > SIR_MAC_RATESET_EID_MAX)
5468 {
5469 pSuppRates->numRates = SIR_MAC_RATESET_EID_MAX;
5470 }
5471
5472 for ( i = 1U; i < pSuppRates->numRates; ++i )
5473 {
5474 nBest = (tANI_U16)CSR_MAX( nBest, pSuppRates->rate[ i ] & ( ~CSR_DOT11_BASIC_RATE_MASK ) );
5475 }
5476
5477 if ( NULL != pExtRates )
5478 {
5479 for ( i = 0U; i < pExtRates->numRates; ++i )
5480 {
5481 nBest = (tANI_U16)CSR_MAX( nBest, pExtRates->rate[ i ] & ( ~CSR_DOT11_BASIC_RATE_MASK ) );
5482 }
5483 }
5484
5485 if ( NULL != pPropRates )
5486 {
5487 for ( i = 0U; i < pPropRates->numPropRates; ++i )
5488 {
5489 nBest = (tANI_U16)CSR_MAX( nBest, csrRatesMacPropToDot11( pPropRates->propRate[ i ] ) );
5490 }
5491 }
5492
5493 return nBest;
5494}
5495
5496
5497void csrReleaseProfile(tpAniSirGlobal pMac, tCsrRoamProfile *pProfile)
5498{
5499 if(pProfile)
5500 {
5501 if(pProfile->BSSIDs.bssid)
5502 {
5503 palFreeMemory(pMac->hHdd, pProfile->BSSIDs.bssid);
5504 pProfile->BSSIDs.bssid = NULL;
5505 }
5506 if(pProfile->SSIDs.SSIDList)
5507 {
5508 palFreeMemory(pMac->hHdd, pProfile->SSIDs.SSIDList);
5509 pProfile->SSIDs.SSIDList = NULL;
5510 }
5511 if(pProfile->pWPAReqIE)
5512 {
5513 palFreeMemory(pMac->hHdd, pProfile->pWPAReqIE);
5514 pProfile->pWPAReqIE = NULL;
5515 }
5516 if(pProfile->pRSNReqIE)
5517 {
5518 palFreeMemory(pMac->hHdd, pProfile->pRSNReqIE);
5519 pProfile->pRSNReqIE = NULL;
5520 }
5521#ifdef FEATURE_WLAN_WAPI
5522 if(pProfile->pWAPIReqIE)
5523 {
5524 palFreeMemory(pMac->hHdd, pProfile->pWAPIReqIE);
5525 pProfile->pWAPIReqIE = NULL;
5526 }
5527#endif /* FEATURE_WLAN_WAPI */
5528
5529 if(pProfile->pAddIEScan)
5530 {
5531 palFreeMemory(pMac->hHdd, pProfile->pAddIEScan);
5532 pProfile->pAddIEScan = NULL;
5533 }
5534
5535 if(pProfile->pAddIEAssoc)
5536 {
5537 palFreeMemory(pMac->hHdd, pProfile->pAddIEAssoc);
5538 pProfile->pAddIEAssoc = NULL;
5539 }
5540 {
5541 palFreeMemory(pMac->hHdd, pProfile->pAddIEAssoc);
5542 pProfile->pAddIEAssoc = NULL;
5543 }
5544
5545 if(pProfile->ChannelInfo.ChannelList)
5546 {
5547 palFreeMemory(pMac->hHdd, pProfile->ChannelInfo.ChannelList);
5548 pProfile->ChannelInfo.ChannelList = NULL;
5549 }
5550
5551
5552 palZeroMemory(pMac->hHdd, pProfile, sizeof(tCsrRoamProfile));
5553 }
5554}
5555
5556void csrFreeScanFilter(tpAniSirGlobal pMac, tCsrScanResultFilter *pScanFilter)
5557{
5558 if(pScanFilter->BSSIDs.bssid)
5559 {
5560 palFreeMemory(pMac->hHdd, pScanFilter->BSSIDs.bssid);
5561 pScanFilter->BSSIDs.bssid = NULL;
5562 }
5563 if(pScanFilter->ChannelInfo.ChannelList)
5564 {
5565 palFreeMemory(pMac->hHdd, pScanFilter->ChannelInfo.ChannelList);
5566 pScanFilter->ChannelInfo.ChannelList = NULL;
5567 }
5568 if(pScanFilter->SSIDs.SSIDList)
5569 {
5570 palFreeMemory(pMac->hHdd, pScanFilter->SSIDs.SSIDList);
5571 pScanFilter->SSIDs.SSIDList = NULL;
5572 }
5573}
5574
5575
5576void csrFreeRoamProfile(tpAniSirGlobal pMac, tANI_U32 sessionId)
5577{
5578 tCsrRoamSession *pSession = &pMac->roam.roamSession[sessionId];
5579
5580 if(pSession->pCurRoamProfile)
5581 {
5582 csrReleaseProfile(pMac, pSession->pCurRoamProfile);
5583 palFreeMemory(pMac->hHdd, pSession->pCurRoamProfile);
5584 pSession->pCurRoamProfile = NULL;
5585 }
5586}
5587
5588
5589void csrFreeConnectBssDesc(tpAniSirGlobal pMac, tANI_U32 sessionId)
5590{
5591 tCsrRoamSession *pSession = &pMac->roam.roamSession[sessionId];
5592
5593 if(pSession->pConnectBssDesc)
5594 {
5595 palFreeMemory(pMac->hHdd, pSession->pConnectBssDesc);
5596 pSession->pConnectBssDesc = NULL;
5597 }
5598}
5599
5600
5601
5602tSirResultCodes csrGetDisassocRspStatusCode( tSirSmeDisassocRsp *pSmeDisassocRsp )
5603{
5604 tANI_U8 *pBuffer = (tANI_U8 *)pSmeDisassocRsp;
5605 tANI_U32 ret;
5606
5607 pBuffer += (sizeof(tANI_U16) + sizeof(tANI_U16) + sizeof(tSirMacAddr));
5608 //tSirResultCodes is an enum, assuming is 32bit
5609 //If we cannot make this assumption, use copymemory
5610 pal_get_U32( pBuffer, &ret );
5611
5612 return( ( tSirResultCodes )ret );
5613}
5614
5615
5616tSirResultCodes csrGetDeAuthRspStatusCode( tSirSmeDeauthRsp *pSmeRsp )
5617{
5618 tANI_U8 *pBuffer = (tANI_U8 *)pSmeRsp;
5619 tANI_U32 ret;
5620
5621 pBuffer += (sizeof(tANI_U16) + sizeof(tANI_U16) + sizeof(tSirMacAddr));
5622 //tSirResultCodes is an enum, assuming is 32bit
5623 //If we cannot make this assumption, use copymemory
5624 pal_get_U32( pBuffer, &ret );
5625
5626 return( ( tSirResultCodes )ret );
5627}
5628
5629#if 0
5630tSirScanType csrGetScanType(tANI_U8 chnId, eRegDomainId domainId, tANI_U8 *countryCode)
5631{
5632 tSirScanType scanType = eSIR_PASSIVE_SCAN;
5633 tANI_U8 cc = 0;
5634
5635 while (cc++ < gCsrDomainChnInfo[domainId].numChannels)
5636 {
5637 if(chnId == gCsrDomainChnInfo[domainId].chnInfo[cc].chnId)
5638 {
5639 scanType = gCsrDomainChnInfo[domainId].chnInfo[cc].scanType;
5640 break;
5641 }
5642 }
5643
5644 return (scanType);
5645}
5646#endif
5647
5648tSirScanType csrGetScanType(tpAniSirGlobal pMac, tANI_U8 chnId)
5649{
5650 tSirScanType scanType = eSIR_PASSIVE_SCAN;
5651 eNVChannelEnabledType channelEnabledType;
5652
5653 channelEnabledType = vos_nv_getChannelEnabledState(chnId);
5654 if( NV_CHANNEL_ENABLE == channelEnabledType)
5655 {
5656 scanType = eSIR_ACTIVE_SCAN;
5657 }
5658 return (scanType);
5659}
5660
5661
5662tANI_U8 csrToUpper( tANI_U8 ch )
5663{
5664 tANI_U8 chOut;
5665
5666 if ( ch >= 'a' && ch <= 'z' )
5667 {
5668 chOut = ch - 'a' + 'A';
5669 }
5670 else
5671 {
5672 chOut = ch;
5673 }
5674 return( chOut );
5675}
5676
5677
5678tSirBssType csrTranslateBsstypeToMacType(eCsrRoamBssType csrtype)
5679{
5680 tSirBssType ret;
5681
5682 switch(csrtype)
5683 {
5684 case eCSR_BSS_TYPE_INFRASTRUCTURE:
5685 ret = eSIR_INFRASTRUCTURE_MODE;
5686 break;
5687 case eCSR_BSS_TYPE_IBSS:
5688 case eCSR_BSS_TYPE_START_IBSS:
5689 ret = eSIR_IBSS_MODE;
5690 break;
5691 case eCSR_BSS_TYPE_WDS_AP:
5692 ret = eSIR_BTAMP_AP_MODE;
5693 break;
5694 case eCSR_BSS_TYPE_WDS_STA:
5695 ret = eSIR_BTAMP_STA_MODE;
5696 break;
5697#ifdef WLAN_SOFTAP_FEATURE
5698 case eCSR_BSS_TYPE_INFRA_AP:
5699 ret = eSIR_INFRA_AP_MODE;
5700 break;
5701#endif
5702 case eCSR_BSS_TYPE_ANY:
5703 default:
5704 ret = eSIR_AUTO_MODE;
5705 break;
5706 }
5707
5708 return (ret);
5709}
5710
5711
5712//This function use the parameters to decide the CFG value.
5713//CSR never sets WNI_CFG_DOT11_MODE_ALL to the CFG
5714//So PE should not see WNI_CFG_DOT11_MODE_ALL when it gets the CFG value
5715#ifdef WLAN_SOFTAP_FEATURE
5716eCsrCfgDot11Mode csrGetCfgDot11ModeFromCsrPhyMode(tCsrRoamProfile *pProfile, eCsrPhyMode phyMode, tANI_BOOLEAN fProprietary)
5717#else
5718eCsrCfgDot11Mode csrGetCfgDot11ModeFromCsrPhyMode(eCsrPhyMode phyMode, tANI_BOOLEAN fProprietary)
5719#endif
5720{
5721 tANI_U32 cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG;
5722
5723 switch(phyMode)
5724 {
5725 case eCSR_DOT11_MODE_11a:
5726 case eCSR_DOT11_MODE_11a_ONLY:
5727 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A;
5728 break;
5729 case eCSR_DOT11_MODE_11b:
5730 case eCSR_DOT11_MODE_11b_ONLY:
5731 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B;
5732 break;
5733 case eCSR_DOT11_MODE_11g:
5734 case eCSR_DOT11_MODE_11g_ONLY:
5735#ifdef WLAN_SOFTAP_FEATURE
5736 if(pProfile && (CSR_IS_INFRA_AP(pProfile)) && (phyMode == eCSR_DOT11_MODE_11g_ONLY))
5737 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G_ONLY;
5738 else
5739#endif
5740 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G;
5741 break;
5742 case eCSR_DOT11_MODE_11n:
5743 if(fProprietary)
5744 {
5745 cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
5746 }
5747 else
5748 {
5749 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
5750 }
5751 break;
5752 case eCSR_DOT11_MODE_11n_ONLY:
5753#ifdef WLAN_SOFTAP_FEATURE
5754 if(pProfile && CSR_IS_INFRA_AP(pProfile))
5755 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N_ONLY;
5756 else
5757#endif
5758 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
5759 break;
5760 case eCSR_DOT11_MODE_TAURUS:
5761 cfgDot11Mode = eCSR_CFG_DOT11_MODE_TAURUS;
5762 break;
5763 case eCSR_DOT11_MODE_abg:
5764 cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG;
5765 break;
5766 case eCSR_DOT11_MODE_AUTO:
5767 cfgDot11Mode = eCSR_CFG_DOT11_MODE_AUTO;
5768 break;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]5769
5770#ifdef WLAN_FEATURE_11AC
5771 case eCSR_DOT11_MODE_11ac:
5772 if (!WDA_getFwWlanFeatCaps(DOT11AC))
5773 {
5774 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N;
5775 }
5776 else
5777 {
5778 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC;
5779 }
5780 break;
5781 case eCSR_DOT11_MODE_11ac_ONLY:
5782 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC_ONLY;
5783 break;
5784#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5785 default:
5786 //No need to assign anything here
5787 break;
5788 }
5789
5790 return (cfgDot11Mode);
5791}
5792
5793
5794eHalStatus csrSetRegulatoryDomain(tpAniSirGlobal pMac, v_REGDOMAIN_t domainId, tANI_BOOLEAN *pfRestartNeeded)
5795{
5796 eHalStatus status = eHAL_STATUS_SUCCESS;
5797 tANI_BOOLEAN fRestart;
5798
5799 if(pMac->scan.domainIdCurrent == domainId)
5800 {
5801 //no change
5802 fRestart = eANI_BOOLEAN_FALSE;
5803 }
5804 else if( !pMac->roam.configParam.fEnforceDefaultDomain )
5805 {
5806 pMac->scan.domainIdCurrent = domainId;
5807 fRestart = eANI_BOOLEAN_TRUE;
5808 }
5809 else
5810 {
5811 //We cannot change the domain
5812 status = eHAL_STATUS_CSR_WRONG_STATE;
5813 fRestart = eANI_BOOLEAN_FALSE;
5814 }
5815 if(pfRestartNeeded)
5816 {
5817 *pfRestartNeeded = fRestart;
5818 }
5819
5820 return (status);
5821}
5822
5823
5824v_REGDOMAIN_t csrGetCurrentRegulatoryDomain(tpAniSirGlobal pMac)
5825{
5826 return (pMac->scan.domainIdCurrent);
5827}
5828
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5829
5830eHalStatus csrGetRegulatoryDomainForCountry(tpAniSirGlobal pMac, tANI_U8 *pCountry, v_REGDOMAIN_t *pDomainId)
5831{
5832 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
5833 VOS_STATUS vosStatus;
5834 v_COUNTRYCODE_t countryCode;
5835 v_REGDOMAIN_t domainId;
5836
5837 if(pCountry)
5838 {
5839 countryCode[0] = pCountry[0];
5840 countryCode[1] = pCountry[1];
5841 vosStatus = vos_nv_getRegDomainFromCountryCode( &domainId, countryCode );
5842 if( VOS_IS_STATUS_SUCCESS(vosStatus) )
5843 {
5844 if( pDomainId )
5845 {
5846 *pDomainId = domainId;
5847 }
5848 status = eHAL_STATUS_SUCCESS;
5849 }
5850 else
5851 {
5852 smsLog(pMac, LOGW, FL(" doesn't match country %c%c\n"), pCountry[0], pCountry[1]);
5853 status = eHAL_STATUS_INVALID_PARAMETER;
5854 }
5855 }
5856
5857 return (status);
5858}
5859
5860//To check whether a country code matches the one in the IE
5861//Only check the first two characters, ignoring in/outdoor
5862//pCountry -- caller allocated buffer contain the country code that is checking against
5863//the one in pIes. It can be NULL.
5864//caller must provide pIes, it cannot be NULL
5865//This function always return TRUE if 11d support is not turned on.
5866tANI_BOOLEAN csrMatchCountryCode( tpAniSirGlobal pMac, tANI_U8 *pCountry, tDot11fBeaconIEs *pIes )
5867{
5868 tANI_BOOLEAN fRet = eANI_BOOLEAN_TRUE;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5869 v_REGDOMAIN_t domainId = REGDOMAIN_COUNT; //This is init to invalid value
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5870 eHalStatus status;
5871
5872 do
5873 {
5874 if( !csrIs11dSupported( pMac) )
5875 {
5876 break;
5877 }
5878 if( !pIes )
5879 {
5880 smsLog(pMac, LOGE, FL(" No IEs\n"));
5881 break;
5882 }
5883 //Make sure this country is recognizable
5884 if( pIes->Country.present )
5885 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5886 status = csrGetRegulatoryDomainForCountry( pMac, pIes->Country.country, &domainId );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5887 if( !HAL_STATUS_SUCCESS( status ) )
5888 {
5889 fRet = eANI_BOOLEAN_FALSE;
5890 break;
5891 }
5892 }
5893 //check whether it is needed to enforce to the default regulatory domain first
5894 if( pMac->roam.configParam.fEnforceDefaultDomain )
5895 {
5896 if( domainId != pMac->scan.domainIdCurrent )
5897 {
5898 fRet = eANI_BOOLEAN_FALSE;
5899 break;
5900 }
5901 }
5902 if( pMac->roam.configParam.fEnforceCountryCodeMatch )
5903 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5904 if( domainId >= REGDOMAIN_COUNT )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5905 {
5906 fRet = eANI_BOOLEAN_FALSE;
5907 break;
5908 }
5909 }
5910 if( pCountry )
5911 {
5912 tANI_U32 i;
5913
5914 if( !pIes->Country.present )
5915 {
5916 fRet = eANI_BOOLEAN_FALSE;
5917 break;
5918 }
5919 // Convert the CountryCode characters to upper
5920 for ( i = 0; i < WNI_CFG_COUNTRY_CODE_LEN - 1; i++ )
5921 {
5922 pCountry[i] = csrToUpper( pCountry[i] );
5923 }
5924 if( !palEqualMemory(pMac->hHdd, pIes->Country.country, pCountry, WNI_CFG_COUNTRY_CODE_LEN - 1) )
5925 {
5926 fRet = eANI_BOOLEAN_FALSE;
5927 break;
5928 }
5929 }
5930 } while(0);
5931
5932 return (fRet);
5933}
5934
5935#if 0
5936eHalStatus csrSetCountryDomainMapping(tpAniSirGlobal pMac, tCsrCountryDomainMapping *pCountryDomainMapping)
5937{
5938 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
5939 tANI_U32 i, j;
5940 tANI_BOOLEAN fDomainChanged = eANI_BOOLEAN_FALSE;
5941 tANI_U8 countryCode[WNI_CFG_COUNTRY_CODE_LEN];
5942
5943 i = WNI_CFG_COUNTRY_CODE_LEN;
5944 //Get the currently used country code
5945 status = ccmCfgGetStr(pMac, WNI_CFG_COUNTRY_CODE, countryCode, &i);
5946 if(HAL_STATUS_SUCCESS(status))
5947 {
5948 if(pCountryDomainMapping && pCountryDomainMapping->numEntry)
5949 {
5950 for(i = 0; i < pCountryDomainMapping->numEntry; i++)
5951 {
5952 for(j = 0; j < eCSR_NUM_COUNTRY_INDEX; j++)
5953 {
5954 if(palEqualMemory(pMac->hHdd, gCsrCountryInfo[j].countryCode,
5955 pCountryDomainMapping->pCountryInfo[i].countryCode, 2))
5956 {
5957 if(gCsrCountryInfo[j].domainId != pCountryDomainMapping->pCountryInfo[i].domainId)
5958 {
5959 gCsrCountryInfo[j].domainId = pCountryDomainMapping->pCountryInfo[i].domainId;
5960 //Check whether it matches the currently used country code
5961 //If matching, need to update base on the new domain setting.
5962 if(palEqualMemory(pMac->hHdd, countryCode,
5963 pCountryDomainMapping->pCountryInfo[i].countryCode, 2))
5964 {
5965 fDomainChanged = eANI_BOOLEAN_TRUE;
5966 }
5967 }
5968 break;
5969 }
5970 }
5971 }
5972 status = eHAL_STATUS_SUCCESS;
5973 if(fDomainChanged)
5974 {
5975 tCsrChannel *pChannelList;
5976
5977 if(pMac->scan.f11dInfoApplied)
5978 {
5979 //11d info already applied. Let's reapply with the new domain setting
5980 if(pMac->scan.channels11d.numChannels)
5981 {
5982 pChannelList = &pMac->scan.channels11d;
5983 }
5984 else
5985 {
5986 pChannelList = &pMac->scan.base20MHzChannels;
5987 }
5988 }
5989 else
5990 {
5991 //no 11d so we use the base channelist from EEPROM
5992 pChannelList = &pMac->scan.base20MHzChannels;
5993 }
5994 //set the new domain's scan requirement to CFG
5995 csrSetCfgScanControlList(pMac, countryCode, pChannelList);
5996 }
5997 }
5998 }
5999
6000 return (status);
6001}
6002
6003eHalStatus csrSetDomainScanSetting(tpAniSirGlobal pMac, tCsrDomainFreqInfo *pDomainFreqInfo)
6004{
6005 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
6006 tANI_U32 i, j;
6007 tANI_U16 freq;
6008
6009 if(pDomainFreqInfo && pDomainFreqInfo->numEntry && (pDomainFreqInfo->domainId < NUM_REG_DOMAINS))
6010 {
6011 tCsrDomainChnInfo *pDomainChnInfo = &gCsrDomainChnInfo[pDomainFreqInfo->domainId];
6012
6013 for(j = 0; j < pDomainChnInfo->numChannels; j++)
6014 {
6015 if(HAL_STATUS_SUCCESS(halPhyChIdToFreqConversion(pDomainChnInfo->chnInfo[j].chnId, &freq)))
6016 {
6017 for(i = 0; i < pDomainFreqInfo->numEntry; i++)
6018 {
6019 if((pDomainFreqInfo->pCsrScanFreqInfo[i].nStartFreq <= freq) &&
6020 (freq <= pDomainFreqInfo->pCsrScanFreqInfo[i].nEndFreq))
6021 {
6022 pDomainChnInfo->chnInfo[j].scanType = pDomainFreqInfo->pCsrScanFreqInfo[i].scanType;
6023 break;
6024 }
6025 }
6026 }
6027 else
6028 {
6029 smsLog(pMac, LOGW, " Failed to get frequency of channel %d", pDomainChnInfo->chnInfo[j].chnId);
6030 }
6031 }
6032 status = eHAL_STATUS_SUCCESS;
6033 }
6034
6035 return (status);
6036}
6037#endif
6038
6039eHalStatus csrGetModifyProfileFields(tpAniSirGlobal pMac, tANI_U32 sessionId,
6040 tCsrRoamModifyProfileFields *pModifyProfileFields)
6041{
6042
6043 if(!pModifyProfileFields)
6044 {
6045 return eHAL_STATUS_FAILURE;
6046 }
6047
6048 palCopyMemory( pMac->hHdd, pModifyProfileFields,
6049 &pMac->roam.roamSession[sessionId].connectedProfile.modifyProfileFields,
6050 sizeof(tCsrRoamModifyProfileFields) );
6051
6052 return eHAL_STATUS_SUCCESS;
6053}
6054
6055eHalStatus csrSetModifyProfileFields(tpAniSirGlobal pMac, tANI_U32 sessionId,
6056 tCsrRoamModifyProfileFields *pModifyProfileFields)
6057{
6058 tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
6059
6060 palCopyMemory( pMac->hHdd, &pSession->connectedProfile.modifyProfileFields,
6061 pModifyProfileFields,
6062 sizeof(tCsrRoamModifyProfileFields) );
6063
6064 return eHAL_STATUS_SUCCESS;
6065}
6066
6067
6068#if 0
6069/* ---------------------------------------------------------------------------
6070 \fn csrGetSupportedCountryCode
6071 \brief this function is to get a list of the country code current being supported
6072 \param pBuf - Caller allocated buffer with at least 3 bytes, upon success return,
6073 this has the country code list. 3 bytes for each country code. This may be NULL if
6074 caller wants to know the needed bytes.
6075 \param pbLen - Caller allocated, as input, it indicates the length of pBuf. Upon success return,
6076 this contains the length of the data in pBuf
6077 \return eHalStatus
6078 -------------------------------------------------------------------------------*/
6079eHalStatus csrGetSupportedCountryCode(tpAniSirGlobal pMac, tANI_U8 *pBuf, tANI_U32 *pbLen)
6080{
6081 tANI_U32 numOfCountry = sizeof( gCsrCountryInfo ) / sizeof( gCsrCountryInfo[0] );
6082 tANI_U32 numBytes = 0;
6083 eHalStatus status = eHAL_STATUS_INVALID_PARAMETER;
6084
6085 if( pbLen )
6086 {
6087 numBytes = *pbLen;
6088 //Consider it ok, at least we can return the number of bytes needed;
6089 *pbLen = numOfCountry * WNI_CFG_COUNTRY_CODE_LEN;
6090 status = eHAL_STATUS_SUCCESS;
6091 if( pBuf && ( numBytes >= *pbLen ) )
6092 {
6093 //The ugly part starts.
6094 //We may need to alter the data structure and find a way to make this faster.
6095 tANI_U32 i;
6096
6097 for( i = 0; i < numOfCountry; i++ )
6098 {
6099 palCopyMemory( pMac->hHdd, pBuf + ( i * WNI_CFG_COUNTRY_CODE_LEN ),
6100 gCsrCountryInfo[i].countryCode, WNI_CFG_COUNTRY_CODE_LEN );
6101 }
6102 }
6103 }
6104
6105 return ( status );
6106}
6107#endif
6108
6109/* ---------------------------------------------------------------------------
6110 \fn csrGetSupportedCountryCode
6111 \brief this function is to get a list of the country code current being supported
6112 \param pBuf - Caller allocated buffer with at least 3 bytes, upon success return,
6113 this has the country code list. 3 bytes for each country code. This may be NULL if
6114 caller wants to know the needed bytes.
6115 \param pbLen - Caller allocated, as input, it indicates the length of pBuf. Upon success return,
6116 this contains the length of the data in pBuf
6117 \return eHalStatus
6118 -------------------------------------------------------------------------------*/
6119eHalStatus csrGetSupportedCountryCode(tpAniSirGlobal pMac, tANI_U8 *pBuf, tANI_U32 *pbLen)
6120{
6121 eHalStatus status = eHAL_STATUS_SUCCESS;
6122 VOS_STATUS vosStatus;
6123 v_SIZE_t size = (v_SIZE_t)*pbLen;
6124
6125 vosStatus = vos_nv_getSupportedCountryCode( pBuf, &size, 1 );
6126 //eiter way, return the value back
6127 *pbLen = (tANI_U32)size;
6128
6129 //If pBuf is NULL, caller just want to get the size, consider it success
6130 if(pBuf)
6131 {
6132 if( VOS_IS_STATUS_SUCCESS( vosStatus ) )
6133 {
6134 tANI_U32 i, n = *pbLen / 3;
6135
6136 for( i = 0; i < n; i++ )
6137 {
6138 pBuf[i*3 + 2] = ' ';
6139 }
6140 }
6141 else
6142 {
6143 status = eHAL_STATUS_FAILURE;
6144 }
6145 }
6146
6147 return (status);
6148}
6149
6150
6151
6152//Upper layer to get the list of the base channels to scan for passively 11d info from csr
6153eHalStatus csrScanGetBaseChannels( tpAniSirGlobal pMac, tCsrChannelInfo * pChannelInfo )
6154{
6155 eHalStatus status = eHAL_STATUS_FAILURE;
6156
6157 do
6158 {
6159
6160 if(!pMac->scan.baseChannels.numChannels || !pChannelInfo)
6161 {
6162 break;
6163 }
6164 status = palAllocateMemory( pMac->hHdd, (void **)&pChannelInfo->ChannelList,
6165 pMac->scan.baseChannels.numChannels );
6166 if( !HAL_STATUS_SUCCESS( status ) )
6167 {
6168 smsLog( pMac, LOGE, FL("csrScanGetBaseChannels: fail to allocate memory\n") );
6169 break;
6170 }
6171 status = palCopyMemory( pMac->hHdd, pChannelInfo->ChannelList, pMac->scan.baseChannels.channelList,
6172 pMac->scan.baseChannels.numChannels );
6173 if( !HAL_STATUS_SUCCESS( status ) )
6174 {
6175 break;
6176 }
6177 pChannelInfo->numOfChannels = pMac->scan.baseChannels.numChannels;
6178
6179 }while(0);
6180
6181 return ( status );
6182}
6183
6184
6185tANI_BOOLEAN csrIsSetKeyAllowed(tpAniSirGlobal pMac, tANI_U32 sessionId)
6186{
6187 tANI_BOOLEAN fRet = eANI_BOOLEAN_TRUE;
6188#ifdef WLAN_SOFTAP_FEATURE
6189 tCsrRoamSession *pSession;
6190
6191 pSession =CSR_GET_SESSION(pMac, sessionId);
6192
6193 /*This condition is not working for infra state. When infra is in not-connected state
6194 * the pSession->pCurRoamProfile is NULL. And this function returns TRUE, that is incorrect.
6195 * Since SAP requires to set key without any BSS started, it needs this condition to be met.
6196 * In other words, this function is useless.
6197 * The current work-around is to process setcontext_rsp and removekey_rsp no matter what the
6198 * state is.
6199 */
6200 smsLog( pMac, LOGE, FL(" is not what it intends to. Must be revisit or removed\n") );
6201 if( (NULL == pSession) ||
6202 ( csrIsConnStateDisconnected( pMac, sessionId ) &&
6203 (pSession->pCurRoamProfile != NULL) &&
6204 (!(CSR_IS_INFRA_AP(pSession->pCurRoamProfile))) )
6205 )
6206 {
6207 fRet = eANI_BOOLEAN_FALSE;
6208 }
6209#else
6210 fRet = !( csrIsConnStateDisconnected( pMac, sessionId ) );
6211#endif
6212
6213 return ( fRet );
6214}
6215
6216//no need to acquire lock for this basic function
6217tANI_U16 sme_ChnToFreq(tANI_U8 chanNum)
6218{
6219 int i;
6220
6221 for (i = 0; i < NUM_RF_CHANNELS; i++)
6222 {
6223 if (rfChannels[i].channelNum == chanNum)
6224 {
6225 return rfChannels[i].targetFreq;
6226 }
6227 }
6228
6229 return (0);
6230}
6231
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]6232#ifndef BMPS_WORKAROUND_NOT_NEEDED
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6233/* Disconnect all active sessions by sending disassoc. This is mainly used to disconnect the remaining session when we
6234 * transition from concurrent sessions to a single session. The use case is Infra STA and wifi direct multiple sessions are up and
6235 * P2P session is removed. The Infra STA session remains and should resume BMPS if BMPS is enabled by default. However, there
6236 * are some issues seen with BMPS resume during this transition and this is a workaround which will allow the Infra STA session to
6237 * disconnect and auto connect back and enter BMPS this giving the same effect as resuming BMPS
6238 */
6239void csrDisconnectAllActiveSessions(tpAniSirGlobal pMac)
6240{
6241 tANI_U8 i;
6242
6243 /* Disconnect all the active sessions */
6244 for (i=0; i<CSR_ROAM_SESSION_MAX; i++)
6245 {
6246 if( CSR_IS_SESSION_VALID( pMac, i ) && !csrIsConnStateDisconnected( pMac, i ) )
6247 {
6248 csrRoamDisconnectInternal(pMac, i, eCSR_DISCONNECT_REASON_UNSPECIFIED);
6249 }
6250 }
6251}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame^]6252#endif