1 /* 2 * Copyright (c) 2011-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 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: csr_util.c 22 * 23 * Implementation supporting routines for CSR. 24 */ 25 26 #include "ani_global.h" 27 28 #include "csr_support.h" 29 #include "csr_inside_api.h" 30 #include "sme_qos_internal.h" 31 #include "wma_types.h" 32 #include "cds_utils.h" 33 #include "wlan_policy_mgr_api.h" 34 #include "wlan_serialization_legacy_api.h" 35 #include "wlan_reg_services_api.h" 36 #include "wlan_crypto_global_api.h" 37 #include "wlan_cm_roam_api.h" 38 #include <../../core/src/wlan_cm_vdev_api.h> 39 #include <wlan_mlo_mgr_public_structs.h> 40 #include "wlan_objmgr_vdev_obj.h" 41 #include "wlan_policy_mgr_ll_sap.h" 42 43 #define CASE_RETURN_STR(n) {\ 44 case (n): return (# n);\ 45 } 46 get_e_roam_cmd_status_str(eRoamCmdStatus val)47 const char *get_e_roam_cmd_status_str(eRoamCmdStatus val) 48 { 49 switch (val) { 50 CASE_RETURN_STR(eCSR_ROAM_LOSTLINK); 51 CASE_RETURN_STR(eCSR_ROAM_MIC_ERROR_IND); 52 CASE_RETURN_STR(eCSR_ROAM_SET_KEY_COMPLETE); 53 CASE_RETURN_STR(eCSR_ROAM_INFRA_IND); 54 CASE_RETURN_STR(eCSR_ROAM_WPS_PBC_PROBE_REQ_IND); 55 CASE_RETURN_STR(eCSR_ROAM_DISCONNECT_ALL_P2P_CLIENTS); 56 CASE_RETURN_STR(eCSR_ROAM_SEND_P2P_STOP_BSS); 57 CASE_RETURN_STR(eCSR_ROAM_UNPROT_MGMT_FRAME_IND); 58 #ifdef FEATURE_WLAN_ESE 59 CASE_RETURN_STR(eCSR_ROAM_TSM_IE_IND); 60 CASE_RETURN_STR(eCSR_ROAM_ESE_ADJ_AP_REPORT_IND); 61 CASE_RETURN_STR(eCSR_ROAM_ESE_BCN_REPORT_IND); 62 #endif /* FEATURE_WLAN_ESE */ 63 CASE_RETURN_STR(eCSR_ROAM_DFS_RADAR_IND); 64 CASE_RETURN_STR(eCSR_ROAM_SET_CHANNEL_RSP); 65 CASE_RETURN_STR(eCSR_ROAM_DFS_CHAN_SW_NOTIFY); 66 CASE_RETURN_STR(eCSR_ROAM_EXT_CHG_CHNL_IND); 67 CASE_RETURN_STR(eCSR_ROAM_STA_CHANNEL_SWITCH); 68 CASE_RETURN_STR(eCSR_ROAM_NDP_STATUS_UPDATE); 69 CASE_RETURN_STR(eCSR_ROAM_CHANNEL_COMPLETE_IND); 70 CASE_RETURN_STR(eCSR_ROAM_SAE_COMPUTE); 71 CASE_RETURN_STR(eCSR_ROAM_CHANNEL_INFO_EVENT_IND); 72 default: 73 return "unknown"; 74 } 75 } 76 get_e_csr_roam_result_str(eCsrRoamResult val)77 const char *get_e_csr_roam_result_str(eCsrRoamResult val) 78 { 79 switch (val) { 80 CASE_RETURN_STR(eCSR_ROAM_RESULT_NONE); 81 CASE_RETURN_STR(eCSR_ROAM_RESULT_FAILURE); 82 CASE_RETURN_STR(eCSR_ROAM_RESULT_ASSOCIATED); 83 CASE_RETURN_STR(eCSR_ROAM_RESULT_NOT_ASSOCIATED); 84 CASE_RETURN_STR(eCSR_ROAM_RESULT_MIC_FAILURE); 85 CASE_RETURN_STR(eCSR_ROAM_RESULT_FORCED); 86 CASE_RETURN_STR(eCSR_ROAM_RESULT_DISASSOC_IND); 87 CASE_RETURN_STR(eCSR_ROAM_RESULT_DEAUTH_IND); 88 CASE_RETURN_STR(eCSR_ROAM_RESULT_CAP_CHANGED); 89 CASE_RETURN_STR(eCSR_ROAM_RESULT_LOSTLINK); 90 CASE_RETURN_STR(eCSR_ROAM_RESULT_MIC_ERROR_UNICAST); 91 CASE_RETURN_STR(eCSR_ROAM_RESULT_MIC_ERROR_GROUP); 92 CASE_RETURN_STR(eCSR_ROAM_RESULT_AUTHENTICATED); 93 CASE_RETURN_STR(eCSR_ROAM_RESULT_NEW_RSN_BSS); 94 #ifdef FEATURE_WLAN_WAPI 95 CASE_RETURN_STR(eCSR_ROAM_RESULT_NEW_WAPI_BSS); 96 #endif /* FEATURE_WLAN_WAPI */ 97 CASE_RETURN_STR(eCSR_ROAM_RESULT_INFRA_STARTED); 98 CASE_RETURN_STR(eCSR_ROAM_RESULT_INFRA_START_FAILED); 99 CASE_RETURN_STR(eCSR_ROAM_RESULT_INFRA_STOPPED); 100 CASE_RETURN_STR(eCSR_ROAM_RESULT_INFRA_ASSOCIATION_IND); 101 CASE_RETURN_STR(eCSR_ROAM_RESULT_INFRA_ASSOCIATION_CNF); 102 CASE_RETURN_STR(eCSR_ROAM_RESULT_INFRA_DISASSOCIATED); 103 CASE_RETURN_STR(eCSR_ROAM_RESULT_WPS_PBC_PROBE_REQ_IND); 104 CASE_RETURN_STR(eCSR_ROAM_RESULT_SEND_ACTION_FAIL); 105 CASE_RETURN_STR(eCSR_ROAM_RESULT_MAX_ASSOC_EXCEEDED); 106 CASE_RETURN_STR(eCSR_ROAM_RESULT_ASSOC_FAIL_CON_CHANNEL); 107 CASE_RETURN_STR(eCSR_ROAM_RESULT_ADD_TDLS_PEER); 108 CASE_RETURN_STR(eCSR_ROAM_RESULT_UPDATE_TDLS_PEER); 109 CASE_RETURN_STR(eCSR_ROAM_RESULT_DELETE_TDLS_PEER); 110 CASE_RETURN_STR(eCSR_ROAM_RESULT_TEARDOWN_TDLS_PEER_IND); 111 CASE_RETURN_STR(eCSR_ROAM_RESULT_DELETE_ALL_TDLS_PEER_IND); 112 CASE_RETURN_STR(eCSR_ROAM_RESULT_LINK_ESTABLISH_REQ_RSP); 113 CASE_RETURN_STR(eCSR_ROAM_RESULT_TDLS_SHOULD_DISCOVER); 114 CASE_RETURN_STR(eCSR_ROAM_RESULT_TDLS_SHOULD_TEARDOWN); 115 CASE_RETURN_STR(eCSR_ROAM_RESULT_TDLS_SHOULD_PEER_DISCONNECTED); 116 CASE_RETURN_STR 117 (eCSR_ROAM_RESULT_TDLS_CONNECTION_TRACKER_NOTIFICATION); 118 CASE_RETURN_STR(eCSR_ROAM_RESULT_DFS_RADAR_FOUND_IND); 119 CASE_RETURN_STR(eCSR_ROAM_RESULT_CHANNEL_CHANGE_SUCCESS); 120 CASE_RETURN_STR(eCSR_ROAM_RESULT_CHANNEL_CHANGE_FAILURE); 121 CASE_RETURN_STR(eCSR_ROAM_RESULT_CSA_RESTART_RSP); 122 CASE_RETURN_STR(eCSR_ROAM_RESULT_DFS_CHANSW_UPDATE_SUCCESS); 123 CASE_RETURN_STR(eCSR_ROAM_EXT_CHG_CHNL_UPDATE_IND); 124 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDI_CREATE_RSP); 125 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDI_DELETE_RSP); 126 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_INITIATOR_RSP); 127 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_NEW_PEER_IND); 128 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_CONFIRM_IND); 129 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_INDICATION); 130 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_SCHED_UPDATE_RSP); 131 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_RESPONDER_RSP); 132 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_END_RSP); 133 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_PEER_DEPARTED_IND); 134 CASE_RETURN_STR(eCSR_ROAM_RESULT_NDP_END_IND); 135 CASE_RETURN_STR(eCSR_ROAM_RESULT_SCAN_FOR_SSID_FAILURE); 136 default: 137 return "unknown"; 138 } 139 } 140 csr_phy_mode_str(eCsrPhyMode phy_mode)141 const char *csr_phy_mode_str(eCsrPhyMode phy_mode) 142 { 143 switch (phy_mode) { 144 case eCSR_DOT11_MODE_abg: 145 return "abg"; 146 case eCSR_DOT11_MODE_11a: 147 return "11a"; 148 case eCSR_DOT11_MODE_11b: 149 return "11b"; 150 case eCSR_DOT11_MODE_11g: 151 return "11g"; 152 case eCSR_DOT11_MODE_11n: 153 return "11n"; 154 case eCSR_DOT11_MODE_11g_ONLY: 155 return "11g_only"; 156 case eCSR_DOT11_MODE_11n_ONLY: 157 return "11n_only"; 158 case eCSR_DOT11_MODE_11b_ONLY: 159 return "11b_only"; 160 case eCSR_DOT11_MODE_11ac: 161 return "11ac"; 162 case eCSR_DOT11_MODE_11ac_ONLY: 163 return "11ac_only"; 164 case eCSR_DOT11_MODE_AUTO: 165 return "auto"; 166 case eCSR_DOT11_MODE_11ax: 167 return "11ax"; 168 case eCSR_DOT11_MODE_11ax_ONLY: 169 return "11ax_only"; 170 case eCSR_DOT11_MODE_11be: 171 return "11be"; 172 case eCSR_DOT11_MODE_11be_ONLY: 173 return "11be_only"; 174 default: 175 return "unknown"; 176 } 177 } 178 csr_purge_pdev_all_ser_cmd_list(struct mac_context * mac_ctx)179 void csr_purge_pdev_all_ser_cmd_list(struct mac_context *mac_ctx) 180 { 181 wlan_serialization_purge_all_pdev_cmd(mac_ctx->pdev); 182 } 183 csr_nonscan_active_ll_peek_head(struct mac_context * mac_ctx,bool inter_locked)184 tListElem *csr_nonscan_active_ll_peek_head(struct mac_context *mac_ctx, 185 bool inter_locked) 186 { 187 struct wlan_serialization_command *cmd; 188 tSmeCmd *sme_cmd; 189 190 cmd = wlan_serialization_peek_head_active_cmd_using_psoc(mac_ctx->psoc, 191 false); 192 if (!cmd || cmd->source != WLAN_UMAC_COMP_MLME) 193 return NULL; 194 195 sme_cmd = cmd->umac_cmd; 196 197 return &sme_cmd->Link; 198 } 199 csr_nonscan_pending_ll_peek_head(struct mac_context * mac_ctx,bool inter_locked)200 tListElem *csr_nonscan_pending_ll_peek_head(struct mac_context *mac_ctx, 201 bool inter_locked) 202 { 203 struct wlan_serialization_command *cmd; 204 tSmeCmd *sme_cmd; 205 206 cmd = wlan_serialization_peek_head_pending_cmd_using_psoc(mac_ctx->psoc, 207 false); 208 while (cmd) { 209 if (cmd->source == WLAN_UMAC_COMP_MLME) { 210 sme_cmd = cmd->umac_cmd; 211 return &sme_cmd->Link; 212 } 213 cmd = wlan_serialization_get_pending_list_next_node_using_psoc( 214 mac_ctx->psoc, cmd, false); 215 } 216 217 return NULL; 218 } 219 csr_nonscan_active_ll_remove_entry(struct mac_context * mac_ctx,tListElem * entry,bool inter_locked)220 bool csr_nonscan_active_ll_remove_entry(struct mac_context *mac_ctx, 221 tListElem *entry, bool inter_locked) 222 { 223 tListElem *head; 224 225 head = csr_nonscan_active_ll_peek_head(mac_ctx, inter_locked); 226 if (head == entry) 227 return true; 228 229 return false; 230 } 231 csr_nonscan_pending_ll_next(struct mac_context * mac_ctx,tListElem * entry,bool inter_locked)232 tListElem *csr_nonscan_pending_ll_next(struct mac_context *mac_ctx, 233 tListElem *entry, bool inter_locked) 234 { 235 tSmeCmd *sme_cmd; 236 struct wlan_serialization_command cmd, *tcmd; 237 238 if (!entry) 239 return NULL; 240 sme_cmd = GET_BASE_ADDR(entry, tSmeCmd, Link); 241 cmd.cmd_id = sme_cmd->cmd_id; 242 cmd.cmd_type = csr_get_cmd_type(sme_cmd); 243 cmd.vdev = wlan_objmgr_get_vdev_by_id_from_psoc_no_state( 244 mac_ctx->psoc, 245 sme_cmd->vdev_id, WLAN_LEGACY_SME_ID); 246 tcmd = wlan_serialization_get_pending_list_next_node_using_psoc( 247 mac_ctx->psoc, &cmd, false); 248 if (cmd.vdev) 249 wlan_objmgr_vdev_release_ref(cmd.vdev, WLAN_LEGACY_SME_ID); 250 while (tcmd) { 251 if (tcmd->source == WLAN_UMAC_COMP_MLME) { 252 sme_cmd = tcmd->umac_cmd; 253 return &sme_cmd->Link; 254 } 255 tcmd = wlan_serialization_get_pending_list_next_node_using_psoc( 256 mac_ctx->psoc, tcmd, false); 257 } 258 259 return NULL; 260 } 261 csr_is_conn_state(struct mac_context * mac_ctx,uint32_t session_id,eCsrConnectState state)262 static bool csr_is_conn_state(struct mac_context *mac_ctx, uint32_t session_id, 263 eCsrConnectState state) 264 { 265 QDF_BUG(session_id < WLAN_MAX_VDEVS); 266 if (session_id >= WLAN_MAX_VDEVS) 267 return false; 268 269 return mac_ctx->roam.roamSession[session_id].connectState == state; 270 } 271 csr_is_conn_state_connected(struct mac_context * mac,uint32_t sessionId)272 bool csr_is_conn_state_connected(struct mac_context *mac, uint32_t sessionId) 273 { 274 return cm_is_vdevid_connected(mac->pdev, sessionId) || 275 csr_is_conn_state_connected_wds(mac, sessionId); 276 } 277 csr_is_conn_state_connected_wds(struct mac_context * mac_ctx,uint32_t session_id)278 bool csr_is_conn_state_connected_wds(struct mac_context *mac_ctx, 279 uint32_t session_id) 280 { 281 return csr_is_conn_state(mac_ctx, session_id, 282 eCSR_ASSOC_STATE_TYPE_WDS_CONNECTED); 283 } 284 csr_is_conn_state_connected_infra_ap(struct mac_context * mac_ctx,uint32_t session_id)285 bool csr_is_conn_state_connected_infra_ap(struct mac_context *mac_ctx, 286 uint32_t session_id) 287 { 288 return csr_is_conn_state(mac_ctx, session_id, 289 eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED) || 290 csr_is_conn_state(mac_ctx, session_id, 291 eCSR_ASSOC_STATE_TYPE_INFRA_DISCONNECTED); 292 } 293 csr_is_conn_state_disconnected_wds(struct mac_context * mac_ctx,uint32_t session_id)294 bool csr_is_conn_state_disconnected_wds(struct mac_context *mac_ctx, 295 uint32_t session_id) 296 { 297 return csr_is_conn_state(mac_ctx, session_id, 298 eCSR_ASSOC_STATE_TYPE_WDS_DISCONNECTED); 299 } 300 csr_is_conn_state_wds(struct mac_context * mac,uint32_t sessionId)301 bool csr_is_conn_state_wds(struct mac_context *mac, uint32_t sessionId) 302 { 303 return csr_is_conn_state_connected_wds(mac, sessionId) || 304 csr_is_conn_state_disconnected_wds(mac, sessionId); 305 } 306 cm_csr_get_vdev_dot11_mode(uint8_t vdev_id)307 uint16_t cm_csr_get_vdev_dot11_mode(uint8_t vdev_id) 308 { 309 mac_handle_t mac_handle; 310 struct mac_context *mac_ctx; 311 enum csr_cfgdot11mode curr_dot11_mode; 312 313 mac_handle = cds_get_context(QDF_MODULE_ID_SME); 314 mac_ctx = MAC_CONTEXT(mac_handle); 315 if (!mac_ctx) 316 return eCSR_CFG_DOT11_MODE_AUTO; 317 318 curr_dot11_mode = mac_ctx->roam.configParam.uCfgDot11Mode; 319 320 return csr_get_vdev_dot11_mode(mac_ctx, vdev_id, curr_dot11_mode); 321 } 322 323 enum csr_cfgdot11mode csr_get_vdev_dot11_mode(struct mac_context * mac,uint8_t vdev_id,enum csr_cfgdot11mode curr_dot11_mode)324 csr_get_vdev_dot11_mode(struct mac_context *mac, 325 uint8_t vdev_id, 326 enum csr_cfgdot11mode curr_dot11_mode) 327 { 328 struct wlan_objmgr_vdev *vdev; 329 struct vdev_mlme_obj *vdev_mlme; 330 enum mlme_vdev_dot11_mode vdev_dot11_mode; 331 enum csr_cfgdot11mode dot11_mode = curr_dot11_mode; 332 333 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, vdev_id, 334 WLAN_MLME_OBJMGR_ID); 335 if (!vdev) 336 return curr_dot11_mode; 337 338 vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev); 339 if (!vdev_mlme) { 340 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 341 return curr_dot11_mode; 342 } 343 344 vdev_dot11_mode = vdev_mlme->proto.vdev_dot11_mode; 345 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 346 347 if (vdev_dot11_mode == MLME_VDEV_DOT11_MODE_AUTO) 348 dot11_mode = curr_dot11_mode; 349 350 if (CSR_IS_DOT11_MODE_11N(curr_dot11_mode) && 351 vdev_dot11_mode == MLME_VDEV_DOT11_MODE_11N) 352 dot11_mode = eCSR_CFG_DOT11_MODE_11N; 353 354 if (CSR_IS_DOT11_MODE_11AC(curr_dot11_mode) && 355 vdev_dot11_mode == MLME_VDEV_DOT11_MODE_11AC) 356 dot11_mode = eCSR_CFG_DOT11_MODE_11AC; 357 358 if (CSR_IS_DOT11_MODE_11AX(curr_dot11_mode) && 359 vdev_dot11_mode == MLME_VDEV_DOT11_MODE_11AX) 360 dot11_mode = eCSR_CFG_DOT11_MODE_11AX; 361 #ifdef WLAN_FEATURE_11BE 362 if (CSR_IS_DOT11_MODE_11BE(curr_dot11_mode) && 363 vdev_dot11_mode == MLME_VDEV_DOT11_MODE_11BE) 364 dot11_mode = eCSR_CFG_DOT11_MODE_11BE; 365 #endif 366 sme_debug("INI vdev_dot11_mode %d new dot11_mode %d", 367 vdev_dot11_mode, dot11_mode); 368 369 return dot11_mode; 370 } 371 csr_is_conn_state_ap(struct mac_context * mac,uint32_t sessionId)372 static bool csr_is_conn_state_ap(struct mac_context *mac, uint32_t sessionId) 373 { 374 enum QDF_OPMODE opmode; 375 376 opmode = wlan_get_opmode_from_vdev_id(mac->pdev, sessionId); 377 if (opmode == QDF_SAP_MODE || opmode == QDF_P2P_GO_MODE) 378 return true; 379 380 return false; 381 } 382 csr_is_any_session_in_connect_state(struct mac_context * mac)383 bool csr_is_any_session_in_connect_state(struct mac_context *mac) 384 { 385 uint32_t i; 386 387 for (i = 0; i < WLAN_MAX_VDEVS; i++) { 388 if (CSR_IS_SESSION_VALID(mac, i) && 389 (cm_is_vdevid_connected(mac->pdev, i) || 390 csr_is_conn_state_ap(mac, i))) { 391 return true; 392 } 393 } 394 395 return false; 396 } 397 csr_get_concurrent_operation_freq(struct mac_context * mac_ctx)398 qdf_freq_t csr_get_concurrent_operation_freq(struct mac_context *mac_ctx) 399 { 400 uint8_t i = 0; 401 qdf_freq_t freq; 402 enum QDF_OPMODE op_mode; 403 404 for (i = 0; i < WLAN_MAX_VDEVS; i++) { 405 op_mode = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, i); 406 /* check only for STA, CLI, GO and SAP */ 407 if (op_mode != QDF_STA_MODE && op_mode != QDF_P2P_CLIENT_MODE && 408 op_mode != QDF_P2P_GO_MODE && op_mode != QDF_SAP_MODE) 409 continue; 410 411 freq = wlan_get_operation_chan_freq_vdev_id(mac_ctx->pdev, i); 412 if (!freq) 413 continue; 414 415 return freq; 416 } 417 418 return 0; 419 } 420 csr_get_beaconing_concurrent_channel(struct mac_context * mac_ctx,uint8_t vdev_id_to_skip)421 uint32_t csr_get_beaconing_concurrent_channel(struct mac_context *mac_ctx, 422 uint8_t vdev_id_to_skip) 423 { 424 struct csr_roam_session *session = NULL; 425 uint8_t i = 0; 426 enum QDF_OPMODE persona; 427 428 for (i = 0; i < WLAN_MAX_VDEVS; i++) { 429 if (i == vdev_id_to_skip) 430 continue; 431 if (!CSR_IS_SESSION_VALID(mac_ctx, i)) 432 continue; 433 session = CSR_GET_SESSION(mac_ctx, i); 434 persona = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, i); 435 if (((persona == QDF_P2P_GO_MODE) || 436 (persona == QDF_SAP_MODE)) && 437 (session->connectState != 438 eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED)) 439 return wlan_get_operation_chan_freq_vdev_id(mac_ctx->pdev, i); 440 } 441 442 return 0; 443 } 444 445 #ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH 446 447 #define HALF_BW_OF(eCSR_bw_val) ((eCSR_bw_val)/2) 448 449 /* calculation of center channel based on V/HT BW and WIFI channel bw=5MHz) */ 450 451 #define CSR_GET_HT40_PLUS_CCH(och) ((och) + 10) 452 #define CSR_GET_HT40_MINUS_CCH(och) ((och) - 10) 453 454 #define CSR_GET_HT80_PLUS_LL_CCH(och) ((och) + 30) 455 #define CSR_GET_HT80_PLUS_HL_CCH(och) ((och) + 30) 456 #define CSR_GET_HT80_MINUS_LH_CCH(och) ((och) - 10) 457 #define CSR_GET_HT80_MINUS_HH_CCH(och) ((och) - 30) 458 459 /** 460 * csr_calc_chb_for_sap_phymode() - to calc channel bandwidth for sap phymode 461 * @mac_ctx: pointer to mac context 462 * @sap_ch: SAP operating channel 463 * @sap_phymode: SAP physical mode 464 * @sap_cch: concurrency channel 465 * @sap_hbw: SAP half bw 466 * @chb: channel bandwidth 467 * 468 * This routine is called to calculate channel bandwidth 469 * 470 * Return: none 471 */ csr_calc_chb_for_sap_phymode(struct mac_context * mac_ctx,uint32_t * sap_ch,eCsrPhyMode * sap_phymode,uint32_t * sap_cch,uint32_t * sap_hbw,uint8_t * chb)472 static void csr_calc_chb_for_sap_phymode(struct mac_context *mac_ctx, 473 uint32_t *sap_ch, eCsrPhyMode *sap_phymode, 474 uint32_t *sap_cch, uint32_t *sap_hbw, uint8_t *chb) 475 { 476 if (*sap_phymode == eCSR_DOT11_MODE_11n || 477 *sap_phymode == eCSR_DOT11_MODE_11n_ONLY) { 478 479 *sap_hbw = HALF_BW_OF(eCSR_BW_40MHz_VAL); 480 if (*chb == PHY_DOUBLE_CHANNEL_LOW_PRIMARY) 481 *sap_cch = CSR_GET_HT40_PLUS_CCH(*sap_ch); 482 else if (*chb == PHY_DOUBLE_CHANNEL_HIGH_PRIMARY) 483 *sap_cch = CSR_GET_HT40_MINUS_CCH(*sap_ch); 484 485 } else if (*sap_phymode == eCSR_DOT11_MODE_11ac || 486 *sap_phymode == eCSR_DOT11_MODE_11ac_ONLY || 487 *sap_phymode == eCSR_DOT11_MODE_11ax || 488 *sap_phymode == eCSR_DOT11_MODE_11ax_ONLY || 489 CSR_IS_DOT11_PHY_MODE_11BE(*sap_phymode) || 490 CSR_IS_DOT11_PHY_MODE_11BE_ONLY(*sap_phymode)) { 491 /*11AC only 80/40/20 Mhz supported in Rome */ 492 if (mac_ctx->roam.configParam.nVhtChannelWidth == 493 (WNI_CFG_VHT_CHANNEL_WIDTH_80MHZ + 1)) { 494 *sap_hbw = HALF_BW_OF(eCSR_BW_80MHz_VAL); 495 if (*chb == 496 (PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW - 1)) 497 *sap_cch = CSR_GET_HT80_PLUS_LL_CCH(*sap_ch); 498 else if (*chb == 499 (PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW 500 - 1)) 501 *sap_cch = CSR_GET_HT80_PLUS_HL_CCH(*sap_ch); 502 else if (*chb == 503 (PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH 504 - 1)) 505 *sap_cch = CSR_GET_HT80_MINUS_LH_CCH(*sap_ch); 506 else if (*chb == 507 (PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH 508 - 1)) 509 *sap_cch = CSR_GET_HT80_MINUS_HH_CCH(*sap_ch); 510 } else { 511 *sap_hbw = HALF_BW_OF(eCSR_BW_40MHz_VAL); 512 if (*chb == (PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW 513 - 1)) 514 *sap_cch = CSR_GET_HT40_PLUS_CCH(*sap_ch); 515 else if (*chb == 516 (PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW 517 - 1)) 518 *sap_cch = CSR_GET_HT40_MINUS_CCH(*sap_ch); 519 else if (*chb == 520 (PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH 521 - 1)) 522 *sap_cch = CSR_GET_HT40_PLUS_CCH(*sap_ch); 523 else if (*chb == 524 (PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH 525 - 1)) 526 *sap_cch = CSR_GET_HT40_MINUS_CCH(*sap_ch); 527 } 528 } 529 } 530 csr_get_half_bw(enum phy_ch_width ch_width)531 static eCSR_BW_Val csr_get_half_bw(enum phy_ch_width ch_width) 532 { 533 eCSR_BW_Val hw_bw = HALF_BW_OF(eCSR_BW_20MHz_VAL); 534 535 switch (ch_width) { 536 case CH_WIDTH_40MHZ: 537 hw_bw = HALF_BW_OF(eCSR_BW_40MHz_VAL); 538 break; 539 case CH_WIDTH_80MHZ: 540 hw_bw = HALF_BW_OF(eCSR_BW_80MHz_VAL); 541 break; 542 case CH_WIDTH_160MHZ: 543 case CH_WIDTH_80P80MHZ: 544 hw_bw = HALF_BW_OF(eCSR_BW_160MHz_VAL); 545 break; 546 default: 547 break; 548 } 549 550 return hw_bw; 551 } 552 553 /** 554 * csr_handle_conc_chnl_overlap_for_sap_go - To handle overlap for AP+AP 555 * @mac_ctx: pointer to mac context 556 * @session: Current session 557 * @sap_ch_freq: SAP/GO operating channel frequency 558 * @sap_hbw: SAP/GO half bw 559 * @sap_cfreq: SAP/GO channel frequency 560 * @intf_ch_freq: concurrent SAP/GO operating channel frequency 561 * @intf_hbw: concurrent SAP/GO half bw 562 * @intf_cfreq: concurrent SAP/GO channel frequency 563 * @op_mode: opmode 564 * 565 * This routine is called to check if one SAP/GO channel is overlapping with 566 * other SAP/GO channel 567 * 568 * Return: none 569 */ csr_handle_conc_chnl_overlap_for_sap_go(struct mac_context * mac_ctx,struct csr_roam_session * session,uint32_t * sap_ch_freq,uint32_t * sap_hbw,uint32_t * sap_cfreq,uint32_t * intf_ch_freq,uint32_t * intf_hbw,uint32_t * intf_cfreq,enum QDF_OPMODE op_mode,uint8_t cc_switch_mode)570 static void csr_handle_conc_chnl_overlap_for_sap_go( 571 struct mac_context *mac_ctx, 572 struct csr_roam_session *session, 573 uint32_t *sap_ch_freq, uint32_t *sap_hbw, uint32_t *sap_cfreq, 574 uint32_t *intf_ch_freq, uint32_t *intf_hbw, 575 uint32_t *intf_cfreq, enum QDF_OPMODE op_mode, 576 uint8_t cc_switch_mode) 577 { 578 qdf_freq_t op_chan_freq; 579 qdf_freq_t freq_seg_0; 580 enum phy_ch_width ch_width; 581 582 wlan_get_op_chan_freq_info_vdev_id(mac_ctx->pdev, session->vdev_id, 583 &op_chan_freq, &freq_seg_0, 584 &ch_width); 585 sme_debug("op_chan_freq:%d freq_seg_0:%d ch_width:%d", 586 op_chan_freq, freq_seg_0, ch_width); 587 /* 588 * if conc_custom_rule1 is defined then we don't 589 * want p2pgo to follow SAP's channel or SAP to 590 * follow P2PGO's channel. 591 */ 592 if (0 == mac_ctx->roam.configParam.conc_custom_rule1 && 593 0 == mac_ctx->roam.configParam.conc_custom_rule2) { 594 if (*sap_ch_freq == 0) { 595 *sap_ch_freq = op_chan_freq; 596 *sap_cfreq = freq_seg_0; 597 *sap_hbw = csr_get_half_bw(ch_width); 598 } else if (*sap_ch_freq != op_chan_freq || 599 (cc_switch_mode == 600 QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL && 601 op_mode == QDF_P2P_GO_MODE)) { 602 *intf_ch_freq = op_chan_freq; 603 *intf_cfreq = freq_seg_0; 604 *intf_hbw = csr_get_half_bw(ch_width); 605 } 606 } else if (*sap_ch_freq == 0 && op_mode == QDF_SAP_MODE) { 607 *sap_ch_freq = op_chan_freq; 608 *sap_cfreq = freq_seg_0; 609 *sap_hbw = csr_get_half_bw(ch_width); 610 } 611 } 612 csr_check_concurrent_channel_overlap(struct mac_context * mac_ctx,uint32_t sap_ch_freq,eCsrPhyMode sap_phymode,uint8_t cc_switch_mode,uint8_t vdev_id)613 uint16_t csr_check_concurrent_channel_overlap(struct mac_context *mac_ctx, 614 uint32_t sap_ch_freq, eCsrPhyMode sap_phymode, 615 uint8_t cc_switch_mode, uint8_t vdev_id) 616 { 617 struct csr_roam_session *session = NULL; 618 uint8_t i = 0, chb = PHY_SINGLE_CHANNEL_CENTERED; 619 uint32_t intf_ch_freq = 0, sap_hbw = 0, intf_hbw = 0, intf_cfreq = 0; 620 uint32_t sap_cfreq = 0; 621 uint32_t sap_lfreq, sap_hfreq, intf_lfreq, intf_hfreq; 622 QDF_STATUS status; 623 enum QDF_OPMODE op_mode; 624 enum phy_ch_width ch_width; 625 enum channel_state state; 626 627 #ifdef WLAN_FEATURE_LL_LT_SAP 628 qdf_freq_t new_sap_freq = 0; 629 bool is_ll_lt_sap_present = false; 630 #endif 631 632 if (mac_ctx->roam.configParam.cc_switch_mode == 633 QDF_MCC_TO_SCC_SWITCH_DISABLE) 634 return 0; 635 636 /* 637 * This is temporary code and will be removed once this feature flag 638 * is enabled 639 */ 640 #ifndef WLAN_FEATURE_LL_LT_SAP 641 if (policy_mgr_is_vdev_ll_lt_sap(mac_ctx->psoc, vdev_id)) 642 return 0; 643 #else 644 policy_mgr_ll_lt_sap_get_valid_freq( 645 mac_ctx->psoc, mac_ctx->pdev, 646 vdev_id, sap_ch_freq, 647 mac_ctx->roam.configParam.cc_switch_mode, 648 &new_sap_freq, 649 &is_ll_lt_sap_present); 650 /* 651 * If ll_lt_sap is present, then it has already updated the frequency 652 * according to current concurrency, so, return from here 653 */ 654 if (is_ll_lt_sap_present) { 655 if (new_sap_freq == sap_ch_freq) 656 return 0; 657 658 sme_debug("LL_LT_SAP concurrency updated freq %d for vdev %d", 659 new_sap_freq, vdev_id); 660 return new_sap_freq; 661 } 662 #endif 663 664 if (sap_ch_freq != 0) { 665 sap_cfreq = sap_ch_freq; 666 sap_hbw = HALF_BW_OF(eCSR_BW_20MHz_VAL); 667 668 if (!WLAN_REG_IS_24GHZ_CH_FREQ(sap_ch_freq)) 669 chb = mac_ctx->roam.configParam.channelBondingMode5GHz; 670 else 671 chb = mac_ctx->roam.configParam.channelBondingMode24GHz; 672 673 if (chb) 674 csr_calc_chb_for_sap_phymode(mac_ctx, &sap_ch_freq, 675 &sap_phymode, &sap_cfreq, 676 &sap_hbw, &chb); 677 } 678 679 sme_debug("sap_ch:%d sap_phymode:%d sap_cch:%d sap_hbw:%d chb:%d", 680 sap_ch_freq, sap_phymode, sap_cfreq, sap_hbw, chb); 681 682 for (i = 0; i < WLAN_MAX_VDEVS; i++) { 683 if (!CSR_IS_SESSION_VALID(mac_ctx, i)) 684 continue; 685 686 session = CSR_GET_SESSION(mac_ctx, i); 687 op_mode = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, i); 688 if ((op_mode == QDF_STA_MODE || 689 op_mode == QDF_P2P_CLIENT_MODE) && 690 cm_is_vdevid_connected(mac_ctx->pdev, i)) { 691 if (op_mode == QDF_STA_MODE && 692 policy_mgr_is_ml_vdev_id(mac_ctx->psoc, 693 session->vdev_id) && 694 policy_mgr_vdev_is_force_inactive( 695 mac_ctx->psoc, 696 session->vdev_id)) { 697 sme_debug("skip inactive ml sta vdev %d", 698 session->vdev_id); 699 continue; 700 } 701 wlan_get_op_chan_freq_info_vdev_id(mac_ctx->pdev, 702 session->vdev_id, 703 &intf_ch_freq, &intf_cfreq, 704 &ch_width); 705 intf_hbw = csr_get_half_bw(ch_width); 706 sme_debug("%d: intf_ch:%d intf_cfreq:%d intf_hbw:%d ch_width %d", 707 i, intf_ch_freq, intf_cfreq, intf_hbw, 708 ch_width); 709 } else if ((op_mode == QDF_P2P_GO_MODE || 710 op_mode == QDF_SAP_MODE) && 711 (session->connectState != 712 eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED)) { 713 714 if (session->ch_switch_in_progress) 715 continue; 716 717 csr_handle_conc_chnl_overlap_for_sap_go(mac_ctx, 718 session, &sap_ch_freq, &sap_hbw, 719 &sap_cfreq, &intf_ch_freq, &intf_hbw, 720 &intf_cfreq, op_mode, 721 cc_switch_mode); 722 } 723 724 if (intf_ch_freq) { 725 state = wlan_reg_get_channel_state_for_pwrmode( 726 mac_ctx->pdev, intf_ch_freq, 727 REG_CURRENT_PWR_MODE); 728 if (state == CHANNEL_STATE_DISABLE || 729 state == CHANNEL_STATE_INVALID) { 730 sme_debug("skip vdev %d for intf_ch:%d", 731 i, intf_ch_freq); 732 intf_ch_freq = 0; 733 continue; 734 } 735 } 736 737 if (intf_ch_freq && 738 ((intf_ch_freq <= wlan_reg_ch_to_freq(CHAN_ENUM_2484) && 739 sap_ch_freq <= wlan_reg_ch_to_freq(CHAN_ENUM_2484)) || 740 (intf_ch_freq > wlan_reg_ch_to_freq(CHAN_ENUM_2484) && 741 sap_ch_freq > wlan_reg_ch_to_freq(CHAN_ENUM_2484)))) 742 break; 743 } 744 745 sme_debug("intf_ch:%d sap_ch:%d cc_switch_mode:%d, dbs:%d", 746 intf_ch_freq, sap_ch_freq, cc_switch_mode, 747 policy_mgr_is_hw_dbs_capable(mac_ctx->psoc)); 748 749 if (intf_ch_freq && sap_ch_freq != intf_ch_freq && 750 !policy_mgr_is_force_scc(mac_ctx->psoc)) { 751 sap_lfreq = sap_cfreq - sap_hbw; 752 sap_hfreq = sap_cfreq + sap_hbw; 753 intf_lfreq = intf_cfreq - intf_hbw; 754 intf_hfreq = intf_cfreq + intf_hbw; 755 756 sme_debug("SAP: OCH: %03d CCH: %03d BW: %d LF: %d HF: %d INTF: OCH: %03d CF: %d BW: %d LF: %d HF: %d", 757 sap_ch_freq, sap_cfreq, sap_hbw * 2, 758 sap_lfreq, sap_hfreq, intf_ch_freq, 759 intf_cfreq, intf_hbw * 2, intf_lfreq, intf_hfreq); 760 761 if (!(((sap_lfreq > intf_lfreq && sap_lfreq < intf_hfreq) || 762 (sap_hfreq > intf_lfreq && sap_hfreq < intf_hfreq)) || 763 ((intf_lfreq > sap_lfreq && intf_lfreq < sap_hfreq) || 764 (intf_hfreq > sap_lfreq && intf_hfreq < sap_hfreq)))) 765 intf_ch_freq = 0; 766 } else if (intf_ch_freq && sap_ch_freq != intf_ch_freq && 767 (policy_mgr_is_force_scc(mac_ctx->psoc))) { 768 policy_mgr_check_scc_channel(mac_ctx->psoc, &intf_ch_freq, 769 sap_ch_freq, vdev_id, 770 cc_switch_mode); 771 } else if ((intf_ch_freq == sap_ch_freq) && (cc_switch_mode == 772 QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)) { 773 status = policy_mgr_handle_go_sap_fav_channel( 774 mac_ctx->psoc, vdev_id, 775 sap_ch_freq, &intf_ch_freq); 776 if (QDF_IS_STATUS_SUCCESS(status) && 777 intf_ch_freq && intf_ch_freq != sap_ch_freq) 778 goto end; 779 780 if (WLAN_REG_IS_24GHZ_CH_FREQ(intf_ch_freq) || 781 WLAN_REG_IS_6GHZ_CHAN_FREQ(sap_ch_freq)) { 782 status = 783 policy_mgr_get_sap_mandatory_channel( 784 mac_ctx->psoc, sap_ch_freq, 785 &intf_ch_freq, vdev_id); 786 if (QDF_IS_STATUS_ERROR(status)) 787 sme_err("no mandatory channel"); 788 } 789 } 790 end: 791 if (intf_ch_freq == sap_ch_freq) 792 intf_ch_freq = 0; 793 794 sme_debug("##Concurrent Channels (%d, %d) %s Interfering", sap_ch_freq, 795 intf_ch_freq, 796 intf_ch_freq == 0 ? "Not" : "Are"); 797 798 return intf_ch_freq; 799 } 800 #endif 801 csr_is_all_session_disconnected(struct mac_context * mac)802 bool csr_is_all_session_disconnected(struct mac_context *mac) 803 { 804 uint32_t i; 805 bool fRc = true; 806 807 for (i = 0; i < WLAN_MAX_VDEVS; i++) { 808 if (CSR_IS_SESSION_VALID(mac, i) 809 && !csr_is_conn_state_disconnected(mac, i)) { 810 fRc = false; 811 break; 812 } 813 } 814 815 return fRc; 816 } 817 csr_is_infra_ap_started(struct mac_context * mac)818 bool csr_is_infra_ap_started(struct mac_context *mac) 819 { 820 uint32_t sessionId; 821 bool fRc = false; 822 823 for (sessionId = 0; sessionId < WLAN_MAX_VDEVS; sessionId++) { 824 if (CSR_IS_SESSION_VALID(mac, sessionId) && 825 (csr_is_conn_state_connected_infra_ap(mac, 826 sessionId))) { 827 fRc = true; 828 break; 829 } 830 } 831 832 return fRc; 833 834 } 835 csr_is_conn_state_disconnected(struct mac_context * mac,uint8_t vdev_id)836 bool csr_is_conn_state_disconnected(struct mac_context *mac, uint8_t vdev_id) 837 { 838 enum QDF_OPMODE opmode; 839 840 opmode = wlan_get_opmode_from_vdev_id(mac->pdev, vdev_id); 841 842 if (opmode == QDF_STA_MODE || opmode == QDF_P2P_CLIENT_MODE) 843 return !cm_is_vdevid_connected(mac->pdev, vdev_id); 844 845 return eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED == 846 mac->roam.roamSession[vdev_id].connectState; 847 } 848 csr_is11h_supported(struct mac_context * mac)849 bool csr_is11h_supported(struct mac_context *mac) 850 { 851 return mac->mlme_cfg->gen.enabled_11h; 852 } 853 csr_is_wmm_supported(struct mac_context * mac)854 bool csr_is_wmm_supported(struct mac_context *mac) 855 { 856 if (WMM_USER_MODE_NO_QOS == mac->roam.configParam.WMMSupportMode) 857 return false; 858 else 859 return true; 860 } 861 862 /* This function will allocate memory for the parsed IEs to the caller. 863 * Caller must free the memory after it is done with the data only if 864 * this function succeeds 865 */ csr_get_parsed_bss_description_ies(struct mac_context * mac_ctx,struct bss_description * bss_desc,tDot11fBeaconIEs ** ppIEStruct)866 QDF_STATUS csr_get_parsed_bss_description_ies(struct mac_context *mac_ctx, 867 struct bss_description *bss_desc, 868 tDot11fBeaconIEs **ppIEStruct) 869 { 870 return wlan_get_parsed_bss_description_ies(mac_ctx, bss_desc, 871 ppIEStruct); 872 } 873 csr_get_frag_thresh(struct mac_context * mac_ctx)874 uint32_t csr_get_frag_thresh(struct mac_context *mac_ctx) 875 { 876 return mac_ctx->mlme_cfg->threshold.frag_threshold; 877 } 878 csr_get_rts_thresh(struct mac_context * mac_ctx)879 uint32_t csr_get_rts_thresh(struct mac_context *mac_ctx) 880 { 881 return mac_ctx->mlme_cfg->threshold.rts_threshold; 882 } 883 csr_translate_to_wni_cfg_dot11_mode(struct mac_context * mac,enum csr_cfgdot11mode csrDot11Mode)884 uint32_t csr_translate_to_wni_cfg_dot11_mode(struct mac_context *mac, 885 enum csr_cfgdot11mode csrDot11Mode) 886 { 887 uint32_t ret; 888 889 switch (csrDot11Mode) { 890 case eCSR_CFG_DOT11_MODE_AUTO: 891 #ifdef WLAN_FEATURE_11BE 892 if (IS_FEATURE_11BE_SUPPORTED_BY_FW) 893 ret = MLME_DOT11_MODE_11BE; 894 else 895 #endif 896 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 897 ret = MLME_DOT11_MODE_11AX; 898 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 899 ret = MLME_DOT11_MODE_11AC; 900 else 901 ret = MLME_DOT11_MODE_11N; 902 break; 903 case eCSR_CFG_DOT11_MODE_11A: 904 ret = MLME_DOT11_MODE_11A; 905 break; 906 case eCSR_CFG_DOT11_MODE_11B: 907 ret = MLME_DOT11_MODE_11B; 908 break; 909 case eCSR_CFG_DOT11_MODE_11G: 910 ret = MLME_DOT11_MODE_11G; 911 break; 912 case eCSR_CFG_DOT11_MODE_11N: 913 ret = MLME_DOT11_MODE_11N; 914 break; 915 case eCSR_CFG_DOT11_MODE_11G_ONLY: 916 ret = MLME_DOT11_MODE_11G_ONLY; 917 break; 918 case eCSR_CFG_DOT11_MODE_11N_ONLY: 919 ret = MLME_DOT11_MODE_11N_ONLY; 920 break; 921 case eCSR_CFG_DOT11_MODE_11AC_ONLY: 922 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 923 ret = MLME_DOT11_MODE_11AC_ONLY; 924 else 925 ret = MLME_DOT11_MODE_11N; 926 break; 927 case eCSR_CFG_DOT11_MODE_11AC: 928 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 929 ret = MLME_DOT11_MODE_11AC; 930 else 931 ret = MLME_DOT11_MODE_11N; 932 break; 933 case eCSR_CFG_DOT11_MODE_11AX_ONLY: 934 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 935 ret = MLME_DOT11_MODE_11AX_ONLY; 936 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 937 ret = MLME_DOT11_MODE_11AC; 938 else 939 ret = MLME_DOT11_MODE_11N; 940 break; 941 case eCSR_CFG_DOT11_MODE_11AX: 942 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 943 ret = MLME_DOT11_MODE_11AX; 944 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 945 ret = MLME_DOT11_MODE_11AC; 946 else 947 ret = MLME_DOT11_MODE_11N; 948 break; 949 #ifdef WLAN_FEATURE_11BE 950 case eCSR_CFG_DOT11_MODE_11BE_ONLY: 951 if (IS_FEATURE_11BE_SUPPORTED_BY_FW) 952 ret = MLME_DOT11_MODE_11BE_ONLY; 953 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 954 ret = MLME_DOT11_MODE_11AX_ONLY; 955 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 956 ret = MLME_DOT11_MODE_11AC; 957 else 958 ret = MLME_DOT11_MODE_11N; 959 break; 960 case eCSR_CFG_DOT11_MODE_11BE: 961 if (IS_FEATURE_11BE_SUPPORTED_BY_FW) 962 ret = MLME_DOT11_MODE_11BE; 963 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 964 ret = MLME_DOT11_MODE_11AX; 965 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 966 ret = MLME_DOT11_MODE_11AC; 967 else 968 ret = MLME_DOT11_MODE_11N; 969 break; 970 #endif 971 case eCSR_CFG_DOT11_MODE_ABG: 972 ret = MLME_DOT11_MODE_ABG; 973 break; 974 default: 975 sme_warn("doesn't expect %d as csrDo11Mode", csrDot11Mode); 976 ret = MLME_DOT11_MODE_ALL; 977 break; 978 } 979 980 return ret; 981 } 982 csr_convert_to_reg_phy_mode(eCsrPhyMode csr_phy_mode,qdf_freq_t freq)983 enum reg_phymode csr_convert_to_reg_phy_mode(eCsrPhyMode csr_phy_mode, 984 qdf_freq_t freq) 985 { 986 if (csr_phy_mode == eCSR_DOT11_MODE_AUTO) 987 return REG_PHYMODE_MAX - 1; 988 #ifdef WLAN_FEATURE_11BE 989 else if (CSR_IS_DOT11_PHY_MODE_11BE(csr_phy_mode) || 990 CSR_IS_DOT11_PHY_MODE_11BE_ONLY(csr_phy_mode)) 991 return REG_PHYMODE_11BE; 992 #endif 993 else if (csr_phy_mode == eCSR_DOT11_MODE_11ax || 994 csr_phy_mode == eCSR_DOT11_MODE_11ax_ONLY) 995 return REG_PHYMODE_11AX; 996 else if (csr_phy_mode == eCSR_DOT11_MODE_11ac || 997 csr_phy_mode == eCSR_DOT11_MODE_11ac_ONLY) 998 return REG_PHYMODE_11AC; 999 else if (csr_phy_mode == eCSR_DOT11_MODE_11n || 1000 csr_phy_mode == eCSR_DOT11_MODE_11n_ONLY) 1001 return REG_PHYMODE_11N; 1002 else if (csr_phy_mode == eCSR_DOT11_MODE_11a) 1003 return REG_PHYMODE_11A; 1004 else if (csr_phy_mode == eCSR_DOT11_MODE_11g || 1005 csr_phy_mode == eCSR_DOT11_MODE_11g_ONLY) 1006 return REG_PHYMODE_11G; 1007 else if (csr_phy_mode == eCSR_DOT11_MODE_11b || 1008 csr_phy_mode == eCSR_DOT11_MODE_11b_ONLY) 1009 return REG_PHYMODE_11B; 1010 else if (csr_phy_mode == eCSR_DOT11_MODE_abg) { 1011 if (WLAN_REG_IS_24GHZ_CH_FREQ(freq)) 1012 return REG_PHYMODE_11G; 1013 else 1014 return REG_PHYMODE_11A; 1015 } else { 1016 sme_err("Invalid eCsrPhyMode"); 1017 return REG_PHYMODE_INVALID; 1018 } 1019 } 1020 csr_convert_from_reg_phy_mode(enum reg_phymode phymode)1021 eCsrPhyMode csr_convert_from_reg_phy_mode(enum reg_phymode phymode) 1022 { 1023 switch (phymode) { 1024 case REG_PHYMODE_INVALID: 1025 return eCSR_DOT11_MODE_AUTO; 1026 case REG_PHYMODE_11B: 1027 return eCSR_DOT11_MODE_11b; 1028 case REG_PHYMODE_11G: 1029 return eCSR_DOT11_MODE_11g; 1030 case REG_PHYMODE_11A: 1031 return eCSR_DOT11_MODE_11a; 1032 case REG_PHYMODE_11N: 1033 return eCSR_DOT11_MODE_11n; 1034 case REG_PHYMODE_11AC: 1035 return eCSR_DOT11_MODE_11ac; 1036 case REG_PHYMODE_11AX: 1037 return eCSR_DOT11_MODE_11ax; 1038 #ifdef WLAN_FEATURE_11BE 1039 case REG_PHYMODE_11BE: 1040 return eCSR_DOT11_MODE_11be; 1041 #endif 1042 case REG_PHYMODE_MAX: 1043 return eCSR_DOT11_MODE_AUTO; 1044 default: 1045 return eCSR_DOT11_MODE_AUTO; 1046 } 1047 } 1048 csr_is_auth_type_ese(enum csr_akm_type AuthType)1049 bool csr_is_auth_type_ese(enum csr_akm_type AuthType) 1050 { 1051 switch (AuthType) { 1052 case eCSR_AUTH_TYPE_CCKM_WPA: 1053 case eCSR_AUTH_TYPE_CCKM_RSN: 1054 return true; 1055 default: 1056 break; 1057 } 1058 return false; 1059 } 1060 csr_is_pmkid_found_for_peer(struct mac_context * mac,struct csr_roam_session * session,tSirMacAddr peer_mac_addr,uint8_t * pmkid,uint16_t pmkid_count)1061 bool csr_is_pmkid_found_for_peer(struct mac_context *mac, 1062 struct csr_roam_session *session, 1063 tSirMacAddr peer_mac_addr, 1064 uint8_t *pmkid, 1065 uint16_t pmkid_count) 1066 { 1067 uint32_t i; 1068 uint8_t *session_pmkid; 1069 struct wlan_crypto_pmksa *pmkid_cache; 1070 1071 pmkid_cache = qdf_mem_malloc(sizeof(*pmkid_cache)); 1072 if (!pmkid_cache) 1073 return false; 1074 1075 qdf_mem_copy(pmkid_cache->bssid.bytes, peer_mac_addr, 1076 QDF_MAC_ADDR_SIZE); 1077 1078 if (!cm_lookup_pmkid_using_bssid(mac->psoc, session->vdev_id, 1079 pmkid_cache)) { 1080 qdf_mem_free(pmkid_cache); 1081 return false; 1082 } 1083 1084 session_pmkid = pmkid_cache->pmkid; 1085 for (i = 0; i < pmkid_count; i++) { 1086 if (!qdf_mem_cmp(pmkid + (i * PMKID_LEN), 1087 session_pmkid, PMKID_LEN)) { 1088 qdf_mem_free(pmkid_cache); 1089 return true; 1090 } 1091 } 1092 1093 sme_debug("PMKID in PmkidCacheInfo doesn't match with PMKIDs of peer"); 1094 qdf_mem_free(pmkid_cache); 1095 1096 return false; 1097 } 1098 csr_is_bssid_match(struct qdf_mac_addr * pProfBssid,struct qdf_mac_addr * BssBssid)1099 bool csr_is_bssid_match(struct qdf_mac_addr *pProfBssid, 1100 struct qdf_mac_addr *BssBssid) 1101 { 1102 bool fMatch = false; 1103 struct qdf_mac_addr ProfileBssid; 1104 1105 /* for efficiency of the MAC_ADDRESS functions, move the */ 1106 /* Bssid's into MAC_ADDRESS structs. */ 1107 qdf_mem_copy(&ProfileBssid, pProfBssid, sizeof(struct qdf_mac_addr)); 1108 1109 do { 1110 /* Give the profile the benefit of the doubt... accept 1111 * either all 0 or the real broadcast Bssid (all 0xff) 1112 * as broadcast Bssids (meaning to match any Bssids). 1113 */ 1114 if (qdf_is_macaddr_zero(&ProfileBssid) || 1115 qdf_is_macaddr_broadcast(&ProfileBssid)) { 1116 fMatch = true; 1117 break; 1118 } 1119 1120 if (qdf_is_macaddr_equal(BssBssid, &ProfileBssid)) { 1121 fMatch = true; 1122 break; 1123 } 1124 1125 } while (0); 1126 1127 return fMatch; 1128 } 1129 1130 /* This function use the parameters to decide the CFG value. */ 1131 /* CSR never sets MLME_DOT11_MODE_ALL to the CFG */ 1132 /* So PE should not see MLME_DOT11_MODE_ALL when it gets the CFG value */ 1133 enum csr_cfgdot11mode csr_get_cfg_dot11_mode_from_csr_phy_mode(bool is_ap,eCsrPhyMode phyMode)1134 csr_get_cfg_dot11_mode_from_csr_phy_mode(bool is_ap, eCsrPhyMode phyMode) 1135 { 1136 uint32_t cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG; 1137 1138 switch (phyMode) { 1139 case eCSR_DOT11_MODE_11a: 1140 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11A; 1141 break; 1142 case eCSR_DOT11_MODE_11b: 1143 case eCSR_DOT11_MODE_11b_ONLY: 1144 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11B; 1145 break; 1146 case eCSR_DOT11_MODE_11g: 1147 case eCSR_DOT11_MODE_11g_ONLY: 1148 if (is_ap && (phyMode == eCSR_DOT11_MODE_11g_ONLY)) 1149 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G_ONLY; 1150 else 1151 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11G; 1152 break; 1153 case eCSR_DOT11_MODE_11n: 1154 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1155 break; 1156 case eCSR_DOT11_MODE_11n_ONLY: 1157 if (is_ap) 1158 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N_ONLY; 1159 else 1160 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1161 break; 1162 case eCSR_DOT11_MODE_abg: 1163 cfgDot11Mode = eCSR_CFG_DOT11_MODE_ABG; 1164 break; 1165 case eCSR_DOT11_MODE_AUTO: 1166 cfgDot11Mode = eCSR_CFG_DOT11_MODE_AUTO; 1167 break; 1168 1169 case eCSR_DOT11_MODE_11ac: 1170 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 1171 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC; 1172 else 1173 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1174 break; 1175 case eCSR_DOT11_MODE_11ac_ONLY: 1176 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 1177 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC_ONLY; 1178 else 1179 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1180 break; 1181 case eCSR_DOT11_MODE_11ax: 1182 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 1183 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AX; 1184 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 1185 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC; 1186 else 1187 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1188 break; 1189 case eCSR_DOT11_MODE_11ax_ONLY: 1190 if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 1191 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AX_ONLY; 1192 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 1193 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC; 1194 else 1195 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1196 break; 1197 #ifdef WLAN_FEATURE_11BE 1198 case eCSR_DOT11_MODE_11be: 1199 if (IS_FEATURE_11BE_SUPPORTED_BY_FW) 1200 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11BE; 1201 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 1202 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AX; 1203 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 1204 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC; 1205 else 1206 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1207 break; 1208 case eCSR_DOT11_MODE_11be_ONLY: 1209 if (IS_FEATURE_11BE_SUPPORTED_BY_FW) 1210 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11BE_ONLY; 1211 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) 1212 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AX_ONLY; 1213 else if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AC)) 1214 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11AC; 1215 else 1216 cfgDot11Mode = eCSR_CFG_DOT11_MODE_11N; 1217 break; 1218 #endif 1219 default: 1220 /* No need to assign anything here */ 1221 break; 1222 } 1223 1224 return cfgDot11Mode; 1225 } 1226 csr_get_modify_profile_fields(struct mac_context * mac,uint32_t sessionId,tCsrRoamModifyProfileFields * pModifyProfileFields)1227 QDF_STATUS csr_get_modify_profile_fields(struct mac_context *mac, 1228 uint32_t sessionId, 1229 tCsrRoamModifyProfileFields * 1230 pModifyProfileFields) 1231 { 1232 if (!pModifyProfileFields) 1233 return QDF_STATUS_E_FAILURE; 1234 1235 qdf_mem_copy(pModifyProfileFields, 1236 &mac->roam.roamSession[sessionId].modifyProfileFields, 1237 sizeof(tCsrRoamModifyProfileFields)); 1238 1239 return QDF_STATUS_SUCCESS; 1240 } 1241 csr_set_modify_profile_fields(struct mac_context * mac,uint32_t sessionId,tCsrRoamModifyProfileFields * pModifyProfileFields)1242 QDF_STATUS csr_set_modify_profile_fields(struct mac_context *mac, 1243 uint32_t sessionId, 1244 tCsrRoamModifyProfileFields * 1245 pModifyProfileFields) 1246 { 1247 struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId); 1248 1249 if (!pSession) { 1250 sme_err("Session_id invalid %d", sessionId); 1251 return QDF_STATUS_E_INVAL; 1252 } 1253 1254 qdf_mem_copy(&pSession->modifyProfileFields, 1255 pModifyProfileFields, sizeof(tCsrRoamModifyProfileFields)); 1256 1257 return QDF_STATUS_SUCCESS; 1258 } 1259 1260 /* no need to acquire lock for this basic function */ sme_chn_to_freq(uint8_t chanNum)1261 uint16_t sme_chn_to_freq(uint8_t chanNum) 1262 { 1263 int i; 1264 1265 for (i = 0; i < NUM_CHANNELS; i++) { 1266 if (WLAN_REG_CH_NUM(i) == chanNum) 1267 return WLAN_REG_CH_TO_FREQ(i); 1268 } 1269 1270 return 0; 1271 } 1272 sme_bss_type_to_string(const uint8_t bss_type)1273 const char *sme_bss_type_to_string(const uint8_t bss_type) 1274 { 1275 switch (bss_type) { 1276 CASE_RETURN_STRING(eCSR_BSS_TYPE_INFRASTRUCTURE); 1277 CASE_RETURN_STRING(eCSR_BSS_TYPE_INFRA_AP); 1278 CASE_RETURN_STRING(eCSR_BSS_TYPE_ANY); 1279 default: 1280 return "unknown bss type"; 1281 } 1282 } 1283 1284 /** 1285 * csr_is_ndi_started() - function to check if NDI is started 1286 * @mac_ctx: handle to mac context 1287 * @session_id: session identifier 1288 * 1289 * returns: true if NDI is started, false otherwise 1290 */ csr_is_ndi_started(struct mac_context * mac_ctx,uint32_t session_id)1291 bool csr_is_ndi_started(struct mac_context *mac_ctx, uint32_t session_id) 1292 { 1293 struct csr_roam_session *session = CSR_GET_SESSION(mac_ctx, session_id); 1294 1295 if (!session) 1296 return false; 1297 1298 return eCSR_CONNECT_STATE_TYPE_NDI_STARTED == session->connectState; 1299 } 1300 csr_is_mcc_channel(struct mac_context * mac_ctx,uint32_t chan_freq)1301 bool csr_is_mcc_channel(struct mac_context *mac_ctx, uint32_t chan_freq) 1302 { 1303 struct csr_roam_session *session; 1304 enum QDF_OPMODE oper_mode; 1305 uint32_t oper_chan_freq = 0; 1306 uint8_t vdev_id; 1307 bool hw_dbs_capable, same_band_freqs; 1308 1309 if (chan_freq == 0) 1310 return false; 1311 1312 hw_dbs_capable = policy_mgr_is_hw_dbs_capable(mac_ctx->psoc); 1313 for (vdev_id = 0; vdev_id < WLAN_MAX_VDEVS; vdev_id++) { 1314 if (!CSR_IS_SESSION_VALID(mac_ctx, vdev_id)) 1315 continue; 1316 1317 session = CSR_GET_SESSION(mac_ctx, vdev_id); 1318 oper_mode = 1319 wlan_get_opmode_from_vdev_id(mac_ctx->pdev, vdev_id); 1320 if ((((oper_mode == QDF_STA_MODE) || 1321 (oper_mode == QDF_P2P_CLIENT_MODE)) && 1322 cm_is_vdevid_connected(mac_ctx->pdev, vdev_id)) || 1323 (((oper_mode == QDF_P2P_GO_MODE) || 1324 (oper_mode == QDF_SAP_MODE)) && 1325 (session->connectState != 1326 eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED))) 1327 oper_chan_freq = 1328 wlan_get_operation_chan_freq_vdev_id(mac_ctx->pdev, 1329 vdev_id); 1330 1331 if (!oper_chan_freq) 1332 continue; 1333 same_band_freqs = WLAN_REG_IS_SAME_BAND_FREQS( 1334 chan_freq, oper_chan_freq); 1335 1336 if (oper_chan_freq && chan_freq != oper_chan_freq && 1337 (!hw_dbs_capable || same_band_freqs)) 1338 return true; 1339 } 1340 1341 return false; 1342 } 1343 csr_phy_mode_to_dot11mode(enum wlan_phymode phy_mode)1344 enum csr_cfgdot11mode csr_phy_mode_to_dot11mode(enum wlan_phymode phy_mode) 1345 { 1346 switch (phy_mode) { 1347 case WLAN_PHYMODE_AUTO: 1348 return eCSR_CFG_DOT11_MODE_AUTO; 1349 case WLAN_PHYMODE_11A: 1350 return eCSR_CFG_DOT11_MODE_11A; 1351 case WLAN_PHYMODE_11B: 1352 return eCSR_CFG_DOT11_MODE_11B; 1353 case WLAN_PHYMODE_11G: 1354 return eCSR_CFG_DOT11_MODE_11G; 1355 case WLAN_PHYMODE_11G_ONLY: 1356 return eCSR_CFG_DOT11_MODE_11G_ONLY; 1357 case WLAN_PHYMODE_11NA_HT20: 1358 case WLAN_PHYMODE_11NG_HT20: 1359 case WLAN_PHYMODE_11NA_HT40: 1360 case WLAN_PHYMODE_11NG_HT40PLUS: 1361 case WLAN_PHYMODE_11NG_HT40MINUS: 1362 case WLAN_PHYMODE_11NG_HT40: 1363 return eCSR_CFG_DOT11_MODE_11N; 1364 case WLAN_PHYMODE_11AC_VHT20: 1365 case WLAN_PHYMODE_11AC_VHT20_2G: 1366 case WLAN_PHYMODE_11AC_VHT40: 1367 case WLAN_PHYMODE_11AC_VHT40PLUS_2G: 1368 case WLAN_PHYMODE_11AC_VHT40MINUS_2G: 1369 case WLAN_PHYMODE_11AC_VHT40_2G: 1370 case WLAN_PHYMODE_11AC_VHT80: 1371 case WLAN_PHYMODE_11AC_VHT80_2G: 1372 case WLAN_PHYMODE_11AC_VHT160: 1373 case WLAN_PHYMODE_11AC_VHT80_80: 1374 return eCSR_CFG_DOT11_MODE_11AC; 1375 case WLAN_PHYMODE_11AXA_HE20: 1376 case WLAN_PHYMODE_11AXG_HE20: 1377 case WLAN_PHYMODE_11AXA_HE40: 1378 case WLAN_PHYMODE_11AXG_HE40PLUS: 1379 case WLAN_PHYMODE_11AXG_HE40MINUS: 1380 case WLAN_PHYMODE_11AXG_HE40: 1381 case WLAN_PHYMODE_11AXA_HE80: 1382 case WLAN_PHYMODE_11AXG_HE80: 1383 case WLAN_PHYMODE_11AXA_HE160: 1384 case WLAN_PHYMODE_11AXA_HE80_80: 1385 return eCSR_CFG_DOT11_MODE_11AX; 1386 #ifdef WLAN_FEATURE_11BE 1387 case WLAN_PHYMODE_11BEA_EHT20: 1388 case WLAN_PHYMODE_11BEG_EHT20: 1389 case WLAN_PHYMODE_11BEA_EHT40: 1390 case WLAN_PHYMODE_11BEG_EHT40PLUS: 1391 case WLAN_PHYMODE_11BEG_EHT40MINUS: 1392 case WLAN_PHYMODE_11BEG_EHT40: 1393 case WLAN_PHYMODE_11BEA_EHT80: 1394 case WLAN_PHYMODE_11BEG_EHT80: 1395 case WLAN_PHYMODE_11BEA_EHT160: 1396 case WLAN_PHYMODE_11BEA_EHT320: 1397 return eCSR_CFG_DOT11_MODE_11BE; 1398 #endif 1399 default: 1400 sme_err("invalid phy mode %d", phy_mode); 1401 return eCSR_CFG_DOT11_MODE_MAX; 1402 } 1403 } 1404 csr_mlme_vdev_disconnect_all_p2p_client_event(uint8_t vdev_id)1405 QDF_STATUS csr_mlme_vdev_disconnect_all_p2p_client_event(uint8_t vdev_id) 1406 { 1407 struct mac_context *mac_ctx = cds_get_context(QDF_MODULE_ID_SME); 1408 1409 if (!mac_ctx) 1410 return QDF_STATUS_E_FAILURE; 1411 1412 return csr_roam_call_callback(mac_ctx, vdev_id, NULL, 1413 eCSR_ROAM_DISCONNECT_ALL_P2P_CLIENTS, 1414 eCSR_ROAM_RESULT_NONE); 1415 } 1416 csr_mlme_vdev_stop_bss(uint8_t vdev_id)1417 QDF_STATUS csr_mlme_vdev_stop_bss(uint8_t vdev_id) 1418 { 1419 struct mac_context *mac_ctx = cds_get_context(QDF_MODULE_ID_SME); 1420 1421 if (!mac_ctx) 1422 return QDF_STATUS_E_FAILURE; 1423 1424 return csr_roam_call_callback(mac_ctx, vdev_id, NULL, 1425 eCSR_ROAM_SEND_P2P_STOP_BSS, 1426 eCSR_ROAM_RESULT_NONE); 1427 } 1428 csr_mlme_get_concurrent_operation_freq(void)1429 qdf_freq_t csr_mlme_get_concurrent_operation_freq(void) 1430 { 1431 struct mac_context *mac_ctx = cds_get_context(QDF_MODULE_ID_SME); 1432 1433 if (!mac_ctx) 1434 return QDF_STATUS_E_FAILURE; 1435 1436 return csr_get_concurrent_operation_freq(mac_ctx); 1437 } 1438