1 /* 2 * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 /* 18 * DOC: contains scan north bound interface definitions 19 */ 20 21 #include <scheduler_api.h> 22 #include <wlan_scan_ucfg_api.h> 23 #include <wlan_objmgr_global_obj.h> 24 #include <wlan_objmgr_cmn.h> 25 #include <wlan_serialization_api.h> 26 #include <wlan_scan_tgt_api.h> 27 #include <wlan_scan_utils_api.h> 28 #include <wlan_reg_ucfg_api.h> 29 #include <wlan_reg_services_api.h> 30 #include <wlan_utility.h> 31 #include "../../core/src/wlan_scan_main.h" 32 #include "../../core/src/wlan_scan_manager.h" 33 #include "../../core/src/wlan_scan_cache_db.h" 34 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 35 #include <wlan_pmo_obj_mgmt_api.h> 36 #endif 37 #ifdef WLAN_POLICY_MGR_ENABLE 38 #include <wlan_dfs_utils_api.h> 39 #include <wlan_policy_mgr_api.h> 40 #endif 41 #include "cfg_ucfg_api.h" 42 #include "wlan_extscan_api.h" 43 44 QDF_STATUS ucfg_scan_register_bcn_cb(struct wlan_objmgr_psoc *psoc, 45 update_beacon_cb cb, enum scan_cb_type type) 46 { 47 return scm_scan_register_bcn_cb(psoc, cb, type); 48 } 49 50 qdf_list_t *ucfg_scan_get_result(struct wlan_objmgr_pdev *pdev, 51 struct scan_filter *filter) 52 { 53 return scm_get_scan_result(pdev, filter); 54 } 55 56 QDF_STATUS ucfg_scan_db_iterate(struct wlan_objmgr_pdev *pdev, 57 scan_iterator_func func, void *arg) 58 { 59 return scm_iterate_scan_db(pdev, func, arg); 60 } 61 62 QDF_STATUS ucfg_scan_purge_results(qdf_list_t *scan_list) 63 { 64 return scm_purge_scan_results(scan_list); 65 } 66 67 QDF_STATUS ucfg_scan_flush_results(struct wlan_objmgr_pdev *pdev, 68 struct scan_filter *filter) 69 { 70 return scm_flush_results(pdev, filter); 71 } 72 73 void ucfg_scan_filter_valid_channel(struct wlan_objmgr_pdev *pdev, 74 uint32_t *chan_freq_list, uint32_t num_chan) 75 { 76 scm_filter_valid_channel(pdev, chan_freq_list, num_chan); 77 } 78 79 QDF_STATUS ucfg_scan_init(void) 80 { 81 QDF_STATUS status; 82 83 status = wlan_objmgr_register_psoc_create_handler(WLAN_UMAC_COMP_SCAN, 84 wlan_scan_psoc_created_notification, NULL); 85 if (QDF_IS_STATUS_ERROR(status)) { 86 scm_err("Failed to register psoc create handler"); 87 goto fail_create_psoc; 88 } 89 90 status = wlan_objmgr_register_psoc_destroy_handler(WLAN_UMAC_COMP_SCAN, 91 wlan_scan_psoc_destroyed_notification, NULL); 92 if (QDF_IS_STATUS_ERROR(status)) { 93 scm_err("Failed to create psoc delete handler"); 94 goto fail_psoc_destroy; 95 } 96 scm_debug("scan psoc create and delete handler registered with objmgr"); 97 98 status = wlan_objmgr_register_vdev_create_handler(WLAN_UMAC_COMP_SCAN, 99 wlan_scan_vdev_created_notification, NULL); 100 if (QDF_IS_STATUS_ERROR(status)) { 101 scm_err("Failed to register vdev create handler"); 102 goto fail_pdev_create; 103 } 104 105 status = wlan_objmgr_register_vdev_destroy_handler(WLAN_UMAC_COMP_SCAN, 106 wlan_scan_vdev_destroyed_notification, NULL); 107 if (QDF_IS_STATUS_SUCCESS(status)) { 108 scm_debug("scan vdev create and delete handler registered with objmgr"); 109 return QDF_STATUS_SUCCESS; 110 } 111 112 scm_err("Failed to destroy vdev delete handler"); 113 wlan_objmgr_unregister_vdev_create_handler(WLAN_UMAC_COMP_SCAN, 114 wlan_scan_vdev_created_notification, NULL); 115 fail_pdev_create: 116 wlan_objmgr_unregister_psoc_destroy_handler(WLAN_UMAC_COMP_SCAN, 117 wlan_scan_psoc_destroyed_notification, NULL); 118 fail_psoc_destroy: 119 wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_SCAN, 120 wlan_scan_psoc_created_notification, NULL); 121 fail_create_psoc: 122 return status; 123 } 124 125 QDF_STATUS ucfg_scan_deinit(void) 126 { 127 QDF_STATUS status; 128 129 status = wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_SCAN, 130 wlan_scan_psoc_created_notification, NULL); 131 if (status != QDF_STATUS_SUCCESS) 132 scm_err("Failed to unregister psoc create handler"); 133 134 status = wlan_objmgr_unregister_psoc_destroy_handler( 135 WLAN_UMAC_COMP_SCAN, 136 wlan_scan_psoc_destroyed_notification, NULL); 137 if (status != QDF_STATUS_SUCCESS) 138 scm_err("Failed to unregister psoc delete handler"); 139 140 status = wlan_objmgr_unregister_vdev_create_handler(WLAN_UMAC_COMP_SCAN, 141 wlan_scan_vdev_created_notification, NULL); 142 if (status != QDF_STATUS_SUCCESS) 143 scm_err("Failed to unregister vdev create handler"); 144 145 status = wlan_objmgr_unregister_vdev_destroy_handler( 146 WLAN_UMAC_COMP_SCAN, 147 wlan_scan_vdev_destroyed_notification, NULL); 148 if (status != QDF_STATUS_SUCCESS) 149 scm_err("Failed to unregister vdev delete handler"); 150 151 return status; 152 } 153 154 #ifdef FEATURE_WLAN_SCAN_PNO 155 156 QDF_STATUS ucfg_scan_pno_start(struct wlan_objmgr_vdev *vdev, 157 struct pno_scan_req_params *req) 158 { 159 struct scan_vdev_obj *scan_vdev_obj; 160 QDF_STATUS status; 161 162 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 163 if (!scan_vdev_obj) { 164 scm_err("null scan_vdev_obj"); 165 return QDF_STATUS_E_INVAL; 166 } 167 if (scan_vdev_obj->pno_in_progress) { 168 scm_err("pno already in progress"); 169 return QDF_STATUS_E_ALREADY; 170 } 171 172 status = tgt_scan_pno_start(vdev, req); 173 if (QDF_IS_STATUS_ERROR(status)) 174 scm_err("pno start failed"); 175 else 176 scan_vdev_obj->pno_in_progress = true; 177 178 return status; 179 } 180 181 QDF_STATUS ucfg_scan_pno_stop(struct wlan_objmgr_vdev *vdev) 182 { 183 struct scan_vdev_obj *scan_vdev_obj; 184 QDF_STATUS status; 185 186 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 187 if (!scan_vdev_obj) { 188 scm_err("null scan_vdev_obj"); 189 return QDF_STATUS_E_INVAL; 190 } 191 if (!scan_vdev_obj->pno_in_progress) { 192 scm_debug("pno already stopped"); 193 return QDF_STATUS_SUCCESS; 194 } 195 196 status = tgt_scan_pno_stop(vdev, wlan_vdev_get_id(vdev)); 197 if (QDF_IS_STATUS_ERROR(status)) 198 scm_err("pno stop failed"); 199 else 200 scan_vdev_obj->pno_in_progress = false; 201 202 return status; 203 } 204 205 bool ucfg_scan_get_pno_in_progress(struct wlan_objmgr_vdev *vdev) 206 { 207 struct scan_vdev_obj *scan_vdev_obj; 208 209 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 210 if (!scan_vdev_obj) { 211 scm_err("null scan_vdev_obj"); 212 return false; 213 } 214 215 return scan_vdev_obj->pno_in_progress; 216 } 217 218 bool ucfg_scan_get_pno_match(struct wlan_objmgr_vdev *vdev) 219 { 220 struct scan_vdev_obj *scan_vdev_obj; 221 222 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 223 if (!scan_vdev_obj) { 224 scm_err("null scan_vdev_obj"); 225 return false; 226 } 227 228 return scan_vdev_obj->pno_match_evt_received; 229 } 230 231 static QDF_STATUS 232 wlan_pno_global_init(struct wlan_objmgr_psoc *psoc, 233 struct wlan_scan_obj *scan_obj) 234 { 235 struct nlo_mawc_params *mawc_cfg; 236 struct pno_def_config *pno_def; 237 238 pno_def = &scan_obj->pno_cfg; 239 qdf_wake_lock_create(&pno_def->pno_wake_lock, "wlan_pno_wl"); 240 mawc_cfg = &pno_def->mawc_params; 241 pno_def->channel_prediction = cfg_get(psoc, CFG_PNO_CHANNEL_PREDICTION); 242 pno_def->top_k_num_of_channels = 243 cfg_get(psoc, CFG_TOP_K_NUM_OF_CHANNELS); 244 pno_def->stationary_thresh = cfg_get(psoc, CFG_STATIONARY_THRESHOLD); 245 pno_def->channel_prediction_full_scan = 246 cfg_get(psoc, CFG_CHANNEL_PREDICTION_SCAN_TIMER); 247 pno_def->adaptive_dwell_mode = 248 cfg_get(psoc, CFG_ADAPTIVE_PNOSCAN_DWELL_MODE); 249 pno_def->dfs_chnl_scan_enabled = 250 cfg_get(psoc, CFG_ENABLE_DFS_PNO_CHNL_SCAN); 251 pno_def->scan_support_enabled = 252 cfg_get(psoc, CFG_PNO_SCAN_SUPPORT); 253 pno_def->scan_timer_repeat_value = 254 cfg_get(psoc, CFG_PNO_SCAN_TIMER_REPEAT_VALUE); 255 pno_def->slow_scan_multiplier = 256 cfg_get(psoc, CFG_PNO_SLOW_SCAN_MULTIPLIER); 257 pno_def->scan_backoff_multiplier = 258 cfg_get(psoc, CFG_SCAN_BACKOFF_MULTIPLIER); 259 pno_def->max_sched_scan_plan_interval = 260 cfg_get(psoc, CFG_MAX_SCHED_SCAN_PLAN_INTERVAL); 261 pno_def->max_sched_scan_plan_iterations = 262 cfg_get(psoc, CFG_MAX_SCHED_SCAN_PLAN_ITERATIONS); 263 264 mawc_cfg->enable = cfg_get(psoc, CFG_MAWC_NLO_ENABLED); 265 mawc_cfg->exp_backoff_ratio = 266 cfg_get(psoc, CFG_MAWC_NLO_EXP_BACKOFF_RATIO); 267 mawc_cfg->init_scan_interval = 268 cfg_get(psoc, CFG_MAWC_NLO_INIT_SCAN_INTERVAL); 269 mawc_cfg->max_scan_interval = 270 cfg_get(psoc, CFG_MAWC_NLO_MAX_SCAN_INTERVAL); 271 272 return QDF_STATUS_SUCCESS; 273 } 274 275 static QDF_STATUS 276 wlan_pno_global_deinit(struct wlan_scan_obj *scan_obj) 277 { 278 qdf_wake_lock_destroy(&scan_obj->pno_cfg.pno_wake_lock); 279 280 return QDF_STATUS_SUCCESS; 281 } 282 283 #ifdef WLAN_POLICY_MGR_ENABLE 284 /* 285 * ucfg_scan_update_pno_dwell_time() - update active and passive dwell time 286 * depending on active concurrency modes 287 * @vdev: vdev object pointer 288 * @req: scan request 289 * 290 * Return: void 291 */ 292 static void ucfg_scan_update_pno_dwell_time(struct wlan_objmgr_vdev *vdev, 293 struct pno_scan_req_params *req, struct scan_default_params *scan_def) 294 { 295 bool sap_or_p2p_present; 296 struct wlan_objmgr_psoc *psoc; 297 298 psoc = wlan_vdev_get_psoc(vdev); 299 300 if (!psoc) 301 return; 302 303 sap_or_p2p_present = policy_mgr_mode_specific_connection_count( 304 psoc, PM_SAP_MODE, NULL) || 305 policy_mgr_mode_specific_connection_count( 306 psoc, PM_P2P_GO_MODE, NULL) || 307 policy_mgr_mode_specific_connection_count( 308 psoc, PM_P2P_CLIENT_MODE, NULL); 309 310 if (sap_or_p2p_present) { 311 req->active_dwell_time = scan_def->conc_active_dwell; 312 req->passive_dwell_time = scan_def->conc_passive_dwell; 313 } 314 315 } 316 #else 317 static inline void ucfg_scan_update_pno_dwell_time(struct wlan_objmgr_vdev *vdev, 318 struct pno_scan_req_params *req, struct scan_default_params *scan_def){} 319 #endif 320 321 QDF_STATUS 322 ucfg_scan_get_pno_def_params(struct wlan_objmgr_vdev *vdev, 323 struct pno_scan_req_params *req) 324 { 325 struct scan_default_params *scan_def; 326 struct wlan_scan_obj *scan; 327 struct pno_def_config *pno_def; 328 329 if (!vdev || !req) { 330 scm_err("vdev: 0x%pK, req: 0x%pK", 331 vdev, req); 332 return QDF_STATUS_E_INVAL; 333 } 334 335 scan = wlan_vdev_get_scan_obj(vdev); 336 if (!scan) { 337 scm_err("scan is NULL"); 338 return QDF_STATUS_E_INVAL; 339 } 340 scan_def = wlan_vdev_get_def_scan_params(vdev); 341 if (!scan_def) { 342 scm_err("wlan_vdev_get_def_scan_params returned NULL"); 343 return QDF_STATUS_E_NULL_VALUE; 344 } 345 346 pno_def = &scan->pno_cfg; 347 req->active_dwell_time = scan_def->active_dwell; 348 req->passive_dwell_time = scan_def->passive_dwell; 349 req->scan_random.randomize = scan_def->enable_mac_spoofing; 350 351 /* 352 * Update active and passive dwell time depending 353 * upon the present active concurrency mode 354 */ 355 ucfg_scan_update_pno_dwell_time(vdev, req, scan_def); 356 req->adaptive_dwell_mode = pno_def->adaptive_dwell_mode; 357 req->pno_channel_prediction = pno_def->channel_prediction; 358 req->top_k_num_of_channels = pno_def->top_k_num_of_channels; 359 req->stationary_thresh = pno_def->stationary_thresh; 360 req->channel_prediction_full_scan = 361 pno_def->channel_prediction_full_scan; 362 req->mawc_params.vdev_id = wlan_vdev_get_id(vdev); 363 qdf_mem_copy(&req->mawc_params, &pno_def->mawc_params, 364 sizeof(req->mawc_params)); 365 366 return QDF_STATUS_SUCCESS; 367 } 368 369 QDF_STATUS 370 ucfg_scan_register_pno_cb(struct wlan_objmgr_psoc *psoc, 371 scan_event_handler event_cb, void *arg) 372 { 373 struct wlan_scan_obj *scan; 374 375 if (!psoc) { 376 scm_err("null psoc"); 377 return QDF_STATUS_E_INVAL; 378 } 379 380 scan = wlan_psoc_get_scan_obj(psoc); 381 if (!scan) { 382 scm_err("scan object null"); 383 return QDF_STATUS_E_INVAL; 384 } 385 386 qdf_spin_lock_bh(&scan->lock); 387 scan->pno_cfg.pno_cb.func = event_cb; 388 scan->pno_cfg.pno_cb.arg = arg; 389 qdf_spin_unlock_bh(&scan->lock); 390 scm_debug("event_cb: 0x%pK, arg: 0x%pK", event_cb, arg); 391 392 return QDF_STATUS_SUCCESS; 393 } 394 395 #else 396 397 static inline QDF_STATUS 398 wlan_pno_global_init(struct wlan_objmgr_psoc *psoc, 399 struct wlan_scan_obj *scan_obj) 400 { 401 return QDF_STATUS_SUCCESS; 402 } 403 404 static inline QDF_STATUS 405 wlan_pno_global_deinit(struct wlan_scan_obj *scan_obj) 406 { 407 return QDF_STATUS_SUCCESS; 408 } 409 410 #endif 411 412 QDF_STATUS 413 ucfg_scan_set_custom_scan_chan_list(struct wlan_objmgr_pdev *pdev, 414 struct chan_list *chan_list) 415 { 416 uint8_t pdev_id; 417 struct wlan_scan_obj *scan_obj; 418 419 if (!pdev || !chan_list) { 420 scm_warn("pdev: 0x%pK, chan_list: 0x%pK", pdev, chan_list); 421 return QDF_STATUS_E_NULL_VALUE; 422 } 423 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 424 scan_obj = wlan_pdev_get_scan_obj(pdev); 425 426 qdf_mem_copy(&scan_obj->pdev_info[pdev_id].custom_chan_list, 427 chan_list, sizeof(*chan_list)); 428 429 return QDF_STATUS_SUCCESS; 430 } 431 432 QDF_STATUS 433 ucfg_scm_scan_free_scan_request_mem(struct scan_start_request *req) 434 { 435 return scm_scan_free_scan_request_mem(req); 436 } 437 438 QDF_STATUS 439 ucfg_scan_start(struct scan_start_request *req) 440 { 441 struct scheduler_msg msg = {0}; 442 QDF_STATUS status; 443 444 if (!req || !req->vdev) { 445 scm_err("req or vdev within req is NULL"); 446 if (req) 447 scm_scan_free_scan_request_mem(req); 448 return QDF_STATUS_E_NULL_VALUE; 449 } 450 451 if (!scm_is_scan_allowed(req->vdev)) { 452 scm_err_rl("scan disabled, rejecting the scan req"); 453 scm_scan_free_scan_request_mem(req); 454 return QDF_STATUS_E_AGAIN; 455 } 456 457 /* Try to get vdev reference. Return if reference could 458 * not be taken. Reference will be released once scan 459 * request handling completes along with free of @req. 460 */ 461 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID); 462 if (QDF_IS_STATUS_ERROR(status)) { 463 scm_info("unable to get reference"); 464 scm_scan_free_scan_request_mem(req); 465 return status; 466 } 467 468 msg.bodyptr = req; 469 msg.callback = scm_scan_start_req; 470 msg.flush_callback = scm_scan_start_flush_callback; 471 472 status = scheduler_post_message(QDF_MODULE_ID_OS_IF, 473 QDF_MODULE_ID_SCAN, 474 QDF_MODULE_ID_OS_IF, &msg); 475 if (QDF_IS_STATUS_ERROR(status)) { 476 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_SCAN_ID); 477 scm_scan_free_scan_request_mem(req); 478 } 479 480 return status; 481 } 482 483 QDF_STATUS ucfg_scan_psoc_set_enable(struct wlan_objmgr_psoc *psoc, 484 enum scan_disable_reason reason) 485 { 486 struct wlan_scan_obj *scan_obj; 487 488 scan_obj = wlan_psoc_get_scan_obj(psoc); 489 if (!scan_obj) { 490 scm_err("Failed to get scan object"); 491 return QDF_STATUS_E_NULL_VALUE; 492 } 493 494 scan_obj->scan_disabled &= ~reason; 495 scm_debug("Psoc scan_disabled %x", scan_obj->scan_disabled); 496 497 return QDF_STATUS_SUCCESS; 498 } 499 500 QDF_STATUS ucfg_scan_psoc_set_disable(struct wlan_objmgr_psoc *psoc, 501 enum scan_disable_reason reason) 502 { 503 struct wlan_scan_obj *scan_obj; 504 505 scan_obj = wlan_psoc_get_scan_obj(psoc); 506 if (!scan_obj) { 507 scm_err("Failed to get scan object"); 508 return QDF_STATUS_E_NULL_VALUE; 509 } 510 511 scan_obj->scan_disabled |= reason; 512 513 scm_debug("Psoc scan_disabled %x", scan_obj->scan_disabled); 514 515 return QDF_STATUS_SUCCESS; 516 } 517 518 519 QDF_STATUS ucfg_scan_vdev_set_enable(struct wlan_objmgr_vdev *vdev, 520 enum scan_disable_reason reason) 521 { 522 struct scan_vdev_obj *scan_vdev_obj; 523 524 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 525 if (!scan_vdev_obj) { 526 scm_err("null scan_vdev_obj"); 527 return QDF_STATUS_E_NULL_VALUE; 528 } 529 530 scan_vdev_obj->scan_disabled &= ~reason; 531 532 scm_debug("Vdev scan_disabled %x", scan_vdev_obj->scan_disabled); 533 534 return QDF_STATUS_SUCCESS; 535 } 536 537 QDF_STATUS ucfg_scan_vdev_set_disable(struct wlan_objmgr_vdev *vdev, 538 enum scan_disable_reason reason) 539 { 540 struct scan_vdev_obj *scan_vdev_obj; 541 542 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 543 if (!scan_vdev_obj) { 544 scm_err("null scan_vdev_obj"); 545 return QDF_STATUS_E_NULL_VALUE; 546 } 547 548 scan_vdev_obj->scan_disabled |= reason; 549 550 scm_debug("Vdev scan_disabled %x", scan_vdev_obj->scan_disabled); 551 552 return QDF_STATUS_SUCCESS; 553 } 554 555 556 QDF_STATUS ucfg_scan_set_miracast( 557 struct wlan_objmgr_psoc *psoc, bool enable) 558 { 559 struct wlan_scan_obj *scan_obj; 560 561 scan_obj = wlan_psoc_get_scan_obj(psoc); 562 if (!scan_obj) { 563 scm_err("Failed to get scan object"); 564 return QDF_STATUS_E_NULL_VALUE; 565 } 566 scan_obj->miracast_enabled = enable; 567 scm_debug("set miracast_enable to %d", scan_obj->miracast_enabled); 568 569 return QDF_STATUS_SUCCESS; 570 } 571 572 QDF_STATUS 573 ucfg_scan_set_wide_band_scan(struct wlan_objmgr_pdev *pdev, bool enable) 574 { 575 uint8_t pdev_id; 576 struct wlan_scan_obj *scan_obj; 577 578 if (!pdev) { 579 scm_warn("null vdev"); 580 return QDF_STATUS_E_NULL_VALUE; 581 } 582 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 583 scan_obj = wlan_pdev_get_scan_obj(pdev); 584 if (!scan_obj) 585 return QDF_STATUS_E_FAILURE; 586 587 scm_debug("set wide_band_scan to %d", enable); 588 scan_obj->pdev_info[pdev_id].wide_band_scan = enable; 589 590 return QDF_STATUS_SUCCESS; 591 } 592 593 bool ucfg_scan_get_wide_band_scan(struct wlan_objmgr_pdev *pdev) 594 { 595 uint8_t pdev_id; 596 struct wlan_scan_obj *scan_obj; 597 598 if (!pdev) { 599 scm_warn("null vdev"); 600 return QDF_STATUS_E_NULL_VALUE; 601 } 602 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 603 scan_obj = wlan_pdev_get_scan_obj(pdev); 604 if (!scan_obj) 605 return QDF_STATUS_E_FAILURE; 606 607 return scan_obj->pdev_info[pdev_id].wide_band_scan; 608 } 609 610 #ifdef WLAN_DFS_CHAN_HIDDEN_SSID 611 QDF_STATUS 612 ucfg_scan_config_hidden_ssid_for_bssid(struct wlan_objmgr_pdev *pdev, 613 uint8_t *bssid, struct wlan_ssid *ssid) 614 { 615 uint8_t pdev_id; 616 struct wlan_scan_obj *scan_obj; 617 618 if (!pdev) { 619 scm_warn("null vdev"); 620 return QDF_STATUS_E_NULL_VALUE; 621 } 622 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 623 scan_obj = wlan_pdev_get_scan_obj(pdev); 624 if (!scan_obj) 625 return QDF_STATUS_E_FAILURE; 626 627 scm_debug("Configure bsssid:%pM ssid:%.*s", 628 bssid, ssid->length, ssid->ssid); 629 qdf_mem_copy(scan_obj->pdev_info[pdev_id].conf_bssid, 630 bssid, QDF_MAC_ADDR_SIZE); 631 scan_obj->pdev_info[pdev_id].conf_ssid.length = ssid->length; 632 qdf_mem_copy(scan_obj->pdev_info[pdev_id].conf_ssid.ssid, 633 ssid->ssid, 634 scan_obj->pdev_info[pdev_id].conf_ssid.length); 635 636 return QDF_STATUS_SUCCESS; 637 } 638 #endif /* WLAN_DFS_CHAN_HIDDEN_SSID */ 639 640 QDF_STATUS 641 ucfg_scan_cancel(struct scan_cancel_request *req) 642 { 643 struct scheduler_msg msg = {0}; 644 QDF_STATUS status; 645 646 if (!req || !req->vdev) { 647 scm_err("req or vdev within req is NULL"); 648 if (req) 649 qdf_mem_free(req); 650 return QDF_STATUS_E_NULL_VALUE; 651 } 652 653 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID); 654 if (QDF_IS_STATUS_ERROR(status)) { 655 scm_info("Failed to get vdev ref; status:%d", status); 656 goto req_free; 657 } 658 659 msg.bodyptr = req; 660 msg.callback = scm_scan_cancel_req; 661 msg.flush_callback = scm_scan_cancel_flush_callback; 662 663 status = scheduler_post_message(QDF_MODULE_ID_OS_IF, 664 QDF_MODULE_ID_SCAN, 665 QDF_MODULE_ID_OS_IF, &msg); 666 if (QDF_IS_STATUS_ERROR(status)) 667 goto vdev_put; 668 669 return QDF_STATUS_SUCCESS; 670 671 vdev_put: 672 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_SCAN_ID); 673 674 req_free: 675 qdf_mem_free(req); 676 677 return status; 678 } 679 680 QDF_STATUS 681 ucfg_scan_cancel_sync(struct scan_cancel_request *req) 682 { 683 QDF_STATUS status; 684 bool cancel_vdev = false, cancel_pdev = false; 685 struct wlan_objmgr_vdev *vdev; 686 struct wlan_objmgr_pdev *pdev; 687 uint32_t max_wait_iterations = SCM_CANCEL_SCAN_WAIT_ITERATION; 688 689 if (!req || !req->vdev) { 690 scm_err("req or vdev within req is NULL"); 691 if (req) 692 qdf_mem_free(req); 693 return QDF_STATUS_E_NULL_VALUE; 694 } 695 696 if (req->cancel_req.req_type == WLAN_SCAN_CANCEL_PDEV_ALL) 697 cancel_pdev = true; 698 else if (req->cancel_req.req_type == WLAN_SCAN_CANCEL_VDEV_ALL || 699 req->cancel_req.req_type == WLAN_SCAN_CANCEL_HOST_VDEV_ALL) 700 cancel_vdev = true; 701 702 vdev = req->vdev; 703 status = ucfg_scan_cancel(req); 704 if (QDF_IS_STATUS_ERROR(status)) 705 return status; 706 707 if (cancel_pdev) { 708 pdev = wlan_vdev_get_pdev(vdev); 709 while ((ucfg_scan_get_pdev_status(pdev) != 710 SCAN_NOT_IN_PROGRESS) && max_wait_iterations) { 711 scm_debug("wait for all pdev scan to get complete"); 712 qdf_sleep(SCM_CANCEL_SCAN_WAIT_TIME); 713 max_wait_iterations--; 714 } 715 } else if (cancel_vdev) { 716 while ((ucfg_scan_get_vdev_status(vdev) != 717 SCAN_NOT_IN_PROGRESS) && max_wait_iterations) { 718 scm_debug("wait for all vdev scan to get complete"); 719 qdf_sleep(SCM_CANCEL_SCAN_WAIT_TIME); 720 max_wait_iterations--; 721 } 722 } 723 724 if (!max_wait_iterations) { 725 scm_err("Failed to wait for scans to get complete"); 726 return QDF_STATUS_E_TIMEOUT; 727 } 728 729 return status; 730 } 731 732 wlan_scan_requester 733 ucfg_scan_register_requester(struct wlan_objmgr_psoc *psoc, 734 uint8_t *name, scan_event_handler event_cb, void *arg) 735 { 736 int i, j; 737 struct wlan_scan_obj *scan; 738 struct scan_requester_info *requesters; 739 wlan_scan_requester requester = {0}; 740 741 if (!psoc) { 742 scm_err("null psoc"); 743 return 0; 744 } 745 scan = wlan_psoc_get_scan_obj(psoc); 746 if (!scan) 747 return 0; 748 749 requesters = scan->requesters; 750 qdf_spin_lock_bh(&scan->lock); 751 for (i = 0; i < WLAN_MAX_REQUESTORS; ++i) { 752 if (requesters[i].requester == 0) { 753 requesters[i].requester = 754 WLAN_SCAN_REQUESTER_ID_PREFIX | i; 755 j = 0; 756 while (name[j] && (j < (WLAN_MAX_MODULE_NAME - 1))) { 757 requesters[i].module[j] = name[j]; 758 ++j; 759 } 760 requesters[i].module[j] = 0; 761 requesters[i].ev_handler.func = event_cb; 762 requesters[i].ev_handler.arg = arg; 763 requester = requesters[i].requester; 764 break; 765 } 766 } 767 qdf_spin_unlock_bh(&scan->lock); 768 scm_debug("module: %s, event_cb: 0x%pK, arg: 0x%pK, reqid: %d", 769 name, event_cb, arg, requester); 770 771 return requester; 772 } 773 774 void 775 ucfg_scan_unregister_requester(struct wlan_objmgr_psoc *psoc, 776 wlan_scan_requester requester) 777 { 778 int idx; 779 struct wlan_scan_obj *scan; 780 struct scan_requester_info *requesters; 781 782 idx = requester & WLAN_SCAN_REQUESTER_ID_PREFIX; 783 if (idx != WLAN_SCAN_REQUESTER_ID_PREFIX) { 784 scm_err("prefix didn't match for requester id %d", requester); 785 return; 786 } 787 788 idx = requester & WLAN_SCAN_REQUESTER_ID_MASK; 789 if (idx >= WLAN_MAX_REQUESTORS) { 790 scm_err("requester id %d greater than max value", requester); 791 return; 792 } 793 794 if (!psoc) { 795 scm_err("null psoc"); 796 return; 797 } 798 scan = wlan_psoc_get_scan_obj(psoc); 799 if (!scan) 800 return; 801 requesters = scan->requesters; 802 scm_debug("reqid: %d", requester); 803 804 qdf_spin_lock_bh(&scan->lock); 805 requesters[idx].requester = 0; 806 requesters[idx].module[0] = 0; 807 requesters[idx].ev_handler.func = NULL; 808 requesters[idx].ev_handler.arg = NULL; 809 qdf_spin_unlock_bh(&scan->lock); 810 } 811 812 uint8_t* 813 ucfg_get_scan_requester_name(struct wlan_objmgr_psoc *psoc, 814 wlan_scan_requester requester) 815 { 816 int idx = requester & WLAN_SCAN_REQUESTER_ID_MASK; 817 struct wlan_scan_obj *scan; 818 struct scan_requester_info *requesters; 819 820 if (!psoc) { 821 scm_err("null psoc"); 822 return "null"; 823 } 824 scan = wlan_psoc_get_scan_obj(psoc); 825 if (!scan) 826 return "null"; 827 828 requesters = scan->requesters; 829 830 if ((idx < WLAN_MAX_REQUESTORS) && 831 (requesters[idx].requester == requester)) { 832 return requesters[idx].module; 833 } 834 835 return (uint8_t *)"unknown"; 836 } 837 838 wlan_scan_id 839 ucfg_scan_get_scan_id(struct wlan_objmgr_psoc *psoc) 840 { 841 wlan_scan_id id; 842 struct wlan_scan_obj *scan; 843 844 if (!psoc) { 845 QDF_ASSERT(0); 846 scm_err("null psoc"); 847 return 0; 848 } 849 850 scan = wlan_psoc_get_scan_obj(psoc); 851 if (!scan) { 852 scm_err("scan object null"); 853 return 0; 854 } 855 856 id = qdf_atomic_inc_return(&scan->scan_ids); 857 id = id & WLAN_SCAN_ID_MASK; 858 /* Mark this scan request as triggered by host 859 * by setting WLAN_HOST_SCAN_REQ_ID_PREFIX flag. 860 */ 861 id = id | WLAN_HOST_SCAN_REQ_ID_PREFIX; 862 scm_debug("scan_id: 0x%x", id); 863 864 return id; 865 } 866 867 static QDF_STATUS 868 scm_add_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler, 869 scan_event_handler event_cb, void *arg) 870 { 871 struct cb_handler *cb_handler; 872 uint32_t handler_cnt = pdev_ev_handler->handler_cnt; 873 874 /* Assign next available slot to this registration request */ 875 cb_handler = &(pdev_ev_handler->cb_handlers[handler_cnt]); 876 cb_handler->func = event_cb; 877 cb_handler->arg = arg; 878 pdev_ev_handler->handler_cnt++; 879 880 return QDF_STATUS_SUCCESS; 881 } 882 883 QDF_STATUS 884 ucfg_scan_register_event_handler(struct wlan_objmgr_pdev *pdev, 885 scan_event_handler event_cb, void *arg) 886 { 887 uint32_t idx; 888 struct wlan_scan_obj *scan; 889 struct pdev_scan_ev_handler *pdev_ev_handler; 890 struct cb_handler *cb_handler; 891 892 /* scan event handler call back can't be NULL */ 893 if (!pdev || !event_cb) { 894 scm_err("pdev: %pK, event_cb: %pK", pdev, event_cb); 895 return QDF_STATUS_E_NULL_VALUE; 896 } 897 898 scm_debug("pdev: %pK, event_cb: %pK, arg: %pK\n", pdev, event_cb, arg); 899 900 scan = wlan_pdev_get_scan_obj(pdev); 901 pdev_ev_handler = wlan_pdev_get_pdev_scan_ev_handlers(pdev); 902 if (!pdev_ev_handler) { 903 scm_err("null pdev_ev_handler"); 904 return QDF_STATUS_E_NULL_VALUE; 905 } 906 cb_handler = &(pdev_ev_handler->cb_handlers[0]); 907 908 qdf_spin_lock_bh(&scan->lock); 909 /* Ensure its not a duplicate registration request */ 910 for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; 911 idx++, cb_handler++) { 912 if ((cb_handler->func == event_cb) && 913 (cb_handler->arg == arg)) { 914 qdf_spin_unlock_bh(&scan->lock); 915 scm_debug("func: %pK, arg: %pK already exists", 916 event_cb, arg); 917 return QDF_STATUS_SUCCESS; 918 } 919 } 920 921 QDF_ASSERT(pdev_ev_handler->handler_cnt < 922 MAX_SCAN_EVENT_HANDLERS_PER_PDEV); 923 924 if (pdev_ev_handler->handler_cnt >= MAX_SCAN_EVENT_HANDLERS_PER_PDEV) { 925 qdf_spin_unlock_bh(&scan->lock); 926 scm_warn("No more registrations possible"); 927 return QDF_STATUS_E_NOMEM; 928 } 929 930 scm_add_scan_event_handler(pdev_ev_handler, event_cb, arg); 931 qdf_spin_unlock_bh(&scan->lock); 932 933 scm_debug("event_cb: 0x%pK, arg: 0x%pK", event_cb, arg); 934 935 return QDF_STATUS_SUCCESS; 936 } 937 938 static QDF_STATUS 939 wlan_scan_global_init(struct wlan_objmgr_psoc *psoc, 940 struct wlan_scan_obj *scan_obj) 941 { 942 scan_obj->scan_disabled = 0; 943 scan_obj->drop_bcn_on_chan_mismatch = 944 cfg_get(psoc, CFG_DROP_BCN_ON_CHANNEL_MISMATCH); 945 scan_obj->drop_bcn_on_invalid_freq = 946 cfg_get(psoc, CFG_DROP_BCN_ON_INVALID_FREQ); 947 scan_obj->disable_timeout = false; 948 scan_obj->scan_def.active_dwell = 949 cfg_get(psoc, CFG_ACTIVE_MAX_CHANNEL_TIME); 950 /* the ini is disallow DFS channel scan if ini is 1, so negate that */ 951 scan_obj->scan_def.allow_dfs_chan_in_first_scan = 952 !cfg_get(psoc, CFG_INITIAL_NO_DFS_SCAN); 953 scan_obj->scan_def.allow_dfs_chan_in_scan = 954 cfg_get(psoc, CFG_ENABLE_DFS_SCAN); 955 scan_obj->scan_def.skip_dfs_chan_in_p2p_search = 956 cfg_get(psoc, CFG_ENABLE_SKIP_DFS_IN_P2P_SEARCH); 957 scan_obj->scan_def.use_wake_lock_in_user_scan = 958 cfg_get(psoc, CFG_ENABLE_WAKE_LOCK_IN_SCAN); 959 scan_obj->scan_def.active_dwell_2g = 960 cfg_get(psoc, CFG_ACTIVE_MAX_2G_CHANNEL_TIME); 961 scan_obj->scan_def.active_dwell_6g = 962 cfg_get(psoc, CFG_ACTIVE_MAX_6G_CHANNEL_TIME); 963 scan_obj->scan_def.passive_dwell_6g = 964 cfg_get(psoc, CFG_PASSIVE_MAX_6G_CHANNEL_TIME); 965 scan_obj->scan_def.passive_dwell = 966 cfg_get(psoc, CFG_PASSIVE_MAX_CHANNEL_TIME); 967 scan_obj->scan_def.max_rest_time = SCAN_MAX_REST_TIME; 968 scan_obj->scan_def.sta_miracast_mcc_rest_time = 969 SCAN_STA_MIRACAST_MCC_REST_TIME; 970 scan_obj->scan_def.min_rest_time = SCAN_MIN_REST_TIME; 971 scan_obj->scan_def.conc_active_dwell = 972 cfg_get(psoc, CFG_ACTIVE_MAX_CHANNEL_TIME_CONC); 973 scan_obj->scan_def.conc_passive_dwell = 974 cfg_get(psoc, CFG_PASSIVE_MAX_CHANNEL_TIME_CONC); 975 scan_obj->scan_def.conc_max_rest_time = 976 cfg_get(psoc, CFG_MAX_REST_TIME_CONC); 977 scan_obj->scan_def.conc_min_rest_time = 978 cfg_get(psoc, CFG_MIN_REST_TIME_CONC); 979 scan_obj->scan_def.conc_idle_time = 980 cfg_get(psoc, CFG_IDLE_TIME_CONC); 981 scan_obj->scan_def.repeat_probe_time = 982 cfg_get(psoc, CFG_SCAN_PROBE_REPEAT_TIME); 983 scan_obj->scan_def.probe_spacing_time = SCAN_PROBE_SPACING_TIME; 984 scan_obj->scan_def.probe_delay = SCAN_PROBE_DELAY; 985 scan_obj->scan_def.burst_duration = SCAN_BURST_DURATION; 986 scan_obj->scan_def.max_scan_time = SCAN_MAX_SCAN_TIME; 987 scan_obj->scan_def.num_probes = cfg_get(psoc, CFG_SCAN_NUM_PROBES); 988 scan_obj->scan_def.scan_cache_aging_time = 989 (cfg_get(psoc, CFG_SCAN_AGING_TIME) * 1000); 990 scan_obj->scan_def.max_bss_per_pdev = SCAN_MAX_BSS_PDEV; 991 scan_obj->scan_def.scan_priority = SCAN_PRIORITY; 992 scan_obj->scan_def.idle_time = SCAN_NETWORK_IDLE_TIMEOUT; 993 scan_obj->scan_def.adaptive_dwell_time_mode = 994 cfg_get(psoc, CFG_ADAPTIVE_SCAN_DWELL_MODE); 995 scan_obj->scan_def.adaptive_dwell_time_mode_nc = 996 cfg_get(psoc, CFG_ADAPTIVE_SCAN_DWELL_MODE_NC); 997 scan_obj->scan_def.honour_nl_scan_policy_flags = 998 cfg_get(psoc, CFG_HONOUR_NL_SCAN_POLICY_FLAGS); 999 scan_obj->scan_def.enable_mac_spoofing = 1000 cfg_get(psoc, CFG_ENABLE_MAC_ADDR_SPOOFING); 1001 scan_obj->scan_def.extscan_adaptive_dwell_mode = 1002 cfg_get(psoc, CFG_ADAPTIVE_EXTSCAN_DWELL_MODE); 1003 1004 /* init burst durations */ 1005 scan_obj->scan_def.sta_scan_burst_duration = 1006 cfg_get(psoc, CFG_STA_SCAN_BURST_DURATION); 1007 scan_obj->scan_def.p2p_scan_burst_duration = 1008 cfg_get(psoc, CFG_P2P_SCAN_BURST_DURATION); 1009 scan_obj->scan_def.go_scan_burst_duration = 1010 cfg_get(psoc, CFG_GO_SCAN_BURST_DURATION); 1011 scan_obj->scan_def.ap_scan_burst_duration = 1012 cfg_get(psoc, CFG_AP_SCAN_BURST_DURATION); 1013 /* scan contrl flags */ 1014 scan_obj->scan_def.scan_f_passive = true; 1015 scan_obj->scan_def.scan_f_ofdm_rates = true; 1016 scan_obj->scan_def.scan_f_2ghz = true; 1017 scan_obj->scan_def.scan_f_5ghz = true; 1018 scan_obj->scan_def.scan_f_chan_stat_evnt = 1019 cfg_get(psoc, CFG_ENABLE_SNR_MONITORING); 1020 /* scan event flags */ 1021 scan_obj->scan_def.scan_ev_started = true; 1022 scan_obj->scan_def.scan_ev_completed = true; 1023 scan_obj->scan_def.scan_ev_bss_chan = true; 1024 scan_obj->scan_def.scan_ev_foreign_chan = true; 1025 scan_obj->scan_def.scan_ev_foreign_chn_exit = true; 1026 scan_obj->scan_def.scan_ev_dequeued = true; 1027 scan_obj->scan_def.scan_ev_preempted = true; 1028 scan_obj->scan_def.scan_ev_start_failed = true; 1029 scan_obj->scan_def.scan_ev_restarted = true; 1030 scan_obj->scan_def.enable_connected_scan = 1031 cfg_get(psoc, CFG_ENABLE_CONNECTED_SCAN); 1032 scan_obj->scan_def.scan_mode_6g = cfg_get(psoc, CFG_6GHZ_SCAN_MODE); 1033 /* init scan id seed */ 1034 qdf_atomic_init(&scan_obj->scan_ids); 1035 1036 /* init extscan */ 1037 wlan_extscan_global_init(psoc, scan_obj); 1038 1039 return wlan_pno_global_init(psoc, scan_obj); 1040 } 1041 1042 static void 1043 wlan_scan_global_deinit(struct wlan_objmgr_psoc *psoc) 1044 { 1045 struct wlan_scan_obj *scan_obj; 1046 1047 scan_obj = wlan_psoc_get_scan_obj(psoc); 1048 wlan_pno_global_deinit(scan_obj); 1049 wlan_extscan_global_deinit(); 1050 } 1051 1052 static QDF_STATUS 1053 scm_remove_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler, 1054 struct cb_handler *entry) 1055 { 1056 struct cb_handler *last_entry; 1057 uint32_t handler_cnt = pdev_ev_handler->handler_cnt; 1058 1059 /* Replace event handler being deleted 1060 * with the last one in the list. 1061 */ 1062 last_entry = &(pdev_ev_handler->cb_handlers[handler_cnt - 1]); 1063 entry->func = last_entry->func; 1064 entry->arg = last_entry->arg; 1065 1066 /* Clear our last entry */ 1067 last_entry->func = NULL; 1068 last_entry->arg = NULL; 1069 pdev_ev_handler->handler_cnt--; 1070 1071 return QDF_STATUS_SUCCESS; 1072 } 1073 1074 void 1075 ucfg_scan_unregister_event_handler(struct wlan_objmgr_pdev *pdev, 1076 scan_event_handler event_cb, void *arg) 1077 { 1078 uint8_t found = false; 1079 uint32_t idx; 1080 uint32_t handler_cnt; 1081 struct wlan_scan_obj *scan; 1082 struct cb_handler *cb_handler; 1083 struct pdev_scan_ev_handler *pdev_ev_handler; 1084 1085 scm_debug("pdev: %pK, event_cb: 0x%pK, arg: 0x%pK", pdev, event_cb, 1086 arg); 1087 if (!pdev) { 1088 scm_err("null pdev"); 1089 return; 1090 } 1091 scan = wlan_pdev_get_scan_obj(pdev); 1092 if (!scan) 1093 return; 1094 1095 pdev_ev_handler = wlan_pdev_get_pdev_scan_ev_handlers(pdev); 1096 if (!pdev_ev_handler) 1097 return; 1098 1099 cb_handler = &(pdev_ev_handler->cb_handlers[0]); 1100 1101 qdf_spin_lock_bh(&scan->lock); 1102 handler_cnt = pdev_ev_handler->handler_cnt; 1103 if (!handler_cnt) { 1104 qdf_spin_unlock_bh(&scan->lock); 1105 scm_info("No event handlers registered"); 1106 return; 1107 } 1108 1109 for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; 1110 idx++, cb_handler++) { 1111 if ((cb_handler->func == event_cb) && 1112 (cb_handler->arg == arg)) { 1113 /* Event handler found, remove it 1114 * from event handler list. 1115 */ 1116 found = true; 1117 scm_remove_scan_event_handler(pdev_ev_handler, 1118 cb_handler); 1119 handler_cnt--; 1120 break; 1121 } 1122 } 1123 qdf_spin_unlock_bh(&scan->lock); 1124 1125 scm_debug("event handler %s, remaining handlers: %d", 1126 (found ? "removed" : "not found"), handler_cnt); 1127 } 1128 1129 QDF_STATUS 1130 ucfg_scan_init_default_params(struct wlan_objmgr_vdev *vdev, 1131 struct scan_start_request *req) 1132 { 1133 struct scan_default_params *def; 1134 1135 if (!vdev | !req) { 1136 scm_err("vdev: 0x%pK, req: 0x%pK", vdev, req); 1137 return QDF_STATUS_E_INVAL; 1138 } 1139 def = wlan_vdev_get_def_scan_params(vdev); 1140 if (!def) { 1141 scm_err("wlan_vdev_get_def_scan_params returned NULL"); 1142 return QDF_STATUS_E_NULL_VALUE; 1143 } 1144 1145 /* Zero out everything and explicitly set fields as required */ 1146 qdf_mem_zero(req, sizeof(*req)); 1147 1148 req->vdev = vdev; 1149 req->scan_req.vdev_id = wlan_vdev_get_id(vdev); 1150 req->scan_req.scan_type = SCAN_TYPE_DEFAULT; 1151 req->scan_req.scan_priority = def->scan_priority; 1152 req->scan_req.dwell_time_active = def->active_dwell; 1153 req->scan_req.dwell_time_active_2g = def->active_dwell_2g; 1154 req->scan_req.dwell_time_active_6g = def->active_dwell_6g; 1155 req->scan_req.dwell_time_passive_6g = def->passive_dwell_6g; 1156 req->scan_req.dwell_time_passive = def->passive_dwell; 1157 req->scan_req.min_rest_time = def->min_rest_time; 1158 req->scan_req.max_rest_time = def->max_rest_time; 1159 req->scan_req.repeat_probe_time = def->repeat_probe_time; 1160 req->scan_req.probe_spacing_time = def->probe_spacing_time; 1161 req->scan_req.idle_time = def->idle_time; 1162 req->scan_req.max_scan_time = def->max_scan_time; 1163 req->scan_req.probe_delay = def->probe_delay; 1164 req->scan_req.burst_duration = def->burst_duration; 1165 req->scan_req.n_probes = def->num_probes; 1166 req->scan_req.adaptive_dwell_time_mode = 1167 def->adaptive_dwell_time_mode; 1168 req->scan_req.scan_flags = def->scan_flags; 1169 req->scan_req.scan_events = def->scan_events; 1170 req->scan_req.scan_random.randomize = def->enable_mac_spoofing; 1171 1172 return QDF_STATUS_SUCCESS; 1173 } 1174 1175 QDF_STATUS 1176 ucfg_scan_init_ssid_params(struct scan_start_request *req, 1177 uint32_t num_ssid, struct wlan_ssid *ssid_list) 1178 { 1179 uint32_t max_ssid = sizeof(req->scan_req.ssid) / 1180 sizeof(req->scan_req.ssid[0]); 1181 1182 if (!req) { 1183 scm_err("null request"); 1184 return QDF_STATUS_E_NULL_VALUE; 1185 } 1186 if (!num_ssid) { 1187 /* empty channel list provided */ 1188 req->scan_req.num_ssids = 0; 1189 qdf_mem_zero(&req->scan_req.ssid[0], 1190 sizeof(req->scan_req.ssid)); 1191 return QDF_STATUS_SUCCESS; 1192 } 1193 if (!ssid_list) { 1194 scm_err("null ssid_list while num_ssid: %d", num_ssid); 1195 return QDF_STATUS_E_NULL_VALUE; 1196 } 1197 if (num_ssid > max_ssid) { 1198 /* got a big list. alert and continue */ 1199 scm_warn("overflow: received %d, max supported : %d", 1200 num_ssid, max_ssid); 1201 return QDF_STATUS_E_E2BIG; 1202 } 1203 1204 if (max_ssid > num_ssid) 1205 max_ssid = num_ssid; 1206 1207 req->scan_req.num_ssids = max_ssid; 1208 qdf_mem_copy(&req->scan_req.ssid[0], ssid_list, 1209 (req->scan_req.num_ssids * sizeof(req->scan_req.ssid[0]))); 1210 1211 return QDF_STATUS_SUCCESS; 1212 } 1213 1214 QDF_STATUS 1215 ucfg_scan_init_bssid_params(struct scan_start_request *req, 1216 uint32_t num_bssid, struct qdf_mac_addr *bssid_list) 1217 { 1218 uint32_t max_bssid = sizeof(req->scan_req.bssid_list) / 1219 sizeof(req->scan_req.bssid_list[0]); 1220 1221 if (!req) { 1222 scm_err("null request"); 1223 return QDF_STATUS_E_NULL_VALUE; 1224 } 1225 if (!num_bssid) { 1226 /* empty channel list provided */ 1227 req->scan_req.num_bssid = 0; 1228 qdf_mem_zero(&req->scan_req.bssid_list[0], 1229 sizeof(req->scan_req.bssid_list)); 1230 return QDF_STATUS_SUCCESS; 1231 } 1232 if (!bssid_list) { 1233 scm_err("null bssid_list while num_bssid: %d", num_bssid); 1234 return QDF_STATUS_E_NULL_VALUE; 1235 } 1236 if (num_bssid > max_bssid) { 1237 /* got a big list. alert and continue */ 1238 scm_warn("overflow: received %d, max supported : %d", 1239 num_bssid, max_bssid); 1240 return QDF_STATUS_E_E2BIG; 1241 } 1242 1243 if (max_bssid > num_bssid) 1244 max_bssid = num_bssid; 1245 1246 req->scan_req.num_bssid = max_bssid; 1247 qdf_mem_copy(&req->scan_req.bssid_list[0], bssid_list, 1248 req->scan_req.num_bssid * sizeof(req->scan_req.bssid_list[0])); 1249 1250 return QDF_STATUS_SUCCESS; 1251 } 1252 1253 /** 1254 * is_chan_enabled_for_scan() - helper API to check if a frequency 1255 * is allowed to scan. 1256 * @reg_chan: regulatory_channel object 1257 * @low_2g: lower 2.4 GHz frequency thresold 1258 * @high_2g: upper 2.4 GHz frequency thresold 1259 * @low_5g: lower 5 GHz frequency thresold 1260 * @high_5g: upper 5 GHz frequency thresold 1261 * 1262 * Return: true if scan is allowed. false otherwise. 1263 */ 1264 static bool 1265 is_chan_enabled_for_scan(struct regulatory_channel *reg_chan, 1266 qdf_freq_t low_2g, qdf_freq_t high_2g, qdf_freq_t low_5g, 1267 qdf_freq_t high_5g) 1268 { 1269 if (reg_chan->state == CHANNEL_STATE_DISABLE) 1270 return false; 1271 if (reg_chan->nol_chan) 1272 return false; 1273 /* 2 GHz channel */ 1274 if ((util_scan_scm_chan_to_band(reg_chan->chan_num) == 1275 WLAN_BAND_2_4_GHZ) && 1276 ((reg_chan->center_freq < low_2g) || 1277 (reg_chan->center_freq > high_2g))) 1278 return false; 1279 else if ((util_scan_scm_chan_to_band(reg_chan->chan_num) == 1280 WLAN_BAND_5_GHZ) && 1281 ((reg_chan->center_freq < low_5g) || 1282 (reg_chan->center_freq > high_5g))) 1283 return false; 1284 1285 return true; 1286 } 1287 1288 QDF_STATUS 1289 ucfg_scan_init_chanlist_params(struct scan_start_request *req, 1290 uint32_t num_chans, uint32_t *chan_list, uint32_t *phymode) 1291 { 1292 uint32_t idx; 1293 QDF_STATUS status; 1294 struct regulatory_channel *reg_chan_list = NULL; 1295 qdf_freq_t low_2g, high_2g, low_5g, high_5g; 1296 struct wlan_objmgr_pdev *pdev = NULL; 1297 uint32_t *scan_freqs = NULL; 1298 uint32_t max_chans = sizeof(req->scan_req.chan_list.chan) / 1299 sizeof(req->scan_req.chan_list.chan[0]); 1300 if (!req) { 1301 scm_err("null request"); 1302 return QDF_STATUS_E_NULL_VALUE; 1303 } 1304 1305 if (req->vdev) 1306 pdev = wlan_vdev_get_pdev(req->vdev); 1307 /* 1308 * If 0 channels are provided for scan and 1309 * wide band scan is enabled, scan all 20 mhz 1310 * available channels. This is required as FW 1311 * scans all channel/phy mode combinations 1312 * provided in scan channel list if 0 chans are 1313 * provided in scan request causing scan to take 1314 * too much time to complete. 1315 */ 1316 if (pdev && !num_chans) { 1317 reg_chan_list = qdf_mem_malloc_atomic(NUM_CHANNELS * 1318 sizeof(struct regulatory_channel)); 1319 if (!reg_chan_list) { 1320 status = QDF_STATUS_E_NOMEM; 1321 goto end; 1322 } 1323 scan_freqs = 1324 qdf_mem_malloc_atomic(sizeof(uint32_t) * max_chans); 1325 if (!scan_freqs) { 1326 status = QDF_STATUS_E_NOMEM; 1327 goto end; 1328 } 1329 status = ucfg_reg_get_current_chan_list(pdev, reg_chan_list); 1330 if (QDF_IS_STATUS_ERROR(status)) 1331 goto end; 1332 1333 status = wlan_reg_get_freq_range(pdev, &low_2g, 1334 &high_2g, &low_5g, &high_5g); 1335 if (QDF_IS_STATUS_ERROR(status)) 1336 goto end; 1337 1338 for (idx = 0, num_chans = 0; 1339 (idx < NUM_CHANNELS && num_chans < max_chans); idx++) 1340 if (is_chan_enabled_for_scan(®_chan_list[idx], 1341 low_2g, high_2g, low_5g, high_5g)) 1342 scan_freqs[num_chans++] = 1343 reg_chan_list[idx].center_freq; 1344 1345 chan_list = scan_freqs; 1346 } 1347 1348 if (!num_chans) { 1349 /* empty channel list provided */ 1350 qdf_mem_zero(&req->scan_req.chan_list, 1351 sizeof(req->scan_req.chan_list)); 1352 req->scan_req.chan_list.num_chan = 0; 1353 status = QDF_STATUS_SUCCESS; 1354 goto end; 1355 } 1356 if (!chan_list) { 1357 scm_info("null chan_list while num_chans: %d", num_chans); 1358 status = QDF_STATUS_E_NULL_VALUE; 1359 goto end; 1360 } 1361 1362 if (num_chans > max_chans) { 1363 /* got a big list. alert and fail */ 1364 scm_warn("overflow: received %d, max supported : %d", 1365 num_chans, max_chans); 1366 status = QDF_STATUS_E_E2BIG; 1367 goto end; 1368 } 1369 1370 req->scan_req.chan_list.num_chan = num_chans; 1371 for (idx = 0; idx < num_chans; idx++) { 1372 req->scan_req.chan_list.chan[idx].freq = 1373 (chan_list[idx] > WLAN_24_GHZ_BASE_FREQ) ? 1374 chan_list[idx] : 1375 wlan_reg_legacy_chan_to_freq(pdev, chan_list[idx]); 1376 if (phymode) 1377 req->scan_req.chan_list.chan[idx].phymode = 1378 phymode[idx]; 1379 else if (req->scan_req.chan_list.chan[idx].freq <= 1380 WLAN_CHAN_15_FREQ) 1381 req->scan_req.chan_list.chan[idx].phymode = 1382 SCAN_PHY_MODE_11G; 1383 else if (req->scan_req.chan_list.chan[idx].freq <= 1384 WLAN_REG_MAX_5GHZ_CHAN_FREQ) 1385 req->scan_req.chan_list.chan[idx].phymode = 1386 SCAN_PHY_MODE_11A; 1387 else 1388 req->scan_req.chan_list.chan[idx].phymode = 1389 SCAN_PHY_MODE_11AX_HE20; 1390 } 1391 1392 end: 1393 if (scan_freqs) 1394 qdf_mem_free(scan_freqs); 1395 1396 if (reg_chan_list) 1397 qdf_mem_free(reg_chan_list); 1398 1399 return QDF_STATUS_SUCCESS; 1400 } 1401 1402 static inline enum scm_scan_status 1403 get_scan_status_from_serialization_status( 1404 enum wlan_serialization_cmd_status status) 1405 { 1406 enum scm_scan_status scan_status; 1407 1408 switch (status) { 1409 case WLAN_SER_CMD_IN_PENDING_LIST: 1410 scan_status = SCAN_IS_PENDING; 1411 break; 1412 case WLAN_SER_CMD_IN_ACTIVE_LIST: 1413 scan_status = SCAN_IS_ACTIVE; 1414 break; 1415 case WLAN_SER_CMDS_IN_ALL_LISTS: 1416 scan_status = SCAN_IS_ACTIVE_AND_PENDING; 1417 break; 1418 case WLAN_SER_CMD_NOT_FOUND: 1419 scan_status = SCAN_NOT_IN_PROGRESS; 1420 break; 1421 default: 1422 scm_warn("invalid serialization status %d", status); 1423 QDF_ASSERT(0); 1424 scan_status = SCAN_NOT_IN_PROGRESS; 1425 break; 1426 } 1427 1428 return scan_status; 1429 } 1430 1431 enum scm_scan_status 1432 ucfg_scan_get_vdev_status(struct wlan_objmgr_vdev *vdev) 1433 { 1434 enum wlan_serialization_cmd_status status; 1435 1436 if (!vdev) { 1437 scm_err("null vdev"); 1438 return SCAN_NOT_IN_PROGRESS; 1439 } 1440 status = wlan_serialization_vdev_scan_status(vdev); 1441 1442 return get_scan_status_from_serialization_status(status); 1443 } 1444 1445 enum scm_scan_status 1446 ucfg_scan_get_pdev_status(struct wlan_objmgr_pdev *pdev) 1447 { 1448 enum wlan_serialization_cmd_status status; 1449 1450 if (!pdev) { 1451 scm_err("null pdev"); 1452 return SCAN_NOT_IN_PROGRESS; 1453 } 1454 status = wlan_serialization_pdev_scan_status(pdev); 1455 1456 return get_scan_status_from_serialization_status(status); 1457 } 1458 1459 static void 1460 ucfg_scan_register_unregister_bcn_cb(struct wlan_objmgr_psoc *psoc, 1461 bool enable) 1462 { 1463 QDF_STATUS status; 1464 struct mgmt_txrx_mgmt_frame_cb_info cb_info[2]; 1465 1466 cb_info[0].frm_type = MGMT_PROBE_RESP; 1467 cb_info[0].mgmt_rx_cb = tgt_scan_bcn_probe_rx_callback; 1468 cb_info[1].frm_type = MGMT_BEACON; 1469 cb_info[1].mgmt_rx_cb = tgt_scan_bcn_probe_rx_callback; 1470 1471 if (enable) 1472 status = wlan_mgmt_txrx_register_rx_cb(psoc, 1473 WLAN_UMAC_COMP_SCAN, cb_info, 2); 1474 else 1475 status = wlan_mgmt_txrx_deregister_rx_cb(psoc, 1476 WLAN_UMAC_COMP_SCAN, cb_info, 2); 1477 if (status != QDF_STATUS_SUCCESS) 1478 scm_err("%s the Handle with MGMT TXRX layer has failed", 1479 enable ? "Registering" : "Deregistering"); 1480 } 1481 1482 QDF_STATUS ucfg_scan_update_user_config(struct wlan_objmgr_psoc *psoc, 1483 struct scan_user_cfg *scan_cfg) 1484 { 1485 struct wlan_scan_obj *scan_obj; 1486 struct scan_default_params *scan_def; 1487 1488 if (!psoc) { 1489 scm_err("null psoc"); 1490 return QDF_STATUS_E_FAILURE; 1491 } 1492 scan_obj = wlan_psoc_get_scan_obj(psoc); 1493 if (!scan_obj) { 1494 scm_err("Failed to get scan object"); 1495 return QDF_STATUS_E_FAILURE; 1496 } 1497 1498 scan_def = &scan_obj->scan_def; 1499 scan_obj->ie_whitelist = scan_cfg->ie_whitelist; 1500 scan_def->sta_miracast_mcc_rest_time = 1501 scan_cfg->sta_miracast_mcc_rest_time; 1502 1503 return QDF_STATUS_SUCCESS; 1504 } 1505 1506 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 1507 static QDF_STATUS 1508 ucfg_scan_cancel_pdev_scan(struct wlan_objmgr_pdev *pdev) 1509 { 1510 struct scan_cancel_request *req; 1511 QDF_STATUS status; 1512 struct wlan_objmgr_vdev *vdev; 1513 1514 req = qdf_mem_malloc_atomic(sizeof(*req)); 1515 if (!req) { 1516 scm_err("Failed to allocate memory"); 1517 return QDF_STATUS_E_NOMEM; 1518 } 1519 1520 vdev = wlan_objmgr_pdev_get_first_vdev(pdev, WLAN_SCAN_ID); 1521 if (!vdev) { 1522 scm_err("Failed to get vdev"); 1523 qdf_mem_free(req); 1524 return QDF_STATUS_E_INVAL; 1525 } 1526 req->vdev = vdev; 1527 req->cancel_req.scan_id = INVAL_SCAN_ID; 1528 req->cancel_req.pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1529 req->cancel_req.vdev_id = INVAL_VDEV_ID; 1530 req->cancel_req.req_type = WLAN_SCAN_CANCEL_PDEV_ALL; 1531 status = ucfg_scan_cancel_sync(req); 1532 if (QDF_IS_STATUS_ERROR(status)) 1533 scm_err("Cancel scan request failed"); 1534 wlan_objmgr_vdev_release_ref(vdev, WLAN_SCAN_ID); 1535 1536 return status; 1537 } 1538 1539 static QDF_STATUS 1540 ucfg_scan_suspend_handler(struct wlan_objmgr_psoc *psoc, void *arg) 1541 { 1542 struct wlan_objmgr_pdev *pdev = NULL; 1543 QDF_STATUS status = QDF_STATUS_SUCCESS; 1544 int i; 1545 1546 ucfg_scan_psoc_set_disable(psoc, REASON_SUSPEND); 1547 /* Check all pdev */ 1548 for (i = 0; i < WLAN_UMAC_MAX_PDEVS; i++) { 1549 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, WLAN_SCAN_ID); 1550 if (!pdev) 1551 continue; 1552 if (ucfg_scan_get_pdev_status(pdev) != 1553 SCAN_NOT_IN_PROGRESS) 1554 status = ucfg_scan_cancel_pdev_scan(pdev); 1555 wlan_objmgr_pdev_release_ref(pdev, WLAN_SCAN_ID); 1556 if (QDF_IS_STATUS_ERROR(status)) { 1557 scm_err("failed to cancel scan for pdev_id %d", i); 1558 return status; 1559 } 1560 } 1561 1562 return QDF_STATUS_SUCCESS; 1563 } 1564 1565 static QDF_STATUS 1566 ucfg_scan_resume_handler(struct wlan_objmgr_psoc *psoc, void *arg) 1567 { 1568 ucfg_scan_psoc_set_enable(psoc, REASON_SUSPEND); 1569 return QDF_STATUS_SUCCESS; 1570 } 1571 1572 static inline void 1573 ucfg_scan_register_pmo_handler(void) 1574 { 1575 pmo_register_suspend_handler(WLAN_UMAC_COMP_SCAN, 1576 ucfg_scan_suspend_handler, NULL); 1577 pmo_register_resume_handler(WLAN_UMAC_COMP_SCAN, 1578 ucfg_scan_resume_handler, NULL); 1579 } 1580 1581 static inline void 1582 ucfg_scan_unregister_pmo_handler(void) 1583 { 1584 pmo_unregister_suspend_handler(WLAN_UMAC_COMP_SCAN, 1585 ucfg_scan_suspend_handler); 1586 pmo_unregister_resume_handler(WLAN_UMAC_COMP_SCAN, 1587 ucfg_scan_resume_handler); 1588 } 1589 1590 #else 1591 static inline void 1592 ucfg_scan_register_pmo_handler(void) 1593 { 1594 } 1595 1596 static inline void 1597 ucfg_scan_unregister_pmo_handler(void) 1598 { 1599 } 1600 #endif 1601 1602 QDF_STATUS 1603 ucfg_scan_psoc_open(struct wlan_objmgr_psoc *psoc) 1604 { 1605 struct wlan_scan_obj *scan_obj; 1606 1607 scm_debug("psoc open: 0x%pK", psoc); 1608 if (!psoc) { 1609 scm_err("null psoc"); 1610 return QDF_STATUS_E_FAILURE; 1611 } 1612 scan_obj = wlan_psoc_get_scan_obj(psoc); 1613 if (!scan_obj) { 1614 scm_err("Failed to get scan object"); 1615 return QDF_STATUS_E_FAILURE; 1616 } 1617 /* Initialize the scan Globals */ 1618 wlan_scan_global_init(psoc, scan_obj); 1619 qdf_spinlock_create(&scan_obj->lock); 1620 ucfg_scan_register_pmo_handler(); 1621 scm_db_init(psoc); 1622 scm_channel_list_db_init(psoc); 1623 1624 return QDF_STATUS_SUCCESS; 1625 } 1626 1627 QDF_STATUS 1628 ucfg_scan_psoc_close(struct wlan_objmgr_psoc *psoc) 1629 { 1630 struct wlan_scan_obj *scan_obj; 1631 1632 scm_debug("psoc close: 0x%pK", psoc); 1633 if (!psoc) { 1634 scm_err("null psoc"); 1635 return QDF_STATUS_E_FAILURE; 1636 } 1637 scm_db_deinit(psoc); 1638 scan_obj = wlan_psoc_get_scan_obj(psoc); 1639 if (!scan_obj) { 1640 scm_err("Failed to get scan object"); 1641 return QDF_STATUS_E_FAILURE; 1642 } 1643 ucfg_scan_unregister_pmo_handler(); 1644 qdf_spinlock_destroy(&scan_obj->lock); 1645 wlan_scan_global_deinit(psoc); 1646 scm_channel_list_db_deinit(psoc); 1647 1648 return QDF_STATUS_SUCCESS; 1649 } 1650 1651 static bool scm_serialization_scan_rules_cb( 1652 union wlan_serialization_rules_info *comp_info, 1653 uint8_t comp_id) 1654 { 1655 switch (comp_id) { 1656 case WLAN_UMAC_COMP_TDLS: 1657 if (comp_info->scan_info.is_tdls_in_progress) { 1658 scm_debug("Cancel scan. Tdls in progress"); 1659 return false; 1660 } 1661 break; 1662 case WLAN_UMAC_COMP_DFS: 1663 if (comp_info->scan_info.is_cac_in_progress) { 1664 scm_debug("Cancel scan. CAC in progress"); 1665 return false; 1666 } 1667 break; 1668 case WLAN_UMAC_COMP_MLME: 1669 if (comp_info->scan_info.is_scan_for_connect) { 1670 scm_debug("Allow scan request from connect"); 1671 return true; 1672 } 1673 1674 if (comp_info->scan_info.is_mlme_op_in_progress) { 1675 scm_debug("Cancel scan. MLME operation in progress"); 1676 return false; 1677 } 1678 break; 1679 default: 1680 scm_debug("not handled comp_id %d", comp_id); 1681 break; 1682 } 1683 1684 return true; 1685 } 1686 1687 QDF_STATUS 1688 ucfg_scan_psoc_enable(struct wlan_objmgr_psoc *psoc) 1689 { 1690 QDF_STATUS status; 1691 1692 scm_debug("psoc enable: 0x%pK", psoc); 1693 if (!psoc) { 1694 scm_err("null psoc"); 1695 return QDF_STATUS_E_FAILURE; 1696 } 1697 /* Subscribe for scan events from lmac layesr */ 1698 status = tgt_scan_register_ev_handler(psoc); 1699 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 1700 if (!wlan_reg_is_11d_offloaded(psoc)) 1701 scm_11d_cc_db_init(psoc); 1702 ucfg_scan_register_unregister_bcn_cb(psoc, true); 1703 status = wlan_serialization_register_apply_rules_cb(psoc, 1704 WLAN_SER_CMD_SCAN, 1705 scm_serialization_scan_rules_cb); 1706 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 1707 return status; 1708 } 1709 1710 QDF_STATUS 1711 ucfg_scan_psoc_disable(struct wlan_objmgr_psoc *psoc) 1712 { 1713 QDF_STATUS status; 1714 1715 scm_debug("psoc disable: 0x%pK", psoc); 1716 if (!psoc) { 1717 scm_err("null psoc"); 1718 return QDF_STATUS_E_FAILURE; 1719 } 1720 /* Unsubscribe for scan events from lmac layesr */ 1721 status = tgt_scan_unregister_ev_handler(psoc); 1722 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 1723 ucfg_scan_register_unregister_bcn_cb(psoc, false); 1724 if (!wlan_reg_is_11d_offloaded(psoc)) 1725 scm_11d_cc_db_deinit(psoc); 1726 1727 return status; 1728 } 1729 1730 uint32_t 1731 ucfg_scan_get_max_active_scans(struct wlan_objmgr_psoc *psoc) 1732 { 1733 struct scan_default_params *scan_params = NULL; 1734 1735 if (!psoc) { 1736 scm_err("null psoc"); 1737 return 0; 1738 } 1739 scan_params = wlan_scan_psoc_get_def_params(psoc); 1740 if (!scan_params) { 1741 scm_err("Failed to get scan object"); 1742 return 0; 1743 } 1744 1745 return scan_params->max_active_scans_allowed; 1746 } 1747 1748 bool ucfg_copy_ie_whitelist_attrs(struct wlan_objmgr_psoc *psoc, 1749 struct probe_req_whitelist_attr *ie_whitelist) 1750 { 1751 struct wlan_scan_obj *scan_obj = NULL; 1752 1753 scan_obj = wlan_psoc_get_scan_obj(psoc); 1754 if (!scan_obj) 1755 return false; 1756 1757 qdf_mem_copy(ie_whitelist, &scan_obj->ie_whitelist, 1758 sizeof(*ie_whitelist)); 1759 1760 return true; 1761 } 1762 1763 bool ucfg_ie_whitelist_enabled(struct wlan_objmgr_psoc *psoc, 1764 struct wlan_objmgr_vdev *vdev) 1765 { 1766 struct wlan_scan_obj *scan_obj = NULL; 1767 1768 scan_obj = wlan_psoc_get_scan_obj(psoc); 1769 if (!scan_obj) 1770 return false; 1771 1772 if ((wlan_vdev_mlme_get_opmode(vdev) != QDF_STA_MODE) || 1773 wlan_vdev_is_up(vdev) == QDF_STATUS_SUCCESS) 1774 return false; 1775 1776 if (!scan_obj->ie_whitelist.white_list) 1777 return false; 1778 1779 return true; 1780 } 1781 1782 void ucfg_scan_set_bt_activity(struct wlan_objmgr_psoc *psoc, 1783 bool bt_a2dp_active) 1784 { 1785 struct wlan_scan_obj *scan_obj; 1786 1787 scan_obj = wlan_psoc_get_scan_obj(psoc); 1788 if (!scan_obj) { 1789 scm_err("Failed to get scan object"); 1790 return; 1791 } 1792 scan_obj->bt_a2dp_enabled = bt_a2dp_active; 1793 } 1794 1795 bool ucfg_scan_get_bt_activity(struct wlan_objmgr_psoc *psoc) 1796 { 1797 struct wlan_scan_obj *scan_obj; 1798 1799 scan_obj = wlan_psoc_get_scan_obj(psoc); 1800 if (!scan_obj) { 1801 scm_err("Failed to get scan object"); 1802 return false; 1803 } 1804 1805 return scan_obj->bt_a2dp_enabled; 1806 } 1807 1808 bool ucfg_scan_wake_lock_in_user_scan(struct wlan_objmgr_psoc *psoc) 1809 { 1810 struct wlan_scan_obj *scan_obj; 1811 1812 scan_obj = wlan_psoc_get_scan_obj(psoc); 1813 if (!scan_obj) 1814 return false; 1815 1816 return scan_obj->scan_def.use_wake_lock_in_user_scan; 1817 } 1818 1819 bool ucfg_scan_is_connected_scan_enabled(struct wlan_objmgr_psoc *psoc) 1820 { 1821 struct wlan_scan_obj *scan_obj; 1822 1823 scan_obj = wlan_psoc_get_scan_obj(psoc); 1824 if (!scan_obj) { 1825 scm_err("Failed to get scan object"); 1826 return cfg_default(CFG_ENABLE_CONNECTED_SCAN); 1827 } 1828 1829 return scan_obj->scan_def.enable_connected_scan; 1830 } 1831 1832 bool ucfg_scan_is_mac_spoofing_enabled(struct wlan_objmgr_psoc *psoc) 1833 { 1834 struct wlan_scan_obj *scan_obj; 1835 1836 scan_obj = wlan_psoc_get_scan_obj(psoc); 1837 if (!scan_obj) { 1838 scm_err("Failed to get scan object"); 1839 return cfg_default(CFG_ENABLE_MAC_ADDR_SPOOFING); 1840 } 1841 1842 return scan_obj->scan_def.enable_mac_spoofing; 1843 } 1844 1845 enum scan_dwelltime_adaptive_mode 1846 ucfg_scan_get_extscan_adaptive_dwell_mode(struct wlan_objmgr_psoc *psoc) 1847 { 1848 struct wlan_scan_obj *scan_obj; 1849 1850 scan_obj = wlan_psoc_get_scan_obj(psoc); 1851 if (!scan_obj) { 1852 scm_err("Failed to get scan object"); 1853 return cfg_default(CFG_ADAPTIVE_EXTSCAN_DWELL_MODE); 1854 } 1855 1856 return scan_obj->scan_def.extscan_adaptive_dwell_mode; 1857 } 1858 1859 QDF_STATUS 1860 ucfg_scan_set_global_config(struct wlan_objmgr_psoc *psoc, 1861 enum scan_config config, uint32_t val) 1862 { 1863 struct wlan_scan_obj *scan_obj; 1864 QDF_STATUS status = QDF_STATUS_SUCCESS; 1865 1866 scan_obj = wlan_psoc_get_scan_obj(psoc); 1867 if (!scan_obj) { 1868 scm_err("Failed to get scan object config:%d, val:%d", 1869 config, val); 1870 return QDF_STATUS_E_INVAL; 1871 } 1872 switch (config) { 1873 case SCAN_CFG_DISABLE_SCAN_COMMAND_TIMEOUT: 1874 scan_obj->disable_timeout = !!val; 1875 break; 1876 case SCAN_CFG_DROP_BCN_ON_CHANNEL_MISMATCH: 1877 scan_obj->drop_bcn_on_chan_mismatch = !!val; 1878 break; 1879 1880 default: 1881 status = QDF_STATUS_E_INVAL; 1882 break; 1883 } 1884 1885 return status; 1886 } 1887 1888 QDF_STATUS ucfg_scan_update_mlme_by_bssinfo(struct wlan_objmgr_pdev *pdev, 1889 struct bss_info *bss_info, struct mlme_info *mlme) 1890 { 1891 QDF_STATUS status; 1892 1893 status = scm_scan_update_mlme_by_bssinfo(pdev, bss_info, mlme); 1894 1895 return status; 1896 } 1897 1898 QDF_STATUS 1899 ucfg_scan_get_global_config(struct wlan_objmgr_psoc *psoc, 1900 enum scan_config config, uint32_t *val) 1901 { 1902 struct wlan_scan_obj *scan_obj; 1903 QDF_STATUS status = QDF_STATUS_SUCCESS; 1904 1905 scan_obj = wlan_psoc_get_scan_obj(psoc); 1906 if (!scan_obj || !val) { 1907 scm_err("scan object:%pK config:%d, val:0x%pK", 1908 scan_obj, config, val); 1909 return QDF_STATUS_E_INVAL; 1910 } 1911 switch (config) { 1912 case SCAN_CFG_DISABLE_SCAN_COMMAND_TIMEOUT: 1913 *val = scan_obj->disable_timeout; 1914 break; 1915 case SCAN_CFG_DROP_BCN_ON_CHANNEL_MISMATCH: 1916 *val = scan_obj->drop_bcn_on_chan_mismatch; 1917 break; 1918 1919 default: 1920 status = QDF_STATUS_E_INVAL; 1921 break; 1922 } 1923 1924 return status; 1925 } 1926 1927 #ifdef FEATURE_WLAN_SCAN_PNO 1928 bool ucfg_scan_is_pno_offload_enabled(struct wlan_objmgr_psoc *psoc) 1929 { 1930 struct wlan_scan_obj *scan_obj; 1931 1932 scan_obj = wlan_psoc_get_scan_obj(psoc); 1933 if (!scan_obj) { 1934 scm_err("NULL scan obj"); 1935 return false; 1936 } 1937 1938 return scan_obj->pno_cfg.pno_offload_enabled; 1939 } 1940 1941 void ucfg_scan_set_pno_offload(struct wlan_objmgr_psoc *psoc, bool value) 1942 { 1943 struct wlan_scan_obj *scan_obj; 1944 1945 scan_obj = wlan_psoc_get_scan_obj(psoc); 1946 if (!scan_obj) { 1947 scm_err("NULL scan obj"); 1948 return; 1949 } 1950 1951 scan_obj->pno_cfg.pno_offload_enabled = value; 1952 } 1953 1954 bool ucfg_scan_get_pno_scan_support(struct wlan_objmgr_psoc *psoc) 1955 { 1956 struct wlan_scan_obj *scan_obj; 1957 1958 scan_obj = wlan_psoc_get_scan_obj(psoc); 1959 if (!scan_obj) { 1960 scm_err("NULL scan obj"); 1961 return cfg_default(CFG_PNO_SCAN_SUPPORT); 1962 } 1963 1964 return scan_obj->pno_cfg.scan_support_enabled; 1965 } 1966 1967 uint8_t ucfg_get_scan_backoff_multiplier(struct wlan_objmgr_psoc *psoc) 1968 { 1969 struct wlan_scan_obj *scan_obj; 1970 1971 scan_obj = wlan_psoc_get_scan_obj(psoc); 1972 if (!scan_obj) { 1973 scm_err("NULL scan obj"); 1974 return cfg_default(CFG_SCAN_BACKOFF_MULTIPLIER); 1975 } 1976 return scan_obj->pno_cfg.scan_backoff_multiplier; 1977 } 1978 1979 bool ucfg_scan_is_dfs_chnl_scan_enabled(struct wlan_objmgr_psoc *psoc) 1980 { 1981 struct wlan_scan_obj *scan_obj; 1982 1983 scan_obj = wlan_psoc_get_scan_obj(psoc); 1984 if (!scan_obj) { 1985 scm_err("NULL scan obj"); 1986 return cfg_default(CFG_ENABLE_DFS_PNO_CHNL_SCAN); 1987 } 1988 return scan_obj->pno_cfg.dfs_chnl_scan_enabled; 1989 } 1990 1991 uint32_t ucfg_scan_get_scan_timer_repeat_value(struct wlan_objmgr_psoc *psoc) 1992 { 1993 struct wlan_scan_obj *scan_obj; 1994 1995 scan_obj = wlan_psoc_get_scan_obj(psoc); 1996 if (!scan_obj) { 1997 scm_err("NULL scan obj"); 1998 return cfg_default(CFG_PNO_SCAN_TIMER_REPEAT_VALUE); 1999 } 2000 return scan_obj->pno_cfg.scan_timer_repeat_value; 2001 } 2002 2003 uint32_t ucfg_scan_get_slow_scan_multiplier(struct wlan_objmgr_psoc *psoc) 2004 { 2005 struct wlan_scan_obj *scan_obj; 2006 2007 scan_obj = wlan_psoc_get_scan_obj(psoc); 2008 if (!scan_obj) { 2009 scm_err("NULL scan obj"); 2010 return cfg_default(CFG_PNO_SLOW_SCAN_MULTIPLIER); 2011 } 2012 return scan_obj->pno_cfg.slow_scan_multiplier; 2013 } 2014 2015 uint32_t 2016 ucfg_scan_get_max_sched_scan_plan_interval(struct wlan_objmgr_psoc *psoc) 2017 { 2018 struct wlan_scan_obj *scan_obj; 2019 2020 scan_obj = wlan_psoc_get_scan_obj(psoc); 2021 if (!scan_obj) { 2022 scm_err("Failed to get scan object"); 2023 return cfg_default(CFG_MAX_SCHED_SCAN_PLAN_INTERVAL); 2024 } 2025 2026 return scan_obj->pno_cfg.max_sched_scan_plan_interval; 2027 } 2028 2029 uint32_t 2030 ucfg_scan_get_max_sched_scan_plan_iterations(struct wlan_objmgr_psoc *psoc) 2031 { 2032 struct wlan_scan_obj *scan_obj; 2033 2034 scan_obj = wlan_psoc_get_scan_obj(psoc); 2035 if (!scan_obj) { 2036 scm_err("Failed to get scan object"); 2037 return cfg_default(CFG_MAX_SCHED_SCAN_PLAN_ITERATIONS); 2038 } 2039 2040 return scan_obj->pno_cfg.max_sched_scan_plan_iterations; 2041 } 2042 2043 #endif 2044