blob: b211e412511f8d06057a8d814305c90a22bfe66d [file] [log] [blame]
Johannes Berg0a51b272008-09-08 17:44:25 +02001/*
Johannes Berg5484e232008-09-08 17:44:27 +02002 * Scanning implementation
3 *
Johannes Berg0a51b272008-09-08 17:44:25 +02004 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
5 * Copyright 2004, Instant802 Networks, Inc.
6 * Copyright 2005, Devicescape Software, Inc.
7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
Johannes Berg0a51b272008-09-08 17:44:25 +020015#include <linux/if_arp.h>
Felix Fietkau888d04d2012-03-01 15:22:09 +010016#include <linux/etherdevice.h>
Johannes Berg078e1e62009-01-22 18:07:31 +010017#include <linux/rtnetlink.h>
Jean Pihete8db0be2011-08-25 15:35:03 +020018#include <linux/pm_qos.h>
Helmut Schaadf13cce2010-02-24 14:19:21 +010019#include <net/sch_generic.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040021#include <linux/export.h>
Johannes Berg0a51b272008-09-08 17:44:25 +020022#include <net/mac80211.h>
Johannes Berg0a51b272008-09-08 17:44:25 +020023
24#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020025#include "driver-ops.h"
Johannes Berg5484e232008-09-08 17:44:27 +020026#include "mesh.h"
Johannes Berg0a51b272008-09-08 17:44:25 +020027
28#define IEEE80211_PROBE_DELAY (HZ / 33)
29#define IEEE80211_CHANNEL_TIME (HZ / 33)
Stanislaw Gruszka3f892b62013-01-23 12:32:45 +010030#define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 9)
Johannes Berg0a51b272008-09-08 17:44:25 +020031
Johannes Berg5484e232008-09-08 17:44:27 +020032void ieee80211_rx_bss_put(struct ieee80211_local *local,
Johannes Bergc2b13452008-09-11 00:01:55 +020033 struct ieee80211_bss *bss)
Johannes Berg5484e232008-09-08 17:44:27 +020034{
Johannes Berg0c1ad2c2009-12-23 13:15:39 +010035 if (!bss)
36 return;
Johannes Berg5b112d32013-02-01 01:49:58 +010037 cfg80211_put_bss(local->hw.wiphy,
38 container_of((void *)bss, struct cfg80211_bss, priv));
Johannes Berg5484e232008-09-08 17:44:27 +020039}
40
Kalle Valoab133152010-01-12 10:42:31 +020041static bool is_uapsd_supported(struct ieee802_11_elems *elems)
42{
43 u8 qos_info;
44
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];
51 else
52 /* no valid wmm information or parameter element found */
53 return false;
54
55 return qos_info & IEEE80211_WMM_IE_AP_QOSINFO_UAPSD;
56}
57
Johannes Bergc2b13452008-09-11 00:01:55 +020058struct ieee80211_bss *
Johannes Berg5484e232008-09-08 17:44:27 +020059ieee80211_bss_info_update(struct ieee80211_local *local,
60 struct ieee80211_rx_status *rx_status,
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +020061 struct ieee80211_mgmt *mgmt, size_t len,
Johannes Berg5484e232008-09-08 17:44:27 +020062 struct ieee802_11_elems *elems,
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +020063 struct ieee80211_channel *channel)
Johannes Berg5484e232008-09-08 17:44:27 +020064{
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +020065 bool beacon = ieee80211_is_beacon(mgmt->frame_control);
Johannes Berg0c1ad2c2009-12-23 13:15:39 +010066 struct cfg80211_bss *cbss;
Johannes Bergc2b13452008-09-11 00:01:55 +020067 struct ieee80211_bss *bss;
Stanislaw Gruszkaf0b058b2010-04-28 15:17:03 +020068 int clen, srlen;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +020069 enum nl80211_bss_scan_width scan_width;
Johannes Berg2a519312009-02-10 21:25:55 +010070 s32 signal = 0;
71
Johannes Berg77965c92009-02-18 18:45:06 +010072 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
Johannes Berg2a519312009-02-10 21:25:55 +010073 signal = rx_status->signal * 100;
Johannes Berg77965c92009-02-18 18:45:06 +010074 else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
Johannes Berg2a519312009-02-10 21:25:55 +010075 signal = (rx_status->signal * 100) / local->hw.max_signal;
Johannes Berg2a519312009-02-10 21:25:55 +010076
Simon Wunderlich7ca15a02013-07-08 16:55:56 +020077 scan_width = NL80211_BSS_CHAN_WIDTH_20;
78 if (rx_status->flag & RX_FLAG_5MHZ)
79 scan_width = NL80211_BSS_CHAN_WIDTH_5;
80 if (rx_status->flag & RX_FLAG_10MHZ)
81 scan_width = NL80211_BSS_CHAN_WIDTH_10;
82
83 cbss = cfg80211_inform_bss_width_frame(local->hw.wiphy, channel,
84 scan_width, mgmt, len, signal,
85 GFP_ATOMIC);
Johannes Berg0c1ad2c2009-12-23 13:15:39 +010086 if (!cbss)
Johannes Berg00d3f142009-02-10 21:26:00 +010087 return NULL;
88
Johannes Berg0c1ad2c2009-12-23 13:15:39 +010089 bss = (void *)cbss->priv;
Johannes Berg5484e232008-09-08 17:44:27 +020090
Johannes Bergef429da2013-02-05 17:48:40 +010091 if (beacon)
92 bss->device_ts_beacon = rx_status->device_timestamp;
93 else
94 bss->device_ts_presp = rx_status->device_timestamp;
Johannes Berg8c358bc2012-05-22 22:13:05 +020095
Paul Stewartfcff4f12012-02-23 17:59:53 -080096 if (elems->parse_error) {
97 if (beacon)
98 bss->corrupt_data |= IEEE80211_BSS_CORRUPT_BEACON;
99 else
100 bss->corrupt_data |= IEEE80211_BSS_CORRUPT_PROBE_RESP;
101 } else {
102 if (beacon)
103 bss->corrupt_data &= ~IEEE80211_BSS_CORRUPT_BEACON;
104 else
105 bss->corrupt_data &= ~IEEE80211_BSS_CORRUPT_PROBE_RESP;
Johannes Berg5484e232008-09-08 17:44:27 +0200106 }
107
Paul Stewartfcff4f12012-02-23 17:59:53 -0800108 /* save the ERP value so that it is available at association time */
Johannes Berg1946bed2013-03-27 14:31:53 +0100109 if (elems->erp_info && (!elems->parse_error ||
110 !(bss->valid_data & IEEE80211_BSS_VALID_ERP))) {
Paul Stewartfcff4f12012-02-23 17:59:53 -0800111 bss->erp_value = elems->erp_info[0];
112 bss->has_erp_value = true;
113 if (!elems->parse_error)
114 bss->valid_data |= IEEE80211_BSS_VALID_ERP;
115 }
116
Stanislaw Gruszkaf0b058b2010-04-28 15:17:03 +0200117 /* replace old supported rates if we get new values */
Paul Stewartfcff4f12012-02-23 17:59:53 -0800118 if (!elems->parse_error ||
119 !(bss->valid_data & IEEE80211_BSS_VALID_RATES)) {
120 srlen = 0;
121 if (elems->supp_rates) {
122 clen = IEEE80211_MAX_SUPP_RATES;
123 if (clen > elems->supp_rates_len)
124 clen = elems->supp_rates_len;
125 memcpy(bss->supp_rates, elems->supp_rates, clen);
126 srlen += clen;
127 }
128 if (elems->ext_supp_rates) {
129 clen = IEEE80211_MAX_SUPP_RATES - srlen;
130 if (clen > elems->ext_supp_rates_len)
131 clen = elems->ext_supp_rates_len;
132 memcpy(bss->supp_rates + srlen, elems->ext_supp_rates,
133 clen);
134 srlen += clen;
135 }
136 if (srlen) {
137 bss->supp_rates_len = srlen;
138 if (!elems->parse_error)
139 bss->valid_data |= IEEE80211_BSS_VALID_RATES;
140 }
Johannes Berg5484e232008-09-08 17:44:27 +0200141 }
Johannes Berg5484e232008-09-08 17:44:27 +0200142
Paul Stewartfcff4f12012-02-23 17:59:53 -0800143 if (!elems->parse_error ||
144 !(bss->valid_data & IEEE80211_BSS_VALID_WMM)) {
145 bss->wmm_used = elems->wmm_param || elems->wmm_info;
146 bss->uapsd_supported = is_uapsd_supported(elems);
147 if (!elems->parse_error)
148 bss->valid_data |= IEEE80211_BSS_VALID_WMM;
149 }
Johannes Berg5484e232008-09-08 17:44:27 +0200150
Alexander Bondar817cee72013-05-19 14:23:57 +0300151 if (beacon) {
152 struct ieee80211_supported_band *sband =
153 local->hw.wiphy->bands[rx_status->band];
154 if (!(rx_status->flag & RX_FLAG_HT) &&
155 !(rx_status->flag & RX_FLAG_VHT))
156 bss->beacon_rate =
157 &sband->bitrates[rx_status->rate_idx];
158 }
159
Johannes Berg5484e232008-09-08 17:44:27 +0200160 return bss;
161}
Johannes Berg0a51b272008-09-08 17:44:25 +0200162
Johannes Bergd48b2962012-07-06 22:19:27 +0200163void ieee80211_scan_rx(struct ieee80211_local *local, struct sk_buff *skb)
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200164{
Johannes Bergf1d58c22009-06-17 13:13:00 +0200165 struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
Johannes Bergd48b2962012-07-06 22:19:27 +0200166 struct ieee80211_sub_if_data *sdata1, *sdata2;
167 struct ieee80211_mgmt *mgmt = (void *)skb->data;
Johannes Bergc2b13452008-09-11 00:01:55 +0200168 struct ieee80211_bss *bss;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200169 u8 *elements;
170 struct ieee80211_channel *channel;
171 size_t baselen;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200172 struct ieee802_11_elems elems;
173
Johannes Bergd48b2962012-07-06 22:19:27 +0200174 if (skb->len < 24 ||
175 (!ieee80211_is_probe_resp(mgmt->frame_control) &&
176 !ieee80211_is_beacon(mgmt->frame_control)))
177 return;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200178
Johannes Bergd48b2962012-07-06 22:19:27 +0200179 sdata1 = rcu_dereference(local->scan_sdata);
180 sdata2 = rcu_dereference(local->sched_scan_sdata);
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200181
Johannes Bergd48b2962012-07-06 22:19:27 +0200182 if (likely(!sdata1 && !sdata2))
183 return;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200184
Johannes Bergd48b2962012-07-06 22:19:27 +0200185 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200186 /* ignore ProbeResp to foreign address */
Johannes Bergd48b2962012-07-06 22:19:27 +0200187 if ((!sdata1 || !ether_addr_equal(mgmt->da, sdata1->vif.addr)) &&
188 (!sdata2 || !ether_addr_equal(mgmt->da, sdata2->vif.addr)))
189 return;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200190
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200191 elements = mgmt->u.probe_resp.variable;
192 baselen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
193 } else {
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200194 baselen = offsetof(struct ieee80211_mgmt, u.beacon.variable);
195 elements = mgmt->u.beacon.variable;
196 }
197
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200198 if (baselen > skb->len)
Johannes Bergd48b2962012-07-06 22:19:27 +0200199 return;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200200
Johannes Bergb2e506b2013-03-26 14:54:16 +0100201 ieee802_11_parse_elems(elements, skb->len - baselen, false, &elems);
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200202
Johannes Berg0172bb72012-11-23 14:23:30 +0100203 channel = ieee80211_get_channel(local->hw.wiphy, rx_status->freq);
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200204
205 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
Johannes Bergd48b2962012-07-06 22:19:27 +0200206 return;
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200207
Johannes Bergd48b2962012-07-06 22:19:27 +0200208 bss = ieee80211_bss_info_update(local, rx_status,
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200209 mgmt, skb->len, &elems,
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +0200210 channel);
Jouni Malinend048e502008-10-11 03:29:55 +0300211 if (bss)
Johannes Bergd48b2962012-07-06 22:19:27 +0200212 ieee80211_rx_bss_put(local, bss);
Johannes Berg98c8fcc2008-09-08 17:44:26 +0200213}
214
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200215static void
216ieee80211_prepare_scan_chandef(struct cfg80211_chan_def *chandef,
217 enum nl80211_bss_scan_width scan_width)
218{
219 memset(chandef, 0, sizeof(*chandef));
220 switch (scan_width) {
221 case NL80211_BSS_CHAN_WIDTH_5:
222 chandef->width = NL80211_CHAN_WIDTH_5;
223 break;
224 case NL80211_BSS_CHAN_WIDTH_10:
225 chandef->width = NL80211_CHAN_WIDTH_10;
226 break;
227 default:
228 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
229 break;
230 }
231}
232
Johannes Berg4d36ec582009-10-27 20:59:55 +0100233/* return false if no more work */
234static bool ieee80211_prep_hw_scan(struct ieee80211_local *local)
235{
236 struct cfg80211_scan_request *req = local->scan_req;
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200237 struct cfg80211_chan_def chandef;
Johannes Berg4d36ec582009-10-27 20:59:55 +0100238 enum ieee80211_band band;
239 int i, ielen, n_chans;
240
Emmanuel Grumbacha7540552013-09-16 11:12:07 +0300241 if (test_bit(SCAN_HW_CANCELLED, &local->scanning))
242 return false;
243
Johannes Berg4d36ec582009-10-27 20:59:55 +0100244 do {
245 if (local->hw_scan_band == IEEE80211_NUM_BANDS)
246 return false;
247
248 band = local->hw_scan_band;
249 n_chans = 0;
250 for (i = 0; i < req->n_channels; i++) {
251 if (req->channels[i]->band == band) {
252 local->hw_scan_req->channels[n_chans] =
253 req->channels[i];
254 n_chans++;
255 }
256 }
257
258 local->hw_scan_band++;
259 } while (!n_chans);
260
261 local->hw_scan_req->n_channels = n_chans;
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200262 ieee80211_prepare_scan_chandef(&chandef, req->scan_width);
Johannes Berg4d36ec582009-10-27 20:59:55 +0100263
264 ielen = ieee80211_build_preq_ies(local, (u8 *)local->hw_scan_req->ie,
Johannes Bergc604b9f2012-11-29 12:45:18 +0100265 local->hw_scan_ies_bufsize,
Johannes Berg8ee31082011-06-22 16:43:48 +0200266 req->ie, req->ie_len, band,
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200267 req->rates[band], &chandef);
Johannes Berg4d36ec582009-10-27 20:59:55 +0100268 local->hw_scan_req->ie_len = ielen;
Johannes Bergdcd83972011-10-04 15:07:33 +0200269 local->hw_scan_req->no_cck = req->no_cck;
Johannes Berg4d36ec582009-10-27 20:59:55 +0100270
271 return true;
272}
273
Eliad Peller8bd2a242013-12-05 11:21:27 +0200274static void __ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
Johannes Berg0a51b272008-09-08 17:44:25 +0200275{
276 struct ieee80211_local *local = hw_to_local(hw);
Eliad Peller8bd2a242013-12-05 11:21:27 +0200277 bool hw_scan = local->ops->hw_scan;
Eliad Pellera2b70e82013-12-05 11:21:28 +0200278 bool was_scanning = local->scanning;
Johannes Berg0a51b272008-09-08 17:44:25 +0200279
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200280 lockdep_assert_held(&local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200281
Johannes Berg6d3560d2009-10-31 07:44:08 +0100282 /*
283 * It's ok to abort a not-yet-running scan (that
284 * we have one at all will be verified by checking
285 * local->scan_req next), but not to complete it
286 * successfully.
287 */
288 if (WARN_ON(!local->scanning && !aborted))
289 aborted = true;
Johannes Bergde95a542009-04-01 11:58:36 +0200290
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200291 if (WARN_ON(!local->scan_req))
Johannes Bergd07bfd82011-03-07 15:48:41 +0100292 return;
Johannes Bergf3b85252009-04-23 16:01:47 +0200293
Eliad Peller8bd2a242013-12-05 11:21:27 +0200294 if (hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
Johannes Berge2fd5db2012-07-06 21:39:28 +0200295 int rc;
296
297 rc = drv_hw_scan(local,
298 rcu_dereference_protected(local->scan_sdata,
299 lockdep_is_held(&local->mtx)),
300 local->hw_scan_req);
301
Stanislaw Gruszka6eb11a92010-10-06 11:22:11 +0200302 if (rc == 0)
Johannes Bergd07bfd82011-03-07 15:48:41 +0100303 return;
Johannes Berg4d36ec582009-10-27 20:59:55 +0100304 }
305
306 kfree(local->hw_scan_req);
307 local->hw_scan_req = NULL;
Johannes Bergf3b85252009-04-23 16:01:47 +0200308
Johannes Berg5ba63532009-08-07 17:54:07 +0200309 if (local->scan_req != local->int_scan_req)
Johannes Berg2a519312009-02-10 21:25:55 +0100310 cfg80211_scan_done(local->scan_req, aborted);
311 local->scan_req = NULL;
Johannes Berg3aa569c2012-07-18 12:42:58 +0200312 rcu_assign_pointer(local->scan_sdata, NULL);
Johannes Berg2a519312009-02-10 21:25:55 +0100313
Helmut Schaafbe9c422009-07-23 12:14:04 +0200314 local->scanning = 0;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200315 local->scan_chandef.chan = NULL;
Johannes Bergf3b85252009-04-23 16:01:47 +0200316
Johannes Berg07ef03e2011-11-08 16:21:21 +0100317 /* Set power back to normal operating levels. */
318 ieee80211_hw_config(local, 0);
Ben Greearb23b0252011-02-04 11:54:17 -0800319
Eliad Peller8bd2a242013-12-05 11:21:27 +0200320 if (!hw_scan) {
Ben Greearb23b0252011-02-04 11:54:17 -0800321 ieee80211_configure_filter(local);
322 drv_sw_scan_complete(local);
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100323 ieee80211_offchannel_return(local);
Ben Greearb23b0252011-02-04 11:54:17 -0800324 }
325
Johannes Berg5cff20e2009-04-29 12:26:17 +0200326 ieee80211_recalc_idle(local);
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200327
Johannes Berg0a51b272008-09-08 17:44:25 +0200328 ieee80211_mlme_notify_scan_completed(local);
Johannes Berg46900292009-02-15 12:44:28 +0100329 ieee80211_ibss_notify_scan_completed(local);
Johannes Berg472dbc42008-09-11 00:01:49 +0200330 ieee80211_mesh_notify_scan_completed(local);
Eliad Pellera2b70e82013-12-05 11:21:28 +0200331 if (was_scanning)
332 ieee80211_start_next_roc(local);
Johannes Berg0a51b272008-09-08 17:44:25 +0200333}
Johannes Berg8789d452010-08-26 13:30:26 +0200334
335void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
336{
337 struct ieee80211_local *local = hw_to_local(hw);
338
339 trace_api_scan_completed(local, aborted);
340
341 set_bit(SCAN_COMPLETED, &local->scanning);
342 if (aborted)
343 set_bit(SCAN_ABORTED, &local->scanning);
344 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
345}
Johannes Berg0a51b272008-09-08 17:44:25 +0200346EXPORT_SYMBOL(ieee80211_scan_completed);
347
Johannes Bergf3b85252009-04-23 16:01:47 +0200348static int ieee80211_start_sw_scan(struct ieee80211_local *local)
349{
Johannes Bergfe57d9f2012-07-26 14:55:08 +0200350 /* Software scan is not supported in multi-channel cases */
351 if (local->use_chanctx)
352 return -EOPNOTSUPP;
353
Johannes Bergf3b85252009-04-23 16:01:47 +0200354 /*
355 * Hardware/driver doesn't support hw_scan, so use software
356 * scanning instead. First send a nullfunc frame with power save
357 * bit on so that AP will buffer the frames for us while we are not
358 * listening, then send probe requests to each channel and wait for
359 * the responses. After all channels are scanned, tune back to the
360 * original channel and send a nullfunc frame with power save bit
361 * off to trigger the AP to send us all the buffered frames.
362 *
363 * Note that while local->sw_scanning is true everything else but
364 * nullfunc frames and probe requests will be dropped in
365 * ieee80211_tx_h_check_assoc().
366 */
Johannes Berg24487982009-04-23 18:52:52 +0200367 drv_sw_scan_start(local);
Johannes Bergf3b85252009-04-23 16:01:47 +0200368
Rajkumar Manoharande312db2012-03-27 11:01:06 +0530369 local->leave_oper_channel_time = jiffies;
Helmut Schaa977923b2009-07-23 12:14:20 +0200370 local->next_scan_state = SCAN_DECISION;
Johannes Bergf3b85252009-04-23 16:01:47 +0200371 local->scan_channel_idx = 0;
372
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100373 ieee80211_offchannel_stop_vifs(local);
Johannes Berga80f7c02009-12-23 13:15:32 +0100374
Seth Forshee9c35d7d2013-02-11 11:21:08 -0600375 /* ensure nullfunc is transmitted before leaving operating channel */
Johannes Berg39ecc012013-02-13 12:11:00 +0100376 ieee80211_flush_queues(local, NULL);
Seth Forshee9c35d7d2013-02-11 11:21:08 -0600377
Johannes Berg3ac64be2009-08-17 16:16:53 +0200378 ieee80211_configure_filter(local);
Johannes Bergf3b85252009-04-23 16:01:47 +0200379
Ben Greear59bdf3b2011-02-07 13:44:38 -0800380 /* We need to set power level at maximum rate for scanning. */
381 ieee80211_hw_config(local, 0);
382
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400383 ieee80211_queue_delayed_work(&local->hw,
Johannes Berg07ef03e2011-11-08 16:21:21 +0100384 &local->scan_work, 0);
Johannes Bergf3b85252009-04-23 16:01:47 +0200385
386 return 0;
387}
388
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200389static bool ieee80211_can_scan(struct ieee80211_local *local,
390 struct ieee80211_sub_if_data *sdata)
391{
Simon Wunderlich164eb022013-02-08 18:16:20 +0100392 if (local->radar_detect_enabled)
393 return false;
394
Johannes Berg2eb278e2012-06-05 14:28:42 +0200395 if (!list_empty(&local->roc_list))
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200396 return false;
397
398 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
Stanislaw Gruszka392b9ff2013-08-27 11:36:35 +0200399 sdata->u.mgd.flags & IEEE80211_STA_CONNECTION_POLL)
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200400 return false;
401
402 return true;
403}
404
405void ieee80211_run_deferred_scan(struct ieee80211_local *local)
406{
407 lockdep_assert_held(&local->mtx);
408
409 if (!local->scan_req || local->scanning)
410 return;
411
Johannes Berge2fd5db2012-07-06 21:39:28 +0200412 if (!ieee80211_can_scan(local,
413 rcu_dereference_protected(
414 local->scan_sdata,
415 lockdep_is_held(&local->mtx))))
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200416 return;
417
418 ieee80211_queue_delayed_work(&local->hw, &local->scan_work,
419 round_jiffies_relative(0));
420}
Johannes Bergf3b85252009-04-23 16:01:47 +0200421
Ben Greear8a690672012-04-17 10:54:16 -0700422static void ieee80211_scan_state_send_probe(struct ieee80211_local *local,
423 unsigned long *next_delay)
424{
425 int i;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200426 struct ieee80211_sub_if_data *sdata;
Karl Beldan675a0b02013-03-25 16:26:57 +0100427 enum ieee80211_band band = local->hw.conf.chandef.chan->band;
Seth Forshee6c17b772013-02-11 11:21:07 -0600428 u32 tx_flags;
429
430 tx_flags = IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
431 if (local->scan_req->no_cck)
432 tx_flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
Ben Greear8a690672012-04-17 10:54:16 -0700433
Johannes Berge2fd5db2012-07-06 21:39:28 +0200434 sdata = rcu_dereference_protected(local->scan_sdata,
Peter Senna Tschudin316b6b52012-09-06 18:09:16 +0200435 lockdep_is_held(&local->mtx));
Johannes Berge2fd5db2012-07-06 21:39:28 +0200436
Ben Greear8a690672012-04-17 10:54:16 -0700437 for (i = 0; i < local->scan_req->n_ssids; i++)
438 ieee80211_send_probe_req(
439 sdata, NULL,
440 local->scan_req->ssids[i].ssid,
441 local->scan_req->ssids[i].ssid_len,
442 local->scan_req->ie, local->scan_req->ie_len,
443 local->scan_req->rates[band], false,
Karl Beldan675a0b02013-03-25 16:26:57 +0100444 tx_flags, local->hw.conf.chandef.chan, true);
Ben Greear8a690672012-04-17 10:54:16 -0700445
446 /*
447 * After sending probe requests, wait for probe responses
448 * on the channel.
449 */
450 *next_delay = IEEE80211_CHANNEL_TIME;
451 local->next_scan_state = SCAN_DECISION;
452}
453
Johannes Bergf3b85252009-04-23 16:01:47 +0200454static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
455 struct cfg80211_scan_request *req)
456{
457 struct ieee80211_local *local = sdata->local;
Johannes Bergf3b85252009-04-23 16:01:47 +0200458 int rc;
459
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200460 lockdep_assert_held(&local->mtx);
461
Johannes Bergf3b85252009-04-23 16:01:47 +0200462 if (local->scan_req)
463 return -EBUSY;
464
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200465 if (!ieee80211_can_scan(local, sdata)) {
John W. Linville6e7e6212010-02-08 16:38:38 -0500466 /* wait for the work to finish/time out */
Johannes Bergc0ce77b2010-02-03 10:22:31 +0100467 local->scan_req = req;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200468 rcu_assign_pointer(local->scan_sdata, sdata);
Johannes Bergc0ce77b2010-02-03 10:22:31 +0100469 return 0;
470 }
471
Johannes Bergf3b85252009-04-23 16:01:47 +0200472 if (local->ops->hw_scan) {
473 u8 *ies;
Johannes Bergf3b85252009-04-23 16:01:47 +0200474
David Spinadele4dcbb32014-02-11 13:45:41 +0200475 local->hw_scan_ies_bufsize = local->scan_ies_len + req->ie_len;
Johannes Berg4d36ec582009-10-27 20:59:55 +0100476 local->hw_scan_req = kmalloc(
477 sizeof(*local->hw_scan_req) +
478 req->n_channels * sizeof(req->channels[0]) +
Johannes Bergc604b9f2012-11-29 12:45:18 +0100479 local->hw_scan_ies_bufsize, GFP_KERNEL);
Johannes Berg4d36ec582009-10-27 20:59:55 +0100480 if (!local->hw_scan_req)
Johannes Bergf3b85252009-04-23 16:01:47 +0200481 return -ENOMEM;
482
Johannes Berg4d36ec582009-10-27 20:59:55 +0100483 local->hw_scan_req->ssids = req->ssids;
484 local->hw_scan_req->n_ssids = req->n_ssids;
485 ies = (u8 *)local->hw_scan_req +
486 sizeof(*local->hw_scan_req) +
487 req->n_channels * sizeof(req->channels[0]);
488 local->hw_scan_req->ie = ies;
Sam Lefflercd2bb512012-10-11 21:03:35 -0700489 local->hw_scan_req->flags = req->flags;
Johannes Berg4d36ec582009-10-27 20:59:55 +0100490
491 local->hw_scan_band = 0;
John W. Linville6e7e6212010-02-08 16:38:38 -0500492
493 /*
494 * After allocating local->hw_scan_req, we must
495 * go through until ieee80211_prep_hw_scan(), so
496 * anything that might be changed here and leave
497 * this function early must not go after this
498 * allocation.
499 */
Johannes Bergf3b85252009-04-23 16:01:47 +0200500 }
501
502 local->scan_req = req;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200503 rcu_assign_pointer(local->scan_sdata, sdata);
Johannes Bergf3b85252009-04-23 16:01:47 +0200504
Ben Greear8a690672012-04-17 10:54:16 -0700505 if (local->ops->hw_scan) {
Helmut Schaafbe9c422009-07-23 12:14:04 +0200506 __set_bit(SCAN_HW_SCANNING, &local->scanning);
Ben Greear8a690672012-04-17 10:54:16 -0700507 } else if ((req->n_channels == 1) &&
Karl Beldan675a0b02013-03-25 16:26:57 +0100508 (req->channels[0] == local->_oper_chandef.chan)) {
Johannes Berg9b864872012-07-26 14:38:32 +0200509 /*
510 * If we are scanning only on the operating channel
511 * then we do not need to stop normal activities
Ben Greear8a690672012-04-17 10:54:16 -0700512 */
513 unsigned long next_delay;
514
515 __set_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
516
517 ieee80211_recalc_idle(local);
518
519 /* Notify driver scan is starting, keep order of operations
520 * same as normal software scan, in case that matters. */
521 drv_sw_scan_start(local);
522
523 ieee80211_configure_filter(local); /* accept probe-responses */
524
525 /* We need to ensure power level is at max for scanning. */
526 ieee80211_hw_config(local, 0);
527
528 if ((req->channels[0]->flags &
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200529 IEEE80211_CHAN_NO_IR) ||
Ben Greear8a690672012-04-17 10:54:16 -0700530 !local->scan_req->n_ssids) {
531 next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
532 } else {
533 ieee80211_scan_state_send_probe(local, &next_delay);
534 next_delay = IEEE80211_CHANNEL_TIME;
535 }
536
537 /* Now, just wait a bit and we are all done! */
538 ieee80211_queue_delayed_work(&local->hw, &local->scan_work,
539 next_delay);
540 return 0;
541 } else {
542 /* Do normal software scan */
Helmut Schaafbe9c422009-07-23 12:14:04 +0200543 __set_bit(SCAN_SW_SCANNING, &local->scanning);
Ben Greear8a690672012-04-17 10:54:16 -0700544 }
John W. Linville6e7e6212010-02-08 16:38:38 -0500545
Johannes Berg5cff20e2009-04-29 12:26:17 +0200546 ieee80211_recalc_idle(local);
Johannes Bergf3b85252009-04-23 16:01:47 +0200547
Johannes Berg4d36ec582009-10-27 20:59:55 +0100548 if (local->ops->hw_scan) {
549 WARN_ON(!ieee80211_prep_hw_scan(local));
Johannes Berga060bbf2010-04-27 11:59:34 +0200550 rc = drv_hw_scan(local, sdata, local->hw_scan_req);
Johannes Berg4d36ec582009-10-27 20:59:55 +0100551 } else
Johannes Bergf3b85252009-04-23 16:01:47 +0200552 rc = ieee80211_start_sw_scan(local);
553
Johannes Bergf3b85252009-04-23 16:01:47 +0200554 if (rc) {
Johannes Berg4d36ec582009-10-27 20:59:55 +0100555 kfree(local->hw_scan_req);
556 local->hw_scan_req = NULL;
Helmut Schaafbe9c422009-07-23 12:14:04 +0200557 local->scanning = 0;
Johannes Bergf3b85252009-04-23 16:01:47 +0200558
Johannes Berg5cff20e2009-04-29 12:26:17 +0200559 ieee80211_recalc_idle(local);
560
Johannes Bergf3b85252009-04-23 16:01:47 +0200561 local->scan_req = NULL;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200562 rcu_assign_pointer(local->scan_sdata, NULL);
Johannes Bergf3b85252009-04-23 16:01:47 +0200563 }
564
565 return rc;
566}
567
Helmut Schaadf13cce2010-02-24 14:19:21 +0100568static unsigned long
569ieee80211_scan_get_channel_time(struct ieee80211_channel *chan)
570{
571 /*
572 * TODO: channel switching also consumes quite some time,
573 * add that delay as well to get a better estimation
574 */
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200575 if (chan->flags & IEEE80211_CHAN_NO_IR)
Helmut Schaadf13cce2010-02-24 14:19:21 +0100576 return IEEE80211_PASSIVE_CHANNEL_TIME;
577 return IEEE80211_PROBE_DELAY + IEEE80211_CHANNEL_TIME;
578}
579
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200580static void ieee80211_scan_state_decision(struct ieee80211_local *local,
581 unsigned long *next_delay)
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200582{
Helmut Schaa142b9f52009-07-23 13:18:01 +0200583 bool associated = false;
Helmut Schaadf13cce2010-02-24 14:19:21 +0100584 bool tx_empty = true;
585 bool bad_latency;
Helmut Schaa142b9f52009-07-23 13:18:01 +0200586 struct ieee80211_sub_if_data *sdata;
Helmut Schaadf13cce2010-02-24 14:19:21 +0100587 struct ieee80211_channel *next_chan;
Sam Lefflercd2bb512012-10-11 21:03:35 -0700588 enum mac80211_scan_state next_scan_state;
Helmut Schaa142b9f52009-07-23 13:18:01 +0200589
Helmut Schaadf13cce2010-02-24 14:19:21 +0100590 /*
591 * check if at least one STA interface is associated,
592 * check if at least one STA interface has pending tx frames
593 * and grab the lowest used beacon interval
594 */
Helmut Schaa142b9f52009-07-23 13:18:01 +0200595 mutex_lock(&local->iflist_mtx);
596 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +0100597 if (!ieee80211_sdata_running(sdata))
Helmut Schaa142b9f52009-07-23 13:18:01 +0200598 continue;
599
600 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
601 if (sdata->u.mgd.associated) {
602 associated = true;
Helmut Schaadf13cce2010-02-24 14:19:21 +0100603
Helmut Schaadf13cce2010-02-24 14:19:21 +0100604 if (!qdisc_all_tx_empty(sdata->dev)) {
605 tx_empty = false;
606 break;
607 }
Helmut Schaa142b9f52009-07-23 13:18:01 +0200608 }
609 }
610 }
611 mutex_unlock(&local->iflist_mtx);
612
Ben Greearb23b0252011-02-04 11:54:17 -0800613 next_chan = local->scan_req->channels[local->scan_channel_idx];
614
Johannes Berg07ef03e2011-11-08 16:21:21 +0100615 /*
616 * we're currently scanning a different channel, let's
617 * see if we can scan another channel without interfering
618 * with the current traffic situation.
619 *
Stanislaw Gruszka3f892b62013-01-23 12:32:45 +0100620 * Keep good latency, do not stay off-channel more than 125 ms.
Johannes Berg07ef03e2011-11-08 16:21:21 +0100621 */
Helmut Schaadf13cce2010-02-24 14:19:21 +0100622
Johannes Berg07ef03e2011-11-08 16:21:21 +0100623 bad_latency = time_after(jiffies +
Stanislaw Gruszka3f892b62013-01-23 12:32:45 +0100624 ieee80211_scan_get_channel_time(next_chan),
625 local->leave_oper_channel_time + HZ / 8);
Helmut Schaadf13cce2010-02-24 14:19:21 +0100626
Sam Lefflercd2bb512012-10-11 21:03:35 -0700627 if (associated && !tx_empty) {
628 if (local->scan_req->flags & NL80211_SCAN_FLAG_LOW_PRIORITY)
629 next_scan_state = SCAN_ABORT;
630 else
631 next_scan_state = SCAN_SUSPEND;
Stanislaw Gruszka3f892b62013-01-23 12:32:45 +0100632 } else if (associated && bad_latency) {
Sam Lefflercd2bb512012-10-11 21:03:35 -0700633 next_scan_state = SCAN_SUSPEND;
634 } else {
635 next_scan_state = SCAN_SET_CHANNEL;
636 }
637
638 local->next_scan_state = next_scan_state;
Helmut Schaa142b9f52009-07-23 13:18:01 +0200639
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200640 *next_delay = 0;
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200641}
642
643static void ieee80211_scan_state_set_channel(struct ieee80211_local *local,
644 unsigned long *next_delay)
645{
646 int skip;
647 struct ieee80211_channel *chan;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200648 enum nl80211_bss_scan_width oper_scan_width;
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200649
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200650 skip = 0;
651 chan = local->scan_req->channels[local->scan_channel_idx];
652
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200653 local->scan_chandef.chan = chan;
654 local->scan_chandef.center_freq1 = chan->center_freq;
655 local->scan_chandef.center_freq2 = 0;
656 switch (local->scan_req->scan_width) {
657 case NL80211_BSS_CHAN_WIDTH_5:
658 local->scan_chandef.width = NL80211_CHAN_WIDTH_5;
659 break;
660 case NL80211_BSS_CHAN_WIDTH_10:
661 local->scan_chandef.width = NL80211_CHAN_WIDTH_10;
662 break;
663 case NL80211_BSS_CHAN_WIDTH_20:
664 /* If scanning on oper channel, use whatever channel-type
665 * is currently in use.
666 */
667 oper_scan_width = cfg80211_chandef_to_scan_width(
668 &local->_oper_chandef);
669 if (chan == local->_oper_chandef.chan &&
670 oper_scan_width == local->scan_req->scan_width)
671 local->scan_chandef = local->_oper_chandef;
672 else
673 local->scan_chandef.width = NL80211_CHAN_WIDTH_20_NOHT;
674 break;
675 }
Ben Greearb23b0252011-02-04 11:54:17 -0800676
Johannes Berg07ef03e2011-11-08 16:21:21 +0100677 if (ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL))
678 skip = 1;
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200679
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200680 /* advance state machine to next channel/band */
681 local->scan_channel_idx++;
682
Helmut Schaa0ee9c132009-07-25 17:25:51 +0200683 if (skip) {
684 /* if we skip this channel return to the decision state */
685 local->next_scan_state = SCAN_DECISION;
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200686 return;
Helmut Schaa0ee9c132009-07-25 17:25:51 +0200687 }
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200688
689 /*
690 * Probe delay is used to update the NAV, cf. 11.1.3.2.2
691 * (which unfortunately doesn't say _why_ step a) is done,
692 * but it waits for the probe delay or until a frame is
693 * received - and the received frame would update the NAV).
694 * For now, we do not support waiting until a frame is
695 * received.
696 *
697 * In any case, it is not necessary for a passive scan.
698 */
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200699 if (chan->flags & IEEE80211_CHAN_NO_IR ||
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200700 !local->scan_req->n_ssids) {
701 *next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
Helmut Schaa977923b2009-07-23 12:14:20 +0200702 local->next_scan_state = SCAN_DECISION;
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200703 return;
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200704 }
705
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200706 /* active scan, send probes */
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200707 *next_delay = IEEE80211_PROBE_DELAY;
Helmut Schaa977923b2009-07-23 12:14:20 +0200708 local->next_scan_state = SCAN_SEND_PROBE;
Helmut Schaa7d3be3c2009-07-23 12:13:41 +0200709}
710
Johannes Berg07ef03e2011-11-08 16:21:21 +0100711static void ieee80211_scan_state_suspend(struct ieee80211_local *local,
712 unsigned long *next_delay)
713{
714 /* switch back to the operating channel */
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200715 local->scan_chandef.chan = NULL;
Johannes Berg07ef03e2011-11-08 16:21:21 +0100716 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
717
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100718 /* disable PS */
719 ieee80211_offchannel_return(local);
Johannes Berg07ef03e2011-11-08 16:21:21 +0100720
721 *next_delay = HZ / 5;
722 /* afterwards, resume scan & go to next channel */
723 local->next_scan_state = SCAN_RESUME;
724}
725
726static void ieee80211_scan_state_resume(struct ieee80211_local *local,
727 unsigned long *next_delay)
728{
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100729 ieee80211_offchannel_stop_vifs(local);
Johannes Berg07ef03e2011-11-08 16:21:21 +0100730
731 if (local->ops->flush) {
Johannes Berg39ecc012013-02-13 12:11:00 +0100732 ieee80211_flush_queues(local, NULL);
Johannes Berg07ef03e2011-11-08 16:21:21 +0100733 *next_delay = 0;
734 } else
735 *next_delay = HZ / 10;
736
737 /* remember when we left the operating channel */
738 local->leave_oper_channel_time = jiffies;
739
740 /* advance to the next channel to be scanned */
Mohammed Shafi Shajakhande2ee842011-12-24 18:43:28 +0530741 local->next_scan_state = SCAN_SET_CHANNEL;
Johannes Berg07ef03e2011-11-08 16:21:21 +0100742}
743
Johannes Bergc2b13452008-09-11 00:01:55 +0200744void ieee80211_scan_work(struct work_struct *work)
Johannes Berg0a51b272008-09-08 17:44:25 +0200745{
746 struct ieee80211_local *local =
747 container_of(work, struct ieee80211_local, scan_work.work);
Johannes Bergd07bfd82011-03-07 15:48:41 +0100748 struct ieee80211_sub_if_data *sdata;
Johannes Berg0a51b272008-09-08 17:44:25 +0200749 unsigned long next_delay = 0;
Eliad Peller8bd2a242013-12-05 11:21:27 +0200750 bool aborted;
Johannes Berg8789d452010-08-26 13:30:26 +0200751
Johannes Berga1699b72010-07-30 16:46:07 +0200752 mutex_lock(&local->mtx);
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200753
Johannes Berge2fd5db2012-07-06 21:39:28 +0200754 sdata = rcu_dereference_protected(local->scan_sdata,
755 lockdep_is_held(&local->mtx));
Johannes Bergd07bfd82011-03-07 15:48:41 +0100756
Ben Greear8a690672012-04-17 10:54:16 -0700757 /* When scanning on-channel, the first-callback means completed. */
758 if (test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning)) {
759 aborted = test_and_clear_bit(SCAN_ABORTED, &local->scanning);
760 goto out_complete;
761 }
762
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200763 if (test_and_clear_bit(SCAN_COMPLETED, &local->scanning)) {
764 aborted = test_and_clear_bit(SCAN_ABORTED, &local->scanning);
765 goto out_complete;
Johannes Bergf3b85252009-04-23 16:01:47 +0200766 }
767
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200768 if (!sdata || !local->scan_req)
769 goto out;
770
Helmut Schaafbe9c422009-07-23 12:14:04 +0200771 if (local->scan_req && !local->scanning) {
Johannes Bergf3b85252009-04-23 16:01:47 +0200772 struct cfg80211_scan_request *req = local->scan_req;
773 int rc;
774
775 local->scan_req = NULL;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200776 rcu_assign_pointer(local->scan_sdata, NULL);
Johannes Bergf3b85252009-04-23 16:01:47 +0200777
778 rc = __ieee80211_start_scan(sdata, req);
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200779 if (rc) {
Stanislaw Gruszka3aed49e2010-10-06 11:22:12 +0200780 /* need to complete scan in cfg80211 */
781 local->scan_req = req;
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200782 aborted = true;
783 goto out_complete;
784 } else
785 goto out;
Johannes Bergf3b85252009-04-23 16:01:47 +0200786 }
787
Johannes Berg5bc75722008-09-11 00:01:51 +0200788 /*
Helmut Schaaf502d092009-07-23 12:13:48 +0200789 * as long as no delay is required advance immediately
790 * without scheduling a new work
791 */
792 do {
Rajkumar Manoharanc29acf22011-05-14 09:43:28 +0530793 if (!ieee80211_sdata_running(sdata)) {
794 aborted = true;
795 goto out_complete;
796 }
797
Helmut Schaa977923b2009-07-23 12:14:20 +0200798 switch (local->next_scan_state) {
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200799 case SCAN_DECISION:
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200800 /* if no more bands/channels left, complete scan */
801 if (local->scan_channel_idx >= local->scan_req->n_channels) {
802 aborted = false;
803 goto out_complete;
804 }
805 ieee80211_scan_state_decision(local, &next_delay);
Helmut Schaaf502d092009-07-23 12:13:48 +0200806 break;
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200807 case SCAN_SET_CHANNEL:
808 ieee80211_scan_state_set_channel(local, &next_delay);
809 break;
Helmut Schaaf502d092009-07-23 12:13:48 +0200810 case SCAN_SEND_PROBE:
811 ieee80211_scan_state_send_probe(local, &next_delay);
812 break;
Johannes Berg07ef03e2011-11-08 16:21:21 +0100813 case SCAN_SUSPEND:
814 ieee80211_scan_state_suspend(local, &next_delay);
Helmut Schaa142b9f52009-07-23 13:18:01 +0200815 break;
Johannes Berg07ef03e2011-11-08 16:21:21 +0100816 case SCAN_RESUME:
817 ieee80211_scan_state_resume(local, &next_delay);
Helmut Schaa142b9f52009-07-23 13:18:01 +0200818 break;
Sam Lefflercd2bb512012-10-11 21:03:35 -0700819 case SCAN_ABORT:
820 aborted = true;
821 goto out_complete;
Helmut Schaaf502d092009-07-23 12:13:48 +0200822 }
823 } while (next_delay == 0);
Johannes Berg0a51b272008-09-08 17:44:25 +0200824
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400825 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
Johannes Bergd07bfd82011-03-07 15:48:41 +0100826 goto out;
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200827
828out_complete:
Eliad Peller8bd2a242013-12-05 11:21:27 +0200829 __ieee80211_scan_completed(&local->hw, aborted);
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200830out:
831 mutex_unlock(&local->mtx);
Johannes Berg0a51b272008-09-08 17:44:25 +0200832}
833
Johannes Bergc2b13452008-09-11 00:01:55 +0200834int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
Johannes Berg2a519312009-02-10 21:25:55 +0100835 struct cfg80211_scan_request *req)
Johannes Berg0a51b272008-09-08 17:44:25 +0200836{
Johannes Bergf3b85252009-04-23 16:01:47 +0200837 int res;
838
Johannes Berga1699b72010-07-30 16:46:07 +0200839 mutex_lock(&sdata->local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200840 res = __ieee80211_start_scan(sdata, req);
Johannes Berga1699b72010-07-30 16:46:07 +0200841 mutex_unlock(&sdata->local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200842
843 return res;
844}
845
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100846int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
847 const u8 *ssid, u8 ssid_len,
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200848 struct ieee80211_channel *chan,
849 enum nl80211_bss_scan_width scan_width)
Johannes Bergf3b85252009-04-23 16:01:47 +0200850{
Johannes Berg0a51b272008-09-08 17:44:25 +0200851 struct ieee80211_local *local = sdata->local;
Johannes Bergf3b85252009-04-23 16:01:47 +0200852 int ret = -EBUSY;
Gertjan van Wingerdefb63bc42010-06-20 20:28:07 +0200853 enum ieee80211_band band;
Johannes Berg0a51b272008-09-08 17:44:25 +0200854
Johannes Berga1699b72010-07-30 16:46:07 +0200855 mutex_lock(&local->mtx);
Johannes Berg2a519312009-02-10 21:25:55 +0100856
Johannes Bergf3b85252009-04-23 16:01:47 +0200857 /* busy scanning */
858 if (local->scan_req)
859 goto unlock;
Johannes Berg2a519312009-02-10 21:25:55 +0100860
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200861 /* fill internal scan request */
862 if (!chan) {
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100863 int i, max_n;
864 int n_ch = 0;
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200865
866 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
867 if (!local->hw.wiphy->bands[band])
868 continue;
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100869
870 max_n = local->hw.wiphy->bands[band]->n_channels;
871 for (i = 0; i < max_n; i++) {
872 struct ieee80211_channel *tmp_ch =
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200873 &local->hw.wiphy->bands[band]->channels[i];
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100874
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200875 if (tmp_ch->flags & (IEEE80211_CHAN_NO_IR |
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100876 IEEE80211_CHAN_DISABLED))
877 continue;
878
879 local->int_scan_req->channels[n_ch] = tmp_ch;
880 n_ch++;
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200881 }
882 }
883
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100884 if (WARN_ON_ONCE(n_ch == 0))
885 goto unlock;
886
887 local->int_scan_req->n_channels = n_ch;
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200888 } else {
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200889 if (WARN_ON_ONCE(chan->flags & (IEEE80211_CHAN_NO_IR |
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100890 IEEE80211_CHAN_DISABLED)))
891 goto unlock;
892
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200893 local->int_scan_req->channels[0] = chan;
894 local->int_scan_req->n_channels = 1;
895 }
896
897 local->int_scan_req->ssids = &local->scan_ssid;
898 local->int_scan_req->n_ssids = 1;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200899 local->int_scan_req->scan_width = scan_width;
Johannes Berg5ba63532009-08-07 17:54:07 +0200900 memcpy(local->int_scan_req->ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
901 local->int_scan_req->ssids[0].ssid_len = ssid_len;
Johannes Berg2a519312009-02-10 21:25:55 +0100902
Johannes Berg5ba63532009-08-07 17:54:07 +0200903 ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
Johannes Bergf3b85252009-04-23 16:01:47 +0200904 unlock:
Johannes Berga1699b72010-07-30 16:46:07 +0200905 mutex_unlock(&local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200906 return ret;
Johannes Berg0a51b272008-09-08 17:44:25 +0200907}
Johannes Berg5bb644a2009-05-17 11:40:42 +0200908
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200909/*
910 * Only call this function when a scan can't be queued -- under RTNL.
911 */
Johannes Berg5bb644a2009-05-17 11:40:42 +0200912void ieee80211_scan_cancel(struct ieee80211_local *local)
913{
Johannes Berg5bb644a2009-05-17 11:40:42 +0200914 /*
Eliad Pellerb8564392011-06-13 12:47:30 +0300915 * We are canceling software scan, or deferred scan that was not
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200916 * yet really started (see __ieee80211_start_scan ).
917 *
918 * Regarding hardware scan:
919 * - we can not call __ieee80211_scan_completed() as when
920 * SCAN_HW_SCANNING bit is set this function change
921 * local->hw_scan_req to operate on 5G band, what race with
922 * driver which can use local->hw_scan_req
923 *
924 * - we can not cancel scan_work since driver can schedule it
925 * by ieee80211_scan_completed(..., true) to finish scan
926 *
Eliad Pellerb8564392011-06-13 12:47:30 +0300927 * Hence we only call the cancel_hw_scan() callback, but the low-level
928 * driver is still responsible for calling ieee80211_scan_completed()
929 * after the scan was completed/aborted.
Johannes Berg5bb644a2009-05-17 11:40:42 +0200930 */
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200931
Johannes Berga1699b72010-07-30 16:46:07 +0200932 mutex_lock(&local->mtx);
Eliad Pellerb8564392011-06-13 12:47:30 +0300933 if (!local->scan_req)
934 goto out;
935
Emmanuel Grumbacha7540552013-09-16 11:12:07 +0300936 /*
937 * We have a scan running and the driver already reported completion,
938 * but the worker hasn't run yet or is stuck on the mutex - mark it as
939 * cancelled.
940 */
941 if (test_bit(SCAN_HW_SCANNING, &local->scanning) &&
942 test_bit(SCAN_COMPLETED, &local->scanning)) {
943 set_bit(SCAN_HW_CANCELLED, &local->scanning);
944 goto out;
945 }
946
Eliad Pellerb8564392011-06-13 12:47:30 +0300947 if (test_bit(SCAN_HW_SCANNING, &local->scanning)) {
Emmanuel Grumbacha7540552013-09-16 11:12:07 +0300948 /*
949 * Make sure that __ieee80211_scan_completed doesn't trigger a
950 * scan on another band.
951 */
952 set_bit(SCAN_HW_CANCELLED, &local->scanning);
Eliad Pellerb8564392011-06-13 12:47:30 +0300953 if (local->ops->cancel_hw_scan)
Johannes Berge2fd5db2012-07-06 21:39:28 +0200954 drv_cancel_hw_scan(local,
955 rcu_dereference_protected(local->scan_sdata,
956 lockdep_is_held(&local->mtx)));
Eliad Pellerb8564392011-06-13 12:47:30 +0300957 goto out;
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200958 }
Eliad Pellerb8564392011-06-13 12:47:30 +0300959
960 /*
961 * If the work is currently running, it must be blocked on
962 * the mutex, but we'll set scan_sdata = NULL and it'll
963 * simply exit once it acquires the mutex.
964 */
965 cancel_delayed_work(&local->scan_work);
966 /* and clean up */
Eliad Peller8bd2a242013-12-05 11:21:27 +0200967 __ieee80211_scan_completed(&local->hw, true);
Eliad Pellerb8564392011-06-13 12:47:30 +0300968out:
Johannes Bergd07bfd82011-03-07 15:48:41 +0100969 mutex_unlock(&local->mtx);
Johannes Berg5bb644a2009-05-17 11:40:42 +0200970}
Luciano Coelho79f460c2011-05-11 17:09:36 +0300971
David Spinadeld43c6b62013-12-08 21:48:57 +0200972int __ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
973 struct cfg80211_sched_scan_request *req)
Luciano Coelho79f460c2011-05-11 17:09:36 +0300974{
975 struct ieee80211_local *local = sdata->local;
David Spinadelbca1e292012-10-29 14:49:41 +0200976 struct ieee80211_sched_scan_ies sched_scan_ies = {};
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200977 struct cfg80211_chan_def chandef;
Johannes Bergc604b9f2012-11-29 12:45:18 +0100978 int ret, i, iebufsz;
979
David Spinadele4dcbb32014-02-11 13:45:41 +0200980 iebufsz = local->scan_ies_len + req->ie_len;
Luciano Coelho79f460c2011-05-11 17:09:36 +0300981
David Spinadeld43c6b62013-12-08 21:48:57 +0200982 lockdep_assert_held(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +0300983
David Spinadeld43c6b62013-12-08 21:48:57 +0200984 if (!local->ops->sched_scan_start)
985 return -ENOTSUPP;
Luciano Coelho79f460c2011-05-11 17:09:36 +0300986
987 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
Arik Nemtsovd811b3d2012-07-09 19:57:28 +0300988 if (!local->hw.wiphy->bands[i])
989 continue;
990
Johannes Bergc604b9f2012-11-29 12:45:18 +0100991 sched_scan_ies.ie[i] = kzalloc(iebufsz, GFP_KERNEL);
Johannes Berg30dd3ed2012-09-04 19:15:01 +0200992 if (!sched_scan_ies.ie[i]) {
Luciano Coelho79f460c2011-05-11 17:09:36 +0300993 ret = -ENOMEM;
994 goto out_free;
995 }
996
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200997 ieee80211_prepare_scan_chandef(&chandef, req->scan_width);
998
Johannes Berg30dd3ed2012-09-04 19:15:01 +0200999 sched_scan_ies.len[i] =
1000 ieee80211_build_preq_ies(local, sched_scan_ies.ie[i],
Johannes Bergc604b9f2012-11-29 12:45:18 +01001001 iebufsz, req->ie, req->ie_len,
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001002 i, (u32) -1, &chandef);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001003 }
1004
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001005 ret = drv_sched_scan_start(local, sdata, req, &sched_scan_ies);
David Spinadeld43c6b62013-12-08 21:48:57 +02001006 if (ret == 0) {
Johannes Berg5260a5b2012-07-06 21:55:11 +02001007 rcu_assign_pointer(local->sched_scan_sdata, sdata);
David Spinadeld43c6b62013-12-08 21:48:57 +02001008 local->sched_scan_req = req;
1009 }
Luciano Coelho79f460c2011-05-11 17:09:36 +03001010
1011out_free:
1012 while (i > 0)
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001013 kfree(sched_scan_ies.ie[--i]);
David Spinadeld43c6b62013-12-08 21:48:57 +02001014
1015 if (ret) {
1016 /* Clean in case of failure after HW restart or upon resume. */
1017 rcu_assign_pointer(local->sched_scan_sdata, NULL);
1018 local->sched_scan_req = NULL;
1019 }
1020
1021 return ret;
1022}
1023
1024int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
1025 struct cfg80211_sched_scan_request *req)
1026{
1027 struct ieee80211_local *local = sdata->local;
1028 int ret;
1029
1030 mutex_lock(&local->mtx);
1031
1032 if (rcu_access_pointer(local->sched_scan_sdata)) {
1033 mutex_unlock(&local->mtx);
1034 return -EBUSY;
1035 }
1036
1037 ret = __ieee80211_request_sched_scan_start(sdata, req);
1038
Johannes Berg5260a5b2012-07-06 21:55:11 +02001039 mutex_unlock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001040 return ret;
1041}
1042
Luciano Coelho85a99942011-05-12 16:28:29 +03001043int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata)
Luciano Coelho79f460c2011-05-11 17:09:36 +03001044{
1045 struct ieee80211_local *local = sdata->local;
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001046 int ret = 0;
Luciano Coelho79f460c2011-05-11 17:09:36 +03001047
Johannes Berg5260a5b2012-07-06 21:55:11 +02001048 mutex_lock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001049
1050 if (!local->ops->sched_scan_stop) {
1051 ret = -ENOTSUPP;
1052 goto out;
1053 }
1054
David Spinadeld43c6b62013-12-08 21:48:57 +02001055 /* We don't want to restart sched scan anymore. */
1056 local->sched_scan_req = NULL;
1057
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001058 if (rcu_access_pointer(local->sched_scan_sdata))
Luciano Coelho85a99942011-05-12 16:28:29 +03001059 drv_sched_scan_stop(local, sdata);
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001060
Luciano Coelho79f460c2011-05-11 17:09:36 +03001061out:
Johannes Berg5260a5b2012-07-06 21:55:11 +02001062 mutex_unlock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001063
1064 return ret;
1065}
1066
1067void ieee80211_sched_scan_results(struct ieee80211_hw *hw)
1068{
1069 struct ieee80211_local *local = hw_to_local(hw);
1070
1071 trace_api_sched_scan_results(local);
1072
1073 cfg80211_sched_scan_results(hw->wiphy);
1074}
1075EXPORT_SYMBOL(ieee80211_sched_scan_results);
1076
Luciano Coelho85a99942011-05-12 16:28:29 +03001077void ieee80211_sched_scan_stopped_work(struct work_struct *work)
1078{
1079 struct ieee80211_local *local =
1080 container_of(work, struct ieee80211_local,
1081 sched_scan_stopped_work);
Luciano Coelho85a99942011-05-12 16:28:29 +03001082
1083 mutex_lock(&local->mtx);
1084
Johannes Berg5260a5b2012-07-06 21:55:11 +02001085 if (!rcu_access_pointer(local->sched_scan_sdata)) {
Luciano Coelho85a99942011-05-12 16:28:29 +03001086 mutex_unlock(&local->mtx);
1087 return;
1088 }
1089
Johannes Berg5260a5b2012-07-06 21:55:11 +02001090 rcu_assign_pointer(local->sched_scan_sdata, NULL);
Luciano Coelho85a99942011-05-12 16:28:29 +03001091
David Spinadeld43c6b62013-12-08 21:48:57 +02001092 /* If sched scan was aborted by the driver. */
1093 local->sched_scan_req = NULL;
1094
Luciano Coelho85a99942011-05-12 16:28:29 +03001095 mutex_unlock(&local->mtx);
1096
1097 cfg80211_sched_scan_stopped(local->hw.wiphy);
1098}
1099
Luciano Coelho79f460c2011-05-11 17:09:36 +03001100void ieee80211_sched_scan_stopped(struct ieee80211_hw *hw)
1101{
1102 struct ieee80211_local *local = hw_to_local(hw);
1103
1104 trace_api_sched_scan_stopped(local);
1105
Johannes Berg18db5942013-11-06 10:34:36 +01001106 schedule_work(&local->sched_scan_stopped_work);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001107}
1108EXPORT_SYMBOL(ieee80211_sched_scan_stopped);