2007-05-05 20:45:53 +02:00
|
|
|
/*
|
|
|
|
* BSS client mode implementation
|
2009-01-08 12:31:59 +01:00
|
|
|
* Copyright 2003-2008, Jouni Malinen <j@w1.fi>
|
2007-05-05 20:45:53 +02:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2007-05-09 03:40:27 +02:00
|
|
|
#include <linux/delay.h>
|
2007-05-05 20:45:53 +02:00
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/etherdevice.h>
|
2011-09-18 19:21:27 +02:00
|
|
|
#include <linux/moduleparam.h>
|
2008-02-25 16:27:46 +01:00
|
|
|
#include <linux/rtnetlink.h>
|
2011-08-25 15:35:03 +02:00
|
|
|
#include <linux/pm_qos.h>
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 13:17:26 +02:00
|
|
|
#include <linux/crc32.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>
|
2011-07-15 17:47:34 +02:00
|
|
|
#include <linux/export.h>
|
2007-05-05 20:45:53 +02:00
|
|
|
#include <net/mac80211.h>
|
2008-09-11 00:01:49 +02:00
|
|
|
#include <asm/unaligned.h>
|
2008-09-08 17:44:22 +02:00
|
|
|
|
2007-05-05 20:45:53 +02:00
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 18:52:52 +02:00
|
|
|
#include "driver-ops.h"
|
2008-04-08 21:14:40 +02:00
|
|
|
#include "rate.h"
|
|
|
|
#include "led.h"
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
#define IEEE80211_AUTH_TIMEOUT (HZ / 5)
|
|
|
|
#define IEEE80211_AUTH_MAX_TRIES 3
|
|
|
|
#define IEEE80211_AUTH_WAIT_ASSOC (HZ * 5)
|
|
|
|
#define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
|
|
|
|
#define IEEE80211_ASSOC_MAX_TRIES 3
|
|
|
|
|
2011-02-05 00:30:24 +01:00
|
|
|
static int max_nullfunc_tries = 2;
|
|
|
|
module_param(max_nullfunc_tries, int, 0644);
|
|
|
|
MODULE_PARM_DESC(max_nullfunc_tries,
|
|
|
|
"Maximum nullfunc tx tries before disconnecting (reason 4).");
|
|
|
|
|
|
|
|
static int max_probe_tries = 5;
|
|
|
|
module_param(max_probe_tries, int, 0644);
|
|
|
|
MODULE_PARM_DESC(max_probe_tries,
|
|
|
|
"Maximum probe tries before disconnecting (reason 4).");
|
2009-07-10 15:29:03 +02:00
|
|
|
|
|
|
|
/*
|
2010-11-19 22:55:38 +01:00
|
|
|
* Beacon loss timeout is calculated as N frames times the
|
|
|
|
* advertised beacon interval. This may need to be somewhat
|
|
|
|
* higher than what hardware might detect to account for
|
|
|
|
* delays in the host processing frames. But since we also
|
|
|
|
* probe on beacon miss before declaring the connection lost
|
|
|
|
* default to what we want.
|
2009-07-10 15:29:03 +02:00
|
|
|
*/
|
2010-11-19 22:55:38 +01:00
|
|
|
#define IEEE80211_BEACON_LOSS_COUNT 7
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
/*
|
|
|
|
* Time the connection can be idle before we probe
|
|
|
|
* it to see if we can still talk to the AP.
|
|
|
|
*/
|
2009-07-31 17:54:23 +02:00
|
|
|
#define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)
|
2009-07-10 15:29:03 +02:00
|
|
|
/*
|
|
|
|
* Time we wait for a probe response after sending
|
|
|
|
* a probe request because of beacon loss or for
|
|
|
|
* checking the connection still works.
|
|
|
|
*/
|
2011-02-05 00:30:24 +01:00
|
|
|
static int probe_wait_ms = 500;
|
|
|
|
module_param(probe_wait_ms, int, 0644);
|
|
|
|
MODULE_PARM_DESC(probe_wait_ms,
|
|
|
|
"Maximum time(ms) to wait for probe response"
|
|
|
|
" before disconnecting (reason 4).");
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2010-03-30 08:28:30 +02:00
|
|
|
/*
|
|
|
|
* Weight given to the latest Beacon frame when calculating average signal
|
|
|
|
* strength for Beacon frames received in the current BSS. This must be
|
|
|
|
* between 1 and 15.
|
|
|
|
*/
|
|
|
|
#define IEEE80211_SIGNAL_AVE_WEIGHT 3
|
|
|
|
|
2010-08-27 21:22:00 +02:00
|
|
|
/*
|
|
|
|
* How many Beacon frames need to have been used in average signal strength
|
|
|
|
* before starting to indicate signal change events.
|
|
|
|
*/
|
|
|
|
#define IEEE80211_SIGNAL_AVE_MIN_COUNT 4
|
|
|
|
|
2009-05-17 11:40:42 +02:00
|
|
|
#define TMR_RUNNING_TIMER 0
|
|
|
|
#define TMR_RUNNING_CHANSW 1
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
/*
|
|
|
|
* All cfg80211 functions have to be called outside a locked
|
|
|
|
* section so that they can acquire a lock themselves... This
|
|
|
|
* is much simpler than queuing up things in cfg80211, but we
|
|
|
|
* do need some indirection for that here.
|
|
|
|
*/
|
|
|
|
enum rx_mgmt_action {
|
|
|
|
/* no action required */
|
|
|
|
RX_MGMT_NONE,
|
|
|
|
|
|
|
|
/* caller must call cfg80211_send_deauth() */
|
|
|
|
RX_MGMT_CFG80211_DEAUTH,
|
|
|
|
|
|
|
|
/* caller must call cfg80211_send_disassoc() */
|
|
|
|
RX_MGMT_CFG80211_DISASSOC,
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
/* caller must call cfg80211_send_rx_auth() */
|
|
|
|
RX_MGMT_CFG80211_RX_AUTH,
|
|
|
|
|
|
|
|
/* caller must call cfg80211_send_rx_assoc() */
|
|
|
|
RX_MGMT_CFG80211_RX_ASSOC,
|
|
|
|
|
|
|
|
/* caller must call cfg80211_send_assoc_timeout() */
|
|
|
|
RX_MGMT_CFG80211_ASSOC_TIMEOUT,
|
2009-07-07 03:45:17 +02:00
|
|
|
};
|
|
|
|
|
2008-09-08 17:44:27 +02:00
|
|
|
/* utils */
|
2009-07-07 03:45:17 +02:00
|
|
|
static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
|
|
|
|
{
|
2010-09-15 13:28:15 +02:00
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
2009-07-07 03:45:17 +02:00
|
|
|
}
|
|
|
|
|
2009-07-10 02:39:48 +02:00
|
|
|
/*
|
|
|
|
* We can have multiple work items (and connection probing)
|
|
|
|
* scheduling this timer, but we need to take care to only
|
|
|
|
* reschedule it when it should fire _earlier_ than it was
|
|
|
|
* asked for before, or if it's not pending right now. This
|
|
|
|
* function ensures that. Note that it then is required to
|
|
|
|
* run this function for all timeouts after the first one
|
|
|
|
* has happened -- the work that runs from this timer will
|
|
|
|
* do that.
|
|
|
|
*/
|
2012-01-20 13:55:27 +01:00
|
|
|
static void run_again(struct ieee80211_if_managed *ifmgd, unsigned long timeout)
|
2009-07-10 02:39:48 +02:00
|
|
|
{
|
|
|
|
ASSERT_MGD_MTX(ifmgd);
|
|
|
|
|
|
|
|
if (!timer_pending(&ifmgd->timer) ||
|
|
|
|
time_before(timeout, ifmgd->timer.expires))
|
|
|
|
mod_timer(&ifmgd->timer, timeout);
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:12:32 +02:00
|
|
|
void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata)
|
2009-07-10 15:29:03 +02:00
|
|
|
{
|
2012-01-19 09:29:57 +01:00
|
|
|
if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)
|
2009-07-10 15:29:03 +02:00
|
|
|
return;
|
|
|
|
|
2012-07-18 10:27:27 +02:00
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
|
|
|
|
return;
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
mod_timer(&sdata->u.mgd.bcn_mon_timer,
|
2010-11-19 22:55:38 +01:00
|
|
|
round_jiffies_up(jiffies + sdata->u.mgd.beacon_timeout));
|
2009-07-10 15:29:03 +02:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:12:29 +02:00
|
|
|
void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
2010-09-16 21:12:30 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
2011-02-25 14:46:02 +01:00
|
|
|
if (unlikely(!sdata->u.mgd.associated))
|
|
|
|
return;
|
|
|
|
|
2010-09-16 21:12:29 +02:00
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mod_timer(&sdata->u.mgd.conn_mon_timer,
|
|
|
|
round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
|
2010-09-16 21:12:30 +02:00
|
|
|
|
|
|
|
ifmgd->probe_send_count = 0;
|
2010-09-16 21:12:29 +02:00
|
|
|
}
|
|
|
|
|
2008-09-08 17:44:27 +02:00
|
|
|
static int ecw2cw(int ecw)
|
2008-09-08 17:44:22 +02:00
|
|
|
{
|
2008-09-08 17:44:27 +02:00
|
|
|
return (1 << ecw) - 1;
|
2008-09-08 17:44:22 +02:00
|
|
|
}
|
|
|
|
|
2012-03-28 10:58:36 +02:00
|
|
|
static u32 ieee80211_config_ht_tx(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_ht_operation *ht_oper,
|
|
|
|
const u8 *bssid, bool reconfig)
|
2009-03-30 13:23:35 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2012-07-26 17:24:39 +02:00
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_channel *chan;
|
2009-03-30 13:23:35 +02:00
|
|
|
struct sta_info *sta;
|
|
|
|
u32 changed = 0;
|
2009-05-08 20:47:39 +02:00
|
|
|
u16 ht_opmode;
|
2012-03-28 10:58:37 +02:00
|
|
|
bool disable_40 = false;
|
2009-03-30 13:23:35 +02:00
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
if (WARN_ON(!chanctx_conf)) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
2012-11-09 11:39:59 +01:00
|
|
|
chan = chanctx_conf->def.chan;
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_unlock();
|
|
|
|
sband = local->hw.wiphy->bands[chan->band];
|
2009-03-30 13:23:35 +02:00
|
|
|
|
2012-11-09 11:39:59 +01:00
|
|
|
switch (sdata->vif.bss_conf.chandef.width) {
|
|
|
|
case NL80211_CHAN_WIDTH_40:
|
|
|
|
if (sdata->vif.bss_conf.chandef.chan->center_freq >
|
|
|
|
sdata->vif.bss_conf.chandef.center_freq1 &&
|
|
|
|
chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
|
2012-03-28 10:58:37 +02:00
|
|
|
disable_40 = true;
|
2012-11-09 11:39:59 +01:00
|
|
|
if (sdata->vif.bss_conf.chandef.chan->center_freq <
|
|
|
|
sdata->vif.bss_conf.chandef.center_freq1 &&
|
|
|
|
chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
|
2012-03-28 10:58:37 +02:00
|
|
|
disable_40 = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-03-30 13:23:35 +02:00
|
|
|
|
2012-03-28 10:58:36 +02:00
|
|
|
/* This can change during the lifetime of the BSS */
|
|
|
|
if (!(ht_oper->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
|
2012-03-28 10:58:37 +02:00
|
|
|
disable_40 = true;
|
|
|
|
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
sta = sta_info_get(sdata, bssid);
|
2009-03-30 13:23:35 +02:00
|
|
|
|
2012-03-28 10:58:37 +02:00
|
|
|
WARN_ON_ONCE(!sta);
|
|
|
|
|
|
|
|
if (sta && !sta->supports_40mhz)
|
|
|
|
disable_40 = true;
|
|
|
|
|
|
|
|
if (sta && (!reconfig ||
|
2012-04-25 16:54:24 +02:00
|
|
|
(disable_40 != !(sta->sta.ht_cap.cap &
|
2012-03-28 10:58:37 +02:00
|
|
|
IEEE80211_HT_CAP_SUP_WIDTH_20_40)))) {
|
2009-03-30 13:23:35 +02:00
|
|
|
|
2012-03-28 10:58:37 +02:00
|
|
|
if (disable_40)
|
|
|
|
sta->sta.ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
|
|
|
|
else
|
|
|
|
sta->sta.ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
|
2011-09-16 12:02:34 +02:00
|
|
|
|
2012-03-28 10:58:37 +02:00
|
|
|
rate_control_rate_update(local, sband, sta,
|
2012-03-30 08:43:32 +02:00
|
|
|
IEEE80211_RC_BW_CHANGED);
|
2010-05-05 15:28:27 +02:00
|
|
|
}
|
2012-03-28 10:58:37 +02:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2009-03-30 13:23:35 +02:00
|
|
|
|
2012-03-15 19:45:16 +01:00
|
|
|
ht_opmode = le16_to_cpu(ht_oper->operation_mode);
|
2009-03-30 13:23:35 +02:00
|
|
|
|
|
|
|
/* if bss configuration changed store the new one */
|
2012-03-28 10:58:36 +02:00
|
|
|
if (!reconfig || (sdata->vif.bss_conf.ht_operation_mode != ht_opmode)) {
|
2009-03-30 13:23:35 +02:00
|
|
|
changed |= BSS_CHANGED_HT;
|
2009-05-08 20:47:39 +02:00
|
|
|
sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
|
2009-03-30 13:23:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2008-09-11 00:01:52 +02:00
|
|
|
/* frame sending functions */
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
static int ieee80211_compatible_rates(const u8 *supp_rates, int supp_rates_len,
|
|
|
|
struct ieee80211_supported_band *sband,
|
|
|
|
u32 *rates)
|
|
|
|
{
|
|
|
|
int i, j, count;
|
|
|
|
*rates = 0;
|
|
|
|
count = 0;
|
|
|
|
for (i = 0; i < supp_rates_len; i++) {
|
|
|
|
int rate = (supp_rates[i] & 0x7F) * 5;
|
|
|
|
|
|
|
|
for (j = 0; j < sband->n_bitrates; j++)
|
|
|
|
if (sband->bitrates[j].bitrate == rate) {
|
|
|
|
*rates |= BIT(j);
|
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_add_ht_ie(struct ieee80211_sub_if_data *sdata,
|
2012-05-16 23:43:19 +02:00
|
|
|
struct sk_buff *skb, u8 ap_ht_param,
|
2012-01-20 13:55:27 +01:00
|
|
|
struct ieee80211_supported_band *sband,
|
|
|
|
struct ieee80211_channel *channel,
|
|
|
|
enum ieee80211_smps_mode smps)
|
|
|
|
{
|
|
|
|
u8 *pos;
|
|
|
|
u32 flags = channel->flags;
|
|
|
|
u16 cap;
|
|
|
|
struct ieee80211_sta_ht_cap ht_cap;
|
|
|
|
|
|
|
|
BUILD_BUG_ON(sizeof(ht_cap) != sizeof(sband->ht_cap));
|
|
|
|
|
|
|
|
memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
|
|
|
|
ieee80211_apply_htcap_overrides(sdata, &ht_cap);
|
|
|
|
|
|
|
|
/* determine capability flags */
|
|
|
|
cap = ht_cap.cap;
|
|
|
|
|
2012-05-16 23:43:19 +02:00
|
|
|
switch (ap_ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
|
2012-01-20 13:55:27 +01:00
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
|
|
|
|
if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SGI_40;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
|
|
|
|
if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SGI_40;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-03-28 10:58:36 +02:00
|
|
|
/*
|
|
|
|
* If 40 MHz was disabled associate as though we weren't
|
|
|
|
* capable of 40 MHz -- some broken APs will never fall
|
|
|
|
* back to trying to transmit in 20 MHz.
|
|
|
|
*/
|
|
|
|
if (sdata->u.mgd.flags & IEEE80211_STA_DISABLE_40MHZ) {
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SGI_40;
|
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* set SM PS mode properly */
|
|
|
|
cap &= ~IEEE80211_HT_CAP_SM_PS;
|
|
|
|
switch (smps) {
|
|
|
|
case IEEE80211_SMPS_AUTOMATIC:
|
|
|
|
case IEEE80211_SMPS_NUM_MODES:
|
|
|
|
WARN_ON(1);
|
|
|
|
case IEEE80211_SMPS_OFF:
|
|
|
|
cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
|
|
|
|
IEEE80211_HT_CAP_SM_PS_SHIFT;
|
|
|
|
break;
|
|
|
|
case IEEE80211_SMPS_STATIC:
|
|
|
|
cap |= WLAN_HT_CAP_SM_PS_STATIC <<
|
|
|
|
IEEE80211_HT_CAP_SM_PS_SHIFT;
|
|
|
|
break;
|
|
|
|
case IEEE80211_SMPS_DYNAMIC:
|
|
|
|
cap |= WLAN_HT_CAP_SM_PS_DYNAMIC <<
|
|
|
|
IEEE80211_HT_CAP_SM_PS_SHIFT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reserve and fill IE */
|
|
|
|
pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2);
|
|
|
|
ieee80211_ie_build_ht_cap(pos, &ht_cap, cap);
|
|
|
|
}
|
|
|
|
|
2012-07-24 05:33:10 +02:00
|
|
|
static void ieee80211_add_vht_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct ieee80211_supported_band *sband)
|
|
|
|
{
|
|
|
|
u8 *pos;
|
|
|
|
u32 cap;
|
|
|
|
struct ieee80211_sta_vht_cap vht_cap;
|
|
|
|
|
|
|
|
BUILD_BUG_ON(sizeof(vht_cap) != sizeof(sband->vht_cap));
|
|
|
|
|
|
|
|
memcpy(&vht_cap, &sband->vht_cap, sizeof(vht_cap));
|
|
|
|
|
|
|
|
/* determine capability flags */
|
|
|
|
cap = vht_cap.cap;
|
|
|
|
|
|
|
|
/* reserve and fill IE */
|
2012-10-10 13:25:40 +02:00
|
|
|
pos = skb_put(skb, sizeof(struct ieee80211_vht_cap) + 2);
|
2012-07-24 05:33:10 +02:00
|
|
|
ieee80211_ie_build_vht_cap(pos, &vht_cap, cap);
|
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
|
|
|
u8 *pos, qos_info;
|
|
|
|
size_t offset = 0, noffset;
|
|
|
|
int i, count, rates_len, supp_rates_len;
|
|
|
|
u16 capab;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2012-07-26 17:24:39 +02:00
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_channel *chan;
|
2012-01-20 13:55:27 +01:00
|
|
|
u32 rates = 0;
|
|
|
|
|
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
if (WARN_ON(!chanctx_conf)) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
2012-11-09 11:39:59 +01:00
|
|
|
chan = chanctx_conf->def.chan;
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_unlock();
|
|
|
|
sband = local->hw.wiphy->bands[chan->band];
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
if (assoc_data->supp_rates_len) {
|
|
|
|
/*
|
|
|
|
* Get all rates supported by the device and the AP as
|
|
|
|
* some APs don't like getting a superset of their rates
|
|
|
|
* in the association request (e.g. D-Link DAP 1353 in
|
|
|
|
* b-only mode)...
|
|
|
|
*/
|
|
|
|
rates_len = ieee80211_compatible_rates(assoc_data->supp_rates,
|
|
|
|
assoc_data->supp_rates_len,
|
|
|
|
sband, &rates);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* In case AP not provide any supported rates information
|
|
|
|
* before association, we send information element(s) with
|
|
|
|
* all rates that we support.
|
|
|
|
*/
|
|
|
|
rates = ~0;
|
|
|
|
rates_len = sband->n_bitrates;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = alloc_skb(local->hw.extra_tx_headroom +
|
|
|
|
sizeof(*mgmt) + /* bit too much but doesn't matter */
|
|
|
|
2 + assoc_data->ssid_len + /* SSID */
|
|
|
|
4 + rates_len + /* (extended) rates */
|
|
|
|
4 + /* power capability */
|
|
|
|
2 + 2 * sband->n_channels + /* supported channels */
|
|
|
|
2 + sizeof(struct ieee80211_ht_cap) + /* HT */
|
2012-10-10 13:25:40 +02:00
|
|
|
2 + sizeof(struct ieee80211_vht_cap) + /* VHT */
|
2012-01-20 13:55:27 +01:00
|
|
|
assoc_data->ie_len + /* extra IEs */
|
|
|
|
9, /* WMM */
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
capab = WLAN_CAPABILITY_ESS;
|
|
|
|
|
|
|
|
if (sband->band == IEEE80211_BAND_2GHZ) {
|
|
|
|
if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
|
|
|
|
capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
|
|
|
|
if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
|
|
|
|
capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (assoc_data->capability & WLAN_CAPABILITY_PRIVACY)
|
|
|
|
capab |= WLAN_CAPABILITY_PRIVACY;
|
|
|
|
|
|
|
|
if ((assoc_data->capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
|
|
|
|
(local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
|
|
|
|
capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
|
|
|
|
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
|
|
|
|
memset(mgmt, 0, 24);
|
|
|
|
memcpy(mgmt->da, assoc_data->bss->bssid, ETH_ALEN);
|
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, assoc_data->bss->bssid, ETH_ALEN);
|
|
|
|
|
|
|
|
if (!is_zero_ether_addr(assoc_data->prev_bssid)) {
|
|
|
|
skb_put(skb, 10);
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_REASSOC_REQ);
|
|
|
|
mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
|
|
|
|
mgmt->u.reassoc_req.listen_interval =
|
|
|
|
cpu_to_le16(local->hw.conf.listen_interval);
|
|
|
|
memcpy(mgmt->u.reassoc_req.current_ap, assoc_data->prev_bssid,
|
|
|
|
ETH_ALEN);
|
|
|
|
} else {
|
|
|
|
skb_put(skb, 4);
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_ASSOC_REQ);
|
|
|
|
mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
|
|
|
|
mgmt->u.assoc_req.listen_interval =
|
|
|
|
cpu_to_le16(local->hw.conf.listen_interval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SSID */
|
|
|
|
pos = skb_put(skb, 2 + assoc_data->ssid_len);
|
|
|
|
*pos++ = WLAN_EID_SSID;
|
|
|
|
*pos++ = assoc_data->ssid_len;
|
|
|
|
memcpy(pos, assoc_data->ssid, assoc_data->ssid_len);
|
|
|
|
|
|
|
|
/* add all rates which were marked to be used above */
|
|
|
|
supp_rates_len = rates_len;
|
|
|
|
if (supp_rates_len > 8)
|
|
|
|
supp_rates_len = 8;
|
|
|
|
|
|
|
|
pos = skb_put(skb, supp_rates_len + 2);
|
|
|
|
*pos++ = WLAN_EID_SUPP_RATES;
|
|
|
|
*pos++ = supp_rates_len;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if (BIT(i) & rates) {
|
|
|
|
int rate = sband->bitrates[i].bitrate;
|
|
|
|
*pos++ = (u8) (rate / 5);
|
|
|
|
if (++count == 8)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rates_len > count) {
|
|
|
|
pos = skb_put(skb, rates_len - count + 2);
|
|
|
|
*pos++ = WLAN_EID_EXT_SUPP_RATES;
|
|
|
|
*pos++ = rates_len - count;
|
|
|
|
|
|
|
|
for (i++; i < sband->n_bitrates; i++) {
|
|
|
|
if (BIT(i) & rates) {
|
|
|
|
int rate = sband->bitrates[i].bitrate;
|
|
|
|
*pos++ = (u8) (rate / 5);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
|
|
|
|
/* 1. power capabilities */
|
|
|
|
pos = skb_put(skb, 4);
|
|
|
|
*pos++ = WLAN_EID_PWR_CAPABILITY;
|
|
|
|
*pos++ = 2;
|
|
|
|
*pos++ = 0; /* min tx power */
|
2012-07-26 17:24:39 +02:00
|
|
|
*pos++ = chan->max_power; /* max tx power */
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
/* 2. supported channels */
|
|
|
|
/* TODO: get this in reg domain format */
|
|
|
|
pos = skb_put(skb, 2 * sband->n_channels + 2);
|
|
|
|
*pos++ = WLAN_EID_SUPPORTED_CHANNELS;
|
|
|
|
*pos++ = 2 * sband->n_channels;
|
|
|
|
for (i = 0; i < sband->n_channels; i++) {
|
|
|
|
*pos++ = ieee80211_frequency_to_channel(
|
|
|
|
sband->channels[i].center_freq);
|
|
|
|
*pos++ = 1; /* one channel in the subband*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if present, add any custom IEs that go before HT */
|
|
|
|
if (assoc_data->ie_len && assoc_data->ie) {
|
|
|
|
static const u8 before_ht[] = {
|
|
|
|
WLAN_EID_SSID,
|
|
|
|
WLAN_EID_SUPP_RATES,
|
|
|
|
WLAN_EID_EXT_SUPP_RATES,
|
|
|
|
WLAN_EID_PWR_CAPABILITY,
|
|
|
|
WLAN_EID_SUPPORTED_CHANNELS,
|
|
|
|
WLAN_EID_RSN,
|
|
|
|
WLAN_EID_QOS_CAPA,
|
|
|
|
WLAN_EID_RRM_ENABLED_CAPABILITIES,
|
|
|
|
WLAN_EID_MOBILITY_DOMAIN,
|
|
|
|
WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(assoc_data->ie, assoc_data->ie_len,
|
|
|
|
before_ht, ARRAY_SIZE(before_ht),
|
|
|
|
offset);
|
|
|
|
pos = skb_put(skb, noffset - offset);
|
|
|
|
memcpy(pos, assoc_data->ie + offset, noffset - offset);
|
|
|
|
offset = noffset;
|
|
|
|
}
|
|
|
|
|
2012-11-22 14:32:09 +01:00
|
|
|
if (!(ifmgd->flags & IEEE80211_STA_DISABLE_HT))
|
2012-05-16 23:43:19 +02:00
|
|
|
ieee80211_add_ht_ie(sdata, skb, assoc_data->ap_ht_param,
|
2012-09-11 14:34:12 +02:00
|
|
|
sband, chan, sdata->smps_mode);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
2012-07-24 05:33:10 +02:00
|
|
|
if (!(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
|
|
|
|
ieee80211_add_vht_ie(sdata, skb, sband);
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* if present, add any custom non-vendor IEs that go after HT */
|
|
|
|
if (assoc_data->ie_len && assoc_data->ie) {
|
|
|
|
noffset = ieee80211_ie_split_vendor(assoc_data->ie,
|
|
|
|
assoc_data->ie_len,
|
|
|
|
offset);
|
|
|
|
pos = skb_put(skb, noffset - offset);
|
|
|
|
memcpy(pos, assoc_data->ie + offset, noffset - offset);
|
|
|
|
offset = noffset;
|
|
|
|
}
|
|
|
|
|
2012-03-08 15:02:05 +01:00
|
|
|
if (assoc_data->wmm) {
|
|
|
|
if (assoc_data->uapsd) {
|
2012-03-14 15:15:03 +01:00
|
|
|
qos_info = ifmgd->uapsd_queues;
|
|
|
|
qos_info |= (ifmgd->uapsd_max_sp_len <<
|
2012-01-20 13:55:27 +01:00
|
|
|
IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT);
|
|
|
|
} else {
|
|
|
|
qos_info = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pos = skb_put(skb, 9);
|
|
|
|
*pos++ = WLAN_EID_VENDOR_SPECIFIC;
|
|
|
|
*pos++ = 7; /* len */
|
|
|
|
*pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
|
|
|
|
*pos++ = 0x50;
|
|
|
|
*pos++ = 0xf2;
|
|
|
|
*pos++ = 2; /* WME */
|
|
|
|
*pos++ = 0; /* WME info */
|
|
|
|
*pos++ = 1; /* WME ver */
|
|
|
|
*pos++ = qos_info;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add any remaining custom (i.e. vendor specific here) IEs */
|
|
|
|
if (assoc_data->ie_len && assoc_data->ie) {
|
|
|
|
noffset = assoc_data->ie_len;
|
|
|
|
pos = skb_put(skb, noffset - offset);
|
|
|
|
memcpy(pos, assoc_data->ie + offset, noffset - offset);
|
|
|
|
}
|
|
|
|
|
2012-06-27 13:18:36 +02:00
|
|
|
drv_mgd_prepare_tx(local, sdata);
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
}
|
|
|
|
|
2009-02-10 16:09:31 +01:00
|
|
|
void ieee80211_send_pspoll(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_pspoll *pspoll;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2010-01-05 19:16:26 +01:00
|
|
|
skb = ieee80211_pspoll_get(&local->hw, &sdata->vif);
|
|
|
|
if (!skb)
|
2009-02-10 16:09:31 +01:00
|
|
|
return;
|
|
|
|
|
2010-01-05 19:16:26 +01:00
|
|
|
pspoll = (struct ieee80211_pspoll *) skb->data;
|
|
|
|
pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
|
2009-02-10 16:09:31 +01:00
|
|
|
|
2009-11-18 18:42:05 +01:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-10 16:09:31 +01:00
|
|
|
}
|
|
|
|
|
2009-04-16 13:17:24 +02:00
|
|
|
void ieee80211_send_nullfunc(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
int powersave)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2010-01-05 19:16:26 +01:00
|
|
|
struct ieee80211_hdr_3addr *nullfunc;
|
2011-09-29 17:04:04 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2009-04-16 13:17:24 +02:00
|
|
|
|
2010-01-05 19:16:26 +01:00
|
|
|
skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif);
|
|
|
|
if (!skb)
|
2009-04-16 13:17:24 +02:00
|
|
|
return;
|
|
|
|
|
2010-01-05 19:16:26 +01:00
|
|
|
nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
|
2009-04-16 13:17:24 +02:00
|
|
|
if (powersave)
|
2010-01-05 19:16:26 +01:00
|
|
|
nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
|
2009-04-16 13:17:24 +02:00
|
|
|
|
2009-11-18 18:42:05 +01:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
2011-09-29 17:04:04 +02:00
|
|
|
if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
|
|
|
|
IEEE80211_STA_CONNECTION_POLL))
|
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_USE_MINRATE;
|
|
|
|
|
2009-11-18 18:42:05 +01:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-04-16 13:17:24 +02:00
|
|
|
}
|
|
|
|
|
2010-01-08 18:06:26 +01:00
|
|
|
static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_hdr *nullfunc;
|
|
|
|
__le16 fc;
|
|
|
|
|
|
|
|
if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
|
|
|
|
return;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
|
2011-08-29 23:17:31 +02:00
|
|
|
if (!skb)
|
2010-01-08 18:06:26 +01:00
|
|
|
return;
|
2011-08-29 23:17:31 +02:00
|
|
|
|
2010-01-08 18:06:26 +01:00
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
|
|
|
|
memset(nullfunc, 0, 30);
|
|
|
|
fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
|
|
|
|
IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
|
|
|
|
nullfunc->frame_control = fc;
|
|
|
|
memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
|
|
|
|
memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
|
|
|
|
memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
|
|
|
|
memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN);
|
|
|
|
|
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
}
|
|
|
|
|
2009-05-15 11:52:31 +02:00
|
|
|
/* spectrum management related things */
|
|
|
|
static void ieee80211_chswitch_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
2009-12-23 13:15:31 +01:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-05-15 11:52:31 +02:00
|
|
|
return;
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
if (!ifmgd->associated)
|
|
|
|
goto out;
|
2009-05-15 11:52:31 +02:00
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
sdata->local->_oper_channel = sdata->local->csa_channel;
|
2010-05-11 16:20:57 +02:00
|
|
|
if (!sdata->local->ops->channel_switch) {
|
|
|
|
/* call "hw_config" only if doing sw channel switch */
|
|
|
|
ieee80211_hw_config(sdata->local,
|
|
|
|
IEEE80211_CONF_CHANGE_CHANNEL);
|
2011-09-08 07:44:05 +02:00
|
|
|
} else {
|
|
|
|
/* update the device channel directly */
|
2012-07-26 17:24:39 +02:00
|
|
|
sdata->local->hw.conf.channel = sdata->local->_oper_channel;
|
2010-05-11 16:20:57 +02:00
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2009-05-15 11:52:31 +02:00
|
|
|
/* XXX: shouldn't really modify cfg80211-owned data! */
|
2012-07-26 17:24:39 +02:00
|
|
|
ifmgd->associated->channel = sdata->local->_oper_channel;
|
2009-05-15 11:52:31 +02:00
|
|
|
|
2012-08-01 15:50:46 +02:00
|
|
|
/* XXX: wait for a beacon first? */
|
2009-05-15 11:52:31 +02:00
|
|
|
ieee80211_wake_queues_by_reason(&sdata->local->hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_CSA);
|
2009-07-07 03:45:17 +02:00
|
|
|
out:
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2009-05-15 11:52:31 +02:00
|
|
|
}
|
|
|
|
|
2010-05-11 16:20:57 +02:00
|
|
|
void ieee80211_chswitch_done(struct ieee80211_vif *vif, bool success)
|
|
|
|
{
|
2012-07-26 17:24:39 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2010-05-11 16:20:57 +02:00
|
|
|
|
|
|
|
trace_api_chswitch_done(sdata, success);
|
|
|
|
if (!success) {
|
2012-08-01 22:32:45 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"driver channel switch failed, disconnecting\n");
|
|
|
|
ieee80211_queue_work(&sdata->local->hw,
|
|
|
|
&ifmgd->csa_connection_drop_work);
|
|
|
|
} else {
|
|
|
|
ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
|
2010-05-11 16:20:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_chswitch_done);
|
|
|
|
|
2009-05-15 11:52:31 +02:00
|
|
|
static void ieee80211_chswitch_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
(struct ieee80211_sub_if_data *) data;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
2009-05-17 11:40:42 +02:00
|
|
|
if (sdata->local->quiescing) {
|
|
|
|
set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-30 02:08:07 +02:00
|
|
|
ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
|
2009-05-15 11:52:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_channel_sw_ie *sw_elem,
|
2010-05-11 16:20:57 +02:00
|
|
|
struct ieee80211_bss *bss,
|
|
|
|
u64 timestamp)
|
2009-05-15 11:52:31 +02:00
|
|
|
{
|
2009-12-23 13:15:39 +01:00
|
|
|
struct cfg80211_bss *cbss =
|
|
|
|
container_of((void *)bss, struct cfg80211_bss, priv);
|
2009-05-15 11:52:31 +02:00
|
|
|
struct ieee80211_channel *new_ch;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2011-01-17 05:37:28 +01:00
|
|
|
int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num,
|
|
|
|
cbss->channel->band);
|
2012-07-26 17:24:39 +02:00
|
|
|
struct ieee80211_chanctx *chanctx;
|
2009-05-15 11:52:31 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
ASSERT_MGD_MTX(ifmgd);
|
|
|
|
|
|
|
|
if (!ifmgd->associated)
|
2009-05-15 11:52:31 +02:00
|
|
|
return;
|
|
|
|
|
2009-07-23 12:14:04 +02:00
|
|
|
if (sdata->local->scanning)
|
2009-05-15 11:52:31 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Disregard subsequent beacons if we are already running a timer
|
|
|
|
processing a CSA */
|
|
|
|
|
|
|
|
if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
|
|
|
|
return;
|
|
|
|
|
|
|
|
new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
|
2012-08-01 22:32:45 +02:00
|
|
|
if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED) {
|
|
|
|
sdata_info(sdata,
|
|
|
|
"AP %pM switches to unsupported channel (%d MHz), disconnecting\n",
|
|
|
|
ifmgd->associated->bssid, new_freq);
|
|
|
|
ieee80211_queue_work(&sdata->local->hw,
|
|
|
|
&ifmgd->csa_connection_drop_work);
|
2009-05-15 11:52:31 +02:00
|
|
|
return;
|
2012-08-01 22:32:45 +02:00
|
|
|
}
|
2009-05-15 11:52:31 +02:00
|
|
|
|
2012-08-01 15:50:46 +02:00
|
|
|
ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
|
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
if (sdata->local->use_chanctx) {
|
|
|
|
sdata_info(sdata,
|
|
|
|
"not handling channel switch with channel contexts\n");
|
|
|
|
ieee80211_queue_work(&sdata->local->hw,
|
|
|
|
&ifmgd->csa_connection_drop_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&sdata->local->chanctx_mtx);
|
|
|
|
if (WARN_ON(!rcu_access_pointer(sdata->vif.chanctx_conf))) {
|
|
|
|
mutex_unlock(&sdata->local->chanctx_mtx);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
chanctx = container_of(rcu_access_pointer(sdata->vif.chanctx_conf),
|
|
|
|
struct ieee80211_chanctx, conf);
|
|
|
|
if (chanctx->refcount > 1) {
|
|
|
|
sdata_info(sdata,
|
|
|
|
"channel switch with multiple interfaces on the same channel, disconnecting\n");
|
|
|
|
ieee80211_queue_work(&sdata->local->hw,
|
|
|
|
&ifmgd->csa_connection_drop_work);
|
|
|
|
mutex_unlock(&sdata->local->chanctx_mtx);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
mutex_unlock(&sdata->local->chanctx_mtx);
|
|
|
|
|
|
|
|
sdata->local->csa_channel = new_ch;
|
|
|
|
|
2012-08-01 15:50:46 +02:00
|
|
|
if (sw_elem->mode)
|
|
|
|
ieee80211_stop_queues_by_reason(&sdata->local->hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_CSA);
|
|
|
|
|
2010-05-11 16:20:57 +02:00
|
|
|
if (sdata->local->ops->channel_switch) {
|
|
|
|
/* use driver's channel switch callback */
|
2012-08-01 15:50:46 +02:00
|
|
|
struct ieee80211_channel_switch ch_switch = {
|
|
|
|
.timestamp = timestamp,
|
|
|
|
.block_tx = sw_elem->mode,
|
|
|
|
.channel = new_ch,
|
|
|
|
.count = sw_elem->count,
|
|
|
|
};
|
|
|
|
|
2010-05-11 16:20:57 +02:00
|
|
|
drv_channel_switch(sdata->local, &ch_switch);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* channel switch handled in software */
|
2012-08-01 15:50:46 +02:00
|
|
|
if (sw_elem->count <= 1)
|
2009-07-30 02:08:07 +02:00
|
|
|
ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
|
2012-08-01 15:50:46 +02:00
|
|
|
else
|
2009-05-15 11:52:31 +02:00
|
|
|
mod_timer(&ifmgd->chswitch_timer,
|
2012-08-01 15:53:45 +02:00
|
|
|
TU_TO_EXP_TIME(sw_elem->count *
|
|
|
|
cbss->beacon_interval));
|
2009-05-15 11:52:31 +02:00
|
|
|
}
|
|
|
|
|
2012-10-24 10:59:25 +02:00
|
|
|
static u32 ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_channel *channel,
|
|
|
|
const u8 *country_ie, u8 country_ie_len,
|
|
|
|
const u8 *pwr_constr_elem)
|
2009-05-15 11:52:31 +02:00
|
|
|
{
|
2012-09-05 13:41:37 +02:00
|
|
|
struct ieee80211_country_ie_triplet *triplet;
|
|
|
|
int chan = ieee80211_frequency_to_channel(channel->center_freq);
|
|
|
|
int i, chan_pwr, chan_increment, new_ap_level;
|
|
|
|
bool have_chan_pwr = false;
|
2009-05-15 11:52:31 +02:00
|
|
|
|
2012-09-05 13:41:37 +02:00
|
|
|
/* Invalid IE */
|
|
|
|
if (country_ie_len % 2 || country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
|
2012-10-24 10:59:25 +02:00
|
|
|
return 0;
|
2009-05-15 11:52:31 +02:00
|
|
|
|
2012-09-05 13:41:37 +02:00
|
|
|
triplet = (void *)(country_ie + 3);
|
|
|
|
country_ie_len -= 3;
|
|
|
|
|
|
|
|
switch (channel->band) {
|
|
|
|
default:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
/* fall through */
|
|
|
|
case IEEE80211_BAND_2GHZ:
|
|
|
|
case IEEE80211_BAND_60GHZ:
|
|
|
|
chan_increment = 1;
|
|
|
|
break;
|
|
|
|
case IEEE80211_BAND_5GHZ:
|
|
|
|
chan_increment = 4;
|
|
|
|
break;
|
2009-05-15 11:52:31 +02:00
|
|
|
}
|
2012-09-05 13:41:37 +02:00
|
|
|
|
|
|
|
/* find channel */
|
|
|
|
while (country_ie_len >= 3) {
|
|
|
|
u8 first_channel = triplet->chans.first_channel;
|
|
|
|
|
|
|
|
if (first_channel >= IEEE80211_COUNTRY_EXTENSION_ID)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
for (i = 0; i < triplet->chans.num_channels; i++) {
|
|
|
|
if (first_channel + i * chan_increment == chan) {
|
|
|
|
have_chan_pwr = true;
|
|
|
|
chan_pwr = triplet->chans.max_power;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (have_chan_pwr)
|
|
|
|
break;
|
|
|
|
|
|
|
|
next:
|
|
|
|
triplet++;
|
|
|
|
country_ie_len -= 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!have_chan_pwr)
|
2012-10-24 10:59:25 +02:00
|
|
|
return 0;
|
2012-09-05 13:41:37 +02:00
|
|
|
|
|
|
|
new_ap_level = max_t(int, 0, chan_pwr - *pwr_constr_elem);
|
|
|
|
|
2012-10-24 10:59:25 +02:00
|
|
|
if (sdata->ap_power_level == new_ap_level)
|
|
|
|
return 0;
|
2012-09-05 13:41:37 +02:00
|
|
|
|
|
|
|
sdata_info(sdata,
|
|
|
|
"Limiting TX power to %d (%d - %d) dBm as advertised by %pM\n",
|
|
|
|
new_ap_level, chan_pwr, *pwr_constr_elem,
|
|
|
|
sdata->u.mgd.bssid);
|
2012-10-24 10:59:25 +02:00
|
|
|
sdata->ap_power_level = new_ap_level;
|
|
|
|
if (__ieee80211_recalc_txpower(sdata))
|
|
|
|
return BSS_CHANGED_TXPOWER;
|
|
|
|
return 0;
|
2009-05-15 11:52:31 +02:00
|
|
|
}
|
|
|
|
|
mac80211: Add interface for driver to temporarily disable dynamic ps
This mechanism introduced in this patch applies (at least) for hardware
designs using a single shared antenna for both WLAN and BT. In these designs,
the antenna must be toggled between WLAN and BT.
In those hardware, managing WLAN co-existence with Bluetooth requires WLAN
full power save whenever there is Bluetooth activity in order for WLAN to be
able to periodically relinquish the antenna to be used for BT. This is because
BT can only access the shared antenna when WLAN is idle or asleep.
Some hardware, for instance the wl1271, are able to indicate to the host
whenever there is BT traffic. In essence, the hardware will send an indication
to the host whenever there is, for example, SCO traffic or A2DP traffic, and
will send another indication when the traffic is over.
The hardware gets information of Bluetooth traffic via hardware co-existence
control lines - these lines are used to negotiate the shared antenna
ownership. The hardware will give the antenna to BT whenever WLAN is sleeping.
This patch adds the interface to mac80211 to facilitate temporarily disabling
of dynamic power save as per request of the WLAN driver. This interface will
immediately force WLAN to full powersave, hence allowing BT coexistence as
described above.
In these kind of shared antenna desings, when WLAN powersave is fully disabled,
Bluetooth will not work simultaneously with WLAN at all. This patch does not
address that problem. This interface will not change PSM state, so if PSM is
disabled it will remain so. Solving this problem requires knowledge about BT
state, and is best done in user-space.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-06-21 07:59:39 +02:00
|
|
|
void ieee80211_enable_dyn_ps(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_conf *conf = &local->hw.conf;
|
|
|
|
|
|
|
|
WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
|
|
|
|
!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
|
|
|
|
(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
|
|
|
|
|
|
|
|
local->disable_dynamic_ps = false;
|
|
|
|
conf->dynamic_ps_timeout = local->dynamic_ps_user_timeout;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_enable_dyn_ps);
|
|
|
|
|
|
|
|
void ieee80211_disable_dyn_ps(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_conf *conf = &local->hw.conf;
|
|
|
|
|
|
|
|
WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
|
|
|
|
!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
|
|
|
|
(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
|
|
|
|
|
|
|
|
local->disable_dynamic_ps = true;
|
|
|
|
conf->dynamic_ps_timeout = 0;
|
|
|
|
del_timer_sync(&local->dynamic_ps_timer);
|
|
|
|
ieee80211_queue_work(&local->hw,
|
|
|
|
&local->dynamic_ps_enable_work);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_disable_dyn_ps);
|
|
|
|
|
2009-04-16 13:17:24 +02:00
|
|
|
/* powersave */
|
|
|
|
static void ieee80211_enable_ps(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_conf *conf = &local->hw.conf;
|
|
|
|
|
2009-04-22 23:02:51 +02:00
|
|
|
/*
|
|
|
|
* If we are scanning right now then the parameters will
|
|
|
|
* take effect when scan finishes.
|
|
|
|
*/
|
2009-07-23 12:14:04 +02:00
|
|
|
if (local->scanning)
|
2009-04-22 23:02:51 +02:00
|
|
|
return;
|
|
|
|
|
2009-04-16 13:17:24 +02:00
|
|
|
if (conf->dynamic_ps_timeout > 0 &&
|
|
|
|
!(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
|
|
|
|
mod_timer(&local->dynamic_ps_timer, jiffies +
|
|
|
|
msecs_to_jiffies(conf->dynamic_ps_timeout));
|
|
|
|
} else {
|
|
|
|
if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
|
|
|
|
ieee80211_send_nullfunc(local, sdata, 1);
|
2010-02-09 10:20:28 +01:00
|
|
|
|
2010-03-09 13:25:02 +01:00
|
|
|
if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
|
|
|
|
(local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
|
|
|
|
return;
|
|
|
|
|
|
|
|
conf->flags |= IEEE80211_CONF_PS;
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
|
2009-04-16 13:17:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_change_ps(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_conf *conf = &local->hw.conf;
|
|
|
|
|
|
|
|
if (local->ps_sdata) {
|
|
|
|
ieee80211_enable_ps(local, local->ps_sdata);
|
|
|
|
} else if (conf->flags & IEEE80211_CONF_PS) {
|
|
|
|
conf->flags &= ~IEEE80211_CONF_PS;
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
|
|
|
|
del_timer_sync(&local->dynamic_ps_timer);
|
|
|
|
cancel_work_sync(&local->dynamic_ps_enable_work);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-11 01:43:19 +01:00
|
|
|
static bool ieee80211_powersave_allowed(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *mgd = &sdata->u.mgd;
|
|
|
|
struct sta_info *sta = NULL;
|
2011-09-29 16:04:36 +02:00
|
|
|
bool authorized = false;
|
2011-03-11 01:43:19 +01:00
|
|
|
|
|
|
|
if (!mgd->powersave)
|
|
|
|
return false;
|
|
|
|
|
2011-10-28 11:59:47 +02:00
|
|
|
if (mgd->broken_ap)
|
|
|
|
return false;
|
|
|
|
|
2011-03-11 01:43:19 +01:00
|
|
|
if (!mgd->associated)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (mgd->flags & (IEEE80211_STA_BEACON_POLL |
|
|
|
|
IEEE80211_STA_CONNECTION_POLL))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
sta = sta_info_get(sdata, mgd->bssid);
|
|
|
|
if (sta)
|
2011-09-29 16:04:36 +02:00
|
|
|
authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
|
2011-03-11 01:43:19 +01:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2011-09-29 16:04:36 +02:00
|
|
|
return authorized;
|
2011-03-11 01:43:19 +01:00
|
|
|
}
|
|
|
|
|
2009-04-16 13:17:24 +02:00
|
|
|
/* need to hold RTNL or interface lock */
|
2009-04-16 13:17:25 +02:00
|
|
|
void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
|
2009-04-16 13:17:24 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata, *found = NULL;
|
|
|
|
int count = 0;
|
2010-04-27 11:47:40 +02:00
|
|
|
int timeout;
|
2009-04-16 13:17:24 +02:00
|
|
|
|
|
|
|
if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
|
|
|
|
local->ps_sdata = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2009-12-23 13:15:31 +01:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-04-16 13:17:24 +02:00
|
|
|
continue;
|
2011-01-31 19:58:59 +01:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
|
|
|
/* If an AP vif is found, then disable PS
|
|
|
|
* by setting the count to zero thereby setting
|
|
|
|
* ps_sdata to NULL.
|
|
|
|
*/
|
|
|
|
count = 0;
|
|
|
|
break;
|
|
|
|
}
|
2009-04-16 13:17:24 +02:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
continue;
|
|
|
|
found = sdata;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
2011-03-11 01:43:19 +01:00
|
|
|
if (count == 1 && ieee80211_powersave_allowed(found)) {
|
mac80211: Add interface for driver to temporarily disable dynamic ps
This mechanism introduced in this patch applies (at least) for hardware
designs using a single shared antenna for both WLAN and BT. In these designs,
the antenna must be toggled between WLAN and BT.
In those hardware, managing WLAN co-existence with Bluetooth requires WLAN
full power save whenever there is Bluetooth activity in order for WLAN to be
able to periodically relinquish the antenna to be used for BT. This is because
BT can only access the shared antenna when WLAN is idle or asleep.
Some hardware, for instance the wl1271, are able to indicate to the host
whenever there is BT traffic. In essence, the hardware will send an indication
to the host whenever there is, for example, SCO traffic or A2DP traffic, and
will send another indication when the traffic is over.
The hardware gets information of Bluetooth traffic via hardware co-existence
control lines - these lines are used to negotiate the shared antenna
ownership. The hardware will give the antenna to BT whenever WLAN is sleeping.
This patch adds the interface to mac80211 to facilitate temporarily disabling
of dynamic power save as per request of the WLAN driver. This interface will
immediately force WLAN to full powersave, hence allowing BT coexistence as
described above.
In these kind of shared antenna desings, when WLAN powersave is fully disabled,
Bluetooth will not work simultaneously with WLAN at all. This patch does not
address that problem. This interface will not change PSM state, so if PSM is
disabled it will remain so. Solving this problem requires knowledge about BT
state, and is best done in user-space.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-06-21 07:59:39 +02:00
|
|
|
struct ieee80211_conf *conf = &local->hw.conf;
|
2009-04-16 13:17:25 +02:00
|
|
|
s32 beaconint_us;
|
|
|
|
|
|
|
|
if (latency < 0)
|
2010-05-06 01:59:26 +02:00
|
|
|
latency = pm_qos_request(PM_QOS_NETWORK_LATENCY);
|
2009-04-16 13:17:25 +02:00
|
|
|
|
|
|
|
beaconint_us = ieee80211_tu_to_usec(
|
|
|
|
found->vif.bss_conf.beacon_int);
|
|
|
|
|
2010-06-09 08:51:52 +02:00
|
|
|
timeout = local->dynamic_ps_forced_timeout;
|
2010-04-27 11:47:40 +02:00
|
|
|
if (timeout < 0) {
|
|
|
|
/*
|
2010-06-09 08:51:52 +02:00
|
|
|
* Go to full PSM if the user configures a very low
|
|
|
|
* latency requirement.
|
2010-12-03 01:16:23 +01:00
|
|
|
* The 2000 second value is there for compatibility
|
|
|
|
* until the PM_QOS_NETWORK_LATENCY is configured
|
|
|
|
* with real values.
|
2010-04-27 11:47:40 +02:00
|
|
|
*/
|
2010-12-03 01:16:23 +01:00
|
|
|
if (latency > (1900 * USEC_PER_MSEC) &&
|
|
|
|
latency != (2000 * USEC_PER_SEC))
|
2010-04-27 11:47:40 +02:00
|
|
|
timeout = 0;
|
2010-06-09 08:51:52 +02:00
|
|
|
else
|
|
|
|
timeout = 100;
|
2010-04-27 11:47:40 +02:00
|
|
|
}
|
mac80211: Add interface for driver to temporarily disable dynamic ps
This mechanism introduced in this patch applies (at least) for hardware
designs using a single shared antenna for both WLAN and BT. In these designs,
the antenna must be toggled between WLAN and BT.
In those hardware, managing WLAN co-existence with Bluetooth requires WLAN
full power save whenever there is Bluetooth activity in order for WLAN to be
able to periodically relinquish the antenna to be used for BT. This is because
BT can only access the shared antenna when WLAN is idle or asleep.
Some hardware, for instance the wl1271, are able to indicate to the host
whenever there is BT traffic. In essence, the hardware will send an indication
to the host whenever there is, for example, SCO traffic or A2DP traffic, and
will send another indication when the traffic is over.
The hardware gets information of Bluetooth traffic via hardware co-existence
control lines - these lines are used to negotiate the shared antenna
ownership. The hardware will give the antenna to BT whenever WLAN is sleeping.
This patch adds the interface to mac80211 to facilitate temporarily disabling
of dynamic power save as per request of the WLAN driver. This interface will
immediately force WLAN to full powersave, hence allowing BT coexistence as
described above.
In these kind of shared antenna desings, when WLAN powersave is fully disabled,
Bluetooth will not work simultaneously with WLAN at all. This patch does not
address that problem. This interface will not change PSM state, so if PSM is
disabled it will remain so. Solving this problem requires knowledge about BT
state, and is best done in user-space.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-06-21 07:59:39 +02:00
|
|
|
local->dynamic_ps_user_timeout = timeout;
|
|
|
|
if (!local->disable_dynamic_ps)
|
|
|
|
conf->dynamic_ps_timeout =
|
|
|
|
local->dynamic_ps_user_timeout;
|
2010-04-27 11:47:40 +02:00
|
|
|
|
2009-04-22 18:44:37 +02:00
|
|
|
if (beaconint_us > latency) {
|
2009-04-16 13:17:25 +02:00
|
|
|
local->ps_sdata = NULL;
|
2009-04-22 18:44:37 +02:00
|
|
|
} else {
|
2010-01-26 14:19:52 +01:00
|
|
|
struct ieee80211_bss *bss;
|
2009-04-22 18:44:37 +02:00
|
|
|
int maxslp = 1;
|
2010-01-26 14:19:52 +01:00
|
|
|
u8 dtimper;
|
2009-04-22 18:44:37 +02:00
|
|
|
|
2010-01-26 14:19:52 +01:00
|
|
|
bss = (void *)found->u.mgd.associated->priv;
|
|
|
|
dtimper = bss->dtim_period;
|
|
|
|
|
|
|
|
/* If the TIM IE is invalid, pretend the value is 1 */
|
|
|
|
if (!dtimper)
|
|
|
|
dtimper = 1;
|
|
|
|
else if (dtimper > 1)
|
2009-04-22 18:44:37 +02:00
|
|
|
maxslp = min_t(int, dtimper,
|
|
|
|
latency / beaconint_us);
|
|
|
|
|
2009-04-23 10:32:36 +02:00
|
|
|
local->hw.conf.max_sleep_period = maxslp;
|
2010-01-26 14:19:52 +01:00
|
|
|
local->hw.conf.ps_dtim_period = dtimper;
|
2009-04-16 13:17:25 +02:00
|
|
|
local->ps_sdata = found;
|
2009-04-22 18:44:37 +02:00
|
|
|
}
|
2009-04-16 13:17:25 +02:00
|
|
|
} else {
|
2009-04-16 13:17:24 +02:00
|
|
|
local->ps_sdata = NULL;
|
2009-04-16 13:17:25 +02:00
|
|
|
}
|
2009-04-16 13:17:24 +02:00
|
|
|
|
|
|
|
ieee80211_change_ps(local);
|
|
|
|
}
|
|
|
|
|
2012-07-27 11:33:22 +02:00
|
|
|
void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
bool ps_allowed = ieee80211_powersave_allowed(sdata);
|
|
|
|
|
|
|
|
if (sdata->vif.bss_conf.ps != ps_allowed) {
|
|
|
|
sdata->vif.bss_conf.ps = ps_allowed;
|
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_PS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-16 13:17:24 +02:00
|
|
|
void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local,
|
|
|
|
dynamic_ps_disable_work);
|
|
|
|
|
|
|
|
if (local->hw.conf.flags & IEEE80211_CONF_PS) {
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_PS;
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_wake_queues_by_reason(&local->hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_PS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local,
|
|
|
|
dynamic_ps_enable_work);
|
|
|
|
struct ieee80211_sub_if_data *sdata = local->ps_sdata;
|
2011-06-30 21:08:43 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd;
|
2011-05-03 13:33:59 +02:00
|
|
|
unsigned long flags;
|
|
|
|
int q;
|
2009-04-16 13:17:24 +02:00
|
|
|
|
|
|
|
/* can only happen when PS was just disabled anyway */
|
|
|
|
if (!sdata)
|
|
|
|
return;
|
|
|
|
|
2011-06-30 21:08:43 +02:00
|
|
|
ifmgd = &sdata->u.mgd;
|
|
|
|
|
2009-04-16 13:17:24 +02:00
|
|
|
if (local->hw.conf.flags & IEEE80211_CONF_PS)
|
|
|
|
return;
|
|
|
|
|
2011-06-26 11:06:54 +02:00
|
|
|
if (!local->disable_dynamic_ps &&
|
|
|
|
local->hw.conf.dynamic_ps_timeout > 0) {
|
|
|
|
/* don't enter PS if TX frames are pending */
|
|
|
|
if (drv_tx_frames_pending(local)) {
|
2011-05-03 13:33:59 +02:00
|
|
|
mod_timer(&local->dynamic_ps_timer, jiffies +
|
|
|
|
msecs_to_jiffies(
|
|
|
|
local->hw.conf.dynamic_ps_timeout));
|
|
|
|
return;
|
|
|
|
}
|
2011-06-26 11:06:54 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* transmission can be stopped by others which leads to
|
|
|
|
* dynamic_ps_timer expiry. Postpone the ps timer if it
|
|
|
|
* is not the actual idle state.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
for (q = 0; q < local->hw.queues; q++) {
|
|
|
|
if (local->queue_stop_reasons[q]) {
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock,
|
|
|
|
flags);
|
|
|
|
mod_timer(&local->dynamic_ps_timer, jiffies +
|
|
|
|
msecs_to_jiffies(
|
|
|
|
local->hw.conf.dynamic_ps_timeout));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
2011-05-03 13:33:59 +02:00
|
|
|
}
|
|
|
|
|
2010-02-09 10:20:28 +01:00
|
|
|
if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
|
2011-12-14 15:16:07 +01:00
|
|
|
!(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
|
2011-02-23 08:34:32 +01:00
|
|
|
netif_tx_stop_all_queues(sdata->dev);
|
2009-04-16 13:17:24 +02:00
|
|
|
|
2011-04-06 08:11:10 +02:00
|
|
|
if (drv_tx_frames_pending(local))
|
|
|
|
mod_timer(&local->dynamic_ps_timer, jiffies +
|
|
|
|
msecs_to_jiffies(
|
|
|
|
local->hw.conf.dynamic_ps_timeout));
|
|
|
|
else {
|
|
|
|
ieee80211_send_nullfunc(local, sdata, 1);
|
|
|
|
/* Flush to get the tx status of nullfunc frame */
|
|
|
|
drv_flush(local, false);
|
|
|
|
}
|
2011-02-23 08:34:32 +01:00
|
|
|
}
|
|
|
|
|
2010-03-09 13:25:02 +01:00
|
|
|
if (!((local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) &&
|
|
|
|
(local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) ||
|
2010-02-09 10:20:28 +01:00
|
|
|
(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
|
|
|
|
local->hw.conf.flags |= IEEE80211_CONF_PS;
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
|
|
|
|
}
|
2011-02-23 08:34:32 +01:00
|
|
|
|
2011-06-26 11:06:54 +02:00
|
|
|
if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
|
|
|
|
netif_tx_wake_all_queues(sdata->dev);
|
2009-04-16 13:17:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_dynamic_ps_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = (void *) data;
|
|
|
|
|
2009-07-27 17:38:25 +02:00
|
|
|
if (local->quiescing || local->suspended)
|
2009-05-17 11:40:42 +02:00
|
|
|
return;
|
|
|
|
|
2009-07-30 02:08:07 +02:00
|
|
|
ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
|
2009-04-16 13:17:24 +02:00
|
|
|
}
|
|
|
|
|
2008-09-08 17:44:22 +02:00
|
|
|
/* MLME */
|
2012-07-06 17:37:43 +02:00
|
|
|
static bool ieee80211_sta_wmm_params(struct ieee80211_local *local,
|
2010-07-19 16:39:04 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata,
|
2007-05-05 20:45:53 +02:00
|
|
|
u8 *wmm_param, size_t wmm_param_len)
|
|
|
|
{
|
|
|
|
struct ieee80211_tx_queue_params params;
|
2010-07-19 16:39:04 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2007-05-05 20:45:53 +02:00
|
|
|
size_t left;
|
|
|
|
int count;
|
2010-01-12 09:42:31 +01:00
|
|
|
u8 *pos, uapsd_queues = 0;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2010-03-29 12:18:34 +02:00
|
|
|
if (!local->ops->conf_tx)
|
2012-07-06 17:37:43 +02:00
|
|
|
return false;
|
2010-03-29 12:18:34 +02:00
|
|
|
|
2012-03-28 11:04:29 +02:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
2012-07-06 17:37:43 +02:00
|
|
|
return false;
|
2008-05-03 00:59:37 +02:00
|
|
|
|
|
|
|
if (!wmm_param)
|
2012-07-06 17:37:43 +02:00
|
|
|
return false;
|
2008-05-03 00:59:37 +02:00
|
|
|
|
2007-05-05 20:45:53 +02:00
|
|
|
if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
|
2012-07-06 17:37:43 +02:00
|
|
|
return false;
|
2010-01-12 09:42:31 +01:00
|
|
|
|
|
|
|
if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
|
2012-03-14 15:15:03 +01:00
|
|
|
uapsd_queues = ifmgd->uapsd_queues;
|
2010-01-12 09:42:31 +01:00
|
|
|
|
2007-05-05 20:45:53 +02:00
|
|
|
count = wmm_param[6] & 0x0f;
|
2009-02-15 12:44:28 +01:00
|
|
|
if (count == ifmgd->wmm_last_param_set)
|
2012-07-06 17:37:43 +02:00
|
|
|
return false;
|
2009-02-15 12:44:28 +01:00
|
|
|
ifmgd->wmm_last_param_set = count;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
|
|
|
pos = wmm_param + 8;
|
|
|
|
left = wmm_param_len - 8;
|
|
|
|
|
|
|
|
memset(¶ms, 0, sizeof(params));
|
|
|
|
|
2012-06-20 14:39:13 +02:00
|
|
|
sdata->wmm_acm = 0;
|
2007-05-05 20:45:53 +02:00
|
|
|
for (; left >= 4; left -= 4, pos += 4) {
|
|
|
|
int aci = (pos[0] >> 5) & 0x03;
|
|
|
|
int acm = (pos[0] >> 4) & 0x01;
|
2010-01-12 09:42:31 +01:00
|
|
|
bool uapsd = false;
|
2007-05-05 20:45:53 +02:00
|
|
|
int queue;
|
|
|
|
|
|
|
|
switch (aci) {
|
2009-03-05 16:23:46 +01:00
|
|
|
case 1: /* AC_BK */
|
2008-04-30 18:51:21 +02:00
|
|
|
queue = 3;
|
2008-04-17 19:21:22 +02:00
|
|
|
if (acm)
|
2012-06-20 14:39:13 +02:00
|
|
|
sdata->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
|
2010-01-12 09:42:31 +01:00
|
|
|
if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
|
|
|
|
uapsd = true;
|
2007-05-05 20:45:53 +02:00
|
|
|
break;
|
2009-03-05 16:23:46 +01:00
|
|
|
case 2: /* AC_VI */
|
2008-04-30 18:51:21 +02:00
|
|
|
queue = 1;
|
2008-04-17 19:21:22 +02:00
|
|
|
if (acm)
|
2012-06-20 14:39:13 +02:00
|
|
|
sdata->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
|
2010-01-12 09:42:31 +01:00
|
|
|
if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
|
|
|
|
uapsd = true;
|
2007-05-05 20:45:53 +02:00
|
|
|
break;
|
2009-03-05 16:23:46 +01:00
|
|
|
case 3: /* AC_VO */
|
2008-04-30 18:51:21 +02:00
|
|
|
queue = 0;
|
2008-04-17 19:21:22 +02:00
|
|
|
if (acm)
|
2012-06-20 14:39:13 +02:00
|
|
|
sdata->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
|
2010-01-12 09:42:31 +01:00
|
|
|
if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
|
|
|
|
uapsd = true;
|
2007-05-05 20:45:53 +02:00
|
|
|
break;
|
2009-03-05 16:23:46 +01:00
|
|
|
case 0: /* AC_BE */
|
2007-05-05 20:45:53 +02:00
|
|
|
default:
|
2008-04-30 18:51:21 +02:00
|
|
|
queue = 2;
|
2008-04-17 19:21:22 +02:00
|
|
|
if (acm)
|
2012-06-20 14:39:13 +02:00
|
|
|
sdata->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
|
2010-01-12 09:42:31 +01:00
|
|
|
if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
|
|
|
|
uapsd = true;
|
2007-05-05 20:45:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
params.aifs = pos[0] & 0x0f;
|
|
|
|
params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
|
|
|
|
params.cw_min = ecw2cw(pos[1] & 0x0f);
|
2008-07-10 11:22:31 +02:00
|
|
|
params.txop = get_unaligned_le16(pos + 2);
|
2010-01-12 09:42:31 +01:00
|
|
|
params.uapsd = uapsd;
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg(sdata,
|
|
|
|
"WMM queue=%d aci=%d acm=%d aifs=%d cWmin=%d cWmax=%d txop=%d uapsd=%d\n",
|
|
|
|
queue, aci, acm,
|
|
|
|
params.aifs, params.cw_min, params.cw_max,
|
|
|
|
params.txop, params.uapsd);
|
2011-09-25 19:06:54 +02:00
|
|
|
sdata->tx_conf[queue] = params;
|
|
|
|
if (drv_conf_tx(local, sdata, queue, ¶ms))
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_err(sdata,
|
|
|
|
"failed to set TX queue parameters for queue %d\n",
|
|
|
|
queue);
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
2010-03-29 12:18:34 +02:00
|
|
|
|
|
|
|
/* enable WMM or activate new settings */
|
2010-07-19 16:39:04 +02:00
|
|
|
sdata->vif.bss_conf.qos = true;
|
2012-07-06 17:37:43 +02:00
|
|
|
return true;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2012-05-16 15:27:20 +02:00
|
|
|
static void __ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&sdata->local->mtx);
|
|
|
|
|
|
|
|
sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
|
|
|
|
IEEE80211_STA_BEACON_POLL);
|
|
|
|
ieee80211_run_deferred_scan(sdata->local);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
mutex_lock(&sdata->local->mtx);
|
|
|
|
__ieee80211_stop_poll(sdata);
|
|
|
|
mutex_unlock(&sdata->local->mtx);
|
|
|
|
}
|
|
|
|
|
2008-10-08 10:59:33 +02:00
|
|
|
static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u16 capab, bool erp_valid, u8 erp)
|
2007-07-10 19:32:10 +02:00
|
|
|
{
|
2008-10-11 01:51:51 +02:00
|
|
|
struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
|
2007-12-28 14:32:58 +01:00
|
|
|
u32 changed = 0;
|
2008-10-08 10:59:33 +02:00
|
|
|
bool use_protection;
|
|
|
|
bool use_short_preamble;
|
|
|
|
bool use_short_slot;
|
|
|
|
|
|
|
|
if (erp_valid) {
|
|
|
|
use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
|
|
|
|
use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
|
|
|
|
} else {
|
|
|
|
use_protection = false;
|
|
|
|
use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
|
2012-07-26 17:24:39 +02:00
|
|
|
if (ieee80211_get_sdata_band(sdata) == IEEE80211_BAND_5GHZ)
|
2010-01-15 03:00:48 +01:00
|
|
|
use_short_slot = true;
|
2007-07-10 19:32:10 +02:00
|
|
|
|
2007-12-28 14:32:58 +01:00
|
|
|
if (use_protection != bss_conf->use_cts_prot) {
|
|
|
|
bss_conf->use_cts_prot = use_protection;
|
|
|
|
changed |= BSS_CHANGED_ERP_CTS_PROT;
|
2007-07-10 19:32:10 +02:00
|
|
|
}
|
2007-07-27 15:43:24 +02:00
|
|
|
|
2008-03-31 17:05:03 +02:00
|
|
|
if (use_short_preamble != bss_conf->use_short_preamble) {
|
|
|
|
bss_conf->use_short_preamble = use_short_preamble;
|
2007-12-28 14:32:58 +01:00
|
|
|
changed |= BSS_CHANGED_ERP_PREAMBLE;
|
2007-07-27 15:43:24 +02:00
|
|
|
}
|
2007-07-27 15:43:24 +02:00
|
|
|
|
2008-10-08 10:59:33 +02:00
|
|
|
if (use_short_slot != bss_conf->use_short_slot) {
|
|
|
|
bss_conf->use_short_slot = use_short_slot;
|
|
|
|
changed |= BSS_CHANGED_ERP_SLOT;
|
2008-04-15 20:09:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2008-08-03 02:04:37 +02:00
|
|
|
static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
|
2009-12-23 13:15:39 +01:00
|
|
|
struct cfg80211_bss *cbss,
|
2008-10-14 16:58:37 +02:00
|
|
|
u32 bss_info_changed)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-12-23 13:15:39 +01:00
|
|
|
struct ieee80211_bss *bss = (void *)cbss->priv;
|
2007-12-28 14:32:58 +01:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-06-09 12:43:26 +02:00
|
|
|
struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
|
2007-08-28 23:01:54 +02:00
|
|
|
|
2008-10-14 16:58:37 +02:00
|
|
|
bss_info_changed |= BSS_CHANGED_ASSOC;
|
2009-07-07 03:45:17 +02:00
|
|
|
bss_info_changed |= ieee80211_handle_bss_capability(sdata,
|
2012-06-20 16:23:24 +02:00
|
|
|
bss_conf->assoc_capability, bss->has_erp_value, bss->erp_value);
|
2008-03-29 00:33:34 +01:00
|
|
|
|
2010-11-19 22:55:38 +01:00
|
|
|
sdata->u.mgd.beacon_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
|
|
|
|
IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
|
|
|
|
|
2009-12-23 13:15:39 +01:00
|
|
|
sdata->u.mgd.associated = cbss;
|
|
|
|
memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2010-03-30 08:28:30 +02:00
|
|
|
sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE;
|
|
|
|
|
2012-10-29 20:08:01 +01:00
|
|
|
if (sdata->vif.p2p) {
|
|
|
|
u8 noa[2];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = cfg80211_get_p2p_attr(cbss->information_elements,
|
|
|
|
cbss->len_information_elements,
|
|
|
|
IEEE80211_P2P_ATTR_ABSENCE_NOTICE,
|
|
|
|
noa, sizeof(noa));
|
|
|
|
if (ret >= 2) {
|
|
|
|
bss_conf->p2p_oppps = noa[1] & 0x80;
|
|
|
|
bss_conf->p2p_ctwindow = noa[1] & 0x7f;
|
|
|
|
bss_info_changed |= BSS_CHANGED_P2P_PS;
|
|
|
|
sdata->u.mgd.p2p_noa_index = noa[0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
/* just to be sure */
|
2012-05-16 15:27:20 +02:00
|
|
|
ieee80211_stop_poll(sdata);
|
2009-07-10 15:29:03 +02:00
|
|
|
|
2008-09-09 10:57:09 +02:00
|
|
|
ieee80211_led_assoc(local, 1);
|
2008-05-29 10:35:23 +02:00
|
|
|
|
2010-07-29 16:08:55 +02:00
|
|
|
if (local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD)
|
|
|
|
bss_conf->dtim_period = bss->dtim_period;
|
|
|
|
else
|
|
|
|
bss_conf->dtim_period = 0;
|
|
|
|
|
2010-06-09 12:43:26 +02:00
|
|
|
bss_conf->assoc = 1;
|
2009-05-14 13:10:14 +02:00
|
|
|
|
2010-03-23 08:02:34 +01:00
|
|
|
/* Tell the driver to monitor connection quality (if supported) */
|
2012-01-19 09:29:58 +01:00
|
|
|
if (sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI &&
|
2010-06-09 12:43:26 +02:00
|
|
|
bss_conf->cqm_rssi_thold)
|
2010-03-23 08:02:34 +01:00
|
|
|
bss_info_changed |= BSS_CHANGED_CQM;
|
|
|
|
|
2010-06-09 12:43:26 +02:00
|
|
|
/* Enable ARP filtering */
|
|
|
|
if (bss_conf->arp_filter_enabled != sdata->arp_filter_state) {
|
|
|
|
bss_conf->arp_filter_enabled = sdata->arp_filter_state;
|
|
|
|
bss_info_changed |= BSS_CHANGED_ARP_FILTER;
|
|
|
|
}
|
|
|
|
|
2008-10-14 16:58:37 +02:00
|
|
|
ieee80211_bss_info_change_notify(sdata, bss_info_changed);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-07-30 21:43:55 +02:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2008-12-18 22:35:13 +01:00
|
|
|
|
2012-09-11 14:34:12 +02:00
|
|
|
ieee80211_recalc_smps(sdata);
|
2012-07-27 11:33:22 +02:00
|
|
|
ieee80211_recalc_ps_vif(sdata);
|
|
|
|
|
2010-01-06 21:39:39 +01:00
|
|
|
netif_tx_start_all_queues(sdata->dev);
|
2008-09-09 10:57:09 +02:00
|
|
|
netif_carrier_on(sdata->dev);
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2010-03-30 08:29:31 +02:00
|
|
|
static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
|
2012-02-24 13:50:54 +01:00
|
|
|
u16 stype, u16 reason, bool tx,
|
|
|
|
u8 *frame_buf)
|
2008-09-08 23:32:12 +02:00
|
|
|
{
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2008-09-08 23:32:12 +02:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sta_info *sta;
|
2012-03-09 13:12:35 +01:00
|
|
|
u32 changed = 0;
|
2008-09-08 23:32:12 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
ASSERT_MGD_MTX(ifmgd);
|
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
if (WARN_ON_ONCE(tx && !frame_buf))
|
|
|
|
return;
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
if (WARN_ON(!ifmgd->associated))
|
|
|
|
return;
|
|
|
|
|
2012-06-12 08:59:45 +02:00
|
|
|
ieee80211_stop_poll(sdata);
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
ifmgd->associated = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we need to commit the associated = NULL change because the
|
|
|
|
* scan code uses that to determine whether this iface should
|
|
|
|
* go to/wake up from powersave or not -- and could otherwise
|
|
|
|
* wake the queues erroneously.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Thus, we can only afterwards stop the queues -- to account
|
|
|
|
* for the case where another CPU is finishing a scan at this
|
|
|
|
* time -- we don't want the scan code to enable queues.
|
|
|
|
*/
|
2008-09-08 23:32:12 +02:00
|
|
|
|
2010-01-06 21:39:39 +01:00
|
|
|
netif_tx_stop_all_queues(sdata->dev);
|
2008-09-08 23:32:12 +02:00
|
|
|
netif_carrier_off(sdata->dev);
|
|
|
|
|
2010-06-10 10:21:29 +02:00
|
|
|
mutex_lock(&local->sta_mtx);
|
2012-06-01 10:14:03 +02:00
|
|
|
sta = sta_info_get(sdata, ifmgd->bssid);
|
2010-02-10 10:22:21 +01:00
|
|
|
if (sta) {
|
2011-09-29 16:04:36 +02:00
|
|
|
set_sta_flag(sta, WLAN_STA_BLOCK_BA);
|
2012-07-18 12:53:34 +02:00
|
|
|
ieee80211_sta_tear_down_BA_sessions(sta, false);
|
2010-02-10 10:22:21 +01:00
|
|
|
}
|
2010-06-10 10:21:29 +02:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2008-09-08 23:32:12 +02:00
|
|
|
|
2012-07-12 16:35:33 +02:00
|
|
|
/*
|
|
|
|
* if we want to get out of ps before disassoc (why?) we have
|
|
|
|
* to do it before sending disassoc, as otherwise the null-packet
|
|
|
|
* won't be valid.
|
|
|
|
*/
|
|
|
|
if (local->hw.conf.flags & IEEE80211_CONF_PS) {
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_PS;
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
|
|
|
|
}
|
|
|
|
local->ps_sdata = NULL;
|
|
|
|
|
2012-07-27 11:33:22 +02:00
|
|
|
/* disable per-vif ps */
|
|
|
|
ieee80211_recalc_ps_vif(sdata);
|
|
|
|
|
2012-06-27 13:18:22 +02:00
|
|
|
/* flush out any pending frame (e.g. DELBA) before deauth/disassoc */
|
|
|
|
if (tx)
|
|
|
|
drv_flush(local, false);
|
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
/* deauthenticate/disassociate now */
|
|
|
|
if (tx || frame_buf)
|
2012-06-01 10:14:03 +02:00
|
|
|
ieee80211_send_deauth_disassoc(sdata, ifmgd->bssid, stype,
|
|
|
|
reason, tx, frame_buf);
|
2012-02-24 13:50:54 +01:00
|
|
|
|
|
|
|
/* flush out frame */
|
|
|
|
if (tx)
|
|
|
|
drv_flush(local, false);
|
|
|
|
|
2012-06-01 10:14:03 +02:00
|
|
|
/* clear bssid only after building the needed mgmt frames */
|
|
|
|
memset(ifmgd->bssid, 0, ETH_ALEN);
|
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
/* remove AP and TDLS peers */
|
|
|
|
sta_info_flush(local, sdata);
|
|
|
|
|
|
|
|
/* finally reset all BSS / config parameters */
|
2008-09-08 17:33:39 +02:00
|
|
|
changed |= ieee80211_reset_erp_info(sdata);
|
|
|
|
|
|
|
|
ieee80211_led_assoc(local, 0);
|
2008-10-14 16:58:37 +02:00
|
|
|
changed |= BSS_CHANGED_ASSOC;
|
|
|
|
sdata->vif.bss_conf.assoc = false;
|
2008-09-08 17:33:39 +02:00
|
|
|
|
2012-10-29 20:08:01 +01:00
|
|
|
sdata->vif.bss_conf.p2p_ctwindow = 0;
|
|
|
|
sdata->vif.bss_conf.p2p_oppps = false;
|
|
|
|
|
2009-05-08 21:21:06 +02:00
|
|
|
/* on the next assoc, re-program HT parameters */
|
2011-11-18 20:32:00 +01:00
|
|
|
memset(&ifmgd->ht_capa, 0, sizeof(ifmgd->ht_capa));
|
|
|
|
memset(&ifmgd->ht_capa_mask, 0, sizeof(ifmgd->ht_capa_mask));
|
2009-05-08 21:21:06 +02:00
|
|
|
|
2012-10-24 10:59:25 +02:00
|
|
|
sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
|
2009-01-09 13:44:15 +01:00
|
|
|
|
2008-12-18 22:35:27 +01:00
|
|
|
del_timer_sync(&local->dynamic_ps_timer);
|
|
|
|
cancel_work_sync(&local->dynamic_ps_enable_work);
|
|
|
|
|
2010-06-09 12:43:26 +02:00
|
|
|
/* Disable ARP filtering */
|
|
|
|
if (sdata->vif.bss_conf.arp_filter_enabled) {
|
|
|
|
sdata->vif.bss_conf.arp_filter_enabled = false;
|
|
|
|
changed |= BSS_CHANGED_ARP_FILTER;
|
|
|
|
}
|
|
|
|
|
2012-03-02 15:56:59 +01:00
|
|
|
sdata->vif.bss_conf.qos = false;
|
|
|
|
changed |= BSS_CHANGED_QOS;
|
|
|
|
|
2010-05-05 15:28:27 +02:00
|
|
|
/* The BSSID (not really interesting) and HT changed */
|
|
|
|
changed |= BSS_CHANGED_BSSID | BSS_CHANGED_HT;
|
2008-10-14 16:58:37 +02:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2008-11-25 12:05:44 +01:00
|
|
|
|
2012-03-02 15:56:59 +01:00
|
|
|
/* disassociated - set to defaults now */
|
|
|
|
ieee80211_set_wmm_default(sdata, false);
|
|
|
|
|
2010-08-27 12:35:54 +02:00
|
|
|
del_timer_sync(&sdata->u.mgd.conn_mon_timer);
|
|
|
|
del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
|
|
|
|
del_timer_sync(&sdata->u.mgd.timer);
|
|
|
|
del_timer_sync(&sdata->u.mgd.chswitch_timer);
|
2012-08-01 20:54:52 +02:00
|
|
|
|
|
|
|
sdata->u.mgd.timers_running = 0;
|
2012-11-26 11:57:41 +01:00
|
|
|
|
|
|
|
ifmgd->flags = 0;
|
|
|
|
ieee80211_vif_release_channel(sdata);
|
2008-09-08 23:32:12 +02:00
|
|
|
}
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-03-22 20:57:06 +01:00
|
|
|
void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_hdr *hdr)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We can postpone the mgd.timer whenever receiving unicast frames
|
|
|
|
* from AP because we know that the connection is working both ways
|
|
|
|
* at that time. But multicast frames (and hence also beacons) must
|
|
|
|
* be ignored here, because we need to trigger the timer during
|
2009-07-10 15:29:03 +02:00
|
|
|
* data idle periods for sending the periodic probe request to the
|
|
|
|
* AP we're connected to.
|
2009-03-22 20:57:06 +01:00
|
|
|
*/
|
2009-07-10 15:29:03 +02:00
|
|
|
if (is_multicast_ether_addr(hdr->addr1))
|
|
|
|
return;
|
|
|
|
|
2010-09-16 21:12:29 +02:00
|
|
|
ieee80211_sta_reset_conn_monitor(sdata);
|
2009-03-22 20:57:06 +01:00
|
|
|
}
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2010-11-23 03:10:31 +01:00
|
|
|
static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2012-03-28 16:01:19 +02:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-11-23 03:10:31 +01:00
|
|
|
|
2012-03-28 16:01:19 +02:00
|
|
|
mutex_lock(&local->mtx);
|
2010-11-23 03:10:31 +01:00
|
|
|
if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
|
2012-03-28 16:01:19 +02:00
|
|
|
IEEE80211_STA_CONNECTION_POLL))) {
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
return;
|
|
|
|
}
|
2010-11-23 03:10:31 +01:00
|
|
|
|
2012-05-16 15:27:20 +02:00
|
|
|
__ieee80211_stop_poll(sdata);
|
2012-03-28 16:01:19 +02:00
|
|
|
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2010-11-23 03:10:31 +01:00
|
|
|
|
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
|
2012-03-28 16:01:19 +02:00
|
|
|
goto out;
|
2010-11-23 03:10:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We've received a probe response, but are not sure whether
|
|
|
|
* we have or will be receiving any beacons or data, so let's
|
|
|
|
* schedule the timers again, just in case.
|
|
|
|
*/
|
|
|
|
ieee80211_sta_reset_beacon_monitor(sdata);
|
|
|
|
|
|
|
|
mod_timer(&ifmgd->conn_mon_timer,
|
|
|
|
round_jiffies_up(jiffies +
|
|
|
|
IEEE80211_CONNECTION_IDLE_TIME));
|
2012-03-28 16:01:19 +02:00
|
|
|
out:
|
|
|
|
mutex_unlock(&local->mtx);
|
2010-11-23 03:10:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
|
2010-12-02 21:01:08 +01:00
|
|
|
struct ieee80211_hdr *hdr, bool ack)
|
2010-11-23 03:10:31 +01:00
|
|
|
{
|
2010-12-02 21:01:07 +01:00
|
|
|
if (!ieee80211_is_data(hdr->frame_control))
|
2010-11-23 03:10:31 +01:00
|
|
|
return;
|
|
|
|
|
2010-12-02 21:01:08 +01:00
|
|
|
if (ack)
|
|
|
|
ieee80211_sta_reset_conn_monitor(sdata);
|
2010-11-23 03:10:31 +01:00
|
|
|
|
|
|
|
if (ieee80211_is_nullfunc(hdr->frame_control) &&
|
|
|
|
sdata->u.mgd.probe_send_count > 0) {
|
2010-12-02 21:01:08 +01:00
|
|
|
if (ack)
|
|
|
|
sdata->u.mgd.probe_send_count = 0;
|
|
|
|
else
|
|
|
|
sdata->u.mgd.nullfunc_failed = true;
|
2010-11-23 03:10:31 +01:00
|
|
|
ieee80211_queue_work(&sdata->local->hw, &sdata->work);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-31 17:54:12 +02:00
|
|
|
static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
const u8 *ssid;
|
2010-09-16 21:12:34 +02:00
|
|
|
u8 *dst = ifmgd->associated->bssid;
|
2011-02-05 00:30:24 +01:00
|
|
|
u8 unicast_limit = max(1, max_probe_tries - 3);
|
2010-09-16 21:12:34 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Try sending broadcast probe requests for the last three
|
|
|
|
* probe requests after the first ones failed since some
|
|
|
|
* buggy APs only support broadcast probe requests.
|
|
|
|
*/
|
|
|
|
if (ifmgd->probe_send_count >= unicast_limit)
|
|
|
|
dst = NULL;
|
2009-07-31 17:54:12 +02:00
|
|
|
|
2010-11-23 03:10:31 +01:00
|
|
|
/*
|
|
|
|
* When the hardware reports an accurate Tx ACK status, it's
|
|
|
|
* better to send a nullfunc frame instead of a probe request,
|
|
|
|
* as it will kick us off the AP quickly if we aren't associated
|
|
|
|
* anymore. The timeout will be reset if the frame is ACKed by
|
|
|
|
* the AP.
|
|
|
|
*/
|
2012-05-20 12:01:13 +02:00
|
|
|
ifmgd->probe_send_count++;
|
|
|
|
|
2010-12-02 21:01:08 +01:00
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
|
|
|
|
ifmgd->nullfunc_failed = false;
|
2010-11-23 03:10:31 +01:00
|
|
|
ieee80211_send_nullfunc(sdata->local, sdata, 0);
|
2010-12-02 21:01:08 +01:00
|
|
|
} else {
|
2012-03-29 16:30:41 +02:00
|
|
|
int ssid_len;
|
|
|
|
|
2010-11-23 03:10:31 +01:00
|
|
|
ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
|
2012-03-29 16:30:41 +02:00
|
|
|
if (WARN_ON_ONCE(ssid == NULL))
|
|
|
|
ssid_len = 0;
|
|
|
|
else
|
|
|
|
ssid_len = ssid[1];
|
|
|
|
|
|
|
|
ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid_len, NULL,
|
2012-07-30 12:26:34 +02:00
|
|
|
0, (u32) -1, true, false,
|
2012-07-26 17:24:39 +02:00
|
|
|
ifmgd->associated->channel, false);
|
2010-11-23 03:10:31 +01:00
|
|
|
}
|
2009-07-31 17:54:12 +02:00
|
|
|
|
2011-02-05 00:30:24 +01:00
|
|
|
ifmgd->probe_timeout = jiffies + msecs_to_jiffies(probe_wait_ms);
|
2009-07-31 17:54:12 +02:00
|
|
|
run_again(ifmgd, ifmgd->probe_timeout);
|
2012-03-15 01:45:26 +01:00
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
|
|
|
|
drv_flush(sdata->local, false);
|
2009-07-31 17:54:12 +02:00
|
|
|
}
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool beacon)
|
2009-03-22 20:57:35 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2009-07-10 15:29:03 +02:00
|
|
|
bool already = false;
|
2009-05-12 19:58:12 +02:00
|
|
|
|
2009-12-23 13:15:31 +01:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-07-13 13:23:39 +02:00
|
|
|
return;
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
|
|
|
|
if (!ifmgd->associated)
|
|
|
|
goto out;
|
|
|
|
|
2012-03-28 16:01:19 +02:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
|
|
|
|
|
|
|
if (sdata->local->tmp_channel || sdata->local->scanning) {
|
|
|
|
mutex_unlock(&sdata->local->mtx);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-05-13 23:56:26 +02:00
|
|
|
if (beacon)
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg_ratelimited(sdata,
|
|
|
|
"detected beacon loss from AP - sending probe request\n");
|
|
|
|
|
2012-05-15 15:38:59 +02:00
|
|
|
ieee80211_cqm_rssi_notify(&sdata->vif,
|
|
|
|
NL80211_CQM_RSSI_BEACON_LOSS_EVENT, GFP_KERNEL);
|
2009-03-22 20:57:35 +01:00
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
/*
|
|
|
|
* The driver/our work has already reported this event or the
|
|
|
|
* connection monitoring has kicked in and we have already sent
|
|
|
|
* a probe request. Or maybe the AP died and the driver keeps
|
|
|
|
* reporting until we disassociate...
|
|
|
|
*
|
|
|
|
* In either case we have to ignore the current call to this
|
|
|
|
* function (except for setting the correct probe reason bit)
|
|
|
|
* because otherwise we would reset the timer every time and
|
|
|
|
* never check whether we received a probe response!
|
|
|
|
*/
|
|
|
|
if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
|
|
|
|
IEEE80211_STA_CONNECTION_POLL))
|
|
|
|
already = true;
|
|
|
|
|
|
|
|
if (beacon)
|
|
|
|
ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
|
|
|
|
else
|
|
|
|
ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
|
|
|
|
|
2012-03-28 16:01:19 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
if (already)
|
|
|
|
goto out;
|
|
|
|
|
2009-06-10 15:16:52 +02:00
|
|
|
mutex_lock(&sdata->local->iflist_mtx);
|
|
|
|
ieee80211_recalc_ps(sdata->local, -1);
|
|
|
|
mutex_unlock(&sdata->local->iflist_mtx);
|
|
|
|
|
2009-07-31 17:54:12 +02:00
|
|
|
ifmgd->probe_send_count = 0;
|
|
|
|
ieee80211_mgd_probe_ap_send(sdata);
|
2009-07-07 03:45:17 +02:00
|
|
|
out:
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2009-03-22 20:57:35 +01:00
|
|
|
}
|
|
|
|
|
2010-11-11 07:50:18 +01:00
|
|
|
struct sk_buff *ieee80211_ap_probereq_get(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2012-06-28 14:03:13 +02:00
|
|
|
struct cfg80211_bss *cbss;
|
2010-11-11 07:50:18 +01:00
|
|
|
struct sk_buff *skb;
|
|
|
|
const u8 *ssid;
|
2012-03-29 16:30:41 +02:00
|
|
|
int ssid_len;
|
2010-11-11 07:50:18 +01:00
|
|
|
|
|
|
|
if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ASSERT_MGD_MTX(ifmgd);
|
|
|
|
|
2012-06-28 14:03:13 +02:00
|
|
|
if (ifmgd->associated)
|
|
|
|
cbss = ifmgd->associated;
|
|
|
|
else if (ifmgd->auth_data)
|
|
|
|
cbss = ifmgd->auth_data->bss;
|
|
|
|
else if (ifmgd->assoc_data)
|
|
|
|
cbss = ifmgd->assoc_data->bss;
|
|
|
|
else
|
2010-11-11 07:50:18 +01:00
|
|
|
return NULL;
|
|
|
|
|
2012-06-28 14:03:13 +02:00
|
|
|
ssid = ieee80211_bss_get_ie(cbss, WLAN_EID_SSID);
|
2012-03-29 16:30:41 +02:00
|
|
|
if (WARN_ON_ONCE(ssid == NULL))
|
|
|
|
ssid_len = 0;
|
|
|
|
else
|
|
|
|
ssid_len = ssid[1];
|
|
|
|
|
2012-06-28 14:03:13 +02:00
|
|
|
skb = ieee80211_build_probe_req(sdata, cbss->bssid,
|
2012-07-26 17:24:39 +02:00
|
|
|
(u32) -1, cbss->channel,
|
2012-07-23 14:53:27 +02:00
|
|
|
ssid + 2, ssid_len,
|
2011-07-18 18:08:36 +02:00
|
|
|
NULL, 0, true);
|
2010-11-11 07:50:18 +01:00
|
|
|
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_ap_probereq_get);
|
|
|
|
|
2012-08-01 22:32:45 +02:00
|
|
|
static void __ieee80211_disconnect(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool transmit_frame)
|
2010-03-19 06:14:53 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2012-09-07 13:28:52 +02:00
|
|
|
u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
|
2010-03-19 06:14:53 +01:00
|
|
|
|
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
if (!ifmgd->associated) {
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
|
|
|
|
WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
|
2012-08-01 22:32:45 +02:00
|
|
|
transmit_frame, frame_buf);
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
|
2010-03-19 06:14:53 +01:00
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2010-08-05 17:02:38 +02:00
|
|
|
|
2010-03-19 06:14:53 +01:00
|
|
|
/*
|
|
|
|
* must be outside lock due to cfg80211,
|
|
|
|
* but that's not a problem.
|
|
|
|
*/
|
2012-09-07 13:28:52 +02:00
|
|
|
cfg80211_send_deauth(sdata->dev, frame_buf, IEEE80211_DEAUTH_FRAME_LEN);
|
2011-11-16 13:34:55 +01:00
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
2010-03-19 06:14:53 +01:00
|
|
|
}
|
|
|
|
|
2012-08-01 16:49:34 +02:00
|
|
|
static void ieee80211_beacon_connection_loss_work(struct work_struct *work)
|
2009-07-10 15:29:03 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data,
|
2010-03-19 06:14:53 +01:00
|
|
|
u.mgd.beacon_connection_loss_work);
|
2011-12-09 20:01:49 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
if (ifmgd->associated) {
|
2011-12-27 14:24:07 +01:00
|
|
|
rcu_read_lock();
|
2011-12-09 20:01:49 +01:00
|
|
|
sta = sta_info_get(sdata, ifmgd->bssid);
|
|
|
|
if (sta)
|
|
|
|
sta->beacon_loss_count++;
|
2011-12-27 14:24:07 +01:00
|
|
|
rcu_read_unlock();
|
2011-12-09 20:01:49 +01:00
|
|
|
}
|
2009-07-10 15:29:03 +02:00
|
|
|
|
2012-08-01 22:32:45 +02:00
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR) {
|
|
|
|
sdata_info(sdata, "Connection to AP %pM lost\n",
|
|
|
|
ifmgd->bssid);
|
|
|
|
__ieee80211_disconnect(sdata, false);
|
|
|
|
} else {
|
2010-03-19 06:14:53 +01:00
|
|
|
ieee80211_mgd_probe_ap(sdata, true);
|
2012-08-01 22:32:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_csa_connection_drop_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data,
|
|
|
|
u.mgd.csa_connection_drop_work);
|
|
|
|
|
|
|
|
ieee80211_wake_queues_by_reason(&sdata->local->hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_CSA);
|
|
|
|
__ieee80211_disconnect(sdata, true);
|
2009-07-10 15:29:03 +02:00
|
|
|
}
|
|
|
|
|
2009-03-22 20:57:35 +01:00
|
|
|
void ieee80211_beacon_loss(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
2010-03-19 06:14:53 +01:00
|
|
|
struct ieee80211_hw *hw = &sdata->local->hw;
|
2009-03-22 20:57:35 +01:00
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_beacon_loss(sdata);
|
|
|
|
|
2010-03-19 06:14:53 +01:00
|
|
|
WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR);
|
|
|
|
ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
|
2009-03-22 20:57:35 +01:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_beacon_loss);
|
|
|
|
|
2010-03-19 06:14:53 +01:00
|
|
|
void ieee80211_connection_loss(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_hw *hw = &sdata->local->hw;
|
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_connection_loss(sdata);
|
|
|
|
|
2010-03-19 06:14:53 +01:00
|
|
|
WARN_ON(!(hw->flags & IEEE80211_HW_CONNECTION_MONITOR));
|
|
|
|
ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_connection_loss);
|
|
|
|
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
static void ieee80211_destroy_auth_data(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool assoc)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
|
|
|
|
|
|
|
|
lockdep_assert_held(&sdata->u.mgd.mtx);
|
|
|
|
|
|
|
|
if (!assoc) {
|
|
|
|
sta_info_destroy_addr(sdata, auth_data->bss->bssid);
|
|
|
|
|
|
|
|
memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
|
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
|
2012-11-26 11:57:41 +01:00
|
|
|
sdata->u.mgd.flags = 0;
|
2012-07-26 17:24:39 +02:00
|
|
|
ieee80211_vif_release_channel(sdata);
|
2012-01-20 13:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
cfg80211_put_bss(auth_data->bss);
|
|
|
|
kfree(auth_data);
|
|
|
|
sdata->u.mgd.auth_data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
|
|
|
|
u8 *pos;
|
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
|
|
|
|
pos = mgmt->u.auth.variable;
|
|
|
|
ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
|
|
|
|
if (!elems.challenge)
|
|
|
|
return;
|
|
|
|
auth_data->expected_transaction = 4;
|
2012-06-27 13:18:36 +02:00
|
|
|
drv_mgd_prepare_tx(sdata->local, sdata);
|
2012-09-30 18:29:37 +02:00
|
|
|
ieee80211_send_auth(sdata, 3, auth_data->algorithm, 0,
|
2012-01-20 13:55:27 +01:00
|
|
|
elems.challenge - 2, elems.challenge_len + 2,
|
|
|
|
auth_data->bss->bssid, auth_data->bss->bssid,
|
|
|
|
auth_data->key, auth_data->key_len,
|
|
|
|
auth_data->key_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum rx_mgmt_action __must_check
|
|
|
|
ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
u16 auth_alg, auth_transaction, status_code;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
|
|
|
|
|
|
|
if (len < 24 + 6)
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
|
|
|
|
if (!ifmgd->auth_data || ifmgd->auth_data->done)
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
|
|
|
|
memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
|
|
|
|
|
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 20:56:52 +02:00
|
|
|
if (!ether_addr_equal(bssid, mgmt->bssid))
|
2012-01-20 13:55:27 +01:00
|
|
|
return RX_MGMT_NONE;
|
|
|
|
|
|
|
|
auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
|
|
|
|
auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
|
|
|
|
status_code = le16_to_cpu(mgmt->u.auth.status_code);
|
|
|
|
|
|
|
|
if (auth_alg != ifmgd->auth_data->algorithm ||
|
2012-09-30 18:29:38 +02:00
|
|
|
auth_transaction != ifmgd->auth_data->expected_transaction) {
|
|
|
|
sdata_info(sdata, "%pM unexpected authentication state: alg %d (expected %d) transact %d (expected %d)\n",
|
|
|
|
mgmt->sa, auth_alg, ifmgd->auth_data->algorithm,
|
|
|
|
auth_transaction,
|
|
|
|
ifmgd->auth_data->expected_transaction);
|
2012-01-20 13:55:27 +01:00
|
|
|
return RX_MGMT_NONE;
|
2012-09-30 18:29:38 +02:00
|
|
|
}
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
if (status_code != WLAN_STATUS_SUCCESS) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "%pM denied authentication (status %d)\n",
|
|
|
|
mgmt->sa, status_code);
|
2012-05-13 17:07:04 +02:00
|
|
|
ieee80211_destroy_auth_data(sdata, false);
|
|
|
|
return RX_MGMT_CFG80211_RX_AUTH;
|
2012-01-20 13:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (ifmgd->auth_data->algorithm) {
|
|
|
|
case WLAN_AUTH_OPEN:
|
|
|
|
case WLAN_AUTH_LEAP:
|
|
|
|
case WLAN_AUTH_FT:
|
2012-09-30 18:29:40 +02:00
|
|
|
case WLAN_AUTH_SAE:
|
2012-01-20 13:55:27 +01:00
|
|
|
break;
|
|
|
|
case WLAN_AUTH_SHARED_KEY:
|
|
|
|
if (ifmgd->auth_data->expected_transaction != 4) {
|
|
|
|
ieee80211_auth_challenge(sdata, mgmt, len);
|
|
|
|
/* need another frame */
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ONCE(1, "invalid auth alg %d",
|
|
|
|
ifmgd->auth_data->algorithm);
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
}
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "authenticated\n");
|
2012-01-20 13:55:27 +01:00
|
|
|
ifmgd->auth_data->done = true;
|
|
|
|
ifmgd->auth_data->timeout = jiffies + IEEE80211_AUTH_WAIT_ASSOC;
|
|
|
|
run_again(ifmgd, ifmgd->auth_data->timeout);
|
|
|
|
|
2012-09-30 18:29:40 +02:00
|
|
|
if (ifmgd->auth_data->algorithm == WLAN_AUTH_SAE &&
|
|
|
|
ifmgd->auth_data->expected_transaction != 2) {
|
|
|
|
/*
|
|
|
|
* Report auth frame to user space for processing since another
|
|
|
|
* round of Authentication frames is still needed.
|
|
|
|
*/
|
|
|
|
return RX_MGMT_CFG80211_RX_AUTH;
|
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* move station state to auth */
|
|
|
|
mutex_lock(&sdata->local->sta_mtx);
|
|
|
|
sta = sta_info_get(sdata, bssid);
|
|
|
|
if (!sta) {
|
|
|
|
WARN_ONCE(1, "%s: STA %pM not found", sdata->name, bssid);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
if (sta_info_move_state(sta, IEEE80211_STA_AUTH)) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "failed moving %pM to auth\n", bssid);
|
2012-01-20 13:55:27 +01:00
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
|
|
|
|
|
|
|
return RX_MGMT_CFG80211_RX_AUTH;
|
|
|
|
out_err:
|
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
|
|
|
/* ignore frame -- wait for timeout */
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
static enum rx_mgmt_action __must_check
|
|
|
|
ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2009-07-07 03:45:17 +02:00
|
|
|
const u8 *bssid = NULL;
|
2007-05-05 20:45:53 +02:00
|
|
|
u16 reason_code;
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
|
|
|
|
2008-06-30 15:10:46 +02:00
|
|
|
if (len < 24 + 2)
|
2009-07-07 03:45:17 +02:00
|
|
|
return RX_MGMT_NONE;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (!ifmgd->associated ||
|
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 20:56:52 +02:00
|
|
|
!ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
|
2012-01-20 13:55:27 +01:00
|
|
|
return RX_MGMT_NONE;
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2009-12-23 13:15:39 +01:00
|
|
|
bssid = ifmgd->associated->bssid;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
|
|
|
reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "deauthenticated from %pM (Reason: %u)\n",
|
|
|
|
bssid, reason_code);
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
|
|
|
|
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
2009-12-23 13:15:33 +01:00
|
|
|
ieee80211_recalc_idle(sdata->local);
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
return RX_MGMT_CFG80211_DEAUTH;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
static enum rx_mgmt_action __must_check
|
|
|
|
ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2007-05-05 20:45:53 +02:00
|
|
|
u16 reason_code;
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (len < 24 + 2)
|
2009-07-07 03:45:17 +02:00
|
|
|
return RX_MGMT_NONE;
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (!ifmgd->associated ||
|
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 20:56:52 +02:00
|
|
|
!ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
|
2009-07-07 03:45:17 +02:00
|
|
|
return RX_MGMT_NONE;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
|
|
|
reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "disassociated from %pM (Reason: %u)\n",
|
|
|
|
mgmt->sa, reason_code);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
|
|
|
|
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
2009-11-29 12:19:06 +01:00
|
|
|
ieee80211_recalc_idle(sdata->local);
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2012-02-24 13:50:54 +01:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
return RX_MGMT_CFG80211_DISASSOC;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2011-10-15 00:14:49 +02:00
|
|
|
static void ieee80211_get_rates(struct ieee80211_supported_band *sband,
|
|
|
|
u8 *supp_rates, unsigned int supp_rates_len,
|
|
|
|
u32 *rates, u32 *basic_rates,
|
|
|
|
bool *have_higher_than_11mbit,
|
|
|
|
int *min_rate, int *min_rate_index)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0; i < supp_rates_len; i++) {
|
|
|
|
int rate = (supp_rates[i] & 0x7f) * 5;
|
|
|
|
bool is_basic = !!(supp_rates[i] & 0x80);
|
|
|
|
|
|
|
|
if (rate > 110)
|
|
|
|
*have_higher_than_11mbit = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* BSS_MEMBERSHIP_SELECTOR_HT_PHY is defined in 802.11n-2009
|
|
|
|
* 7.3.2.2 as a magic value instead of a rate. Hence, skip it.
|
|
|
|
*
|
|
|
|
* Note: Even through the membership selector and the basic
|
|
|
|
* rate flag share the same bit, they are not exactly
|
|
|
|
* the same.
|
|
|
|
*/
|
|
|
|
if (!!(supp_rates[i] & 0x80) &&
|
|
|
|
(supp_rates[i] & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; j < sband->n_bitrates; j++) {
|
|
|
|
if (sband->bitrates[j].bitrate == rate) {
|
|
|
|
*rates |= BIT(j);
|
|
|
|
if (is_basic)
|
|
|
|
*basic_rates |= BIT(j);
|
|
|
|
if (rate < *min_rate) {
|
|
|
|
*min_rate = rate;
|
|
|
|
*min_rate_index = j;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
static void ieee80211_destroy_assoc_data(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool assoc)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
|
|
|
|
|
|
|
|
lockdep_assert_held(&sdata->u.mgd.mtx);
|
|
|
|
|
|
|
|
if (!assoc) {
|
|
|
|
sta_info_destroy_addr(sdata, assoc_data->bss->bssid);
|
|
|
|
|
|
|
|
memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
|
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
|
2012-11-26 11:57:41 +01:00
|
|
|
sdata->u.mgd.flags = 0;
|
2012-07-26 17:24:39 +02:00
|
|
|
ieee80211_vif_release_channel(sdata);
|
2012-01-20 13:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(assoc_data);
|
|
|
|
sdata->u.mgd.assoc_data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool ieee80211_assoc_success(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_bss *cbss,
|
2009-12-23 13:15:35 +01:00
|
|
|
struct ieee80211_mgmt *mgmt, size_t len)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2007-12-28 14:32:58 +01:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2008-01-24 19:38:38 +01:00
|
|
|
struct ieee80211_supported_band *sband;
|
2007-05-05 20:45:53 +02:00
|
|
|
struct sta_info *sta;
|
2009-12-23 13:15:35 +01:00
|
|
|
u8 *pos;
|
|
|
|
u16 capab_info, aid;
|
2007-05-05 20:45:53 +02:00
|
|
|
struct ieee802_11_elems elems;
|
2008-10-11 01:51:51 +02:00
|
|
|
struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
|
2008-10-14 16:58:37 +02:00
|
|
|
u32 changed = 0;
|
2011-10-15 00:14:49 +02:00
|
|
|
int err;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-12-23 13:15:35 +01:00
|
|
|
/* AssocResp and ReassocResp have identical structure */
|
2007-05-05 20:45:53 +02:00
|
|
|
|
|
|
|
aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
|
2009-12-23 13:15:35 +01:00
|
|
|
capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2007-10-10 12:03:41 +02:00
|
|
|
if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "invalid AID value 0x%x; bits 15:14 not set\n",
|
|
|
|
aid);
|
2007-10-10 12:03:41 +02:00
|
|
|
aid &= ~(BIT(15) | BIT(14));
|
|
|
|
|
2011-10-28 11:59:47 +02:00
|
|
|
ifmgd->broken_ap = false;
|
|
|
|
|
|
|
|
if (aid == 0 || aid > IEEE80211_MAX_AID) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "invalid AID value %d (out of range), turn off PS\n",
|
|
|
|
aid);
|
2011-10-28 11:59:47 +02:00
|
|
|
aid = 0;
|
|
|
|
ifmgd->broken_ap = true;
|
|
|
|
}
|
|
|
|
|
2009-12-23 13:15:35 +01:00
|
|
|
pos = mgmt->u.assoc_resp.variable;
|
|
|
|
ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
|
|
|
|
|
2007-05-05 20:45:53 +02:00
|
|
|
if (!elems.supp_rates) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "no SuppRates element in AssocResp\n");
|
2009-12-23 13:15:35 +01:00
|
|
|
return false;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2009-02-15 12:44:28 +01:00
|
|
|
ifmgd->aid = aid;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2011-08-17 14:18:15 +02:00
|
|
|
mutex_lock(&sdata->local->sta_mtx);
|
|
|
|
/*
|
|
|
|
* station info was already allocated and inserted before
|
|
|
|
* the association and should be available to us
|
|
|
|
*/
|
2012-01-20 13:55:24 +01:00
|
|
|
sta = sta_info_get(sdata, cbss->bssid);
|
2011-08-17 14:18:15 +02:00
|
|
|
if (WARN_ON(!sta)) {
|
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
2009-12-23 13:15:35 +01:00
|
|
|
return false;
|
2009-07-07 03:45:17 +02:00
|
|
|
}
|
2008-04-01 01:00:13 +02:00
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
sband = local->hw.wiphy->bands[ieee80211_get_sdata_band(sdata)];
|
2008-02-23 15:17:12 +01:00
|
|
|
|
2012-11-22 14:32:09 +01:00
|
|
|
if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_HT))
|
2011-11-18 20:32:00 +01:00
|
|
|
ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
|
2008-10-09 12:13:49 +02:00
|
|
|
elems.ht_cap_elem, &sta->sta.ht_cap);
|
2008-10-14 16:58:37 +02:00
|
|
|
|
2012-03-28 10:58:37 +02:00
|
|
|
sta->supports_40mhz =
|
|
|
|
sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40;
|
|
|
|
|
2012-10-10 13:33:04 +02:00
|
|
|
if (elems.vht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
|
|
|
|
ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
|
|
|
|
elems.vht_cap_elem,
|
|
|
|
&sta->sta.vht_cap);
|
|
|
|
|
2008-09-18 18:14:18 +02:00
|
|
|
rate_control_rate_init(sta);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-02-15 12:44:28 +01:00
|
|
|
if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
|
2011-09-29 16:04:36 +02:00
|
|
|
set_sta_flag(sta, WLAN_STA_MFP);
|
2009-01-08 12:31:59 +01:00
|
|
|
|
2008-10-22 11:41:38 +02:00
|
|
|
if (elems.wmm_param)
|
2011-09-29 16:04:36 +02:00
|
|
|
set_sta_flag(sta, WLAN_STA_WME);
|
2008-10-22 11:41:38 +02:00
|
|
|
|
2012-01-20 13:55:17 +01:00
|
|
|
err = sta_info_move_state(sta, IEEE80211_STA_AUTH);
|
|
|
|
if (!err)
|
|
|
|
err = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
|
|
|
|
if (!err && !(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
|
|
|
|
err = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
|
|
|
|
if (err) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"failed to move station %pM to desired state\n",
|
|
|
|
sta->sta.addr);
|
2012-01-20 13:55:17 +01:00
|
|
|
WARN_ON(__sta_info_destroy(sta));
|
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:24 +01:00
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
2008-10-22 11:41:38 +02:00
|
|
|
|
2010-09-28 13:39:32 +02:00
|
|
|
/*
|
|
|
|
* Always handle WMM once after association regardless
|
|
|
|
* of the first value the AP uses. Setting -1 here has
|
|
|
|
* that effect because the AP values is an unsigned
|
|
|
|
* 4-bit value.
|
|
|
|
*/
|
|
|
|
ifmgd->wmm_last_param_set = -1;
|
|
|
|
|
2008-10-22 11:41:38 +02:00
|
|
|
if (elems.wmm_param)
|
2010-07-19 16:39:04 +02:00
|
|
|
ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
|
2008-09-08 17:44:22 +02:00
|
|
|
elems.wmm_param_len);
|
2009-05-07 16:16:24 +02:00
|
|
|
else
|
2012-03-02 15:56:59 +01:00
|
|
|
ieee80211_set_wmm_default(sdata, false);
|
|
|
|
changed |= BSS_CHANGED_QOS;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-03-15 19:45:16 +01:00
|
|
|
if (elems.ht_operation && elems.wmm_param &&
|
2012-11-22 14:32:09 +01:00
|
|
|
!(ifmgd->flags & IEEE80211_STA_DISABLE_HT))
|
2012-03-28 10:58:36 +02:00
|
|
|
changed |= ieee80211_config_ht_tx(sdata, elems.ht_operation,
|
|
|
|
cbss->bssid, false);
|
2008-10-14 16:58:37 +02:00
|
|
|
|
2008-09-08 17:44:22 +02:00
|
|
|
/* set AID and assoc capability,
|
|
|
|
* ieee80211_set_associated() will tell the driver */
|
|
|
|
bss_conf->aid = aid;
|
|
|
|
bss_conf->assoc_capability = capab_info;
|
2009-12-23 13:15:39 +01:00
|
|
|
ieee80211_set_associated(sdata, cbss, changed);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2010-01-08 18:06:26 +01:00
|
|
|
/*
|
|
|
|
* If we're using 4-addr mode, let the AP know that we're
|
|
|
|
* doing so, so that it can create the STA VLAN on its side
|
|
|
|
*/
|
|
|
|
if (ifmgd->use_4addr)
|
|
|
|
ieee80211_send_4addr_nullfunc(local, sdata);
|
|
|
|
|
2009-03-22 20:57:14 +01:00
|
|
|
/*
|
2009-07-10 15:29:03 +02:00
|
|
|
* Start timer to probe the connection to the AP now.
|
|
|
|
* Also start the timer that will detect beacon loss.
|
2009-03-22 20:57:14 +01:00
|
|
|
*/
|
2009-07-10 15:29:03 +02:00
|
|
|
ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
|
2010-09-16 21:12:32 +02:00
|
|
|
ieee80211_sta_reset_beacon_monitor(sdata);
|
2009-03-22 20:57:14 +01:00
|
|
|
|
2009-12-23 13:15:35 +01:00
|
|
|
return true;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
static enum rx_mgmt_action __must_check
|
|
|
|
ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len,
|
|
|
|
struct cfg80211_bss **bss)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
|
|
|
|
u16 capab_info, status_code, aid;
|
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
u8 *pos;
|
|
|
|
bool reassoc;
|
|
|
|
|
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
|
|
|
|
|
|
|
if (!assoc_data)
|
|
|
|
return RX_MGMT_NONE;
|
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 20:56:52 +02:00
|
|
|
if (!ether_addr_equal(assoc_data->bss->bssid, mgmt->bssid))
|
2012-01-20 13:55:27 +01:00
|
|
|
return RX_MGMT_NONE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AssocResp and ReassocResp have identical structure, so process both
|
|
|
|
* of them in this function.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (len < 24 + 6)
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
|
|
|
|
reassoc = ieee80211_is_reassoc_req(mgmt->frame_control);
|
|
|
|
capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
|
|
|
|
status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
|
|
|
|
aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"RX %sssocResp from %pM (capab=0x%x status=%d aid=%d)\n",
|
|
|
|
reassoc ? "Rea" : "A", mgmt->sa,
|
|
|
|
capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
pos = mgmt->u.assoc_resp.variable;
|
|
|
|
ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
|
|
|
|
|
|
|
|
if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
|
|
|
|
elems.timeout_int && elems.timeout_int_len == 5 &&
|
|
|
|
elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
|
|
|
|
u32 tu, ms;
|
|
|
|
tu = get_unaligned_le32(elems.timeout_int + 1);
|
|
|
|
ms = tu * 1024 / 1000;
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"%pM rejected association temporarily; comeback duration %u TU (%u ms)\n",
|
|
|
|
mgmt->sa, tu, ms);
|
2012-01-20 13:55:27 +01:00
|
|
|
assoc_data->timeout = jiffies + msecs_to_jiffies(ms);
|
|
|
|
if (ms > IEEE80211_ASSOC_TIMEOUT)
|
|
|
|
run_again(ifmgd, assoc_data->timeout);
|
|
|
|
return RX_MGMT_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*bss = assoc_data->bss;
|
|
|
|
|
|
|
|
if (status_code != WLAN_STATUS_SUCCESS) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "%pM denied association (code=%d)\n",
|
|
|
|
mgmt->sa, status_code);
|
2012-01-20 13:55:27 +01:00
|
|
|
ieee80211_destroy_assoc_data(sdata, false);
|
|
|
|
} else {
|
|
|
|
if (!ieee80211_assoc_success(sdata, *bss, mgmt, len)) {
|
|
|
|
/* oops -- internal error -- send timeout for now */
|
2012-07-02 13:42:03 +02:00
|
|
|
ieee80211_destroy_assoc_data(sdata, false);
|
2012-01-20 13:55:27 +01:00
|
|
|
cfg80211_put_bss(*bss);
|
|
|
|
return RX_MGMT_CFG80211_ASSOC_TIMEOUT;
|
|
|
|
}
|
2012-07-09 22:34:34 +02:00
|
|
|
sdata_info(sdata, "associated\n");
|
2012-02-20 14:19:58 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* destroy assoc_data afterwards, as otherwise an idle
|
|
|
|
* recalc after assoc_data is NULL but before associated
|
|
|
|
* is set can cause the interface to go idle
|
|
|
|
*/
|
|
|
|
ieee80211_destroy_assoc_data(sdata, true);
|
2012-01-20 13:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return RX_MGMT_CFG80211_RX_ASSOC;
|
|
|
|
}
|
2008-09-08 17:44:26 +02:00
|
|
|
static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len,
|
|
|
|
struct ieee80211_rx_status *rx_status,
|
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
bool beacon)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int freq;
|
2008-09-11 00:01:55 +02:00
|
|
|
struct ieee80211_bss *bss;
|
2008-09-08 17:44:26 +02:00
|
|
|
struct ieee80211_channel *channel;
|
2010-01-26 14:19:52 +01:00
|
|
|
bool need_ps = false;
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (sdata->u.mgd.associated &&
|
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 20:56:52 +02:00
|
|
|
ether_addr_equal(mgmt->bssid, sdata->u.mgd.associated->bssid)) {
|
2010-01-26 14:19:52 +01:00
|
|
|
bss = (void *)sdata->u.mgd.associated->priv;
|
|
|
|
/* not previously set so we may need to recalc */
|
|
|
|
need_ps = !bss->dtim_period;
|
|
|
|
}
|
2008-09-08 17:44:26 +02:00
|
|
|
|
|
|
|
if (elems->ds_params && elems->ds_params_len == 1)
|
2011-01-17 05:37:28 +01:00
|
|
|
freq = ieee80211_channel_to_frequency(elems->ds_params[0],
|
|
|
|
rx_status->band);
|
2008-09-08 17:44:26 +02:00
|
|
|
else
|
|
|
|
freq = rx_status->freq;
|
|
|
|
|
|
|
|
channel = ieee80211_get_channel(local->hw.wiphy, freq);
|
|
|
|
|
|
|
|
if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
|
2009-02-10 21:25:55 +01:00
|
|
|
channel, beacon);
|
2009-07-07 03:45:17 +02:00
|
|
|
if (bss)
|
|
|
|
ieee80211_rx_bss_put(local, bss);
|
|
|
|
|
|
|
|
if (!sdata->u.mgd.associated)
|
2008-09-08 17:44:26 +02:00
|
|
|
return;
|
|
|
|
|
2010-01-26 14:19:52 +01:00
|
|
|
if (need_ps) {
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
}
|
|
|
|
|
2012-08-01 16:13:02 +02:00
|
|
|
if (elems->ch_switch_ie &&
|
|
|
|
memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid, ETH_ALEN) == 0)
|
|
|
|
ieee80211_sta_process_chanswitch(sdata, elems->ch_switch_ie,
|
2010-05-11 16:20:57 +02:00
|
|
|
bss, rx_status->mactime);
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-08-03 02:04:37 +02:00
|
|
|
static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
|
2009-12-23 13:15:35 +01:00
|
|
|
struct sk_buff *skb)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-12-23 13:15:35 +01:00
|
|
|
struct ieee80211_mgmt *mgmt = (void *)skb->data;
|
2009-03-22 20:57:14 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd;
|
2009-12-23 13:15:35 +01:00
|
|
|
struct ieee80211_rx_status *rx_status = (void *) skb->cb;
|
|
|
|
size_t baselen, len = skb->len;
|
2008-06-27 17:54:48 +02:00
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
|
2009-03-22 20:57:14 +01:00
|
|
|
ifmgd = &sdata->u.mgd;
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
ASSERT_MGD_MTX(ifmgd);
|
|
|
|
|
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 20:56:52 +02:00
|
|
|
if (!ether_addr_equal(mgmt->da, sdata->vif.addr))
|
2008-08-03 13:32:01 +02:00
|
|
|
return; /* ignore ProbeResp to foreign address */
|
|
|
|
|
2008-06-27 17:54:48 +02:00
|
|
|
baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
|
|
|
|
if (baselen > len)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
|
|
|
|
&elems);
|
|
|
|
|
2008-09-08 17:44:26 +02:00
|
|
|
ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
|
2008-08-09 02:02:19 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
if (ifmgd->associated &&
|
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 20:56:52 +02:00
|
|
|
ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
|
2010-11-23 03:10:31 +01:00
|
|
|
ieee80211_reset_ap_probe(sdata);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
if (ifmgd->auth_data && !ifmgd->auth_data->bss->proberesp_ies &&
|
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 20:56:52 +02:00
|
|
|
ether_addr_equal(mgmt->bssid, ifmgd->auth_data->bss->bssid)) {
|
2012-01-20 13:55:27 +01:00
|
|
|
/* got probe response, continue with auth */
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "direct probe responded\n");
|
2012-01-20 13:55:27 +01:00
|
|
|
ifmgd->auth_data->tries = 0;
|
|
|
|
ifmgd->auth_data->timeout = jiffies;
|
|
|
|
run_again(ifmgd, ifmgd->auth_data->timeout);
|
|
|
|
}
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 13:17:26 +02:00
|
|
|
/*
|
|
|
|
* This is the canonical list of information elements we care about,
|
|
|
|
* the filter code also gives us all changes to the Microsoft OUI
|
|
|
|
* (00:50:F2) vendor IE which is used for WMM which we need to track.
|
|
|
|
*
|
|
|
|
* We implement beacon filtering in software since that means we can
|
|
|
|
* avoid processing the frame here and in cfg80211, and userspace
|
|
|
|
* will not be able to tell whether the hardware supports it or not.
|
|
|
|
*
|
|
|
|
* XXX: This list needs to be dynamic -- userspace needs to be able to
|
|
|
|
* add items it requires. It also needs to be able to tell us to
|
|
|
|
* look out for other vendor IEs.
|
|
|
|
*/
|
|
|
|
static const u64 care_about_ies =
|
2009-04-22 11:25:43 +02:00
|
|
|
(1ULL << WLAN_EID_COUNTRY) |
|
|
|
|
(1ULL << WLAN_EID_ERP_INFO) |
|
|
|
|
(1ULL << WLAN_EID_CHANNEL_SWITCH) |
|
|
|
|
(1ULL << WLAN_EID_PWR_CONSTRAINT) |
|
|
|
|
(1ULL << WLAN_EID_HT_CAPABILITY) |
|
2012-03-15 19:45:16 +01:00
|
|
|
(1ULL << WLAN_EID_HT_OPERATION);
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 13:17:26 +02:00
|
|
|
|
2008-08-03 02:04:37 +02:00
|
|
|
static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
|
2007-05-05 20:45:53 +02:00
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len,
|
|
|
|
struct ieee80211_rx_status *rx_status)
|
|
|
|
{
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 13:17:26 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2010-03-30 08:28:30 +02:00
|
|
|
struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
|
2007-05-05 20:45:53 +02:00
|
|
|
size_t baselen;
|
|
|
|
struct ieee802_11_elems elems;
|
2008-08-03 02:04:37 +02:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2012-07-26 17:24:39 +02:00
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_channel *chan;
|
2007-12-28 14:32:58 +01:00
|
|
|
u32 changed = 0;
|
2012-10-25 10:16:23 +02:00
|
|
|
bool erp_valid;
|
2008-10-08 10:59:33 +02:00
|
|
|
u8 erp_value = 0;
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 13:17:26 +02:00
|
|
|
u32 ncrc;
|
2009-07-07 03:45:17 +02:00
|
|
|
u8 *bssid;
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2008-06-27 17:54:48 +02:00
|
|
|
/* Process beacon from the current BSS */
|
|
|
|
baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
|
|
|
|
if (baselen > len)
|
|
|
|
return;
|
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
if (!chanctx_conf) {
|
|
|
|
rcu_read_unlock();
|
2007-05-05 20:45:53 +02:00
|
|
|
return;
|
2012-07-26 17:24:39 +02:00
|
|
|
}
|
|
|
|
|
2012-11-09 11:39:59 +01:00
|
|
|
if (rx_status->freq != chanctx_conf->def.chan->center_freq) {
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
2012-11-09 11:39:59 +01:00
|
|
|
chan = chanctx_conf->def.chan;
|
2012-07-26 17:24:39 +02:00
|
|
|
rcu_read_unlock();
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->assoc_data && !ifmgd->assoc_data->have_beacon &&
|
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 20:56:52 +02:00
|
|
|
ether_addr_equal(mgmt->bssid, ifmgd->assoc_data->bss->bssid)) {
|
2012-01-20 13:55:27 +01:00
|
|
|
ieee802_11_parse_elems(mgmt->u.beacon.variable,
|
|
|
|
len - baselen, &elems);
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
|
|
|
|
false);
|
|
|
|
ifmgd->assoc_data->have_beacon = true;
|
|
|
|
ifmgd->assoc_data->sent_assoc = false;
|
|
|
|
/* continue assoc process */
|
|
|
|
ifmgd->assoc_data->timeout = jiffies;
|
|
|
|
run_again(ifmgd, ifmgd->assoc_data->timeout);
|
|
|
|
return;
|
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (!ifmgd->associated ||
|
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 20:56:52 +02:00
|
|
|
!ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
|
2007-05-05 20:45:53 +02:00
|
|
|
return;
|
2012-01-20 13:55:27 +01:00
|
|
|
bssid = ifmgd->associated->bssid;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2010-03-30 08:28:30 +02:00
|
|
|
/* Track average RSSI from the Beacon frames of the current AP */
|
|
|
|
ifmgd->last_beacon_signal = rx_status->signal;
|
|
|
|
if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) {
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE;
|
2010-08-27 21:21:13 +02:00
|
|
|
ifmgd->ave_beacon_signal = rx_status->signal * 16;
|
2010-03-30 08:28:30 +02:00
|
|
|
ifmgd->last_cqm_event_signal = 0;
|
2010-08-27 21:22:00 +02:00
|
|
|
ifmgd->count_beacon_signal = 1;
|
2011-07-08 17:46:22 +02:00
|
|
|
ifmgd->last_ave_beacon_signal = 0;
|
2010-03-30 08:28:30 +02:00
|
|
|
} else {
|
|
|
|
ifmgd->ave_beacon_signal =
|
|
|
|
(IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
|
|
|
|
(16 - IEEE80211_SIGNAL_AVE_WEIGHT) *
|
|
|
|
ifmgd->ave_beacon_signal) / 16;
|
2010-08-27 21:22:00 +02:00
|
|
|
ifmgd->count_beacon_signal++;
|
2010-03-30 08:28:30 +02:00
|
|
|
}
|
2011-07-08 17:46:22 +02:00
|
|
|
|
|
|
|
if (ifmgd->rssi_min_thold != ifmgd->rssi_max_thold &&
|
|
|
|
ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT) {
|
|
|
|
int sig = ifmgd->ave_beacon_signal;
|
|
|
|
int last_sig = ifmgd->last_ave_beacon_signal;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if signal crosses either of the boundaries, invoke callback
|
|
|
|
* with appropriate parameters
|
|
|
|
*/
|
|
|
|
if (sig > ifmgd->rssi_max_thold &&
|
|
|
|
(last_sig <= ifmgd->rssi_min_thold || last_sig == 0)) {
|
|
|
|
ifmgd->last_ave_beacon_signal = sig;
|
|
|
|
drv_rssi_callback(local, RSSI_EVENT_HIGH);
|
|
|
|
} else if (sig < ifmgd->rssi_min_thold &&
|
|
|
|
(last_sig >= ifmgd->rssi_max_thold ||
|
|
|
|
last_sig == 0)) {
|
|
|
|
ifmgd->last_ave_beacon_signal = sig;
|
|
|
|
drv_rssi_callback(local, RSSI_EVENT_LOW);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-30 08:28:30 +02:00
|
|
|
if (bss_conf->cqm_rssi_thold &&
|
2010-08-27 21:22:00 +02:00
|
|
|
ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
|
2012-01-19 09:29:58 +01:00
|
|
|
!(sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)) {
|
2010-03-30 08:28:30 +02:00
|
|
|
int sig = ifmgd->ave_beacon_signal / 16;
|
|
|
|
int last_event = ifmgd->last_cqm_event_signal;
|
|
|
|
int thold = bss_conf->cqm_rssi_thold;
|
|
|
|
int hyst = bss_conf->cqm_rssi_hyst;
|
|
|
|
if (sig < thold &&
|
|
|
|
(last_event == 0 || sig < last_event - hyst)) {
|
|
|
|
ifmgd->last_cqm_event_signal = sig;
|
|
|
|
ieee80211_cqm_rssi_notify(
|
|
|
|
&sdata->vif,
|
|
|
|
NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
|
|
|
|
GFP_KERNEL);
|
|
|
|
} else if (sig > thold &&
|
|
|
|
(last_event == 0 || sig > last_event + hyst)) {
|
|
|
|
ifmgd->last_cqm_event_signal = sig;
|
|
|
|
ieee80211_cqm_rssi_notify(
|
|
|
|
&sdata->vif,
|
|
|
|
NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg_ratelimited(sdata,
|
|
|
|
"cancelling probereq poll due to a received beacon\n");
|
2012-05-16 15:27:20 +02:00
|
|
|
mutex_lock(&local->mtx);
|
2009-07-10 15:29:03 +02:00
|
|
|
ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
|
2012-05-16 15:27:20 +02:00
|
|
|
ieee80211_run_deferred_scan(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
2009-06-10 15:16:52 +02:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2009-05-14 20:15:36 +02:00
|
|
|
}
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
/*
|
|
|
|
* Push the beacon loss detection into the future since
|
|
|
|
* we are processing a beacon from the AP just now.
|
|
|
|
*/
|
2010-09-16 21:12:32 +02:00
|
|
|
ieee80211_sta_reset_beacon_monitor(sdata);
|
2009-07-10 15:29:03 +02:00
|
|
|
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 13:17:26 +02:00
|
|
|
ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
|
|
|
|
ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
|
|
|
|
len - baselen, &elems,
|
|
|
|
care_about_ies, ncrc);
|
|
|
|
|
2009-03-02 15:50:30 +01:00
|
|
|
if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
|
2012-10-25 10:16:23 +02:00
|
|
|
bool directed_tim = ieee80211_check_tim(elems.tim,
|
|
|
|
elems.tim_len,
|
|
|
|
ifmgd->aid);
|
2009-02-10 16:09:24 +01:00
|
|
|
if (directed_tim) {
|
2009-02-10 16:09:31 +01:00
|
|
|
if (local->hw.conf.dynamic_ps_timeout > 0) {
|
2012-03-19 14:37:20 +01:00
|
|
|
if (local->hw.conf.flags & IEEE80211_CONF_PS) {
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_PS;
|
|
|
|
ieee80211_hw_config(local,
|
|
|
|
IEEE80211_CONF_CHANGE_PS);
|
|
|
|
}
|
2009-02-10 16:09:31 +01:00
|
|
|
ieee80211_send_nullfunc(local, sdata, 0);
|
2012-03-15 01:20:36 +01:00
|
|
|
} else if (!local->pspolling && sdata->u.mgd.powersave) {
|
2009-02-10 16:09:31 +01:00
|
|
|
local->pspolling = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Here is assumed that the driver will be
|
|
|
|
* able to send ps-poll frame and receive a
|
|
|
|
* response even though power save mode is
|
|
|
|
* enabled, but some drivers might require
|
|
|
|
* to disable power save here. This needs
|
|
|
|
* to be investigated.
|
|
|
|
*/
|
|
|
|
ieee80211_send_pspoll(local, sdata);
|
|
|
|
}
|
2008-12-24 03:39:02 +01:00
|
|
|
}
|
|
|
|
}
|
2008-10-08 10:59:33 +02:00
|
|
|
|
2012-10-29 20:08:01 +01:00
|
|
|
if (sdata->vif.p2p) {
|
|
|
|
u8 noa[2];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = cfg80211_get_p2p_attr(mgmt->u.beacon.variable,
|
|
|
|
len - baselen,
|
|
|
|
IEEE80211_P2P_ATTR_ABSENCE_NOTICE,
|
|
|
|
noa, sizeof(noa));
|
|
|
|
if (ret >= 2 && sdata->u.mgd.p2p_noa_index != noa[0]) {
|
|
|
|
bss_conf->p2p_oppps = noa[1] & 0x80;
|
|
|
|
bss_conf->p2p_ctwindow = noa[1] & 0x7f;
|
|
|
|
changed |= BSS_CHANGED_P2P_PS;
|
|
|
|
sdata->u.mgd.p2p_noa_index = noa[0];
|
|
|
|
/*
|
|
|
|
* make sure we update all information, the CRC
|
|
|
|
* mechanism doesn't look at P2P attributes.
|
|
|
|
*/
|
|
|
|
ifmgd->beacon_crc_valid = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
mac80211: Add validity check for beacon_crc value
On association to an AP, after receiving beacons, the beacon_crc value is set.
The beacon_crc value is not reset in disassociation, but the BSS data may be
expired at a later point. When associating again, it's possible that a
beacon for the AP is not received, resulting in the beacon_ies to remain NULL.
After association, further beacons will not update the beacon data, as the
crc value of the beacon has not changed, and the beacon_crc still holds a
value matching the beacon. The beacon_ies will remain forever null.
One of the results of this is that WLAN power save cannot be entered, the STA
will remain foreven in active mode.
Fix this by adding a validation flag for the beacon_crc, which is cleared on
association.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-10-01 15:02:31 +02:00
|
|
|
if (ncrc == ifmgd->beacon_crc && ifmgd->beacon_crc_valid)
|
2009-05-19 16:01:43 +02:00
|
|
|
return;
|
|
|
|
ifmgd->beacon_crc = ncrc;
|
mac80211: Add validity check for beacon_crc value
On association to an AP, after receiving beacons, the beacon_crc value is set.
The beacon_crc value is not reset in disassociation, but the BSS data may be
expired at a later point. When associating again, it's possible that a
beacon for the AP is not received, resulting in the beacon_ies to remain NULL.
After association, further beacons will not update the beacon data, as the
crc value of the beacon has not changed, and the beacon_crc still holds a
value matching the beacon. The beacon_ies will remain forever null.
One of the results of this is that WLAN power save cannot be entered, the STA
will remain foreven in active mode.
Fix this by adding a validation flag for the beacon_crc, which is cleared on
association.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-10-01 15:02:31 +02:00
|
|
|
ifmgd->beacon_crc_valid = true;
|
2009-05-19 16:01:43 +02:00
|
|
|
|
2012-07-06 17:37:43 +02:00
|
|
|
ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
|
|
|
|
true);
|
|
|
|
|
|
|
|
if (ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
|
|
|
|
elems.wmm_param_len))
|
|
|
|
changed |= BSS_CHANGED_QOS;
|
|
|
|
|
2008-10-08 10:59:33 +02:00
|
|
|
if (elems.erp_info && elems.erp_info_len >= 1) {
|
|
|
|
erp_valid = true;
|
|
|
|
erp_value = elems.erp_info[0];
|
|
|
|
} else {
|
|
|
|
erp_valid = false;
|
2008-04-15 20:09:27 +02:00
|
|
|
}
|
2008-10-08 10:59:33 +02:00
|
|
|
changed |= ieee80211_handle_bss_capability(sdata,
|
|
|
|
le16_to_cpu(mgmt->u.beacon.capab_info),
|
|
|
|
erp_valid, erp_value);
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2007-11-26 15:14:34 +01:00
|
|
|
|
2012-03-15 19:45:16 +01:00
|
|
|
if (elems.ht_cap_elem && elems.ht_operation && elems.wmm_param &&
|
2012-11-22 14:32:09 +01:00
|
|
|
!(ifmgd->flags & IEEE80211_STA_DISABLE_HT))
|
2012-03-28 10:58:36 +02:00
|
|
|
changed |= ieee80211_config_ht_tx(sdata, elems.ht_operation,
|
|
|
|
bssid, true);
|
2007-11-26 15:14:34 +01:00
|
|
|
|
2012-09-05 13:41:37 +02:00
|
|
|
if (elems.country_elem && elems.pwr_constr_elem &&
|
|
|
|
mgmt->u.probe_resp.capab_info &
|
|
|
|
cpu_to_le16(WLAN_CAPABILITY_SPECTRUM_MGMT))
|
2012-10-24 10:59:25 +02:00
|
|
|
changed |= ieee80211_handle_pwr_constr(sdata, chan,
|
|
|
|
elems.country_elem,
|
|
|
|
elems.country_elem_len,
|
|
|
|
elems.pwr_constr_elem);
|
2008-11-12 23:22:02 +01:00
|
|
|
|
2007-12-28 14:32:58 +01:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2010-06-10 10:21:32 +02:00
|
|
|
void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-07-07 03:45:17 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2007-05-05 20:45:53 +02:00
|
|
|
struct ieee80211_rx_status *rx_status;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
2012-01-20 13:55:27 +01:00
|
|
|
struct cfg80211_bss *bss = NULL;
|
2009-07-07 03:45:17 +02:00
|
|
|
enum rx_mgmt_action rma = RX_MGMT_NONE;
|
2007-05-05 20:45:53 +02:00
|
|
|
u16 fc;
|
|
|
|
|
|
|
|
rx_status = (struct ieee80211_rx_status *) skb->cb;
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb->data;
|
|
|
|
fc = le16_to_cpu(mgmt->frame_control);
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
switch (fc & IEEE80211_FCTL_STYPE) {
|
|
|
|
case IEEE80211_STYPE_BEACON:
|
|
|
|
ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, rx_status);
|
|
|
|
break;
|
|
|
|
case IEEE80211_STYPE_PROBE_RESP:
|
|
|
|
ieee80211_rx_mgmt_probe_resp(sdata, skb);
|
|
|
|
break;
|
|
|
|
case IEEE80211_STYPE_AUTH:
|
|
|
|
rma = ieee80211_rx_mgmt_auth(sdata, mgmt, skb->len);
|
|
|
|
break;
|
|
|
|
case IEEE80211_STYPE_DEAUTH:
|
|
|
|
rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
|
|
|
|
break;
|
|
|
|
case IEEE80211_STYPE_DISASSOC:
|
|
|
|
rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
|
|
|
|
break;
|
|
|
|
case IEEE80211_STYPE_ASSOC_RESP:
|
|
|
|
case IEEE80211_STYPE_REASSOC_RESP:
|
|
|
|
rma = ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, &bss);
|
|
|
|
break;
|
|
|
|
case IEEE80211_STYPE_ACTION:
|
|
|
|
switch (mgmt->u.action.category) {
|
|
|
|
case WLAN_CATEGORY_SPECTRUM_MGMT:
|
|
|
|
ieee80211_sta_process_chanswitch(sdata,
|
|
|
|
&mgmt->u.action.u.chan_switch.sw_elem,
|
|
|
|
(void *)ifmgd->associated->priv,
|
|
|
|
rx_status->mactime);
|
2009-07-07 03:45:17 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
switch (rma) {
|
|
|
|
case RX_MGMT_NONE:
|
|
|
|
/* no action */
|
|
|
|
break;
|
|
|
|
case RX_MGMT_CFG80211_DEAUTH:
|
2009-10-13 13:28:13 +02:00
|
|
|
cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
|
2012-01-20 13:55:27 +01:00
|
|
|
break;
|
|
|
|
case RX_MGMT_CFG80211_DISASSOC:
|
|
|
|
cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
|
|
|
|
break;
|
|
|
|
case RX_MGMT_CFG80211_RX_AUTH:
|
|
|
|
cfg80211_send_rx_auth(sdata->dev, (u8 *)mgmt, skb->len);
|
|
|
|
break;
|
|
|
|
case RX_MGMT_CFG80211_RX_ASSOC:
|
|
|
|
cfg80211_send_rx_assoc(sdata->dev, bss, (u8 *)mgmt, skb->len);
|
|
|
|
break;
|
|
|
|
case RX_MGMT_CFG80211_ASSOC_TIMEOUT:
|
|
|
|
cfg80211_send_assoc_timeout(sdata->dev, mgmt->bssid);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN(1, "unexpected: %d", rma);
|
2010-06-07 21:50:07 +02:00
|
|
|
}
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2008-09-11 00:01:52 +02:00
|
|
|
static void ieee80211_sta_timer(unsigned long data)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2008-09-08 17:44:22 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
(struct ieee80211_sub_if_data *) data;
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2008-09-08 17:44:22 +02:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-05-17 11:40:42 +02:00
|
|
|
if (local->quiescing) {
|
|
|
|
set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-06-10 10:21:31 +02:00
|
|
|
ieee80211_queue_work(&local->hw, &sdata->work);
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2010-12-02 21:01:08 +01:00
|
|
|
static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
|
2011-07-12 12:30:59 +02:00
|
|
|
u8 *bssid, u8 reason)
|
2010-12-02 21:01:08 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2012-09-07 13:28:52 +02:00
|
|
|
u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
|
2010-12-02 21:01:08 +01:00
|
|
|
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH, reason,
|
|
|
|
false, frame_buf);
|
2010-12-02 21:01:08 +01:00
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2012-02-24 13:50:54 +01:00
|
|
|
|
2010-12-02 21:01:08 +01:00
|
|
|
/*
|
|
|
|
* must be outside lock due to cfg80211,
|
|
|
|
* but that's not a problem.
|
|
|
|
*/
|
2012-09-07 13:28:52 +02:00
|
|
|
cfg80211_send_deauth(sdata->dev, frame_buf, IEEE80211_DEAUTH_FRAME_LEN);
|
2011-11-16 13:34:55 +01:00
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
2010-12-02 21:01:08 +01:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
static int ieee80211_probe_auth(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_mgd_auth_data *auth_data = ifmgd->auth_data;
|
|
|
|
|
|
|
|
lockdep_assert_held(&ifmgd->mtx);
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!auth_data))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
auth_data->tries++;
|
|
|
|
|
|
|
|
if (auth_data->tries > IEEE80211_AUTH_MAX_TRIES) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "authentication with %pM timed out\n",
|
|
|
|
auth_data->bss->bssid);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Most likely AP is not in the range so remove the
|
|
|
|
* bss struct for that AP.
|
|
|
|
*/
|
|
|
|
cfg80211_unlink_bss(local->hw.wiphy, auth_data->bss);
|
|
|
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
2012-06-27 13:18:36 +02:00
|
|
|
drv_mgd_prepare_tx(local, sdata);
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (auth_data->bss->proberesp_ies) {
|
2012-09-30 18:29:40 +02:00
|
|
|
u16 trans = 1;
|
|
|
|
u16 status = 0;
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "send auth to %pM (try %d/%d)\n",
|
|
|
|
auth_data->bss->bssid, auth_data->tries,
|
|
|
|
IEEE80211_AUTH_MAX_TRIES);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
auth_data->expected_transaction = 2;
|
2012-09-30 18:29:40 +02:00
|
|
|
|
|
|
|
if (auth_data->algorithm == WLAN_AUTH_SAE) {
|
|
|
|
trans = auth_data->sae_trans;
|
|
|
|
status = auth_data->sae_status;
|
|
|
|
auth_data->expected_transaction = trans;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_send_auth(sdata, trans, auth_data->algorithm, status,
|
|
|
|
auth_data->data, auth_data->data_len,
|
2012-01-20 13:55:27 +01:00
|
|
|
auth_data->bss->bssid,
|
|
|
|
auth_data->bss->bssid, NULL, 0, 0);
|
|
|
|
} else {
|
|
|
|
const u8 *ssidie;
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "direct probe to %pM (try %d/%i)\n",
|
|
|
|
auth_data->bss->bssid, auth_data->tries,
|
|
|
|
IEEE80211_AUTH_MAX_TRIES);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
ssidie = ieee80211_bss_get_ie(auth_data->bss, WLAN_EID_SSID);
|
|
|
|
if (!ssidie)
|
|
|
|
return -EINVAL;
|
|
|
|
/*
|
|
|
|
* Direct probe is sent to broadcast address as some APs
|
|
|
|
* will not answer to direct packet in unassociated state.
|
|
|
|
*/
|
|
|
|
ieee80211_send_probe_req(sdata, NULL, ssidie + 2, ssidie[1],
|
2012-07-30 12:26:34 +02:00
|
|
|
NULL, 0, (u32) -1, true, false,
|
2012-07-26 17:24:39 +02:00
|
|
|
auth_data->bss->channel, false);
|
2012-01-20 13:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
auth_data->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
|
|
|
|
run_again(ifmgd, auth_data->timeout);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_do_assoc(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
lockdep_assert_held(&sdata->u.mgd.mtx);
|
|
|
|
|
|
|
|
assoc_data->tries++;
|
|
|
|
if (assoc_data->tries > IEEE80211_ASSOC_MAX_TRIES) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "association with %pM timed out\n",
|
|
|
|
assoc_data->bss->bssid);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Most likely AP is not in the range so remove the
|
|
|
|
* bss struct for that AP.
|
|
|
|
*/
|
|
|
|
cfg80211_unlink_bss(local->hw.wiphy, assoc_data->bss);
|
|
|
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "associate with %pM (try %d/%d)\n",
|
|
|
|
assoc_data->bss->bssid, assoc_data->tries,
|
|
|
|
IEEE80211_ASSOC_MAX_TRIES);
|
2012-01-20 13:55:27 +01:00
|
|
|
ieee80211_send_assoc(sdata);
|
|
|
|
|
|
|
|
assoc_data->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
|
|
|
|
run_again(&sdata->u.mgd, assoc_data->timeout);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-10 10:21:32 +02:00
|
|
|
void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
|
2008-09-11 00:01:52 +02:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-06-10 10:21:32 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2008-09-11 00:01:52 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->auth_data &&
|
|
|
|
time_after(jiffies, ifmgd->auth_data->timeout)) {
|
|
|
|
if (ifmgd->auth_data->done) {
|
|
|
|
/*
|
|
|
|
* ok ... we waited for assoc but userspace didn't,
|
|
|
|
* so let's just kill the auth data
|
|
|
|
*/
|
|
|
|
ieee80211_destroy_auth_data(sdata, false);
|
|
|
|
} else if (ieee80211_probe_auth(sdata)) {
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
|
|
|
|
memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
|
|
|
|
|
|
|
|
ieee80211_destroy_auth_data(sdata, false);
|
|
|
|
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
cfg80211_send_auth_timeout(sdata->dev, bssid);
|
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
}
|
|
|
|
} else if (ifmgd->auth_data)
|
|
|
|
run_again(ifmgd, ifmgd->auth_data->timeout);
|
|
|
|
|
|
|
|
if (ifmgd->assoc_data &&
|
|
|
|
time_after(jiffies, ifmgd->assoc_data->timeout)) {
|
|
|
|
if (!ifmgd->assoc_data->have_beacon ||
|
|
|
|
ieee80211_do_assoc(sdata)) {
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
|
|
|
|
memcpy(bssid, ifmgd->assoc_data->bss->bssid, ETH_ALEN);
|
|
|
|
|
|
|
|
ieee80211_destroy_assoc_data(sdata, false);
|
|
|
|
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
cfg80211_send_assoc_timeout(sdata->dev, bssid);
|
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
}
|
|
|
|
} else if (ifmgd->assoc_data)
|
|
|
|
run_again(ifmgd, ifmgd->assoc_data->timeout);
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
|
|
|
|
IEEE80211_STA_CONNECTION_POLL) &&
|
|
|
|
ifmgd->associated) {
|
2009-07-31 17:54:12 +02:00
|
|
|
u8 bssid[ETH_ALEN];
|
2010-11-23 03:10:32 +01:00
|
|
|
int max_tries;
|
2009-07-31 17:54:12 +02:00
|
|
|
|
2009-12-23 13:15:39 +01:00
|
|
|
memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
|
2010-11-23 03:10:31 +01:00
|
|
|
|
2010-11-23 03:10:32 +01:00
|
|
|
if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
|
2011-02-05 00:30:24 +01:00
|
|
|
max_tries = max_nullfunc_tries;
|
2010-11-23 03:10:32 +01:00
|
|
|
else
|
2011-02-05 00:30:24 +01:00
|
|
|
max_tries = max_probe_tries;
|
2010-11-23 03:10:32 +01:00
|
|
|
|
2010-11-23 03:10:31 +01:00
|
|
|
/* ACK received for nullfunc probing frame */
|
|
|
|
if (!ifmgd->probe_send_count)
|
|
|
|
ieee80211_reset_ap_probe(sdata);
|
2010-12-02 21:01:08 +01:00
|
|
|
else if (ifmgd->nullfunc_failed) {
|
|
|
|
if (ifmgd->probe_send_count < max_tries) {
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg(sdata,
|
|
|
|
"No ack for nullfunc frame to AP %pM, try %d/%i\n",
|
|
|
|
bssid, ifmgd->probe_send_count,
|
|
|
|
max_tries);
|
2010-12-02 21:01:08 +01:00
|
|
|
ieee80211_mgd_probe_ap_send(sdata);
|
|
|
|
} else {
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg(sdata,
|
|
|
|
"No ack for nullfunc frame to AP %pM, disconnecting.\n",
|
|
|
|
bssid);
|
2011-07-12 12:30:59 +02:00
|
|
|
ieee80211_sta_connection_lost(sdata, bssid,
|
|
|
|
WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
|
2010-12-02 21:01:08 +01:00
|
|
|
}
|
|
|
|
} else if (time_is_after_jiffies(ifmgd->probe_timeout))
|
2009-07-10 15:29:03 +02:00
|
|
|
run_again(ifmgd, ifmgd->probe_timeout);
|
2010-12-02 21:01:08 +01:00
|
|
|
else if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg(sdata,
|
|
|
|
"Failed to send nullfunc to AP %pM after %dms, disconnecting\n",
|
|
|
|
bssid, probe_wait_ms);
|
2011-07-12 12:30:59 +02:00
|
|
|
ieee80211_sta_connection_lost(sdata, bssid,
|
|
|
|
WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
|
2010-12-02 21:01:08 +01:00
|
|
|
} else if (ifmgd->probe_send_count < max_tries) {
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg(sdata,
|
|
|
|
"No probe response from AP %pM after %dms, try %d/%i\n",
|
|
|
|
bssid, probe_wait_ms,
|
|
|
|
ifmgd->probe_send_count, max_tries);
|
2009-07-31 17:54:12 +02:00
|
|
|
ieee80211_mgd_probe_ap_send(sdata);
|
|
|
|
} else {
|
2009-07-10 15:29:03 +02:00
|
|
|
/*
|
|
|
|
* We actually lost the connection ... or did we?
|
|
|
|
* Let's make sure!
|
|
|
|
*/
|
2010-10-08 01:12:06 +02:00
|
|
|
wiphy_debug(local->hw.wiphy,
|
|
|
|
"%s: No probe response from AP %pM"
|
|
|
|
" after %dms, disconnecting.\n",
|
|
|
|
sdata->name,
|
2011-02-05 00:30:24 +01:00
|
|
|
bssid, probe_wait_ms);
|
2010-12-02 21:01:08 +01:00
|
|
|
|
2011-07-12 12:30:59 +02:00
|
|
|
ieee80211_sta_connection_lost(sdata, bssid,
|
|
|
|
WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
|
2009-07-10 15:29:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
static void ieee80211_sta_bcn_mon_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
(struct ieee80211_sub_if_data *) data;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
if (local->quiescing)
|
|
|
|
return;
|
|
|
|
|
2010-03-19 06:14:53 +01:00
|
|
|
ieee80211_queue_work(&sdata->local->hw,
|
|
|
|
&sdata->u.mgd.beacon_connection_loss_work);
|
2009-07-10 15:29:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_sta_conn_mon_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
(struct ieee80211_sub_if_data *) data;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
if (local->quiescing)
|
|
|
|
return;
|
|
|
|
|
2009-07-30 02:08:07 +02:00
|
|
|
ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
|
2009-07-10 15:29:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_sta_monitor_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data,
|
|
|
|
u.mgd.monitor_work);
|
|
|
|
|
|
|
|
ieee80211_mgd_probe_ap(sdata, false);
|
|
|
|
}
|
|
|
|
|
2008-09-11 00:01:52 +02:00
|
|
|
static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
2012-02-19 14:26:09 +01:00
|
|
|
u32 flags;
|
|
|
|
|
2009-04-19 07:47:19 +02:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION) {
|
2012-05-16 15:27:20 +02:00
|
|
|
__ieee80211_stop_poll(sdata);
|
2009-04-19 07:47:19 +02:00
|
|
|
|
2009-07-10 15:29:03 +02:00
|
|
|
/* let's probe the connection once */
|
2012-02-19 14:26:09 +01:00
|
|
|
flags = sdata->local->hw.flags;
|
|
|
|
if (!(flags & IEEE80211_HW_CONNECTION_MONITOR))
|
|
|
|
ieee80211_queue_work(&sdata->local->hw,
|
|
|
|
&sdata->u.mgd.monitor_work);
|
2009-07-10 15:29:03 +02:00
|
|
|
/* and do all the other regular work too */
|
2010-06-10 10:21:31 +02:00
|
|
|
ieee80211_queue_work(&sdata->local->hw, &sdata->work);
|
2009-04-19 07:47:19 +02:00
|
|
|
}
|
2008-09-11 00:01:52 +02:00
|
|
|
}
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-05-17 11:40:42 +02:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we need to use atomic bitops for the running bits
|
|
|
|
* only because both timers might fire at the same
|
|
|
|
* time -- the code here is properly synchronised.
|
|
|
|
*/
|
|
|
|
|
2010-08-05 17:05:55 +02:00
|
|
|
cancel_work_sync(&ifmgd->request_smps_work);
|
|
|
|
|
2011-11-09 12:14:16 +01:00
|
|
|
cancel_work_sync(&ifmgd->monitor_work);
|
2010-03-19 06:14:53 +01:00
|
|
|
cancel_work_sync(&ifmgd->beacon_connection_loss_work);
|
2012-08-01 22:32:45 +02:00
|
|
|
cancel_work_sync(&ifmgd->csa_connection_drop_work);
|
2009-05-17 11:40:42 +02:00
|
|
|
if (del_timer_sync(&ifmgd->timer))
|
|
|
|
set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
|
|
|
|
|
|
|
|
cancel_work_sync(&ifmgd->chswitch_work);
|
|
|
|
if (del_timer_sync(&ifmgd->chswitch_timer))
|
|
|
|
set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
|
2009-07-10 15:29:03 +02:00
|
|
|
|
|
|
|
/* these will just be re-established on connection */
|
|
|
|
del_timer_sync(&ifmgd->conn_mon_timer);
|
|
|
|
del_timer_sync(&ifmgd->bcn_mon_timer);
|
2009-05-17 11:40:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
2011-07-07 20:03:39 +02:00
|
|
|
if (!ifmgd->associated)
|
|
|
|
return;
|
|
|
|
|
2011-07-12 12:30:59 +02:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_DISCONNECT_RESUME) {
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_DISCONNECT_RESUME;
|
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
if (ifmgd->associated) {
|
2012-06-22 11:29:50 +02:00
|
|
|
mlme_dbg(sdata,
|
|
|
|
"driver requested disconnect after resume\n");
|
2011-07-12 12:30:59 +02:00
|
|
|
ieee80211_sta_connection_lost(sdata,
|
|
|
|
ifmgd->associated->bssid,
|
|
|
|
WLAN_REASON_UNSPECIFIED);
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
}
|
|
|
|
|
2009-05-17 11:40:42 +02:00
|
|
|
if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
|
|
|
|
add_timer(&ifmgd->timer);
|
|
|
|
if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
|
|
|
|
add_timer(&ifmgd->chswitch_timer);
|
2010-11-19 22:55:37 +01:00
|
|
|
ieee80211_sta_reset_beacon_monitor(sdata);
|
2012-05-16 15:27:20 +02:00
|
|
|
|
|
|
|
mutex_lock(&sdata->local->mtx);
|
2010-11-23 20:28:03 +01:00
|
|
|
ieee80211_restart_sta_timer(sdata);
|
2012-05-16 15:27:20 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2009-05-17 11:40:42 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-09-11 00:01:52 +02:00
|
|
|
/* interface setup */
|
|
|
|
void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd;
|
2008-04-17 19:21:22 +02:00
|
|
|
|
2009-02-15 12:44:28 +01:00
|
|
|
ifmgd = &sdata->u.mgd;
|
2009-07-10 15:29:03 +02:00
|
|
|
INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
|
2009-02-15 12:44:28 +01:00
|
|
|
INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
|
2010-03-19 06:14:53 +01:00
|
|
|
INIT_WORK(&ifmgd->beacon_connection_loss_work,
|
|
|
|
ieee80211_beacon_connection_loss_work);
|
2012-08-01 22:32:45 +02:00
|
|
|
INIT_WORK(&ifmgd->csa_connection_drop_work,
|
|
|
|
ieee80211_csa_connection_drop_work);
|
2010-08-05 17:05:55 +02:00
|
|
|
INIT_WORK(&ifmgd->request_smps_work, ieee80211_request_smps_work);
|
2009-02-15 12:44:28 +01:00
|
|
|
setup_timer(&ifmgd->timer, ieee80211_sta_timer,
|
2009-01-06 04:58:37 +01:00
|
|
|
(unsigned long) sdata);
|
2009-07-10 15:29:03 +02:00
|
|
|
setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
|
|
|
|
(unsigned long) sdata);
|
|
|
|
setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
|
|
|
|
(unsigned long) sdata);
|
2009-02-15 12:44:28 +01:00
|
|
|
setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
|
2008-09-11 00:01:52 +02:00
|
|
|
(unsigned long) sdata);
|
|
|
|
|
2009-07-01 21:41:17 +02:00
|
|
|
ifmgd->flags = 0;
|
2011-12-14 15:16:08 +01:00
|
|
|
ifmgd->powersave = sdata->wdev.ps;
|
2012-03-14 15:15:03 +01:00
|
|
|
ifmgd->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
|
|
|
|
ifmgd->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
|
2009-04-16 13:27:42 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_init(&ifmgd->mtx);
|
2009-12-01 13:37:02 +01:00
|
|
|
|
|
|
|
if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS)
|
|
|
|
ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC;
|
|
|
|
else
|
|
|
|
ifmgd->req_smps = IEEE80211_SMPS_OFF;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
/* scan finished notification */
|
|
|
|
void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
|
2008-09-08 17:44:22 +02:00
|
|
|
{
|
2012-07-06 21:18:24 +02:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-09-08 17:44:22 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
/* Restart STA timers */
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list)
|
|
|
|
ieee80211_restart_sta_timer(sdata);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2008-09-08 17:44:22 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
int ieee80211_max_network_latency(struct notifier_block *nb,
|
|
|
|
unsigned long data, void *dummy)
|
|
|
|
{
|
|
|
|
s32 latency_usec = (s32) data;
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(nb, struct ieee80211_local,
|
|
|
|
network_latency_notifier);
|
2009-06-15 18:13:58 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
ieee80211_recalc_ps(local, latency_usec);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2009-01-24 01:19:04 +01:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
return 0;
|
2008-09-11 00:01:52 +02:00
|
|
|
}
|
|
|
|
|
2012-07-27 11:41:27 +02:00
|
|
|
static int ieee80211_prep_channel(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_bss *cbss)
|
2012-03-08 15:02:07 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2012-03-28 10:58:36 +02:00
|
|
|
int ht_cfreq;
|
|
|
|
enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
|
|
|
|
const u8 *ht_oper_ie;
|
|
|
|
const struct ieee80211_ht_operation *ht_oper = NULL;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2012-11-09 11:39:59 +01:00
|
|
|
struct cfg80211_chan_def chandef;
|
2012-03-08 15:02:07 +01:00
|
|
|
|
2012-03-28 10:58:36 +02:00
|
|
|
sband = local->hw.wiphy->bands[cbss->channel->band];
|
|
|
|
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_DISABLE_40MHZ;
|
|
|
|
|
|
|
|
if (sband->ht_cap.ht_supported) {
|
|
|
|
ht_oper_ie = cfg80211_find_ie(WLAN_EID_HT_OPERATION,
|
|
|
|
cbss->information_elements,
|
|
|
|
cbss->len_information_elements);
|
|
|
|
if (ht_oper_ie && ht_oper_ie[1] >= sizeof(*ht_oper))
|
|
|
|
ht_oper = (void *)(ht_oper_ie + 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ht_oper) {
|
|
|
|
ht_cfreq = ieee80211_channel_to_frequency(ht_oper->primary_chan,
|
|
|
|
cbss->channel->band);
|
|
|
|
/* check that channel matches the right operating channel */
|
|
|
|
if (cbss->channel->center_freq != ht_cfreq) {
|
|
|
|
/*
|
|
|
|
* It's possible that some APs are confused here;
|
|
|
|
* Netgear WNDR3700 sometimes reports 4 higher than
|
|
|
|
* the actual channel in association responses, but
|
|
|
|
* since we look at probe response/beacon data here
|
|
|
|
* it should be OK.
|
|
|
|
*/
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"Wrong control channel: center-freq: %d ht-cfreq: %d ht->primary_chan: %d band: %d - Disabling HT\n",
|
|
|
|
cbss->channel->center_freq,
|
|
|
|
ht_cfreq, ht_oper->primary_chan,
|
|
|
|
cbss->channel->band);
|
2012-03-28 10:58:36 +02:00
|
|
|
ht_oper = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-22 14:17:23 +01:00
|
|
|
if (ht_oper) {
|
2012-10-01 15:52:00 +02:00
|
|
|
/*
|
|
|
|
* cfg80211 already verified that the channel itself can
|
|
|
|
* be used, but it didn't check that we can do the right
|
|
|
|
* HT type, so do that here as well. If HT40 isn't allowed
|
|
|
|
* on this channel, disable 40 MHz operation.
|
|
|
|
*/
|
2012-09-11 14:34:12 +02:00
|
|
|
const u8 *ht_cap_ie;
|
|
|
|
const struct ieee80211_ht_cap *ht_cap;
|
|
|
|
u8 chains = 1;
|
|
|
|
|
2012-03-28 10:58:36 +02:00
|
|
|
channel_type = NL80211_CHAN_HT20;
|
|
|
|
|
2012-11-22 14:17:23 +01:00
|
|
|
if (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) {
|
|
|
|
switch (ht_oper->ht_param &
|
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
|
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
|
|
|
|
if (cbss->channel->flags &
|
|
|
|
IEEE80211_CHAN_NO_HT40PLUS)
|
|
|
|
ifmgd->flags |=
|
|
|
|
IEEE80211_STA_DISABLE_40MHZ;
|
|
|
|
else
|
|
|
|
channel_type = NL80211_CHAN_HT40PLUS;
|
|
|
|
break;
|
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
|
|
|
|
if (cbss->channel->flags &
|
|
|
|
IEEE80211_CHAN_NO_HT40MINUS)
|
|
|
|
ifmgd->flags |=
|
|
|
|
IEEE80211_STA_DISABLE_40MHZ;
|
|
|
|
else
|
|
|
|
channel_type = NL80211_CHAN_HT40MINUS;
|
|
|
|
break;
|
|
|
|
}
|
2012-03-28 10:58:36 +02:00
|
|
|
}
|
2012-09-11 14:34:12 +02:00
|
|
|
|
|
|
|
ht_cap_ie = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY,
|
|
|
|
cbss->information_elements,
|
|
|
|
cbss->len_information_elements);
|
|
|
|
if (ht_cap_ie && ht_cap_ie[1] >= sizeof(*ht_cap)) {
|
|
|
|
ht_cap = (void *)(ht_cap_ie + 2);
|
|
|
|
chains = ieee80211_mcs_to_chains(&ht_cap->mcs);
|
|
|
|
}
|
|
|
|
sdata->needed_rx_chains = min(chains, local->rx_chains);
|
|
|
|
} else {
|
|
|
|
sdata->needed_rx_chains = 1;
|
2012-11-22 14:34:05 +01:00
|
|
|
sdata->u.mgd.flags |= IEEE80211_STA_DISABLE_HT;
|
2012-03-28 10:58:36 +02:00
|
|
|
}
|
|
|
|
|
2012-09-11 14:34:12 +02:00
|
|
|
/* will change later if needed */
|
|
|
|
sdata->smps_mode = IEEE80211_SMPS_OFF;
|
|
|
|
|
2012-07-26 17:24:39 +02:00
|
|
|
ieee80211_vif_release_channel(sdata);
|
2012-11-09 11:39:59 +01:00
|
|
|
cfg80211_chandef_create(&chandef, cbss->channel, channel_type);
|
|
|
|
return ieee80211_vif_use_channel(sdata, &chandef,
|
2012-07-26 17:24:39 +02:00
|
|
|
IEEE80211_CHANCTX_SHARED);
|
2012-07-27 11:41:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_prep_connection(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_bss *cbss, bool assoc)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_bss *bss = (void *)cbss->priv;
|
|
|
|
struct sta_info *new_sta = NULL;
|
|
|
|
bool have_sta = false;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (WARN_ON(!ifmgd->auth_data && !ifmgd->assoc_data))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (assoc) {
|
|
|
|
rcu_read_lock();
|
|
|
|
have_sta = sta_info_get(sdata, cbss->bssid);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!have_sta) {
|
|
|
|
new_sta = sta_info_alloc(sdata, cbss->bssid, GFP_KERNEL);
|
|
|
|
if (!new_sta)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_recalc_idle(sdata->local);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
2012-07-27 10:43:16 +02:00
|
|
|
if (new_sta) {
|
2012-03-08 15:02:08 +01:00
|
|
|
u32 rates = 0, basic_rates = 0;
|
|
|
|
bool have_higher_than_11mbit;
|
|
|
|
int min_rate = INT_MAX, min_rate_index = -1;
|
2012-07-27 11:41:27 +02:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[cbss->channel->band];
|
|
|
|
|
|
|
|
err = ieee80211_prep_channel(sdata, cbss);
|
|
|
|
if (err) {
|
|
|
|
sta_info_free(local, new_sta);
|
|
|
|
return err;
|
|
|
|
}
|
2012-03-08 15:02:08 +01:00
|
|
|
|
|
|
|
ieee80211_get_rates(sband, bss->supp_rates,
|
|
|
|
bss->supp_rates_len,
|
|
|
|
&rates, &basic_rates,
|
|
|
|
&have_higher_than_11mbit,
|
|
|
|
&min_rate, &min_rate_index);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This used to be a workaround for basic rates missing
|
|
|
|
* in the association response frame. Now that we no
|
|
|
|
* longer use the basic rates from there, it probably
|
|
|
|
* doesn't happen any more, but keep the workaround so
|
|
|
|
* in case some *other* APs are buggy in different ways
|
|
|
|
* we can connect -- with a warning.
|
|
|
|
*/
|
|
|
|
if (!basic_rates && min_rate_index >= 0) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"No basic rates, using min rate instead\n");
|
2012-03-08 15:02:08 +01:00
|
|
|
basic_rates = BIT(min_rate_index);
|
|
|
|
}
|
|
|
|
|
2012-07-27 10:43:16 +02:00
|
|
|
new_sta->sta.supp_rates[cbss->channel->band] = rates;
|
2012-03-08 15:02:08 +01:00
|
|
|
sdata->vif.bss_conf.basic_rates = basic_rates;
|
|
|
|
|
|
|
|
/* cf. IEEE 802.11 9.2.12 */
|
2012-07-26 17:24:39 +02:00
|
|
|
if (cbss->channel->band == IEEE80211_BAND_2GHZ &&
|
2012-03-08 15:02:08 +01:00
|
|
|
have_higher_than_11mbit)
|
|
|
|
sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
|
|
|
|
else
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
|
|
|
|
|
|
|
|
memcpy(ifmgd->bssid, cbss->bssid, ETH_ALEN);
|
|
|
|
|
2012-05-22 22:13:05 +02:00
|
|
|
/* set timing information */
|
|
|
|
sdata->vif.bss_conf.beacon_int = cbss->beacon_interval;
|
|
|
|
sdata->vif.bss_conf.sync_tsf = cbss->tsf;
|
|
|
|
sdata->vif.bss_conf.sync_device_ts = bss->device_ts;
|
|
|
|
|
|
|
|
/* tell driver about BSSID, basic rates and timing */
|
2012-03-08 15:02:08 +01:00
|
|
|
ieee80211_bss_info_change_notify(sdata,
|
2012-05-22 22:13:05 +02:00
|
|
|
BSS_CHANGED_BSSID | BSS_CHANGED_BASIC_RATES |
|
|
|
|
BSS_CHANGED_BEACON_INT);
|
2012-03-08 15:02:07 +01:00
|
|
|
|
|
|
|
if (assoc)
|
2012-07-27 10:43:16 +02:00
|
|
|
sta_info_pre_move_state(new_sta, IEEE80211_STA_AUTH);
|
2012-03-08 15:02:07 +01:00
|
|
|
|
2012-07-27 10:43:16 +02:00
|
|
|
err = sta_info_insert(new_sta);
|
|
|
|
new_sta = NULL;
|
2012-03-08 15:02:07 +01:00
|
|
|
if (err) {
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"failed to insert STA entry for the AP (error %d)\n",
|
|
|
|
err);
|
2012-03-08 15:02:07 +01:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
} else
|
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 20:56:52 +02:00
|
|
|
WARN_ON_ONCE(!ether_addr_equal(ifmgd->bssid, cbss->bssid));
|
2012-03-08 15:02:07 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
/* config hooks */
|
|
|
|
int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_auth_request *req)
|
2008-09-11 00:01:52 +02:00
|
|
|
{
|
2012-01-20 13:55:27 +01:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
struct ieee80211_mgd_auth_data *auth_data;
|
2009-07-07 03:45:17 +02:00
|
|
|
u16 auth_alg;
|
2012-01-20 13:55:27 +01:00
|
|
|
int err;
|
|
|
|
|
|
|
|
/* prepare auth data structure */
|
2008-09-11 00:01:52 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
switch (req->auth_type) {
|
|
|
|
case NL80211_AUTHTYPE_OPEN_SYSTEM:
|
|
|
|
auth_alg = WLAN_AUTH_OPEN;
|
|
|
|
break;
|
|
|
|
case NL80211_AUTHTYPE_SHARED_KEY:
|
2012-01-20 13:55:27 +01:00
|
|
|
if (IS_ERR(local->wep_tx_tfm))
|
2010-07-21 10:09:25 +02:00
|
|
|
return -EOPNOTSUPP;
|
2009-07-07 03:45:17 +02:00
|
|
|
auth_alg = WLAN_AUTH_SHARED_KEY;
|
|
|
|
break;
|
|
|
|
case NL80211_AUTHTYPE_FT:
|
|
|
|
auth_alg = WLAN_AUTH_FT;
|
|
|
|
break;
|
|
|
|
case NL80211_AUTHTYPE_NETWORK_EAP:
|
|
|
|
auth_alg = WLAN_AUTH_LEAP;
|
|
|
|
break;
|
2012-09-30 18:29:40 +02:00
|
|
|
case NL80211_AUTHTYPE_SAE:
|
|
|
|
auth_alg = WLAN_AUTH_SAE;
|
|
|
|
break;
|
2009-07-07 03:45:17 +02:00
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
2008-09-08 17:44:22 +02:00
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-09-30 18:29:40 +02:00
|
|
|
auth_data = kzalloc(sizeof(*auth_data) + req->sae_data_len +
|
|
|
|
req->ie_len, GFP_KERNEL);
|
2012-01-20 13:55:27 +01:00
|
|
|
if (!auth_data)
|
2008-09-11 00:01:52 +02:00
|
|
|
return -ENOMEM;
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
auth_data->bss = req->bss;
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-09-30 18:29:40 +02:00
|
|
|
if (req->sae_data_len >= 4) {
|
|
|
|
__le16 *pos = (__le16 *) req->sae_data;
|
|
|
|
auth_data->sae_trans = le16_to_cpu(pos[0]);
|
|
|
|
auth_data->sae_status = le16_to_cpu(pos[1]);
|
|
|
|
memcpy(auth_data->data, req->sae_data + 4,
|
|
|
|
req->sae_data_len - 4);
|
|
|
|
auth_data->data_len += req->sae_data_len - 4;
|
|
|
|
}
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
if (req->ie && req->ie_len) {
|
2012-09-30 18:29:40 +02:00
|
|
|
memcpy(&auth_data->data[auth_data->data_len],
|
|
|
|
req->ie, req->ie_len);
|
|
|
|
auth_data->data_len += req->ie_len;
|
2008-09-11 00:01:52 +02:00
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 14:22:54 +02:00
|
|
|
if (req->key && req->key_len) {
|
2012-01-20 13:55:27 +01:00
|
|
|
auth_data->key_len = req->key_len;
|
|
|
|
auth_data->key_idx = req->key_idx;
|
|
|
|
memcpy(auth_data->key, req->key, req->key_len);
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 14:22:54 +02:00
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
auth_data->algorithm = auth_alg;
|
2008-09-08 17:44:22 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* try to authenticate/probe */
|
2011-08-17 14:18:15 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
2011-08-17 14:18:15 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if ((ifmgd->auth_data && !ifmgd->auth_data->done) ||
|
|
|
|
ifmgd->assoc_data) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto err_free;
|
2011-08-17 14:18:15 +02:00
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->auth_data)
|
|
|
|
ieee80211_destroy_auth_data(sdata, false);
|
2011-08-17 14:18:15 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* prep auth_data so we don't go into idle on disassoc */
|
|
|
|
ifmgd->auth_data = auth_data;
|
2009-12-23 13:15:35 +01:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->associated)
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
|
2009-12-23 13:15:35 +01:00
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "authenticate with %pM\n", req->bss->bssid);
|
2010-07-29 16:08:55 +02:00
|
|
|
|
2012-03-08 15:02:07 +01:00
|
|
|
err = ieee80211_prep_connection(sdata, req->bss, false);
|
|
|
|
if (err)
|
2012-01-20 13:55:27 +01:00
|
|
|
goto err_clear;
|
2009-12-23 13:15:35 +01:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
err = ieee80211_probe_auth(sdata);
|
|
|
|
if (err) {
|
|
|
|
sta_info_destroy_addr(sdata, req->bss->bssid);
|
|
|
|
goto err_clear;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* hold our own reference */
|
|
|
|
cfg80211_ref_bss(auth_data->bss);
|
|
|
|
err = 0;
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
err_clear:
|
2012-09-04 16:44:45 +02:00
|
|
|
memset(ifmgd->bssid, 0, ETH_ALEN);
|
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
|
2012-01-20 13:55:27 +01:00
|
|
|
ifmgd->auth_data = NULL;
|
|
|
|
err_free:
|
|
|
|
kfree(auth_data);
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2011-07-19 10:39:53 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
return err;
|
2009-12-23 13:15:35 +01:00
|
|
|
}
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_assoc_request *req)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2012-01-20 13:55:27 +01:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-07-07 03:45:17 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2009-12-23 13:15:39 +01:00
|
|
|
struct ieee80211_bss *bss = (void *)req->bss->priv;
|
2012-01-20 13:55:27 +01:00
|
|
|
struct ieee80211_mgd_assoc_data *assoc_data;
|
2012-03-08 15:02:04 +01:00
|
|
|
struct ieee80211_supported_band *sband;
|
2012-05-16 23:43:19 +02:00
|
|
|
const u8 *ssidie, *ht_ie;
|
2011-08-17 14:18:15 +02:00
|
|
|
int i, err;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
ssidie = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
|
|
|
|
if (!ssidie)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
assoc_data = kzalloc(sizeof(*assoc_data) + req->ie_len, GFP_KERNEL);
|
|
|
|
if (!assoc_data)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
2010-02-28 11:13:46 +01:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->associated)
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
if (ifmgd->auth_data && !ifmgd->auth_data->done) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto err_free;
|
2009-12-23 13:15:35 +01:00
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->assoc_data) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto err_free;
|
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
if (ifmgd->auth_data) {
|
|
|
|
bool match;
|
|
|
|
|
|
|
|
/* keep sta info, bssid if matching */
|
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 20:56:52 +02:00
|
|
|
match = ether_addr_equal(ifmgd->bssid, req->bss->bssid);
|
2012-01-20 13:55:27 +01:00
|
|
|
ieee80211_destroy_auth_data(sdata, match);
|
2011-08-17 14:18:15 +02:00
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* prepare assoc data */
|
2012-08-01 20:13:36 +02:00
|
|
|
|
mac80211: Add validity check for beacon_crc value
On association to an AP, after receiving beacons, the beacon_crc value is set.
The beacon_crc value is not reset in disassociation, but the BSS data may be
expired at a later point. When associating again, it's possible that a
beacon for the AP is not received, resulting in the beacon_ies to remain NULL.
After association, further beacons will not update the beacon data, as the
crc value of the beacon has not changed, and the beacon_crc still holds a
value matching the beacon. The beacon_ies will remain forever null.
One of the results of this is that WLAN power save cannot be entered, the STA
will remain foreven in active mode.
Fix this by adding a validation flag for the beacon_crc, which is cleared on
association.
Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-10-01 15:02:31 +02:00
|
|
|
ifmgd->beacon_crc_valid = false;
|
|
|
|
|
2012-03-08 15:02:03 +01:00
|
|
|
/*
|
|
|
|
* IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode.
|
|
|
|
* We still associate in non-HT mode (11a/b/g) if any one of these
|
|
|
|
* ciphers is configured as pairwise.
|
|
|
|
* We can set this to true for non-11n hardware, that'll be checked
|
|
|
|
* separately along with the peer capabilities.
|
|
|
|
*/
|
2012-05-30 15:57:00 +02:00
|
|
|
for (i = 0; i < req->crypto.n_ciphers_pairwise; i++) {
|
2009-07-07 03:45:17 +02:00
|
|
|
if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
|
|
|
|
req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
|
2012-05-30 15:57:00 +02:00
|
|
|
req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104) {
|
2012-11-22 14:32:09 +01:00
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_HT;
|
2012-07-24 05:33:10 +02:00
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
|
2012-05-30 15:57:00 +02:00
|
|
|
netdev_info(sdata->dev,
|
2012-07-24 05:33:10 +02:00
|
|
|
"disabling HT/VHT due to WEP/TKIP use\n");
|
2012-05-30 15:57:00 +02:00
|
|
|
}
|
|
|
|
}
|
2009-07-07 03:45:17 +02:00
|
|
|
|
2012-07-24 05:33:10 +02:00
|
|
|
if (req->flags & ASSOC_REQ_DISABLE_HT) {
|
2012-11-22 14:32:09 +01:00
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_HT;
|
2012-07-24 05:33:10 +02:00
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
|
|
|
|
}
|
2011-11-18 20:32:00 +01:00
|
|
|
|
2012-03-08 15:02:04 +01:00
|
|
|
/* Also disable HT if we don't support it or the AP doesn't use WMM */
|
|
|
|
sband = local->hw.wiphy->bands[req->bss->channel->band];
|
|
|
|
if (!sband->ht_cap.ht_supported ||
|
2012-05-30 15:57:00 +02:00
|
|
|
local->hw.queues < IEEE80211_NUM_ACS || !bss->wmm_used) {
|
2012-11-22 14:32:09 +01:00
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_HT;
|
2012-07-27 10:29:14 +02:00
|
|
|
if (!bss->wmm_used)
|
|
|
|
netdev_info(sdata->dev,
|
|
|
|
"disabling HT as WMM/QoS is not supported by the AP\n");
|
2012-05-30 15:57:00 +02:00
|
|
|
}
|
2012-03-08 15:02:04 +01:00
|
|
|
|
2012-07-24 05:33:10 +02:00
|
|
|
/* disable VHT if we don't support it or the AP doesn't use WMM */
|
|
|
|
if (!sband->vht_cap.vht_supported ||
|
|
|
|
local->hw.queues < IEEE80211_NUM_ACS || !bss->wmm_used) {
|
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
|
2012-07-27 10:29:14 +02:00
|
|
|
if (!bss->wmm_used)
|
|
|
|
netdev_info(sdata->dev,
|
|
|
|
"disabling VHT as WMM/QoS is not supported by the AP\n");
|
2012-07-24 05:33:10 +02:00
|
|
|
}
|
|
|
|
|
2011-11-18 20:32:00 +01:00
|
|
|
memcpy(&ifmgd->ht_capa, &req->ht_capa, sizeof(ifmgd->ht_capa));
|
|
|
|
memcpy(&ifmgd->ht_capa_mask, &req->ht_capa_mask,
|
|
|
|
sizeof(ifmgd->ht_capa_mask));
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
if (req->ie && req->ie_len) {
|
2012-01-20 13:55:27 +01:00
|
|
|
memcpy(assoc_data->ie, req->ie, req->ie_len);
|
|
|
|
assoc_data->ie_len = req->ie_len;
|
|
|
|
}
|
2009-12-23 13:15:34 +01:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
assoc_data->bss = req->bss;
|
2009-12-23 13:15:34 +01:00
|
|
|
|
2009-12-23 13:15:35 +01:00
|
|
|
if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) {
|
|
|
|
if (ifmgd->powersave)
|
2012-09-11 14:34:12 +02:00
|
|
|
sdata->smps_mode = IEEE80211_SMPS_DYNAMIC;
|
2009-12-23 13:15:35 +01:00
|
|
|
else
|
2012-09-11 14:34:12 +02:00
|
|
|
sdata->smps_mode = IEEE80211_SMPS_OFF;
|
2009-12-23 13:15:35 +01:00
|
|
|
} else
|
2012-09-11 14:34:12 +02:00
|
|
|
sdata->smps_mode = ifmgd->req_smps;
|
2009-12-23 13:15:35 +01:00
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
assoc_data->capability = req->bss->capability;
|
2012-03-28 11:04:29 +02:00
|
|
|
assoc_data->wmm = bss->wmm_used &&
|
|
|
|
(local->hw.queues >= IEEE80211_NUM_ACS);
|
2012-01-20 13:55:27 +01:00
|
|
|
assoc_data->supp_rates = bss->supp_rates;
|
|
|
|
assoc_data->supp_rates_len = bss->supp_rates_len;
|
2012-05-16 23:43:19 +02:00
|
|
|
|
|
|
|
ht_ie = ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_OPERATION);
|
|
|
|
if (ht_ie && ht_ie[1] >= sizeof(struct ieee80211_ht_operation))
|
|
|
|
assoc_data->ap_ht_param =
|
|
|
|
((struct ieee80211_ht_operation *)(ht_ie + 2))->ht_param;
|
|
|
|
else
|
2012-11-22 14:32:09 +01:00
|
|
|
ifmgd->flags |= IEEE80211_STA_DISABLE_HT;
|
2009-12-23 13:15:33 +01:00
|
|
|
|
2010-01-12 09:42:31 +01:00
|
|
|
if (bss->wmm_used && bss->uapsd_supported &&
|
|
|
|
(sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
|
2012-03-08 15:02:05 +01:00
|
|
|
assoc_data->uapsd = true;
|
2010-01-12 09:42:31 +01:00
|
|
|
ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
|
|
|
|
} else {
|
2012-03-08 15:02:05 +01:00
|
|
|
assoc_data->uapsd = false;
|
2010-01-12 09:42:31 +01:00
|
|
|
ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED;
|
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
memcpy(assoc_data->ssid, ssidie + 2, ssidie[1]);
|
|
|
|
assoc_data->ssid_len = ssidie[1];
|
2009-12-23 13:15:33 +01:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
if (req->prev_bssid)
|
2012-01-20 13:55:27 +01:00
|
|
|
memcpy(assoc_data->prev_bssid, req->prev_bssid, ETH_ALEN);
|
2009-07-07 03:45:17 +02:00
|
|
|
|
|
|
|
if (req->use_mfp) {
|
|
|
|
ifmgd->mfp = IEEE80211_MFP_REQUIRED;
|
|
|
|
ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
|
|
|
|
} else {
|
|
|
|
ifmgd->mfp = IEEE80211_MFP_DISABLED;
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->crypto.control_port)
|
|
|
|
ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
|
|
|
|
else
|
|
|
|
ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
|
|
|
|
|
2010-08-27 13:26:54 +02:00
|
|
|
sdata->control_port_protocol = req->crypto.control_port_ethertype;
|
|
|
|
sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
/* kick off associate process */
|
|
|
|
|
|
|
|
ifmgd->assoc_data = assoc_data;
|
|
|
|
|
2012-03-08 15:02:07 +01:00
|
|
|
err = ieee80211_prep_connection(sdata, req->bss, true);
|
|
|
|
if (err)
|
|
|
|
goto err_clear;
|
2012-01-20 13:55:27 +01:00
|
|
|
|
|
|
|
if (!bss->dtim_period &&
|
|
|
|
sdata->local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD) {
|
|
|
|
/*
|
|
|
|
* Wait up to one beacon interval ...
|
|
|
|
* should this be more if we miss one?
|
|
|
|
*/
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "waiting for beacon from %pM\n",
|
|
|
|
ifmgd->bssid);
|
2012-03-28 21:02:46 +02:00
|
|
|
assoc_data->timeout = TU_TO_EXP_TIME(req->bss->beacon_interval);
|
2012-01-20 13:55:27 +01:00
|
|
|
} else {
|
|
|
|
assoc_data->have_beacon = true;
|
|
|
|
assoc_data->sent_assoc = false;
|
|
|
|
assoc_data->timeout = jiffies;
|
|
|
|
}
|
|
|
|
run_again(ifmgd, assoc_data->timeout);
|
|
|
|
|
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-24 02:59:53 +01:00
|
|
|
if (bss->corrupt_data) {
|
|
|
|
char *corrupt_type = "data";
|
|
|
|
if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_BEACON) {
|
|
|
|
if (bss->corrupt_data &
|
|
|
|
IEEE80211_BSS_CORRUPT_PROBE_RESP)
|
|
|
|
corrupt_type = "beacon and probe response";
|
|
|
|
else
|
|
|
|
corrupt_type = "beacon";
|
|
|
|
} else if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_PROBE_RESP)
|
|
|
|
corrupt_type = "probe response";
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata, "associating with AP with corrupt %s\n",
|
|
|
|
corrupt_type);
|
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-24 02:59:53 +01:00
|
|
|
}
|
|
|
|
|
2012-01-20 13:55:27 +01:00
|
|
|
err = 0;
|
|
|
|
goto out;
|
|
|
|
err_clear:
|
2012-09-04 16:44:45 +02:00
|
|
|
memset(ifmgd->bssid, 0, ETH_ALEN);
|
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
|
2012-01-20 13:55:27 +01:00
|
|
|
ifmgd->assoc_data = NULL;
|
|
|
|
err_free:
|
|
|
|
kfree(assoc_data);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
|
|
|
|
return err;
|
2007-05-05 20:45:53 +02:00
|
|
|
}
|
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
|
2012-02-24 13:50:51 +01:00
|
|
|
struct cfg80211_deauth_request *req)
|
2007-05-05 20:45:53 +02:00
|
|
|
{
|
2009-02-15 12:44:28 +01:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2012-09-07 13:28:52 +02:00
|
|
|
u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
|
2012-10-15 14:52:41 +02:00
|
|
|
bool tx = !req->local_state_change;
|
2012-10-29 09:46:31 +01:00
|
|
|
bool sent_frame = false;
|
2007-05-05 20:45:53 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"deauthenticating from %pM by local choice (reason=%d)\n",
|
|
|
|
req->bssid, req->reason_code);
|
2009-09-26 14:45:41 +02:00
|
|
|
|
2012-10-29 09:46:31 +01:00
|
|
|
if (ifmgd->auth_data) {
|
2012-07-25 00:42:36 +02:00
|
|
|
drv_mgd_prepare_tx(sdata->local, sdata);
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_send_deauth_disassoc(sdata, req->bssid,
|
|
|
|
IEEE80211_STYPE_DEAUTH,
|
2012-10-15 14:52:41 +02:00
|
|
|
req->reason_code, tx,
|
2012-02-24 13:50:54 +01:00
|
|
|
frame_buf);
|
2012-10-29 09:46:31 +01:00
|
|
|
ieee80211_destroy_auth_data(sdata, false);
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
|
|
|
|
sent_frame = tx;
|
|
|
|
goto out;
|
2012-07-25 00:42:36 +02:00
|
|
|
}
|
|
|
|
|
2012-10-29 09:46:31 +01:00
|
|
|
if (ifmgd->associated &&
|
|
|
|
ether_addr_equal(ifmgd->associated->bssid, req->bssid)) {
|
|
|
|
ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
|
|
|
|
req->reason_code, tx, frame_buf);
|
|
|
|
sent_frame = tx;
|
|
|
|
}
|
2012-02-24 13:50:54 +01:00
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
|
2012-10-29 09:46:31 +01:00
|
|
|
out:
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
2009-11-29 12:19:06 +01:00
|
|
|
ieee80211_recalc_idle(sdata->local);
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2009-11-29 12:19:06 +01:00
|
|
|
|
2012-10-29 09:46:31 +01:00
|
|
|
if (sent_frame)
|
|
|
|
__cfg80211_send_deauth(sdata->dev, frame_buf,
|
|
|
|
IEEE80211_DEAUTH_FRAME_LEN);
|
|
|
|
|
2007-05-05 20:45:53 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-05 01:59:58 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
|
2012-02-24 13:50:51 +01:00
|
|
|
struct cfg80211_disassoc_request *req)
|
2008-09-11 00:01:52 +02:00
|
|
|
{
|
2009-07-07 03:45:17 +02:00
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
2010-03-30 08:29:31 +02:00
|
|
|
u8 bssid[ETH_ALEN];
|
2012-09-07 13:28:52 +02:00
|
|
|
u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
|
2008-09-11 00:01:52 +02:00
|
|
|
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_lock(&ifmgd->mtx);
|
2009-04-16 13:17:25 +02:00
|
|
|
|
2009-07-25 11:58:36 +02:00
|
|
|
/*
|
|
|
|
* cfg80211 should catch this ... but it's racy since
|
|
|
|
* we can receive a disassoc frame, process it, hand it
|
|
|
|
* to cfg80211 while that's in a locked section already
|
|
|
|
* trying to tell us that the user wants to disconnect.
|
|
|
|
*/
|
2009-12-23 13:15:39 +01:00
|
|
|
if (ifmgd->associated != req->bss) {
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
return -ENOLINK;
|
|
|
|
}
|
|
|
|
|
2012-06-22 11:29:50 +02:00
|
|
|
sdata_info(sdata,
|
|
|
|
"disassociating from %pM by local choice (reason=%d)\n",
|
|
|
|
req->bss->bssid, req->reason_code);
|
2009-09-26 14:45:41 +02:00
|
|
|
|
2010-03-30 08:29:31 +02:00
|
|
|
memcpy(bssid, req->bss->bssid, ETH_ALEN);
|
2012-02-24 13:50:54 +01:00
|
|
|
ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DISASSOC,
|
|
|
|
req->reason_code, !req->local_state_change,
|
|
|
|
frame_buf);
|
2009-07-07 03:45:17 +02:00
|
|
|
mutex_unlock(&ifmgd->mtx);
|
2009-04-16 13:17:25 +02:00
|
|
|
|
2012-09-07 13:28:52 +02:00
|
|
|
__cfg80211_send_disassoc(sdata->dev, frame_buf,
|
|
|
|
IEEE80211_DEAUTH_FRAME_LEN);
|
2009-11-29 12:19:06 +01:00
|
|
|
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_lock(&sdata->local->mtx);
|
2009-11-29 12:19:06 +01:00
|
|
|
ieee80211_recalc_idle(sdata->local);
|
2010-08-05 17:02:38 +02:00
|
|
|
mutex_unlock(&sdata->local->mtx);
|
2009-11-29 12:19:06 +01:00
|
|
|
|
2009-04-16 13:17:25 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2010-02-15 11:53:10 +01:00
|
|
|
|
2012-04-23 13:45:15 +02:00
|
|
|
void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata)
|
2012-02-25 21:48:08 +01:00
|
|
|
{
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
|
|
|
mutex_lock(&ifmgd->mtx);
|
|
|
|
if (ifmgd->assoc_data)
|
|
|
|
ieee80211_destroy_assoc_data(sdata, false);
|
|
|
|
if (ifmgd->auth_data)
|
|
|
|
ieee80211_destroy_auth_data(sdata, false);
|
|
|
|
del_timer_sync(&ifmgd->timer);
|
|
|
|
mutex_unlock(&ifmgd->mtx);
|
|
|
|
}
|
|
|
|
|
2010-03-23 08:02:34 +01:00
|
|
|
void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
|
|
|
|
enum nl80211_cqm_rssi_threshold_event rssi_event,
|
|
|
|
gfp_t gfp)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_cqm_rssi_notify(sdata, rssi_event);
|
|
|
|
|
2010-03-23 08:02:34 +01:00
|
|
|
cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_cqm_rssi_notify);
|