2007-07-27 20:43:23 +07:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
|
|
* Copyright 2007 Johannes Berg <johannes@sipsolutions.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.
|
|
|
|
*
|
|
|
|
* utilities for mac80211
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include <linux/netdevice.h>
|
2011-07-15 22:47:34 +07:00
|
|
|
#include <linux/export.h>
|
2007-07-27 20:43:23 +07:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/bitmap.h>
|
2011-11-18 22:54:50 +07:00
|
|
|
#include <linux/crc32.h>
|
2007-09-18 01:56:21 +07:00
|
|
|
#include <net/net_namespace.h>
|
2007-07-27 20:43:23 +07:00
|
|
|
#include <net/cfg80211.h>
|
2007-11-09 07:57:29 +07:00
|
|
|
#include <net/rtnetlink.h>
|
2007-07-27 20:43:23 +07:00
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 23:52:52 +07:00
|
|
|
#include "driver-ops.h"
|
2008-04-09 02:14:40 +07:00
|
|
|
#include "rate.h"
|
2008-02-23 21:17:11 +07:00
|
|
|
#include "mesh.h"
|
2007-07-27 20:43:23 +07:00
|
|
|
#include "wme.h"
|
2009-04-14 15:09:24 +07:00
|
|
|
#include "led.h"
|
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 19:22:54 +07:00
|
|
|
#include "wep.h"
|
2007-07-27 20:43:23 +07:00
|
|
|
|
|
|
|
/* privid for wiphys to determine whether they belong to us or not */
|
2014-01-21 05:55:44 +07:00
|
|
|
const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2009-01-23 06:05:53 +07:00
|
|
|
struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
BUG_ON(!wiphy);
|
|
|
|
|
|
|
|
local = wiphy_priv(wiphy);
|
|
|
|
return &local->hw;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2007-12-25 22:00:36 +07:00
|
|
|
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
|
2008-09-11 05:01:58 +07:00
|
|
|
enum nl80211_iftype type)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
2008-06-12 04:21:58 +07:00
|
|
|
__le16 fc = hdr->frame_control;
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2007-12-18 22:23:53 +07:00
|
|
|
/* drop ACK/CTS frames and incorrect hdr len (ctrl) */
|
|
|
|
if (len < 16)
|
2007-07-27 20:43:23 +07:00
|
|
|
return NULL;
|
|
|
|
|
2008-06-12 04:21:58 +07:00
|
|
|
if (ieee80211_is_data(fc)) {
|
2007-12-18 22:23:53 +07:00
|
|
|
if (len < 24) /* drop incorrect hdr len (data) */
|
|
|
|
return NULL;
|
2008-06-12 04:21:58 +07:00
|
|
|
|
|
|
|
if (ieee80211_has_a4(fc))
|
2007-07-27 20:43:23 +07:00
|
|
|
return NULL;
|
2008-06-12 04:21:58 +07:00
|
|
|
if (ieee80211_has_tods(fc))
|
|
|
|
return hdr->addr1;
|
|
|
|
if (ieee80211_has_fromds(fc))
|
2007-07-27 20:43:23 +07:00
|
|
|
return hdr->addr2;
|
2008-06-12 04:21:58 +07:00
|
|
|
|
|
|
|
return hdr->addr3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_mgmt(fc)) {
|
2007-12-18 22:23:53 +07:00
|
|
|
if (len < 24) /* drop incorrect hdr len (mgmt) */
|
|
|
|
return NULL;
|
2007-07-27 20:43:23 +07:00
|
|
|
return hdr->addr3;
|
2008-06-12 04:21:58 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_ctl(fc)) {
|
2013-12-18 14:44:16 +07:00
|
|
|
if (ieee80211_is_pspoll(fc))
|
2007-07-27 20:43:23 +07:00
|
|
|
return hdr->addr1;
|
2008-06-12 04:21:58 +07:00
|
|
|
|
|
|
|
if (ieee80211_is_back_req(fc)) {
|
2007-12-25 22:00:36 +07:00
|
|
|
switch (type) {
|
2008-09-11 05:01:58 +07:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2007-12-25 22:00:36 +07:00
|
|
|
return hdr->addr2;
|
2008-09-11 05:01:58 +07:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2007-12-25 22:00:36 +07:00
|
|
|
return hdr->addr1;
|
|
|
|
default:
|
2008-06-12 04:21:58 +07:00
|
|
|
break; /* fall through to the return */
|
2007-12-25 22:00:36 +07:00
|
|
|
}
|
|
|
|
}
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-25 22:27:43 +07:00
|
|
|
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
2011-11-16 21:28:55 +07:00
|
|
|
struct sk_buff *skb;
|
2009-03-23 23:28:35 +07:00
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
|
2011-11-16 21:28:55 +07:00
|
|
|
skb_queue_walk(&tx->skbs, skb) {
|
2009-03-23 23:28:35 +07:00
|
|
|
hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
2011-11-16 21:28:55 +07:00
|
|
|
}
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
|
|
|
|
2012-04-11 13:47:56 +07:00
|
|
|
int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
|
2013-07-08 21:55:51 +07:00
|
|
|
int rate, int erp, int short_preamble,
|
|
|
|
int shift)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
|
|
|
int dur;
|
|
|
|
|
|
|
|
/* calculate duration (in microseconds, rounded up to next higher
|
|
|
|
* integer if it includes a fractional microsecond) to send frame of
|
|
|
|
* len bytes (does not include FCS) at the given rate. Duration will
|
|
|
|
* also include SIFS.
|
|
|
|
*
|
|
|
|
* rate is in 100 kbps, so divident is multiplied by 10 in the
|
|
|
|
* DIV_ROUND_UP() operations.
|
2013-07-08 21:55:51 +07:00
|
|
|
*
|
|
|
|
* shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
|
|
|
|
* is assumed to be 0 otherwise.
|
2007-07-27 20:43:23 +07:00
|
|
|
*/
|
|
|
|
|
2012-04-11 13:47:56 +07:00
|
|
|
if (band == IEEE80211_BAND_5GHZ || erp) {
|
2007-07-27 20:43:23 +07:00
|
|
|
/*
|
|
|
|
* OFDM:
|
|
|
|
*
|
|
|
|
* N_DBPS = DATARATE x 4
|
|
|
|
* N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
|
|
|
|
* (16 = SIGNAL time, 6 = tail bits)
|
|
|
|
* TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
|
|
|
|
*
|
|
|
|
* T_SYM = 4 usec
|
2013-07-08 21:55:51 +07:00
|
|
|
* 802.11a - 18.5.2: aSIFSTime = 16 usec
|
2007-07-27 20:43:23 +07:00
|
|
|
* 802.11g - 19.8.4: aSIFSTime = 10 usec +
|
|
|
|
* signal ext = 6 usec
|
|
|
|
*/
|
|
|
|
dur = 16; /* SIFS + signal ext */
|
2013-07-08 21:55:51 +07:00
|
|
|
dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
|
|
|
|
dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
|
|
|
|
|
|
|
|
/* IEEE 802.11-2012 18.3.2.4: all values above are:
|
|
|
|
* * times 4 for 5 MHz
|
|
|
|
* * times 2 for 10 MHz
|
|
|
|
*/
|
|
|
|
dur *= 1 << shift;
|
2013-07-08 21:55:53 +07:00
|
|
|
|
|
|
|
/* rates should already consider the channel bandwidth,
|
|
|
|
* don't apply divisor again.
|
|
|
|
*/
|
|
|
|
dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
|
|
|
|
4 * rate); /* T_SYM x N_SYM */
|
2007-07-27 20:43:23 +07:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* 802.11b or 802.11g with 802.11b compatibility:
|
|
|
|
* 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
|
|
|
|
* Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
|
|
|
|
*
|
|
|
|
* 802.11 (DS): 15.3.3, 802.11b: 18.3.4
|
|
|
|
* aSIFSTime = 10 usec
|
|
|
|
* aPreambleLength = 144 usec or 72 usec with short preamble
|
|
|
|
* aPLCPHeaderLength = 48 usec or 24 usec with short preamble
|
|
|
|
*/
|
|
|
|
dur = 10; /* aSIFSTime = 10 usec */
|
|
|
|
dur += short_preamble ? (72 + 24) : (144 + 48);
|
|
|
|
|
|
|
|
dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dur;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exported duration function for driver use */
|
2007-12-19 07:31:26 +07:00
|
|
|
__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2012-04-11 13:47:56 +07:00
|
|
|
enum ieee80211_band band,
|
2008-01-25 01:38:38 +07:00
|
|
|
size_t frame_len,
|
|
|
|
struct ieee80211_rate *rate)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
2008-09-13 03:52:47 +07:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-07-27 20:43:23 +07:00
|
|
|
u16 dur;
|
2013-07-08 21:55:51 +07:00
|
|
|
int erp, shift = 0;
|
2008-09-13 03:52:47 +07:00
|
|
|
bool short_preamble = false;
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2008-01-25 01:38:38 +07:00
|
|
|
erp = 0;
|
2008-09-13 03:52:47 +07:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-11 06:51:51 +07:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-13 03:52:47 +07:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
2013-07-08 21:55:51 +07:00
|
|
|
shift = ieee80211_vif_get_shift(vif);
|
2008-09-13 03:52:47 +07:00
|
|
|
}
|
2008-01-25 01:38:38 +07:00
|
|
|
|
2012-04-11 13:47:56 +07:00
|
|
|
dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
|
2013-07-08 21:55:51 +07:00
|
|
|
short_preamble, shift);
|
2007-07-27 20:43:23 +07:00
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_generic_frame_duration);
|
|
|
|
|
2007-12-19 07:31:26 +07:00
|
|
|
__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif, size_t frame_len,
|
2008-05-15 17:55:29 +07:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-13 03:52:47 +07:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 20:32:58 +07:00
|
|
|
bool short_preamble;
|
2013-07-08 21:55:53 +07:00
|
|
|
int erp, shift = 0, bitrate;
|
2007-07-27 20:43:23 +07:00
|
|
|
u16 dur;
|
2008-05-15 17:55:27 +07:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
2012-04-11 13:47:56 +07:00
|
|
|
sband = local->hw.wiphy->bands[frame_txctl->band];
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2008-09-13 03:52:47 +07:00
|
|
|
short_preamble = false;
|
2007-07-27 20:43:24 +07:00
|
|
|
|
2008-05-15 17:55:29 +07:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-25 01:38:38 +07:00
|
|
|
|
|
|
|
erp = 0;
|
2008-09-13 03:52:47 +07:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-11 06:51:51 +07:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-13 03:52:47 +07:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
2013-07-08 21:55:51 +07:00
|
|
|
shift = ieee80211_vif_get_shift(vif);
|
2008-09-13 03:52:47 +07:00
|
|
|
}
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
|
|
|
|
|
2007-07-27 20:43:23 +07:00
|
|
|
/* CTS duration */
|
2013-07-08 21:55:53 +07:00
|
|
|
dur = ieee80211_frame_duration(sband->band, 10, bitrate,
|
2013-07-08 21:55:51 +07:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 20:43:23 +07:00
|
|
|
/* Data frame duration */
|
2013-07-08 21:55:53 +07:00
|
|
|
dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
|
2013-07-08 21:55:51 +07:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 20:43:23 +07:00
|
|
|
/* ACK duration */
|
2013-07-08 21:55:53 +07:00
|
|
|
dur += ieee80211_frame_duration(sband->band, 10, bitrate,
|
2013-07-08 21:55:51 +07:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 20:43:23 +07:00
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_rts_duration);
|
|
|
|
|
2007-12-19 07:31:26 +07:00
|
|
|
__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2007-07-27 20:43:23 +07:00
|
|
|
size_t frame_len,
|
2008-05-15 17:55:29 +07:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-13 03:52:47 +07:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 20:32:58 +07:00
|
|
|
bool short_preamble;
|
2013-07-08 21:55:53 +07:00
|
|
|
int erp, shift = 0, bitrate;
|
2007-07-27 20:43:23 +07:00
|
|
|
u16 dur;
|
2008-05-15 17:55:27 +07:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
2012-04-11 13:47:56 +07:00
|
|
|
sband = local->hw.wiphy->bands[frame_txctl->band];
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2008-09-13 03:52:47 +07:00
|
|
|
short_preamble = false;
|
2007-07-27 20:43:24 +07:00
|
|
|
|
2008-05-15 17:55:29 +07:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-25 01:38:38 +07:00
|
|
|
erp = 0;
|
2008-09-13 03:52:47 +07:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-11 06:51:51 +07:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-13 03:52:47 +07:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
2013-07-08 21:55:51 +07:00
|
|
|
shift = ieee80211_vif_get_shift(vif);
|
2008-09-13 03:52:47 +07:00
|
|
|
}
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
|
|
|
|
|
2007-07-27 20:43:23 +07:00
|
|
|
/* Data frame duration */
|
2013-07-08 21:55:53 +07:00
|
|
|
dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
|
2013-07-08 21:55:51 +07:00
|
|
|
erp, short_preamble, shift);
|
2008-05-15 17:55:29 +07:00
|
|
|
if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
|
2007-07-27 20:43:23 +07:00
|
|
|
/* ACK duration */
|
2013-07-08 21:55:53 +07:00
|
|
|
dur += ieee80211_frame_duration(sband->band, 10, bitrate,
|
2013-07-08 21:55:51 +07:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_ctstoself_duration);
|
|
|
|
|
2012-04-03 21:28:50 +07:00
|
|
|
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-07-04 17:49:59 +07:00
|
|
|
int n_acs = IEEE80211_NUM_ACS;
|
|
|
|
|
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
n_acs = 1;
|
2012-04-03 21:28:50 +07:00
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
2012-06-19 01:07:15 +07:00
|
|
|
if (!sdata->dev)
|
|
|
|
continue;
|
|
|
|
|
2012-04-03 21:28:50 +07:00
|
|
|
if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
|
|
|
|
local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
|
|
|
|
continue;
|
|
|
|
|
2012-07-04 17:49:59 +07:00
|
|
|
for (ac = 0; ac < n_acs; ac++) {
|
2012-04-03 21:28:50 +07:00
|
|
|
int ac_queue = sdata->vif.hw_queue[ac];
|
|
|
|
|
|
|
|
if (ac_queue == queue ||
|
|
|
|
(sdata->vif.cab_queue == queue &&
|
|
|
|
local->queue_stop_reasons[ac_queue] == 0 &&
|
|
|
|
skb_queue_empty(&local->pending[ac_queue])))
|
|
|
|
netif_wake_subqueue(sdata->dev, ac);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-19 04:35:20 +07:00
|
|
|
static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2010-04-07 21:48:40 +07:00
|
|
|
trace_wake_queue(local, queue, reason);
|
|
|
|
|
2009-03-23 23:28:42 +07:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return;
|
2008-12-19 04:35:20 +07:00
|
|
|
|
2012-03-28 16:04:27 +07:00
|
|
|
if (!test_bit(reason, &local->queue_stop_reasons[queue]))
|
|
|
|
return;
|
|
|
|
|
2014-06-13 20:30:05 +07:00
|
|
|
if (!refcounted)
|
|
|
|
local->q_stop_reasons[queue][reason] = 0;
|
|
|
|
else
|
|
|
|
local->q_stop_reasons[queue][reason]--;
|
|
|
|
|
|
|
|
if (local->q_stop_reasons[queue][reason] == 0)
|
|
|
|
__clear_bit(reason, &local->queue_stop_reasons[queue]);
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 06:51:53 +07:00
|
|
|
|
|
|
|
if (local->queue_stop_reasons[queue] != 0)
|
|
|
|
/* someone still has this queue stopped */
|
|
|
|
return;
|
|
|
|
|
2010-03-23 03:42:43 +07:00
|
|
|
if (skb_queue_empty(&local->pending[queue])) {
|
|
|
|
rcu_read_lock();
|
2012-04-03 21:28:50 +07:00
|
|
|
ieee80211_propagate_queue_wake(local, queue);
|
2010-03-23 03:42:43 +07:00
|
|
|
rcu_read_unlock();
|
|
|
|
} else
|
2009-06-17 22:43:56 +07:00
|
|
|
tasklet_schedule(&local->tx_pending_tasklet);
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
2008-12-19 04:35:20 +07:00
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 06:51:53 +07:00
|
|
|
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2008-12-19 04:35:20 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2014-06-13 20:30:05 +07:00
|
|
|
__ieee80211_wake_queue(hw, queue, reason, refcounted);
|
2008-12-19 04:35:20 +07:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queue_by_reason(hw, queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2008-12-19 04:35:20 +07:00
|
|
|
}
|
2007-07-27 20:43:23 +07:00
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queue);
|
|
|
|
|
2008-12-19 04:35:20 +07:00
|
|
|
static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2010-01-06 00:00:58 +07:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-07-04 17:49:59 +07:00
|
|
|
int n_acs = IEEE80211_NUM_ACS;
|
2007-07-27 20:43:23 +07:00
|
|
|
|
2010-04-07 21:48:40 +07:00
|
|
|
trace_stop_queue(local, queue, reason);
|
|
|
|
|
2009-03-23 23:28:42 +07:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 06:51:53 +07:00
|
|
|
|
2014-06-13 20:30:05 +07:00
|
|
|
if (!refcounted)
|
|
|
|
local->q_stop_reasons[queue][reason] = 1;
|
|
|
|
else
|
|
|
|
local->q_stop_reasons[queue][reason]++;
|
2012-03-28 16:04:27 +07:00
|
|
|
|
2014-06-13 20:30:05 +07:00
|
|
|
if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue]))
|
|
|
|
return;
|
2010-01-06 00:00:58 +07:00
|
|
|
|
2012-07-04 17:49:59 +07:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
n_acs = 1;
|
|
|
|
|
2010-01-06 00:00:58 +07:00
|
|
|
rcu_read_lock();
|
2012-04-03 21:28:50 +07:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
2012-06-19 01:07:15 +07:00
|
|
|
if (!sdata->dev)
|
|
|
|
continue;
|
|
|
|
|
2012-07-04 17:49:59 +07:00
|
|
|
for (ac = 0; ac < n_acs; ac++) {
|
2012-04-03 21:28:50 +07:00
|
|
|
if (sdata->vif.hw_queue[ac] == queue ||
|
|
|
|
sdata->vif.cab_queue == queue)
|
|
|
|
netif_stop_subqueue(sdata->dev, ac);
|
|
|
|
}
|
|
|
|
}
|
2010-01-06 00:00:58 +07:00
|
|
|
rcu_read_unlock();
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
2008-12-19 04:35:20 +07:00
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 06:51:53 +07:00
|
|
|
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2008-12-19 04:35:20 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2014-06-13 20:30:05 +07:00
|
|
|
__ieee80211_stop_queue(hw, queue, reason, refcounted);
|
2008-12-19 04:35:20 +07:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queue_by_reason(hw, queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2008-12-19 04:35:20 +07:00
|
|
|
}
|
2007-07-27 20:43:23 +07:00
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queue);
|
|
|
|
|
2009-06-08 02:58:37 +07:00
|
|
|
void ieee80211_add_pending_skb(struct ieee80211_local *local,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
unsigned long flags;
|
2009-07-27 15:33:31 +07:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2012-04-03 21:28:50 +07:00
|
|
|
int queue = info->hw_queue;
|
2009-07-27 15:33:31 +07:00
|
|
|
|
|
|
|
if (WARN_ON(!info->control.vif)) {
|
2012-10-11 03:40:23 +07:00
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
2009-07-27 15:33:31 +07:00
|
|
|
return;
|
|
|
|
}
|
2009-06-08 02:58:37 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2014-06-13 20:30:05 +07:00
|
|
|
__ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
|
|
|
false);
|
2009-06-17 22:43:56 +07:00
|
|
|
__skb_queue_tail(&local->pending[queue], skb);
|
2014-06-13 20:30:05 +07:00
|
|
|
__ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
|
|
|
false);
|
2009-06-08 02:58:37 +07:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2014-02-20 17:19:58 +07:00
|
|
|
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
|
|
|
|
struct sk_buff_head *skbs)
|
2009-06-08 02:58:37 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned long flags;
|
2011-09-29 21:04:30 +07:00
|
|
|
int queue, i;
|
2009-06-08 02:58:37 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
while ((skb = skb_dequeue(skbs))) {
|
2009-07-27 15:33:31 +07:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
|
|
|
|
if (WARN_ON(!info->control.vif)) {
|
2012-10-11 03:40:23 +07:00
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
2009-07-27 15:33:31 +07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-04-03 21:28:50 +07:00
|
|
|
queue = info->hw_queue;
|
2012-03-28 16:04:28 +07:00
|
|
|
|
|
|
|
__ieee80211_stop_queue(hw, queue,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
|
|
|
false);
|
2012-03-28 16:04:28 +07:00
|
|
|
|
2009-06-17 22:43:56 +07:00
|
|
|
__skb_queue_tail(&local->pending[queue], skb);
|
2009-06-08 02:58:37 +07:00
|
|
|
}
|
|
|
|
|
2009-06-17 22:43:56 +07:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2009-06-08 02:58:37 +07:00
|
|
|
__ieee80211_wake_queue(hw, i,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
|
|
|
false);
|
2009-06-08 02:58:37 +07:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-12-19 04:35:20 +07:00
|
|
|
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
|
2013-02-13 18:25:28 +07:00
|
|
|
unsigned long queues,
|
2014-06-13 20:30:05 +07:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
2008-12-19 04:35:20 +07:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 20:43:23 +07:00
|
|
|
int i;
|
|
|
|
|
2008-12-19 04:35:20 +07:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
2013-02-13 18:25:28 +07:00
|
|
|
for_each_set_bit(i, &queues, hw->queues)
|
2014-06-13 20:30:05 +07:00
|
|
|
__ieee80211_stop_queue(hw, i, reason, refcounted);
|
2008-12-19 04:35:20 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
2013-02-13 18:25:28 +07:00
|
|
|
ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queues);
|
|
|
|
|
2008-07-25 01:02:04 +07:00
|
|
|
int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2009-06-17 22:43:56 +07:00
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 06:51:53 +07:00
|
|
|
|
2009-03-23 23:28:42 +07:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return true;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 06:51:53 +07:00
|
|
|
|
2009-06-17 22:43:56 +07:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2013-04-11 05:41:40 +07:00
|
|
|
ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
&local->queue_stop_reasons[queue]);
|
2009-06-17 22:43:56 +07:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
return ret;
|
2008-07-25 01:02:04 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_queue_stopped);
|
|
|
|
|
2008-12-19 04:35:20 +07:00
|
|
|
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
|
2013-02-13 18:25:28 +07:00
|
|
|
unsigned long queues,
|
2014-06-13 20:30:05 +07:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 20:43:23 +07:00
|
|
|
{
|
2008-12-19 04:35:20 +07:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 20:43:23 +07:00
|
|
|
int i;
|
|
|
|
|
2008-12-19 04:35:20 +07:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
2013-02-13 18:25:28 +07:00
|
|
|
for_each_set_bit(i, &queues, hw->queues)
|
2014-06-13 20:30:05 +07:00
|
|
|
__ieee80211_wake_queue(hw, i, reason, refcounted);
|
2008-12-19 04:35:20 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
2013-02-13 18:25:28 +07:00
|
|
|
ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2007-07-27 20:43:23 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queues);
|
2007-11-09 07:57:29 +07:00
|
|
|
|
2014-06-13 20:30:06 +07:00
|
|
|
static unsigned int
|
|
|
|
ieee80211_get_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
2013-02-13 18:11:00 +07:00
|
|
|
{
|
2014-06-13 20:30:06 +07:00
|
|
|
unsigned int queues;
|
2013-02-13 18:11:00 +07:00
|
|
|
|
|
|
|
if (sdata && local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) {
|
|
|
|
int ac;
|
|
|
|
|
|
|
|
queues = 0;
|
|
|
|
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
|
|
|
|
queues |= BIT(sdata->vif.hw_queue[ac]);
|
|
|
|
if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
|
|
|
|
queues |= BIT(sdata->vif.cab_queue);
|
|
|
|
} else {
|
|
|
|
/* all queues */
|
|
|
|
queues = BIT(local->hw.queues) - 1;
|
|
|
|
}
|
|
|
|
|
2014-06-13 20:30:06 +07:00
|
|
|
return queues;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_flush_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
unsigned int queues;
|
|
|
|
|
|
|
|
if (!local->ops->flush)
|
|
|
|
return;
|
|
|
|
|
|
|
|
queues = ieee80211_get_vif_queues(local, sdata);
|
|
|
|
|
2014-06-13 20:30:04 +07:00
|
|
|
ieee80211_stop_queues_by_reason(&local->hw, queues,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_FLUSH,
|
|
|
|
false);
|
2013-02-13 18:25:28 +07:00
|
|
|
|
2014-03-27 16:30:29 +07:00
|
|
|
drv_flush(local, sdata, queues, false);
|
2013-02-13 18:25:28 +07:00
|
|
|
|
2014-06-13 20:30:04 +07:00
|
|
|
ieee80211_wake_queues_by_reason(&local->hw, queues,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_FLUSH,
|
|
|
|
false);
|
2013-02-13 18:11:00 +07:00
|
|
|
}
|
|
|
|
|
2014-06-13 20:30:06 +07:00
|
|
|
void ieee80211_stop_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum queue_stop_reason reason)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queues_by_reason(&local->hw,
|
|
|
|
ieee80211_get_vif_queues(local, sdata),
|
|
|
|
reason, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum queue_stop_reason reason)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queues_by_reason(&local->hw,
|
|
|
|
ieee80211_get_vif_queues(local, sdata),
|
|
|
|
reason, true);
|
|
|
|
}
|
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
static void __iterate_active_interfaces(struct ieee80211_local *local,
|
|
|
|
u32 iter_flags,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
2007-11-09 07:57:29 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
2008-05-10 18:40:49 +07:00
|
|
|
switch (sdata->vif.type) {
|
2008-09-11 05:01:58 +07:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
2013-05-28 18:01:53 +07:00
|
|
|
if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
|
|
|
|
continue;
|
|
|
|
break;
|
2008-09-11 05:01:58 +07:00
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2008-05-10 18:40:49 +07:00
|
|
|
continue;
|
2010-09-16 19:58:23 +07:00
|
|
|
default:
|
2008-05-10 18:40:49 +07:00
|
|
|
break;
|
|
|
|
}
|
2012-11-07 02:23:30 +07:00
|
|
|
if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
|
|
|
|
!(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
|
|
|
continue;
|
2009-12-23 19:15:31 +07:00
|
|
|
if (ieee80211_sdata_running(sdata))
|
2009-11-25 23:46:19 +07:00
|
|
|
iterator(data, sdata->vif.addr,
|
2008-05-10 18:40:49 +07:00
|
|
|
&sdata->vif);
|
|
|
|
}
|
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
sdata = rcu_dereference_check(local->monitor_sdata,
|
|
|
|
lockdep_is_held(&local->iflist_mtx) ||
|
|
|
|
lockdep_rtnl_is_held());
|
2012-11-07 02:23:30 +07:00
|
|
|
if (sdata &&
|
|
|
|
(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL ||
|
|
|
|
sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
2012-07-11 21:38:09 +07:00
|
|
|
iterator(data, sdata->vif.addr, &sdata->vif);
|
2013-08-22 03:07:20 +07:00
|
|
|
}
|
2012-07-11 21:38:09 +07:00
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
void ieee80211_iterate_active_interfaces(
|
|
|
|
struct ieee80211_hw *hw, u32 iter_flags,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
__iterate_active_interfaces(local, iter_flags, iterator, data);
|
2009-01-24 04:54:03 +07:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2008-05-10 18:40:49 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
|
|
|
|
|
|
|
|
void ieee80211_iterate_active_interfaces_atomic(
|
2012-11-07 02:23:30 +07:00
|
|
|
struct ieee80211_hw *hw, u32 iter_flags,
|
2008-05-10 18:40:49 +07:00
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2007-11-28 16:55:32 +07:00
|
|
|
rcu_read_lock();
|
2013-08-22 03:07:20 +07:00
|
|
|
__iterate_active_interfaces(local, iter_flags, iterator, data);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
|
2007-11-09 07:57:29 +07:00
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
void ieee80211_iterate_active_interfaces_rtnl(
|
|
|
|
struct ieee80211_hw *hw, u32 iter_flags,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2007-11-28 16:55:32 +07:00
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
ASSERT_RTNL();
|
2012-07-11 21:38:09 +07:00
|
|
|
|
2013-08-22 03:07:20 +07:00
|
|
|
__iterate_active_interfaces(local, iter_flags, iterator, data);
|
2007-11-09 07:57:29 +07:00
|
|
|
}
|
2013-08-22 03:07:20 +07:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_rtnl);
|
2008-09-08 21:40:36 +07:00
|
|
|
|
2013-11-13 19:37:47 +07:00
|
|
|
struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
|
|
|
|
|
|
|
|
if (!ieee80211_sdata_running(sdata) ||
|
|
|
|
!(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
|
|
|
return NULL;
|
|
|
|
return &sdata->vif;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
|
|
|
|
|
2009-07-30 07:08:07 +07:00
|
|
|
/*
|
|
|
|
* Nothing should have been stuffed into the workqueue during
|
|
|
|
* the suspend->resume cycle. If this WARN is seen then there
|
|
|
|
* is a bug with either the driver suspend or something in
|
|
|
|
* mac80211 stuffing into the workqueue which we haven't yet
|
|
|
|
* cleared during mac80211's suspend cycle.
|
|
|
|
*/
|
|
|
|
static bool ieee80211_can_queue_work(struct ieee80211_local *local)
|
|
|
|
{
|
2009-11-19 20:29:39 +07:00
|
|
|
if (WARN(local->suspended && !local->resuming,
|
|
|
|
"queueing ieee80211 work while going to suspend\n"))
|
|
|
|
return false;
|
2009-07-30 07:08:07 +07:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
if (!ieee80211_can_queue_work(local))
|
|
|
|
return;
|
|
|
|
|
|
|
|
queue_work(local->workqueue, work);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_queue_work);
|
|
|
|
|
|
|
|
void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
|
|
|
|
struct delayed_work *dwork,
|
|
|
|
unsigned long delay)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
if (!ieee80211_can_queue_work(local))
|
|
|
|
return;
|
|
|
|
|
|
|
|
queue_delayed_work(local->workqueue, dwork, delay);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_queue_delayed_work);
|
|
|
|
|
2013-05-28 15:54:03 +07:00
|
|
|
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
|
2011-11-18 22:54:50 +07:00
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
u64 filter, u32 crc)
|
|
|
|
{
|
|
|
|
size_t left = len;
|
2013-05-28 15:54:03 +07:00
|
|
|
const u8 *pos = start;
|
2011-11-18 22:54:50 +07:00
|
|
|
bool calc_crc = filter != 0;
|
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 08:59:53 +07:00
|
|
|
DECLARE_BITMAP(seen_elems, 256);
|
2013-03-26 20:54:16 +07:00
|
|
|
const u8 *ie;
|
2011-11-18 22:54:50 +07:00
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 08:59:53 +07:00
|
|
|
bitmap_zero(seen_elems, 256);
|
2011-11-18 22:54:50 +07:00
|
|
|
memset(elems, 0, sizeof(*elems));
|
|
|
|
elems->ie_start = start;
|
|
|
|
elems->total_len = len;
|
|
|
|
|
|
|
|
while (left >= 2) {
|
|
|
|
u8 id, elen;
|
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 08:59:53 +07:00
|
|
|
bool elem_parse_failed;
|
2011-11-18 22:54:50 +07:00
|
|
|
|
|
|
|
id = *pos++;
|
|
|
|
elen = *pos++;
|
|
|
|
left -= 2;
|
|
|
|
|
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 08:59:53 +07:00
|
|
|
if (elen > left) {
|
|
|
|
elems->parse_error = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
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 08:59:53 +07:00
|
|
|
}
|
|
|
|
|
2012-10-24 19:19:53 +07:00
|
|
|
switch (id) {
|
|
|
|
case WLAN_EID_SSID:
|
|
|
|
case WLAN_EID_SUPP_RATES:
|
|
|
|
case WLAN_EID_FH_PARAMS:
|
|
|
|
case WLAN_EID_DS_PARAMS:
|
|
|
|
case WLAN_EID_CF_PARAMS:
|
|
|
|
case WLAN_EID_TIM:
|
|
|
|
case WLAN_EID_IBSS_PARAMS:
|
|
|
|
case WLAN_EID_CHALLENGE:
|
|
|
|
case WLAN_EID_RSN:
|
|
|
|
case WLAN_EID_ERP_INFO:
|
|
|
|
case WLAN_EID_EXT_SUPP_RATES:
|
|
|
|
case WLAN_EID_HT_CAPABILITY:
|
|
|
|
case WLAN_EID_HT_OPERATION:
|
|
|
|
case WLAN_EID_VHT_CAPABILITY:
|
|
|
|
case WLAN_EID_VHT_OPERATION:
|
|
|
|
case WLAN_EID_MESH_ID:
|
|
|
|
case WLAN_EID_MESH_CONFIG:
|
|
|
|
case WLAN_EID_PEER_MGMT:
|
|
|
|
case WLAN_EID_PREQ:
|
|
|
|
case WLAN_EID_PREP:
|
|
|
|
case WLAN_EID_PERR:
|
|
|
|
case WLAN_EID_RANN:
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH:
|
|
|
|
case WLAN_EID_EXT_CHANSWITCH_ANN:
|
|
|
|
case WLAN_EID_COUNTRY:
|
|
|
|
case WLAN_EID_PWR_CONSTRAINT:
|
|
|
|
case WLAN_EID_TIMEOUT_INTERVAL:
|
2013-03-26 00:29:27 +07:00
|
|
|
case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
|
2013-03-26 20:54:16 +07:00
|
|
|
case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
|
2013-10-15 09:08:27 +07:00
|
|
|
case WLAN_EID_CHAN_SWITCH_PARAM:
|
2013-03-26 20:54:16 +07:00
|
|
|
/*
|
|
|
|
* not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
|
|
|
|
* that if the content gets bigger it might be needed more than once
|
|
|
|
*/
|
2012-10-24 19:19:53 +07:00
|
|
|
if (test_bit(id, seen_elems)) {
|
|
|
|
elems->parse_error = true;
|
|
|
|
left -= elen;
|
|
|
|
pos += elen;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
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 08:59:53 +07:00
|
|
|
}
|
2011-11-18 22:54:50 +07:00
|
|
|
|
|
|
|
if (calc_crc && id < 64 && (filter & (1ULL << id)))
|
|
|
|
crc = crc32_be(crc, pos - 2, elen + 2);
|
|
|
|
|
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 08:59:53 +07:00
|
|
|
elem_parse_failed = false;
|
|
|
|
|
2011-11-18 22:54:50 +07:00
|
|
|
switch (id) {
|
|
|
|
case WLAN_EID_SSID:
|
|
|
|
elems->ssid = pos;
|
|
|
|
elems->ssid_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_SUPP_RATES:
|
|
|
|
elems->supp_rates = pos;
|
|
|
|
elems->supp_rates_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_DS_PARAMS:
|
2013-03-27 20:30:12 +07:00
|
|
|
if (elen >= 1)
|
|
|
|
elems->ds_params = pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_TIM:
|
|
|
|
if (elen >= sizeof(struct ieee80211_tim_ie)) {
|
|
|
|
elems->tim = (void *)pos;
|
|
|
|
elems->tim_len = elen;
|
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 08:59:53 +07:00
|
|
|
} else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_CHALLENGE:
|
|
|
|
elems->challenge = pos;
|
|
|
|
elems->challenge_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_VENDOR_SPECIFIC:
|
|
|
|
if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
|
|
|
|
pos[2] == 0xf2) {
|
|
|
|
/* Microsoft OUI (00:50:F2) */
|
|
|
|
|
|
|
|
if (calc_crc)
|
|
|
|
crc = crc32_be(crc, pos - 2, elen + 2);
|
|
|
|
|
2013-02-12 22:27:04 +07:00
|
|
|
if (elen >= 5 && pos[3] == 2) {
|
2011-11-18 22:54:50 +07:00
|
|
|
/* OUI Type 2 - WMM IE */
|
|
|
|
if (pos[4] == 0) {
|
|
|
|
elems->wmm_info = pos;
|
|
|
|
elems->wmm_info_len = elen;
|
|
|
|
} else if (pos[4] == 1) {
|
|
|
|
elems->wmm_param = pos;
|
|
|
|
elems->wmm_param_len = elen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WLAN_EID_RSN:
|
|
|
|
elems->rsn = pos;
|
|
|
|
elems->rsn_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_ERP_INFO:
|
2013-03-27 20:31:53 +07:00
|
|
|
if (elen >= 1)
|
|
|
|
elems->erp_info = pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_EXT_SUPP_RATES:
|
|
|
|
elems->ext_supp_rates = pos;
|
|
|
|
elems->ext_supp_rates_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_HT_CAPABILITY:
|
|
|
|
if (elen >= sizeof(struct ieee80211_ht_cap))
|
|
|
|
elems->ht_cap_elem = (void *)pos;
|
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 08:59:53 +07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
2012-03-16 01:45:16 +07:00
|
|
|
case WLAN_EID_HT_OPERATION:
|
|
|
|
if (elen >= sizeof(struct ieee80211_ht_operation))
|
|
|
|
elems->ht_operation = (void *)pos;
|
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 08:59:53 +07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
2012-10-10 18:33:04 +07:00
|
|
|
case WLAN_EID_VHT_CAPABILITY:
|
|
|
|
if (elen >= sizeof(struct ieee80211_vht_cap))
|
|
|
|
elems->vht_cap_elem = (void *)pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_VHT_OPERATION:
|
|
|
|
if (elen >= sizeof(struct ieee80211_vht_operation))
|
|
|
|
elems->vht_operation = (void *)pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
2013-02-08 04:24:55 +07:00
|
|
|
case WLAN_EID_OPMODE_NOTIF:
|
|
|
|
if (elen > 0)
|
|
|
|
elems->opmode_notif = pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
2011-11-18 22:54:50 +07:00
|
|
|
case WLAN_EID_MESH_ID:
|
|
|
|
elems->mesh_id = pos;
|
|
|
|
elems->mesh_id_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_MESH_CONFIG:
|
|
|
|
if (elen >= sizeof(struct ieee80211_meshconf_ie))
|
|
|
|
elems->mesh_config = (void *)pos;
|
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 08:59:53 +07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_PEER_MGMT:
|
|
|
|
elems->peering = pos;
|
|
|
|
elems->peering_len = elen;
|
|
|
|
break;
|
2013-01-31 00:14:08 +07:00
|
|
|
case WLAN_EID_MESH_AWAKE_WINDOW:
|
|
|
|
if (elen >= 2)
|
|
|
|
elems->awake_window = (void *)pos;
|
|
|
|
break;
|
2011-11-18 22:54:50 +07:00
|
|
|
case WLAN_EID_PREQ:
|
|
|
|
elems->preq = pos;
|
|
|
|
elems->preq_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PREP:
|
|
|
|
elems->prep = pos;
|
|
|
|
elems->prep_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PERR:
|
|
|
|
elems->perr = pos;
|
|
|
|
elems->perr_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_RANN:
|
|
|
|
if (elen >= sizeof(struct ieee80211_rann_ie))
|
|
|
|
elems->rann = (void *)pos;
|
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 08:59:53 +07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH:
|
2012-08-01 21:13:02 +07:00
|
|
|
if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->ch_switch_ie = (void *)pos;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
2013-03-26 20:13:58 +07:00
|
|
|
case WLAN_EID_EXT_CHANSWITCH_ANN:
|
|
|
|
if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->ext_chansw_ie = (void *)pos;
|
|
|
|
break;
|
2013-03-26 00:29:27 +07:00
|
|
|
case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
|
|
|
|
if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->sec_chan_offs = (void *)pos;
|
|
|
|
break;
|
2013-10-15 09:08:27 +07:00
|
|
|
case WLAN_EID_CHAN_SWITCH_PARAM:
|
|
|
|
if (elen !=
|
|
|
|
sizeof(*elems->mesh_chansw_params_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->mesh_chansw_params_ie = (void *)pos;
|
|
|
|
break;
|
2013-03-26 20:54:16 +07:00
|
|
|
case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
|
|
|
|
if (!action ||
|
|
|
|
elen != sizeof(*elems->wide_bw_chansw_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->wide_bw_chansw_ie = (void *)pos;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
|
|
|
|
if (action) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* This is a bit tricky, but as we only care about
|
|
|
|
* the wide bandwidth channel switch element, so
|
|
|
|
* just parse it out manually.
|
|
|
|
*/
|
|
|
|
ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
|
|
|
|
pos, elen);
|
|
|
|
if (ie) {
|
|
|
|
if (ie[1] == sizeof(*elems->wide_bw_chansw_ie))
|
|
|
|
elems->wide_bw_chansw_ie =
|
|
|
|
(void *)(ie + 2);
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
}
|
|
|
|
break;
|
2011-11-18 22:54:50 +07:00
|
|
|
case WLAN_EID_COUNTRY:
|
|
|
|
elems->country_elem = pos;
|
|
|
|
elems->country_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PWR_CONSTRAINT:
|
2012-09-05 18:07:00 +07:00
|
|
|
if (elen != 1) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
2011-11-18 22:54:50 +07:00
|
|
|
elems->pwr_constr_elem = pos;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_TIMEOUT_INTERVAL:
|
2013-03-27 20:38:07 +07:00
|
|
|
if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
|
|
|
|
elems->timeout_int = (void *)pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 22:54:50 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
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 08:59:53 +07:00
|
|
|
if (elem_parse_failed)
|
|
|
|
elems->parse_error = true;
|
|
|
|
else
|
2012-10-24 19:22:37 +07:00
|
|
|
__set_bit(id, seen_elems);
|
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 08:59:53 +07:00
|
|
|
|
2011-11-18 22:54:50 +07:00
|
|
|
left -= elen;
|
|
|
|
pos += elen;
|
|
|
|
}
|
|
|
|
|
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 08:59:53 +07:00
|
|
|
if (left != 0)
|
|
|
|
elems->parse_error = true;
|
|
|
|
|
2011-11-18 22:54:50 +07:00
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
2012-03-02 21:56:59 +07:00
|
|
|
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool bss_notify)
|
2008-09-09 17:56:01 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_tx_queue_params qparam;
|
2012-07-26 22:24:39 +07:00
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
2012-03-28 16:04:25 +07:00
|
|
|
int ac;
|
2012-05-30 15:56:46 +07:00
|
|
|
bool use_11b, enable_qos;
|
2009-05-07 21:16:24 +07:00
|
|
|
int aCWmin, aCWmax;
|
2008-09-09 17:56:01 +07:00
|
|
|
|
|
|
|
if (!local->ops->conf_tx)
|
|
|
|
return;
|
|
|
|
|
2012-03-28 16:04:25 +07:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
return;
|
|
|
|
|
2008-09-09 17:56:01 +07:00
|
|
|
memset(&qparam, 0, sizeof(qparam));
|
|
|
|
|
2012-07-26 22:24:39 +07:00
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
use_11b = (chanctx_conf &&
|
2012-11-09 17:39:59 +07:00
|
|
|
chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ) &&
|
2009-05-07 21:16:24 +07:00
|
|
|
!(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
|
2012-07-26 22:24:39 +07:00
|
|
|
rcu_read_unlock();
|
2008-09-09 17:56:01 +07:00
|
|
|
|
2012-05-30 15:56:46 +07:00
|
|
|
/*
|
|
|
|
* By default disable QoS in STA mode for old access points, which do
|
|
|
|
* not support 802.11e. New APs will provide proper queue parameters,
|
|
|
|
* that we will configure later.
|
|
|
|
*/
|
|
|
|
enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION);
|
|
|
|
|
2013-09-09 22:03:41 +07:00
|
|
|
/* Set defaults according to 802.11-2007 Table 7-37 */
|
|
|
|
aCWmax = 1023;
|
|
|
|
if (use_11b)
|
|
|
|
aCWmin = 31;
|
|
|
|
else
|
|
|
|
aCWmin = 15;
|
|
|
|
|
|
|
|
/* Confiure old 802.11b/g medium access rules. */
|
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
|
|
|
qparam.txop = 0;
|
|
|
|
qparam.aifs = 2;
|
2009-05-07 21:16:24 +07:00
|
|
|
|
2013-09-09 22:03:41 +07:00
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
/* Update if QoS is enabled. */
|
2012-05-30 15:56:46 +07:00
|
|
|
if (enable_qos) {
|
|
|
|
switch (ac) {
|
|
|
|
case IEEE80211_AC_BK:
|
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
|
|
|
qparam.txop = 0;
|
|
|
|
qparam.aifs = 7;
|
|
|
|
break;
|
|
|
|
/* never happens but let's not leave undefined */
|
|
|
|
default:
|
|
|
|
case IEEE80211_AC_BE:
|
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
|
|
|
qparam.txop = 0;
|
|
|
|
qparam.aifs = 3;
|
|
|
|
break;
|
|
|
|
case IEEE80211_AC_VI:
|
|
|
|
qparam.cw_max = aCWmin;
|
|
|
|
qparam.cw_min = (aCWmin + 1) / 2 - 1;
|
|
|
|
if (use_11b)
|
|
|
|
qparam.txop = 6016/32;
|
|
|
|
else
|
|
|
|
qparam.txop = 3008/32;
|
|
|
|
qparam.aifs = 2;
|
|
|
|
break;
|
|
|
|
case IEEE80211_AC_VO:
|
|
|
|
qparam.cw_max = (aCWmin + 1) / 2 - 1;
|
|
|
|
qparam.cw_min = (aCWmin + 1) / 4 - 1;
|
|
|
|
if (use_11b)
|
|
|
|
qparam.txop = 3264/32;
|
|
|
|
else
|
|
|
|
qparam.txop = 1504/32;
|
|
|
|
qparam.aifs = 2;
|
|
|
|
break;
|
|
|
|
}
|
2009-05-07 21:16:24 +07:00
|
|
|
}
|
2008-09-09 17:56:01 +07:00
|
|
|
|
2010-01-12 15:42:31 +07:00
|
|
|
qparam.uapsd = false;
|
|
|
|
|
2012-03-28 16:04:25 +07:00
|
|
|
sdata->tx_conf[ac] = qparam;
|
|
|
|
drv_conf_tx(local, sdata, ac, &qparam);
|
2009-05-07 21:16:24 +07:00
|
|
|
}
|
2010-03-29 17:18:34 +07:00
|
|
|
|
2012-06-19 01:07:15 +07:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
|
2012-05-30 15:56:46 +07:00
|
|
|
sdata->vif.bss_conf.qos = enable_qos;
|
2012-03-02 21:56:59 +07:00
|
|
|
if (bss_notify)
|
|
|
|
ieee80211_bss_info_change_notify(sdata,
|
|
|
|
BSS_CHANGED_QOS);
|
2010-07-23 12:17:11 +07:00
|
|
|
}
|
2008-09-09 17:56:01 +07:00
|
|
|
}
|
2008-09-09 20:07:09 +07:00
|
|
|
|
2009-02-15 18:44:28 +07:00
|
|
|
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
|
2012-09-30 23:29:37 +07:00
|
|
|
u16 transaction, u16 auth_alg, u16 status,
|
2013-02-12 22:43:19 +07:00
|
|
|
const u8 *extra, size_t extra_len, const u8 *da,
|
2013-01-29 21:02:27 +07:00
|
|
|
const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
|
|
|
|
u32 tx_flags)
|
2009-02-15 18:44:28 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
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 19:22:54 +07:00
|
|
|
int err;
|
2009-02-15 18:44:28 +07:00
|
|
|
|
2013-09-24 09:33:01 +07:00
|
|
|
/* 24 + 6 = header + auth_algo + auth_transaction + status_code */
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 6 + extra_len);
|
2011-08-30 04:17:31 +07:00
|
|
|
if (!skb)
|
2009-02-15 18:44:28 +07:00
|
|
|
return;
|
2011-08-30 04:17:31 +07:00
|
|
|
|
2009-02-15 18:44:28 +07:00
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
|
|
|
|
memset(mgmt, 0, 24 + 6);
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_AUTH);
|
2012-01-10 01:43:06 +07:00
|
|
|
memcpy(mgmt->da, da, ETH_ALEN);
|
2009-11-25 23:46:19 +07:00
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
2009-02-15 18:44:28 +07:00
|
|
|
memcpy(mgmt->bssid, bssid, ETH_ALEN);
|
|
|
|
mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
|
|
|
|
mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
|
2012-09-30 23:29:37 +07:00
|
|
|
mgmt->u.auth.status_code = cpu_to_le16(status);
|
2009-02-15 18:44:28 +07:00
|
|
|
if (extra)
|
|
|
|
memcpy(skb_put(skb, extra_len), extra, extra_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 19:22:54 +07:00
|
|
|
if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
|
|
|
|
mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
|
|
|
err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
|
|
|
|
WARN_ON(err);
|
|
|
|
}
|
|
|
|
|
2013-01-29 21:02:27 +07:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
|
|
|
|
tx_flags;
|
2009-11-19 00:42:05 +07:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-15 18:44:28 +07:00
|
|
|
}
|
|
|
|
|
2012-09-07 18:28:52 +07:00
|
|
|
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *bssid, u16 stype, u16 reason,
|
|
|
|
bool send_frame, u8 *frame_buf)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt = (void *)frame_buf;
|
|
|
|
|
|
|
|
/* build frame */
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
|
|
|
|
mgmt->duration = 0; /* initialize only */
|
|
|
|
mgmt->seq_ctrl = 0; /* initialize only */
|
|
|
|
memcpy(mgmt->da, bssid, ETH_ALEN);
|
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, bssid, ETH_ALEN);
|
|
|
|
/* u.deauth.reason_code == u.disassoc.reason_code */
|
|
|
|
mgmt->u.deauth.reason_code = cpu_to_le16(reason);
|
|
|
|
|
|
|
|
if (send_frame) {
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom +
|
|
|
|
IEEE80211_DEAUTH_FRAME_LEN);
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
/* copy in frame */
|
|
|
|
memcpy(skb_put(skb, IEEE80211_DEAUTH_FRAME_LEN),
|
|
|
|
mgmt, IEEE80211_DEAUTH_FRAME_LEN);
|
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION ||
|
|
|
|
!(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
|
|
|
|
IEEE80211_SKB_CB(skb)->flags |=
|
|
|
|
IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-05 20:21:13 +07:00
|
|
|
static int ieee80211_build_preq_ies_band(struct ieee80211_local *local,
|
|
|
|
u8 *buffer, size_t buffer_len,
|
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
enum ieee80211_band band,
|
|
|
|
u32 rate_mask,
|
|
|
|
struct cfg80211_chan_def *chandef,
|
|
|
|
size_t *offset)
|
2009-04-01 16:58:36 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
2012-11-29 18:45:18 +07:00
|
|
|
u8 *pos = buffer, *end = buffer + buffer_len;
|
2014-02-05 20:21:13 +07:00
|
|
|
size_t noffset;
|
2009-12-23 19:15:38 +07:00
|
|
|
int supp_rates_len, i;
|
2010-08-28 23:36:10 +07:00
|
|
|
u8 rates[32];
|
|
|
|
int num_rates;
|
|
|
|
int ext_rates_len;
|
2013-07-08 21:55:53 +07:00
|
|
|
int shift;
|
|
|
|
u32 rate_flags;
|
2009-04-01 16:58:36 +07:00
|
|
|
|
2014-02-05 20:21:13 +07:00
|
|
|
*offset = 0;
|
|
|
|
|
2009-10-28 02:59:55 +07:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2012-07-09 23:57:28 +07:00
|
|
|
if (WARN_ON_ONCE(!sband))
|
|
|
|
return 0;
|
2009-04-01 16:58:36 +07:00
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
rate_flags = ieee80211_chandef_rate_flags(chandef);
|
|
|
|
shift = ieee80211_chandef_get_shift(chandef);
|
|
|
|
|
2010-08-28 23:36:10 +07:00
|
|
|
num_rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((BIT(i) & rate_mask) == 0)
|
|
|
|
continue; /* skip rate */
|
2013-07-08 21:55:53 +07:00
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rates[num_rates++] =
|
|
|
|
(u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
|
|
|
|
(1 << shift) * 5);
|
2010-08-28 23:36:10 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
supp_rates_len = min_t(int, num_rates, 8);
|
2009-12-23 19:15:38 +07:00
|
|
|
|
2012-11-29 18:45:18 +07:00
|
|
|
if (end - pos < 2 + supp_rates_len)
|
|
|
|
goto out_err;
|
2009-04-01 16:58:36 +07:00
|
|
|
*pos++ = WLAN_EID_SUPP_RATES;
|
2009-12-23 19:15:38 +07:00
|
|
|
*pos++ = supp_rates_len;
|
2010-08-28 23:36:10 +07:00
|
|
|
memcpy(pos, rates, supp_rates_len);
|
|
|
|
pos += supp_rates_len;
|
2009-12-23 19:15:38 +07:00
|
|
|
|
|
|
|
/* insert "request information" if in custom IEs */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
static const u8 before_extrates[] = {
|
|
|
|
WLAN_EID_SSID,
|
|
|
|
WLAN_EID_SUPP_RATES,
|
|
|
|
WLAN_EID_REQUEST,
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_extrates,
|
|
|
|
ARRAY_SIZE(before_extrates),
|
2014-02-05 20:21:13 +07:00
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
2012-11-29 18:45:18 +07:00
|
|
|
goto out_err;
|
2014-02-05 20:21:13 +07:00
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
2009-12-23 19:15:38 +07:00
|
|
|
}
|
|
|
|
|
2010-08-28 23:36:10 +07:00
|
|
|
ext_rates_len = num_rates - supp_rates_len;
|
|
|
|
if (ext_rates_len > 0) {
|
2012-11-29 18:45:18 +07:00
|
|
|
if (end - pos < 2 + ext_rates_len)
|
|
|
|
goto out_err;
|
2009-12-23 19:15:38 +07:00
|
|
|
*pos++ = WLAN_EID_EXT_SUPP_RATES;
|
2010-08-28 23:36:10 +07:00
|
|
|
*pos++ = ext_rates_len;
|
|
|
|
memcpy(pos, rates + supp_rates_len, ext_rates_len);
|
|
|
|
pos += ext_rates_len;
|
2009-12-23 19:15:38 +07:00
|
|
|
}
|
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
if (chandef->chan && sband->band == IEEE80211_BAND_2GHZ) {
|
2012-11-29 18:45:18 +07:00
|
|
|
if (end - pos < 3)
|
|
|
|
goto out_err;
|
2010-08-28 23:37:51 +07:00
|
|
|
*pos++ = WLAN_EID_DS_PARAMS;
|
|
|
|
*pos++ = 1;
|
2013-07-08 21:55:53 +07:00
|
|
|
*pos++ = ieee80211_frequency_to_channel(
|
|
|
|
chandef->chan->center_freq);
|
2010-08-28 23:37:51 +07:00
|
|
|
}
|
|
|
|
|
2009-12-23 19:15:38 +07:00
|
|
|
/* insert custom IEs that go before HT */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
static const u8 before_ht[] = {
|
|
|
|
WLAN_EID_SSID,
|
|
|
|
WLAN_EID_SUPP_RATES,
|
|
|
|
WLAN_EID_REQUEST,
|
|
|
|
WLAN_EID_EXT_SUPP_RATES,
|
|
|
|
WLAN_EID_DS_PARAMS,
|
|
|
|
WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_ht, ARRAY_SIZE(before_ht),
|
2014-02-05 20:21:13 +07:00
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
2012-11-29 18:45:18 +07:00
|
|
|
goto out_err;
|
2014-02-05 20:21:13 +07:00
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
2009-04-01 16:58:36 +07:00
|
|
|
}
|
|
|
|
|
2012-11-29 18:45:18 +07:00
|
|
|
if (sband->ht_cap.ht_supported) {
|
|
|
|
if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
|
|
|
|
goto out_err;
|
2011-11-19 02:32:00 +07:00
|
|
|
pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
|
|
|
|
sband->ht_cap.cap);
|
2012-11-29 18:45:18 +07:00
|
|
|
}
|
2009-03-31 17:12:07 +07:00
|
|
|
|
2009-04-01 16:58:36 +07:00
|
|
|
/*
|
|
|
|
* If adding more here, adjust code in main.c
|
|
|
|
* that calculates local->scan_ies_len.
|
|
|
|
*/
|
|
|
|
|
2014-02-04 15:48:34 +07:00
|
|
|
/* insert custom IEs that go before VHT */
|
2009-12-23 19:15:38 +07:00
|
|
|
if (ie && ie_len) {
|
2014-02-04 15:48:34 +07:00
|
|
|
static const u8 before_vht[] = {
|
|
|
|
WLAN_EID_SSID,
|
|
|
|
WLAN_EID_SUPP_RATES,
|
|
|
|
WLAN_EID_REQUEST,
|
|
|
|
WLAN_EID_EXT_SUPP_RATES,
|
|
|
|
WLAN_EID_DS_PARAMS,
|
|
|
|
WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
|
|
|
|
WLAN_EID_HT_CAPABILITY,
|
|
|
|
WLAN_EID_BSS_COEX_2040,
|
|
|
|
WLAN_EID_EXT_CAPABILITY,
|
|
|
|
WLAN_EID_SSID_LIST,
|
|
|
|
WLAN_EID_CHANNEL_USAGE,
|
|
|
|
WLAN_EID_INTERWORKING,
|
|
|
|
/* mesh ID can't happen here */
|
|
|
|
/* 60 GHz can't happen here right now */
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_vht, ARRAY_SIZE(before_vht),
|
2014-02-05 20:21:13 +07:00
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
2012-11-29 18:45:18 +07:00
|
|
|
goto out_err;
|
2014-02-05 20:21:13 +07:00
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
2009-04-01 16:58:36 +07:00
|
|
|
}
|
|
|
|
|
2012-11-29 18:45:18 +07:00
|
|
|
if (sband->vht_cap.vht_supported) {
|
|
|
|
if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
|
|
|
|
goto out_err;
|
2012-07-02 18:25:12 +07:00
|
|
|
pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
|
|
|
|
sband->vht_cap.cap);
|
2012-11-29 18:45:18 +07:00
|
|
|
}
|
2012-07-02 18:25:12 +07:00
|
|
|
|
2012-11-29 18:45:18 +07:00
|
|
|
return pos - buffer;
|
|
|
|
out_err:
|
|
|
|
WARN_ONCE(1, "not enough space for preq IEs\n");
|
2009-04-01 16:58:36 +07:00
|
|
|
return pos - buffer;
|
|
|
|
}
|
|
|
|
|
2014-02-05 20:21:13 +07:00
|
|
|
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
|
|
|
|
size_t buffer_len,
|
|
|
|
struct ieee80211_scan_ies *ie_desc,
|
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
u8 bands_used, u32 *rate_masks,
|
|
|
|
struct cfg80211_chan_def *chandef)
|
|
|
|
{
|
|
|
|
size_t pos = 0, old_pos = 0, custom_ie_offset = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(ie_desc, 0, sizeof(*ie_desc));
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
|
|
|
|
if (bands_used & BIT(i)) {
|
|
|
|
pos += ieee80211_build_preq_ies_band(local,
|
|
|
|
buffer + pos,
|
|
|
|
buffer_len - pos,
|
|
|
|
ie, ie_len, i,
|
|
|
|
rate_masks[i],
|
|
|
|
chandef,
|
|
|
|
&custom_ie_offset);
|
|
|
|
ie_desc->ies[i] = buffer + old_pos;
|
|
|
|
ie_desc->len[i] = pos - old_pos;
|
|
|
|
old_pos = pos;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add any remaining custom IEs */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
if (WARN_ONCE(buffer_len - pos < ie_len - custom_ie_offset,
|
|
|
|
"not enough space for preq custom IEs\n"))
|
|
|
|
return pos;
|
|
|
|
memcpy(buffer + pos, ie + custom_ie_offset,
|
|
|
|
ie_len - custom_ie_offset);
|
|
|
|
ie_desc->common_ies = buffer + pos;
|
|
|
|
ie_desc->common_ie_len = ie_len - custom_ie_offset;
|
|
|
|
pos += ie_len - custom_ie_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
};
|
|
|
|
|
2010-11-11 13:50:18 +07:00
|
|
|
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
|
2011-07-18 23:08:36 +07:00
|
|
|
u8 *dst, u32 ratemask,
|
2012-07-23 19:53:27 +07:00
|
|
|
struct ieee80211_channel *chan,
|
2010-11-11 13:50:18 +07:00
|
|
|
const u8 *ssid, size_t ssid_len,
|
2011-06-24 00:00:11 +07:00
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
bool directed)
|
2009-02-15 18:44:28 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2013-07-08 21:55:53 +07:00
|
|
|
struct cfg80211_chan_def chandef;
|
2009-02-15 18:44:28 +07:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
2012-11-29 19:00:10 +07:00
|
|
|
int ies_len;
|
2014-02-05 20:21:13 +07:00
|
|
|
u32 rate_masks[IEEE80211_NUM_BANDS] = {};
|
|
|
|
struct ieee80211_scan_ies dummy_ie_desc;
|
2009-02-15 18:44:28 +07:00
|
|
|
|
2011-06-24 00:00:11 +07:00
|
|
|
/*
|
|
|
|
* Do not send DS Channel parameter for directed probe requests
|
|
|
|
* in order to maximize the chance that we get a response. Some
|
|
|
|
* badly-behaved APs don't respond when this parameter is included.
|
|
|
|
*/
|
2013-07-08 21:55:53 +07:00
|
|
|
chandef.width = sdata->vif.bss_conf.chandef.width;
|
2011-06-24 00:00:11 +07:00
|
|
|
if (directed)
|
2013-07-08 21:55:53 +07:00
|
|
|
chandef.chan = NULL;
|
2011-06-24 00:00:11 +07:00
|
|
|
else
|
2013-07-08 21:55:53 +07:00
|
|
|
chandef.chan = chan;
|
2010-08-28 23:37:51 +07:00
|
|
|
|
2010-01-06 01:16:44 +07:00
|
|
|
skb = ieee80211_probereq_get(&local->hw, &sdata->vif,
|
2012-11-29 19:00:10 +07:00
|
|
|
ssid, ssid_len, 100 + ie_len);
|
2011-11-08 19:04:41 +07:00
|
|
|
if (!skb)
|
2012-11-29 19:00:10 +07:00
|
|
|
return NULL;
|
|
|
|
|
2014-02-05 20:21:13 +07:00
|
|
|
rate_masks[chan->band] = ratemask;
|
2012-11-29 19:00:10 +07:00
|
|
|
ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb),
|
2014-02-05 20:21:13 +07:00
|
|
|
skb_tailroom(skb), &dummy_ie_desc,
|
|
|
|
ie, ie_len, BIT(chan->band),
|
|
|
|
rate_masks, &chandef);
|
2012-11-29 19:00:10 +07:00
|
|
|
skb_put(skb, ies_len);
|
2010-01-06 01:16:44 +07:00
|
|
|
|
2009-02-15 18:44:28 +07:00
|
|
|
if (dst) {
|
2010-01-06 01:16:44 +07:00
|
|
|
mgmt = (struct ieee80211_mgmt *) skb->data;
|
2009-02-15 18:44:28 +07:00
|
|
|
memcpy(mgmt->da, dst, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, dst, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
2009-11-19 00:42:05 +07:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
2011-11-08 19:04:41 +07:00
|
|
|
|
2010-11-11 13:50:18 +07:00
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
|
|
|
|
const u8 *ssid, size_t ssid_len,
|
2011-06-24 00:00:11 +07:00
|
|
|
const u8 *ie, size_t ie_len,
|
2013-01-29 21:02:27 +07:00
|
|
|
u32 ratemask, bool directed, u32 tx_flags,
|
2012-07-26 22:24:39 +07:00
|
|
|
struct ieee80211_channel *channel, bool scan)
|
2010-11-11 13:50:18 +07:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2012-07-30 17:26:34 +07:00
|
|
|
skb = ieee80211_build_probe_req(sdata, dst, ratemask, channel,
|
2012-07-23 19:53:27 +07:00
|
|
|
ssid, ssid_len,
|
2011-07-18 23:08:36 +07:00
|
|
|
ie, ie_len, directed);
|
2011-09-25 16:23:31 +07:00
|
|
|
if (skb) {
|
2013-01-29 21:02:27 +07:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= tx_flags;
|
2012-07-26 22:24:39 +07:00
|
|
|
if (scan)
|
|
|
|
ieee80211_tx_skb_tid_band(sdata, skb, 7, channel->band);
|
|
|
|
else
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2011-09-25 16:23:31 +07:00
|
|
|
}
|
2009-02-15 18:44:28 +07:00
|
|
|
}
|
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
|
2009-02-15 18:44:28 +07:00
|
|
|
struct ieee802_11_elems *elems,
|
2012-04-03 11:21:21 +07:00
|
|
|
enum ieee80211_band band, u32 *basic_rates)
|
2009-02-15 18:44:28 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
size_t num_rates;
|
2013-07-08 21:55:53 +07:00
|
|
|
u32 supp_rates, rate_flags;
|
|
|
|
int i, j, shift;
|
|
|
|
sband = sdata->local->hw.wiphy->bands[band];
|
|
|
|
|
|
|
|
rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
|
|
|
|
shift = ieee80211_vif_get_shift(&sdata->vif);
|
2009-02-15 18:44:28 +07:00
|
|
|
|
2012-04-11 13:47:56 +07:00
|
|
|
if (WARN_ON(!sband))
|
|
|
|
return 1;
|
2009-02-15 18:44:28 +07:00
|
|
|
|
|
|
|
num_rates = sband->n_bitrates;
|
|
|
|
supp_rates = 0;
|
|
|
|
for (i = 0; i < elems->supp_rates_len +
|
|
|
|
elems->ext_supp_rates_len; i++) {
|
|
|
|
u8 rate = 0;
|
|
|
|
int own_rate;
|
2012-04-03 11:21:21 +07:00
|
|
|
bool is_basic;
|
2009-02-15 18:44:28 +07:00
|
|
|
if (i < elems->supp_rates_len)
|
|
|
|
rate = elems->supp_rates[i];
|
|
|
|
else if (elems->ext_supp_rates)
|
|
|
|
rate = elems->ext_supp_rates
|
|
|
|
[i - elems->supp_rates_len];
|
|
|
|
own_rate = 5 * (rate & 0x7f);
|
2012-04-03 11:21:21 +07:00
|
|
|
is_basic = !!(rate & 0x80);
|
|
|
|
|
|
|
|
if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; j < num_rates; j++) {
|
2013-07-08 21:55:53 +07:00
|
|
|
int brate;
|
|
|
|
if ((rate_flags & sband->bitrates[j].flags)
|
|
|
|
!= rate_flags)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
|
|
|
|
1 << shift);
|
|
|
|
|
|
|
|
if (brate == own_rate) {
|
2009-02-15 18:44:28 +07:00
|
|
|
supp_rates |= BIT(j);
|
2012-04-03 11:21:21 +07:00
|
|
|
if (basic_rates && is_basic)
|
|
|
|
*basic_rates |= BIT(j);
|
|
|
|
}
|
|
|
|
}
|
2009-02-15 18:44:28 +07:00
|
|
|
}
|
|
|
|
return supp_rates;
|
|
|
|
}
|
2009-04-14 15:09:24 +07:00
|
|
|
|
2009-08-21 01:02:20 +07:00
|
|
|
void ieee80211_stop_device(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
ieee80211_led_radio(local, false);
|
2010-11-30 14:59:23 +07:00
|
|
|
ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
|
2009-08-21 01:02:20 +07:00
|
|
|
|
|
|
|
cancel_work_sync(&local->reconfig_filter);
|
|
|
|
|
|
|
|
flush_workqueue(local->workqueue);
|
2010-01-10 20:07:53 +07:00
|
|
|
drv_stop(local);
|
2009-08-21 01:02:20 +07:00
|
|
|
}
|
|
|
|
|
2014-04-30 19:19:04 +07:00
|
|
|
static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We get here if during resume the device can't be restarted properly.
|
|
|
|
* We might also get here if this happens during HW reset, which is a
|
|
|
|
* slightly different situation and we need to drop all connections in
|
|
|
|
* the latter case.
|
|
|
|
*
|
|
|
|
* Ask cfg80211 to turn off all interfaces, this will result in more
|
|
|
|
* warnings but at least we'll then get into a clean stopped state.
|
|
|
|
*/
|
|
|
|
|
|
|
|
local->resuming = false;
|
|
|
|
local->suspended = false;
|
|
|
|
local->started = false;
|
|
|
|
|
|
|
|
/* scheduled scan clearly can't be running any more, but tell
|
|
|
|
* cfg80211 and clear local state
|
|
|
|
*/
|
|
|
|
ieee80211_sched_scan_end(local);
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list)
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
|
|
|
|
|
|
|
|
/* Mark channel contexts as not being in the driver any more to avoid
|
|
|
|
* removing them from the driver during the shutdown process...
|
|
|
|
*/
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list)
|
|
|
|
ctx->driver_present = false;
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
cfg80211_shutdown_all_interfaces(local->hw.wiphy);
|
|
|
|
}
|
|
|
|
|
2013-02-28 16:55:30 +07:00
|
|
|
static void ieee80211_assign_chanctx(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *conf;
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
|
|
|
|
if (!local->use_chanctx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
|
|
|
|
lockdep_is_held(&local->chanctx_mtx));
|
|
|
|
if (conf) {
|
|
|
|
ctx = container_of(conf, struct ieee80211_chanctx, conf);
|
|
|
|
drv_assign_vif_chanctx(local, sdata, ctx);
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
}
|
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
int ieee80211_reconfig(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-07-26 22:24:39 +07:00
|
|
|
struct ieee80211_chanctx *ctx;
|
2009-04-14 15:09:24 +07:00
|
|
|
struct sta_info *sta;
|
2011-07-15 00:29:42 +07:00
|
|
|
int res, i;
|
2013-01-11 05:55:33 +07:00
|
|
|
bool reconfig_due_to_wowlan = false;
|
2013-12-09 02:48:57 +07:00
|
|
|
struct ieee80211_sub_if_data *sched_scan_sdata;
|
|
|
|
bool sched_scan_stopped = false;
|
2013-01-11 05:55:33 +07:00
|
|
|
|
2013-01-11 06:28:01 +07:00
|
|
|
#ifdef CONFIG_PM
|
2009-11-19 20:29:39 +07:00
|
|
|
if (local->suspended)
|
|
|
|
local->resuming = true;
|
2009-04-14 15:09:24 +07:00
|
|
|
|
2011-05-04 20:37:29 +07:00
|
|
|
if (local->wowlan) {
|
|
|
|
res = drv_resume(local);
|
2013-08-08 01:11:55 +07:00
|
|
|
local->wowlan = false;
|
2011-05-04 20:37:29 +07:00
|
|
|
if (res < 0) {
|
|
|
|
local->resuming = false;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
if (res == 0)
|
|
|
|
goto wake_up;
|
|
|
|
WARN_ON(res > 1);
|
|
|
|
/*
|
|
|
|
* res is 1, which means the driver requested
|
|
|
|
* to go through a regular reset on wakeup.
|
|
|
|
*/
|
2013-01-11 05:55:33 +07:00
|
|
|
reconfig_due_to_wowlan = true;
|
2011-05-04 20:37:29 +07:00
|
|
|
}
|
|
|
|
#endif
|
2011-07-14 21:48:54 +07:00
|
|
|
/* everything else happens only if HW was up & running */
|
|
|
|
if (!local->open_count)
|
|
|
|
goto wake_up;
|
2009-04-14 15:09:24 +07:00
|
|
|
|
2011-07-14 21:48:54 +07:00
|
|
|
/*
|
|
|
|
* Upon resume hardware can sometimes be goofy due to
|
|
|
|
* various platform / driver / bus issues, so restarting
|
|
|
|
* the device may at times not work immediately. Propagate
|
|
|
|
* the error.
|
|
|
|
*/
|
|
|
|
res = drv_start(local);
|
|
|
|
if (res) {
|
2014-04-30 19:19:04 +07:00
|
|
|
if (local->suspended)
|
|
|
|
WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
|
|
|
|
else
|
|
|
|
WARN(1, "Hardware became unavailable during restart.\n");
|
|
|
|
ieee80211_handle_reconfig_failure(local);
|
2011-07-14 21:48:54 +07:00
|
|
|
return res;
|
2009-04-14 15:09:24 +07:00
|
|
|
}
|
|
|
|
|
2011-12-30 18:04:25 +07:00
|
|
|
/* setup fragmentation threshold */
|
|
|
|
drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
|
|
|
|
|
|
|
|
/* setup RTS threshold */
|
|
|
|
drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
|
|
|
|
|
|
|
|
/* reset coverage class */
|
|
|
|
drv_set_coverage_class(local, hw->wiphy->coverage_class);
|
|
|
|
|
2011-07-14 21:48:54 +07:00
|
|
|
ieee80211_led_radio(local, true);
|
|
|
|
ieee80211_mod_tpt_led_trig(local,
|
|
|
|
IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
|
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
/* add interfaces */
|
2012-04-03 19:35:57 +07:00
|
|
|
sdata = rtnl_dereference(local->monitor_sdata);
|
|
|
|
if (sdata) {
|
2013-03-28 05:20:27 +07:00
|
|
|
/* in HW restart it exists already */
|
|
|
|
WARN_ON(local->resuming);
|
2012-04-03 19:35:57 +07:00
|
|
|
res = drv_add_interface(local, sdata);
|
|
|
|
if (WARN_ON(res)) {
|
2014-03-24 02:21:43 +07:00
|
|
|
RCU_INIT_POINTER(local->monitor_sdata, NULL);
|
2012-04-03 19:35:57 +07:00
|
|
|
synchronize_net();
|
|
|
|
kfree(sdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
2009-12-23 19:15:45 +07:00
|
|
|
ieee80211_sdata_running(sdata))
|
2011-11-03 20:41:13 +07:00
|
|
|
res = drv_add_interface(local, sdata);
|
2009-04-14 15:09:24 +07:00
|
|
|
}
|
|
|
|
|
2012-07-26 22:24:39 +07:00
|
|
|
/* add channel contexts */
|
2012-11-19 18:01:05 +07:00
|
|
|
if (local->use_chanctx) {
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list)
|
2014-06-25 17:35:06 +07:00
|
|
|
if (ctx->replace_state !=
|
|
|
|
IEEE80211_CHANCTX_REPLACES_OTHER)
|
|
|
|
WARN_ON(drv_add_chanctx(local, ctx));
|
2012-11-19 18:01:05 +07:00
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
2012-07-26 22:24:39 +07:00
|
|
|
|
2014-04-26 08:43:40 +07:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
ieee80211_assign_chanctx(local, sdata);
|
|
|
|
}
|
2012-11-07 18:40:41 +07:00
|
|
|
|
2014-04-26 08:43:40 +07:00
|
|
|
sdata = rtnl_dereference(local->monitor_sdata);
|
|
|
|
if (sdata && ieee80211_sdata_running(sdata))
|
|
|
|
ieee80211_assign_chanctx(local, sdata);
|
|
|
|
}
|
2012-11-20 04:19:08 +07:00
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
/* add STAs back */
|
2010-02-03 19:59:58 +07:00
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
2012-06-04 03:31:56 +07:00
|
|
|
enum ieee80211_sta_state state;
|
2012-01-20 19:55:21 +07:00
|
|
|
|
2012-06-04 03:31:56 +07:00
|
|
|
if (!sta->uploaded)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* AP-mode stations will be added later */
|
|
|
|
if (sta->sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (state = IEEE80211_STA_NOTEXIST;
|
|
|
|
state < sta->sta_state; state++)
|
|
|
|
WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
|
|
|
|
state + 1));
|
2009-04-14 15:09:24 +07:00
|
|
|
}
|
2010-02-03 19:59:58 +07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2009-04-14 15:09:24 +07:00
|
|
|
|
2011-07-15 00:29:42 +07:00
|
|
|
/* reconfigure tx conf */
|
2012-03-28 16:04:25 +07:00
|
|
|
if (hw->queues >= IEEE80211_NUM_ACS) {
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_MONITOR ||
|
|
|
|
!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
2011-09-26 00:06:54 +07:00
|
|
|
|
2012-03-28 16:04:25 +07:00
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++)
|
|
|
|
drv_conf_tx(local, sdata, i,
|
|
|
|
&sdata->tx_conf[i]);
|
|
|
|
}
|
2011-09-26 00:06:54 +07:00
|
|
|
}
|
2011-07-15 00:29:42 +07:00
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
/* reconfigure hardware */
|
|
|
|
ieee80211_hw_config(local, ~0);
|
|
|
|
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
|
|
|
|
/* Finally also reconfigure all the BSS information */
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2010-05-05 14:44:02 +07:00
|
|
|
u32 changed;
|
|
|
|
|
2009-12-23 19:15:31 +07:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-04-14 15:09:24 +07:00
|
|
|
continue;
|
2010-05-05 14:44:02 +07:00
|
|
|
|
|
|
|
/* common change flags for all interface types */
|
|
|
|
changed = BSS_CHANGED_ERP_CTS_PROT |
|
|
|
|
BSS_CHANGED_ERP_PREAMBLE |
|
|
|
|
BSS_CHANGED_ERP_SLOT |
|
|
|
|
BSS_CHANGED_HT |
|
|
|
|
BSS_CHANGED_BASIC_RATES |
|
|
|
|
BSS_CHANGED_BEACON_INT |
|
|
|
|
BSS_CHANGED_BSSID |
|
2010-07-19 21:39:04 +07:00
|
|
|
BSS_CHANGED_CQM |
|
2011-11-01 20:16:55 +07:00
|
|
|
BSS_CHANGED_QOS |
|
2012-10-24 15:59:25 +07:00
|
|
|
BSS_CHANGED_IDLE |
|
|
|
|
BSS_CHANGED_TXPOWER;
|
2010-05-05 14:44:02 +07:00
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
2011-12-12 19:10:49 +07:00
|
|
|
changed |= BSS_CHANGED_ASSOC |
|
2012-07-27 16:33:22 +07:00
|
|
|
BSS_CHANGED_ARP_FILTER |
|
|
|
|
BSS_CHANGED_PS;
|
2012-12-12 15:12:24 +07:00
|
|
|
|
2013-05-16 21:34:17 +07:00
|
|
|
/* Re-send beacon info report to the driver */
|
|
|
|
if (sdata->u.mgd.have_beacon)
|
|
|
|
changed |= BSS_CHANGED_BEACON_INFO;
|
2012-12-12 15:12:24 +07:00
|
|
|
|
2013-05-10 17:32:47 +07:00
|
|
|
sdata_lock(sdata);
|
2010-05-05 14:44:02 +07:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2013-05-10 17:32:47 +07:00
|
|
|
sdata_unlock(sdata);
|
2010-05-05 14:44:02 +07:00
|
|
|
break;
|
2009-04-14 15:09:24 +07:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2010-05-05 14:44:02 +07:00
|
|
|
changed |= BSS_CHANGED_IBSS;
|
|
|
|
/* fall through */
|
2009-04-14 15:09:24 +07:00
|
|
|
case NL80211_IFTYPE_AP:
|
2012-11-14 21:21:17 +07:00
|
|
|
changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
|
2011-11-23 00:33:18 +07:00
|
|
|
|
2012-10-19 20:44:42 +07:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
2011-11-23 00:33:18 +07:00
|
|
|
changed |= BSS_CHANGED_AP_PROBE_RESP;
|
|
|
|
|
2012-10-19 20:44:42 +07:00
|
|
|
if (rcu_access_pointer(sdata->u.ap.beacon))
|
|
|
|
drv_start_ap(local, sdata);
|
|
|
|
}
|
|
|
|
|
2011-09-04 15:11:32 +07:00
|
|
|
/* fall through */
|
2009-04-14 15:09:24 +07:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2012-12-14 20:17:26 +07:00
|
|
|
if (sdata->vif.bss_conf.enable_beacon) {
|
|
|
|
changed |= BSS_CHANGED_BEACON |
|
|
|
|
BSS_CHANGED_BEACON_ENABLED;
|
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
|
|
|
}
|
2009-04-14 15:09:24 +07:00
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_WDS:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
2012-06-16 05:19:54 +07:00
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
2014-04-26 08:43:41 +07:00
|
|
|
/* nothing to do */
|
2012-06-19 01:07:15 +07:00
|
|
|
break;
|
2009-04-14 15:09:24 +07:00
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
2010-08-12 20:38:38 +07:00
|
|
|
case NUM_NL80211_IFTYPES:
|
2010-09-16 19:58:23 +07:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2009-04-14 15:09:24 +07:00
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-09 17:29:06 +07:00
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
|
2012-01-26 18:36:05 +07:00
|
|
|
/*
|
|
|
|
* The sta might be in psm against the ap (e.g. because
|
|
|
|
* this was the state before a hw restart), so we
|
|
|
|
* explicitly send a null packet in order to make sure
|
|
|
|
* it'll sync against the ap (and get out of psm).
|
|
|
|
*/
|
|
|
|
if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
continue;
|
2012-11-08 20:06:28 +07:00
|
|
|
if (!sdata->u.mgd.associated)
|
|
|
|
continue;
|
2012-01-26 18:36:05 +07:00
|
|
|
|
|
|
|
ieee80211_send_nullfunc(local, sdata, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-04 03:31:56 +07:00
|
|
|
/* APs are now beaconing, add back stations */
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
|
|
|
enum ieee80211_sta_state state;
|
|
|
|
|
|
|
|
if (!sta->uploaded)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sta->sdata->vif.type != NL80211_IFTYPE_AP)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (state = IEEE80211_STA_NOTEXIST;
|
|
|
|
state < sta->sta_state; state++)
|
|
|
|
WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
|
|
|
|
state + 1));
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
|
2012-05-29 16:00:22 +07:00
|
|
|
/* add back keys */
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list)
|
|
|
|
if (ieee80211_sdata_running(sdata))
|
|
|
|
ieee80211_enable_keys(sdata);
|
|
|
|
|
2012-07-02 19:08:25 +07:00
|
|
|
wake_up:
|
2012-06-06 15:25:02 +07:00
|
|
|
local->in_reconfig = false;
|
|
|
|
barrier();
|
|
|
|
|
2013-03-28 05:20:27 +07:00
|
|
|
if (local->monitors == local->open_count && local->monitors > 0)
|
|
|
|
ieee80211_add_virtual_monitor(local);
|
|
|
|
|
2010-06-10 15:21:29 +07:00
|
|
|
/*
|
|
|
|
* Clear the WLAN_STA_BLOCK_BA flag so new aggregation
|
|
|
|
* sessions can be established after a resume.
|
|
|
|
*
|
|
|
|
* Also tear down aggregation sessions since reconfiguring
|
|
|
|
* them in a hardware restart scenario is not easily done
|
|
|
|
* right now, and the hardware will have lost information
|
|
|
|
* about the sessions, but we and the AP still think they
|
|
|
|
* are active. This is really a workaround though.
|
|
|
|
*/
|
2010-02-04 00:28:55 +07:00
|
|
|
if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
|
2010-06-10 15:21:29 +07:00
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
2012-07-18 18:31:31 +07:00
|
|
|
ieee80211_sta_tear_down_BA_sessions(
|
|
|
|
sta, AGG_STOP_LOCAL_REQUEST);
|
2011-09-29 21:04:36 +07:00
|
|
|
clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
|
2010-02-04 00:28:55 +07:00
|
|
|
}
|
2010-06-10 15:21:29 +07:00
|
|
|
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
2010-02-04 00:28:55 +07:00
|
|
|
}
|
|
|
|
|
2013-02-13 18:25:28 +07:00
|
|
|
ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 20:30:05 +07:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SUSPEND,
|
|
|
|
false);
|
2009-04-14 15:09:24 +07:00
|
|
|
|
2014-02-11 17:27:19 +07:00
|
|
|
/*
|
|
|
|
* Reconfigure sched scan if it was interrupted by FW restart or
|
|
|
|
* suspend.
|
|
|
|
*/
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
|
|
|
|
lockdep_is_held(&local->mtx));
|
|
|
|
if (sched_scan_sdata && local->sched_scan_req)
|
|
|
|
/*
|
|
|
|
* Sched scan stopped, but we don't want to report it. Instead,
|
|
|
|
* we're trying to reschedule.
|
|
|
|
*/
|
|
|
|
if (__ieee80211_request_sched_scan_start(sched_scan_sdata,
|
|
|
|
local->sched_scan_req))
|
|
|
|
sched_scan_stopped = true;
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
if (sched_scan_stopped)
|
2014-04-30 20:14:24 +07:00
|
|
|
cfg80211_sched_scan_stopped_rtnl(local->hw.wiphy);
|
2014-02-11 17:27:19 +07:00
|
|
|
|
2009-05-17 16:40:42 +07:00
|
|
|
/*
|
|
|
|
* If this is for hw restart things are still running.
|
|
|
|
* We may want to change that later, however.
|
|
|
|
*/
|
2013-01-11 06:28:01 +07:00
|
|
|
if (!local->suspended || reconfig_due_to_wowlan)
|
2012-11-07 01:18:13 +07:00
|
|
|
drv_restart_complete(local);
|
2013-01-11 06:28:01 +07:00
|
|
|
|
|
|
|
if (!local->suspended)
|
2009-05-17 16:40:42 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
2009-11-19 20:29:39 +07:00
|
|
|
/* first set suspended false, then resuming */
|
2009-05-17 16:40:42 +07:00
|
|
|
local->suspended = false;
|
2009-11-19 20:29:39 +07:00
|
|
|
mb();
|
|
|
|
local->resuming = false;
|
2009-05-17 16:40:42 +07:00
|
|
|
|
2013-04-29 19:57:44 +07:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
ieee80211_sta_restart(sdata);
|
|
|
|
}
|
|
|
|
|
2011-04-01 18:52:48 +07:00
|
|
|
mod_timer(&local->sta_cleanup, jiffies + 1);
|
2009-05-17 16:40:42 +07:00
|
|
|
#else
|
|
|
|
WARN_ON(1);
|
|
|
|
#endif
|
2013-12-09 02:48:57 +07:00
|
|
|
|
2009-04-14 15:09:24 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2009-07-30 07:08:07 +07:00
|
|
|
|
2011-07-12 17:30:59 +07:00
|
|
|
void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_key *key;
|
|
|
|
|
|
|
|
if (WARN_ON(!vif))
|
|
|
|
return;
|
|
|
|
|
|
|
|
sdata = vif_to_sdata(vif);
|
|
|
|
local = sdata->local;
|
|
|
|
|
|
|
|
if (WARN_ON(!local->resuming))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
|
|
|
|
return;
|
|
|
|
|
|
|
|
sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
|
|
|
|
|
|
|
|
mutex_lock(&local->key_mtx);
|
|
|
|
list_for_each_entry(key, &sdata->key_list, list)
|
|
|
|
key->flags |= KEY_FLAG_TAINTED;
|
|
|
|
mutex_unlock(&local->key_mtx);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
|
|
|
|
|
2012-09-11 19:34:12 +07:00
|
|
|
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
|
2009-12-01 19:37:02 +07:00
|
|
|
{
|
2012-09-11 19:34:12 +07:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_chanctx *chanctx;
|
2010-10-05 15:41:47 +07:00
|
|
|
|
2012-09-11 19:34:12 +07:00
|
|
|
mutex_lock(&local->chanctx_mtx);
|
2009-12-01 19:37:02 +07:00
|
|
|
|
2012-09-11 19:34:12 +07:00
|
|
|
chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
|
|
|
|
lockdep_is_held(&local->chanctx_mtx));
|
2009-12-01 19:37:02 +07:00
|
|
|
|
2012-09-11 19:34:12 +07:00
|
|
|
if (WARN_ON_ONCE(!chanctx_conf))
|
2012-09-11 15:17:11 +07:00
|
|
|
goto unlock;
|
2009-12-01 19:37:02 +07:00
|
|
|
|
2012-09-11 19:34:12 +07:00
|
|
|
chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
|
|
|
|
ieee80211_recalc_smps_chanctx(local, chanctx);
|
2012-09-11 15:17:11 +07:00
|
|
|
unlock:
|
2012-09-11 19:34:12 +07:00
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
2009-12-01 19:37:02 +07:00
|
|
|
}
|
2009-12-23 19:15:38 +07:00
|
|
|
|
2013-11-12 01:14:01 +07:00
|
|
|
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_chanctx *chanctx;
|
|
|
|
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
|
|
|
|
lockdep_is_held(&local->chanctx_mtx));
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!chanctx_conf))
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
|
|
|
|
ieee80211_recalc_chanctx_min_def(local, chanctx);
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
}
|
|
|
|
|
2009-12-23 19:15:38 +07:00
|
|
|
static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < n_ids; i++)
|
|
|
|
if (ids[i] == id)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ieee80211_ie_split - split an IE buffer according to ordering
|
|
|
|
*
|
|
|
|
* @ies: the IE buffer
|
|
|
|
* @ielen: the length of the IE buffer
|
|
|
|
* @ids: an array with element IDs that are allowed before
|
|
|
|
* the split
|
|
|
|
* @n_ids: the size of the element ID array
|
|
|
|
* @offset: offset where to start splitting in the buffer
|
|
|
|
*
|
|
|
|
* This function splits an IE buffer by updating the @offset
|
|
|
|
* variable to point to the location where the buffer should be
|
|
|
|
* split.
|
|
|
|
*
|
|
|
|
* It assumes that the given IE buffer is well-formed, this
|
|
|
|
* has to be guaranteed by the caller!
|
|
|
|
*
|
|
|
|
* It also assumes that the IEs in the buffer are ordered
|
|
|
|
* correctly, if not the result of using this function will not
|
|
|
|
* be ordered correctly either, i.e. it does no reordering.
|
|
|
|
*
|
|
|
|
* The function returns the offset where the next part of the
|
|
|
|
* buffer starts, which may be @ielen if the entire (remainder)
|
|
|
|
* of the buffer should be used.
|
|
|
|
*/
|
|
|
|
size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
|
|
|
|
const u8 *ids, int n_ids, size_t offset)
|
|
|
|
{
|
|
|
|
size_t pos = offset;
|
|
|
|
|
|
|
|
while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos]))
|
|
|
|
pos += 2 + ies[pos + 1];
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
|
|
|
|
{
|
|
|
|
size_t pos = offset;
|
|
|
|
|
|
|
|
while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
|
|
|
|
pos += 2 + ies[pos + 1];
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
2011-07-08 22:46:22 +07:00
|
|
|
|
|
|
|
static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
|
|
|
|
int rssi_min_thold,
|
|
|
|
int rssi_max_thold)
|
|
|
|
{
|
|
|
|
trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
|
|
|
|
|
|
|
|
if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale up threshold values before storing it, as the RSSI averaging
|
|
|
|
* algorithm uses a scaled up value as well. Change this scaling
|
|
|
|
* factor if the RSSI averaging algorithm changes.
|
|
|
|
*/
|
|
|
|
sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
|
|
|
|
sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
|
|
|
|
int rssi_min_thold,
|
|
|
|
int rssi_max_thold)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
|
|
|
|
WARN_ON(rssi_min_thold == rssi_max_thold ||
|
|
|
|
rssi_min_thold > rssi_max_thold);
|
|
|
|
|
|
|
|
_ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
|
|
|
|
rssi_max_thold);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
|
|
|
|
|
|
|
|
void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
|
|
|
|
_ieee80211_enable_rssi_reports(sdata, 0, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
|
2011-09-28 18:12:51 +07:00
|
|
|
|
2011-11-19 02:32:00 +07:00
|
|
|
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2011-10-27 04:47:26 +07:00
|
|
|
u16 cap)
|
|
|
|
{
|
|
|
|
__le16 tmp;
|
|
|
|
|
|
|
|
*pos++ = WLAN_EID_HT_CAPABILITY;
|
|
|
|
*pos++ = sizeof(struct ieee80211_ht_cap);
|
|
|
|
memset(pos, 0, sizeof(struct ieee80211_ht_cap));
|
|
|
|
|
|
|
|
/* capability flags */
|
|
|
|
tmp = cpu_to_le16(cap);
|
|
|
|
memcpy(pos, &tmp, sizeof(u16));
|
|
|
|
pos += sizeof(u16);
|
|
|
|
|
|
|
|
/* AMPDU parameters */
|
2011-11-19 02:32:00 +07:00
|
|
|
*pos++ = ht_cap->ampdu_factor |
|
|
|
|
(ht_cap->ampdu_density <<
|
2011-10-27 04:47:26 +07:00
|
|
|
IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
|
|
|
|
|
|
|
|
/* MCS set */
|
2011-11-19 02:32:00 +07:00
|
|
|
memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
|
|
|
|
pos += sizeof(ht_cap->mcs);
|
2011-10-27 04:47:26 +07:00
|
|
|
|
|
|
|
/* extended capabilities */
|
|
|
|
pos += sizeof(__le16);
|
|
|
|
|
|
|
|
/* BF capabilities */
|
|
|
|
pos += sizeof(__le32);
|
|
|
|
|
|
|
|
/* antenna selection */
|
|
|
|
pos += sizeof(u8);
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2012-07-02 18:25:12 +07:00
|
|
|
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
|
2012-12-07 18:45:06 +07:00
|
|
|
u32 cap)
|
2012-07-02 18:25:12 +07:00
|
|
|
{
|
|
|
|
__le32 tmp;
|
|
|
|
|
|
|
|
*pos++ = WLAN_EID_VHT_CAPABILITY;
|
2012-10-10 18:25:40 +07:00
|
|
|
*pos++ = sizeof(struct ieee80211_vht_cap);
|
|
|
|
memset(pos, 0, sizeof(struct ieee80211_vht_cap));
|
2012-07-02 18:25:12 +07:00
|
|
|
|
|
|
|
/* capability flags */
|
|
|
|
tmp = cpu_to_le32(cap);
|
|
|
|
memcpy(pos, &tmp, sizeof(u32));
|
|
|
|
pos += sizeof(u32);
|
|
|
|
|
|
|
|
/* VHT MCS set */
|
|
|
|
memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
|
|
|
|
pos += sizeof(vht_cap->vht_mcs);
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2012-03-16 01:45:16 +07:00
|
|
|
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2012-11-09 17:39:59 +07:00
|
|
|
const struct cfg80211_chan_def *chandef,
|
2012-05-01 04:20:29 +07:00
|
|
|
u16 prot_mode)
|
2011-10-27 04:47:26 +07:00
|
|
|
{
|
2012-03-16 01:45:16 +07:00
|
|
|
struct ieee80211_ht_operation *ht_oper;
|
2011-10-27 04:47:26 +07:00
|
|
|
/* Build HT Information */
|
2012-03-16 01:45:16 +07:00
|
|
|
*pos++ = WLAN_EID_HT_OPERATION;
|
|
|
|
*pos++ = sizeof(struct ieee80211_ht_operation);
|
|
|
|
ht_oper = (struct ieee80211_ht_operation *)pos;
|
2012-11-09 17:39:59 +07:00
|
|
|
ht_oper->primary_chan = ieee80211_frequency_to_channel(
|
|
|
|
chandef->chan->center_freq);
|
|
|
|
switch (chandef->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_160:
|
|
|
|
case NL80211_CHAN_WIDTH_80P80:
|
|
|
|
case NL80211_CHAN_WIDTH_80:
|
|
|
|
case NL80211_CHAN_WIDTH_40:
|
|
|
|
if (chandef->center_freq1 > chandef->chan->center_freq)
|
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
|
|
|
else
|
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
2011-10-27 04:47:26 +07:00
|
|
|
break;
|
|
|
|
default:
|
2012-03-16 01:45:16 +07:00
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
|
2011-10-27 04:47:26 +07:00
|
|
|
break;
|
|
|
|
}
|
2012-04-19 09:24:14 +07:00
|
|
|
if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
|
2012-11-09 17:39:59 +07:00
|
|
|
chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
|
|
|
|
chandef->width != NL80211_CHAN_WIDTH_20)
|
2012-03-16 01:45:16 +07:00
|
|
|
ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
|
2011-11-30 22:56:33 +07:00
|
|
|
|
2012-05-01 04:20:29 +07:00
|
|
|
ht_oper->operation_mode = cpu_to_le16(prot_mode);
|
2012-03-16 01:45:16 +07:00
|
|
|
ht_oper->stbc_param = 0x0000;
|
2011-10-27 04:47:26 +07:00
|
|
|
|
|
|
|
/* It seems that Basic MCS set and Supported MCS set
|
|
|
|
are identical for the first 10 bytes */
|
2012-03-16 01:45:16 +07:00
|
|
|
memset(&ht_oper->basic_set, 0, 16);
|
|
|
|
memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
|
2011-10-27 04:47:26 +07:00
|
|
|
|
2012-03-16 01:45:16 +07:00
|
|
|
return pos + sizeof(struct ieee80211_ht_operation);
|
2011-10-27 04:47:26 +07:00
|
|
|
}
|
|
|
|
|
2012-11-09 17:39:59 +07:00
|
|
|
void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan,
|
2013-02-12 22:43:19 +07:00
|
|
|
const struct ieee80211_ht_operation *ht_oper,
|
2012-11-09 17:39:59 +07:00
|
|
|
struct cfg80211_chan_def *chandef)
|
2011-10-27 04:47:26 +07:00
|
|
|
{
|
|
|
|
enum nl80211_channel_type channel_type;
|
|
|
|
|
2012-11-09 17:39:59 +07:00
|
|
|
if (!ht_oper) {
|
|
|
|
cfg80211_chandef_create(chandef, control_chan,
|
|
|
|
NL80211_CHAN_NO_HT);
|
|
|
|
return;
|
|
|
|
}
|
2011-10-27 04:47:26 +07:00
|
|
|
|
2012-03-16 01:45:16 +07:00
|
|
|
switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
|
2011-10-27 04:47:26 +07:00
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_NONE:
|
|
|
|
channel_type = NL80211_CHAN_HT20;
|
|
|
|
break;
|
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
|
|
|
|
channel_type = NL80211_CHAN_HT40PLUS;
|
|
|
|
break;
|
|
|
|
case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
|
|
|
|
channel_type = NL80211_CHAN_HT40MINUS;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
channel_type = NL80211_CHAN_NO_HT;
|
|
|
|
}
|
|
|
|
|
2012-11-09 17:39:59 +07:00
|
|
|
cfg80211_chandef_create(chandef, control_chan, channel_type);
|
2011-10-27 04:47:26 +07:00
|
|
|
}
|
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
|
|
|
|
const struct ieee80211_supported_band *sband,
|
|
|
|
const u8 *srates, int srates_len, u32 *rates)
|
|
|
|
{
|
|
|
|
u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
|
|
|
|
int shift = ieee80211_chandef_get_shift(chandef);
|
|
|
|
struct ieee80211_rate *br;
|
|
|
|
int brate, rate, i, j, count = 0;
|
|
|
|
|
|
|
|
*rates = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < srates_len; i++) {
|
|
|
|
rate = srates[i] & 0x7f;
|
|
|
|
|
|
|
|
for (j = 0; j < sband->n_bitrates; j++) {
|
|
|
|
br = &sband->bitrates[j];
|
|
|
|
if ((rate_flags & br->flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
|
|
|
|
if (brate == rate) {
|
|
|
|
*rates |= BIT(j);
|
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2012-06-28 15:33:25 +07:00
|
|
|
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
|
2012-07-23 19:53:27 +07:00
|
|
|
struct sk_buff *skb, bool need_basic,
|
|
|
|
enum ieee80211_band band)
|
2011-09-28 18:12:51 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2013-07-08 21:55:53 +07:00
|
|
|
int rate, shift;
|
2011-09-28 18:12:51 +07:00
|
|
|
u8 i, rates, *pos;
|
2012-06-28 15:33:25 +07:00
|
|
|
u32 basic_rates = sdata->vif.bss_conf.basic_rates;
|
2013-07-08 21:55:53 +07:00
|
|
|
u32 rate_flags;
|
2011-09-28 18:12:51 +07:00
|
|
|
|
2013-07-08 21:55:53 +07:00
|
|
|
shift = ieee80211_vif_get_shift(&sdata->vif);
|
|
|
|
rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
|
2012-07-23 19:53:27 +07:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2013-07-08 21:55:53 +07:00
|
|
|
rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
rates++;
|
|
|
|
}
|
2011-09-28 18:12:51 +07:00
|
|
|
if (rates > 8)
|
|
|
|
rates = 8;
|
|
|
|
|
|
|
|
if (skb_tailroom(skb) < rates + 2)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pos = skb_put(skb, rates + 2);
|
|
|
|
*pos++ = WLAN_EID_SUPP_RATES;
|
|
|
|
*pos++ = rates;
|
|
|
|
for (i = 0; i < rates; i++) {
|
2012-04-03 11:21:20 +07:00
|
|
|
u8 basic = 0;
|
2013-07-08 21:55:53 +07:00
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
|
2012-04-03 11:21:20 +07:00
|
|
|
if (need_basic && basic_rates & BIT(i))
|
|
|
|
basic = 0x80;
|
2011-09-28 18:12:51 +07:00
|
|
|
rate = sband->bitrates[i].bitrate;
|
2013-07-08 21:55:53 +07:00
|
|
|
rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
|
|
|
|
5 * (1 << shift));
|
|
|
|
*pos++ = basic | (u8) rate;
|
2011-09-28 18:12:51 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-28 15:33:25 +07:00
|
|
|
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
|
2012-07-23 19:53:27 +07:00
|
|
|
struct sk_buff *skb, bool need_basic,
|
|
|
|
enum ieee80211_band band)
|
2011-09-28 18:12:51 +07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2013-09-08 13:40:44 +07:00
|
|
|
int rate, shift;
|
2011-09-28 18:12:51 +07:00
|
|
|
u8 i, exrates, *pos;
|
2012-06-28 15:33:25 +07:00
|
|
|
u32 basic_rates = sdata->vif.bss_conf.basic_rates;
|
2013-07-08 21:55:53 +07:00
|
|
|
u32 rate_flags;
|
|
|
|
|
|
|
|
rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
|
|
|
|
shift = ieee80211_vif_get_shift(&sdata->vif);
|
2011-09-28 18:12:51 +07:00
|
|
|
|
2012-07-23 19:53:27 +07:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2013-07-08 21:55:53 +07:00
|
|
|
exrates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
exrates++;
|
|
|
|
}
|
|
|
|
|
2011-09-28 18:12:51 +07:00
|
|
|
if (exrates > 8)
|
|
|
|
exrates -= 8;
|
|
|
|
else
|
|
|
|
exrates = 0;
|
|
|
|
|
|
|
|
if (skb_tailroom(skb) < exrates + 2)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (exrates) {
|
|
|
|
pos = skb_put(skb, exrates + 2);
|
|
|
|
*pos++ = WLAN_EID_EXT_SUPP_RATES;
|
|
|
|
*pos++ = exrates;
|
|
|
|
for (i = 8; i < sband->n_bitrates; i++) {
|
2012-04-03 11:21:20 +07:00
|
|
|
u8 basic = 0;
|
2013-07-08 21:55:53 +07:00
|
|
|
if ((rate_flags & sband->bitrates[i].flags)
|
|
|
|
!= rate_flags)
|
|
|
|
continue;
|
2012-04-03 11:21:20 +07:00
|
|
|
if (need_basic && basic_rates & BIT(i))
|
|
|
|
basic = 0x80;
|
2013-07-08 21:55:53 +07:00
|
|
|
rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
|
|
|
|
5 * (1 << shift));
|
|
|
|
*pos++ = basic | (u8) rate;
|
2011-09-28 18:12:51 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-04-14 02:02:57 +07:00
|
|
|
|
|
|
|
int ieee80211_ave_rssi(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
|
|
|
|
|
2012-04-23 23:30:32 +07:00
|
|
|
if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
|
|
|
|
/* non-managed type inferfaces */
|
|
|
|
return 0;
|
|
|
|
}
|
2013-03-20 22:05:45 +07:00
|
|
|
return ifmgd->ave_beacon_signal / 16;
|
2012-04-14 02:02:57 +07:00
|
|
|
}
|
2012-04-21 01:57:00 +07:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
|
2012-09-11 19:34:12 +07:00
|
|
|
|
|
|
|
u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
|
|
|
|
{
|
|
|
|
if (!mcs)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* TODO: consider rx_highest */
|
|
|
|
|
|
|
|
if (mcs->rx_mask[3])
|
|
|
|
return 4;
|
|
|
|
if (mcs->rx_mask[2])
|
|
|
|
return 3;
|
|
|
|
if (mcs->rx_mask[1])
|
|
|
|
return 2;
|
|
|
|
return 1;
|
|
|
|
}
|
2012-11-14 01:46:27 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ieee80211_calculate_rx_timestamp - calculate timestamp in frame
|
|
|
|
* @local: mac80211 hw info struct
|
|
|
|
* @status: RX status
|
|
|
|
* @mpdu_len: total MPDU length (including FCS)
|
|
|
|
* @mpdu_offset: offset into MPDU to calculate timestamp at
|
|
|
|
*
|
|
|
|
* This function calculates the RX timestamp at the given MPDU offset, taking
|
|
|
|
* into account what the RX timestamp was. An offset of 0 will just normalize
|
|
|
|
* the timestamp to TSF at beginning of MPDU reception.
|
|
|
|
*/
|
|
|
|
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_rx_status *status,
|
|
|
|
unsigned int mpdu_len,
|
|
|
|
unsigned int mpdu_offset)
|
|
|
|
{
|
|
|
|
u64 ts = status->mactime;
|
|
|
|
struct rate_info ri;
|
|
|
|
u16 rate;
|
|
|
|
|
|
|
|
if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
memset(&ri, 0, sizeof(ri));
|
|
|
|
|
|
|
|
/* Fill cfg80211 rate info */
|
|
|
|
if (status->flag & RX_FLAG_HT) {
|
|
|
|
ri.mcs = status->rate_idx;
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_MCS;
|
|
|
|
if (status->flag & RX_FLAG_40MHZ)
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
|
|
|
|
if (status->flag & RX_FLAG_SHORT_GI)
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
|
2012-11-09 21:07:02 +07:00
|
|
|
} else if (status->flag & RX_FLAG_VHT) {
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
|
|
|
|
ri.mcs = status->rate_idx;
|
|
|
|
ri.nss = status->vht_nss;
|
|
|
|
if (status->flag & RX_FLAG_40MHZ)
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
|
2014-02-05 21:37:11 +07:00
|
|
|
if (status->vht_flag & RX_VHT_FLAG_80MHZ)
|
2012-11-09 21:07:02 +07:00
|
|
|
ri.flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
|
2014-02-05 21:37:11 +07:00
|
|
|
if (status->vht_flag & RX_VHT_FLAG_80P80MHZ)
|
2012-11-09 21:07:02 +07:00
|
|
|
ri.flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
|
2014-02-05 21:37:11 +07:00
|
|
|
if (status->vht_flag & RX_VHT_FLAG_160MHZ)
|
2012-11-09 21:07:02 +07:00
|
|
|
ri.flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
|
|
|
|
if (status->flag & RX_FLAG_SHORT_GI)
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
|
2012-11-14 01:46:27 +07:00
|
|
|
} else {
|
|
|
|
struct ieee80211_supported_band *sband;
|
2013-07-08 21:55:53 +07:00
|
|
|
int shift = 0;
|
|
|
|
int bitrate;
|
|
|
|
|
|
|
|
if (status->flag & RX_FLAG_10MHZ)
|
|
|
|
shift = 1;
|
|
|
|
if (status->flag & RX_FLAG_5MHZ)
|
|
|
|
shift = 2;
|
2012-11-14 01:46:27 +07:00
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[status->band];
|
2013-07-08 21:55:53 +07:00
|
|
|
bitrate = sband->bitrates[status->rate_idx].bitrate;
|
|
|
|
ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
|
2012-11-14 01:46:27 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
rate = cfg80211_calculate_bitrate(&ri);
|
2013-10-11 20:47:06 +07:00
|
|
|
if (WARN_ONCE(!rate,
|
|
|
|
"Invalid bitrate: flags=0x%x, idx=%d, vht_nss=%d\n",
|
|
|
|
status->flag, status->rate_idx, status->vht_nss))
|
|
|
|
return 0;
|
2012-11-14 01:46:27 +07:00
|
|
|
|
|
|
|
/* rewind from end of MPDU */
|
|
|
|
if (status->flag & RX_FLAG_MACTIME_END)
|
|
|
|
ts -= mpdu_len * 8 * 10 / rate;
|
|
|
|
|
|
|
|
ts += mpdu_offset * 8 * 10 / rate;
|
|
|
|
|
|
|
|
return ts;
|
|
|
|
}
|
2013-02-09 00:16:20 +07:00
|
|
|
|
|
|
|
void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2013-11-06 19:55:51 +07:00
|
|
|
struct cfg80211_chan_def chandef;
|
2013-02-09 00:16:20 +07:00
|
|
|
|
mac80211: fix iflist_mtx/mtx locking in radar detection
The scan code creates an iflist_mtx -> mtx locking dependency,
and a few other places, notably radar detection, were creating
the opposite dependency, causing lockdep to complain. As scan
and radar detection are mutually exclusive, the deadlock can't
really happen in practice, but it's still bad form.
A similar issue exists in the monitor mode code, but this is
only used by channel-context drivers right now and those have
to have hardware scan, so that also can't happen.
Still, fix these issues by making some of the channel context
code require the mtx to be held rather than acquiring it, thus
allowing the monitor/radar callers to keep the iflist_mtx->mtx
lock ordering.
While at it, also fix access to the local->scanning variable
in the radar code, and document that radar_detect_enabled is
now properly protected by the mtx.
All this would now introduce an ABBA deadlock between the DFS
work cancelling and local->mtx, so change the locking there a
bit to not need to use cancel_delayed_work_sync() but be able
to just use cancel_delayed_work(). The work is also safely
stopped/removed when the interface is stopped, so no extra
changes are needed.
Reported-by: Kalle Valo <kvalo@qca.qualcomm.com>
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-12-18 15:43:33 +07:00
|
|
|
mutex_lock(&local->mtx);
|
2013-02-09 00:16:20 +07:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
mac80211: fix iflist_mtx/mtx locking in radar detection
The scan code creates an iflist_mtx -> mtx locking dependency,
and a few other places, notably radar detection, were creating
the opposite dependency, causing lockdep to complain. As scan
and radar detection are mutually exclusive, the deadlock can't
really happen in practice, but it's still bad form.
A similar issue exists in the monitor mode code, but this is
only used by channel-context drivers right now and those have
to have hardware scan, so that also can't happen.
Still, fix these issues by making some of the channel context
code require the mtx to be held rather than acquiring it, thus
allowing the monitor/radar callers to keep the iflist_mtx->mtx
lock ordering.
While at it, also fix access to the local->scanning variable
in the radar code, and document that radar_detect_enabled is
now properly protected by the mtx.
All this would now introduce an ABBA deadlock between the DFS
work cancelling and local->mtx, so change the locking there a
bit to not need to use cancel_delayed_work_sync() but be able
to just use cancel_delayed_work(). The work is also safely
stopped/removed when the interface is stopped, so no extra
changes are needed.
Reported-by: Kalle Valo <kvalo@qca.qualcomm.com>
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-12-18 15:43:33 +07:00
|
|
|
/* it might be waiting for the local->mtx, but then
|
|
|
|
* by the time it gets it, sdata->wdev.cac_started
|
|
|
|
* will no longer be true
|
|
|
|
*/
|
|
|
|
cancel_delayed_work(&sdata->dfs_cac_timer_work);
|
2013-02-09 00:16:20 +07:00
|
|
|
|
|
|
|
if (sdata->wdev.cac_started) {
|
2013-11-06 19:55:51 +07:00
|
|
|
chandef = sdata->vif.bss_conf.chandef;
|
2013-02-09 00:16:20 +07:00
|
|
|
ieee80211_vif_release_channel(sdata);
|
|
|
|
cfg80211_cac_event(sdata->dev,
|
2013-11-06 19:55:51 +07:00
|
|
|
&chandef,
|
2013-02-09 00:16:20 +07:00
|
|
|
NL80211_RADAR_CAC_ABORTED,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
mac80211: fix iflist_mtx/mtx locking in radar detection
The scan code creates an iflist_mtx -> mtx locking dependency,
and a few other places, notably radar detection, were creating
the opposite dependency, causing lockdep to complain. As scan
and radar detection are mutually exclusive, the deadlock can't
really happen in practice, but it's still bad form.
A similar issue exists in the monitor mode code, but this is
only used by channel-context drivers right now and those have
to have hardware scan, so that also can't happen.
Still, fix these issues by making some of the channel context
code require the mtx to be held rather than acquiring it, thus
allowing the monitor/radar callers to keep the iflist_mtx->mtx
lock ordering.
While at it, also fix access to the local->scanning variable
in the radar code, and document that radar_detect_enabled is
now properly protected by the mtx.
All this would now introduce an ABBA deadlock between the DFS
work cancelling and local->mtx, so change the locking there a
bit to not need to use cancel_delayed_work_sync() but be able
to just use cancel_delayed_work(). The work is also safely
stopped/removed when the interface is stopped, so no extra
changes are needed.
Reported-by: Kalle Valo <kvalo@qca.qualcomm.com>
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-12-18 15:43:33 +07:00
|
|
|
mutex_unlock(&local->mtx);
|
2013-02-09 00:16:20 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_dfs_radar_detected_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local, radar_detected_work);
|
2013-11-05 20:48:46 +07:00
|
|
|
struct cfg80211_chan_def chandef = local->hw.conf.chandef;
|
2013-02-09 00:16:20 +07:00
|
|
|
|
|
|
|
ieee80211_dfs_cac_cancel(local);
|
|
|
|
|
|
|
|
if (local->use_chanctx)
|
|
|
|
/* currently not handled */
|
|
|
|
WARN_ON(1);
|
2013-11-05 20:48:46 +07:00
|
|
|
else
|
2013-02-09 00:16:20 +07:00
|
|
|
cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_radar_detected(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
trace_api_radar_detected(local);
|
|
|
|
|
|
|
|
ieee80211_queue_work(hw, &local->radar_detected_work);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_radar_detected);
|
2013-08-28 18:41:29 +07:00
|
|
|
|
|
|
|
u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
|
|
|
|
{
|
|
|
|
u32 ret;
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
switch (c->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_20:
|
|
|
|
c->width = NL80211_CHAN_WIDTH_20_NOHT;
|
|
|
|
ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_40:
|
|
|
|
c->width = NL80211_CHAN_WIDTH_20;
|
|
|
|
c->center_freq1 = c->chan->center_freq;
|
|
|
|
ret = IEEE80211_STA_DISABLE_40MHZ |
|
|
|
|
IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80:
|
|
|
|
tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
|
|
|
|
/* n_P40 */
|
|
|
|
tmp /= 2;
|
|
|
|
/* freq_P40 */
|
|
|
|
c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
|
|
|
|
c->width = NL80211_CHAN_WIDTH_40;
|
|
|
|
ret = IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80P80:
|
|
|
|
c->center_freq2 = 0;
|
|
|
|
c->width = NL80211_CHAN_WIDTH_80;
|
|
|
|
ret = IEEE80211_STA_DISABLE_80P80MHZ |
|
|
|
|
IEEE80211_STA_DISABLE_160MHZ;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_160:
|
|
|
|
/* n_P20 */
|
|
|
|
tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
|
|
|
|
/* n_P80 */
|
|
|
|
tmp /= 4;
|
|
|
|
c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
|
|
|
|
c->width = NL80211_CHAN_WIDTH_80;
|
|
|
|
ret = IEEE80211_STA_DISABLE_80P80MHZ |
|
|
|
|
IEEE80211_STA_DISABLE_160MHZ;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case NL80211_CHAN_WIDTH_20_NOHT:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
c->width = NL80211_CHAN_WIDTH_20_NOHT;
|
|
|
|
ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_5:
|
|
|
|
case NL80211_CHAN_WIDTH_10:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
/* keep c->width */
|
|
|
|
ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!cfg80211_chandef_valid(c));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-10-01 20:45:43 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns true if smps_mode_new is strictly more restrictive than
|
|
|
|
* smps_mode_old.
|
|
|
|
*/
|
|
|
|
bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
|
|
|
|
enum ieee80211_smps_mode smps_mode_new)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC ||
|
|
|
|
smps_mode_new == IEEE80211_SMPS_AUTOMATIC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (smps_mode_old) {
|
|
|
|
case IEEE80211_SMPS_STATIC:
|
|
|
|
return false;
|
|
|
|
case IEEE80211_SMPS_DYNAMIC:
|
|
|
|
return smps_mode_new == IEEE80211_SMPS_STATIC;
|
|
|
|
case IEEE80211_SMPS_OFF:
|
|
|
|
return smps_mode_new != IEEE80211_SMPS_OFF;
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2013-10-15 09:08:28 +07:00
|
|
|
|
|
|
|
int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_csa_settings *csa_settings)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int freq;
|
|
|
|
int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.chan_switch) +
|
|
|
|
sizeof(mgmt->u.action.u.chan_switch);
|
|
|
|
u8 *pos;
|
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->tx_headroom + hdr_len +
|
|
|
|
5 + /* channel switch announcement element */
|
|
|
|
3 + /* secondary channel offset element */
|
|
|
|
8); /* mesh channel switch parameters element */
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->tx_headroom);
|
|
|
|
mgmt = (struct ieee80211_mgmt *)skb_put(skb, hdr_len);
|
|
|
|
memset(mgmt, 0, hdr_len);
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_ACTION);
|
|
|
|
|
|
|
|
eth_broadcast_addr(mgmt->da);
|
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
|
|
|
memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
|
|
|
|
} else {
|
|
|
|
struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
|
|
|
|
memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
|
|
|
|
}
|
|
|
|
mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
|
|
|
|
mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
|
|
|
|
pos = skb_put(skb, 5);
|
|
|
|
*pos++ = WLAN_EID_CHANNEL_SWITCH; /* EID */
|
|
|
|
*pos++ = 3; /* IE length */
|
|
|
|
*pos++ = csa_settings->block_tx ? 1 : 0; /* CSA mode */
|
|
|
|
freq = csa_settings->chandef.chan->center_freq;
|
|
|
|
*pos++ = ieee80211_frequency_to_channel(freq); /* channel */
|
|
|
|
*pos++ = csa_settings->count; /* count */
|
|
|
|
|
|
|
|
if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
|
|
|
|
enum nl80211_channel_type ch_type;
|
|
|
|
|
|
|
|
skb_put(skb, 3);
|
|
|
|
*pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET; /* EID */
|
|
|
|
*pos++ = 1; /* IE length */
|
|
|
|
ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
|
|
|
|
if (ch_type == NL80211_CHAN_HT40PLUS)
|
|
|
|
*pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
|
|
|
else
|
|
|
|
*pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
|
|
|
struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
|
|
|
|
|
|
|
|
skb_put(skb, 8);
|
|
|
|
*pos++ = WLAN_EID_CHAN_SWITCH_PARAM; /* EID */
|
|
|
|
*pos++ = 6; /* IE length */
|
|
|
|
*pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL; /* Mesh TTL */
|
|
|
|
*pos = 0x00; /* Mesh Flag: Tx Restrict, Initiator, Reason */
|
|
|
|
*pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
|
|
|
|
*pos++ |= csa_settings->block_tx ?
|
|
|
|
WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
|
|
|
|
put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
|
|
|
|
pos += 2;
|
2013-11-12 09:31:48 +07:00
|
|
|
put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
|
2013-10-15 09:08:28 +07:00
|
|
|
pos += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-03-24 19:23:27 +07:00
|
|
|
|
|
|
|
bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
|
|
|
|
{
|
|
|
|
return !(cs == NULL || cs->cipher == 0 ||
|
|
|
|
cs->hdr_len < cs->pn_len + cs->pn_off ||
|
|
|
|
cs->hdr_len <= cs->key_idx_off ||
|
|
|
|
cs->key_idx_shift > 7 ||
|
|
|
|
cs->key_idx_mask == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Ensure we have enough iftype bitmap space for all iftype values */
|
|
|
|
WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
if (!ieee80211_cs_valid(&cs[i]))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct ieee80211_cipher_scheme *
|
|
|
|
ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
|
|
|
|
enum nl80211_iftype iftype)
|
|
|
|
{
|
|
|
|
const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
|
|
|
|
int n = local->hw.n_cipher_schemes;
|
|
|
|
int i;
|
|
|
|
const struct ieee80211_cipher_scheme *cs = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (l[i].cipher == cipher) {
|
|
|
|
cs = &l[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cs || !(cs->iftype & BIT(iftype)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return cs;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ieee80211_cs_headroom(struct ieee80211_local *local,
|
|
|
|
struct cfg80211_crypto_settings *crypto,
|
|
|
|
enum nl80211_iftype iftype)
|
|
|
|
{
|
|
|
|
const struct ieee80211_cipher_scheme *cs;
|
|
|
|
int headroom = IEEE80211_ENCRYPT_HEADROOM;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
|
|
|
|
cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
|
|
|
|
iftype);
|
|
|
|
|
|
|
|
if (cs && headroom < cs->hdr_len)
|
|
|
|
headroom = cs->hdr_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
|
|
|
|
if (cs && headroom < cs->hdr_len)
|
|
|
|
headroom = cs->hdr_len;
|
|
|
|
|
|
|
|
return headroom;
|
|
|
|
}
|
2013-12-17 03:49:14 +07:00
|
|
|
|
|
|
|
static bool
|
|
|
|
ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
|
|
|
|
{
|
|
|
|
s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
|
|
|
|
int skip;
|
|
|
|
|
|
|
|
if (end > 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* End time is in the past, check for repetitions */
|
|
|
|
skip = DIV_ROUND_UP(-end, data->desc[i].interval);
|
|
|
|
if (data->count[i] < 255) {
|
|
|
|
if (data->count[i] <= skip) {
|
|
|
|
data->count[i] = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->count[i] -= skip;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->desc[i].start += skip * data->desc[i].interval;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
|
|
|
|
s32 *offset)
|
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
|
|
|
|
s32 cur;
|
|
|
|
|
|
|
|
if (!data->count[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
|
|
|
|
ret = true;
|
|
|
|
|
|
|
|
cur = data->desc[i].start - tsf;
|
|
|
|
if (cur > *offset)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cur = data->desc[i].start + data->desc[i].duration - tsf;
|
|
|
|
if (cur > *offset)
|
|
|
|
*offset = cur;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32
|
|
|
|
ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
|
|
|
|
{
|
|
|
|
s32 offset = 0;
|
|
|
|
int tries = 0;
|
|
|
|
/*
|
|
|
|
* arbitrary limit, used to avoid infinite loops when combined NoA
|
|
|
|
* descriptors cover the full time period.
|
|
|
|
*/
|
|
|
|
int max_tries = 5;
|
|
|
|
|
|
|
|
ieee80211_extend_absent_time(data, tsf, &offset);
|
|
|
|
do {
|
|
|
|
if (!ieee80211_extend_absent_time(data, tsf, &offset))
|
|
|
|
break;
|
|
|
|
|
|
|
|
tries++;
|
|
|
|
} while (tries < max_tries);
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
|
|
|
|
{
|
|
|
|
u32 next_offset = BIT(31) - 1;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
data->absent = 0;
|
|
|
|
data->has_next_tsf = false;
|
|
|
|
for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
|
|
|
|
s32 start;
|
|
|
|
|
|
|
|
if (!data->count[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ieee80211_extend_noa_desc(data, tsf, i);
|
|
|
|
start = data->desc[i].start - tsf;
|
|
|
|
if (start <= 0)
|
|
|
|
data->absent |= BIT(i);
|
|
|
|
|
|
|
|
if (next_offset > start)
|
|
|
|
next_offset = start;
|
|
|
|
|
|
|
|
data->has_next_tsf = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data->absent)
|
|
|
|
next_offset = ieee80211_get_noa_absent_time(data, tsf);
|
|
|
|
|
|
|
|
data->next_tsf = tsf + next_offset;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_update_p2p_noa);
|
|
|
|
|
|
|
|
int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
|
|
|
|
struct ieee80211_noa_data *data, u32 tsf)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(data, 0, sizeof(*data));
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
|
|
|
|
const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
|
|
|
|
|
|
|
|
if (!desc->count || !desc->duration)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
data->count[i] = desc->count;
|
|
|
|
data->desc[i].start = le32_to_cpu(desc->start_time);
|
|
|
|
data->desc[i].duration = le32_to_cpu(desc->duration);
|
|
|
|
data->desc[i].interval = le32_to_cpu(desc->interval);
|
|
|
|
|
|
|
|
if (data->count[i] > 1 &&
|
|
|
|
data->desc[i].interval < data->desc[i].duration)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ieee80211_extend_noa_desc(data, tsf, i);
|
|
|
|
ret++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
ieee80211_update_p2p_noa(data, tsf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
|
2013-12-20 01:25:15 +07:00
|
|
|
|
|
|
|
void ieee80211_recalc_dtim(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
u64 tsf = drv_get_tsf(local, sdata);
|
|
|
|
u64 dtim_count = 0;
|
|
|
|
u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
|
|
|
|
u8 dtim_period = sdata->vif.bss_conf.dtim_period;
|
|
|
|
struct ps_data *ps;
|
|
|
|
u8 bcns_from_dtim;
|
|
|
|
|
|
|
|
if (tsf == -1ULL || !beacon_int || !dtim_period)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
|
|
|
|
if (!sdata->bss)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ps = &sdata->bss->ps;
|
|
|
|
} else if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
|
|
|
ps = &sdata->u.mesh.ps;
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* actually finds last dtim_count, mac80211 will update in
|
|
|
|
* __beacon_add_tim().
|
|
|
|
* dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
|
|
|
|
*/
|
|
|
|
do_div(tsf, beacon_int);
|
|
|
|
bcns_from_dtim = do_div(tsf, dtim_period);
|
|
|
|
/* just had a DTIM */
|
|
|
|
if (!bcns_from_dtim)
|
|
|
|
dtim_count = 0;
|
|
|
|
else
|
|
|
|
dtim_count = dtim_period - bcns_from_dtim;
|
|
|
|
|
|
|
|
ps->dtim_count = dtim_count;
|
|
|
|
}
|
2014-02-13 16:31:59 +07:00
|
|
|
|
2014-06-25 17:35:07 +07:00
|
|
|
static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_chanctx *ctx)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
u8 radar_detect = 0;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list)
|
|
|
|
if (sdata->reserved_radar_required)
|
|
|
|
radar_detect |= BIT(sdata->reserved_chandef.width);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* An in-place reservation context should not have any assigned vifs
|
|
|
|
* until it replaces the other context.
|
|
|
|
*/
|
|
|
|
WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
|
|
|
|
!list_empty(&ctx->assigned_vifs));
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list)
|
|
|
|
if (sdata->radar_required)
|
|
|
|
radar_detect |= BIT(sdata->vif.bss_conf.chandef.width);
|
|
|
|
|
|
|
|
return radar_detect;
|
|
|
|
}
|
|
|
|
|
2014-02-13 16:31:59 +07:00
|
|
|
int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
enum ieee80211_chanctx_mode chanmode,
|
|
|
|
u8 radar_detect)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *sdata_iter;
|
|
|
|
enum nl80211_iftype iftype = sdata->wdev.iftype;
|
|
|
|
int num[NUM_NL80211_IFTYPES];
|
|
|
|
struct ieee80211_chanctx *ctx;
|
2014-02-27 16:07:21 +07:00
|
|
|
int num_different_channels = 0;
|
2014-02-13 16:31:59 +07:00
|
|
|
int total = 1;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
if (WARN_ON(hweight32(radar_detect) > 1))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-02-27 16:07:21 +07:00
|
|
|
if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
|
|
|
|
!chandef->chan))
|
2014-02-13 16:31:59 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-02-27 16:07:21 +07:00
|
|
|
if (chandef)
|
|
|
|
num_different_channels = 1;
|
|
|
|
|
2014-02-13 16:31:59 +07:00
|
|
|
if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Always allow software iftypes */
|
|
|
|
if (local->hw.wiphy->software_iftypes & BIT(iftype)) {
|
|
|
|
if (radar_detect)
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(num, 0, sizeof(num));
|
|
|
|
|
|
|
|
if (iftype != NL80211_IFTYPE_UNSPECIFIED)
|
|
|
|
num[iftype] = 1;
|
|
|
|
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list) {
|
2014-06-25 17:35:06 +07:00
|
|
|
if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
|
|
|
|
continue;
|
2014-06-25 17:35:07 +07:00
|
|
|
radar_detect |= ieee80211_chanctx_radar_detect(local, ctx);
|
2014-02-13 16:31:59 +07:00
|
|
|
if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) {
|
|
|
|
num_different_channels++;
|
|
|
|
continue;
|
|
|
|
}
|
2014-02-27 16:07:21 +07:00
|
|
|
if (chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
|
2014-02-13 16:31:59 +07:00
|
|
|
cfg80211_chandef_compatible(chandef,
|
|
|
|
&ctx->conf.def))
|
|
|
|
continue;
|
|
|
|
num_different_channels++;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) {
|
|
|
|
struct wireless_dev *wdev_iter;
|
|
|
|
|
|
|
|
wdev_iter = &sdata_iter->wdev;
|
|
|
|
|
|
|
|
if (sdata_iter == sdata ||
|
|
|
|
rcu_access_pointer(sdata_iter->vif.chanctx_conf) == NULL ||
|
|
|
|
local->hw.wiphy->software_iftypes & BIT(wdev_iter->iftype))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
num[wdev_iter->iftype]++;
|
|
|
|
total++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (total == 1 && !radar_detect)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return cfg80211_check_combinations(local->hw.wiphy,
|
|
|
|
num_different_channels,
|
|
|
|
radar_detect, num);
|
|
|
|
}
|
2014-04-09 20:29:23 +07:00
|
|
|
|
|
|
|
static void
|
|
|
|
ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
u32 *max_num_different_channels = data;
|
|
|
|
|
|
|
|
*max_num_different_channels = max(*max_num_different_channels,
|
|
|
|
c->num_different_channels);
|
|
|
|
}
|
|
|
|
|
|
|
|
int ieee80211_max_num_channels(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
int num[NUM_NL80211_IFTYPES] = {};
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
int num_different_channels = 0;
|
|
|
|
u8 radar_detect = 0;
|
|
|
|
u32 max_num_different_channels = 1;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list) {
|
2014-06-25 17:35:06 +07:00
|
|
|
if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
|
|
|
|
continue;
|
|
|
|
|
2014-04-09 20:29:23 +07:00
|
|
|
num_different_channels++;
|
|
|
|
|
2014-06-25 17:35:07 +07:00
|
|
|
radar_detect |= ieee80211_chanctx_radar_detect(local, ctx);
|
2014-04-09 20:29:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list)
|
|
|
|
num[sdata->wdev.iftype]++;
|
|
|
|
|
|
|
|
err = cfg80211_iter_combinations(local->hw.wiphy,
|
|
|
|
num_different_channels, radar_detect,
|
|
|
|
num, ieee80211_iter_max_chans,
|
|
|
|
&max_num_different_channels);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return max_num_different_channels;
|
|
|
|
}
|
2014-07-17 21:14:23 +07:00
|
|
|
|
|
|
|
u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo)
|
|
|
|
{
|
|
|
|
*buf++ = WLAN_EID_VENDOR_SPECIFIC;
|
|
|
|
*buf++ = 7; /* len */
|
|
|
|
*buf++ = 0x00; /* Microsoft OUI 00:50:F2 */
|
|
|
|
*buf++ = 0x50;
|
|
|
|
*buf++ = 0xf2;
|
|
|
|
*buf++ = 2; /* WME */
|
|
|
|
*buf++ = 0; /* WME info */
|
|
|
|
*buf++ = 1; /* WME ver */
|
|
|
|
*buf++ = qosinfo; /* U-APSD no in use */
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|