blob: bcc4833d7542b91e1b754ed490d1dedcaee559c1 [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
Johannes Bergd07bfd82011-03-07 15:48:41 +0100274static void __ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted,
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200275 bool was_hw_scan)
Johannes Berg0a51b272008-09-08 17:44:25 +0200276{
277 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg0a51b272008-09-08 17:44:25 +0200278
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200279 lockdep_assert_held(&local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200280
Johannes Berg6d3560d2009-10-31 07:44:08 +0100281 /*
282 * It's ok to abort a not-yet-running scan (that
283 * we have one at all will be verified by checking
284 * local->scan_req next), but not to complete it
285 * successfully.
286 */
287 if (WARN_ON(!local->scanning && !aborted))
288 aborted = true;
Johannes Bergde95a542009-04-01 11:58:36 +0200289
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200290 if (WARN_ON(!local->scan_req))
Johannes Bergd07bfd82011-03-07 15:48:41 +0100291 return;
Johannes Bergf3b85252009-04-23 16:01:47 +0200292
Johannes Berg4d36ec582009-10-27 20:59:55 +0100293 if (was_hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
Johannes Berge2fd5db2012-07-06 21:39:28 +0200294 int rc;
295
296 rc = drv_hw_scan(local,
297 rcu_dereference_protected(local->scan_sdata,
298 lockdep_is_held(&local->mtx)),
299 local->hw_scan_req);
300
Stanislaw Gruszka6eb11a92010-10-06 11:22:11 +0200301 if (rc == 0)
Johannes Bergd07bfd82011-03-07 15:48:41 +0100302 return;
Johannes Berg4d36ec582009-10-27 20:59:55 +0100303 }
304
305 kfree(local->hw_scan_req);
306 local->hw_scan_req = NULL;
Johannes Bergf3b85252009-04-23 16:01:47 +0200307
Johannes Berg5ba63532009-08-07 17:54:07 +0200308 if (local->scan_req != local->int_scan_req)
Johannes Berg2a519312009-02-10 21:25:55 +0100309 cfg80211_scan_done(local->scan_req, aborted);
310 local->scan_req = NULL;
Johannes Berg3aa569c2012-07-18 12:42:58 +0200311 rcu_assign_pointer(local->scan_sdata, NULL);
Johannes Berg2a519312009-02-10 21:25:55 +0100312
Helmut Schaafbe9c422009-07-23 12:14:04 +0200313 local->scanning = 0;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200314 local->scan_chandef.chan = NULL;
Johannes Bergf3b85252009-04-23 16:01:47 +0200315
Johannes Berg07ef03e2011-11-08 16:21:21 +0100316 /* Set power back to normal operating levels. */
317 ieee80211_hw_config(local, 0);
Ben Greearb23b0252011-02-04 11:54:17 -0800318
319 if (!was_hw_scan) {
Ben Greearb23b0252011-02-04 11:54:17 -0800320 ieee80211_configure_filter(local);
321 drv_sw_scan_complete(local);
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100322 ieee80211_offchannel_return(local);
Ben Greearb23b0252011-02-04 11:54:17 -0800323 }
324
Johannes Berg5cff20e2009-04-29 12:26:17 +0200325 ieee80211_recalc_idle(local);
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200326
Johannes Berg0a51b272008-09-08 17:44:25 +0200327 ieee80211_mlme_notify_scan_completed(local);
Johannes Berg46900292009-02-15 12:44:28 +0100328 ieee80211_ibss_notify_scan_completed(local);
Johannes Berg472dbc42008-09-11 00:01:49 +0200329 ieee80211_mesh_notify_scan_completed(local);
Johannes Berg2eb278e2012-06-05 14:28:42 +0200330 ieee80211_start_next_roc(local);
Johannes Berg0a51b272008-09-08 17:44:25 +0200331}
Johannes Berg8789d452010-08-26 13:30:26 +0200332
333void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
334{
335 struct ieee80211_local *local = hw_to_local(hw);
336
337 trace_api_scan_completed(local, aborted);
338
339 set_bit(SCAN_COMPLETED, &local->scanning);
340 if (aborted)
341 set_bit(SCAN_ABORTED, &local->scanning);
342 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
343}
Johannes Berg0a51b272008-09-08 17:44:25 +0200344EXPORT_SYMBOL(ieee80211_scan_completed);
345
Johannes Bergf3b85252009-04-23 16:01:47 +0200346static int ieee80211_start_sw_scan(struct ieee80211_local *local)
347{
Johannes Bergfe57d9f2012-07-26 14:55:08 +0200348 /* Software scan is not supported in multi-channel cases */
349 if (local->use_chanctx)
350 return -EOPNOTSUPP;
351
Johannes Bergf3b85252009-04-23 16:01:47 +0200352 /*
353 * Hardware/driver doesn't support hw_scan, so use software
354 * scanning instead. First send a nullfunc frame with power save
355 * bit on so that AP will buffer the frames for us while we are not
356 * listening, then send probe requests to each channel and wait for
357 * the responses. After all channels are scanned, tune back to the
358 * original channel and send a nullfunc frame with power save bit
359 * off to trigger the AP to send us all the buffered frames.
360 *
361 * Note that while local->sw_scanning is true everything else but
362 * nullfunc frames and probe requests will be dropped in
363 * ieee80211_tx_h_check_assoc().
364 */
Johannes Berg24487982009-04-23 18:52:52 +0200365 drv_sw_scan_start(local);
Johannes Bergf3b85252009-04-23 16:01:47 +0200366
Rajkumar Manoharande312db2012-03-27 11:01:06 +0530367 local->leave_oper_channel_time = jiffies;
Helmut Schaa977923b2009-07-23 12:14:20 +0200368 local->next_scan_state = SCAN_DECISION;
Johannes Bergf3b85252009-04-23 16:01:47 +0200369 local->scan_channel_idx = 0;
370
Stanislaw Gruszkaaacde9e2012-12-20 14:41:18 +0100371 ieee80211_offchannel_stop_vifs(local);
Johannes Berga80f7c02009-12-23 13:15:32 +0100372
Seth Forshee9c35d7d2013-02-11 11:21:08 -0600373 /* ensure nullfunc is transmitted before leaving operating channel */
Johannes Berg39ecc012013-02-13 12:11:00 +0100374 ieee80211_flush_queues(local, NULL);
Seth Forshee9c35d7d2013-02-11 11:21:08 -0600375
Johannes Berg3ac64be2009-08-17 16:16:53 +0200376 ieee80211_configure_filter(local);
Johannes Bergf3b85252009-04-23 16:01:47 +0200377
Ben Greear59bdf3b2011-02-07 13:44:38 -0800378 /* We need to set power level at maximum rate for scanning. */
379 ieee80211_hw_config(local, 0);
380
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400381 ieee80211_queue_delayed_work(&local->hw,
Johannes Berg07ef03e2011-11-08 16:21:21 +0100382 &local->scan_work, 0);
Johannes Bergf3b85252009-04-23 16:01:47 +0200383
384 return 0;
385}
386
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200387static bool ieee80211_can_scan(struct ieee80211_local *local,
388 struct ieee80211_sub_if_data *sdata)
389{
Simon Wunderlich164eb022013-02-08 18:16:20 +0100390 if (local->radar_detect_enabled)
391 return false;
392
Johannes Berg2eb278e2012-06-05 14:28:42 +0200393 if (!list_empty(&local->roc_list))
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200394 return false;
395
396 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
Stanislaw Gruszka392b9ff2013-08-27 11:36:35 +0200397 sdata->u.mgd.flags & IEEE80211_STA_CONNECTION_POLL)
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200398 return false;
399
400 return true;
401}
402
403void ieee80211_run_deferred_scan(struct ieee80211_local *local)
404{
405 lockdep_assert_held(&local->mtx);
406
407 if (!local->scan_req || local->scanning)
408 return;
409
Johannes Berge2fd5db2012-07-06 21:39:28 +0200410 if (!ieee80211_can_scan(local,
411 rcu_dereference_protected(
412 local->scan_sdata,
413 lockdep_is_held(&local->mtx))))
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200414 return;
415
416 ieee80211_queue_delayed_work(&local->hw, &local->scan_work,
417 round_jiffies_relative(0));
418}
Johannes Bergf3b85252009-04-23 16:01:47 +0200419
Ben Greear8a690672012-04-17 10:54:16 -0700420static void ieee80211_scan_state_send_probe(struct ieee80211_local *local,
421 unsigned long *next_delay)
422{
423 int i;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200424 struct ieee80211_sub_if_data *sdata;
Karl Beldan675a0b02013-03-25 16:26:57 +0100425 enum ieee80211_band band = local->hw.conf.chandef.chan->band;
Seth Forshee6c17b772013-02-11 11:21:07 -0600426 u32 tx_flags;
427
428 tx_flags = IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
429 if (local->scan_req->no_cck)
430 tx_flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
Ben Greear8a690672012-04-17 10:54:16 -0700431
Johannes Berge2fd5db2012-07-06 21:39:28 +0200432 sdata = rcu_dereference_protected(local->scan_sdata,
Peter Senna Tschudin316b6b52012-09-06 18:09:16 +0200433 lockdep_is_held(&local->mtx));
Johannes Berge2fd5db2012-07-06 21:39:28 +0200434
Ben Greear8a690672012-04-17 10:54:16 -0700435 for (i = 0; i < local->scan_req->n_ssids; i++)
436 ieee80211_send_probe_req(
437 sdata, NULL,
438 local->scan_req->ssids[i].ssid,
439 local->scan_req->ssids[i].ssid_len,
440 local->scan_req->ie, local->scan_req->ie_len,
441 local->scan_req->rates[band], false,
Karl Beldan675a0b02013-03-25 16:26:57 +0100442 tx_flags, local->hw.conf.chandef.chan, true);
Ben Greear8a690672012-04-17 10:54:16 -0700443
444 /*
445 * After sending probe requests, wait for probe responses
446 * on the channel.
447 */
448 *next_delay = IEEE80211_CHANNEL_TIME;
449 local->next_scan_state = SCAN_DECISION;
450}
451
Johannes Bergf3b85252009-04-23 16:01:47 +0200452static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
453 struct cfg80211_scan_request *req)
454{
455 struct ieee80211_local *local = sdata->local;
Johannes Bergf3b85252009-04-23 16:01:47 +0200456 int rc;
457
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200458 lockdep_assert_held(&local->mtx);
459
Johannes Bergf3b85252009-04-23 16:01:47 +0200460 if (local->scan_req)
461 return -EBUSY;
462
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +0200463 if (!ieee80211_can_scan(local, sdata)) {
John W. Linville6e7e6212010-02-08 16:38:38 -0500464 /* wait for the work to finish/time out */
Johannes Bergc0ce77b2010-02-03 10:22:31 +0100465 local->scan_req = req;
Johannes Berge2fd5db2012-07-06 21:39:28 +0200466 rcu_assign_pointer(local->scan_sdata, sdata);
Johannes Bergc0ce77b2010-02-03 10:22:31 +0100467 return 0;
468 }
469
Johannes Bergf3b85252009-04-23 16:01:47 +0200470 if (local->ops->hw_scan) {
471 u8 *ies;
Johannes Bergf3b85252009-04-23 16:01:47 +0200472
Johannes Bergc604b9f2012-11-29 12:45:18 +0100473 local->hw_scan_ies_bufsize = 2 + IEEE80211_MAX_SSID_LEN +
474 local->scan_ies_len +
475 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 &
529 IEEE80211_CHAN_PASSIVE_SCAN) ||
530 !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 */
575 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
576 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 */
699 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
700 !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;
Johannes Bergd07bfd82011-03-07 15:48:41 +0100750 bool aborted, hw_scan;
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 /*
789 * Avoid re-scheduling when the sdata is going away.
790 */
Johannes Berg9607e6b2009-12-23 13:15:31 +0100791 if (!ieee80211_sdata_running(sdata)) {
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200792 aborted = true;
793 goto out_complete;
Johannes Bergf3b85252009-04-23 16:01:47 +0200794 }
Johannes Berg0a51b272008-09-08 17:44:25 +0200795
Helmut Schaaf502d092009-07-23 12:13:48 +0200796 /*
797 * as long as no delay is required advance immediately
798 * without scheduling a new work
799 */
800 do {
Rajkumar Manoharanc29acf22011-05-14 09:43:28 +0530801 if (!ieee80211_sdata_running(sdata)) {
802 aborted = true;
803 goto out_complete;
804 }
805
Helmut Schaa977923b2009-07-23 12:14:20 +0200806 switch (local->next_scan_state) {
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200807 case SCAN_DECISION:
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200808 /* if no more bands/channels left, complete scan */
809 if (local->scan_channel_idx >= local->scan_req->n_channels) {
810 aborted = false;
811 goto out_complete;
812 }
813 ieee80211_scan_state_decision(local, &next_delay);
Helmut Schaaf502d092009-07-23 12:13:48 +0200814 break;
Helmut Schaa2fb3f022009-07-23 12:13:56 +0200815 case SCAN_SET_CHANNEL:
816 ieee80211_scan_state_set_channel(local, &next_delay);
817 break;
Helmut Schaaf502d092009-07-23 12:13:48 +0200818 case SCAN_SEND_PROBE:
819 ieee80211_scan_state_send_probe(local, &next_delay);
820 break;
Johannes Berg07ef03e2011-11-08 16:21:21 +0100821 case SCAN_SUSPEND:
822 ieee80211_scan_state_suspend(local, &next_delay);
Helmut Schaa142b9f52009-07-23 13:18:01 +0200823 break;
Johannes Berg07ef03e2011-11-08 16:21:21 +0100824 case SCAN_RESUME:
825 ieee80211_scan_state_resume(local, &next_delay);
Helmut Schaa142b9f52009-07-23 13:18:01 +0200826 break;
Sam Lefflercd2bb512012-10-11 21:03:35 -0700827 case SCAN_ABORT:
828 aborted = true;
829 goto out_complete;
Helmut Schaaf502d092009-07-23 12:13:48 +0200830 }
831 } while (next_delay == 0);
Johannes Berg0a51b272008-09-08 17:44:25 +0200832
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400833 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
Johannes Bergd07bfd82011-03-07 15:48:41 +0100834 goto out;
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200835
836out_complete:
Stanislaw Gruszkae229f842010-10-06 11:22:09 +0200837 hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
Johannes Bergd07bfd82011-03-07 15:48:41 +0100838 __ieee80211_scan_completed(&local->hw, aborted, hw_scan);
Stanislaw Gruszka259b62e2010-10-06 11:22:08 +0200839out:
840 mutex_unlock(&local->mtx);
Johannes Berg0a51b272008-09-08 17:44:25 +0200841}
842
Johannes Bergc2b13452008-09-11 00:01:55 +0200843int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
Johannes Berg2a519312009-02-10 21:25:55 +0100844 struct cfg80211_scan_request *req)
Johannes Berg0a51b272008-09-08 17:44:25 +0200845{
Johannes Bergf3b85252009-04-23 16:01:47 +0200846 int res;
847
Johannes Berga1699b72010-07-30 16:46:07 +0200848 mutex_lock(&sdata->local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200849 res = __ieee80211_start_scan(sdata, req);
Johannes Berga1699b72010-07-30 16:46:07 +0200850 mutex_unlock(&sdata->local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200851
852 return res;
853}
854
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100855int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
856 const u8 *ssid, u8 ssid_len,
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200857 struct ieee80211_channel *chan,
858 enum nl80211_bss_scan_width scan_width)
Johannes Bergf3b85252009-04-23 16:01:47 +0200859{
Johannes Berg0a51b272008-09-08 17:44:25 +0200860 struct ieee80211_local *local = sdata->local;
Johannes Bergf3b85252009-04-23 16:01:47 +0200861 int ret = -EBUSY;
Gertjan van Wingerdefb63bc42010-06-20 20:28:07 +0200862 enum ieee80211_band band;
Johannes Berg0a51b272008-09-08 17:44:25 +0200863
Johannes Berga1699b72010-07-30 16:46:07 +0200864 mutex_lock(&local->mtx);
Johannes Berg2a519312009-02-10 21:25:55 +0100865
Johannes Bergf3b85252009-04-23 16:01:47 +0200866 /* busy scanning */
867 if (local->scan_req)
868 goto unlock;
Johannes Berg2a519312009-02-10 21:25:55 +0100869
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200870 /* fill internal scan request */
871 if (!chan) {
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100872 int i, max_n;
873 int n_ch = 0;
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200874
875 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
876 if (!local->hw.wiphy->bands[band])
877 continue;
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100878
879 max_n = local->hw.wiphy->bands[band]->n_channels;
880 for (i = 0; i < max_n; i++) {
881 struct ieee80211_channel *tmp_ch =
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200882 &local->hw.wiphy->bands[band]->channels[i];
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100883
884 if (tmp_ch->flags & (IEEE80211_CHAN_NO_IBSS |
885 IEEE80211_CHAN_DISABLED))
886 continue;
887
888 local->int_scan_req->channels[n_ch] = tmp_ch;
889 n_ch++;
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200890 }
891 }
892
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100893 if (WARN_ON_ONCE(n_ch == 0))
894 goto unlock;
895
896 local->int_scan_req->n_channels = n_ch;
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200897 } else {
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +0100898 if (WARN_ON_ONCE(chan->flags & (IEEE80211_CHAN_NO_IBSS |
899 IEEE80211_CHAN_DISABLED)))
900 goto unlock;
901
Johannes Bergbe4a4b62010-05-03 08:49:48 +0200902 local->int_scan_req->channels[0] = chan;
903 local->int_scan_req->n_channels = 1;
904 }
905
906 local->int_scan_req->ssids = &local->scan_ssid;
907 local->int_scan_req->n_ssids = 1;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200908 local->int_scan_req->scan_width = scan_width;
Johannes Berg5ba63532009-08-07 17:54:07 +0200909 memcpy(local->int_scan_req->ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
910 local->int_scan_req->ssids[0].ssid_len = ssid_len;
Johannes Berg2a519312009-02-10 21:25:55 +0100911
Johannes Berg5ba63532009-08-07 17:54:07 +0200912 ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
Johannes Bergf3b85252009-04-23 16:01:47 +0200913 unlock:
Johannes Berga1699b72010-07-30 16:46:07 +0200914 mutex_unlock(&local->mtx);
Johannes Bergf3b85252009-04-23 16:01:47 +0200915 return ret;
Johannes Berg0a51b272008-09-08 17:44:25 +0200916}
Johannes Berg5bb644a2009-05-17 11:40:42 +0200917
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200918/*
919 * Only call this function when a scan can't be queued -- under RTNL.
920 */
Johannes Berg5bb644a2009-05-17 11:40:42 +0200921void ieee80211_scan_cancel(struct ieee80211_local *local)
922{
Johannes Berg5bb644a2009-05-17 11:40:42 +0200923 /*
Eliad Pellerb8564392011-06-13 12:47:30 +0300924 * We are canceling software scan, or deferred scan that was not
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200925 * yet really started (see __ieee80211_start_scan ).
926 *
927 * Regarding hardware scan:
928 * - we can not call __ieee80211_scan_completed() as when
929 * SCAN_HW_SCANNING bit is set this function change
930 * local->hw_scan_req to operate on 5G band, what race with
931 * driver which can use local->hw_scan_req
932 *
933 * - we can not cancel scan_work since driver can schedule it
934 * by ieee80211_scan_completed(..., true) to finish scan
935 *
Eliad Pellerb8564392011-06-13 12:47:30 +0300936 * Hence we only call the cancel_hw_scan() callback, but the low-level
937 * driver is still responsible for calling ieee80211_scan_completed()
938 * after the scan was completed/aborted.
Johannes Berg5bb644a2009-05-17 11:40:42 +0200939 */
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200940
Johannes Berga1699b72010-07-30 16:46:07 +0200941 mutex_lock(&local->mtx);
Eliad Pellerb8564392011-06-13 12:47:30 +0300942 if (!local->scan_req)
943 goto out;
944
Emmanuel Grumbacha7540552013-09-16 11:12:07 +0300945 /*
946 * We have a scan running and the driver already reported completion,
947 * but the worker hasn't run yet or is stuck on the mutex - mark it as
948 * cancelled.
949 */
950 if (test_bit(SCAN_HW_SCANNING, &local->scanning) &&
951 test_bit(SCAN_COMPLETED, &local->scanning)) {
952 set_bit(SCAN_HW_CANCELLED, &local->scanning);
953 goto out;
954 }
955
Eliad Pellerb8564392011-06-13 12:47:30 +0300956 if (test_bit(SCAN_HW_SCANNING, &local->scanning)) {
Emmanuel Grumbacha7540552013-09-16 11:12:07 +0300957 /*
958 * Make sure that __ieee80211_scan_completed doesn't trigger a
959 * scan on another band.
960 */
961 set_bit(SCAN_HW_CANCELLED, &local->scanning);
Eliad Pellerb8564392011-06-13 12:47:30 +0300962 if (local->ops->cancel_hw_scan)
Johannes Berge2fd5db2012-07-06 21:39:28 +0200963 drv_cancel_hw_scan(local,
964 rcu_dereference_protected(local->scan_sdata,
965 lockdep_is_held(&local->mtx)));
Eliad Pellerb8564392011-06-13 12:47:30 +0300966 goto out;
Stanislaw Gruszka4136c422010-10-06 11:22:10 +0200967 }
Eliad Pellerb8564392011-06-13 12:47:30 +0300968
969 /*
970 * If the work is currently running, it must be blocked on
971 * the mutex, but we'll set scan_sdata = NULL and it'll
972 * simply exit once it acquires the mutex.
973 */
974 cancel_delayed_work(&local->scan_work);
975 /* and clean up */
976 __ieee80211_scan_completed(&local->hw, true, false);
977out:
Johannes Bergd07bfd82011-03-07 15:48:41 +0100978 mutex_unlock(&local->mtx);
Johannes Berg5bb644a2009-05-17 11:40:42 +0200979}
Luciano Coelho79f460c2011-05-11 17:09:36 +0300980
981int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
982 struct cfg80211_sched_scan_request *req)
983{
984 struct ieee80211_local *local = sdata->local;
David Spinadelbca1e292012-10-29 14:49:41 +0200985 struct ieee80211_sched_scan_ies sched_scan_ies = {};
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200986 struct cfg80211_chan_def chandef;
Johannes Bergc604b9f2012-11-29 12:45:18 +0100987 int ret, i, iebufsz;
988
989 iebufsz = 2 + IEEE80211_MAX_SSID_LEN +
990 local->scan_ies_len + req->ie_len;
Luciano Coelho79f460c2011-05-11 17:09:36 +0300991
Johannes Berg5260a5b2012-07-06 21:55:11 +0200992 mutex_lock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +0300993
Johannes Berg5260a5b2012-07-06 21:55:11 +0200994 if (rcu_access_pointer(local->sched_scan_sdata)) {
Luciano Coelho79f460c2011-05-11 17:09:36 +0300995 ret = -EBUSY;
996 goto out;
997 }
998
999 if (!local->ops->sched_scan_start) {
1000 ret = -ENOTSUPP;
1001 goto out;
1002 }
1003
1004 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
Arik Nemtsovd811b3d2012-07-09 19:57:28 +03001005 if (!local->hw.wiphy->bands[i])
1006 continue;
1007
Johannes Bergc604b9f2012-11-29 12:45:18 +01001008 sched_scan_ies.ie[i] = kzalloc(iebufsz, GFP_KERNEL);
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001009 if (!sched_scan_ies.ie[i]) {
Luciano Coelho79f460c2011-05-11 17:09:36 +03001010 ret = -ENOMEM;
1011 goto out_free;
1012 }
1013
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001014 ieee80211_prepare_scan_chandef(&chandef, req->scan_width);
1015
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001016 sched_scan_ies.len[i] =
1017 ieee80211_build_preq_ies(local, sched_scan_ies.ie[i],
Johannes Bergc604b9f2012-11-29 12:45:18 +01001018 iebufsz, req->ie, req->ie_len,
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001019 i, (u32) -1, &chandef);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001020 }
1021
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001022 ret = drv_sched_scan_start(local, sdata, req, &sched_scan_ies);
1023 if (ret == 0)
Johannes Berg5260a5b2012-07-06 21:55:11 +02001024 rcu_assign_pointer(local->sched_scan_sdata, sdata);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001025
1026out_free:
1027 while (i > 0)
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001028 kfree(sched_scan_ies.ie[--i]);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001029out:
Johannes Berg5260a5b2012-07-06 21:55:11 +02001030 mutex_unlock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001031 return ret;
1032}
1033
Luciano Coelho85a99942011-05-12 16:28:29 +03001034int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata)
Luciano Coelho79f460c2011-05-11 17:09:36 +03001035{
1036 struct ieee80211_local *local = sdata->local;
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001037 int ret = 0;
Luciano Coelho79f460c2011-05-11 17:09:36 +03001038
Johannes Berg5260a5b2012-07-06 21:55:11 +02001039 mutex_lock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001040
1041 if (!local->ops->sched_scan_stop) {
1042 ret = -ENOTSUPP;
1043 goto out;
1044 }
1045
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001046 if (rcu_access_pointer(local->sched_scan_sdata))
Luciano Coelho85a99942011-05-12 16:28:29 +03001047 drv_sched_scan_stop(local, sdata);
Johannes Berg30dd3ed2012-09-04 19:15:01 +02001048
Luciano Coelho79f460c2011-05-11 17:09:36 +03001049out:
Johannes Berg5260a5b2012-07-06 21:55:11 +02001050 mutex_unlock(&local->mtx);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001051
1052 return ret;
1053}
1054
1055void ieee80211_sched_scan_results(struct ieee80211_hw *hw)
1056{
1057 struct ieee80211_local *local = hw_to_local(hw);
1058
1059 trace_api_sched_scan_results(local);
1060
1061 cfg80211_sched_scan_results(hw->wiphy);
1062}
1063EXPORT_SYMBOL(ieee80211_sched_scan_results);
1064
Luciano Coelho85a99942011-05-12 16:28:29 +03001065void ieee80211_sched_scan_stopped_work(struct work_struct *work)
1066{
1067 struct ieee80211_local *local =
1068 container_of(work, struct ieee80211_local,
1069 sched_scan_stopped_work);
Luciano Coelho85a99942011-05-12 16:28:29 +03001070
1071 mutex_lock(&local->mtx);
1072
Johannes Berg5260a5b2012-07-06 21:55:11 +02001073 if (!rcu_access_pointer(local->sched_scan_sdata)) {
Luciano Coelho85a99942011-05-12 16:28:29 +03001074 mutex_unlock(&local->mtx);
1075 return;
1076 }
1077
Johannes Berg5260a5b2012-07-06 21:55:11 +02001078 rcu_assign_pointer(local->sched_scan_sdata, NULL);
Luciano Coelho85a99942011-05-12 16:28:29 +03001079
1080 mutex_unlock(&local->mtx);
1081
1082 cfg80211_sched_scan_stopped(local->hw.wiphy);
1083}
1084
Luciano Coelho79f460c2011-05-11 17:09:36 +03001085void ieee80211_sched_scan_stopped(struct ieee80211_hw *hw)
1086{
1087 struct ieee80211_local *local = hw_to_local(hw);
1088
1089 trace_api_sched_scan_stopped(local);
1090
Johannes Berg18db5942013-11-06 10:34:36 +01001091 schedule_work(&local->sched_scan_stopped_work);
Luciano Coelho79f460c2011-05-11 17:09:36 +03001092}
1093EXPORT_SYMBOL(ieee80211_sched_scan_stopped);