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