1 /* 2 * Copyright (c) 2017-2019 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 uint8_t *chan_list, uint32_t num_chan) 75 { 76 scm_filter_valid_channel(pdev, chan_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_E_ALREADY; 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 start 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 scan = wlan_psoc_get_scan_obj(psoc); 380 qdf_spin_lock_bh(&scan->lock); 381 scan->pno_cfg.pno_cb.func = event_cb; 382 scan->pno_cfg.pno_cb.arg = arg; 383 qdf_spin_unlock_bh(&scan->lock); 384 scm_debug("event_cb: 0x%pK, arg: 0x%pK", event_cb, arg); 385 386 return QDF_STATUS_SUCCESS; 387 } 388 389 #else 390 391 static inline QDF_STATUS 392 wlan_pno_global_init(struct wlan_objmgr_psoc *psoc, 393 struct wlan_scan_obj *scan_obj) 394 { 395 return QDF_STATUS_SUCCESS; 396 } 397 398 static inline QDF_STATUS 399 wlan_pno_global_deinit(struct wlan_scan_obj *scan_obj) 400 { 401 return QDF_STATUS_SUCCESS; 402 } 403 404 #endif 405 406 QDF_STATUS 407 ucfg_scan_set_custom_scan_chan_list(struct wlan_objmgr_pdev *pdev, 408 struct chan_list *chan_list) 409 { 410 uint8_t pdev_id; 411 struct wlan_scan_obj *scan_obj; 412 413 if (!pdev || !chan_list) { 414 scm_warn("pdev: 0x%pK, chan_list: 0x%pK", pdev, chan_list); 415 return QDF_STATUS_E_NULL_VALUE; 416 } 417 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 418 scan_obj = wlan_pdev_get_scan_obj(pdev); 419 420 qdf_mem_copy(&scan_obj->pdev_info[pdev_id].custom_chan_list, 421 chan_list, sizeof(*chan_list)); 422 423 return QDF_STATUS_SUCCESS; 424 } 425 426 QDF_STATUS 427 ucfg_scan_start(struct scan_start_request *req) 428 { 429 struct scheduler_msg msg = {0}; 430 QDF_STATUS status; 431 432 if (!req || !req->vdev) { 433 scm_err("req or vdev within req is NULL"); 434 if (req) 435 scm_scan_free_scan_request_mem(req); 436 return QDF_STATUS_E_NULL_VALUE; 437 } 438 439 if (!scm_is_scan_allowed(req->vdev)) { 440 scm_err("scan disabled, rejecting the scan req"); 441 scm_scan_free_scan_request_mem(req); 442 return QDF_STATUS_E_AGAIN; 443 } 444 445 scm_debug("reqid: %d, scanid: %d, vdevid: %d", 446 req->scan_req.scan_req_id, req->scan_req.scan_id, 447 req->scan_req.vdev_id); 448 449 /* Try to get vdev reference. Return if reference could 450 * not be taken. Reference will be released once scan 451 * request handling completes along with free of @req. 452 */ 453 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID); 454 if (QDF_IS_STATUS_ERROR(status)) { 455 scm_info("unable to get reference"); 456 scm_scan_free_scan_request_mem(req); 457 return status; 458 } 459 460 msg.bodyptr = req; 461 msg.callback = scm_scan_start_req; 462 msg.flush_callback = scm_scan_start_flush_callback; 463 464 status = scheduler_post_message(QDF_MODULE_ID_OS_IF, 465 QDF_MODULE_ID_SCAN, 466 QDF_MODULE_ID_OS_IF, &msg); 467 if (QDF_IS_STATUS_ERROR(status)) { 468 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_SCAN_ID); 469 scm_scan_free_scan_request_mem(req); 470 } 471 472 return status; 473 } 474 475 QDF_STATUS ucfg_scan_psoc_set_enable(struct wlan_objmgr_psoc *psoc, 476 enum scan_disable_reason reason) 477 { 478 struct wlan_scan_obj *scan_obj; 479 480 scan_obj = wlan_psoc_get_scan_obj(psoc); 481 if (!scan_obj) { 482 scm_err("Failed to get scan object"); 483 return QDF_STATUS_E_NULL_VALUE; 484 } 485 486 scan_obj->scan_disabled &= ~reason; 487 scm_debug("Psoc scan_disabled %x", scan_obj->scan_disabled); 488 489 return QDF_STATUS_SUCCESS; 490 } 491 492 QDF_STATUS ucfg_scan_psoc_set_disable(struct wlan_objmgr_psoc *psoc, 493 enum scan_disable_reason reason) 494 { 495 struct wlan_scan_obj *scan_obj; 496 497 scan_obj = wlan_psoc_get_scan_obj(psoc); 498 if (!scan_obj) { 499 scm_err("Failed to get scan object"); 500 return QDF_STATUS_E_NULL_VALUE; 501 } 502 503 scan_obj->scan_disabled |= reason; 504 505 scm_debug("Psoc scan_disabled %x", scan_obj->scan_disabled); 506 507 return QDF_STATUS_SUCCESS; 508 } 509 510 511 QDF_STATUS ucfg_scan_vdev_set_enable(struct wlan_objmgr_vdev *vdev, 512 enum scan_disable_reason reason) 513 { 514 struct scan_vdev_obj *scan_vdev_obj; 515 516 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 517 if (!scan_vdev_obj) { 518 scm_err("null scan_vdev_obj"); 519 return QDF_STATUS_E_NULL_VALUE; 520 } 521 522 scan_vdev_obj->scan_disabled &= ~reason; 523 524 scm_debug("Vdev scan_disabled %x", scan_vdev_obj->scan_disabled); 525 526 return QDF_STATUS_SUCCESS; 527 } 528 529 QDF_STATUS ucfg_scan_vdev_set_disable(struct wlan_objmgr_vdev *vdev, 530 enum scan_disable_reason reason) 531 { 532 struct scan_vdev_obj *scan_vdev_obj; 533 534 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 535 if (!scan_vdev_obj) { 536 scm_err("null scan_vdev_obj"); 537 return QDF_STATUS_E_NULL_VALUE; 538 } 539 540 scan_vdev_obj->scan_disabled |= reason; 541 542 scm_debug("Vdev scan_disabled %x", scan_vdev_obj->scan_disabled); 543 544 return QDF_STATUS_SUCCESS; 545 } 546 547 548 QDF_STATUS ucfg_scan_set_miracast( 549 struct wlan_objmgr_psoc *psoc, bool enable) 550 { 551 struct wlan_scan_obj *scan_obj; 552 553 scan_obj = wlan_psoc_get_scan_obj(psoc); 554 if (!scan_obj) { 555 scm_err("Failed to get scan object"); 556 return QDF_STATUS_E_NULL_VALUE; 557 } 558 scan_obj->miracast_enabled = enable; 559 scm_debug("set miracast_enable to %d", scan_obj->miracast_enabled); 560 561 return QDF_STATUS_SUCCESS; 562 } 563 564 QDF_STATUS 565 ucfg_scan_set_wide_band_scan(struct wlan_objmgr_pdev *pdev, bool enable) 566 { 567 uint8_t pdev_id; 568 struct wlan_scan_obj *scan_obj; 569 570 if (!pdev) { 571 scm_warn("null vdev"); 572 return QDF_STATUS_E_NULL_VALUE; 573 } 574 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 575 scan_obj = wlan_pdev_get_scan_obj(pdev); 576 if (!scan_obj) 577 return QDF_STATUS_E_FAILURE; 578 579 scm_debug("set wide_band_scan to %d", enable); 580 scan_obj->pdev_info[pdev_id].wide_band_scan = enable; 581 582 return QDF_STATUS_SUCCESS; 583 } 584 585 bool ucfg_scan_get_wide_band_scan(struct wlan_objmgr_pdev *pdev) 586 { 587 uint8_t pdev_id; 588 struct wlan_scan_obj *scan_obj; 589 590 if (!pdev) { 591 scm_warn("null vdev"); 592 return QDF_STATUS_E_NULL_VALUE; 593 } 594 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 595 scan_obj = wlan_pdev_get_scan_obj(pdev); 596 if (!scan_obj) 597 return QDF_STATUS_E_FAILURE; 598 599 return scan_obj->pdev_info[pdev_id].wide_band_scan; 600 } 601 602 #ifdef WLAN_DFS_CHAN_HIDDEN_SSID 603 QDF_STATUS 604 ucfg_scan_config_hidden_ssid_for_bssid(struct wlan_objmgr_pdev *pdev, 605 uint8_t *bssid, struct wlan_ssid *ssid) 606 { 607 uint8_t pdev_id; 608 struct wlan_scan_obj *scan_obj; 609 610 if (!pdev) { 611 scm_warn("null vdev"); 612 return QDF_STATUS_E_NULL_VALUE; 613 } 614 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 615 scan_obj = wlan_pdev_get_scan_obj(pdev); 616 if (!scan_obj) 617 return QDF_STATUS_E_FAILURE; 618 619 scm_debug("Configure bsssid:%pM ssid:%.*s", 620 bssid, ssid->length, ssid->ssid); 621 qdf_mem_copy(scan_obj->pdev_info[pdev_id].conf_bssid, 622 bssid, QDF_MAC_ADDR_SIZE); 623 scan_obj->pdev_info[pdev_id].conf_ssid.length = ssid->length; 624 qdf_mem_copy(scan_obj->pdev_info[pdev_id].conf_ssid.ssid, 625 ssid->ssid, 626 scan_obj->pdev_info[pdev_id].conf_ssid.length); 627 628 return QDF_STATUS_SUCCESS; 629 } 630 #endif /* WLAN_DFS_CHAN_HIDDEN_SSID */ 631 632 QDF_STATUS 633 ucfg_scan_cancel(struct scan_cancel_request *req) 634 { 635 struct scheduler_msg msg = {0}; 636 QDF_STATUS status; 637 638 if (!req || !req->vdev) { 639 scm_err("req or vdev within req is NULL"); 640 if (req) 641 qdf_mem_free(req); 642 return QDF_STATUS_E_NULL_VALUE; 643 } 644 scm_debug("reqid: %d, scanid: %d, vdevid: %d, type: %d", 645 req->cancel_req.requester, req->cancel_req.scan_id, 646 req->cancel_req.vdev_id, req->cancel_req.req_type); 647 648 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID); 649 if (QDF_IS_STATUS_ERROR(status)) { 650 scm_info("Failed to get vdev ref; status:%d", status); 651 goto req_free; 652 } 653 654 msg.bodyptr = req; 655 msg.callback = scm_scan_cancel_req; 656 msg.flush_callback = scm_scan_cancel_flush_callback; 657 658 status = scheduler_post_message(QDF_MODULE_ID_OS_IF, 659 QDF_MODULE_ID_SCAN, 660 QDF_MODULE_ID_OS_IF, &msg); 661 if (QDF_IS_STATUS_ERROR(status)) 662 goto vdev_put; 663 664 return QDF_STATUS_SUCCESS; 665 666 vdev_put: 667 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_SCAN_ID); 668 669 req_free: 670 qdf_mem_free(req); 671 672 return status; 673 } 674 675 QDF_STATUS 676 ucfg_scan_cancel_sync(struct scan_cancel_request *req) 677 { 678 QDF_STATUS status; 679 bool cancel_vdev = false, cancel_pdev = false; 680 struct wlan_objmgr_vdev *vdev; 681 struct wlan_objmgr_pdev *pdev; 682 uint32_t max_wait_iterations = SCM_CANCEL_SCAN_WAIT_ITERATION; 683 qdf_event_t cancel_scan_event; 684 685 if (!req || !req->vdev) { 686 scm_err("req or vdev within req is NULL"); 687 if (req) 688 qdf_mem_free(req); 689 return QDF_STATUS_E_NULL_VALUE; 690 } 691 692 if (req->cancel_req.req_type == 693 WLAN_SCAN_CANCEL_PDEV_ALL) 694 cancel_pdev = true; 695 else if (req->cancel_req.req_type == 696 WLAN_SCAN_CANCEL_VDEV_ALL) 697 cancel_vdev = true; 698 699 vdev = req->vdev; 700 status = ucfg_scan_cancel(req); 701 if (QDF_IS_STATUS_ERROR(status)) 702 return status; 703 704 memset(&cancel_scan_event, 0, sizeof(cancel_scan_event)); 705 /* 706 * If cancel req is to cancel all scan of pdev or vdev 707 * wait until all scan of pdev or vdev get cancelled 708 */ 709 qdf_event_create(&cancel_scan_event); 710 qdf_event_reset(&cancel_scan_event); 711 712 if (cancel_pdev) { 713 pdev = wlan_vdev_get_pdev(vdev); 714 while ((ucfg_scan_get_pdev_status(pdev) != 715 SCAN_NOT_IN_PROGRESS) && max_wait_iterations) { 716 scm_debug("wait for all pdev scan to get complete"); 717 qdf_wait_single_event(&cancel_scan_event, 718 SCM_CANCEL_SCAN_WAIT_TIME); 719 max_wait_iterations--; 720 } 721 } else if (cancel_vdev) { 722 while ((ucfg_scan_get_vdev_status(vdev) != 723 SCAN_NOT_IN_PROGRESS) && max_wait_iterations) { 724 scm_debug("wait for all vdev scan to get complete"); 725 qdf_wait_single_event(&cancel_scan_event, 726 SCM_CANCEL_SCAN_WAIT_TIME); 727 max_wait_iterations--; 728 } 729 } 730 731 qdf_event_destroy(&cancel_scan_event); 732 733 if (!max_wait_iterations) { 734 scm_err("Failed to wait for scans to get complete"); 735 return QDF_STATUS_E_TIMEOUT; 736 } 737 738 return status; 739 } 740 741 wlan_scan_requester 742 ucfg_scan_register_requester(struct wlan_objmgr_psoc *psoc, 743 uint8_t *name, scan_event_handler event_cb, void *arg) 744 { 745 int i, j; 746 struct wlan_scan_obj *scan; 747 struct scan_requester_info *requesters; 748 wlan_scan_requester requester = {0}; 749 750 if (!psoc) { 751 scm_err("null psoc"); 752 return 0; 753 } 754 scan = wlan_psoc_get_scan_obj(psoc); 755 if (!scan) 756 return 0; 757 758 requesters = scan->requesters; 759 qdf_spin_lock_bh(&scan->lock); 760 for (i = 0; i < WLAN_MAX_REQUESTORS; ++i) { 761 if (requesters[i].requester == 0) { 762 requesters[i].requester = 763 WLAN_SCAN_REQUESTER_ID_PREFIX | i; 764 j = 0; 765 while (name[j] && (j < (WLAN_MAX_MODULE_NAME - 1))) { 766 requesters[i].module[j] = name[j]; 767 ++j; 768 } 769 requesters[i].module[j] = 0; 770 requesters[i].ev_handler.func = event_cb; 771 requesters[i].ev_handler.arg = arg; 772 requester = requesters[i].requester; 773 break; 774 } 775 } 776 qdf_spin_unlock_bh(&scan->lock); 777 scm_debug("module: %s, event_cb: 0x%pK, arg: 0x%pK, reqid: %d", 778 name, event_cb, arg, requester); 779 780 return requester; 781 } 782 783 void 784 ucfg_scan_unregister_requester(struct wlan_objmgr_psoc *psoc, 785 wlan_scan_requester requester) 786 { 787 int idx; 788 struct wlan_scan_obj *scan; 789 struct scan_requester_info *requesters; 790 791 idx = requester & WLAN_SCAN_REQUESTER_ID_PREFIX; 792 if (idx != WLAN_SCAN_REQUESTER_ID_PREFIX) { 793 scm_err("prefix didn't match for requester id %d", requester); 794 return; 795 } 796 797 idx = requester & WLAN_SCAN_REQUESTER_ID_MASK; 798 if (idx >= WLAN_MAX_REQUESTORS) { 799 scm_err("requester id %d greater than max value", requester); 800 return; 801 } 802 803 if (!psoc) { 804 scm_err("null psoc"); 805 return; 806 } 807 scan = wlan_psoc_get_scan_obj(psoc); 808 if (!scan) 809 return; 810 requesters = scan->requesters; 811 scm_debug("reqid: %d", requester); 812 813 qdf_spin_lock_bh(&scan->lock); 814 requesters[idx].requester = 0; 815 requesters[idx].module[0] = 0; 816 requesters[idx].ev_handler.func = NULL; 817 requesters[idx].ev_handler.arg = NULL; 818 qdf_spin_unlock_bh(&scan->lock); 819 } 820 821 uint8_t* 822 ucfg_get_scan_requester_name(struct wlan_objmgr_psoc *psoc, 823 wlan_scan_requester requester) 824 { 825 int idx = requester & WLAN_SCAN_REQUESTER_ID_MASK; 826 struct wlan_scan_obj *scan; 827 struct scan_requester_info *requesters; 828 829 if (!psoc) { 830 scm_err("null psoc"); 831 return "null"; 832 } 833 scan = wlan_psoc_get_scan_obj(psoc); 834 if (!scan) 835 return "null"; 836 837 requesters = scan->requesters; 838 839 if ((idx < WLAN_MAX_REQUESTORS) && 840 (requesters[idx].requester == requester)) { 841 return requesters[idx].module; 842 } 843 844 return (uint8_t *)"unknown"; 845 } 846 847 wlan_scan_id 848 ucfg_scan_get_scan_id(struct wlan_objmgr_psoc *psoc) 849 { 850 wlan_scan_id id; 851 struct wlan_scan_obj *scan; 852 853 if (!psoc) { 854 QDF_ASSERT(0); 855 scm_err("null psoc"); 856 return 0; 857 } 858 scan = wlan_psoc_get_scan_obj(psoc); 859 860 id = qdf_atomic_inc_return(&scan->scan_ids); 861 id = id & WLAN_SCAN_ID_MASK; 862 /* Mark this scan request as triggered by host 863 * by setting WLAN_HOST_SCAN_REQ_ID_PREFIX flag. 864 */ 865 id = id | WLAN_HOST_SCAN_REQ_ID_PREFIX; 866 scm_debug("scan_id: 0x%x", id); 867 868 return id; 869 } 870 871 static QDF_STATUS 872 scm_add_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler, 873 scan_event_handler event_cb, void *arg) 874 { 875 struct cb_handler *cb_handler; 876 uint32_t handler_cnt = pdev_ev_handler->handler_cnt; 877 878 /* Assign next available slot to this registration request */ 879 cb_handler = &(pdev_ev_handler->cb_handlers[handler_cnt]); 880 cb_handler->func = event_cb; 881 cb_handler->arg = arg; 882 pdev_ev_handler->handler_cnt++; 883 884 return QDF_STATUS_SUCCESS; 885 } 886 887 QDF_STATUS 888 ucfg_scan_register_event_handler(struct wlan_objmgr_pdev *pdev, 889 scan_event_handler event_cb, void *arg) 890 { 891 uint32_t idx; 892 struct wlan_scan_obj *scan; 893 struct pdev_scan_ev_handler *pdev_ev_handler; 894 struct cb_handler *cb_handler; 895 896 /* scan event handler call back can't be NULL */ 897 if (!pdev || !event_cb) { 898 scm_err("pdev: %pK, event_cb: %pK", pdev, event_cb); 899 return QDF_STATUS_E_NULL_VALUE; 900 } 901 902 scm_debug("pdev: %pK, event_cb: %pK, arg: %pK\n", pdev, event_cb, arg); 903 904 scan = wlan_pdev_get_scan_obj(pdev); 905 pdev_ev_handler = wlan_pdev_get_pdev_scan_ev_handlers(pdev); 906 if (!pdev_ev_handler) { 907 scm_err("null pdev_ev_handler"); 908 return QDF_STATUS_E_NULL_VALUE; 909 } 910 cb_handler = &(pdev_ev_handler->cb_handlers[0]); 911 912 qdf_spin_lock_bh(&scan->lock); 913 /* Ensure its not a duplicate registration request */ 914 for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; 915 idx++, cb_handler++) { 916 if ((cb_handler->func == event_cb) && 917 (cb_handler->arg == arg)) { 918 qdf_spin_unlock_bh(&scan->lock); 919 scm_debug("func: %pK, arg: %pK already exists", 920 event_cb, arg); 921 return QDF_STATUS_SUCCESS; 922 } 923 } 924 925 QDF_ASSERT(pdev_ev_handler->handler_cnt < 926 MAX_SCAN_EVENT_HANDLERS_PER_PDEV); 927 928 if (pdev_ev_handler->handler_cnt >= MAX_SCAN_EVENT_HANDLERS_PER_PDEV) { 929 qdf_spin_unlock_bh(&scan->lock); 930 scm_warn("No more registrations possible"); 931 return QDF_STATUS_E_NOMEM; 932 } 933 934 scm_add_scan_event_handler(pdev_ev_handler, event_cb, arg); 935 qdf_spin_unlock_bh(&scan->lock); 936 937 scm_debug("event_cb: 0x%pK, arg: 0x%pK", event_cb, arg); 938 939 return QDF_STATUS_SUCCESS; 940 } 941 942 static QDF_STATUS 943 wlan_scan_global_init(struct wlan_objmgr_psoc *psoc, 944 struct wlan_scan_obj *scan_obj) 945 { 946 scan_obj->scan_disabled = 0; 947 scan_obj->drop_bcn_on_chan_mismatch = 948 cfg_get(psoc, CFG_DROP_BCN_ON_CHANNEL_MISMATCH); 949 scan_obj->disable_timeout = false; 950 scan_obj->scan_def.active_dwell = 951 cfg_get(psoc, CFG_ACTIVE_MAX_CHANNEL_TIME); 952 /* the ini is disallow DFS channel scan if ini is 1, so negate that */ 953 scan_obj->scan_def.allow_dfs_chan_in_first_scan = 954 !cfg_get(psoc, CFG_INITIAL_NO_DFS_SCAN); 955 scan_obj->scan_def.allow_dfs_chan_in_scan = 956 cfg_get(psoc, CFG_ENABLE_DFS_SCAN); 957 scan_obj->scan_def.skip_dfs_chan_in_p2p_search = 958 cfg_get(psoc, CFG_ENABLE_SKIP_DFS_IN_P2P_SEARCH); 959 scan_obj->scan_def.use_wake_lock_in_user_scan = 960 cfg_get(psoc, CFG_ENABLE_WAKE_LOCK_IN_SCAN); 961 scan_obj->scan_def.active_dwell_2g = 962 cfg_get(psoc, CFG_ACTIVE_MAX_2G_CHANNEL_TIME); 963 scan_obj->scan_def.passive_dwell = 964 cfg_get(psoc, CFG_PASSIVE_MAX_CHANNEL_TIME); 965 scan_obj->scan_def.max_rest_time = SCAN_MAX_REST_TIME; 966 scan_obj->scan_def.sta_miracast_mcc_rest_time = 967 SCAN_STA_MIRACAST_MCC_REST_TIME; 968 scan_obj->scan_def.min_rest_time = SCAN_MIN_REST_TIME; 969 scan_obj->scan_def.conc_active_dwell = 970 cfg_get(psoc, CFG_ACTIVE_MAX_CHANNEL_TIME_CONC); 971 scan_obj->scan_def.conc_passive_dwell = 972 cfg_get(psoc, CFG_PASSIVE_MAX_CHANNEL_TIME_CONC); 973 scan_obj->scan_def.conc_max_rest_time = 974 cfg_get(psoc, CFG_MAX_REST_TIME_CONC); 975 scan_obj->scan_def.conc_min_rest_time = 976 cfg_get(psoc, CFG_MIN_REST_TIME_CONC); 977 scan_obj->scan_def.conc_idle_time = 978 cfg_get(psoc, CFG_IDLE_TIME_CONC); 979 scan_obj->scan_def.repeat_probe_time = 980 cfg_get(psoc, CFG_SCAN_PROBE_REPEAT_TIME); 981 scan_obj->scan_def.probe_spacing_time = SCAN_PROBE_SPACING_TIME; 982 scan_obj->scan_def.probe_delay = SCAN_PROBE_DELAY; 983 scan_obj->scan_def.burst_duration = SCAN_BURST_DURATION; 984 scan_obj->scan_def.max_scan_time = SCAN_MAX_SCAN_TIME; 985 scan_obj->scan_def.num_probes = cfg_get(psoc, CFG_SCAN_NUM_PROBES); 986 scan_obj->scan_def.scan_cache_aging_time = 987 (cfg_get(psoc, CFG_SCAN_AGING_TIME) * 1000); 988 scan_obj->scan_def.max_bss_per_pdev = SCAN_MAX_BSS_PDEV; 989 scan_obj->scan_def.scan_priority = SCAN_PRIORITY; 990 scan_obj->scan_def.idle_time = SCAN_NETWORK_IDLE_TIMEOUT; 991 scan_obj->scan_def.adaptive_dwell_time_mode = 992 cfg_get(psoc, CFG_ADAPTIVE_SCAN_DWELL_MODE); 993 scan_obj->scan_def.adaptive_dwell_time_mode_nc = 994 cfg_get(psoc, CFG_ADAPTIVE_SCAN_DWELL_MODE_NC); 995 scan_obj->scan_def.honour_nl_scan_policy_flags = 996 cfg_get(psoc, CFG_HONOUR_NL_SCAN_POLICY_FLAGS); 997 scan_obj->scan_def.enable_mac_spoofing = 998 cfg_get(psoc, CFG_ENABLE_MAC_ADDR_SPOOFING); 999 scan_obj->scan_def.extscan_adaptive_dwell_mode = 1000 cfg_get(psoc, CFG_ADAPTIVE_EXTSCAN_DWELL_MODE); 1001 1002 /* init burst durations */ 1003 scan_obj->scan_def.sta_scan_burst_duration = 1004 cfg_get(psoc, CFG_STA_SCAN_BURST_DURATION); 1005 scan_obj->scan_def.p2p_scan_burst_duration = 1006 cfg_get(psoc, CFG_P2P_SCAN_BURST_DURATION); 1007 scan_obj->scan_def.go_scan_burst_duration = 1008 cfg_get(psoc, CFG_GO_SCAN_BURST_DURATION); 1009 scan_obj->scan_def.ap_scan_burst_duration = 1010 cfg_get(psoc, CFG_AP_SCAN_BURST_DURATION); 1011 /* scan contrl flags */ 1012 scan_obj->scan_def.scan_f_passive = true; 1013 scan_obj->scan_def.scan_f_ofdm_rates = true; 1014 scan_obj->scan_def.scan_f_2ghz = true; 1015 scan_obj->scan_def.scan_f_5ghz = true; 1016 scan_obj->scan_def.scan_f_chan_stat_evnt = 1017 cfg_get(psoc, CFG_ENABLE_SNR_MONITORING); 1018 /* scan event flags */ 1019 scan_obj->scan_def.scan_ev_started = true; 1020 scan_obj->scan_def.scan_ev_completed = true; 1021 scan_obj->scan_def.scan_ev_bss_chan = true; 1022 scan_obj->scan_def.scan_ev_foreign_chan = true; 1023 scan_obj->scan_def.scan_ev_foreign_chn_exit = true; 1024 scan_obj->scan_def.scan_ev_dequeued = true; 1025 scan_obj->scan_def.scan_ev_preempted = true; 1026 scan_obj->scan_def.scan_ev_start_failed = true; 1027 scan_obj->scan_def.scan_ev_restarted = true; 1028 scan_obj->scan_def.enable_connected_scan = 1029 cfg_get(psoc, CFG_ENABLE_CONNECTED_SCAN); 1030 /* init scan id seed */ 1031 qdf_atomic_init(&scan_obj->scan_ids); 1032 1033 /* init extscan */ 1034 wlan_extscan_global_init(psoc, scan_obj); 1035 1036 return wlan_pno_global_init(psoc, scan_obj); 1037 } 1038 1039 static void 1040 wlan_scan_global_deinit(struct wlan_objmgr_psoc *psoc) 1041 { 1042 struct wlan_scan_obj *scan_obj; 1043 1044 scan_obj = wlan_psoc_get_scan_obj(psoc); 1045 wlan_pno_global_deinit(scan_obj); 1046 wlan_extscan_global_deinit(); 1047 } 1048 1049 static QDF_STATUS 1050 scm_remove_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler, 1051 struct cb_handler *entry) 1052 { 1053 struct cb_handler *last_entry; 1054 uint32_t handler_cnt = pdev_ev_handler->handler_cnt; 1055 1056 /* Replace event handler being deleted 1057 * with the last one in the list. 1058 */ 1059 last_entry = &(pdev_ev_handler->cb_handlers[handler_cnt - 1]); 1060 entry->func = last_entry->func; 1061 entry->arg = last_entry->arg; 1062 1063 /* Clear our last entry */ 1064 last_entry->func = NULL; 1065 last_entry->arg = NULL; 1066 pdev_ev_handler->handler_cnt--; 1067 1068 return QDF_STATUS_SUCCESS; 1069 } 1070 1071 void 1072 ucfg_scan_unregister_event_handler(struct wlan_objmgr_pdev *pdev, 1073 scan_event_handler event_cb, void *arg) 1074 { 1075 uint8_t found = false; 1076 uint32_t idx; 1077 uint32_t handler_cnt; 1078 struct wlan_scan_obj *scan; 1079 struct cb_handler *cb_handler; 1080 struct pdev_scan_ev_handler *pdev_ev_handler; 1081 1082 scm_debug("pdev: %pK, event_cb: 0x%pK, arg: 0x%pK", pdev, event_cb, 1083 arg); 1084 if (!pdev) { 1085 scm_err("null pdev"); 1086 return; 1087 } 1088 scan = wlan_pdev_get_scan_obj(pdev); 1089 if (!scan) 1090 return; 1091 1092 pdev_ev_handler = wlan_pdev_get_pdev_scan_ev_handlers(pdev); 1093 if (!pdev_ev_handler) 1094 return; 1095 1096 cb_handler = &(pdev_ev_handler->cb_handlers[0]); 1097 1098 qdf_spin_lock_bh(&scan->lock); 1099 handler_cnt = pdev_ev_handler->handler_cnt; 1100 if (!handler_cnt) { 1101 qdf_spin_unlock_bh(&scan->lock); 1102 scm_info("No event handlers registered"); 1103 return; 1104 } 1105 1106 for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; 1107 idx++, cb_handler++) { 1108 if ((cb_handler->func == event_cb) && 1109 (cb_handler->arg == arg)) { 1110 /* Event handler found, remove it 1111 * from event handler list. 1112 */ 1113 found = true; 1114 scm_remove_scan_event_handler(pdev_ev_handler, 1115 cb_handler); 1116 handler_cnt--; 1117 break; 1118 } 1119 } 1120 qdf_spin_unlock_bh(&scan->lock); 1121 1122 scm_debug("event handler %s, remaining handlers: %d", 1123 (found ? "removed" : "not found"), handler_cnt); 1124 } 1125 1126 QDF_STATUS 1127 ucfg_scan_init_default_params(struct wlan_objmgr_vdev *vdev, 1128 struct scan_start_request *req) 1129 { 1130 struct scan_default_params *def; 1131 1132 if (!vdev | !req) { 1133 scm_err("vdev: 0x%pK, req: 0x%pK", vdev, req); 1134 return QDF_STATUS_E_INVAL; 1135 } 1136 def = wlan_vdev_get_def_scan_params(vdev); 1137 if (!def) { 1138 scm_err("wlan_vdev_get_def_scan_params returned NULL"); 1139 return QDF_STATUS_E_NULL_VALUE; 1140 } 1141 1142 /* Zero out everything and explicitly set fields as required */ 1143 qdf_mem_zero(req, sizeof(*req)); 1144 1145 req->vdev = vdev; 1146 req->scan_req.vdev_id = wlan_vdev_get_id(vdev); 1147 req->scan_req.scan_type = SCAN_TYPE_DEFAULT; 1148 req->scan_req.scan_priority = def->scan_priority; 1149 req->scan_req.dwell_time_active = def->active_dwell; 1150 req->scan_req.dwell_time_active_2g = def->active_dwell_2g; 1151 req->scan_req.dwell_time_passive = def->passive_dwell; 1152 req->scan_req.min_rest_time = def->min_rest_time; 1153 req->scan_req.max_rest_time = def->max_rest_time; 1154 req->scan_req.repeat_probe_time = def->repeat_probe_time; 1155 req->scan_req.probe_spacing_time = def->probe_spacing_time; 1156 req->scan_req.idle_time = def->idle_time; 1157 req->scan_req.max_scan_time = def->max_scan_time; 1158 req->scan_req.probe_delay = def->probe_delay; 1159 req->scan_req.burst_duration = def->burst_duration; 1160 req->scan_req.n_probes = def->num_probes; 1161 req->scan_req.adaptive_dwell_time_mode = 1162 def->adaptive_dwell_time_mode; 1163 req->scan_req.scan_flags = def->scan_flags; 1164 req->scan_req.scan_events = def->scan_events; 1165 req->scan_req.scan_random.randomize = def->enable_mac_spoofing; 1166 1167 return QDF_STATUS_SUCCESS; 1168 } 1169 1170 QDF_STATUS 1171 ucfg_scan_init_ssid_params(struct scan_start_request *req, 1172 uint32_t num_ssid, struct wlan_ssid *ssid_list) 1173 { 1174 uint32_t max_ssid = sizeof(req->scan_req.ssid) / 1175 sizeof(req->scan_req.ssid[0]); 1176 1177 if (!req) { 1178 scm_err("null request"); 1179 return QDF_STATUS_E_NULL_VALUE; 1180 } 1181 if (!num_ssid) { 1182 /* empty channel list provided */ 1183 req->scan_req.num_ssids = 0; 1184 qdf_mem_zero(&req->scan_req.ssid[0], 1185 sizeof(req->scan_req.ssid)); 1186 return QDF_STATUS_SUCCESS; 1187 } 1188 if (!ssid_list) { 1189 scm_err("null ssid_list while num_ssid: %d", num_ssid); 1190 return QDF_STATUS_E_NULL_VALUE; 1191 } 1192 if (num_ssid > max_ssid) { 1193 /* got a big list. alert and continue */ 1194 scm_warn("overflow: received %d, max supported : %d", 1195 num_ssid, max_ssid); 1196 return QDF_STATUS_E_E2BIG; 1197 } 1198 1199 if (max_ssid > num_ssid) 1200 max_ssid = num_ssid; 1201 1202 req->scan_req.num_ssids = max_ssid; 1203 qdf_mem_copy(&req->scan_req.ssid[0], ssid_list, 1204 (req->scan_req.num_ssids * sizeof(req->scan_req.ssid[0]))); 1205 1206 return QDF_STATUS_SUCCESS; 1207 } 1208 1209 QDF_STATUS 1210 ucfg_scan_init_bssid_params(struct scan_start_request *req, 1211 uint32_t num_bssid, struct qdf_mac_addr *bssid_list) 1212 { 1213 uint32_t max_bssid = sizeof(req->scan_req.bssid_list) / 1214 sizeof(req->scan_req.bssid_list[0]); 1215 1216 if (!req) { 1217 scm_err("null request"); 1218 return QDF_STATUS_E_NULL_VALUE; 1219 } 1220 if (!num_bssid) { 1221 /* empty channel list provided */ 1222 req->scan_req.num_bssid = 0; 1223 qdf_mem_zero(&req->scan_req.bssid_list[0], 1224 sizeof(req->scan_req.bssid_list)); 1225 return QDF_STATUS_SUCCESS; 1226 } 1227 if (!bssid_list) { 1228 scm_err("null bssid_list while num_bssid: %d", num_bssid); 1229 return QDF_STATUS_E_NULL_VALUE; 1230 } 1231 if (num_bssid > max_bssid) { 1232 /* got a big list. alert and continue */ 1233 scm_warn("overflow: received %d, max supported : %d", 1234 num_bssid, max_bssid); 1235 return QDF_STATUS_E_E2BIG; 1236 } 1237 1238 if (max_bssid > num_bssid) 1239 max_bssid = num_bssid; 1240 1241 req->scan_req.num_bssid = max_bssid; 1242 qdf_mem_copy(&req->scan_req.bssid_list[0], bssid_list, 1243 req->scan_req.num_bssid * sizeof(req->scan_req.bssid_list[0])); 1244 1245 return QDF_STATUS_SUCCESS; 1246 } 1247 1248 /** 1249 * is_chan_enabled_for_scan() - helper API to check if a frequency 1250 * is allowed to scan. 1251 * @reg_chan: regulatory_channel object 1252 * @low_2g: lower 2.4 GHz frequency thresold 1253 * @high_2g: upper 2.4 GHz frequency thresold 1254 * @low_5g: lower 5 GHz frequency thresold 1255 * @high_5g: upper 5 GHz frequency thresold 1256 * 1257 * Return: true if scan is allowed. false otherwise. 1258 */ 1259 static bool 1260 is_chan_enabled_for_scan(struct regulatory_channel *reg_chan, 1261 uint32_t low_2g, uint32_t high_2g, uint32_t low_5g, 1262 uint32_t high_5g) 1263 { 1264 if (reg_chan->state == CHANNEL_STATE_DISABLE) 1265 return false; 1266 if (reg_chan->nol_chan) 1267 return false; 1268 /* 2 GHz channel */ 1269 if ((util_scan_scm_chan_to_band(reg_chan->chan_num) == 1270 WLAN_BAND_2_4_GHZ) && 1271 ((reg_chan->center_freq < low_2g) || 1272 (reg_chan->center_freq > high_2g))) 1273 return false; 1274 else if ((util_scan_scm_chan_to_band(reg_chan->chan_num) == 1275 WLAN_BAND_5_GHZ) && 1276 ((reg_chan->center_freq < low_5g) || 1277 (reg_chan->center_freq > high_5g))) 1278 return false; 1279 1280 return true; 1281 } 1282 1283 QDF_STATUS 1284 ucfg_scan_init_chanlist_params(struct scan_start_request *req, 1285 uint32_t num_chans, uint32_t *chan_list, uint32_t *phymode) 1286 { 1287 uint32_t idx; 1288 QDF_STATUS status; 1289 struct regulatory_channel *reg_chan_list = NULL; 1290 uint32_t low_2g, high_2g, low_5g, high_5g; 1291 struct wlan_objmgr_pdev *pdev = NULL; 1292 uint32_t *scan_freqs = NULL; 1293 uint32_t max_chans = sizeof(req->scan_req.chan_list.chan) / 1294 sizeof(req->scan_req.chan_list.chan[0]); 1295 if (!req) { 1296 scm_err("null request"); 1297 return QDF_STATUS_E_NULL_VALUE; 1298 } 1299 1300 if (req->vdev) 1301 pdev = wlan_vdev_get_pdev(req->vdev); 1302 /* 1303 * If 0 channels are provided for scan and 1304 * wide band scan is enabled, scan all 20 mhz 1305 * available channels. This is required as FW 1306 * scans all channel/phy mode combinations 1307 * provided in scan channel list if 0 chans are 1308 * provided in scan request causing scan to take 1309 * too much time to complete. 1310 */ 1311 if (pdev && !num_chans) { 1312 reg_chan_list = qdf_mem_malloc_atomic(NUM_CHANNELS * 1313 sizeof(struct regulatory_channel)); 1314 if (!reg_chan_list) { 1315 scm_err("Couldn't allocate reg_chan_list memory"); 1316 status = QDF_STATUS_E_NOMEM; 1317 goto end; 1318 } 1319 scan_freqs = 1320 qdf_mem_malloc_atomic(sizeof(uint32_t) * max_chans); 1321 if (!scan_freqs) { 1322 scm_err("Couldn't allocate scan_freqs memory"); 1323 status = QDF_STATUS_E_NOMEM; 1324 goto end; 1325 } 1326 status = ucfg_reg_get_current_chan_list(pdev, reg_chan_list); 1327 if (QDF_IS_STATUS_ERROR(status)) { 1328 scm_err("Couldn't get current chan list"); 1329 goto end; 1330 } 1331 status = wlan_reg_get_freq_range(pdev, &low_2g, 1332 &high_2g, &low_5g, &high_5g); 1333 if (QDF_IS_STATUS_ERROR(status)) { 1334 scm_err("Couldn't get frequency range"); 1335 goto end; 1336 } 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_err("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_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 1384 req->scan_req.chan_list.chan[idx].phymode = 1385 SCAN_PHY_MODE_11A; 1386 1387 scm_debug("chan[%d]: freq:%d, phymode:%d", idx, 1388 req->scan_req.chan_list.chan[idx].freq, 1389 req->scan_req.chan_list.chan[idx].phymode); 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 qdf_mem_copy(&scan_def->score_config, &scan_cfg->score_config, 1504 sizeof(struct scoring_config)); 1505 scm_validate_scoring_config(&scan_def->score_config); 1506 1507 return QDF_STATUS_SUCCESS; 1508 } 1509 1510 QDF_STATUS ucfg_scan_update_roam_params(struct wlan_objmgr_psoc *psoc, 1511 struct roam_filter_params *roam_params) 1512 { 1513 struct scan_default_params *scan_def; 1514 1515 if (!psoc) { 1516 scm_err("null psoc"); 1517 return QDF_STATUS_E_FAILURE; 1518 } 1519 scan_def = wlan_scan_psoc_get_def_params(psoc); 1520 if (!scan_def) { 1521 scm_err("Failed to get scan object"); 1522 return QDF_STATUS_E_FAILURE; 1523 } 1524 1525 qdf_mem_copy(&scan_def->roam_params, roam_params, 1526 sizeof(struct roam_filter_params)); 1527 1528 return QDF_STATUS_SUCCESS; 1529 } 1530 1531 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 1532 static QDF_STATUS 1533 ucfg_scan_cancel_pdev_scan(struct wlan_objmgr_pdev *pdev) 1534 { 1535 struct scan_cancel_request *req; 1536 QDF_STATUS status; 1537 struct wlan_objmgr_vdev *vdev; 1538 1539 req = qdf_mem_malloc_atomic(sizeof(*req)); 1540 if (!req) { 1541 scm_err("Failed to allocate memory"); 1542 return QDF_STATUS_E_NOMEM; 1543 } 1544 1545 vdev = wlan_objmgr_pdev_get_first_vdev(pdev, WLAN_SCAN_ID); 1546 if (!vdev) { 1547 scm_err("Failed to get vdev"); 1548 qdf_mem_free(req); 1549 return QDF_STATUS_E_INVAL; 1550 } 1551 req->vdev = vdev; 1552 req->cancel_req.scan_id = INVAL_SCAN_ID; 1553 req->cancel_req.pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1554 req->cancel_req.vdev_id = INVAL_VDEV_ID; 1555 req->cancel_req.req_type = WLAN_SCAN_CANCEL_PDEV_ALL; 1556 status = ucfg_scan_cancel_sync(req); 1557 if (QDF_IS_STATUS_ERROR(status)) 1558 scm_err("Cancel scan request failed"); 1559 wlan_objmgr_vdev_release_ref(vdev, WLAN_SCAN_ID); 1560 1561 return status; 1562 } 1563 1564 static QDF_STATUS 1565 ucfg_scan_suspend_handler(struct wlan_objmgr_psoc *psoc, void *arg) 1566 { 1567 struct wlan_objmgr_pdev *pdev = NULL; 1568 QDF_STATUS status = QDF_STATUS_SUCCESS; 1569 int i; 1570 1571 ucfg_scan_psoc_set_disable(psoc, REASON_SUSPEND); 1572 /* Check all pdev */ 1573 for (i = 0; i < WLAN_UMAC_MAX_PDEVS; i++) { 1574 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, WLAN_SCAN_ID); 1575 if (!pdev) 1576 continue; 1577 if (ucfg_scan_get_pdev_status(pdev) != 1578 SCAN_NOT_IN_PROGRESS) 1579 status = ucfg_scan_cancel_pdev_scan(pdev); 1580 wlan_objmgr_pdev_release_ref(pdev, WLAN_SCAN_ID); 1581 if (QDF_IS_STATUS_ERROR(status)) { 1582 scm_err("failed to cancel scan for pdev_id %d", i); 1583 return status; 1584 } 1585 } 1586 1587 return QDF_STATUS_SUCCESS; 1588 } 1589 1590 static QDF_STATUS 1591 ucfg_scan_resume_handler(struct wlan_objmgr_psoc *psoc, void *arg) 1592 { 1593 ucfg_scan_psoc_set_enable(psoc, REASON_SUSPEND); 1594 return QDF_STATUS_SUCCESS; 1595 } 1596 1597 static inline void 1598 ucfg_scan_register_pmo_handler(void) 1599 { 1600 pmo_register_suspend_handler(WLAN_UMAC_COMP_SCAN, 1601 ucfg_scan_suspend_handler, NULL); 1602 pmo_register_resume_handler(WLAN_UMAC_COMP_SCAN, 1603 ucfg_scan_resume_handler, NULL); 1604 } 1605 1606 static inline void 1607 ucfg_scan_unregister_pmo_handler(void) 1608 { 1609 pmo_unregister_suspend_handler(WLAN_UMAC_COMP_SCAN, 1610 ucfg_scan_suspend_handler); 1611 pmo_unregister_resume_handler(WLAN_UMAC_COMP_SCAN, 1612 ucfg_scan_resume_handler); 1613 } 1614 1615 #else 1616 static inline void 1617 ucfg_scan_register_pmo_handler(void) 1618 { 1619 } 1620 1621 static inline void 1622 ucfg_scan_unregister_pmo_handler(void) 1623 { 1624 } 1625 #endif 1626 1627 QDF_STATUS 1628 ucfg_scan_psoc_open(struct wlan_objmgr_psoc *psoc) 1629 { 1630 struct wlan_scan_obj *scan_obj; 1631 1632 scm_debug("psoc open: 0x%pK", psoc); 1633 if (!psoc) { 1634 scm_err("null psoc"); 1635 return QDF_STATUS_E_FAILURE; 1636 } 1637 scan_obj = wlan_psoc_get_scan_obj(psoc); 1638 if (!scan_obj) { 1639 scm_err("Failed to get scan object"); 1640 return QDF_STATUS_E_FAILURE; 1641 } 1642 /* Initialize the scan Globals */ 1643 wlan_scan_global_init(psoc, scan_obj); 1644 qdf_spinlock_create(&scan_obj->lock); 1645 ucfg_scan_register_pmo_handler(); 1646 scm_db_init(psoc); 1647 1648 return QDF_STATUS_SUCCESS; 1649 } 1650 1651 QDF_STATUS 1652 ucfg_scan_psoc_close(struct wlan_objmgr_psoc *psoc) 1653 { 1654 struct wlan_scan_obj *scan_obj; 1655 1656 scm_debug("psoc close: 0x%pK", psoc); 1657 if (!psoc) { 1658 scm_err("null psoc"); 1659 return QDF_STATUS_E_FAILURE; 1660 } 1661 scm_db_deinit(psoc); 1662 scan_obj = wlan_psoc_get_scan_obj(psoc); 1663 if (!scan_obj) { 1664 scm_err("Failed to get scan object"); 1665 return QDF_STATUS_E_FAILURE; 1666 } 1667 ucfg_scan_unregister_pmo_handler(); 1668 qdf_spinlock_destroy(&scan_obj->lock); 1669 wlan_scan_global_deinit(psoc); 1670 1671 return QDF_STATUS_SUCCESS; 1672 } 1673 1674 static bool scm_serialization_scan_rules_cb( 1675 union wlan_serialization_rules_info *comp_info, 1676 uint8_t comp_id) 1677 { 1678 switch (comp_id) { 1679 case WLAN_UMAC_COMP_TDLS: 1680 if (comp_info->scan_info.is_tdls_in_progress) { 1681 scm_debug("Cancel scan. Tdls in progress"); 1682 return false; 1683 } 1684 break; 1685 case WLAN_UMAC_COMP_DFS: 1686 if (comp_info->scan_info.is_cac_in_progress) { 1687 scm_debug("Cancel scan. CAC in progress"); 1688 return false; 1689 } 1690 break; 1691 case WLAN_UMAC_COMP_MLME: 1692 if (comp_info->scan_info.is_mlme_op_in_progress) { 1693 scm_debug("Cancel scan. MLME operation in progress"); 1694 return false; 1695 } 1696 break; 1697 default: 1698 scm_debug("not handled comp_id %d", comp_id); 1699 break; 1700 } 1701 1702 return true; 1703 } 1704 1705 QDF_STATUS 1706 ucfg_scan_psoc_enable(struct wlan_objmgr_psoc *psoc) 1707 { 1708 QDF_STATUS status; 1709 1710 scm_debug("psoc enable: 0x%pK", psoc); 1711 if (!psoc) { 1712 scm_err("null psoc"); 1713 return QDF_STATUS_E_FAILURE; 1714 } 1715 /* Subscribe for scan events from lmac layesr */ 1716 status = tgt_scan_register_ev_handler(psoc); 1717 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 1718 if (!wlan_reg_is_11d_offloaded(psoc)) 1719 scm_11d_cc_db_init(psoc); 1720 ucfg_scan_register_unregister_bcn_cb(psoc, true); 1721 status = wlan_serialization_register_apply_rules_cb(psoc, 1722 WLAN_SER_CMD_SCAN, 1723 scm_serialization_scan_rules_cb); 1724 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 1725 return status; 1726 } 1727 1728 QDF_STATUS 1729 ucfg_scan_psoc_disable(struct wlan_objmgr_psoc *psoc) 1730 { 1731 QDF_STATUS status; 1732 1733 scm_debug("psoc disable: 0x%pK", psoc); 1734 if (!psoc) { 1735 scm_err("null psoc"); 1736 return QDF_STATUS_E_FAILURE; 1737 } 1738 /* Unsubscribe for scan events from lmac layesr */ 1739 status = tgt_scan_unregister_ev_handler(psoc); 1740 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 1741 ucfg_scan_register_unregister_bcn_cb(psoc, false); 1742 if (!wlan_reg_is_11d_offloaded(psoc)) 1743 scm_11d_cc_db_deinit(psoc); 1744 1745 return status; 1746 } 1747 1748 uint32_t 1749 ucfg_scan_get_max_active_scans(struct wlan_objmgr_psoc *psoc) 1750 { 1751 struct scan_default_params *scan_params = NULL; 1752 1753 if (!psoc) { 1754 scm_err("null psoc"); 1755 return 0; 1756 } 1757 scan_params = wlan_scan_psoc_get_def_params(psoc); 1758 if (!scan_params) { 1759 scm_err("Failed to get scan object"); 1760 return 0; 1761 } 1762 1763 return scan_params->max_active_scans_allowed; 1764 } 1765 1766 bool ucfg_copy_ie_whitelist_attrs(struct wlan_objmgr_psoc *psoc, 1767 struct probe_req_whitelist_attr *ie_whitelist) 1768 { 1769 struct wlan_scan_obj *scan_obj = NULL; 1770 1771 scan_obj = wlan_psoc_get_scan_obj(psoc); 1772 if (!scan_obj) 1773 return false; 1774 1775 qdf_mem_copy(ie_whitelist, &scan_obj->ie_whitelist, 1776 sizeof(*ie_whitelist)); 1777 1778 return true; 1779 } 1780 1781 bool ucfg_ie_whitelist_enabled(struct wlan_objmgr_psoc *psoc, 1782 struct wlan_objmgr_vdev *vdev) 1783 { 1784 struct wlan_scan_obj *scan_obj = NULL; 1785 1786 scan_obj = wlan_psoc_get_scan_obj(psoc); 1787 if (!scan_obj) 1788 return false; 1789 1790 if ((wlan_vdev_mlme_get_opmode(vdev) != QDF_STA_MODE) || 1791 wlan_vdev_is_up(vdev) == QDF_STATUS_SUCCESS) 1792 return false; 1793 1794 if (!scan_obj->ie_whitelist.white_list) 1795 return false; 1796 1797 return true; 1798 } 1799 1800 void ucfg_scan_set_bt_activity(struct wlan_objmgr_psoc *psoc, 1801 bool bt_a2dp_active) 1802 { 1803 struct wlan_scan_obj *scan_obj; 1804 1805 scan_obj = wlan_psoc_get_scan_obj(psoc); 1806 if (!scan_obj) { 1807 scm_err("Failed to get scan object"); 1808 return; 1809 } 1810 scan_obj->bt_a2dp_enabled = bt_a2dp_active; 1811 } 1812 1813 bool ucfg_scan_get_bt_activity(struct wlan_objmgr_psoc *psoc) 1814 { 1815 struct wlan_scan_obj *scan_obj; 1816 1817 scan_obj = wlan_psoc_get_scan_obj(psoc); 1818 if (!scan_obj) { 1819 scm_err("Failed to get scan object"); 1820 return false; 1821 } 1822 1823 return scan_obj->bt_a2dp_enabled; 1824 } 1825 1826 bool ucfg_scan_wake_lock_in_user_scan(struct wlan_objmgr_psoc *psoc) 1827 { 1828 struct wlan_scan_obj *scan_obj; 1829 1830 scan_obj = wlan_psoc_get_scan_obj(psoc); 1831 if (!scan_obj) 1832 return false; 1833 1834 return scan_obj->scan_def.use_wake_lock_in_user_scan; 1835 } 1836 1837 bool ucfg_scan_is_connected_scan_enabled(struct wlan_objmgr_psoc *psoc) 1838 { 1839 struct wlan_scan_obj *scan_obj; 1840 1841 scan_obj = wlan_psoc_get_scan_obj(psoc); 1842 if (!scan_obj) { 1843 scm_err("Failed to get scan object"); 1844 return cfg_default(CFG_ENABLE_CONNECTED_SCAN); 1845 } 1846 1847 return scan_obj->scan_def.enable_connected_scan; 1848 } 1849 1850 bool ucfg_scan_is_mac_spoofing_enabled(struct wlan_objmgr_psoc *psoc) 1851 { 1852 struct wlan_scan_obj *scan_obj; 1853 1854 scan_obj = wlan_psoc_get_scan_obj(psoc); 1855 if (!scan_obj) { 1856 scm_err("Failed to get scan object"); 1857 return cfg_default(CFG_ENABLE_MAC_ADDR_SPOOFING); 1858 } 1859 1860 return scan_obj->scan_def.enable_mac_spoofing; 1861 } 1862 1863 enum scan_dwelltime_adaptive_mode 1864 ucfg_scan_get_extscan_adaptive_dwell_mode(struct wlan_objmgr_psoc *psoc) 1865 { 1866 struct wlan_scan_obj *scan_obj; 1867 1868 scan_obj = wlan_psoc_get_scan_obj(psoc); 1869 if (!scan_obj) { 1870 scm_err("Failed to get scan object"); 1871 return cfg_default(CFG_ADAPTIVE_EXTSCAN_DWELL_MODE); 1872 } 1873 1874 return scan_obj->scan_def.extscan_adaptive_dwell_mode; 1875 } 1876 1877 QDF_STATUS 1878 ucfg_scan_set_global_config(struct wlan_objmgr_psoc *psoc, 1879 enum scan_config config, uint32_t val) 1880 { 1881 struct wlan_scan_obj *scan_obj; 1882 QDF_STATUS status = QDF_STATUS_SUCCESS; 1883 1884 scan_obj = wlan_psoc_get_scan_obj(psoc); 1885 if (!scan_obj) { 1886 scm_err("Failed to get scan object config:%d, val:%d", 1887 config, val); 1888 return QDF_STATUS_E_INVAL; 1889 } 1890 switch (config) { 1891 case SCAN_CFG_DISABLE_SCAN_COMMAND_TIMEOUT: 1892 scan_obj->disable_timeout = !!val; 1893 break; 1894 case SCAN_CFG_DROP_BCN_ON_CHANNEL_MISMATCH: 1895 scan_obj->drop_bcn_on_chan_mismatch = !!val; 1896 break; 1897 1898 default: 1899 status = QDF_STATUS_E_INVAL; 1900 break; 1901 } 1902 1903 return status; 1904 } 1905 1906 QDF_STATUS ucfg_scan_update_mlme_by_bssinfo(struct wlan_objmgr_pdev *pdev, 1907 struct bss_info *bss_info, struct mlme_info *mlme) 1908 { 1909 QDF_STATUS status; 1910 1911 status = scm_scan_update_mlme_by_bssinfo(pdev, bss_info, mlme); 1912 1913 return status; 1914 } 1915 1916 QDF_STATUS 1917 ucfg_scan_get_global_config(struct wlan_objmgr_psoc *psoc, 1918 enum scan_config config, uint32_t *val) 1919 { 1920 struct wlan_scan_obj *scan_obj; 1921 QDF_STATUS status = QDF_STATUS_SUCCESS; 1922 1923 scan_obj = wlan_psoc_get_scan_obj(psoc); 1924 if (!scan_obj || !val) { 1925 scm_err("scan object:%pK config:%d, val:0x%pK", 1926 scan_obj, config, val); 1927 return QDF_STATUS_E_INVAL; 1928 } 1929 switch (config) { 1930 case SCAN_CFG_DISABLE_SCAN_COMMAND_TIMEOUT: 1931 *val = scan_obj->disable_timeout; 1932 break; 1933 case SCAN_CFG_DROP_BCN_ON_CHANNEL_MISMATCH: 1934 *val = scan_obj->drop_bcn_on_chan_mismatch; 1935 break; 1936 1937 default: 1938 status = QDF_STATUS_E_INVAL; 1939 break; 1940 } 1941 1942 return status; 1943 } 1944 1945 #ifdef FEATURE_WLAN_SCAN_PNO 1946 bool ucfg_scan_is_pno_offload_enabled(struct wlan_objmgr_psoc *psoc) 1947 { 1948 struct wlan_scan_obj *scan_obj; 1949 1950 scan_obj = wlan_psoc_get_scan_obj(psoc); 1951 if (!scan_obj) { 1952 scm_err("NULL scan obj"); 1953 return false; 1954 } 1955 1956 return scan_obj->pno_cfg.pno_offload_enabled; 1957 } 1958 1959 void ucfg_scan_set_pno_offload(struct wlan_objmgr_psoc *psoc, bool value) 1960 { 1961 struct wlan_scan_obj *scan_obj; 1962 1963 scan_obj = wlan_psoc_get_scan_obj(psoc); 1964 if (!scan_obj) { 1965 scm_err("NULL scan obj"); 1966 return; 1967 } 1968 1969 scan_obj->pno_cfg.pno_offload_enabled = value; 1970 } 1971 1972 bool ucfg_scan_get_pno_scan_support(struct wlan_objmgr_psoc *psoc) 1973 { 1974 struct wlan_scan_obj *scan_obj; 1975 1976 scan_obj = wlan_psoc_get_scan_obj(psoc); 1977 if (!scan_obj) { 1978 scm_err("NULL scan obj"); 1979 return cfg_default(CFG_PNO_SCAN_SUPPORT); 1980 } 1981 1982 return scan_obj->pno_cfg.scan_support_enabled; 1983 } 1984 1985 uint8_t ucfg_get_scan_backoff_multiplier(struct wlan_objmgr_psoc *psoc) 1986 { 1987 struct wlan_scan_obj *scan_obj; 1988 1989 scan_obj = wlan_psoc_get_scan_obj(psoc); 1990 if (!scan_obj) { 1991 scm_err("NULL scan obj"); 1992 return cfg_default(CFG_SCAN_BACKOFF_MULTIPLIER); 1993 } 1994 return scan_obj->pno_cfg.scan_backoff_multiplier; 1995 } 1996 1997 bool ucfg_scan_is_dfs_chnl_scan_enabled(struct wlan_objmgr_psoc *psoc) 1998 { 1999 struct wlan_scan_obj *scan_obj; 2000 2001 scan_obj = wlan_psoc_get_scan_obj(psoc); 2002 if (!scan_obj) { 2003 scm_err("NULL scan obj"); 2004 return cfg_default(CFG_ENABLE_DFS_PNO_CHNL_SCAN); 2005 } 2006 return scan_obj->pno_cfg.dfs_chnl_scan_enabled; 2007 } 2008 2009 uint32_t ucfg_scan_get_scan_timer_repeat_value(struct wlan_objmgr_psoc *psoc) 2010 { 2011 struct wlan_scan_obj *scan_obj; 2012 2013 scan_obj = wlan_psoc_get_scan_obj(psoc); 2014 if (!scan_obj) { 2015 scm_err("NULL scan obj"); 2016 return cfg_default(CFG_PNO_SCAN_TIMER_REPEAT_VALUE); 2017 } 2018 return scan_obj->pno_cfg.scan_timer_repeat_value; 2019 } 2020 2021 uint32_t ucfg_scan_get_slow_scan_multiplier(struct wlan_objmgr_psoc *psoc) 2022 { 2023 struct wlan_scan_obj *scan_obj; 2024 2025 scan_obj = wlan_psoc_get_scan_obj(psoc); 2026 if (!scan_obj) { 2027 scm_err("NULL scan obj"); 2028 return cfg_default(CFG_PNO_SLOW_SCAN_MULTIPLIER); 2029 } 2030 return scan_obj->pno_cfg.slow_scan_multiplier; 2031 } 2032 2033 uint32_t 2034 ucfg_scan_get_max_sched_scan_plan_interval(struct wlan_objmgr_psoc *psoc) 2035 { 2036 struct wlan_scan_obj *scan_obj; 2037 2038 scan_obj = wlan_psoc_get_scan_obj(psoc); 2039 if (!scan_obj) { 2040 scm_err("Failed to get scan object"); 2041 return cfg_default(CFG_MAX_SCHED_SCAN_PLAN_INTERVAL); 2042 } 2043 2044 return scan_obj->pno_cfg.max_sched_scan_plan_interval; 2045 } 2046 2047 uint32_t 2048 ucfg_scan_get_max_sched_scan_plan_iterations(struct wlan_objmgr_psoc *psoc) 2049 { 2050 struct wlan_scan_obj *scan_obj; 2051 2052 scan_obj = wlan_psoc_get_scan_obj(psoc); 2053 if (!scan_obj) { 2054 scm_err("Failed to get scan object"); 2055 return cfg_default(CFG_MAX_SCHED_SCAN_PLAN_ITERATIONS); 2056 } 2057 2058 return scan_obj->pno_cfg.max_sched_scan_plan_iterations; 2059 } 2060 2061 #endif 2062