2008-09-08 09:44:25 -06:00
|
|
|
/*
|
2008-09-08 09:44:27 -06:00
|
|
|
* Scanning implementation
|
|
|
|
*
|
2008-09-08 09:44:25 -06: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>
|
2012-03-01 07:22:09 -07:00
|
|
|
#include <linux/etherdevice.h>
|
2009-01-22 10:07:31 -07:00
|
|
|
#include <linux/rtnetlink.h>
|
2011-08-25 07:35:03 -06:00
|
|
|
#include <linux/pm_qos.h>
|
2010-02-24 06:19:21 -07:00
|
|
|
#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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2011-07-15 09:47:34 -06:00
|
|
|
#include <linux/export.h>
|
2008-09-08 09:44:25 -06:00
|
|
|
#include <net/mac80211.h>
|
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 10:52:52 -06:00
|
|
|
#include "driver-ops.h"
|
2008-09-08 09:44:27 -06:00
|
|
|
#include "mesh.h"
|
2008-09-08 09:44:25 -06:00
|
|
|
|
|
|
|
#define IEEE80211_PROBE_DELAY (HZ / 33)
|
|
|
|
#define IEEE80211_CHANNEL_TIME (HZ / 33)
|
2009-06-30 06:49:18 -06:00
|
|
|
#define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 8)
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2009-02-10 13:26:00 -07:00
|
|
|
static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
|
2008-09-08 09:44:27 -06:00
|
|
|
{
|
2009-12-23 05:15:39 -07:00
|
|
|
struct ieee80211_bss *bss = (void *)cbss->priv;
|
2008-09-08 09:44:27 -06:00
|
|
|
|
|
|
|
kfree(bss_mesh_id(bss));
|
|
|
|
kfree(bss_mesh_cfg(bss));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_rx_bss_put(struct ieee80211_local *local,
|
2008-09-10 16:01:55 -06:00
|
|
|
struct ieee80211_bss *bss)
|
2008-09-08 09:44:27 -06:00
|
|
|
{
|
2009-12-23 05:15:39 -07:00
|
|
|
if (!bss)
|
|
|
|
return;
|
|
|
|
cfg80211_put_bss(container_of((void *)bss, struct cfg80211_bss, priv));
|
2008-09-08 09:44:27 -06:00
|
|
|
}
|
|
|
|
|
2010-01-12 01:42:31 -07: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-10 16:01:55 -06:00
|
|
|
struct ieee80211_bss *
|
2008-09-08 09:44:27 -06: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 13:25:55 -07:00
|
|
|
struct ieee80211_channel *channel,
|
|
|
|
bool beacon)
|
2008-09-08 09:44:27 -06:00
|
|
|
{
|
2009-12-23 05:15:39 -07:00
|
|
|
struct cfg80211_bss *cbss;
|
2008-09-10 16:01:55 -06:00
|
|
|
struct ieee80211_bss *bss;
|
2010-04-28 07:17:03 -06:00
|
|
|
int clen, srlen;
|
2009-02-10 13:25:55 -07:00
|
|
|
s32 signal = 0;
|
|
|
|
|
2009-02-18 10:45:06 -07:00
|
|
|
if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
|
2009-02-10 13:25:55 -07:00
|
|
|
signal = rx_status->signal * 100;
|
2009-02-18 10:45:06 -07:00
|
|
|
else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
|
2009-02-10 13:25:55 -07:00
|
|
|
signal = (rx_status->signal * 100) / local->hw.max_signal;
|
|
|
|
|
2009-12-23 05:15:39 -07:00
|
|
|
cbss = cfg80211_inform_bss_frame(local->hw.wiphy, channel,
|
|
|
|
mgmt, len, signal, GFP_ATOMIC);
|
2008-09-08 09:44:27 -06:00
|
|
|
|
2009-12-23 05:15:39 -07:00
|
|
|
if (!cbss)
|
2009-02-10 13:26:00 -07:00
|
|
|
return NULL;
|
|
|
|
|
2009-12-23 05:15:39 -07:00
|
|
|
cbss->free_priv = ieee80211_rx_bss_free;
|
|
|
|
bss = (void *)cbss->priv;
|
2008-09-08 09:44:27 -06:00
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (elems->parse_error) {
|
|
|
|
if (beacon)
|
|
|
|
bss->corrupt_data |= IEEE80211_BSS_CORRUPT_BEACON;
|
|
|
|
else
|
|
|
|
bss->corrupt_data |= IEEE80211_BSS_CORRUPT_PROBE_RESP;
|
|
|
|
} else {
|
|
|
|
if (beacon)
|
|
|
|
bss->corrupt_data &= ~IEEE80211_BSS_CORRUPT_BEACON;
|
|
|
|
else
|
|
|
|
bss->corrupt_data &= ~IEEE80211_BSS_CORRUPT_PROBE_RESP;
|
|
|
|
}
|
|
|
|
|
2008-09-08 09:44:27 -06:00
|
|
|
/* save the ERP value so that it is available at association time */
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (elems->erp_info && elems->erp_info_len >= 1 &&
|
|
|
|
(!elems->parse_error ||
|
|
|
|
!(bss->valid_data & IEEE80211_BSS_VALID_ERP))) {
|
2008-09-08 09:44:27 -06:00
|
|
|
bss->erp_value = elems->erp_info[0];
|
2011-12-19 06:56:45 -07:00
|
|
|
bss->has_erp_value = true;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (!elems->parse_error)
|
|
|
|
bss->valid_data |= IEEE80211_BSS_VALID_ERP;
|
2008-09-08 09:44:27 -06:00
|
|
|
}
|
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (elems->tim && (!elems->parse_error ||
|
|
|
|
!(bss->valid_data & IEEE80211_BSS_VALID_DTIM))) {
|
2008-09-08 09:44:27 -06:00
|
|
|
struct ieee80211_tim_ie *tim_ie =
|
|
|
|
(struct ieee80211_tim_ie *)elems->tim;
|
|
|
|
bss->dtim_period = tim_ie->dtim_period;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (!elems->parse_error)
|
|
|
|
bss->valid_data |= IEEE80211_BSS_VALID_DTIM;
|
2008-09-08 09:44:27 -06:00
|
|
|
}
|
|
|
|
|
2010-07-29 08:08:55 -06: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 07:17:03 -06:00
|
|
|
/* replace old supported rates if we get new values */
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (!elems->parse_error ||
|
|
|
|
!(bss->valid_data & IEEE80211_BSS_VALID_RATES)) {
|
|
|
|
srlen = 0;
|
|
|
|
if (elems->supp_rates) {
|
|
|
|
clen = IEEE80211_MAX_SUPP_RATES;
|
|
|
|
if (clen > elems->supp_rates_len)
|
|
|
|
clen = elems->supp_rates_len;
|
|
|
|
memcpy(bss->supp_rates, elems->supp_rates, clen);
|
|
|
|
srlen += clen;
|
|
|
|
}
|
|
|
|
if (elems->ext_supp_rates) {
|
|
|
|
clen = IEEE80211_MAX_SUPP_RATES - srlen;
|
|
|
|
if (clen > elems->ext_supp_rates_len)
|
|
|
|
clen = elems->ext_supp_rates_len;
|
|
|
|
memcpy(bss->supp_rates + srlen, elems->ext_supp_rates,
|
|
|
|
clen);
|
|
|
|
srlen += clen;
|
|
|
|
}
|
|
|
|
if (srlen) {
|
|
|
|
bss->supp_rates_len = srlen;
|
|
|
|
if (!elems->parse_error)
|
|
|
|
bss->valid_data |= IEEE80211_BSS_VALID_RATES;
|
|
|
|
}
|
2008-09-08 09:44:27 -06:00
|
|
|
}
|
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-23 18:59:53 -07:00
|
|
|
if (!elems->parse_error ||
|
|
|
|
!(bss->valid_data & IEEE80211_BSS_VALID_WMM)) {
|
|
|
|
bss->wmm_used = elems->wmm_param || elems->wmm_info;
|
|
|
|
bss->uapsd_supported = is_uapsd_supported(elems);
|
|
|
|
if (!elems->parse_error)
|
|
|
|
bss->valid_data |= IEEE80211_BSS_VALID_WMM;
|
|
|
|
}
|
2008-09-08 09:44:27 -06:00
|
|
|
|
|
|
|
if (!beacon)
|
|
|
|
bss->last_probe_resp = jiffies;
|
|
|
|
|
|
|
|
return bss;
|
|
|
|
}
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2008-09-08 09:44:26 -06:00
|
|
|
ieee80211_rx_result
|
2009-06-17 05:13:00 -06:00
|
|
|
ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
|
2008-09-08 09:44:26 -06:00
|
|
|
{
|
2009-06-17 05:13:00 -06:00
|
|
|
struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
|
2008-09-08 09:44:26 -06:00
|
|
|
struct ieee80211_mgmt *mgmt;
|
2008-09-10 16:01:55 -06:00
|
|
|
struct ieee80211_bss *bss;
|
2008-09-08 09:44:26 -06: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)
|
2011-05-09 10:15:04 -06:00
|
|
|
return RX_CONTINUE;
|
2008-09-08 09:44:26 -06:00
|
|
|
|
|
|
|
presp = ieee80211_is_probe_resp(fc);
|
|
|
|
if (presp) {
|
|
|
|
/* ignore ProbeResp to foreign address */
|
mac80211: Convert compare_ether_addr to ether_addr_equal
Use the new bool function ether_addr_equal to add
some clarity and reduce the likelihood for misuse
of compare_ether_addr for sorting.
Done via cocci script:
$ cat compare_ether_addr.cocci
@@
expression a,b;
@@
- !compare_ether_addr(a, b)
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- compare_ether_addr(a, b)
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) == 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) != 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) == 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) != 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !!ether_addr_equal(a, b)
+ ether_addr_equal(a, b)
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-05-08 12:56:52 -06:00
|
|
|
if (!ether_addr_equal(mgmt->da, sdata->vif.addr))
|
2008-09-08 09:44:26 -06: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)
|
2011-01-16 21:37:28 -07:00
|
|
|
freq = ieee80211_channel_to_frequency(elems.ds_params[0],
|
|
|
|
rx_status->band);
|
2008-09-08 09:44:26 -06:00
|
|
|
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 13:25:55 -07:00
|
|
|
channel, beacon);
|
2008-10-10 18:29:55 -06:00
|
|
|
if (bss)
|
|
|
|
ieee80211_rx_bss_put(sdata->local, bss);
|
2008-09-08 09:44:26 -06:00
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
if (channel == sdata->local->oper_channel)
|
mac80211: Optimize scans on current operating channel.
This should decrease un-necessary flushes, on/off channel work,
and channel changes in cases where the only scanned channel is
the current operating channel.
* Removes SCAN_OFF_CHANNEL flag, uses SDATA_STATE_OFFCHANNEL
and is-scanning flags instead.
* Add helper method to determine if we are currently configured
for the operating channel.
* Do no blindly go off/on channel in work.c Instead, only call
appropriate on/off code when we really need to change channels.
Always enable offchannel-ps mode when starting work,
and disable it when we are done.
* Consolidate ieee80211_offchannel_stop_station and
ieee80211_offchannel_stop_beaconing, call it
ieee80211_offchannel_stop_vifs instead.
* Accept non-beacon frames when scanning on operating channel.
* Scan state machine optimized to minimize on/off channel
transitions. Also, when going on-channel, go ahead and
re-enable beaconing. We're going to be there for 200ms,
so seems like some useful beaconing could happen.
Always enable offchannel-ps mode when starting software
scan, and disable it when we are done.
* Grab local->mtx earlier in __ieee80211_scan_completed_finish
so that we are protected when calling hw_config(), etc.
* Pass probe-responses up the stack if scanning on local
channel, so that mlme can take a look.
Signed-off-by: Ben Greear <greearb@candelatech.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-02-04 12:54:17 -07:00
|
|
|
return RX_CONTINUE;
|
|
|
|
|
2008-09-08 09:44:26 -06:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return RX_QUEUED;
|
|
|
|
}
|
|
|
|
|
2009-10-27 13:59:55 -06: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,
|
2011-06-22 08:43:48 -06:00
|
|
|
req->ie, req->ie_len, band,
|
2011-07-18 10:08:36 -06:00
|
|
|
req->rates[band], 0);
|
2009-10-27 13:59:55 -06:00
|
|
|
local->hw_scan_req->ie_len = ielen;
|
2011-10-04 07:07:33 -06:00
|
|
|
local->hw_scan_req->no_cck = req->no_cck;
|
2009-10-27 13:59:55 -06:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-03-07 07:48:41 -07:00
|
|
|
static void __ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted,
|
2010-10-06 03:22:09 -06:00
|
|
|
bool was_hw_scan)
|
2008-09-08 09:44:25 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2010-10-06 03:22:09 -06:00
|
|
|
lockdep_assert_held(&local->mtx);
|
2008-09-10 16:01:51 -06:00
|
|
|
|
2009-10-31 00:44:08 -06: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-10 16:01:51 -06:00
|
|
|
|
2010-10-06 03:22:09 -06:00
|
|
|
if (WARN_ON(!local->scan_req))
|
2011-03-07 07:48:41 -07:00
|
|
|
return;
|
2009-04-01 03:58:36 -06:00
|
|
|
|
2009-10-27 13:59:55 -06:00
|
|
|
if (was_hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
|
2010-10-06 03:22:11 -06:00
|
|
|
int rc = drv_hw_scan(local, local->scan_sdata, local->hw_scan_req);
|
|
|
|
if (rc == 0)
|
2011-03-07 07:48:41 -07:00
|
|
|
return;
|
2009-10-27 13:59:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(local->hw_scan_req);
|
|
|
|
local->hw_scan_req = NULL;
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2009-08-07 09:54:07 -06:00
|
|
|
if (local->scan_req != local->int_scan_req)
|
2009-02-10 13:25:55 -07:00
|
|
|
cfg80211_scan_done(local->scan_req, aborted);
|
|
|
|
local->scan_req = NULL;
|
2009-08-25 08:33:47 -06:00
|
|
|
local->scan_sdata = NULL;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2009-07-23 04:14:04 -06: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 06:23:01 -06:00
|
|
|
local->scan_channel = NULL;
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
/* Set power back to normal operating levels. */
|
|
|
|
ieee80211_hw_config(local, 0);
|
2010-07-27 14:33:08 -06:00
|
|
|
|
2010-10-06 03:22:09 -06:00
|
|
|
if (!was_hw_scan) {
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
drv_sw_scan_complete(local);
|
2011-11-29 02:20:02 -07:00
|
|
|
ieee80211_offchannel_return(local, true);
|
2010-10-06 03:22:09 -06:00
|
|
|
}
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2009-04-29 04:26:17 -06:00
|
|
|
ieee80211_recalc_idle(local);
|
2010-10-06 03:22:09 -06:00
|
|
|
|
2008-09-08 09:44:25 -06:00
|
|
|
ieee80211_mlme_notify_scan_completed(local);
|
2009-02-15 04:44:28 -07:00
|
|
|
ieee80211_ibss_notify_scan_completed(local);
|
2008-09-10 16:01:49 -06:00
|
|
|
ieee80211_mesh_notify_scan_completed(local);
|
2010-01-06 07:30:58 -07:00
|
|
|
ieee80211_queue_work(&local->hw, &local->work_work);
|
2008-09-08 09:44:25 -06:00
|
|
|
}
|
2010-08-26 05:30:26 -06: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 09:44:25 -06:00
|
|
|
EXPORT_SYMBOL(ieee80211_scan_completed);
|
|
|
|
|
2009-04-23 08:01:47 -06: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 10:52:52 -06:00
|
|
|
drv_sw_scan_start(local);
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2012-03-26 23:31:06 -06:00
|
|
|
local->leave_oper_channel_time = jiffies;
|
2009-07-23 04:14:20 -06:00
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-04-23 08:01:47 -06:00
|
|
|
local->scan_channel_idx = 0;
|
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
ieee80211_offchannel_stop_vifs(local, true);
|
2009-12-23 05:15:32 -07:00
|
|
|
|
2009-08-17 08:16:53 -06:00
|
|
|
ieee80211_configure_filter(local);
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2011-02-07 14:44:38 -07:00
|
|
|
/* We need to set power level at maximum rate for scanning. */
|
|
|
|
ieee80211_hw_config(local, 0);
|
|
|
|
|
2009-07-29 18:08:07 -06:00
|
|
|
ieee80211_queue_delayed_work(&local->hw,
|
2011-11-08 08:21:21 -07:00
|
|
|
&local->scan_work, 0);
|
2009-04-23 08:01:47 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-28 08:01:19 -06:00
|
|
|
static bool ieee80211_can_scan(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
if (!list_empty(&local->work_list))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
|
|
|
|
sdata->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |
|
|
|
|
IEEE80211_STA_CONNECTION_POLL))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_run_deferred_scan(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&local->mtx);
|
|
|
|
|
|
|
|
if (!local->scan_req || local->scanning)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!ieee80211_can_scan(local, local->scan_sdata))
|
|
|
|
return;
|
|
|
|
|
|
|
|
ieee80211_queue_delayed_work(&local->hw, &local->scan_work,
|
|
|
|
round_jiffies_relative(0));
|
|
|
|
}
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2012-04-17 11:54:16 -06: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;
|
|
|
|
enum ieee80211_band band = local->hw.conf.channel->band;
|
|
|
|
|
|
|
|
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,
|
|
|
|
local->scan_req->rates[band], false,
|
|
|
|
local->scan_req->no_cck);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After sending probe requests, wait for probe responses
|
|
|
|
* on the channel.
|
|
|
|
*/
|
|
|
|
*next_delay = IEEE80211_CHANNEL_TIME;
|
|
|
|
local->next_scan_state = SCAN_DECISION;
|
|
|
|
}
|
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
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 03:22:09 -06:00
|
|
|
lockdep_assert_held(&local->mtx);
|
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
if (local->scan_req)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2012-03-28 08:01:19 -06:00
|
|
|
if (!ieee80211_can_scan(local, sdata)) {
|
2010-02-08 14:38:38 -07:00
|
|
|
/* wait for the work to finish/time out */
|
2010-02-03 02:22:31 -07:00
|
|
|
local->scan_req = req;
|
|
|
|
local->scan_sdata = sdata;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
if (local->ops->hw_scan) {
|
|
|
|
u8 *ies;
|
|
|
|
|
2009-10-27 13:59:55 -06: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 08:01:47 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-10-27 13:59:55 -06: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 14:38:38 -07: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 08:01:47 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
local->scan_req = req;
|
|
|
|
local->scan_sdata = sdata;
|
|
|
|
|
2012-04-17 11:54:16 -06:00
|
|
|
if (local->ops->hw_scan) {
|
2009-07-23 04:14:04 -06:00
|
|
|
__set_bit(SCAN_HW_SCANNING, &local->scanning);
|
2012-04-17 11:54:16 -06:00
|
|
|
} else if ((req->n_channels == 1) &&
|
|
|
|
(req->channels[0]->center_freq ==
|
|
|
|
local->hw.conf.channel->center_freq)) {
|
|
|
|
|
|
|
|
/* If we are scanning only on the current channel, then
|
|
|
|
* we do not need to stop normal activities
|
|
|
|
*/
|
|
|
|
unsigned long next_delay;
|
|
|
|
|
|
|
|
__set_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
|
|
|
|
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
|
|
|
|
/* Notify driver scan is starting, keep order of operations
|
|
|
|
* same as normal software scan, in case that matters. */
|
|
|
|
drv_sw_scan_start(local);
|
|
|
|
|
|
|
|
ieee80211_configure_filter(local); /* accept probe-responses */
|
|
|
|
|
|
|
|
/* We need to ensure power level is at max for scanning. */
|
|
|
|
ieee80211_hw_config(local, 0);
|
|
|
|
|
|
|
|
if ((req->channels[0]->flags &
|
|
|
|
IEEE80211_CHAN_PASSIVE_SCAN) ||
|
|
|
|
!local->scan_req->n_ssids) {
|
|
|
|
next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
|
|
|
|
} else {
|
|
|
|
ieee80211_scan_state_send_probe(local, &next_delay);
|
|
|
|
next_delay = IEEE80211_CHANNEL_TIME;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now, just wait a bit and we are all done! */
|
|
|
|
ieee80211_queue_delayed_work(&local->hw, &local->scan_work,
|
|
|
|
next_delay);
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
/* Do normal software scan */
|
2009-07-23 04:14:04 -06:00
|
|
|
__set_bit(SCAN_SW_SCANNING, &local->scanning);
|
2012-04-17 11:54:16 -06:00
|
|
|
}
|
2010-02-08 14:38:38 -07:00
|
|
|
|
2009-04-29 04:26:17 -06:00
|
|
|
ieee80211_recalc_idle(local);
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2009-10-27 13:59:55 -06:00
|
|
|
if (local->ops->hw_scan) {
|
|
|
|
WARN_ON(!ieee80211_prep_hw_scan(local));
|
2010-04-27 03:59:34 -06:00
|
|
|
rc = drv_hw_scan(local, sdata, local->hw_scan_req);
|
2009-10-27 13:59:55 -06:00
|
|
|
} else
|
2009-04-23 08:01:47 -06:00
|
|
|
rc = ieee80211_start_sw_scan(local);
|
|
|
|
|
|
|
|
if (rc) {
|
2009-10-27 13:59:55 -06:00
|
|
|
kfree(local->hw_scan_req);
|
|
|
|
local->hw_scan_req = NULL;
|
2009-07-23 04:14:04 -06:00
|
|
|
local->scanning = 0;
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2009-04-29 04:26:17 -06:00
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
local->scan_req = NULL;
|
|
|
|
local->scan_sdata = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2010-02-24 06:19:21 -07: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 03:22:09 -06:00
|
|
|
static void ieee80211_scan_state_decision(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
2009-07-23 04:13:41 -06:00
|
|
|
{
|
2009-07-23 05:18:01 -06:00
|
|
|
bool associated = false;
|
2010-02-24 06:19:21 -07:00
|
|
|
bool tx_empty = true;
|
|
|
|
bool bad_latency;
|
|
|
|
bool listen_int_exceeded;
|
|
|
|
unsigned long min_beacon_int = 0;
|
2009-07-23 05:18:01 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2010-02-24 06:19:21 -07:00
|
|
|
struct ieee80211_channel *next_chan;
|
2009-07-23 05:18:01 -06:00
|
|
|
|
2010-02-24 06:19:21 -07: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 05:18:01 -06:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2009-12-23 05:15:31 -07:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-07-23 05:18:01 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION) {
|
|
|
|
if (sdata->u.mgd.associated) {
|
|
|
|
associated = true;
|
2010-02-24 06:19:21 -07: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 05:18:01 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
mac80211: Optimize scans on current operating channel.
This should decrease un-necessary flushes, on/off channel work,
and channel changes in cases where the only scanned channel is
the current operating channel.
* Removes SCAN_OFF_CHANNEL flag, uses SDATA_STATE_OFFCHANNEL
and is-scanning flags instead.
* Add helper method to determine if we are currently configured
for the operating channel.
* Do no blindly go off/on channel in work.c Instead, only call
appropriate on/off code when we really need to change channels.
Always enable offchannel-ps mode when starting work,
and disable it when we are done.
* Consolidate ieee80211_offchannel_stop_station and
ieee80211_offchannel_stop_beaconing, call it
ieee80211_offchannel_stop_vifs instead.
* Accept non-beacon frames when scanning on operating channel.
* Scan state machine optimized to minimize on/off channel
transitions. Also, when going on-channel, go ahead and
re-enable beaconing. We're going to be there for 200ms,
so seems like some useful beaconing could happen.
Always enable offchannel-ps mode when starting software
scan, and disable it when we are done.
* Grab local->mtx earlier in __ieee80211_scan_completed_finish
so that we are protected when calling hw_config(), etc.
* Pass probe-responses up the stack if scanning on local
channel, so that mlme can take a look.
Signed-off-by: Ben Greear <greearb@candelatech.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-02-04 12:54:17 -07:00
|
|
|
next_chan = local->scan_req->channels[local->scan_channel_idx];
|
|
|
|
|
2009-12-23 05:15:32 -07:00
|
|
|
/*
|
2011-11-08 08:21:21 -07:00
|
|
|
* we're currently scanning a different channel, let's
|
|
|
|
* 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-12-23 05:15:32 -07:00
|
|
|
*/
|
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
bad_latency = time_after(jiffies +
|
|
|
|
ieee80211_scan_get_channel_time(next_chan),
|
|
|
|
local->leave_oper_channel_time +
|
|
|
|
usecs_to_jiffies(pm_qos_request(PM_QOS_NETWORK_LATENCY)));
|
2010-02-24 06:19:21 -07:00
|
|
|
|
2011-11-08 08:21:21 -07: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);
|
2009-07-23 05:18:01 -06:00
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
if (associated && (!tx_empty || bad_latency || listen_int_exceeded))
|
|
|
|
local->next_scan_state = SCAN_SUSPEND;
|
|
|
|
else
|
|
|
|
local->next_scan_state = SCAN_SET_CHANNEL;
|
2009-07-23 05:18:01 -06:00
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
*next_delay = 0;
|
2009-07-23 05:18:01 -06:00
|
|
|
}
|
|
|
|
|
2009-07-23 04:13:56 -06: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 04:13:41 -06:00
|
|
|
skip = 0;
|
|
|
|
chan = local->scan_req->channels[local->scan_channel_idx];
|
|
|
|
|
2009-11-02 05:32:03 -07:00
|
|
|
local->scan_channel = chan;
|
mac80211: Optimize scans on current operating channel.
This should decrease un-necessary flushes, on/off channel work,
and channel changes in cases where the only scanned channel is
the current operating channel.
* Removes SCAN_OFF_CHANNEL flag, uses SDATA_STATE_OFFCHANNEL
and is-scanning flags instead.
* Add helper method to determine if we are currently configured
for the operating channel.
* Do no blindly go off/on channel in work.c Instead, only call
appropriate on/off code when we really need to change channels.
Always enable offchannel-ps mode when starting work,
and disable it when we are done.
* Consolidate ieee80211_offchannel_stop_station and
ieee80211_offchannel_stop_beaconing, call it
ieee80211_offchannel_stop_vifs instead.
* Accept non-beacon frames when scanning on operating channel.
* Scan state machine optimized to minimize on/off channel
transitions. Also, when going on-channel, go ahead and
re-enable beaconing. We're going to be there for 200ms,
so seems like some useful beaconing could happen.
Always enable offchannel-ps mode when starting software
scan, and disable it when we are done.
* Grab local->mtx earlier in __ieee80211_scan_completed_finish
so that we are protected when calling hw_config(), etc.
* Pass probe-responses up the stack if scanning on local
channel, so that mlme can take a look.
Signed-off-by: Ben Greear <greearb@candelatech.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-02-04 12:54:17 -07:00
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
if (ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL))
|
|
|
|
skip = 1;
|
2009-07-23 04:13:41 -06:00
|
|
|
|
|
|
|
/* advance state machine to next channel/band */
|
|
|
|
local->scan_channel_idx++;
|
|
|
|
|
2009-07-25 09:25:51 -06:00
|
|
|
if (skip) {
|
|
|
|
/* if we skip this channel return to the decision state */
|
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-07-23 04:13:56 -06:00
|
|
|
return;
|
2009-07-25 09:25:51 -06:00
|
|
|
}
|
2009-07-23 04:13:41 -06: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 04:14:20 -06:00
|
|
|
local->next_scan_state = SCAN_DECISION;
|
2009-07-23 04:13:56 -06:00
|
|
|
return;
|
2009-07-23 04:13:41 -06:00
|
|
|
}
|
|
|
|
|
2009-07-23 04:13:56 -06:00
|
|
|
/* active scan, send probes */
|
2009-07-23 04:13:41 -06:00
|
|
|
*next_delay = IEEE80211_PROBE_DELAY;
|
2009-07-23 04:14:20 -06:00
|
|
|
local->next_scan_state = SCAN_SEND_PROBE;
|
2009-07-23 04:13:41 -06:00
|
|
|
}
|
|
|
|
|
2011-11-08 08:21:21 -07:00
|
|
|
static void ieee80211_scan_state_suspend(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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Re-enable vifs and beaconing. Leave PS
|
|
|
|
* in off-channel state..will put that back
|
|
|
|
* on-channel at the end of scanning.
|
|
|
|
*/
|
2011-11-29 02:20:02 -07:00
|
|
|
ieee80211_offchannel_return(local, false);
|
2011-11-08 08:21:21 -07:00
|
|
|
|
|
|
|
*next_delay = HZ / 5;
|
|
|
|
/* afterwards, resume scan & go to next channel */
|
|
|
|
local->next_scan_state = SCAN_RESUME;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_scan_state_resume(struct ieee80211_local *local,
|
|
|
|
unsigned long *next_delay)
|
|
|
|
{
|
|
|
|
/* PS already is in off-channel mode */
|
|
|
|
ieee80211_offchannel_stop_vifs(local, false);
|
|
|
|
|
|
|
|
if (local->ops->flush) {
|
|
|
|
drv_flush(local, false);
|
|
|
|
*next_delay = 0;
|
|
|
|
} else
|
|
|
|
*next_delay = HZ / 10;
|
|
|
|
|
|
|
|
/* remember when we left the operating channel */
|
|
|
|
local->leave_oper_channel_time = jiffies;
|
|
|
|
|
|
|
|
/* advance to the next channel to be scanned */
|
2011-12-24 06:13:28 -07:00
|
|
|
local->next_scan_state = SCAN_SET_CHANNEL;
|
2011-11-08 08:21:21 -07:00
|
|
|
}
|
|
|
|
|
2008-09-10 16:01:55 -06:00
|
|
|
void ieee80211_scan_work(struct work_struct *work)
|
2008-09-08 09:44:25 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local, scan_work.work);
|
2011-03-07 07:48:41 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-09-08 09:44:25 -06:00
|
|
|
unsigned long next_delay = 0;
|
2011-03-07 07:48:41 -07:00
|
|
|
bool aborted, hw_scan;
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2010-10-06 03:22:08 -06:00
|
|
|
mutex_lock(&local->mtx);
|
2010-08-26 05:30:26 -06:00
|
|
|
|
2011-03-07 07:48:41 -07:00
|
|
|
sdata = local->scan_sdata;
|
|
|
|
|
2012-04-17 11:54:16 -06:00
|
|
|
/* When scanning on-channel, the first-callback means completed. */
|
|
|
|
if (test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning)) {
|
|
|
|
aborted = test_and_clear_bit(SCAN_ABORTED, &local->scanning);
|
|
|
|
goto out_complete;
|
|
|
|
}
|
|
|
|
|
2010-10-06 03:22:08 -06:00
|
|
|
if (test_and_clear_bit(SCAN_COMPLETED, &local->scanning)) {
|
2010-08-26 05:30:26 -06:00
|
|
|
aborted = test_and_clear_bit(SCAN_ABORTED, &local->scanning);
|
2010-10-06 03:22:08 -06:00
|
|
|
goto out_complete;
|
2010-08-26 05:30:26 -06:00
|
|
|
}
|
|
|
|
|
2010-10-06 03:22:08 -06:00
|
|
|
if (!sdata || !local->scan_req)
|
|
|
|
goto out;
|
2009-04-23 08:01:47 -06:00
|
|
|
|
2009-07-23 04:14:04 -06:00
|
|
|
if (local->scan_req && !local->scanning) {
|
2009-04-23 08:01:47 -06:00
|
|
|
struct cfg80211_scan_request *req = local->scan_req;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
local->scan_req = NULL;
|
2009-08-25 08:33:47 -06:00
|
|
|
local->scan_sdata = NULL;
|
2009-04-23 08:01:47 -06:00
|
|
|
|
|
|
|
rc = __ieee80211_start_scan(sdata, req);
|
2010-10-06 03:22:08 -06:00
|
|
|
if (rc) {
|
2010-10-06 03:22:12 -06:00
|
|
|
/* need to complete scan in cfg80211 */
|
|
|
|
local->scan_req = req;
|
2010-10-06 03:22:08 -06:00
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
|
|
|
} else
|
|
|
|
goto out;
|
2009-04-23 08:01:47 -06:00
|
|
|
}
|
|
|
|
|
2008-09-10 16:01:51 -06:00
|
|
|
/*
|
|
|
|
* Avoid re-scheduling when the sdata is going away.
|
|
|
|
*/
|
2009-12-23 05:15:31 -07:00
|
|
|
if (!ieee80211_sdata_running(sdata)) {
|
2010-10-06 03:22:08 -06:00
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
2009-04-23 08:01:47 -06:00
|
|
|
}
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2009-07-23 04:13:48 -06:00
|
|
|
/*
|
|
|
|
* as long as no delay is required advance immediately
|
|
|
|
* without scheduling a new work
|
|
|
|
*/
|
|
|
|
do {
|
2011-05-13 22:13:28 -06:00
|
|
|
if (!ieee80211_sdata_running(sdata)) {
|
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
|
|
|
}
|
|
|
|
|
2009-07-23 04:14:20 -06:00
|
|
|
switch (local->next_scan_state) {
|
2009-07-23 04:13:56 -06:00
|
|
|
case SCAN_DECISION:
|
2010-10-06 03:22:09 -06: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 04:13:48 -06:00
|
|
|
break;
|
2009-07-23 04:13:56 -06:00
|
|
|
case SCAN_SET_CHANNEL:
|
|
|
|
ieee80211_scan_state_set_channel(local, &next_delay);
|
|
|
|
break;
|
2009-07-23 04:13:48 -06:00
|
|
|
case SCAN_SEND_PROBE:
|
|
|
|
ieee80211_scan_state_send_probe(local, &next_delay);
|
|
|
|
break;
|
2011-11-08 08:21:21 -07:00
|
|
|
case SCAN_SUSPEND:
|
|
|
|
ieee80211_scan_state_suspend(local, &next_delay);
|
2009-07-23 05:18:01 -06:00
|
|
|
break;
|
2011-11-08 08:21:21 -07:00
|
|
|
case SCAN_RESUME:
|
|
|
|
ieee80211_scan_state_resume(local, &next_delay);
|
2009-07-23 05:18:01 -06:00
|
|
|
break;
|
2009-07-23 04:13:48 -06:00
|
|
|
}
|
|
|
|
} while (next_delay == 0);
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2009-07-29 18:08:07 -06:00
|
|
|
ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
|
2011-03-07 07:48:41 -07:00
|
|
|
goto out;
|
2010-10-06 03:22:08 -06:00
|
|
|
|
|
|
|
out_complete:
|
2010-10-06 03:22:09 -06:00
|
|
|
hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
|
2011-03-07 07:48:41 -07:00
|
|
|
__ieee80211_scan_completed(&local->hw, aborted, hw_scan);
|
2010-10-06 03:22:08 -06:00
|
|
|
out:
|
|
|
|
mutex_unlock(&local->mtx);
|
2008-09-08 09:44:25 -06:00
|
|
|
}
|
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_scan_request *req)
|
2008-09-08 09:44:25 -06:00
|
|
|
{
|
2009-04-23 08:01:47 -06:00
|
|
|
int res;
|
2009-04-01 03:58:36 -06:00
|
|
|
|
2010-07-30 08:46:07 -06:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
2009-04-23 08:01:47 -06:00
|
|
|
res = __ieee80211_start_scan(sdata, req);
|
2010-07-30 08:46:07 -06:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
return res;
|
2008-09-08 09:44:25 -06:00
|
|
|
}
|
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
|
2010-05-03 00:49:48 -06:00
|
|
|
const u8 *ssid, u8 ssid_len,
|
|
|
|
struct ieee80211_channel *chan)
|
2008-09-08 09:44:25 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-04-23 08:01:47 -06:00
|
|
|
int ret = -EBUSY;
|
2010-06-20 12:28:07 -06:00
|
|
|
enum ieee80211_band band;
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2010-07-30 08:46:07 -06:00
|
|
|
mutex_lock(&local->mtx);
|
2008-09-08 09:44:25 -06:00
|
|
|
|
2009-04-23 08:01:47 -06:00
|
|
|
/* busy scanning */
|
|
|
|
if (local->scan_req)
|
|
|
|
goto unlock;
|
2008-09-08 09:47:23 -06:00
|
|
|
|
2010-05-03 00:49:48 -06: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 09:54:07 -06: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 09:47:23 -06:00
|
|
|
|
2009-08-07 09:54:07 -06:00
|
|
|
ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
|
2009-04-23 08:01:47 -06:00
|
|
|
unlock:
|
2010-07-30 08:46:07 -06:00
|
|
|
mutex_unlock(&local->mtx);
|
2009-04-23 08:01:47 -06:00
|
|
|
return ret;
|
2008-09-08 09:44:25 -06:00
|
|
|
}
|
2009-05-17 03:40:42 -06:00
|
|
|
|
2010-10-06 03:22:10 -06:00
|
|
|
/*
|
|
|
|
* Only call this function when a scan can't be queued -- under RTNL.
|
|
|
|
*/
|
2009-05-17 03:40:42 -06:00
|
|
|
void ieee80211_scan_cancel(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
/*
|
2011-06-13 03:47:30 -06:00
|
|
|
* We are canceling software scan, or deferred scan that was not
|
2010-10-06 03:22:10 -06:00
|
|
|
* yet really started (see __ieee80211_start_scan ).
|
|
|
|
*
|
|
|
|
* Regarding hardware scan:
|
|
|
|
* - we can not call __ieee80211_scan_completed() as when
|
|
|
|
* SCAN_HW_SCANNING bit is set this function change
|
|
|
|
* local->hw_scan_req to operate on 5G band, what race with
|
|
|
|
* driver which can use local->hw_scan_req
|
|
|
|
*
|
|
|
|
* - we can not cancel scan_work since driver can schedule it
|
|
|
|
* by ieee80211_scan_completed(..., true) to finish scan
|
|
|
|
*
|
2011-06-13 03:47:30 -06:00
|
|
|
* Hence we only call the cancel_hw_scan() callback, but the low-level
|
|
|
|
* driver is still responsible for calling ieee80211_scan_completed()
|
|
|
|
* after the scan was completed/aborted.
|
2009-05-17 03:40:42 -06:00
|
|
|
*/
|
2010-10-06 03:22:10 -06:00
|
|
|
|
2010-07-30 08:46:07 -06:00
|
|
|
mutex_lock(&local->mtx);
|
2011-06-13 03:47:30 -06:00
|
|
|
if (!local->scan_req)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (test_bit(SCAN_HW_SCANNING, &local->scanning)) {
|
|
|
|
if (local->ops->cancel_hw_scan)
|
|
|
|
drv_cancel_hw_scan(local, local->scan_sdata);
|
|
|
|
goto out;
|
2010-10-06 03:22:10 -06:00
|
|
|
}
|
2011-06-13 03:47:30 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the work is currently running, it must be blocked on
|
|
|
|
* the mutex, but we'll set scan_sdata = NULL and it'll
|
|
|
|
* simply exit once it acquires the mutex.
|
|
|
|
*/
|
|
|
|
cancel_delayed_work(&local->scan_work);
|
|
|
|
/* and clean up */
|
|
|
|
__ieee80211_scan_completed(&local->hw, true, false);
|
|
|
|
out:
|
2011-03-07 07:48:41 -07:00
|
|
|
mutex_unlock(&local->mtx);
|
2009-05-17 03:40:42 -06:00
|
|
|
}
|
2011-05-11 08:09:36 -06:00
|
|
|
|
|
|
|
int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_sched_scan_request *req)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
mutex_lock(&sdata->local->mtx);
|
|
|
|
|
|
|
|
if (local->sched_scanning) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!local->ops->sched_scan_start) {
|
|
|
|
ret = -ENOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
|
|
|
|
local->sched_scan_ies.ie[i] = kzalloc(2 +
|
|
|
|
IEEE80211_MAX_SSID_LEN +
|
2011-07-07 06:18:27 -06:00
|
|
|
local->scan_ies_len +
|
|
|
|
req->ie_len,
|
2011-05-11 08:09:36 -06:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!local->sched_scan_ies.ie[i]) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
local->sched_scan_ies.len[i] =
|
|
|
|
ieee80211_build_preq_ies(local,
|
|
|
|
local->sched_scan_ies.ie[i],
|
|
|
|
req->ie, req->ie_len, i,
|
|
|
|
(u32) -1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = drv_sched_scan_start(local, sdata, req,
|
|
|
|
&local->sched_scan_ies);
|
|
|
|
if (ret == 0) {
|
|
|
|
local->sched_scanning = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
while (i > 0)
|
|
|
|
kfree(local->sched_scan_ies.ie[--i]);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&sdata->local->mtx);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-05-12 07:28:29 -06:00
|
|
|
int ieee80211_request_sched_scan_stop(struct ieee80211_sub_if_data *sdata)
|
2011-05-11 08:09:36 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int ret = 0, i;
|
|
|
|
|
|
|
|
mutex_lock(&sdata->local->mtx);
|
|
|
|
|
|
|
|
if (!local->ops->sched_scan_stop) {
|
|
|
|
ret = -ENOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (local->sched_scanning) {
|
|
|
|
for (i = 0; i < IEEE80211_NUM_BANDS; i++)
|
|
|
|
kfree(local->sched_scan_ies.ie[i]);
|
|
|
|
|
2011-05-12 07:28:29 -06:00
|
|
|
drv_sched_scan_stop(local, sdata);
|
2011-05-11 08:09:36 -06:00
|
|
|
local->sched_scanning = false;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
mutex_unlock(&sdata->local->mtx);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sched_scan_results(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
trace_api_sched_scan_results(local);
|
|
|
|
|
|
|
|
cfg80211_sched_scan_results(hw->wiphy);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_sched_scan_results);
|
|
|
|
|
2011-05-12 07:28:29 -06:00
|
|
|
void ieee80211_sched_scan_stopped_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local,
|
|
|
|
sched_scan_stopped_work);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
|
|
|
|
if (!local->sched_scanning) {
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_NUM_BANDS; i++)
|
|
|
|
kfree(local->sched_scan_ies.ie[i]);
|
|
|
|
|
|
|
|
local->sched_scanning = false;
|
|
|
|
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
cfg80211_sched_scan_stopped(local->hw.wiphy);
|
|
|
|
}
|
|
|
|
|
2011-05-11 08:09:36 -06:00
|
|
|
void ieee80211_sched_scan_stopped(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
trace_api_sched_scan_stopped(local);
|
|
|
|
|
2011-05-12 07:28:29 -06:00
|
|
|
ieee80211_queue_work(&local->hw, &local->sched_scan_stopped_work);
|
2011-05-11 08:09:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_sched_scan_stopped);
|