1 /****************************************************************************** 2 * 3 * This file is provided under a dual BSD/GPLv2 license. When using or 4 * redistributing this file, you may do so under either license. 5 * 6 * GPL LICENSE SUMMARY 7 * 8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. 9 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH 10 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH 11 * Copyright(c) 2018 - 2019 Intel Corporation 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of version 2 of the GNU General Public License as 15 * published by the Free Software Foundation. 16 * 17 * This program is distributed in the hope that it will be useful, but 18 * WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * General Public License for more details. 21 * 22 * The full GNU General Public License is included in this distribution 23 * in the file called COPYING. 24 * 25 * Contact Information: 26 * Intel Linux Wireless <linuxwifi@intel.com> 27 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 28 * 29 * BSD LICENSE 30 * 31 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. 32 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH 33 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH 34 * Copyright(c) 2018 - 2019 Intel Corporation 35 * All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 41 * * Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * * Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in 45 * the documentation and/or other materials provided with the 46 * distribution. 47 * * Neither the name Intel Corporation nor the names of its 48 * contributors may be used to endorse or promote products derived 49 * from this software without specific prior written permission. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 52 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 53 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 54 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 55 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 56 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 57 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 58 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 59 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 60 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 61 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 62 * 63 *****************************************************************************/ 64 65 #include <linux/etherdevice.h> 66 #include <net/mac80211.h> 67 68 #include "mvm.h" 69 #include "fw/api/scan.h" 70 #include "iwl-io.h" 71 72 #define IWL_DENSE_EBS_SCAN_RATIO 5 73 #define IWL_SPARSE_EBS_SCAN_RATIO 1 74 75 #define IWL_SCAN_DWELL_ACTIVE 10 76 #define IWL_SCAN_DWELL_PASSIVE 110 77 #define IWL_SCAN_DWELL_FRAGMENTED 44 78 #define IWL_SCAN_DWELL_EXTENDED 90 79 #define IWL_SCAN_NUM_OF_FRAGS 3 80 #define IWL_SCAN_LAST_2_4_CHN 14 81 82 /* adaptive dwell max budget time [TU] for full scan */ 83 #define IWL_SCAN_ADWELL_MAX_BUDGET_FULL_SCAN 300 84 /* adaptive dwell max budget time [TU] for directed scan */ 85 #define IWL_SCAN_ADWELL_MAX_BUDGET_DIRECTED_SCAN 100 86 /* adaptive dwell default high band APs number */ 87 #define IWL_SCAN_ADWELL_DEFAULT_HB_N_APS 8 88 /* adaptive dwell default low band APs number */ 89 #define IWL_SCAN_ADWELL_DEFAULT_LB_N_APS 2 90 /* adaptive dwell default APs number in social channels (1, 6, 11) */ 91 #define IWL_SCAN_ADWELL_DEFAULT_N_APS_SOCIAL 10 92 /* number of scan channels */ 93 #define IWL_SCAN_NUM_CHANNELS 112 94 /* adaptive dwell number of APs override mask for p2p friendly GO */ 95 #define IWL_SCAN_ADWELL_N_APS_GO_FRIENDLY_BIT BIT(20) 96 /* adaptive dwell number of APs override mask for social channels */ 97 #define IWL_SCAN_ADWELL_N_APS_SOCIAL_CHS_BIT BIT(21) 98 /* adaptive dwell number of APs override for p2p friendly GO channels */ 99 #define IWL_SCAN_ADWELL_N_APS_GO_FRIENDLY 10 100 /* adaptive dwell number of APs override for social channels */ 101 #define IWL_SCAN_ADWELL_N_APS_SOCIAL_CHS 2 102 103 struct iwl_mvm_scan_timing_params { 104 u32 suspend_time; 105 u32 max_out_time; 106 }; 107 108 static struct iwl_mvm_scan_timing_params scan_timing[] = { 109 [IWL_SCAN_TYPE_UNASSOC] = { 110 .suspend_time = 0, 111 .max_out_time = 0, 112 }, 113 [IWL_SCAN_TYPE_WILD] = { 114 .suspend_time = 30, 115 .max_out_time = 120, 116 }, 117 [IWL_SCAN_TYPE_MILD] = { 118 .suspend_time = 120, 119 .max_out_time = 120, 120 }, 121 [IWL_SCAN_TYPE_FRAGMENTED] = { 122 .suspend_time = 95, 123 .max_out_time = 44, 124 }, 125 [IWL_SCAN_TYPE_FAST_BALANCE] = { 126 .suspend_time = 30, 127 .max_out_time = 37, 128 }, 129 }; 130 131 struct iwl_mvm_scan_params { 132 /* For CDB this is low band scan type, for non-CDB - type. */ 133 enum iwl_mvm_scan_type type; 134 enum iwl_mvm_scan_type hb_type; 135 u32 n_channels; 136 u16 delay; 137 int n_ssids; 138 struct cfg80211_ssid *ssids; 139 struct ieee80211_channel **channels; 140 u32 flags; 141 u8 *mac_addr; 142 u8 *mac_addr_mask; 143 bool no_cck; 144 bool pass_all; 145 int n_match_sets; 146 struct iwl_scan_probe_req preq; 147 struct cfg80211_match_set *match_sets; 148 int n_scan_plans; 149 struct cfg80211_sched_scan_plan *scan_plans; 150 u32 measurement_dwell; 151 }; 152 153 static inline void *iwl_mvm_get_scan_req_umac_data(struct iwl_mvm *mvm) 154 { 155 struct iwl_scan_req_umac *cmd = mvm->scan_cmd; 156 157 if (iwl_mvm_is_adaptive_dwell_v2_supported(mvm)) 158 return (void *)&cmd->v8.data; 159 160 if (iwl_mvm_is_adaptive_dwell_supported(mvm)) 161 return (void *)&cmd->v7.data; 162 163 if (iwl_mvm_cdb_scan_api(mvm)) 164 return (void *)&cmd->v6.data; 165 166 return (void *)&cmd->v1.data; 167 } 168 169 static inline struct iwl_scan_umac_chan_param * 170 iwl_mvm_get_scan_req_umac_channel(struct iwl_mvm *mvm) 171 { 172 struct iwl_scan_req_umac *cmd = mvm->scan_cmd; 173 174 if (iwl_mvm_is_adaptive_dwell_v2_supported(mvm)) 175 return &cmd->v8.channel; 176 177 if (iwl_mvm_is_adaptive_dwell_supported(mvm)) 178 return &cmd->v7.channel; 179 180 if (iwl_mvm_cdb_scan_api(mvm)) 181 return &cmd->v6.channel; 182 183 return &cmd->v1.channel; 184 } 185 186 static u8 iwl_mvm_scan_rx_ant(struct iwl_mvm *mvm) 187 { 188 if (mvm->scan_rx_ant != ANT_NONE) 189 return mvm->scan_rx_ant; 190 return iwl_mvm_get_valid_rx_ant(mvm); 191 } 192 193 static inline __le16 iwl_mvm_scan_rx_chain(struct iwl_mvm *mvm) 194 { 195 u16 rx_chain; 196 u8 rx_ant; 197 198 rx_ant = iwl_mvm_scan_rx_ant(mvm); 199 rx_chain = rx_ant << PHY_RX_CHAIN_VALID_POS; 200 rx_chain |= rx_ant << PHY_RX_CHAIN_FORCE_MIMO_SEL_POS; 201 rx_chain |= rx_ant << PHY_RX_CHAIN_FORCE_SEL_POS; 202 rx_chain |= 0x1 << PHY_RX_CHAIN_DRIVER_FORCE_POS; 203 return cpu_to_le16(rx_chain); 204 } 205 206 static inline __le32 207 iwl_mvm_scan_rate_n_flags(struct iwl_mvm *mvm, enum nl80211_band band, 208 bool no_cck) 209 { 210 u32 tx_ant; 211 212 iwl_mvm_toggle_tx_ant(mvm, &mvm->scan_last_antenna_idx); 213 tx_ant = BIT(mvm->scan_last_antenna_idx) << RATE_MCS_ANT_POS; 214 215 if (band == NL80211_BAND_2GHZ && !no_cck) 216 return cpu_to_le32(IWL_RATE_1M_PLCP | RATE_MCS_CCK_MSK | 217 tx_ant); 218 else 219 return cpu_to_le32(IWL_RATE_6M_PLCP | tx_ant); 220 } 221 222 static void iwl_mvm_scan_condition_iterator(void *data, u8 *mac, 223 struct ieee80211_vif *vif) 224 { 225 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 226 int *global_cnt = data; 227 228 if (vif->type != NL80211_IFTYPE_P2P_DEVICE && mvmvif->phy_ctxt && 229 mvmvif->phy_ctxt->id < NUM_PHY_CTX) 230 *global_cnt += 1; 231 } 232 233 static enum iwl_mvm_traffic_load iwl_mvm_get_traffic_load(struct iwl_mvm *mvm) 234 { 235 return mvm->tcm.result.global_load; 236 } 237 238 static enum iwl_mvm_traffic_load 239 iwl_mvm_get_traffic_load_band(struct iwl_mvm *mvm, enum nl80211_band band) 240 { 241 return mvm->tcm.result.band_load[band]; 242 } 243 244 struct iwl_is_dcm_with_go_iterator_data { 245 struct ieee80211_vif *current_vif; 246 bool is_dcm_with_p2p_go; 247 }; 248 249 static void iwl_mvm_is_dcm_with_go_iterator(void *_data, u8 *mac, 250 struct ieee80211_vif *vif) 251 { 252 struct iwl_is_dcm_with_go_iterator_data *data = _data; 253 struct iwl_mvm_vif *other_mvmvif = iwl_mvm_vif_from_mac80211(vif); 254 struct iwl_mvm_vif *curr_mvmvif = 255 iwl_mvm_vif_from_mac80211(data->current_vif); 256 257 /* exclude the given vif */ 258 if (vif == data->current_vif) 259 return; 260 261 if (vif->type == NL80211_IFTYPE_AP && vif->p2p && 262 other_mvmvif->phy_ctxt && curr_mvmvif->phy_ctxt && 263 other_mvmvif->phy_ctxt->id != curr_mvmvif->phy_ctxt->id) 264 data->is_dcm_with_p2p_go = true; 265 } 266 267 static enum 268 iwl_mvm_scan_type _iwl_mvm_get_scan_type(struct iwl_mvm *mvm, 269 struct ieee80211_vif *vif, 270 enum iwl_mvm_traffic_load load, 271 bool low_latency) 272 { 273 int global_cnt = 0; 274 275 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 276 IEEE80211_IFACE_ITER_NORMAL, 277 iwl_mvm_scan_condition_iterator, 278 &global_cnt); 279 if (!global_cnt) 280 return IWL_SCAN_TYPE_UNASSOC; 281 282 if (fw_has_api(&mvm->fw->ucode_capa, 283 IWL_UCODE_TLV_API_FRAGMENTED_SCAN)) { 284 if ((load == IWL_MVM_TRAFFIC_HIGH || low_latency) && 285 (!vif || vif->type != NL80211_IFTYPE_P2P_DEVICE)) 286 return IWL_SCAN_TYPE_FRAGMENTED; 287 288 /* in case of DCM with GO where BSS DTIM interval < 220msec 289 * set all scan requests as fast-balance scan 290 * */ 291 if (vif && vif->type == NL80211_IFTYPE_STATION && 292 vif->bss_conf.dtim_period < 220) { 293 struct iwl_is_dcm_with_go_iterator_data data = { 294 .current_vif = vif, 295 .is_dcm_with_p2p_go = false, 296 }; 297 298 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 299 IEEE80211_IFACE_ITER_NORMAL, 300 iwl_mvm_is_dcm_with_go_iterator, 301 &data); 302 if (data.is_dcm_with_p2p_go) 303 return IWL_SCAN_TYPE_FAST_BALANCE; 304 } 305 } 306 307 if (load >= IWL_MVM_TRAFFIC_MEDIUM || low_latency) 308 return IWL_SCAN_TYPE_MILD; 309 310 return IWL_SCAN_TYPE_WILD; 311 } 312 313 static enum 314 iwl_mvm_scan_type iwl_mvm_get_scan_type(struct iwl_mvm *mvm, 315 struct ieee80211_vif *vif) 316 { 317 enum iwl_mvm_traffic_load load; 318 bool low_latency; 319 320 load = iwl_mvm_get_traffic_load(mvm); 321 low_latency = iwl_mvm_low_latency(mvm); 322 323 return _iwl_mvm_get_scan_type(mvm, vif, load, low_latency); 324 } 325 326 static enum 327 iwl_mvm_scan_type iwl_mvm_get_scan_type_band(struct iwl_mvm *mvm, 328 struct ieee80211_vif *vif, 329 enum nl80211_band band) 330 { 331 enum iwl_mvm_traffic_load load; 332 bool low_latency; 333 334 load = iwl_mvm_get_traffic_load_band(mvm, band); 335 low_latency = iwl_mvm_low_latency_band(mvm, band); 336 337 return _iwl_mvm_get_scan_type(mvm, vif, load, low_latency); 338 } 339 340 static int 341 iwl_mvm_get_measurement_dwell(struct iwl_mvm *mvm, 342 struct cfg80211_scan_request *req, 343 struct iwl_mvm_scan_params *params) 344 { 345 u32 duration = scan_timing[params->type].max_out_time; 346 347 if (!req->duration) 348 return 0; 349 350 if (iwl_mvm_is_cdb_supported(mvm)) { 351 u32 hb_time = scan_timing[params->hb_type].max_out_time; 352 353 duration = min_t(u32, duration, hb_time); 354 } 355 356 if (req->duration_mandatory && req->duration > duration) { 357 IWL_DEBUG_SCAN(mvm, 358 "Measurement scan - too long dwell %hu (max out time %u)\n", 359 req->duration, 360 duration); 361 return -EOPNOTSUPP; 362 } 363 364 return min_t(u32, (u32)req->duration, duration); 365 } 366 367 static inline bool iwl_mvm_rrm_scan_needed(struct iwl_mvm *mvm) 368 { 369 /* require rrm scan whenever the fw supports it */ 370 return fw_has_capa(&mvm->fw->ucode_capa, 371 IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT); 372 } 373 374 static int iwl_mvm_max_scan_ie_fw_cmd_room(struct iwl_mvm *mvm) 375 { 376 int max_probe_len; 377 378 max_probe_len = SCAN_OFFLOAD_PROBE_REQ_SIZE; 379 380 /* we create the 802.11 header and SSID element */ 381 max_probe_len -= 24 + 2; 382 383 /* DS parameter set element is added on 2.4GHZ band if required */ 384 if (iwl_mvm_rrm_scan_needed(mvm)) 385 max_probe_len -= 3; 386 387 return max_probe_len; 388 } 389 390 int iwl_mvm_max_scan_ie_len(struct iwl_mvm *mvm) 391 { 392 int max_ie_len = iwl_mvm_max_scan_ie_fw_cmd_room(mvm); 393 394 /* TODO: [BUG] This function should return the maximum allowed size of 395 * scan IEs, however the LMAC scan api contains both 2GHZ and 5GHZ IEs 396 * in the same command. So the correct implementation of this function 397 * is just iwl_mvm_max_scan_ie_fw_cmd_room() / 2. Currently the scan 398 * command has only 512 bytes and it would leave us with about 240 399 * bytes for scan IEs, which is clearly not enough. So meanwhile 400 * we will report an incorrect value. This may result in a failure to 401 * issue a scan in unified_scan_lmac and unified_sched_scan_lmac 402 * functions with -ENOBUFS, if a large enough probe will be provided. 403 */ 404 return max_ie_len; 405 } 406 407 void iwl_mvm_rx_lmac_scan_iter_complete_notif(struct iwl_mvm *mvm, 408 struct iwl_rx_cmd_buffer *rxb) 409 { 410 struct iwl_rx_packet *pkt = rxb_addr(rxb); 411 struct iwl_lmac_scan_complete_notif *notif = (void *)pkt->data; 412 413 IWL_DEBUG_SCAN(mvm, 414 "Scan offload iteration complete: status=0x%x scanned channels=%d\n", 415 notif->status, notif->scanned_channels); 416 417 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_FOUND) { 418 IWL_DEBUG_SCAN(mvm, "Pass all scheduled scan results found\n"); 419 ieee80211_sched_scan_results(mvm->hw); 420 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_ENABLED; 421 } 422 } 423 424 void iwl_mvm_rx_scan_match_found(struct iwl_mvm *mvm, 425 struct iwl_rx_cmd_buffer *rxb) 426 { 427 IWL_DEBUG_SCAN(mvm, "Scheduled scan results\n"); 428 ieee80211_sched_scan_results(mvm->hw); 429 } 430 431 static const char *iwl_mvm_ebs_status_str(enum iwl_scan_ebs_status status) 432 { 433 switch (status) { 434 case IWL_SCAN_EBS_SUCCESS: 435 return "successful"; 436 case IWL_SCAN_EBS_INACTIVE: 437 return "inactive"; 438 case IWL_SCAN_EBS_FAILED: 439 case IWL_SCAN_EBS_CHAN_NOT_FOUND: 440 default: 441 return "failed"; 442 } 443 } 444 445 void iwl_mvm_rx_lmac_scan_complete_notif(struct iwl_mvm *mvm, 446 struct iwl_rx_cmd_buffer *rxb) 447 { 448 struct iwl_rx_packet *pkt = rxb_addr(rxb); 449 struct iwl_periodic_scan_complete *scan_notif = (void *)pkt->data; 450 bool aborted = (scan_notif->status == IWL_SCAN_OFFLOAD_ABORTED); 451 452 /* If this happens, the firmware has mistakenly sent an LMAC 453 * notification during UMAC scans -- warn and ignore it. 454 */ 455 if (WARN_ON_ONCE(fw_has_capa(&mvm->fw->ucode_capa, 456 IWL_UCODE_TLV_CAPA_UMAC_SCAN))) 457 return; 458 459 /* scan status must be locked for proper checking */ 460 lockdep_assert_held(&mvm->mutex); 461 462 /* We first check if we were stopping a scan, in which case we 463 * just clear the stopping flag. Then we check if it was a 464 * firmware initiated stop, in which case we need to inform 465 * mac80211. 466 * Note that we can have a stopping and a running scan 467 * simultaneously, but we can't have two different types of 468 * scans stopping or running at the same time (since LMAC 469 * doesn't support it). 470 */ 471 472 if (mvm->scan_status & IWL_MVM_SCAN_STOPPING_SCHED) { 473 WARN_ON_ONCE(mvm->scan_status & IWL_MVM_SCAN_STOPPING_REGULAR); 474 475 IWL_DEBUG_SCAN(mvm, "Scheduled scan %s, EBS status %s\n", 476 aborted ? "aborted" : "completed", 477 iwl_mvm_ebs_status_str(scan_notif->ebs_status)); 478 IWL_DEBUG_SCAN(mvm, 479 "Last line %d, Last iteration %d, Time after last iteration %d\n", 480 scan_notif->last_schedule_line, 481 scan_notif->last_schedule_iteration, 482 __le32_to_cpu(scan_notif->time_after_last_iter)); 483 484 mvm->scan_status &= ~IWL_MVM_SCAN_STOPPING_SCHED; 485 } else if (mvm->scan_status & IWL_MVM_SCAN_STOPPING_REGULAR) { 486 IWL_DEBUG_SCAN(mvm, "Regular scan %s, EBS status %s\n", 487 aborted ? "aborted" : "completed", 488 iwl_mvm_ebs_status_str(scan_notif->ebs_status)); 489 490 mvm->scan_status &= ~IWL_MVM_SCAN_STOPPING_REGULAR; 491 } else if (mvm->scan_status & IWL_MVM_SCAN_SCHED) { 492 WARN_ON_ONCE(mvm->scan_status & IWL_MVM_SCAN_REGULAR); 493 494 IWL_DEBUG_SCAN(mvm, "Scheduled scan %s, EBS status %s\n", 495 aborted ? "aborted" : "completed", 496 iwl_mvm_ebs_status_str(scan_notif->ebs_status)); 497 IWL_DEBUG_SCAN(mvm, 498 "Last line %d, Last iteration %d, Time after last iteration %d (FW)\n", 499 scan_notif->last_schedule_line, 500 scan_notif->last_schedule_iteration, 501 __le32_to_cpu(scan_notif->time_after_last_iter)); 502 503 mvm->scan_status &= ~IWL_MVM_SCAN_SCHED; 504 ieee80211_sched_scan_stopped(mvm->hw); 505 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED; 506 } else if (mvm->scan_status & IWL_MVM_SCAN_REGULAR) { 507 struct cfg80211_scan_info info = { 508 .aborted = aborted, 509 }; 510 511 IWL_DEBUG_SCAN(mvm, "Regular scan %s, EBS status %s (FW)\n", 512 aborted ? "aborted" : "completed", 513 iwl_mvm_ebs_status_str(scan_notif->ebs_status)); 514 515 mvm->scan_status &= ~IWL_MVM_SCAN_REGULAR; 516 ieee80211_scan_completed(mvm->hw, &info); 517 cancel_delayed_work(&mvm->scan_timeout_dwork); 518 iwl_mvm_resume_tcm(mvm); 519 } else { 520 IWL_ERR(mvm, 521 "got scan complete notification but no scan is running\n"); 522 } 523 524 mvm->last_ebs_successful = 525 scan_notif->ebs_status == IWL_SCAN_EBS_SUCCESS || 526 scan_notif->ebs_status == IWL_SCAN_EBS_INACTIVE; 527 } 528 529 static int iwl_ssid_exist(u8 *ssid, u8 ssid_len, struct iwl_ssid_ie *ssid_list) 530 { 531 int i; 532 533 for (i = 0; i < PROBE_OPTION_MAX; i++) { 534 if (!ssid_list[i].len) 535 break; 536 if (ssid_list[i].len == ssid_len && 537 !memcmp(ssid_list->ssid, ssid, ssid_len)) 538 return i; 539 } 540 return -1; 541 } 542 543 /* We insert the SSIDs in an inverted order, because the FW will 544 * invert it back. 545 */ 546 static void iwl_scan_build_ssids(struct iwl_mvm_scan_params *params, 547 struct iwl_ssid_ie *ssids, 548 u32 *ssid_bitmap) 549 { 550 int i, j; 551 int index; 552 u32 tmp_bitmap = 0; 553 554 /* 555 * copy SSIDs from match list. 556 * iwl_config_sched_scan_profiles() uses the order of these ssids to 557 * config match list. 558 */ 559 for (i = 0, j = params->n_match_sets - 1; 560 j >= 0 && i < PROBE_OPTION_MAX; 561 i++, j--) { 562 /* skip empty SSID matchsets */ 563 if (!params->match_sets[j].ssid.ssid_len) 564 continue; 565 ssids[i].id = WLAN_EID_SSID; 566 ssids[i].len = params->match_sets[j].ssid.ssid_len; 567 memcpy(ssids[i].ssid, params->match_sets[j].ssid.ssid, 568 ssids[i].len); 569 } 570 571 /* add SSIDs from scan SSID list */ 572 for (j = params->n_ssids - 1; 573 j >= 0 && i < PROBE_OPTION_MAX; 574 i++, j--) { 575 index = iwl_ssid_exist(params->ssids[j].ssid, 576 params->ssids[j].ssid_len, 577 ssids); 578 if (index < 0) { 579 ssids[i].id = WLAN_EID_SSID; 580 ssids[i].len = params->ssids[j].ssid_len; 581 memcpy(ssids[i].ssid, params->ssids[j].ssid, 582 ssids[i].len); 583 tmp_bitmap |= BIT(i); 584 } else { 585 tmp_bitmap |= BIT(index); 586 } 587 } 588 if (ssid_bitmap) 589 *ssid_bitmap = tmp_bitmap; 590 } 591 592 static int 593 iwl_mvm_config_sched_scan_profiles(struct iwl_mvm *mvm, 594 struct cfg80211_sched_scan_request *req) 595 { 596 struct iwl_scan_offload_profile *profile; 597 struct iwl_scan_offload_profile_cfg_v1 *profile_cfg_v1; 598 struct iwl_scan_offload_blacklist *blacklist; 599 struct iwl_scan_offload_profile_cfg_data *data; 600 int max_profiles = iwl_umac_scan_get_max_profiles(mvm->fw); 601 int profile_cfg_size = sizeof(*data) + 602 sizeof(*profile) * max_profiles; 603 struct iwl_host_cmd cmd = { 604 .id = SCAN_OFFLOAD_UPDATE_PROFILES_CMD, 605 .len[1] = profile_cfg_size, 606 .dataflags[0] = IWL_HCMD_DFL_NOCOPY, 607 .dataflags[1] = IWL_HCMD_DFL_NOCOPY, 608 }; 609 int blacklist_len; 610 int i; 611 int ret; 612 613 if (WARN_ON(req->n_match_sets > max_profiles)) 614 return -EIO; 615 616 if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_SHORT_BL) 617 blacklist_len = IWL_SCAN_SHORT_BLACKLIST_LEN; 618 else 619 blacklist_len = IWL_SCAN_MAX_BLACKLIST_LEN; 620 621 blacklist = kcalloc(blacklist_len, sizeof(*blacklist), GFP_KERNEL); 622 if (!blacklist) 623 return -ENOMEM; 624 625 profile_cfg_v1 = kzalloc(profile_cfg_size, GFP_KERNEL); 626 if (!profile_cfg_v1) { 627 ret = -ENOMEM; 628 goto free_blacklist; 629 } 630 631 cmd.data[0] = blacklist; 632 cmd.len[0] = sizeof(*blacklist) * blacklist_len; 633 cmd.data[1] = profile_cfg_v1; 634 635 /* if max_profile is MAX_PROFILES_V2, we have the new API */ 636 if (max_profiles == IWL_SCAN_MAX_PROFILES_V2) { 637 struct iwl_scan_offload_profile_cfg *profile_cfg = 638 (struct iwl_scan_offload_profile_cfg *)profile_cfg_v1; 639 640 data = &profile_cfg->data; 641 } else { 642 data = &profile_cfg_v1->data; 643 } 644 645 /* No blacklist configuration */ 646 data->num_profiles = req->n_match_sets; 647 data->active_clients = SCAN_CLIENT_SCHED_SCAN; 648 data->pass_match = SCAN_CLIENT_SCHED_SCAN; 649 data->match_notify = SCAN_CLIENT_SCHED_SCAN; 650 651 if (!req->n_match_sets || !req->match_sets[0].ssid.ssid_len) 652 data->any_beacon_notify = SCAN_CLIENT_SCHED_SCAN; 653 654 for (i = 0; i < req->n_match_sets; i++) { 655 profile = &profile_cfg_v1->profiles[i]; 656 profile->ssid_index = i; 657 /* Support any cipher and auth algorithm */ 658 profile->unicast_cipher = 0xff; 659 profile->auth_alg = 0xff; 660 profile->network_type = IWL_NETWORK_TYPE_ANY; 661 profile->band_selection = IWL_SCAN_OFFLOAD_SELECT_ANY; 662 profile->client_bitmap = SCAN_CLIENT_SCHED_SCAN; 663 } 664 665 IWL_DEBUG_SCAN(mvm, "Sending scheduled scan profile config\n"); 666 667 ret = iwl_mvm_send_cmd(mvm, &cmd); 668 kfree(profile_cfg_v1); 669 free_blacklist: 670 kfree(blacklist); 671 672 return ret; 673 } 674 675 static bool iwl_mvm_scan_pass_all(struct iwl_mvm *mvm, 676 struct cfg80211_sched_scan_request *req) 677 { 678 if (req->n_match_sets && req->match_sets[0].ssid.ssid_len) { 679 IWL_DEBUG_SCAN(mvm, 680 "Sending scheduled scan with filtering, n_match_sets %d\n", 681 req->n_match_sets); 682 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED; 683 return false; 684 } 685 686 IWL_DEBUG_SCAN(mvm, "Sending Scheduled scan without filtering\n"); 687 688 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_ENABLED; 689 return true; 690 } 691 692 static int iwl_mvm_lmac_scan_abort(struct iwl_mvm *mvm) 693 { 694 int ret; 695 struct iwl_host_cmd cmd = { 696 .id = SCAN_OFFLOAD_ABORT_CMD, 697 }; 698 u32 status = CAN_ABORT_STATUS; 699 700 ret = iwl_mvm_send_cmd_status(mvm, &cmd, &status); 701 if (ret) 702 return ret; 703 704 if (status != CAN_ABORT_STATUS) { 705 /* 706 * The scan abort will return 1 for success or 707 * 2 for "failure". A failure condition can be 708 * due to simply not being in an active scan which 709 * can occur if we send the scan abort before the 710 * microcode has notified us that a scan is completed. 711 */ 712 IWL_DEBUG_SCAN(mvm, "SCAN OFFLOAD ABORT ret %d.\n", status); 713 ret = -ENOENT; 714 } 715 716 return ret; 717 } 718 719 static void iwl_mvm_scan_fill_tx_cmd(struct iwl_mvm *mvm, 720 struct iwl_scan_req_tx_cmd *tx_cmd, 721 bool no_cck) 722 { 723 tx_cmd[0].tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL | 724 TX_CMD_FLG_BT_DIS); 725 tx_cmd[0].rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm, 726 NL80211_BAND_2GHZ, 727 no_cck); 728 tx_cmd[0].sta_id = mvm->aux_sta.sta_id; 729 730 tx_cmd[1].tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL | 731 TX_CMD_FLG_BT_DIS); 732 tx_cmd[1].rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm, 733 NL80211_BAND_5GHZ, 734 no_cck); 735 tx_cmd[1].sta_id = mvm->aux_sta.sta_id; 736 } 737 738 static void 739 iwl_mvm_lmac_scan_cfg_channels(struct iwl_mvm *mvm, 740 struct ieee80211_channel **channels, 741 int n_channels, u32 ssid_bitmap, 742 struct iwl_scan_req_lmac *cmd) 743 { 744 struct iwl_scan_channel_cfg_lmac *channel_cfg = (void *)&cmd->data; 745 int i; 746 747 for (i = 0; i < n_channels; i++) { 748 channel_cfg[i].channel_num = 749 cpu_to_le16(channels[i]->hw_value); 750 channel_cfg[i].iter_count = cpu_to_le16(1); 751 channel_cfg[i].iter_interval = 0; 752 channel_cfg[i].flags = 753 cpu_to_le32(IWL_UNIFIED_SCAN_CHANNEL_PARTIAL | 754 ssid_bitmap); 755 } 756 } 757 758 static u8 *iwl_mvm_copy_and_insert_ds_elem(struct iwl_mvm *mvm, const u8 *ies, 759 size_t len, u8 *const pos) 760 { 761 static const u8 before_ds_params[] = { 762 WLAN_EID_SSID, 763 WLAN_EID_SUPP_RATES, 764 WLAN_EID_REQUEST, 765 WLAN_EID_EXT_SUPP_RATES, 766 }; 767 size_t offs; 768 u8 *newpos = pos; 769 770 if (!iwl_mvm_rrm_scan_needed(mvm)) { 771 memcpy(newpos, ies, len); 772 return newpos + len; 773 } 774 775 offs = ieee80211_ie_split(ies, len, 776 before_ds_params, 777 ARRAY_SIZE(before_ds_params), 778 0); 779 780 memcpy(newpos, ies, offs); 781 newpos += offs; 782 783 /* Add a placeholder for DS Parameter Set element */ 784 *newpos++ = WLAN_EID_DS_PARAMS; 785 *newpos++ = 1; 786 *newpos++ = 0; 787 788 memcpy(newpos, ies + offs, len - offs); 789 newpos += len - offs; 790 791 return newpos; 792 } 793 794 #define WFA_TPC_IE_LEN 9 795 796 static void iwl_mvm_add_tpc_report_ie(u8 *pos) 797 { 798 pos[0] = WLAN_EID_VENDOR_SPECIFIC; 799 pos[1] = WFA_TPC_IE_LEN - 2; 800 pos[2] = (WLAN_OUI_MICROSOFT >> 16) & 0xff; 801 pos[3] = (WLAN_OUI_MICROSOFT >> 8) & 0xff; 802 pos[4] = WLAN_OUI_MICROSOFT & 0xff; 803 pos[5] = WLAN_OUI_TYPE_MICROSOFT_TPC; 804 pos[6] = 0; 805 /* pos[7] - tx power will be inserted by the FW */ 806 pos[7] = 0; 807 pos[8] = 0; 808 } 809 810 static void 811 iwl_mvm_build_scan_probe(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 812 struct ieee80211_scan_ies *ies, 813 struct iwl_mvm_scan_params *params) 814 { 815 struct ieee80211_mgmt *frame = (void *)params->preq.buf; 816 u8 *pos, *newpos; 817 const u8 *mac_addr = params->flags & NL80211_SCAN_FLAG_RANDOM_ADDR ? 818 params->mac_addr : NULL; 819 820 /* 821 * Unfortunately, right now the offload scan doesn't support randomising 822 * within the firmware, so until the firmware API is ready we implement 823 * it in the driver. This means that the scan iterations won't really be 824 * random, only when it's restarted, but at least that helps a bit. 825 */ 826 if (mac_addr) 827 get_random_mask_addr(frame->sa, mac_addr, 828 params->mac_addr_mask); 829 else 830 memcpy(frame->sa, vif->addr, ETH_ALEN); 831 832 frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ); 833 eth_broadcast_addr(frame->da); 834 eth_broadcast_addr(frame->bssid); 835 frame->seq_ctrl = 0; 836 837 pos = frame->u.probe_req.variable; 838 *pos++ = WLAN_EID_SSID; 839 *pos++ = 0; 840 841 params->preq.mac_header.offset = 0; 842 params->preq.mac_header.len = cpu_to_le16(24 + 2); 843 844 /* Insert ds parameter set element on 2.4 GHz band */ 845 newpos = iwl_mvm_copy_and_insert_ds_elem(mvm, 846 ies->ies[NL80211_BAND_2GHZ], 847 ies->len[NL80211_BAND_2GHZ], 848 pos); 849 params->preq.band_data[0].offset = cpu_to_le16(pos - params->preq.buf); 850 params->preq.band_data[0].len = cpu_to_le16(newpos - pos); 851 pos = newpos; 852 853 memcpy(pos, ies->ies[NL80211_BAND_5GHZ], 854 ies->len[NL80211_BAND_5GHZ]); 855 params->preq.band_data[1].offset = cpu_to_le16(pos - params->preq.buf); 856 params->preq.band_data[1].len = 857 cpu_to_le16(ies->len[NL80211_BAND_5GHZ]); 858 pos += ies->len[NL80211_BAND_5GHZ]; 859 860 memcpy(pos, ies->common_ies, ies->common_ie_len); 861 params->preq.common_data.offset = cpu_to_le16(pos - params->preq.buf); 862 863 if (iwl_mvm_rrm_scan_needed(mvm) && 864 !fw_has_capa(&mvm->fw->ucode_capa, 865 IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT)) { 866 iwl_mvm_add_tpc_report_ie(pos + ies->common_ie_len); 867 params->preq.common_data.len = cpu_to_le16(ies->common_ie_len + 868 WFA_TPC_IE_LEN); 869 } else { 870 params->preq.common_data.len = cpu_to_le16(ies->common_ie_len); 871 } 872 } 873 874 static void iwl_mvm_scan_lmac_dwell(struct iwl_mvm *mvm, 875 struct iwl_scan_req_lmac *cmd, 876 struct iwl_mvm_scan_params *params) 877 { 878 cmd->active_dwell = IWL_SCAN_DWELL_ACTIVE; 879 cmd->passive_dwell = IWL_SCAN_DWELL_PASSIVE; 880 cmd->fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED; 881 cmd->extended_dwell = IWL_SCAN_DWELL_EXTENDED; 882 cmd->max_out_time = cpu_to_le32(scan_timing[params->type].max_out_time); 883 cmd->suspend_time = cpu_to_le32(scan_timing[params->type].suspend_time); 884 cmd->scan_prio = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); 885 } 886 887 static inline bool iwl_mvm_scan_fits(struct iwl_mvm *mvm, int n_ssids, 888 struct ieee80211_scan_ies *ies, 889 int n_channels) 890 { 891 return ((n_ssids <= PROBE_OPTION_MAX) && 892 (n_channels <= mvm->fw->ucode_capa.n_scan_channels) & 893 (ies->common_ie_len + 894 ies->len[NL80211_BAND_2GHZ] + 895 ies->len[NL80211_BAND_5GHZ] <= 896 iwl_mvm_max_scan_ie_fw_cmd_room(mvm))); 897 } 898 899 static inline bool iwl_mvm_scan_use_ebs(struct iwl_mvm *mvm, 900 struct ieee80211_vif *vif) 901 { 902 const struct iwl_ucode_capabilities *capa = &mvm->fw->ucode_capa; 903 bool low_latency; 904 905 if (iwl_mvm_is_cdb_supported(mvm)) 906 low_latency = iwl_mvm_low_latency_band(mvm, NL80211_BAND_5GHZ); 907 else 908 low_latency = iwl_mvm_low_latency(mvm); 909 910 /* We can only use EBS if: 911 * 1. the feature is supported; 912 * 2. the last EBS was successful; 913 * 3. if only single scan, the single scan EBS API is supported; 914 * 4. it's not a p2p find operation. 915 * 5. we are not in low latency mode, 916 * or if fragmented ebs is supported by the FW 917 */ 918 return ((capa->flags & IWL_UCODE_TLV_FLAGS_EBS_SUPPORT) && 919 mvm->last_ebs_successful && IWL_MVM_ENABLE_EBS && 920 vif->type != NL80211_IFTYPE_P2P_DEVICE && 921 (!low_latency || iwl_mvm_is_frag_ebs_supported(mvm))); 922 } 923 924 static inline bool iwl_mvm_is_regular_scan(struct iwl_mvm_scan_params *params) 925 { 926 return params->n_scan_plans == 1 && 927 params->scan_plans[0].iterations == 1; 928 } 929 930 static bool iwl_mvm_is_scan_fragmented(enum iwl_mvm_scan_type type) 931 { 932 return (type == IWL_SCAN_TYPE_FRAGMENTED || 933 type == IWL_SCAN_TYPE_FAST_BALANCE); 934 } 935 936 static int iwl_mvm_scan_lmac_flags(struct iwl_mvm *mvm, 937 struct iwl_mvm_scan_params *params, 938 struct ieee80211_vif *vif) 939 { 940 int flags = 0; 941 942 if (params->n_ssids == 0) 943 flags |= IWL_MVM_LMAC_SCAN_FLAG_PASSIVE; 944 945 if (params->n_ssids == 1 && params->ssids[0].ssid_len != 0) 946 flags |= IWL_MVM_LMAC_SCAN_FLAG_PRE_CONNECTION; 947 948 if (iwl_mvm_is_scan_fragmented(params->type)) 949 flags |= IWL_MVM_LMAC_SCAN_FLAG_FRAGMENTED; 950 951 if (iwl_mvm_rrm_scan_needed(mvm) && 952 fw_has_capa(&mvm->fw->ucode_capa, 953 IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT)) 954 flags |= IWL_MVM_LMAC_SCAN_FLAGS_RRM_ENABLED; 955 956 if (params->pass_all) 957 flags |= IWL_MVM_LMAC_SCAN_FLAG_PASS_ALL; 958 else 959 flags |= IWL_MVM_LMAC_SCAN_FLAG_MATCH; 960 961 #ifdef CONFIG_IWLWIFI_DEBUGFS 962 if (mvm->scan_iter_notif_enabled) 963 flags |= IWL_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE; 964 #endif 965 966 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_ENABLED) 967 flags |= IWL_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE; 968 969 if (iwl_mvm_is_regular_scan(params) && 970 vif->type != NL80211_IFTYPE_P2P_DEVICE && 971 !iwl_mvm_is_scan_fragmented(params->type)) 972 flags |= IWL_MVM_LMAC_SCAN_FLAG_EXTENDED_DWELL; 973 974 return flags; 975 } 976 977 static void 978 iwl_mvm_scan_set_legacy_probe_req(struct iwl_scan_probe_req_v1 *p_req, 979 struct iwl_scan_probe_req *src_p_req) 980 { 981 int i; 982 983 p_req->mac_header = src_p_req->mac_header; 984 for (i = 0; i < SCAN_NUM_BAND_PROBE_DATA_V_1; i++) 985 p_req->band_data[i] = src_p_req->band_data[i]; 986 p_req->common_data = src_p_req->common_data; 987 memcpy(p_req->buf, src_p_req->buf, sizeof(p_req->buf)); 988 } 989 990 static int iwl_mvm_scan_lmac(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 991 struct iwl_mvm_scan_params *params) 992 { 993 struct iwl_scan_req_lmac *cmd = mvm->scan_cmd; 994 struct iwl_scan_probe_req_v1 *preq = 995 (void *)(cmd->data + sizeof(struct iwl_scan_channel_cfg_lmac) * 996 mvm->fw->ucode_capa.n_scan_channels); 997 u32 ssid_bitmap = 0; 998 int i; 999 u8 band; 1000 1001 if (WARN_ON(params->n_scan_plans > IWL_MAX_SCHED_SCAN_PLANS)) 1002 return -EINVAL; 1003 1004 iwl_mvm_scan_lmac_dwell(mvm, cmd, params); 1005 1006 cmd->rx_chain_select = iwl_mvm_scan_rx_chain(mvm); 1007 cmd->iter_num = cpu_to_le32(1); 1008 cmd->n_channels = (u8)params->n_channels; 1009 1010 cmd->delay = cpu_to_le32(params->delay); 1011 1012 cmd->scan_flags = cpu_to_le32(iwl_mvm_scan_lmac_flags(mvm, params, 1013 vif)); 1014 1015 band = iwl_mvm_phy_band_from_nl80211(params->channels[0]->band); 1016 cmd->flags = cpu_to_le32(band); 1017 cmd->filter_flags = cpu_to_le32(MAC_FILTER_ACCEPT_GRP | 1018 MAC_FILTER_IN_BEACON); 1019 iwl_mvm_scan_fill_tx_cmd(mvm, cmd->tx_cmd, params->no_cck); 1020 iwl_scan_build_ssids(params, cmd->direct_scan, &ssid_bitmap); 1021 1022 /* this API uses bits 1-20 instead of 0-19 */ 1023 ssid_bitmap <<= 1; 1024 1025 for (i = 0; i < params->n_scan_plans; i++) { 1026 struct cfg80211_sched_scan_plan *scan_plan = 1027 ¶ms->scan_plans[i]; 1028 1029 cmd->schedule[i].delay = 1030 cpu_to_le16(scan_plan->interval); 1031 cmd->schedule[i].iterations = scan_plan->iterations; 1032 cmd->schedule[i].full_scan_mul = 1; 1033 } 1034 1035 /* 1036 * If the number of iterations of the last scan plan is set to 1037 * zero, it should run infinitely. However, this is not always the case. 1038 * For example, when regular scan is requested the driver sets one scan 1039 * plan with one iteration. 1040 */ 1041 if (!cmd->schedule[i - 1].iterations) 1042 cmd->schedule[i - 1].iterations = 0xff; 1043 1044 if (iwl_mvm_scan_use_ebs(mvm, vif)) { 1045 cmd->channel_opt[0].flags = 1046 cpu_to_le16(IWL_SCAN_CHANNEL_FLAG_EBS | 1047 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE | 1048 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD); 1049 cmd->channel_opt[0].non_ebs_ratio = 1050 cpu_to_le16(IWL_DENSE_EBS_SCAN_RATIO); 1051 cmd->channel_opt[1].flags = 1052 cpu_to_le16(IWL_SCAN_CHANNEL_FLAG_EBS | 1053 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE | 1054 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD); 1055 cmd->channel_opt[1].non_ebs_ratio = 1056 cpu_to_le16(IWL_SPARSE_EBS_SCAN_RATIO); 1057 } 1058 1059 iwl_mvm_lmac_scan_cfg_channels(mvm, params->channels, 1060 params->n_channels, ssid_bitmap, cmd); 1061 1062 iwl_mvm_scan_set_legacy_probe_req(preq, ¶ms->preq); 1063 1064 return 0; 1065 } 1066 1067 static int rate_to_scan_rate_flag(unsigned int rate) 1068 { 1069 static const int rate_to_scan_rate[IWL_RATE_COUNT] = { 1070 [IWL_RATE_1M_INDEX] = SCAN_CONFIG_RATE_1M, 1071 [IWL_RATE_2M_INDEX] = SCAN_CONFIG_RATE_2M, 1072 [IWL_RATE_5M_INDEX] = SCAN_CONFIG_RATE_5M, 1073 [IWL_RATE_11M_INDEX] = SCAN_CONFIG_RATE_11M, 1074 [IWL_RATE_6M_INDEX] = SCAN_CONFIG_RATE_6M, 1075 [IWL_RATE_9M_INDEX] = SCAN_CONFIG_RATE_9M, 1076 [IWL_RATE_12M_INDEX] = SCAN_CONFIG_RATE_12M, 1077 [IWL_RATE_18M_INDEX] = SCAN_CONFIG_RATE_18M, 1078 [IWL_RATE_24M_INDEX] = SCAN_CONFIG_RATE_24M, 1079 [IWL_RATE_36M_INDEX] = SCAN_CONFIG_RATE_36M, 1080 [IWL_RATE_48M_INDEX] = SCAN_CONFIG_RATE_48M, 1081 [IWL_RATE_54M_INDEX] = SCAN_CONFIG_RATE_54M, 1082 }; 1083 1084 return rate_to_scan_rate[rate]; 1085 } 1086 1087 static __le32 iwl_mvm_scan_config_rates(struct iwl_mvm *mvm) 1088 { 1089 struct ieee80211_supported_band *band; 1090 unsigned int rates = 0; 1091 int i; 1092 1093 band = &mvm->nvm_data->bands[NL80211_BAND_2GHZ]; 1094 for (i = 0; i < band->n_bitrates; i++) 1095 rates |= rate_to_scan_rate_flag(band->bitrates[i].hw_value); 1096 band = &mvm->nvm_data->bands[NL80211_BAND_5GHZ]; 1097 for (i = 0; i < band->n_bitrates; i++) 1098 rates |= rate_to_scan_rate_flag(band->bitrates[i].hw_value); 1099 1100 /* Set both basic rates and supported rates */ 1101 rates |= SCAN_CONFIG_SUPPORTED_RATE(rates); 1102 1103 return cpu_to_le32(rates); 1104 } 1105 1106 static void iwl_mvm_fill_scan_dwell(struct iwl_mvm *mvm, 1107 struct iwl_scan_dwell *dwell) 1108 { 1109 dwell->active = IWL_SCAN_DWELL_ACTIVE; 1110 dwell->passive = IWL_SCAN_DWELL_PASSIVE; 1111 dwell->fragmented = IWL_SCAN_DWELL_FRAGMENTED; 1112 dwell->extended = IWL_SCAN_DWELL_EXTENDED; 1113 } 1114 1115 static void iwl_mvm_fill_channels(struct iwl_mvm *mvm, u8 *channels, 1116 u32 max_channels) 1117 { 1118 struct ieee80211_supported_band *band; 1119 int i, j = 0; 1120 1121 band = &mvm->nvm_data->bands[NL80211_BAND_2GHZ]; 1122 for (i = 0; i < band->n_channels && j < max_channels; i++, j++) 1123 channels[j] = band->channels[i].hw_value; 1124 band = &mvm->nvm_data->bands[NL80211_BAND_5GHZ]; 1125 for (i = 0; i < band->n_channels && j < max_channels; i++, j++) 1126 channels[j] = band->channels[i].hw_value; 1127 } 1128 1129 static void iwl_mvm_fill_scan_config_v1(struct iwl_mvm *mvm, void *config, 1130 u32 flags, u8 channel_flags, 1131 u32 max_channels) 1132 { 1133 enum iwl_mvm_scan_type type = iwl_mvm_get_scan_type(mvm, NULL); 1134 struct iwl_scan_config_v1 *cfg = config; 1135 1136 cfg->flags = cpu_to_le32(flags); 1137 cfg->tx_chains = cpu_to_le32(iwl_mvm_get_valid_tx_ant(mvm)); 1138 cfg->rx_chains = cpu_to_le32(iwl_mvm_scan_rx_ant(mvm)); 1139 cfg->legacy_rates = iwl_mvm_scan_config_rates(mvm); 1140 cfg->out_of_channel_time = cpu_to_le32(scan_timing[type].max_out_time); 1141 cfg->suspend_time = cpu_to_le32(scan_timing[type].suspend_time); 1142 1143 iwl_mvm_fill_scan_dwell(mvm, &cfg->dwell); 1144 1145 memcpy(&cfg->mac_addr, &mvm->addresses[0].addr, ETH_ALEN); 1146 1147 cfg->bcast_sta_id = mvm->aux_sta.sta_id; 1148 cfg->channel_flags = channel_flags; 1149 1150 iwl_mvm_fill_channels(mvm, cfg->channel_array, max_channels); 1151 } 1152 1153 static void iwl_mvm_fill_scan_config_v2(struct iwl_mvm *mvm, void *config, 1154 u32 flags, u8 channel_flags, 1155 u32 max_channels) 1156 { 1157 struct iwl_scan_config_v2 *cfg = config; 1158 1159 cfg->flags = cpu_to_le32(flags); 1160 cfg->tx_chains = cpu_to_le32(iwl_mvm_get_valid_tx_ant(mvm)); 1161 cfg->rx_chains = cpu_to_le32(iwl_mvm_scan_rx_ant(mvm)); 1162 cfg->legacy_rates = iwl_mvm_scan_config_rates(mvm); 1163 1164 if (iwl_mvm_is_cdb_supported(mvm)) { 1165 enum iwl_mvm_scan_type lb_type, hb_type; 1166 1167 lb_type = iwl_mvm_get_scan_type_band(mvm, NULL, 1168 NL80211_BAND_2GHZ); 1169 hb_type = iwl_mvm_get_scan_type_band(mvm, NULL, 1170 NL80211_BAND_5GHZ); 1171 1172 cfg->out_of_channel_time[SCAN_LB_LMAC_IDX] = 1173 cpu_to_le32(scan_timing[lb_type].max_out_time); 1174 cfg->suspend_time[SCAN_LB_LMAC_IDX] = 1175 cpu_to_le32(scan_timing[lb_type].suspend_time); 1176 1177 cfg->out_of_channel_time[SCAN_HB_LMAC_IDX] = 1178 cpu_to_le32(scan_timing[hb_type].max_out_time); 1179 cfg->suspend_time[SCAN_HB_LMAC_IDX] = 1180 cpu_to_le32(scan_timing[hb_type].suspend_time); 1181 } else { 1182 enum iwl_mvm_scan_type type = 1183 iwl_mvm_get_scan_type(mvm, NULL); 1184 1185 cfg->out_of_channel_time[SCAN_LB_LMAC_IDX] = 1186 cpu_to_le32(scan_timing[type].max_out_time); 1187 cfg->suspend_time[SCAN_LB_LMAC_IDX] = 1188 cpu_to_le32(scan_timing[type].suspend_time); 1189 } 1190 1191 iwl_mvm_fill_scan_dwell(mvm, &cfg->dwell); 1192 1193 memcpy(&cfg->mac_addr, &mvm->addresses[0].addr, ETH_ALEN); 1194 1195 cfg->bcast_sta_id = mvm->aux_sta.sta_id; 1196 cfg->channel_flags = channel_flags; 1197 1198 iwl_mvm_fill_channels(mvm, cfg->channel_array, max_channels); 1199 } 1200 1201 static int iwl_mvm_legacy_config_scan(struct iwl_mvm *mvm) 1202 { 1203 void *cfg; 1204 int ret, cmd_size; 1205 struct iwl_host_cmd cmd = { 1206 .id = iwl_cmd_id(SCAN_CFG_CMD, IWL_ALWAYS_LONG_GROUP, 0), 1207 }; 1208 enum iwl_mvm_scan_type type; 1209 enum iwl_mvm_scan_type hb_type = IWL_SCAN_TYPE_NOT_SET; 1210 int num_channels = 1211 mvm->nvm_data->bands[NL80211_BAND_2GHZ].n_channels + 1212 mvm->nvm_data->bands[NL80211_BAND_5GHZ].n_channels; 1213 u32 flags; 1214 u8 channel_flags; 1215 1216 if (WARN_ON(num_channels > mvm->fw->ucode_capa.n_scan_channels)) 1217 num_channels = mvm->fw->ucode_capa.n_scan_channels; 1218 1219 if (iwl_mvm_is_cdb_supported(mvm)) { 1220 type = iwl_mvm_get_scan_type_band(mvm, NULL, 1221 NL80211_BAND_2GHZ); 1222 hb_type = iwl_mvm_get_scan_type_band(mvm, NULL, 1223 NL80211_BAND_5GHZ); 1224 if (type == mvm->scan_type && hb_type == mvm->hb_scan_type) 1225 return 0; 1226 } else { 1227 type = iwl_mvm_get_scan_type(mvm, NULL); 1228 if (type == mvm->scan_type) 1229 return 0; 1230 } 1231 1232 if (iwl_mvm_cdb_scan_api(mvm)) 1233 cmd_size = sizeof(struct iwl_scan_config_v2); 1234 else 1235 cmd_size = sizeof(struct iwl_scan_config_v1); 1236 cmd_size += mvm->fw->ucode_capa.n_scan_channels; 1237 1238 cfg = kzalloc(cmd_size, GFP_KERNEL); 1239 if (!cfg) 1240 return -ENOMEM; 1241 1242 flags = SCAN_CONFIG_FLAG_ACTIVATE | 1243 SCAN_CONFIG_FLAG_ALLOW_CHUB_REQS | 1244 SCAN_CONFIG_FLAG_SET_TX_CHAINS | 1245 SCAN_CONFIG_FLAG_SET_RX_CHAINS | 1246 SCAN_CONFIG_FLAG_SET_AUX_STA_ID | 1247 SCAN_CONFIG_FLAG_SET_ALL_TIMES | 1248 SCAN_CONFIG_FLAG_SET_LEGACY_RATES | 1249 SCAN_CONFIG_FLAG_SET_MAC_ADDR | 1250 SCAN_CONFIG_FLAG_SET_CHANNEL_FLAGS | 1251 SCAN_CONFIG_N_CHANNELS(num_channels) | 1252 (iwl_mvm_is_scan_fragmented(type) ? 1253 SCAN_CONFIG_FLAG_SET_FRAGMENTED : 1254 SCAN_CONFIG_FLAG_CLEAR_FRAGMENTED); 1255 1256 channel_flags = IWL_CHANNEL_FLAG_EBS | 1257 IWL_CHANNEL_FLAG_ACCURATE_EBS | 1258 IWL_CHANNEL_FLAG_EBS_ADD | 1259 IWL_CHANNEL_FLAG_PRE_SCAN_PASSIVE2ACTIVE; 1260 1261 /* 1262 * Check for fragmented scan on LMAC2 - high band. 1263 * LMAC1 - low band is checked above. 1264 */ 1265 if (iwl_mvm_cdb_scan_api(mvm)) { 1266 if (iwl_mvm_is_cdb_supported(mvm)) 1267 flags |= (iwl_mvm_is_scan_fragmented(hb_type)) ? 1268 SCAN_CONFIG_FLAG_SET_LMAC2_FRAGMENTED : 1269 SCAN_CONFIG_FLAG_CLEAR_LMAC2_FRAGMENTED; 1270 iwl_mvm_fill_scan_config_v2(mvm, cfg, flags, channel_flags, 1271 num_channels); 1272 } else { 1273 iwl_mvm_fill_scan_config_v1(mvm, cfg, flags, channel_flags, 1274 num_channels); 1275 } 1276 1277 cmd.data[0] = cfg; 1278 cmd.len[0] = cmd_size; 1279 cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY; 1280 1281 IWL_DEBUG_SCAN(mvm, "Sending UMAC scan config\n"); 1282 1283 ret = iwl_mvm_send_cmd(mvm, &cmd); 1284 if (!ret) { 1285 mvm->scan_type = type; 1286 mvm->hb_scan_type = hb_type; 1287 } 1288 1289 kfree(cfg); 1290 return ret; 1291 } 1292 1293 int iwl_mvm_config_scan(struct iwl_mvm *mvm) 1294 { 1295 struct iwl_scan_config cfg; 1296 struct iwl_host_cmd cmd = { 1297 .id = iwl_cmd_id(SCAN_CFG_CMD, IWL_ALWAYS_LONG_GROUP, 0), 1298 .len[0] = sizeof(cfg), 1299 .data[0] = &cfg, 1300 .dataflags[0] = IWL_HCMD_DFL_NOCOPY, 1301 }; 1302 1303 if (!iwl_mvm_is_reduced_config_scan_supported(mvm)) 1304 return iwl_mvm_legacy_config_scan(mvm); 1305 1306 memset(&cfg, 0, sizeof(cfg)); 1307 1308 cfg.bcast_sta_id = mvm->aux_sta.sta_id; 1309 cfg.tx_chains = cpu_to_le32(iwl_mvm_get_valid_tx_ant(mvm)); 1310 cfg.rx_chains = cpu_to_le32(iwl_mvm_scan_rx_ant(mvm)); 1311 1312 IWL_DEBUG_SCAN(mvm, "Sending UMAC scan config\n"); 1313 1314 return iwl_mvm_send_cmd(mvm, &cmd); 1315 } 1316 1317 static int iwl_mvm_scan_uid_by_status(struct iwl_mvm *mvm, int status) 1318 { 1319 int i; 1320 1321 for (i = 0; i < mvm->max_scans; i++) 1322 if (mvm->scan_uid_status[i] == status) 1323 return i; 1324 1325 return -ENOENT; 1326 } 1327 1328 static void iwl_mvm_scan_umac_dwell(struct iwl_mvm *mvm, 1329 struct iwl_scan_req_umac *cmd, 1330 struct iwl_mvm_scan_params *params) 1331 { 1332 struct iwl_mvm_scan_timing_params *timing, *hb_timing; 1333 u8 active_dwell, passive_dwell; 1334 1335 timing = &scan_timing[params->type]; 1336 active_dwell = params->measurement_dwell ? 1337 params->measurement_dwell : IWL_SCAN_DWELL_ACTIVE; 1338 passive_dwell = params->measurement_dwell ? 1339 params->measurement_dwell : IWL_SCAN_DWELL_PASSIVE; 1340 1341 if (iwl_mvm_is_adaptive_dwell_supported(mvm)) { 1342 cmd->v7.adwell_default_n_aps_social = 1343 IWL_SCAN_ADWELL_DEFAULT_N_APS_SOCIAL; 1344 cmd->v7.adwell_default_n_aps = 1345 IWL_SCAN_ADWELL_DEFAULT_LB_N_APS; 1346 1347 if (iwl_mvm_is_adwell_hb_ap_num_supported(mvm)) 1348 cmd->v9.adwell_default_hb_n_aps = 1349 IWL_SCAN_ADWELL_DEFAULT_HB_N_APS; 1350 1351 /* if custom max budget was configured with debugfs */ 1352 if (IWL_MVM_ADWELL_MAX_BUDGET) 1353 cmd->v7.adwell_max_budget = 1354 cpu_to_le16(IWL_MVM_ADWELL_MAX_BUDGET); 1355 else if (params->ssids && params->ssids[0].ssid_len) 1356 cmd->v7.adwell_max_budget = 1357 cpu_to_le16(IWL_SCAN_ADWELL_MAX_BUDGET_DIRECTED_SCAN); 1358 else 1359 cmd->v7.adwell_max_budget = 1360 cpu_to_le16(IWL_SCAN_ADWELL_MAX_BUDGET_FULL_SCAN); 1361 1362 cmd->v7.scan_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); 1363 cmd->v7.max_out_time[SCAN_LB_LMAC_IDX] = 1364 cpu_to_le32(timing->max_out_time); 1365 cmd->v7.suspend_time[SCAN_LB_LMAC_IDX] = 1366 cpu_to_le32(timing->suspend_time); 1367 1368 if (iwl_mvm_is_cdb_supported(mvm)) { 1369 hb_timing = &scan_timing[params->hb_type]; 1370 1371 cmd->v7.max_out_time[SCAN_HB_LMAC_IDX] = 1372 cpu_to_le32(hb_timing->max_out_time); 1373 cmd->v7.suspend_time[SCAN_HB_LMAC_IDX] = 1374 cpu_to_le32(hb_timing->suspend_time); 1375 } 1376 1377 if (!iwl_mvm_is_adaptive_dwell_v2_supported(mvm)) { 1378 cmd->v7.active_dwell = active_dwell; 1379 cmd->v7.passive_dwell = passive_dwell; 1380 cmd->v7.fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED; 1381 } else { 1382 cmd->v8.active_dwell[SCAN_LB_LMAC_IDX] = active_dwell; 1383 cmd->v8.passive_dwell[SCAN_LB_LMAC_IDX] = passive_dwell; 1384 if (iwl_mvm_is_cdb_supported(mvm)) { 1385 cmd->v8.active_dwell[SCAN_HB_LMAC_IDX] = 1386 active_dwell; 1387 cmd->v8.passive_dwell[SCAN_HB_LMAC_IDX] = 1388 passive_dwell; 1389 } 1390 } 1391 } else { 1392 cmd->v1.extended_dwell = params->measurement_dwell ? 1393 params->measurement_dwell : IWL_SCAN_DWELL_EXTENDED; 1394 cmd->v1.active_dwell = active_dwell; 1395 cmd->v1.passive_dwell = passive_dwell; 1396 cmd->v1.fragmented_dwell = IWL_SCAN_DWELL_FRAGMENTED; 1397 1398 if (iwl_mvm_is_cdb_supported(mvm)) { 1399 hb_timing = &scan_timing[params->hb_type]; 1400 1401 cmd->v6.max_out_time[SCAN_HB_LMAC_IDX] = 1402 cpu_to_le32(hb_timing->max_out_time); 1403 cmd->v6.suspend_time[SCAN_HB_LMAC_IDX] = 1404 cpu_to_le32(hb_timing->suspend_time); 1405 } 1406 1407 if (iwl_mvm_cdb_scan_api(mvm)) { 1408 cmd->v6.scan_priority = 1409 cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); 1410 cmd->v6.max_out_time[SCAN_LB_LMAC_IDX] = 1411 cpu_to_le32(timing->max_out_time); 1412 cmd->v6.suspend_time[SCAN_LB_LMAC_IDX] = 1413 cpu_to_le32(timing->suspend_time); 1414 } else { 1415 cmd->v1.scan_priority = 1416 cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); 1417 cmd->v1.max_out_time = 1418 cpu_to_le32(timing->max_out_time); 1419 cmd->v1.suspend_time = 1420 cpu_to_le32(timing->suspend_time); 1421 } 1422 } 1423 1424 if (iwl_mvm_is_regular_scan(params)) 1425 cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); 1426 else 1427 cmd->ooc_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_2); 1428 } 1429 1430 static u32 iwl_mvm_scan_umac_ooc_priority(struct iwl_mvm_scan_params *params) 1431 { 1432 return iwl_mvm_is_regular_scan(params) ? 1433 IWL_SCAN_PRIORITY_EXT_6 : 1434 IWL_SCAN_PRIORITY_EXT_2; 1435 } 1436 1437 static void 1438 iwl_mvm_scan_umac_dwell_v10(struct iwl_mvm *mvm, 1439 struct iwl_scan_general_params_v10 *general_params, 1440 struct iwl_mvm_scan_params *params) 1441 { 1442 struct iwl_mvm_scan_timing_params *timing, *hb_timing; 1443 u8 active_dwell, passive_dwell; 1444 1445 timing = &scan_timing[params->type]; 1446 active_dwell = params->measurement_dwell ? 1447 params->measurement_dwell : IWL_SCAN_DWELL_ACTIVE; 1448 passive_dwell = params->measurement_dwell ? 1449 params->measurement_dwell : IWL_SCAN_DWELL_PASSIVE; 1450 1451 general_params->adwell_default_social_chn = 1452 IWL_SCAN_ADWELL_DEFAULT_N_APS_SOCIAL; 1453 general_params->adwell_default_2g = IWL_SCAN_ADWELL_DEFAULT_LB_N_APS; 1454 general_params->adwell_default_5g = IWL_SCAN_ADWELL_DEFAULT_HB_N_APS; 1455 1456 /* if custom max budget was configured with debugfs */ 1457 if (IWL_MVM_ADWELL_MAX_BUDGET) 1458 general_params->adwell_max_budget = 1459 cpu_to_le16(IWL_MVM_ADWELL_MAX_BUDGET); 1460 else if (params->ssids && params->ssids[0].ssid_len) 1461 general_params->adwell_max_budget = 1462 cpu_to_le16(IWL_SCAN_ADWELL_MAX_BUDGET_DIRECTED_SCAN); 1463 else 1464 general_params->adwell_max_budget = 1465 cpu_to_le16(IWL_SCAN_ADWELL_MAX_BUDGET_FULL_SCAN); 1466 1467 general_params->scan_priority = cpu_to_le32(IWL_SCAN_PRIORITY_EXT_6); 1468 general_params->max_out_of_time[SCAN_LB_LMAC_IDX] = 1469 cpu_to_le32(timing->max_out_time); 1470 general_params->suspend_time[SCAN_LB_LMAC_IDX] = 1471 cpu_to_le32(timing->suspend_time); 1472 1473 hb_timing = &scan_timing[params->hb_type]; 1474 1475 general_params->max_out_of_time[SCAN_HB_LMAC_IDX] = 1476 cpu_to_le32(hb_timing->max_out_time); 1477 general_params->suspend_time[SCAN_HB_LMAC_IDX] = 1478 cpu_to_le32(hb_timing->suspend_time); 1479 1480 general_params->active_dwell[SCAN_LB_LMAC_IDX] = active_dwell; 1481 general_params->passive_dwell[SCAN_LB_LMAC_IDX] = passive_dwell; 1482 general_params->active_dwell[SCAN_HB_LMAC_IDX] = active_dwell; 1483 general_params->passive_dwell[SCAN_HB_LMAC_IDX] = passive_dwell; 1484 } 1485 1486 struct iwl_mvm_scan_channel_segment { 1487 u8 start_idx; 1488 u8 end_idx; 1489 u8 first_channel_id; 1490 u8 last_channel_id; 1491 u8 channel_spacing_shift; 1492 u8 band; 1493 }; 1494 1495 static const struct iwl_mvm_scan_channel_segment scan_channel_segments[] = { 1496 { 1497 .start_idx = 0, 1498 .end_idx = 13, 1499 .first_channel_id = 1, 1500 .last_channel_id = 14, 1501 .channel_spacing_shift = 0, 1502 .band = PHY_BAND_24 1503 }, 1504 { 1505 .start_idx = 14, 1506 .end_idx = 41, 1507 .first_channel_id = 36, 1508 .last_channel_id = 144, 1509 .channel_spacing_shift = 2, 1510 .band = PHY_BAND_5 1511 }, 1512 { 1513 .start_idx = 42, 1514 .end_idx = 50, 1515 .first_channel_id = 149, 1516 .last_channel_id = 181, 1517 .channel_spacing_shift = 2, 1518 .band = PHY_BAND_5 1519 }, 1520 }; 1521 1522 static int iwl_mvm_scan_ch_and_band_to_idx(u8 channel_id, u8 band) 1523 { 1524 int i, index; 1525 1526 if (!channel_id) 1527 return -EINVAL; 1528 1529 for (i = 0; i < ARRAY_SIZE(scan_channel_segments); i++) { 1530 const struct iwl_mvm_scan_channel_segment *ch_segment = 1531 &scan_channel_segments[i]; 1532 u32 ch_offset; 1533 1534 if (ch_segment->band != band || 1535 ch_segment->first_channel_id > channel_id || 1536 ch_segment->last_channel_id < channel_id) 1537 continue; 1538 1539 ch_offset = (channel_id - ch_segment->first_channel_id) >> 1540 ch_segment->channel_spacing_shift; 1541 1542 index = scan_channel_segments[i].start_idx + ch_offset; 1543 if (index < IWL_SCAN_NUM_CHANNELS) 1544 return index; 1545 1546 break; 1547 } 1548 1549 return -EINVAL; 1550 } 1551 1552 static const u8 p2p_go_friendly_chs[] = { 1553 36, 40, 44, 48, 149, 153, 157, 161, 165, 1554 }; 1555 1556 static const u8 social_chs[] = { 1557 1, 6, 11 1558 }; 1559 1560 static void iwl_mvm_scan_ch_add_n_aps_override(enum nl80211_iftype vif_type, 1561 u8 ch_id, u8 band, u8 *ch_bitmap, 1562 size_t bitmap_n_entries) 1563 { 1564 int i; 1565 1566 if (vif_type != NL80211_IFTYPE_P2P_DEVICE) 1567 return; 1568 1569 for (i = 0; i < ARRAY_SIZE(p2p_go_friendly_chs); i++) { 1570 if (p2p_go_friendly_chs[i] == ch_id) { 1571 int ch_idx, bitmap_idx; 1572 1573 ch_idx = iwl_mvm_scan_ch_and_band_to_idx(ch_id, band); 1574 if (ch_idx < 0) 1575 return; 1576 1577 bitmap_idx = ch_idx / 8; 1578 if (bitmap_idx >= bitmap_n_entries) 1579 return; 1580 1581 ch_idx = ch_idx % 8; 1582 ch_bitmap[bitmap_idx] |= BIT(ch_idx); 1583 1584 return; 1585 } 1586 } 1587 } 1588 1589 static u32 iwl_mvm_scan_ch_n_aps_flag(enum nl80211_iftype vif_type, u8 ch_id) 1590 { 1591 int i; 1592 u32 flags = 0; 1593 1594 if (vif_type != NL80211_IFTYPE_P2P_DEVICE) 1595 goto out; 1596 1597 for (i = 0; i < ARRAY_SIZE(p2p_go_friendly_chs); i++) { 1598 if (p2p_go_friendly_chs[i] == ch_id) { 1599 flags |= IWL_SCAN_ADWELL_N_APS_GO_FRIENDLY_BIT; 1600 break; 1601 } 1602 } 1603 1604 if (flags) 1605 goto out; 1606 1607 for (i = 0; i < ARRAY_SIZE(social_chs); i++) { 1608 if (social_chs[i] == ch_id) { 1609 flags |= IWL_SCAN_ADWELL_N_APS_SOCIAL_CHS_BIT; 1610 break; 1611 } 1612 } 1613 1614 out: 1615 return flags; 1616 } 1617 1618 static void 1619 iwl_mvm_umac_scan_cfg_channels(struct iwl_mvm *mvm, 1620 struct ieee80211_channel **channels, 1621 int n_channels, u32 flags, 1622 struct iwl_scan_channel_cfg_umac *channel_cfg) 1623 { 1624 int i; 1625 1626 for (i = 0; i < n_channels; i++) { 1627 channel_cfg[i].flags = cpu_to_le32(flags); 1628 channel_cfg[i].v1.channel_num = channels[i]->hw_value; 1629 if (iwl_mvm_is_scan_ext_chan_supported(mvm)) { 1630 enum nl80211_band band = channels[i]->band; 1631 1632 channel_cfg[i].v2.band = 1633 iwl_mvm_phy_band_from_nl80211(band); 1634 channel_cfg[i].v2.iter_count = 1; 1635 channel_cfg[i].v2.iter_interval = 0; 1636 } else { 1637 channel_cfg[i].v1.iter_count = 1; 1638 channel_cfg[i].v1.iter_interval = 0; 1639 } 1640 } 1641 } 1642 1643 static void 1644 iwl_mvm_umac_scan_cfg_channels_v4(struct iwl_mvm *mvm, 1645 struct ieee80211_channel **channels, 1646 struct iwl_scan_channel_params_v4 *cp, 1647 int n_channels, u32 flags, 1648 enum nl80211_iftype vif_type) 1649 { 1650 u8 *bitmap = cp->adwell_ch_override_bitmap; 1651 size_t bitmap_n_entries = ARRAY_SIZE(cp->adwell_ch_override_bitmap); 1652 int i; 1653 1654 for (i = 0; i < n_channels; i++) { 1655 enum nl80211_band band = channels[i]->band; 1656 struct iwl_scan_channel_cfg_umac *cfg = 1657 &cp->channel_config[i]; 1658 1659 cfg->flags = cpu_to_le32(flags); 1660 cfg->v2.channel_num = channels[i]->hw_value; 1661 cfg->v2.band = iwl_mvm_phy_band_from_nl80211(band); 1662 cfg->v2.iter_count = 1; 1663 cfg->v2.iter_interval = 0; 1664 1665 iwl_mvm_scan_ch_add_n_aps_override(vif_type, 1666 cfg->v2.channel_num, 1667 cfg->v2.band, bitmap, 1668 bitmap_n_entries); 1669 } 1670 } 1671 1672 static void 1673 iwl_mvm_umac_scan_cfg_channels_v6(struct iwl_mvm *mvm, 1674 struct ieee80211_channel **channels, 1675 struct iwl_scan_channel_params_v6 *cp, 1676 int n_channels, u32 flags, 1677 enum nl80211_iftype vif_type) 1678 { 1679 int i; 1680 1681 for (i = 0; i < n_channels; i++) { 1682 enum nl80211_band band = channels[i]->band; 1683 struct iwl_scan_channel_cfg_umac *cfg = &cp->channel_config[i]; 1684 u32 n_aps_flag = 1685 iwl_mvm_scan_ch_n_aps_flag(vif_type, 1686 cfg->v2.channel_num); 1687 1688 cfg->flags = cpu_to_le32(flags | n_aps_flag); 1689 cfg->v2.channel_num = channels[i]->hw_value; 1690 cfg->v2.band = iwl_mvm_phy_band_from_nl80211(band); 1691 cfg->v2.iter_count = 1; 1692 cfg->v2.iter_interval = 0; 1693 } 1694 } 1695 1696 static u8 iwl_mvm_scan_umac_chan_flags_v2(struct iwl_mvm *mvm, 1697 struct iwl_mvm_scan_params *params, 1698 struct ieee80211_vif *vif) 1699 { 1700 u8 flags = 0; 1701 1702 flags |= IWL_SCAN_CHANNEL_FLAG_ENABLE_CHAN_ORDER; 1703 1704 if (iwl_mvm_scan_use_ebs(mvm, vif)) 1705 flags |= IWL_SCAN_CHANNEL_FLAG_EBS | 1706 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE | 1707 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD; 1708 1709 /* set fragmented ebs for fragmented scan on HB channels */ 1710 if (iwl_mvm_is_scan_fragmented(params->hb_type)) 1711 flags |= IWL_SCAN_CHANNEL_FLAG_EBS_FRAG; 1712 1713 return flags; 1714 } 1715 1716 static u16 iwl_mvm_scan_umac_flags_v2(struct iwl_mvm *mvm, 1717 struct iwl_mvm_scan_params *params, 1718 struct ieee80211_vif *vif, 1719 int type) 1720 { 1721 u16 flags = 0; 1722 1723 if (params->n_ssids == 0) 1724 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_FORCE_PASSIVE; 1725 1726 if (iwl_mvm_is_scan_fragmented(params->type)) 1727 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_FRAGMENTED_LMAC1; 1728 1729 if (iwl_mvm_is_scan_fragmented(params->hb_type)) 1730 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_FRAGMENTED_LMAC2; 1731 1732 if (params->pass_all) 1733 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_PASS_ALL; 1734 else 1735 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_MATCH; 1736 1737 if (!iwl_mvm_is_regular_scan(params)) 1738 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_PERIODIC; 1739 1740 if (params->measurement_dwell || 1741 mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_ENABLED) 1742 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_NTFY_ITER_COMPLETE; 1743 1744 if (IWL_MVM_ADWELL_ENABLE) 1745 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_ADAPTIVE_DWELL; 1746 1747 if (type == IWL_MVM_SCAN_SCHED || type == IWL_MVM_SCAN_NETDETECT) 1748 flags |= IWL_UMAC_SCAN_GEN_FLAGS_V2_PREEMPTIVE; 1749 1750 return flags; 1751 } 1752 1753 static u16 iwl_mvm_scan_umac_flags(struct iwl_mvm *mvm, 1754 struct iwl_mvm_scan_params *params, 1755 struct ieee80211_vif *vif) 1756 { 1757 u16 flags = 0; 1758 1759 if (params->n_ssids == 0) 1760 flags = IWL_UMAC_SCAN_GEN_FLAGS_PASSIVE; 1761 1762 if (params->n_ssids == 1 && params->ssids[0].ssid_len != 0) 1763 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT; 1764 1765 if (iwl_mvm_is_scan_fragmented(params->type)) 1766 flags |= IWL_UMAC_SCAN_GEN_FLAGS_FRAGMENTED; 1767 1768 if (iwl_mvm_is_cdb_supported(mvm) && 1769 iwl_mvm_is_scan_fragmented(params->hb_type)) 1770 flags |= IWL_UMAC_SCAN_GEN_FLAGS_LMAC2_FRAGMENTED; 1771 1772 if (iwl_mvm_rrm_scan_needed(mvm) && 1773 fw_has_capa(&mvm->fw->ucode_capa, 1774 IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT)) 1775 flags |= IWL_UMAC_SCAN_GEN_FLAGS_RRM_ENABLED; 1776 1777 if (params->pass_all) 1778 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PASS_ALL; 1779 else 1780 flags |= IWL_UMAC_SCAN_GEN_FLAGS_MATCH; 1781 1782 if (!iwl_mvm_is_regular_scan(params)) 1783 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PERIODIC; 1784 1785 if (params->measurement_dwell) 1786 flags |= IWL_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE; 1787 1788 #ifdef CONFIG_IWLWIFI_DEBUGFS 1789 if (mvm->scan_iter_notif_enabled) 1790 flags |= IWL_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE; 1791 #endif 1792 1793 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_ENABLED) 1794 flags |= IWL_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE; 1795 1796 if (iwl_mvm_is_adaptive_dwell_supported(mvm) && IWL_MVM_ADWELL_ENABLE) 1797 flags |= IWL_UMAC_SCAN_GEN_FLAGS_ADAPTIVE_DWELL; 1798 1799 /* 1800 * Extended dwell is relevant only for low band to start with, as it is 1801 * being used for social channles only (1, 6, 11), so we can check 1802 * only scan type on low band also for CDB. 1803 */ 1804 if (iwl_mvm_is_regular_scan(params) && 1805 vif->type != NL80211_IFTYPE_P2P_DEVICE && 1806 !iwl_mvm_is_scan_fragmented(params->type) && 1807 !iwl_mvm_is_adaptive_dwell_supported(mvm) && 1808 !iwl_mvm_is_oce_supported(mvm)) 1809 flags |= IWL_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL; 1810 1811 if (iwl_mvm_is_oce_supported(mvm)) { 1812 if ((params->flags & 1813 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE)) 1814 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PROB_REQ_HIGH_TX_RATE; 1815 /* Since IWL_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL and 1816 * NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION shares 1817 * the same bit, we need to make sure that we use this bit here 1818 * only when IWL_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL cannot be 1819 * used. */ 1820 if ((params->flags & 1821 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) && 1822 !WARN_ON_ONCE(!iwl_mvm_is_adaptive_dwell_supported(mvm))) 1823 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PROB_REQ_DEFER_SUPP; 1824 if ((params->flags & NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME)) 1825 flags |= IWL_UMAC_SCAN_GEN_FLAGS_MAX_CHNL_TIME; 1826 } 1827 1828 return flags; 1829 } 1830 1831 static int 1832 iwl_mvm_fill_scan_sched_params(struct iwl_mvm_scan_params *params, 1833 struct iwl_scan_umac_schedule *schedule, 1834 __le16 *delay) 1835 { 1836 int i; 1837 if (WARN_ON(!params->n_scan_plans || 1838 params->n_scan_plans > IWL_MAX_SCHED_SCAN_PLANS)) 1839 return -EINVAL; 1840 1841 for (i = 0; i < params->n_scan_plans; i++) { 1842 struct cfg80211_sched_scan_plan *scan_plan = 1843 ¶ms->scan_plans[i]; 1844 1845 schedule[i].iter_count = scan_plan->iterations; 1846 schedule[i].interval = 1847 cpu_to_le16(scan_plan->interval); 1848 } 1849 1850 /* 1851 * If the number of iterations of the last scan plan is set to 1852 * zero, it should run infinitely. However, this is not always the case. 1853 * For example, when regular scan is requested the driver sets one scan 1854 * plan with one iteration. 1855 */ 1856 if (!schedule[params->n_scan_plans - 1].iter_count) 1857 schedule[params->n_scan_plans - 1].iter_count = 0xff; 1858 1859 *delay = cpu_to_le16(params->delay); 1860 1861 return 0; 1862 } 1863 1864 static int iwl_mvm_scan_umac(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 1865 struct iwl_mvm_scan_params *params, 1866 int type, int uid) 1867 { 1868 struct iwl_scan_req_umac *cmd = mvm->scan_cmd; 1869 struct iwl_scan_umac_chan_param *chan_param; 1870 void *cmd_data = iwl_mvm_get_scan_req_umac_data(mvm); 1871 void *sec_part = cmd_data + sizeof(struct iwl_scan_channel_cfg_umac) * 1872 mvm->fw->ucode_capa.n_scan_channels; 1873 struct iwl_scan_req_umac_tail_v2 *tail_v2 = 1874 (struct iwl_scan_req_umac_tail_v2 *)sec_part; 1875 struct iwl_scan_req_umac_tail_v1 *tail_v1; 1876 struct iwl_ssid_ie *direct_scan; 1877 int ret = 0; 1878 u32 ssid_bitmap = 0; 1879 u8 channel_flags = 0; 1880 u16 gen_flags; 1881 struct iwl_mvm_vif *scan_vif = iwl_mvm_vif_from_mac80211(vif); 1882 1883 chan_param = iwl_mvm_get_scan_req_umac_channel(mvm); 1884 1885 iwl_mvm_scan_umac_dwell(mvm, cmd, params); 1886 1887 mvm->scan_uid_status[uid] = type; 1888 1889 cmd->uid = cpu_to_le32(uid); 1890 gen_flags = iwl_mvm_scan_umac_flags(mvm, params, vif); 1891 cmd->general_flags = cpu_to_le16(gen_flags); 1892 if (iwl_mvm_is_adaptive_dwell_v2_supported(mvm)) { 1893 if (gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_FRAGMENTED) 1894 cmd->v8.num_of_fragments[SCAN_LB_LMAC_IDX] = 1895 IWL_SCAN_NUM_OF_FRAGS; 1896 if (gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_LMAC2_FRAGMENTED) 1897 cmd->v8.num_of_fragments[SCAN_HB_LMAC_IDX] = 1898 IWL_SCAN_NUM_OF_FRAGS; 1899 1900 cmd->v8.general_flags2 = 1901 IWL_UMAC_SCAN_GEN_FLAGS2_ALLOW_CHNL_REORDER; 1902 } 1903 1904 cmd->scan_start_mac_id = scan_vif->id; 1905 1906 if (type == IWL_MVM_SCAN_SCHED || type == IWL_MVM_SCAN_NETDETECT) 1907 cmd->flags = cpu_to_le32(IWL_UMAC_SCAN_FLAG_PREEMPTIVE); 1908 1909 if (iwl_mvm_scan_use_ebs(mvm, vif)) { 1910 channel_flags = IWL_SCAN_CHANNEL_FLAG_EBS | 1911 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE | 1912 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD; 1913 1914 /* set fragmented ebs for fragmented scan on HB channels */ 1915 if (iwl_mvm_is_frag_ebs_supported(mvm)) { 1916 if (gen_flags & 1917 IWL_UMAC_SCAN_GEN_FLAGS_LMAC2_FRAGMENTED || 1918 (!iwl_mvm_is_cdb_supported(mvm) && 1919 gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_FRAGMENTED)) 1920 channel_flags |= IWL_SCAN_CHANNEL_FLAG_EBS_FRAG; 1921 } 1922 } 1923 1924 chan_param->flags = channel_flags; 1925 chan_param->count = params->n_channels; 1926 1927 ret = iwl_mvm_fill_scan_sched_params(params, tail_v2->schedule, 1928 &tail_v2->delay); 1929 if (ret) 1930 return ret; 1931 1932 if (iwl_mvm_is_scan_ext_chan_supported(mvm)) { 1933 tail_v2->preq = params->preq; 1934 direct_scan = tail_v2->direct_scan; 1935 } else { 1936 tail_v1 = (struct iwl_scan_req_umac_tail_v1 *)sec_part; 1937 iwl_mvm_scan_set_legacy_probe_req(&tail_v1->preq, 1938 ¶ms->preq); 1939 direct_scan = tail_v1->direct_scan; 1940 } 1941 iwl_scan_build_ssids(params, direct_scan, &ssid_bitmap); 1942 iwl_mvm_umac_scan_cfg_channels(mvm, params->channels, 1943 params->n_channels, ssid_bitmap, 1944 cmd_data); 1945 return 0; 1946 } 1947 1948 static void 1949 iwl_mvm_scan_umac_fill_general_p_v10(struct iwl_mvm *mvm, 1950 struct iwl_mvm_scan_params *params, 1951 struct ieee80211_vif *vif, 1952 struct iwl_scan_general_params_v10 *gp, 1953 u16 gen_flags) 1954 { 1955 struct iwl_mvm_vif *scan_vif = iwl_mvm_vif_from_mac80211(vif); 1956 1957 iwl_mvm_scan_umac_dwell_v10(mvm, gp, params); 1958 1959 gp->flags = cpu_to_le16(gen_flags); 1960 1961 if (gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_V2_FRAGMENTED_LMAC1) 1962 gp->num_of_fragments[SCAN_LB_LMAC_IDX] = IWL_SCAN_NUM_OF_FRAGS; 1963 if (gen_flags & IWL_UMAC_SCAN_GEN_FLAGS_V2_FRAGMENTED_LMAC2) 1964 gp->num_of_fragments[SCAN_HB_LMAC_IDX] = IWL_SCAN_NUM_OF_FRAGS; 1965 1966 gp->scan_start_mac_id = scan_vif->id; 1967 } 1968 1969 static void 1970 iwl_mvm_scan_umac_fill_probe_p_v3(struct iwl_mvm_scan_params *params, 1971 struct iwl_scan_probe_params_v3 *pp) 1972 { 1973 pp->preq = params->preq; 1974 pp->ssid_num = params->n_ssids; 1975 iwl_scan_build_ssids(params, pp->direct_scan, NULL); 1976 } 1977 1978 static void 1979 iwl_mvm_scan_umac_fill_probe_p_v4(struct iwl_mvm_scan_params *params, 1980 struct iwl_scan_probe_params_v4 *pp, 1981 u32 *bitmap_ssid) 1982 { 1983 pp->preq = params->preq; 1984 iwl_scan_build_ssids(params, pp->direct_scan, bitmap_ssid); 1985 } 1986 1987 static void 1988 iwl_mvm_scan_umac_fill_ch_p_v4(struct iwl_mvm *mvm, 1989 struct iwl_mvm_scan_params *params, 1990 struct ieee80211_vif *vif, 1991 struct iwl_scan_channel_params_v4 *cp, 1992 u32 channel_cfg_flags) 1993 { 1994 cp->flags = iwl_mvm_scan_umac_chan_flags_v2(mvm, params, vif); 1995 cp->count = params->n_channels; 1996 cp->num_of_aps_override = IWL_SCAN_ADWELL_N_APS_GO_FRIENDLY; 1997 1998 iwl_mvm_umac_scan_cfg_channels_v4(mvm, params->channels, cp, 1999 params->n_channels, 2000 channel_cfg_flags, 2001 vif->type); 2002 } 2003 2004 static void 2005 iwl_mvm_scan_umac_fill_ch_p_v6(struct iwl_mvm *mvm, 2006 struct iwl_mvm_scan_params *params, 2007 struct ieee80211_vif *vif, 2008 struct iwl_scan_channel_params_v6 *cp, 2009 u32 channel_cfg_flags) 2010 { 2011 cp->flags = iwl_mvm_scan_umac_chan_flags_v2(mvm, params, vif); 2012 cp->count = params->n_channels; 2013 cp->n_aps_override[0] = IWL_SCAN_ADWELL_N_APS_GO_FRIENDLY; 2014 cp->n_aps_override[1] = IWL_SCAN_ADWELL_N_APS_SOCIAL_CHS; 2015 2016 iwl_mvm_umac_scan_cfg_channels_v6(mvm, params->channels, cp, 2017 params->n_channels, 2018 channel_cfg_flags, 2019 vif->type); 2020 } 2021 2022 static int iwl_mvm_scan_umac_v12(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2023 struct iwl_mvm_scan_params *params, int type, 2024 int uid) 2025 { 2026 struct iwl_scan_req_umac_v12 *cmd = mvm->scan_cmd; 2027 struct iwl_scan_req_params_v12 *scan_p = &cmd->scan_params; 2028 int ret; 2029 u16 gen_flags; 2030 2031 mvm->scan_uid_status[uid] = type; 2032 2033 cmd->ooc_priority = cpu_to_le32(iwl_mvm_scan_umac_ooc_priority(params)); 2034 cmd->uid = cpu_to_le32(uid); 2035 2036 gen_flags = iwl_mvm_scan_umac_flags_v2(mvm, params, vif, type); 2037 iwl_mvm_scan_umac_fill_general_p_v10(mvm, params, vif, 2038 &scan_p->general_params, 2039 gen_flags); 2040 2041 ret = iwl_mvm_fill_scan_sched_params(params, 2042 scan_p->periodic_params.schedule, 2043 &scan_p->periodic_params.delay); 2044 if (ret) 2045 return ret; 2046 2047 iwl_mvm_scan_umac_fill_probe_p_v3(params, &scan_p->probe_params); 2048 iwl_mvm_scan_umac_fill_ch_p_v4(mvm, params, vif, 2049 &scan_p->channel_params, 0); 2050 2051 return 0; 2052 } 2053 2054 static int iwl_mvm_scan_umac_v14(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2055 struct iwl_mvm_scan_params *params, int type, 2056 int uid) 2057 { 2058 struct iwl_scan_req_umac_v14 *cmd = mvm->scan_cmd; 2059 struct iwl_scan_req_params_v14 *scan_p = &cmd->scan_params; 2060 int ret; 2061 u16 gen_flags; 2062 u32 bitmap_ssid = 0; 2063 2064 mvm->scan_uid_status[uid] = type; 2065 2066 cmd->ooc_priority = cpu_to_le32(iwl_mvm_scan_umac_ooc_priority(params)); 2067 cmd->uid = cpu_to_le32(uid); 2068 2069 gen_flags = iwl_mvm_scan_umac_flags_v2(mvm, params, vif, type); 2070 iwl_mvm_scan_umac_fill_general_p_v10(mvm, params, vif, 2071 &scan_p->general_params, 2072 gen_flags); 2073 2074 ret = iwl_mvm_fill_scan_sched_params(params, 2075 scan_p->periodic_params.schedule, 2076 &scan_p->periodic_params.delay); 2077 if (ret) 2078 return ret; 2079 2080 iwl_mvm_scan_umac_fill_probe_p_v4(params, &scan_p->probe_params, 2081 &bitmap_ssid); 2082 iwl_mvm_scan_umac_fill_ch_p_v6(mvm, params, vif, 2083 &scan_p->channel_params, bitmap_ssid); 2084 2085 return 0; 2086 } 2087 2088 static int iwl_mvm_num_scans(struct iwl_mvm *mvm) 2089 { 2090 return hweight32(mvm->scan_status & IWL_MVM_SCAN_MASK); 2091 } 2092 2093 static int iwl_mvm_check_running_scans(struct iwl_mvm *mvm, int type) 2094 { 2095 bool unified_image = fw_has_capa(&mvm->fw->ucode_capa, 2096 IWL_UCODE_TLV_CAPA_CNSLDTD_D3_D0_IMG); 2097 2098 /* This looks a bit arbitrary, but the idea is that if we run 2099 * out of possible simultaneous scans and the userspace is 2100 * trying to run a scan type that is already running, we 2101 * return -EBUSY. But if the userspace wants to start a 2102 * different type of scan, we stop the opposite type to make 2103 * space for the new request. The reason is backwards 2104 * compatibility with old wpa_supplicant that wouldn't stop a 2105 * scheduled scan before starting a normal scan. 2106 */ 2107 2108 /* FW supports only a single periodic scan */ 2109 if ((type == IWL_MVM_SCAN_SCHED || type == IWL_MVM_SCAN_NETDETECT) && 2110 mvm->scan_status & (IWL_MVM_SCAN_SCHED | IWL_MVM_SCAN_NETDETECT)) 2111 return -EBUSY; 2112 2113 if (iwl_mvm_num_scans(mvm) < mvm->max_scans) 2114 return 0; 2115 2116 /* Use a switch, even though this is a bitmask, so that more 2117 * than one bits set will fall in default and we will warn. 2118 */ 2119 switch (type) { 2120 case IWL_MVM_SCAN_REGULAR: 2121 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR_MASK) 2122 return -EBUSY; 2123 return iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true); 2124 case IWL_MVM_SCAN_SCHED: 2125 if (mvm->scan_status & IWL_MVM_SCAN_SCHED_MASK) 2126 return -EBUSY; 2127 return iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true); 2128 case IWL_MVM_SCAN_NETDETECT: 2129 /* For non-unified images, there's no need to stop 2130 * anything for net-detect since the firmware is 2131 * restarted anyway. This way, any sched scans that 2132 * were running will be restarted when we resume. 2133 */ 2134 if (!unified_image) 2135 return 0; 2136 2137 /* If this is a unified image and we ran out of scans, 2138 * we need to stop something. Prefer stopping regular 2139 * scans, because the results are useless at this 2140 * point, and we should be able to keep running 2141 * another scheduled scan while suspended. 2142 */ 2143 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR_MASK) 2144 return iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, 2145 true); 2146 if (mvm->scan_status & IWL_MVM_SCAN_SCHED_MASK) 2147 return iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, 2148 true); 2149 /* Something is wrong if no scan was running but we 2150 * ran out of scans. 2151 */ 2152 /* fall through */ 2153 default: 2154 WARN_ON(1); 2155 break; 2156 } 2157 2158 return -EIO; 2159 } 2160 2161 #define SCAN_TIMEOUT 20000 2162 2163 void iwl_mvm_scan_timeout_wk(struct work_struct *work) 2164 { 2165 struct delayed_work *delayed_work = to_delayed_work(work); 2166 struct iwl_mvm *mvm = container_of(delayed_work, struct iwl_mvm, 2167 scan_timeout_dwork); 2168 2169 IWL_ERR(mvm, "regular scan timed out\n"); 2170 2171 iwl_force_nmi(mvm->trans); 2172 } 2173 2174 static void iwl_mvm_fill_scan_type(struct iwl_mvm *mvm, 2175 struct iwl_mvm_scan_params *params, 2176 struct ieee80211_vif *vif) 2177 { 2178 if (iwl_mvm_is_cdb_supported(mvm)) { 2179 params->type = 2180 iwl_mvm_get_scan_type_band(mvm, vif, 2181 NL80211_BAND_2GHZ); 2182 params->hb_type = 2183 iwl_mvm_get_scan_type_band(mvm, vif, 2184 NL80211_BAND_5GHZ); 2185 } else { 2186 params->type = iwl_mvm_get_scan_type(mvm, vif); 2187 } 2188 } 2189 2190 struct iwl_scan_umac_handler { 2191 u8 version; 2192 int (*handler)(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2193 struct iwl_mvm_scan_params *params, int type, int uid); 2194 }; 2195 2196 #define IWL_SCAN_UMAC_HANDLER(_ver) { \ 2197 .version = _ver, \ 2198 .handler = iwl_mvm_scan_umac_v##_ver, \ 2199 } 2200 2201 static const struct iwl_scan_umac_handler iwl_scan_umac_handlers[] = { 2202 /* set the newest version first to shorten the list traverse time */ 2203 IWL_SCAN_UMAC_HANDLER(14), 2204 IWL_SCAN_UMAC_HANDLER(12), 2205 }; 2206 2207 static int iwl_mvm_build_scan_cmd(struct iwl_mvm *mvm, 2208 struct ieee80211_vif *vif, 2209 struct iwl_host_cmd *hcmd, 2210 struct iwl_mvm_scan_params *params, 2211 int type) 2212 { 2213 int uid, i; 2214 u8 scan_ver; 2215 2216 lockdep_assert_held(&mvm->mutex); 2217 memset(mvm->scan_cmd, 0, ksize(mvm->scan_cmd)); 2218 2219 if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) { 2220 hcmd->id = SCAN_OFFLOAD_REQUEST_CMD; 2221 2222 return iwl_mvm_scan_lmac(mvm, vif, params); 2223 } 2224 2225 uid = iwl_mvm_scan_uid_by_status(mvm, 0); 2226 if (uid < 0) 2227 return uid; 2228 2229 hcmd->id = iwl_cmd_id(SCAN_REQ_UMAC, IWL_ALWAYS_LONG_GROUP, 0); 2230 2231 scan_ver = iwl_fw_lookup_cmd_ver(mvm->fw, IWL_ALWAYS_LONG_GROUP, 2232 SCAN_REQ_UMAC); 2233 2234 for (i = 0; i < ARRAY_SIZE(iwl_scan_umac_handlers); i++) { 2235 const struct iwl_scan_umac_handler *ver_handler = 2236 &iwl_scan_umac_handlers[i]; 2237 2238 if (ver_handler->version != scan_ver) 2239 continue; 2240 2241 return ver_handler->handler(mvm, vif, params, type, uid); 2242 } 2243 2244 return iwl_mvm_scan_umac(mvm, vif, params, type, uid); 2245 } 2246 2247 int iwl_mvm_reg_scan_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif, 2248 struct cfg80211_scan_request *req, 2249 struct ieee80211_scan_ies *ies) 2250 { 2251 struct iwl_host_cmd hcmd = { 2252 .len = { iwl_mvm_scan_size(mvm), }, 2253 .data = { mvm->scan_cmd, }, 2254 .dataflags = { IWL_HCMD_DFL_NOCOPY, }, 2255 }; 2256 struct iwl_mvm_scan_params params = {}; 2257 int ret; 2258 struct cfg80211_sched_scan_plan scan_plan = { .iterations = 1 }; 2259 2260 lockdep_assert_held(&mvm->mutex); 2261 2262 if (iwl_mvm_is_lar_supported(mvm) && !mvm->lar_regdom_set) { 2263 IWL_ERR(mvm, "scan while LAR regdomain is not set\n"); 2264 return -EBUSY; 2265 } 2266 2267 ret = iwl_mvm_check_running_scans(mvm, IWL_MVM_SCAN_REGULAR); 2268 if (ret) 2269 return ret; 2270 2271 /* we should have failed registration if scan_cmd was NULL */ 2272 if (WARN_ON(!mvm->scan_cmd)) 2273 return -ENOMEM; 2274 2275 if (!iwl_mvm_scan_fits(mvm, req->n_ssids, ies, req->n_channels)) 2276 return -ENOBUFS; 2277 2278 params.n_ssids = req->n_ssids; 2279 params.flags = req->flags; 2280 params.n_channels = req->n_channels; 2281 params.delay = 0; 2282 params.ssids = req->ssids; 2283 params.channels = req->channels; 2284 params.mac_addr = req->mac_addr; 2285 params.mac_addr_mask = req->mac_addr_mask; 2286 params.no_cck = req->no_cck; 2287 params.pass_all = true; 2288 params.n_match_sets = 0; 2289 params.match_sets = NULL; 2290 2291 params.scan_plans = &scan_plan; 2292 params.n_scan_plans = 1; 2293 2294 iwl_mvm_fill_scan_type(mvm, ¶ms, vif); 2295 2296 ret = iwl_mvm_get_measurement_dwell(mvm, req, ¶ms); 2297 if (ret < 0) 2298 return ret; 2299 2300 params.measurement_dwell = ret; 2301 2302 iwl_mvm_build_scan_probe(mvm, vif, ies, ¶ms); 2303 2304 ret = iwl_mvm_build_scan_cmd(mvm, vif, &hcmd, ¶ms, 2305 IWL_MVM_SCAN_REGULAR); 2306 2307 if (ret) 2308 return ret; 2309 2310 iwl_mvm_pause_tcm(mvm, false); 2311 2312 ret = iwl_mvm_send_cmd(mvm, &hcmd); 2313 if (ret) { 2314 /* If the scan failed, it usually means that the FW was unable 2315 * to allocate the time events. Warn on it, but maybe we 2316 * should try to send the command again with different params. 2317 */ 2318 IWL_ERR(mvm, "Scan failed! ret %d\n", ret); 2319 iwl_mvm_resume_tcm(mvm); 2320 return ret; 2321 } 2322 2323 IWL_DEBUG_SCAN(mvm, "Scan request was sent successfully\n"); 2324 mvm->scan_status |= IWL_MVM_SCAN_REGULAR; 2325 mvm->scan_vif = iwl_mvm_vif_from_mac80211(vif); 2326 2327 schedule_delayed_work(&mvm->scan_timeout_dwork, 2328 msecs_to_jiffies(SCAN_TIMEOUT)); 2329 2330 return 0; 2331 } 2332 2333 int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm, 2334 struct ieee80211_vif *vif, 2335 struct cfg80211_sched_scan_request *req, 2336 struct ieee80211_scan_ies *ies, 2337 int type) 2338 { 2339 struct iwl_host_cmd hcmd = { 2340 .len = { iwl_mvm_scan_size(mvm), }, 2341 .data = { mvm->scan_cmd, }, 2342 .dataflags = { IWL_HCMD_DFL_NOCOPY, }, 2343 }; 2344 struct iwl_mvm_scan_params params = {}; 2345 int ret; 2346 2347 lockdep_assert_held(&mvm->mutex); 2348 2349 if (iwl_mvm_is_lar_supported(mvm) && !mvm->lar_regdom_set) { 2350 IWL_ERR(mvm, "sched-scan while LAR regdomain is not set\n"); 2351 return -EBUSY; 2352 } 2353 2354 ret = iwl_mvm_check_running_scans(mvm, type); 2355 if (ret) 2356 return ret; 2357 2358 /* we should have failed registration if scan_cmd was NULL */ 2359 if (WARN_ON(!mvm->scan_cmd)) 2360 return -ENOMEM; 2361 2362 if (!iwl_mvm_scan_fits(mvm, req->n_ssids, ies, req->n_channels)) 2363 return -ENOBUFS; 2364 2365 params.n_ssids = req->n_ssids; 2366 params.flags = req->flags; 2367 params.n_channels = req->n_channels; 2368 params.ssids = req->ssids; 2369 params.channels = req->channels; 2370 params.mac_addr = req->mac_addr; 2371 params.mac_addr_mask = req->mac_addr_mask; 2372 params.no_cck = false; 2373 params.pass_all = iwl_mvm_scan_pass_all(mvm, req); 2374 params.n_match_sets = req->n_match_sets; 2375 params.match_sets = req->match_sets; 2376 if (!req->n_scan_plans) 2377 return -EINVAL; 2378 2379 params.n_scan_plans = req->n_scan_plans; 2380 params.scan_plans = req->scan_plans; 2381 2382 iwl_mvm_fill_scan_type(mvm, ¶ms, vif); 2383 2384 /* In theory, LMAC scans can handle a 32-bit delay, but since 2385 * waiting for over 18 hours to start the scan is a bit silly 2386 * and to keep it aligned with UMAC scans (which only support 2387 * 16-bit delays), trim it down to 16-bits. 2388 */ 2389 if (req->delay > U16_MAX) { 2390 IWL_DEBUG_SCAN(mvm, 2391 "delay value is > 16-bits, set to max possible\n"); 2392 params.delay = U16_MAX; 2393 } else { 2394 params.delay = req->delay; 2395 } 2396 2397 ret = iwl_mvm_config_sched_scan_profiles(mvm, req); 2398 if (ret) 2399 return ret; 2400 2401 iwl_mvm_build_scan_probe(mvm, vif, ies, ¶ms); 2402 2403 ret = iwl_mvm_build_scan_cmd(mvm, vif, &hcmd, ¶ms, type); 2404 2405 if (ret) 2406 return ret; 2407 2408 ret = iwl_mvm_send_cmd(mvm, &hcmd); 2409 if (!ret) { 2410 IWL_DEBUG_SCAN(mvm, 2411 "Sched scan request was sent successfully\n"); 2412 mvm->scan_status |= type; 2413 } else { 2414 /* If the scan failed, it usually means that the FW was unable 2415 * to allocate the time events. Warn on it, but maybe we 2416 * should try to send the command again with different params. 2417 */ 2418 IWL_ERR(mvm, "Sched scan failed! ret %d\n", ret); 2419 } 2420 2421 return ret; 2422 } 2423 2424 void iwl_mvm_rx_umac_scan_complete_notif(struct iwl_mvm *mvm, 2425 struct iwl_rx_cmd_buffer *rxb) 2426 { 2427 struct iwl_rx_packet *pkt = rxb_addr(rxb); 2428 struct iwl_umac_scan_complete *notif = (void *)pkt->data; 2429 u32 uid = __le32_to_cpu(notif->uid); 2430 bool aborted = (notif->status == IWL_SCAN_OFFLOAD_ABORTED); 2431 2432 if (WARN_ON(!(mvm->scan_uid_status[uid] & mvm->scan_status))) 2433 return; 2434 2435 /* if the scan is already stopping, we don't need to notify mac80211 */ 2436 if (mvm->scan_uid_status[uid] == IWL_MVM_SCAN_REGULAR) { 2437 struct cfg80211_scan_info info = { 2438 .aborted = aborted, 2439 .scan_start_tsf = mvm->scan_start, 2440 }; 2441 2442 memcpy(info.tsf_bssid, mvm->scan_vif->bssid, ETH_ALEN); 2443 ieee80211_scan_completed(mvm->hw, &info); 2444 mvm->scan_vif = NULL; 2445 cancel_delayed_work(&mvm->scan_timeout_dwork); 2446 iwl_mvm_resume_tcm(mvm); 2447 } else if (mvm->scan_uid_status[uid] == IWL_MVM_SCAN_SCHED) { 2448 ieee80211_sched_scan_stopped(mvm->hw); 2449 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED; 2450 } 2451 2452 mvm->scan_status &= ~mvm->scan_uid_status[uid]; 2453 IWL_DEBUG_SCAN(mvm, 2454 "Scan completed, uid %u type %u, status %s, EBS status %s\n", 2455 uid, mvm->scan_uid_status[uid], 2456 notif->status == IWL_SCAN_OFFLOAD_COMPLETED ? 2457 "completed" : "aborted", 2458 iwl_mvm_ebs_status_str(notif->ebs_status)); 2459 IWL_DEBUG_SCAN(mvm, 2460 "Last line %d, Last iteration %d, Time from last iteration %d\n", 2461 notif->last_schedule, notif->last_iter, 2462 __le32_to_cpu(notif->time_from_last_iter)); 2463 2464 if (notif->ebs_status != IWL_SCAN_EBS_SUCCESS && 2465 notif->ebs_status != IWL_SCAN_EBS_INACTIVE) 2466 mvm->last_ebs_successful = false; 2467 2468 mvm->scan_uid_status[uid] = 0; 2469 } 2470 2471 void iwl_mvm_rx_umac_scan_iter_complete_notif(struct iwl_mvm *mvm, 2472 struct iwl_rx_cmd_buffer *rxb) 2473 { 2474 struct iwl_rx_packet *pkt = rxb_addr(rxb); 2475 struct iwl_umac_scan_iter_complete_notif *notif = (void *)pkt->data; 2476 2477 mvm->scan_start = le64_to_cpu(notif->start_tsf); 2478 2479 IWL_DEBUG_SCAN(mvm, 2480 "UMAC Scan iteration complete: status=0x%x scanned_channels=%d\n", 2481 notif->status, notif->scanned_channels); 2482 2483 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_FOUND) { 2484 IWL_DEBUG_SCAN(mvm, "Pass all scheduled scan results found\n"); 2485 ieee80211_sched_scan_results(mvm->hw); 2486 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_ENABLED; 2487 } 2488 2489 IWL_DEBUG_SCAN(mvm, 2490 "UMAC Scan iteration complete: scan started at %llu (TSF)\n", 2491 mvm->scan_start); 2492 } 2493 2494 static int iwl_mvm_umac_scan_abort(struct iwl_mvm *mvm, int type) 2495 { 2496 struct iwl_umac_scan_abort cmd = {}; 2497 int uid, ret; 2498 2499 lockdep_assert_held(&mvm->mutex); 2500 2501 /* We should always get a valid index here, because we already 2502 * checked that this type of scan was running in the generic 2503 * code. 2504 */ 2505 uid = iwl_mvm_scan_uid_by_status(mvm, type); 2506 if (WARN_ON_ONCE(uid < 0)) 2507 return uid; 2508 2509 cmd.uid = cpu_to_le32(uid); 2510 2511 IWL_DEBUG_SCAN(mvm, "Sending scan abort, uid %u\n", uid); 2512 2513 ret = iwl_mvm_send_cmd_pdu(mvm, 2514 iwl_cmd_id(SCAN_ABORT_UMAC, 2515 IWL_ALWAYS_LONG_GROUP, 0), 2516 0, sizeof(cmd), &cmd); 2517 if (!ret) 2518 mvm->scan_uid_status[uid] = type << IWL_MVM_SCAN_STOPPING_SHIFT; 2519 2520 return ret; 2521 } 2522 2523 static int iwl_mvm_scan_stop_wait(struct iwl_mvm *mvm, int type) 2524 { 2525 struct iwl_notification_wait wait_scan_done; 2526 static const u16 scan_done_notif[] = { SCAN_COMPLETE_UMAC, 2527 SCAN_OFFLOAD_COMPLETE, }; 2528 int ret; 2529 2530 lockdep_assert_held(&mvm->mutex); 2531 2532 iwl_init_notification_wait(&mvm->notif_wait, &wait_scan_done, 2533 scan_done_notif, 2534 ARRAY_SIZE(scan_done_notif), 2535 NULL, NULL); 2536 2537 IWL_DEBUG_SCAN(mvm, "Preparing to stop scan, type %x\n", type); 2538 2539 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) 2540 ret = iwl_mvm_umac_scan_abort(mvm, type); 2541 else 2542 ret = iwl_mvm_lmac_scan_abort(mvm); 2543 2544 if (ret) { 2545 IWL_DEBUG_SCAN(mvm, "couldn't stop scan type %d\n", type); 2546 iwl_remove_notification(&mvm->notif_wait, &wait_scan_done); 2547 return ret; 2548 } 2549 2550 return iwl_wait_notification(&mvm->notif_wait, &wait_scan_done, 2551 1 * HZ); 2552 } 2553 2554 #define IWL_SCAN_REQ_UMAC_HANDLE_SIZE(_ver) { \ 2555 case (_ver): return sizeof(struct iwl_scan_req_umac_v##_ver); \ 2556 } 2557 2558 static int iwl_scan_req_umac_get_size(u8 scan_ver) 2559 { 2560 switch (scan_ver) { 2561 IWL_SCAN_REQ_UMAC_HANDLE_SIZE(14); 2562 IWL_SCAN_REQ_UMAC_HANDLE_SIZE(12); 2563 } 2564 2565 return 0; 2566 } 2567 2568 int iwl_mvm_scan_size(struct iwl_mvm *mvm) 2569 { 2570 int base_size, tail_size; 2571 u8 scan_ver = iwl_fw_lookup_cmd_ver(mvm->fw, IWL_ALWAYS_LONG_GROUP, 2572 SCAN_REQ_UMAC); 2573 2574 base_size = iwl_scan_req_umac_get_size(scan_ver); 2575 if (base_size) 2576 return base_size; 2577 2578 2579 if (iwl_mvm_is_adaptive_dwell_v2_supported(mvm)) 2580 base_size = IWL_SCAN_REQ_UMAC_SIZE_V8; 2581 else if (iwl_mvm_is_adaptive_dwell_supported(mvm)) 2582 base_size = IWL_SCAN_REQ_UMAC_SIZE_V7; 2583 else if (iwl_mvm_cdb_scan_api(mvm)) 2584 base_size = IWL_SCAN_REQ_UMAC_SIZE_V6; 2585 else 2586 base_size = IWL_SCAN_REQ_UMAC_SIZE_V1; 2587 2588 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) { 2589 if (iwl_mvm_is_scan_ext_chan_supported(mvm)) 2590 tail_size = sizeof(struct iwl_scan_req_umac_tail_v2); 2591 else 2592 tail_size = sizeof(struct iwl_scan_req_umac_tail_v1); 2593 2594 return base_size + 2595 sizeof(struct iwl_scan_channel_cfg_umac) * 2596 mvm->fw->ucode_capa.n_scan_channels + 2597 tail_size; 2598 } 2599 return sizeof(struct iwl_scan_req_lmac) + 2600 sizeof(struct iwl_scan_channel_cfg_lmac) * 2601 mvm->fw->ucode_capa.n_scan_channels + 2602 sizeof(struct iwl_scan_probe_req_v1); 2603 } 2604 2605 /* 2606 * This function is used in nic restart flow, to inform mac80211 about scans 2607 * that was aborted by restart flow or by an assert. 2608 */ 2609 void iwl_mvm_report_scan_aborted(struct iwl_mvm *mvm) 2610 { 2611 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) { 2612 int uid, i; 2613 2614 uid = iwl_mvm_scan_uid_by_status(mvm, IWL_MVM_SCAN_REGULAR); 2615 if (uid >= 0) { 2616 struct cfg80211_scan_info info = { 2617 .aborted = true, 2618 }; 2619 2620 ieee80211_scan_completed(mvm->hw, &info); 2621 mvm->scan_uid_status[uid] = 0; 2622 } 2623 uid = iwl_mvm_scan_uid_by_status(mvm, IWL_MVM_SCAN_SCHED); 2624 if (uid >= 0 && !mvm->fw_restart) { 2625 ieee80211_sched_scan_stopped(mvm->hw); 2626 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED; 2627 mvm->scan_uid_status[uid] = 0; 2628 } 2629 2630 /* We shouldn't have any UIDs still set. Loop over all the 2631 * UIDs to make sure there's nothing left there and warn if 2632 * any is found. 2633 */ 2634 for (i = 0; i < mvm->max_scans; i++) { 2635 if (WARN_ONCE(mvm->scan_uid_status[i], 2636 "UMAC scan UID %d status was not cleaned\n", 2637 i)) 2638 mvm->scan_uid_status[i] = 0; 2639 } 2640 } else { 2641 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR) { 2642 struct cfg80211_scan_info info = { 2643 .aborted = true, 2644 }; 2645 2646 ieee80211_scan_completed(mvm->hw, &info); 2647 } 2648 2649 /* Sched scan will be restarted by mac80211 in 2650 * restart_hw, so do not report if FW is about to be 2651 * restarted. 2652 */ 2653 if ((mvm->scan_status & IWL_MVM_SCAN_SCHED) && 2654 !mvm->fw_restart) { 2655 ieee80211_sched_scan_stopped(mvm->hw); 2656 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED; 2657 } 2658 } 2659 } 2660 2661 int iwl_mvm_scan_stop(struct iwl_mvm *mvm, int type, bool notify) 2662 { 2663 int ret; 2664 2665 if (!(mvm->scan_status & type)) 2666 return 0; 2667 2668 if (iwl_mvm_is_radio_killed(mvm)) { 2669 ret = 0; 2670 goto out; 2671 } 2672 2673 ret = iwl_mvm_scan_stop_wait(mvm, type); 2674 if (!ret) 2675 mvm->scan_status |= type << IWL_MVM_SCAN_STOPPING_SHIFT; 2676 out: 2677 /* Clear the scan status so the next scan requests will 2678 * succeed and mark the scan as stopping, so that the Rx 2679 * handler doesn't do anything, as the scan was stopped from 2680 * above. 2681 */ 2682 mvm->scan_status &= ~type; 2683 2684 if (type == IWL_MVM_SCAN_REGULAR) { 2685 cancel_delayed_work(&mvm->scan_timeout_dwork); 2686 if (notify) { 2687 struct cfg80211_scan_info info = { 2688 .aborted = true, 2689 }; 2690 2691 ieee80211_scan_completed(mvm->hw, &info); 2692 } 2693 } else if (notify) { 2694 ieee80211_sched_scan_stopped(mvm->hw); 2695 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED; 2696 } 2697 2698 return ret; 2699 } 2700