2007-07-27 07:43:23 -06: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 09:47:34 -06:00
|
|
|
#include <linux/export.h>
|
2007-07-27 07:43:23 -06: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 08:54:50 -07:00
|
|
|
#include <linux/crc32.h>
|
2007-09-17 12:56:21 -06:00
|
|
|
#include <net/net_namespace.h>
|
2007-07-27 07:43:23 -06:00
|
|
|
#include <net/cfg80211.h>
|
2007-11-08 17:57:29 -07:00
|
|
|
#include <net/rtnetlink.h>
|
2007-07-27 07:43:23 -06:00
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 10:52:52 -06:00
|
|
|
#include "driver-ops.h"
|
2008-04-08 13:14:40 -06:00
|
|
|
#include "rate.h"
|
2008-02-23 07:17:11 -07:00
|
|
|
#include "mesh.h"
|
2007-07-27 07:43:23 -06:00
|
|
|
#include "wme.h"
|
2009-04-14 02:09:24 -06: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 06:22:54 -06:00
|
|
|
#include "wep.h"
|
2007-07-27 07:43:23 -06:00
|
|
|
|
|
|
|
/* privid for wiphys to determine whether they belong to us or not */
|
|
|
|
void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
|
|
|
|
|
2009-01-22 16: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 07:43:23 -06:00
|
|
|
|
2007-12-25 08:00:36 -07:00
|
|
|
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
|
2008-09-10 16:01:58 -06:00
|
|
|
enum nl80211_iftype type)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
2008-06-11 15:21:58 -06:00
|
|
|
__le16 fc = hdr->frame_control;
|
2007-07-27 07:43:23 -06:00
|
|
|
|
2007-12-18 08:23:53 -07:00
|
|
|
/* drop ACK/CTS frames and incorrect hdr len (ctrl) */
|
|
|
|
if (len < 16)
|
2007-07-27 07:43:23 -06:00
|
|
|
return NULL;
|
|
|
|
|
2008-06-11 15:21:58 -06:00
|
|
|
if (ieee80211_is_data(fc)) {
|
2007-12-18 08:23:53 -07:00
|
|
|
if (len < 24) /* drop incorrect hdr len (data) */
|
|
|
|
return NULL;
|
2008-06-11 15:21:58 -06:00
|
|
|
|
|
|
|
if (ieee80211_has_a4(fc))
|
2007-07-27 07:43:23 -06:00
|
|
|
return NULL;
|
2008-06-11 15:21:58 -06:00
|
|
|
if (ieee80211_has_tods(fc))
|
|
|
|
return hdr->addr1;
|
|
|
|
if (ieee80211_has_fromds(fc))
|
2007-07-27 07:43:23 -06:00
|
|
|
return hdr->addr2;
|
2008-06-11 15:21:58 -06:00
|
|
|
|
|
|
|
return hdr->addr3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_mgmt(fc)) {
|
2007-12-18 08:23:53 -07:00
|
|
|
if (len < 24) /* drop incorrect hdr len (mgmt) */
|
|
|
|
return NULL;
|
2007-07-27 07:43:23 -06:00
|
|
|
return hdr->addr3;
|
2008-06-11 15:21:58 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_ctl(fc)) {
|
|
|
|
if(ieee80211_is_pspoll(fc))
|
2007-07-27 07:43:23 -06:00
|
|
|
return hdr->addr1;
|
2008-06-11 15:21:58 -06:00
|
|
|
|
|
|
|
if (ieee80211_is_back_req(fc)) {
|
2007-12-25 08:00:36 -07:00
|
|
|
switch (type) {
|
2008-09-10 16:01:58 -06:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2007-12-25 08:00:36 -07:00
|
|
|
return hdr->addr2;
|
2008-09-10 16:01:58 -06:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2007-12-25 08:00:36 -07:00
|
|
|
return hdr->addr1;
|
|
|
|
default:
|
2008-06-11 15:21:58 -06:00
|
|
|
break; /* fall through to the return */
|
2007-12-25 08:00:36 -07:00
|
|
|
}
|
|
|
|
}
|
2007-07-27 07:43:23 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-25 08:27:43 -07:00
|
|
|
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
2011-11-16 07:28:55 -07:00
|
|
|
struct sk_buff *skb;
|
2009-03-23 10:28:35 -06:00
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
|
2011-11-16 07:28:55 -07:00
|
|
|
skb_queue_walk(&tx->skbs, skb) {
|
2009-03-23 10:28:35 -06:00
|
|
|
hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
2011-11-16 07:28:55 -07:00
|
|
|
}
|
2007-07-27 07:43:23 -06:00
|
|
|
}
|
|
|
|
|
2012-04-11 00:47:56 -06:00
|
|
|
int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
|
2007-07-27 07:43:23 -06:00
|
|
|
int rate, int erp, int short_preamble)
|
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2012-04-11 00:47:56 -06:00
|
|
|
if (band == IEEE80211_BAND_5GHZ || erp) {
|
2007-07-27 07:43:23 -06: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
|
|
|
|
* 802.11a - 17.5.2: aSIFSTime = 16 usec
|
|
|
|
* 802.11g - 19.8.4: aSIFSTime = 10 usec +
|
|
|
|
* signal ext = 6 usec
|
|
|
|
*/
|
|
|
|
dur = 16; /* SIFS + signal ext */
|
|
|
|
dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
|
|
|
|
dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
|
|
|
|
dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
|
|
|
|
4 * rate); /* T_SYM x N_SYM */
|
|
|
|
} 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-18 17:31:26 -07:00
|
|
|
__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2012-04-11 00:47:56 -06:00
|
|
|
enum ieee80211_band band,
|
2008-01-24 11:38:38 -07:00
|
|
|
size_t frame_len,
|
|
|
|
struct ieee80211_rate *rate)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
2008-09-12 14:52:47 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-07-27 07:43:23 -06:00
|
|
|
u16 dur;
|
|
|
|
int erp;
|
2008-09-12 14:52:47 -06:00
|
|
|
bool short_preamble = false;
|
2007-07-27 07:43:23 -06:00
|
|
|
|
2008-01-24 11:38:38 -07:00
|
|
|
erp = 0;
|
2008-09-12 14:52:47 -06:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 17:51:51 -06:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 14:52:47 -06:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
|
|
|
}
|
2008-01-24 11:38:38 -07:00
|
|
|
|
2012-04-11 00:47:56 -06:00
|
|
|
dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
|
2008-09-12 14:52:47 -06:00
|
|
|
short_preamble);
|
2007-07-27 07:43:23 -06:00
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_generic_frame_duration);
|
|
|
|
|
2007-12-18 17:31:26 -07:00
|
|
|
__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif, size_t frame_len,
|
2008-05-15 04:55:29 -06:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-12 14:52:47 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 06:32:58 -07:00
|
|
|
bool short_preamble;
|
2007-07-27 07:43:23 -06:00
|
|
|
int erp;
|
|
|
|
u16 dur;
|
2008-05-15 04:55:27 -06:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
2012-04-11 00:47:56 -06:00
|
|
|
sband = local->hw.wiphy->bands[frame_txctl->band];
|
2007-07-27 07:43:23 -06:00
|
|
|
|
2008-09-12 14:52:47 -06:00
|
|
|
short_preamble = false;
|
2007-07-27 07:43:24 -06:00
|
|
|
|
2008-05-15 04:55:29 -06:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-24 11:38:38 -07:00
|
|
|
|
|
|
|
erp = 0;
|
2008-09-12 14:52:47 -06:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 17:51:51 -06:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 14:52:47 -06:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
|
|
|
}
|
2007-07-27 07:43:23 -06:00
|
|
|
|
|
|
|
/* CTS duration */
|
2012-04-11 00:47:56 -06:00
|
|
|
dur = ieee80211_frame_duration(sband->band, 10, rate->bitrate,
|
2007-07-27 07:43:23 -06:00
|
|
|
erp, short_preamble);
|
|
|
|
/* Data frame duration */
|
2012-04-11 00:47:56 -06:00
|
|
|
dur += ieee80211_frame_duration(sband->band, frame_len, rate->bitrate,
|
2007-07-27 07:43:23 -06:00
|
|
|
erp, short_preamble);
|
|
|
|
/* ACK duration */
|
2012-04-11 00:47:56 -06:00
|
|
|
dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate,
|
2007-07-27 07:43:23 -06:00
|
|
|
erp, short_preamble);
|
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_rts_duration);
|
|
|
|
|
2007-12-18 17:31:26 -07:00
|
|
|
__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2007-07-27 07:43:23 -06:00
|
|
|
size_t frame_len,
|
2008-05-15 04:55:29 -06:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-12 14:52:47 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 06:32:58 -07:00
|
|
|
bool short_preamble;
|
2007-07-27 07:43:23 -06:00
|
|
|
int erp;
|
|
|
|
u16 dur;
|
2008-05-15 04:55:27 -06:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
2012-04-11 00:47:56 -06:00
|
|
|
sband = local->hw.wiphy->bands[frame_txctl->band];
|
2007-07-27 07:43:23 -06:00
|
|
|
|
2008-09-12 14:52:47 -06:00
|
|
|
short_preamble = false;
|
2007-07-27 07:43:24 -06:00
|
|
|
|
2008-05-15 04:55:29 -06:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-24 11:38:38 -07:00
|
|
|
erp = 0;
|
2008-09-12 14:52:47 -06:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 17:51:51 -06:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 14:52:47 -06:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
|
|
|
}
|
2007-07-27 07:43:23 -06:00
|
|
|
|
|
|
|
/* Data frame duration */
|
2012-04-11 00:47:56 -06:00
|
|
|
dur = ieee80211_frame_duration(sband->band, frame_len, rate->bitrate,
|
2007-07-27 07:43:23 -06:00
|
|
|
erp, short_preamble);
|
2008-05-15 04:55:29 -06:00
|
|
|
if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
|
2007-07-27 07:43:23 -06:00
|
|
|
/* ACK duration */
|
2012-04-11 00:47:56 -06:00
|
|
|
dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate,
|
2007-07-27 07:43:23 -06:00
|
|
|
erp, short_preamble);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_ctstoself_duration);
|
|
|
|
|
2012-04-03 08:28:50 -06:00
|
|
|
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
|
|
|
if (test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
|
|
|
|
local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
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-18 14:35:20 -07:00
|
|
|
static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2010-04-07 08:48:40 -06:00
|
|
|
trace_wake_queue(local, queue, reason);
|
|
|
|
|
2009-03-23 10:28:42 -06:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return;
|
2008-12-18 14:35:20 -07:00
|
|
|
|
2012-03-28 03:04:27 -06:00
|
|
|
if (!test_bit(reason, &local->queue_stop_reasons[queue]))
|
|
|
|
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-11 16:51:53 -07:00
|
|
|
__clear_bit(reason, &local->queue_stop_reasons[queue]);
|
|
|
|
|
|
|
|
if (local->queue_stop_reasons[queue] != 0)
|
|
|
|
/* someone still has this queue stopped */
|
|
|
|
return;
|
|
|
|
|
2010-03-22 14:42:43 -06:00
|
|
|
if (skb_queue_empty(&local->pending[queue])) {
|
|
|
|
rcu_read_lock();
|
2012-04-03 08:28:50 -06:00
|
|
|
ieee80211_propagate_queue_wake(local, queue);
|
2010-03-22 14:42:43 -06:00
|
|
|
rcu_read_unlock();
|
|
|
|
} else
|
2009-06-17 09:43:56 -06:00
|
|
|
tasklet_schedule(&local->tx_pending_tasklet);
|
2007-07-27 07:43:23 -06:00
|
|
|
}
|
2008-12-18 14: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-11 16:51:53 -07:00
|
|
|
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2008-12-18 14:35:20 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
__ieee80211_wake_queue(hw, queue, reason);
|
|
|
|
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,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
|
|
|
}
|
2007-07-27 07:43:23 -06:00
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queue);
|
|
|
|
|
2008-12-18 14:35:20 -07:00
|
|
|
static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2010-01-05 10:00:58 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-07-27 07:43:23 -06:00
|
|
|
|
2010-04-07 08:48:40 -06:00
|
|
|
trace_stop_queue(local, queue, reason);
|
|
|
|
|
2009-03-23 10:28:42 -06: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-11 16:51:53 -07:00
|
|
|
|
2012-03-28 03:04:27 -06:00
|
|
|
if (test_bit(reason, &local->queue_stop_reasons[queue]))
|
|
|
|
return;
|
|
|
|
|
2009-03-23 10:28:37 -06:00
|
|
|
__set_bit(reason, &local->queue_stop_reasons[queue]);
|
2010-01-05 10:00:58 -07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2012-04-03 08:28:50 -06:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
if (sdata->vif.hw_queue[ac] == queue ||
|
|
|
|
sdata->vif.cab_queue == queue)
|
|
|
|
netif_stop_subqueue(sdata->dev, ac);
|
|
|
|
}
|
|
|
|
}
|
2010-01-05 10:00:58 -07:00
|
|
|
rcu_read_unlock();
|
2007-07-27 07:43:23 -06:00
|
|
|
}
|
2008-12-18 14: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-11 16:51:53 -07:00
|
|
|
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2008-12-18 14:35:20 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
__ieee80211_stop_queue(hw, queue, reason);
|
|
|
|
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,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
|
|
|
}
|
2007-07-27 07:43:23 -06:00
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queue);
|
|
|
|
|
2009-06-07 13:58:37 -06: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 02:33:31 -06:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2012-04-03 08:28:50 -06:00
|
|
|
int queue = info->hw_queue;
|
2009-07-27 02:33:31 -06:00
|
|
|
|
|
|
|
if (WARN_ON(!info->control.vif)) {
|
2009-10-06 07:52:35 -06:00
|
|
|
kfree_skb(skb);
|
2009-07-27 02:33:31 -06:00
|
|
|
return;
|
|
|
|
}
|
2009-06-07 13:58:37 -06:00
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
__ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
|
2009-06-17 09:43:56 -06:00
|
|
|
__skb_queue_tail(&local->pending[queue], skb);
|
2009-06-07 13:58:37 -06:00
|
|
|
__ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2011-09-29 08:04:30 -06:00
|
|
|
void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local,
|
|
|
|
struct sk_buff_head *skbs,
|
|
|
|
void (*fn)(void *data), void *data)
|
2009-06-07 13:58:37 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned long flags;
|
2011-09-29 08:04:30 -06:00
|
|
|
int queue, i;
|
2009-06-07 13:58:37 -06:00
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
while ((skb = skb_dequeue(skbs))) {
|
2009-07-27 02:33:31 -06:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
|
|
|
|
if (WARN_ON(!info->control.vif)) {
|
2009-10-06 07:52:35 -06:00
|
|
|
kfree_skb(skb);
|
2009-07-27 02:33:31 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-04-03 08:28:50 -06:00
|
|
|
queue = info->hw_queue;
|
2012-03-28 03:04:28 -06:00
|
|
|
|
|
|
|
__ieee80211_stop_queue(hw, queue,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
|
|
|
|
|
2009-06-17 09:43:56 -06:00
|
|
|
__skb_queue_tail(&local->pending[queue], skb);
|
2009-06-07 13:58:37 -06:00
|
|
|
}
|
|
|
|
|
2010-11-16 12:50:28 -07:00
|
|
|
if (fn)
|
|
|
|
fn(data);
|
|
|
|
|
2009-06-17 09:43:56 -06:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2009-06-07 13:58:37 -06:00
|
|
|
__ieee80211_wake_queue(hw, i,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-12-18 14:35:20 -07:00
|
|
|
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
2008-12-18 14:35:20 -07:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 07:43:23 -06:00
|
|
|
int i;
|
|
|
|
|
2008-12-18 14:35:20 -07:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
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-11 16:51:53 -07:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2008-12-18 14:35:20 -07:00
|
|
|
__ieee80211_stop_queue(hw, i, reason);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queues_by_reason(hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
2007-07-27 07:43:23 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queues);
|
|
|
|
|
2008-07-24 12:02:04 -06:00
|
|
|
int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2009-06-17 09:43:56 -06: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-11 16:51:53 -07:00
|
|
|
|
2009-03-23 10:28:42 -06: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-11 16:51:53 -07:00
|
|
|
|
2009-06-17 09:43:56 -06:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
ret = !!local->queue_stop_reasons[queue];
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
return ret;
|
2008-07-24 12:02:04 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_queue_stopped);
|
|
|
|
|
2008-12-18 14:35:20 -07:00
|
|
|
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 07:43:23 -06:00
|
|
|
{
|
2008-12-18 14:35:20 -07:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 07:43:23 -06:00
|
|
|
int i;
|
|
|
|
|
2008-12-18 14:35:20 -07:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
2009-03-23 10:28:42 -06:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2008-12-18 14:35:20 -07:00
|
|
|
__ieee80211_wake_queue(hw, i, reason);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
2007-07-27 07:43:23 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queues);
|
2007-11-08 17:57:29 -07:00
|
|
|
|
2007-12-18 17:31:26 -07:00
|
|
|
void ieee80211_iterate_active_interfaces(
|
|
|
|
struct ieee80211_hw *hw,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
2007-11-08 17:57:29 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
2009-01-23 14:54:03 -07:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2008-05-10 05:40:49 -06:00
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
switch (sdata->vif.type) {
|
2008-09-10 16:01:58 -06:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2008-05-10 05:40:49 -06:00
|
|
|
continue;
|
2010-09-16 06:58:23 -06:00
|
|
|
default:
|
2008-05-10 05:40:49 -06:00
|
|
|
break;
|
|
|
|
}
|
2009-12-23 05:15:31 -07:00
|
|
|
if (ieee80211_sdata_running(sdata))
|
2009-11-25 09:46:19 -07:00
|
|
|
iterator(data, sdata->vif.addr,
|
2008-05-10 05:40:49 -06:00
|
|
|
&sdata->vif);
|
|
|
|
}
|
|
|
|
|
2009-01-23 14:54:03 -07:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2008-05-10 05:40:49 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
|
|
|
|
|
|
|
|
void ieee80211_iterate_active_interfaces_atomic(
|
|
|
|
struct ieee80211_hw *hw,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
2007-11-28 02:55:32 -07:00
|
|
|
rcu_read_lock();
|
2007-11-08 17:57:29 -07:00
|
|
|
|
2007-11-28 02:55:32 -07:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
2007-12-18 17:31:27 -07:00
|
|
|
switch (sdata->vif.type) {
|
2008-09-10 16:01:58 -06:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2007-11-08 17:57:29 -07:00
|
|
|
continue;
|
2010-09-16 06:58:23 -06:00
|
|
|
default:
|
2007-11-08 17:57:29 -07:00
|
|
|
break;
|
|
|
|
}
|
2009-12-23 05:15:31 -07:00
|
|
|
if (ieee80211_sdata_running(sdata))
|
2009-11-25 09:46:19 -07:00
|
|
|
iterator(data, sdata->vif.addr,
|
2007-12-18 17:31:26 -07:00
|
|
|
&sdata->vif);
|
2007-11-08 17:57:29 -07:00
|
|
|
}
|
2007-11-28 02:55:32 -07:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
2007-11-08 17:57:29 -07:00
|
|
|
}
|
2008-05-10 05:40:49 -06:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
|
2008-09-08 08:40:36 -06:00
|
|
|
|
2009-07-29 18:08:07 -06: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 06:29:39 -07:00
|
|
|
if (WARN(local->suspended && !local->resuming,
|
|
|
|
"queueing ieee80211 work while going to suspend\n"))
|
|
|
|
return false;
|
2009-07-29 18:08:07 -06: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);
|
|
|
|
|
2011-11-18 08:54:50 -07:00
|
|
|
u32 ieee802_11_parse_elems_crc(u8 *start, size_t len,
|
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
u64 filter, u32 crc)
|
|
|
|
{
|
|
|
|
size_t left = len;
|
|
|
|
u8 *pos = start;
|
|
|
|
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-23 18:59:53 -07:00
|
|
|
DECLARE_BITMAP(seen_elems, 256);
|
2011-11-18 08: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-23 18:59:53 -07:00
|
|
|
bitmap_zero(seen_elems, 256);
|
2011-11-18 08: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-23 18:59:53 -07:00
|
|
|
bool elem_parse_failed;
|
2011-11-18 08: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-23 18:59:53 -07:00
|
|
|
if (elen > left) {
|
|
|
|
elems->parse_error = true;
|
2011-11-18 08: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-23 18:59:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (id != WLAN_EID_VENDOR_SPECIFIC &&
|
|
|
|
id != WLAN_EID_QUIET &&
|
|
|
|
test_bit(id, seen_elems)) {
|
|
|
|
elems->parse_error = true;
|
|
|
|
left -= elen;
|
|
|
|
pos += elen;
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-18 08: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-23 18:59:53 -07:00
|
|
|
elem_parse_failed = false;
|
|
|
|
|
2011-11-18 08: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_FH_PARAMS:
|
|
|
|
elems->fh_params = pos;
|
|
|
|
elems->fh_params_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_DS_PARAMS:
|
|
|
|
elems->ds_params = pos;
|
|
|
|
elems->ds_params_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CF_PARAMS:
|
|
|
|
elems->cf_params = pos;
|
|
|
|
elems->cf_params_len = elen;
|
|
|
|
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-23 18:59:53 -07:00
|
|
|
} else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 08:54:50 -07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_IBSS_PARAMS:
|
|
|
|
elems->ibss_params = pos;
|
|
|
|
elems->ibss_params_len = elen;
|
|
|
|
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);
|
|
|
|
|
|
|
|
if (pos[3] == 1) {
|
|
|
|
/* OUI Type 1 - WPA IE */
|
|
|
|
elems->wpa = pos;
|
|
|
|
elems->wpa_len = elen;
|
|
|
|
} else if (elen >= 5 && pos[3] == 2) {
|
|
|
|
/* 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:
|
|
|
|
elems->erp_info = pos;
|
|
|
|
elems->erp_info_len = elen;
|
|
|
|
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-23 18:59:53 -07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 08:54:50 -07:00
|
|
|
break;
|
2012-03-15 12:45:16 -06: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-23 18:59:53 -07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 08:54:50 -07:00
|
|
|
break;
|
|
|
|
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-23 18:59:53 -07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 08:54:50 -07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_PEER_MGMT:
|
|
|
|
elems->peering = pos;
|
|
|
|
elems->peering_len = elen;
|
|
|
|
break;
|
|
|
|
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-23 18:59:53 -07:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 08:54:50 -07:00
|
|
|
break;
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH:
|
|
|
|
elems->ch_switch_elem = pos;
|
|
|
|
elems->ch_switch_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_QUIET:
|
|
|
|
if (!elems->quiet_elem) {
|
|
|
|
elems->quiet_elem = pos;
|
|
|
|
elems->quiet_elem_len = elen;
|
|
|
|
}
|
|
|
|
elems->num_of_quiet_elem++;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_COUNTRY:
|
|
|
|
elems->country_elem = pos;
|
|
|
|
elems->country_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PWR_CONSTRAINT:
|
|
|
|
elems->pwr_constr_elem = pos;
|
|
|
|
elems->pwr_constr_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_TIMEOUT_INTERVAL:
|
|
|
|
elems->timeout_int = pos;
|
|
|
|
elems->timeout_int_len = elen;
|
|
|
|
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-23 18:59:53 -07:00
|
|
|
if (elem_parse_failed)
|
|
|
|
elems->parse_error = true;
|
|
|
|
else
|
|
|
|
set_bit(id, seen_elems);
|
|
|
|
|
2011-11-18 08: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-23 18:59:53 -07:00
|
|
|
if (left != 0)
|
|
|
|
elems->parse_error = true;
|
|
|
|
|
2011-11-18 08:54:50 -07:00
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
2008-09-08 08:40:36 -06:00
|
|
|
void ieee802_11_parse_elems(u8 *start, size_t len,
|
|
|
|
struct ieee802_11_elems *elems)
|
mac80211: implement beacon filtering in software
Regardless of whether the hardware implements beacon filtering,
there's no need to process all beacons in software all the time
throughout the stack (mac80211 does a lot, then cfg80211, then
in the future possibly userspace).
This patch implements the "best possible" beacon filtering in
mac80211. "Best possible" means that it can look for changes in
all requested information elements, and distinguish vendor IEs
by their OUI.
In the future, we will add nl80211 API for userspace to request
information elements and vendor IE OUIs to watch -- drivers can
then implement the best they can do while software implements
it fully.
It is unclear whether or not this actually saves CPU time, but
the data is all in the cache already so it should be fairly
cheap. The additional _testing_, however, has great benefit;
Without this, and on hardware that doesn't implement beacon
filtering, wrong assumptions about, for example, scan result
updates could quickly creep into code.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-04-16 05:17:26 -06:00
|
|
|
{
|
|
|
|
ieee802_11_parse_elems_crc(start, len, elems, 0, 0);
|
|
|
|
}
|
|
|
|
|
2012-03-02 07:56:59 -07:00
|
|
|
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool bss_notify)
|
2008-09-09 04:56:01 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_tx_queue_params qparam;
|
2012-03-28 03:04:25 -06:00
|
|
|
int ac;
|
2009-05-07 08:16:24 -06:00
|
|
|
bool use_11b;
|
|
|
|
int aCWmin, aCWmax;
|
2008-09-09 04:56:01 -06:00
|
|
|
|
|
|
|
if (!local->ops->conf_tx)
|
|
|
|
return;
|
|
|
|
|
2012-03-28 03:04:25 -06:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
return;
|
|
|
|
|
2008-09-09 04:56:01 -06:00
|
|
|
memset(&qparam, 0, sizeof(qparam));
|
|
|
|
|
2009-05-07 08:16:24 -06:00
|
|
|
use_11b = (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) &&
|
|
|
|
!(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
|
2008-09-09 04:56:01 -06:00
|
|
|
|
2012-03-28 03:04:25 -06:00
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
2009-05-07 08:16:24 -06:00
|
|
|
/* Set defaults according to 802.11-2007 Table 7-37 */
|
|
|
|
aCWmax = 1023;
|
|
|
|
if (use_11b)
|
|
|
|
aCWmin = 31;
|
|
|
|
else
|
|
|
|
aCWmin = 15;
|
|
|
|
|
2012-03-28 03:04:25 -06:00
|
|
|
switch (ac) {
|
2012-03-27 06:18:40 -06:00
|
|
|
case IEEE80211_AC_BK:
|
2009-05-27 01:41:06 -06:00
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
2009-05-07 08:16:24 -06:00
|
|
|
qparam.txop = 0;
|
|
|
|
qparam.aifs = 7;
|
|
|
|
break;
|
|
|
|
default: /* never happens but let's not leave undefined */
|
2012-03-27 06:18:40 -06:00
|
|
|
case IEEE80211_AC_BE:
|
2009-05-27 01:41:06 -06:00
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
2009-05-07 08:16:24 -06:00
|
|
|
qparam.txop = 0;
|
|
|
|
qparam.aifs = 3;
|
|
|
|
break;
|
2012-03-27 06:18:40 -06:00
|
|
|
case IEEE80211_AC_VI:
|
2009-05-07 08:16:24 -06:00
|
|
|
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;
|
2012-03-27 06:18:40 -06:00
|
|
|
case IEEE80211_AC_VO:
|
2009-05-07 08:16:24 -06:00
|
|
|
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;
|
|
|
|
}
|
2008-09-09 04:56:01 -06:00
|
|
|
|
2010-01-12 01:42:31 -07:00
|
|
|
qparam.uapsd = false;
|
|
|
|
|
2012-03-28 03:04:25 -06:00
|
|
|
sdata->tx_conf[ac] = qparam;
|
|
|
|
drv_conf_tx(local, sdata, ac, &qparam);
|
2009-05-07 08:16:24 -06:00
|
|
|
}
|
2010-03-29 04:18:34 -06:00
|
|
|
|
|
|
|
/* after reinitialize QoS TX queues setting to default,
|
|
|
|
* disable QoS at all */
|
2010-07-22 23:17:11 -06:00
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_MONITOR) {
|
|
|
|
sdata->vif.bss_conf.qos =
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_STATION;
|
2012-03-02 07:56:59 -07:00
|
|
|
if (bss_notify)
|
|
|
|
ieee80211_bss_info_change_notify(sdata,
|
|
|
|
BSS_CHANGED_QOS);
|
2010-07-22 23:17:11 -06:00
|
|
|
}
|
2008-09-09 04:56:01 -06:00
|
|
|
}
|
2008-09-09 07:07:09 -06:00
|
|
|
|
2009-02-15 04:44:28 -07:00
|
|
|
void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const size_t supp_rates_len,
|
|
|
|
const u8 *supp_rates)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int i, have_higher_than_11mbit = 0;
|
|
|
|
|
|
|
|
/* cf. IEEE 802.11 9.2.12 */
|
|
|
|
for (i = 0; i < supp_rates_len; i++)
|
|
|
|
if ((supp_rates[i] & 0x7f) * 5 > 110)
|
|
|
|
have_higher_than_11mbit = 1;
|
|
|
|
|
|
|
|
if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
|
|
|
|
have_higher_than_11mbit)
|
|
|
|
sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
|
|
|
|
else
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
|
|
|
|
|
2012-03-02 07:56:59 -07:00
|
|
|
ieee80211_set_wmm_default(sdata, true);
|
2009-02-15 04:44:28 -07:00
|
|
|
}
|
|
|
|
|
2009-01-21 07:13:48 -07:00
|
|
|
u32 ieee80211_mandatory_rates(struct ieee80211_local *local,
|
2008-09-10 16:01:57 -06:00
|
|
|
enum ieee80211_band band)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_rate *bitrates;
|
2009-01-21 07:13:48 -07:00
|
|
|
u32 mandatory_rates;
|
2008-09-10 16:01:57 -06:00
|
|
|
enum ieee80211_rate_flags mandatory_flag;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
2012-04-11 00:47:56 -06:00
|
|
|
if (WARN_ON(!sband))
|
|
|
|
return 1;
|
2008-09-10 16:01:57 -06:00
|
|
|
|
|
|
|
if (band == IEEE80211_BAND_2GHZ)
|
|
|
|
mandatory_flag = IEEE80211_RATE_MANDATORY_B;
|
|
|
|
else
|
|
|
|
mandatory_flag = IEEE80211_RATE_MANDATORY_A;
|
|
|
|
|
|
|
|
bitrates = sband->bitrates;
|
|
|
|
mandatory_rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++)
|
|
|
|
if (bitrates[i].flags & mandatory_flag)
|
|
|
|
mandatory_rates |= BIT(i);
|
|
|
|
return mandatory_rates;
|
|
|
|
}
|
2009-02-15 04:44:28 -07:00
|
|
|
|
|
|
|
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u16 transaction, u16 auth_alg,
|
2012-01-09 11:43:06 -07:00
|
|
|
u8 *extra, size_t extra_len, const u8 *da,
|
|
|
|
const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx)
|
2009-02-15 04: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 06:22:54 -06:00
|
|
|
int err;
|
2009-02-15 04:44:28 -07:00
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom +
|
2009-03-20 13:21:16 -06:00
|
|
|
sizeof(*mgmt) + 6 + extra_len);
|
2011-08-29 15:17:31 -06:00
|
|
|
if (!skb)
|
2009-02-15 04:44:28 -07:00
|
|
|
return;
|
2011-08-29 15:17:31 -06:00
|
|
|
|
2009-02-15 04: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-09 11:43:06 -07:00
|
|
|
memcpy(mgmt->da, da, ETH_ALEN);
|
2009-11-25 09:46:19 -07:00
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
2009-02-15 04: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);
|
|
|
|
mgmt->u.auth.status_code = cpu_to_le16(0);
|
|
|
|
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 06:22:54 -06: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);
|
|
|
|
}
|
|
|
|
|
2009-11-18 10:42:05 -07:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-15 04:44:28 -07:00
|
|
|
}
|
|
|
|
|
2009-04-01 03:58:36 -06:00
|
|
|
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
|
2009-10-27 13:59:55 -06:00
|
|
|
const u8 *ie, size_t ie_len,
|
2010-08-28 10:37:51 -06:00
|
|
|
enum ieee80211_band band, u32 rate_mask,
|
|
|
|
u8 channel)
|
2009-04-01 03:58:36 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
2009-12-23 05:15:38 -07:00
|
|
|
u8 *pos;
|
|
|
|
size_t offset = 0, noffset;
|
|
|
|
int supp_rates_len, i;
|
2010-08-28 10:36:10 -06:00
|
|
|
u8 rates[32];
|
|
|
|
int num_rates;
|
|
|
|
int ext_rates_len;
|
2009-04-01 03:58:36 -06:00
|
|
|
|
2009-10-27 13:59:55 -06:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2009-04-01 03:58:36 -06:00
|
|
|
|
|
|
|
pos = buffer;
|
|
|
|
|
2010-08-28 10:36:10 -06:00
|
|
|
num_rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((BIT(i) & rate_mask) == 0)
|
|
|
|
continue; /* skip rate */
|
|
|
|
rates[num_rates++] = (u8) (sband->bitrates[i].bitrate / 5);
|
|
|
|
}
|
|
|
|
|
|
|
|
supp_rates_len = min_t(int, num_rates, 8);
|
2009-12-23 05:15:38 -07:00
|
|
|
|
2009-04-01 03:58:36 -06:00
|
|
|
*pos++ = WLAN_EID_SUPP_RATES;
|
2009-12-23 05:15:38 -07:00
|
|
|
*pos++ = supp_rates_len;
|
2010-08-28 10:36:10 -06:00
|
|
|
memcpy(pos, rates, supp_rates_len);
|
|
|
|
pos += supp_rates_len;
|
2009-12-23 05: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),
|
|
|
|
offset);
|
|
|
|
memcpy(pos, ie + offset, noffset - offset);
|
|
|
|
pos += noffset - offset;
|
|
|
|
offset = noffset;
|
|
|
|
}
|
|
|
|
|
2010-08-28 10:36:10 -06:00
|
|
|
ext_rates_len = num_rates - supp_rates_len;
|
|
|
|
if (ext_rates_len > 0) {
|
2009-12-23 05:15:38 -07:00
|
|
|
*pos++ = WLAN_EID_EXT_SUPP_RATES;
|
2010-08-28 10:36:10 -06:00
|
|
|
*pos++ = ext_rates_len;
|
|
|
|
memcpy(pos, rates + supp_rates_len, ext_rates_len);
|
|
|
|
pos += ext_rates_len;
|
2009-12-23 05:15:38 -07:00
|
|
|
}
|
|
|
|
|
2010-08-28 10:37:51 -06:00
|
|
|
if (channel && sband->band == IEEE80211_BAND_2GHZ) {
|
|
|
|
*pos++ = WLAN_EID_DS_PARAMS;
|
|
|
|
*pos++ = 1;
|
|
|
|
*pos++ = channel;
|
|
|
|
}
|
|
|
|
|
2009-12-23 05: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),
|
|
|
|
offset);
|
|
|
|
memcpy(pos, ie + offset, noffset - offset);
|
|
|
|
pos += noffset - offset;
|
|
|
|
offset = noffset;
|
2009-04-01 03:58:36 -06:00
|
|
|
}
|
|
|
|
|
2011-10-26 15:47:26 -06:00
|
|
|
if (sband->ht_cap.ht_supported)
|
2011-11-18 12:32:00 -07:00
|
|
|
pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
|
|
|
|
sband->ht_cap.cap);
|
2009-03-31 04:12:07 -06:00
|
|
|
|
2009-04-01 03:58:36 -06:00
|
|
|
/*
|
|
|
|
* If adding more here, adjust code in main.c
|
|
|
|
* that calculates local->scan_ies_len.
|
|
|
|
*/
|
|
|
|
|
2009-12-23 05:15:38 -07:00
|
|
|
/* add any remaining custom IEs */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
noffset = ie_len;
|
|
|
|
memcpy(pos, ie + offset, noffset - offset);
|
|
|
|
pos += noffset - offset;
|
2009-04-01 03:58:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return pos - buffer;
|
|
|
|
}
|
|
|
|
|
2010-11-10 23:50:18 -07:00
|
|
|
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
|
2011-07-18 10:08:36 -06:00
|
|
|
u8 *dst, u32 ratemask,
|
2010-11-10 23:50:18 -07:00
|
|
|
const u8 *ssid, size_t ssid_len,
|
2011-06-23 11:00:11 -06:00
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
bool directed)
|
2009-02-15 04:44:28 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
2010-01-05 11:16:44 -07:00
|
|
|
size_t buf_len;
|
|
|
|
u8 *buf;
|
2010-08-28 10:37:51 -06:00
|
|
|
u8 chan;
|
2010-01-05 11:16:44 -07:00
|
|
|
|
|
|
|
/* FIXME: come up with a proper value */
|
|
|
|
buf = kmalloc(200 + ie_len, GFP_KERNEL);
|
2011-08-29 15:17:31 -06:00
|
|
|
if (!buf)
|
2010-11-10 23:50:18 -07:00
|
|
|
return NULL;
|
2009-02-15 04:44:28 -07:00
|
|
|
|
2011-06-23 11:00:11 -06: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.
|
|
|
|
*/
|
|
|
|
if (directed)
|
|
|
|
chan = 0;
|
|
|
|
else
|
|
|
|
chan = ieee80211_frequency_to_channel(
|
|
|
|
local->hw.conf.channel->center_freq);
|
2010-08-28 10:37:51 -06:00
|
|
|
|
2010-01-05 11:16:44 -07:00
|
|
|
buf_len = ieee80211_build_preq_ies(local, buf, ie, ie_len,
|
2010-08-28 10:36:10 -06:00
|
|
|
local->hw.conf.channel->band,
|
2011-07-18 10:08:36 -06:00
|
|
|
ratemask, chan);
|
2010-01-05 11:16:44 -07:00
|
|
|
|
|
|
|
skb = ieee80211_probereq_get(&local->hw, &sdata->vif,
|
|
|
|
ssid, ssid_len,
|
|
|
|
buf, buf_len);
|
2011-11-08 05:04:41 -07:00
|
|
|
if (!skb)
|
|
|
|
goto out;
|
2010-01-05 11:16:44 -07:00
|
|
|
|
2009-02-15 04:44:28 -07:00
|
|
|
if (dst) {
|
2010-01-05 11:16:44 -07:00
|
|
|
mgmt = (struct ieee80211_mgmt *) skb->data;
|
2009-02-15 04:44:28 -07:00
|
|
|
memcpy(mgmt->da, dst, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, dst, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
2009-11-18 10:42:05 -07:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
2011-11-08 05:04:41 -07:00
|
|
|
|
|
|
|
out:
|
2010-01-15 06:44:21 -07:00
|
|
|
kfree(buf);
|
2010-11-10 23: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-23 11:00:11 -06:00
|
|
|
const u8 *ie, size_t ie_len,
|
2011-09-25 03:23:31 -06:00
|
|
|
u32 ratemask, bool directed, bool no_cck)
|
2010-11-10 23:50:18 -07:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2011-07-18 10:08:36 -06:00
|
|
|
skb = ieee80211_build_probe_req(sdata, dst, ratemask, ssid, ssid_len,
|
|
|
|
ie, ie_len, directed);
|
2011-09-25 03:23:31 -06:00
|
|
|
if (skb) {
|
|
|
|
if (no_cck)
|
|
|
|
IEEE80211_SKB_CB(skb)->flags |=
|
|
|
|
IEEE80211_TX_CTL_NO_CCK_RATE;
|
2010-11-10 23:50:18 -07:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2011-09-25 03:23:31 -06:00
|
|
|
}
|
2009-02-15 04:44:28 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
|
|
|
|
struct ieee802_11_elems *elems,
|
2012-04-02 22:21:21 -06:00
|
|
|
enum ieee80211_band band, u32 *basic_rates)
|
2009-02-15 04:44:28 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_rate *bitrates;
|
|
|
|
size_t num_rates;
|
|
|
|
u32 supp_rates;
|
|
|
|
int i, j;
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
|
|
|
|
2012-04-11 00:47:56 -06:00
|
|
|
if (WARN_ON(!sband))
|
|
|
|
return 1;
|
2009-02-15 04:44:28 -07:00
|
|
|
|
|
|
|
bitrates = sband->bitrates;
|
|
|
|
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-02 22:21:21 -06:00
|
|
|
bool is_basic;
|
2009-02-15 04: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-02 22:21:21 -06:00
|
|
|
is_basic = !!(rate & 0x80);
|
|
|
|
|
|
|
|
if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; j < num_rates; j++) {
|
|
|
|
if (bitrates[j].bitrate == own_rate) {
|
2009-02-15 04:44:28 -07:00
|
|
|
supp_rates |= BIT(j);
|
2012-04-02 22:21:21 -06:00
|
|
|
if (basic_rates && is_basic)
|
|
|
|
*basic_rates |= BIT(j);
|
|
|
|
}
|
|
|
|
}
|
2009-02-15 04:44:28 -07:00
|
|
|
}
|
|
|
|
return supp_rates;
|
|
|
|
}
|
2009-04-14 02:09:24 -06:00
|
|
|
|
2009-08-20 12:02:20 -06:00
|
|
|
void ieee80211_stop_device(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
ieee80211_led_radio(local, false);
|
2010-11-30 00:59:23 -07:00
|
|
|
ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
|
2009-08-20 12:02:20 -06:00
|
|
|
|
|
|
|
cancel_work_sync(&local->reconfig_filter);
|
|
|
|
|
|
|
|
flush_workqueue(local->workqueue);
|
2010-01-10 06:07:53 -07:00
|
|
|
drv_stop(local);
|
2009-08-20 12:02:20 -06:00
|
|
|
}
|
|
|
|
|
2009-04-14 02:09:24 -06:00
|
|
|
int ieee80211_reconfig(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct sta_info *sta;
|
2011-07-14 11:29:42 -06:00
|
|
|
int res, i;
|
2009-05-17 03:40:42 -06:00
|
|
|
|
2011-05-04 07:37:29 -06:00
|
|
|
#ifdef CONFIG_PM
|
2009-11-19 06:29:39 -07:00
|
|
|
if (local->suspended)
|
|
|
|
local->resuming = true;
|
2009-04-14 02:09:24 -06:00
|
|
|
|
2011-05-04 07:37:29 -06:00
|
|
|
if (local->wowlan) {
|
|
|
|
local->wowlan = false;
|
|
|
|
res = drv_resume(local);
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
#endif
|
2011-07-14 08:48:54 -06:00
|
|
|
/* everything else happens only if HW was up & running */
|
|
|
|
if (!local->open_count)
|
|
|
|
goto wake_up;
|
2009-04-14 02:09:24 -06:00
|
|
|
|
2011-07-14 08:48:54 -06: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) {
|
|
|
|
WARN(local->suspended, "Hardware became unavailable "
|
|
|
|
"upon resume. This could be a software issue "
|
|
|
|
"prior to suspend or a hardware issue.\n");
|
|
|
|
return res;
|
2009-04-14 02:09:24 -06:00
|
|
|
}
|
|
|
|
|
2011-12-30 04: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 08:48:54 -06:00
|
|
|
ieee80211_led_radio(local, true);
|
|
|
|
ieee80211_mod_tpt_led_trig(local,
|
|
|
|
IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
|
|
|
|
|
2009-04-14 02:09:24 -06:00
|
|
|
/* add interfaces */
|
2012-04-03 06:35:57 -06:00
|
|
|
sdata = rtnl_dereference(local->monitor_sdata);
|
|
|
|
if (sdata) {
|
|
|
|
res = drv_add_interface(local, sdata);
|
|
|
|
if (WARN_ON(res)) {
|
|
|
|
rcu_assign_pointer(local->monitor_sdata, NULL);
|
|
|
|
synchronize_net();
|
|
|
|
kfree(sdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-14 02:09:24 -06: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 05:15:45 -07:00
|
|
|
ieee80211_sdata_running(sdata))
|
2011-11-03 07:41:13 -06:00
|
|
|
res = drv_add_interface(local, sdata);
|
2009-04-14 02:09:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* add STAs back */
|
2010-02-03 05:59:58 -07:00
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
2012-01-20 05:55:21 -07:00
|
|
|
if (sta->uploaded) {
|
|
|
|
enum ieee80211_sta_state state;
|
|
|
|
|
|
|
|
for (state = IEEE80211_STA_NOTEXIST;
|
2012-05-30 03:39:33 -06:00
|
|
|
state < sta->sta_state; state++)
|
2012-01-20 05:55:21 -07:00
|
|
|
WARN_ON(drv_sta_state(local, sta->sdata, sta,
|
|
|
|
state, state + 1));
|
|
|
|
}
|
2009-04-14 02:09:24 -06:00
|
|
|
}
|
2010-02-03 05:59:58 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2009-04-14 02:09:24 -06:00
|
|
|
|
2011-07-14 11:29:42 -06:00
|
|
|
/* reconfigure tx conf */
|
2012-03-28 03:04:25 -06: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-25 11:06:54 -06:00
|
|
|
|
2012-03-28 03:04:25 -06:00
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++)
|
|
|
|
drv_conf_tx(local, sdata, i,
|
|
|
|
&sdata->tx_conf[i]);
|
|
|
|
}
|
2011-09-25 11:06:54 -06:00
|
|
|
}
|
2011-07-14 11:29:42 -06:00
|
|
|
|
2009-04-14 02:09:24 -06: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 01:44:02 -06:00
|
|
|
u32 changed;
|
|
|
|
|
2009-12-23 05:15:31 -07:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-04-14 02:09:24 -06:00
|
|
|
continue;
|
2010-05-05 01:44:02 -06: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 08:39:04 -06:00
|
|
|
BSS_CHANGED_CQM |
|
2011-11-01 07:16:55 -06:00
|
|
|
BSS_CHANGED_QOS |
|
|
|
|
BSS_CHANGED_IDLE;
|
2010-05-05 01:44:02 -06:00
|
|
|
|
2009-04-14 02:09:24 -06:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
2011-12-12 05:10:49 -07:00
|
|
|
changed |= BSS_CHANGED_ASSOC |
|
|
|
|
BSS_CHANGED_ARP_FILTER;
|
2011-02-08 09:43:19 -07:00
|
|
|
mutex_lock(&sdata->u.mgd.mtx);
|
2010-05-05 01:44:02 -06:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2011-02-08 09:43:19 -07:00
|
|
|
mutex_unlock(&sdata->u.mgd.mtx);
|
2010-05-05 01:44:02 -06:00
|
|
|
break;
|
2009-04-14 02:09:24 -06:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2010-05-05 01:44:02 -06:00
|
|
|
changed |= BSS_CHANGED_IBSS;
|
|
|
|
/* fall through */
|
2009-04-14 02:09:24 -06:00
|
|
|
case NL80211_IFTYPE_AP:
|
2011-11-22 10:33:18 -07:00
|
|
|
changed |= BSS_CHANGED_SSID;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
changed |= BSS_CHANGED_AP_PROBE_RESP;
|
|
|
|
|
2011-09-04 02:11:32 -06:00
|
|
|
/* fall through */
|
2009-04-14 02:09:24 -06:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2010-05-05 01:44:02 -06:00
|
|
|
changed |= BSS_CHANGED_BEACON |
|
|
|
|
BSS_CHANGED_BEACON_ENABLED;
|
2009-04-23 08:13:26 -06:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2009-04-14 02:09:24 -06:00
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_WDS:
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
/* ignore virtual */
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
2010-08-12 07:38:38 -06:00
|
|
|
case NUM_NL80211_IFTYPES:
|
2010-09-16 06:58:23 -06:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2009-04-14 02:09:24 -06:00
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-09 03:29:06 -07:00
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
|
2012-01-26 04: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;
|
|
|
|
|
|
|
|
ieee80211_send_nullfunc(local, sdata, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-29 03:00:22 -06:00
|
|
|
/* add back keys */
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list)
|
|
|
|
if (ieee80211_sdata_running(sdata))
|
|
|
|
ieee80211_enable_keys(sdata);
|
|
|
|
|
|
|
|
wake_up:
|
2010-06-10 02:21:29 -06: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-03 10:28:55 -07:00
|
|
|
if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
|
2010-06-10 02:21:29 -06:00
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
2010-10-05 11:37:40 -06:00
|
|
|
ieee80211_sta_tear_down_BA_sessions(sta, true);
|
2011-09-29 08:04:36 -06:00
|
|
|
clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
|
2010-02-03 10:28:55 -07:00
|
|
|
}
|
2010-06-10 02:21:29 -06:00
|
|
|
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
2010-02-03 10:28:55 -07:00
|
|
|
}
|
|
|
|
|
2009-04-14 02:09:24 -06:00
|
|
|
ieee80211_wake_queues_by_reason(hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_SUSPEND);
|
|
|
|
|
2009-05-17 03:40:42 -06:00
|
|
|
/*
|
|
|
|
* If this is for hw restart things are still running.
|
|
|
|
* We may want to change that later, however.
|
|
|
|
*/
|
2009-11-19 06:29:39 -07:00
|
|
|
if (!local->suspended)
|
2009-05-17 03:40:42 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
2009-11-19 06:29:39 -07:00
|
|
|
/* first set suspended false, then resuming */
|
2009-05-17 03:40:42 -06:00
|
|
|
local->suspended = false;
|
2009-11-19 06:29:39 -07:00
|
|
|
mb();
|
|
|
|
local->resuming = false;
|
2009-05-17 03:40:42 -06:00
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
switch(sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
ieee80211_sta_restart(sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
ieee80211_ibss_restart(sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
|
|
|
ieee80211_mesh_restart(sdata);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-01 05:52:48 -06:00
|
|
|
mod_timer(&local->sta_cleanup, jiffies + 1);
|
2009-05-17 03:40:42 -06:00
|
|
|
|
2010-02-03 05:59:58 -07:00
|
|
|
mutex_lock(&local->sta_mtx);
|
2009-05-17 03:40:42 -06:00
|
|
|
list_for_each_entry(sta, &local->sta_list, list)
|
|
|
|
mesh_plink_restart(sta);
|
2010-02-03 05:59:58 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2009-05-17 03:40:42 -06:00
|
|
|
#else
|
|
|
|
WARN_ON(1);
|
|
|
|
#endif
|
2009-04-14 02:09:24 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2009-07-29 18:08:07 -06:00
|
|
|
|
2011-07-12 04:30:59 -06: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);
|
|
|
|
|
2009-12-01 05:37:02 -07:00
|
|
|
static int check_mgd_smps(struct ieee80211_if_managed *ifmgd,
|
|
|
|
enum ieee80211_smps_mode *smps_mode)
|
|
|
|
{
|
|
|
|
if (ifmgd->associated) {
|
|
|
|
*smps_mode = ifmgd->ap_smps;
|
|
|
|
|
|
|
|
if (*smps_mode == IEEE80211_SMPS_AUTOMATIC) {
|
|
|
|
if (ifmgd->powersave)
|
|
|
|
*smps_mode = IEEE80211_SMPS_DYNAMIC;
|
|
|
|
else
|
|
|
|
*smps_mode = IEEE80211_SMPS_OFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* must hold iflist_mtx */
|
2010-10-05 02:41:47 -06:00
|
|
|
void ieee80211_recalc_smps(struct ieee80211_local *local)
|
2009-12-01 05:37:02 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
enum ieee80211_smps_mode smps_mode = IEEE80211_SMPS_OFF;
|
|
|
|
int count = 0;
|
|
|
|
|
2010-09-15 05:28:15 -06:00
|
|
|
lockdep_assert_held(&local->iflist_mtx);
|
2009-12-01 05:37:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This function could be improved to handle multiple
|
|
|
|
* interfaces better, but right now it makes any
|
|
|
|
* non-station interfaces force SM PS to be turned
|
|
|
|
* off. If there are multiple station interfaces it
|
|
|
|
* could also use the best possible mode, e.g. if
|
|
|
|
* one is in static and the other in dynamic then
|
|
|
|
* dynamic is ok.
|
|
|
|
*/
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2010-08-27 04:35:55 -06:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-12-01 05:37:02 -07:00
|
|
|
continue;
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
goto set;
|
2010-10-05 02:41:47 -06:00
|
|
|
|
|
|
|
count += check_mgd_smps(&sdata->u.mgd, &smps_mode);
|
2009-12-01 05:37:02 -07:00
|
|
|
|
|
|
|
if (count > 1) {
|
|
|
|
smps_mode = IEEE80211_SMPS_OFF;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (smps_mode == local->smps_mode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
set:
|
|
|
|
local->smps_mode = smps_mode;
|
|
|
|
/* changed flag is auto-detected for this */
|
|
|
|
ieee80211_hw_config(local, 0);
|
|
|
|
}
|
2009-12-23 05: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 09:46:22 -06: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 05:12:51 -06:00
|
|
|
|
2011-11-18 12:32:00 -07:00
|
|
|
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2011-10-26 15:47:26 -06: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-18 12:32:00 -07:00
|
|
|
*pos++ = ht_cap->ampdu_factor |
|
|
|
|
(ht_cap->ampdu_density <<
|
2011-10-26 15:47:26 -06:00
|
|
|
IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
|
|
|
|
|
|
|
|
/* MCS set */
|
2011-11-18 12:32:00 -07:00
|
|
|
memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
|
|
|
|
pos += sizeof(ht_cap->mcs);
|
2011-10-26 15:47:26 -06:00
|
|
|
|
|
|
|
/* extended capabilities */
|
|
|
|
pos += sizeof(__le16);
|
|
|
|
|
|
|
|
/* BF capabilities */
|
|
|
|
pos += sizeof(__le32);
|
|
|
|
|
|
|
|
/* antenna selection */
|
|
|
|
pos += sizeof(u8);
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2012-03-15 12:45:16 -06:00
|
|
|
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2011-10-26 15:47:26 -06:00
|
|
|
struct ieee80211_channel *channel,
|
2012-04-30 15:20:29 -06:00
|
|
|
enum nl80211_channel_type channel_type,
|
|
|
|
u16 prot_mode)
|
2011-10-26 15:47:26 -06:00
|
|
|
{
|
2012-03-15 12:45:16 -06:00
|
|
|
struct ieee80211_ht_operation *ht_oper;
|
2011-10-26 15:47:26 -06:00
|
|
|
/* Build HT Information */
|
2012-03-15 12:45:16 -06:00
|
|
|
*pos++ = WLAN_EID_HT_OPERATION;
|
|
|
|
*pos++ = sizeof(struct ieee80211_ht_operation);
|
|
|
|
ht_oper = (struct ieee80211_ht_operation *)pos;
|
|
|
|
ht_oper->primary_chan =
|
2011-10-26 15:47:26 -06:00
|
|
|
ieee80211_frequency_to_channel(channel->center_freq);
|
|
|
|
switch (channel_type) {
|
|
|
|
case NL80211_CHAN_HT40MINUS:
|
2012-03-15 12:45:16 -06:00
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
2011-10-26 15:47:26 -06:00
|
|
|
break;
|
|
|
|
case NL80211_CHAN_HT40PLUS:
|
2012-03-15 12:45:16 -06:00
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
2011-10-26 15:47:26 -06:00
|
|
|
break;
|
|
|
|
case NL80211_CHAN_HT20:
|
|
|
|
default:
|
2012-03-15 12:45:16 -06:00
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
|
2011-10-26 15:47:26 -06:00
|
|
|
break;
|
|
|
|
}
|
2012-04-18 20:24:14 -06:00
|
|
|
if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
|
|
|
|
channel_type != NL80211_CHAN_NO_HT &&
|
|
|
|
channel_type != NL80211_CHAN_HT20)
|
2012-03-15 12:45:16 -06:00
|
|
|
ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
|
2011-11-30 08:56:33 -07:00
|
|
|
|
2012-04-30 15:20:29 -06:00
|
|
|
ht_oper->operation_mode = cpu_to_le16(prot_mode);
|
2012-03-15 12:45:16 -06:00
|
|
|
ht_oper->stbc_param = 0x0000;
|
2011-10-26 15:47:26 -06:00
|
|
|
|
|
|
|
/* It seems that Basic MCS set and Supported MCS set
|
|
|
|
are identical for the first 10 bytes */
|
2012-03-15 12:45:16 -06:00
|
|
|
memset(&ht_oper->basic_set, 0, 16);
|
|
|
|
memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
|
2011-10-26 15:47:26 -06:00
|
|
|
|
2012-03-15 12:45:16 -06:00
|
|
|
return pos + sizeof(struct ieee80211_ht_operation);
|
2011-10-26 15:47:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
enum nl80211_channel_type
|
2012-03-15 12:45:16 -06:00
|
|
|
ieee80211_ht_oper_to_channel_type(struct ieee80211_ht_operation *ht_oper)
|
2011-10-26 15:47:26 -06:00
|
|
|
{
|
|
|
|
enum nl80211_channel_type channel_type;
|
|
|
|
|
2012-03-15 12:45:16 -06:00
|
|
|
if (!ht_oper)
|
2011-10-26 15:47:26 -06:00
|
|
|
return NL80211_CHAN_NO_HT;
|
|
|
|
|
2012-03-15 12:45:16 -06:00
|
|
|
switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
|
2011-10-26 15:47:26 -06: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
return channel_type;
|
|
|
|
}
|
|
|
|
|
2012-04-02 22:21:20 -06:00
|
|
|
int ieee80211_add_srates_ie(struct ieee80211_vif *vif,
|
|
|
|
struct sk_buff *skb, bool need_basic)
|
2011-09-28 05:12:51 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
int rate;
|
|
|
|
u8 i, rates, *pos;
|
2012-04-02 22:21:20 -06:00
|
|
|
u32 basic_rates = vif->bss_conf.basic_rates;
|
2011-09-28 05:12:51 -06:00
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
|
|
|
rates = sband->n_bitrates;
|
|
|
|
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-02 22:21:20 -06:00
|
|
|
u8 basic = 0;
|
|
|
|
if (need_basic && basic_rates & BIT(i))
|
|
|
|
basic = 0x80;
|
2011-09-28 05:12:51 -06:00
|
|
|
rate = sband->bitrates[i].bitrate;
|
2012-04-02 22:21:20 -06:00
|
|
|
*pos++ = basic | (u8) (rate / 5);
|
2011-09-28 05:12:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-02 22:21:20 -06:00
|
|
|
int ieee80211_add_ext_srates_ie(struct ieee80211_vif *vif,
|
|
|
|
struct sk_buff *skb, bool need_basic)
|
2011-09-28 05:12:51 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
int rate;
|
|
|
|
u8 i, exrates, *pos;
|
2012-04-02 22:21:20 -06:00
|
|
|
u32 basic_rates = vif->bss_conf.basic_rates;
|
2011-09-28 05:12:51 -06:00
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
|
|
|
exrates = sband->n_bitrates;
|
|
|
|
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-02 22:21:20 -06:00
|
|
|
u8 basic = 0;
|
|
|
|
if (need_basic && basic_rates & BIT(i))
|
|
|
|
basic = 0x80;
|
2011-09-28 05:12:51 -06:00
|
|
|
rate = sband->bitrates[i].bitrate;
|
2012-04-02 22:21:20 -06:00
|
|
|
*pos++ = basic | (u8) (rate / 5);
|
2011-09-28 05:12:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-04-13 13:02:57 -06: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 10:30:32 -06:00
|
|
|
if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
|
|
|
|
/* non-managed type inferfaces */
|
|
|
|
return 0;
|
|
|
|
}
|
2012-04-13 13:02:57 -06:00
|
|
|
return ifmgd->ave_beacon_signal;
|
|
|
|
}
|
2012-04-20 12:57:00 -06:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
|