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