1 /*
2 * Copyright (c) 2012-2021 The Linux Foundation. All rights reserved.
3 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for
6 * any purpose with or without fee is hereby granted, provided that the
7 * above copyright notice and this permission notice appear in all
8 * copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17 * PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 /**
21 * DOC: wlan_hdd_assoc.c
22 *
23 * WLAN Host Device Driver implementation
24 *
25 */
26
27 #include "wlan_hdd_includes.h"
28 #include <ani_global.h>
29 #include "dot11f.h"
30 #include "wlan_hdd_power.h"
31 #include "wlan_hdd_trace.h"
32 #include <linux/ieee80211.h>
33 #include <linux/wireless.h>
34 #include <linux/etherdevice.h>
35 #include <net/cfg80211.h>
36 #include "wlan_hdd_cfg80211.h"
37 #include "csr_inside_api.h"
38 #include "wlan_hdd_p2p.h"
39 #include "wlan_hdd_tdls.h"
40 #include "sme_api.h"
41 #include "wlan_hdd_hostapd.h"
42 #include <wlan_hdd_green_ap.h>
43 #include <wlan_hdd_ipa.h>
44 #include "wlan_hdd_lpass.h"
45 #include <wlan_logging_sock_svc.h>
46 #include <cds_sched.h>
47 #include "wlan_policy_mgr_api.h"
48 #include <cds_utils.h>
49 #include "sme_power_save_api.h"
50 #include "wlan_hdd_napi.h"
51 #include <cdp_txrx_cmn.h>
52 #include <cdp_txrx_flow_ctrl_legacy.h>
53 #include <cdp_txrx_peer_ops.h>
54 #include <cdp_txrx_misc.h>
55 #include <cdp_txrx_ctrl.h>
56 #include "ol_txrx.h"
57 #include <wlan_logging_sock_svc.h>
58 #include <wlan_hdd_object_manager.h>
59 #include <cdp_txrx_handle.h>
60 #include "wlan_pmo_ucfg_api.h"
61 #include "wlan_hdd_tsf.h"
62 #include "wlan_utility.h"
63 #include "wlan_p2p_ucfg_api.h"
64 #include "wlan_ipa_ucfg_api.h"
65 #include "wlan_hdd_stats.h"
66 #include "wlan_hdd_scan.h"
67 #include "wlan_crypto_global_api.h"
68 #include "wlan_hdd_bcn_recv.h"
69 #include "wlan_mlme_twt_ucfg_api.h"
70
71 #include <wlan_cfg80211_crypto.h>
72 #include <wlan_crypto_global_api.h>
73 #include "wlan_dlm_ucfg_api.h"
74 #include "wlan_hdd_sta_info.h"
75 #include "wlan_hdd_ftm_time_sync.h"
76 #include "wlan_cm_roam_api.h"
77
78 #include <ol_defines.h>
79 #include "wlan_pkt_capture_ucfg_api.h"
80 #include "wlan_if_mgr_ucfg_api.h"
81 #include "wlan_if_mgr_public_struct.h"
82 #include "wlan_cm_public_struct.h"
83 #include "osif_cm_util.h"
84 #include "wlan_hdd_cm_api.h"
85 #include "cm_utf.h"
86
87 #include "wlan_hdd_bootup_marker.h"
88 #include "wlan_roam_debug.h"
89
90 #include "wlan_hdd_twt.h"
91 #include "wlan_cm_roam_ucfg_api.h"
92 #include "wlan_hdd_son.h"
93 #include "wlan_dp_ucfg_api.h"
94 #include "wlan_cm_ucfg_api.h"
95
96 /* These are needed to recognize WPA and RSN suite types */
97 #define HDD_WPA_OUI_SIZE 4
98 #define HDD_RSN_OUI_SIZE 4
99 uint8_t ccp_wpa_oui00[HDD_WPA_OUI_SIZE] = { 0x00, 0x50, 0xf2, 0x00 };
100 uint8_t ccp_wpa_oui01[HDD_WPA_OUI_SIZE] = { 0x00, 0x50, 0xf2, 0x01 };
101 uint8_t ccp_wpa_oui02[HDD_WPA_OUI_SIZE] = { 0x00, 0x50, 0xf2, 0x02 };
102 uint8_t ccp_wpa_oui03[HDD_WPA_OUI_SIZE] = { 0x00, 0x50, 0xf2, 0x03 };
103 uint8_t ccp_wpa_oui04[HDD_WPA_OUI_SIZE] = { 0x00, 0x50, 0xf2, 0x04 };
104 uint8_t ccp_wpa_oui05[HDD_WPA_OUI_SIZE] = { 0x00, 0x50, 0xf2, 0x05 };
105
106 #ifdef FEATURE_WLAN_ESE
107 /* CCKM */
108 uint8_t ccp_wpa_oui06[HDD_WPA_OUI_SIZE] = { 0x00, 0x40, 0x96, 0x00 };
109 /* CCKM */
110 uint8_t ccp_rsn_oui06[HDD_RSN_OUI_SIZE] = { 0x00, 0x40, 0x96, 0x00 };
111 #endif /* FEATURE_WLAN_ESE */
112
113 /* group cipher */
114 uint8_t ccp_rsn_oui00[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x00 };
115
116 /* WEP-40 or RSN */
117 uint8_t ccp_rsn_oui01[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x01 };
118
119 /* TKIP or RSN-PSK */
120 uint8_t ccp_rsn_oui02[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x02 };
121
122 /* Reserved */
123 uint8_t ccp_rsn_oui03[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x03 };
124
125 /* AES-CCMP */
126 uint8_t ccp_rsn_oui04[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x04 };
127
128 /* WEP-104 */
129 uint8_t ccp_rsn_oui05[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x05 };
130
131 /* RSN-PSK-SHA256 */
132 uint8_t ccp_rsn_oui07[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x06 };
133
134 /* RSN-8021X-SHA256 */
135 uint8_t ccp_rsn_oui08[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x05 };
136
137 /* AES-GCMP-128 */
138 uint8_t ccp_rsn_oui09[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x08 };
139
140 /* AES-GCMP-256 */
141 uint8_t ccp_rsn_oui0a[HDD_RSN_OUI_SIZE] = { 0x00, 0x0F, 0xAC, 0x09 };
142 #ifdef WLAN_FEATURE_FILS_SK
143 uint8_t ccp_rsn_oui_0e[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x0E};
144 uint8_t ccp_rsn_oui_0f[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x0F};
145 uint8_t ccp_rsn_oui_10[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x10};
146 uint8_t ccp_rsn_oui_11[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x11};
147 #endif
148 uint8_t ccp_rsn_oui_12[HDD_RSN_OUI_SIZE] = {0x50, 0x6F, 0x9A, 0x02};
149 uint8_t ccp_rsn_oui_0b[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x0B};
150 uint8_t ccp_rsn_oui_0c[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x0C};
151 /* FT-SUITE-B AKM */
152 uint8_t ccp_rsn_oui_0d[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x0D};
153
154 /* OWE https://tools.ietf.org/html/rfc8110 */
155 uint8_t ccp_rsn_oui_18[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x12};
156
157 #ifdef WLAN_FEATURE_SAE
158 /* SAE AKM */
159 uint8_t ccp_rsn_oui_80[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x08};
160 /* FT SAE AKM */
161 uint8_t ccp_rsn_oui_90[HDD_RSN_OUI_SIZE] = {0x00, 0x0F, 0xAC, 0x09};
162 #endif
163 static const
164 u8 ccp_rsn_oui_13[HDD_RSN_OUI_SIZE] = {0x50, 0x6F, 0x9A, 0x01};
165
166 #ifdef FEATURE_WLAN_WAPI
167 #define HDD_WAPI_OUI_SIZE 4
168 /* WPI-SMS4 */
169 uint8_t ccp_wapi_oui01[HDD_WAPI_OUI_SIZE] = { 0x00, 0x14, 0x72, 0x01 };
170 /* WAI-PSK */
171 uint8_t ccp_wapi_oui02[HDD_WAPI_OUI_SIZE] = { 0x00, 0x14, 0x72, 0x02 };
172 #endif /* FEATURE_WLAN_WAPI */
173
174 /* Offset where the EID-Len-IE, start. */
175 #define ASSOC_RSP_IES_OFFSET 6 /* Capability(2) + AID(2) + Status Code(2) */
176 #define ASSOC_REQ_IES_OFFSET 4 /* Capability(2) + LI(2) */
177
178 /*
179 * beacon_filter_table - table of IEs used for beacon filtering
180 */
181 static const int beacon_filter_table[] = {
182 WLAN_ELEMID_DSPARMS,
183 WLAN_ELEMID_ERP,
184 WLAN_ELEMID_EDCAPARMS,
185 WLAN_ELEMID_QOS_CAPABILITY,
186 WLAN_ELEMID_HTINFO_ANA,
187 WLAN_ELEMID_OP_MODE_NOTIFY,
188 WLAN_ELEMID_VHTOP,
189 WLAN_ELEMID_QUIET_CHANNEL,
190 WLAN_ELEMID_TWT,
191 #ifdef WLAN_FEATURE_11AX_BSS_COLOR
192 /*
193 * EID: 221 vendor IE is being used temporarily by 11AX
194 * bss-color-change IE till it gets any fixed number. This
195 * vendor EID needs to be replaced with bss-color-change IE
196 * number.
197 */
198 WLAN_ELEMID_VENDOR,
199 #endif
200 };
201
202 /*
203 * beacon_filter_extn_table - table of extn IEs used for beacon filtering
204 */
205 static const int beacon_filter_extn_table[] = {
206 WLAN_EXTN_ELEMID_HEOP,
207 WLAN_EXTN_ELEMID_UORA,
208 WLAN_EXTN_ELEMID_MUEDCA,
209 #ifdef WLAN_FEATURE_11BE
210 WLAN_EXTN_ELEMID_EHTOP,
211 #endif
212 };
213
214 /* HE operation BIT positins */
215 #if defined(WLAN_FEATURE_11AX)
216 #define HE_OPERATION_DFLT_PE_DURATION_POS 0
217 #define HE_OPERATION_TWT_REQUIRED_POS 3
218 #define HE_OPERATION_RTS_THRESHOLD_POS 4
219 #define HE_OPERATION_VHT_OPER_POS 14
220 #define HE_OPERATION_CO_LOCATED_BSS_POS 15
221 #define HE_OPERATION_ER_SU_DISABLE_POS 16
222 #define HE_OPERATION_OPER_INFO_6G_POS 17
223 #define HE_OPERATION_RESERVED_POS 18
224 #define HE_OPERATION_BSS_COLOR_POS 24
225 #define HE_OPERATION_PARTIAL_BSS_COLOR_POS 30
226 #define HE_OPERATION_BSS_COL_DISABLED_POS 31
227 #endif
228
229 /* EHT operation BIT positins */
230 #if defined(WLAN_FEATURE_11BE)
231 #define EHT_OPER_BASIC_RX_NSS_MCS_0_TO_7_POS 0
232 #define EHT_OPER_BASIC_TX_NSS_MCS_0_TO_7_POS 4
233 #define EHT_OPER_BASIC_RX_NSS_MCS_8_AND_9_POS 8
234 #define EHT_OPER_BASIC_TX_NSS_MCS_8_AND_9_POS 12
235 #define EHT_OPER_BASIC_RX_NSS_MCS_10_AND_11_POS 16
236 #define EHT_OPER_BASIC_TX_NSS_MCS_10_AND_11_POS 20
237 #define EHT_OPER_BASIC_RX_NSS_MCS_12_AND_13_POS 24
238 #define EHT_OPER_BASIC_TX_NSS_MCS_12_AND_13_POS 28
239 #endif
240
241 #if defined(WLAN_FEATURE_SAE) && \
242 (defined(CFG80211_EXTERNAL_AUTH_SUPPORT) || \
243 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0))
244 #if defined (CFG80211_SAE_AUTH_TA_ADDR_SUPPORT)
245 /**
246 * wlan_hdd_sae_copy_ta_addr() - Send TA address to supplicant
247 * @params: pointer to external auth params
248 * @link_info: Link info pointer in HDD adapter
249 *
250 * This API is used to copy TA address info in supplicant structure.
251 *
252 * Return: None
253 */
254 static inline
wlan_hdd_sae_copy_ta_addr(struct cfg80211_external_auth_params * params,struct wlan_hdd_link_info * link_info)255 void wlan_hdd_sae_copy_ta_addr(struct cfg80211_external_auth_params *params,
256 struct wlan_hdd_link_info *link_info)
257 {
258 struct qdf_mac_addr ta = QDF_MAC_ADDR_ZERO_INIT;
259 QDF_STATUS status = QDF_STATUS_SUCCESS;
260 uint8_t *link_addr;
261
262 status = ucfg_cm_get_sae_auth_ta(link_info->adapter->hdd_ctx->pdev,
263 link_info->vdev_id,
264 &ta);
265 if (QDF_IS_STATUS_SUCCESS(status))
266 qdf_ether_addr_copy(params->tx_addr, ta.bytes);
267 else if (wlan_vdev_mlme_is_mlo_vdev(link_info->vdev)) {
268 link_addr = wlan_vdev_mlme_get_linkaddr(link_info->vdev);
269 qdf_ether_addr_copy(params->tx_addr, link_addr);
270 }
271
272 hdd_debug("status:%d ta:" QDF_MAC_ADDR_FMT, status,
273 QDF_MAC_ADDR_REF(params->tx_addr));
274
275 }
276 #else
277 static inline
wlan_hdd_sae_copy_ta_addr(struct cfg80211_external_auth_params * params,struct wlan_hdd_link_info * link_info)278 void wlan_hdd_sae_copy_ta_addr(struct cfg80211_external_auth_params *params,
279 struct wlan_hdd_link_info *link_info)
280 {
281 }
282 #endif
283
284 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_EXTERNAL_AUTH_MLO_SUPPORT)
285 /**
286 * wlan_hdd_sae_update_mld_addr() - Send mld address to supplicant
287 * @params: pointer to external auth params
288 * @link_info: Link info pointer in HDD adapter
289 *
290 * This API is used to copy MLD address info in supplicant structure.
291 *
292 * Return: QDF_STATUS
293 */
294 static inline QDF_STATUS
wlan_hdd_sae_update_mld_addr(struct cfg80211_external_auth_params * params,struct wlan_hdd_link_info * link_info)295 wlan_hdd_sae_update_mld_addr(struct cfg80211_external_auth_params *params,
296 struct wlan_hdd_link_info *link_info)
297 {
298 struct qdf_mac_addr mld_addr;
299 struct qdf_mac_addr *mld_roaming_addr;
300 QDF_STATUS status = QDF_STATUS_SUCCESS;
301 struct wlan_objmgr_vdev *vdev;
302
303 if (!link_info->vdev)
304 return QDF_STATUS_E_INVAL;
305
306 vdev = link_info->vdev;
307 wlan_objmgr_vdev_get_ref(vdev, WLAN_HDD_ID_OBJ_MGR);
308
309 if (!ucfg_cm_is_sae_auth_addr_conversion_required(vdev))
310 goto end;
311
312 if (ucfg_cm_is_vdev_roaming(vdev)) {
313 /*
314 * while roaming, peer is not created yet till authentication
315 * So retrieving the MLD address which is cached from the
316 * scan entry.
317 */
318 mld_roaming_addr = ucfg_cm_roaming_get_peer_mld_addr(vdev);
319 if (!mld_roaming_addr) {
320 status = QDF_STATUS_E_INVAL;
321 goto end;
322 }
323 mld_addr = *mld_roaming_addr;
324 } else {
325 status = wlan_vdev_get_bss_peer_mld_mac(vdev, &mld_addr);
326 if (QDF_IS_STATUS_ERROR(status)) {
327 status = QDF_STATUS_E_INVAL;
328 goto end;
329 }
330 }
331
332 qdf_mem_copy(params->mld_addr, mld_addr.bytes, QDF_MAC_ADDR_SIZE);
333 hdd_debug("Sending MLD:" QDF_MAC_ADDR_FMT" to userspace",
334 QDF_MAC_ADDR_REF(mld_addr.bytes));
335
336 end:
337 wlan_objmgr_vdev_release_ref(vdev, WLAN_HDD_ID_OBJ_MGR);
338 return status;
339 }
340 #else
341 static inline QDF_STATUS
wlan_hdd_sae_update_mld_addr(struct cfg80211_external_auth_params * params,struct wlan_hdd_link_info * link_info)342 wlan_hdd_sae_update_mld_addr(struct cfg80211_external_auth_params *params,
343 struct wlan_hdd_link_info *link_info)
344 {
345 return QDF_STATUS_SUCCESS;
346 }
347 #endif
348
349 /**
350 * wlan_hdd_get_keymgmt_for_sae_akm() - Get the keymgmt OUI
351 * corresponding to the SAE AKM type
352 * @akm: AKM type
353 *
354 * This API is used to get the keymgmt OUI for the SAE AKM type.
355 * Return: keymgmt OUI
356 */
357 static uint32_t
wlan_hdd_get_keymgmt_for_sae_akm(uint32_t akm)358 wlan_hdd_get_keymgmt_for_sae_akm(uint32_t akm)
359 {
360 if (akm == WLAN_AKM_SAE)
361 return WLAN_AKM_SUITE_SAE;
362 else if (akm == WLAN_AKM_FT_SAE)
363 return WLAN_AKM_SUITE_FT_OVER_SAE;
364 else if (akm == WLAN_AKM_SAE_EXT_KEY)
365 return WLAN_AKM_SUITE_SAE_EXT_KEY;
366 else if (akm == WLAN_AKM_FT_SAE_EXT_KEY)
367 return WLAN_AKM_SUITE_FT_SAE_EXT_KEY;
368 /**
369 * Legacy FW doesn't support SAE-EXK-KEY or
370 * Cross-SAE_AKM roaming. In such cases, send
371 * SAE for both SAE and FT-SAE AKMs. The supplicant
372 * has backward compatibility to handle this case.
373 */
374 else
375 return WLAN_AKM_SUITE_SAE;
376 }
377
378 /**
379 * wlan_hdd_sae_callback() - Sends SAE info to supplicant
380 * @link_info: Link info pointer in HDD adapter
381 * @roam_info: pointer to roam info
382 *
383 * This API is used to send required SAE info to trigger SAE in supplicant.
384 *
385 * Return: None
386 */
wlan_hdd_sae_callback(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roam_info)387 static void wlan_hdd_sae_callback(struct wlan_hdd_link_info *link_info,
388 struct csr_roam_info *roam_info)
389 {
390 struct hdd_adapter *adapter = link_info->adapter;
391 struct hdd_context *hdd_ctx = adapter->hdd_ctx;
392 int flags;
393 struct sir_sae_info *sae_info = roam_info->sae_info;
394 struct cfg80211_external_auth_params params = {0};
395 QDF_STATUS status;
396
397 if (wlan_hdd_validate_context(hdd_ctx))
398 return;
399
400 if (!sae_info) {
401 hdd_err("SAE info in NULL");
402 return;
403 }
404
405 flags = cds_get_gfp_flags();
406
407 params.key_mgmt_suite =
408 wlan_hdd_get_keymgmt_for_sae_akm(sae_info->akm);
409
410 params.action = NL80211_EXTERNAL_AUTH_START;
411 qdf_ether_addr_copy(params.bssid, sae_info->peer_mac_addr.bytes);
412 wlan_hdd_sae_copy_ta_addr(¶ms, link_info);
413 status = wlan_hdd_sae_update_mld_addr(¶ms, link_info);
414 if (QDF_IS_STATUS_ERROR(status))
415 return;
416
417 qdf_mem_copy(params.ssid.ssid, sae_info->ssid.ssId,
418 sae_info->ssid.length);
419 params.ssid.ssid_len = sae_info->ssid.length;
420 cfg80211_external_auth_request(adapter->dev, ¶ms, flags);
421 hdd_debug("SAE: sent cmd");
422 }
423 #else
wlan_hdd_sae_callback(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roam_info)424 static inline void wlan_hdd_sae_callback(struct wlan_hdd_link_info *link_info,
425 struct csr_roam_info *roam_info)
426 { }
427 #endif
428
429 /**
430 * hdd_start_powersave_timer_on_associated() - Start auto powersave timer
431 * after associated
432 * @link_info: Link info pointer in HDD adapter
433 *
434 * This function will start auto powersave timer for STA/P2P Client.
435 *
436 * Return: none
437 */
438 static void
hdd_start_powersave_timer_on_associated(struct wlan_hdd_link_info * link_info)439 hdd_start_powersave_timer_on_associated(struct wlan_hdd_link_info *link_info)
440 {
441 uint32_t timeout;
442 uint32_t auto_bmps_timer_val;
443 struct hdd_adapter *adapter = link_info->adapter;
444 struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
445
446 if (adapter->device_mode != QDF_STA_MODE &&
447 adapter->device_mode != QDF_P2P_CLIENT_MODE)
448 return;
449
450 ucfg_mlme_get_auto_bmps_timer_value(hdd_ctx->psoc,
451 &auto_bmps_timer_val);
452 timeout = hdd_cm_is_vdev_roaming(link_info) ?
453 AUTO_PS_ENTRY_TIMER_DEFAULT_VALUE :
454 (auto_bmps_timer_val * 1000);
455 sme_ps_enable_auto_ps_timer(hdd_ctx->mac_handle,
456 link_info->vdev_id,
457 timeout);
458 }
459
hdd_conn_set_authenticated(struct wlan_hdd_link_info * link_info,uint8_t auth_state)460 void hdd_conn_set_authenticated(struct wlan_hdd_link_info *link_info,
461 uint8_t auth_state)
462 {
463 struct hdd_station_ctx *sta_ctx;
464 struct wlan_objmgr_vdev *vdev;
465 char *auth_time;
466 uint32_t time_buffer_size;
467
468 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
469 /* save the new connection state */
470 hdd_debug("Authenticated state Changed from oldState:%d to State:%d",
471 sta_ctx->conn_info.is_authenticated, auth_state);
472 sta_ctx->conn_info.is_authenticated = auth_state;
473
474 vdev = hdd_objmgr_get_vdev_by_user(link_info, WLAN_DP_ID);
475 if (vdev) {
476 ucfg_dp_conn_info_set_peer_authenticate(vdev, auth_state);
477 hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
478 }
479
480 auth_time = sta_ctx->conn_info.auth_time;
481 time_buffer_size = sizeof(sta_ctx->conn_info.auth_time);
482
483 if (auth_state)
484 qdf_get_time_of_the_day_in_hr_min_sec_usec(auth_time,
485 time_buffer_size);
486 else
487 qdf_mem_zero(auth_time, time_buffer_size);
488 if (auth_state &&
489 (sta_ctx->conn_info.ptk_installed ||
490 sta_ctx->conn_info.uc_encrypt_type == eCSR_ENCRYPT_TYPE_NONE))
491 hdd_start_powersave_timer_on_associated(link_info);
492 }
493
hdd_conn_set_connection_state(struct hdd_adapter * adapter,eConnectionState conn_state)494 void hdd_conn_set_connection_state(struct hdd_adapter *adapter,
495 eConnectionState conn_state)
496 {
497 struct hdd_station_ctx *hdd_sta_ctx =
498 WLAN_HDD_GET_STATION_CTX_PTR(adapter->deflink);
499
500 /* save the new connection state */
501 if (conn_state == hdd_sta_ctx->conn_info.conn_state)
502 return;
503
504 hdd_nofl_debug("connection state changed %d --> %d for dev %s (vdev %d)",
505 hdd_sta_ctx->conn_info.conn_state, conn_state,
506 adapter->dev->name, adapter->deflink->vdev_id);
507
508 hdd_sta_ctx->conn_info.conn_state = conn_state;
509 }
510
hdd_conn_get_connected_band(struct wlan_hdd_link_info * link_info)511 enum band_info hdd_conn_get_connected_band(struct wlan_hdd_link_info *link_info)
512 {
513 struct hdd_station_ctx *sta_ctx;
514 uint32_t sta_freq = 0;
515
516 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
517 if (hdd_cm_is_vdev_associated(link_info))
518 sta_freq = sta_ctx->conn_info.chan_freq;
519
520 if (wlan_reg_is_24ghz_ch_freq(sta_freq))
521 return BAND_2G;
522 else if (wlan_reg_is_5ghz_ch_freq(sta_freq) ||
523 wlan_reg_is_6ghz_chan_freq(sta_freq))
524 return BAND_5G;
525 else /* If station is not connected return as BAND_ALL */
526 return BAND_ALL;
527 }
528
529 /**
530 * hdd_conn_get_connected_cipher_algo() - get current connection cipher type
531 * @link_info: Link info pointer in HDD adapter.
532 * @sta_ctx: pointer to global HDD Station context
533 * @pConnectedCipherAlgo: pointer to connected cipher algo
534 *
535 * Return: false if any errors encountered, true otherwise
536 */
537 static inline bool
hdd_conn_get_connected_cipher_algo(struct wlan_hdd_link_info * link_info,struct hdd_station_ctx * sta_ctx,eCsrEncryptionType * pConnectedCipherAlgo)538 hdd_conn_get_connected_cipher_algo(struct wlan_hdd_link_info *link_info,
539 struct hdd_station_ctx *sta_ctx,
540 eCsrEncryptionType *pConnectedCipherAlgo)
541 {
542 bool connected;
543
544 connected = hdd_cm_is_vdev_associated(link_info);
545 if (pConnectedCipherAlgo)
546 *pConnectedCipherAlgo = sta_ctx->conn_info.uc_encrypt_type;
547
548 return connected;
549 }
550
551 struct wlan_hdd_link_info *
hdd_get_sta_connection_in_progress(struct hdd_context * hdd_ctx)552 hdd_get_sta_connection_in_progress(struct hdd_context *hdd_ctx)
553 {
554 struct hdd_adapter *adapter = NULL, *next_adapter = NULL;
555 wlan_net_dev_ref_dbgid dbgid =
556 NET_DEV_HOLD_GET_STA_CONNECTION_IN_PROGRESS;
557 struct wlan_hdd_link_info *link_info;
558
559 if (!hdd_ctx) {
560 hdd_err("HDD context is NULL");
561 return NULL;
562 }
563
564 hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter,
565 dbgid) {
566 if ((QDF_STA_MODE == adapter->device_mode) ||
567 (QDF_P2P_CLIENT_MODE == adapter->device_mode) ||
568 (QDF_P2P_DEVICE_MODE == adapter->device_mode)) {
569 hdd_adapter_for_each_active_link_info(adapter,
570 link_info) {
571 if (!hdd_cm_is_connecting(link_info))
572 continue;
573
574 hdd_debug("vdev_id %d: Connection is in progress",
575 link_info->vdev_id);
576 hdd_adapter_dev_put_debug(adapter, dbgid);
577 if (next_adapter)
578 hdd_adapter_dev_put_debug(next_adapter,
579 dbgid);
580 return link_info;
581 }
582 }
583 hdd_adapter_dev_put_debug(adapter, dbgid);
584 }
585 return NULL;
586 }
587
hdd_abort_ongoing_sta_connection(struct hdd_context * hdd_ctx)588 void hdd_abort_ongoing_sta_connection(struct hdd_context *hdd_ctx)
589 {
590 struct wlan_hdd_link_info *link_info;
591
592 link_info = hdd_get_sta_connection_in_progress(hdd_ctx);
593 if (link_info &&
594 !wlan_vdev_mlme_is_mlo_link_switch_in_progress(link_info->vdev))
595 wlan_hdd_cm_issue_disconnect(link_info,
596 REASON_UNSPEC_FAILURE, false);
597 }
598
hdd_abort_ongoing_sta_sae_connection(struct hdd_context * hdd_ctx)599 void hdd_abort_ongoing_sta_sae_connection(struct hdd_context *hdd_ctx)
600 {
601 struct wlan_hdd_link_info *link_info;
602 struct wlan_objmgr_vdev *vdev;
603 int32_t key_mgmt;
604
605 link_info = hdd_get_sta_connection_in_progress(hdd_ctx);
606 if (!link_info ||
607 wlan_vdev_mlme_is_mlo_link_switch_in_progress(link_info->vdev))
608 return;
609
610 vdev = hdd_objmgr_get_vdev_by_user(link_info->adapter->deflink,
611 WLAN_OSIF_ID);
612 if (!vdev)
613 return;
614
615 key_mgmt = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_KEY_MGMT);
616 hdd_objmgr_put_vdev_by_user(vdev, WLAN_OSIF_ID);
617
618 if (key_mgmt < 0) {
619 hdd_debug_rl("Invalid key_mgmt: %d", key_mgmt);
620 return;
621 }
622
623 if (QDF_HAS_PARAM(key_mgmt, WLAN_CRYPTO_KEY_MGMT_SAE) ||
624 QDF_HAS_PARAM(key_mgmt, WLAN_CRYPTO_KEY_MGMT_FT_SAE) ||
625 QDF_HAS_PARAM(key_mgmt, WLAN_CRYPTO_KEY_MGMT_SAE_EXT_KEY) ||
626 QDF_HAS_PARAM(key_mgmt, WLAN_CRYPTO_KEY_MGMT_FT_SAE_EXT_KEY))
627 wlan_hdd_cm_issue_disconnect(link_info->adapter->deflink,
628 REASON_DISASSOC_NETWORK_LEAVING,
629 false);
630 }
631
hdd_get_first_connected_sta_vdev_id(struct hdd_context * hdd_ctx,uint32_t * vdev_id)632 QDF_STATUS hdd_get_first_connected_sta_vdev_id(struct hdd_context *hdd_ctx,
633 uint32_t *vdev_id)
634 {
635 struct hdd_adapter *adapter = NULL, *next_adapter = NULL;
636 wlan_net_dev_ref_dbgid dbgid = NET_DEV_HOLD_IS_ANY_STA_CONNECTED;
637 struct wlan_hdd_link_info *link_info;
638
639 if (!hdd_ctx) {
640 hdd_err("HDD context is NULL");
641 return QDF_STATUS_E_INVAL;
642 }
643
644 hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter,
645 dbgid) {
646 if (adapter->device_mode == QDF_STA_MODE ||
647 adapter->device_mode == QDF_P2P_CLIENT_MODE) {
648 hdd_adapter_for_each_active_link_info(adapter,
649 link_info) {
650 if (!hdd_cm_is_vdev_connected(link_info))
651 continue;
652
653 *vdev_id = link_info->vdev_id;
654 hdd_adapter_dev_put_debug(adapter, dbgid);
655 if (next_adapter)
656 hdd_adapter_dev_put_debug(next_adapter,
657 dbgid);
658 return QDF_STATUS_SUCCESS;
659 }
660 }
661 hdd_adapter_dev_put_debug(adapter, dbgid);
662 }
663 return QDF_STATUS_E_FAILURE;
664 }
665
hdd_is_any_sta_connected(struct hdd_context * hdd_ctx)666 bool hdd_is_any_sta_connected(struct hdd_context *hdd_ctx)
667 {
668 QDF_STATUS status;
669 uint32_t vdev_id;
670
671 status = hdd_get_first_connected_sta_vdev_id(hdd_ctx, &vdev_id);
672 return QDF_IS_STATUS_ERROR(status) ? false : true;
673 }
674
675 /**
676 * hdd_remove_beacon_filter() - remove beacon filter
677 * @adapter: Pointer to the hdd adapter
678 *
679 * Return: 0 on success and errno on failure
680 */
hdd_remove_beacon_filter(struct hdd_adapter * adapter)681 int hdd_remove_beacon_filter(struct hdd_adapter *adapter)
682 {
683 QDF_STATUS status;
684 struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
685
686 status = sme_remove_beacon_filter(hdd_ctx->mac_handle,
687 adapter->deflink->vdev_id);
688 if (!QDF_IS_STATUS_SUCCESS(status)) {
689 hdd_err("sme_remove_beacon_filter() failed");
690 return -EFAULT;
691 }
692
693 return 0;
694 }
695
hdd_add_beacon_filter(struct hdd_adapter * adapter)696 int hdd_add_beacon_filter(struct hdd_adapter *adapter)
697 {
698 int i;
699 uint32_t ie_map[SIR_BCN_FLT_MAX_ELEMS_IE_LIST] = {0};
700 QDF_STATUS status;
701 struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
702
703 for (i = 0; i < ARRAY_SIZE(beacon_filter_table); i++)
704 qdf_set_bit(beacon_filter_table[i],
705 (unsigned long *)ie_map);
706
707 for (i = 0; i < ARRAY_SIZE(beacon_filter_extn_table); i++)
708 qdf_set_bit(beacon_filter_extn_table[i] + WLAN_ELEMID_EXTN_ELEM,
709 (unsigned long *)ie_map);
710
711 status = sme_add_beacon_filter(hdd_ctx->mac_handle,
712 adapter->deflink->vdev_id, ie_map);
713 if (!QDF_IS_STATUS_SUCCESS(status)) {
714 hdd_err("sme_add_beacon_filter() failed");
715 return -EFAULT;
716 }
717 return 0;
718 }
719
hdd_copy_ht_caps(struct ieee80211_ht_cap * hdd_ht_cap,tDot11fIEHTCaps * roam_ht_cap)720 void hdd_copy_ht_caps(struct ieee80211_ht_cap *hdd_ht_cap,
721 tDot11fIEHTCaps *roam_ht_cap)
722
723 {
724 uint32_t i, temp_ht_cap;
725
726 qdf_mem_zero(hdd_ht_cap, sizeof(struct ieee80211_ht_cap));
727
728 if (roam_ht_cap->advCodingCap)
729 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_LDPC_CODING;
730 if (roam_ht_cap->supportedChannelWidthSet)
731 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
732 temp_ht_cap = roam_ht_cap->mimoPowerSave &
733 (IEEE80211_HT_CAP_SM_PS >> IEEE80211_HT_CAP_SM_PS_SHIFT);
734 if (temp_ht_cap)
735 hdd_ht_cap->cap_info |=
736 temp_ht_cap << IEEE80211_HT_CAP_SM_PS_SHIFT;
737 if (roam_ht_cap->greenField)
738 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_GRN_FLD;
739 if (roam_ht_cap->shortGI20MHz)
740 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_SGI_20;
741 if (roam_ht_cap->shortGI40MHz)
742 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_SGI_40;
743 if (roam_ht_cap->txSTBC)
744 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_TX_STBC;
745 temp_ht_cap = roam_ht_cap->rxSTBC & (IEEE80211_HT_CAP_RX_STBC >>
746 IEEE80211_HT_CAP_RX_STBC_SHIFT);
747 if (temp_ht_cap)
748 hdd_ht_cap->cap_info |=
749 temp_ht_cap << IEEE80211_HT_CAP_RX_STBC_SHIFT;
750 if (roam_ht_cap->delayedBA)
751 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_DELAY_BA;
752 if (roam_ht_cap->maximalAMSDUsize)
753 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_MAX_AMSDU;
754 if (roam_ht_cap->dsssCckMode40MHz)
755 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_DSSSCCK40;
756 if (roam_ht_cap->psmp)
757 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_RESERVED;
758 if (roam_ht_cap->stbcControlFrame)
759 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_40MHZ_INTOLERANT;
760 if (roam_ht_cap->lsigTXOPProtection)
761 hdd_ht_cap->cap_info |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
762
763 /* 802.11n HT capability AMPDU settings (for ampdu_params_info) */
764 if (roam_ht_cap->maxRxAMPDUFactor)
765 hdd_ht_cap->ampdu_params_info |=
766 IEEE80211_HT_AMPDU_PARM_FACTOR;
767 temp_ht_cap = roam_ht_cap->mpduDensity &
768 (IEEE80211_HT_AMPDU_PARM_DENSITY >>
769 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
770 if (temp_ht_cap)
771 hdd_ht_cap->ampdu_params_info |=
772 temp_ht_cap << IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT;
773
774 /* 802.11n HT extended capabilities masks */
775 if (roam_ht_cap->pco)
776 hdd_ht_cap->extended_ht_cap_info |=
777 IEEE80211_HT_EXT_CAP_PCO;
778 temp_ht_cap = roam_ht_cap->transitionTime &
779 (IEEE80211_HT_EXT_CAP_PCO_TIME >>
780 IEEE80211_HT_EXT_CAP_PCO_TIME_SHIFT);
781 if (temp_ht_cap)
782 hdd_ht_cap->extended_ht_cap_info |=
783 temp_ht_cap << IEEE80211_HT_EXT_CAP_PCO_TIME_SHIFT;
784 temp_ht_cap = roam_ht_cap->mcsFeedback &
785 (IEEE80211_HT_EXT_CAP_MCS_FB >> IEEE80211_HT_EXT_CAP_MCS_FB_SHIFT);
786 if (temp_ht_cap)
787 hdd_ht_cap->extended_ht_cap_info |=
788 temp_ht_cap << IEEE80211_HT_EXT_CAP_MCS_FB_SHIFT;
789
790 /* tx_bf_cap_info capabilities */
791 if (roam_ht_cap->txBF)
792 hdd_ht_cap->tx_BF_cap_info |= TX_BF_CAP_INFO_TX_BF;
793 if (roam_ht_cap->rxStaggeredSounding)
794 hdd_ht_cap->tx_BF_cap_info |=
795 TX_BF_CAP_INFO_RX_STAG_RED_SOUNDING;
796 if (roam_ht_cap->txStaggeredSounding)
797 hdd_ht_cap->tx_BF_cap_info |=
798 TX_BF_CAP_INFO_TX_STAG_RED_SOUNDING;
799 if (roam_ht_cap->rxZLF)
800 hdd_ht_cap->tx_BF_cap_info |= TX_BF_CAP_INFO_RX_ZFL;
801 if (roam_ht_cap->txZLF)
802 hdd_ht_cap->tx_BF_cap_info |= TX_BF_CAP_INFO_TX_ZFL;
803 if (roam_ht_cap->implicitTxBF)
804 hdd_ht_cap->tx_BF_cap_info |= TX_BF_CAP_INFO_IMP_TX_BF;
805 temp_ht_cap = roam_ht_cap->calibration &
806 (TX_BF_CAP_INFO_CALIBRATION >> TX_BF_CAP_INFO_CALIBRATION_SHIFT);
807 if (temp_ht_cap)
808 hdd_ht_cap->tx_BF_cap_info |=
809 temp_ht_cap << TX_BF_CAP_INFO_CALIBRATION_SHIFT;
810 if (roam_ht_cap->explicitCSITxBF)
811 hdd_ht_cap->tx_BF_cap_info |= TX_BF_CAP_INFO_EXP_CSIT_BF;
812 if (roam_ht_cap->explicitUncompressedSteeringMatrix)
813 hdd_ht_cap->tx_BF_cap_info |=
814 TX_BF_CAP_INFO_EXP_UNCOMP_STEER_MAT;
815 temp_ht_cap = roam_ht_cap->explicitBFCSIFeedback &
816 (TX_BF_CAP_INFO_EXP_BF_CSI_FB >>
817 TX_BF_CAP_INFO_EXP_BF_CSI_FB_SHIFT);
818 if (temp_ht_cap)
819 hdd_ht_cap->tx_BF_cap_info |=
820 temp_ht_cap << TX_BF_CAP_INFO_EXP_BF_CSI_FB_SHIFT;
821 temp_ht_cap =
822 roam_ht_cap->explicitUncompressedSteeringMatrixFeedback &
823 (TX_BF_CAP_INFO_EXP_UNCMP_STEER_MAT >>
824 TX_BF_CAP_INFO_EXP_UNCMP_STEER_MAT_SHIFT);
825 if (temp_ht_cap)
826 hdd_ht_cap->tx_BF_cap_info |=
827 temp_ht_cap <<
828 TX_BF_CAP_INFO_EXP_UNCMP_STEER_MAT_SHIFT;
829 temp_ht_cap =
830 roam_ht_cap->explicitCompressedSteeringMatrixFeedback &
831 (TX_BF_CAP_INFO_EXP_CMP_STEER_MAT_FB >>
832 TX_BF_CAP_INFO_EXP_CMP_STEER_MAT_FB_SHIFT);
833 if (temp_ht_cap)
834 hdd_ht_cap->tx_BF_cap_info |=
835 temp_ht_cap <<
836 TX_BF_CAP_INFO_EXP_CMP_STEER_MAT_FB_SHIFT;
837 temp_ht_cap = roam_ht_cap->csiNumBFAntennae &
838 (TX_BF_CAP_INFO_CSI_NUM_BF_ANT >>
839 TX_BF_CAP_INFO_CSI_NUM_BF_ANT_SHIFT);
840 if (temp_ht_cap)
841 hdd_ht_cap->tx_BF_cap_info |=
842 temp_ht_cap << TX_BF_CAP_INFO_CSI_NUM_BF_ANT_SHIFT;
843 temp_ht_cap = roam_ht_cap->uncompressedSteeringMatrixBFAntennae &
844 (TX_BF_CAP_INFO_UNCOMP_STEER_MAT_BF_ANT >>
845 TX_BF_CAP_INFO_UNCOMP_STEER_MAT_BF_ANT_SHIFT);
846 if (temp_ht_cap)
847 hdd_ht_cap->tx_BF_cap_info |=
848 temp_ht_cap <<
849 TX_BF_CAP_INFO_UNCOMP_STEER_MAT_BF_ANT_SHIFT;
850 temp_ht_cap = roam_ht_cap->compressedSteeringMatrixBFAntennae &
851 (TX_BF_CAP_INFO_COMP_STEER_MAT_BF_ANT >>
852 TX_BF_CAP_INFO_COMP_STEER_MAT_BF_ANT_SHIFT);
853 if (temp_ht_cap)
854 hdd_ht_cap->tx_BF_cap_info |=
855 temp_ht_cap <<
856 TX_BF_CAP_INFO_COMP_STEER_MAT_BF_ANT_SHIFT;
857
858 /* antenna selection */
859 if (roam_ht_cap->antennaSelection)
860 hdd_ht_cap->antenna_selection_info |= ANTENNA_SEL_INFO;
861 if (roam_ht_cap->explicitCSIFeedbackTx)
862 hdd_ht_cap->antenna_selection_info |=
863 ANTENNA_SEL_INFO_EXP_CSI_FB_TX;
864 if (roam_ht_cap->antennaIndicesFeedbackTx)
865 hdd_ht_cap->antenna_selection_info |=
866 ANTENNA_SEL_INFO_ANT_ID_FB_TX;
867 if (roam_ht_cap->explicitCSIFeedback)
868 hdd_ht_cap->antenna_selection_info |=
869 ANTENNA_SEL_INFO_EXP_CSI_FB;
870 if (roam_ht_cap->antennaIndicesFeedback)
871 hdd_ht_cap->antenna_selection_info |=
872 ANTENNA_SEL_INFO_ANT_ID_FB;
873 if (roam_ht_cap->rxAS)
874 hdd_ht_cap->antenna_selection_info |=
875 ANTENNA_SEL_INFO_RX_AS;
876 if (roam_ht_cap->txSoundingPPDUs)
877 hdd_ht_cap->antenna_selection_info |=
878 ANTENNA_SEL_INFO_TX_SOUNDING_PPDU;
879
880 /* mcs data rate */
881 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; ++i)
882 hdd_ht_cap->mcs.rx_mask[i] =
883 roam_ht_cap->supportedMCSSet[i];
884 hdd_ht_cap->mcs.rx_highest =
885 ((short) (roam_ht_cap->supportedMCSSet[11]) << 8) |
886 ((short) (roam_ht_cap->supportedMCSSet[10]));
887 hdd_ht_cap->mcs.tx_params =
888 roam_ht_cap->supportedMCSSet[12];
889 }
890
891 #define VHT_CAP_MAX_MPDU_LENGTH_MASK 0x00000003
892 #define VHT_CAP_SUPP_CHAN_WIDTH_MASK_SHIFT 2
893 #define VHT_CAP_RXSTBC_MASK_SHIFT 8
894 #define VHT_CAP_BEAMFORMEE_STS_SHIFT 13
895 #define VHT_CAP_BEAMFORMEE_STS_MASK \
896 (0x0000e000 >> VHT_CAP_BEAMFORMEE_STS_SHIFT)
897 #define VHT_CAP_SOUNDING_DIMENSIONS_SHIFT 16
898 #define VHT_CAP_SOUNDING_DIMENSIONS_MASK \
899 (0x00070000 >> VHT_CAP_SOUNDING_DIMENSIONS_SHIFT)
900 #define VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK_SHIFT 23
901 #define VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK \
902 (0x03800000 >> VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK_SHIFT)
903 #define VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB_SHIFT 26
904
hdd_copy_vht_caps(struct ieee80211_vht_cap * hdd_vht_cap,tDot11fIEVHTCaps * roam_vht_cap)905 void hdd_copy_vht_caps(struct ieee80211_vht_cap *hdd_vht_cap,
906 tDot11fIEVHTCaps *roam_vht_cap)
907 {
908 uint32_t temp_vht_cap;
909
910 qdf_mem_zero(hdd_vht_cap, sizeof(struct ieee80211_vht_cap));
911
912 temp_vht_cap = roam_vht_cap->maxMPDULen & VHT_CAP_MAX_MPDU_LENGTH_MASK;
913 hdd_vht_cap->vht_cap_info |= temp_vht_cap;
914 temp_vht_cap = roam_vht_cap->supportedChannelWidthSet &
915 (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK >>
916 VHT_CAP_SUPP_CHAN_WIDTH_MASK_SHIFT);
917 if (temp_vht_cap) {
918 if (roam_vht_cap->supportedChannelWidthSet &
919 (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ >>
920 VHT_CAP_SUPP_CHAN_WIDTH_MASK_SHIFT))
921 hdd_vht_cap->vht_cap_info |=
922 temp_vht_cap <<
923 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
924 if (roam_vht_cap->supportedChannelWidthSet &
925 (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ >>
926 VHT_CAP_SUPP_CHAN_WIDTH_MASK_SHIFT))
927 hdd_vht_cap->vht_cap_info |=
928 temp_vht_cap <<
929 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
930 }
931 if (roam_vht_cap->ldpcCodingCap)
932 hdd_vht_cap->vht_cap_info |= IEEE80211_VHT_CAP_RXLDPC;
933 if (roam_vht_cap->shortGI80MHz)
934 hdd_vht_cap->vht_cap_info |= IEEE80211_VHT_CAP_SHORT_GI_80;
935 if (roam_vht_cap->shortGI160and80plus80MHz)
936 hdd_vht_cap->vht_cap_info |= IEEE80211_VHT_CAP_SHORT_GI_160;
937 if (roam_vht_cap->txSTBC)
938 hdd_vht_cap->vht_cap_info |= IEEE80211_VHT_CAP_TXSTBC;
939 temp_vht_cap = roam_vht_cap->rxSTBC & (IEEE80211_VHT_CAP_RXSTBC_MASK >>
940 VHT_CAP_RXSTBC_MASK_SHIFT);
941 if (temp_vht_cap)
942 hdd_vht_cap->vht_cap_info |=
943 temp_vht_cap << VHT_CAP_RXSTBC_MASK_SHIFT;
944 if (roam_vht_cap->suBeamFormerCap)
945 hdd_vht_cap->vht_cap_info |=
946 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
947 if (roam_vht_cap->suBeamformeeCap)
948 hdd_vht_cap->vht_cap_info |=
949 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
950 temp_vht_cap = roam_vht_cap->csnofBeamformerAntSup &
951 (VHT_CAP_BEAMFORMEE_STS_MASK);
952 if (temp_vht_cap)
953 hdd_vht_cap->vht_cap_info |=
954 temp_vht_cap << VHT_CAP_BEAMFORMEE_STS_SHIFT;
955 temp_vht_cap = roam_vht_cap->numSoundingDim &
956 (VHT_CAP_SOUNDING_DIMENSIONS_MASK);
957 if (temp_vht_cap)
958 hdd_vht_cap->vht_cap_info |=
959 temp_vht_cap << VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
960 if (roam_vht_cap->muBeamformerCap)
961 hdd_vht_cap->vht_cap_info |=
962 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
963 if (roam_vht_cap->muBeamformeeCap)
964 hdd_vht_cap->vht_cap_info |=
965 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
966 if (roam_vht_cap->vhtTXOPPS)
967 hdd_vht_cap->vht_cap_info |=
968 IEEE80211_VHT_CAP_VHT_TXOP_PS;
969 if (roam_vht_cap->htcVHTCap)
970 hdd_vht_cap->vht_cap_info |=
971 IEEE80211_VHT_CAP_HTC_VHT;
972 temp_vht_cap = roam_vht_cap->maxAMPDULenExp &
973 (VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK);
974 if (temp_vht_cap)
975 hdd_vht_cap->vht_cap_info |=
976 temp_vht_cap <<
977 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK_SHIFT;
978 temp_vht_cap = roam_vht_cap->vhtLinkAdaptCap &
979 (IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB >>
980 VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB_SHIFT);
981 if (temp_vht_cap)
982 hdd_vht_cap->vht_cap_info |= temp_vht_cap <<
983 VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB_SHIFT;
984 if (roam_vht_cap->rxAntPattern)
985 hdd_vht_cap->vht_cap_info |=
986 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
987 if (roam_vht_cap->txAntPattern)
988 hdd_vht_cap->vht_cap_info |=
989 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
990 hdd_vht_cap->supp_mcs.rx_mcs_map = roam_vht_cap->rxMCSMap;
991 hdd_vht_cap->supp_mcs.rx_highest =
992 ((uint16_t)roam_vht_cap->rxHighSupDataRate);
993 hdd_vht_cap->supp_mcs.tx_mcs_map = roam_vht_cap->txMCSMap;
994 hdd_vht_cap->supp_mcs.tx_highest =
995 ((uint16_t)roam_vht_cap->txSupDataRate);
996 }
997
998 /* ht param */
999 #define HT_PARAM_CONTROLLED_ACCESS_ONLY 0x10
1000 #define HT_PARAM_SERVICE_INT_GRAN 0xe0
1001 #define HT_PARAM_SERVICE_INT_GRAN_SHIFT 5
1002
1003 /* operatinon mode */
1004 #define HT_OP_MODE_TX_BURST_LIMIT 0x0008
1005
1006 /* stbc_param */
1007 #define HT_STBC_PARAM_MCS 0x007f
1008
hdd_copy_ht_operation(struct hdd_station_ctx * hdd_sta_ctx,tDot11fIEHTInfo * ht_ops)1009 void hdd_copy_ht_operation(struct hdd_station_ctx *hdd_sta_ctx,
1010 tDot11fIEHTInfo *ht_ops)
1011 {
1012 struct ieee80211_ht_operation *hdd_ht_ops =
1013 &hdd_sta_ctx->conn_info.ht_operation;
1014 uint32_t i, temp_ht_ops;
1015
1016 qdf_mem_zero(hdd_ht_ops, sizeof(struct ieee80211_ht_operation));
1017
1018 hdd_ht_ops->primary_chan = ht_ops->primaryChannel;
1019
1020 /* HT_PARAMS */
1021 temp_ht_ops = ht_ops->secondaryChannelOffset &
1022 IEEE80211_HT_PARAM_CHA_SEC_OFFSET;
1023 if (temp_ht_ops)
1024 hdd_ht_ops->ht_param |= temp_ht_ops;
1025 else
1026 hdd_ht_ops->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
1027 if (ht_ops->recommendedTxWidthSet)
1028 hdd_ht_ops->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
1029 if (ht_ops->rifsMode)
1030 hdd_ht_ops->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
1031 if (ht_ops->controlledAccessOnly)
1032 hdd_ht_ops->ht_param |= HT_PARAM_CONTROLLED_ACCESS_ONLY;
1033 temp_ht_ops = ht_ops->serviceIntervalGranularity &
1034 (HT_PARAM_SERVICE_INT_GRAN >> HT_PARAM_SERVICE_INT_GRAN_SHIFT);
1035 if (temp_ht_ops)
1036 hdd_ht_ops->ht_param |= temp_ht_ops <<
1037 HT_PARAM_SERVICE_INT_GRAN_SHIFT;
1038
1039 /* operation mode */
1040 temp_ht_ops = ht_ops->opMode &
1041 IEEE80211_HT_OP_MODE_PROTECTION;
1042 switch (temp_ht_ops) {
1043 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER:
1044 hdd_ht_ops->operation_mode |=
1045 IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER;
1046 break;
1047 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
1048 hdd_ht_ops->operation_mode |=
1049 IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
1050 break;
1051 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
1052 hdd_ht_ops->operation_mode |=
1053 IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
1054 break;
1055 case IEEE80211_HT_OP_MODE_PROTECTION_NONE:
1056 default:
1057 hdd_ht_ops->operation_mode |=
1058 IEEE80211_HT_OP_MODE_PROTECTION_NONE;
1059 }
1060 if (ht_ops->nonGFDevicesPresent)
1061 hdd_ht_ops->operation_mode |=
1062 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1063 if (ht_ops->transmitBurstLimit)
1064 hdd_ht_ops->operation_mode |=
1065 HT_OP_MODE_TX_BURST_LIMIT;
1066 if (ht_ops->obssNonHTStaPresent)
1067 hdd_ht_ops->operation_mode |=
1068 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1069
1070 if (ht_ops->chan_center_freq_seg2)
1071 hdd_ht_ops->operation_mode |=
1072 (ht_ops->chan_center_freq_seg2 << IEEE80211_HT_OP_MODE_CCFS2_SHIFT);
1073 /* stbc_param */
1074 temp_ht_ops = ht_ops->basicSTBCMCS &
1075 HT_STBC_PARAM_MCS;
1076 if (temp_ht_ops)
1077 hdd_ht_ops->stbc_param |= temp_ht_ops;
1078 if (ht_ops->dualCTSProtection)
1079 hdd_ht_ops->stbc_param |=
1080 IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT;
1081 if (ht_ops->secondaryBeacon)
1082 hdd_ht_ops->stbc_param |=
1083 IEEE80211_HT_STBC_PARAM_STBC_BEACON;
1084 if (ht_ops->lsigTXOPProtectionFullSupport)
1085 hdd_ht_ops->stbc_param |=
1086 IEEE80211_HT_STBC_PARAM_LSIG_TXOP_FULLPROT;
1087 if (ht_ops->pcoActive)
1088 hdd_ht_ops->stbc_param |=
1089 IEEE80211_HT_STBC_PARAM_PCO_ACTIVE;
1090 if (ht_ops->pcoPhase)
1091 hdd_ht_ops->stbc_param |=
1092 IEEE80211_HT_STBC_PARAM_PCO_PHASE;
1093
1094 /* basic MCs set */
1095 for (i = 0; i < 16; ++i)
1096 hdd_ht_ops->basic_set[i] =
1097 ht_ops->basicMCSSet[i];
1098 }
1099
1100 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
hdd_copy_vht_center_freq(struct ieee80211_vht_operation * ieee_ops,tDot11fIEVHTOperation * roam_ops)1101 static void hdd_copy_vht_center_freq(struct ieee80211_vht_operation *ieee_ops,
1102 tDot11fIEVHTOperation *roam_ops)
1103 {
1104 ieee_ops->center_freq_seg0_idx = roam_ops->chan_center_freq_seg0;
1105 ieee_ops->center_freq_seg1_idx = roam_ops->chan_center_freq_seg1;
1106 }
1107 #else
hdd_copy_vht_center_freq(struct ieee80211_vht_operation * ieee_ops,tDot11fIEVHTOperation * roam_ops)1108 static void hdd_copy_vht_center_freq(struct ieee80211_vht_operation *ieee_ops,
1109 tDot11fIEVHTOperation *roam_ops)
1110 {
1111 ieee_ops->center_freq_seg1_idx = roam_ops->chan_center_freq_seg0;
1112 ieee_ops->center_freq_seg2_idx = roam_ops->chan_center_freq_seg1;
1113 }
1114 #endif /* KERNEL_VERSION(4, 12, 0) */
1115
hdd_copy_vht_operation(struct hdd_station_ctx * hdd_sta_ctx,tDot11fIEVHTOperation * vht_ops)1116 void hdd_copy_vht_operation(struct hdd_station_ctx *hdd_sta_ctx,
1117 tDot11fIEVHTOperation *vht_ops)
1118 {
1119 struct ieee80211_vht_operation *hdd_vht_ops =
1120 &hdd_sta_ctx->conn_info.vht_operation;
1121
1122 qdf_mem_zero(hdd_vht_ops, sizeof(struct ieee80211_vht_operation));
1123
1124 hdd_vht_ops->chan_width = vht_ops->chanWidth;
1125 hdd_copy_vht_center_freq(hdd_vht_ops, vht_ops);
1126 hdd_vht_ops->basic_mcs_set = vht_ops->basicMCSSet;
1127 }
1128
1129 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 5, 0)) && \
1130 defined(WLAN_FEATURE_11BE)
hdd_copy_eht_operation(struct hdd_station_ctx * hdd_sta_ctx,tDot11fIEeht_op * eht_ops)1131 void hdd_copy_eht_operation(struct hdd_station_ctx *hdd_sta_ctx,
1132 tDot11fIEeht_op *eht_ops)
1133 {
1134 struct ieee80211_eht_operation *hdd_eht_ops =
1135 &hdd_sta_ctx->conn_info.eht_operation;
1136 struct ieee80211_eht_mcs_nss_supp_20mhz_only mcs_param;
1137 uint32_t filled = 0, len = 0;
1138
1139 qdf_mem_zero(hdd_eht_ops, sizeof(struct ieee80211_eht_operation));
1140
1141 if (!eht_ops->eht_op_information_present)
1142 return;
1143
1144 /* Min length if op_info_present */
1145 len += 3;
1146
1147 hdd_eht_ops->params |= IEEE80211_EHT_OPER_INFO_PRESENT;
1148
1149 if (eht_ops->eht_default_pe_duration)
1150 hdd_eht_ops->params |=
1151 IEEE80211_EHT_OPER_EHT_DEF_PE_DURATION;
1152 if (eht_ops->group_addr_bu_indication_limit)
1153 hdd_eht_ops->params |=
1154 IEEE80211_EHT_OPER_GROUP_ADDRESSED_BU_IND_LIMIT;
1155 if (eht_ops->group_addr_bu_indication_exponent)
1156 hdd_eht_ops->params |=
1157 IEEE80211_EHT_OPER_GROUP_ADDRESSED_BU_IND_EXP_MASK;
1158
1159 mcs_param.rx_tx_mcs7_max_nss =
1160 eht_ops->basic_rx_max_nss_for_mcs_0_to_7 <<
1161 EHT_OPER_BASIC_RX_NSS_MCS_0_TO_7_POS;
1162 mcs_param.rx_tx_mcs7_max_nss |=
1163 eht_ops->basic_tx_max_nss_for_mcs_0_to_7 <<
1164 EHT_OPER_BASIC_TX_NSS_MCS_0_TO_7_POS;
1165 mcs_param.rx_tx_mcs9_max_nss =
1166 eht_ops->basic_rx_max_nss_for_mcs_8_and_9 <<
1167 EHT_OPER_BASIC_RX_NSS_MCS_8_AND_9_POS;
1168 mcs_param.rx_tx_mcs9_max_nss |=
1169 eht_ops->basic_tx_max_nss_for_mcs_8_and_9 <<
1170 EHT_OPER_BASIC_TX_NSS_MCS_8_AND_9_POS;
1171 mcs_param.rx_tx_mcs11_max_nss =
1172 eht_ops->basic_rx_max_nss_for_mcs_10_and_11 <<
1173 EHT_OPER_BASIC_RX_NSS_MCS_10_AND_11_POS;
1174 mcs_param.rx_tx_mcs11_max_nss |=
1175 eht_ops->basic_tx_max_nss_for_mcs_10_and_11 <<
1176 EHT_OPER_BASIC_TX_NSS_MCS_10_AND_11_POS;
1177 mcs_param.rx_tx_mcs13_max_nss =
1178 eht_ops->basic_rx_max_nss_for_mcs_12_and_13 <<
1179 EHT_OPER_BASIC_RX_NSS_MCS_12_AND_13_POS;
1180 mcs_param.rx_tx_mcs13_max_nss |=
1181 eht_ops->basic_tx_max_nss_for_mcs_12_and_13 <<
1182 EHT_OPER_BASIC_TX_NSS_MCS_12_AND_13_POS;
1183
1184 hdd_eht_ops->basic_mcs_nss = mcs_param;
1185 hdd_eht_ops->optional[filled++] = eht_ops->channel_width;
1186 hdd_eht_ops->optional[filled++] = eht_ops->ccfs0;
1187 hdd_eht_ops->optional[filled++] = eht_ops->ccfs1;
1188
1189 if (eht_ops->disabled_sub_chan_bitmap_present) {
1190 hdd_eht_ops->params |=
1191 IEEE80211_EHT_OPER_DISABLED_SUBCHANNEL_BITMAP_PRESENT;
1192 len += 2;
1193 hdd_eht_ops->optional[filled++] =
1194 eht_ops->disabled_sub_chan_bitmap[0][0];
1195 hdd_eht_ops->optional[filled++] =
1196 eht_ops->disabled_sub_chan_bitmap[0][1];
1197 }
1198 hdd_sta_ctx->conn_info.eht_oper_len =
1199 sizeof(struct ieee80211_eht_operation) + len;
1200 }
1201 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)) && \
1202 defined(WLAN_FEATURE_11BE)
hdd_copy_eht_operation(struct hdd_station_ctx * hdd_sta_ctx,tDot11fIEeht_op * eht_ops)1203 void hdd_copy_eht_operation(struct hdd_station_ctx *hdd_sta_ctx,
1204 tDot11fIEeht_op *eht_ops)
1205 {
1206 struct ieee80211_eht_operation *hdd_eht_ops =
1207 &hdd_sta_ctx->conn_info.eht_operation;
1208 uint32_t mcs_param = 0, filled = 0, len = 0;
1209
1210 qdf_mem_zero(hdd_eht_ops, sizeof(struct ieee80211_eht_operation));
1211
1212 if (!eht_ops->eht_op_information_present)
1213 return;
1214
1215 /* Min length if op_info_present */
1216 len += 3;
1217
1218 hdd_eht_ops->params |= IEEE80211_EHT_OPER_INFO_PRESENT;
1219
1220 if (eht_ops->eht_default_pe_duration)
1221 hdd_eht_ops->params |=
1222 IEEE80211_EHT_OPER_EHT_DEF_PE_DURATION;
1223 if (eht_ops->group_addr_bu_indication_limit)
1224 hdd_eht_ops->params |=
1225 IEEE80211_EHT_OPER_GROUP_ADDRESSED_BU_IND_LIMIT;
1226 if (eht_ops->group_addr_bu_indication_exponent)
1227 hdd_eht_ops->params |=
1228 IEEE80211_EHT_OPER_GROUP_ADDRESSED_BU_IND_EXP_MASK;
1229
1230 mcs_param |= eht_ops->basic_rx_max_nss_for_mcs_0_to_7 <<
1231 EHT_OPER_BASIC_RX_NSS_MCS_0_TO_7_POS;
1232 mcs_param |= eht_ops->basic_tx_max_nss_for_mcs_0_to_7 <<
1233 EHT_OPER_BASIC_TX_NSS_MCS_0_TO_7_POS;
1234 mcs_param |= eht_ops->basic_rx_max_nss_for_mcs_8_and_9 <<
1235 EHT_OPER_BASIC_RX_NSS_MCS_8_AND_9_POS;
1236 mcs_param |= eht_ops->basic_tx_max_nss_for_mcs_8_and_9 <<
1237 EHT_OPER_BASIC_TX_NSS_MCS_8_AND_9_POS;
1238 mcs_param |= eht_ops->basic_rx_max_nss_for_mcs_10_and_11 <<
1239 EHT_OPER_BASIC_RX_NSS_MCS_10_AND_11_POS;
1240 mcs_param |= eht_ops->basic_tx_max_nss_for_mcs_10_and_11 <<
1241 EHT_OPER_BASIC_TX_NSS_MCS_10_AND_11_POS;
1242 mcs_param |= eht_ops->basic_rx_max_nss_for_mcs_12_and_13 <<
1243 EHT_OPER_BASIC_RX_NSS_MCS_12_AND_13_POS;
1244 mcs_param |= eht_ops->basic_tx_max_nss_for_mcs_12_and_13 <<
1245 EHT_OPER_BASIC_TX_NSS_MCS_12_AND_13_POS;
1246
1247 hdd_eht_ops->basic_mcs_nss = mcs_param;
1248 hdd_eht_ops->optional[filled++] = eht_ops->channel_width;
1249 hdd_eht_ops->optional[filled++] = eht_ops->ccfs0;
1250 hdd_eht_ops->optional[filled++] = eht_ops->ccfs1;
1251
1252 if (eht_ops->disabled_sub_chan_bitmap_present) {
1253 hdd_eht_ops->params |=
1254 IEEE80211_EHT_OPER_DISABLED_SUBCHANNEL_BITMAP_PRESENT;
1255 len += 2;
1256 hdd_eht_ops->optional[filled++] =
1257 eht_ops->disabled_sub_chan_bitmap[0][0];
1258 hdd_eht_ops->optional[filled++] =
1259 eht_ops->disabled_sub_chan_bitmap[0][1];
1260 }
1261 hdd_sta_ctx->conn_info.eht_oper_len =
1262 sizeof(struct ieee80211_eht_operation) + len;
1263 }
1264 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0)) && \
1265 defined(WLAN_FEATURE_11BE)
hdd_copy_eht_operation(struct hdd_station_ctx * hdd_sta_ctx,tDot11fIEeht_op * eht_ops)1266 void hdd_copy_eht_operation(struct hdd_station_ctx *hdd_sta_ctx,
1267 tDot11fIEeht_op *eht_ops)
1268 {
1269 struct ieee80211_eht_operation *hdd_eht_ops =
1270 &hdd_sta_ctx->conn_info.eht_operation;
1271 uint32_t filled = 0, len = 0;
1272
1273 qdf_mem_zero(hdd_eht_ops, sizeof(struct ieee80211_eht_operation));
1274
1275 if (!eht_ops->eht_op_information_present)
1276 return;
1277
1278 hdd_eht_ops->chan_width = eht_ops->channel_width;
1279 hdd_eht_ops->ccfs = eht_ops->ccfs0;
1280 hdd_eht_ops->present_bm = eht_ops->disabled_sub_chan_bitmap_present;
1281
1282 if (eht_ops->disabled_sub_chan_bitmap_present) {
1283 hdd_eht_ops->disable_subchannel_bitmap[filled++] =
1284 eht_ops->disabled_sub_chan_bitmap[0][0];
1285 hdd_eht_ops->disable_subchannel_bitmap[filled++] =
1286 eht_ops->disabled_sub_chan_bitmap[0][1];
1287 len += 2;
1288 }
1289 hdd_sta_ctx->conn_info.eht_oper_len =
1290 sizeof(struct ieee80211_eht_operation) + len;
1291 }
1292 #endif
1293
1294 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0)) && \
1295 defined(WLAN_FEATURE_11AX)
hdd_copy_he_operation(struct hdd_station_ctx * hdd_sta_ctx,tDot11fIEhe_op * he_operation)1296 void hdd_copy_he_operation(struct hdd_station_ctx *hdd_sta_ctx,
1297 tDot11fIEhe_op *he_operation)
1298 {
1299 struct ieee80211_he_operation *hdd_he_operation;
1300 uint32_t he_oper_params = 0;
1301 uint32_t len = 0, filled = 0;
1302 uint8_t he_oper_6g_params = 0;
1303 uint32_t he_oper_len;
1304
1305 if (!he_operation->present)
1306 return;
1307 if (he_operation->vht_oper_present)
1308 len += 3;
1309 if (he_operation->co_located_bss)
1310 len += 1;
1311 if (he_operation->oper_info_6g_present)
1312 len += 5;
1313
1314 he_oper_len = sizeof(struct ieee80211_he_operation) + len;
1315
1316 hdd_he_operation = qdf_mem_malloc(he_oper_len);
1317 if (!hdd_he_operation)
1318 return;
1319
1320 /* Fill he_oper_params */
1321 he_oper_params |= he_operation->default_pe <<
1322 HE_OPERATION_DFLT_PE_DURATION_POS;
1323 he_oper_params |= he_operation->twt_required <<
1324 HE_OPERATION_TWT_REQUIRED_POS;
1325 he_oper_params |= he_operation->txop_rts_threshold <<
1326 HE_OPERATION_RTS_THRESHOLD_POS;
1327 he_oper_params |= he_operation->vht_oper_present <<
1328 HE_OPERATION_VHT_OPER_POS;
1329 he_oper_params |= he_operation->co_located_bss <<
1330 HE_OPERATION_CO_LOCATED_BSS_POS;
1331 he_oper_params |= he_operation->er_su_disable <<
1332 HE_OPERATION_ER_SU_DISABLE_POS;
1333 he_oper_params |= he_operation->oper_info_6g_present <<
1334 HE_OPERATION_OPER_INFO_6G_POS;
1335 he_oper_params |= he_operation->reserved2 <<
1336 HE_OPERATION_RESERVED_POS;
1337 he_oper_params |= he_operation->bss_color <<
1338 HE_OPERATION_BSS_COLOR_POS;
1339 he_oper_params |= he_operation->partial_bss_col <<
1340 HE_OPERATION_PARTIAL_BSS_COLOR_POS;
1341 he_oper_params |= he_operation->bss_col_disabled <<
1342 HE_OPERATION_BSS_COL_DISABLED_POS;
1343
1344 hdd_he_operation->he_oper_params = he_oper_params;
1345
1346 /* Fill he_mcs_nss set */
1347 qdf_mem_copy(&hdd_he_operation->he_mcs_nss_set,
1348 he_operation->basic_mcs_nss,
1349 sizeof(hdd_he_operation->he_mcs_nss_set));
1350
1351 /* Fill he_params_optional fields */
1352
1353 if (he_operation->vht_oper_present) {
1354 hdd_he_operation->optional[filled++] =
1355 he_operation->vht_oper.info.chan_width;
1356 hdd_he_operation->optional[filled++] =
1357 he_operation->vht_oper.info.center_freq_seg0;
1358 hdd_he_operation->optional[filled++] =
1359 he_operation->vht_oper.info.center_freq_seg1;
1360 }
1361 if (he_operation->co_located_bss)
1362 hdd_he_operation->optional[filled++] =
1363 he_operation->maxbssid_ind.info.data;
1364
1365 if (he_operation->oper_info_6g_present) {
1366 hdd_he_operation->optional[filled++] =
1367 he_operation->oper_info_6g.info.primary_ch;
1368 he_oper_6g_params |=
1369 he_operation->oper_info_6g.info.ch_width << 0;
1370 he_oper_6g_params |=
1371 he_operation->oper_info_6g.info.dup_bcon << 2;
1372 he_oper_6g_params |=
1373 he_operation->oper_info_6g.info.reserved << 3;
1374
1375 hdd_he_operation->optional[filled++] = he_oper_6g_params;
1376 hdd_he_operation->optional[filled++] =
1377 he_operation->oper_info_6g.info.center_freq_seg0;
1378 hdd_he_operation->optional[filled++] =
1379 he_operation->oper_info_6g.info.center_freq_seg1;
1380 hdd_he_operation->optional[filled] =
1381 he_operation->oper_info_6g.info.min_rate;
1382 }
1383
1384 if (hdd_sta_ctx->cache_conn_info.he_operation) {
1385 qdf_mem_free(hdd_sta_ctx->cache_conn_info.he_operation);
1386 hdd_sta_ctx->cache_conn_info.he_operation = NULL;
1387 }
1388
1389 hdd_sta_ctx->cache_conn_info.he_oper_len = he_oper_len;
1390
1391 hdd_sta_ctx->cache_conn_info.he_operation = hdd_he_operation;
1392 }
1393 #endif
1394
hdd_is_roam_sync_in_progress(struct hdd_context * hdd_ctx,uint8_t vdev_id)1395 bool hdd_is_roam_sync_in_progress(struct hdd_context *hdd_ctx, uint8_t vdev_id)
1396 {
1397 return wlan_cm_is_roam_sync_in_progress(hdd_ctx->psoc, vdev_id);
1398 }
1399
hdd_conn_remove_connect_info(struct hdd_station_ctx * sta_ctx)1400 void hdd_conn_remove_connect_info(struct hdd_station_ctx *sta_ctx)
1401 {
1402 /* Remove bssid and peer_macaddr */
1403 qdf_mem_zero(&sta_ctx->conn_info.bssid, QDF_MAC_ADDR_SIZE);
1404 qdf_mem_zero(&sta_ctx->conn_info.peer_macaddr[0],
1405 QDF_MAC_ADDR_SIZE);
1406
1407 /* Clear all security settings */
1408 sta_ctx->conn_info.auth_type = eCSR_AUTH_TYPE_OPEN_SYSTEM;
1409 sta_ctx->conn_info.uc_encrypt_type = eCSR_ENCRYPT_TYPE_NONE;
1410
1411 sta_ctx->conn_info.proxy_arp_service = 0;
1412
1413 qdf_mem_zero(&sta_ctx->conn_info.ssid, sizeof(tCsrSSIDInfo));
1414
1415 /*
1416 * Reset the ptk, gtk status flags to avoid using current connection
1417 * status in further connections.
1418 */
1419 sta_ctx->conn_info.gtk_installed = false;
1420 sta_ctx->conn_info.ptk_installed = false;
1421 }
1422
hdd_clear_roam_profile_ie(struct hdd_adapter * adapter)1423 void hdd_clear_roam_profile_ie(struct hdd_adapter *adapter)
1424 {
1425 hdd_enter();
1426
1427 #ifdef FEATURE_WLAN_WAPI
1428 adapter->wapi_info.wapi_auth_mode = WAPI_AUTH_MODE_OPEN;
1429 adapter->wapi_info.wapi_mode = false;
1430 #endif
1431
1432 hdd_exit();
1433 }
1434
1435 #if defined(QCA_LL_LEGACY_TX_FLOW_CONTROL) || defined(QCA_LL_TX_FLOW_CONTROL_V2)
hdd_set_unpause_queue(void * soc,uint8_t vdev_id)1436 static inline void hdd_set_unpause_queue(void *soc, uint8_t vdev_id)
1437 {
1438 cdp_fc_vdev_unpause(soc, vdev_id,
1439 OL_TXQ_PAUSE_REASON_PEER_UNAUTHORIZED, 0);
1440 }
1441 #else
hdd_set_unpause_queue(void * soc,uint8_t vdev_id)1442 static inline void hdd_set_unpause_queue(void *soc, uint8_t vdev_id)
1443 {
1444 }
1445 #endif
1446
1447 #ifdef FEATURE_WDS
1448 /**
1449 * hdd_config_wds_repeater_mode() - configures vdev for wds repeater mode
1450 * @link_info: Link info pointer in HDD adapter
1451 * @peer_addr: peer mac address
1452 *
1453 * Configure dp vdev to detect and drop multicast echo packets and enable
1454 * 4 address frame format in fw.
1455 *
1456 * Return: None
1457 */
hdd_config_wds_repeater_mode(struct wlan_hdd_link_info * link_info,uint8_t * peer_addr)1458 static void hdd_config_wds_repeater_mode(struct wlan_hdd_link_info *link_info,
1459 uint8_t *peer_addr)
1460 {
1461 cdp_config_param_type vdev_param;
1462 ol_txrx_soc_handle soc = cds_get_context(QDF_MODULE_ID_SOC);
1463
1464 vdev_param.cdp_vdev_param_mec = true;
1465 if (cdp_txrx_set_vdev_param(soc, link_info->vdev_id,
1466 CDP_ENABLE_MEC, vdev_param))
1467 hdd_debug("Failed to set MEC param on DP vdev");
1468
1469 hdd_nofl_info("Turn on 4 address for peer: " QDF_MAC_ADDR_FMT,
1470 QDF_MAC_ADDR_REF(peer_addr));
1471 if (sme_set_peer_param(peer_addr, WMI_HOST_PEER_USE_4ADDR, true,
1472 link_info->vdev_id))
1473 hdd_err("Failed to enable WDS on vdev");
1474 }
1475 #else
1476 static inline void
hdd_config_wds_repeater_mode(struct wlan_hdd_link_info * link_info,uint8_t * peer_addr)1477 hdd_config_wds_repeater_mode(struct wlan_hdd_link_info *link_info,
1478 uint8_t *peer_addr)
1479 {
1480 }
1481 #endif
1482
hdd_change_peer_state(struct wlan_hdd_link_info * link_info,uint8_t * peer_mac,enum ol_txrx_peer_state sta_state)1483 QDF_STATUS hdd_change_peer_state(struct wlan_hdd_link_info *link_info,
1484 uint8_t *peer_mac,
1485 enum ol_txrx_peer_state sta_state)
1486 {
1487 QDF_STATUS err;
1488 struct hdd_adapter *adapter = link_info->adapter;
1489 struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
1490 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
1491
1492 err = cdp_peer_state_update(soc, peer_mac, sta_state);
1493 if (err != QDF_STATUS_SUCCESS) {
1494 hdd_err("peer state update failed");
1495 return QDF_STATUS_E_FAULT;
1496 }
1497
1498 if (hdd_is_roam_sync_in_progress(hdd_ctx, link_info->vdev_id)) {
1499 if (adapter->device_mode == QDF_STA_MODE &&
1500 (wlan_mlme_get_wds_mode(hdd_ctx->psoc) ==
1501 WLAN_WDS_MODE_REPEATER))
1502 hdd_config_wds_repeater_mode(link_info, peer_mac);
1503
1504 hdd_son_deliver_peer_authorize_event(link_info, peer_mac);
1505 return QDF_STATUS_SUCCESS;
1506 }
1507
1508 if (sta_state == OL_TXRX_PEER_STATE_AUTH) {
1509 /* Reset scan reject params on successful set key */
1510 hdd_debug("Reset scan reject params");
1511 hdd_init_scan_reject_params(hdd_ctx);
1512
1513 err = sme_set_peer_authorized(peer_mac, link_info->vdev_id);
1514 if (err != QDF_STATUS_SUCCESS) {
1515 hdd_err("Failed to set the peer state to authorized");
1516 return QDF_STATUS_E_FAULT;
1517 }
1518
1519 if (adapter->device_mode == QDF_STA_MODE ||
1520 adapter->device_mode == QDF_P2P_CLIENT_MODE) {
1521 hdd_set_unpause_queue(soc, link_info->vdev_id);
1522 }
1523
1524 if (adapter->device_mode == QDF_STA_MODE &&
1525 (wlan_mlme_get_wds_mode(hdd_ctx->psoc) ==
1526 WLAN_WDS_MODE_REPEATER))
1527 hdd_config_wds_repeater_mode(link_info, peer_mac);
1528
1529 hdd_son_deliver_peer_authorize_event(link_info, peer_mac);
1530 }
1531 return QDF_STATUS_SUCCESS;
1532 }
1533
hdd_update_dp_vdev_flags(void * cbk_data,uint8_t vdev_id,uint32_t vdev_param,bool is_link_up)1534 QDF_STATUS hdd_update_dp_vdev_flags(void *cbk_data,
1535 uint8_t vdev_id,
1536 uint32_t vdev_param,
1537 bool is_link_up)
1538 {
1539 QDF_STATUS status = QDF_STATUS_SUCCESS;
1540 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
1541 struct hdd_context *hdd_ctx;
1542 struct wlan_objmgr_psoc **psoc;
1543 cdp_config_param_type val;
1544
1545 if (!cbk_data)
1546 return status;
1547
1548 psoc = cbk_data;
1549
1550 hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
1551 if (!hdd_ctx)
1552 return QDF_STATUS_E_INVAL;
1553
1554 if (!hdd_ctx->tdls_nap_active)
1555 return status;
1556
1557 if (vdev_id == WLAN_INVALID_VDEV_ID) {
1558 status = QDF_STATUS_E_FAILURE;
1559 return status;
1560 }
1561
1562 val.cdp_vdev_param_tdls_flags = is_link_up;
1563 cdp_txrx_set_vdev_param(soc, vdev_id, vdev_param, val);
1564
1565 return status;
1566 }
1567
hdd_roam_register_sta(struct wlan_hdd_link_info * link_info,struct qdf_mac_addr * bssid,bool is_auth_required)1568 QDF_STATUS hdd_roam_register_sta(struct wlan_hdd_link_info *link_info,
1569 struct qdf_mac_addr *bssid,
1570 bool is_auth_required)
1571 {
1572 QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
1573 struct ol_txrx_desc_type txrx_desc = {0};
1574 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
1575 enum phy_ch_width ch_width;
1576 enum wlan_phymode phymode;
1577 struct wlan_objmgr_vdev *vdev;
1578 struct hdd_adapter *adapter = link_info->adapter;
1579
1580 /* Get the Station ID from the one saved during the association */
1581 if (!QDF_IS_ADDR_BROADCAST(bssid->bytes))
1582 WLAN_ADDR_COPY(txrx_desc.peer_addr.bytes,
1583 bssid->bytes);
1584 else
1585 WLAN_ADDR_COPY(txrx_desc.peer_addr.bytes,
1586 adapter->mac_addr.bytes);
1587
1588 /* set the QoS field appropriately */
1589 if (hdd_wmm_is_active(adapter))
1590 txrx_desc.is_qos_enabled = 1;
1591 else
1592 txrx_desc.is_qos_enabled = 0;
1593
1594 #ifdef FEATURE_WLAN_WAPI
1595 hdd_debug("WAPI STA Registered: %d",
1596 adapter->wapi_info.is_wapi_sta);
1597 if (adapter->wapi_info.is_wapi_sta)
1598 txrx_desc.is_wapi_supported = 1;
1599 else
1600 txrx_desc.is_wapi_supported = 0;
1601 #endif /* FEATURE_WLAN_WAPI */
1602
1603 vdev = hdd_objmgr_get_vdev_by_user(link_info, WLAN_DP_ID);
1604 if (!vdev)
1605 return QDF_STATUS_E_INVAL;
1606
1607 qdf_status = ucfg_dp_sta_register_txrx_ops(vdev);
1608 hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
1609 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
1610 hdd_err("DP tx/rx ops register failed Status: %d", qdf_status);
1611 return qdf_status;
1612 }
1613
1614 if (adapter->device_mode == QDF_NDI_MODE) {
1615 phymode = ucfg_mlme_get_vdev_phy_mode(
1616 adapter->hdd_ctx->psoc,
1617 link_info->vdev_id);
1618 ch_width = ucfg_mlme_get_ch_width_from_phymode(phymode);
1619 } else {
1620 ch_width = ucfg_mlme_get_peer_ch_width(adapter->hdd_ctx->psoc,
1621 txrx_desc.peer_addr.bytes);
1622 }
1623 txrx_desc.bw = hdd_convert_ch_width_to_cdp_peer_bw(ch_width);
1624 qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &txrx_desc);
1625 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
1626 hdd_err("cdp_peer_register() failed Status: %d [0x%08X]",
1627 qdf_status, qdf_status);
1628 return qdf_status;
1629 }
1630
1631 hdd_cm_set_peer_authenticate(link_info, &txrx_desc.peer_addr,
1632 is_auth_required);
1633
1634 return qdf_status;
1635 }
1636
1637 /**
1638 * hdd_change_sta_state_authenticated()-
1639 * This function changes STA state to authenticated
1640 * @link_info: Link info pointer in HDD adapter
1641 * @roaminfo: pointer to the RoamInfo structure.
1642 *
1643 * This is called from hdd_RoamSetKeyCompleteHandler
1644 * in context to eCSR_ROAM_SET_KEY_COMPLETE event from fw.
1645 *
1646 * Return: 0 on success and errno on failure
1647 */
1648 static int
hdd_change_sta_state_authenticated(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roaminfo)1649 hdd_change_sta_state_authenticated(struct wlan_hdd_link_info *link_info,
1650 struct csr_roam_info *roaminfo)
1651 {
1652 uint8_t *mac_addr;
1653 struct hdd_station_ctx *sta_ctx;
1654 struct hdd_adapter *adapter = link_info->adapter;
1655 struct hdd_context *hdd_ctx;
1656 QDF_STATUS status;
1657 bool alt_pipe;
1658
1659 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
1660
1661 mac_addr = sta_ctx->conn_info.bssid.bytes;
1662
1663 if (ucfg_ipa_is_enabled() && !sta_ctx->conn_info.is_authenticated &&
1664 adapter->device_mode == QDF_STA_MODE &&
1665 sta_ctx->conn_info.auth_type != eCSR_AUTH_TYPE_NONE &&
1666 sta_ctx->conn_info.auth_type != eCSR_AUTH_TYPE_OPEN_SYSTEM &&
1667 sta_ctx->conn_info.auth_type != eCSR_AUTH_TYPE_SHARED_KEY) {
1668
1669 hdd_ctx = WLAN_HDD_GET_CTX(adapter);
1670 status = hdd_ipa_get_tx_pipe(hdd_ctx, link_info, &alt_pipe);
1671 if (!QDF_IS_STATUS_SUCCESS(status)) {
1672 hdd_debug("Failed to get alternate pipe for vdev %d",
1673 link_info->vdev_id);
1674 alt_pipe = false;
1675 }
1676
1677 ucfg_ipa_wlan_evt(adapter->hdd_ctx->pdev, adapter->dev,
1678 adapter->device_mode,
1679 link_info->vdev_id,
1680 WLAN_IPA_STA_CONNECT, mac_addr,
1681 alt_pipe);
1682 }
1683
1684 hdd_cm_set_peer_authenticate(link_info,
1685 &sta_ctx->conn_info.bssid, false);
1686
1687 return 0;
1688 }
1689
1690 /**
1691 * hdd_change_peer_state_after_set_key() - change the peer state on set key
1692 * complete
1693 * @link_info: Link info pointer in HDD adapter
1694 * @roaminfo: pointer to roam info
1695 * @roam_result: roam result
1696 *
1697 * Peer state will be OL_TXRX_PEER_STATE_CONN until set key is complete.
1698 * This function checks for the successful set key completion and update
1699 * the peer state to OL_TXRX_PEER_STATE_AUTH.
1700 *
1701 * Return: None
1702 */
1703 static void
hdd_change_peer_state_after_set_key(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roaminfo,eCsrRoamResult roam_result)1704 hdd_change_peer_state_after_set_key(struct wlan_hdd_link_info *link_info,
1705 struct csr_roam_info *roaminfo,
1706 eCsrRoamResult roam_result)
1707 {
1708 struct hdd_station_ctx *hdd_sta_ctx;
1709 eCsrEncryptionType encr_type;
1710 struct hdd_adapter *adapter = link_info->adapter;
1711
1712 hdd_sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
1713 encr_type = hdd_sta_ctx->conn_info.uc_encrypt_type;
1714
1715 if (eCSR_ROAM_RESULT_AUTHENTICATED == roam_result) {
1716 hdd_sta_ctx->conn_info.gtk_installed = true;
1717 /*
1718 * PTK exchange happens in preauthentication itself if key_mgmt
1719 * is FT-PSK, ptk_installed was false as there is no set PTK
1720 * after roaming. STA TL state moves to authenticated only if
1721 * ptk_installed is true. So, make ptk_installed to true in
1722 * case of 11R roaming.
1723 */
1724 if (sme_neighbor_roam_is11r_assoc(adapter->hdd_ctx->mac_handle,
1725 link_info->vdev_id))
1726 hdd_sta_ctx->conn_info.ptk_installed = true;
1727 } else {
1728 hdd_sta_ctx->conn_info.ptk_installed = true;
1729 }
1730
1731 /* In WPA case move STA to authenticated when ptk is installed. Earlier
1732 * in WEP case STA was moved to AUTHENTICATED prior to setting the
1733 * unicast key and it was resulting in sending few un-encrypted packet.
1734 * Now in WEP case STA state will be moved to AUTHENTICATED after we
1735 * set the unicast and broadcast key.
1736 */
1737 if ((encr_type == eCSR_ENCRYPT_TYPE_WEP40) ||
1738 (encr_type == eCSR_ENCRYPT_TYPE_WEP104) ||
1739 (encr_type == eCSR_ENCRYPT_TYPE_WEP40_STATICKEY) ||
1740 (encr_type == eCSR_ENCRYPT_TYPE_WEP104_STATICKEY)) {
1741 if (hdd_sta_ctx->conn_info.gtk_installed &&
1742 hdd_sta_ctx->conn_info.ptk_installed)
1743 hdd_change_sta_state_authenticated(link_info, roaminfo);
1744 } else if (hdd_sta_ctx->conn_info.ptk_installed) {
1745 hdd_change_sta_state_authenticated(link_info, roaminfo);
1746 }
1747
1748 if (hdd_sta_ctx->conn_info.gtk_installed &&
1749 hdd_sta_ctx->conn_info.ptk_installed) {
1750 hdd_sta_ctx->conn_info.gtk_installed = false;
1751 hdd_sta_ctx->conn_info.ptk_installed = false;
1752 }
1753 }
1754
1755 /**
1756 * hdd_roam_set_key_complete_handler() - Update the security parameters
1757 * @link_info: Link info pointer in HDD adapter
1758 * @roam_info: pointer to roam info
1759 * @roam_status: roam status
1760 * @roam_result: roam result
1761 *
1762 * Return: QDF_STATUS enumeration
1763 */
1764 static QDF_STATUS
hdd_roam_set_key_complete_handler(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roam_info,eRoamCmdStatus roam_status,eCsrRoamResult roam_result)1765 hdd_roam_set_key_complete_handler(struct wlan_hdd_link_info *link_info,
1766 struct csr_roam_info *roam_info,
1767 eRoamCmdStatus roam_status,
1768 eCsrRoamResult roam_result)
1769 {
1770 eCsrEncryptionType algorithm;
1771 bool connected;
1772 struct hdd_station_ctx *sta_ctx;
1773 struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(link_info->adapter);
1774
1775 hdd_enter();
1776
1777 if (!roam_info) {
1778 hdd_err("roam_info is NULL");
1779 return QDF_STATUS_E_FAILURE;
1780 }
1781
1782 if (!hdd_ctx || !hdd_ctx->psoc) {
1783 hdd_err("hdd_ctx or psoc is NULL");
1784 return QDF_STATUS_E_FAILURE;
1785 }
1786
1787 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
1788 /*
1789 * if (WPA), tell TL to go to 'authenticated' after the keys are set.
1790 * then go to 'authenticated'. For all other authentication types
1791 * (those that do not require upper layer authentication) we can put TL
1792 * directly into 'authenticated' state.
1793 */
1794 hdd_debug("Set Key completion roam_status =%d roam_result=%d "
1795 QDF_MAC_ADDR_FMT, roam_status, roam_result,
1796 QDF_MAC_ADDR_REF(roam_info->peerMac.bytes));
1797
1798 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
1799 connected = hdd_conn_get_connected_cipher_algo(link_info, sta_ctx,
1800 &algorithm);
1801 if (connected) {
1802 hdd_change_peer_state_after_set_key(link_info,
1803 roam_info, roam_result);
1804 }
1805
1806 policy_mgr_restart_opportunistic_timer(hdd_ctx->psoc, false);
1807
1808 hdd_exit();
1809 return QDF_STATUS_SUCCESS;
1810 }
1811
hdd_save_peer(struct hdd_station_ctx * sta_ctx,struct qdf_mac_addr * peer_mac_addr)1812 bool hdd_save_peer(struct hdd_station_ctx *sta_ctx,
1813 struct qdf_mac_addr *peer_mac_addr)
1814 {
1815 int idx;
1816 struct qdf_mac_addr *mac_addr;
1817
1818 for (idx = 0; idx < MAX_PEERS; idx++) {
1819 mac_addr = &sta_ctx->conn_info.peer_macaddr[idx];
1820 if (qdf_is_macaddr_zero(mac_addr)) {
1821 hdd_debug("adding peer: "QDF_MAC_ADDR_FMT" at idx: %d",
1822 QDF_MAC_ADDR_REF(peer_mac_addr->bytes), idx);
1823 qdf_copy_macaddr(mac_addr, peer_mac_addr);
1824 return true;
1825 }
1826 }
1827
1828 return false;
1829 }
1830
hdd_delete_peer(struct hdd_station_ctx * sta_ctx,struct qdf_mac_addr * peer_mac_addr)1831 void hdd_delete_peer(struct hdd_station_ctx *sta_ctx,
1832 struct qdf_mac_addr *peer_mac_addr)
1833 {
1834 int i;
1835 struct qdf_mac_addr *mac_addr;
1836
1837 for (i = 0; i < MAX_PEERS; i++) {
1838 mac_addr = &sta_ctx->conn_info.peer_macaddr[i];
1839 if (qdf_is_macaddr_equal(mac_addr, peer_mac_addr)) {
1840 qdf_zero_macaddr(mac_addr);
1841 return;
1842 }
1843 }
1844 }
1845
hdd_any_valid_peer_present(struct wlan_hdd_link_info * link_info)1846 bool hdd_any_valid_peer_present(struct wlan_hdd_link_info *link_info)
1847 {
1848 struct hdd_station_ctx *sta_ctx;
1849 int i;
1850 struct qdf_mac_addr *mac_addr;
1851
1852 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
1853 for (i = 0; i < MAX_PEERS; i++) {
1854 mac_addr = &sta_ctx->conn_info.peer_macaddr[i];
1855 if (!qdf_is_macaddr_zero(mac_addr) &&
1856 !qdf_is_macaddr_broadcast(mac_addr)) {
1857 hdd_debug("peer: index: %u " QDF_MAC_ADDR_FMT, i,
1858 QDF_MAC_ADDR_REF(mac_addr->bytes));
1859 return true;
1860 }
1861 }
1862
1863 return false;
1864 }
1865
1866 /**
1867 * hdd_roam_mic_error_indication_handler() - MIC error indication handler
1868 * @link_info: Link info pointer in HDD adapter
1869 * @roam_info: pointer to roam info
1870 *
1871 * This function indicates the Mic failure to the supplicant
1872 *
1873 * Return: None
1874 */
1875 static void
hdd_roam_mic_error_indication_handler(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roam_info)1876 hdd_roam_mic_error_indication_handler(struct wlan_hdd_link_info *link_info,
1877 struct csr_roam_info *roam_info)
1878 {
1879 struct hdd_adapter *adapter = link_info->adapter;
1880 tSirMicFailureInfo *mic_failure_info;
1881
1882 if (!hdd_cm_is_vdev_associated(link_info))
1883 return;
1884
1885 mic_failure_info = roam_info->u.pMICFailureInfo;
1886 cfg80211_michael_mic_failure(adapter->dev,
1887 mic_failure_info->taMacAddr,
1888 mic_failure_info->multicast ?
1889 NL80211_KEYTYPE_GROUP :
1890 NL80211_KEYTYPE_PAIRWISE,
1891 mic_failure_info->keyId,
1892 mic_failure_info->TSC,
1893 GFP_KERNEL);
1894 }
1895
1896 #ifdef FEATURE_WLAN_TDLS
hdd_roam_register_tdlssta(struct hdd_adapter * adapter,const uint8_t * peerMac,uint8_t qos)1897 QDF_STATUS hdd_roam_register_tdlssta(struct hdd_adapter *adapter,
1898 const uint8_t *peerMac, uint8_t qos)
1899 {
1900 QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
1901 struct ol_txrx_desc_type txrx_desc = { 0 };
1902 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
1903 enum phy_ch_width ch_width;
1904 struct wlan_objmgr_vdev *vdev;
1905
1906 /*
1907 * TDLS sta in BSS should be set as STA type TDLS and STA MAC should
1908 * be peer MAC, here we are working on direct Link
1909 */
1910 WLAN_ADDR_COPY(txrx_desc.peer_addr.bytes, peerMac);
1911
1912 /* set the QoS field appropriately .. */
1913 txrx_desc.is_qos_enabled = qos;
1914
1915 vdev = hdd_objmgr_get_vdev_by_user(adapter->deflink, WLAN_DP_ID);
1916 if (!vdev)
1917 return QDF_STATUS_E_INVAL;
1918
1919 qdf_status = ucfg_dp_tdlsta_register_txrx_ops(vdev);
1920 hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
1921 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
1922 hdd_err("DP tx/rx ops register failed Status: %d", qdf_status);
1923 return qdf_status;
1924 }
1925
1926 ch_width = ucfg_mlme_get_peer_ch_width(adapter->hdd_ctx->psoc,
1927 txrx_desc.peer_addr.bytes);
1928 txrx_desc.bw = hdd_convert_ch_width_to_cdp_peer_bw(ch_width);
1929 /* Register the Station with TL... */
1930 qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &txrx_desc);
1931 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
1932 hdd_err("cdp_peer_register() failed Status: %d [0x%08X]",
1933 qdf_status, qdf_status);
1934 return qdf_status;
1935 }
1936
1937 return qdf_status;
1938 }
1939
1940 #endif
1941
1942 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0))
1943
hdd_rx_unprot_disassoc(struct net_device * dev,const u8 * buf,size_t len)1944 static void hdd_rx_unprot_disassoc(struct net_device *dev,
1945 const u8 *buf, size_t len)
1946 {
1947 cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
1948 }
1949
hdd_rx_unprot_deauth(struct net_device * dev,const u8 * buf,size_t len)1950 static void hdd_rx_unprot_deauth(struct net_device *dev,
1951 const u8 *buf, size_t len)
1952 {
1953 cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
1954 }
1955
1956 #else
1957
hdd_rx_unprot_disassoc(struct net_device * dev,const u8 * buf,size_t len)1958 static void hdd_rx_unprot_disassoc(struct net_device *dev,
1959 const u8 *buf, size_t len)
1960 {
1961 cfg80211_send_unprot_disassoc(dev, buf, len);
1962 }
1963
hdd_rx_unprot_deauth(struct net_device * dev,const u8 * buf,size_t len)1964 static void hdd_rx_unprot_deauth(struct net_device *dev,
1965 const u8 *buf, size_t len)
1966 {
1967 cfg80211_send_unprot_deauth(dev, buf, len);
1968 }
1969
1970 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0)) */
1971
1972 /**
1973 * hdd_indicate_unprot_mgmt_frame() - indicate unprotected management frame
1974 * @link_info: Link info pointer in HDD adapter
1975 * @frame_length: Length of the unprotected frame being passed
1976 * @frame: Pointer to the frame buffer
1977 * @frame_type: 802.11 frame type
1978 *
1979 * This function forwards the unprotected management frame to the supplicant.
1980 *
1981 * Return: nothing
1982 */
1983 static void
hdd_indicate_unprot_mgmt_frame(struct wlan_hdd_link_info * link_info,uint32_t frame_length,uint8_t * frame,uint8_t frame_type)1984 hdd_indicate_unprot_mgmt_frame(struct wlan_hdd_link_info *link_info,
1985 uint32_t frame_length, uint8_t *frame,
1986 uint8_t frame_type)
1987 {
1988 uint8_t type, subtype;
1989 struct hdd_stats *hdd_stats;
1990 struct hdd_adapter *adapter = link_info->adapter;
1991
1992 hdd_debug("Frame Type = %d Frame Length = %d",
1993 frame_type, frame_length);
1994
1995 if (hdd_validate_adapter(adapter))
1996 return;
1997
1998 if (!frame_length) {
1999 hdd_err("Frame Length is Invalid ZERO");
2000 return;
2001 }
2002
2003 if (!frame) {
2004 hdd_err("frame is NULL");
2005 return;
2006 }
2007
2008 type = WLAN_HDD_GET_TYPE_FRM_FC(frame[0]);
2009 if (type != SIR_MAC_MGMT_FRAME) {
2010 hdd_warn("Unexpected frame type %d", type);
2011 return;
2012 }
2013
2014 hdd_stats = &link_info->hdd_stats;
2015 subtype = WLAN_HDD_GET_SUBTYPE_FRM_FC(frame[0]);
2016 switch (subtype) {
2017 case SIR_MAC_MGMT_DISASSOC:
2018 hdd_rx_unprot_disassoc(adapter->dev, frame, frame_length);
2019 hdd_stats->hdd_pmf_stats.num_unprot_disassoc_rx++;
2020 break;
2021 case SIR_MAC_MGMT_DEAUTH:
2022 hdd_rx_unprot_deauth(adapter->dev, frame, frame_length);
2023 hdd_stats->hdd_pmf_stats.num_unprot_deauth_rx++;
2024 break;
2025 default:
2026 hdd_warn("Unexpected frame subtype %d", subtype);
2027 break;
2028 }
2029 }
2030
2031 #ifdef FEATURE_WLAN_ESE
2032 /**
2033 * hdd_indicate_tsm_ie() - send traffic stream metrics ie
2034 * @adapter: pointer to adapter
2035 * @tid: traffic identifier
2036 * @state: state
2037 * @measInterval: measurement interval
2038 *
2039 * This function sends traffic stream metrics IE information to
2040 * the supplicant via wireless event.
2041 *
2042 * Return: none
2043 */
2044 static void
hdd_indicate_tsm_ie(struct hdd_adapter * adapter,uint8_t tid,uint8_t state,uint16_t measInterval)2045 hdd_indicate_tsm_ie(struct hdd_adapter *adapter, uint8_t tid,
2046 uint8_t state, uint16_t measInterval)
2047 {
2048 union iwreq_data wrqu;
2049 char buf[IW_CUSTOM_MAX + 1];
2050 int nBytes = 0;
2051
2052 if (!adapter)
2053 return;
2054
2055 /* create the event */
2056 memset(&wrqu, '\0', sizeof(wrqu));
2057 memset(buf, '\0', sizeof(buf));
2058
2059 hdd_debug("TSM Ind tid(%d) state(%d) MeasInt(%d)",
2060 tid, state, measInterval);
2061
2062 nBytes =
2063 snprintf(buf, IW_CUSTOM_MAX, "TSMIE=%d:%d:%d", tid, state,
2064 measInterval);
2065
2066 wrqu.data.pointer = buf;
2067 wrqu.data.length = nBytes;
2068 /* send the event */
2069 hdd_wext_send_event(adapter->dev, IWEVCUSTOM, &wrqu, buf);
2070 }
2071
2072 /**
2073 * hdd_indicate_ese_adj_ap_rep_ind() - send adjacent AP report indication
2074 * @adapter: pointer to adapter
2075 * @roam_info: pointer to roam info
2076 *
2077 * Return: none
2078 */
2079 static void
hdd_indicate_ese_adj_ap_rep_ind(struct hdd_adapter * adapter,struct csr_roam_info * roam_info)2080 hdd_indicate_ese_adj_ap_rep_ind(struct hdd_adapter *adapter,
2081 struct csr_roam_info *roam_info)
2082 {
2083 union iwreq_data wrqu;
2084 char buf[IW_CUSTOM_MAX + 1];
2085 int nBytes = 0;
2086
2087 if ((!adapter) || (!roam_info))
2088 return;
2089
2090 /* create the event */
2091 memset(&wrqu, '\0', sizeof(wrqu));
2092 memset(buf, '\0', sizeof(buf));
2093
2094 hdd_debug("CCXADJAPREP=%u", roam_info->tsmRoamDelay);
2095
2096 nBytes =
2097 snprintf(buf, IW_CUSTOM_MAX, "CCXADJAPREP=%u",
2098 roam_info->tsmRoamDelay);
2099
2100 wrqu.data.pointer = buf;
2101 wrqu.data.length = nBytes;
2102
2103 /* send the event */
2104 hdd_wext_send_event(adapter->dev, IWEVCUSTOM, &wrqu, buf);
2105 }
2106
2107 /**
2108 * hdd_indicate_ese_bcn_report_no_results() - beacon report no scan results
2109 * @adapter: pointer to adapter
2110 * @measurementToken: measurement token
2111 * @flag: flag
2112 * @numBss: number of bss
2113 *
2114 * If the measurement is none and no scan results found,
2115 * indicate the supplicant about measurement done.
2116 *
2117 * Return: none
2118 */
2119 void
hdd_indicate_ese_bcn_report_no_results(const struct hdd_adapter * adapter,const uint16_t measurementToken,const bool flag,const uint8_t numBss)2120 hdd_indicate_ese_bcn_report_no_results(const struct hdd_adapter *adapter,
2121 const uint16_t measurementToken,
2122 const bool flag, const uint8_t numBss)
2123 {
2124 union iwreq_data wrqu;
2125 char buf[IW_CUSTOM_MAX];
2126 char *pos = buf;
2127 int nBytes = 0, freeBytes = IW_CUSTOM_MAX;
2128
2129 memset(&wrqu, '\0', sizeof(wrqu));
2130 memset(buf, '\0', sizeof(buf));
2131
2132 hdd_debug("CCXBCNREP=%d %d %d", measurementToken,
2133 flag, numBss);
2134
2135 nBytes =
2136 snprintf(pos, freeBytes, "CCXBCNREP=%d %d %d", measurementToken,
2137 flag, numBss);
2138
2139 wrqu.data.pointer = buf;
2140 wrqu.data.length = nBytes;
2141 /* send the event */
2142 hdd_wext_send_event(adapter->dev, IWEVCUSTOM, &wrqu, buf);
2143 }
2144
2145 /**
2146 * hdd_indicate_ese_bcn_report_ind() - send beacon report indication
2147 * @adapter: pointer to adapter
2148 * @roam_info: pointer to roam info
2149 *
2150 * If the measurement is none and no scan results found,
2151 * indicate the supplicant about measurement done.
2152 *
2153 * Return: none
2154 */
2155 static void
hdd_indicate_ese_bcn_report_ind(const struct hdd_adapter * adapter,const struct csr_roam_info * roam_info)2156 hdd_indicate_ese_bcn_report_ind(const struct hdd_adapter *adapter,
2157 const struct csr_roam_info *roam_info)
2158 {
2159 union iwreq_data wrqu;
2160 char buf[IW_CUSTOM_MAX];
2161 char *pos = buf;
2162 int nBytes = 0, freeBytes = IW_CUSTOM_MAX;
2163 uint8_t i = 0, len = 0;
2164 uint8_t tot_bcn_ieLen = 0; /* total size of the beacon report data */
2165 uint8_t lastSent = 0, sendBss = 0;
2166 int bcnRepFieldSize =
2167 sizeof(roam_info->pEseBcnReportRsp->bcnRepBssInfo[0].
2168 bcnReportFields);
2169 uint8_t ieLenByte = 1;
2170 /*
2171 * CCXBCNREP=meas_tok<sp>flag<sp>no_of_bss<sp>tot_bcn_ie_len = 18 bytes
2172 */
2173 #define ESEBCNREPHEADER_LEN (18)
2174
2175 if ((!adapter) || (!roam_info))
2176 return;
2177
2178 /*
2179 * Custom event can pass maximum of 256 bytes of data,
2180 * based on the IE len we need to identify how many BSS info can
2181 * be filled in to custom event data.
2182 */
2183 /*
2184 * meas_tok<sp>flag<sp>no_of_bss<sp>tot_bcn_ie_len bcn_rep_data
2185 * bcn_rep_data will have bcn_rep_fields,ie_len,ie without any spaces
2186 * CCXBCNREP=meas_tok<sp>flag<sp>no_of_bss<sp>tot_bcn_ie_len = 18 bytes
2187 */
2188
2189 if ((roam_info->pEseBcnReportRsp->flag >> 1)
2190 && (!roam_info->pEseBcnReportRsp->numBss)) {
2191 hdd_debug("Measurement Done but no scan results");
2192 /* If the measurement is none and no scan results found,
2193 * indicate the supplicant about measurement done
2194 */
2195 hdd_indicate_ese_bcn_report_no_results(
2196 adapter,
2197 roam_info->pEseBcnReportRsp->
2198 measurementToken,
2199 roam_info->pEseBcnReportRsp->flag,
2200 roam_info->pEseBcnReportRsp->numBss);
2201 } else {
2202 while (lastSent < roam_info->pEseBcnReportRsp->numBss) {
2203 memset(&wrqu, '\0', sizeof(wrqu));
2204 memset(buf, '\0', sizeof(buf));
2205 tot_bcn_ieLen = 0;
2206 sendBss = 0;
2207 pos = buf;
2208 freeBytes = IW_CUSTOM_MAX;
2209
2210 for (i = lastSent;
2211 i < roam_info->pEseBcnReportRsp->numBss; i++) {
2212 len =
2213 bcnRepFieldSize + ieLenByte +
2214 roam_info->pEseBcnReportRsp->
2215 bcnRepBssInfo[i].ieLen;
2216 if ((len + tot_bcn_ieLen) >
2217 (IW_CUSTOM_MAX - ESEBCNREPHEADER_LEN)) {
2218 break;
2219 }
2220 tot_bcn_ieLen += len;
2221 sendBss++;
2222 hdd_debug("i(%d) sizeof bcnReportFields(%d) IeLength(%d) Length of Ie(%d) totLen(%d)",
2223 i, bcnRepFieldSize, 1,
2224 roam_info->pEseBcnReportRsp->
2225 bcnRepBssInfo[i].ieLen, tot_bcn_ieLen);
2226 }
2227
2228 hdd_debug("Sending %d BSS Info", sendBss);
2229 hdd_debug("CCXBCNREP=%d %d %d %d",
2230 roam_info->pEseBcnReportRsp->measurementToken,
2231 roam_info->pEseBcnReportRsp->flag, sendBss,
2232 tot_bcn_ieLen);
2233
2234 nBytes = snprintf(pos, freeBytes, "CCXBCNREP=%d %d %d ",
2235 roam_info->pEseBcnReportRsp->
2236 measurementToken,
2237 roam_info->pEseBcnReportRsp->flag,
2238 sendBss);
2239 pos += nBytes;
2240 freeBytes -= nBytes;
2241
2242 /* Copy total Beacon report data length */
2243 qdf_mem_copy(pos, (char *)&tot_bcn_ieLen,
2244 sizeof(tot_bcn_ieLen));
2245 pos += sizeof(tot_bcn_ieLen);
2246 freeBytes -= sizeof(tot_bcn_ieLen);
2247
2248 for (i = 0; i < sendBss; i++) {
2249 hdd_debug("ChanNum(%d) Spare(%d) MeasDuration(%d)"
2250 " PhyType(%d) RecvSigPower(%d) ParentTSF(%u)"
2251 " TargetTSF[0](%u) TargetTSF[1](%u) BeaconInterval(%u)"
2252 " CapabilityInfo(%d) BSSID(%02X:%02X:%02X:%02X:%02X:%02X)",
2253 roam_info->pEseBcnReportRsp->
2254 bcnRepBssInfo[i +
2255 lastSent].bcnReportFields.
2256 ChanNum,
2257 roam_info->pEseBcnReportRsp->
2258 bcnRepBssInfo[i +
2259 lastSent].bcnReportFields.
2260 Spare,
2261 roam_info->pEseBcnReportRsp->
2262 bcnRepBssInfo[i +
2263 lastSent].bcnReportFields.
2264 MeasDuration,
2265 roam_info->pEseBcnReportRsp->
2266 bcnRepBssInfo[i +
2267 lastSent].bcnReportFields.
2268 PhyType,
2269 roam_info->pEseBcnReportRsp->
2270 bcnRepBssInfo[i +
2271 lastSent].bcnReportFields.
2272 RecvSigPower,
2273 roam_info->pEseBcnReportRsp->
2274 bcnRepBssInfo[i +
2275 lastSent].bcnReportFields.
2276 ParentTsf,
2277 roam_info->pEseBcnReportRsp->
2278 bcnRepBssInfo[i +
2279 lastSent].bcnReportFields.
2280 TargetTsf[0],
2281 roam_info->pEseBcnReportRsp->
2282 bcnRepBssInfo[i +
2283 lastSent].bcnReportFields.
2284 TargetTsf[1],
2285 roam_info->pEseBcnReportRsp->
2286 bcnRepBssInfo[i +
2287 lastSent].bcnReportFields.
2288 BcnInterval,
2289 roam_info->pEseBcnReportRsp->
2290 bcnRepBssInfo[i +
2291 lastSent].bcnReportFields.
2292 CapabilityInfo,
2293 roam_info->pEseBcnReportRsp->
2294 bcnRepBssInfo[i +
2295 lastSent].bcnReportFields.
2296 Bssid[0],
2297 roam_info->pEseBcnReportRsp->
2298 bcnRepBssInfo[i +
2299 lastSent].bcnReportFields.
2300 Bssid[1],
2301 roam_info->pEseBcnReportRsp->
2302 bcnRepBssInfo[i +
2303 lastSent].bcnReportFields.
2304 Bssid[2],
2305 roam_info->pEseBcnReportRsp->
2306 bcnRepBssInfo[i +
2307 lastSent].bcnReportFields.
2308 Bssid[3],
2309 roam_info->pEseBcnReportRsp->
2310 bcnRepBssInfo[i +
2311 lastSent].bcnReportFields.
2312 Bssid[4],
2313 roam_info->pEseBcnReportRsp->
2314 bcnRepBssInfo[i +
2315 lastSent].bcnReportFields.
2316 Bssid[5]);
2317
2318 /* bcn report fields are copied */
2319 len =
2320 sizeof(roam_info->pEseBcnReportRsp->
2321 bcnRepBssInfo[i +
2322 lastSent].
2323 bcnReportFields);
2324 qdf_mem_copy(pos,
2325 (char *)&roam_info->
2326 pEseBcnReportRsp->bcnRepBssInfo[i +
2327 lastSent].
2328 bcnReportFields, len);
2329 pos += len;
2330 freeBytes -= len;
2331
2332 /* Add 1 byte of ie len */
2333 len =
2334 roam_info->pEseBcnReportRsp->
2335 bcnRepBssInfo[i + lastSent].ieLen;
2336 qdf_mem_copy(pos, (char *)&len, sizeof(len));
2337 pos += sizeof(len);
2338 freeBytes -= sizeof(len);
2339
2340 /* copy IE from scan results */
2341 qdf_mem_copy(pos,
2342 (char *)roam_info->
2343 pEseBcnReportRsp->bcnRepBssInfo[i +
2344 lastSent].
2345 pBuf, len);
2346 pos += len;
2347 freeBytes -= len;
2348 }
2349
2350 wrqu.data.pointer = buf;
2351 wrqu.data.length = IW_CUSTOM_MAX - freeBytes;
2352
2353 /* send the event */
2354 hdd_wext_send_event(adapter->dev, IWEVCUSTOM, &wrqu,
2355 buf);
2356 lastSent += sendBss;
2357 }
2358 }
2359 }
2360
2361 #endif /* FEATURE_WLAN_ESE */
2362
2363 /*
2364 * hdd_roam_channel_switch_handler() - hdd channel switch handler
2365 * @link_info: Link info pointer in HDD adapter
2366 * @roam_info: Pointer to roam info
2367 *
2368 * Return: None
2369 */
2370 static void
hdd_roam_channel_switch_handler(struct wlan_hdd_link_info * link_info,struct csr_roam_info * roam_info)2371 hdd_roam_channel_switch_handler(struct wlan_hdd_link_info *link_info,
2372 struct csr_roam_info *roam_info)
2373 {
2374 struct hdd_chan_change_params chan_change = {0};
2375 QDF_STATUS status;
2376 struct hdd_adapter *adapter = link_info->adapter;
2377 struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
2378 mac_handle_t mac_handle;
2379 struct hdd_station_ctx *sta_ctx;
2380 uint8_t connected_vdev;
2381 bool notify = true, is_sap_go_moved_before_sta = false;
2382 struct wlan_objmgr_vdev *vdev;
2383
2384 mac_handle = hdd_adapter_get_mac_handle(adapter);
2385 if (!mac_handle)
2386 return;
2387
2388 /* Enable Roaming on STA interface which was disabled before CSA */
2389 if (adapter->device_mode == QDF_STA_MODE)
2390 sme_start_roaming(mac_handle, link_info->vdev_id,
2391 REASON_VDEV_RESTART_FROM_HOST,
2392 RSO_CHANNEL_SWITCH);
2393
2394 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
2395 if (sta_ctx) {
2396 sta_ctx->conn_info.chan_freq = roam_info->chan_info.mhz;
2397 sta_ctx->conn_info.ch_width = roam_info->chan_info.ch_width;
2398 }
2399
2400 chan_change.chan_freq = roam_info->chan_info.mhz;
2401 chan_change.chan_params.ch_width =
2402 roam_info->chan_info.ch_width;
2403 chan_change.chan_params.sec_ch_offset =
2404 roam_info->chan_info.sec_ch_offset;
2405 chan_change.chan_params.mhz_freq_seg0 =
2406 roam_info->chan_info.band_center_freq1;
2407 chan_change.chan_params.mhz_freq_seg1 =
2408 roam_info->chan_info.band_center_freq2;
2409
2410 vdev = hdd_objmgr_get_vdev_by_user(link_info, WLAN_OSIF_ID);
2411 if (!vdev) {
2412 hdd_err("Invalid vdev");
2413 return;
2414 }
2415
2416 if ((adapter->device_mode == QDF_STA_MODE ||
2417 adapter->device_mode == QDF_P2P_CLIENT_MODE)) {
2418 if (!wlan_get_connected_vdev_by_bssid(
2419 hdd_ctx->pdev, sta_ctx->conn_info.bssid.bytes,
2420 &connected_vdev))
2421 notify = false;
2422 else if (link_info->vdev_id != connected_vdev ||
2423 !ucfg_cm_is_vdev_active(vdev))
2424 notify = false;
2425 }
2426 if (notify) {
2427 qdf_sched_work(0, &link_info->chan_change_notify_work);
2428 } else {
2429 hdd_err("BSS "QDF_MAC_ADDR_FMT" no connected with vdev %d (%d)",
2430 QDF_MAC_ADDR_REF(sta_ctx->conn_info.bssid.bytes),
2431 link_info->vdev_id, connected_vdev);
2432 }
2433 status = policy_mgr_set_hw_mode_on_channel_switch(hdd_ctx->psoc,
2434 link_info->vdev_id);
2435 if (QDF_IS_STATUS_ERROR(status))
2436 hdd_debug("set hw mode change not done");
2437
2438 is_sap_go_moved_before_sta =
2439 wlan_vdev_mlme_is_sap_go_move_before_sta(vdev);
2440 hdd_objmgr_put_vdev_by_user(vdev, WLAN_OSIF_ID);
2441
2442 if (!is_sap_go_moved_before_sta)
2443 policy_mgr_check_concurrent_intf_and_restart_sap(
2444 hdd_ctx->psoc,
2445 !!link_info->session.ap.sap_config.acs_cfg.acs_mode);
2446
2447 wlan_twt_concurrency_update(hdd_ctx);
2448 if (adapter->device_mode == QDF_STA_MODE ||
2449 adapter->device_mode == QDF_P2P_CLIENT_MODE) {
2450 vdev = hdd_objmgr_get_vdev_by_user(link_info,
2451 WLAN_OSIF_ID);
2452 if (!vdev)
2453 return;
2454
2455 status = ucfg_if_mgr_deliver_event(
2456 vdev, WLAN_IF_MGR_EV_STA_CSA_COMPLETE, NULL);
2457 if (QDF_IS_STATUS_ERROR(status))
2458 hdd_debug("Failed to deliver CSA complete evt");
2459
2460 hdd_objmgr_put_vdev_by_user(vdev, WLAN_OSIF_ID);
2461 }
2462 }
2463
2464 #ifdef WLAN_FEATURE_HOST_ROAM
wlan_hdd_ft_set_key_delay(struct wlan_objmgr_vdev * vdev)2465 void wlan_hdd_ft_set_key_delay(struct wlan_objmgr_vdev *vdev)
2466 {
2467 int errno = 0;
2468
2469 if (ucfg_cm_ft_key_ready_for_install(vdev))
2470 errno =
2471 wlan_cfg80211_crypto_add_key(vdev,
2472 WLAN_CRYPTO_KEY_TYPE_UNICAST,
2473 0, false);
2474 if (errno)
2475 hdd_err("ft set key failed");
2476 }
2477 #endif
2478
hdd_sme_roam_callback(void * context,struct csr_roam_info * roam_info,eRoamCmdStatus roam_status,eCsrRoamResult roam_result)2479 QDF_STATUS hdd_sme_roam_callback(void *context,
2480 struct csr_roam_info *roam_info,
2481 eRoamCmdStatus roam_status,
2482 eCsrRoamResult roam_result)
2483 {
2484 QDF_STATUS qdf_ret_status = QDF_STATUS_SUCCESS;
2485 struct wlan_hdd_link_info *link_info = context;
2486 struct hdd_adapter *adapter = link_info->adapter;
2487 struct hdd_station_ctx *sta_ctx = NULL;
2488 struct hdd_context *hdd_ctx;
2489
2490 hdd_debug("CSR Callback: status=%s (%d) result= %s (%d)",
2491 get_e_roam_cmd_status_str(roam_status), roam_status,
2492 get_e_csr_roam_result_str(roam_result), roam_result);
2493
2494 /* Sanity check */
2495 if (WLAN_HDD_ADAPTER_MAGIC != adapter->magic) {
2496 hdd_err("Invalid adapter or adapter has invalid magic");
2497 return QDF_STATUS_E_FAILURE;
2498 }
2499
2500 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
2501 hdd_ctx = WLAN_HDD_GET_CTX(adapter);
2502
2503 MTRACE(qdf_trace(QDF_MODULE_ID_HDD, TRACE_CODE_HDD_RX_SME_MSG,
2504 link_info->vdev_id, roam_status));
2505
2506 switch (roam_status) {
2507 case eCSR_ROAM_MIC_ERROR_IND:
2508 hdd_roam_mic_error_indication_handler(link_info, roam_info);
2509 break;
2510
2511 case eCSR_ROAM_SET_KEY_COMPLETE:
2512 {
2513 qdf_ret_status =
2514 hdd_roam_set_key_complete_handler(link_info, roam_info,
2515 roam_status,
2516 roam_result);
2517 if (eCSR_ROAM_RESULT_AUTHENTICATED == roam_result)
2518 hdd_debug("set key complete, session: %d",
2519 link_info->vdev_id);
2520 }
2521 break;
2522 case eCSR_ROAM_UNPROT_MGMT_FRAME_IND:
2523 if (roam_info)
2524 hdd_indicate_unprot_mgmt_frame(link_info,
2525 roam_info->nFrameLength,
2526 roam_info->pbFrames,
2527 roam_info->frameType);
2528 break;
2529 #ifdef FEATURE_WLAN_ESE
2530 case eCSR_ROAM_TSM_IE_IND:
2531 if (roam_info)
2532 hdd_indicate_tsm_ie(adapter,
2533 roam_info->tsm_ie.tsid,
2534 roam_info->tsm_ie.state,
2535 roam_info->tsm_ie.msmt_interval);
2536 break;
2537 case eCSR_ROAM_ESE_ADJ_AP_REPORT_IND:
2538 {
2539 hdd_indicate_ese_adj_ap_rep_ind(adapter, roam_info);
2540 break;
2541 }
2542
2543 case eCSR_ROAM_ESE_BCN_REPORT_IND:
2544 {
2545 hdd_indicate_ese_bcn_report_ind(adapter, roam_info);
2546 break;
2547 }
2548 #endif /* FEATURE_WLAN_ESE */
2549 case eCSR_ROAM_STA_CHANNEL_SWITCH:
2550 hdd_roam_channel_switch_handler(link_info, roam_info);
2551 break;
2552
2553 case eCSR_ROAM_NDP_STATUS_UPDATE:
2554 hdd_ndp_event_handler(link_info, roam_info,
2555 roam_status, roam_result);
2556 break;
2557 case eCSR_ROAM_SAE_COMPUTE:
2558 if (roam_info)
2559 wlan_hdd_sae_callback(link_info, roam_info);
2560 break;
2561 default:
2562 break;
2563 }
2564 return qdf_ret_status;
2565 }
2566
2567 #ifdef WLAN_FEATURE_FILS_SK
2568 /**
2569 * hdd_translate_fils_rsn_to_csr_auth() - Translate FILS RSN to CSR auth type
2570 * @auth_suite: auth suite
2571 * @auth_type: pointer to enum csr_akm_type
2572 *
2573 * Return: None
2574 */
hdd_translate_fils_rsn_to_csr_auth(int8_t auth_suite[4],enum csr_akm_type * auth_type)2575 static void hdd_translate_fils_rsn_to_csr_auth(int8_t auth_suite[4],
2576 enum csr_akm_type *auth_type)
2577 {
2578 if (!memcmp(auth_suite, ccp_rsn_oui_0e, 4))
2579 *auth_type = eCSR_AUTH_TYPE_FILS_SHA256;
2580 else if (!memcmp(auth_suite, ccp_rsn_oui_0f, 4))
2581 *auth_type = eCSR_AUTH_TYPE_FILS_SHA384;
2582 else if (!memcmp(auth_suite, ccp_rsn_oui_10, 4))
2583 *auth_type = eCSR_AUTH_TYPE_FT_FILS_SHA256;
2584 else if (!memcmp(auth_suite, ccp_rsn_oui_11, 4))
2585 *auth_type = eCSR_AUTH_TYPE_FT_FILS_SHA384;
2586 }
2587 #else
hdd_translate_fils_rsn_to_csr_auth(int8_t auth_suite[4],enum csr_akm_type * auth_type)2588 static inline void hdd_translate_fils_rsn_to_csr_auth(int8_t auth_suite[4],
2589 enum csr_akm_type *auth_type)
2590 {
2591 }
2592 #endif
2593
2594 #ifdef WLAN_FEATURE_SAE
2595 /**
2596 * hdd_translate_sae_rsn_to_csr_auth() - Translate SAE RSN to CSR auth type
2597 * @auth_suite: auth suite
2598 * @auth_type: pointer to enum csr_akm_type
2599 *
2600 * Return: None
2601 */
hdd_translate_sae_rsn_to_csr_auth(int8_t auth_suite[4],enum csr_akm_type * auth_type)2602 static void hdd_translate_sae_rsn_to_csr_auth(int8_t auth_suite[4],
2603 enum csr_akm_type *auth_type)
2604 {
2605 if (qdf_mem_cmp(auth_suite, ccp_rsn_oui_80, 4) == 0)
2606 *auth_type = eCSR_AUTH_TYPE_SAE;
2607 else if (qdf_mem_cmp(auth_suite, ccp_rsn_oui_90, 4) == 0)
2608 *auth_type = eCSR_AUTH_TYPE_FT_SAE;
2609
2610 }
2611 #else
hdd_translate_sae_rsn_to_csr_auth(int8_t auth_suite[4],enum csr_akm_type * auth_type)2612 static inline void hdd_translate_sae_rsn_to_csr_auth(int8_t auth_suite[4],
2613 enum csr_akm_type *auth_type)
2614 {
2615 }
2616 #endif
2617
hdd_filter_ft_info(const uint8_t * frame,size_t len,uint32_t * ft_info_len)2618 void *hdd_filter_ft_info(const uint8_t *frame, size_t len,
2619 uint32_t *ft_info_len)
2620 {
2621 uint32_t ft_ie_len, md_ie_len, rsn_ie_len, ie_len;
2622 const uint8_t *rsn_ie, *md_ie, *ft_ie;
2623 void *ft_info;
2624
2625 ft_ie_len = 0;
2626 md_ie_len = 0;
2627 rsn_ie_len = 0;
2628 ie_len = len - DOT11F_FF_CAPABILITIES_LEN - DOT11F_FF_STATUS_LEN
2629 - DOT11F_IE_AID_MAX_LEN - sizeof(tSirMacMgmtHdr);
2630 rsn_ie = wlan_get_ie_ptr_from_eid(DOT11F_EID_RSN, frame, ie_len);
2631
2632 if (rsn_ie) {
2633 rsn_ie_len = rsn_ie[1] + 2;
2634 QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
2635 (void *)rsn_ie, rsn_ie_len);
2636 }
2637 md_ie = wlan_get_ie_ptr_from_eid(DOT11F_EID_MOBILITYDOMAIN,
2638 frame, ie_len);
2639 if (md_ie) {
2640 md_ie_len = md_ie[1] + 2;
2641 QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
2642 (void *)md_ie, md_ie_len);
2643 }
2644 ft_ie = wlan_get_ie_ptr_from_eid(DOT11F_EID_FTINFO, frame, ie_len);
2645 if (ft_ie)
2646 ft_ie_len = ft_ie[1] + 2;
2647
2648 *ft_info_len = rsn_ie_len + md_ie_len + ft_ie_len;
2649 ft_info = qdf_mem_malloc(*ft_info_len);
2650 if (!ft_info)
2651 return NULL;
2652 if (rsn_ie_len)
2653 qdf_mem_copy(ft_info, rsn_ie, rsn_ie_len);
2654 if (md_ie_len)
2655 qdf_mem_copy(ft_info + rsn_ie_len, md_ie, md_ie_len);
2656 if (ft_ie_len)
2657 qdf_mem_copy(ft_info + rsn_ie_len + md_ie_len,
2658 ft_ie, ft_ie_len);
2659 return ft_info;
2660 }
2661
2662 /**
2663 * hdd_translate_rsn_to_csr_auth_type() - Translate RSN to CSR auth type
2664 * @auth_suite: auth suite
2665 *
2666 * Return: enum csr_akm_type enumeration
2667 */
hdd_translate_rsn_to_csr_auth_type(uint8_t auth_suite[4])2668 enum csr_akm_type hdd_translate_rsn_to_csr_auth_type(uint8_t auth_suite[4])
2669 {
2670 enum csr_akm_type auth_type = eCSR_AUTH_TYPE_UNKNOWN;
2671 /* is the auth type supported? */
2672 if (memcmp(auth_suite, ccp_rsn_oui01, 4) == 0) {
2673 auth_type = eCSR_AUTH_TYPE_RSN;
2674 } else if (memcmp(auth_suite, ccp_rsn_oui02, 4) == 0) {
2675 auth_type = eCSR_AUTH_TYPE_RSN_PSK;
2676 } else if (memcmp(auth_suite, ccp_rsn_oui04, 4) == 0) {
2677 /* Check for 11r FT Authentication with PSK */
2678 auth_type = eCSR_AUTH_TYPE_FT_RSN_PSK;
2679 } else if (memcmp(auth_suite, ccp_rsn_oui03, 4) == 0) {
2680 /* Check for 11R FT Authentication with 802.1X */
2681 auth_type = eCSR_AUTH_TYPE_FT_RSN;
2682 } else
2683 #ifdef FEATURE_WLAN_ESE
2684 if (memcmp(auth_suite, ccp_rsn_oui06, 4) == 0) {
2685 auth_type = eCSR_AUTH_TYPE_CCKM_RSN;
2686 } else
2687 #endif /* FEATURE_WLAN_ESE */
2688 if (memcmp(auth_suite, ccp_rsn_oui07, 4) == 0) {
2689 auth_type = eCSR_AUTH_TYPE_RSN_PSK_SHA256;
2690 } else if (memcmp(auth_suite, ccp_rsn_oui08, 4) == 0) {
2691 auth_type = eCSR_AUTH_TYPE_RSN_8021X_SHA256;
2692 } else if (memcmp(auth_suite, ccp_rsn_oui_18, 4) == 0) {
2693 auth_type = eCSR_AUTH_TYPE_OWE;
2694 } else if (memcmp(auth_suite, ccp_rsn_oui_12, 4) == 0) {
2695 auth_type = eCSR_AUTH_TYPE_DPP_RSN;
2696 } else if (memcmp(auth_suite, ccp_rsn_oui_0b, 4) == 0) {
2697 /* Check for Suite B EAP 256 */
2698 auth_type = eCSR_AUTH_TYPE_SUITEB_EAP_SHA256;
2699 } else if (memcmp(auth_suite, ccp_rsn_oui_0c, 4) == 0) {
2700 /* Check for Suite B EAP 384 */
2701 auth_type = eCSR_AUTH_TYPE_SUITEB_EAP_SHA384;
2702 } else if (memcmp(auth_suite, ccp_rsn_oui_0d, 4) == 0) {
2703 /* Check for FT Suite B EAP 384 */
2704 auth_type = eCSR_AUTH_TYPE_FT_SUITEB_EAP_SHA384;
2705 } else if (memcmp(auth_suite, ccp_rsn_oui_13, 4) == 0) {
2706 auth_type = eCSR_AUTH_TYPE_OSEN;
2707 } else {
2708 hdd_translate_fils_rsn_to_csr_auth(auth_suite, &auth_type);
2709 hdd_translate_sae_rsn_to_csr_auth(auth_suite, &auth_type);
2710 }
2711
2712 return auth_type;
2713 }
2714
2715 /**
2716 * hdd_translate_wpa_to_csr_auth_type() - Translate WPA to CSR auth type
2717 * @auth_suite: auth suite
2718 *
2719 * Return: enum csr_akm_type enumeration
2720 */
hdd_translate_wpa_to_csr_auth_type(uint8_t auth_suite[4])2721 enum csr_akm_type hdd_translate_wpa_to_csr_auth_type(uint8_t auth_suite[4])
2722 {
2723 enum csr_akm_type auth_type = eCSR_AUTH_TYPE_UNKNOWN;
2724 /* is the auth type supported? */
2725 if (memcmp(auth_suite, ccp_wpa_oui01, 4) == 0) {
2726 auth_type = eCSR_AUTH_TYPE_WPA;
2727 } else if (memcmp(auth_suite, ccp_wpa_oui02, 4) == 0) {
2728 auth_type = eCSR_AUTH_TYPE_WPA_PSK;
2729 } else
2730 #ifdef FEATURE_WLAN_ESE
2731 if (memcmp(auth_suite, ccp_wpa_oui06, 4) == 0) {
2732 auth_type = eCSR_AUTH_TYPE_CCKM_WPA;
2733 } else
2734 #endif /* FEATURE_WLAN_ESE */
2735 {
2736 hdd_translate_fils_rsn_to_csr_auth(auth_suite, &auth_type);
2737 }
2738
2739 return auth_type;
2740 }
2741
2742 /**
2743 * hdd_translate_rsn_to_csr_encryption_type() -
2744 * Translate RSN to CSR encryption type
2745 * @cipher_suite: cipher suite
2746 *
2747 * Return: eCsrEncryptionType enumeration
2748 */
2749 eCsrEncryptionType
hdd_translate_rsn_to_csr_encryption_type(uint8_t cipher_suite[4])2750 hdd_translate_rsn_to_csr_encryption_type(uint8_t cipher_suite[4])
2751 {
2752 eCsrEncryptionType cipher_type;
2753
2754 if (memcmp(cipher_suite, ccp_rsn_oui04, 4) == 0)
2755 cipher_type = eCSR_ENCRYPT_TYPE_AES;
2756 else if (memcmp(cipher_suite, ccp_rsn_oui09, 4) == 0)
2757 cipher_type = eCSR_ENCRYPT_TYPE_AES_GCMP;
2758 else if (memcmp(cipher_suite, ccp_rsn_oui0a, 4) == 0)
2759 cipher_type = eCSR_ENCRYPT_TYPE_AES_GCMP_256;
2760 else if (memcmp(cipher_suite, ccp_rsn_oui02, 4) == 0)
2761 cipher_type = eCSR_ENCRYPT_TYPE_TKIP;
2762 else if (memcmp(cipher_suite, ccp_rsn_oui00, 4) == 0)
2763 cipher_type = eCSR_ENCRYPT_TYPE_NONE;
2764 else if (memcmp(cipher_suite, ccp_rsn_oui01, 4) == 0)
2765 cipher_type = eCSR_ENCRYPT_TYPE_WEP40_STATICKEY;
2766 else if (memcmp(cipher_suite, ccp_rsn_oui05, 4) == 0)
2767 cipher_type = eCSR_ENCRYPT_TYPE_WEP104_STATICKEY;
2768 else
2769 cipher_type = eCSR_ENCRYPT_TYPE_FAILED;
2770
2771 return cipher_type;
2772 }
2773
2774 /**
2775 * hdd_translate_wpa_to_csr_encryption_type() -
2776 * Translate WPA to CSR encryption type
2777 * @cipher_suite: cipher suite
2778 *
2779 * Return: eCsrEncryptionType enumeration
2780 */
2781 eCsrEncryptionType
hdd_translate_wpa_to_csr_encryption_type(uint8_t cipher_suite[4])2782 hdd_translate_wpa_to_csr_encryption_type(uint8_t cipher_suite[4])
2783 {
2784 eCsrEncryptionType cipher_type;
2785
2786 if (memcmp(cipher_suite, ccp_wpa_oui04, 4) == 0)
2787 cipher_type = eCSR_ENCRYPT_TYPE_AES;
2788 else if (memcmp(cipher_suite, ccp_wpa_oui02, 4) == 0)
2789 cipher_type = eCSR_ENCRYPT_TYPE_TKIP;
2790 else if (memcmp(cipher_suite, ccp_wpa_oui00, 4) == 0)
2791 cipher_type = eCSR_ENCRYPT_TYPE_NONE;
2792 else if (memcmp(cipher_suite, ccp_wpa_oui01, 4) == 0)
2793 cipher_type = eCSR_ENCRYPT_TYPE_WEP40_STATICKEY;
2794 else if (memcmp(cipher_suite, ccp_wpa_oui05, 4) == 0)
2795 cipher_type = eCSR_ENCRYPT_TYPE_WEP104_STATICKEY;
2796 else
2797 cipher_type = eCSR_ENCRYPT_TYPE_FAILED;
2798
2799 return cipher_type;
2800 }
2801
2802 #ifdef FEATURE_WLAN_WAPI
hdd_translate_wapi_to_csr_auth_type(uint8_t auth_suite[4])2803 enum csr_akm_type hdd_translate_wapi_to_csr_auth_type(uint8_t auth_suite[4])
2804 {
2805 enum csr_akm_type auth_type;
2806
2807 if (memcmp(auth_suite, ccp_wapi_oui01, 4) == 0)
2808 auth_type = eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
2809 else if (memcmp(auth_suite, ccp_wapi_oui02, 4) == 0)
2810 auth_type = eCSR_AUTH_TYPE_WAPI_WAI_PSK;
2811 else
2812 auth_type = eCSR_AUTH_TYPE_UNKNOWN;
2813
2814 return auth_type;
2815 }
2816
2817 eCsrEncryptionType
hdd_translate_wapi_to_csr_encryption_type(uint8_t cipher_suite[4])2818 hdd_translate_wapi_to_csr_encryption_type(uint8_t cipher_suite[4])
2819 {
2820 eCsrEncryptionType cipher_type;
2821
2822 if (memcmp(cipher_suite, ccp_wapi_oui01, 4) == 0 ||
2823 memcmp(cipher_suite, ccp_wapi_oui02, 4) == 0)
2824 cipher_type = eCSR_ENCRYPT_TYPE_WPI;
2825 else
2826 cipher_type = eCSR_ENCRYPT_TYPE_FAILED;
2827
2828 return cipher_type;
2829 }
2830 #endif /* FEATURE_WLAN_WAPI */
2831
2832 enum cdp_peer_bw
hdd_convert_ch_width_to_cdp_peer_bw(enum phy_ch_width ch_width)2833 hdd_convert_ch_width_to_cdp_peer_bw(enum phy_ch_width ch_width)
2834 {
2835 switch (ch_width) {
2836 case CH_WIDTH_20MHZ:
2837 return CDP_20_MHZ;
2838 case CH_WIDTH_40MHZ:
2839 return CDP_40_MHZ;
2840 case CH_WIDTH_80MHZ:
2841 return CDP_80_MHZ;
2842 case CH_WIDTH_160MHZ:
2843 return CDP_160_MHZ;
2844 case CH_WIDTH_80P80MHZ:
2845 return CDP_80P80_MHZ;
2846 case CH_WIDTH_5MHZ:
2847 return CDP_5_MHZ;
2848 case CH_WIDTH_10MHZ:
2849 return CDP_10_MHZ;
2850 case CH_WIDTH_320MHZ:
2851 return CDP_320_MHZ;
2852 default:
2853 return CDP_BW_INVALID;
2854 }
2855
2856 return CDP_BW_INVALID;
2857 }
2858
2859 #ifdef WLAN_FEATURE_FILS_SK
hdd_is_fils_connection(struct hdd_context * hdd_ctx,struct hdd_adapter * adapter)2860 bool hdd_is_fils_connection(struct hdd_context *hdd_ctx,
2861 struct hdd_adapter *adapter)
2862 {
2863 struct wlan_fils_connection_info *fils_info;
2864
2865 fils_info = wlan_cm_get_fils_connection_info(hdd_ctx->psoc,
2866 adapter->deflink->vdev_id);
2867 if (fils_info)
2868 return fils_info->is_fils_connection;
2869
2870 return false;
2871 }
2872 #else
hdd_is_fils_connection(struct hdd_context * hdd_ctx,struct hdd_adapter * adapter)2873 bool hdd_is_fils_connection(struct hdd_context *hdd_ctx,
2874 struct hdd_adapter *adapter)
2875 {
2876 return false;
2877 }
2878 #endif
2879
hdd_roam_profile_init(struct wlan_hdd_link_info * link_info)2880 void hdd_roam_profile_init(struct wlan_hdd_link_info *link_info)
2881 {
2882 struct csr_roam_profile *roam_profile;
2883 struct hdd_station_ctx *sta_ctx;
2884
2885 hdd_enter();
2886
2887 roam_profile = hdd_roam_profile(link_info);
2888 qdf_mem_zero(roam_profile, sizeof(*roam_profile));
2889
2890 sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
2891
2892 /* Configure the roaming profile links to SSID and bssid. */
2893 roam_profile->SSIDs.numOfSSIDs = 0;
2894 roam_profile->SSIDs.SSIDList = &sta_ctx->conn_info.ssid;
2895
2896 roam_profile->BSSIDs.numOfBSSIDs = 0;
2897 roam_profile->BSSIDs.bssid = &sta_ctx->conn_info.bssid;
2898
2899 /* Set the numOfChannels to zero to scan all the channels */
2900 roam_profile->ChannelInfo.numOfChannels = 0;
2901 roam_profile->ChannelInfo.freq_list = NULL;
2902
2903 roam_profile->BSSType = eCSR_BSS_TYPE_INFRASTRUCTURE;
2904
2905 roam_profile->phyMode = eCSR_DOT11_MODE_AUTO;
2906
2907 /* Set the default scan mode */
2908 link_info->adapter->scan_info.scan_mode = eSIR_ACTIVE_SCAN;
2909
2910 hdd_clear_roam_profile_ie(link_info->adapter);
2911 hdd_exit();
2912 }
2913
2914 struct osif_cm_ops osif_ops = {
2915 .connect_active_notify_cb = hdd_cm_connect_active_notify,
2916 .connect_complete_cb = hdd_cm_connect_complete,
2917 .disconnect_complete_cb = hdd_cm_disconnect_complete,
2918 .netif_queue_control_cb = hdd_cm_netif_queue_control,
2919 .napi_serialize_control_cb = hdd_cm_napi_serialize_control,
2920 .save_gtk_cb = hdd_cm_save_gtk,
2921 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
2922 .roam_rt_stats_event_cb = wlan_hdd_cfg80211_roam_events_callback,
2923 #endif
2924 #ifdef WLAN_FEATURE_FILS_SK
2925 .set_hlp_data_cb = hdd_cm_set_hlp_data,
2926 #endif
2927 #ifdef WLAN_FEATURE_PREAUTH_ENABLE
2928 .ft_preauth_complete_cb = hdd_cm_ft_preauth_complete,
2929 #ifdef FEATURE_WLAN_ESE
2930 .cckm_preauth_complete_cb = hdd_cm_cckm_preauth_complete,
2931 #endif
2932 #endif
2933 #ifdef WLAN_VENDOR_HANDOFF_CONTROL
2934 .vendor_handoff_params_cb = hdd_cm_get_vendor_handoff_params,
2935 #endif
2936 .send_vdev_keys_cb = hdd_cm_send_vdev_keys,
2937 .get_scan_ie_params_cb = hdd_cm_get_scan_ie_params,
2938 #ifdef WLAN_BOOST_CPU_FREQ_IN_ROAM
2939 .perfd_set_cpufreq_cb = hdd_cm_perfd_set_cpufreq,
2940 #endif
2941 };
2942
hdd_cm_register_cb(void)2943 QDF_STATUS hdd_cm_register_cb(void)
2944 {
2945 QDF_STATUS status;
2946 osif_cm_set_legacy_cb(&osif_ops);
2947
2948 status = osif_cm_register_cb();
2949 if (QDF_IS_STATUS_ERROR(status))
2950 return status;
2951
2952 /* Overwrite with UTF cb if UTF enabled */
2953 return cm_utf_register_os_if_cb();
2954 }
2955
hdd_cm_unregister_cb(void)2956 void hdd_cm_unregister_cb(void)
2957 {
2958 osif_cm_reset_legacy_cb();
2959 }
2960