1 // SPDX-License-Identifier: GPL-2.0-only
3 * Scanning implementation
5 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
6 * Copyright 2004, Instant802 Networks, Inc.
7 * Copyright 2005, Devicescape Software, Inc.
8 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
9 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
10 * Copyright 2013-2015 Intel Mobile Communications GmbH
11 * Copyright 2016-2017 Intel Deutschland GmbH
12 * Copyright (C) 2018-2020 Intel Corporation
15 #include <linux/if_arp.h>
16 #include <linux/etherdevice.h>
17 #include <linux/rtnetlink.h>
18 #include <net/sch_generic.h>
19 #include <linux/slab.h>
20 #include <linux/export.h>
21 #include <linux/random.h>
22 #include <net/mac80211.h>
24 #include "ieee80211_i.h"
25 #include "driver-ops.h"
28 #define IEEE80211_PROBE_DELAY (HZ / 33)
29 #define IEEE80211_CHANNEL_TIME (HZ / 33)
30 #define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 9)
32 void ieee80211_rx_bss_put(struct ieee80211_local
*local
,
33 struct ieee80211_bss
*bss
)
37 cfg80211_put_bss(local
->hw
.wiphy
,
38 container_of((void *)bss
, struct cfg80211_bss
, priv
));
41 static bool is_uapsd_supported(struct ieee802_11_elems
*elems
)
45 if (elems
->wmm_info
&& elems
->wmm_info_len
== 7
46 && elems
->wmm_info
[5] == 1)
47 qos_info
= elems
->wmm_info
[6];
48 else if (elems
->wmm_param
&& elems
->wmm_param_len
== 24
49 && elems
->wmm_param
[5] == 1)
50 qos_info
= elems
->wmm_param
[6];
52 /* no valid wmm information or parameter element found */
55 return qos_info
& IEEE80211_WMM_IE_AP_QOSINFO_UAPSD
;
59 ieee80211_update_bss_from_elems(struct ieee80211_local
*local
,
60 struct ieee80211_bss
*bss
,
61 struct ieee802_11_elems
*elems
,
62 struct ieee80211_rx_status
*rx_status
,
68 bss
->device_ts_beacon
= rx_status
->device_timestamp
;
70 bss
->device_ts_presp
= rx_status
->device_timestamp
;
72 if (elems
->parse_error
) {
74 bss
->corrupt_data
|= IEEE80211_BSS_CORRUPT_BEACON
;
76 bss
->corrupt_data
|= IEEE80211_BSS_CORRUPT_PROBE_RESP
;
79 bss
->corrupt_data
&= ~IEEE80211_BSS_CORRUPT_BEACON
;
81 bss
->corrupt_data
&= ~IEEE80211_BSS_CORRUPT_PROBE_RESP
;
84 /* save the ERP value so that it is available at association time */
85 if (elems
->erp_info
&& (!elems
->parse_error
||
86 !(bss
->valid_data
& IEEE80211_BSS_VALID_ERP
))) {
87 bss
->erp_value
= elems
->erp_info
[0];
88 bss
->has_erp_value
= true;
89 if (!elems
->parse_error
)
90 bss
->valid_data
|= IEEE80211_BSS_VALID_ERP
;
93 /* replace old supported rates if we get new values */
94 if (!elems
->parse_error
||
95 !(bss
->valid_data
& IEEE80211_BSS_VALID_RATES
)) {
97 if (elems
->supp_rates
) {
98 clen
= IEEE80211_MAX_SUPP_RATES
;
99 if (clen
> elems
->supp_rates_len
)
100 clen
= elems
->supp_rates_len
;
101 memcpy(bss
->supp_rates
, elems
->supp_rates
, clen
);
104 if (elems
->ext_supp_rates
) {
105 clen
= IEEE80211_MAX_SUPP_RATES
- srlen
;
106 if (clen
> elems
->ext_supp_rates_len
)
107 clen
= elems
->ext_supp_rates_len
;
108 memcpy(bss
->supp_rates
+ srlen
, elems
->ext_supp_rates
,
113 bss
->supp_rates_len
= srlen
;
114 if (!elems
->parse_error
)
115 bss
->valid_data
|= IEEE80211_BSS_VALID_RATES
;
119 if (!elems
->parse_error
||
120 !(bss
->valid_data
& IEEE80211_BSS_VALID_WMM
)) {
121 bss
->wmm_used
= elems
->wmm_param
|| elems
->wmm_info
;
122 bss
->uapsd_supported
= is_uapsd_supported(elems
);
123 if (!elems
->parse_error
)
124 bss
->valid_data
|= IEEE80211_BSS_VALID_WMM
;
128 struct ieee80211_supported_band
*sband
=
129 local
->hw
.wiphy
->bands
[rx_status
->band
];
130 if (!(rx_status
->encoding
== RX_ENC_HT
) &&
131 !(rx_status
->encoding
== RX_ENC_VHT
))
133 &sband
->bitrates
[rx_status
->rate_idx
];
136 if (elems
->vht_cap_elem
)
138 le32_to_cpu(elems
->vht_cap_elem
->vht_cap_info
);
140 bss
->vht_cap_info
= 0;
143 struct ieee80211_bss
*
144 ieee80211_bss_info_update(struct ieee80211_local
*local
,
145 struct ieee80211_rx_status
*rx_status
,
146 struct ieee80211_mgmt
*mgmt
, size_t len
,
147 struct ieee80211_channel
*channel
)
149 bool beacon
= ieee80211_is_beacon(mgmt
->frame_control
) ||
150 ieee80211_is_s1g_beacon(mgmt
->frame_control
);
151 struct cfg80211_bss
*cbss
, *non_tx_cbss
;
152 struct ieee80211_bss
*bss
, *non_tx_bss
;
153 struct cfg80211_inform_bss bss_meta
= {
154 .boottime_ns
= rx_status
->boottime_ns
,
157 struct ieee80211_sub_if_data
*scan_sdata
;
158 struct ieee802_11_elems elems
;
162 if (rx_status
->flag
& RX_FLAG_NO_SIGNAL_VAL
)
163 bss_meta
.signal
= 0; /* invalid signal indication */
164 else if (ieee80211_hw_check(&local
->hw
, SIGNAL_DBM
))
165 bss_meta
.signal
= rx_status
->signal
* 100;
166 else if (ieee80211_hw_check(&local
->hw
, SIGNAL_UNSPEC
))
167 bss_meta
.signal
= (rx_status
->signal
* 100) / local
->hw
.max_signal
;
169 bss_meta
.scan_width
= NL80211_BSS_CHAN_WIDTH_20
;
170 if (rx_status
->bw
== RATE_INFO_BW_5
)
171 bss_meta
.scan_width
= NL80211_BSS_CHAN_WIDTH_5
;
172 else if (rx_status
->bw
== RATE_INFO_BW_10
)
173 bss_meta
.scan_width
= NL80211_BSS_CHAN_WIDTH_10
;
175 bss_meta
.chan
= channel
;
178 scan_sdata
= rcu_dereference(local
->scan_sdata
);
179 if (scan_sdata
&& scan_sdata
->vif
.type
== NL80211_IFTYPE_STATION
&&
180 scan_sdata
->vif
.bss_conf
.assoc
&&
181 ieee80211_have_rx_timestamp(rx_status
)) {
182 bss_meta
.parent_tsf
=
183 ieee80211_calculate_rx_timestamp(local
, rx_status
,
185 ether_addr_copy(bss_meta
.parent_bssid
,
186 scan_sdata
->vif
.bss_conf
.bssid
);
190 cbss
= cfg80211_inform_bss_frame_data(local
->hw
.wiphy
, &bss_meta
,
191 mgmt
, len
, GFP_ATOMIC
);
195 if (ieee80211_is_probe_resp(mgmt
->frame_control
)) {
196 elements
= mgmt
->u
.probe_resp
.variable
;
197 baselen
= offsetof(struct ieee80211_mgmt
,
198 u
.probe_resp
.variable
);
199 } else if (ieee80211_is_s1g_beacon(mgmt
->frame_control
)) {
200 struct ieee80211_ext
*ext
= (void *) mgmt
;
202 baselen
= offsetof(struct ieee80211_ext
, u
.s1g_beacon
.variable
);
203 elements
= ext
->u
.s1g_beacon
.variable
;
205 baselen
= offsetof(struct ieee80211_mgmt
, u
.beacon
.variable
);
206 elements
= mgmt
->u
.beacon
.variable
;
212 ieee802_11_parse_elems(elements
, len
- baselen
, false, &elems
,
213 mgmt
->bssid
, cbss
->bssid
);
215 /* In case the signal is invalid update the status */
216 signal_valid
= channel
== cbss
->channel
;
218 rx_status
->flag
|= RX_FLAG_NO_SIGNAL_VAL
;
220 bss
= (void *)cbss
->priv
;
221 ieee80211_update_bss_from_elems(local
, bss
, &elems
, rx_status
, beacon
);
223 list_for_each_entry(non_tx_cbss
, &cbss
->nontrans_list
, nontrans_list
) {
224 non_tx_bss
= (void *)non_tx_cbss
->priv
;
226 ieee80211_update_bss_from_elems(local
, non_tx_bss
, &elems
,
233 static bool ieee80211_scan_accept_presp(struct ieee80211_sub_if_data
*sdata
,
234 u32 scan_flags
, const u8
*da
)
238 /* accept broadcast for OCE */
239 if (scan_flags
& NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP
&&
240 is_broadcast_ether_addr(da
))
242 if (scan_flags
& NL80211_SCAN_FLAG_RANDOM_ADDR
)
244 return ether_addr_equal(da
, sdata
->vif
.addr
);
247 void ieee80211_scan_rx(struct ieee80211_local
*local
, struct sk_buff
*skb
)
249 struct ieee80211_rx_status
*rx_status
= IEEE80211_SKB_RXCB(skb
);
250 struct ieee80211_sub_if_data
*sdata1
, *sdata2
;
251 struct ieee80211_mgmt
*mgmt
= (void *)skb
->data
;
252 struct ieee80211_bss
*bss
;
253 struct ieee80211_channel
*channel
;
254 size_t min_hdr_len
= offsetof(struct ieee80211_mgmt
,
255 u
.probe_resp
.variable
);
257 if (!ieee80211_is_probe_resp(mgmt
->frame_control
) &&
258 !ieee80211_is_beacon(mgmt
->frame_control
) &&
259 !ieee80211_is_s1g_beacon(mgmt
->frame_control
))
262 if (ieee80211_is_s1g_beacon(mgmt
->frame_control
)) {
263 if (ieee80211_is_s1g_short_beacon(mgmt
->frame_control
))
264 min_hdr_len
= offsetof(struct ieee80211_ext
,
265 u
.s1g_short_beacon
.variable
);
267 min_hdr_len
= offsetof(struct ieee80211_ext
,
271 if (skb
->len
< min_hdr_len
)
274 sdata1
= rcu_dereference(local
->scan_sdata
);
275 sdata2
= rcu_dereference(local
->sched_scan_sdata
);
277 if (likely(!sdata1
&& !sdata2
))
280 if (ieee80211_is_probe_resp(mgmt
->frame_control
)) {
281 struct cfg80211_scan_request
*scan_req
;
282 struct cfg80211_sched_scan_request
*sched_scan_req
;
283 u32 scan_req_flags
= 0, sched_scan_req_flags
= 0;
285 scan_req
= rcu_dereference(local
->scan_req
);
286 sched_scan_req
= rcu_dereference(local
->sched_scan_req
);
289 scan_req_flags
= scan_req
->flags
;
292 sched_scan_req_flags
= sched_scan_req
->flags
;
294 /* ignore ProbeResp to foreign address or non-bcast (OCE)
295 * unless scanning with randomised address
297 if (!ieee80211_scan_accept_presp(sdata1
, scan_req_flags
,
299 !ieee80211_scan_accept_presp(sdata2
, sched_scan_req_flags
,
304 channel
= ieee80211_get_channel_khz(local
->hw
.wiphy
,
305 ieee80211_rx_status_to_khz(rx_status
));
307 if (!channel
|| channel
->flags
& IEEE80211_CHAN_DISABLED
)
310 bss
= ieee80211_bss_info_update(local
, rx_status
,
314 ieee80211_rx_bss_put(local
, bss
);
318 ieee80211_prepare_scan_chandef(struct cfg80211_chan_def
*chandef
,
319 enum nl80211_bss_scan_width scan_width
)
321 memset(chandef
, 0, sizeof(*chandef
));
322 switch (scan_width
) {
323 case NL80211_BSS_CHAN_WIDTH_5
:
324 chandef
->width
= NL80211_CHAN_WIDTH_5
;
326 case NL80211_BSS_CHAN_WIDTH_10
:
327 chandef
->width
= NL80211_CHAN_WIDTH_10
;
330 chandef
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
335 /* return false if no more work */
336 static bool ieee80211_prep_hw_scan(struct ieee80211_sub_if_data
*sdata
)
338 struct ieee80211_local
*local
= sdata
->local
;
339 struct cfg80211_scan_request
*req
;
340 struct cfg80211_chan_def chandef
;
342 int i
, ielen
, n_chans
;
345 req
= rcu_dereference_protected(local
->scan_req
,
346 lockdep_is_held(&local
->mtx
));
348 if (test_bit(SCAN_HW_CANCELLED
, &local
->scanning
))
351 if (ieee80211_hw_check(&local
->hw
, SINGLE_SCAN_ON_ALL_BANDS
)) {
352 for (i
= 0; i
< req
->n_channels
; i
++) {
353 local
->hw_scan_req
->req
.channels
[i
] = req
->channels
[i
];
354 bands_used
|= BIT(req
->channels
[i
]->band
);
357 n_chans
= req
->n_channels
;
360 if (local
->hw_scan_band
== NUM_NL80211_BANDS
)
365 for (i
= 0; i
< req
->n_channels
; i
++) {
366 if (req
->channels
[i
]->band
!=
369 local
->hw_scan_req
->req
.channels
[n_chans
] =
372 bands_used
|= BIT(req
->channels
[i
]->band
);
375 local
->hw_scan_band
++;
379 local
->hw_scan_req
->req
.n_channels
= n_chans
;
380 ieee80211_prepare_scan_chandef(&chandef
, req
->scan_width
);
382 if (req
->flags
& NL80211_SCAN_FLAG_MIN_PREQ_CONTENT
)
383 flags
|= IEEE80211_PROBE_FLAG_MIN_CONTENT
;
385 ielen
= ieee80211_build_preq_ies(sdata
,
386 (u8
*)local
->hw_scan_req
->req
.ie
,
387 local
->hw_scan_ies_bufsize
,
388 &local
->hw_scan_req
->ies
,
389 req
->ie
, req
->ie_len
,
390 bands_used
, req
->rates
, &chandef
,
392 local
->hw_scan_req
->req
.ie_len
= ielen
;
393 local
->hw_scan_req
->req
.no_cck
= req
->no_cck
;
394 ether_addr_copy(local
->hw_scan_req
->req
.mac_addr
, req
->mac_addr
);
395 ether_addr_copy(local
->hw_scan_req
->req
.mac_addr_mask
,
397 ether_addr_copy(local
->hw_scan_req
->req
.bssid
, req
->bssid
);
402 static void __ieee80211_scan_completed(struct ieee80211_hw
*hw
, bool aborted
)
404 struct ieee80211_local
*local
= hw_to_local(hw
);
405 bool hw_scan
= test_bit(SCAN_HW_SCANNING
, &local
->scanning
);
406 bool was_scanning
= local
->scanning
;
407 struct cfg80211_scan_request
*scan_req
;
408 struct ieee80211_sub_if_data
*scan_sdata
;
409 struct ieee80211_sub_if_data
*sdata
;
411 lockdep_assert_held(&local
->mtx
);
414 * It's ok to abort a not-yet-running scan (that
415 * we have one at all will be verified by checking
416 * local->scan_req next), but not to complete it
419 if (WARN_ON(!local
->scanning
&& !aborted
))
422 if (WARN_ON(!local
->scan_req
))
425 scan_sdata
= rcu_dereference_protected(local
->scan_sdata
,
426 lockdep_is_held(&local
->mtx
));
428 if (hw_scan
&& !aborted
&&
429 !ieee80211_hw_check(&local
->hw
, SINGLE_SCAN_ON_ALL_BANDS
) &&
430 ieee80211_prep_hw_scan(scan_sdata
)) {
433 rc
= drv_hw_scan(local
,
434 rcu_dereference_protected(local
->scan_sdata
,
435 lockdep_is_held(&local
->mtx
)),
441 /* HW scan failed and is going to be reported as aborted,
442 * so clear old scan info.
444 memset(&local
->scan_info
, 0, sizeof(local
->scan_info
));
448 kfree(local
->hw_scan_req
);
449 local
->hw_scan_req
= NULL
;
451 scan_req
= rcu_dereference_protected(local
->scan_req
,
452 lockdep_is_held(&local
->mtx
));
454 if (scan_req
!= local
->int_scan_req
) {
455 local
->scan_info
.aborted
= aborted
;
456 cfg80211_scan_done(scan_req
, &local
->scan_info
);
458 RCU_INIT_POINTER(local
->scan_req
, NULL
);
459 RCU_INIT_POINTER(local
->scan_sdata
, NULL
);
462 local
->scan_chandef
.chan
= NULL
;
464 /* Set power back to normal operating levels. */
465 ieee80211_hw_config(local
, 0);
468 ieee80211_configure_filter(local
);
469 drv_sw_scan_complete(local
, scan_sdata
);
470 ieee80211_offchannel_return(local
);
473 ieee80211_recalc_idle(local
);
475 ieee80211_mlme_notify_scan_completed(local
);
476 ieee80211_ibss_notify_scan_completed(local
);
478 /* Requeue all the work that might have been ignored while
479 * the scan was in progress; if there was none this will
480 * just be a no-op for the particular interface.
482 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
483 if (ieee80211_sdata_running(sdata
))
484 ieee80211_queue_work(&sdata
->local
->hw
, &sdata
->work
);
488 ieee80211_start_next_roc(local
);
491 void ieee80211_scan_completed(struct ieee80211_hw
*hw
,
492 struct cfg80211_scan_info
*info
)
494 struct ieee80211_local
*local
= hw_to_local(hw
);
496 trace_api_scan_completed(local
, info
->aborted
);
498 set_bit(SCAN_COMPLETED
, &local
->scanning
);
500 set_bit(SCAN_ABORTED
, &local
->scanning
);
502 memcpy(&local
->scan_info
, info
, sizeof(*info
));
504 ieee80211_queue_delayed_work(&local
->hw
, &local
->scan_work
, 0);
506 EXPORT_SYMBOL(ieee80211_scan_completed
);
508 static int ieee80211_start_sw_scan(struct ieee80211_local
*local
,
509 struct ieee80211_sub_if_data
*sdata
)
511 /* Software scan is not supported in multi-channel cases */
512 if (local
->use_chanctx
)
516 * Hardware/driver doesn't support hw_scan, so use software
517 * scanning instead. First send a nullfunc frame with power save
518 * bit on so that AP will buffer the frames for us while we are not
519 * listening, then send probe requests to each channel and wait for
520 * the responses. After all channels are scanned, tune back to the
521 * original channel and send a nullfunc frame with power save bit
522 * off to trigger the AP to send us all the buffered frames.
524 * Note that while local->sw_scanning is true everything else but
525 * nullfunc frames and probe requests will be dropped in
526 * ieee80211_tx_h_check_assoc().
528 drv_sw_scan_start(local
, sdata
, local
->scan_addr
);
530 local
->leave_oper_channel_time
= jiffies
;
531 local
->next_scan_state
= SCAN_DECISION
;
532 local
->scan_channel_idx
= 0;
534 ieee80211_offchannel_stop_vifs(local
);
536 /* ensure nullfunc is transmitted before leaving operating channel */
537 ieee80211_flush_queues(local
, NULL
, false);
539 ieee80211_configure_filter(local
);
541 /* We need to set power level at maximum rate for scanning. */
542 ieee80211_hw_config(local
, 0);
544 ieee80211_queue_delayed_work(&local
->hw
,
545 &local
->scan_work
, 0);
550 static bool __ieee80211_can_leave_ch(struct ieee80211_sub_if_data
*sdata
)
552 struct ieee80211_local
*local
= sdata
->local
;
553 struct ieee80211_sub_if_data
*sdata_iter
;
555 if (!ieee80211_is_radar_required(local
))
558 if (!regulatory_pre_cac_allowed(local
->hw
.wiphy
))
561 mutex_lock(&local
->iflist_mtx
);
562 list_for_each_entry(sdata_iter
, &local
->interfaces
, list
) {
563 if (sdata_iter
->wdev
.cac_started
) {
564 mutex_unlock(&local
->iflist_mtx
);
568 mutex_unlock(&local
->iflist_mtx
);
573 static bool ieee80211_can_scan(struct ieee80211_local
*local
,
574 struct ieee80211_sub_if_data
*sdata
)
576 if (!__ieee80211_can_leave_ch(sdata
))
579 if (!list_empty(&local
->roc_list
))
582 if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
&&
583 sdata
->u
.mgd
.flags
& IEEE80211_STA_CONNECTION_POLL
)
589 void ieee80211_run_deferred_scan(struct ieee80211_local
*local
)
591 lockdep_assert_held(&local
->mtx
);
593 if (!local
->scan_req
|| local
->scanning
)
596 if (!ieee80211_can_scan(local
,
597 rcu_dereference_protected(
599 lockdep_is_held(&local
->mtx
))))
602 ieee80211_queue_delayed_work(&local
->hw
, &local
->scan_work
,
603 round_jiffies_relative(0));
606 static void ieee80211_send_scan_probe_req(struct ieee80211_sub_if_data
*sdata
,
607 const u8
*src
, const u8
*dst
,
608 const u8
*ssid
, size_t ssid_len
,
609 const u8
*ie
, size_t ie_len
,
610 u32 ratemask
, u32 flags
, u32 tx_flags
,
611 struct ieee80211_channel
*channel
)
615 skb
= ieee80211_build_probe_req(sdata
, src
, dst
, ratemask
, channel
,
620 if (flags
& IEEE80211_PROBE_FLAG_RANDOM_SN
) {
621 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
622 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
623 u16 sn
= get_random_u32();
625 info
->control
.flags
|= IEEE80211_TX_CTRL_NO_SEQNO
;
627 cpu_to_le16(IEEE80211_SN_TO_SEQ(sn
));
629 IEEE80211_SKB_CB(skb
)->flags
|= tx_flags
;
630 ieee80211_tx_skb_tid_band(sdata
, skb
, 7, channel
->band
);
634 static void ieee80211_scan_state_send_probe(struct ieee80211_local
*local
,
635 unsigned long *next_delay
)
638 struct ieee80211_sub_if_data
*sdata
;
639 struct cfg80211_scan_request
*scan_req
;
640 enum nl80211_band band
= local
->hw
.conf
.chandef
.chan
->band
;
641 u32 flags
= 0, tx_flags
;
643 scan_req
= rcu_dereference_protected(local
->scan_req
,
644 lockdep_is_held(&local
->mtx
));
646 tx_flags
= IEEE80211_TX_INTFL_OFFCHAN_TX_OK
;
647 if (scan_req
->no_cck
)
648 tx_flags
|= IEEE80211_TX_CTL_NO_CCK_RATE
;
649 if (scan_req
->flags
& NL80211_SCAN_FLAG_MIN_PREQ_CONTENT
)
650 flags
|= IEEE80211_PROBE_FLAG_MIN_CONTENT
;
651 if (scan_req
->flags
& NL80211_SCAN_FLAG_RANDOM_SN
)
652 flags
|= IEEE80211_PROBE_FLAG_RANDOM_SN
;
654 sdata
= rcu_dereference_protected(local
->scan_sdata
,
655 lockdep_is_held(&local
->mtx
));
657 for (i
= 0; i
< scan_req
->n_ssids
; i
++)
658 ieee80211_send_scan_probe_req(
659 sdata
, local
->scan_addr
, scan_req
->bssid
,
660 scan_req
->ssids
[i
].ssid
, scan_req
->ssids
[i
].ssid_len
,
661 scan_req
->ie
, scan_req
->ie_len
,
662 scan_req
->rates
[band
], flags
,
663 tx_flags
, local
->hw
.conf
.chandef
.chan
);
666 * After sending probe requests, wait for probe responses
669 *next_delay
= IEEE80211_CHANNEL_TIME
;
670 local
->next_scan_state
= SCAN_DECISION
;
673 static int __ieee80211_start_scan(struct ieee80211_sub_if_data
*sdata
,
674 struct cfg80211_scan_request
*req
)
676 struct ieee80211_local
*local
= sdata
->local
;
677 bool hw_scan
= local
->ops
->hw_scan
;
680 lockdep_assert_held(&local
->mtx
);
685 if (!__ieee80211_can_leave_ch(sdata
))
688 if (!ieee80211_can_scan(local
, sdata
)) {
689 /* wait for the work to finish/time out */
690 rcu_assign_pointer(local
->scan_req
, req
);
691 rcu_assign_pointer(local
->scan_sdata
, sdata
);
699 local
->hw_scan_ies_bufsize
= local
->scan_ies_len
+ req
->ie_len
;
701 if (ieee80211_hw_check(&local
->hw
, SINGLE_SCAN_ON_ALL_BANDS
)) {
703 u8 bands_counted
= 0;
705 for (i
= 0; i
< req
->n_channels
; i
++) {
706 if (bands_counted
& BIT(req
->channels
[i
]->band
))
708 bands_counted
|= BIT(req
->channels
[i
]->band
);
712 local
->hw_scan_ies_bufsize
*= n_bands
;
715 local
->hw_scan_req
= kmalloc(
716 sizeof(*local
->hw_scan_req
) +
717 req
->n_channels
* sizeof(req
->channels
[0]) +
718 local
->hw_scan_ies_bufsize
, GFP_KERNEL
);
719 if (!local
->hw_scan_req
)
722 local
->hw_scan_req
->req
.ssids
= req
->ssids
;
723 local
->hw_scan_req
->req
.n_ssids
= req
->n_ssids
;
724 ies
= (u8
*)local
->hw_scan_req
+
725 sizeof(*local
->hw_scan_req
) +
726 req
->n_channels
* sizeof(req
->channels
[0]);
727 local
->hw_scan_req
->req
.ie
= ies
;
728 local
->hw_scan_req
->req
.flags
= req
->flags
;
729 eth_broadcast_addr(local
->hw_scan_req
->req
.bssid
);
730 local
->hw_scan_req
->req
.duration
= req
->duration
;
731 local
->hw_scan_req
->req
.duration_mandatory
=
732 req
->duration_mandatory
;
734 local
->hw_scan_band
= 0;
735 local
->hw_scan_req
->req
.n_6ghz_params
= req
->n_6ghz_params
;
736 local
->hw_scan_req
->req
.scan_6ghz_params
=
737 req
->scan_6ghz_params
;
738 local
->hw_scan_req
->req
.scan_6ghz
= req
->scan_6ghz
;
741 * After allocating local->hw_scan_req, we must
742 * go through until ieee80211_prep_hw_scan(), so
743 * anything that might be changed here and leave
744 * this function early must not go after this
749 rcu_assign_pointer(local
->scan_req
, req
);
750 rcu_assign_pointer(local
->scan_sdata
, sdata
);
752 if (req
->flags
& NL80211_SCAN_FLAG_RANDOM_ADDR
)
753 get_random_mask_addr(local
->scan_addr
,
757 memcpy(local
->scan_addr
, sdata
->vif
.addr
, ETH_ALEN
);
760 __set_bit(SCAN_HW_SCANNING
, &local
->scanning
);
761 } else if ((req
->n_channels
== 1) &&
762 (req
->channels
[0] == local
->_oper_chandef
.chan
)) {
764 * If we are scanning only on the operating channel
765 * then we do not need to stop normal activities
767 unsigned long next_delay
;
769 __set_bit(SCAN_ONCHANNEL_SCANNING
, &local
->scanning
);
771 ieee80211_recalc_idle(local
);
773 /* Notify driver scan is starting, keep order of operations
774 * same as normal software scan, in case that matters. */
775 drv_sw_scan_start(local
, sdata
, local
->scan_addr
);
777 ieee80211_configure_filter(local
); /* accept probe-responses */
779 /* We need to ensure power level is at max for scanning. */
780 ieee80211_hw_config(local
, 0);
782 if ((req
->channels
[0]->flags
& (IEEE80211_CHAN_NO_IR
|
783 IEEE80211_CHAN_RADAR
)) ||
785 next_delay
= IEEE80211_PASSIVE_CHANNEL_TIME
;
787 ieee80211_scan_state_send_probe(local
, &next_delay
);
788 next_delay
= IEEE80211_CHANNEL_TIME
;
791 /* Now, just wait a bit and we are all done! */
792 ieee80211_queue_delayed_work(&local
->hw
, &local
->scan_work
,
796 /* Do normal software scan */
797 __set_bit(SCAN_SW_SCANNING
, &local
->scanning
);
800 ieee80211_recalc_idle(local
);
803 WARN_ON(!ieee80211_prep_hw_scan(sdata
));
804 rc
= drv_hw_scan(local
, sdata
, local
->hw_scan_req
);
806 rc
= ieee80211_start_sw_scan(local
, sdata
);
810 kfree(local
->hw_scan_req
);
811 local
->hw_scan_req
= NULL
;
814 ieee80211_recalc_idle(local
);
816 local
->scan_req
= NULL
;
817 RCU_INIT_POINTER(local
->scan_sdata
, NULL
);
820 if (hw_scan
&& rc
== 1) {
822 * we can't fall back to software for P2P-GO
823 * as it must update NoA etc.
825 if (ieee80211_vif_type_p2p(&sdata
->vif
) ==
826 NL80211_IFTYPE_P2P_GO
)
836 ieee80211_scan_get_channel_time(struct ieee80211_channel
*chan
)
839 * TODO: channel switching also consumes quite some time,
840 * add that delay as well to get a better estimation
842 if (chan
->flags
& (IEEE80211_CHAN_NO_IR
| IEEE80211_CHAN_RADAR
))
843 return IEEE80211_PASSIVE_CHANNEL_TIME
;
844 return IEEE80211_PROBE_DELAY
+ IEEE80211_CHANNEL_TIME
;
847 static void ieee80211_scan_state_decision(struct ieee80211_local
*local
,
848 unsigned long *next_delay
)
850 bool associated
= false;
851 bool tx_empty
= true;
853 struct ieee80211_sub_if_data
*sdata
;
854 struct ieee80211_channel
*next_chan
;
855 enum mac80211_scan_state next_scan_state
;
856 struct cfg80211_scan_request
*scan_req
;
859 * check if at least one STA interface is associated,
860 * check if at least one STA interface has pending tx frames
861 * and grab the lowest used beacon interval
863 mutex_lock(&local
->iflist_mtx
);
864 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
865 if (!ieee80211_sdata_running(sdata
))
868 if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
) {
869 if (sdata
->u
.mgd
.associated
) {
872 if (!qdisc_all_tx_empty(sdata
->dev
)) {
879 mutex_unlock(&local
->iflist_mtx
);
881 scan_req
= rcu_dereference_protected(local
->scan_req
,
882 lockdep_is_held(&local
->mtx
));
884 next_chan
= scan_req
->channels
[local
->scan_channel_idx
];
887 * we're currently scanning a different channel, let's
888 * see if we can scan another channel without interfering
889 * with the current traffic situation.
891 * Keep good latency, do not stay off-channel more than 125 ms.
894 bad_latency
= time_after(jiffies
+
895 ieee80211_scan_get_channel_time(next_chan
),
896 local
->leave_oper_channel_time
+ HZ
/ 8);
898 if (associated
&& !tx_empty
) {
899 if (scan_req
->flags
& NL80211_SCAN_FLAG_LOW_PRIORITY
)
900 next_scan_state
= SCAN_ABORT
;
902 next_scan_state
= SCAN_SUSPEND
;
903 } else if (associated
&& bad_latency
) {
904 next_scan_state
= SCAN_SUSPEND
;
906 next_scan_state
= SCAN_SET_CHANNEL
;
909 local
->next_scan_state
= next_scan_state
;
914 static void ieee80211_scan_state_set_channel(struct ieee80211_local
*local
,
915 unsigned long *next_delay
)
918 struct ieee80211_channel
*chan
;
919 enum nl80211_bss_scan_width oper_scan_width
;
920 struct cfg80211_scan_request
*scan_req
;
922 scan_req
= rcu_dereference_protected(local
->scan_req
,
923 lockdep_is_held(&local
->mtx
));
926 chan
= scan_req
->channels
[local
->scan_channel_idx
];
928 local
->scan_chandef
.chan
= chan
;
929 local
->scan_chandef
.center_freq1
= chan
->center_freq
;
930 local
->scan_chandef
.freq1_offset
= chan
->freq_offset
;
931 local
->scan_chandef
.center_freq2
= 0;
933 /* For scanning on the S1G band, ignore scan_width (which is constant
934 * across all channels) for now since channel width is specific to each
935 * channel. Detect the required channel width here and likely revisit
936 * later. Maybe scan_width could be used to build the channel scan list?
938 if (chan
->band
== NL80211_BAND_S1GHZ
) {
939 local
->scan_chandef
.width
= ieee80211_s1g_channel_width(chan
);
943 switch (scan_req
->scan_width
) {
944 case NL80211_BSS_CHAN_WIDTH_5
:
945 local
->scan_chandef
.width
= NL80211_CHAN_WIDTH_5
;
947 case NL80211_BSS_CHAN_WIDTH_10
:
948 local
->scan_chandef
.width
= NL80211_CHAN_WIDTH_10
;
951 case NL80211_BSS_CHAN_WIDTH_20
:
952 /* If scanning on oper channel, use whatever channel-type
953 * is currently in use.
955 oper_scan_width
= cfg80211_chandef_to_scan_width(
956 &local
->_oper_chandef
);
957 if (chan
== local
->_oper_chandef
.chan
&&
958 oper_scan_width
== scan_req
->scan_width
)
959 local
->scan_chandef
= local
->_oper_chandef
;
961 local
->scan_chandef
.width
= NL80211_CHAN_WIDTH_20_NOHT
;
963 case NL80211_BSS_CHAN_WIDTH_1
:
964 case NL80211_BSS_CHAN_WIDTH_2
:
965 /* shouldn't get here, S1G handled above */
971 if (ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
))
974 /* advance state machine to next channel/band */
975 local
->scan_channel_idx
++;
978 /* if we skip this channel return to the decision state */
979 local
->next_scan_state
= SCAN_DECISION
;
984 * Probe delay is used to update the NAV, cf. 11.1.3.2.2
985 * (which unfortunately doesn't say _why_ step a) is done,
986 * but it waits for the probe delay or until a frame is
987 * received - and the received frame would update the NAV).
988 * For now, we do not support waiting until a frame is
991 * In any case, it is not necessary for a passive scan.
993 if ((chan
->flags
& (IEEE80211_CHAN_NO_IR
| IEEE80211_CHAN_RADAR
)) ||
994 !scan_req
->n_ssids
) {
995 *next_delay
= IEEE80211_PASSIVE_CHANNEL_TIME
;
996 local
->next_scan_state
= SCAN_DECISION
;
1000 /* active scan, send probes */
1001 *next_delay
= IEEE80211_PROBE_DELAY
;
1002 local
->next_scan_state
= SCAN_SEND_PROBE
;
1005 static void ieee80211_scan_state_suspend(struct ieee80211_local
*local
,
1006 unsigned long *next_delay
)
1008 /* switch back to the operating channel */
1009 local
->scan_chandef
.chan
= NULL
;
1010 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
);
1013 ieee80211_offchannel_return(local
);
1015 *next_delay
= HZ
/ 5;
1016 /* afterwards, resume scan & go to next channel */
1017 local
->next_scan_state
= SCAN_RESUME
;
1020 static void ieee80211_scan_state_resume(struct ieee80211_local
*local
,
1021 unsigned long *next_delay
)
1023 ieee80211_offchannel_stop_vifs(local
);
1025 if (local
->ops
->flush
) {
1026 ieee80211_flush_queues(local
, NULL
, false);
1029 *next_delay
= HZ
/ 10;
1031 /* remember when we left the operating channel */
1032 local
->leave_oper_channel_time
= jiffies
;
1034 /* advance to the next channel to be scanned */
1035 local
->next_scan_state
= SCAN_SET_CHANNEL
;
1038 void ieee80211_scan_work(struct work_struct
*work
)
1040 struct ieee80211_local
*local
=
1041 container_of(work
, struct ieee80211_local
, scan_work
.work
);
1042 struct ieee80211_sub_if_data
*sdata
;
1043 struct cfg80211_scan_request
*scan_req
;
1044 unsigned long next_delay
= 0;
1047 mutex_lock(&local
->mtx
);
1049 if (!ieee80211_can_run_worker(local
)) {
1054 sdata
= rcu_dereference_protected(local
->scan_sdata
,
1055 lockdep_is_held(&local
->mtx
));
1056 scan_req
= rcu_dereference_protected(local
->scan_req
,
1057 lockdep_is_held(&local
->mtx
));
1059 /* When scanning on-channel, the first-callback means completed. */
1060 if (test_bit(SCAN_ONCHANNEL_SCANNING
, &local
->scanning
)) {
1061 aborted
= test_and_clear_bit(SCAN_ABORTED
, &local
->scanning
);
1065 if (test_and_clear_bit(SCAN_COMPLETED
, &local
->scanning
)) {
1066 aborted
= test_and_clear_bit(SCAN_ABORTED
, &local
->scanning
);
1070 if (!sdata
|| !scan_req
)
1073 if (!local
->scanning
) {
1076 RCU_INIT_POINTER(local
->scan_req
, NULL
);
1077 RCU_INIT_POINTER(local
->scan_sdata
, NULL
);
1079 rc
= __ieee80211_start_scan(sdata
, scan_req
);
1081 /* need to complete scan in cfg80211 */
1082 rcu_assign_pointer(local
->scan_req
, scan_req
);
1090 * as long as no delay is required advance immediately
1091 * without scheduling a new work
1094 if (!ieee80211_sdata_running(sdata
)) {
1099 switch (local
->next_scan_state
) {
1101 /* if no more bands/channels left, complete scan */
1102 if (local
->scan_channel_idx
>= scan_req
->n_channels
) {
1106 ieee80211_scan_state_decision(local
, &next_delay
);
1108 case SCAN_SET_CHANNEL
:
1109 ieee80211_scan_state_set_channel(local
, &next_delay
);
1111 case SCAN_SEND_PROBE
:
1112 ieee80211_scan_state_send_probe(local
, &next_delay
);
1115 ieee80211_scan_state_suspend(local
, &next_delay
);
1118 ieee80211_scan_state_resume(local
, &next_delay
);
1124 } while (next_delay
== 0);
1126 ieee80211_queue_delayed_work(&local
->hw
, &local
->scan_work
, next_delay
);
1130 __ieee80211_scan_completed(&local
->hw
, aborted
);
1132 mutex_unlock(&local
->mtx
);
1135 int ieee80211_request_scan(struct ieee80211_sub_if_data
*sdata
,
1136 struct cfg80211_scan_request
*req
)
1140 mutex_lock(&sdata
->local
->mtx
);
1141 res
= __ieee80211_start_scan(sdata
, req
);
1142 mutex_unlock(&sdata
->local
->mtx
);
1147 int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data
*sdata
,
1148 const u8
*ssid
, u8 ssid_len
,
1149 struct ieee80211_channel
**channels
,
1150 unsigned int n_channels
,
1151 enum nl80211_bss_scan_width scan_width
)
1153 struct ieee80211_local
*local
= sdata
->local
;
1154 int ret
= -EBUSY
, i
, n_ch
= 0;
1155 enum nl80211_band band
;
1157 mutex_lock(&local
->mtx
);
1160 if (local
->scan_req
)
1163 /* fill internal scan request */
1167 for (band
= 0; band
< NUM_NL80211_BANDS
; band
++) {
1168 if (!local
->hw
.wiphy
->bands
[band
] ||
1169 band
== NL80211_BAND_6GHZ
)
1172 max_n
= local
->hw
.wiphy
->bands
[band
]->n_channels
;
1173 for (i
= 0; i
< max_n
; i
++) {
1174 struct ieee80211_channel
*tmp_ch
=
1175 &local
->hw
.wiphy
->bands
[band
]->channels
[i
];
1177 if (tmp_ch
->flags
& (IEEE80211_CHAN_NO_IR
|
1178 IEEE80211_CHAN_DISABLED
))
1181 local
->int_scan_req
->channels
[n_ch
] = tmp_ch
;
1186 if (WARN_ON_ONCE(n_ch
== 0))
1189 local
->int_scan_req
->n_channels
= n_ch
;
1191 for (i
= 0; i
< n_channels
; i
++) {
1192 if (channels
[i
]->flags
& (IEEE80211_CHAN_NO_IR
|
1193 IEEE80211_CHAN_DISABLED
))
1196 local
->int_scan_req
->channels
[n_ch
] = channels
[i
];
1200 if (WARN_ON_ONCE(n_ch
== 0))
1203 local
->int_scan_req
->n_channels
= n_ch
;
1206 local
->int_scan_req
->ssids
= &local
->scan_ssid
;
1207 local
->int_scan_req
->n_ssids
= 1;
1208 local
->int_scan_req
->scan_width
= scan_width
;
1209 memcpy(local
->int_scan_req
->ssids
[0].ssid
, ssid
, IEEE80211_MAX_SSID_LEN
);
1210 local
->int_scan_req
->ssids
[0].ssid_len
= ssid_len
;
1212 ret
= __ieee80211_start_scan(sdata
, sdata
->local
->int_scan_req
);
1214 mutex_unlock(&local
->mtx
);
1219 * Only call this function when a scan can't be queued -- under RTNL.
1221 void ieee80211_scan_cancel(struct ieee80211_local
*local
)
1224 * We are canceling software scan, or deferred scan that was not
1225 * yet really started (see __ieee80211_start_scan ).
1227 * Regarding hardware scan:
1228 * - we can not call __ieee80211_scan_completed() as when
1229 * SCAN_HW_SCANNING bit is set this function change
1230 * local->hw_scan_req to operate on 5G band, what race with
1231 * driver which can use local->hw_scan_req
1233 * - we can not cancel scan_work since driver can schedule it
1234 * by ieee80211_scan_completed(..., true) to finish scan
1236 * Hence we only call the cancel_hw_scan() callback, but the low-level
1237 * driver is still responsible for calling ieee80211_scan_completed()
1238 * after the scan was completed/aborted.
1241 mutex_lock(&local
->mtx
);
1242 if (!local
->scan_req
)
1246 * We have a scan running and the driver already reported completion,
1247 * but the worker hasn't run yet or is stuck on the mutex - mark it as
1250 if (test_bit(SCAN_HW_SCANNING
, &local
->scanning
) &&
1251 test_bit(SCAN_COMPLETED
, &local
->scanning
)) {
1252 set_bit(SCAN_HW_CANCELLED
, &local
->scanning
);
1256 if (test_bit(SCAN_HW_SCANNING
, &local
->scanning
)) {
1258 * Make sure that __ieee80211_scan_completed doesn't trigger a
1259 * scan on another band.
1261 set_bit(SCAN_HW_CANCELLED
, &local
->scanning
);
1262 if (local
->ops
->cancel_hw_scan
)
1263 drv_cancel_hw_scan(local
,
1264 rcu_dereference_protected(local
->scan_sdata
,
1265 lockdep_is_held(&local
->mtx
)));
1270 * If the work is currently running, it must be blocked on
1271 * the mutex, but we'll set scan_sdata = NULL and it'll
1272 * simply exit once it acquires the mutex.
1274 cancel_delayed_work(&local
->scan_work
);
1276 memset(&local
->scan_info
, 0, sizeof(local
->scan_info
));
1277 __ieee80211_scan_completed(&local
->hw
, true);
1279 mutex_unlock(&local
->mtx
);
1282 int __ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data
*sdata
,
1283 struct cfg80211_sched_scan_request
*req
)
1285 struct ieee80211_local
*local
= sdata
->local
;
1286 struct ieee80211_scan_ies sched_scan_ies
= {};
1287 struct cfg80211_chan_def chandef
;
1288 int ret
, i
, iebufsz
, num_bands
= 0;
1289 u32 rate_masks
[NUM_NL80211_BANDS
] = {};
1294 iebufsz
= local
->scan_ies_len
+ req
->ie_len
;
1296 lockdep_assert_held(&local
->mtx
);
1298 if (!local
->ops
->sched_scan_start
)
1301 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++) {
1302 if (local
->hw
.wiphy
->bands
[i
]) {
1303 bands_used
|= BIT(i
);
1304 rate_masks
[i
] = (u32
) -1;
1309 if (req
->flags
& NL80211_SCAN_FLAG_MIN_PREQ_CONTENT
)
1310 flags
|= IEEE80211_PROBE_FLAG_MIN_CONTENT
;
1312 ie
= kcalloc(iebufsz
, num_bands
, GFP_KERNEL
);
1318 ieee80211_prepare_scan_chandef(&chandef
, req
->scan_width
);
1320 ieee80211_build_preq_ies(sdata
, ie
, num_bands
* iebufsz
,
1321 &sched_scan_ies
, req
->ie
,
1322 req
->ie_len
, bands_used
, rate_masks
, &chandef
,
1325 ret
= drv_sched_scan_start(local
, sdata
, req
, &sched_scan_ies
);
1327 rcu_assign_pointer(local
->sched_scan_sdata
, sdata
);
1328 rcu_assign_pointer(local
->sched_scan_req
, req
);
1335 /* Clean in case of failure after HW restart or upon resume. */
1336 RCU_INIT_POINTER(local
->sched_scan_sdata
, NULL
);
1337 RCU_INIT_POINTER(local
->sched_scan_req
, NULL
);
1343 int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data
*sdata
,
1344 struct cfg80211_sched_scan_request
*req
)
1346 struct ieee80211_local
*local
= sdata
->local
;
1349 mutex_lock(&local
->mtx
);
1351 if (rcu_access_pointer(local
->sched_scan_sdata
)) {
1352 mutex_unlock(&local
->mtx
);
1356 ret
= __ieee80211_request_sched_scan_start(sdata
, req
);
1358 mutex_unlock(&local
->mtx
);
1362 int ieee80211_request_sched_scan_stop(struct ieee80211_local
*local
)
1364 struct ieee80211_sub_if_data
*sched_scan_sdata
;
1367 mutex_lock(&local
->mtx
);
1369 if (!local
->ops
->sched_scan_stop
) {
1374 /* We don't want to restart sched scan anymore. */
1375 RCU_INIT_POINTER(local
->sched_scan_req
, NULL
);
1377 sched_scan_sdata
= rcu_dereference_protected(local
->sched_scan_sdata
,
1378 lockdep_is_held(&local
->mtx
));
1379 if (sched_scan_sdata
) {
1380 ret
= drv_sched_scan_stop(local
, sched_scan_sdata
);
1382 RCU_INIT_POINTER(local
->sched_scan_sdata
, NULL
);
1385 mutex_unlock(&local
->mtx
);
1390 void ieee80211_sched_scan_results(struct ieee80211_hw
*hw
)
1392 struct ieee80211_local
*local
= hw_to_local(hw
);
1394 trace_api_sched_scan_results(local
);
1396 cfg80211_sched_scan_results(hw
->wiphy
, 0);
1398 EXPORT_SYMBOL(ieee80211_sched_scan_results
);
1400 void ieee80211_sched_scan_end(struct ieee80211_local
*local
)
1402 mutex_lock(&local
->mtx
);
1404 if (!rcu_access_pointer(local
->sched_scan_sdata
)) {
1405 mutex_unlock(&local
->mtx
);
1409 RCU_INIT_POINTER(local
->sched_scan_sdata
, NULL
);
1411 /* If sched scan was aborted by the driver. */
1412 RCU_INIT_POINTER(local
->sched_scan_req
, NULL
);
1414 mutex_unlock(&local
->mtx
);
1416 cfg80211_sched_scan_stopped(local
->hw
.wiphy
, 0);
1419 void ieee80211_sched_scan_stopped_work(struct work_struct
*work
)
1421 struct ieee80211_local
*local
=
1422 container_of(work
, struct ieee80211_local
,
1423 sched_scan_stopped_work
);
1425 ieee80211_sched_scan_end(local
);
1428 void ieee80211_sched_scan_stopped(struct ieee80211_hw
*hw
)
1430 struct ieee80211_local
*local
= hw_to_local(hw
);
1432 trace_api_sched_scan_stopped(local
);
1435 * this shouldn't really happen, so for simplicity
1436 * simply ignore it, and let mac80211 reconfigure
1437 * the sched scan later on.
1439 if (local
->in_reconfig
)
1442 schedule_work(&local
->sched_scan_stopped_work
);
1444 EXPORT_SYMBOL(ieee80211_sched_scan_stopped
);