1 /* 2 * Copyright (c) 2012-2015, 2020-2021, The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 /** 19 * DOC: Implements general util apis of connection manager 20 */ 21 22 #include "wlan_cm_main_api.h" 23 #include "wlan_scan_api.h" 24 #include "wlan_cm_public_struct.h" 25 #include "wlan_serialization_api.h" 26 #include "wlan_cm_bss_score_param.h" 27 #ifdef WLAN_POLICY_MGR_ENABLE 28 #include <wlan_policy_mgr_api.h> 29 #endif 30 #include "wlan_cm_roam.h" 31 #include <qdf_platform.h> 32 #include <wlan_mlo_mgr_link_switch.h> 33 34 static uint32_t cm_get_prefix_for_cm_id(enum wlan_cm_source source) { 35 switch (source) { 36 case CM_OSIF_CONNECT: 37 case CM_OSIF_CFG_CONNECT: 38 case CM_MLO_LINK_VDEV_CONNECT: 39 case CM_MLO_LINK_SWITCH_CONNECT: 40 return CONNECT_REQ_PREFIX; 41 case CM_ROAMING_HOST: 42 case CM_ROAMING_FW: 43 case CM_ROAMING_NUD_FAILURE: 44 case CM_ROAMING_LINK_REMOVAL: 45 case CM_ROAMING_USER: 46 return ROAM_REQ_PREFIX; 47 default: 48 return DISCONNECT_REQ_PREFIX; 49 } 50 } 51 52 wlan_cm_id cm_get_cm_id(struct cnx_mgr *cm_ctx, enum wlan_cm_source source) 53 { 54 wlan_cm_id cm_id; 55 uint32_t prefix; 56 uint8_t vdev_id = wlan_vdev_get_id(cm_ctx->vdev); 57 58 prefix = cm_get_prefix_for_cm_id(source); 59 60 cm_id = qdf_atomic_inc_return(&cm_ctx->global_cmd_id); 61 cm_id = (cm_id & CM_ID_MASK); 62 cm_id = CM_ID_SET_VDEV_ID(cm_id, vdev_id); 63 cm_id = (cm_id | prefix); 64 if (source == CM_MLO_LINK_SWITCH_DISCONNECT || 65 source == CM_MLO_LINK_SWITCH_CONNECT) 66 cm_id |= CM_ID_LSWITCH_BIT; 67 68 return cm_id; 69 } 70 71 struct cnx_mgr *cm_get_cm_ctx_fl(struct wlan_objmgr_vdev *vdev, 72 const char *func, uint32_t line) 73 { 74 struct vdev_mlme_obj *vdev_mlme; 75 struct cnx_mgr *cm_ctx = NULL; 76 77 if (!vdev) { 78 mlme_rl_nofl_err("%s:%u: vdev is NULL", func, line); 79 return NULL; 80 } 81 82 vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev); 83 if (vdev_mlme) 84 cm_ctx = vdev_mlme->cnx_mgr_ctx; 85 86 if (!cm_ctx) 87 mlme_nofl_err("%s:%u: vdev %d cm_ctx is NULL", func, line, 88 wlan_vdev_get_id(vdev)); 89 90 return cm_ctx; 91 } 92 93 cm_ext_t *cm_get_ext_hdl_fl(struct wlan_objmgr_vdev *vdev, 94 const char *func, uint32_t line) 95 { 96 struct cnx_mgr *cm_ctx; 97 cm_ext_t *ext_ctx = NULL; 98 99 cm_ctx = cm_get_cm_ctx_fl(vdev, func, line); 100 if (cm_ctx) 101 ext_ctx = cm_ctx->ext_cm_ptr; 102 103 if (!ext_ctx) 104 mlme_nofl_err("%s:%u: vdev %d cm ext ctx is NULL", func, line, 105 wlan_vdev_get_id(vdev)); 106 return ext_ctx; 107 } 108 109 void cm_reset_active_cm_id(struct wlan_objmgr_vdev *vdev, wlan_cm_id cm_id) 110 { 111 struct cnx_mgr *cm_ctx; 112 113 cm_ctx = cm_get_cm_ctx(vdev); 114 if (!cm_ctx) 115 return; 116 117 /* Reset active cm id if cm id match */ 118 if (cm_ctx->active_cm_id == cm_id) 119 cm_ctx->active_cm_id = CM_ID_INVALID; 120 } 121 122 123 #ifdef WLAN_CM_USE_SPINLOCK 124 /** 125 * cm_req_lock_acquire - acquire CM SM mutex/spinlock 126 * @cm_ctx: connection manager ctx 127 * 128 * acquire CM SM mutex/spinlock 129 * 130 * return: void 131 */ 132 inline void cm_req_lock_acquire(struct cnx_mgr *cm_ctx) 133 { 134 qdf_spinlock_acquire(&cm_ctx->cm_req_lock); 135 } 136 137 /** 138 * cm_req_lock_release - release CM SM mutex/spinlock 139 * @cm_ctx: connection manager ctx 140 * 141 * release CM SM mutex/spinlock 142 * 143 * return: void 144 */ 145 inline void cm_req_lock_release(struct cnx_mgr *cm_ctx) 146 { 147 qdf_spinlock_release(&cm_ctx->cm_req_lock); 148 } 149 150 QDF_STATUS cm_activate_cmd_req_flush_cb(struct scheduler_msg *msg) 151 { 152 struct wlan_serialization_command *cmd = msg->bodyptr; 153 154 if (!cmd || !cmd->vdev) { 155 mlme_err("Null input cmd:%pK", cmd); 156 return QDF_STATUS_E_INVAL; 157 } 158 159 wlan_objmgr_vdev_release_ref(cmd->vdev, WLAN_MLME_CM_ID); 160 return QDF_STATUS_SUCCESS; 161 } 162 163 #else 164 inline void cm_req_lock_acquire(struct cnx_mgr *cm_ctx) 165 { 166 qdf_mutex_acquire(&cm_ctx->cm_req_lock); 167 } 168 169 inline void cm_req_lock_release(struct cnx_mgr *cm_ctx) 170 { 171 qdf_mutex_release(&cm_ctx->cm_req_lock); 172 } 173 #endif /* WLAN_CM_USE_SPINLOCK */ 174 175 #ifdef CRYPTO_SET_KEY_CONVERGED 176 QDF_STATUS cm_set_key(struct cnx_mgr *cm_ctx, bool unicast, 177 uint8_t key_idx, struct qdf_mac_addr *bssid) 178 { 179 enum wlan_crypto_cipher_type cipher; 180 struct wlan_crypto_key *crypto_key; 181 uint8_t wep_key_idx = 0; 182 183 cipher = wlan_crypto_get_cipher(cm_ctx->vdev, unicast, key_idx); 184 if (IS_WEP_CIPHER(cipher)) { 185 wep_key_idx = wlan_crypto_get_default_key_idx(cm_ctx->vdev, 186 false); 187 crypto_key = wlan_crypto_get_key(cm_ctx->vdev, wep_key_idx); 188 qdf_mem_copy(crypto_key->macaddr, bssid->bytes, 189 QDF_MAC_ADDR_SIZE); 190 } else { 191 crypto_key = wlan_crypto_get_key(cm_ctx->vdev, key_idx); 192 } 193 194 return wlan_crypto_set_key_req(cm_ctx->vdev, crypto_key, (unicast ? 195 WLAN_CRYPTO_KEY_TYPE_UNICAST : 196 WLAN_CRYPTO_KEY_TYPE_GROUP)); 197 } 198 #endif 199 200 static void cm_dump_sm_history(struct wlan_objmgr_vdev *vdev) 201 { 202 struct vdev_mlme_obj *vdev_mlme; 203 struct wlan_sm *vdev_sm; 204 205 vdev_mlme = wlan_objmgr_vdev_get_comp_private_obj(vdev, 206 WLAN_UMAC_COMP_MLME); 207 if (!vdev_mlme) 208 return; 209 210 vdev_sm = vdev_mlme->sm_hdl; 211 if (!vdev_sm) 212 return; 213 214 wlan_sm_print_history(vdev_sm); 215 cm_sm_history_print(vdev); 216 } 217 218 #ifdef CONN_MGR_ADV_FEATURE 219 void cm_store_wep_key(struct cnx_mgr *cm_ctx, 220 struct wlan_cm_connect_crypto_info *crypto, 221 wlan_cm_id cm_id) 222 { 223 struct wlan_crypto_key *crypto_key = NULL; 224 QDF_STATUS status; 225 enum wlan_crypto_cipher_type cipher_type; 226 struct wlan_cm_wep_key_params *wep_keys; 227 228 if (!(crypto->ciphers_pairwise & (1 << WLAN_CRYPTO_CIPHER_WEP_40 | 229 1 << WLAN_CRYPTO_CIPHER_WEP_104))) 230 return; 231 232 if (crypto->ciphers_pairwise & 1 << WLAN_CRYPTO_CIPHER_WEP_40) 233 cipher_type = WLAN_CRYPTO_CIPHER_WEP_40; 234 else 235 cipher_type = WLAN_CRYPTO_CIPHER_WEP_104; 236 237 wep_keys = &crypto->wep_keys; 238 status = wlan_crypto_validate_key_params(cipher_type, 239 wep_keys->key_idx, 240 wep_keys->key_len, 241 wep_keys->seq_len); 242 if (QDF_IS_STATUS_ERROR(status)) { 243 mlme_err(CM_PREFIX_FMT "Invalid key params", 244 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id)); 245 return; 246 } 247 248 crypto_key = wlan_crypto_get_key(cm_ctx->vdev, wep_keys->key_idx); 249 if (!crypto_key) { 250 crypto_key = qdf_mem_malloc(sizeof(*crypto_key)); 251 if (!crypto_key) 252 return; 253 254 status = wlan_crypto_save_key(cm_ctx->vdev, wep_keys->key_idx, 255 crypto_key); 256 if (QDF_IS_STATUS_ERROR(status)) { 257 mlme_err(CM_PREFIX_FMT "Failed to save key", 258 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 259 cm_id)); 260 qdf_mem_free(crypto_key); 261 return; 262 } 263 } 264 qdf_mem_zero(crypto_key, sizeof(*crypto_key)); 265 crypto_key->cipher_type = cipher_type; 266 crypto_key->keylen = wep_keys->key_len; 267 crypto_key->keyix = wep_keys->key_idx; 268 qdf_mem_copy(&crypto_key->keyval[0], wep_keys->key, wep_keys->key_len); 269 qdf_mem_copy(&crypto_key->keyrsc[0], wep_keys->seq, wep_keys->seq_len); 270 mlme_debug(CM_PREFIX_FMT "cipher_type %d key_len %d, seq_len %d", 271 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id), 272 crypto_key->cipher_type, wep_keys->key_len, 273 wep_keys->seq_len); 274 } 275 276 void cm_trigger_panic_on_cmd_timeout(struct wlan_objmgr_vdev *vdev, 277 enum qdf_hang_reason reason) 278 { 279 struct wlan_objmgr_psoc *psoc; 280 281 psoc = wlan_vdev_get_psoc(vdev); 282 if (!psoc) 283 return; 284 285 if (qdf_is_recovering() || qdf_is_fw_down()) 286 return; 287 288 cm_dump_sm_history(vdev); 289 qdf_trigger_self_recovery(psoc, reason); 290 } 291 292 #else 293 void cm_trigger_panic_on_cmd_timeout(struct wlan_objmgr_vdev *vdev, 294 enum qdf_hang_reason reason) 295 { 296 cm_dump_sm_history(vdev); 297 QDF_ASSERT(0); 298 } 299 #endif 300 301 #ifdef WLAN_FEATURE_FILS_SK 302 void cm_store_fils_key(struct cnx_mgr *cm_ctx, bool unicast, 303 uint8_t key_id, uint16_t key_length, 304 uint8_t *key, struct qdf_mac_addr *bssid, 305 wlan_cm_id cm_id) 306 { 307 struct wlan_crypto_key *crypto_key = NULL; 308 QDF_STATUS status; 309 uint8_t i; 310 int32_t cipher; 311 enum wlan_crypto_cipher_type cipher_type = WLAN_CRYPTO_CIPHER_NONE; 312 313 if (unicast) 314 cipher = wlan_crypto_get_param(cm_ctx->vdev, 315 WLAN_CRYPTO_PARAM_UCAST_CIPHER); 316 else 317 cipher = wlan_crypto_get_param(cm_ctx->vdev, 318 WLAN_CRYPTO_PARAM_MCAST_CIPHER); 319 320 for (i = 0; i <= WLAN_CRYPTO_CIPHER_MAX; i++) { 321 if (QDF_HAS_PARAM(cipher, i)) { 322 cipher_type = i; 323 break; 324 } 325 } 326 crypto_key = wlan_crypto_get_key(cm_ctx->vdev, key_id); 327 if (!crypto_key) { 328 crypto_key = qdf_mem_malloc(sizeof(*crypto_key)); 329 if (!crypto_key) 330 return; 331 status = wlan_crypto_save_key(cm_ctx->vdev, key_id, crypto_key); 332 if (QDF_IS_STATUS_ERROR(status)) { 333 mlme_err(CM_PREFIX_FMT "Failed to save key", 334 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 335 cm_id)); 336 qdf_mem_free(crypto_key); 337 return; 338 } 339 } 340 qdf_mem_zero(crypto_key, sizeof(*crypto_key)); 341 crypto_key->cipher_type = cipher_type; 342 crypto_key->keylen = key_length; 343 crypto_key->keyix = key_id; 344 qdf_mem_copy(&crypto_key->keyval[0], key, key_length); 345 qdf_mem_copy(crypto_key->macaddr, bssid->bytes, QDF_MAC_ADDR_SIZE); 346 mlme_debug(CM_PREFIX_FMT "cipher_type %d key_len %d, key_id %d mac:" QDF_MAC_ADDR_FMT, 347 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id), 348 crypto_key->cipher_type, crypto_key->keylen, 349 crypto_key->keyix, QDF_MAC_ADDR_REF(crypto_key->macaddr)); 350 } 351 static void cm_set_fils_connection_from_req(struct wlan_cm_connect_req *req, 352 struct wlan_cm_connect_resp *resp) 353 { 354 resp->is_fils_connection = req->fils_info.is_fils_connection; 355 } 356 #else 357 static inline 358 void cm_set_fils_connection_from_req(struct wlan_cm_connect_req *req, 359 struct wlan_cm_connect_resp *resp) 360 {} 361 #endif 362 363 bool cm_check_cmid_match_list_head(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id) 364 { 365 qdf_list_node_t *cur_node = NULL; 366 struct cm_req *cm_req; 367 bool match = false; 368 wlan_cm_id head_cm_id = 0; 369 370 if (!cm_id) 371 return false; 372 373 cm_req_lock_acquire(cm_ctx); 374 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 375 if (!cur_node) 376 goto exit; 377 378 cm_req = qdf_container_of(cur_node, struct cm_req, node); 379 head_cm_id = cm_req->cm_id; 380 if (head_cm_id == *cm_id) 381 match = true; 382 383 exit: 384 cm_req_lock_release(cm_ctx); 385 if (!match) 386 mlme_info("head_cm_id 0x%x didn't match the given cm_id 0x%x", 387 head_cm_id, *cm_id); 388 389 return match; 390 } 391 392 bool cm_check_scanid_match_list_head(struct cnx_mgr *cm_ctx, 393 wlan_scan_id *scan_id) 394 { 395 qdf_list_node_t *cur_node = NULL; 396 struct cm_req *cm_req; 397 bool match = false; 398 wlan_cm_id head_scan_id = 0; 399 uint32_t prefix = 0; 400 401 if (!scan_id) 402 return false; 403 404 cm_req_lock_acquire(cm_ctx); 405 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 406 if (!cur_node) 407 goto exit; 408 409 cm_req = qdf_container_of(cur_node, struct cm_req, node); 410 prefix = CM_ID_GET_PREFIX(cm_req->cm_id); 411 /* Check only if head is connect req */ 412 if (prefix != CONNECT_REQ_PREFIX) 413 goto exit; 414 head_scan_id = cm_req->connect_req.scan_id; 415 if (head_scan_id == *scan_id) 416 match = true; 417 418 exit: 419 cm_req_lock_release(cm_ctx); 420 if (!match) 421 mlme_info("head_scan_id 0x%x didn't match the given scan_id 0x%x prefix 0x%x", 422 head_scan_id, *scan_id, prefix); 423 424 return match; 425 } 426 427 struct cm_req *cm_get_req_by_cm_id_fl(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id, 428 const char *func, uint32_t line) 429 { 430 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 431 struct cm_req * cm_req; 432 433 cm_req_lock_acquire(cm_ctx); 434 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 435 while (cur_node) { 436 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 437 cm_req = qdf_container_of(cur_node, struct cm_req, node); 438 439 if (cm_req->cm_id == cm_id) { 440 cm_req_lock_release(cm_ctx); 441 return cm_req; 442 } 443 444 cur_node = next_node; 445 next_node = NULL; 446 } 447 cm_req_lock_release(cm_ctx); 448 449 mlme_nofl_info("%s:%u: cm req not found for cm id 0x%x", func, 450 line, cm_id); 451 452 return NULL; 453 } 454 455 #ifdef WLAN_FEATURE_11BE_MLO 456 void 457 cm_connect_resp_fill_mld_addr_from_candidate(struct wlan_objmgr_vdev *vdev, 458 struct scan_cache_entry *entry, 459 struct wlan_cm_connect_resp *resp) 460 { 461 struct qdf_mac_addr *mld_addr; 462 463 if (!entry || !vdev || !wlan_vdev_mlme_is_mlo_vdev(vdev)) 464 return; 465 466 mld_addr = util_scan_entry_mldaddr(entry); 467 if (!mld_addr) 468 return; 469 470 qdf_copy_macaddr(&resp->mld_addr, mld_addr); 471 } 472 473 void 474 cm_connect_resp_fill_mld_addr_from_cm_id(struct wlan_objmgr_vdev *vdev, 475 wlan_cm_id cm_id, 476 struct wlan_cm_connect_resp *rsp) 477 { 478 struct cm_req *cm_req; 479 struct cnx_mgr *cm_ctx; 480 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 481 struct scan_cache_entry *entry; 482 483 if (!wlan_vdev_mlme_is_mlo_vdev(vdev)) 484 return; 485 486 cm_ctx = cm_get_cm_ctx(vdev); 487 if (!cm_ctx) 488 return; 489 490 cm_req_lock_acquire(cm_ctx); 491 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 492 while (cur_node) { 493 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 494 cm_req = qdf_container_of(cur_node, struct cm_req, node); 495 496 if (cm_req->cm_id != cm_id) { 497 cur_node = next_node; 498 next_node = NULL; 499 continue; 500 } 501 502 if (!cm_req->connect_req.cur_candidate || 503 !cm_req->connect_req.cur_candidate->entry) 504 break; 505 506 entry = cm_req->connect_req.cur_candidate->entry; 507 cm_connect_resp_fill_mld_addr_from_candidate(vdev, entry, rsp); 508 break; 509 } 510 cm_req_lock_release(cm_ctx); 511 } 512 513 static void 514 cm_connect_resp_fill_mld_addr_from_scan_db(struct wlan_objmgr_vdev *vdev, 515 struct qdf_mac_addr *bssid, 516 struct wlan_cm_connect_resp *resp) 517 { 518 if (!wlan_vdev_mlme_is_mlo_vdev(vdev)) 519 return; 520 521 wlan_scan_get_mld_addr_by_link_addr(wlan_vdev_get_pdev(vdev), bssid, 522 &resp->mld_addr); 523 } 524 #else 525 static inline void 526 cm_connect_resp_fill_mld_addr_from_scan_db(struct wlan_objmgr_vdev *vdev, 527 struct qdf_mac_addr *bssid, 528 struct wlan_cm_connect_resp *resp) 529 { 530 } 531 #endif 532 533 /** 534 * cm_fill_connect_resp_from_req() - Fill connect resp from connect request 535 * @vdev: VDEV objmgr pointer 536 * @resp: cm connect response 537 * @cm_req: cm request 538 * 539 * Context: Can be called from APIs holding cm request list lock 540 * 541 * Return: void 542 */ 543 static void 544 cm_fill_connect_resp_from_req(struct wlan_objmgr_vdev *vdev, 545 struct wlan_cm_connect_resp *resp, 546 struct cm_req *cm_req) 547 { 548 struct scan_cache_node *candidate; 549 struct wlan_cm_connect_req *req; 550 551 req = &cm_req->connect_req.req; 552 candidate = cm_req->connect_req.cur_candidate; 553 if (candidate) { 554 qdf_copy_macaddr(&resp->bssid, &candidate->entry->bssid); 555 cm_connect_resp_fill_mld_addr_from_candidate(vdev, 556 candidate->entry, 557 resp); 558 } else if (!qdf_is_macaddr_zero(&req->bssid)) { 559 qdf_copy_macaddr(&resp->bssid, &req->bssid); 560 cm_connect_resp_fill_mld_addr_from_scan_db(vdev, &req->bssid, 561 resp); 562 } else { 563 qdf_copy_macaddr(&resp->bssid, &req->bssid_hint); 564 cm_connect_resp_fill_mld_addr_from_scan_db(vdev, &req->bssid, 565 resp); 566 } 567 568 if (candidate) 569 resp->freq = candidate->entry->channel.chan_freq; 570 else if (req->chan_freq) 571 resp->freq = req->chan_freq; 572 else 573 resp->freq = req->chan_freq_hint; 574 575 resp->ssid = req->ssid; 576 resp->is_wps_connection = req->is_wps_connection; 577 resp->is_osen_connection = req->is_osen_connection; 578 cm_set_fils_connection_from_req(req, resp); 579 } 580 581 /** 582 * cm_handle_connect_flush() - Fill fail connect resp from req and indicate 583 * same to osif 584 * @cm_ctx: connection manager context 585 * @cm_req: cm request 586 * 587 * Context: Can be called from APIs holding cm request list lock 588 * 589 * Return: void 590 */ 591 static void 592 cm_handle_connect_flush(struct cnx_mgr *cm_ctx, struct cm_req *cm_req) 593 { 594 struct wlan_cm_connect_resp *resp; 595 596 resp = qdf_mem_malloc(sizeof(*resp)); 597 if (!resp) 598 return; 599 600 resp->connect_status = QDF_STATUS_E_FAILURE; 601 resp->cm_id = cm_req->cm_id; 602 resp->vdev_id = wlan_vdev_get_id(cm_ctx->vdev); 603 if (cm_req->failed_req) 604 resp->reason = CM_GENERIC_FAILURE; 605 else 606 resp->reason = CM_ABORT_DUE_TO_NEW_REQ_RECVD; 607 608 /* Get bssid and ssid and freq for the cm id from the req list */ 609 cm_fill_connect_resp_from_req(cm_ctx->vdev, resp, cm_req); 610 611 cm_notify_connect_complete(cm_ctx, resp, 0); 612 613 /* For link switch connect request, notify MLO mgr */ 614 if (cm_is_link_switch_connect_resp(resp)) { 615 cm_reset_active_cm_id(cm_ctx->vdev, resp->cm_id); 616 mlo_mgr_link_switch_connect_done(cm_ctx->vdev, 617 resp->connect_status); 618 } 619 620 qdf_mem_free(resp); 621 } 622 623 /** 624 * cm_handle_disconnect_flush() - Fill disconnect resp from req and indicate 625 * same to osif 626 * @cm_ctx: connection manager context 627 * @cm_req: cm request 628 * 629 * Context: Can be called from APIs holding cm request list lock 630 * 631 * Return: void 632 */ 633 static void 634 cm_handle_disconnect_flush(struct cnx_mgr *cm_ctx, struct cm_req *cm_req) 635 { 636 struct wlan_cm_discon_rsp resp; 637 638 qdf_mem_zero(&resp, sizeof(resp)); 639 resp.req.cm_id = cm_req->cm_id; 640 resp.req.req = cm_req->discon_req.req; 641 /* 642 * Indicate to OSIF to inform kernel if not already done and this is 643 * the latest disconnect req received. If this is not the latest, it 644 * will be dropped in OSIF as src and cm_id will not match. A flushed 645 * disconnect can be last of this was received when previous disconnect 646 * was already in serialization active queue and thus wasn't flushed. 647 */ 648 mlme_cm_osif_disconnect_complete(cm_ctx->vdev, &resp); 649 650 if (cm_is_link_switch_disconnect_resp(&resp)) { 651 cm_reset_active_cm_id(cm_ctx->vdev, resp.req.cm_id); 652 mlo_mgr_link_switch_disconnect_done(cm_ctx->vdev, 653 QDF_STATUS_E_ABORTED, 654 true); 655 } 656 } 657 658 void cm_remove_cmd_from_serialization(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id) 659 { 660 struct wlan_serialization_queued_cmd_info cmd_info; 661 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 662 663 qdf_mem_zero(&cmd_info, sizeof(cmd_info)); 664 cmd_info.cmd_id = cm_id; 665 cmd_info.req_type = WLAN_SER_CANCEL_NON_SCAN_CMD; 666 667 if (prefix == CONNECT_REQ_PREFIX) { 668 cmd_info.cmd_type = WLAN_SER_CMD_VDEV_CONNECT; 669 } else if (prefix == ROAM_REQ_PREFIX) { 670 /* 671 * Try removing PREAUTH command when in preauth state else 672 * try remove ROAM command 673 */ 674 if (cm_ctx->preauth_in_progress) 675 cmd_info.cmd_type = WLAN_SER_CMD_PERFORM_PRE_AUTH; 676 else 677 cmd_info.cmd_type = WLAN_SER_CMD_VDEV_ROAM; 678 cm_ctx->preauth_in_progress = false; 679 } else if (prefix == DISCONNECT_REQ_PREFIX) { 680 cmd_info.cmd_type = WLAN_SER_CMD_VDEV_DISCONNECT; 681 } else { 682 mlme_err(CM_PREFIX_FMT "Invalid prefix %x", 683 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id), 684 prefix); 685 return; 686 } 687 688 cmd_info.vdev = cm_ctx->vdev; 689 690 if (cm_id == cm_ctx->active_cm_id) { 691 mlme_debug(CM_PREFIX_FMT "Remove cmd type %d from active", 692 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id), 693 cmd_info.cmd_type); 694 cmd_info.queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; 695 /* 696 * Active command id is reset during memory release, but a new 697 * command will become active before memory release of 698 * serialization command, and if it try to check the active 699 * cm_id(using cm_get_active_req_type) it will be valid (), so 700 * reset the cm id for active command before calling release 701 * active command. 702 * One example: For ML vdevs, disconnect on Assoc vdev can get 703 * activated before release memory of link vdev command which 704 * reset active CM id, and thus during RSO stop can lead to 705 * assumption that link vdev disconnect is active when it is not. 706 */ 707 cm_reset_active_cm_id(cm_ctx->vdev, cm_id); 708 wlan_serialization_remove_cmd(&cmd_info); 709 } else { 710 mlme_debug(CM_PREFIX_FMT "Remove cmd type %d from pending", 711 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id), 712 cmd_info.cmd_type); 713 cmd_info.queue_type = WLAN_SERIALIZATION_PENDING_QUEUE; 714 wlan_serialization_cancel_request(&cmd_info); 715 } 716 } 717 718 void 719 cm_flush_pending_request(struct cnx_mgr *cm_ctx, uint32_t prefix, 720 bool only_failed_req) 721 { 722 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 723 struct cm_req *cm_req; 724 uint32_t req_prefix; 725 bool roam_offload = false; 726 727 if (cm_roam_offload_enabled(wlan_vdev_get_psoc(cm_ctx->vdev)) && 728 prefix == ROAM_REQ_PREFIX) 729 roam_offload = true; 730 731 cm_req_lock_acquire(cm_ctx); 732 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 733 while (cur_node) { 734 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 735 cm_req = qdf_container_of(cur_node, struct cm_req, node); 736 737 req_prefix = CM_ID_GET_PREFIX(cm_req->cm_id); 738 739 /* 740 * Only remove requests matching the flush prefix and 741 * the pending req for non roam offload(LFR3) commands 742 * (roam command is dummy in FW roam/LFR3 so active 743 * command can be removed) 744 */ 745 if (req_prefix != prefix || 746 (!roam_offload && cm_req->cm_id == cm_ctx->active_cm_id)) 747 goto next; 748 749 /* If only_failed_req is set flush only failed req */ 750 if (only_failed_req && !cm_req->failed_req) 751 goto next; 752 753 if (req_prefix == CONNECT_REQ_PREFIX) { 754 cm_handle_connect_flush(cm_ctx, cm_req); 755 cm_ctx->connect_count--; 756 cm_free_connect_req_mem(&cm_req->connect_req); 757 } else if (req_prefix == ROAM_REQ_PREFIX) { 758 cm_free_roam_req_mem(&cm_req->roam_req); 759 } else if (req_prefix == DISCONNECT_REQ_PREFIX) { 760 cm_handle_disconnect_flush(cm_ctx, cm_req); 761 cm_ctx->disconnect_count--; 762 } else { 763 mlme_err(CM_PREFIX_FMT "Invalid prefix %x", 764 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 765 cm_req->cm_id), prefix); 766 } 767 768 cm_req_history_del(cm_ctx, cm_req, CM_REQ_DEL_FLUSH); 769 mlme_debug(CM_PREFIX_FMT, 770 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 771 cm_req->cm_id)); 772 cm_remove_cmd_from_serialization(cm_ctx, cm_req->cm_id); 773 qdf_list_remove_node(&cm_ctx->req_list, &cm_req->node); 774 qdf_mem_free(cm_req); 775 next: 776 cur_node = next_node; 777 next_node = NULL; 778 } 779 780 cm_req_lock_release(cm_ctx); 781 } 782 783 QDF_STATUS 784 cm_fill_bss_info_in_connect_rsp_by_cm_id(struct cnx_mgr *cm_ctx, 785 wlan_cm_id cm_id, 786 struct wlan_cm_connect_resp *resp) 787 { 788 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 789 struct cm_req *cm_req; 790 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 791 792 if (prefix != CONNECT_REQ_PREFIX) 793 return QDF_STATUS_E_INVAL; 794 795 cm_req_lock_acquire(cm_ctx); 796 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 797 while (cur_node) { 798 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 799 cm_req = qdf_container_of(cur_node, struct cm_req, node); 800 801 if (cm_req->cm_id == cm_id) { 802 cm_fill_connect_resp_from_req(cm_ctx->vdev, 803 resp, cm_req); 804 cm_req_lock_release(cm_ctx); 805 return QDF_STATUS_SUCCESS; 806 } 807 808 cur_node = next_node; 809 next_node = NULL; 810 } 811 cm_req_lock_release(cm_ctx); 812 813 return QDF_STATUS_E_FAILURE; 814 } 815 816 #if defined(WLAN_SAE_SINGLE_PMK) && defined(WLAN_FEATURE_ROAM_OFFLOAD) 817 bool cm_is_cm_id_current_candidate_single_pmk(struct cnx_mgr *cm_ctx, 818 wlan_cm_id cm_id) 819 { 820 struct wlan_objmgr_psoc *psoc; 821 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 822 struct cm_req *cm_req; 823 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 824 int32_t akm; 825 struct scan_cache_node *candidate; 826 bool is_single_pmk = false; 827 828 psoc = wlan_vdev_get_psoc(cm_ctx->vdev); 829 if (!psoc) { 830 mlme_err(CM_PREFIX_FMT "Failed to find psoc", 831 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 832 cm_id)); 833 return is_single_pmk; 834 } 835 836 if (prefix != CONNECT_REQ_PREFIX) 837 return is_single_pmk; 838 839 akm = wlan_crypto_get_param(cm_ctx->vdev, WLAN_CRYPTO_PARAM_KEY_MGMT); 840 if (!(QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_SAE) || 841 QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_SAE_EXT_KEY))) 842 return is_single_pmk; 843 844 cm_req_lock_acquire(cm_ctx); 845 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 846 while (cur_node) { 847 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 848 cm_req = qdf_container_of(cur_node, struct cm_req, node); 849 850 if (cm_req->cm_id == cm_id) { 851 candidate = cm_req->connect_req.cur_candidate; 852 if (candidate && 853 util_scan_entry_single_pmk(psoc, candidate->entry)) 854 is_single_pmk = true; 855 break; 856 } 857 858 cur_node = next_node; 859 next_node = NULL; 860 } 861 cm_req_lock_release(cm_ctx); 862 863 return is_single_pmk; 864 } 865 #endif 866 867 QDF_STATUS cm_add_req_to_list_and_indicate_osif(struct cnx_mgr *cm_ctx, 868 struct cm_req *cm_req, 869 enum wlan_cm_source source) 870 { 871 uint32_t prefix = CM_ID_GET_PREFIX(cm_req->cm_id); 872 873 cm_req_lock_acquire(cm_ctx); 874 if (qdf_list_size(&cm_ctx->req_list) >= CM_MAX_REQ) { 875 cm_req_lock_release(cm_ctx); 876 mlme_err(CM_PREFIX_FMT "List full size %d", 877 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 878 cm_req->cm_id), 879 qdf_list_size(&cm_ctx->req_list)); 880 return QDF_STATUS_E_FAILURE; 881 } 882 883 qdf_list_insert_front(&cm_ctx->req_list, &cm_req->node); 884 if (prefix == CONNECT_REQ_PREFIX) 885 cm_ctx->connect_count++; 886 else if (prefix == DISCONNECT_REQ_PREFIX) 887 cm_ctx->disconnect_count++; 888 889 cm_req_history_add(cm_ctx, cm_req); 890 cm_req_lock_release(cm_ctx); 891 mlme_debug(CM_PREFIX_FMT, 892 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 893 cm_req->cm_id)); 894 895 mlme_cm_osif_update_id_and_src(cm_ctx->vdev, source, cm_req->cm_id); 896 897 return QDF_STATUS_SUCCESS; 898 } 899 900 static void cm_zero_and_free_memory(uint8_t *ptr, uint32_t len) 901 { 902 if (!ptr) 903 return; 904 905 qdf_mem_zero(ptr, len); 906 qdf_mem_free(ptr); 907 } 908 909 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 910 /** 911 * cm_free_roaming_info() - Function to free all params in roaming info 912 * @connect_rsp: pointer to connect response 913 * 914 * Function to free up all the memory in connect response 915 * 916 * Return: void 917 */ 918 static 919 void cm_free_roaming_info(struct wlan_cm_connect_resp *connect_rsp) 920 { 921 cm_zero_and_free_memory((uint8_t *)connect_rsp->roaming_info, 922 sizeof(*connect_rsp->roaming_info)); 923 } 924 #else 925 static inline 926 void cm_free_roaming_info(struct wlan_cm_connect_resp *connect_rsp) 927 { 928 } 929 #endif 930 931 #ifdef WLAN_FEATURE_FILS_SK 932 /** 933 * cm_free_fils_ie() - function to free all params in fils ie 934 * @connect_ie: ptr to connect ies 935 * 936 * Function to free up all the memory in fils ies response. 937 * 938 * Return: void 939 */ 940 static 941 void cm_free_fils_ie(struct wlan_connect_rsp_ies *connect_ie) 942 { 943 if (!connect_ie->fils_ie) 944 return; 945 946 if (connect_ie->fils_ie->fils_pmk) 947 cm_zero_and_free_memory(connect_ie->fils_ie->fils_pmk, 948 connect_ie->fils_ie->fils_pmk_len); 949 950 cm_zero_and_free_memory((uint8_t *)connect_ie->fils_ie, 951 sizeof(*connect_ie->fils_ie)); 952 } 953 #else 954 static inline 955 void cm_free_fils_ie(struct wlan_connect_rsp_ies *connect_ie) 956 { 957 } 958 #endif 959 960 /** 961 * cm_free_connect_ies() - Function to free all params in coonect ies 962 * @connect_ie: ptr to connect ies 963 * 964 * Function to free up all the memory in connect ies response 965 * 966 * Return: void 967 */ 968 static 969 void cm_free_connect_ies(struct wlan_connect_rsp_ies *connect_ie) 970 { 971 cm_zero_and_free_memory(connect_ie->assoc_req.ptr, 972 connect_ie->assoc_req.len); 973 connect_ie->assoc_req.len = 0; 974 975 cm_zero_and_free_memory(connect_ie->bcn_probe_rsp.ptr, 976 connect_ie->bcn_probe_rsp.len); 977 connect_ie->bcn_probe_rsp.len = 0; 978 979 cm_zero_and_free_memory(connect_ie->link_bcn_probe_rsp.ptr, 980 connect_ie->link_bcn_probe_rsp.len); 981 connect_ie->link_bcn_probe_rsp.len = 0; 982 983 cm_zero_and_free_memory(connect_ie->assoc_rsp.ptr, 984 connect_ie->assoc_rsp.len); 985 connect_ie->assoc_rsp.len = 0; 986 } 987 988 void cm_free_connect_rsp_ies(struct wlan_cm_connect_resp *connect_rsp) 989 { 990 cm_free_connect_ies(&connect_rsp->connect_ies); 991 cm_free_fils_ie(&connect_rsp->connect_ies); 992 cm_free_roaming_info(connect_rsp); 993 } 994 995 static void cm_free_connect_req_ies(struct wlan_cm_connect_req *req) 996 { 997 cm_zero_and_free_memory(req->assoc_ie.ptr, req->assoc_ie.len); 998 req->assoc_ie.ptr = NULL; 999 cm_zero_and_free_memory(req->scan_ie.ptr, req->scan_ie.len); 1000 req->scan_ie.ptr = NULL; 1001 } 1002 1003 void cm_free_wep_key_params(struct wlan_cm_connect_req *req) 1004 { 1005 cm_zero_and_free_memory(req->crypto.wep_keys.key, 1006 req->crypto.wep_keys.key_len); 1007 req->crypto.wep_keys.key = NULL; 1008 cm_zero_and_free_memory(req->crypto.wep_keys.seq, 1009 req->crypto.wep_keys.seq_len); 1010 req->crypto.wep_keys.seq = NULL; 1011 } 1012 1013 void cm_free_connect_req_param(struct wlan_cm_connect_req *req) 1014 { 1015 cm_free_connect_req_ies(req); 1016 cm_free_wep_key_params(req); 1017 } 1018 1019 void cm_free_connect_req(struct wlan_cm_connect_req *req) 1020 { 1021 cm_free_connect_req_param(req); 1022 cm_zero_and_free_memory((uint8_t *)req, sizeof(*req)); 1023 } 1024 1025 void cm_free_connect_rsp(struct wlan_cm_connect_resp *connect_rsp) 1026 { 1027 cm_free_connect_rsp_ies(connect_rsp); 1028 cm_zero_and_free_memory((uint8_t *)connect_rsp, sizeof(*connect_rsp)); 1029 } 1030 1031 #ifdef CONN_MGR_ADV_FEATURE 1032 /** 1033 * cm_free_first_connect_rsp() - Function to free all params in connect rsp 1034 * @req: pointer to connect req struct 1035 * 1036 * Function to free up all the memory in connect rsp. 1037 * 1038 * Return: void 1039 */ 1040 static 1041 void cm_free_first_connect_rsp(struct cm_connect_req *req) 1042 { 1043 struct wlan_cm_connect_resp *connect_rsp = req->first_candidate_rsp; 1044 1045 if (!connect_rsp) 1046 return; 1047 1048 cm_free_connect_rsp(connect_rsp); 1049 } 1050 #else 1051 static inline 1052 void cm_free_first_connect_rsp(struct cm_connect_req *req) 1053 { 1054 } 1055 #endif /* CONN_MGR_ADV_FEATURE */ 1056 1057 void cm_free_connect_req_mem(struct cm_connect_req *connect_req) 1058 { 1059 struct wlan_cm_connect_req *req; 1060 1061 req = &connect_req->req; 1062 1063 if (connect_req->candidate_list) 1064 wlan_scan_purge_results(connect_req->candidate_list); 1065 1066 cm_free_connect_req_param(req); 1067 1068 cm_free_first_connect_rsp(connect_req); 1069 1070 qdf_mem_zero(connect_req, sizeof(*connect_req)); 1071 } 1072 1073 QDF_STATUS 1074 cm_delete_req_from_list(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id) 1075 { 1076 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 1077 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1078 struct cm_req *cm_req = NULL; 1079 1080 cm_req_lock_acquire(cm_ctx); 1081 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1082 while (cur_node) { 1083 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1084 1085 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1086 if (cm_req->cm_id == cm_id) 1087 break; 1088 1089 cur_node = next_node; 1090 next_node = NULL; 1091 cm_req = NULL; 1092 } 1093 1094 if (!cm_req) { 1095 cm_req_lock_release(cm_ctx); 1096 mlme_err(CM_PREFIX_FMT " req not found", 1097 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id)); 1098 return QDF_STATUS_E_FAILURE; 1099 } 1100 1101 qdf_list_remove_node(&cm_ctx->req_list, &cm_req->node); 1102 if (prefix == CONNECT_REQ_PREFIX) { 1103 cm_ctx->connect_count--; 1104 cm_free_connect_req_mem(&cm_req->connect_req); 1105 } else if (prefix == ROAM_REQ_PREFIX) { 1106 cm_free_roam_req_mem(&cm_req->roam_req); 1107 } else if (prefix == DISCONNECT_REQ_PREFIX) { 1108 cm_ctx->disconnect_count--; 1109 } else { 1110 mlme_err(CM_PREFIX_FMT "Invalid prefix %x", 1111 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 1112 cm_req->cm_id), prefix); 1113 } 1114 1115 if (cm_id == cm_ctx->active_cm_id) 1116 cm_req_history_del(cm_ctx, cm_req, CM_REQ_DEL_ACTIVE); 1117 else 1118 cm_req_history_del(cm_ctx, cm_req, CM_REQ_DEL_PENDING); 1119 1120 mlme_debug(CM_PREFIX_FMT, 1121 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 1122 cm_req->cm_id)); 1123 1124 qdf_mem_free(cm_req); 1125 cm_req_lock_release(cm_ctx); 1126 1127 return QDF_STATUS_SUCCESS; 1128 } 1129 1130 void cm_remove_cmd(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id_to_remove) 1131 { 1132 struct wlan_objmgr_psoc *psoc; 1133 QDF_STATUS status; 1134 wlan_cm_id cm_id; 1135 1136 if (!cm_id_to_remove) { 1137 mlme_err("cm_id_to_remove is null"); 1138 return; 1139 } 1140 1141 /* 1142 * store local value as cm_delete_req_from_list may free the 1143 * cm_id_to_remove pointer 1144 */ 1145 cm_id = *cm_id_to_remove; 1146 /* return if zero or invalid cm_id */ 1147 if (!cm_id || cm_id == CM_ID_INVALID) { 1148 mlme_debug(CM_PREFIX_FMT " Invalid cm_id", 1149 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), 1150 cm_id)); 1151 return; 1152 } 1153 1154 psoc = wlan_vdev_get_psoc(cm_ctx->vdev); 1155 if (!psoc) { 1156 mlme_err(CM_PREFIX_FMT "Failed to find psoc", 1157 CM_PREFIX_REF(wlan_vdev_get_id(cm_ctx->vdev), cm_id)); 1158 return; 1159 } 1160 1161 status = cm_delete_req_from_list(cm_ctx, cm_id); 1162 if (QDF_IS_STATUS_ERROR(status)) 1163 return; 1164 1165 if (cm_is_link_switch_cmd(cm_id)) { 1166 mlme_debug("Skip cmd remove for link switch connect/disconnect"); 1167 return; 1168 } 1169 1170 cm_remove_cmd_from_serialization(cm_ctx, cm_id); 1171 } 1172 1173 void cm_vdev_scan_cancel(struct wlan_objmgr_pdev *pdev, 1174 struct wlan_objmgr_vdev *vdev) 1175 { 1176 struct scan_cancel_request *req; 1177 QDF_STATUS status; 1178 1179 req = qdf_mem_malloc(sizeof(*req)); 1180 if (!req) 1181 return; 1182 1183 req->vdev = vdev; 1184 req->cancel_req.scan_id = INVAL_SCAN_ID; 1185 req->cancel_req.vdev_id = wlan_vdev_get_id(vdev); 1186 req->cancel_req.pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1187 req->cancel_req.req_type = WLAN_SCAN_CANCEL_VDEV_ALL; 1188 1189 status = wlan_scan_cancel(req); 1190 /* In success/failure case wlan_scan_cancel free the req memory */ 1191 if (QDF_IS_STATUS_ERROR(status)) 1192 mlme_err("vdev %d cancel scan request failed", 1193 wlan_vdev_get_id(vdev)); 1194 } 1195 1196 void cm_set_max_connect_attempts(struct wlan_objmgr_vdev *vdev, 1197 uint8_t max_connect_attempts) 1198 { 1199 struct cnx_mgr *cm_ctx; 1200 1201 cm_ctx = cm_get_cm_ctx(vdev); 1202 if (!cm_ctx) 1203 return; 1204 1205 cm_ctx->max_connect_attempts = 1206 QDF_MIN(max_connect_attempts, CM_MAX_CONNECT_ATTEMPTS); 1207 mlme_debug("vdev %d max connect attempts set to %d, requested %d", 1208 wlan_vdev_get_id(vdev), 1209 cm_ctx->max_connect_attempts, max_connect_attempts); 1210 } 1211 1212 void cm_set_max_connect_timeout(struct wlan_objmgr_vdev *vdev, 1213 uint32_t max_connect_timeout) 1214 { 1215 struct cnx_mgr *cm_ctx; 1216 1217 cm_ctx = cm_get_cm_ctx(vdev); 1218 if (!cm_ctx) 1219 return; 1220 1221 cm_ctx->connect_timeout = max_connect_timeout; 1222 } 1223 1224 QDF_STATUS 1225 cm_fill_disconnect_resp_from_cm_id(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id, 1226 struct wlan_cm_discon_rsp *resp) 1227 { 1228 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1229 struct cm_req *cm_req; 1230 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 1231 1232 if (prefix != DISCONNECT_REQ_PREFIX) 1233 return QDF_STATUS_E_INVAL; 1234 1235 cm_req_lock_acquire(cm_ctx); 1236 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1237 while (cur_node) { 1238 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1239 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1240 1241 if (cm_req->cm_id == cm_id) { 1242 resp->req.cm_id = cm_id; 1243 resp->req.req = cm_req->discon_req.req; 1244 cm_req_lock_release(cm_ctx); 1245 return QDF_STATUS_SUCCESS; 1246 } 1247 1248 cur_node = next_node; 1249 next_node = NULL; 1250 } 1251 cm_req_lock_release(cm_ctx); 1252 1253 return QDF_STATUS_E_FAILURE; 1254 } 1255 1256 void cm_inform_bcn_probe(struct cnx_mgr *cm_ctx, uint8_t *bcn_probe, 1257 uint32_t len, qdf_freq_t freq, int32_t rssi, 1258 wlan_cm_id cm_id) 1259 { 1260 qdf_nbuf_t buf; 1261 struct wlan_objmgr_pdev *pdev; 1262 uint8_t *data, i, vdev_id; 1263 struct mgmt_rx_event_params rx_param = {0}; 1264 struct wlan_frame_hdr *hdr; 1265 enum mgmt_frame_type frm_type = MGMT_BEACON; 1266 1267 vdev_id = wlan_vdev_get_id(cm_ctx->vdev); 1268 if (!bcn_probe || !len || (len < sizeof(*hdr))) { 1269 mlme_err(CM_PREFIX_FMT "bcn_probe is null or invalid len %d", 1270 CM_PREFIX_REF(vdev_id, cm_id), len); 1271 return; 1272 } 1273 1274 pdev = wlan_vdev_get_pdev(cm_ctx->vdev); 1275 if (!pdev) { 1276 mlme_err(CM_PREFIX_FMT "Failed to find pdev", 1277 CM_PREFIX_REF(vdev_id, cm_id)); 1278 return; 1279 } 1280 1281 hdr = (struct wlan_frame_hdr *)bcn_probe; 1282 if ((hdr->i_fc[0] & QDF_IEEE80211_FC0_SUBTYPE_MASK) == 1283 MGMT_SUBTYPE_PROBE_RESP) 1284 frm_type = MGMT_PROBE_RESP; 1285 1286 rx_param.pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1287 rx_param.chan_freq = freq; 1288 rx_param.rssi = rssi; 1289 1290 /* Set all per chain rssi as invalid */ 1291 for (i = 0; i < WLAN_MGMT_TXRX_HOST_MAX_ANTENNA; i++) 1292 rx_param.rssi_ctl[i] = WLAN_INVALID_PER_CHAIN_RSSI; 1293 1294 buf = qdf_nbuf_alloc(NULL, qdf_roundup(len, 4), 0, 4, false); 1295 if (!buf) 1296 return; 1297 1298 qdf_nbuf_put_tail(buf, len); 1299 qdf_nbuf_set_protocol(buf, ETH_P_CONTROL); 1300 1301 data = qdf_nbuf_data(buf); 1302 qdf_mem_copy(data, bcn_probe, len); 1303 /* buf will be freed by scan module in error or success case */ 1304 wlan_scan_process_bcn_probe_rx_sync(wlan_pdev_get_psoc(pdev), buf, 1305 &rx_param, frm_type); 1306 } 1307 1308 bool cm_is_vdev_connecting(struct wlan_objmgr_vdev *vdev) 1309 { 1310 struct cnx_mgr *cm_ctx; 1311 enum wlan_cm_sm_state state; 1312 1313 cm_ctx = cm_get_cm_ctx(vdev); 1314 if (!cm_ctx) 1315 return false; 1316 1317 state = cm_get_state(cm_ctx); 1318 1319 if (state == WLAN_CM_S_CONNECTING) 1320 return true; 1321 1322 return false; 1323 } 1324 1325 bool cm_is_vdev_connected(struct wlan_objmgr_vdev *vdev) 1326 { 1327 struct cnx_mgr *cm_ctx; 1328 enum wlan_cm_sm_state state; 1329 1330 cm_ctx = cm_get_cm_ctx(vdev); 1331 if (!cm_ctx) 1332 return false; 1333 1334 state = cm_get_state(cm_ctx); 1335 1336 if (state == WLAN_CM_S_CONNECTED) 1337 return true; 1338 1339 return false; 1340 } 1341 1342 bool cm_is_vdev_active(struct wlan_objmgr_vdev *vdev) 1343 { 1344 struct cnx_mgr *cm_ctx; 1345 enum wlan_cm_sm_state state; 1346 1347 cm_ctx = cm_get_cm_ctx(vdev); 1348 if (!cm_ctx) 1349 return false; 1350 1351 state = cm_get_state(cm_ctx); 1352 1353 if (state == WLAN_CM_S_CONNECTED || state == WLAN_CM_S_ROAMING) 1354 return true; 1355 1356 return false; 1357 } 1358 1359 bool cm_is_vdev_disconnecting(struct wlan_objmgr_vdev *vdev) 1360 { 1361 struct cnx_mgr *cm_ctx; 1362 enum wlan_cm_sm_state state; 1363 1364 cm_ctx = cm_get_cm_ctx(vdev); 1365 if (!cm_ctx) 1366 return false; 1367 1368 state = cm_get_state(cm_ctx); 1369 1370 if (state == WLAN_CM_S_DISCONNECTING) 1371 return true; 1372 1373 return false; 1374 } 1375 1376 bool cm_is_vdev_disconnected(struct wlan_objmgr_vdev *vdev) 1377 { 1378 struct cnx_mgr *cm_ctx; 1379 enum wlan_cm_sm_state state; 1380 1381 cm_ctx = cm_get_cm_ctx(vdev); 1382 if (!cm_ctx) 1383 return true; 1384 1385 state = cm_get_state(cm_ctx); 1386 1387 if (state == WLAN_CM_S_INIT) 1388 return true; 1389 1390 return false; 1391 } 1392 1393 #ifdef CONN_MGR_ADV_FEATURE 1394 bool cm_is_vdev_idle_due_to_link_switch(struct wlan_objmgr_vdev *vdev) 1395 { 1396 struct cnx_mgr *cm_ctx; 1397 enum wlan_cm_sm_state state; 1398 enum wlan_cm_sm_state sub_state; 1399 1400 cm_ctx = cm_get_cm_ctx(vdev); 1401 if (!cm_ctx) 1402 return false; 1403 1404 state = cm_get_state(cm_ctx); 1405 sub_state = cm_get_sub_state(cm_ctx); 1406 1407 if (state == WLAN_CM_S_INIT && 1408 sub_state == WLAN_CM_SS_IDLE_DUE_TO_LINK_SWITCH) 1409 return true; 1410 1411 return false; 1412 } 1413 #endif 1414 1415 bool cm_is_vdev_roaming(struct wlan_objmgr_vdev *vdev) 1416 { 1417 struct cnx_mgr *cm_ctx; 1418 enum wlan_cm_sm_state state; 1419 1420 cm_ctx = cm_get_cm_ctx(vdev); 1421 if (!cm_ctx) 1422 return false; 1423 1424 state = cm_get_state(cm_ctx); 1425 1426 if (state == WLAN_CM_S_ROAMING) 1427 return true; 1428 1429 return false; 1430 } 1431 1432 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 1433 bool cm_is_vdev_roam_started(struct wlan_objmgr_vdev *vdev) 1434 { 1435 struct cnx_mgr *cm_ctx; 1436 enum wlan_cm_sm_state state; 1437 enum wlan_cm_sm_state sub_state; 1438 1439 cm_ctx = cm_get_cm_ctx(vdev); 1440 if (!cm_ctx) 1441 return false; 1442 1443 state = cm_get_state(cm_ctx); 1444 sub_state = cm_get_sub_state(cm_ctx); 1445 if (state == WLAN_CM_S_ROAMING && sub_state == WLAN_CM_SS_ROAM_STARTED) 1446 return true; 1447 1448 return false; 1449 } 1450 1451 bool cm_is_vdev_roam_sync_inprogress(struct wlan_objmgr_vdev *vdev) 1452 { 1453 struct cnx_mgr *cm_ctx; 1454 enum wlan_cm_sm_state state; 1455 enum wlan_cm_sm_state sub_state; 1456 1457 cm_ctx = cm_get_cm_ctx(vdev); 1458 if (!cm_ctx) 1459 return false; 1460 1461 state = cm_get_state(cm_ctx); 1462 sub_state = cm_get_sub_state(cm_ctx); 1463 if (state == WLAN_CM_S_ROAMING && sub_state == WLAN_CM_SS_ROAM_SYNC) 1464 return true; 1465 1466 return false; 1467 } 1468 #endif 1469 1470 #ifdef WLAN_FEATURE_HOST_ROAM 1471 bool cm_is_vdev_roam_preauth_state(struct wlan_objmgr_vdev *vdev) 1472 { 1473 struct cnx_mgr *cm_ctx; 1474 enum wlan_cm_sm_state state; 1475 enum wlan_cm_sm_state sub_state; 1476 1477 cm_ctx = cm_get_cm_ctx(vdev); 1478 if (!cm_ctx) 1479 return false; 1480 1481 state = cm_get_state(cm_ctx); 1482 sub_state = cm_get_sub_state(cm_ctx); 1483 if (state == WLAN_CM_S_ROAMING && sub_state == WLAN_CM_SS_PREAUTH) 1484 return true; 1485 1486 return false; 1487 } 1488 1489 bool cm_is_vdev_roam_reassoc_state(struct wlan_objmgr_vdev *vdev) 1490 { 1491 struct cnx_mgr *cm_ctx; 1492 enum wlan_cm_sm_state state; 1493 enum wlan_cm_sm_state sub_state; 1494 1495 cm_ctx = cm_get_cm_ctx(vdev); 1496 if (!cm_ctx) 1497 return false; 1498 1499 state = cm_get_state(cm_ctx); 1500 sub_state = cm_get_sub_state(cm_ctx); 1501 if (state == WLAN_CM_S_ROAMING && sub_state == WLAN_CM_SS_REASSOC) 1502 return true; 1503 1504 return false; 1505 } 1506 #endif 1507 1508 enum wlan_cm_active_request_type 1509 cm_get_active_req_type(struct wlan_objmgr_vdev *vdev) 1510 { 1511 struct cnx_mgr *cm_ctx; 1512 wlan_cm_id cm_id; 1513 uint32_t active_req_prefix = 0; 1514 1515 cm_ctx = cm_get_cm_ctx(vdev); 1516 if (!cm_ctx) 1517 return CM_NONE; 1518 1519 cm_id = cm_ctx->active_cm_id; 1520 1521 if (cm_id != CM_ID_INVALID) 1522 active_req_prefix = CM_ID_GET_PREFIX(cm_id); 1523 1524 if (active_req_prefix == CONNECT_REQ_PREFIX) 1525 return CM_CONNECT_ACTIVE; 1526 else if (active_req_prefix == DISCONNECT_REQ_PREFIX) 1527 return CM_DISCONNECT_ACTIVE; 1528 else if (active_req_prefix == ROAM_REQ_PREFIX) 1529 return CM_ROAM_ACTIVE; 1530 else 1531 return CM_NONE; 1532 } 1533 1534 #ifdef WLAN_FEATURE_11BE_MLO 1535 static inline 1536 void cm_fill_ml_partner_info(struct wlan_cm_connect_req *req, 1537 struct wlan_cm_vdev_connect_req *connect_req) 1538 { 1539 if (req->ml_parnter_info.num_partner_links) 1540 qdf_mem_copy(&connect_req->ml_parnter_info, 1541 &req->ml_parnter_info, 1542 sizeof(struct mlo_partner_info)); 1543 } 1544 #else 1545 static inline 1546 void cm_fill_ml_partner_info(struct wlan_cm_connect_req *req, 1547 struct wlan_cm_vdev_connect_req *connect_req) 1548 { 1549 } 1550 #endif 1551 1552 bool cm_find_bss_from_candidate_list(qdf_list_t *candidate_list, 1553 struct qdf_mac_addr *bssid, 1554 struct scan_cache_node **entry_found) 1555 { 1556 struct scan_cache_node *scan_entry; 1557 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1558 struct qdf_mac_addr *bssid2; 1559 1560 if (qdf_is_macaddr_zero(bssid) || 1561 qdf_is_macaddr_broadcast(bssid)) 1562 return false; 1563 1564 if (qdf_list_peek_front(candidate_list, &cur_node) != 1565 QDF_STATUS_SUCCESS) { 1566 mlme_err("failed to peer front of candidate_list"); 1567 return false; 1568 } 1569 1570 while (cur_node) { 1571 qdf_list_peek_next(candidate_list, cur_node, &next_node); 1572 1573 scan_entry = qdf_container_of(cur_node, struct scan_cache_node, 1574 node); 1575 bssid2 = &scan_entry->entry->bssid; 1576 if (qdf_is_macaddr_zero(bssid2)) 1577 goto next; 1578 1579 if (qdf_is_macaddr_equal(bssid, bssid2)) { 1580 if (entry_found) 1581 *entry_found = scan_entry; 1582 return true; 1583 } 1584 next: 1585 cur_node = next_node; 1586 next_node = NULL; 1587 } 1588 1589 return false; 1590 } 1591 1592 bool cm_is_connect_req_reassoc(struct wlan_cm_connect_req *req) 1593 { 1594 if (!qdf_is_macaddr_zero(&req->prev_bssid) && 1595 (!qdf_is_macaddr_zero(&req->bssid) || 1596 !qdf_is_macaddr_zero(&req->bssid_hint)) && 1597 (req->chan_freq || req->chan_freq_hint)) 1598 return true; 1599 1600 return false; 1601 } 1602 1603 bool cm_is_first_candidate_connect_attempt(struct wlan_objmgr_vdev *vdev) 1604 { 1605 struct cnx_mgr *cm_ctx; 1606 struct cm_req *cm_req; 1607 bool status = false; 1608 1609 cm_ctx = cm_get_cm_ctx(vdev); 1610 if (!cm_ctx) 1611 return status; 1612 1613 cm_req_lock_acquire(cm_ctx); 1614 cm_req = cm_get_req_by_cm_id(cm_ctx, cm_ctx->active_cm_id); 1615 if (!cm_req) 1616 goto out; 1617 1618 if (cm_req->connect_req.cur_candidate_retries || 1619 cm_req->connect_req.connect_attempts > 1) 1620 goto out; 1621 1622 status = true; 1623 1624 out: 1625 cm_req_lock_release(cm_ctx); 1626 return status; 1627 } 1628 1629 QDF_STATUS 1630 cm_get_active_connect_req_param(struct wlan_objmgr_vdev *vdev, 1631 struct wlan_cm_connect_req *req) 1632 { 1633 struct cnx_mgr *cm_ctx; 1634 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1635 struct cm_req *cm_req = NULL; 1636 QDF_STATUS status = QDF_STATUS_E_FAILURE; 1637 uint32_t cm_id_prefix; 1638 1639 cm_ctx = cm_get_cm_ctx(vdev); 1640 if (!cm_ctx) 1641 return QDF_STATUS_E_FAILURE; 1642 1643 cm_req_lock_acquire(cm_ctx); 1644 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1645 while (cur_node) { 1646 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1647 1648 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1649 cm_id_prefix = CM_ID_GET_PREFIX((cm_req->cm_id)); 1650 1651 if (cm_req->cm_id != cm_ctx->active_cm_id || 1652 cm_id_prefix != CONNECT_REQ_PREFIX) { 1653 cur_node = next_node; 1654 next_node = NULL; 1655 continue; 1656 } 1657 1658 *req = cm_req->connect_req.req; 1659 qdf_mem_zero(&req->assoc_ie, sizeof(struct element_info)); 1660 qdf_mem_zero(&req->scan_ie, sizeof(struct element_info)); 1661 if (cm_req->connect_req.req.assoc_ie.len) { 1662 req->assoc_ie.ptr = 1663 qdf_mem_malloc(cm_req->connect_req.req.assoc_ie.len); 1664 if (!req->assoc_ie.ptr) { 1665 status = QDF_STATUS_E_NOMEM; 1666 break; 1667 } 1668 qdf_mem_copy(req->assoc_ie.ptr, 1669 cm_req->connect_req.req.assoc_ie.ptr, 1670 cm_req->connect_req.req.assoc_ie.len); 1671 req->assoc_ie.len = 1672 cm_req->connect_req.req.assoc_ie.len; 1673 } 1674 1675 if (cm_req->connect_req.req.scan_ie.len) { 1676 req->scan_ie.ptr = 1677 qdf_mem_malloc(cm_req->connect_req.req.scan_ie.len); 1678 if (!req->scan_ie.ptr) { 1679 qdf_mem_free(req->assoc_ie.ptr); 1680 qdf_mem_zero(&req->assoc_ie, 1681 sizeof(struct element_info)); 1682 status = QDF_STATUS_E_NOMEM; 1683 break; 1684 } 1685 qdf_mem_copy(req->scan_ie.ptr, 1686 cm_req->connect_req.req.scan_ie.ptr, 1687 cm_req->connect_req.req.scan_ie.len); 1688 req->scan_ie.len = cm_req->connect_req.req.scan_ie.len; 1689 } 1690 1691 status = QDF_STATUS_SUCCESS; 1692 break; 1693 } 1694 1695 cm_req_lock_release(cm_ctx); 1696 return status; 1697 } 1698 1699 bool cm_get_active_connect_req(struct wlan_objmgr_vdev *vdev, 1700 struct wlan_cm_vdev_connect_req *req) 1701 { 1702 struct cnx_mgr *cm_ctx; 1703 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1704 struct cm_req *cm_req = NULL; 1705 bool status = false; 1706 uint32_t cm_id_prefix; 1707 1708 cm_ctx = cm_get_cm_ctx(vdev); 1709 if (!cm_ctx) 1710 return status; 1711 1712 cm_req_lock_acquire(cm_ctx); 1713 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1714 while (cur_node) { 1715 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1716 1717 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1718 cm_id_prefix = CM_ID_GET_PREFIX((cm_req->cm_id)); 1719 1720 if (cm_req->cm_id == cm_ctx->active_cm_id && 1721 cm_id_prefix == CONNECT_REQ_PREFIX) { 1722 req->vdev_id = wlan_vdev_get_id(vdev); 1723 req->cm_id = cm_req->connect_req.cm_id; 1724 req->bss = cm_req->connect_req.cur_candidate; 1725 req->is_wps_connection = 1726 cm_req->connect_req.req.is_wps_connection; 1727 req->is_osen_connection = 1728 cm_req->connect_req.req.is_osen_connection; 1729 req->is_non_assoc_link = cm_req->connect_req.req.is_non_assoc_link; 1730 cm_fill_ml_partner_info(&cm_req->connect_req.req, req); 1731 status = true; 1732 cm_req_lock_release(cm_ctx); 1733 return status; 1734 } 1735 1736 cur_node = next_node; 1737 next_node = NULL; 1738 } 1739 cm_req_lock_release(cm_ctx); 1740 1741 return status; 1742 } 1743 1744 bool cm_get_active_disconnect_req(struct wlan_objmgr_vdev *vdev, 1745 struct wlan_cm_vdev_discon_req *req) 1746 { 1747 struct cnx_mgr *cm_ctx; 1748 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1749 struct cm_req *cm_req = NULL; 1750 bool status = false; 1751 uint32_t cm_id_prefix; 1752 1753 cm_ctx = cm_get_cm_ctx(vdev); 1754 if (!cm_ctx) 1755 return status; 1756 1757 cm_req_lock_acquire(cm_ctx); 1758 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1759 while (cur_node) { 1760 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1761 1762 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1763 cm_id_prefix = CM_ID_GET_PREFIX((cm_req->cm_id)); 1764 1765 if (cm_req->cm_id == cm_ctx->active_cm_id && 1766 cm_id_prefix == DISCONNECT_REQ_PREFIX) { 1767 req->cm_id = cm_req->cm_id; 1768 req->req.vdev_id = wlan_vdev_get_id(vdev); 1769 req->req.source = cm_req->discon_req.req.source; 1770 req->req.reason_code = 1771 cm_req->discon_req.req.reason_code; 1772 req->req.bssid = cm_req->discon_req.req.bssid; 1773 req->req.is_no_disassoc_disconnect = 1774 cm_req->discon_req.req.is_no_disassoc_disconnect; 1775 status = true; 1776 cm_req_lock_release(cm_ctx); 1777 return status; 1778 } 1779 1780 cur_node = next_node; 1781 next_node = NULL; 1782 } 1783 cm_req_lock_release(cm_ctx); 1784 1785 return status; 1786 } 1787 1788 struct cm_req *cm_get_req_by_scan_id(struct cnx_mgr *cm_ctx, 1789 wlan_scan_id scan_id) 1790 { 1791 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1792 struct cm_req *cm_req; 1793 1794 cm_req_lock_acquire(cm_ctx); 1795 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1796 while (cur_node) { 1797 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1798 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1799 1800 if (cm_req->connect_req.scan_id == scan_id) { 1801 cm_req_lock_release(cm_ctx); 1802 return cm_req; 1803 } 1804 1805 cur_node = next_node; 1806 next_node = NULL; 1807 } 1808 cm_req_lock_release(cm_ctx); 1809 1810 return NULL; 1811 } 1812 1813 wlan_cm_id cm_get_cm_id_by_scan_id(struct cnx_mgr *cm_ctx, 1814 wlan_scan_id scan_id) 1815 { 1816 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1817 struct cm_req *cm_req; 1818 1819 cm_req_lock_acquire(cm_ctx); 1820 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1821 while (cur_node) { 1822 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1823 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1824 1825 if (cm_req->connect_req.scan_id == scan_id) { 1826 cm_req_lock_release(cm_ctx); 1827 return cm_req->cm_id; 1828 } 1829 1830 cur_node = next_node; 1831 next_node = NULL; 1832 } 1833 cm_req_lock_release(cm_ctx); 1834 1835 return CM_ID_INVALID; 1836 } 1837 1838 QDF_STATUS cm_get_rnr(struct wlan_objmgr_vdev *vdev, wlan_cm_id cm_id, 1839 struct reduced_neighbor_report *rnr) 1840 { 1841 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1842 struct cm_req *cm_req; 1843 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 1844 struct cnx_mgr *cm_ctx; 1845 1846 if (prefix != CONNECT_REQ_PREFIX) 1847 return QDF_STATUS_E_INVAL; 1848 1849 cm_ctx = cm_get_cm_ctx(vdev); 1850 if (!cm_ctx) 1851 return QDF_STATUS_E_INVAL; 1852 1853 cm_req_lock_acquire(cm_ctx); 1854 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1855 while (cur_node) { 1856 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1857 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1858 1859 if (cm_req->cm_id == cm_id) { 1860 if (!cm_req->connect_req.cur_candidate || 1861 !cm_req->connect_req.cur_candidate->entry) 1862 break; 1863 1864 qdf_mem_copy(rnr, 1865 &cm_req->connect_req.cur_candidate->entry->rnr, 1866 sizeof(*rnr)); 1867 cm_req_lock_release(cm_ctx); 1868 return QDF_STATUS_SUCCESS; 1869 } 1870 1871 cur_node = next_node; 1872 next_node = NULL; 1873 } 1874 cm_req_lock_release(cm_ctx); 1875 1876 return QDF_STATUS_E_FAILURE; 1877 } 1878 1879 struct scan_cache_entry * 1880 cm_get_curr_candidate_entry(struct wlan_objmgr_vdev *vdev, 1881 wlan_cm_id cm_id) 1882 { 1883 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 1884 struct cm_req *cm_req; 1885 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 1886 struct cnx_mgr *cm_ctx; 1887 struct scan_cache_entry *cur_entry, *entry = NULL; 1888 1889 if (prefix != CONNECT_REQ_PREFIX) 1890 return NULL; 1891 1892 cm_ctx = cm_get_cm_ctx(vdev); 1893 if (!cm_ctx) 1894 return NULL; 1895 1896 cm_req_lock_acquire(cm_ctx); 1897 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 1898 while (cur_node) { 1899 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 1900 cm_req = qdf_container_of(cur_node, struct cm_req, node); 1901 1902 if (cm_req->cm_id != cm_id) { 1903 cur_node = next_node; 1904 next_node = NULL; 1905 continue; 1906 } 1907 1908 if (!cm_req->connect_req.cur_candidate) 1909 break; 1910 1911 cur_entry = cm_req->connect_req.cur_candidate->entry; 1912 entry = util_scan_copy_cache_entry(cur_entry); 1913 break; 1914 } 1915 cm_req_lock_release(cm_ctx); 1916 1917 return entry; 1918 } 1919 1920 #ifdef WLAN_POLICY_MGR_ENABLE 1921 static void 1922 cm_get_pcl_chan_weigtage_for_sta(struct wlan_objmgr_pdev *pdev, 1923 struct pcl_freq_weight_list *pcl_lst, 1924 struct wlan_objmgr_vdev *vdev) 1925 { 1926 uint32_t num_entries = 0; 1927 uint8_t vdev_id; 1928 QDF_STATUS status; 1929 1930 if (!pcl_lst || !vdev) 1931 return; 1932 1933 vdev_id = wlan_vdev_get_id(vdev); 1934 1935 status = policy_mgr_get_pcl(wlan_pdev_get_psoc(pdev), 1936 PM_STA_MODE, 1937 pcl_lst->pcl_freq_list, 1938 &num_entries, 1939 pcl_lst->pcl_weight_list, 1940 NUM_CHANNELS, vdev_id); 1941 if (QDF_IS_STATUS_ERROR(status)) 1942 return; 1943 pcl_lst->num_of_pcl_channels = num_entries; 1944 } 1945 1946 void cm_calculate_scores(struct cnx_mgr *cm_ctx, 1947 struct wlan_objmgr_pdev *pdev, 1948 struct scan_filter *filter, qdf_list_t *list) 1949 { 1950 struct pcl_freq_weight_list *pcl_lst = NULL; 1951 1952 if (!filter->num_of_bssid) { 1953 pcl_lst = qdf_mem_malloc(sizeof(*pcl_lst)); 1954 cm_get_pcl_chan_weigtage_for_sta(pdev, pcl_lst, cm_ctx->vdev); 1955 if (pcl_lst && !pcl_lst->num_of_pcl_channels) { 1956 qdf_mem_free(pcl_lst); 1957 pcl_lst = NULL; 1958 } 1959 } 1960 wlan_cm_calculate_bss_score(pdev, pcl_lst, list, &filter->bssid_hint, 1961 (struct qdf_mac_addr *) 1962 wlan_vdev_mlme_get_macaddr(cm_ctx->vdev)); 1963 if (pcl_lst) 1964 qdf_mem_free(pcl_lst); 1965 } 1966 #else 1967 inline 1968 void cm_calculate_scores(struct cnx_mgr *cm_ctx, 1969 struct wlan_objmgr_pdev *pdev, 1970 struct scan_filter *filter, qdf_list_t *list) 1971 { 1972 wlan_cm_calculate_bss_score(pdev, NULL, list, &filter->bssid_hint, 1973 NULL); 1974 1975 /* 1976 * Custom sorting if enabled 1977 */ 1978 if (cm_ctx && cm_ctx->cm_candidate_list_custom_sort) 1979 cm_ctx->cm_candidate_list_custom_sort(cm_ctx->vdev, list); 1980 } 1981 #endif 1982 1983 #ifdef SM_ENG_HIST_ENABLE 1984 static const char *cm_id_to_string(wlan_cm_id cm_id) 1985 { 1986 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 1987 1988 switch (prefix) { 1989 case CONNECT_REQ_PREFIX: 1990 return "CONNECT"; 1991 case DISCONNECT_REQ_PREFIX: 1992 return "DISCONNECT"; 1993 case ROAM_REQ_PREFIX: 1994 return "ROAM"; 1995 default: 1996 return "INVALID"; 1997 } 1998 } 1999 2000 void cm_req_history_add(struct cnx_mgr *cm_ctx, 2001 struct cm_req *cm_req) 2002 { 2003 struct cm_req_history *history = &cm_ctx->req_history; 2004 struct cm_req_history_info *data; 2005 2006 qdf_spin_lock_bh(&history->cm_req_hist_lock); 2007 data = &history->data[history->index]; 2008 history->index++; 2009 history->index %= CM_REQ_HISTORY_SIZE; 2010 2011 qdf_mem_zero(data, sizeof(*data)); 2012 data->cm_id = cm_req->cm_id; 2013 data->add_time = qdf_get_log_timestamp(); 2014 data->add_cm_state = cm_get_state(cm_ctx); 2015 qdf_spin_unlock_bh(&history->cm_req_hist_lock); 2016 } 2017 2018 void cm_req_history_del(struct cnx_mgr *cm_ctx, 2019 struct cm_req *cm_req, 2020 enum cm_req_del_type del_type) 2021 { 2022 uint8_t i, idx; 2023 struct cm_req_history_info *data; 2024 struct cm_req_history *history = &cm_ctx->req_history; 2025 2026 qdf_spin_lock_bh(&history->cm_req_hist_lock); 2027 for (i = 0; i < CM_REQ_HISTORY_SIZE; i++) { 2028 if (history->index < i) 2029 idx = CM_REQ_HISTORY_SIZE + history->index - i; 2030 else 2031 idx = history->index - i; 2032 2033 data = &history->data[idx]; 2034 if (data->cm_id == cm_req->cm_id) { 2035 data->del_time = qdf_get_log_timestamp(); 2036 data->del_cm_state = cm_get_state(cm_ctx); 2037 data->del_type = del_type; 2038 break; 2039 } 2040 2041 if (!data->cm_id) 2042 break; 2043 } 2044 qdf_spin_unlock_bh(&history->cm_req_hist_lock); 2045 } 2046 2047 void cm_req_history_init(struct cnx_mgr *cm_ctx) 2048 { 2049 qdf_mem_zero(&cm_ctx->req_history, sizeof(struct cm_req_history)); 2050 qdf_spinlock_create(&cm_ctx->req_history.cm_req_hist_lock); 2051 } 2052 2053 void cm_req_history_deinit(struct cnx_mgr *cm_ctx) 2054 { 2055 qdf_spinlock_destroy(&cm_ctx->req_history.cm_req_hist_lock); 2056 } 2057 2058 static inline void cm_req_history_print_entry(uint16_t idx, 2059 struct cm_req_history_info *data) 2060 { 2061 if (!data->cm_id) 2062 return; 2063 2064 mlme_nofl_err(" |%6u | 0x%016llx | 0x%016llx |%12s | 0x%08x |%15s |%15s |%8u", 2065 idx, data->add_time, data->del_time, 2066 cm_id_to_string(data->cm_id), data->cm_id, 2067 cm_sm_info[data->add_cm_state].name, 2068 cm_sm_info[data->del_cm_state].name, 2069 data->del_type); 2070 } 2071 2072 void cm_req_history_print(struct cnx_mgr *cm_ctx) 2073 { 2074 struct cm_req_history *history = &cm_ctx->req_history; 2075 uint8_t i, idx; 2076 2077 mlme_nofl_err("CM Request history is as below"); 2078 mlme_nofl_err("|%6s |%19s |%19s |%12s |%11s |%15s |%15s |%8s", 2079 "Index", "Add Time", "Del Time", "Req type", 2080 "Cm Id", "Add State", "Del State", "Del Type"); 2081 2082 qdf_spin_lock_bh(&history->cm_req_hist_lock); 2083 for (i = 0; i < CM_REQ_HISTORY_SIZE; i++) { 2084 idx = (history->index + i) % CM_REQ_HISTORY_SIZE; 2085 cm_req_history_print_entry(idx, &history->data[idx]); 2086 } 2087 qdf_spin_unlock_bh(&history->cm_req_hist_lock); 2088 } 2089 #endif 2090 2091 #ifndef CONN_MGR_ADV_FEATURE 2092 void cm_set_candidate_advance_filter_cb( 2093 struct wlan_objmgr_vdev *vdev, 2094 void (*filter_fun)(struct wlan_objmgr_vdev *vdev, 2095 struct scan_filter *filter)) 2096 { 2097 struct cnx_mgr *cm_ctx; 2098 2099 cm_ctx = cm_get_cm_ctx(vdev); 2100 if (!cm_ctx) 2101 return; 2102 2103 cm_ctx->cm_candidate_advance_filter = filter_fun; 2104 } 2105 2106 void cm_set_candidate_custom_sort_cb( 2107 struct wlan_objmgr_vdev *vdev, 2108 void (*sort_fun)(struct wlan_objmgr_vdev *vdev, 2109 qdf_list_t *list)) 2110 { 2111 struct cnx_mgr *cm_ctx; 2112 2113 cm_ctx = cm_get_cm_ctx(vdev); 2114 if (!cm_ctx) 2115 return; 2116 2117 cm_ctx->cm_candidate_list_custom_sort = sort_fun; 2118 } 2119 #endif 2120 2121 #ifdef CONN_MGR_ADV_FEATURE 2122 #define CM_MIN_CANDIDATE_NUM 1 2123 2124 /** 2125 * cm_fill_connect_ies_from_rsp() - fill connect ies from response structure 2126 * @first_cand_rsp: first candidate connect failure response 2127 * @rsp: connect response 2128 * 2129 * This API fills roaming info for first candidate failure response from the 2130 * provided response. 2131 * 2132 * Return: void 2133 */ 2134 static 2135 void cm_fill_connect_ies_from_rsp(struct wlan_cm_connect_resp *first_cand_rsp, 2136 struct wlan_cm_connect_resp *rsp) 2137 { 2138 struct wlan_connect_rsp_ies *connect_ies; 2139 2140 connect_ies = &first_cand_rsp->connect_ies; 2141 2142 connect_ies->bcn_probe_rsp.ptr = NULL; 2143 connect_ies->link_bcn_probe_rsp.ptr = NULL; 2144 connect_ies->assoc_req.ptr = NULL; 2145 connect_ies->assoc_rsp.ptr = NULL; 2146 2147 /* Beacon/Probe Rsp frame */ 2148 if (rsp->connect_ies.bcn_probe_rsp.ptr && 2149 rsp->connect_ies.bcn_probe_rsp.len) { 2150 connect_ies->bcn_probe_rsp.ptr = 2151 qdf_mem_malloc(rsp->connect_ies.bcn_probe_rsp.len); 2152 if (connect_ies->bcn_probe_rsp.ptr) 2153 qdf_mem_copy(connect_ies->bcn_probe_rsp.ptr, 2154 rsp->connect_ies.bcn_probe_rsp.ptr, 2155 rsp->connect_ies.bcn_probe_rsp.len); 2156 else 2157 connect_ies->bcn_probe_rsp.len = 0; 2158 } 2159 2160 /* Link Beacon/Probe Rsp frame */ 2161 if (rsp->connect_ies.link_bcn_probe_rsp.ptr && 2162 rsp->connect_ies.link_bcn_probe_rsp.len) { 2163 connect_ies->link_bcn_probe_rsp.ptr = 2164 qdf_mem_malloc(rsp->connect_ies.link_bcn_probe_rsp.len); 2165 if (connect_ies->link_bcn_probe_rsp.ptr) 2166 qdf_mem_copy(connect_ies->link_bcn_probe_rsp.ptr, 2167 rsp->connect_ies.link_bcn_probe_rsp.ptr, 2168 rsp->connect_ies.link_bcn_probe_rsp.len); 2169 else 2170 connect_ies->link_bcn_probe_rsp.len = 0; 2171 } 2172 2173 /* Assoc Req IE data */ 2174 if (rsp->connect_ies.assoc_req.ptr && 2175 rsp->connect_ies.assoc_req.len) { 2176 connect_ies->assoc_req.ptr = 2177 qdf_mem_malloc(rsp->connect_ies.assoc_req.len); 2178 if (connect_ies->assoc_req.ptr) 2179 qdf_mem_copy(connect_ies->assoc_req.ptr, 2180 rsp->connect_ies.assoc_req.ptr, 2181 rsp->connect_ies.assoc_req.len); 2182 else 2183 connect_ies->assoc_req.len = 0; 2184 } 2185 2186 /* Assoc Rsp IE data */ 2187 if (rsp->connect_ies.assoc_rsp.ptr && 2188 rsp->connect_ies.assoc_rsp.len) { 2189 connect_ies->assoc_rsp.ptr = 2190 qdf_mem_malloc(rsp->connect_ies.assoc_rsp.len); 2191 if (connect_ies->assoc_rsp.ptr) 2192 qdf_mem_copy(connect_ies->assoc_rsp.ptr, 2193 rsp->connect_ies.assoc_rsp.ptr, 2194 rsp->connect_ies.assoc_rsp.len); 2195 else 2196 connect_ies->assoc_rsp.len = 0; 2197 } 2198 } 2199 2200 /** 2201 * cm_copy_rsp_from_rsp() - copy response from other response 2202 * @destination_rsp: destination connect response 2203 * @source_rsp: source connect response 2204 * 2205 * This API copies source response to destination response. 2206 * 2207 * Return: void 2208 */ 2209 static 2210 void cm_copy_rsp_from_rsp(struct wlan_cm_connect_resp *destination_rsp, 2211 struct wlan_cm_connect_resp *source_rsp) 2212 { 2213 *destination_rsp = *source_rsp; 2214 cm_fill_connect_ies_from_rsp(destination_rsp, source_rsp); 2215 } 2216 2217 void cm_store_first_candidate_rsp(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id, 2218 struct wlan_cm_connect_resp *resp) 2219 { 2220 struct wlan_cm_connect_resp *first_candid_rsp; 2221 uint8_t num_candidates; 2222 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 2223 struct cm_req *cm_req; 2224 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 2225 2226 if (prefix != CONNECT_REQ_PREFIX) 2227 return; 2228 2229 cm_req_lock_acquire(cm_ctx); 2230 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 2231 while (cur_node) { 2232 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 2233 cm_req = qdf_container_of(cur_node, struct cm_req, node); 2234 2235 if (cm_req->cm_id == cm_id) { 2236 /* 2237 * Do not cache response if first candidate response is 2238 * already stored. "first_candidate_rsp" pointer is 2239 * freed once connect request is completed and freed. 2240 */ 2241 if (cm_req->connect_req.first_candidate_rsp) 2242 break; 2243 2244 /* only cached for more than one candidate */ 2245 num_candidates = qdf_list_size( 2246 cm_req->connect_req.candidate_list); 2247 if (num_candidates <= CM_MIN_CANDIDATE_NUM) 2248 break; 2249 2250 first_candid_rsp = qdf_mem_malloc( 2251 sizeof(*first_candid_rsp)); 2252 if (!first_candid_rsp) 2253 break; 2254 2255 cm_copy_rsp_from_rsp(first_candid_rsp, resp); 2256 cm_req->connect_req.first_candidate_rsp = 2257 first_candid_rsp; 2258 mlme_debug(CM_PREFIX_FMT " " QDF_MAC_ADDR_FMT " with reason %d", 2259 CM_PREFIX_REF(first_candid_rsp->vdev_id, 2260 cm_id), 2261 QDF_MAC_ADDR_REF(first_candid_rsp->bssid.bytes), 2262 first_candid_rsp->reason); 2263 break; 2264 } 2265 2266 cur_node = next_node; 2267 next_node = NULL; 2268 } 2269 2270 cm_req_lock_release(cm_ctx); 2271 } 2272 2273 QDF_STATUS 2274 cm_get_first_candidate_rsp(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id, 2275 struct wlan_cm_connect_resp *first_candid_rsp) 2276 { 2277 qdf_list_node_t *cur_node = NULL, *next_node = NULL; 2278 struct cm_req *cm_req; 2279 uint32_t prefix = CM_ID_GET_PREFIX(cm_id); 2280 2281 if (prefix != CONNECT_REQ_PREFIX) 2282 return QDF_STATUS_E_INVAL; 2283 2284 cm_req_lock_acquire(cm_ctx); 2285 qdf_list_peek_front(&cm_ctx->req_list, &cur_node); 2286 while (cur_node) { 2287 qdf_list_peek_next(&cm_ctx->req_list, cur_node, &next_node); 2288 cm_req = qdf_container_of(cur_node, struct cm_req, node); 2289 2290 if (cm_req->cm_id == cm_id) { 2291 if (!cm_req->connect_req.first_candidate_rsp) 2292 break; 2293 2294 cm_copy_rsp_from_rsp(first_candid_rsp, 2295 cm_req->connect_req.first_candidate_rsp); 2296 2297 mlme_debug(CM_PREFIX_FMT " " QDF_MAC_ADDR_FMT "with reason %d", 2298 CM_PREFIX_REF(first_candid_rsp->vdev_id, 2299 cm_id), 2300 QDF_MAC_ADDR_REF(first_candid_rsp->bssid.bytes), 2301 first_candid_rsp->reason); 2302 2303 cm_req_lock_release(cm_ctx); 2304 return QDF_STATUS_SUCCESS; 2305 } 2306 2307 cur_node = next_node; 2308 next_node = NULL; 2309 } 2310 2311 cm_req_lock_release(cm_ctx); 2312 return QDF_STATUS_E_FAILURE; 2313 } 2314 2315 void cm_store_n_send_failed_candidate(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id) 2316 { 2317 struct wlan_cm_connect_resp resp = {0}; 2318 2319 cm_fill_failure_resp_from_cm_id(cm_ctx, &resp, cm_id, 2320 CM_VALID_CANDIDATE_CHECK_FAIL); 2321 cm_store_first_candidate_rsp(cm_ctx, cm_id, &resp); 2322 mlme_cm_osif_failed_candidate_ind(cm_ctx->vdev, &resp); 2323 } 2324 #endif /* CONN_MGR_ADV_FEATURE */ 2325 2326 #ifdef WLAN_CHIPSET_STATS 2327 void 2328 cm_cp_stats_cstats_log_connecting_event(struct wlan_objmgr_vdev *vdev, 2329 struct wlan_cm_vdev_connect_req *req, 2330 struct cm_req *cm_req) 2331 { 2332 struct cstats_sta_connect_req stat = {0}; 2333 2334 stat.cmn.hdr.evt_id = WLAN_CHIPSET_STATS_STA_CONNECTING_EVENT_ID; 2335 stat.cmn.hdr.length = sizeof(struct cstats_sta_connect_req) - 2336 sizeof(struct cstats_hdr); 2337 stat.cmn.opmode = wlan_vdev_mlme_get_opmode(vdev); 2338 stat.cmn.vdev_id = wlan_vdev_get_id(vdev); 2339 stat.cmn.timestamp_us = qdf_get_time_of_the_day_us(); 2340 stat.cmn.time_tick = qdf_get_log_timestamp(); 2341 stat.freq = req->bss->entry->channel.chan_freq; 2342 stat.ssid_len = cm_req->connect_req.req.ssid.length; 2343 qdf_mem_copy(&stat.ssid, cm_req->connect_req.req.ssid.ssid, 2344 cm_req->connect_req.req.ssid.length); 2345 CSTATS_MAC_COPY(stat.bssid, req->bss->entry->bssid.bytes); 2346 2347 wlan_cstats_host_stats(sizeof(struct cstats_sta_connect_req), &stat); 2348 } 2349 #endif /* WLAN_CHIPSET_STATS */ 2350