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