1 /* 2 * Copyright (c) 2012-2015, 2020-2021, The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 /** 18 * DOC: wlan_cm_main_api.h 19 * 20 * This header file maintain connect, disconnect APIs of connection manager 21 */ 22 23 #ifndef __WLAN_CM_MAIN_API_H__ 24 #define __WLAN_CM_MAIN_API_H__ 25 26 #include "wlan_cm_main.h" 27 #include "wlan_cm_sm.h" 28 #include <include/wlan_mlme_cmn.h> 29 #include <wlan_crypto_global_api.h> 30 #include <wlan_if_mgr_api.h> 31 #ifdef WLAN_CM_USE_SPINLOCK 32 #include <scheduler_api.h> 33 #endif 34 35 #define CONNECT_REQ_PREFIX 0x00C00000 36 #define DISCONNECT_REQ_PREFIX 0x00D00000 37 #define ROAM_REQ_PREFIX 0x00F00000 38 39 #define CM_ID_MASK 0x0000FFFF 40 41 #define CM_ID_GET_PREFIX(cm_id) cm_id & 0xFFFF0000 42 43 #define CM_PREFIX_FMT "vdev %d cm_id 0x%x: " 44 #define CM_PREFIX_REF(vdev_id, cm_id) (vdev_id), (cm_id) 45 46 /*************** CONNECT APIs ****************/ 47 48 /** 49 * cm_connect_start() - This API will be called to initiate the connect 50 * process 51 * @cm_ctx: connection manager context 52 * @req: Connect request. 53 * 54 * Return: QDF status 55 */ 56 QDF_STATUS cm_connect_start(struct cnx_mgr *cm_ctx, struct cm_connect_req *req); 57 58 /** 59 * cm_if_mgr_inform_connect_complete() - inform ifmanager the connect complete 60 * @vdev: vdev for which connect cmpleted 61 * @connect_status: connect status 62 * 63 * Return: QDF_STATUS 64 */ 65 QDF_STATUS cm_if_mgr_inform_connect_complete(struct wlan_objmgr_vdev *vdev, 66 QDF_STATUS connect_status); 67 68 /** 69 * cm_handle_connect_req_in_non_init_state() - Handle connect request in non 70 * init state. 71 * @cm_ctx: connection manager context 72 * @cm_req: cm request 73 * @cm_state_substate: state of CM SM 74 * 75 * Context: Can be called only while handling connection manager event 76 * ie holding state machine lock 77 * 78 * Return: QDF_STATUS 79 */ 80 QDF_STATUS 81 cm_handle_connect_req_in_non_init_state(struct cnx_mgr *cm_ctx, 82 struct cm_connect_req *cm_req, 83 enum wlan_cm_sm_state cm_state_substate); 84 85 /** 86 * cm_handle_discon_req_in_non_connected_state() - Handle disconnect req in non 87 * connected state. 88 * @cm_ctx: connection manager context 89 * @cm_req: cm request 90 * @cm_state_substate: state of CM SM 91 * 92 * Context: Can be called only while handling connection manager event 93 * ie holding state machine lock 94 * 95 * Return: QDF_STATUS 96 */ 97 QDF_STATUS 98 cm_handle_discon_req_in_non_connected_state(struct cnx_mgr *cm_ctx, 99 struct cm_disconnect_req *cm_req, 100 enum wlan_cm_sm_state cm_state_substate); 101 102 /** 103 * cm_connect_scan_start() - This API will be called to initiate the connect 104 * scan if no candidate are found in scan db. 105 * @cm_ctx: connection manager context 106 * @req: Connect request. 107 * 108 * Return: QDF status 109 */ 110 QDF_STATUS cm_connect_scan_start(struct cnx_mgr *cm_ctx, 111 struct cm_connect_req *req); 112 113 /** 114 * cm_connect_scan_resp() - Handle the connect scan resp and next action 115 * scan if no candidate are found in scan db. 116 * @scan_id: scan id of the req 117 * @status: Connect scan status 118 * 119 * Return: QDF status 120 */ 121 QDF_STATUS cm_connect_scan_resp(struct cnx_mgr *cm_ctx, wlan_scan_id *scan_id, 122 QDF_STATUS status); 123 124 /** 125 * cm_connect_handle_event_post_fail() - initiate connect failure if msg posting 126 * to SM fails 127 * @cm_ctx: connection manager context 128 * @cm_id: cm_id for connect req for which post fails 129 * 130 * Context: Can be called from any context and to be used only after posting a 131 * msg to SM fails from external event e.g. peer create resp, 132 * HW mode change resp serialization cb. 133 * 134 * Return: QDF_STATUS 135 */ 136 void 137 cm_connect_handle_event_post_fail(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id); 138 139 /** 140 * wlan_cm_scan_cb() - Callback function for scan for ssid 141 * @vdev: VDEV MLME comp object 142 * @event: scan event definition 143 * @arg: reference to connection manager context 144 * 145 * API handles scan success/failure case 146 * 147 * Context: Can be called from any context. 148 * Return: None 149 */ 150 void wlan_cm_scan_cb(struct wlan_objmgr_vdev *vdev, 151 struct scan_event *event, void *arg); 152 153 /** 154 * cm_connect_resp_cmid_match_list_head() - Check if resp cmid is same as list 155 * head 156 * @cm_ctx: connection manager context 157 * @resp: connect resp 158 * 159 * Return: bool 160 */ 161 bool cm_connect_resp_cmid_match_list_head(struct cnx_mgr *cm_ctx, 162 struct wlan_cm_connect_resp *resp); 163 164 /** 165 * cm_connect_active() - This API would be called after the connect 166 * request gets activated in serialization. 167 * @cm_ctx: connection manager context 168 * @cm_id: Connection mgr ID assigned to this connect request. 169 * 170 * Return: QDF status 171 */ 172 QDF_STATUS cm_connect_active(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id); 173 174 /** 175 * cm_try_next_candidate() - This API would try to connect to next valid 176 * candidate and fail if no candidate left 177 * request gets activated in serialization. 178 * @cm_ctx: connection manager context 179 * @connect_resp: connect resp. 180 * 181 * Return: QDF status 182 */ 183 QDF_STATUS cm_try_next_candidate(struct cnx_mgr *cm_ctx, 184 struct wlan_cm_connect_resp *connect_resp); 185 186 /** 187 * cm_resume_connect_after_peer_create() - Called after bss create rsp 188 * @cm_ctx: connection manager context 189 * @cm_id: Connection mgr ID assigned to this connect request. 190 * 191 * Return: QDF status 192 */ 193 QDF_STATUS 194 cm_resume_connect_after_peer_create(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id); 195 196 /** 197 * cm_bss_peer_create_rsp() - handle bss peer create response 198 * @vdev: vdev 199 * @status: bss peer create status 200 * @peer_mac: peer mac 201 * 202 * Return: QDF status 203 */ 204 QDF_STATUS cm_bss_peer_create_rsp(struct wlan_objmgr_vdev *vdev, 205 QDF_STATUS status, 206 struct qdf_mac_addr *peer_mac); 207 208 /** 209 * cm_connect_rsp() - Connection manager connect response 210 * @vdev: vdev pointer 211 * @resp: Connect response 212 * 213 * Return: QDF_STATUS 214 */ 215 QDF_STATUS cm_connect_rsp(struct wlan_objmgr_vdev *vdev, 216 struct wlan_cm_connect_resp *resp); 217 218 /** 219 * cm_notify_connect_complete() - This API would be called for sending 220 * connect response notification 221 * @cm_ctx: connection manager context 222 * @resp: connection complete resp. 223 * 224 * This API would be called after connection completion resp from VDEV mgr 225 * 226 * Return: QDF status 227 */ 228 QDF_STATUS cm_notify_connect_complete(struct cnx_mgr *cm_ctx, 229 struct wlan_cm_connect_resp *resp); 230 /** 231 * cm_connect_complete() - This API would be called after connect complete 232 * request from the serialization. 233 * @cm_ctx: connection manager context 234 * @resp: Connection complete resp. 235 * 236 * This API would be called after connection completion resp from VDEV mgr 237 * 238 * Return: QDF status 239 */ 240 QDF_STATUS cm_connect_complete(struct cnx_mgr *cm_ctx, 241 struct wlan_cm_connect_resp *resp); 242 243 /** 244 * cm_add_connect_req_to_list() - add connect req to the connection manager 245 * req list 246 * @vdev: vdev on which connect is received 247 * @req: Connection req provided 248 * 249 * Return: QDF status 250 */ 251 QDF_STATUS cm_add_connect_req_to_list(struct cnx_mgr *cm_ctx, 252 struct cm_connect_req *req); 253 254 /** 255 * cm_connect_start_req() - Connect start req from the requester 256 * @vdev: vdev on which connect is received 257 * @req: Connection req provided 258 * 259 * Return: QDF status 260 */ 261 QDF_STATUS cm_connect_start_req(struct wlan_objmgr_vdev *vdev, 262 struct wlan_cm_connect_req *req); 263 264 /** 265 * cm_send_connect_start_fail() - initiate connect failure 266 * @cm_ctx: connection manager context 267 * @req: connect req for which connect failed 268 * @reason: failure reason 269 * 270 * Context: Can be called from any context and to be used only after posting a 271 * msg to SM (ie holding the SM lock) to avoid use after free for req. 272 * 273 * Return: QDF_STATUS 274 */ 275 QDF_STATUS 276 cm_send_connect_start_fail(struct cnx_mgr *cm_ctx, 277 struct cm_connect_req *req, 278 enum wlan_cm_connect_fail_reason reason); 279 280 #ifdef WLAN_POLICY_MGR_ENABLE 281 /** 282 * cm_hw_mode_change_resp() - HW mode change response 283 * @pdev: pdev pointer 284 * @vdev_id: vdev id 285 * @cm_id: connection ID which gave the hw mode change request 286 * @status: status of the HW mode change. 287 * 288 * Return: void 289 */ 290 void cm_hw_mode_change_resp(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 291 wlan_cm_id cm_id, QDF_STATUS status); 292 293 /** 294 * cm_handle_hw_mode_change() - SM handling of hw mode change resp 295 * @cm_ctx: connection manager context 296 * @cm_id: Connection mgr ID assigned to this connect request. 297 * @event: HW mode success or failure event 298 * 299 * Return: QDF_STATUS 300 */ 301 QDF_STATUS cm_handle_hw_mode_change(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id, 302 enum wlan_cm_sm_evt event); 303 #else 304 static inline 305 QDF_STATUS cm_handle_hw_mode_change(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id, 306 enum wlan_cm_sm_evt event) 307 { 308 return QDF_STATUS_SUCCESS; 309 } 310 #endif 311 312 /*************** DISCONNECT APIs ****************/ 313 314 /** 315 * cm_disconnect_start() - Initiate the disconnect process 316 * @cm_ctx: connection manager context 317 * @req: Disconnect request. 318 * 319 * Return: QDF status 320 */ 321 QDF_STATUS cm_disconnect_start(struct cnx_mgr *cm_ctx, 322 struct cm_disconnect_req *req); 323 324 /** 325 * cm_disconnect_active() - This API would be called after the disconnect 326 * request gets activated in serialization. 327 * @cm_ctx: connection manager context 328 * @cm_id: Connection mgr ID assigned to this connect request. 329 * 330 * Return: QDF status 331 */ 332 QDF_STATUS cm_disconnect_active(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id); 333 334 /** 335 * cm_notify_disconnect_complete() - This API would be called for sending 336 * disconnect response notification 337 * @cm_ctx: connection manager context 338 * @resp: disconnection complete resp. 339 * 340 * This API would be called after disconnect completion resp from VDEV mgr 341 * 342 * Return: QDF status 343 */ 344 QDF_STATUS cm_notify_disconnect_complete(struct cnx_mgr *cm_ctx, 345 struct wlan_cm_discon_rsp *resp); 346 /** 347 * cm_disconnect_complete() - This API would be called after disconnect complete 348 * request from the serialization. 349 * @cm_ctx: connection manager context 350 * @resp: disconnection complete resp. 351 * 352 * This API would be called after connection completion resp from VDEV mgr 353 * 354 * Return: QDF status 355 */ 356 QDF_STATUS cm_disconnect_complete(struct cnx_mgr *cm_ctx, 357 struct wlan_cm_discon_rsp *resp); 358 359 /** 360 * cm_add_disconnect_req_to_list() - add disconnect req to the connection 361 * manager req list 362 * @vdev: vdev on which connect is received 363 * @req: Disconnection req provided 364 * 365 * Return: QDF status 366 */ 367 QDF_STATUS cm_add_disconnect_req_to_list(struct cnx_mgr *cm_ctx, 368 struct cm_disconnect_req *req); 369 370 /** 371 * cm_disconnect_start_req() - Disconnect start req from the requester 372 * @vdev: vdev on which connect is received 373 * @req: disconnection req provided 374 * 375 * Return: QDF status 376 */ 377 QDF_STATUS cm_disconnect_start_req(struct wlan_objmgr_vdev *vdev, 378 struct wlan_cm_disconnect_req *req); 379 380 /** 381 * cm_disconnect_start_req_sync() - disconnect request with wait till 382 * completed 383 * @vdev: vdev pointer 384 * @req: disconnect req 385 * 386 * Context: Only call for north bound disconnect req, if wait till complete 387 * is required, e.g. during vdev delete. Do not call from scheduler context. 388 * 389 * Return: QDF_STATUS 390 */ 391 QDF_STATUS cm_disconnect_start_req_sync(struct wlan_objmgr_vdev *vdev, 392 struct wlan_cm_disconnect_req *req); 393 394 /** 395 * cm_bss_peer_delete_req() - Connection manager bss peer delete 396 * request 397 * @vdev: VDEV object 398 * @peer_mac: Peer mac address 399 * 400 * This function is called on peer delete indication and sends peer delete 401 * request to mlme. 402 * 403 * Context: Any context. 404 * 405 * Return: QDF_STATUS 406 */ 407 QDF_STATUS cm_bss_peer_delete_req(struct wlan_objmgr_vdev *vdev, 408 struct qdf_mac_addr *peer_mac); 409 410 /** 411 * cm_vdev_down_req() - Connection manager req to send vdev down to FW 412 * @vdev: VDEV object 413 * @status: status 414 * 415 * This function is called when peer delete response is received, to send 416 * vdev down request to mlme 417 * 418 * Context: Any context. 419 * 420 * Return: QDF_STATUS 421 */ 422 QDF_STATUS cm_vdev_down_req(struct wlan_objmgr_vdev *vdev, uint32_t status); 423 424 /** 425 * cm_disconnect_rsp() - Connection manager api to post connect event 426 * @vdev: VDEV object 427 * @cm_discon_rsp: Disconnect response 428 * 429 * This function is called when disconnecte response is received, to deliver 430 * disconnect event to SM 431 * 432 * Context: Any context. 433 * 434 * Return: QDF_STATUS 435 */ 436 QDF_STATUS cm_disconnect_rsp(struct wlan_objmgr_vdev *vdev, 437 struct wlan_cm_discon_rsp *resp); 438 439 /** 440 * cm_initiate_internal_disconnect() - Initiate internal disconnect to cleanup 441 * a active connect in case of back to back request 442 * @cm_ctx: connection manager context 443 * 444 * Context: Can be called from any context. Hold the SM lock while calling this 445 * api. 446 * 447 * Return: void 448 */ 449 void cm_initiate_internal_disconnect(struct cnx_mgr *cm_ctx); 450 451 /** 452 * cm_send_disconnect_resp() - Initiate disconnect resp for the cm_id 453 * @cm_ctx: connection manager context 454 * @cm_id: cm id to send disconnect resp for 455 * 456 * Context: Can be called from any context. Hold the SM lock while calling this 457 * api. 458 * 459 * Return: void 460 */ 461 void cm_send_disconnect_resp(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id); 462 463 /*************** UTIL APIs ****************/ 464 465 /** 466 * cm_ser_get_blocking_cmd() - check if serialization command needs to be 467 * blocking 468 * 469 * Return: bool 470 */ 471 #ifdef CONN_MGR_ADV_FEATURE 472 static inline bool cm_ser_get_blocking_cmd(void) 473 { 474 return true; 475 } 476 #else 477 static inline bool cm_ser_get_blocking_cmd(void) 478 { 479 return false; 480 } 481 #endif 482 483 /** 484 * cm_get_cm_id() - Get unique cm id for connect/disconnect request 485 * @cm_ctx: connection manager context 486 * @source: source of the request (can be connect or disconnect request) 487 * 488 * Return: cm id 489 */ 490 wlan_cm_id cm_get_cm_id(struct cnx_mgr *cm_ctx, enum wlan_cm_source source); 491 492 struct cnx_mgr *cm_get_cm_ctx_fl(struct wlan_objmgr_vdev *vdev, 493 const char *func, uint32_t line); 494 495 /** 496 * cm_get_cm_ctx() - Get connection manager context from vdev 497 * @vdev: vdev object pointer 498 * 499 * Return: pointer to connection manager context 500 */ 501 #define cm_get_cm_ctx(vdev) \ 502 cm_get_cm_ctx_fl(vdev, __func__, __LINE__) 503 504 cm_ext_t *cm_get_ext_hdl_fl(struct wlan_objmgr_vdev *vdev, 505 const char *func, uint32_t line); 506 507 /** 508 * cm_get_ext_hdl() - Get connection manager ext context from vdev 509 * @vdev: vdev object pointer 510 * 511 * Return: pointer to connection manager ext context 512 */ 513 #define cm_get_ext_hdl(vdev) \ 514 cm_get_ext_hdl_fl(vdev, __func__, __LINE__) 515 516 /** 517 * cm_reset_active_cm_id() - Reset active cm_id from cm context, if its same as 518 * passed cm_id 519 * @vdev: vdev object pointer 520 * @cm_id: cmid to match 521 * 522 * Return: void 523 */ 524 void cm_reset_active_cm_id(struct wlan_objmgr_vdev *vdev, wlan_cm_id cm_id); 525 526 #ifdef CRYPTO_SET_KEY_CONVERGED 527 /** 528 * cm_set_key() - set wep or fils key on connection completion 529 * @cm_ctx: connection manager context 530 * @unicast: if key is unicast 531 * @key_idx: Key index 532 * @bssid: bssid of the connected AP 533 * 534 * Return: void 535 */ 536 QDF_STATUS cm_set_key(struct cnx_mgr *cm_ctx, bool unicast, 537 uint8_t key_idx, struct qdf_mac_addr *bssid); 538 #endif 539 540 #ifdef CONN_MGR_ADV_FEATURE 541 /** 542 * cm_store_wep_key() - store wep keys in crypto on connect active 543 * @cm_ctx: connection manager context 544 * @crypto: connection crypto info 545 * @cm_id: cm_id of the connection 546 * 547 * Return: void 548 */ 549 void cm_store_wep_key(struct cnx_mgr *cm_ctx, 550 struct wlan_cm_connect_crypto_info *crypto, 551 wlan_cm_id cm_id); 552 553 /** 554 * cm_inform_blm_connect_complete() - inform bsl about connect complete 555 * @vdev: vdev 556 * @resp: connect resp 557 * 558 * Return: QDF_STATUS 559 */ 560 QDF_STATUS 561 cm_inform_blm_connect_complete(struct wlan_objmgr_vdev *vdev, 562 struct wlan_cm_connect_resp *resp); 563 564 static inline QDF_STATUS 565 cm_peer_create_on_bss_select_ind_resp(struct cnx_mgr *cm_ctx, 566 wlan_cm_id *cm_id) 567 { 568 return QDF_STATUS_SUCCESS; 569 } 570 571 static inline 572 QDF_STATUS cm_bss_select_ind_rsp(struct wlan_objmgr_vdev *vdev, 573 QDF_STATUS status) 574 { 575 return QDF_STATUS_SUCCESS; 576 } 577 #else 578 static inline void cm_store_wep_key(struct cnx_mgr *cm_ctx, 579 struct wlan_cm_connect_crypto_info *crypto, 580 wlan_cm_id cm_id) 581 {} 582 583 static inline QDF_STATUS 584 cm_inform_blm_connect_complete(struct wlan_objmgr_vdev *vdev, 585 struct wlan_cm_connect_resp *resp) 586 { 587 return QDF_STATUS_SUCCESS; 588 } 589 590 /** 591 * cm_peer_create_on_bss_select_ind_resp() - Called to create peer 592 * if bss select inidication's resp was success 593 * @cm_ctx: connection manager context 594 * @cm_id: Connection mgr ID assigned to this connect request. 595 * 596 * Return: QDF status 597 */ 598 QDF_STATUS 599 cm_peer_create_on_bss_select_ind_resp(struct cnx_mgr *cm_ctx, 600 wlan_cm_id *cm_id); 601 602 /** 603 * cm_bss_select_ind_rsp() - Connection manager resp for bss 604 * select indication 605 * @vdev: vdev pointer 606 * @status: Status 607 * 608 * Return: QDF_STATUS 609 */ 610 QDF_STATUS cm_bss_select_ind_rsp(struct wlan_objmgr_vdev *vdev, 611 QDF_STATUS status); 612 #endif 613 614 #ifdef WLAN_FEATURE_FILS_SK 615 /** 616 * cm_store_fils_key() - store fils keys in crypto on connection complete 617 * @cm_ctx: connection manager context 618 * @unicast: if key is unicast 619 * @key_id: Key index 620 * @key_length: key length 621 * @key: key data 622 * @bssid: bssid of the connected AP 623 * @cm_id: cm_id of the connection 624 * 625 * Return: void 626 */ 627 void cm_store_fils_key(struct cnx_mgr *cm_ctx, bool unicast, 628 uint8_t key_id, uint16_t key_length, 629 uint8_t *key, struct qdf_mac_addr *bssid, 630 wlan_cm_id cm_id); 631 #endif 632 633 /** 634 * cm_check_cmid_match_list_head() - check if list head command matches the 635 * given cm_id 636 * @cm_ctx: connection manager context 637 * @cm_id: cm id of connect/disconnect req 638 * 639 * Check if front req command matches the given 640 * cm_id, this can be used to check if the latest (head) is same we are 641 * trying to processing 642 * 643 * Return: true if match else false 644 */ 645 bool cm_check_cmid_match_list_head(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id); 646 647 /** 648 * cm_check_scanid_match_list_head() - check if list head command matches the 649 * given scan_id 650 * @cm_ctx: connection manager context 651 * @scan_id: scan_id of connect req 652 * 653 * Check if front req command is connect command and matches the given 654 * scan_id, this can be used to check if the latest (head) is same we are 655 * trying to processing 656 * 657 * Return: true if match else false 658 */ 659 bool cm_check_scanid_match_list_head(struct cnx_mgr *cm_ctx, 660 wlan_scan_id *scan_id); 661 662 /** 663 * cm_free_connect_req_mem() - free connect req internal memory, to be called 664 * before cm_req is freed 665 * @connect_req: connect req 666 * 667 * Return: void 668 */ 669 void cm_free_connect_req_mem(struct cm_connect_req *connect_req); 670 671 /** 672 * cm_delete_req_from_list() - Delete the request matching cm id 673 * @cm_ctx: connection manager context 674 * @cm_id: cm id of connect/disconnect req 675 * 676 * Context: Can be called from any context. 677 * 678 * Return: QDF_STATUS 679 */ 680 QDF_STATUS cm_delete_req_from_list(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id); 681 682 /** 683 * cm_fill_bss_info_in_connect_rsp_by_cm_id() - fill bss info for the cm id 684 * @cm_ctx: connection manager context 685 * @cm_id: cm id of connect/disconnect req 686 * @resp: resp to copy bss info like ssid/bssid and freq 687 * 688 * Fill the SSID form the connect req. 689 * Fill freq and bssid from current candidate if available (i.e the connection 690 * has tried to connect to a candidate), else get the bssid from req bssid or 691 * bssid hint which ever is present. 692 * 693 * Return: Success if entry was found else failure 694 */ 695 QDF_STATUS 696 cm_fill_bss_info_in_connect_rsp_by_cm_id(struct cnx_mgr *cm_ctx, 697 wlan_cm_id cm_id, 698 struct wlan_cm_connect_resp *resp); 699 700 #if defined(WLAN_SAE_SINGLE_PMK) && defined(WLAN_FEATURE_ROAM_OFFLOAD) 701 bool cm_is_cm_id_current_candidate_single_pmk(struct cnx_mgr *cm_ctx, 702 wlan_cm_id cm_id); 703 #else 704 static inline 705 bool cm_is_cm_id_current_candidate_single_pmk(struct cnx_mgr *cm_ctx, 706 wlan_cm_id cm_id) 707 { 708 return false; 709 } 710 #endif 711 712 /** 713 * cm_flush_pending_request() - Flush all pending requests matching flush prefix 714 * @cm_ctx: connection manager context 715 * @prefix: prefix for the type of command to flush 716 * @only_failed_req: flush only the failed pending req 717 * 718 * Context: Can be called from any context. 719 * 720 * Return: void 721 */ 722 void cm_flush_pending_request(struct cnx_mgr *cm_ctx, uint32_t prefix, 723 bool only_failed_req); 724 725 /** 726 * cm_remove_cmd() - Remove cmd from req list and serialization 727 * @cm_ctx: connection manager context 728 * @cm_id_to_remove: cm id of connect/disconnect/roam req 729 * 730 * Return: void 731 */ 732 void cm_remove_cmd(struct cnx_mgr *cm_ctx, wlan_cm_id *cm_id_to_remove); 733 734 /** 735 * cm_add_req_to_list_and_indicate_osif() - Add the request to request list in 736 * cm ctx and indicate same to osif 737 * @cm_ctx: connection manager context 738 * @cm_req: cm request 739 * @source: source of request 740 * 741 * Context: Can be called from any context. 742 * 743 * Return: QDF_STATUS 744 */ 745 QDF_STATUS cm_add_req_to_list_and_indicate_osif(struct cnx_mgr *cm_ctx, 746 struct cm_req *cm_req, 747 enum wlan_cm_source source); 748 749 struct cm_req *cm_get_req_by_cm_id_fl(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id, 750 const char *func, uint32_t line); 751 752 /** 753 * cm_get_req_by_cm_id() - Get cm req matching the cm id 754 * @cm_ctx: connection manager context 755 * @cm_id: cm id of connect/disconnect req 756 * 757 * Context: Can be called from any context and to be used only after posting a 758 * msg to SM (ie holding the SM lock) to avoid use after free. also returned req 759 * should only be used till SM lock is hold. 760 * 761 * Return: cm req from the req list whose cm id matches the argument 762 */ 763 #define cm_get_req_by_cm_id(cm_ctx, cm_id) \ 764 cm_get_req_by_cm_id_fl(cm_ctx, cm_id, __func__, __LINE__) 765 766 /** 767 * cm_vdev_scan_cancel() - cancel all scans for vdev 768 * @pdev: pdev pointer 769 * @vdev: vdev for which scan to be canceled 770 * 771 * Return: void 772 */ 773 void cm_vdev_scan_cancel(struct wlan_objmgr_pdev *pdev, 774 struct wlan_objmgr_vdev *vdev); 775 776 /** 777 * cm_fill_disconnect_resp_from_cm_id() - Fill disconnect response 778 * @cm_ctx: connection manager context 779 * @cm_id: cm id of connect/disconnect req 780 * @resp: Disconnect response which needs to filled 781 * 782 * This function is called to fill disconnect response from cm id 783 * 784 * Context: Any Context. 785 * 786 * Return: Success if disconnect 787 */ 788 QDF_STATUS 789 cm_fill_disconnect_resp_from_cm_id(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id, 790 struct wlan_cm_discon_rsp *resp); 791 792 /** 793 * cm_inform_bcn_probe() - update scan db with beacon or probe resp 794 * @cm_ctx: connection manager context 795 * @bcn_probe: beacon or probe resp received during connect 796 * @len: beacon or probe resp length 797 * @rssi: rssi of the beacon or probe resp 798 * @cm_id: cm id of connect/disconnect req 799 * 800 * update scan db, so that kernel and driver do not age out 801 * the connected AP entry. 802 * 803 * Context: Any Context. 804 * 805 * Return: void 806 */ 807 void cm_inform_bcn_probe(struct cnx_mgr *cm_ctx, uint8_t *bcn_probe, 808 uint32_t len, qdf_freq_t freq, int32_t rssi, 809 wlan_cm_id cm_id); 810 811 /** 812 * cm_set_max_connect_attempts() - Set max connect attempts 813 * @vdev: vdev pointer 814 * @max_connect_attempts: max connect attempts to be set. 815 * 816 * Set max connect attempts. Max value is limited to CM_MAX_CONNECT_ATTEMPTS. 817 * 818 * Return: void 819 */ 820 void cm_set_max_connect_attempts(struct wlan_objmgr_vdev *vdev, 821 uint8_t max_connect_attempts); 822 823 /** 824 * cm_trigger_panic_on_cmd_timeout() - trigger panic on active command timeout 825 * @vdev: vdev pointer 826 * 827 * Return: void 828 */ 829 void cm_trigger_panic_on_cmd_timeout(struct wlan_objmgr_vdev *vdev); 830 831 /** 832 * cm_set_max_connect_timeout() - Set max connect timeout 833 * @vdev: vdev pointer 834 * @max_connect_timeout: max connect timeout to be set. 835 * 836 * Set max connect timeout. 837 * 838 * Return: void 839 */ 840 void cm_set_max_connect_timeout(struct wlan_objmgr_vdev *vdev, 841 uint32_t max_connect_timeout); 842 843 /** 844 * cm_is_vdev_connecting() - check if vdev is in conneting state 845 * @vdev: vdev pointer 846 * 847 * Return: bool 848 */ 849 bool cm_is_vdev_connecting(struct wlan_objmgr_vdev *vdev); 850 851 /** 852 * cm_is_vdev_connected() - check if vdev is in conneted state 853 * @vdev: vdev pointer 854 * 855 * Return: bool 856 */ 857 bool cm_is_vdev_connected(struct wlan_objmgr_vdev *vdev); 858 859 /** 860 * cm_is_vdev_active() - check if vdev is in active state ie conneted or roaming 861 * state 862 * @vdev: vdev pointer 863 * 864 * Return: bool 865 */ 866 bool cm_is_vdev_active(struct wlan_objmgr_vdev *vdev); 867 868 /** 869 * cm_is_vdev_disconnecting() - check if vdev is in disconneting state 870 * @vdev: vdev pointer 871 * 872 * Return: bool 873 */ 874 bool cm_is_vdev_disconnecting(struct wlan_objmgr_vdev *vdev); 875 876 /** 877 * cm_is_vdev_disconnected() - check if vdev is disconnected/init state 878 * @vdev: vdev pointer 879 * 880 * Return: bool 881 */ 882 bool cm_is_vdev_disconnected(struct wlan_objmgr_vdev *vdev); 883 884 /** 885 * cm_is_vdev_roaming() - check if vdev is in roaming state 886 * @vdev: vdev pointer 887 * 888 * Return: bool 889 */ 890 bool cm_is_vdev_roaming(struct wlan_objmgr_vdev *vdev); 891 892 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 893 /** 894 * cm_is_vdev_roam_started() - check if vdev is in roaming state and 895 * roam started sub stated 896 * @vdev: vdev pointer 897 * 898 * Return: bool 899 */ 900 bool cm_is_vdev_roam_started(struct wlan_objmgr_vdev *vdev); 901 902 /** 903 * cm_is_vdev_roam_sync_inprogress() - check if vdev is in roaming state 904 * and roam sync substate 905 * @vdev: vdev pointer 906 * 907 * Return: bool 908 */ 909 bool cm_is_vdev_roam_sync_inprogress(struct wlan_objmgr_vdev *vdev); 910 #endif 911 912 #ifdef WLAN_FEATURE_HOST_ROAM 913 /** 914 * cm_is_vdev_roam_preauth_state() - check if vdev is in roaming state and 915 * preauth is in progress 916 * @vdev: vdev pointer 917 * 918 * Return: bool 919 */ 920 bool cm_is_vdev_roam_preauth_state(struct wlan_objmgr_vdev *vdev); 921 922 /** 923 * cm_is_vdev_roam_reassoc_state() - check if vdev is in roaming state 924 * and reassoc is in progress 925 * @vdev: vdev pointer 926 * 927 * Return: bool 928 */ 929 bool cm_is_vdev_roam_reassoc_state(struct wlan_objmgr_vdev *vdev); 930 #endif 931 932 /** 933 * cm_get_active_req_type() - CM active req type 934 * @vdev: vdev pointer 935 * 936 * Return: CM active req type 937 */ 938 enum wlan_cm_active_request_type 939 cm_get_active_req_type(struct wlan_objmgr_vdev *vdev); 940 941 /** 942 * cm_get_active_connect_req() - Get copy of active connect request 943 * @vdev: vdev pointer 944 * @req: pointer to the copy of the active connect request 945 * * 946 * Context: Should be called only in the conext of the 947 * cm request activation 948 * 949 * Return: true and connect req if any request is active 950 */ 951 bool cm_get_active_connect_req(struct wlan_objmgr_vdev *vdev, 952 struct wlan_cm_vdev_connect_req *req); 953 954 /** 955 * cm_get_active_disconnect_req() - Get copy of active disconnect request 956 * @vdev: vdev pointer 957 * @req: pointer to the copy of the active disconnect request 958 * * 959 * Context: Should be called only in the conext of the 960 * cm request activation 961 * 962 * Return: true and disconnect req if any request is active 963 */ 964 bool cm_get_active_disconnect_req(struct wlan_objmgr_vdev *vdev, 965 struct wlan_cm_vdev_discon_req *req); 966 967 /* 968 * cm_connect_handle_event_post_fail() - initiate connect failure if msg posting 969 * to SM fails 970 * @cm_ctx: connection manager context 971 * @cm_id: cm_id for connect req for which post fails 972 * 973 * Context: Can be called from any context and to be used only after posting a 974 * msg to SM fails from external event e.g. peer create resp, 975 * HW mode change resp serialization cb. 976 * 977 * Return: QDF_STATUS 978 */ 979 void 980 cm_connect_handle_event_post_fail(struct cnx_mgr *cm_ctx, wlan_cm_id cm_id); 981 982 /** 983 * cm_get_req_by_scan_id() - Get cm req matching the scan id 984 * @cm_ctx: connection manager context 985 * @scan_id: scan id of scan req 986 * 987 * Context: Can be called from any context and to be used only after posting a 988 * msg to SM (ie holding the SM lock) to avoid use after free. also returned req 989 * should only be used till SM lock is hold. 990 * 991 * Return: cm req from the req list whose scan id matches the argument 992 */ 993 struct cm_req *cm_get_req_by_scan_id(struct cnx_mgr *cm_ctx, 994 wlan_scan_id scan_id); 995 996 /** 997 * cm_get_cm_id_by_scan_id() - Get cm id by matching the scan id 998 * @cm_ctx: connection manager context 999 * @scan_id: scan id of scan req 1000 * 1001 * Context: Can be called from any context and used to get cm_id 1002 * from scan id when SM lock is not held 1003 * 1004 * Return: cm id from the req list whose scan id matches the argument 1005 */ 1006 wlan_cm_id cm_get_cm_id_by_scan_id(struct cnx_mgr *cm_ctx, 1007 wlan_scan_id scan_id); 1008 1009 /** 1010 * cm_update_scan_mlme_on_disconnect() - update the scan mlme info 1011 * on disconnect completion 1012 * @vdev: Object manager vdev 1013 * @req: Disconnect request 1014 * 1015 * Return: void 1016 */ 1017 void 1018 cm_update_scan_mlme_on_disconnect(struct wlan_objmgr_vdev *vdev, 1019 struct cm_disconnect_req *req); 1020 1021 /** 1022 * cm_calculate_scores() - Score the candidates obtained from scan 1023 * manager after filtering 1024 * @cm_ctx: Connection manager context 1025 * @pdev: Object manager pdev 1026 * @filter: Scan filter params 1027 * @list: List of candidates to be scored 1028 * 1029 * Return: void 1030 */ 1031 void cm_calculate_scores(struct cnx_mgr *cm_ctx, 1032 struct wlan_objmgr_pdev *pdev, 1033 struct scan_filter *filter, qdf_list_t *list); 1034 1035 /** 1036 * cm_req_lock_acquire() - Acquire connection manager request lock 1037 * @cm_ctx: Connection manager context 1038 * 1039 * Return: void 1040 */ 1041 void cm_req_lock_acquire(struct cnx_mgr *cm_ctx); 1042 1043 /** 1044 * cm_req_lock_release() - Release connection manager request lock 1045 * @cm_ctx: Connection manager context 1046 * 1047 * Return: void 1048 */ 1049 void cm_req_lock_release(struct cnx_mgr *cm_ctx); 1050 1051 #ifdef SM_ENG_HIST_ENABLE 1052 /** 1053 * cm_req_history_add() - Save request history 1054 * @cm_ctx: Connection manager context 1055 * @cm_req: Connection manager request 1056 * 1057 * Return: void 1058 */ 1059 void cm_req_history_add(struct cnx_mgr *cm_ctx, 1060 struct cm_req *cm_req); 1061 /** 1062 * cm_req_history_del() - Update history on request deletion 1063 * @cm_ctx: Connection manager context 1064 * @cm_req: Connection manager request 1065 * @del_type: Context in which the request is deleted 1066 * 1067 * Return: void 1068 */ 1069 void cm_req_history_del(struct cnx_mgr *cm_ctx, 1070 struct cm_req *cm_req, 1071 enum cm_req_del_type del_type); 1072 1073 /** 1074 * cm_history_init() - Initialize the history data struct 1075 * @cm_ctx: Connection manager context 1076 * 1077 * Return: void 1078 */ 1079 void cm_req_history_init(struct cnx_mgr *cm_ctx); 1080 1081 /** 1082 * cm_history_deinit() - Deinitialize the history data struct 1083 * @cm_ctx: Connection manager context 1084 * 1085 * Return: void 1086 */ 1087 void cm_req_history_deinit(struct cnx_mgr *cm_ctx); 1088 1089 /** 1090 * cm_history_print() - Print the history data struct 1091 * @cm_ctx: Connection manager context 1092 * 1093 * Return: void 1094 */ 1095 void cm_req_history_print(struct cnx_mgr *cm_ctx); 1096 extern struct wlan_sm_state_info cm_sm_info[]; 1097 #else 1098 static inline 1099 void cm_req_history_add(struct cnx_mgr *cm_ctx, 1100 struct cm_req *cm_req) 1101 {} 1102 1103 static inline 1104 void cm_req_history_del(struct cnx_mgr *cm_ctx, 1105 struct cm_req *cm_req, 1106 enum cm_req_del_type del_type) 1107 {} 1108 1109 static inline void cm_req_history_init(struct cnx_mgr *cm_ctx) 1110 {} 1111 1112 static inline void cm_req_history_deinit(struct cnx_mgr *cm_ctx) 1113 {} 1114 1115 static inline void cm_req_history_print(struct cnx_mgr *cm_ctx) 1116 {} 1117 #endif 1118 1119 #ifdef WLAN_CM_USE_SPINLOCK 1120 /** 1121 * cm_activate_cmd_req_flush_cb() - Callback when the scheduler msg is flushed 1122 * @msg: scheduler message 1123 * 1124 * Return: QDF_STATUS 1125 */ 1126 QDF_STATUS cm_activate_cmd_req_flush_cb(struct scheduler_msg *msg); 1127 #endif 1128 1129 #ifndef CONN_MGR_ADV_FEATURE 1130 /** 1131 * cm_set_candidate_advance_filter_cb() - Set CM candidate advance 1132 * filter cb 1133 * @vdev: Objmgr vdev 1134 * @filter_fun: CM candidate advance filter cb 1135 * 1136 * Return: void 1137 */ 1138 void cm_set_candidate_advance_filter_cb( 1139 struct wlan_objmgr_vdev *vdev, 1140 void (*filter_fun)(struct wlan_objmgr_vdev *vdev, 1141 struct scan_filter *filter)); 1142 1143 /** 1144 * cm_set_candidate_custom_sort_cb() - Set CM candidate custom sort cb 1145 * @vdev: Objmgr vdev 1146 * @sort_fun: CM candidate custom sort cb 1147 * 1148 * Return: void 1149 */ 1150 void cm_set_candidate_custom_sort_cb( 1151 struct wlan_objmgr_vdev *vdev, 1152 void (*sort_fun)(struct wlan_objmgr_vdev *vdev, 1153 qdf_list_t *list)); 1154 1155 #endif 1156 1157 #endif /* __WLAN_CM_MAIN_API_H__ */ 1158