2008-09-08 17:44:25 +02:00
|
|
|
/*
|
2008-09-08 17:44:27 +02:00
|
|
|
* Scanning implementation
|
|
|
|
*
|
2008-09-08 17:44:25 +02:00
|
|
|
* Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
|
|
|
|
* Copyright 2004, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
|
|
* Copyright 2007, Michael Wu <flamingice@sourmilk.net>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/if_arp.h>
|
2009-01-22 18:07:31 +01:00
|
|
|
#include <linux/rtnetlink.h>
|
2010-02-24 14:19:21 +01:00
|
|
|
#include <linux/pm_qos_params.h>
|
|
|
|
#include <net/sch_generic.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2008-09-08 17:44:25 +02:00
|
|
|
#include <net/mac80211.h>
|
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 18:52:52 +02:00
|
|
|
#include "driver-ops.h"
|
2008-09-08 17:44:27 +02:00
|
|
|
#include "mesh.h"
|
2008-09-08 17:44:25 +02:00
|
|
|
|
|
|
|
#define IEEE80211_PROBE_DELAY (HZ / 33)
|
|
|
|
#define IEEE80211_CHANNEL_TIME (HZ / 33)
|
2009-06-30 14:49:18 +02:00
|
|
|
#define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 8)
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2008-09-11 00:01:55 +02:00
|
|
|
struct ieee80211_bss *
|
2008-09-08 17:44:27 +02:00
|
|
|
ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq,
|
|
|
|
u8 *ssid, u8 ssid_len)
|
|
|
|
{
|
2009-12-23 13:15:39 +01:00
|
|
|
struct cfg80211_bss *cbss;
|
|
|
|
|
|
|
|
cbss = cfg80211_get_bss(local->hw.wiphy,
|
|
|
|
ieee80211_get_channel(local->hw.wiphy, freq),
|
|
|
|
bssid, ssid, ssid_len, 0, 0);
|
|
|
|
if (!cbss)
|
|
|
|
return NULL;
|
|
|
|
return (void *)cbss->priv;
|
2008-09-08 17:44:27 +02:00
|
|
|
}
|
|
|
|
|
2009-02-10 21:26:00 +01:00
|
|
|
static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
|
2008-09-08 17:44:27 +02:00
|
|
|
{
|
2009-12-23 13:15:39 +01:00
|
|
|
struct ieee80211_bss *bss = (void *)cbss->priv;
|
2008-09-08 17:44:27 +02:00
|
|
|
|
|
|
|
kfree(bss_mesh_id(bss));
|
|
|
|
kfree(bss_mesh_cfg(bss));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_rx_bss_put(struct ieee80211_local *local,
|
2008-09-11 00:01:55 +02:00
|
|
|
struct ieee80211_bss *bss)
|
2008-09-08 17:44:27 +02:00
|
|
|
{
|
2009-12-23 13:15:39 +01:00
|
|
|
if (!bss)
|
|
|
|
return;
|
|
|
|
cfg80211_put_bss(container_of((void *)bss, struct cfg80211_bss, priv));
|
2008-09-08 17:44:27 +02:00
|
|
|
}
|
|
|
|
|
2010-01-12 09:42:31 +01:00
|
|
|
static bool is_uapsd_supported(struct ieee802_11_elems *elems)
|
|
|
|
{
|
|
|
|
u8 qos_info;
|
|
|
|
|
|
|
|
if (elems->wmm_info && elems->wmm_info_len == 7
|
|
|
|
&& elems->wmm_info[5] == 1)
|
|
|
|
qos_info = elems->wmm_info[6];
|
|
|
|
else if (elems->wmm_param && elems->wmm_param_len == 24
|
|
|
|
&& elems->wmm_param[5] == 1)
|
|
|
|
qos_info = elems->wmm_param[6];
|
|
|
|
else
|
|
|
|
/* no valid wmm information or parameter element found */
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return qos_info & IEEE80211_WMM_IE_AP_QOSINFO_UAPSD;
|
|
|
|
}
|
|
|
|
|
2008-09-11 00:01:55 +02:00
|
|
|
struct ieee80211_bss *
|
2008-09-08 17:44:27 +02:00
|
|
|
ieee80211_bss_info_update(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_rx_status *rx_status,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len,
|
|
|
|
struct ieee802_11_elems *elems,
|
2009-02-10 21:25:55 +01:00
|
|
|
struct ieee80211_channel *channel,
|
|
|
|
bool beacon)
|
2008-09-08 17:44:27 +02:00
|
|
|
{
|
2009-12-23 13:15:39 +01:00
|
|
|
struct cfg80211_bss *cbss;
|
2008-09-11 00:01:55 +02:00
|
|
|
struct ieee80211_bss *bss;
|
2010-04-28 15:17:03 +02:00
|
|
|
int clen, srlen;
|
2009-02-10 21:25:55 +01:00
|
|
|
s32 signal = 0;
|
|
|
|
|
2009-02-18 18:45:06 +01:00
|
|
|
if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
|
2009-02-10 21:25:55 +01:00
|
|
|
signal = rx_status->signal * 100;
|
2009-02-18 18:45:06 +01:00
|
|
|
else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
|
2009-02-10 21:25:55 +01:00
|
|
|
signal = (rx_status->signal * 100) / local->hw.max_signal;
|
|
|
|
|
2009-12-23 13:15:39 +01:00
|
|
|
cbss = cfg80211_inform_bss_frame(local->hw.wiphy, channel,
|
|
|
|
mgmt, len, signal, GFP_ATOMIC);
|
2008-09-08 17:44:27 +02:00
|
|
|
|
2009-12-23 13:15:39 +01:00
|
|
|
if (!cbss)
|
2009-02-10 21:26:00 +01:00
|
|
|
return NULL;
|
|
|
|
|
2009-12-23 13:15:39 +01:00
|
|
|
cbss->free_priv = ieee80211_rx_bss_free;
|
|
|
|
bss = (void *)cbss->priv;
|
2008-09-08 17:44:27 +02:00
|
|
|
|
|
|
|
/* save the ERP value so that it is available at association time */
|
|
|
|
if (elems->erp_info && elems->erp_info_len >= 1) {
|
|
|
|
bss->erp_value = elems->erp_info[0];
|
|
|
|
bss->has_erp_value = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (elems->tim) {
|
|
|
|
struct ieee80211_tim_ie *tim_ie =
|
|
|
|
(struct ieee80211_tim_ie *)elems->tim;
|
|
|
|
bss->dtim_period = tim_ie->dtim_period;
|
|
|
|
}
|
|
|
|
|
2010-07-29 16:08:55 +02:00
|
|
|
/* If the beacon had no TIM IE, or it was invalid, use 1 */
|
|
|
|
if (beacon && !bss->dtim_period)
|
|
|
|
bss->dtim_period = 1;
|
|
|
|
|
2010-04-28 15:17:03 +02:00
|
|
|
/* replace old supported rates if we get new values */
|
|
|
|
srlen = 0;
|
2008-09-08 17:44:27 +02:00
|
|
|
if (elems->supp_rates) {
|
2010-04-28 15:17:03 +02:00
|
|
|
clen = IEEE80211_MAX_SUPP_RATES;
|
2008-09-08 17:44:27 +02:00
|
|
|
if (clen > elems->supp_rates_len)
|
|
|
|
clen = elems->supp_rates_len;
|
2010-04-28 15:17:03 +02:00
|
|
|
memcpy(bss->supp_rates, elems->supp_rates, clen);
|
|
|
|
srlen += clen;
|
2008-09-08 17:44:27 +02:00
|
|
|
}
|
|
|
|
if (elems->ext_supp_rates) {
|
2010-04-28 15:17:03 +02:00
|
|
|
clen = IEEE80211_MAX_SUPP_RATES - srlen;
|
2008-09-08 17:44:27 +02:00
|
|
|
if (clen > elems->ext_supp_rates_len)
|
|
|
|
clen = elems->ext_supp_rates_len;
|
2010-04-28 15:17:03 +02:00
|
|
|
memcpy(bss->supp_rates + srlen, elems->ext_supp_rates, clen);
|
|
|
|
srlen += clen;
|
2008-09-08 17:44:27 +02:00
|
|
|
}
|
2010-04-28 15:17:03 +02:00
|
|
|
if (srlen)
|
|
|
|
bss->supp_rates_len = srlen;
|
2008-09-08 17:44:27 +02:00
|
|
|
|
|
|
|
bss->wmm_used = elems->wmm_param || elems->wmm_info;
|
2010-01-12 09:42:31 +01:00
|
|
|
bss->uapsd_supported = is_uapsd_supported(elems);
|
2008-09-08 17:44:27 +02:00
|
|
|
|
|
|
|
if (!beacon)
|
|
|
|
bss->last_probe_resp = jiffies;
|
|
|
|
|
|
|
|
return bss;
|
|
|
|
}
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2008-09-08 17:44:26 +02:00
|
|
|
ieee80211_rx_result
|
2009-06-17 13:13:00 +02:00
|
|
|
ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
|
2008-09-08 17:44:26 +02:00
|
|
|
{
|
2009-06-17 13:13:00 +02:00
|
|
|
struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
|
2008-09-08 17:44:26 +02:00
|
|
|
struct ieee80211_mgmt *mgmt;
|
2008-09-11 00:01:55 +02:00
|
|
|
struct ieee80211_bss *bss;
|
2008-09-08 17:44:26 +02:00
|
|
|
u8 *elements;
|
|
|
|
struct ieee80211_channel *channel;
|
|
|
|
size_t baselen;
|
|
|
|
int freq;
|
|
|
|
__le16 fc;
|
|
|
|
bool presp, beacon = false;
|
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
|
|
|
|
if (skb->len < 2)
|
|
|
|
return RX_DROP_UNUSABLE;
|
|
|
|
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb->data;
|
|
|
|
fc = mgmt->frame_control;
|
|
|
|
|
|
|
|
if (ieee80211_is_ctl(fc))
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (skb->len < 24)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
presp = ieee80211_is_probe_resp(fc);
|
|
|
|
if (presp) {
|
|
|
|
/* ignore ProbeResp to foreign address */
|
2009-11-25 17:46:19 +01:00
|
|
|
if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN))
|
2008-09-08 17:44:26 +02:00
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
presp = true;
|
|
|
|
elements = mgmt->u.probe_resp.variable;
|
|
|
|
baselen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
|
|
|
|
} else {
|
|
|
|
beacon = ieee80211_is_beacon(fc);
|
|
|
|
baselen = offsetof(struct ieee80211_mgmt, u.beacon.variable);
|
|
|
|
elements = mgmt->u.beacon.variable;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!presp && !beacon)
|
|
|
|
return RX_CONTINUE;
|
|
|
|
|
|
|
|
if (baselen > skb->len)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
ieee802_11_parse_elems(elements, skb->len - baselen, &elems);
|
|
|
|
|
|
|
|
if (elems.ds_params && elems.ds_params_len == 1)
|
|
|
|
freq = ieee80211_channel_to_frequency(elems.ds_params[0]);
|
|
|
|
else
|
|
|
|
freq = rx_status->freq;
|
|
|
|
|
|
|
|
channel = ieee80211_get_channel(sdata->local->hw.wiphy, freq);
|
|
|
|
|
|
|
|
if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
|
|
|
|
return RX_DROP_MONITOR;
|
|
|
|
|
|
|
|
bss = ieee80211_bss_info_update(sdata->local, rx_status,
|
|
|
|
mgmt, skb->len, &elems,
|
2009-02-10 21:25:55 +01:00
|
|
|
channel, beacon);
|
2008-10-11 02:29:55 +02:00
|
|
|
if (bss)
|
|
|
|
ieee80211_rx_bss_put(sdata->local, bss);
|
2008-09-08 17:44:26 +02:00
|
|
|
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return RX_QUEUED;
|
|
|
|
}
|
|
|
|
|
2009-10-27 20:59:55 +01:00
|
|
|
/* return false if no more work */
|
|
|
|
static bool ieee80211_prep_hw_scan(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct cfg80211_scan_request *req = local->scan_req;
|
|
|
|
enum ieee80211_band band;
|
|
|
|
int i, ielen, n_chans;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (local->hw_scan_band == IEEE80211_NUM_BANDS)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
band = local->hw_scan_band;
|
|
|
|
n_chans = 0;
|
|
|
|
for (i = 0; i < req->n_channels; i++) {
|
|
|
|
if (req->channels[i]->band == band) {
|
|
|
|
local->hw_scan_req->channels[n_chans] =
|
|
|
|
req->channels[i];
|
|
|
|
n_chans++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
local->hw_scan_band++;
|
|
|
|
} while (!n_chans);
|
|
|
|
|
|
|
|
local->hw_scan_req->n_channels = n_chans;
|
|
|
|
|
|
|
|
ielen = ieee80211_build_preq_ies(local, (u8 *)local->hw_scan_req->ie,
|
2010-08-28 18:37:51 +02:00
|
|
|
req->ie, req->ie_len, band, (u32) -1,
|
|
|
|
0);
|
2009-10-27 20:59:55 +01:00
|
|
|
local->hw_scan_req->ie_len = ielen;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
static bool __ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted,
|
|
|
|
bool was_hw_scan)
|
2008-09-08 17:44:25 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
lockdep_assert_held(&local->mtx);
|
2008-09-11 00:01:51 +02:00
|
|
|
|
2009-10-31 07:44:08 +01:00
|
|
|
/*
|
|
|
|
* It's ok to abort a not-yet-running scan (that
|
|
|
|
* we have one at all will be verified by checking
|
|
|
|
* local->scan_req next), but not to complete it
|
|
|
|
* successfully.
|
|
|
|
*/
|
|
|
|
if (WARN_ON(!local->scanning && !aborted))
|
|
|
|
aborted = true;
|
2008-09-11 00:01:51 +02:00
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
if (WARN_ON(!local->scan_req))
|
|
|
|
return false;
|
2009-04-01 11:58:36 +02:00
|
|
|
|
2009-10-27 20:59:55 +01:00
|
|
|
if (was_hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
|
|
|
|
ieee80211_queue_delayed_work(&local->hw,
|
|
|
|
&local->scan_work, 0);
|
2010-10-06 11:22:09 +02:00
|
|
|
return false;
|
2009-10-27 20:59:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(local->hw_scan_req);
|
|
|
|
local->hw_scan_req = NULL;
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2009-08-07 17:54:07 +02:00
|
|
|
if (local->scan_req != local->int_scan_req)
|
2009-02-10 21:25:55 +01:00
|
|
|
cfg80211_scan_done(local->scan_req, aborted);
|
|
|
|
local->scan_req = NULL;
|
2009-08-25 16:33:47 +02:00
|
|
|
local->scan_sdata = NULL;
|
2009-02-10 21:25:55 +01:00
|
|
|
|
2009-07-23 12:14:04 +02:00
|
|
|
local->scanning = 0;
|
mac80211: fix scan channel race
When a software scan starts, it first sets sw_scanning, but
leaves the scan_channel "unset" (it currently actually gets
initialised to a default). Now, when something else tries
to (re)configure the hardware in the window between these two
events (after sw_scanning = true, but before scan_channel is
set), the current code switches to the (unset!) scan_channel.
This causes trouble, especially when switching bands and
sending frames on the wrong channel.
To work around this, leave scan_channel initialised to NULL
and use it to determine whether or not a switch to a different
channel should occur (and also use the same condition to check
whether to adjust power for scan or not).
Additionally, avoid reconfiguring the hardware completely when
recalculating idle resulted in no changes, this was the problem
that originally led us to discover the race condition in the
first place, which was helpfully bisected by Pavel. This part
of the patch should not be necessary with the other fixes, but
not calling the ieee80211_hw_config function when we know it to
be unnecessary is certainly a correct thing to do.
Unfortunately, this patch cannot and does not fix the race
condition completely, but due to the way the scan code is
structured it makes the particular problem Pavel discovered
(race while changing channel at the same time as transmitting
frames) go away. To fix it completely, more work especially
with locking configuration is needed.
Bisected-by: Pavel Roskin <proski@gnu.org>
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-05-07 14:23:01 +02:00
|
|
|
local->scan_channel = NULL;
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
return true;
|
|
|
|
}
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
static void __ieee80211_scan_completed_finish(struct ieee80211_hw *hw,
|
|
|
|
bool was_hw_scan)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2010-07-27 22:33:08 +02:00
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
|
|
|
|
if (!was_hw_scan) {
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
drv_sw_scan_complete(local);
|
|
|
|
ieee80211_offchannel_return(local, true);
|
|
|
|
}
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_lock(&local->mtx);
|
2009-04-29 12:26:17 +02:00
|
|
|
ieee80211_recalc_idle(local);
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_unlock(&local->mtx);
|
2010-10-06 11:22:09 +02:00
|
|
|
|
2008-09-08 17:44:25 +02:00
|
|
|
ieee80211_mlme_notify_scan_completed(local);
|
2009-02-15 12:44:28 +01:00
|
|
|
ieee80211_ibss_notify_scan_completed(local);
|
2008-09-11 00:01:49 +02:00
|
|
|
ieee80211_mesh_notify_scan_completed(local);
|
2010-01-06 15:30:58 +01:00
|
|
|
ieee80211_queue_work(&local->hw, &local->work_work);
|
2008-09-08 17:44:25 +02:00
|
|
|
}
|
2010-08-26 13:30:26 +02:00
|
|
|
|
|
|
|
void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
trace_api_scan_completed(local, aborted);
|
|
|
|
|
|
|
|
set_bit(SCAN_COMPLETED, &local->scanning);
|
|
|
|
if (aborted)
|
|
|
|
set_bit(SCAN_ABORTED, &local->scanning);
|
|
|
|
ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
|
|
|
|
}
|
2008-09-08 17:44:25 +02:00
|
|
|
EXPORT_SYMBOL(ieee80211_scan_completed);
|
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
static int ieee80211_start_sw_scan(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Hardware/driver doesn't support hw_scan, so use software
|
|
|
|
* scanning instead. First send a nullfunc frame with power save
|
|
|
|
* bit on so that AP will buffer the frames for us while we are not
|
|
|
|
* listening, then send probe requests to each channel and wait for
|
|
|
|
* the responses. After all channels are scanned, tune back to the
|
|
|
|
* original channel and send a nullfunc frame with power save bit
|
|
|
|
* off to trigger the AP to send us all the buffered frames.
|
|
|
|
*
|
|
|
|
* Note that while local->sw_scanning is true everything else but
|
|
|
|
* nullfunc frames and probe requests will be dropped in
|
|
|
|
* ieee80211_tx_h_check_assoc().
|
|
|
|
*/
|
2009-04-23 18:52:52 +02:00
|
|
|
drv_sw_scan_start(local);
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2009-12-23 13:15:40 +01:00
|
|
|
ieee80211_offchannel_stop_beaconing(local);
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2010-02-24 14:19:21 +01:00
|
|
|
local->leave_oper_channel_time = 0;
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-04-23 16:01:47 +02:00
|
|
|
local->scan_channel_idx = 0;
|
|
|
|
|
2009-12-23 13:15:32 +01:00
|
|
|
drv_flush(local, false);
|
|
|
|
|
2009-08-17 16:16:53 +02:00
|
|
|
ieee80211_configure_filter(local);
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2009-07-30 02:08:07 +02:00
|
|
|
ieee80211_queue_delayed_work(&local->hw,
|
|
|
|
&local->scan_work,
|
|
|
|
IEEE80211_CHANNEL_TIME);
|
2009-04-23 16:01:47 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_scan_request *req)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int rc;
|
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
lockdep_assert_held(&local->mtx);
|
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
if (local->scan_req)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2010-02-08 22:38:38 +01:00
|
|
|
if (!list_empty(&local->work_list)) {
|
|
|
|
/* wait for the work to finish/time out */
|
2010-02-03 10:22:31 +01:00
|
|
|
local->scan_req = req;
|
|
|
|
local->scan_sdata = sdata;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
if (local->ops->hw_scan) {
|
|
|
|
u8 *ies;
|
|
|
|
|
2009-10-27 20:59:55 +01:00
|
|
|
local->hw_scan_req = kmalloc(
|
|
|
|
sizeof(*local->hw_scan_req) +
|
|
|
|
req->n_channels * sizeof(req->channels[0]) +
|
|
|
|
2 + IEEE80211_MAX_SSID_LEN + local->scan_ies_len +
|
|
|
|
req->ie_len, GFP_KERNEL);
|
|
|
|
if (!local->hw_scan_req)
|
2009-04-23 16:01:47 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-10-27 20:59:55 +01:00
|
|
|
local->hw_scan_req->ssids = req->ssids;
|
|
|
|
local->hw_scan_req->n_ssids = req->n_ssids;
|
|
|
|
ies = (u8 *)local->hw_scan_req +
|
|
|
|
sizeof(*local->hw_scan_req) +
|
|
|
|
req->n_channels * sizeof(req->channels[0]);
|
|
|
|
local->hw_scan_req->ie = ies;
|
|
|
|
|
|
|
|
local->hw_scan_band = 0;
|
2010-02-08 22:38:38 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* After allocating local->hw_scan_req, we must
|
|
|
|
* go through until ieee80211_prep_hw_scan(), so
|
|
|
|
* anything that might be changed here and leave
|
|
|
|
* this function early must not go after this
|
|
|
|
* allocation.
|
|
|
|
*/
|
2009-04-23 16:01:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
local->scan_req = req;
|
|
|
|
local->scan_sdata = sdata;
|
|
|
|
|
|
|
|
if (local->ops->hw_scan)
|
2009-07-23 12:14:04 +02:00
|
|
|
__set_bit(SCAN_HW_SCANNING, &local->scanning);
|
2009-04-23 16:01:47 +02:00
|
|
|
else
|
2009-07-23 12:14:04 +02:00
|
|
|
__set_bit(SCAN_SW_SCANNING, &local->scanning);
|
2010-02-08 22:38:38 +01:00
|
|
|
|
2009-04-29 12:26:17 +02:00
|
|
|
ieee80211_recalc_idle(local);
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2009-10-27 20:59:55 +01:00
|
|
|
if (local->ops->hw_scan) {
|
|
|
|
WARN_ON(!ieee80211_prep_hw_scan(local));
|
2010-04-27 11:59:34 +02:00
|
|
|
rc = drv_hw_scan(local, sdata, local->hw_scan_req);
|
2009-10-27 20:59:55 +01:00
|
|
|
} else
|
2009-04-23 16:01:47 +02:00
|
|
|
rc = ieee80211_start_sw_scan(local);
|
|
|
|
|
|
|
|
if (rc) {
|
2009-10-27 20:59:55 +01:00
|
|
|
kfree(local->hw_scan_req);
|
|
|
|
local->hw_scan_req = NULL;
|
2009-07-23 12:14:04 +02:00
|
|
|
local->scanning = 0;
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2009-04-29 12:26:17 +02:00
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
local->scan_req = NULL;
|
|
|
|
local->scan_sdata = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2010-02-24 14:19:21 +01:00
|
|
|
static unsigned long
|
|
|
|
ieee80211_scan_get_channel_time(struct ieee80211_channel *chan)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* TODO: channel switching also consumes quite some time,
|
|
|
|
* add that delay as well to get a better estimation
|
|
|
|
*/
|
|
|
|
if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
|
|
|
|
return IEEE80211_PASSIVE_CHANNEL_TIME;
|
|
|
|
return IEEE80211_PROBE_DELAY + IEEE80211_CHANNEL_TIME;
|
|
|
|
}
|
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
static void ieee80211_scan_state_decision(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
2009-07-23 12:13:41 +02:00
|
|
|
{
|
2009-07-23 13:18:01 +02:00
|
|
|
bool associated = false;
|
2010-02-24 14:19:21 +01:00
|
|
|
bool tx_empty = true;
|
|
|
|
bool bad_latency;
|
|
|
|
bool listen_int_exceeded;
|
|
|
|
unsigned long min_beacon_int = 0;
|
2009-07-23 13:18:01 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2010-02-24 14:19:21 +01:00
|
|
|
struct ieee80211_channel *next_chan;
|
2009-07-23 13:18:01 +02:00
|
|
|
|
2010-02-24 14:19:21 +01:00
|
|
|
/*
|
|
|
|
* check if at least one STA interface is associated,
|
|
|
|
* check if at least one STA interface has pending tx frames
|
|
|
|
* and grab the lowest used beacon interval
|
|
|
|
*/
|
2009-07-23 13:18:01 +02:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2009-12-23 13:15:31 +01:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-07-23 13:18:01 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION) {
|
|
|
|
if (sdata->u.mgd.associated) {
|
|
|
|
associated = true;
|
2010-02-24 14:19:21 +01:00
|
|
|
|
|
|
|
if (sdata->vif.bss_conf.beacon_int <
|
|
|
|
min_beacon_int || min_beacon_int == 0)
|
|
|
|
min_beacon_int =
|
|
|
|
sdata->vif.bss_conf.beacon_int;
|
|
|
|
|
|
|
|
if (!qdisc_all_tx_empty(sdata->dev)) {
|
|
|
|
tx_empty = false;
|
|
|
|
break;
|
|
|
|
}
|
2009-07-23 13:18:01 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
if (local->scan_channel) {
|
|
|
|
/*
|
|
|
|
* we're currently scanning a different channel, let's
|
2010-02-24 14:19:21 +01:00
|
|
|
* see if we can scan another channel without interfering
|
|
|
|
* with the current traffic situation.
|
|
|
|
*
|
|
|
|
* Since we don't know if the AP has pending frames for us
|
|
|
|
* we can only check for our tx queues and use the current
|
|
|
|
* pm_qos requirements for rx. Hence, if no tx traffic occurs
|
|
|
|
* at all we will scan as many channels in a row as the pm_qos
|
|
|
|
* latency allows us to. Additionally we also check for the
|
|
|
|
* currently negotiated listen interval to prevent losing
|
|
|
|
* frames unnecessarily.
|
|
|
|
*
|
|
|
|
* Otherwise switch back to the operating channel.
|
2009-07-23 13:18:01 +02:00
|
|
|
*/
|
2010-02-24 14:19:21 +01:00
|
|
|
next_chan = local->scan_req->channels[local->scan_channel_idx];
|
|
|
|
|
|
|
|
bad_latency = time_after(jiffies +
|
|
|
|
ieee80211_scan_get_channel_time(next_chan),
|
|
|
|
local->leave_oper_channel_time +
|
2010-05-21 06:04:44 +02:00
|
|
|
usecs_to_jiffies(pm_qos_request(PM_QOS_NETWORK_LATENCY)));
|
2010-02-24 14:19:21 +01:00
|
|
|
|
|
|
|
listen_int_exceeded = time_after(jiffies +
|
|
|
|
ieee80211_scan_get_channel_time(next_chan),
|
|
|
|
local->leave_oper_channel_time +
|
|
|
|
usecs_to_jiffies(min_beacon_int * 1024) *
|
|
|
|
local->hw.conf.listen_interval);
|
|
|
|
|
|
|
|
if (associated && ( !tx_empty || bad_latency ||
|
|
|
|
listen_int_exceeded))
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_ENTER_OPER_CHANNEL;
|
2009-07-23 13:18:01 +02:00
|
|
|
else
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_SET_CHANNEL;
|
2009-07-23 13:18:01 +02:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* we're on the operating channel currently, let's
|
|
|
|
* leave that channel now to scan another one
|
|
|
|
*/
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_LEAVE_OPER_CHANNEL;
|
2009-07-23 13:18:01 +02:00
|
|
|
}
|
|
|
|
|
2009-07-23 12:13:56 +02:00
|
|
|
*next_delay = 0;
|
|
|
|
}
|
|
|
|
|
2009-07-23 13:18:01 +02:00
|
|
|
static void ieee80211_scan_state_leave_oper_channel(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
|
|
|
{
|
2009-12-23 13:15:40 +01:00
|
|
|
ieee80211_offchannel_stop_station(local);
|
2009-07-23 13:18:01 +02:00
|
|
|
|
|
|
|
__set_bit(SCAN_OFF_CHANNEL, &local->scanning);
|
|
|
|
|
2009-12-23 13:15:32 +01:00
|
|
|
/*
|
|
|
|
* What if the nullfunc frames didn't arrive?
|
|
|
|
*/
|
|
|
|
drv_flush(local, false);
|
|
|
|
if (local->ops->flush)
|
|
|
|
*next_delay = 0;
|
|
|
|
else
|
|
|
|
*next_delay = HZ / 10;
|
|
|
|
|
2010-02-24 14:19:21 +01:00
|
|
|
/* remember when we left the operating channel */
|
|
|
|
local->leave_oper_channel_time = jiffies;
|
|
|
|
|
2009-07-23 13:18:01 +02:00
|
|
|
/* advance to the next channel to be scanned */
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_SET_CHANNEL;
|
2009-07-23 13:18:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_scan_state_enter_oper_channel(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
|
|
|
{
|
|
|
|
/* switch back to the operating channel */
|
|
|
|
local->scan_channel = NULL;
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
|
|
|
|
|
|
|
|
/*
|
2009-12-23 13:15:40 +01:00
|
|
|
* Only re-enable station mode interface now; beaconing will be
|
|
|
|
* re-enabled once the full scan has been completed.
|
2009-07-23 13:18:01 +02:00
|
|
|
*/
|
2009-12-23 13:15:40 +01:00
|
|
|
ieee80211_offchannel_return(local, false);
|
2009-07-23 13:18:01 +02:00
|
|
|
|
|
|
|
__clear_bit(SCAN_OFF_CHANNEL, &local->scanning);
|
|
|
|
|
|
|
|
*next_delay = HZ / 5;
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-07-23 13:18:01 +02:00
|
|
|
}
|
|
|
|
|
2009-07-23 12:13:56 +02:00
|
|
|
static void ieee80211_scan_state_set_channel(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
|
|
|
{
|
|
|
|
int skip;
|
|
|
|
struct ieee80211_channel *chan;
|
|
|
|
|
2009-07-23 12:13:41 +02:00
|
|
|
skip = 0;
|
|
|
|
chan = local->scan_req->channels[local->scan_channel_idx];
|
|
|
|
|
2009-11-02 13:32:03 +01:00
|
|
|
local->scan_channel = chan;
|
|
|
|
if (ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL))
|
2009-07-23 12:13:41 +02:00
|
|
|
skip = 1;
|
|
|
|
|
|
|
|
/* advance state machine to next channel/band */
|
|
|
|
local->scan_channel_idx++;
|
|
|
|
|
2009-07-25 17:25:51 +02:00
|
|
|
if (skip) {
|
|
|
|
/* if we skip this channel return to the decision state */
|
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-07-23 12:13:56 +02:00
|
|
|
return;
|
2009-07-25 17:25:51 +02:00
|
|
|
}
|
2009-07-23 12:13:41 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe delay is used to update the NAV, cf. 11.1.3.2.2
|
|
|
|
* (which unfortunately doesn't say _why_ step a) is done,
|
|
|
|
* but it waits for the probe delay or until a frame is
|
|
|
|
* received - and the received frame would update the NAV).
|
|
|
|
* For now, we do not support waiting until a frame is
|
|
|
|
* received.
|
|
|
|
*
|
|
|
|
* In any case, it is not necessary for a passive scan.
|
|
|
|
*/
|
|
|
|
if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
|
|
|
|
!local->scan_req->n_ssids) {
|
|
|
|
*next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-07-23 12:13:56 +02:00
|
|
|
return;
|
2009-07-23 12:13:41 +02:00
|
|
|
}
|
|
|
|
|
2009-07-23 12:13:56 +02:00
|
|
|
/* active scan, send probes */
|
2009-07-23 12:13:41 +02:00
|
|
|
*next_delay = IEEE80211_PROBE_DELAY;
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_SEND_PROBE;
|
2009-07-23 12:13:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_scan_state_send_probe(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct ieee80211_sub_if_data *sdata = local->scan_sdata;
|
|
|
|
|
|
|
|
for (i = 0; i < local->scan_req->n_ssids; i++)
|
|
|
|
ieee80211_send_probe_req(
|
|
|
|
sdata, NULL,
|
|
|
|
local->scan_req->ssids[i].ssid,
|
|
|
|
local->scan_req->ssids[i].ssid_len,
|
|
|
|
local->scan_req->ie, local->scan_req->ie_len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After sending probe requests, wait for probe responses
|
|
|
|
* on the channel.
|
|
|
|
*/
|
|
|
|
*next_delay = IEEE80211_CHANNEL_TIME;
|
2009-07-23 12:14:20 +02:00
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-07-23 12:13:41 +02:00
|
|
|
}
|
|
|
|
|
2008-09-11 00:01:55 +02:00
|
|
|
void ieee80211_scan_work(struct work_struct *work)
|
2008-09-08 17:44:25 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local, scan_work.work);
|
|
|
|
struct ieee80211_sub_if_data *sdata = local->scan_sdata;
|
|
|
|
unsigned long next_delay = 0;
|
2010-10-06 11:22:09 +02:00
|
|
|
bool aborted, hw_scan, finish;
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2010-10-06 11:22:08 +02:00
|
|
|
mutex_lock(&local->mtx);
|
2010-08-26 13:30:26 +02:00
|
|
|
|
2010-10-06 11:22:08 +02:00
|
|
|
if (test_and_clear_bit(SCAN_COMPLETED, &local->scanning)) {
|
2010-08-26 13:30:26 +02:00
|
|
|
aborted = test_and_clear_bit(SCAN_ABORTED, &local->scanning);
|
2010-10-06 11:22:08 +02:00
|
|
|
goto out_complete;
|
2010-08-26 13:30:26 +02:00
|
|
|
}
|
|
|
|
|
2010-10-06 11:22:08 +02:00
|
|
|
if (!sdata || !local->scan_req)
|
|
|
|
goto out;
|
2009-04-23 16:01:47 +02:00
|
|
|
|
2009-10-27 20:59:55 +01:00
|
|
|
if (local->hw_scan_req) {
|
2010-04-27 11:59:34 +02:00
|
|
|
int rc = drv_hw_scan(local, sdata, local->hw_scan_req);
|
2010-10-06 11:22:08 +02:00
|
|
|
if (rc) {
|
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
|
|
|
} else
|
|
|
|
goto out;
|
2009-10-27 20:59:55 +01:00
|
|
|
}
|
|
|
|
|
2009-07-23 12:14:04 +02:00
|
|
|
if (local->scan_req && !local->scanning) {
|
2009-04-23 16:01:47 +02:00
|
|
|
struct cfg80211_scan_request *req = local->scan_req;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
local->scan_req = NULL;
|
2009-08-25 16:33:47 +02:00
|
|
|
local->scan_sdata = NULL;
|
2009-04-23 16:01:47 +02:00
|
|
|
|
|
|
|
rc = __ieee80211_start_scan(sdata, req);
|
2010-10-06 11:22:08 +02:00
|
|
|
if (rc) {
|
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
|
|
|
} else
|
|
|
|
goto out;
|
2009-04-23 16:01:47 +02:00
|
|
|
}
|
|
|
|
|
2008-09-11 00:01:51 +02:00
|
|
|
/*
|
|
|
|
* Avoid re-scheduling when the sdata is going away.
|
|
|
|
*/
|
2009-12-23 13:15:31 +01:00
|
|
|
if (!ieee80211_sdata_running(sdata)) {
|
2010-10-06 11:22:08 +02:00
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
2009-04-23 16:01:47 +02:00
|
|
|
}
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2010-10-06 11:22:08 +02:00
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
2009-07-23 12:13:48 +02:00
|
|
|
/*
|
|
|
|
* as long as no delay is required advance immediately
|
|
|
|
* without scheduling a new work
|
|
|
|
*/
|
|
|
|
do {
|
2009-07-23 12:14:20 +02:00
|
|
|
switch (local->next_scan_state) {
|
2009-07-23 12:13:56 +02:00
|
|
|
case SCAN_DECISION:
|
2010-10-06 11:22:09 +02:00
|
|
|
/* if no more bands/channels left, complete scan */
|
|
|
|
if (local->scan_channel_idx >= local->scan_req->n_channels) {
|
|
|
|
aborted = false;
|
|
|
|
goto out_complete;
|
|
|
|
}
|
|
|
|
ieee80211_scan_state_decision(local, &next_delay);
|
2009-07-23 12:13:48 +02:00
|
|
|
break;
|
2009-07-23 12:13:56 +02:00
|
|
|
case SCAN_SET_CHANNEL:
|
|
|
|
ieee80211_scan_state_set_channel(local, &next_delay);
|
|
|
|
break;
|
2009-07-23 12:13:48 +02:00
|
|
|
case SCAN_SEND_PROBE:
|
|
|
|
ieee80211_scan_state_send_probe(local, &next_delay);
|
|
|
|
break;
|
2009-07-23 13:18:01 +02:00
|
|
|
case SCAN_LEAVE_OPER_CHANNEL:
|
|
|
|
ieee80211_scan_state_leave_oper_channel(local, &next_delay);
|
|
|
|
break;
|
|
|
|
case SCAN_ENTER_OPER_CHANNEL:
|
|
|
|
ieee80211_scan_state_enter_oper_channel(local, &next_delay);
|
|
|
|
break;
|
2009-07-23 12:13:48 +02:00
|
|
|
}
|
|
|
|
} while (next_delay == 0);
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2009-07-30 02:08:07 +02:00
|
|
|
ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
|
2010-10-06 11:22:08 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
out_complete:
|
2010-10-06 11:22:09 +02:00
|
|
|
hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
|
|
|
|
finish = __ieee80211_scan_completed(&local->hw, aborted, hw_scan);
|
2010-10-06 11:22:08 +02:00
|
|
|
mutex_unlock(&local->mtx);
|
2010-10-06 11:22:09 +02:00
|
|
|
if (finish)
|
|
|
|
__ieee80211_scan_completed_finish(&local->hw, hw_scan);
|
2010-10-06 11:22:08 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&local->mtx);
|
2008-09-08 17:44:25 +02:00
|
|
|
}
|
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_scan_request *req)
|
2008-09-08 17:44:25 +02:00
|
|
|
{
|
2009-04-23 16:01:47 +02:00
|
|
|
int res;
|
2009-04-01 11:58:36 +02:00
|
|
|
|
2010-07-30 16:46:07 +02:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
2009-04-23 16:01:47 +02:00
|
|
|
res = __ieee80211_start_scan(sdata, req);
|
2010-07-30 16:46:07 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
return res;
|
2008-09-08 17:44:25 +02:00
|
|
|
}
|
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
|
2010-05-03 08:49:48 +02:00
|
|
|
const u8 *ssid, u8 ssid_len,
|
|
|
|
struct ieee80211_channel *chan)
|
2008-09-08 17:44:25 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-04-23 16:01:47 +02:00
|
|
|
int ret = -EBUSY;
|
2010-06-20 20:28:07 +02:00
|
|
|
enum ieee80211_band band;
|
2009-02-10 21:25:55 +01:00
|
|
|
|
2010-07-30 16:46:07 +02:00
|
|
|
mutex_lock(&local->mtx);
|
2008-09-08 17:44:25 +02:00
|
|
|
|
2009-04-23 16:01:47 +02:00
|
|
|
/* busy scanning */
|
|
|
|
if (local->scan_req)
|
|
|
|
goto unlock;
|
2008-09-08 17:47:23 +02:00
|
|
|
|
2010-05-03 08:49:48 +02:00
|
|
|
/* fill internal scan request */
|
|
|
|
if (!chan) {
|
|
|
|
int i, nchan = 0;
|
|
|
|
|
|
|
|
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
|
|
|
|
if (!local->hw.wiphy->bands[band])
|
|
|
|
continue;
|
|
|
|
for (i = 0;
|
|
|
|
i < local->hw.wiphy->bands[band]->n_channels;
|
|
|
|
i++) {
|
|
|
|
local->int_scan_req->channels[nchan] =
|
|
|
|
&local->hw.wiphy->bands[band]->channels[i];
|
|
|
|
nchan++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
local->int_scan_req->n_channels = nchan;
|
|
|
|
} else {
|
|
|
|
local->int_scan_req->channels[0] = chan;
|
|
|
|
local->int_scan_req->n_channels = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
local->int_scan_req->ssids = &local->scan_ssid;
|
|
|
|
local->int_scan_req->n_ssids = 1;
|
2009-08-07 17:54:07 +02:00
|
|
|
memcpy(local->int_scan_req->ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
|
|
|
|
local->int_scan_req->ssids[0].ssid_len = ssid_len;
|
2008-09-08 17:47:23 +02:00
|
|
|
|
2009-08-07 17:54:07 +02:00
|
|
|
ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
|
2009-04-23 16:01:47 +02:00
|
|
|
unlock:
|
2010-07-30 16:46:07 +02:00
|
|
|
mutex_unlock(&local->mtx);
|
2009-04-23 16:01:47 +02:00
|
|
|
return ret;
|
2008-09-08 17:44:25 +02:00
|
|
|
}
|
2009-05-17 11:40:42 +02:00
|
|
|
|
|
|
|
void ieee80211_scan_cancel(struct ieee80211_local *local)
|
|
|
|
{
|
2009-08-25 16:33:47 +02:00
|
|
|
bool abortscan;
|
2010-10-06 11:22:09 +02:00
|
|
|
bool finish = false;
|
2009-05-17 11:40:42 +02:00
|
|
|
|
|
|
|
cancel_delayed_work_sync(&local->scan_work);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only call this function when a scan can't be
|
|
|
|
* queued -- mostly at suspend under RTNL.
|
|
|
|
*/
|
2010-07-30 16:46:07 +02:00
|
|
|
mutex_lock(&local->mtx);
|
2009-08-25 16:33:47 +02:00
|
|
|
abortscan = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
|
|
|
|
(!local->scanning && local->scan_req);
|
2010-10-06 11:22:09 +02:00
|
|
|
if (abortscan)
|
|
|
|
finish = __ieee80211_scan_completed(&local->hw, true, false);
|
2010-07-30 16:46:07 +02:00
|
|
|
mutex_unlock(&local->mtx);
|
2009-05-17 11:40:42 +02:00
|
|
|
|
2010-10-06 11:22:09 +02:00
|
|
|
if (finish)
|
|
|
|
__ieee80211_scan_completed_finish(&local->hw, false);
|
2009-05-17 11:40:42 +02:00
|
|
|
}
|