1 /* 2 * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 /* 20 * DOC: contains scan north bound interface definitions 21 */ 22 23 #include <scheduler_api.h> 24 #include <wlan_scan_ucfg_api.h> 25 #include <wlan_objmgr_global_obj.h> 26 #include <wlan_objmgr_cmn.h> 27 #include <wlan_serialization_api.h> 28 #include <wlan_scan_tgt_api.h> 29 #include <wlan_scan_utils_api.h> 30 #include <wlan_reg_ucfg_api.h> 31 #include <wlan_reg_services_api.h> 32 #include <wlan_utility.h> 33 #include "../../core/src/wlan_scan_main.h" 34 #include "../../core/src/wlan_scan_manager.h" 35 #include "../../core/src/wlan_scan_cache_db.h" 36 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 37 #include <wlan_pmo_obj_mgmt_api.h> 38 #endif 39 #ifdef WLAN_POLICY_MGR_ENABLE 40 #include <wlan_dfs_utils_api.h> 41 #include <wlan_policy_mgr_api.h> 42 #endif 43 #include "cfg_ucfg_api.h" 44 #include "wlan_extscan_api.h" 45 46 QDF_STATUS ucfg_scan_register_bcn_cb(struct wlan_objmgr_psoc *psoc, 47 update_beacon_cb cb, enum scan_cb_type type) 48 { 49 return scm_scan_register_bcn_cb(psoc, cb, type); 50 } 51 52 qdf_list_t *ucfg_scan_get_result(struct wlan_objmgr_pdev *pdev, 53 struct scan_filter *filter) 54 { 55 return scm_get_scan_result(pdev, filter); 56 } 57 58 QDF_STATUS ucfg_scan_db_iterate(struct wlan_objmgr_pdev *pdev, 59 scan_iterator_func func, void *arg) 60 { 61 return scm_iterate_scan_db(pdev, func, arg); 62 } 63 64 QDF_STATUS ucfg_scan_purge_results(qdf_list_t *scan_list) 65 { 66 return scm_purge_scan_results(scan_list); 67 } 68 69 QDF_STATUS ucfg_scan_flush_results(struct wlan_objmgr_pdev *pdev, 70 struct scan_filter *filter) 71 { 72 return scm_flush_results(pdev, filter); 73 } 74 75 void ucfg_scan_filter_valid_channel(struct wlan_objmgr_pdev *pdev, 76 uint8_t *chan_list, uint32_t num_chan) 77 { 78 scm_filter_valid_channel(pdev, chan_list, num_chan); 79 } 80 81 QDF_STATUS ucfg_scan_init(void) 82 { 83 QDF_STATUS status; 84 85 status = wlan_objmgr_register_psoc_create_handler(WLAN_UMAC_COMP_SCAN, 86 wlan_scan_psoc_created_notification, NULL); 87 if (QDF_IS_STATUS_ERROR(status)) { 88 scm_err("Failed to register psoc create handler"); 89 goto fail_create_psoc; 90 } 91 92 status = wlan_objmgr_register_psoc_destroy_handler(WLAN_UMAC_COMP_SCAN, 93 wlan_scan_psoc_destroyed_notification, NULL); 94 if (QDF_IS_STATUS_ERROR(status)) { 95 scm_err("Failed to create psoc delete handler"); 96 goto fail_psoc_destroy; 97 } 98 scm_debug("scan psoc create and delete handler registered with objmgr"); 99 100 status = wlan_objmgr_register_vdev_create_handler(WLAN_UMAC_COMP_SCAN, 101 wlan_scan_vdev_created_notification, NULL); 102 if (QDF_IS_STATUS_ERROR(status)) { 103 scm_err("Failed to register vdev create handler"); 104 goto fail_pdev_create; 105 } 106 107 status = wlan_objmgr_register_vdev_destroy_handler(WLAN_UMAC_COMP_SCAN, 108 wlan_scan_vdev_destroyed_notification, NULL); 109 if (QDF_IS_STATUS_SUCCESS(status)) { 110 scm_debug("scan vdev create and delete handler registered with objmgr"); 111 return QDF_STATUS_SUCCESS; 112 } 113 114 scm_err("Failed to destroy vdev delete handler"); 115 wlan_objmgr_unregister_vdev_create_handler(WLAN_UMAC_COMP_SCAN, 116 wlan_scan_vdev_created_notification, NULL); 117 fail_pdev_create: 118 wlan_objmgr_unregister_psoc_destroy_handler(WLAN_UMAC_COMP_SCAN, 119 wlan_scan_psoc_destroyed_notification, NULL); 120 fail_psoc_destroy: 121 wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_SCAN, 122 wlan_scan_psoc_created_notification, NULL); 123 fail_create_psoc: 124 return status; 125 } 126 127 QDF_STATUS ucfg_scan_deinit(void) 128 { 129 QDF_STATUS status; 130 131 status = wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_SCAN, 132 wlan_scan_psoc_created_notification, NULL); 133 if (status != QDF_STATUS_SUCCESS) 134 scm_err("Failed to unregister psoc create handler"); 135 136 status = wlan_objmgr_unregister_psoc_destroy_handler( 137 WLAN_UMAC_COMP_SCAN, 138 wlan_scan_psoc_destroyed_notification, NULL); 139 if (status != QDF_STATUS_SUCCESS) 140 scm_err("Failed to unregister psoc delete handler"); 141 142 status = wlan_objmgr_unregister_vdev_create_handler(WLAN_UMAC_COMP_SCAN, 143 wlan_scan_vdev_created_notification, NULL); 144 if (status != QDF_STATUS_SUCCESS) 145 scm_err("Failed to unregister vdev create handler"); 146 147 status = wlan_objmgr_unregister_vdev_destroy_handler( 148 WLAN_UMAC_COMP_SCAN, 149 wlan_scan_vdev_destroyed_notification, NULL); 150 if (status != QDF_STATUS_SUCCESS) 151 scm_err("Failed to unregister vdev delete handler"); 152 153 return status; 154 } 155 156 #ifdef FEATURE_WLAN_SCAN_PNO 157 158 QDF_STATUS ucfg_scan_pno_start(struct wlan_objmgr_vdev *vdev, 159 struct pno_scan_req_params *req) 160 { 161 struct scan_vdev_obj *scan_vdev_obj; 162 QDF_STATUS status; 163 164 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 165 if (!scan_vdev_obj) { 166 scm_err("null scan_vdev_obj"); 167 return QDF_STATUS_E_INVAL; 168 } 169 if (scan_vdev_obj->pno_in_progress) { 170 scm_err("pno already in progress"); 171 return QDF_STATUS_E_ALREADY; 172 } 173 174 status = tgt_scan_pno_start(vdev, req); 175 if (QDF_IS_STATUS_ERROR(status)) 176 scm_err("pno start failed"); 177 else 178 scan_vdev_obj->pno_in_progress = true; 179 180 return status; 181 } 182 183 QDF_STATUS ucfg_scan_pno_stop(struct wlan_objmgr_vdev *vdev) 184 { 185 struct scan_vdev_obj *scan_vdev_obj; 186 QDF_STATUS status; 187 188 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 189 if (!scan_vdev_obj) { 190 scm_err("null scan_vdev_obj"); 191 return QDF_STATUS_E_INVAL; 192 } 193 if (!scan_vdev_obj->pno_in_progress) { 194 scm_debug("pno already stopped"); 195 return QDF_STATUS_E_ALREADY; 196 } 197 198 status = tgt_scan_pno_stop(vdev, wlan_vdev_get_id(vdev)); 199 if (QDF_IS_STATUS_ERROR(status)) 200 scm_err("pno start failed"); 201 else 202 scan_vdev_obj->pno_in_progress = false; 203 204 return status; 205 } 206 207 bool ucfg_scan_get_pno_in_progress(struct wlan_objmgr_vdev *vdev) 208 { 209 struct scan_vdev_obj *scan_vdev_obj; 210 211 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 212 if (!scan_vdev_obj) { 213 scm_err("null scan_vdev_obj"); 214 return false; 215 } 216 217 return scan_vdev_obj->pno_in_progress; 218 } 219 220 bool ucfg_scan_get_pno_match(struct wlan_objmgr_vdev *vdev) 221 { 222 struct scan_vdev_obj *scan_vdev_obj; 223 224 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 225 if (!scan_vdev_obj) { 226 scm_err("null scan_vdev_obj"); 227 return false; 228 } 229 230 return scan_vdev_obj->pno_match_evt_received; 231 } 232 233 static QDF_STATUS 234 wlan_pno_global_init(struct pno_def_config *pno_def) 235 { 236 struct nlo_mawc_params *mawc_cfg; 237 238 qdf_wake_lock_create(&pno_def->pno_wake_lock, "wlan_pno_wl"); 239 mawc_cfg = &pno_def->mawc_params; 240 pno_def->channel_prediction = SCAN_PNO_CHANNEL_PREDICTION; 241 pno_def->top_k_num_of_channels = SCAN_TOP_K_NUM_OF_CHANNELS; 242 pno_def->stationary_thresh = SCAN_STATIONARY_THRESHOLD; 243 pno_def->channel_prediction_full_scan = 244 SCAN_CHANNEL_PREDICTION_FULL_SCAN_MS; 245 pno_def->adaptive_dwell_mode = SCAN_ADAPTIVE_PNOSCAN_DWELL_MODE; 246 mawc_cfg->enable = SCAN_MAWC_NLO_ENABLED; 247 mawc_cfg->exp_backoff_ratio = SCAN_MAWC_NLO_EXP_BACKOFF_RATIO; 248 mawc_cfg->init_scan_interval = SCAN_MAWC_NLO_INIT_SCAN_INTERVAL; 249 mawc_cfg->max_scan_interval = SCAN_MAWC_NLO_MAX_SCAN_INTERVAL; 250 251 return QDF_STATUS_SUCCESS; 252 } 253 254 static QDF_STATUS 255 wlan_pno_global_deinit(struct pno_def_config *pno_def) 256 { 257 qdf_wake_lock_destroy(&pno_def->pno_wake_lock); 258 259 return QDF_STATUS_SUCCESS; 260 } 261 262 #ifdef WLAN_POLICY_MGR_ENABLE 263 /* 264 * ucfg_scan_update_pno_dwell_time() - update active and passive dwell time 265 * depending on active concurrency modes 266 * @vdev: vdev object pointer 267 * @req: scan request 268 * 269 * Return: void 270 */ 271 static void ucfg_scan_update_pno_dwell_time(struct wlan_objmgr_vdev *vdev, 272 struct pno_scan_req_params *req, struct scan_default_params *scan_def) 273 { 274 bool sap_or_p2p_present; 275 struct wlan_objmgr_psoc *psoc; 276 277 psoc = wlan_vdev_get_psoc(vdev); 278 279 if (!psoc) 280 return; 281 282 sap_or_p2p_present = policy_mgr_mode_specific_connection_count( 283 psoc, PM_SAP_MODE, NULL) || 284 policy_mgr_mode_specific_connection_count( 285 psoc, PM_P2P_GO_MODE, NULL) || 286 policy_mgr_mode_specific_connection_count( 287 psoc, PM_P2P_CLIENT_MODE, NULL); 288 289 if (sap_or_p2p_present) { 290 req->active_dwell_time = scan_def->conc_active_dwell; 291 req->passive_dwell_time = scan_def->conc_passive_dwell; 292 } 293 294 } 295 #else 296 static inline void ucfg_scan_update_pno_dwell_time(struct wlan_objmgr_vdev *vdev, 297 struct pno_scan_req_params *req, struct scan_default_params *scan_def){} 298 #endif 299 300 QDF_STATUS 301 ucfg_scan_get_pno_def_params(struct wlan_objmgr_vdev *vdev, 302 struct pno_scan_req_params *req) 303 { 304 struct scan_default_params *scan_def; 305 struct wlan_scan_obj *scan; 306 struct pno_def_config *pno_def; 307 308 if (!vdev || !req) { 309 scm_err("vdev: 0x%pK, req: 0x%pK", 310 vdev, req); 311 return QDF_STATUS_E_INVAL; 312 } 313 314 scan = wlan_vdev_get_scan_obj(vdev); 315 if (!scan) { 316 scm_err("scan is NULL"); 317 return QDF_STATUS_E_INVAL; 318 } 319 scan_def = wlan_vdev_get_def_scan_params(vdev); 320 if (!scan_def) { 321 scm_err("wlan_vdev_get_def_scan_params returned NULL"); 322 return QDF_STATUS_E_NULL_VALUE; 323 } 324 325 pno_def = &scan->pno_cfg; 326 req->active_dwell_time = scan_def->active_dwell; 327 req->passive_dwell_time = scan_def->passive_dwell; 328 req->scan_random.randomize = scan_def->enable_mac_spoofing; 329 330 /* 331 * Update active and passive dwell time depending 332 * upon the present active concurrency mode 333 */ 334 ucfg_scan_update_pno_dwell_time(vdev, req, scan_def); 335 req->adaptive_dwell_mode = pno_def->adaptive_dwell_mode; 336 req->pno_channel_prediction = pno_def->channel_prediction; 337 req->top_k_num_of_channels = pno_def->top_k_num_of_channels; 338 req->stationary_thresh = pno_def->stationary_thresh; 339 req->channel_prediction_full_scan = 340 pno_def->channel_prediction_full_scan; 341 req->mawc_params.vdev_id = wlan_vdev_get_id(vdev); 342 qdf_mem_copy(&req->mawc_params, &pno_def->mawc_params, 343 sizeof(req->mawc_params)); 344 345 return QDF_STATUS_SUCCESS; 346 } 347 348 static QDF_STATUS ucfg_scan_update_pno_config(struct pno_def_config *pno, 349 struct pno_user_cfg *pno_cfg) 350 { 351 pno->channel_prediction = pno_cfg->channel_prediction; 352 pno->top_k_num_of_channels = pno_cfg->top_k_num_of_channels; 353 pno->stationary_thresh = pno_cfg->stationary_thresh; 354 pno->adaptive_dwell_mode = pno_cfg->adaptive_dwell_mode; 355 pno->channel_prediction_full_scan = 356 pno_cfg->channel_prediction_full_scan; 357 qdf_mem_copy(&pno->mawc_params, &pno_cfg->mawc_params, 358 sizeof(pno->mawc_params)); 359 360 return QDF_STATUS_SUCCESS; 361 } 362 363 QDF_STATUS 364 ucfg_scan_register_pno_cb(struct wlan_objmgr_psoc *psoc, 365 scan_event_handler event_cb, void *arg) 366 { 367 struct wlan_scan_obj *scan; 368 369 if (!psoc) { 370 scm_err("null psoc"); 371 return QDF_STATUS_E_INVAL; 372 } 373 scan = wlan_psoc_get_scan_obj(psoc); 374 qdf_spin_lock_bh(&scan->lock); 375 scan->pno_cfg.pno_cb.func = event_cb; 376 scan->pno_cfg.pno_cb.arg = arg; 377 qdf_spin_unlock_bh(&scan->lock); 378 scm_debug("event_cb: 0x%pK, arg: 0x%pK", event_cb, arg); 379 380 return QDF_STATUS_SUCCESS; 381 } 382 383 #else 384 385 static inline QDF_STATUS 386 wlan_pno_global_init(struct pno_def_config *pno_def) 387 { 388 return QDF_STATUS_SUCCESS; 389 } 390 static inline QDF_STATUS 391 wlan_pno_global_deinit(struct pno_def_config *pno_def) 392 { 393 return QDF_STATUS_SUCCESS; 394 } 395 396 static inline QDF_STATUS 397 ucfg_scan_update_pno_config(struct pno_def_config *pno, 398 struct pno_user_cfg *pno_cfg) 399 { 400 return QDF_STATUS_SUCCESS; 401 } 402 403 #endif 404 405 #ifdef WLAN_POLICY_MGR_ENABLE 406 /** 407 * ucfg_scan_update_dbs_scan_ctrl_ext_flag() - update dbs scan ctrl flags 408 * @req: pointer to scan request 409 * 410 * This function sets scan_ctrl_flags_ext value depending on the type of 411 * scan and the channel lists. 412 * 413 * Non-DBS scan is requested if any of the below case is met: 414 * 1. HW is DBS incapable 415 * 2. Directed scan 416 * 3. Channel list has only few channels 417 * 4. Channel list has single band channels 418 * 5. A high accuracy scan request is sent by kernel. 419 * 420 * DBS scan is enabled for these conditions: 421 * 1. A low power or low span scan request is sent by kernel. 422 * For remaining cases DBS is enabled by default. 423 * Return: void 424 */ 425 static void 426 ucfg_scan_update_dbs_scan_ctrl_ext_flag(struct scan_start_request *req) 427 { 428 uint32_t num_chan; 429 struct wlan_objmgr_psoc *psoc; 430 uint32_t scan_dbs_policy = SCAN_DBS_POLICY_DEFAULT; 431 uint32_t conn_cnt; 432 433 psoc = wlan_vdev_get_psoc(req->vdev); 434 435 if ((DISABLE_DBS_CXN_AND_SCAN == 436 wlan_objmgr_psoc_get_dual_mac_disable(psoc)) || 437 (ENABLE_DBS_CXN_AND_DISABLE_DBS_SCAN == 438 wlan_objmgr_psoc_get_dual_mac_disable(psoc))) 439 goto end; 440 441 if (req->scan_req.scan_policy_high_accuracy) 442 goto end; 443 444 if ((req->scan_req.scan_policy_low_power) || 445 (req->scan_req.scan_policy_low_span)) { 446 scan_dbs_policy = SCAN_DBS_POLICY_IGNORE_DUTY; 447 goto end; 448 } 449 450 conn_cnt = policy_mgr_get_connection_count(psoc); 451 if (conn_cnt > 0) { 452 scm_debug("%d active connections, go for DBS scan", 453 conn_cnt); 454 scan_dbs_policy = SCAN_DBS_POLICY_DEFAULT; 455 goto end; 456 } 457 458 if (req->scan_req.num_ssids) { 459 scm_debug("directed SSID"); 460 goto end; 461 } 462 463 if (req->scan_req.num_bssid) { 464 scm_debug("directed BSSID"); 465 goto end; 466 } 467 468 num_chan = req->scan_req.chan_list.num_chan; 469 470 /* num_chan=0 means all channels */ 471 if (!num_chan) 472 scan_dbs_policy = SCAN_DBS_POLICY_DEFAULT; 473 474 if (num_chan < SCAN_MIN_CHAN_DBS_SCAN_THRESHOLD) 475 goto end; 476 477 while (num_chan > 1) { 478 if (!WLAN_REG_IS_SAME_BAND_CHANNELS( 479 req->scan_req.chan_list.chan[0].freq, 480 req->scan_req.chan_list.chan[num_chan-1].freq)) { 481 scan_dbs_policy = SCAN_DBS_POLICY_DEFAULT; 482 break; 483 } 484 num_chan--; 485 } 486 487 end: 488 req->scan_req.scan_ctrl_flags_ext |= 489 ((scan_dbs_policy << SCAN_FLAG_EXT_DBS_SCAN_POLICY_BIT) 490 & SCAN_FLAG_EXT_DBS_SCAN_POLICY_MASK); 491 scm_debug("scan_ctrl_flags_ext: 0x%x", 492 req->scan_req.scan_ctrl_flags_ext); 493 } 494 495 /** 496 * ucfg_update_passive_dwell_time() - update dwell passive time 497 * @vdev: vdev object 498 * @req: scan request 499 * 500 * Return: None 501 */ 502 static void 503 ucfg_update_passive_dwell_time(struct wlan_objmgr_vdev *vdev, 504 struct scan_start_request *req) 505 { 506 struct wlan_objmgr_psoc *psoc; 507 508 psoc = wlan_vdev_get_psoc(vdev); 509 if (!psoc) 510 return; 511 512 if (policy_mgr_is_sta_connected_2g(psoc) && 513 !policy_mgr_is_hw_dbs_capable(psoc) && 514 ucfg_scan_get_bt_activity(psoc)) 515 req->scan_req.dwell_time_passive = 516 PASSIVE_DWELL_TIME_BT_A2DP_ENABLED; 517 } 518 519 static const struct probe_time_dwell_time 520 scan_probe_time_dwell_time_map[SCAN_DWELL_TIME_PROBE_TIME_MAP_SIZE] = { 521 {28, 11}, /* 0 SSID */ 522 {28, 20}, /* 1 SSID */ 523 {28, 20}, /* 2 SSID */ 524 {28, 20}, /* 3 SSID */ 525 {28, 20}, /* 4 SSID */ 526 {28, 20}, /* 5 SSID */ 527 {28, 20}, /* 6 SSID */ 528 {28, 11}, /* 7 SSID */ 529 {28, 11}, /* 8 SSID */ 530 {28, 11}, /* 9 SSID */ 531 {28, 8} /* 10 SSID */ 532 }; 533 534 /** 535 * ucfg_scan_get_burst_duration() - get burst duration depending on max chan 536 * and miracast. 537 * @max_ch_time: max channel time 538 * @miracast_enabled: if miracast is enabled 539 * 540 * Return: burst_duration 541 */ 542 static inline 543 int ucfg_scan_get_burst_duration(int max_ch_time, 544 bool miracast_enabled) 545 { 546 int burst_duration = 0; 547 548 if (miracast_enabled) { 549 /* 550 * When miracast is running, burst 551 * duration needs to be minimum to avoid 552 * any stutter or glitch in miracast 553 * during station scan 554 */ 555 if (max_ch_time <= SCAN_GO_MIN_ACTIVE_SCAN_BURST_DURATION) 556 burst_duration = max_ch_time; 557 else 558 burst_duration = SCAN_GO_MIN_ACTIVE_SCAN_BURST_DURATION; 559 } else { 560 /* 561 * If miracast is not running, accommodate max 562 * stations to make the scans faster 563 */ 564 burst_duration = SCAN_BURST_SCAN_MAX_NUM_OFFCHANNELS * 565 max_ch_time; 566 if (burst_duration > SCAN_GO_MAX_ACTIVE_SCAN_BURST_DURATION) { 567 uint8_t channels = SCAN_P2P_SCAN_MAX_BURST_DURATION / 568 max_ch_time; 569 570 if (channels) 571 burst_duration = channels * max_ch_time; 572 else 573 burst_duration = 574 SCAN_GO_MAX_ACTIVE_SCAN_BURST_DURATION; 575 } 576 } 577 return burst_duration; 578 } 579 580 /** 581 * ucfg_scan_req_update_params() - update scan req params depending on 582 * concurrent mode present. 583 * @vdev: vdev object pointer 584 * @req: scan request 585 * @scan_obj: scan object 586 * 587 * Return: void 588 */ 589 static void ucfg_scan_req_update_concurrency_params( 590 struct wlan_objmgr_vdev *vdev, struct scan_start_request *req, 591 struct wlan_scan_obj *scan_obj) 592 { 593 bool ap_present, go_present, sta_active, p2p_cli_present, ndi_present; 594 struct wlan_objmgr_psoc *psoc; 595 596 psoc = wlan_vdev_get_psoc(vdev); 597 598 if (!psoc) 599 return; 600 601 ap_present = policy_mgr_mode_specific_connection_count( 602 psoc, PM_SAP_MODE, NULL); 603 go_present = policy_mgr_mode_specific_connection_count( 604 psoc, PM_P2P_GO_MODE, NULL); 605 p2p_cli_present = policy_mgr_mode_specific_connection_count( 606 psoc, PM_P2P_CLIENT_MODE, NULL); 607 sta_active = policy_mgr_mode_specific_connection_count( 608 psoc, PM_STA_MODE, NULL); 609 ndi_present = policy_mgr_mode_specific_connection_count( 610 psoc, PM_NDI_MODE, NULL); 611 612 if (policy_mgr_get_connection_count(psoc)) { 613 if (req->scan_req.scan_f_passive) 614 req->scan_req.dwell_time_passive = 615 scan_obj->scan_def.conc_passive_dwell; 616 else 617 req->scan_req.dwell_time_active = 618 scan_obj->scan_def.conc_active_dwell; 619 req->scan_req.max_rest_time = 620 scan_obj->scan_def.conc_max_rest_time; 621 req->scan_req.min_rest_time = 622 scan_obj->scan_def.conc_min_rest_time; 623 req->scan_req.idle_time = scan_obj->scan_def.conc_idle_time; 624 } 625 626 /* 627 * If AP is active set min rest time same as max rest time, so that 628 * firmware spends more time on home channel which will increase the 629 * probability of sending beacon at TBTT 630 */ 631 if (ap_present || go_present) 632 req->scan_req.min_rest_time = req->scan_req.max_rest_time; 633 634 if (req->scan_req.p2p_scan_type == SCAN_NON_P2P_DEFAULT) { 635 /* 636 * Decide burst_duration and dwell_time_active based on 637 * what type of devices are active. 638 */ 639 do { 640 if (ap_present && go_present && sta_active) { 641 if (req->scan_req.dwell_time_active <= 642 SCAN_3PORT_CONC_SCAN_MAX_BURST_DURATION) 643 req->scan_req.burst_duration = 644 req->scan_req.dwell_time_active; 645 else 646 req->scan_req.burst_duration = 647 SCAN_3PORT_CONC_SCAN_MAX_BURST_DURATION; 648 649 break; 650 } 651 652 if (scan_obj->miracast_enabled && 653 policy_mgr_is_mcc_in_24G(psoc)) 654 req->scan_req.max_rest_time = 655 scan_obj->scan_def.sta_miracast_mcc_rest_time; 656 657 if (go_present) { 658 /* 659 * Background scan while GO is sending beacons. 660 * Every off-channel transition has overhead of 661 * 2 beacon intervals for NOA. Maximize number 662 * of channels in every transition by using 663 * burst scan. 664 */ 665 req->scan_req.burst_duration = 666 ucfg_scan_get_burst_duration( 667 req->scan_req.dwell_time_active, 668 scan_obj->miracast_enabled); 669 break; 670 } 671 if ((sta_active || p2p_cli_present) && 672 !req->scan_req.burst_duration) { 673 /* Typical background scan. 674 * Disable burst scan for now. 675 */ 676 req->scan_req.burst_duration = 0; 677 break; 678 } 679 680 if (ndi_present) { 681 req->scan_req.burst_duration = 682 ucfg_scan_get_burst_duration( 683 req->scan_req.dwell_time_active, 684 scan_obj->miracast_enabled); 685 break; 686 } 687 } while (0); 688 689 if (ap_present) { 690 uint8_t ssid_num; 691 ssid_num = req->scan_req.num_ssids * 692 req->scan_req.num_bssid; 693 req->scan_req.repeat_probe_time = 694 scan_probe_time_dwell_time_map[ 695 QDF_MIN(ssid_num, 696 SCAN_DWELL_TIME_PROBE_TIME_MAP_SIZE 697 - 1)].probe_time; 698 req->scan_req.n_probes = 699 (req->scan_req.repeat_probe_time > 0) ? 700 req->scan_req.dwell_time_active / 701 req->scan_req.repeat_probe_time : 0; 702 } 703 } 704 705 if (ap_present) { 706 uint8_t ap_chan; 707 struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); 708 709 ap_chan = policy_mgr_get_channel(psoc, PM_SAP_MODE, NULL); 710 /* 711 * P2P/STA scan while SoftAP is sending beacons. 712 * Max duration of CTS2self is 32 ms, which limits the 713 * dwell time. If DBS is supported and if SAP is on 2G channel 714 * then keep passive dwell time default. 715 */ 716 req->scan_req.dwell_time_active = 717 QDF_MIN(req->scan_req.dwell_time_active, 718 (SCAN_CTS_DURATION_MS_MAX - 719 SCAN_ROAM_SCAN_CHANNEL_SWITCH_TIME)); 720 if (!policy_mgr_is_hw_dbs_capable(psoc) || 721 (policy_mgr_is_hw_dbs_capable(psoc) && 722 WLAN_CHAN_IS_5GHZ(ap_chan))) { 723 req->scan_req.dwell_time_passive = 724 req->scan_req.dwell_time_active; 725 } 726 req->scan_req.burst_duration = 0; 727 if (utils_is_dfs_ch(pdev, ap_chan)) 728 req->scan_req.burst_duration = 729 SCAN_BURST_SCAN_MAX_NUM_OFFCHANNELS * 730 req->scan_req.dwell_time_active; 731 } 732 } 733 734 #else 735 static inline void ucfg_scan_req_update_concurrency_params( 736 struct wlan_objmgr_vdev *vdev, struct scan_start_request *req, 737 struct wlan_scan_obj *scan_obj) 738 { 739 } 740 static inline void 741 ucfg_update_passive_dwell_time(struct wlan_objmgr_vdev *vdev, 742 struct scan_start_request *req) {} 743 static inline void 744 ucfg_scan_update_dbs_scan_ctrl_ext_flag( 745 struct scan_start_request *req) {} 746 #endif 747 748 QDF_STATUS 749 ucfg_scan_set_custom_scan_chan_list(struct wlan_objmgr_pdev *pdev, 750 struct chan_list *chan_list) 751 { 752 uint8_t pdev_id; 753 struct wlan_scan_obj *scan_obj; 754 755 if (!pdev || !chan_list) { 756 scm_warn("pdev: 0x%pK, chan_list: 0x%pK", pdev, chan_list); 757 return QDF_STATUS_E_NULL_VALUE; 758 } 759 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 760 scan_obj = wlan_pdev_get_scan_obj(pdev); 761 762 qdf_mem_copy(&scan_obj->pdev_info[pdev_id].custom_chan_list, 763 chan_list, sizeof(*chan_list)); 764 765 return QDF_STATUS_SUCCESS; 766 } 767 768 /** 769 * ucfg_scan_req_update_params() - update scan req params depending on modes 770 * and scan type. 771 * @vdev: vdev object pointer 772 * @req: scan request 773 * @scan_obj: scan object 774 * 775 * Return: void 776 */ 777 static void 778 ucfg_scan_req_update_params(struct wlan_objmgr_vdev *vdev, 779 struct scan_start_request *req, struct wlan_scan_obj *scan_obj) 780 { 781 struct chan_list *custom_chan_list; 782 struct wlan_objmgr_pdev *pdev; 783 uint8_t pdev_id; 784 785 /* Ensure correct number of probes are sent on active channel */ 786 if (!req->scan_req.repeat_probe_time) 787 req->scan_req.repeat_probe_time = 788 req->scan_req.dwell_time_active / SCAN_NPROBES_DEFAULT; 789 790 if (req->scan_req.scan_f_passive) 791 req->scan_req.scan_ctrl_flags_ext |= 792 SCAN_FLAG_EXT_FILTER_PUBLIC_ACTION_FRAME; 793 794 if (!req->scan_req.n_probes) 795 req->scan_req.n_probes = (req->scan_req.repeat_probe_time > 0) ? 796 req->scan_req.dwell_time_active / 797 req->scan_req.repeat_probe_time : 0; 798 799 if (req->scan_req.p2p_scan_type == SCAN_NON_P2P_DEFAULT) { 800 req->scan_req.scan_f_cck_rates = true; 801 if (!req->scan_req.num_ssids) 802 req->scan_req.scan_f_bcast_probe = true; 803 req->scan_req.scan_f_add_ds_ie_in_probe = true; 804 req->scan_req.scan_f_filter_prb_req = true; 805 req->scan_req.scan_f_add_tpc_ie_in_probe = true; 806 } else { 807 req->scan_req.adaptive_dwell_time_mode = SCAN_DWELL_MODE_STATIC; 808 if (req->scan_req.p2p_scan_type == SCAN_P2P_LISTEN) { 809 req->scan_req.repeat_probe_time = 0; 810 } else { 811 req->scan_req.scan_f_filter_prb_req = true; 812 if (!req->scan_req.num_ssids) 813 req->scan_req.scan_f_bcast_probe = true; 814 815 req->scan_req.dwell_time_active += 816 P2P_SEARCH_DWELL_TIME_INC; 817 /* 818 * 3 channels with default max dwell time 40 ms. 819 * Cap limit will be set by 820 * P2P_SCAN_MAX_BURST_DURATION. Burst duration 821 * should be such that no channel is scanned less 822 * than the dwell time in normal scenarios. 823 */ 824 if (req->scan_req.chan_list.num_chan == 825 WLAN_P2P_SOCIAL_CHANNELS && 826 !scan_obj->miracast_enabled) 827 req->scan_req.repeat_probe_time = 828 req->scan_req.dwell_time_active / 5; 829 else 830 req->scan_req.repeat_probe_time = 831 req->scan_req.dwell_time_active / 3; 832 833 req->scan_req.burst_duration = 834 BURST_SCAN_MAX_NUM_OFFCHANNELS * 835 req->scan_req.dwell_time_active; 836 if (req->scan_req.burst_duration > 837 P2P_SCAN_MAX_BURST_DURATION) { 838 uint8_t channels = 839 P2P_SCAN_MAX_BURST_DURATION / 840 req->scan_req.dwell_time_active; 841 if (channels) 842 req->scan_req.burst_duration = 843 channels * 844 req->scan_req.dwell_time_active; 845 else 846 req->scan_req.burst_duration = 847 P2P_SCAN_MAX_BURST_DURATION; 848 } 849 req->scan_req.scan_ev_bss_chan = false; 850 } 851 } 852 853 if (!req->scan_req.scan_f_passive) 854 ucfg_update_passive_dwell_time(vdev, req); 855 ucfg_scan_update_dbs_scan_ctrl_ext_flag(req); 856 857 /* 858 * No need to update conncurrency parmas if req is passive scan on 859 * single channel ie ROC, Preauth etc 860 */ 861 if (!(req->scan_req.scan_f_passive && 862 req->scan_req.chan_list.num_chan == 1)) 863 ucfg_scan_req_update_concurrency_params(vdev, req, scan_obj); 864 865 /* Set wide band flag if enabled. This will cause 866 * phymode TLV being sent to FW. 867 */ 868 pdev = wlan_vdev_get_pdev(vdev); 869 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 870 if (ucfg_scan_get_wide_band_scan(pdev)) 871 req->scan_req.scan_f_wide_band = true; 872 else 873 req->scan_req.scan_f_wide_band = false; 874 875 /* Overwrite scan channles with custom scan channel 876 * list if configured. 877 */ 878 custom_chan_list = &scan_obj->pdev_info[pdev_id].custom_chan_list; 879 if (custom_chan_list->num_chan) 880 qdf_mem_copy(&req->scan_req.chan_list, custom_chan_list, 881 sizeof(struct chan_list)); 882 else if (req->scan_req.scan_f_wide_band && 883 !req->scan_req.chan_list.num_chan) 884 ucfg_scan_init_chanlist_params(req, 0, NULL, NULL); 885 886 scm_debug("dwell time: active %d, passive %d, repeat_probe_time %d " 887 "n_probes %d flags_ext %x, wide_bw_scan: %d", 888 req->scan_req.dwell_time_active, 889 req->scan_req.dwell_time_passive, 890 req->scan_req.repeat_probe_time, req->scan_req.n_probes, 891 req->scan_req.scan_ctrl_flags_ext, 892 req->scan_req.scan_f_wide_band); 893 } 894 895 QDF_STATUS 896 ucfg_scan_start(struct scan_start_request *req) 897 { 898 struct scheduler_msg msg = {0}; 899 QDF_STATUS status; 900 struct wlan_scan_obj *scan_obj; 901 struct wlan_objmgr_pdev *pdev; 902 uint8_t idx; 903 904 if (!req || !req->vdev) { 905 scm_err("req or vdev within req is NULL"); 906 if (req) 907 scm_scan_free_scan_request_mem(req); 908 return QDF_STATUS_E_NULL_VALUE; 909 } 910 911 pdev = wlan_vdev_get_pdev(req->vdev); 912 if (!pdev) { 913 scm_err("Failed to get pdev object"); 914 scm_scan_free_scan_request_mem(req); 915 return QDF_STATUS_E_NULL_VALUE; 916 } 917 918 scan_obj = wlan_pdev_get_scan_obj(pdev); 919 if (!scan_obj) { 920 scm_err("Failed to get scan object"); 921 scm_scan_free_scan_request_mem(req); 922 return QDF_STATUS_E_NULL_VALUE; 923 } 924 925 if (!scan_obj->enable_scan) { 926 scm_err("scan disabled, rejecting the scan req"); 927 scm_scan_free_scan_request_mem(req); 928 return QDF_STATUS_E_AGAIN; 929 } 930 931 scm_debug("reqid: %d, scanid: %d, vdevid: %d", 932 req->scan_req.scan_req_id, req->scan_req.scan_id, 933 req->scan_req.vdev_id); 934 935 ucfg_scan_req_update_params(req->vdev, req, scan_obj); 936 937 /* Try to get vdev reference. Return if reference could 938 * not be taken. Reference will be released once scan 939 * request handling completes along with free of @req. 940 */ 941 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID); 942 if (QDF_IS_STATUS_ERROR(status)) { 943 scm_info("unable to get reference"); 944 scm_scan_free_scan_request_mem(req); 945 return status; 946 } 947 948 scm_info("request to scan %d channels", 949 req->scan_req.chan_list.num_chan); 950 for (idx = 0; idx < req->scan_req.chan_list.num_chan; idx++) 951 scm_debug("chan[%d]: freq:%d, phymode:%d", idx, 952 req->scan_req.chan_list.chan[idx].freq, 953 req->scan_req.chan_list.chan[idx].phymode); 954 955 msg.bodyptr = req; 956 msg.callback = scm_scan_start_req; 957 msg.flush_callback = scm_scan_start_flush_callback; 958 959 status = scheduler_post_message(QDF_MODULE_ID_OS_IF, 960 QDF_MODULE_ID_SCAN, 961 QDF_MODULE_ID_OS_IF, &msg); 962 if (QDF_IS_STATUS_ERROR(status)) { 963 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_SCAN_ID); 964 scm_err("failed to post to QDF_MODULE_ID_OS_IF"); 965 scm_scan_free_scan_request_mem(req); 966 } 967 968 return status; 969 } 970 971 QDF_STATUS ucfg_scan_set_enable(struct wlan_objmgr_psoc *psoc, bool enable) 972 { 973 struct wlan_scan_obj *scan_obj; 974 975 scan_obj = wlan_psoc_get_scan_obj(psoc); 976 if (!scan_obj) { 977 scm_err("Failed to get scan object"); 978 return QDF_STATUS_E_NULL_VALUE; 979 } 980 scan_obj->enable_scan = enable; 981 scm_debug("set enable_scan to %d", scan_obj->enable_scan); 982 983 return QDF_STATUS_SUCCESS; 984 } 985 986 bool ucfg_scan_get_enable(struct wlan_objmgr_psoc *psoc) 987 { 988 struct wlan_scan_obj *scan_obj; 989 990 scan_obj = wlan_psoc_get_scan_obj(psoc); 991 if (!scan_obj) { 992 scm_err("Failed to get scan object"); 993 return false; 994 } 995 return scan_obj->enable_scan; 996 } 997 998 QDF_STATUS ucfg_scan_set_miracast( 999 struct wlan_objmgr_psoc *psoc, bool enable) 1000 { 1001 struct wlan_scan_obj *scan_obj; 1002 1003 scan_obj = wlan_psoc_get_scan_obj(psoc); 1004 if (!scan_obj) { 1005 scm_err("Failed to get scan object"); 1006 return QDF_STATUS_E_NULL_VALUE; 1007 } 1008 scan_obj->miracast_enabled = enable; 1009 scm_debug("set miracast_enable to %d", scan_obj->miracast_enabled); 1010 1011 return QDF_STATUS_SUCCESS; 1012 } 1013 1014 QDF_STATUS 1015 ucfg_scan_set_wide_band_scan(struct wlan_objmgr_pdev *pdev, bool enable) 1016 { 1017 uint8_t pdev_id; 1018 struct wlan_scan_obj *scan_obj; 1019 1020 if (!pdev) { 1021 scm_warn("null vdev"); 1022 return QDF_STATUS_E_NULL_VALUE; 1023 } 1024 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1025 scan_obj = wlan_pdev_get_scan_obj(pdev); 1026 1027 scm_debug("set wide_band_scan to %d", enable); 1028 scan_obj->pdev_info[pdev_id].wide_band_scan = enable; 1029 1030 return QDF_STATUS_SUCCESS; 1031 } 1032 1033 bool ucfg_scan_get_wide_band_scan(struct wlan_objmgr_pdev *pdev) 1034 { 1035 uint8_t pdev_id; 1036 struct wlan_scan_obj *scan_obj; 1037 1038 if (!pdev) { 1039 scm_warn("null vdev"); 1040 return QDF_STATUS_E_NULL_VALUE; 1041 } 1042 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1043 scan_obj = wlan_pdev_get_scan_obj(pdev); 1044 1045 return scan_obj->pdev_info[pdev_id].wide_band_scan; 1046 } 1047 1048 #ifdef WLAN_DFS_CHAN_HIDDEN_SSID 1049 QDF_STATUS 1050 ucfg_scan_config_hidden_ssid_for_bssid(struct wlan_objmgr_pdev *pdev, 1051 uint8_t *bssid, struct wlan_ssid *ssid) 1052 { 1053 uint8_t pdev_id; 1054 struct wlan_scan_obj *scan_obj; 1055 1056 if (!pdev) { 1057 scm_warn("null vdev"); 1058 return QDF_STATUS_E_NULL_VALUE; 1059 } 1060 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1061 scan_obj = wlan_pdev_get_scan_obj(pdev); 1062 1063 scm_debug("Configure bsssid:%pM ssid:%.*s", 1064 bssid, ssid->length, ssid->ssid); 1065 qdf_mem_copy(scan_obj->pdev_info[pdev_id].conf_bssid, 1066 bssid, QDF_MAC_ADDR_SIZE); 1067 scan_obj->pdev_info[pdev_id].conf_ssid.length = ssid->length; 1068 qdf_mem_copy(scan_obj->pdev_info[pdev_id].conf_ssid.ssid, 1069 ssid->ssid, 1070 scan_obj->pdev_info[pdev_id].conf_ssid.length); 1071 1072 return QDF_STATUS_SUCCESS; 1073 } 1074 #endif /* WLAN_DFS_CHAN_HIDDEN_SSID */ 1075 1076 QDF_STATUS 1077 ucfg_scan_cancel(struct scan_cancel_request *req) 1078 { 1079 struct scheduler_msg msg = {0}; 1080 QDF_STATUS status; 1081 1082 if (!req || !req->vdev) { 1083 scm_err("req or vdev within req is NULL"); 1084 if (req) 1085 qdf_mem_free(req); 1086 return QDF_STATUS_E_NULL_VALUE; 1087 } 1088 scm_debug("reqid: %d, scanid: %d, vdevid: %d, type: %d", 1089 req->cancel_req.requester, req->cancel_req.scan_id, 1090 req->cancel_req.vdev_id, req->cancel_req.req_type); 1091 1092 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID); 1093 if (QDF_IS_STATUS_ERROR(status)) { 1094 scm_info("Failed to get vdev ref; status:%d", status); 1095 goto req_free; 1096 } 1097 1098 msg.bodyptr = req; 1099 msg.callback = scm_scan_cancel_req; 1100 msg.flush_callback = scm_scan_cancel_flush_callback; 1101 1102 status = scheduler_post_message(QDF_MODULE_ID_OS_IF, 1103 QDF_MODULE_ID_SCAN, 1104 QDF_MODULE_ID_OS_IF, &msg); 1105 if (QDF_IS_STATUS_ERROR(status)) { 1106 scm_err("failed to post to QDF_MODULE_ID_OS_IF"); 1107 goto vdev_put; 1108 } 1109 1110 return QDF_STATUS_SUCCESS; 1111 1112 vdev_put: 1113 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_SCAN_ID); 1114 1115 req_free: 1116 qdf_mem_free(req); 1117 1118 return status; 1119 } 1120 1121 QDF_STATUS 1122 ucfg_scan_cancel_sync(struct scan_cancel_request *req) 1123 { 1124 QDF_STATUS status; 1125 bool cancel_vdev = false, cancel_pdev = false; 1126 struct wlan_objmgr_vdev *vdev; 1127 struct wlan_objmgr_pdev *pdev; 1128 uint32_t max_wait_iterations = SCM_CANCEL_SCAN_WAIT_ITERATION; 1129 qdf_event_t cancel_scan_event; 1130 1131 if (!req || !req->vdev) { 1132 scm_err("req or vdev within req is NULL"); 1133 if (req) 1134 qdf_mem_free(req); 1135 return QDF_STATUS_E_NULL_VALUE; 1136 } 1137 1138 if (req->cancel_req.req_type == 1139 WLAN_SCAN_CANCEL_PDEV_ALL) 1140 cancel_pdev = true; 1141 else if (req->cancel_req.req_type == 1142 WLAN_SCAN_CANCEL_VDEV_ALL) 1143 cancel_vdev = true; 1144 1145 vdev = req->vdev; 1146 status = ucfg_scan_cancel(req); 1147 if (QDF_IS_STATUS_ERROR(status)) { 1148 scm_err("failed to post to QDF_MODULE_ID_OS_IF"); 1149 return status; 1150 } 1151 1152 memset(&cancel_scan_event, 0, sizeof(cancel_scan_event)); 1153 /* 1154 * If cancel req is to cancel all scan of pdev or vdev 1155 * wait until all scan of pdev or vdev get cancelled 1156 */ 1157 qdf_event_create(&cancel_scan_event); 1158 qdf_event_reset(&cancel_scan_event); 1159 1160 if (cancel_pdev) { 1161 pdev = wlan_vdev_get_pdev(vdev); 1162 while ((ucfg_scan_get_pdev_status(pdev) != 1163 SCAN_NOT_IN_PROGRESS) && max_wait_iterations) { 1164 scm_debug("wait for all pdev scan to get complete"); 1165 qdf_wait_single_event(&cancel_scan_event, 1166 qdf_system_msecs_to_ticks( 1167 SCM_CANCEL_SCAN_WAIT_TIME)); 1168 max_wait_iterations--; 1169 } 1170 } else if (cancel_vdev) { 1171 while ((ucfg_scan_get_vdev_status(vdev) != 1172 SCAN_NOT_IN_PROGRESS) && max_wait_iterations) { 1173 scm_debug("wait for all vdev scan to get complete"); 1174 qdf_wait_single_event(&cancel_scan_event, 1175 qdf_system_msecs_to_ticks( 1176 SCM_CANCEL_SCAN_WAIT_TIME)); 1177 max_wait_iterations--; 1178 } 1179 } 1180 1181 qdf_event_destroy(&cancel_scan_event); 1182 1183 if (!max_wait_iterations) { 1184 scm_err("Failed to wait for scans to get complete"); 1185 return QDF_STATUS_E_TIMEOUT; 1186 } 1187 1188 return status; 1189 } 1190 1191 wlan_scan_requester 1192 ucfg_scan_register_requester(struct wlan_objmgr_psoc *psoc, 1193 uint8_t *name, scan_event_handler event_cb, void *arg) 1194 { 1195 int i, j; 1196 struct wlan_scan_obj *scan; 1197 struct scan_requester_info *requesters; 1198 wlan_scan_requester requester = {0}; 1199 1200 if (!psoc) { 1201 scm_err("null psoc"); 1202 return 0; 1203 } 1204 scan = wlan_psoc_get_scan_obj(psoc); 1205 requesters = scan->requesters; 1206 qdf_spin_lock_bh(&scan->lock); 1207 for (i = 0; i < WLAN_MAX_REQUESTORS; ++i) { 1208 if (requesters[i].requester == 0) { 1209 requesters[i].requester = 1210 WLAN_SCAN_REQUESTER_ID_PREFIX | i; 1211 j = 0; 1212 while (name[j] && (j < (WLAN_MAX_MODULE_NAME - 1))) { 1213 requesters[i].module[j] = name[j]; 1214 ++j; 1215 } 1216 requesters[i].module[j] = 0; 1217 requesters[i].ev_handler.func = event_cb; 1218 requesters[i].ev_handler.arg = arg; 1219 requester = requesters[i].requester; 1220 break; 1221 } 1222 } 1223 qdf_spin_unlock_bh(&scan->lock); 1224 scm_debug("module: %s, event_cb: 0x%pK, arg: 0x%pK, reqid: %d", 1225 name, event_cb, arg, requester); 1226 1227 return requester; 1228 } 1229 1230 void 1231 ucfg_scan_unregister_requester(struct wlan_objmgr_psoc *psoc, 1232 wlan_scan_requester requester) 1233 { 1234 int idx = requester & WLAN_SCAN_REQUESTER_ID_MASK; 1235 struct wlan_scan_obj *scan; 1236 struct scan_requester_info *requesters; 1237 1238 if (idx >= WLAN_MAX_REQUESTORS) { 1239 scm_err("requester id invalid"); 1240 return; 1241 } 1242 1243 if (!psoc) { 1244 scm_err("null psoc"); 1245 return; 1246 } 1247 scan = wlan_psoc_get_scan_obj(psoc); 1248 requesters = scan->requesters; 1249 scm_debug("reqid: %d", requester); 1250 1251 qdf_spin_lock_bh(&scan->lock); 1252 requesters[idx].requester = 0; 1253 requesters[idx].module[0] = 0; 1254 requesters[idx].ev_handler.func = NULL; 1255 requesters[idx].ev_handler.arg = NULL; 1256 qdf_spin_unlock_bh(&scan->lock); 1257 } 1258 1259 uint8_t* 1260 ucfg_get_scan_requester_name(struct wlan_objmgr_psoc *psoc, 1261 wlan_scan_requester requester) 1262 { 1263 int idx = requester & WLAN_SCAN_REQUESTER_ID_MASK; 1264 struct wlan_scan_obj *scan; 1265 struct scan_requester_info *requesters; 1266 1267 if (!psoc) { 1268 scm_err("null psoc"); 1269 return "null"; 1270 } 1271 scan = wlan_psoc_get_scan_obj(psoc); 1272 requesters = scan->requesters; 1273 1274 if ((idx < WLAN_MAX_REQUESTORS) && 1275 (requesters[idx].requester == requester)) { 1276 return requesters[idx].module; 1277 } 1278 1279 return (uint8_t *)"unknown"; 1280 } 1281 1282 wlan_scan_id 1283 ucfg_scan_get_scan_id(struct wlan_objmgr_psoc *psoc) 1284 { 1285 wlan_scan_id id; 1286 struct wlan_scan_obj *scan; 1287 1288 if (!psoc) { 1289 QDF_ASSERT(0); 1290 scm_err("null psoc"); 1291 return 0; 1292 } 1293 scan = wlan_psoc_get_scan_obj(psoc); 1294 1295 id = qdf_atomic_inc_return(&scan->scan_ids); 1296 id = id & WLAN_SCAN_ID_MASK; 1297 /* Mark this scan request as triggered by host 1298 * by setting WLAN_HOST_SCAN_REQ_ID_PREFIX flag. 1299 */ 1300 id = id | WLAN_HOST_SCAN_REQ_ID_PREFIX; 1301 scm_debug("scan_id: 0x%x", id); 1302 1303 return id; 1304 } 1305 1306 static QDF_STATUS 1307 scm_add_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler, 1308 scan_event_handler event_cb, void *arg) 1309 { 1310 struct cb_handler *cb_handler; 1311 uint32_t handler_cnt = pdev_ev_handler->handler_cnt; 1312 1313 /* Assign next available slot to this registration request */ 1314 cb_handler = &(pdev_ev_handler->cb_handlers[handler_cnt]); 1315 cb_handler->func = event_cb; 1316 cb_handler->arg = arg; 1317 pdev_ev_handler->handler_cnt++; 1318 1319 return QDF_STATUS_SUCCESS; 1320 } 1321 1322 QDF_STATUS 1323 ucfg_scan_register_event_handler(struct wlan_objmgr_pdev *pdev, 1324 scan_event_handler event_cb, void *arg) 1325 { 1326 uint32_t idx; 1327 struct wlan_scan_obj *scan; 1328 struct pdev_scan_ev_handler *pdev_ev_handler; 1329 struct cb_handler *cb_handler; 1330 1331 /* scan event handler call back can't be NULL */ 1332 if (!pdev || !event_cb) { 1333 scm_err("pdev: %pK, event_cb: %pK", pdev, event_cb); 1334 return QDF_STATUS_E_NULL_VALUE; 1335 } 1336 1337 scm_debug("pdev: %pK, event_cb: %pK, arg: %pK\n", pdev, event_cb, arg); 1338 1339 scan = wlan_pdev_get_scan_obj(pdev); 1340 pdev_ev_handler = wlan_pdev_get_pdev_scan_ev_handlers(pdev); 1341 cb_handler = &(pdev_ev_handler->cb_handlers[0]); 1342 1343 qdf_spin_lock_bh(&scan->lock); 1344 /* Ensure its not a duplicate registration request */ 1345 for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; 1346 idx++, cb_handler++) { 1347 if ((cb_handler->func == event_cb) && 1348 (cb_handler->arg == arg)) { 1349 qdf_spin_unlock_bh(&scan->lock); 1350 scm_debug("func: %pK, arg: %pK already exists", 1351 event_cb, arg); 1352 return QDF_STATUS_SUCCESS; 1353 } 1354 } 1355 1356 QDF_ASSERT(pdev_ev_handler->handler_cnt < 1357 MAX_SCAN_EVENT_HANDLERS_PER_PDEV); 1358 1359 if (pdev_ev_handler->handler_cnt >= MAX_SCAN_EVENT_HANDLERS_PER_PDEV) { 1360 qdf_spin_unlock_bh(&scan->lock); 1361 scm_warn("No more registrations possible"); 1362 return QDF_STATUS_E_NOMEM; 1363 } 1364 1365 scm_add_scan_event_handler(pdev_ev_handler, event_cb, arg); 1366 qdf_spin_unlock_bh(&scan->lock); 1367 1368 scm_debug("event_cb: 0x%pK, arg: 0x%pK", event_cb, arg); 1369 1370 return QDF_STATUS_SUCCESS; 1371 } 1372 1373 void wlan_scan_cfg_get_passive_dwelltime(struct wlan_objmgr_psoc *psoc, 1374 uint32_t *dwell_time) 1375 { 1376 struct wlan_scan_obj *scan_obj; 1377 1378 scan_obj = wlan_psoc_get_scan_obj(psoc); 1379 if (!scan_obj) { 1380 scm_err("Failed to get scan object"); 1381 return; 1382 } 1383 1384 *dwell_time = scan_obj->scan_def.passive_dwell; 1385 } 1386 1387 void wlan_scan_cfg_set_passive_dwelltime(struct wlan_objmgr_psoc *psoc, 1388 uint32_t dwell_time) 1389 { 1390 struct wlan_scan_obj *scan_obj; 1391 1392 scan_obj = wlan_psoc_get_scan_obj(psoc); 1393 if (!scan_obj) { 1394 scm_err("Failed to get scan object"); 1395 return; 1396 } 1397 1398 scan_obj->scan_def.passive_dwell = dwell_time; 1399 } 1400 1401 void wlan_scan_cfg_get_active_dwelltime(struct wlan_objmgr_psoc *psoc, 1402 uint32_t *dwell_time) 1403 { 1404 struct wlan_scan_obj *scan_obj; 1405 1406 scan_obj = wlan_psoc_get_scan_obj(psoc); 1407 if (!scan_obj) { 1408 scm_err("Failed to get scan object"); 1409 return; 1410 } 1411 1412 *dwell_time = scan_obj->scan_def.active_dwell; 1413 } 1414 1415 void wlan_scan_cfg_set_active_dwelltime(struct wlan_objmgr_psoc *psoc, 1416 uint32_t dwell_time) 1417 { 1418 struct wlan_scan_obj *scan_obj; 1419 1420 scan_obj = wlan_psoc_get_scan_obj(psoc); 1421 if (!scan_obj) { 1422 scm_err("Failed to get scan object"); 1423 return; 1424 } 1425 1426 scan_obj->scan_def.active_dwell = dwell_time; 1427 } 1428 1429 static QDF_STATUS 1430 wlan_scan_global_init(struct wlan_objmgr_psoc *psoc, 1431 struct wlan_scan_obj *scan_obj) 1432 { 1433 scan_obj->enable_scan = true; 1434 scan_obj->drop_bcn_on_chan_mismatch = true; 1435 scan_obj->disable_timeout = false; 1436 scan_obj->scan_def.active_dwell = 1437 cfg_get(psoc, CFG_ACTIVE_MAX_CHANNEL_TIME); 1438 scan_obj->scan_def.active_dwell_2g = 1439 cfg_get(psoc, CFG_ACTIVE_MAX_2G_CHANNEL_TIME); 1440 scan_obj->scan_def.passive_dwell = 1441 cfg_get(psoc, CFG_PASSIVE_MAX_CHANNEL_TIME); 1442 scan_obj->scan_def.max_rest_time = SCAN_MAX_REST_TIME; 1443 scan_obj->scan_def.sta_miracast_mcc_rest_time = 1444 SCAN_STA_MIRACAST_MCC_REST_TIME; 1445 scan_obj->scan_def.min_rest_time = SCAN_MIN_REST_TIME; 1446 scan_obj->scan_def.conc_active_dwell = SCAN_CONC_ACTIVE_DWELL_TIME; 1447 scan_obj->scan_def.conc_passive_dwell = SCAN_CONC_PASSIVE_DWELL_TIME; 1448 scan_obj->scan_def.conc_max_rest_time = SCAN_CONC_MAX_REST_TIME; 1449 scan_obj->scan_def.conc_min_rest_time = SCAN_CONC_MIN_REST_TIME; 1450 scan_obj->scan_def.conc_idle_time = SCAN_CONC_IDLE_TIME; 1451 scan_obj->scan_def.repeat_probe_time = 1452 cfg_get(psoc, CFG_SCAN_PROBE_REPEAT_TIME); 1453 scan_obj->scan_def.probe_spacing_time = SCAN_PROBE_SPACING_TIME; 1454 scan_obj->scan_def.probe_delay = SCAN_PROBE_DELAY; 1455 scan_obj->scan_def.burst_duration = SCAN_BURST_DURATION; 1456 scan_obj->scan_def.max_scan_time = SCAN_MAX_SCAN_TIME; 1457 scan_obj->scan_def.num_probes = cfg_get(psoc, CFG_SCAN_NUM_PROBES); 1458 scan_obj->scan_def.scan_cache_aging_time = SCAN_CACHE_AGING_TIME; 1459 scan_obj->scan_def.max_bss_per_pdev = SCAN_MAX_BSS_PDEV; 1460 scan_obj->scan_def.scan_priority = SCAN_PRIORITY; 1461 scan_obj->scan_def.idle_time = SCAN_NETWORK_IDLE_TIMEOUT; 1462 scan_obj->scan_def.adaptive_dwell_time_mode = 1463 cfg_get(psoc, CFG_ADAPTIVE_SCAN_DWELL_MODE); 1464 scan_obj->scan_def.is_bssid_hint_priority = 1465 cfg_get(psoc, CFG_IS_BSSID_HINT_PRIORITY); 1466 /* scan contrl flags */ 1467 scan_obj->scan_def.scan_f_passive = true; 1468 scan_obj->scan_def.scan_f_ofdm_rates = true; 1469 scan_obj->scan_def.scan_f_2ghz = true; 1470 scan_obj->scan_def.scan_f_5ghz = true; 1471 scan_obj->scan_def.scan_f_chan_stat_evnt = SCAN_CHAN_STATS_EVENT_ENAB; 1472 /* scan event flags */ 1473 scan_obj->scan_def.scan_ev_started = true; 1474 scan_obj->scan_def.scan_ev_completed = true; 1475 scan_obj->scan_def.scan_ev_bss_chan = true; 1476 scan_obj->scan_def.scan_ev_foreign_chan = true; 1477 scan_obj->scan_def.scan_ev_foreign_chn_exit = true; 1478 scan_obj->scan_def.scan_ev_dequeued = true; 1479 scan_obj->scan_def.scan_ev_preempted = true; 1480 scan_obj->scan_def.scan_ev_start_failed = true; 1481 scan_obj->scan_def.scan_ev_restarted = true; 1482 /* init scan id seed */ 1483 qdf_atomic_init(&scan_obj->scan_ids); 1484 1485 /* init extscan */ 1486 wlan_extscan_global_init(psoc, scan_obj); 1487 1488 return wlan_pno_global_init(&scan_obj->pno_cfg); 1489 } 1490 1491 static void 1492 wlan_scan_global_deinit(struct wlan_objmgr_psoc *psoc) 1493 { 1494 struct wlan_scan_obj *scan_obj; 1495 1496 scan_obj = wlan_psoc_get_scan_obj(psoc); 1497 wlan_pno_global_deinit(&scan_obj->pno_cfg); 1498 wlan_extscan_global_deinit(); 1499 } 1500 1501 static QDF_STATUS 1502 scm_remove_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler, 1503 struct cb_handler *entry) 1504 { 1505 struct cb_handler *last_entry; 1506 uint32_t handler_cnt = pdev_ev_handler->handler_cnt; 1507 1508 /* Replace event handler being deleted 1509 * with the last one in the list. 1510 */ 1511 last_entry = &(pdev_ev_handler->cb_handlers[handler_cnt - 1]); 1512 entry->func = last_entry->func; 1513 entry->arg = last_entry->arg; 1514 1515 /* Clear our last entry */ 1516 last_entry->func = NULL; 1517 last_entry->arg = NULL; 1518 pdev_ev_handler->handler_cnt--; 1519 1520 return QDF_STATUS_SUCCESS; 1521 } 1522 1523 void 1524 ucfg_scan_unregister_event_handler(struct wlan_objmgr_pdev *pdev, 1525 scan_event_handler event_cb, void *arg) 1526 { 1527 uint8_t found = false; 1528 uint32_t idx; 1529 uint32_t handler_cnt; 1530 struct wlan_scan_obj *scan; 1531 struct cb_handler *cb_handler; 1532 struct pdev_scan_ev_handler *pdev_ev_handler; 1533 1534 scm_debug("pdev: %pK, event_cb: 0x%pK, arg: 0x%pK", pdev, event_cb, 1535 arg); 1536 if (!pdev) { 1537 scm_err("null pdev"); 1538 return; 1539 } 1540 scan = wlan_pdev_get_scan_obj(pdev); 1541 pdev_ev_handler = wlan_pdev_get_pdev_scan_ev_handlers(pdev); 1542 cb_handler = &(pdev_ev_handler->cb_handlers[0]); 1543 1544 qdf_spin_lock_bh(&scan->lock); 1545 handler_cnt = pdev_ev_handler->handler_cnt; 1546 if (!handler_cnt) { 1547 qdf_spin_unlock_bh(&scan->lock); 1548 scm_info("No event handlers registered"); 1549 return; 1550 } 1551 1552 for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; 1553 idx++, cb_handler++) { 1554 if ((cb_handler->func == event_cb) && 1555 (cb_handler->arg == arg)) { 1556 /* Event handler found, remove it 1557 * from event handler list. 1558 */ 1559 found = true; 1560 scm_remove_scan_event_handler(pdev_ev_handler, 1561 cb_handler); 1562 handler_cnt--; 1563 break; 1564 } 1565 } 1566 qdf_spin_unlock_bh(&scan->lock); 1567 1568 scm_debug("event handler %s, remaining handlers: %d", 1569 (found ? "removed" : "not found"), handler_cnt); 1570 } 1571 1572 QDF_STATUS 1573 ucfg_scan_init_default_params(struct wlan_objmgr_vdev *vdev, 1574 struct scan_start_request *req) 1575 { 1576 struct scan_default_params *def; 1577 1578 if (!vdev | !req) { 1579 scm_err("vdev: 0x%pK, req: 0x%pK", vdev, req); 1580 return QDF_STATUS_E_INVAL; 1581 } 1582 def = wlan_vdev_get_def_scan_params(vdev); 1583 if (!def) { 1584 scm_err("wlan_vdev_get_def_scan_params returned NULL"); 1585 return QDF_STATUS_E_NULL_VALUE; 1586 } 1587 1588 /* Zero out everything and explicitly set fields as required */ 1589 qdf_mem_zero(req, sizeof(*req)); 1590 1591 req->vdev = vdev; 1592 req->scan_req.vdev_id = wlan_vdev_get_id(vdev); 1593 req->scan_req.p2p_scan_type = SCAN_NON_P2P_DEFAULT; 1594 req->scan_req.scan_priority = def->scan_priority; 1595 req->scan_req.dwell_time_active = def->active_dwell; 1596 req->scan_req.dwell_time_active_2g = def->active_dwell_2g; 1597 req->scan_req.dwell_time_passive = def->passive_dwell; 1598 req->scan_req.min_rest_time = def->min_rest_time; 1599 req->scan_req.max_rest_time = def->max_rest_time; 1600 req->scan_req.repeat_probe_time = def->repeat_probe_time; 1601 req->scan_req.probe_spacing_time = def->probe_spacing_time; 1602 req->scan_req.idle_time = def->idle_time; 1603 req->scan_req.max_scan_time = def->max_scan_time; 1604 req->scan_req.probe_delay = def->probe_delay; 1605 req->scan_req.burst_duration = def->burst_duration; 1606 req->scan_req.n_probes = def->num_probes; 1607 req->scan_req.adaptive_dwell_time_mode = 1608 def->adaptive_dwell_time_mode; 1609 req->scan_req.scan_flags = def->scan_flags; 1610 req->scan_req.scan_events = def->scan_events; 1611 req->scan_req.scan_random.randomize = def->enable_mac_spoofing; 1612 1613 return QDF_STATUS_SUCCESS; 1614 } 1615 1616 QDF_STATUS 1617 ucfg_scan_init_ssid_params(struct scan_start_request *req, 1618 uint32_t num_ssid, struct wlan_ssid *ssid_list) 1619 { 1620 uint32_t max_ssid = sizeof(req->scan_req.ssid) / 1621 sizeof(req->scan_req.ssid[0]); 1622 1623 if (!req) { 1624 scm_err("null request"); 1625 return QDF_STATUS_E_NULL_VALUE; 1626 } 1627 if (!num_ssid) { 1628 /* empty channel list provided */ 1629 req->scan_req.num_ssids = 0; 1630 qdf_mem_zero(&req->scan_req.ssid[0], 1631 sizeof(req->scan_req.ssid)); 1632 return QDF_STATUS_SUCCESS; 1633 } 1634 if (!ssid_list) { 1635 scm_err("null ssid_list while num_ssid: %d", num_ssid); 1636 return QDF_STATUS_E_NULL_VALUE; 1637 } 1638 if (num_ssid > max_ssid) { 1639 /* got a big list. alert and continue */ 1640 scm_warn("overflow: received %d, max supported : %d", 1641 num_ssid, max_ssid); 1642 return QDF_STATUS_E_E2BIG; 1643 } 1644 1645 if (max_ssid > num_ssid) 1646 max_ssid = num_ssid; 1647 1648 req->scan_req.num_ssids = max_ssid; 1649 qdf_mem_copy(&req->scan_req.ssid[0], ssid_list, 1650 (req->scan_req.num_ssids * sizeof(req->scan_req.ssid[0]))); 1651 1652 return QDF_STATUS_SUCCESS; 1653 } 1654 1655 QDF_STATUS 1656 ucfg_scan_init_bssid_params(struct scan_start_request *req, 1657 uint32_t num_bssid, struct qdf_mac_addr *bssid_list) 1658 { 1659 uint32_t max_bssid = sizeof(req->scan_req.bssid_list) / 1660 sizeof(req->scan_req.bssid_list[0]); 1661 1662 if (!req) { 1663 scm_err("null request"); 1664 return QDF_STATUS_E_NULL_VALUE; 1665 } 1666 if (!num_bssid) { 1667 /* empty channel list provided */ 1668 req->scan_req.num_bssid = 0; 1669 qdf_mem_zero(&req->scan_req.bssid_list[0], 1670 sizeof(req->scan_req.bssid_list)); 1671 return QDF_STATUS_SUCCESS; 1672 } 1673 if (!bssid_list) { 1674 scm_err("null bssid_list while num_bssid: %d", num_bssid); 1675 return QDF_STATUS_E_NULL_VALUE; 1676 } 1677 if (num_bssid > max_bssid) { 1678 /* got a big list. alert and continue */ 1679 scm_warn("overflow: received %d, max supported : %d", 1680 num_bssid, max_bssid); 1681 return QDF_STATUS_E_E2BIG; 1682 } 1683 1684 if (max_bssid > num_bssid) 1685 max_bssid = num_bssid; 1686 1687 req->scan_req.num_bssid = max_bssid; 1688 qdf_mem_copy(&req->scan_req.bssid_list[0], bssid_list, 1689 req->scan_req.num_bssid * sizeof(req->scan_req.bssid_list[0])); 1690 1691 return QDF_STATUS_SUCCESS; 1692 } 1693 1694 /** 1695 * is_chan_enabled_for_scan() - helper API to check if a frequency 1696 * is allowed to scan. 1697 * @reg_chan: regulatory_channel object 1698 * @low_2g: lower 2.4 GHz frequency thresold 1699 * @high_2g: upper 2.4 GHz frequency thresold 1700 * @low_5g: lower 5 GHz frequency thresold 1701 * @high_5g: upper 5 GHz frequency thresold 1702 * 1703 * Return: true if scan is allowed. false otherwise. 1704 */ 1705 static bool 1706 is_chan_enabled_for_scan(struct regulatory_channel *reg_chan, 1707 uint32_t low_2g, uint32_t high_2g, uint32_t low_5g, 1708 uint32_t high_5g) 1709 { 1710 if (reg_chan->state == CHANNEL_STATE_DISABLE) 1711 return false; 1712 if (reg_chan->nol_chan) 1713 return false; 1714 /* 2 GHz channel */ 1715 if ((util_scan_scm_chan_to_band(reg_chan->chan_num) == 1716 WLAN_BAND_2_4_GHZ) && 1717 ((reg_chan->center_freq < low_2g) || 1718 (reg_chan->center_freq > high_2g))) 1719 return false; 1720 else if ((reg_chan->center_freq < low_5g) || 1721 (reg_chan->center_freq > high_5g)) 1722 return false; 1723 1724 return true; 1725 } 1726 1727 QDF_STATUS 1728 ucfg_scan_init_chanlist_params(struct scan_start_request *req, 1729 uint32_t num_chans, uint32_t *chan_list, uint32_t *phymode) 1730 { 1731 uint32_t idx; 1732 QDF_STATUS status; 1733 struct regulatory_channel *reg_chan_list = NULL; 1734 uint32_t low_2g, high_2g, low_5g, high_5g; 1735 struct wlan_objmgr_pdev *pdev = NULL; 1736 uint32_t *scan_freqs = NULL; 1737 uint32_t max_chans = sizeof(req->scan_req.chan_list.chan) / 1738 sizeof(req->scan_req.chan_list.chan[0]); 1739 if (!req) { 1740 scm_err("null request"); 1741 return QDF_STATUS_E_NULL_VALUE; 1742 } 1743 1744 if (req->vdev) 1745 pdev = wlan_vdev_get_pdev(req->vdev); 1746 /* 1747 * If 0 channels are provided for scan and 1748 * wide band scan is enabled, scan all 20 mhz 1749 * available channels. This is required as FW 1750 * scans all channel/phy mode combinations 1751 * provided in scan channel list if 0 chans are 1752 * provided in scan request causing scan to take 1753 * too much time to complete. 1754 */ 1755 if (pdev && !num_chans && ucfg_scan_get_wide_band_scan(pdev)) { 1756 reg_chan_list = qdf_mem_malloc_atomic(NUM_CHANNELS * 1757 sizeof(struct regulatory_channel)); 1758 if (!reg_chan_list) { 1759 scm_err("Couldn't allocate reg_chan_list memory"); 1760 status = QDF_STATUS_E_NOMEM; 1761 goto end; 1762 } 1763 scan_freqs = 1764 qdf_mem_malloc_atomic(sizeof(uint32_t) * max_chans); 1765 if (!scan_freqs) { 1766 scm_err("Couldn't allocate scan_freqs memory"); 1767 status = QDF_STATUS_E_NOMEM; 1768 goto end; 1769 } 1770 status = ucfg_reg_get_current_chan_list(pdev, reg_chan_list); 1771 if (QDF_IS_STATUS_ERROR(status)) { 1772 scm_err("Couldn't get current chan list"); 1773 goto end; 1774 } 1775 status = wlan_reg_get_freq_range(pdev, &low_2g, 1776 &high_2g, &low_5g, &high_5g); 1777 if (QDF_IS_STATUS_ERROR(status)) { 1778 scm_err("Couldn't get frequency range"); 1779 goto end; 1780 } 1781 1782 for (idx = 0, num_chans = 0; 1783 (idx < NUM_CHANNELS && num_chans < max_chans); idx++) 1784 if (is_chan_enabled_for_scan(®_chan_list[idx], 1785 low_2g, high_2g, low_5g, high_5g)) 1786 scan_freqs[num_chans++] = 1787 reg_chan_list[idx].center_freq; 1788 1789 chan_list = scan_freqs; 1790 } 1791 1792 if (!num_chans) { 1793 /* empty channel list provided */ 1794 qdf_mem_zero(&req->scan_req.chan_list, 1795 sizeof(req->scan_req.chan_list)); 1796 req->scan_req.chan_list.num_chan = 0; 1797 status = QDF_STATUS_SUCCESS; 1798 goto end; 1799 } 1800 if (!chan_list) { 1801 scm_err("null chan_list while num_chans: %d", num_chans); 1802 status = QDF_STATUS_E_NULL_VALUE; 1803 goto end; 1804 } 1805 1806 if (num_chans > max_chans) { 1807 /* got a big list. alert and fail */ 1808 scm_warn("overflow: received %d, max supported : %d", 1809 num_chans, max_chans); 1810 status = QDF_STATUS_E_E2BIG; 1811 goto end; 1812 } 1813 1814 req->scan_req.chan_list.num_chan = num_chans; 1815 for (idx = 0; idx < num_chans; idx++) { 1816 req->scan_req.chan_list.chan[idx].freq = 1817 (chan_list[idx] > WLAN_24_GHZ_BASE_FREQ) ? 1818 chan_list[idx] : 1819 wlan_reg_chan_to_freq(pdev, chan_list[idx]); 1820 if (phymode) 1821 req->scan_req.chan_list.chan[idx].phymode = 1822 phymode[idx]; 1823 else if (req->scan_req.chan_list.chan[idx].freq <= 1824 WLAN_CHAN_15_FREQ) 1825 req->scan_req.chan_list.chan[idx].phymode = 1826 SCAN_PHY_MODE_11G; 1827 else 1828 req->scan_req.chan_list.chan[idx].phymode = 1829 SCAN_PHY_MODE_11A; 1830 1831 scm_debug("chan[%d]: freq:%d, phymode:%d", idx, 1832 req->scan_req.chan_list.chan[idx].freq, 1833 req->scan_req.chan_list.chan[idx].phymode); 1834 } 1835 1836 end: 1837 if (scan_freqs) 1838 qdf_mem_free(scan_freqs); 1839 1840 return QDF_STATUS_SUCCESS; 1841 } 1842 1843 static inline enum scm_scan_status 1844 get_scan_status_from_serialization_status( 1845 enum wlan_serialization_cmd_status status) 1846 { 1847 enum scm_scan_status scan_status; 1848 1849 switch (status) { 1850 case WLAN_SER_CMD_IN_PENDING_LIST: 1851 scan_status = SCAN_IS_PENDING; 1852 break; 1853 case WLAN_SER_CMD_IN_ACTIVE_LIST: 1854 scan_status = SCAN_IS_ACTIVE; 1855 break; 1856 case WLAN_SER_CMDS_IN_ALL_LISTS: 1857 scan_status = SCAN_IS_ACTIVE_AND_PENDING; 1858 break; 1859 case WLAN_SER_CMD_NOT_FOUND: 1860 scan_status = SCAN_NOT_IN_PROGRESS; 1861 break; 1862 default: 1863 scm_warn("invalid serialization status %d", status); 1864 QDF_ASSERT(0); 1865 scan_status = SCAN_NOT_IN_PROGRESS; 1866 break; 1867 } 1868 1869 return scan_status; 1870 } 1871 1872 enum scm_scan_status 1873 ucfg_scan_get_vdev_status(struct wlan_objmgr_vdev *vdev) 1874 { 1875 enum wlan_serialization_cmd_status status; 1876 1877 if (!vdev) { 1878 scm_err("null vdev"); 1879 return SCAN_NOT_IN_PROGRESS; 1880 } 1881 status = wlan_serialization_vdev_scan_status(vdev); 1882 1883 return get_scan_status_from_serialization_status(status); 1884 } 1885 1886 enum scm_scan_status 1887 ucfg_scan_get_pdev_status(struct wlan_objmgr_pdev *pdev) 1888 { 1889 enum wlan_serialization_cmd_status status; 1890 1891 if (!pdev) { 1892 scm_err("null pdev"); 1893 return SCAN_NOT_IN_PROGRESS; 1894 } 1895 status = wlan_serialization_pdev_scan_status(pdev); 1896 1897 return get_scan_status_from_serialization_status(status); 1898 } 1899 1900 static void 1901 ucfg_scan_register_unregister_bcn_cb(struct wlan_objmgr_psoc *psoc, 1902 bool enable) 1903 { 1904 QDF_STATUS status; 1905 struct mgmt_txrx_mgmt_frame_cb_info cb_info[2]; 1906 1907 cb_info[0].frm_type = MGMT_PROBE_RESP; 1908 cb_info[0].mgmt_rx_cb = tgt_scan_bcn_probe_rx_callback; 1909 cb_info[1].frm_type = MGMT_BEACON; 1910 cb_info[1].mgmt_rx_cb = tgt_scan_bcn_probe_rx_callback; 1911 1912 if (enable) 1913 status = wlan_mgmt_txrx_register_rx_cb(psoc, 1914 WLAN_UMAC_COMP_SCAN, cb_info, 2); 1915 else 1916 status = wlan_mgmt_txrx_deregister_rx_cb(psoc, 1917 WLAN_UMAC_COMP_SCAN, cb_info, 2); 1918 if (status != QDF_STATUS_SUCCESS) 1919 scm_err("%s the Handle with MGMT TXRX layer has failed", 1920 enable ? "Registering" : "Deregistering"); 1921 } 1922 1923 static void ucfg_scan_assign_rssi_category(struct scan_default_params *params, 1924 int32_t best_ap_rssi, uint32_t cat_offset) 1925 { 1926 int i; 1927 1928 scm_debug("best AP RSSI:%d, cat offset: %d", best_ap_rssi, cat_offset); 1929 if (cat_offset) 1930 for (i = 0; i < SCM_NUM_RSSI_CAT; i++) { 1931 params->rssi_cat[SCM_NUM_RSSI_CAT - i - 1] = 1932 (best_ap_rssi - 1933 params->select_5ghz_margin - 1934 (int)(i * cat_offset)); 1935 params->bss_prefer_val[i] = i; 1936 } 1937 } 1938 1939 QDF_STATUS ucfg_scan_update_user_config(struct wlan_objmgr_psoc *psoc, 1940 struct scan_user_cfg *scan_cfg) 1941 { 1942 struct wlan_scan_obj *scan_obj; 1943 struct scan_default_params *scan_def; 1944 1945 if (!psoc) { 1946 scm_err("null psoc"); 1947 return QDF_STATUS_E_FAILURE; 1948 } 1949 scan_obj = wlan_psoc_get_scan_obj(psoc); 1950 if (scan_obj == NULL) { 1951 scm_err("Failed to get scan object"); 1952 return QDF_STATUS_E_FAILURE; 1953 } 1954 1955 scan_def = &scan_obj->scan_def; 1956 scan_def->passive_dwell = scan_cfg->passive_dwell; 1957 scan_def->conc_active_dwell = scan_cfg->conc_active_dwell; 1958 scan_def->conc_passive_dwell = scan_cfg->conc_passive_dwell; 1959 scan_def->conc_max_rest_time = scan_cfg->conc_max_rest_time; 1960 scan_def->conc_min_rest_time = scan_cfg->conc_min_rest_time; 1961 scan_def->conc_idle_time = scan_cfg->conc_idle_time; 1962 scan_def->scan_cache_aging_time = scan_cfg->scan_cache_aging_time; 1963 scan_def->prefer_5ghz = scan_cfg->prefer_5ghz; 1964 scan_def->select_5ghz_margin = scan_cfg->select_5ghz_margin; 1965 scan_def->scan_f_chan_stat_evnt = scan_cfg->is_snr_monitoring_enabled; 1966 scan_obj->ie_whitelist = scan_cfg->ie_whitelist; 1967 scan_def->enable_mac_spoofing = scan_cfg->enable_mac_spoofing; 1968 scan_def->sta_miracast_mcc_rest_time = 1969 scan_cfg->sta_miracast_mcc_rest_time; 1970 1971 ucfg_scan_assign_rssi_category(scan_def, 1972 scan_cfg->scan_bucket_threshold, 1973 scan_cfg->rssi_cat_gap); 1974 1975 ucfg_scan_update_pno_config(&scan_obj->pno_cfg, 1976 &scan_cfg->pno_cfg); 1977 1978 qdf_mem_copy(&scan_def->score_config, &scan_cfg->score_config, 1979 sizeof(struct scoring_config)); 1980 scm_validate_scoring_config(&scan_def->score_config); 1981 1982 return QDF_STATUS_SUCCESS; 1983 } 1984 1985 QDF_STATUS ucfg_scan_update_roam_params(struct wlan_objmgr_psoc *psoc, 1986 struct roam_filter_params *roam_params) 1987 { 1988 struct scan_default_params *scan_def; 1989 1990 if (!psoc) { 1991 scm_err("null psoc"); 1992 return QDF_STATUS_E_FAILURE; 1993 } 1994 scan_def = wlan_scan_psoc_get_def_params(psoc); 1995 if (!scan_def) { 1996 scm_err("Failed to get scan object"); 1997 return QDF_STATUS_E_FAILURE; 1998 } 1999 2000 qdf_mem_copy(&scan_def->roam_params, roam_params, 2001 sizeof(struct roam_filter_params)); 2002 2003 return QDF_STATUS_SUCCESS; 2004 } 2005 2006 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 2007 static QDF_STATUS 2008 ucfg_scan_cancel_pdev_scan(struct wlan_objmgr_pdev *pdev) 2009 { 2010 struct scan_cancel_request *req; 2011 QDF_STATUS status; 2012 struct wlan_objmgr_vdev *vdev; 2013 2014 req = qdf_mem_malloc_atomic(sizeof(*req)); 2015 if (!req) { 2016 scm_err("Failed to allocate memory"); 2017 return QDF_STATUS_E_NOMEM; 2018 } 2019 2020 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, 0, WLAN_OSIF_ID); 2021 if (!vdev) { 2022 scm_err("Failed to get vdev"); 2023 return QDF_STATUS_E_INVAL; 2024 } 2025 req->vdev = vdev; 2026 req->cancel_req.scan_id = INVAL_SCAN_ID; 2027 req->cancel_req.pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2028 req->cancel_req.vdev_id = INVAL_VDEV_ID; 2029 req->cancel_req.req_type = WLAN_SCAN_CANCEL_PDEV_ALL; 2030 status = ucfg_scan_cancel_sync(req); 2031 if (QDF_IS_STATUS_ERROR(status)) 2032 scm_err("Cancel scan request failed"); 2033 wlan_objmgr_vdev_release_ref(vdev, WLAN_OSIF_ID); 2034 2035 return status; 2036 } 2037 2038 static QDF_STATUS 2039 ucfg_scan_suspend_handler(struct wlan_objmgr_psoc *psoc, void *arg) 2040 { 2041 struct wlan_objmgr_pdev *pdev = NULL; 2042 QDF_STATUS status = QDF_STATUS_SUCCESS; 2043 int i; 2044 2045 /* Check all pdev */ 2046 for (i = 0; i < WLAN_UMAC_MAX_PDEVS; i++) { 2047 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, WLAN_SCAN_ID); 2048 if (!pdev) 2049 continue; 2050 if (ucfg_scan_get_pdev_status(pdev) != 2051 SCAN_NOT_IN_PROGRESS) 2052 status = ucfg_scan_cancel_pdev_scan(pdev); 2053 wlan_objmgr_pdev_release_ref(pdev, WLAN_SCAN_ID); 2054 if (QDF_IS_STATUS_ERROR(status)) { 2055 scm_err("failed to cancel scan for pdev_id %d", i); 2056 return status; 2057 } 2058 } 2059 2060 return QDF_STATUS_SUCCESS; 2061 } 2062 2063 static QDF_STATUS 2064 ucfg_scan_resume_handler(struct wlan_objmgr_psoc *psoc, void *arg) 2065 { 2066 return QDF_STATUS_SUCCESS; 2067 } 2068 2069 static inline void 2070 ucfg_scan_register_pmo_handler(void) 2071 { 2072 pmo_register_suspend_handler(WLAN_UMAC_COMP_SCAN, 2073 ucfg_scan_suspend_handler, NULL); 2074 pmo_register_resume_handler(WLAN_UMAC_COMP_SCAN, 2075 ucfg_scan_resume_handler, NULL); 2076 } 2077 2078 static inline void 2079 ucfg_scan_unregister_pmo_handler(void) 2080 { 2081 pmo_unregister_suspend_handler(WLAN_UMAC_COMP_SCAN, 2082 ucfg_scan_suspend_handler); 2083 pmo_unregister_resume_handler(WLAN_UMAC_COMP_SCAN, 2084 ucfg_scan_resume_handler); 2085 } 2086 2087 #else 2088 static inline void 2089 ucfg_scan_register_pmo_handler(void) 2090 { 2091 } 2092 2093 static inline void 2094 ucfg_scan_unregister_pmo_handler(void) 2095 { 2096 } 2097 #endif 2098 2099 QDF_STATUS 2100 ucfg_scan_psoc_open(struct wlan_objmgr_psoc *psoc) 2101 { 2102 struct wlan_scan_obj *scan_obj; 2103 2104 scm_debug("psoc open: 0x%pK", psoc); 2105 if (!psoc) { 2106 scm_err("null psoc"); 2107 return QDF_STATUS_E_FAILURE; 2108 } 2109 scan_obj = wlan_psoc_get_scan_obj(psoc); 2110 if (scan_obj == NULL) { 2111 scm_err("Failed to get scan object"); 2112 return QDF_STATUS_E_FAILURE; 2113 } 2114 /* Initialize the scan Globals */ 2115 wlan_scan_global_init(psoc, scan_obj); 2116 qdf_spinlock_create(&scan_obj->lock); 2117 ucfg_scan_register_pmo_handler(); 2118 scm_db_init(psoc); 2119 2120 return QDF_STATUS_SUCCESS; 2121 } 2122 2123 QDF_STATUS 2124 ucfg_scan_psoc_close(struct wlan_objmgr_psoc *psoc) 2125 { 2126 struct wlan_scan_obj *scan_obj; 2127 2128 scm_debug("psoc close: 0x%pK", psoc); 2129 if (!psoc) { 2130 scm_err("null psoc"); 2131 return QDF_STATUS_E_FAILURE; 2132 } 2133 scm_db_deinit(psoc); 2134 scan_obj = wlan_psoc_get_scan_obj(psoc); 2135 if (scan_obj == NULL) { 2136 scm_err("Failed to get scan object"); 2137 return QDF_STATUS_E_FAILURE; 2138 } 2139 ucfg_scan_unregister_pmo_handler(); 2140 qdf_spinlock_destroy(&scan_obj->lock); 2141 wlan_scan_global_deinit(psoc); 2142 2143 return QDF_STATUS_SUCCESS; 2144 } 2145 2146 static bool scm_serialization_scan_rules_cb( 2147 union wlan_serialization_rules_info *comp_info, 2148 uint8_t comp_id) 2149 { 2150 switch (comp_id) { 2151 case WLAN_UMAC_COMP_TDLS: 2152 if (comp_info->scan_info.is_tdls_in_progress) { 2153 scm_debug("Cancel scan. Tdls in progress"); 2154 return false; 2155 } 2156 break; 2157 case WLAN_UMAC_COMP_DFS: 2158 if (comp_info->scan_info.is_cac_in_progress) { 2159 scm_debug("Cancel scan. CAC in progress"); 2160 return false; 2161 } 2162 break; 2163 default: 2164 scm_debug("not handled comp_id %d", comp_id); 2165 break; 2166 } 2167 2168 return true; 2169 } 2170 2171 QDF_STATUS 2172 ucfg_scan_psoc_enable(struct wlan_objmgr_psoc *psoc) 2173 { 2174 QDF_STATUS status; 2175 2176 scm_debug("psoc enable: 0x%pK", psoc); 2177 if (!psoc) { 2178 scm_err("null psoc"); 2179 return QDF_STATUS_E_FAILURE; 2180 } 2181 /* Subscribe for scan events from lmac layesr */ 2182 status = tgt_scan_register_ev_handler(psoc); 2183 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 2184 if (!wlan_reg_is_11d_offloaded(psoc)) 2185 scm_11d_cc_db_init(psoc); 2186 ucfg_scan_register_unregister_bcn_cb(psoc, true); 2187 status = wlan_serialization_register_apply_rules_cb(psoc, 2188 WLAN_SER_CMD_SCAN, 2189 scm_serialization_scan_rules_cb); 2190 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 2191 return status; 2192 } 2193 2194 QDF_STATUS 2195 ucfg_scan_psoc_disable(struct wlan_objmgr_psoc *psoc) 2196 { 2197 QDF_STATUS status; 2198 2199 scm_debug("psoc disable: 0x%pK", psoc); 2200 if (!psoc) { 2201 scm_err("null psoc"); 2202 return QDF_STATUS_E_FAILURE; 2203 } 2204 /* Unsubscribe for scan events from lmac layesr */ 2205 status = tgt_scan_unregister_ev_handler(psoc); 2206 QDF_ASSERT(status == QDF_STATUS_SUCCESS); 2207 ucfg_scan_register_unregister_bcn_cb(psoc, false); 2208 if (!wlan_reg_is_11d_offloaded(psoc)) 2209 scm_11d_cc_db_deinit(psoc); 2210 2211 return status; 2212 } 2213 2214 uint32_t 2215 ucfg_scan_get_max_active_scans(struct wlan_objmgr_psoc *psoc) 2216 { 2217 struct scan_default_params *scan_params = NULL; 2218 2219 if (!psoc) { 2220 scm_err("null psoc"); 2221 return 0; 2222 } 2223 scan_params = wlan_scan_psoc_get_def_params(psoc); 2224 if (!scan_params) { 2225 scm_err("Failed to get scan object"); 2226 return 0; 2227 } 2228 2229 return scan_params->max_active_scans_allowed; 2230 } 2231 2232 bool ucfg_copy_ie_whitelist_attrs(struct wlan_objmgr_psoc *psoc, 2233 struct probe_req_whitelist_attr *ie_whitelist) 2234 { 2235 struct wlan_scan_obj *scan_obj = NULL; 2236 2237 scan_obj = wlan_psoc_get_scan_obj(psoc); 2238 if (!scan_obj) 2239 return false; 2240 2241 qdf_mem_copy(ie_whitelist, &scan_obj->ie_whitelist, 2242 sizeof(*ie_whitelist)); 2243 2244 return true; 2245 } 2246 2247 bool ucfg_ie_whitelist_enabled(struct wlan_objmgr_psoc *psoc, 2248 struct wlan_objmgr_vdev *vdev) 2249 { 2250 struct wlan_scan_obj *scan_obj = NULL; 2251 2252 scan_obj = wlan_psoc_get_scan_obj(psoc); 2253 if (!scan_obj) 2254 return false; 2255 2256 if ((wlan_vdev_mlme_get_opmode(vdev) != QDF_STA_MODE) || 2257 wlan_vdev_is_connected(vdev)) 2258 return false; 2259 2260 if (!scan_obj->ie_whitelist.white_list) 2261 return false; 2262 2263 return true; 2264 } 2265 2266 void ucfg_scan_set_bt_activity(struct wlan_objmgr_psoc *psoc, 2267 bool bt_a2dp_active) 2268 { 2269 struct wlan_scan_obj *scan_obj; 2270 2271 scan_obj = wlan_psoc_get_scan_obj(psoc); 2272 if (!scan_obj) { 2273 scm_err("Failed to get scan object"); 2274 return; 2275 } 2276 scan_obj->bt_a2dp_enabled = bt_a2dp_active; 2277 } 2278 2279 bool ucfg_scan_get_bt_activity(struct wlan_objmgr_psoc *psoc) 2280 { 2281 struct wlan_scan_obj *scan_obj; 2282 2283 scan_obj = wlan_psoc_get_scan_obj(psoc); 2284 if (!scan_obj) { 2285 scm_err("Failed to get scan object"); 2286 return false; 2287 } 2288 2289 return scan_obj->bt_a2dp_enabled; 2290 } 2291 2292 void ucfg_scan_set_vdev_del_in_progress(struct wlan_objmgr_vdev *vdev) 2293 { 2294 struct scan_vdev_obj *scan_vdev_obj; 2295 2296 if (!vdev) { 2297 scm_err("invalid vdev"); 2298 return; 2299 } 2300 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 2301 if (!scan_vdev_obj) { 2302 scm_err("null scan_vdev_obj"); 2303 return; 2304 } 2305 scan_vdev_obj->is_vdev_delete_in_progress = true; 2306 } 2307 2308 void ucfg_scan_clear_vdev_del_in_progress(struct wlan_objmgr_vdev *vdev) 2309 { 2310 struct scan_vdev_obj *scan_vdev_obj; 2311 2312 if (!vdev) { 2313 scm_err("invalid vdev"); 2314 return; 2315 } 2316 scan_vdev_obj = wlan_get_vdev_scan_obj(vdev); 2317 if (!scan_vdev_obj) { 2318 scm_err("null scan_vdev_obj"); 2319 return; 2320 } 2321 scan_vdev_obj->is_vdev_delete_in_progress = false; 2322 } 2323 2324 QDF_STATUS 2325 ucfg_scan_set_global_config(struct wlan_objmgr_psoc *psoc, 2326 enum scan_config config, uint32_t val) 2327 { 2328 struct wlan_scan_obj *scan_obj; 2329 QDF_STATUS status = QDF_STATUS_SUCCESS; 2330 2331 scan_obj = wlan_psoc_get_scan_obj(psoc); 2332 if (!scan_obj) { 2333 scm_err("Failed to get scan object config:%d, val:%d", 2334 config, val); 2335 return QDF_STATUS_E_INVAL; 2336 } 2337 switch (config) { 2338 case SCAN_CFG_DISABLE_SCAN_COMMAND_TIMEOUT: 2339 scan_obj->disable_timeout = !!val; 2340 break; 2341 case SCAN_CFG_DROP_BCN_ON_CHANNEL_MISMATCH: 2342 scan_obj->drop_bcn_on_chan_mismatch = !!val; 2343 break; 2344 2345 default: 2346 status = QDF_STATUS_E_INVAL; 2347 break; 2348 } 2349 2350 return status; 2351 } 2352 2353 QDF_STATUS ucfg_scan_update_mlme_by_bssinfo(struct wlan_objmgr_pdev *pdev, 2354 struct bss_info *bss_info, struct mlme_info *mlme) 2355 { 2356 QDF_STATUS status; 2357 2358 status = scm_scan_update_mlme_by_bssinfo(pdev, bss_info, mlme); 2359 2360 return status; 2361 } 2362 2363 QDF_STATUS 2364 ucfg_scan_get_global_config(struct wlan_objmgr_psoc *psoc, 2365 enum scan_config config, uint32_t *val) 2366 { 2367 struct wlan_scan_obj *scan_obj; 2368 QDF_STATUS status = QDF_STATUS_SUCCESS; 2369 2370 scan_obj = wlan_psoc_get_scan_obj(psoc); 2371 if (!scan_obj || !val) { 2372 scm_err("scan object:%pK config:%d, val:0x%pK", 2373 scan_obj, config, val); 2374 return QDF_STATUS_E_INVAL; 2375 } 2376 switch (config) { 2377 case SCAN_CFG_DISABLE_SCAN_COMMAND_TIMEOUT: 2378 *val = scan_obj->disable_timeout; 2379 break; 2380 case SCAN_CFG_DROP_BCN_ON_CHANNEL_MISMATCH: 2381 *val = scan_obj->drop_bcn_on_chan_mismatch; 2382 break; 2383 2384 default: 2385 status = QDF_STATUS_E_INVAL; 2386 break; 2387 } 2388 2389 return status; 2390 } 2391