2007-07-27 13:43:23 +00: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>
|
2014-09-03 12:24:57 +00:00
|
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
2017-04-26 10:14:59 +00:00
|
|
|
* Copyright (C) 2015-2017 Intel Deutschland GmbH
|
2019-02-06 11:17:12 +00:00
|
|
|
* Copyright (C) 2018-2019 Intel Corporation
|
2007-07-27 13:43:23 +00:00
|
|
|
*
|
|
|
|
* 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 15:47:34 +00:00
|
|
|
#include <linux/export.h>
|
2007-07-27 13:43:23 +00: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 15:54:50 +00:00
|
|
|
#include <linux/crc32.h>
|
2007-09-17 18:56:21 +00:00
|
|
|
#include <net/net_namespace.h>
|
2007-07-27 13:43:23 +00:00
|
|
|
#include <net/cfg80211.h>
|
2007-11-09 00:57:29 +00:00
|
|
|
#include <net/rtnetlink.h>
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 16:52:52 +00:00
|
|
|
#include "driver-ops.h"
|
2008-04-08 19:14:40 +00:00
|
|
|
#include "rate.h"
|
2008-02-23 14:17:11 +00:00
|
|
|
#include "mesh.h"
|
2007-07-27 13:43:23 +00:00
|
|
|
#include "wme.h"
|
2009-04-14 08:09:24 +00: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 12:22:54 +00:00
|
|
|
#include "wep.h"
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
/* privid for wiphys to determine whether they belong to us or not */
|
2014-01-20 22:55:44 +00:00
|
|
|
const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2009-01-22 23:05:53 +00: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 13:43:23 +00:00
|
|
|
|
2008-02-25 15:27:43 +00:00
|
|
|
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2011-11-16 14:28:55 +00:00
|
|
|
struct sk_buff *skb;
|
2009-03-23 16:28:35 +00:00
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
|
2011-11-16 14:28:55 +00:00
|
|
|
skb_queue_walk(&tx->skbs, skb) {
|
2009-03-23 16:28:35 +00:00
|
|
|
hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
2011-11-16 14:28:55 +00:00
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
int ieee80211_frame_duration(enum nl80211_band band, size_t len,
|
2013-07-08 14:55:51 +00:00
|
|
|
int rate, int erp, int short_preamble,
|
|
|
|
int shift)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
int dur;
|
|
|
|
|
|
|
|
/* calculate duration (in microseconds, rounded up to next higher
|
|
|
|
* integer if it includes a fractional microsecond) to send frame of
|
|
|
|
* len bytes (does not include FCS) at the given rate. Duration will
|
|
|
|
* also include SIFS.
|
|
|
|
*
|
|
|
|
* rate is in 100 kbps, so divident is multiplied by 10 in the
|
|
|
|
* DIV_ROUND_UP() operations.
|
2013-07-08 14:55:51 +00:00
|
|
|
*
|
|
|
|
* shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
|
|
|
|
* is assumed to be 0 otherwise.
|
2007-07-27 13:43:23 +00:00
|
|
|
*/
|
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
if (band == NL80211_BAND_5GHZ || erp) {
|
2007-07-27 13:43:23 +00:00
|
|
|
/*
|
|
|
|
* OFDM:
|
|
|
|
*
|
|
|
|
* N_DBPS = DATARATE x 4
|
|
|
|
* N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
|
|
|
|
* (16 = SIGNAL time, 6 = tail bits)
|
|
|
|
* TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
|
|
|
|
*
|
|
|
|
* T_SYM = 4 usec
|
2013-07-08 14:55:51 +00:00
|
|
|
* 802.11a - 18.5.2: aSIFSTime = 16 usec
|
2007-07-27 13:43:23 +00:00
|
|
|
* 802.11g - 19.8.4: aSIFSTime = 10 usec +
|
|
|
|
* signal ext = 6 usec
|
|
|
|
*/
|
|
|
|
dur = 16; /* SIFS + signal ext */
|
2013-07-08 14:55:51 +00:00
|
|
|
dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
|
|
|
|
dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
|
|
|
|
|
|
|
|
/* IEEE 802.11-2012 18.3.2.4: all values above are:
|
|
|
|
* * times 4 for 5 MHz
|
|
|
|
* * times 2 for 10 MHz
|
|
|
|
*/
|
|
|
|
dur *= 1 << shift;
|
2013-07-08 14:55:53 +00:00
|
|
|
|
|
|
|
/* rates should already consider the channel bandwidth,
|
|
|
|
* don't apply divisor again.
|
|
|
|
*/
|
|
|
|
dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
|
|
|
|
4 * rate); /* T_SYM x N_SYM */
|
2007-07-27 13:43:23 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* 802.11b or 802.11g with 802.11b compatibility:
|
|
|
|
* 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
|
|
|
|
* Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
|
|
|
|
*
|
|
|
|
* 802.11 (DS): 15.3.3, 802.11b: 18.3.4
|
|
|
|
* aSIFSTime = 10 usec
|
|
|
|
* aPreambleLength = 144 usec or 72 usec with short preamble
|
|
|
|
* aPLCPHeaderLength = 48 usec or 24 usec with short preamble
|
|
|
|
*/
|
|
|
|
dur = 10; /* aSIFSTime = 10 usec */
|
|
|
|
dur += short_preamble ? (72 + 24) : (144 + 48);
|
|
|
|
|
|
|
|
dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dur;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exported duration function for driver use */
|
2007-12-19 00:31:26 +00:00
|
|
|
__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band,
|
2008-01-24 18:38:38 +00:00
|
|
|
size_t frame_len,
|
|
|
|
struct ieee80211_rate *rate)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-09-12 20:52:47 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-07-27 13:43:23 +00:00
|
|
|
u16 dur;
|
2013-07-08 14:55:51 +00:00
|
|
|
int erp, shift = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
bool short_preamble = false;
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
erp = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 23:51:51 +00:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
2013-07-08 14:55:51 +00:00
|
|
|
shift = ieee80211_vif_get_shift(vif);
|
2008-09-12 20:52:47 +00:00
|
|
|
}
|
2008-01-24 18:38:38 +00:00
|
|
|
|
2012-04-11 06:47:56 +00:00
|
|
|
dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
|
2013-07-08 14:55:51 +00:00
|
|
|
short_preamble, shift);
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_generic_frame_duration);
|
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif, size_t frame_len,
|
2008-05-15 10:55:29 +00:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-12 20:52:47 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 13:32:58 +00:00
|
|
|
bool short_preamble;
|
2013-07-08 14:55:53 +00:00
|
|
|
int erp, shift = 0, bitrate;
|
2007-07-27 13:43:23 +00:00
|
|
|
u16 dur;
|
2008-05-15 10:55:27 +00:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
2012-04-11 06:47:56 +00:00
|
|
|
sband = local->hw.wiphy->bands[frame_txctl->band];
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2008-09-12 20:52:47 +00:00
|
|
|
short_preamble = false;
|
2007-07-27 13:43:24 +00:00
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-24 18:38:38 +00:00
|
|
|
|
|
|
|
erp = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 23:51:51 +00:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
2013-07-08 14:55:51 +00:00
|
|
|
shift = ieee80211_vif_get_shift(vif);
|
2008-09-12 20:52:47 +00:00
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
|
|
|
|
|
2007-07-27 13:43:23 +00:00
|
|
|
/* CTS duration */
|
2013-07-08 14:55:53 +00:00
|
|
|
dur = ieee80211_frame_duration(sband->band, 10, bitrate,
|
2013-07-08 14:55:51 +00:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 13:43:23 +00:00
|
|
|
/* Data frame duration */
|
2013-07-08 14:55:53 +00:00
|
|
|
dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
|
2013-07-08 14:55:51 +00:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 13:43:23 +00:00
|
|
|
/* ACK duration */
|
2013-07-08 14:55:53 +00:00
|
|
|
dur += ieee80211_frame_duration(sband->band, 10, bitrate,
|
2013-07-08 14:55:51 +00:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_rts_duration);
|
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2007-07-27 13:43:23 +00:00
|
|
|
size_t frame_len,
|
2008-05-15 10:55:29 +00:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-12 20:52:47 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 13:32:58 +00:00
|
|
|
bool short_preamble;
|
2013-07-08 14:55:53 +00:00
|
|
|
int erp, shift = 0, bitrate;
|
2007-07-27 13:43:23 +00:00
|
|
|
u16 dur;
|
2008-05-15 10:55:27 +00:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
2012-04-11 06:47:56 +00:00
|
|
|
sband = local->hw.wiphy->bands[frame_txctl->band];
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2008-09-12 20:52:47 +00:00
|
|
|
short_preamble = false;
|
2007-07-27 13:43:24 +00:00
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-24 18:38:38 +00:00
|
|
|
erp = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 23:51:51 +00:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
2013-07-08 14:55:51 +00:00
|
|
|
shift = ieee80211_vif_get_shift(vif);
|
2008-09-12 20:52:47 +00:00
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
|
|
|
|
|
2007-07-27 13:43:23 +00:00
|
|
|
/* Data frame duration */
|
2013-07-08 14:55:53 +00:00
|
|
|
dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
|
2013-07-08 14:55:51 +00:00
|
|
|
erp, short_preamble, shift);
|
2008-05-15 10:55:29 +00:00
|
|
|
if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
|
2007-07-27 13:43:23 +00:00
|
|
|
/* ACK duration */
|
2013-07-08 14:55:53 +00:00
|
|
|
dur += ieee80211_frame_duration(sband->band, 10, bitrate,
|
2013-07-08 14:55:51 +00:00
|
|
|
erp, short_preamble, shift);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_ctstoself_duration);
|
|
|
|
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_vif *vif = &sdata->vif;
|
|
|
|
struct fq *fq = &local->fq;
|
|
|
|
struct ps_data *ps = NULL;
|
|
|
|
struct txq_info *txqi;
|
|
|
|
struct sta_info *sta;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_bh(&fq->lock);
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
ps = &sdata->bss->ps;
|
|
|
|
|
|
|
|
sdata->vif.txqs_stopped[ac] = false;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sta, &local->sta_list, list) {
|
|
|
|
if (sdata != sta->sdata)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
|
|
|
|
struct ieee80211_txq *txq = sta->sta.txq[i];
|
|
|
|
|
2018-09-14 16:00:34 +00:00
|
|
|
if (!txq)
|
|
|
|
continue;
|
|
|
|
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
txqi = to_txq_info(txq);
|
|
|
|
|
|
|
|
if (ac != txq->ac)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX,
|
|
|
|
&txqi->flags))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_unlock_bh(&fq->lock);
|
|
|
|
drv_wake_tx_queue(local, txqi);
|
|
|
|
spin_lock_bh(&fq->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!vif->txq)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
txqi = to_txq_info(vif->txq);
|
|
|
|
|
|
|
|
if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX, &txqi->flags) ||
|
|
|
|
(ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
spin_unlock_bh(&fq->lock);
|
|
|
|
|
|
|
|
drv_wake_tx_queue(local, txqi);
|
|
|
|
return;
|
|
|
|
out:
|
|
|
|
spin_unlock_bh(&fq->lock);
|
|
|
|
}
|
|
|
|
|
2018-12-03 19:15:49 +00:00
|
|
|
static void
|
|
|
|
__releases(&local->queue_stop_reason_lock)
|
|
|
|
__acquires(&local->queue_stop_reason_lock)
|
|
|
|
_ieee80211_wake_txqs(struct ieee80211_local *local, unsigned long *flags)
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
int n_acs = IEEE80211_NUM_ACS;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
n_acs = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < local->hw.queues; i++) {
|
|
|
|
if (local->queue_stop_reasons[i])
|
|
|
|
continue;
|
|
|
|
|
2018-12-03 19:15:49 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, *flags);
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
|
|
|
for (ac = 0; ac < n_acs; ac++) {
|
|
|
|
int ac_queue = sdata->vif.hw_queue[ac];
|
|
|
|
|
|
|
|
if (ac_queue == i ||
|
|
|
|
sdata->vif.cab_queue == i)
|
|
|
|
__ieee80211_wake_txqs(sdata, ac);
|
|
|
|
}
|
|
|
|
}
|
2018-12-03 19:15:49 +00:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, *flags);
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2018-12-03 19:15:49 +00:00
|
|
|
void ieee80211_wake_txqs(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = (struct ieee80211_local *)data;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
_ieee80211_wake_txqs(local, &flags);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2012-04-03 14:28:50 +00:00
|
|
|
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-07-04 10:49:59 +00:00
|
|
|
int n_acs = IEEE80211_NUM_ACS;
|
|
|
|
|
2016-05-19 08:37:48 +00:00
|
|
|
if (local->ops->wake_tx_queue)
|
|
|
|
return;
|
|
|
|
|
2012-07-04 10:49:59 +00:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
n_acs = 1;
|
2012-04-03 14:28:50 +00:00
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
if (!sdata->dev)
|
|
|
|
continue;
|
|
|
|
|
2012-04-03 14:28:50 +00:00
|
|
|
if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
|
|
|
|
local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
|
|
|
|
continue;
|
|
|
|
|
2012-07-04 10:49:59 +00:00
|
|
|
for (ac = 0; ac < n_acs; ac++) {
|
2012-04-03 14:28:50 +00:00
|
|
|
int ac_queue = sdata->vif.hw_queue[ac];
|
|
|
|
|
|
|
|
if (ac_queue == queue ||
|
|
|
|
(sdata->vif.cab_queue == queue &&
|
|
|
|
local->queue_stop_reasons[ac_queue] == 0 &&
|
|
|
|
skb_queue_empty(&local->pending[ac_queue])))
|
|
|
|
netif_wake_subqueue(sdata->dev, ac);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
2018-12-03 19:15:49 +00:00
|
|
|
bool refcounted,
|
|
|
|
unsigned long *flags)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2010-04-07 14:48:40 +00:00
|
|
|
trace_wake_queue(local, queue, reason);
|
|
|
|
|
2009-03-23 16:28:42 +00:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return;
|
2008-12-18 21:35:20 +00:00
|
|
|
|
2012-03-28 09:04:27 +00:00
|
|
|
if (!test_bit(reason, &local->queue_stop_reasons[queue]))
|
|
|
|
return;
|
|
|
|
|
2015-11-24 14:29:53 +00:00
|
|
|
if (!refcounted) {
|
2014-06-13 13:30:05 +00:00
|
|
|
local->q_stop_reasons[queue][reason] = 0;
|
2015-11-24 14:29:53 +00:00
|
|
|
} else {
|
2014-06-13 13:30:05 +00:00
|
|
|
local->q_stop_reasons[queue][reason]--;
|
2015-11-24 14:29:53 +00:00
|
|
|
if (WARN_ON(local->q_stop_reasons[queue][reason] < 0))
|
|
|
|
local->q_stop_reasons[queue][reason] = 0;
|
|
|
|
}
|
2014-06-13 13:30:05 +00:00
|
|
|
|
|
|
|
if (local->q_stop_reasons[queue][reason] == 0)
|
|
|
|
__clear_bit(reason, &local->queue_stop_reasons[queue]);
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
|
|
|
|
if (local->queue_stop_reasons[queue] != 0)
|
|
|
|
/* someone still has this queue stopped */
|
|
|
|
return;
|
|
|
|
|
2010-03-22 20:42:43 +00:00
|
|
|
if (skb_queue_empty(&local->pending[queue])) {
|
|
|
|
rcu_read_lock();
|
2012-04-03 14:28:50 +00:00
|
|
|
ieee80211_propagate_queue_wake(local, queue);
|
2010-03-22 20:42:43 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
} else
|
2009-06-17 15:43:56 +00:00
|
|
|
tasklet_schedule(&local->tx_pending_tasklet);
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
|
2018-12-03 19:15:49 +00:00
|
|
|
/*
|
|
|
|
* Calling _ieee80211_wake_txqs here can be a problem because it may
|
|
|
|
* release queue_stop_reason_lock which has been taken by
|
|
|
|
* __ieee80211_wake_queue's caller. It is certainly not very nice to
|
|
|
|
* release someone's lock, but it is fine because all the callers of
|
|
|
|
* __ieee80211_wake_queue call it right before releasing the lock.
|
|
|
|
*/
|
|
|
|
if (local->ops->wake_tx_queue) {
|
|
|
|
if (reason == IEEE80211_QUEUE_STOP_REASON_DRIVER)
|
|
|
|
tasklet_schedule(&local->wake_txqs_tasklet);
|
|
|
|
else
|
|
|
|
_ieee80211_wake_txqs(local, flags);
|
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
2008-12-18 21:35:20 +00: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 23:51:53 +00:00
|
|
|
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2008-12-18 21:35:20 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2018-12-03 19:15:49 +00:00
|
|
|
__ieee80211_wake_queue(hw, queue, reason, refcounted, &flags);
|
2008-12-18 21:35:20 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queue_by_reason(hw, queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2008-12-18 21:35:20 +00:00
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queue);
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2010-01-05 17:00:58 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-07-04 10:49:59 +00:00
|
|
|
int n_acs = IEEE80211_NUM_ACS;
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2010-04-07 14:48:40 +00:00
|
|
|
trace_stop_queue(local, queue, reason);
|
|
|
|
|
2009-03-23 16:28:42 +00: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 23:51:53 +00:00
|
|
|
|
2014-06-13 13:30:05 +00:00
|
|
|
if (!refcounted)
|
|
|
|
local->q_stop_reasons[queue][reason] = 1;
|
|
|
|
else
|
|
|
|
local->q_stop_reasons[queue][reason]++;
|
2012-03-28 09:04:27 +00:00
|
|
|
|
2014-06-13 13:30:05 +00:00
|
|
|
if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue]))
|
|
|
|
return;
|
2010-01-05 17:00:58 +00:00
|
|
|
|
2012-07-04 10:49:59 +00:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
n_acs = 1;
|
|
|
|
|
2010-01-05 17:00:58 +00:00
|
|
|
rcu_read_lock();
|
2012-04-03 14:28:50 +00:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
int ac;
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
if (!sdata->dev)
|
|
|
|
continue;
|
|
|
|
|
2012-07-04 10:49:59 +00:00
|
|
|
for (ac = 0; ac < n_acs; ac++) {
|
2012-04-03 14:28:50 +00:00
|
|
|
if (sdata->vif.hw_queue[ac] == queue ||
|
mac80211: add stop/start logic for software TXQs
Sometimes, it is required to stop the transmissions momentarily and
resume it later; stopping the txqs becomes very critical in scenarios where
the packet transmission has to be ceased completely. For example, during
the hardware restart, during off channel operations,
when initiating CSA(upon detecting a radar on the DFS channel), etc.
The TX queue stop/start logic in mac80211 works well in stopping the TX
when drivers make use of netdev queues, i.e, when Qdiscs in network layer
take care of traffic scheduling. Since the devices implementing
wake_tx_queue can run without Qdiscs, packets will be handed to mac80211
directly without queueing them in the netdev queues.
Also, mac80211 does not invoke any of the
netif_stop_*/netif_wake_* APIs if wake_tx_queue is implemented.
Since the queues are not stopped in this case, transmissions can continue
and this will impact negatively on the operation of the wireless device.
For example,
During hardware restart, we stop the netdev queues so that packets are
not sent to the driver. Since ath10k implements wake_tx_queue,
TX queues will not be stopped and packets might reach the hardware while
it is restarting; this can make hardware unresponsive and the only
possible option for recovery is to reboot the entire system.
There is another problem to this, it is observed that the packets
were sent on the DFS channel for a prolonged duration after radar
detection impacting the channel closing time.
We can still invoke netif stop/wake APIs when wake_tx_queue is implemented
but this could lead to packet drops in network layer; adding stop/start
logic for software TXQs in mac80211 instead makes more sense; the change
proposed adds the same in mac80211.
Signed-off-by: Manikanta Pubbisetty <mpubbise@codeaurora.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-07-10 18:42:53 +00:00
|
|
|
sdata->vif.cab_queue == queue) {
|
|
|
|
if (!local->ops->wake_tx_queue) {
|
|
|
|
netif_stop_subqueue(sdata->dev, ac);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
spin_lock(&local->fq.lock);
|
|
|
|
sdata->vif.txqs_stopped[ac] = true;
|
|
|
|
spin_unlock(&local->fq.lock);
|
|
|
|
}
|
2012-04-03 14:28:50 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-05 17:00:58 +00:00
|
|
|
rcu_read_unlock();
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
2008-12-18 21:35:20 +00: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 23:51:53 +00:00
|
|
|
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2008-12-18 21:35:20 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2014-06-13 13:30:05 +00:00
|
|
|
__ieee80211_stop_queue(hw, queue, reason, refcounted);
|
2008-12-18 21:35:20 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queue_by_reason(hw, queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2008-12-18 21:35:20 +00:00
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queue);
|
|
|
|
|
2009-06-07 19:58:37 +00: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 08:33:31 +00:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2012-04-03 14:28:50 +00:00
|
|
|
int queue = info->hw_queue;
|
2009-07-27 08:33:31 +00:00
|
|
|
|
|
|
|
if (WARN_ON(!info->control.vif)) {
|
2012-10-10 20:40:23 +00:00
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
2009-07-27 08:33:31 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-06-07 19:58:37 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2014-06-13 13:30:05 +00:00
|
|
|
__ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
|
|
|
false);
|
2009-06-17 15:43:56 +00:00
|
|
|
__skb_queue_tail(&local->pending[queue], skb);
|
2014-06-13 13:30:05 +00:00
|
|
|
__ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
2018-12-03 19:15:49 +00:00
|
|
|
false, &flags);
|
2009-06-07 19:58:37 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:19:58 +00:00
|
|
|
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
|
|
|
|
struct sk_buff_head *skbs)
|
2009-06-07 19:58:37 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned long flags;
|
2011-09-29 14:04:30 +00:00
|
|
|
int queue, i;
|
2009-06-07 19:58:37 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
while ((skb = skb_dequeue(skbs))) {
|
2009-07-27 08:33:31 +00:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
|
|
|
|
if (WARN_ON(!info->control.vif)) {
|
2012-10-10 20:40:23 +00:00
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
2009-07-27 08:33:31 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-04-03 14:28:50 +00:00
|
|
|
queue = info->hw_queue;
|
2012-03-28 09:04:28 +00:00
|
|
|
|
|
|
|
__ieee80211_stop_queue(hw, queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
|
|
|
false);
|
2012-03-28 09:04:28 +00:00
|
|
|
|
2009-06-17 15:43:56 +00:00
|
|
|
__skb_queue_tail(&local->pending[queue], skb);
|
2009-06-07 19:58:37 +00:00
|
|
|
}
|
|
|
|
|
2009-06-17 15:43:56 +00:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2009-06-07 19:58:37 +00:00
|
|
|
__ieee80211_wake_queue(hw, i,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
|
2018-12-03 19:15:49 +00:00
|
|
|
false, &flags);
|
2009-06-07 19:58:37 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
|
2013-02-13 11:25:28 +00:00
|
|
|
unsigned long queues,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-12-18 21:35:20 +00:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 13:43:23 +00:00
|
|
|
int i;
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
2013-02-13 11:25:28 +00:00
|
|
|
for_each_set_bit(i, &queues, hw->queues)
|
2014-06-13 13:30:05 +00:00
|
|
|
__ieee80211_stop_queue(hw, i, reason, refcounted);
|
2008-12-18 21:35:20 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
2013-02-13 11:25:28 +00:00
|
|
|
ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queues);
|
|
|
|
|
2008-07-24 18:02:04 +00:00
|
|
|
int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2009-06-17 15:43:56 +00: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 23:51:53 +00:00
|
|
|
|
2009-03-23 16:28:42 +00: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 23:51:53 +00:00
|
|
|
|
2009-06-17 15:43:56 +00:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
2013-04-10 22:41:40 +00:00
|
|
|
ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
&local->queue_stop_reasons[queue]);
|
2009-06-17 15:43:56 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
return ret;
|
2008-07-24 18:02:04 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_queue_stopped);
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
|
2013-02-13 11:25:28 +00:00
|
|
|
unsigned long queues,
|
2014-06-13 13:30:05 +00:00
|
|
|
enum queue_stop_reason reason,
|
|
|
|
bool refcounted)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-12-18 21:35:20 +00:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 13:43:23 +00:00
|
|
|
int i;
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
2013-02-13 11:25:28 +00:00
|
|
|
for_each_set_bit(i, &queues, hw->queues)
|
2018-12-03 19:15:49 +00:00
|
|
|
__ieee80211_wake_queue(hw, i, reason, refcounted, &flags);
|
2008-12-18 21:35:20 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
2013-02-13 11:25:28 +00:00
|
|
|
ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER,
|
|
|
|
false);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queues);
|
2007-11-09 00:57:29 +00:00
|
|
|
|
2014-06-13 13:30:06 +00:00
|
|
|
static unsigned int
|
|
|
|
ieee80211_get_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
2013-02-13 11:11:00 +00:00
|
|
|
{
|
2014-06-13 13:30:06 +00:00
|
|
|
unsigned int queues;
|
2013-02-13 11:11:00 +00:00
|
|
|
|
2015-06-02 19:39:54 +00:00
|
|
|
if (sdata && ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) {
|
2013-02-13 11:11:00 +00:00
|
|
|
int ac;
|
|
|
|
|
|
|
|
queues = 0;
|
|
|
|
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
|
|
|
|
queues |= BIT(sdata->vif.hw_queue[ac]);
|
|
|
|
if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
|
|
|
|
queues |= BIT(sdata->vif.cab_queue);
|
|
|
|
} else {
|
|
|
|
/* all queues */
|
|
|
|
queues = BIT(local->hw.queues) - 1;
|
|
|
|
}
|
|
|
|
|
2014-06-13 13:30:06 +00:00
|
|
|
return queues;
|
|
|
|
}
|
|
|
|
|
2014-11-09 16:50:21 +00:00
|
|
|
void __ieee80211_flush_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
2015-01-07 13:42:39 +00:00
|
|
|
unsigned int queues, bool drop)
|
2014-06-13 13:30:06 +00:00
|
|
|
{
|
|
|
|
if (!local->ops->flush)
|
|
|
|
return;
|
|
|
|
|
2014-11-09 16:50:21 +00:00
|
|
|
/*
|
|
|
|
* If no queue was set, or if the HW doesn't support
|
|
|
|
* IEEE80211_HW_QUEUE_CONTROL - flush all queues
|
|
|
|
*/
|
2015-06-02 19:39:54 +00:00
|
|
|
if (!queues || !ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
|
2014-11-09 16:50:21 +00:00
|
|
|
queues = ieee80211_get_vif_queues(local, sdata);
|
2014-06-13 13:30:06 +00:00
|
|
|
|
2014-06-13 13:30:04 +00:00
|
|
|
ieee80211_stop_queues_by_reason(&local->hw, queues,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_FLUSH,
|
|
|
|
false);
|
2013-02-13 11:25:28 +00:00
|
|
|
|
2015-01-07 13:42:39 +00:00
|
|
|
drv_flush(local, sdata, queues, drop);
|
2013-02-13 11:25:28 +00:00
|
|
|
|
2014-06-13 13:30:04 +00:00
|
|
|
ieee80211_wake_queues_by_reason(&local->hw, queues,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_FLUSH,
|
|
|
|
false);
|
2013-02-13 11:11:00 +00:00
|
|
|
}
|
|
|
|
|
2014-11-09 16:50:21 +00:00
|
|
|
void ieee80211_flush_queues(struct ieee80211_local *local,
|
2015-01-07 13:42:39 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata, bool drop)
|
2014-11-09 16:50:21 +00:00
|
|
|
{
|
2015-01-07 13:42:39 +00:00
|
|
|
__ieee80211_flush_queues(local, sdata, 0, drop);
|
2014-11-09 16:50:21 +00:00
|
|
|
}
|
|
|
|
|
2014-06-13 13:30:06 +00:00
|
|
|
void ieee80211_stop_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum queue_stop_reason reason)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queues_by_reason(&local->hw,
|
|
|
|
ieee80211_get_vif_queues(local, sdata),
|
|
|
|
reason, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_vif_queues(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum queue_stop_reason reason)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queues_by_reason(&local->hw,
|
|
|
|
ieee80211_get_vif_queues(local, sdata),
|
|
|
|
reason, true);
|
|
|
|
}
|
|
|
|
|
2015-03-01 07:10:15 +00:00
|
|
|
static void __iterate_interfaces(struct ieee80211_local *local,
|
|
|
|
u32 iter_flags,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
2007-11-09 00:57:29 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2015-03-01 07:10:15 +00:00
|
|
|
bool active_only = iter_flags & IEEE80211_IFACE_ITER_ACTIVE;
|
2007-11-09 00:57:29 +00:00
|
|
|
|
2013-08-21 20:07:20 +00:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
2008-05-10 11:40:49 +00:00
|
|
|
switch (sdata->vif.type) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
2016-08-29 20:25:15 +00:00
|
|
|
if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
2013-05-28 11:01:53 +00:00
|
|
|
continue;
|
|
|
|
break;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2008-05-10 11:40:49 +00:00
|
|
|
continue;
|
2010-09-16 12:58:23 +00:00
|
|
|
default:
|
2008-05-10 11:40:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-11-06 19:23:30 +00:00
|
|
|
if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
|
2015-03-01 07:10:15 +00:00
|
|
|
active_only && !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
2012-11-06 19:23:30 +00:00
|
|
|
continue;
|
2015-03-01 07:10:15 +00:00
|
|
|
if (ieee80211_sdata_running(sdata) || !active_only)
|
2009-11-25 16:46:19 +00:00
|
|
|
iterator(data, sdata->vif.addr,
|
2008-05-10 11:40:49 +00:00
|
|
|
&sdata->vif);
|
|
|
|
}
|
|
|
|
|
2013-08-21 20:07:20 +00:00
|
|
|
sdata = rcu_dereference_check(local->monitor_sdata,
|
|
|
|
lockdep_is_held(&local->iflist_mtx) ||
|
|
|
|
lockdep_rtnl_is_held());
|
2012-11-06 19:23:30 +00:00
|
|
|
if (sdata &&
|
2015-03-01 07:10:15 +00:00
|
|
|
(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || !active_only ||
|
2012-11-06 19:23:30 +00:00
|
|
|
sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
2012-07-11 14:38:09 +00:00
|
|
|
iterator(data, sdata->vif.addr, &sdata->vif);
|
2013-08-21 20:07:20 +00:00
|
|
|
}
|
2012-07-11 14:38:09 +00:00
|
|
|
|
2015-03-01 07:10:15 +00:00
|
|
|
void ieee80211_iterate_interfaces(
|
2013-08-21 20:07:20 +00:00
|
|
|
struct ieee80211_hw *hw, u32 iter_flags,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
2015-03-01 07:10:15 +00:00
|
|
|
__iterate_interfaces(local, iter_flags, iterator, data);
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2008-05-10 11:40:49 +00:00
|
|
|
}
|
2015-03-01 07:10:15 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces);
|
2008-05-10 11:40:49 +00:00
|
|
|
|
|
|
|
void ieee80211_iterate_active_interfaces_atomic(
|
2012-11-06 19:23:30 +00:00
|
|
|
struct ieee80211_hw *hw, u32 iter_flags,
|
2008-05-10 11:40:49 +00:00
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2007-11-28 09:55:32 +00:00
|
|
|
rcu_read_lock();
|
2015-03-01 07:10:15 +00:00
|
|
|
__iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
|
|
|
|
iterator, data);
|
2013-08-21 20:07:20 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
|
2007-11-09 00:57:29 +00:00
|
|
|
|
2013-08-21 20:07:20 +00:00
|
|
|
void ieee80211_iterate_active_interfaces_rtnl(
|
|
|
|
struct ieee80211_hw *hw, u32 iter_flags,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2007-11-28 09:55:32 +00:00
|
|
|
|
2013-08-21 20:07:20 +00:00
|
|
|
ASSERT_RTNL();
|
2012-07-11 14:38:09 +00:00
|
|
|
|
2015-03-01 07:10:15 +00:00
|
|
|
__iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
|
|
|
|
iterator, data);
|
2007-11-09 00:57:29 +00:00
|
|
|
}
|
2013-08-21 20:07:20 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_rtnl);
|
2008-09-08 14:40:36 +00:00
|
|
|
|
2014-10-22 09:30:59 +00:00
|
|
|
static void __iterate_stations(struct ieee80211_local *local,
|
|
|
|
void (*iterator)(void *data,
|
|
|
|
struct ieee80211_sta *sta),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sta, &local->sta_list, list) {
|
|
|
|
if (!sta->uploaded)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
iterator(data, &sta->sta);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
|
|
|
|
void (*iterator)(void *data,
|
|
|
|
struct ieee80211_sta *sta),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
__iterate_stations(local, iterator, data);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);
|
|
|
|
|
2013-11-13 12:37:47 +00:00
|
|
|
struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
|
|
|
|
|
|
|
|
if (!ieee80211_sdata_running(sdata) ||
|
|
|
|
!(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
|
|
|
return NULL;
|
|
|
|
return &sdata->vif;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
|
|
|
|
|
2015-03-12 06:53:24 +00:00
|
|
|
struct wireless_dev *ieee80211_vif_to_wdev(struct ieee80211_vif *vif)
|
|
|
|
{
|
2015-06-10 17:18:55 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
|
|
|
if (!vif)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sdata = vif_to_sdata(vif);
|
2015-03-12 06:53:24 +00:00
|
|
|
|
|
|
|
if (!ieee80211_sdata_running(sdata) ||
|
|
|
|
!(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &sdata->wdev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev);
|
|
|
|
|
2009-07-30 00:08:07 +00:00
|
|
|
/*
|
|
|
|
* Nothing should have been stuffed into the workqueue during
|
2015-01-22 21:32:46 +00:00
|
|
|
* the suspend->resume cycle. Since we can't check each caller
|
|
|
|
* of this function if we are already quiescing / suspended,
|
|
|
|
* check here and don't WARN since this can actually happen when
|
|
|
|
* the rx path (for example) is racing against __ieee80211_suspend
|
|
|
|
* and suspending / quiescing was set after the rx path checked
|
|
|
|
* them.
|
2009-07-30 00:08:07 +00:00
|
|
|
*/
|
|
|
|
static bool ieee80211_can_queue_work(struct ieee80211_local *local)
|
|
|
|
{
|
2015-01-22 21:32:46 +00:00
|
|
|
if (local->quiescing || (local->suspended && !local->resuming)) {
|
|
|
|
pr_warn("queueing ieee80211 work while going to suspend\n");
|
2009-11-19 13:29:39 +00:00
|
|
|
return false;
|
2015-01-22 21:32:46 +00:00
|
|
|
}
|
2009-07-30 00:08:07 +00: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);
|
|
|
|
|
2019-01-16 16:22:56 +00:00
|
|
|
static u32
|
|
|
|
_ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
|
|
|
|
struct ieee802_11_elems *elems,
|
2019-03-15 15:39:04 +00:00
|
|
|
u64 filter, u32 crc,
|
|
|
|
const struct element *check_inherit)
|
2011-11-18 15:54:50 +00:00
|
|
|
{
|
2019-03-15 15:39:04 +00:00
|
|
|
const struct element *elem;
|
2011-11-18 15:54:50 +00:00
|
|
|
bool calc_crc = filter != 0;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
DECLARE_BITMAP(seen_elems, 256);
|
2013-03-26 13:54:16 +00:00
|
|
|
const u8 *ie;
|
2011-11-18 15:54:50 +00:00
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
bitmap_zero(seen_elems, 256);
|
2011-11-18 15:54:50 +00:00
|
|
|
|
2019-02-07 21:18:19 +00:00
|
|
|
for_each_element(elem, start, len) {
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
bool elem_parse_failed;
|
2019-02-07 21:18:19 +00:00
|
|
|
u8 id = elem->id;
|
|
|
|
u8 elen = elem->datalen;
|
|
|
|
const u8 *pos = elem->data;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
|
2019-03-15 15:39:04 +00:00
|
|
|
if (check_inherit &&
|
|
|
|
!cfg80211_is_element_inherited(elem,
|
|
|
|
check_inherit))
|
|
|
|
continue;
|
|
|
|
|
2012-10-24 12:19:53 +00:00
|
|
|
switch (id) {
|
|
|
|
case WLAN_EID_SSID:
|
|
|
|
case WLAN_EID_SUPP_RATES:
|
|
|
|
case WLAN_EID_FH_PARAMS:
|
|
|
|
case WLAN_EID_DS_PARAMS:
|
|
|
|
case WLAN_EID_CF_PARAMS:
|
|
|
|
case WLAN_EID_TIM:
|
|
|
|
case WLAN_EID_IBSS_PARAMS:
|
|
|
|
case WLAN_EID_CHALLENGE:
|
|
|
|
case WLAN_EID_RSN:
|
|
|
|
case WLAN_EID_ERP_INFO:
|
|
|
|
case WLAN_EID_EXT_SUPP_RATES:
|
|
|
|
case WLAN_EID_HT_CAPABILITY:
|
|
|
|
case WLAN_EID_HT_OPERATION:
|
|
|
|
case WLAN_EID_VHT_CAPABILITY:
|
|
|
|
case WLAN_EID_VHT_OPERATION:
|
|
|
|
case WLAN_EID_MESH_ID:
|
|
|
|
case WLAN_EID_MESH_CONFIG:
|
|
|
|
case WLAN_EID_PEER_MGMT:
|
|
|
|
case WLAN_EID_PREQ:
|
|
|
|
case WLAN_EID_PREP:
|
|
|
|
case WLAN_EID_PERR:
|
|
|
|
case WLAN_EID_RANN:
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH:
|
|
|
|
case WLAN_EID_EXT_CHANSWITCH_ANN:
|
|
|
|
case WLAN_EID_COUNTRY:
|
|
|
|
case WLAN_EID_PWR_CONSTRAINT:
|
|
|
|
case WLAN_EID_TIMEOUT_INTERVAL:
|
2013-03-25 17:29:27 +00:00
|
|
|
case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
|
2013-03-26 13:54:16 +00:00
|
|
|
case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
|
2013-10-15 02:08:27 +00:00
|
|
|
case WLAN_EID_CHAN_SWITCH_PARAM:
|
2014-11-09 16:50:15 +00:00
|
|
|
case WLAN_EID_EXT_CAPABILITY:
|
2014-11-09 16:50:18 +00:00
|
|
|
case WLAN_EID_CHAN_SWITCH_TIMING:
|
|
|
|
case WLAN_EID_LINK_ID:
|
2017-04-26 07:58:47 +00:00
|
|
|
case WLAN_EID_BSS_MAX_IDLE_PERIOD:
|
2013-03-26 13:54:16 +00:00
|
|
|
/*
|
|
|
|
* not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
|
|
|
|
* that if the content gets bigger it might be needed more than once
|
|
|
|
*/
|
2012-10-24 12:19:53 +00:00
|
|
|
if (test_bit(id, seen_elems)) {
|
|
|
|
elems->parse_error = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
}
|
2011-11-18 15:54:50 +00:00
|
|
|
|
|
|
|
if (calc_crc && id < 64 && (filter & (1ULL << id)))
|
|
|
|
crc = crc32_be(crc, pos - 2, elen + 2);
|
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
elem_parse_failed = false;
|
|
|
|
|
2011-11-18 15:54:50 +00:00
|
|
|
switch (id) {
|
2014-11-09 16:50:18 +00:00
|
|
|
case WLAN_EID_LINK_ID:
|
|
|
|
if (elen + 2 != sizeof(struct ieee80211_tdls_lnkie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->lnk_id = (void *)(pos - 2);
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CHAN_SWITCH_TIMING:
|
|
|
|
if (elen != sizeof(struct ieee80211_ch_switch_timing)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->ch_sw_timing = (void *)pos;
|
|
|
|
break;
|
2014-11-09 16:50:15 +00:00
|
|
|
case WLAN_EID_EXT_CAPABILITY:
|
|
|
|
elems->ext_capab = pos;
|
|
|
|
elems->ext_capab_len = elen;
|
|
|
|
break;
|
2011-11-18 15:54:50 +00:00
|
|
|
case WLAN_EID_SSID:
|
|
|
|
elems->ssid = pos;
|
|
|
|
elems->ssid_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_SUPP_RATES:
|
|
|
|
elems->supp_rates = pos;
|
|
|
|
elems->supp_rates_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_DS_PARAMS:
|
2013-03-27 13:30:12 +00:00
|
|
|
if (elen >= 1)
|
|
|
|
elems->ds_params = pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
|
|
|
case WLAN_EID_TIM:
|
|
|
|
if (elen >= sizeof(struct ieee80211_tim_ie)) {
|
|
|
|
elems->tim = (void *)pos;
|
|
|
|
elems->tim_len = elen;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
} else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
|
|
|
case WLAN_EID_CHALLENGE:
|
|
|
|
elems->challenge = pos;
|
|
|
|
elems->challenge_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_VENDOR_SPECIFIC:
|
|
|
|
if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
|
|
|
|
pos[2] == 0xf2) {
|
|
|
|
/* Microsoft OUI (00:50:F2) */
|
|
|
|
|
|
|
|
if (calc_crc)
|
|
|
|
crc = crc32_be(crc, pos - 2, elen + 2);
|
|
|
|
|
2013-02-12 15:27:04 +00:00
|
|
|
if (elen >= 5 && pos[3] == 2) {
|
2011-11-18 15:54:50 +00:00
|
|
|
/* OUI Type 2 - WMM IE */
|
|
|
|
if (pos[4] == 0) {
|
|
|
|
elems->wmm_info = pos;
|
|
|
|
elems->wmm_info_len = elen;
|
|
|
|
} else if (pos[4] == 1) {
|
|
|
|
elems->wmm_param = pos;
|
|
|
|
elems->wmm_param_len = elen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WLAN_EID_RSN:
|
|
|
|
elems->rsn = pos;
|
|
|
|
elems->rsn_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_ERP_INFO:
|
2013-03-27 13:31:53 +00:00
|
|
|
if (elen >= 1)
|
|
|
|
elems->erp_info = pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
|
|
|
case WLAN_EID_EXT_SUPP_RATES:
|
|
|
|
elems->ext_supp_rates = pos;
|
|
|
|
elems->ext_supp_rates_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_HT_CAPABILITY:
|
|
|
|
if (elen >= sizeof(struct ieee80211_ht_cap))
|
|
|
|
elems->ht_cap_elem = (void *)pos;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
2012-03-15 18:45:16 +00:00
|
|
|
case WLAN_EID_HT_OPERATION:
|
|
|
|
if (elen >= sizeof(struct ieee80211_ht_operation))
|
|
|
|
elems->ht_operation = (void *)pos;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
2012-10-10 11:33:04 +00:00
|
|
|
case WLAN_EID_VHT_CAPABILITY:
|
|
|
|
if (elen >= sizeof(struct ieee80211_vht_cap))
|
|
|
|
elems->vht_cap_elem = (void *)pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_VHT_OPERATION:
|
|
|
|
if (elen >= sizeof(struct ieee80211_vht_operation))
|
|
|
|
elems->vht_operation = (void *)pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
2013-02-07 21:24:55 +00:00
|
|
|
case WLAN_EID_OPMODE_NOTIF:
|
|
|
|
if (elen > 0)
|
|
|
|
elems->opmode_notif = pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
2011-11-18 15:54:50 +00:00
|
|
|
case WLAN_EID_MESH_ID:
|
|
|
|
elems->mesh_id = pos;
|
|
|
|
elems->mesh_id_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_MESH_CONFIG:
|
|
|
|
if (elen >= sizeof(struct ieee80211_meshconf_ie))
|
|
|
|
elems->mesh_config = (void *)pos;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
|
|
|
case WLAN_EID_PEER_MGMT:
|
|
|
|
elems->peering = pos;
|
|
|
|
elems->peering_len = elen;
|
|
|
|
break;
|
2013-01-30 17:14:08 +00:00
|
|
|
case WLAN_EID_MESH_AWAKE_WINDOW:
|
|
|
|
if (elen >= 2)
|
|
|
|
elems->awake_window = (void *)pos;
|
|
|
|
break;
|
2011-11-18 15:54:50 +00:00
|
|
|
case WLAN_EID_PREQ:
|
|
|
|
elems->preq = pos;
|
|
|
|
elems->preq_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PREP:
|
|
|
|
elems->prep = pos;
|
|
|
|
elems->prep_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PERR:
|
|
|
|
elems->perr = pos;
|
|
|
|
elems->perr_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_RANN:
|
|
|
|
if (elen >= sizeof(struct ieee80211_rann_ie))
|
|
|
|
elems->rann = (void *)pos;
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH:
|
2012-08-01 14:13:02 +00:00
|
|
|
if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->ch_switch_ie = (void *)pos;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
2013-03-26 13:13:58 +00:00
|
|
|
case WLAN_EID_EXT_CHANSWITCH_ANN:
|
|
|
|
if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->ext_chansw_ie = (void *)pos;
|
|
|
|
break;
|
2013-03-25 17:29:27 +00:00
|
|
|
case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
|
|
|
|
if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->sec_chan_offs = (void *)pos;
|
|
|
|
break;
|
2013-10-15 02:08:27 +00:00
|
|
|
case WLAN_EID_CHAN_SWITCH_PARAM:
|
|
|
|
if (elen !=
|
|
|
|
sizeof(*elems->mesh_chansw_params_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->mesh_chansw_params_ie = (void *)pos;
|
|
|
|
break;
|
2013-03-26 13:54:16 +00:00
|
|
|
case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
|
|
|
|
if (!action ||
|
|
|
|
elen != sizeof(*elems->wide_bw_chansw_ie)) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
elems->wide_bw_chansw_ie = (void *)pos;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
|
|
|
|
if (action) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* This is a bit tricky, but as we only care about
|
|
|
|
* the wide bandwidth channel switch element, so
|
|
|
|
* just parse it out manually.
|
|
|
|
*/
|
|
|
|
ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
|
|
|
|
pos, elen);
|
|
|
|
if (ie) {
|
|
|
|
if (ie[1] == sizeof(*elems->wide_bw_chansw_ie))
|
|
|
|
elems->wide_bw_chansw_ie =
|
|
|
|
(void *)(ie + 2);
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
|
|
|
}
|
|
|
|
break;
|
2011-11-18 15:54:50 +00:00
|
|
|
case WLAN_EID_COUNTRY:
|
|
|
|
elems->country_elem = pos;
|
|
|
|
elems->country_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PWR_CONSTRAINT:
|
2012-09-05 11:07:00 +00:00
|
|
|
if (elen != 1) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
2011-11-18 15:54:50 +00:00
|
|
|
elems->pwr_constr_elem = pos;
|
|
|
|
break;
|
mac80211: support DTPC IE (from Cisco Client eXtensions)
Linux already supports 802.11h, where the access point can tell the
client to reduce its transmission power. However, 802.11h is only
defined for 5 GHz, where the need for this is much smaller than on
2.4 GHz.
Cisco has their own solution, called DTPC (Dynamic Transmit Power
Control). Cisco APs on a controller sometimes but not always send
802.11h; they always send DTPC, even on 2.4 GHz. This patch adds support
for parsing and honoring the DTPC IE in addition to the 802.11h
element (they do not always contain the same limits, so both must
be honored); the format is not documented, but very simple.
Tested (on top of wireless.git and on 3.16.1) against a Cisco Aironet
1142 joined to a Cisco 2504 WLC, by setting various transmit power
levels for the given access points and observing the results.
The Wireshark 802.11 dissector agrees with the interpretation of the
element, except for negative numbers, which seem to never happen
anyway.
Signed-off-by: Steinar H. Gunderson <sgunderson@bigfoot.com>
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
2014-09-03 13:48:37 +00:00
|
|
|
case WLAN_EID_CISCO_VENDOR_SPECIFIC:
|
|
|
|
/* Lots of different options exist, but we only care
|
|
|
|
* about the Dynamic Transmit Power Control element.
|
|
|
|
* First check for the Cisco OUI, then for the DTPC
|
|
|
|
* tag (0x00).
|
|
|
|
*/
|
|
|
|
if (elen < 4) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pos[0] != 0x00 || pos[1] != 0x40 ||
|
|
|
|
pos[2] != 0x96 || pos[3] != 0x00)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (elen != 6) {
|
|
|
|
elem_parse_failed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (calc_crc)
|
|
|
|
crc = crc32_be(crc, pos - 2, elen + 2);
|
|
|
|
|
|
|
|
elems->cisco_dtpc_elem = pos;
|
|
|
|
break;
|
2011-11-18 15:54:50 +00:00
|
|
|
case WLAN_EID_TIMEOUT_INTERVAL:
|
2013-03-27 13:38:07 +00:00
|
|
|
if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
|
|
|
|
elems->timeout_int = (void *)pos;
|
|
|
|
else
|
|
|
|
elem_parse_failed = true;
|
2011-11-18 15:54:50 +00:00
|
|
|
break;
|
2017-04-26 07:58:47 +00:00
|
|
|
case WLAN_EID_BSS_MAX_IDLE_PERIOD:
|
|
|
|
if (elen >= sizeof(*elems->max_idle_period_ie))
|
|
|
|
elems->max_idle_period_ie = (void *)pos;
|
|
|
|
break;
|
2018-06-09 06:14:44 +00:00
|
|
|
case WLAN_EID_EXTENSION:
|
|
|
|
if (pos[0] == WLAN_EID_EXT_HE_MU_EDCA &&
|
|
|
|
elen >= (sizeof(*elems->mu_edca_param_set) + 1)) {
|
|
|
|
elems->mu_edca_param_set = (void *)&pos[1];
|
2018-12-15 09:03:15 +00:00
|
|
|
if (calc_crc)
|
|
|
|
crc = crc32_be(crc, pos - 2, elen + 2);
|
2018-06-09 06:14:44 +00:00
|
|
|
} else if (pos[0] == WLAN_EID_EXT_HE_CAPABILITY) {
|
|
|
|
elems->he_cap = (void *)&pos[1];
|
|
|
|
elems->he_cap_len = elen - 1;
|
|
|
|
} else if (pos[0] == WLAN_EID_EXT_HE_OPERATION &&
|
|
|
|
elen >= sizeof(*elems->he_operation) &&
|
|
|
|
elen >= ieee80211_he_oper_size(&pos[1])) {
|
|
|
|
elems->he_operation = (void *)&pos[1];
|
|
|
|
} else if (pos[0] == WLAN_EID_EXT_UORA && elen >= 1) {
|
|
|
|
elems->uora_element = (void *)&pos[1];
|
2019-02-06 11:17:09 +00:00
|
|
|
} else if (pos[0] ==
|
|
|
|
WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME &&
|
|
|
|
elen == 4) {
|
|
|
|
elems->max_channel_switch_time = pos + 1;
|
2019-01-16 16:22:56 +00:00
|
|
|
} else if (pos[0] ==
|
|
|
|
WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION &&
|
|
|
|
elen == 3) {
|
|
|
|
elems->mbssid_config_ie = (void *)&pos[1];
|
2018-06-09 06:14:44 +00:00
|
|
|
}
|
|
|
|
break;
|
2011-11-18 15:54:50 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
if (elem_parse_failed)
|
|
|
|
elems->parse_error = true;
|
|
|
|
else
|
2012-10-24 12:22:37 +00:00
|
|
|
__set_bit(id, seen_elems);
|
2011-11-18 15:54:50 +00:00
|
|
|
}
|
|
|
|
|
2019-02-07 21:18:19 +00:00
|
|
|
if (!for_each_element_completed(elem, start, len))
|
mac80211: Filter duplicate IE ids
mac80211 is lenient with respect to reception of corrupted beacons.
Even if the frame is corrupted as a whole, the available IE elements
are still passed back and accepted, sometimes replacing legitimate
data. It is unknown to what extent this "feature" is made use of,
but it is clear that in some cases, this is detrimental. One such
case is reported in http://crosbug.com/26832 where an AP corrupts
its beacons but not its probe responses.
One approach would be to completely reject frames with invaid data
(for example, if the last tag extends beyond the end of the enclosing
PDU). The enclosed approach is much more conservative: we simply
prevent later IEs from overwriting the state from previous ones.
This approach hopes that there might be some salient data in the
IE stream before the corruption, and seeks to at least prevent that
data from being overwritten. This approach will fix the case above.
Further, we flag element structures that contain data we think might
be corrupted, so that as we fill the mac80211 BSS structure, we try
not to replace data from an un-corrupted probe response with that
of a corrupted beacon, for example.
Short of any statistics gathering in the various forms of AP breakage,
it's not possible to ascertain the side effects of more stringent
discarding of data.
Signed-off-by: Paul Stewart <pstew@chromium.org>
Cc: Sam Leffler <sleffler@chromium.org>
Cc: Eliad Peller <eliad@wizery.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2012-02-24 01:59:53 +00:00
|
|
|
elems->parse_error = true;
|
|
|
|
|
2011-11-18 15:54:50 +00:00
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
2019-03-15 15:39:06 +00:00
|
|
|
static size_t ieee802_11_find_bssid_profile(const u8 *start, size_t len,
|
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
u8 *transmitter_bssid,
|
|
|
|
u8 *bss_bssid,
|
2019-04-11 08:59:50 +00:00
|
|
|
u8 *nontransmitted_profile)
|
2019-03-15 15:39:04 +00:00
|
|
|
{
|
|
|
|
const struct element *elem, *sub;
|
2019-03-15 15:39:06 +00:00
|
|
|
size_t profile_len = 0;
|
|
|
|
bool found = false;
|
2019-03-15 15:39:04 +00:00
|
|
|
|
|
|
|
if (!bss_bssid || !transmitter_bssid)
|
2019-03-15 15:39:06 +00:00
|
|
|
return profile_len;
|
2019-03-15 15:39:04 +00:00
|
|
|
|
|
|
|
for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID, start, len) {
|
|
|
|
if (elem->datalen < 2)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for_each_element(sub, elem->data + 1, elem->datalen - 1) {
|
|
|
|
u8 new_bssid[ETH_ALEN];
|
|
|
|
const u8 *index;
|
|
|
|
|
|
|
|
if (sub->id != 0 || sub->datalen < 4) {
|
|
|
|
/* not a valid BSS profile */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sub->data[0] != WLAN_EID_NON_TX_BSSID_CAP ||
|
|
|
|
sub->data[1] != 2) {
|
|
|
|
/* The first element of the
|
|
|
|
* Nontransmitted BSSID Profile is not
|
|
|
|
* the Nontransmitted BSSID Capability
|
|
|
|
* element.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-04-11 08:59:50 +00:00
|
|
|
memset(nontransmitted_profile, 0, len);
|
2019-03-15 15:39:06 +00:00
|
|
|
profile_len = cfg80211_merge_profile(start, len,
|
|
|
|
elem,
|
|
|
|
sub,
|
|
|
|
nontransmitted_profile,
|
|
|
|
len);
|
|
|
|
|
2019-03-15 15:39:04 +00:00
|
|
|
/* found a Nontransmitted BSSID Profile */
|
|
|
|
index = cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX,
|
2019-04-11 08:59:50 +00:00
|
|
|
nontransmitted_profile,
|
2019-03-15 15:39:06 +00:00
|
|
|
profile_len);
|
2019-03-15 15:39:04 +00:00
|
|
|
if (!index || index[1] < 1 || index[2] == 0) {
|
|
|
|
/* Invalid MBSSID Index element */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg80211_gen_new_bssid(transmitter_bssid,
|
|
|
|
elem->data[0],
|
|
|
|
index[2],
|
|
|
|
new_bssid);
|
|
|
|
if (ether_addr_equal(new_bssid, bss_bssid)) {
|
2019-03-15 15:39:06 +00:00
|
|
|
found = true;
|
2019-03-15 15:39:04 +00:00
|
|
|
elems->bssid_index_len = index[1];
|
|
|
|
elems->bssid_index = (void *)&index[2];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-03-15 15:39:06 +00:00
|
|
|
|
|
|
|
return found ? profile_len : 0;
|
2019-03-15 15:39:04 +00:00
|
|
|
}
|
|
|
|
|
2019-01-16 16:22:56 +00:00
|
|
|
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
|
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
u64 filter, u32 crc, u8 *transmitter_bssid,
|
|
|
|
u8 *bss_bssid)
|
|
|
|
{
|
2019-03-15 15:39:04 +00:00
|
|
|
const struct element *non_inherit = NULL;
|
2019-03-15 15:39:06 +00:00
|
|
|
u8 *nontransmitted_profile;
|
|
|
|
int nontransmitted_profile_len = 0;
|
2019-03-15 15:39:04 +00:00
|
|
|
|
2019-01-16 16:22:56 +00:00
|
|
|
memset(elems, 0, sizeof(*elems));
|
|
|
|
elems->ie_start = start;
|
|
|
|
elems->total_len = len;
|
|
|
|
|
2019-03-15 15:39:06 +00:00
|
|
|
nontransmitted_profile = kmalloc(len, GFP_ATOMIC);
|
|
|
|
if (nontransmitted_profile) {
|
|
|
|
nontransmitted_profile_len =
|
|
|
|
ieee802_11_find_bssid_profile(start, len, elems,
|
|
|
|
transmitter_bssid,
|
|
|
|
bss_bssid,
|
2019-04-11 08:59:50 +00:00
|
|
|
nontransmitted_profile);
|
2019-03-15 15:39:04 +00:00
|
|
|
non_inherit =
|
|
|
|
cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE,
|
2019-03-15 15:39:06 +00:00
|
|
|
nontransmitted_profile,
|
|
|
|
nontransmitted_profile_len);
|
|
|
|
}
|
2019-03-15 15:39:04 +00:00
|
|
|
|
2019-01-16 16:22:56 +00:00
|
|
|
crc = _ieee802_11_parse_elems_crc(start, len, action, elems, filter,
|
2019-03-15 15:39:04 +00:00
|
|
|
crc, non_inherit);
|
2019-01-16 16:22:56 +00:00
|
|
|
|
|
|
|
/* Override with nontransmitted profile, if found */
|
2019-03-15 15:39:06 +00:00
|
|
|
if (nontransmitted_profile_len)
|
|
|
|
_ieee802_11_parse_elems_crc(nontransmitted_profile,
|
|
|
|
nontransmitted_profile_len,
|
2019-03-15 15:39:04 +00:00
|
|
|
action, elems, 0, 0, NULL);
|
2019-01-16 16:22:56 +00:00
|
|
|
|
|
|
|
if (elems->tim && !elems->parse_error) {
|
|
|
|
const struct ieee80211_tim_ie *tim_ie = elems->tim;
|
|
|
|
|
|
|
|
elems->dtim_period = tim_ie->dtim_period;
|
|
|
|
elems->dtim_count = tim_ie->dtim_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Override DTIM period and count if needed */
|
|
|
|
if (elems->bssid_index &&
|
|
|
|
elems->bssid_index_len >=
|
|
|
|
offsetofend(struct ieee80211_bssid_index, dtim_period))
|
|
|
|
elems->dtim_period = elems->bssid_index->dtim_period;
|
|
|
|
|
|
|
|
if (elems->bssid_index &&
|
|
|
|
elems->bssid_index_len >=
|
|
|
|
offsetofend(struct ieee80211_bssid_index, dtim_count))
|
|
|
|
elems->dtim_count = elems->bssid_index->dtim_count;
|
|
|
|
|
2019-03-15 15:39:06 +00:00
|
|
|
kfree(nontransmitted_profile);
|
|
|
|
|
2019-01-16 16:22:56 +00:00
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
2018-03-28 10:24:10 +00:00
|
|
|
void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct ieee80211_tx_queue_params
|
|
|
|
*qparam, int ac)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
const struct ieee80211_reg_rule *rrule;
|
2018-08-22 11:52:21 +00:00
|
|
|
const struct ieee80211_wmm_ac *wmm_ac;
|
2018-03-28 10:24:10 +00:00
|
|
|
u16 center_freq = 0;
|
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_AP &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
if (chanctx_conf)
|
|
|
|
center_freq = chanctx_conf->def.chan->center_freq;
|
|
|
|
|
|
|
|
if (!center_freq) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rrule = freq_reg_info(sdata->wdev.wiphy, MHZ_TO_KHZ(center_freq));
|
|
|
|
|
2018-08-22 11:52:21 +00:00
|
|
|
if (IS_ERR_OR_NULL(rrule) || !rrule->has_wmm) {
|
2018-03-28 10:24:10 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP)
|
2018-08-22 11:52:21 +00:00
|
|
|
wmm_ac = &rrule->wmm_rule.ap[ac];
|
2018-03-28 10:24:10 +00:00
|
|
|
else
|
2018-08-22 11:52:21 +00:00
|
|
|
wmm_ac = &rrule->wmm_rule.client[ac];
|
2018-03-28 10:24:10 +00:00
|
|
|
qparam->cw_min = max_t(u16, qparam->cw_min, wmm_ac->cw_min);
|
|
|
|
qparam->cw_max = max_t(u16, qparam->cw_max, wmm_ac->cw_max);
|
|
|
|
qparam->aifs = max_t(u8, qparam->aifs, wmm_ac->aifsn);
|
2018-08-31 08:31:04 +00:00
|
|
|
qparam->txop = min_t(u16, qparam->txop, wmm_ac->cot / 32);
|
2018-03-28 10:24:10 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2012-03-02 14:56:59 +00:00
|
|
|
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
|
2015-10-22 15:46:04 +00:00
|
|
|
bool bss_notify, bool enable_qos)
|
2008-09-09 10:56:01 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_tx_queue_params qparam;
|
2012-07-26 15:24:39 +00:00
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
2012-03-28 09:04:25 +00:00
|
|
|
int ac;
|
2015-10-22 15:46:04 +00:00
|
|
|
bool use_11b;
|
2014-11-03 09:33:19 +00:00
|
|
|
bool is_ocb; /* Use another EDCA parameters if dot11OCBActivated=true */
|
2009-05-07 14:16:24 +00:00
|
|
|
int aCWmin, aCWmax;
|
2008-09-09 10:56:01 +00:00
|
|
|
|
|
|
|
if (!local->ops->conf_tx)
|
|
|
|
return;
|
|
|
|
|
2012-03-28 09:04:25 +00:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
return;
|
|
|
|
|
2008-09-09 10:56:01 +00:00
|
|
|
memset(&qparam, 0, sizeof(qparam));
|
|
|
|
|
2012-07-26 15:24:39 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
use_11b = (chanctx_conf &&
|
2016-04-12 13:56:15 +00:00
|
|
|
chanctx_conf->def.chan->band == NL80211_BAND_2GHZ) &&
|
2009-05-07 14:16:24 +00:00
|
|
|
!(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
|
2012-07-26 15:24:39 +00:00
|
|
|
rcu_read_unlock();
|
2008-09-09 10:56:01 +00:00
|
|
|
|
2014-11-03 09:33:19 +00:00
|
|
|
is_ocb = (sdata->vif.type == NL80211_IFTYPE_OCB);
|
|
|
|
|
2013-09-09 15:03:41 +00:00
|
|
|
/* Set defaults according to 802.11-2007 Table 7-37 */
|
|
|
|
aCWmax = 1023;
|
|
|
|
if (use_11b)
|
|
|
|
aCWmin = 31;
|
|
|
|
else
|
|
|
|
aCWmin = 15;
|
|
|
|
|
|
|
|
/* Confiure old 802.11b/g medium access rules. */
|
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
|
|
|
qparam.txop = 0;
|
|
|
|
qparam.aifs = 2;
|
2009-05-07 14:16:24 +00:00
|
|
|
|
2013-09-09 15:03:41 +00:00
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
/* Update if QoS is enabled. */
|
2012-05-30 08:56:46 +00:00
|
|
|
if (enable_qos) {
|
|
|
|
switch (ac) {
|
|
|
|
case IEEE80211_AC_BK:
|
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
|
|
|
qparam.txop = 0;
|
2014-11-03 09:33:19 +00:00
|
|
|
if (is_ocb)
|
|
|
|
qparam.aifs = 9;
|
|
|
|
else
|
|
|
|
qparam.aifs = 7;
|
2012-05-30 08:56:46 +00:00
|
|
|
break;
|
|
|
|
/* never happens but let's not leave undefined */
|
|
|
|
default:
|
|
|
|
case IEEE80211_AC_BE:
|
|
|
|
qparam.cw_max = aCWmax;
|
|
|
|
qparam.cw_min = aCWmin;
|
|
|
|
qparam.txop = 0;
|
2014-11-03 09:33:19 +00:00
|
|
|
if (is_ocb)
|
|
|
|
qparam.aifs = 6;
|
|
|
|
else
|
|
|
|
qparam.aifs = 3;
|
2012-05-30 08:56:46 +00:00
|
|
|
break;
|
|
|
|
case IEEE80211_AC_VI:
|
|
|
|
qparam.cw_max = aCWmin;
|
|
|
|
qparam.cw_min = (aCWmin + 1) / 2 - 1;
|
2014-11-03 09:33:19 +00:00
|
|
|
if (is_ocb)
|
|
|
|
qparam.txop = 0;
|
|
|
|
else if (use_11b)
|
2012-05-30 08:56:46 +00:00
|
|
|
qparam.txop = 6016/32;
|
|
|
|
else
|
|
|
|
qparam.txop = 3008/32;
|
2014-11-03 09:33:19 +00:00
|
|
|
|
|
|
|
if (is_ocb)
|
|
|
|
qparam.aifs = 3;
|
|
|
|
else
|
|
|
|
qparam.aifs = 2;
|
2012-05-30 08:56:46 +00:00
|
|
|
break;
|
|
|
|
case IEEE80211_AC_VO:
|
|
|
|
qparam.cw_max = (aCWmin + 1) / 2 - 1;
|
|
|
|
qparam.cw_min = (aCWmin + 1) / 4 - 1;
|
2014-11-03 09:33:19 +00:00
|
|
|
if (is_ocb)
|
|
|
|
qparam.txop = 0;
|
|
|
|
else if (use_11b)
|
2012-05-30 08:56:46 +00:00
|
|
|
qparam.txop = 3264/32;
|
|
|
|
else
|
|
|
|
qparam.txop = 1504/32;
|
|
|
|
qparam.aifs = 2;
|
|
|
|
break;
|
|
|
|
}
|
2009-05-07 14:16:24 +00:00
|
|
|
}
|
2018-03-28 10:24:10 +00:00
|
|
|
ieee80211_regulatory_limit_wmm_params(sdata, &qparam, ac);
|
2008-09-09 10:56:01 +00:00
|
|
|
|
2010-01-12 08:42:31 +00:00
|
|
|
qparam.uapsd = false;
|
|
|
|
|
2012-03-28 09:04:25 +00:00
|
|
|
sdata->tx_conf[ac] = qparam;
|
|
|
|
drv_conf_tx(local, sdata, ac, &qparam);
|
2009-05-07 14:16:24 +00:00
|
|
|
}
|
2010-03-29 10:18:34 +00:00
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
2016-09-20 14:31:14 +00:00
|
|
|
sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_NAN) {
|
2012-05-30 08:56:46 +00:00
|
|
|
sdata->vif.bss_conf.qos = enable_qos;
|
2012-03-02 14:56:59 +00:00
|
|
|
if (bss_notify)
|
|
|
|
ieee80211_bss_info_change_notify(sdata,
|
|
|
|
BSS_CHANGED_QOS);
|
2010-07-23 05:17:11 +00:00
|
|
|
}
|
2008-09-09 10:56:01 +00:00
|
|
|
}
|
2008-09-09 13:07:09 +00:00
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
|
2012-09-30 16:29:37 +00:00
|
|
|
u16 transaction, u16 auth_alg, u16 status,
|
2013-02-12 15:43:19 +00:00
|
|
|
const u8 *extra, size_t extra_len, const u8 *da,
|
2013-01-29 14:02:27 +00:00
|
|
|
const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
|
|
|
|
u32 tx_flags)
|
2009-02-15 11:44:28 +00: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 12:22:54 +00:00
|
|
|
int err;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2013-09-24 02:33:01 +00:00
|
|
|
/* 24 + 6 = header + auth_algo + auth_transaction + status_code */
|
2014-06-10 17:00:08 +00:00
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN +
|
|
|
|
24 + 6 + extra_len + IEEE80211_WEP_ICV_LEN);
|
2011-08-29 21:17:31 +00:00
|
|
|
if (!skb)
|
2009-02-15 11:44:28 +00:00
|
|
|
return;
|
2011-08-29 21:17:31 +00:00
|
|
|
|
2014-06-10 17:00:08 +00:00
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
networking: convert many more places to skb_put_zero()
There were many places that my previous spatch didn't find,
as pointed out by yuan linyu in various patches.
The following spatch found many more and also removes the
now unnecessary casts:
@@
identifier p, p2;
expression len;
expression skb;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_zero(skb, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_zero(skb, len);
)
... when != p
(
p2 = (t2)p;
-memset(p2, 0, len);
|
-memset(p, 0, len);
)
@@
type t, t2;
identifier p, p2;
expression skb;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_zero(skb, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_zero(skb, sizeof(t));
)
... when != p
(
p2 = (t2)p;
-memset(p2, 0, sizeof(*p));
|
-memset(p, 0, sizeof(*p));
)
@@
expression skb, len;
@@
-memset(skb_put(skb, len), 0, len);
+skb_put_zero(skb, len);
Apply it to the tree (with one manual fixup to keep the
comment in vxlan.c, which spatch removed.)
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 12:29:19 +00:00
|
|
|
mgmt = skb_put_zero(skb, 24 + 6);
|
2009-02-15 11:44:28 +00:00
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_AUTH);
|
2012-01-09 18:43:06 +00:00
|
|
|
memcpy(mgmt->da, da, ETH_ALEN);
|
2009-11-25 16:46:19 +00:00
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
2009-02-15 11:44:28 +00:00
|
|
|
memcpy(mgmt->bssid, bssid, ETH_ALEN);
|
|
|
|
mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
|
|
|
|
mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
|
2012-09-30 16:29:37 +00:00
|
|
|
mgmt->u.auth.status_code = cpu_to_le16(status);
|
2009-02-15 11:44:28 +00:00
|
|
|
if (extra)
|
networking: introduce and use skb_put_data()
A common pattern with skb_put() is to just want to memcpy()
some data into the new space, introduce skb_put_data() for
this.
An spatch similar to the one for skb_put_zero() converts many
of the places using it:
@@
identifier p, p2;
expression len, skb, data;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_data(skb, data, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_data(skb, data, len);
)
(
p2 = (t2)p;
-memcpy(p2, data, len);
|
-memcpy(p, data, len);
)
@@
type t, t2;
identifier p, p2;
expression skb, data;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
)
(
p2 = (t2)p;
-memcpy(p2, data, sizeof(*p));
|
-memcpy(p, data, sizeof(*p));
)
@@
expression skb, len, data;
@@
-memcpy(skb_put(skb, len), data, len);
+skb_put_data(skb, data, len);
(again, manually post-processed to retain some comments)
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 12:29:20 +00:00
|
|
|
skb_put_data(skb, extra, extra_len);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 12:22:54 +00:00
|
|
|
if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
|
|
|
|
mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
|
|
|
err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
|
|
|
|
WARN_ON(err);
|
|
|
|
}
|
|
|
|
|
2013-01-29 14:02:27 +00:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
|
|
|
|
tx_flags;
|
2009-11-18 17:42:05 +00:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-15 11:44:28 +00:00
|
|
|
}
|
|
|
|
|
2012-09-07 11:28:52 +00:00
|
|
|
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *bssid, u16 stype, u16 reason,
|
|
|
|
bool send_frame, u8 *frame_buf)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt = (void *)frame_buf;
|
|
|
|
|
|
|
|
/* build frame */
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
|
|
|
|
mgmt->duration = 0; /* initialize only */
|
|
|
|
mgmt->seq_ctrl = 0; /* initialize only */
|
|
|
|
memcpy(mgmt->da, bssid, ETH_ALEN);
|
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, bssid, ETH_ALEN);
|
|
|
|
/* u.deauth.reason_code == u.disassoc.reason_code */
|
|
|
|
mgmt->u.deauth.reason_code = cpu_to_le16(reason);
|
|
|
|
|
|
|
|
if (send_frame) {
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom +
|
|
|
|
IEEE80211_DEAUTH_FRAME_LEN);
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
/* copy in frame */
|
networking: introduce and use skb_put_data()
A common pattern with skb_put() is to just want to memcpy()
some data into the new space, introduce skb_put_data() for
this.
An spatch similar to the one for skb_put_zero() converts many
of the places using it:
@@
identifier p, p2;
expression len, skb, data;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_data(skb, data, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_data(skb, data, len);
)
(
p2 = (t2)p;
-memcpy(p2, data, len);
|
-memcpy(p, data, len);
)
@@
type t, t2;
identifier p, p2;
expression skb, data;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
)
(
p2 = (t2)p;
-memcpy(p2, data, sizeof(*p));
|
-memcpy(p, data, sizeof(*p));
)
@@
expression skb, len, data;
@@
-memcpy(skb_put(skb, len), data, len);
+skb_put_data(skb, data, len);
(again, manually post-processed to retain some comments)
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 12:29:20 +00:00
|
|
|
skb_put_data(skb, mgmt, IEEE80211_DEAUTH_FRAME_LEN);
|
2012-09-07 11:28:52 +00:00
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION ||
|
|
|
|
!(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
|
|
|
|
IEEE80211_SKB_CB(skb)->flags |=
|
|
|
|
IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-05 13:21:13 +00:00
|
|
|
static int ieee80211_build_preq_ies_band(struct ieee80211_local *local,
|
|
|
|
u8 *buffer, size_t buffer_len,
|
|
|
|
const u8 *ie, size_t ie_len,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band,
|
2014-02-05 13:21:13 +00:00
|
|
|
u32 rate_mask,
|
|
|
|
struct cfg80211_chan_def *chandef,
|
2018-05-28 13:47:38 +00:00
|
|
|
size_t *offset, u32 flags)
|
2009-04-01 09:58:36 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
2018-06-09 06:14:44 +00:00
|
|
|
const struct ieee80211_sta_he_cap *he_cap;
|
2012-11-29 11:45:18 +00:00
|
|
|
u8 *pos = buffer, *end = buffer + buffer_len;
|
2014-02-05 13:21:13 +00:00
|
|
|
size_t noffset;
|
2009-12-23 12:15:38 +00:00
|
|
|
int supp_rates_len, i;
|
2010-08-28 16:36:10 +00:00
|
|
|
u8 rates[32];
|
|
|
|
int num_rates;
|
|
|
|
int ext_rates_len;
|
2013-07-08 14:55:53 +00:00
|
|
|
int shift;
|
|
|
|
u32 rate_flags;
|
2014-11-24 14:49:44 +00:00
|
|
|
bool have_80mhz = false;
|
2009-04-01 09:58:36 +00:00
|
|
|
|
2014-02-05 13:21:13 +00:00
|
|
|
*offset = 0;
|
|
|
|
|
2009-10-27 19:59:55 +00:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2012-07-09 16:57:28 +00:00
|
|
|
if (WARN_ON_ONCE(!sband))
|
|
|
|
return 0;
|
2009-04-01 09:58:36 +00:00
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
rate_flags = ieee80211_chandef_rate_flags(chandef);
|
|
|
|
shift = ieee80211_chandef_get_shift(chandef);
|
|
|
|
|
2010-08-28 16:36:10 +00:00
|
|
|
num_rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((BIT(i) & rate_mask) == 0)
|
|
|
|
continue; /* skip rate */
|
2013-07-08 14:55:53 +00:00
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rates[num_rates++] =
|
|
|
|
(u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
|
|
|
|
(1 << shift) * 5);
|
2010-08-28 16:36:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
supp_rates_len = min_t(int, num_rates, 8);
|
2009-12-23 12:15:38 +00:00
|
|
|
|
2012-11-29 11:45:18 +00:00
|
|
|
if (end - pos < 2 + supp_rates_len)
|
|
|
|
goto out_err;
|
2009-04-01 09:58:36 +00:00
|
|
|
*pos++ = WLAN_EID_SUPP_RATES;
|
2009-12-23 12:15:38 +00:00
|
|
|
*pos++ = supp_rates_len;
|
2010-08-28 16:36:10 +00:00
|
|
|
memcpy(pos, rates, supp_rates_len);
|
|
|
|
pos += supp_rates_len;
|
2009-12-23 12:15:38 +00:00
|
|
|
|
|
|
|
/* insert "request information" if in custom IEs */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
static const u8 before_extrates[] = {
|
|
|
|
WLAN_EID_SSID,
|
|
|
|
WLAN_EID_SUPP_RATES,
|
|
|
|
WLAN_EID_REQUEST,
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_extrates,
|
|
|
|
ARRAY_SIZE(before_extrates),
|
2014-02-05 13:21:13 +00:00
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
2012-11-29 11:45:18 +00:00
|
|
|
goto out_err;
|
2014-02-05 13:21:13 +00:00
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
2009-12-23 12:15:38 +00:00
|
|
|
}
|
|
|
|
|
2010-08-28 16:36:10 +00:00
|
|
|
ext_rates_len = num_rates - supp_rates_len;
|
|
|
|
if (ext_rates_len > 0) {
|
2012-11-29 11:45:18 +00:00
|
|
|
if (end - pos < 2 + ext_rates_len)
|
|
|
|
goto out_err;
|
2009-12-23 12:15:38 +00:00
|
|
|
*pos++ = WLAN_EID_EXT_SUPP_RATES;
|
2010-08-28 16:36:10 +00:00
|
|
|
*pos++ = ext_rates_len;
|
|
|
|
memcpy(pos, rates + supp_rates_len, ext_rates_len);
|
|
|
|
pos += ext_rates_len;
|
2009-12-23 12:15:38 +00:00
|
|
|
}
|
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
if (chandef->chan && sband->band == NL80211_BAND_2GHZ) {
|
2012-11-29 11:45:18 +00:00
|
|
|
if (end - pos < 3)
|
|
|
|
goto out_err;
|
2010-08-28 16:37:51 +00:00
|
|
|
*pos++ = WLAN_EID_DS_PARAMS;
|
|
|
|
*pos++ = 1;
|
2013-07-08 14:55:53 +00:00
|
|
|
*pos++ = ieee80211_frequency_to_channel(
|
|
|
|
chandef->chan->center_freq);
|
2010-08-28 16:37:51 +00:00
|
|
|
}
|
|
|
|
|
2018-05-28 13:47:41 +00:00
|
|
|
if (flags & IEEE80211_PROBE_FLAG_MIN_CONTENT)
|
|
|
|
goto done;
|
|
|
|
|
2009-12-23 12:15:38 +00:00
|
|
|
/* insert custom IEs that go before HT */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
static const u8 before_ht[] = {
|
2017-08-05 08:44:32 +00:00
|
|
|
/*
|
|
|
|
* no need to list the ones split off already
|
|
|
|
* (or generated here)
|
|
|
|
*/
|
2009-12-23 12:15:38 +00:00
|
|
|
WLAN_EID_DS_PARAMS,
|
|
|
|
WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_ht, ARRAY_SIZE(before_ht),
|
2014-02-05 13:21:13 +00:00
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
2012-11-29 11:45:18 +00:00
|
|
|
goto out_err;
|
2014-02-05 13:21:13 +00:00
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
2009-04-01 09:58:36 +00:00
|
|
|
}
|
|
|
|
|
2012-11-29 11:45:18 +00:00
|
|
|
if (sband->ht_cap.ht_supported) {
|
|
|
|
if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
|
|
|
|
goto out_err;
|
2011-11-18 19:32:00 +00:00
|
|
|
pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
|
|
|
|
sband->ht_cap.cap);
|
2012-11-29 11:45:18 +00:00
|
|
|
}
|
2009-03-31 10:12:07 +00:00
|
|
|
|
2014-02-04 08:48:34 +00:00
|
|
|
/* insert custom IEs that go before VHT */
|
2009-12-23 12:15:38 +00:00
|
|
|
if (ie && ie_len) {
|
2014-02-04 08:48:34 +00:00
|
|
|
static const u8 before_vht[] = {
|
2017-08-05 08:44:32 +00:00
|
|
|
/*
|
|
|
|
* no need to list the ones split off already
|
|
|
|
* (or generated here)
|
|
|
|
*/
|
2014-02-04 08:48:34 +00:00
|
|
|
WLAN_EID_BSS_COEX_2040,
|
|
|
|
WLAN_EID_EXT_CAPABILITY,
|
|
|
|
WLAN_EID_SSID_LIST,
|
|
|
|
WLAN_EID_CHANNEL_USAGE,
|
|
|
|
WLAN_EID_INTERWORKING,
|
2017-08-05 08:44:29 +00:00
|
|
|
WLAN_EID_MESH_ID,
|
2017-08-05 08:44:32 +00:00
|
|
|
/* 60 GHz (Multi-band, DMG, MMS) can't happen */
|
2014-02-04 08:48:34 +00:00
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_vht, ARRAY_SIZE(before_vht),
|
2014-02-05 13:21:13 +00:00
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
2012-11-29 11:45:18 +00:00
|
|
|
goto out_err;
|
2014-02-05 13:21:13 +00:00
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
2009-04-01 09:58:36 +00:00
|
|
|
}
|
|
|
|
|
2014-11-24 14:49:44 +00:00
|
|
|
/* Check if any channel in this sband supports at least 80 MHz */
|
|
|
|
for (i = 0; i < sband->n_channels; i++) {
|
2015-01-01 11:43:17 +00:00
|
|
|
if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
|
|
|
|
IEEE80211_CHAN_NO_80MHZ))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
have_80mhz = true;
|
|
|
|
break;
|
2014-11-24 14:49:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sband->vht_cap.vht_supported && have_80mhz) {
|
2012-11-29 11:45:18 +00:00
|
|
|
if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
|
|
|
|
goto out_err;
|
2012-07-02 11:25:12 +00:00
|
|
|
pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
|
|
|
|
sband->vht_cap.cap);
|
2012-11-29 11:45:18 +00:00
|
|
|
}
|
2012-07-02 11:25:12 +00:00
|
|
|
|
2018-06-09 06:14:44 +00:00
|
|
|
/* insert custom IEs that go before HE */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
static const u8 before_he[] = {
|
|
|
|
/*
|
|
|
|
* no need to list the ones split off before VHT
|
|
|
|
* or generated here
|
|
|
|
*/
|
|
|
|
WLAN_EID_EXTENSION, WLAN_EID_EXT_FILS_REQ_PARAMS,
|
|
|
|
WLAN_EID_AP_CSN,
|
|
|
|
/* TODO: add 11ah/11aj/11ak elements */
|
|
|
|
};
|
|
|
|
noffset = ieee80211_ie_split(ie, ie_len,
|
|
|
|
before_he, ARRAY_SIZE(before_he),
|
|
|
|
*offset);
|
|
|
|
if (end - pos < noffset - *offset)
|
|
|
|
goto out_err;
|
|
|
|
memcpy(pos, ie + *offset, noffset - *offset);
|
|
|
|
pos += noffset - *offset;
|
|
|
|
*offset = noffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
he_cap = ieee80211_get_he_sta_cap(sband);
|
|
|
|
if (he_cap) {
|
|
|
|
pos = ieee80211_ie_build_he_cap(pos, he_cap, end);
|
|
|
|
if (!pos)
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If adding more here, adjust code in main.c
|
|
|
|
* that calculates local->scan_ies_len.
|
|
|
|
*/
|
|
|
|
|
2012-11-29 11:45:18 +00:00
|
|
|
return pos - buffer;
|
|
|
|
out_err:
|
|
|
|
WARN_ONCE(1, "not enough space for preq IEs\n");
|
2018-05-28 13:47:41 +00:00
|
|
|
done:
|
2009-04-01 09:58:36 +00:00
|
|
|
return pos - buffer;
|
|
|
|
}
|
|
|
|
|
2014-02-05 13:21:13 +00:00
|
|
|
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
|
|
|
|
size_t buffer_len,
|
|
|
|
struct ieee80211_scan_ies *ie_desc,
|
|
|
|
const u8 *ie, size_t ie_len,
|
|
|
|
u8 bands_used, u32 *rate_masks,
|
2018-05-28 13:47:38 +00:00
|
|
|
struct cfg80211_chan_def *chandef,
|
|
|
|
u32 flags)
|
2014-02-05 13:21:13 +00:00
|
|
|
{
|
|
|
|
size_t pos = 0, old_pos = 0, custom_ie_offset = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(ie_desc, 0, sizeof(*ie_desc));
|
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
for (i = 0; i < NUM_NL80211_BANDS; i++) {
|
2014-02-05 13:21:13 +00:00
|
|
|
if (bands_used & BIT(i)) {
|
|
|
|
pos += ieee80211_build_preq_ies_band(local,
|
|
|
|
buffer + pos,
|
|
|
|
buffer_len - pos,
|
|
|
|
ie, ie_len, i,
|
|
|
|
rate_masks[i],
|
|
|
|
chandef,
|
2018-05-28 13:47:38 +00:00
|
|
|
&custom_ie_offset,
|
|
|
|
flags);
|
2014-02-05 13:21:13 +00:00
|
|
|
ie_desc->ies[i] = buffer + old_pos;
|
|
|
|
ie_desc->len[i] = pos - old_pos;
|
|
|
|
old_pos = pos;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add any remaining custom IEs */
|
|
|
|
if (ie && ie_len) {
|
|
|
|
if (WARN_ONCE(buffer_len - pos < ie_len - custom_ie_offset,
|
|
|
|
"not enough space for preq custom IEs\n"))
|
|
|
|
return pos;
|
|
|
|
memcpy(buffer + pos, ie + custom_ie_offset,
|
|
|
|
ie_len - custom_ie_offset);
|
|
|
|
ie_desc->common_ies = buffer + pos;
|
|
|
|
ie_desc->common_ie_len = ie_len - custom_ie_offset;
|
|
|
|
pos += ie_len - custom_ie_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
};
|
|
|
|
|
2010-11-11 06:50:18 +00:00
|
|
|
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
|
2014-06-12 20:24:31 +00:00
|
|
|
const u8 *src, const u8 *dst,
|
|
|
|
u32 ratemask,
|
2012-07-23 12:53:27 +00:00
|
|
|
struct ieee80211_channel *chan,
|
2010-11-11 06:50:18 +00:00
|
|
|
const u8 *ssid, size_t ssid_len,
|
2011-06-23 17:00:11 +00:00
|
|
|
const u8 *ie, size_t ie_len,
|
2018-05-28 13:47:38 +00:00
|
|
|
u32 flags)
|
2009-02-15 11:44:28 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2013-07-08 14:55:53 +00:00
|
|
|
struct cfg80211_chan_def chandef;
|
2009-02-15 11:44:28 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
2012-11-29 12:00:10 +00:00
|
|
|
int ies_len;
|
2016-04-12 13:56:15 +00:00
|
|
|
u32 rate_masks[NUM_NL80211_BANDS] = {};
|
2014-02-05 13:21:13 +00:00
|
|
|
struct ieee80211_scan_ies dummy_ie_desc;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
2011-06-23 17:00:11 +00:00
|
|
|
/*
|
|
|
|
* Do not send DS Channel parameter for directed probe requests
|
|
|
|
* in order to maximize the chance that we get a response. Some
|
|
|
|
* badly-behaved APs don't respond when this parameter is included.
|
|
|
|
*/
|
2013-07-08 14:55:53 +00:00
|
|
|
chandef.width = sdata->vif.bss_conf.chandef.width;
|
2018-05-28 13:47:38 +00:00
|
|
|
if (flags & IEEE80211_PROBE_FLAG_DIRECTED)
|
2013-07-08 14:55:53 +00:00
|
|
|
chandef.chan = NULL;
|
2011-06-23 17:00:11 +00:00
|
|
|
else
|
2013-07-08 14:55:53 +00:00
|
|
|
chandef.chan = chan;
|
2010-08-28 16:37:51 +00:00
|
|
|
|
2014-06-12 20:24:31 +00:00
|
|
|
skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
|
|
|
|
100 + ie_len);
|
2011-11-08 12:04:41 +00:00
|
|
|
if (!skb)
|
2012-11-29 12:00:10 +00:00
|
|
|
return NULL;
|
|
|
|
|
2014-02-05 13:21:13 +00:00
|
|
|
rate_masks[chan->band] = ratemask;
|
2012-11-29 12:00:10 +00:00
|
|
|
ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb),
|
2014-02-05 13:21:13 +00:00
|
|
|
skb_tailroom(skb), &dummy_ie_desc,
|
|
|
|
ie, ie_len, BIT(chan->band),
|
2018-05-28 13:47:38 +00:00
|
|
|
rate_masks, &chandef, flags);
|
2012-11-29 12:00:10 +00:00
|
|
|
skb_put(skb, ies_len);
|
2010-01-05 18:16:44 +00:00
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
if (dst) {
|
2010-01-05 18:16:44 +00:00
|
|
|
mgmt = (struct ieee80211_mgmt *) skb->data;
|
2009-02-15 11:44:28 +00:00
|
|
|
memcpy(mgmt->da, dst, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, dst, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
2009-11-18 17:42:05 +00:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
2011-11-08 12:04:41 +00:00
|
|
|
|
2010-11-11 06:50:18 +00:00
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
|
2009-02-15 11:44:28 +00:00
|
|
|
struct ieee802_11_elems *elems,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band, u32 *basic_rates)
|
2009-02-15 11:44:28 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
size_t num_rates;
|
2013-07-08 14:55:53 +00:00
|
|
|
u32 supp_rates, rate_flags;
|
|
|
|
int i, j, shift;
|
2017-04-27 07:15:38 +00:00
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
sband = sdata->local->hw.wiphy->bands[band];
|
2017-04-27 07:15:38 +00:00
|
|
|
if (WARN_ON(!sband))
|
|
|
|
return 1;
|
2013-07-08 14:55:53 +00:00
|
|
|
|
|
|
|
rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
|
|
|
|
shift = ieee80211_vif_get_shift(&sdata->vif);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
|
|
|
num_rates = sband->n_bitrates;
|
|
|
|
supp_rates = 0;
|
|
|
|
for (i = 0; i < elems->supp_rates_len +
|
|
|
|
elems->ext_supp_rates_len; i++) {
|
|
|
|
u8 rate = 0;
|
|
|
|
int own_rate;
|
2012-04-03 04:21:21 +00:00
|
|
|
bool is_basic;
|
2009-02-15 11:44:28 +00:00
|
|
|
if (i < elems->supp_rates_len)
|
|
|
|
rate = elems->supp_rates[i];
|
|
|
|
else if (elems->ext_supp_rates)
|
|
|
|
rate = elems->ext_supp_rates
|
|
|
|
[i - elems->supp_rates_len];
|
|
|
|
own_rate = 5 * (rate & 0x7f);
|
2012-04-03 04:21:21 +00:00
|
|
|
is_basic = !!(rate & 0x80);
|
|
|
|
|
|
|
|
if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; j < num_rates; j++) {
|
2013-07-08 14:55:53 +00:00
|
|
|
int brate;
|
|
|
|
if ((rate_flags & sband->bitrates[j].flags)
|
|
|
|
!= rate_flags)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
|
|
|
|
1 << shift);
|
|
|
|
|
|
|
|
if (brate == own_rate) {
|
2009-02-15 11:44:28 +00:00
|
|
|
supp_rates |= BIT(j);
|
2012-04-03 04:21:21 +00:00
|
|
|
if (basic_rates && is_basic)
|
|
|
|
*basic_rates |= BIT(j);
|
|
|
|
}
|
|
|
|
}
|
2009-02-15 11:44:28 +00:00
|
|
|
}
|
|
|
|
return supp_rates;
|
|
|
|
}
|
2009-04-14 08:09:24 +00:00
|
|
|
|
2009-08-20 18:02:20 +00:00
|
|
|
void ieee80211_stop_device(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
ieee80211_led_radio(local, false);
|
2010-11-30 07:59:23 +00:00
|
|
|
ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
|
2009-08-20 18:02:20 +00:00
|
|
|
|
|
|
|
cancel_work_sync(&local->reconfig_filter);
|
|
|
|
|
|
|
|
flush_workqueue(local->workqueue);
|
2010-01-10 13:07:53 +00:00
|
|
|
drv_stop(local);
|
2009-08-20 18:02:20 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 14:04:38 +00:00
|
|
|
static void ieee80211_flush_completed_scan(struct ieee80211_local *local,
|
|
|
|
bool aborted)
|
|
|
|
{
|
|
|
|
/* It's possible that we don't handle the scan completion in
|
|
|
|
* time during suspend, so if it's still marked as completed
|
|
|
|
* here, queue the work and flush it to clean things up.
|
|
|
|
* Instead of calling the worker function directly here, we
|
|
|
|
* really queue it to avoid potential races with other flows
|
|
|
|
* scheduling the same work.
|
|
|
|
*/
|
|
|
|
if (test_bit(SCAN_COMPLETED, &local->scanning)) {
|
|
|
|
/* If coming from reconfiguration failure, abort the scan so
|
|
|
|
* we don't attempt to continue a partial HW scan - which is
|
|
|
|
* possible otherwise if (e.g.) the 2.4 GHz portion was the
|
|
|
|
* completed scan, and a 5 GHz portion is still pending.
|
|
|
|
*/
|
|
|
|
if (aborted)
|
|
|
|
set_bit(SCAN_ABORTED, &local->scanning);
|
|
|
|
ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
|
|
|
|
flush_delayed_work(&local->scan_work);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-30 12:19:04 +00:00
|
|
|
static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We get here if during resume the device can't be restarted properly.
|
|
|
|
* We might also get here if this happens during HW reset, which is a
|
|
|
|
* slightly different situation and we need to drop all connections in
|
|
|
|
* the latter case.
|
|
|
|
*
|
|
|
|
* Ask cfg80211 to turn off all interfaces, this will result in more
|
|
|
|
* warnings but at least we'll then get into a clean stopped state.
|
|
|
|
*/
|
|
|
|
|
|
|
|
local->resuming = false;
|
|
|
|
local->suspended = false;
|
2015-06-10 17:19:37 +00:00
|
|
|
local->in_reconfig = false;
|
2014-04-30 12:19:04 +00:00
|
|
|
|
2015-12-08 14:04:38 +00:00
|
|
|
ieee80211_flush_completed_scan(local, true);
|
|
|
|
|
2014-04-30 12:19:04 +00:00
|
|
|
/* scheduled scan clearly can't be running any more, but tell
|
|
|
|
* cfg80211 and clear local state
|
|
|
|
*/
|
|
|
|
ieee80211_sched_scan_end(local);
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list)
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
|
|
|
|
|
|
|
|
/* Mark channel contexts as not being in the driver any more to avoid
|
|
|
|
* removing them from the driver during the shutdown process...
|
|
|
|
*/
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list)
|
|
|
|
ctx->driver_present = false;
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
cfg80211_shutdown_all_interfaces(local->hw.wiphy);
|
|
|
|
}
|
|
|
|
|
2013-02-28 09:55:30 +00:00
|
|
|
static void ieee80211_assign_chanctx(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *conf;
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
|
|
|
|
if (!local->use_chanctx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
|
|
|
|
lockdep_is_held(&local->chanctx_mtx));
|
|
|
|
if (conf) {
|
|
|
|
ctx = container_of(conf, struct ieee80211_chanctx, conf);
|
|
|
|
drv_assign_vif_chanctx(local, sdata, ctx);
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
}
|
|
|
|
|
2015-12-08 14:04:39 +00:00
|
|
|
static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
/* add STAs back */
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
|
|
|
enum ieee80211_sta_state state;
|
|
|
|
|
|
|
|
if (!sta->uploaded || sta->sdata != sdata)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (state = IEEE80211_STA_NOTEXIST;
|
|
|
|
state < sta->sta_state; state++)
|
|
|
|
WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
|
|
|
|
state + 1));
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
}
|
|
|
|
|
2016-09-20 14:31:20 +00:00
|
|
|
static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct cfg80211_nan_func *func, **funcs;
|
|
|
|
int res, id, i = 0;
|
|
|
|
|
|
|
|
res = drv_start_nan(sdata->local, sdata,
|
|
|
|
&sdata->u.nan.conf);
|
|
|
|
if (WARN_ON(res))
|
|
|
|
return res;
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1,
|
|
|
|
sizeof(*funcs),
|
|
|
|
GFP_KERNEL);
|
2016-09-20 14:31:20 +00:00
|
|
|
if (!funcs)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Add all the functions:
|
|
|
|
* This is a little bit ugly. We need to call a potentially sleeping
|
|
|
|
* callback for each NAN function, so we can't hold the spinlock.
|
|
|
|
*/
|
|
|
|
spin_lock_bh(&sdata->u.nan.func_lock);
|
|
|
|
|
|
|
|
idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id)
|
|
|
|
funcs[i++] = func;
|
|
|
|
|
|
|
|
spin_unlock_bh(&sdata->u.nan.func_lock);
|
|
|
|
|
|
|
|
for (i = 0; funcs[i]; i++) {
|
|
|
|
res = drv_add_nan_func(sdata->local, sdata, funcs[i]);
|
|
|
|
if (WARN_ON(res))
|
|
|
|
ieee80211_nan_func_terminated(&sdata->vif,
|
|
|
|
funcs[i]->instance_id,
|
|
|
|
NL80211_NAN_FUNC_TERM_REASON_ERROR,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(funcs);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
int ieee80211_reconfig(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = &local->hw;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-07-26 15:24:39 +00:00
|
|
|
struct ieee80211_chanctx *ctx;
|
2009-04-14 08:09:24 +00:00
|
|
|
struct sta_info *sta;
|
2011-07-14 17:29:42 +00:00
|
|
|
int res, i;
|
2013-01-10 22:55:33 +00:00
|
|
|
bool reconfig_due_to_wowlan = false;
|
2013-12-08 19:48:57 +00:00
|
|
|
struct ieee80211_sub_if_data *sched_scan_sdata;
|
2014-11-19 10:55:49 +00:00
|
|
|
struct cfg80211_sched_scan_request *sched_scan_req;
|
2013-12-08 19:48:57 +00:00
|
|
|
bool sched_scan_stopped = false;
|
2015-07-08 12:41:47 +00:00
|
|
|
bool suspended = local->suspended;
|
2013-01-10 22:55:33 +00:00
|
|
|
|
2014-12-14 09:05:53 +00:00
|
|
|
/* nothing to do if HW shouldn't run */
|
|
|
|
if (!local->open_count)
|
|
|
|
goto wake_up;
|
|
|
|
|
2013-01-10 23:28:01 +00:00
|
|
|
#ifdef CONFIG_PM
|
2015-07-08 12:41:47 +00:00
|
|
|
if (suspended)
|
2009-11-19 13:29:39 +00:00
|
|
|
local->resuming = true;
|
2009-04-14 08:09:24 +00:00
|
|
|
|
2011-05-04 13:37:29 +00:00
|
|
|
if (local->wowlan) {
|
2015-07-08 12:41:47 +00:00
|
|
|
/*
|
|
|
|
* In the wowlan case, both mac80211 and the device
|
|
|
|
* are functional when the resume op is called, so
|
|
|
|
* clear local->suspended so the device could operate
|
|
|
|
* normally (e.g. pass rx frames).
|
|
|
|
*/
|
|
|
|
local->suspended = false;
|
2011-05-04 13:37:29 +00:00
|
|
|
res = drv_resume(local);
|
2013-08-07 18:11:55 +00:00
|
|
|
local->wowlan = false;
|
2011-05-04 13:37:29 +00:00
|
|
|
if (res < 0) {
|
|
|
|
local->resuming = false;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
if (res == 0)
|
|
|
|
goto wake_up;
|
|
|
|
WARN_ON(res > 1);
|
|
|
|
/*
|
|
|
|
* res is 1, which means the driver requested
|
|
|
|
* to go through a regular reset on wakeup.
|
2015-07-08 12:41:47 +00:00
|
|
|
* restore local->suspended in this case.
|
2011-05-04 13:37:29 +00:00
|
|
|
*/
|
2013-01-10 22:55:33 +00:00
|
|
|
reconfig_due_to_wowlan = true;
|
2015-07-08 12:41:47 +00:00
|
|
|
local->suspended = true;
|
2011-05-04 13:37:29 +00:00
|
|
|
}
|
|
|
|
#endif
|
2009-04-14 08:09:24 +00:00
|
|
|
|
2015-10-25 08:59:35 +00:00
|
|
|
/*
|
|
|
|
* In case of hw_restart during suspend (without wowlan),
|
|
|
|
* cancel restart work, as we are reconfiguring the device
|
|
|
|
* anyway.
|
|
|
|
* Note that restart_work is scheduled on a frozen workqueue,
|
|
|
|
* so we can't deadlock in this case.
|
|
|
|
*/
|
|
|
|
if (suspended && local->in_reconfig && !reconfig_due_to_wowlan)
|
|
|
|
cancel_work_sync(&local->restart_work);
|
|
|
|
|
2015-10-25 08:59:36 +00:00
|
|
|
local->started = false;
|
|
|
|
|
2011-07-14 14:48:54 +00: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) {
|
2015-07-08 12:41:47 +00:00
|
|
|
if (suspended)
|
2014-04-30 12:19:04 +00:00
|
|
|
WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
|
|
|
|
else
|
|
|
|
WARN(1, "Hardware became unavailable during restart.\n");
|
|
|
|
ieee80211_handle_reconfig_failure(local);
|
2011-07-14 14:48:54 +00:00
|
|
|
return res;
|
2009-04-14 08:09:24 +00:00
|
|
|
}
|
|
|
|
|
2011-12-30 11:04:25 +00: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 14:48:54 +00:00
|
|
|
ieee80211_led_radio(local, true);
|
|
|
|
ieee80211_mod_tpt_led_trig(local,
|
|
|
|
IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
|
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
/* add interfaces */
|
2012-04-03 12:35:57 +00:00
|
|
|
sdata = rtnl_dereference(local->monitor_sdata);
|
|
|
|
if (sdata) {
|
2013-03-27 22:20:27 +00:00
|
|
|
/* in HW restart it exists already */
|
|
|
|
WARN_ON(local->resuming);
|
2012-04-03 12:35:57 +00:00
|
|
|
res = drv_add_interface(local, sdata);
|
|
|
|
if (WARN_ON(res)) {
|
2014-03-23 19:21:43 +00:00
|
|
|
RCU_INIT_POINTER(local->monitor_sdata, NULL);
|
2012-04-03 12:35:57 +00:00
|
|
|
synchronize_net();
|
|
|
|
kfree(sdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
2015-03-01 07:10:04 +00:00
|
|
|
ieee80211_sdata_running(sdata)) {
|
2011-11-03 13:41:13 +00:00
|
|
|
res = drv_add_interface(local, sdata);
|
2015-03-01 07:10:04 +00:00
|
|
|
if (WARN_ON(res))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If adding any of the interfaces failed above, roll back and
|
|
|
|
* report failure.
|
|
|
|
*/
|
|
|
|
if (res) {
|
|
|
|
list_for_each_entry_continue_reverse(sdata, &local->interfaces,
|
|
|
|
list)
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
|
|
|
ieee80211_sdata_running(sdata))
|
|
|
|
drv_remove_interface(local, sdata);
|
|
|
|
ieee80211_handle_reconfig_failure(local);
|
|
|
|
return res;
|
2009-04-14 08:09:24 +00:00
|
|
|
}
|
|
|
|
|
2012-07-26 15:24:39 +00:00
|
|
|
/* add channel contexts */
|
2012-11-19 11:01:05 +00:00
|
|
|
if (local->use_chanctx) {
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list)
|
2014-06-25 10:35:06 +00:00
|
|
|
if (ctx->replace_state !=
|
|
|
|
IEEE80211_CHANCTX_REPLACES_OTHER)
|
|
|
|
WARN_ON(drv_add_chanctx(local, ctx));
|
2012-11-19 11:01:05 +00:00
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
2012-07-26 15:24:39 +00:00
|
|
|
|
2014-04-26 01:43:40 +00:00
|
|
|
sdata = rtnl_dereference(local->monitor_sdata);
|
|
|
|
if (sdata && ieee80211_sdata_running(sdata))
|
|
|
|
ieee80211_assign_chanctx(local, sdata);
|
|
|
|
}
|
2012-11-19 21:19:08 +00:00
|
|
|
|
2009-04-14 08:09:24 +00: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 07:44:02 +00:00
|
|
|
u32 changed;
|
|
|
|
|
2009-12-23 12:15:31 +00:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2009-04-14 08:09:24 +00:00
|
|
|
continue;
|
2010-05-05 07:44:02 +00:00
|
|
|
|
2015-12-08 14:04:39 +00:00
|
|
|
ieee80211_assign_chanctx(local, sdata);
|
|
|
|
|
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
break;
|
2019-02-06 11:17:12 +00:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
if (sdata->vif.bss_conf.ibss_joined)
|
|
|
|
WARN_ON(drv_join_ibss(local, sdata));
|
|
|
|
/* fall through */
|
2015-12-08 14:04:39 +00:00
|
|
|
default:
|
|
|
|
ieee80211_reconfig_stations(sdata);
|
|
|
|
/* fall through */
|
|
|
|
case NL80211_IFTYPE_AP: /* AP stations are handled later */
|
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++)
|
|
|
|
drv_conf_tx(local, sdata, i,
|
|
|
|
&sdata->tx_conf[i]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-05-05 07:44:02 +00: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 14:39:04 +00:00
|
|
|
BSS_CHANGED_CQM |
|
2011-11-01 13:16:55 +00:00
|
|
|
BSS_CHANGED_QOS |
|
2012-10-24 08:59:25 +00:00
|
|
|
BSS_CHANGED_IDLE |
|
2018-03-22 19:18:03 +00:00
|
|
|
BSS_CHANGED_TXPOWER |
|
|
|
|
BSS_CHANGED_MCAST_RATE;
|
2010-05-05 07:44:02 +00:00
|
|
|
|
2016-02-16 10:48:18 +00:00
|
|
|
if (sdata->vif.mu_mimo_owner)
|
2015-12-08 14:04:31 +00:00
|
|
|
changed |= BSS_CHANGED_MU_GROUPS;
|
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
2011-12-12 12:10:49 +00:00
|
|
|
changed |= BSS_CHANGED_ASSOC |
|
2012-07-27 09:33:22 +00:00
|
|
|
BSS_CHANGED_ARP_FILTER |
|
|
|
|
BSS_CHANGED_PS;
|
2012-12-12 08:12:24 +00:00
|
|
|
|
2013-05-16 14:34:17 +00:00
|
|
|
/* Re-send beacon info report to the driver */
|
|
|
|
if (sdata->u.mgd.have_beacon)
|
|
|
|
changed |= BSS_CHANGED_BEACON_INFO;
|
2012-12-12 08:12:24 +00:00
|
|
|
|
2017-04-26 07:58:47 +00:00
|
|
|
if (sdata->vif.bss_conf.max_idle_period ||
|
|
|
|
sdata->vif.bss_conf.protected_keep_alive)
|
|
|
|
changed |= BSS_CHANGED_KEEP_ALIVE;
|
|
|
|
|
2013-05-10 10:32:47 +00:00
|
|
|
sdata_lock(sdata);
|
2010-05-05 07:44:02 +00:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2013-05-10 10:32:47 +00:00
|
|
|
sdata_unlock(sdata);
|
2010-05-05 07:44:02 +00:00
|
|
|
break;
|
2014-11-03 09:33:18 +00:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2014-11-03 09:33:19 +00:00
|
|
|
changed |= BSS_CHANGED_OCB;
|
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2014-11-03 09:33:18 +00:00
|
|
|
break;
|
2009-04-14 08:09:24 +00:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2010-05-05 07:44:02 +00:00
|
|
|
changed |= BSS_CHANGED_IBSS;
|
|
|
|
/* fall through */
|
2009-04-14 08:09:24 +00:00
|
|
|
case NL80211_IFTYPE_AP:
|
2012-11-14 14:21:17 +00:00
|
|
|
changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
|
2011-11-22 17:33:18 +00:00
|
|
|
|
2018-10-04 03:19:20 +00:00
|
|
|
if (sdata->vif.bss_conf.ftm_responder == 1 &&
|
|
|
|
wiphy_ext_feature_isset(sdata->local->hw.wiphy,
|
|
|
|
NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
|
|
|
|
changed |= BSS_CHANGED_FTM_RESPONDER;
|
|
|
|
|
2012-10-19 13:44:42 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
2011-11-22 17:33:18 +00:00
|
|
|
changed |= BSS_CHANGED_AP_PROBE_RESP;
|
|
|
|
|
2012-10-19 13:44:42 +00:00
|
|
|
if (rcu_access_pointer(sdata->u.ap.beacon))
|
|
|
|
drv_start_ap(local, sdata);
|
|
|
|
}
|
|
|
|
|
2011-09-04 08:11:32 +00:00
|
|
|
/* fall through */
|
2009-04-14 08:09:24 +00:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2012-12-14 13:17:26 +00:00
|
|
|
if (sdata->vif.bss_conf.enable_beacon) {
|
|
|
|
changed |= BSS_CHANGED_BEACON |
|
|
|
|
BSS_CHANGED_BEACON_ENABLED;
|
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
|
|
|
}
|
2009-04-14 08:09:24 +00:00
|
|
|
break;
|
2016-09-20 14:31:20 +00:00
|
|
|
case NL80211_IFTYPE_NAN:
|
|
|
|
res = ieee80211_reconfig_nan(sdata);
|
|
|
|
if (res < 0) {
|
|
|
|
ieee80211_handle_reconfig_failure(local);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
break;
|
2009-04-14 08:09:24 +00:00
|
|
|
case NL80211_IFTYPE_WDS:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
2012-06-15 22:19:54 +00:00
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
2014-04-26 01:43:41 +00:00
|
|
|
/* nothing to do */
|
2012-06-18 18:07:15 +00:00
|
|
|
break;
|
2009-04-14 08:09:24 +00:00
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
2010-08-12 13:38:38 +00:00
|
|
|
case NUM_NL80211_IFTYPES:
|
2010-09-16 12:58:23 +00:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2009-04-14 08:09:24 +00:00
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-14 16:02:43 +00:00
|
|
|
ieee80211_recalc_ps(local);
|
2011-11-09 10:29:06 +00:00
|
|
|
|
2012-01-26 11:36:05 +00:00
|
|
|
/*
|
|
|
|
* The sta might be in psm against the ap (e.g. because
|
|
|
|
* this was the state before a hw restart), so we
|
|
|
|
* explicitly send a null packet in order to make sure
|
|
|
|
* it'll sync against the ap (and get out of psm).
|
|
|
|
*/
|
|
|
|
if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
continue;
|
2012-11-08 13:06:28 +00:00
|
|
|
if (!sdata->u.mgd.associated)
|
|
|
|
continue;
|
2012-01-26 11:36:05 +00:00
|
|
|
|
2015-09-24 14:14:55 +00:00
|
|
|
ieee80211_send_nullfunc(local, sdata, false);
|
2012-01-26 11:36:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-03 20:31:56 +00:00
|
|
|
/* APs are now beaconing, add back stations */
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
|
|
|
enum ieee80211_sta_state state;
|
|
|
|
|
|
|
|
if (!sta->uploaded)
|
|
|
|
continue;
|
|
|
|
|
2018-07-02 10:10:14 +00:00
|
|
|
if (sta->sdata->vif.type != NL80211_IFTYPE_AP &&
|
|
|
|
sta->sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
|
2012-06-03 20:31:56 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
for (state = IEEE80211_STA_NOTEXIST;
|
|
|
|
state < sta->sta_state; state++)
|
|
|
|
WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
|
|
|
|
state + 1));
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
|
2012-05-29 09:00:22 +00:00
|
|
|
/* add back keys */
|
2015-05-13 09:16:48 +00:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list)
|
|
|
|
ieee80211_reset_crypto_tx_tailroom(sdata);
|
|
|
|
|
2012-05-29 09:00:22 +00:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list)
|
|
|
|
if (ieee80211_sdata_running(sdata))
|
|
|
|
ieee80211_enable_keys(sdata);
|
|
|
|
|
2015-10-25 08:59:33 +00:00
|
|
|
/* Reconfigure sched scan if it was interrupted by FW restart */
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
|
|
|
|
lockdep_is_held(&local->mtx));
|
|
|
|
sched_scan_req = rcu_dereference_protected(local->sched_scan_req,
|
|
|
|
lockdep_is_held(&local->mtx));
|
|
|
|
if (sched_scan_sdata && sched_scan_req)
|
|
|
|
/*
|
|
|
|
* Sched scan stopped, but we don't want to report it. Instead,
|
|
|
|
* we're trying to reschedule. However, if more than one scan
|
|
|
|
* plan was set, we cannot reschedule since we don't know which
|
|
|
|
* scan plan was currently running (and some scan plans may have
|
|
|
|
* already finished).
|
|
|
|
*/
|
|
|
|
if (sched_scan_req->n_scan_plans > 1 ||
|
|
|
|
__ieee80211_request_sched_scan_start(sched_scan_sdata,
|
2015-12-16 13:45:45 +00:00
|
|
|
sched_scan_req)) {
|
|
|
|
RCU_INIT_POINTER(local->sched_scan_sdata, NULL);
|
|
|
|
RCU_INIT_POINTER(local->sched_scan_req, NULL);
|
2015-10-25 08:59:33 +00:00
|
|
|
sched_scan_stopped = true;
|
2015-12-16 13:45:45 +00:00
|
|
|
}
|
2015-10-25 08:59:33 +00:00
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
if (sched_scan_stopped)
|
2017-04-28 12:40:28 +00:00
|
|
|
cfg80211_sched_scan_stopped_rtnl(local->hw.wiphy, 0);
|
2015-10-25 08:59:33 +00:00
|
|
|
|
2012-07-02 12:08:25 +00:00
|
|
|
wake_up:
|
2012-06-06 08:25:02 +00:00
|
|
|
|
2013-03-27 22:20:27 +00:00
|
|
|
if (local->monitors == local->open_count && local->monitors > 0)
|
|
|
|
ieee80211_add_virtual_monitor(local);
|
|
|
|
|
2010-06-10 08:21:29 +00: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.
|
|
|
|
*/
|
2015-06-02 19:39:54 +00:00
|
|
|
if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) {
|
2010-06-10 08:21:29 +00:00
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
|
|
|
|
list_for_each_entry(sta, &local->sta_list, list) {
|
2015-09-21 12:50:26 +00:00
|
|
|
if (!local->resuming)
|
|
|
|
ieee80211_sta_tear_down_BA_sessions(
|
|
|
|
sta, AGG_STOP_LOCAL_REQUEST);
|
2011-09-29 14:04:36 +00:00
|
|
|
clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
|
2010-02-03 17:28:55 +00:00
|
|
|
}
|
2010-06-10 08:21:29 +00:00
|
|
|
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
2010-02-03 17:28:55 +00:00
|
|
|
}
|
|
|
|
|
2017-10-29 09:51:08 +00:00
|
|
|
if (local->in_reconfig) {
|
|
|
|
local->in_reconfig = false;
|
|
|
|
barrier();
|
|
|
|
|
|
|
|
/* Restart deferred ROCs */
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_start_next_roc(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
}
|
|
|
|
|
2013-02-13 11:25:28 +00:00
|
|
|
ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_SUSPEND,
|
|
|
|
false);
|
2009-04-14 08:09:24 +00:00
|
|
|
|
2009-05-17 09:40:42 +00:00
|
|
|
/*
|
|
|
|
* If this is for hw restart things are still running.
|
|
|
|
* We may want to change that later, however.
|
|
|
|
*/
|
2015-07-08 12:41:47 +00:00
|
|
|
if (local->open_count && (!suspended || reconfig_due_to_wowlan))
|
2014-11-04 09:43:54 +00:00
|
|
|
drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
|
2013-01-10 23:28:01 +00:00
|
|
|
|
2015-07-08 12:41:47 +00:00
|
|
|
if (!suspended)
|
2009-05-17 09:40:42 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
2009-11-19 13:29:39 +00:00
|
|
|
/* first set suspended false, then resuming */
|
2009-05-17 09:40:42 +00:00
|
|
|
local->suspended = false;
|
2009-11-19 13:29:39 +00:00
|
|
|
mb();
|
|
|
|
local->resuming = false;
|
2009-05-17 09:40:42 +00:00
|
|
|
|
2015-12-08 14:04:38 +00:00
|
|
|
ieee80211_flush_completed_scan(local, false);
|
2015-01-24 08:30:02 +00:00
|
|
|
|
2014-12-14 09:05:53 +00:00
|
|
|
if (local->open_count && !reconfig_due_to_wowlan)
|
2014-11-04 09:43:54 +00:00
|
|
|
drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND);
|
|
|
|
|
2013-04-29 12:57:44 +00:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
ieee80211_sta_restart(sdata);
|
|
|
|
}
|
|
|
|
|
2011-04-01 11:52:48 +00:00
|
|
|
mod_timer(&local->sta_cleanup, jiffies + 1);
|
2009-05-17 09:40:42 +00:00
|
|
|
#else
|
|
|
|
WARN_ON(1);
|
|
|
|
#endif
|
2013-12-08 19:48:57 +00:00
|
|
|
|
2009-04-14 08:09:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2009-07-30 00:08:07 +00:00
|
|
|
|
2011-07-12 10:30:59 +00:00
|
|
|
void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_key *key;
|
|
|
|
|
|
|
|
if (WARN_ON(!vif))
|
|
|
|
return;
|
|
|
|
|
|
|
|
sdata = vif_to_sdata(vif);
|
|
|
|
local = sdata->local;
|
|
|
|
|
|
|
|
if (WARN_ON(!local->resuming))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
|
|
|
|
return;
|
|
|
|
|
|
|
|
sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
|
|
|
|
|
|
|
|
mutex_lock(&local->key_mtx);
|
|
|
|
list_for_each_entry(key, &sdata->key_list, list)
|
|
|
|
key->flags |= KEY_FLAG_TAINTED;
|
|
|
|
mutex_unlock(&local->key_mtx);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
|
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
|
2009-12-01 12:37:02 +00:00
|
|
|
{
|
2012-09-11 12:34:12 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_chanctx *chanctx;
|
2010-10-05 08:41:47 +00:00
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
mutex_lock(&local->chanctx_mtx);
|
2009-12-01 12:37:02 +00:00
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
|
|
|
|
lockdep_is_held(&local->chanctx_mtx));
|
2009-12-01 12:37:02 +00:00
|
|
|
|
2015-10-25 08:59:40 +00:00
|
|
|
/*
|
|
|
|
* This function can be called from a work, thus it may be possible
|
|
|
|
* that the chanctx_conf is removed (due to a disconnection, for
|
|
|
|
* example).
|
|
|
|
* So nothing should be done in such case.
|
|
|
|
*/
|
|
|
|
if (!chanctx_conf)
|
2012-09-11 08:17:11 +00:00
|
|
|
goto unlock;
|
2009-12-01 12:37:02 +00:00
|
|
|
|
2012-09-11 12:34:12 +00:00
|
|
|
chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
|
|
|
|
ieee80211_recalc_smps_chanctx(local, chanctx);
|
2012-09-11 08:17:11 +00:00
|
|
|
unlock:
|
2012-09-11 12:34:12 +00:00
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
2009-12-01 12:37:02 +00:00
|
|
|
}
|
2009-12-23 12:15:38 +00:00
|
|
|
|
2013-11-11 18:14:01 +00:00
|
|
|
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
struct ieee80211_chanctx *chanctx;
|
|
|
|
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
|
|
|
|
lockdep_is_held(&local->chanctx_mtx));
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!chanctx_conf))
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
|
|
|
|
ieee80211_recalc_chanctx_min_def(local, chanctx);
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
}
|
|
|
|
|
2009-12-23 12:15:38 +00:00
|
|
|
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 15:46:22 +00: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 11:12:51 +00:00
|
|
|
|
2011-11-18 19:32:00 +00:00
|
|
|
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2011-10-26 21:47:26 +00: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 19:32:00 +00:00
|
|
|
*pos++ = ht_cap->ampdu_factor |
|
|
|
|
(ht_cap->ampdu_density <<
|
2011-10-26 21:47:26 +00:00
|
|
|
IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
|
|
|
|
|
|
|
|
/* MCS set */
|
2011-11-18 19:32:00 +00:00
|
|
|
memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
|
|
|
|
pos += sizeof(ht_cap->mcs);
|
2011-10-26 21:47:26 +00:00
|
|
|
|
|
|
|
/* extended capabilities */
|
|
|
|
pos += sizeof(__le16);
|
|
|
|
|
|
|
|
/* BF capabilities */
|
|
|
|
pos += sizeof(__le32);
|
|
|
|
|
|
|
|
/* antenna selection */
|
|
|
|
pos += sizeof(u8);
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2012-07-02 11:25:12 +00:00
|
|
|
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
|
2012-12-07 11:45:06 +00:00
|
|
|
u32 cap)
|
2012-07-02 11:25:12 +00:00
|
|
|
{
|
|
|
|
__le32 tmp;
|
|
|
|
|
|
|
|
*pos++ = WLAN_EID_VHT_CAPABILITY;
|
2012-10-10 11:25:40 +00:00
|
|
|
*pos++ = sizeof(struct ieee80211_vht_cap);
|
|
|
|
memset(pos, 0, sizeof(struct ieee80211_vht_cap));
|
2012-07-02 11:25:12 +00:00
|
|
|
|
|
|
|
/* capability flags */
|
|
|
|
tmp = cpu_to_le32(cap);
|
|
|
|
memcpy(pos, &tmp, sizeof(u32));
|
|
|
|
pos += sizeof(u32);
|
|
|
|
|
|
|
|
/* VHT MCS set */
|
|
|
|
memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
|
|
|
|
pos += sizeof(vht_cap->vht_mcs);
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2018-06-09 06:14:44 +00:00
|
|
|
u8 *ieee80211_ie_build_he_cap(u8 *pos,
|
|
|
|
const struct ieee80211_sta_he_cap *he_cap,
|
|
|
|
u8 *end)
|
|
|
|
{
|
|
|
|
u8 n;
|
|
|
|
u8 ie_len;
|
|
|
|
u8 *orig_pos = pos;
|
|
|
|
|
|
|
|
/* Make sure we have place for the IE */
|
|
|
|
/*
|
|
|
|
* TODO: the 1 added is because this temporarily is under the EXTENSION
|
|
|
|
* IE. Get rid of it when it moves.
|
|
|
|
*/
|
|
|
|
if (!he_cap)
|
|
|
|
return orig_pos;
|
|
|
|
|
|
|
|
n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
|
|
|
|
ie_len = 2 + 1 +
|
|
|
|
sizeof(he_cap->he_cap_elem) + n +
|
|
|
|
ieee80211_he_ppe_size(he_cap->ppe_thres[0],
|
|
|
|
he_cap->he_cap_elem.phy_cap_info);
|
|
|
|
|
|
|
|
if ((end - pos) < ie_len)
|
|
|
|
return orig_pos;
|
|
|
|
|
|
|
|
*pos++ = WLAN_EID_EXTENSION;
|
|
|
|
pos++; /* We'll set the size later below */
|
|
|
|
*pos++ = WLAN_EID_EXT_HE_CAPABILITY;
|
|
|
|
|
|
|
|
/* Fixed data */
|
|
|
|
memcpy(pos, &he_cap->he_cap_elem, sizeof(he_cap->he_cap_elem));
|
|
|
|
pos += sizeof(he_cap->he_cap_elem);
|
|
|
|
|
|
|
|
memcpy(pos, &he_cap->he_mcs_nss_supp, n);
|
|
|
|
pos += n;
|
|
|
|
|
|
|
|
/* Check if PPE Threshold should be present */
|
|
|
|
if ((he_cap->he_cap_elem.phy_cap_info[6] &
|
|
|
|
IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate how many PPET16/PPET8 pairs are to come. Algorithm:
|
|
|
|
* (NSS_M1 + 1) x (num of 1 bits in RU_INDEX_BITMASK)
|
|
|
|
*/
|
|
|
|
n = hweight8(he_cap->ppe_thres[0] &
|
|
|
|
IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
|
|
|
|
n *= (1 + ((he_cap->ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) >>
|
|
|
|
IEEE80211_PPE_THRES_NSS_POS));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each pair is 6 bits, and we need to add the 7 "header" bits to the
|
|
|
|
* total size.
|
|
|
|
*/
|
|
|
|
n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7;
|
|
|
|
n = DIV_ROUND_UP(n, 8);
|
|
|
|
|
|
|
|
/* Copy PPE Thresholds */
|
|
|
|
memcpy(pos, &he_cap->ppe_thres, n);
|
|
|
|
pos += n;
|
|
|
|
|
|
|
|
end:
|
|
|
|
orig_pos[1] = (pos - orig_pos) - 2;
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2012-03-15 18:45:16 +00:00
|
|
|
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
|
2012-11-09 10:39:59 +00:00
|
|
|
const struct cfg80211_chan_def *chandef,
|
2015-10-25 08:59:34 +00:00
|
|
|
u16 prot_mode, bool rifs_mode)
|
2011-10-26 21:47:26 +00:00
|
|
|
{
|
2012-03-15 18:45:16 +00:00
|
|
|
struct ieee80211_ht_operation *ht_oper;
|
2011-10-26 21:47:26 +00:00
|
|
|
/* Build HT Information */
|
2012-03-15 18:45:16 +00:00
|
|
|
*pos++ = WLAN_EID_HT_OPERATION;
|
|
|
|
*pos++ = sizeof(struct ieee80211_ht_operation);
|
|
|
|
ht_oper = (struct ieee80211_ht_operation *)pos;
|
2012-11-09 10:39:59 +00:00
|
|
|
ht_oper->primary_chan = ieee80211_frequency_to_channel(
|
|
|
|
chandef->chan->center_freq);
|
|
|
|
switch (chandef->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_160:
|
|
|
|
case NL80211_CHAN_WIDTH_80P80:
|
|
|
|
case NL80211_CHAN_WIDTH_80:
|
|
|
|
case NL80211_CHAN_WIDTH_40:
|
|
|
|
if (chandef->center_freq1 > chandef->chan->center_freq)
|
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
|
|
|
else
|
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
2011-10-26 21:47:26 +00:00
|
|
|
break;
|
|
|
|
default:
|
2012-03-15 18:45:16 +00:00
|
|
|
ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
|
2011-10-26 21:47:26 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-04-19 02:24:14 +00:00
|
|
|
if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
|
2012-11-09 10:39:59 +00:00
|
|
|
chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
|
|
|
|
chandef->width != NL80211_CHAN_WIDTH_20)
|
2012-03-15 18:45:16 +00:00
|
|
|
ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
|
2011-11-30 15:56:33 +00:00
|
|
|
|
2015-10-25 08:59:34 +00:00
|
|
|
if (rifs_mode)
|
|
|
|
ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
|
|
|
|
|
2012-04-30 21:20:29 +00:00
|
|
|
ht_oper->operation_mode = cpu_to_le16(prot_mode);
|
2012-03-15 18:45:16 +00:00
|
|
|
ht_oper->stbc_param = 0x0000;
|
2011-10-26 21:47:26 +00:00
|
|
|
|
|
|
|
/* It seems that Basic MCS set and Supported MCS set
|
|
|
|
are identical for the first 10 bytes */
|
2012-03-15 18:45:16 +00:00
|
|
|
memset(&ht_oper->basic_set, 0, 16);
|
|
|
|
memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
|
2011-10-26 21:47:26 +00:00
|
|
|
|
2012-03-15 18:45:16 +00:00
|
|
|
return pos + sizeof(struct ieee80211_ht_operation);
|
2011-10-26 21:47:26 +00:00
|
|
|
}
|
|
|
|
|
2017-05-23 15:00:42 +00:00
|
|
|
void ieee80211_ie_build_wide_bw_cs(u8 *pos,
|
|
|
|
const struct cfg80211_chan_def *chandef)
|
|
|
|
{
|
|
|
|
*pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH; /* EID */
|
|
|
|
*pos++ = 3; /* IE length */
|
|
|
|
/* New channel width */
|
|
|
|
switch (chandef->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_80:
|
|
|
|
*pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_160:
|
|
|
|
*pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80P80:
|
|
|
|
*pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* new center frequency segment 0 */
|
|
|
|
*pos++ = ieee80211_frequency_to_channel(chandef->center_freq1);
|
|
|
|
/* new center frequency segment 1 */
|
|
|
|
if (chandef->center_freq2)
|
|
|
|
*pos++ = ieee80211_frequency_to_channel(chandef->center_freq2);
|
|
|
|
else
|
|
|
|
*pos++ = 0;
|
|
|
|
}
|
|
|
|
|
2015-03-01 07:10:02 +00:00
|
|
|
u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
|
|
|
|
const struct cfg80211_chan_def *chandef)
|
|
|
|
{
|
|
|
|
struct ieee80211_vht_operation *vht_oper;
|
|
|
|
|
|
|
|
*pos++ = WLAN_EID_VHT_OPERATION;
|
|
|
|
*pos++ = sizeof(struct ieee80211_vht_operation);
|
|
|
|
vht_oper = (struct ieee80211_vht_operation *)pos;
|
2017-02-15 14:02:06 +00:00
|
|
|
vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel(
|
2015-03-01 07:10:02 +00:00
|
|
|
chandef->center_freq1);
|
|
|
|
if (chandef->center_freq2)
|
2017-02-15 14:02:06 +00:00
|
|
|
vht_oper->center_freq_seg1_idx =
|
2015-03-01 07:10:02 +00:00
|
|
|
ieee80211_frequency_to_channel(chandef->center_freq2);
|
2015-09-04 02:58:05 +00:00
|
|
|
else
|
2017-02-15 14:02:06 +00:00
|
|
|
vht_oper->center_freq_seg1_idx = 0x00;
|
2015-03-01 07:10:02 +00:00
|
|
|
|
|
|
|
switch (chandef->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_160:
|
2016-02-01 09:40:55 +00:00
|
|
|
/*
|
|
|
|
* Convert 160 MHz channel width to new style as interop
|
|
|
|
* workaround.
|
|
|
|
*/
|
|
|
|
vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
|
2017-02-15 14:02:06 +00:00
|
|
|
vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx;
|
2016-02-01 09:40:55 +00:00
|
|
|
if (chandef->chan->center_freq < chandef->center_freq1)
|
2017-02-15 14:02:06 +00:00
|
|
|
vht_oper->center_freq_seg0_idx -= 8;
|
2016-02-01 09:40:55 +00:00
|
|
|
else
|
2017-02-15 14:02:06 +00:00
|
|
|
vht_oper->center_freq_seg0_idx += 8;
|
2015-03-01 07:10:02 +00:00
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80P80:
|
2016-02-01 09:40:55 +00:00
|
|
|
/*
|
|
|
|
* Convert 80+80 MHz channel width to new style as interop
|
|
|
|
* workaround.
|
|
|
|
*/
|
|
|
|
vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
|
2015-03-01 07:10:02 +00:00
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80:
|
|
|
|
vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* don't require special VHT peer rates */
|
|
|
|
vht_oper->basic_mcs_set = cpu_to_le16(0xffff);
|
|
|
|
|
|
|
|
return pos + sizeof(struct ieee80211_vht_operation);
|
|
|
|
}
|
|
|
|
|
2015-12-18 14:08:34 +00:00
|
|
|
bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
|
|
|
|
struct cfg80211_chan_def *chandef)
|
2011-10-26 21:47:26 +00:00
|
|
|
{
|
|
|
|
enum nl80211_channel_type channel_type;
|
|
|
|
|
2015-12-18 14:08:34 +00:00
|
|
|
if (!ht_oper)
|
|
|
|
return false;
|
2011-10-26 21:47:26 +00:00
|
|
|
|
2012-03-15 18:45:16 +00:00
|
|
|
switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
|
2011-10-26 21:47:26 +00: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;
|
2015-12-18 14:08:34 +00:00
|
|
|
return false;
|
2011-10-26 21:47:26 +00:00
|
|
|
}
|
|
|
|
|
2015-12-18 14:08:34 +00:00
|
|
|
cfg80211_chandef_create(chandef, chandef->chan, channel_type);
|
|
|
|
return true;
|
2011-10-26 21:47:26 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 08:31:18 +00:00
|
|
|
bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw,
|
|
|
|
const struct ieee80211_vht_operation *oper,
|
|
|
|
const struct ieee80211_ht_operation *htop,
|
2015-12-18 14:08:34 +00:00
|
|
|
struct cfg80211_chan_def *chandef)
|
2015-03-20 05:37:01 +00:00
|
|
|
{
|
2015-12-18 14:08:34 +00:00
|
|
|
struct cfg80211_chan_def new = *chandef;
|
2018-08-31 08:31:18 +00:00
|
|
|
int cf0, cf1;
|
|
|
|
int ccfs0, ccfs1, ccfs2;
|
|
|
|
int ccf0, ccf1;
|
2015-12-18 14:08:34 +00:00
|
|
|
|
2018-08-31 08:31:18 +00:00
|
|
|
if (!oper || !htop)
|
2015-12-18 14:08:34 +00:00
|
|
|
return false;
|
2015-03-20 05:37:01 +00:00
|
|
|
|
2018-08-31 08:31:18 +00:00
|
|
|
ccfs0 = oper->center_freq_seg0_idx;
|
|
|
|
ccfs1 = oper->center_freq_seg1_idx;
|
|
|
|
ccfs2 = (le16_to_cpu(htop->operation_mode) &
|
|
|
|
IEEE80211_HT_OP_MODE_CCFS2_MASK)
|
|
|
|
>> IEEE80211_HT_OP_MODE_CCFS2_SHIFT;
|
|
|
|
|
|
|
|
/* when parsing (and we know how to) CCFS1 and CCFS2 are equivalent */
|
|
|
|
ccf0 = ccfs0;
|
|
|
|
ccf1 = ccfs1;
|
|
|
|
if (!ccfs1 && ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW))
|
|
|
|
ccf1 = ccfs2;
|
|
|
|
|
|
|
|
cf0 = ieee80211_channel_to_frequency(ccf0, chandef->chan->band);
|
|
|
|
cf1 = ieee80211_channel_to_frequency(ccf1, chandef->chan->band);
|
2015-03-20 05:37:01 +00:00
|
|
|
|
|
|
|
switch (oper->chan_width) {
|
|
|
|
case IEEE80211_VHT_CHANWIDTH_USE_HT:
|
2018-08-31 08:31:18 +00:00
|
|
|
/* just use HT information directly */
|
2015-03-20 05:37:01 +00:00
|
|
|
break;
|
|
|
|
case IEEE80211_VHT_CHANWIDTH_80MHZ:
|
2015-12-18 14:08:34 +00:00
|
|
|
new.width = NL80211_CHAN_WIDTH_80;
|
2018-08-31 08:31:18 +00:00
|
|
|
new.center_freq1 = cf0;
|
2016-02-01 09:40:55 +00:00
|
|
|
/* If needed, adjust based on the newer interop workaround. */
|
2018-08-31 08:31:18 +00:00
|
|
|
if (ccf1) {
|
2016-02-01 09:40:55 +00:00
|
|
|
unsigned int diff;
|
|
|
|
|
2018-08-31 08:31:18 +00:00
|
|
|
diff = abs(ccf1 - ccf0);
|
2016-02-01 09:40:55 +00:00
|
|
|
if (diff == 8) {
|
|
|
|
new.width = NL80211_CHAN_WIDTH_160;
|
2018-08-31 08:31:18 +00:00
|
|
|
new.center_freq1 = cf1;
|
2016-02-01 09:40:55 +00:00
|
|
|
} else if (diff > 8) {
|
|
|
|
new.width = NL80211_CHAN_WIDTH_80P80;
|
2018-08-31 08:31:18 +00:00
|
|
|
new.center_freq2 = cf1;
|
2016-02-01 09:40:55 +00:00
|
|
|
}
|
|
|
|
}
|
2015-03-20 05:37:01 +00:00
|
|
|
break;
|
|
|
|
case IEEE80211_VHT_CHANWIDTH_160MHZ:
|
2018-08-31 08:31:18 +00:00
|
|
|
/* deprecated encoding */
|
2015-12-18 14:08:34 +00:00
|
|
|
new.width = NL80211_CHAN_WIDTH_160;
|
2018-08-31 08:31:18 +00:00
|
|
|
new.center_freq1 = cf0;
|
2015-03-20 05:37:01 +00:00
|
|
|
break;
|
|
|
|
case IEEE80211_VHT_CHANWIDTH_80P80MHZ:
|
2018-08-31 08:31:18 +00:00
|
|
|
/* deprecated encoding */
|
2015-12-18 14:08:34 +00:00
|
|
|
new.width = NL80211_CHAN_WIDTH_80P80;
|
2018-08-31 08:31:18 +00:00
|
|
|
new.center_freq1 = cf0;
|
|
|
|
new.center_freq2 = cf1;
|
2015-03-20 05:37:01 +00:00
|
|
|
break;
|
|
|
|
default:
|
2015-12-18 14:08:34 +00:00
|
|
|
return false;
|
2015-03-20 05:37:01 +00:00
|
|
|
}
|
|
|
|
|
2015-12-18 14:08:34 +00:00
|
|
|
if (!cfg80211_chandef_valid(&new))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*chandef = new;
|
|
|
|
return true;
|
2015-03-20 05:37:01 +00:00
|
|
|
}
|
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
|
|
|
|
const struct ieee80211_supported_band *sband,
|
|
|
|
const u8 *srates, int srates_len, u32 *rates)
|
|
|
|
{
|
|
|
|
u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
|
|
|
|
int shift = ieee80211_chandef_get_shift(chandef);
|
|
|
|
struct ieee80211_rate *br;
|
|
|
|
int brate, rate, i, j, count = 0;
|
|
|
|
|
|
|
|
*rates = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < srates_len; i++) {
|
|
|
|
rate = srates[i] & 0x7f;
|
|
|
|
|
|
|
|
for (j = 0; j < sband->n_bitrates; j++) {
|
|
|
|
br = &sband->bitrates[j];
|
|
|
|
if ((rate_flags & br->flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
|
|
|
|
if (brate == rate) {
|
|
|
|
*rates |= BIT(j);
|
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2012-06-28 08:33:25 +00:00
|
|
|
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
|
2012-07-23 12:53:27 +00:00
|
|
|
struct sk_buff *skb, bool need_basic,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band)
|
2011-09-28 11:12:51 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2013-07-08 14:55:53 +00:00
|
|
|
int rate, shift;
|
2011-09-28 11:12:51 +00:00
|
|
|
u8 i, rates, *pos;
|
2012-06-28 08:33:25 +00:00
|
|
|
u32 basic_rates = sdata->vif.bss_conf.basic_rates;
|
2013-07-08 14:55:53 +00:00
|
|
|
u32 rate_flags;
|
2011-09-28 11:12:51 +00:00
|
|
|
|
2013-07-08 14:55:53 +00:00
|
|
|
shift = ieee80211_vif_get_shift(&sdata->vif);
|
|
|
|
rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
|
2012-07-23 12:53:27 +00:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2013-07-08 14:55:53 +00:00
|
|
|
rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
rates++;
|
|
|
|
}
|
2011-09-28 11:12:51 +00:00
|
|
|
if (rates > 8)
|
|
|
|
rates = 8;
|
|
|
|
|
|
|
|
if (skb_tailroom(skb) < rates + 2)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pos = skb_put(skb, rates + 2);
|
|
|
|
*pos++ = WLAN_EID_SUPP_RATES;
|
|
|
|
*pos++ = rates;
|
|
|
|
for (i = 0; i < rates; i++) {
|
2012-04-03 04:21:20 +00:00
|
|
|
u8 basic = 0;
|
2013-07-08 14:55:53 +00:00
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
|
2012-04-03 04:21:20 +00:00
|
|
|
if (need_basic && basic_rates & BIT(i))
|
|
|
|
basic = 0x80;
|
2013-07-08 14:55:53 +00:00
|
|
|
rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
|
|
|
|
5 * (1 << shift));
|
|
|
|
*pos++ = basic | (u8) rate;
|
2011-09-28 11:12:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-28 08:33:25 +00:00
|
|
|
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
|
2012-07-23 12:53:27 +00:00
|
|
|
struct sk_buff *skb, bool need_basic,
|
2016-04-12 13:56:15 +00:00
|
|
|
enum nl80211_band band)
|
2011-09-28 11:12:51 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
2013-09-08 06:40:44 +00:00
|
|
|
int rate, shift;
|
2011-09-28 11:12:51 +00:00
|
|
|
u8 i, exrates, *pos;
|
2012-06-28 08:33:25 +00:00
|
|
|
u32 basic_rates = sdata->vif.bss_conf.basic_rates;
|
2013-07-08 14:55:53 +00:00
|
|
|
u32 rate_flags;
|
|
|
|
|
|
|
|
rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
|
|
|
|
shift = ieee80211_vif_get_shift(&sdata->vif);
|
2011-09-28 11:12:51 +00:00
|
|
|
|
2012-07-23 12:53:27 +00:00
|
|
|
sband = local->hw.wiphy->bands[band];
|
2013-07-08 14:55:53 +00:00
|
|
|
exrates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
|
|
|
|
continue;
|
|
|
|
exrates++;
|
|
|
|
}
|
|
|
|
|
2011-09-28 11:12:51 +00:00
|
|
|
if (exrates > 8)
|
|
|
|
exrates -= 8;
|
|
|
|
else
|
|
|
|
exrates = 0;
|
|
|
|
|
|
|
|
if (skb_tailroom(skb) < exrates + 2)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (exrates) {
|
|
|
|
pos = skb_put(skb, exrates + 2);
|
|
|
|
*pos++ = WLAN_EID_EXT_SUPP_RATES;
|
|
|
|
*pos++ = exrates;
|
|
|
|
for (i = 8; i < sband->n_bitrates; i++) {
|
2012-04-03 04:21:20 +00:00
|
|
|
u8 basic = 0;
|
2013-07-08 14:55:53 +00:00
|
|
|
if ((rate_flags & sband->bitrates[i].flags)
|
|
|
|
!= rate_flags)
|
|
|
|
continue;
|
2012-04-03 04:21:20 +00:00
|
|
|
if (need_basic && basic_rates & BIT(i))
|
|
|
|
basic = 0x80;
|
2013-07-08 14:55:53 +00:00
|
|
|
rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
|
|
|
|
5 * (1 << shift));
|
|
|
|
*pos++ = basic | (u8) rate;
|
2011-09-28 11:12:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-04-13 19:02:57 +00: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 16:30:32 +00:00
|
|
|
if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
|
|
|
|
/* non-managed type inferfaces */
|
|
|
|
return 0;
|
|
|
|
}
|
2015-08-28 08:52:54 +00:00
|
|
|
return -ewma_beacon_signal_read(&ifmgd->ave_beacon_signal);
|
2012-04-13 19:02:57 +00:00
|
|
|
}
|
2012-04-20 18:57:00 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
|
2012-09-11 12:34:12 +00:00
|
|
|
|
|
|
|
u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
|
|
|
|
{
|
|
|
|
if (!mcs)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* TODO: consider rx_highest */
|
|
|
|
|
|
|
|
if (mcs->rx_mask[3])
|
|
|
|
return 4;
|
|
|
|
if (mcs->rx_mask[2])
|
|
|
|
return 3;
|
|
|
|
if (mcs->rx_mask[1])
|
|
|
|
return 2;
|
|
|
|
return 1;
|
|
|
|
}
|
2012-11-13 18:46:27 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ieee80211_calculate_rx_timestamp - calculate timestamp in frame
|
|
|
|
* @local: mac80211 hw info struct
|
|
|
|
* @status: RX status
|
|
|
|
* @mpdu_len: total MPDU length (including FCS)
|
|
|
|
* @mpdu_offset: offset into MPDU to calculate timestamp at
|
|
|
|
*
|
|
|
|
* This function calculates the RX timestamp at the given MPDU offset, taking
|
|
|
|
* into account what the RX timestamp was. An offset of 0 will just normalize
|
|
|
|
* the timestamp to TSF at beginning of MPDU reception.
|
|
|
|
*/
|
|
|
|
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_rx_status *status,
|
|
|
|
unsigned int mpdu_len,
|
|
|
|
unsigned int mpdu_offset)
|
|
|
|
{
|
|
|
|
u64 ts = status->mactime;
|
|
|
|
struct rate_info ri;
|
|
|
|
u16 rate;
|
|
|
|
|
|
|
|
if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
memset(&ri, 0, sizeof(ri));
|
|
|
|
|
2018-04-20 10:49:21 +00:00
|
|
|
ri.bw = status->bw;
|
|
|
|
|
2012-11-13 18:46:27 +00:00
|
|
|
/* Fill cfg80211 rate info */
|
2017-04-26 10:14:59 +00:00
|
|
|
switch (status->encoding) {
|
|
|
|
case RX_ENC_HT:
|
2012-11-13 18:46:27 +00:00
|
|
|
ri.mcs = status->rate_idx;
|
|
|
|
ri.flags |= RATE_INFO_FLAGS_MCS;
|
2017-04-26 09:13:00 +00:00
|
|
|
if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
|
2012-11-13 18:46:27 +00:00
|
|
|
ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
|
2017-04-26 10:14:59 +00:00
|
|
|
break;
|
|
|
|
case RX_ENC_VHT:
|
2012-11-09 14:07:02 +00:00
|
|
|
ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
|
|
|
|
ri.mcs = status->rate_idx;
|
2017-04-26 11:51:41 +00:00
|
|
|
ri.nss = status->nss;
|
2017-04-26 09:13:00 +00:00
|
|
|
if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
|
2012-11-09 14:07:02 +00:00
|
|
|
ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
|
2017-04-26 10:14:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
/* fall through */
|
|
|
|
case RX_ENC_LEGACY: {
|
2012-11-13 18:46:27 +00:00
|
|
|
struct ieee80211_supported_band *sband;
|
2013-07-08 14:55:53 +00:00
|
|
|
int shift = 0;
|
|
|
|
int bitrate;
|
|
|
|
|
2017-04-26 10:14:59 +00:00
|
|
|
switch (status->bw) {
|
|
|
|
case RATE_INFO_BW_10:
|
2013-07-08 14:55:53 +00:00
|
|
|
shift = 1;
|
2017-04-26 10:14:59 +00:00
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_5:
|
2013-07-08 14:55:53 +00:00
|
|
|
shift = 2;
|
2017-04-26 10:14:59 +00:00
|
|
|
break;
|
2015-01-15 15:14:02 +00:00
|
|
|
}
|
2012-11-13 18:46:27 +00:00
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[status->band];
|
2013-07-08 14:55:53 +00:00
|
|
|
bitrate = sband->bitrates[status->rate_idx].bitrate;
|
|
|
|
ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
|
2016-01-25 13:46:34 +00:00
|
|
|
|
|
|
|
if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
|
|
|
|
/* TODO: handle HT/VHT preambles */
|
2016-04-12 13:56:15 +00:00
|
|
|
if (status->band == NL80211_BAND_5GHZ) {
|
2016-01-25 13:46:34 +00:00
|
|
|
ts += 20 << shift;
|
|
|
|
mpdu_offset += 2;
|
2017-04-26 09:13:00 +00:00
|
|
|
} else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) {
|
2016-01-25 13:46:34 +00:00
|
|
|
ts += 96;
|
|
|
|
} else {
|
|
|
|
ts += 192;
|
|
|
|
}
|
|
|
|
}
|
2017-04-26 10:14:59 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-11-13 18:46:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rate = cfg80211_calculate_bitrate(&ri);
|
2013-10-11 13:47:06 +00:00
|
|
|
if (WARN_ONCE(!rate,
|
2016-02-24 09:49:45 +00:00
|
|
|
"Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
|
|
|
|
(unsigned long long)status->flag, status->rate_idx,
|
2017-04-26 11:51:41 +00:00
|
|
|
status->nss))
|
2013-10-11 13:47:06 +00:00
|
|
|
return 0;
|
2012-11-13 18:46:27 +00:00
|
|
|
|
|
|
|
/* rewind from end of MPDU */
|
|
|
|
if (status->flag & RX_FLAG_MACTIME_END)
|
|
|
|
ts -= mpdu_len * 8 * 10 / rate;
|
|
|
|
|
|
|
|
ts += mpdu_offset * 8 * 10 / rate;
|
|
|
|
|
|
|
|
return ts;
|
|
|
|
}
|
2013-02-08 17:16:20 +00:00
|
|
|
|
|
|
|
void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2013-11-06 12:55:51 +00:00
|
|
|
struct cfg80211_chan_def chandef;
|
2013-02-08 17:16:20 +00:00
|
|
|
|
2017-04-26 07:58:53 +00:00
|
|
|
/* for interface list, to avoid linking iflist_mtx and chanctx_mtx */
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
mac80211: fix iflist_mtx/mtx locking in radar detection
The scan code creates an iflist_mtx -> mtx locking dependency,
and a few other places, notably radar detection, were creating
the opposite dependency, causing lockdep to complain. As scan
and radar detection are mutually exclusive, the deadlock can't
really happen in practice, but it's still bad form.
A similar issue exists in the monitor mode code, but this is
only used by channel-context drivers right now and those have
to have hardware scan, so that also can't happen.
Still, fix these issues by making some of the channel context
code require the mtx to be held rather than acquiring it, thus
allowing the monitor/radar callers to keep the iflist_mtx->mtx
lock ordering.
While at it, also fix access to the local->scanning variable
in the radar code, and document that radar_detect_enabled is
now properly protected by the mtx.
All this would now introduce an ABBA deadlock between the DFS
work cancelling and local->mtx, so change the locking there a
bit to not need to use cancel_delayed_work_sync() but be able
to just use cancel_delayed_work(). The work is also safely
stopped/removed when the interface is stopped, so no extra
changes are needed.
Reported-by: Kalle Valo <kvalo@qca.qualcomm.com>
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-12-18 08:43:33 +00:00
|
|
|
mutex_lock(&local->mtx);
|
2013-02-08 17:16:20 +00:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
mac80211: fix iflist_mtx/mtx locking in radar detection
The scan code creates an iflist_mtx -> mtx locking dependency,
and a few other places, notably radar detection, were creating
the opposite dependency, causing lockdep to complain. As scan
and radar detection are mutually exclusive, the deadlock can't
really happen in practice, but it's still bad form.
A similar issue exists in the monitor mode code, but this is
only used by channel-context drivers right now and those have
to have hardware scan, so that also can't happen.
Still, fix these issues by making some of the channel context
code require the mtx to be held rather than acquiring it, thus
allowing the monitor/radar callers to keep the iflist_mtx->mtx
lock ordering.
While at it, also fix access to the local->scanning variable
in the radar code, and document that radar_detect_enabled is
now properly protected by the mtx.
All this would now introduce an ABBA deadlock between the DFS
work cancelling and local->mtx, so change the locking there a
bit to not need to use cancel_delayed_work_sync() but be able
to just use cancel_delayed_work(). The work is also safely
stopped/removed when the interface is stopped, so no extra
changes are needed.
Reported-by: Kalle Valo <kvalo@qca.qualcomm.com>
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-12-18 08:43:33 +00:00
|
|
|
/* it might be waiting for the local->mtx, but then
|
|
|
|
* by the time it gets it, sdata->wdev.cac_started
|
|
|
|
* will no longer be true
|
|
|
|
*/
|
|
|
|
cancel_delayed_work(&sdata->dfs_cac_timer_work);
|
2013-02-08 17:16:20 +00:00
|
|
|
|
|
|
|
if (sdata->wdev.cac_started) {
|
2013-11-06 12:55:51 +00:00
|
|
|
chandef = sdata->vif.bss_conf.chandef;
|
2013-02-08 17:16:20 +00:00
|
|
|
ieee80211_vif_release_channel(sdata);
|
|
|
|
cfg80211_cac_event(sdata->dev,
|
2013-11-06 12:55:51 +00:00
|
|
|
&chandef,
|
2013-02-08 17:16:20 +00:00
|
|
|
NL80211_RADAR_CAC_ABORTED,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
|
|
|
}
|
mac80211: fix iflist_mtx/mtx locking in radar detection
The scan code creates an iflist_mtx -> mtx locking dependency,
and a few other places, notably radar detection, were creating
the opposite dependency, causing lockdep to complain. As scan
and radar detection are mutually exclusive, the deadlock can't
really happen in practice, but it's still bad form.
A similar issue exists in the monitor mode code, but this is
only used by channel-context drivers right now and those have
to have hardware scan, so that also can't happen.
Still, fix these issues by making some of the channel context
code require the mtx to be held rather than acquiring it, thus
allowing the monitor/radar callers to keep the iflist_mtx->mtx
lock ordering.
While at it, also fix access to the local->scanning variable
in the radar code, and document that radar_detect_enabled is
now properly protected by the mtx.
All this would now introduce an ABBA deadlock between the DFS
work cancelling and local->mtx, so change the locking there a
bit to not need to use cancel_delayed_work_sync() but be able
to just use cancel_delayed_work(). The work is also safely
stopped/removed when the interface is stopped, so no extra
changes are needed.
Reported-by: Kalle Valo <kvalo@qca.qualcomm.com>
Tested-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-12-18 08:43:33 +00:00
|
|
|
mutex_unlock(&local->mtx);
|
2013-02-08 17:16:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_dfs_radar_detected_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local =
|
|
|
|
container_of(work, struct ieee80211_local, radar_detected_work);
|
2013-11-05 13:48:46 +00:00
|
|
|
struct cfg80211_chan_def chandef = local->hw.conf.chandef;
|
2014-10-10 10:43:23 +00:00
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
int num_chanctx = 0;
|
|
|
|
|
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list) {
|
|
|
|
if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
num_chanctx++;
|
|
|
|
chandef = ctx->conf.def;
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
2013-02-08 17:16:20 +00:00
|
|
|
|
2017-04-26 07:58:53 +00:00
|
|
|
rtnl_lock();
|
2013-02-08 17:16:20 +00:00
|
|
|
ieee80211_dfs_cac_cancel(local);
|
2017-04-26 07:58:53 +00:00
|
|
|
rtnl_unlock();
|
2013-02-08 17:16:20 +00:00
|
|
|
|
2014-10-10 10:43:23 +00:00
|
|
|
if (num_chanctx > 1)
|
|
|
|
/* XXX: multi-channel is not supported yet */
|
2013-02-08 17:16:20 +00:00
|
|
|
WARN_ON(1);
|
2013-11-05 13:48:46 +00:00
|
|
|
else
|
2013-02-08 17:16:20 +00:00
|
|
|
cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_radar_detected(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
|
|
|
trace_api_radar_detected(local);
|
|
|
|
|
2017-04-26 07:58:53 +00:00
|
|
|
schedule_work(&local->radar_detected_work);
|
2013-02-08 17:16:20 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_radar_detected);
|
2013-08-28 11:41:29 +00:00
|
|
|
|
|
|
|
u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
|
|
|
|
{
|
|
|
|
u32 ret;
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
switch (c->width) {
|
|
|
|
case NL80211_CHAN_WIDTH_20:
|
|
|
|
c->width = NL80211_CHAN_WIDTH_20_NOHT;
|
|
|
|
ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_40:
|
|
|
|
c->width = NL80211_CHAN_WIDTH_20;
|
|
|
|
c->center_freq1 = c->chan->center_freq;
|
|
|
|
ret = IEEE80211_STA_DISABLE_40MHZ |
|
|
|
|
IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80:
|
|
|
|
tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
|
|
|
|
/* n_P40 */
|
|
|
|
tmp /= 2;
|
|
|
|
/* freq_P40 */
|
|
|
|
c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
|
|
|
|
c->width = NL80211_CHAN_WIDTH_40;
|
|
|
|
ret = IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_80P80:
|
|
|
|
c->center_freq2 = 0;
|
|
|
|
c->width = NL80211_CHAN_WIDTH_80;
|
|
|
|
ret = IEEE80211_STA_DISABLE_80P80MHZ |
|
|
|
|
IEEE80211_STA_DISABLE_160MHZ;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_160:
|
|
|
|
/* n_P20 */
|
|
|
|
tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
|
|
|
|
/* n_P80 */
|
|
|
|
tmp /= 4;
|
|
|
|
c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
|
|
|
|
c->width = NL80211_CHAN_WIDTH_80;
|
|
|
|
ret = IEEE80211_STA_DISABLE_80P80MHZ |
|
|
|
|
IEEE80211_STA_DISABLE_160MHZ;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case NL80211_CHAN_WIDTH_20_NOHT:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
c->width = NL80211_CHAN_WIDTH_20_NOHT;
|
|
|
|
ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
case NL80211_CHAN_WIDTH_5:
|
|
|
|
case NL80211_CHAN_WIDTH_10:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
/* keep c->width */
|
|
|
|
ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!cfg80211_chandef_valid(c));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-10-01 13:45:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns true if smps_mode_new is strictly more restrictive than
|
|
|
|
* smps_mode_old.
|
|
|
|
*/
|
|
|
|
bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
|
|
|
|
enum ieee80211_smps_mode smps_mode_new)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC ||
|
|
|
|
smps_mode_new == IEEE80211_SMPS_AUTOMATIC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (smps_mode_old) {
|
|
|
|
case IEEE80211_SMPS_STATIC:
|
|
|
|
return false;
|
|
|
|
case IEEE80211_SMPS_DYNAMIC:
|
|
|
|
return smps_mode_new == IEEE80211_SMPS_STATIC;
|
|
|
|
case IEEE80211_SMPS_OFF:
|
|
|
|
return smps_mode_new != IEEE80211_SMPS_OFF;
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2013-10-15 02:08:28 +00:00
|
|
|
|
|
|
|
int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_csa_settings *csa_settings)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int freq;
|
2017-09-08 09:54:46 +00:00
|
|
|
int hdr_len = offsetofend(struct ieee80211_mgmt,
|
|
|
|
u.action.u.chan_switch);
|
2013-10-15 02:08:28 +00:00
|
|
|
u8 *pos;
|
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->tx_headroom + hdr_len +
|
|
|
|
5 + /* channel switch announcement element */
|
|
|
|
3 + /* secondary channel offset element */
|
2017-05-23 15:00:42 +00:00
|
|
|
5 + /* wide bandwidth channel switch announcement */
|
2013-10-15 02:08:28 +00:00
|
|
|
8); /* mesh channel switch parameters element */
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->tx_headroom);
|
networking: convert many more places to skb_put_zero()
There were many places that my previous spatch didn't find,
as pointed out by yuan linyu in various patches.
The following spatch found many more and also removes the
now unnecessary casts:
@@
identifier p, p2;
expression len;
expression skb;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_zero(skb, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_zero(skb, len);
)
... when != p
(
p2 = (t2)p;
-memset(p2, 0, len);
|
-memset(p, 0, len);
)
@@
type t, t2;
identifier p, p2;
expression skb;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_zero(skb, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_zero(skb, sizeof(t));
)
... when != p
(
p2 = (t2)p;
-memset(p2, 0, sizeof(*p));
|
-memset(p, 0, sizeof(*p));
)
@@
expression skb, len;
@@
-memset(skb_put(skb, len), 0, len);
+skb_put_zero(skb, len);
Apply it to the tree (with one manual fixup to keep the
comment in vxlan.c, which spatch removed.)
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 12:29:19 +00:00
|
|
|
mgmt = skb_put_zero(skb, hdr_len);
|
2013-10-15 02:08:28 +00:00
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_ACTION);
|
|
|
|
|
|
|
|
eth_broadcast_addr(mgmt->da);
|
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
|
|
|
memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
|
|
|
|
} else {
|
|
|
|
struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
|
|
|
|
memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
|
|
|
|
}
|
|
|
|
mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
|
|
|
|
mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
|
|
|
|
pos = skb_put(skb, 5);
|
|
|
|
*pos++ = WLAN_EID_CHANNEL_SWITCH; /* EID */
|
|
|
|
*pos++ = 3; /* IE length */
|
|
|
|
*pos++ = csa_settings->block_tx ? 1 : 0; /* CSA mode */
|
|
|
|
freq = csa_settings->chandef.chan->center_freq;
|
|
|
|
*pos++ = ieee80211_frequency_to_channel(freq); /* channel */
|
|
|
|
*pos++ = csa_settings->count; /* count */
|
|
|
|
|
|
|
|
if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
|
|
|
|
enum nl80211_channel_type ch_type;
|
|
|
|
|
|
|
|
skb_put(skb, 3);
|
|
|
|
*pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET; /* EID */
|
|
|
|
*pos++ = 1; /* IE length */
|
|
|
|
ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
|
|
|
|
if (ch_type == NL80211_CHAN_HT40PLUS)
|
|
|
|
*pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
|
|
|
else
|
|
|
|
*pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
|
|
|
struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
|
|
|
|
|
|
|
|
skb_put(skb, 8);
|
|
|
|
*pos++ = WLAN_EID_CHAN_SWITCH_PARAM; /* EID */
|
|
|
|
*pos++ = 6; /* IE length */
|
|
|
|
*pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL; /* Mesh TTL */
|
|
|
|
*pos = 0x00; /* Mesh Flag: Tx Restrict, Initiator, Reason */
|
|
|
|
*pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
|
|
|
|
*pos++ |= csa_settings->block_tx ?
|
|
|
|
WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
|
|
|
|
put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
|
|
|
|
pos += 2;
|
2013-11-12 02:31:48 +00:00
|
|
|
put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
|
2013-10-15 02:08:28 +00:00
|
|
|
pos += 2;
|
|
|
|
}
|
|
|
|
|
2017-05-23 15:00:42 +00:00
|
|
|
if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 ||
|
|
|
|
csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 ||
|
|
|
|
csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) {
|
|
|
|
skb_put(skb, 5);
|
|
|
|
ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef);
|
|
|
|
}
|
|
|
|
|
2013-10-15 02:08:28 +00:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-03-24 12:23:27 +00:00
|
|
|
|
|
|
|
bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
|
|
|
|
{
|
|
|
|
return !(cs == NULL || cs->cipher == 0 ||
|
|
|
|
cs->hdr_len < cs->pn_len + cs->pn_off ||
|
|
|
|
cs->hdr_len <= cs->key_idx_off ||
|
|
|
|
cs->key_idx_shift > 7 ||
|
|
|
|
cs->key_idx_mask == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Ensure we have enough iftype bitmap space for all iftype values */
|
|
|
|
WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
if (!ieee80211_cs_valid(&cs[i]))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct ieee80211_cipher_scheme *
|
|
|
|
ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
|
|
|
|
enum nl80211_iftype iftype)
|
|
|
|
{
|
|
|
|
const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
|
|
|
|
int n = local->hw.n_cipher_schemes;
|
|
|
|
int i;
|
|
|
|
const struct ieee80211_cipher_scheme *cs = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (l[i].cipher == cipher) {
|
|
|
|
cs = &l[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cs || !(cs->iftype & BIT(iftype)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return cs;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ieee80211_cs_headroom(struct ieee80211_local *local,
|
|
|
|
struct cfg80211_crypto_settings *crypto,
|
|
|
|
enum nl80211_iftype iftype)
|
|
|
|
{
|
|
|
|
const struct ieee80211_cipher_scheme *cs;
|
|
|
|
int headroom = IEEE80211_ENCRYPT_HEADROOM;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
|
|
|
|
cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
|
|
|
|
iftype);
|
|
|
|
|
|
|
|
if (cs && headroom < cs->hdr_len)
|
|
|
|
headroom = cs->hdr_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
|
|
|
|
if (cs && headroom < cs->hdr_len)
|
|
|
|
headroom = cs->hdr_len;
|
|
|
|
|
|
|
|
return headroom;
|
|
|
|
}
|
2013-12-16 20:49:14 +00:00
|
|
|
|
|
|
|
static bool
|
|
|
|
ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
|
|
|
|
{
|
|
|
|
s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
|
|
|
|
int skip;
|
|
|
|
|
|
|
|
if (end > 0)
|
|
|
|
return false;
|
|
|
|
|
2015-10-27 07:35:11 +00:00
|
|
|
/* One shot NOA */
|
|
|
|
if (data->count[i] == 1)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (data->desc[i].interval == 0)
|
|
|
|
return false;
|
|
|
|
|
2013-12-16 20:49:14 +00:00
|
|
|
/* End time is in the past, check for repetitions */
|
|
|
|
skip = DIV_ROUND_UP(-end, data->desc[i].interval);
|
|
|
|
if (data->count[i] < 255) {
|
|
|
|
if (data->count[i] <= skip) {
|
|
|
|
data->count[i] = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->count[i] -= skip;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->desc[i].start += skip * data->desc[i].interval;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
|
|
|
|
s32 *offset)
|
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
|
|
|
|
s32 cur;
|
|
|
|
|
|
|
|
if (!data->count[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
|
|
|
|
ret = true;
|
|
|
|
|
|
|
|
cur = data->desc[i].start - tsf;
|
|
|
|
if (cur > *offset)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cur = data->desc[i].start + data->desc[i].duration - tsf;
|
|
|
|
if (cur > *offset)
|
|
|
|
*offset = cur;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32
|
|
|
|
ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
|
|
|
|
{
|
|
|
|
s32 offset = 0;
|
|
|
|
int tries = 0;
|
|
|
|
/*
|
|
|
|
* arbitrary limit, used to avoid infinite loops when combined NoA
|
|
|
|
* descriptors cover the full time period.
|
|
|
|
*/
|
|
|
|
int max_tries = 5;
|
|
|
|
|
|
|
|
ieee80211_extend_absent_time(data, tsf, &offset);
|
|
|
|
do {
|
|
|
|
if (!ieee80211_extend_absent_time(data, tsf, &offset))
|
|
|
|
break;
|
|
|
|
|
|
|
|
tries++;
|
|
|
|
} while (tries < max_tries);
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
|
|
|
|
{
|
|
|
|
u32 next_offset = BIT(31) - 1;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
data->absent = 0;
|
|
|
|
data->has_next_tsf = false;
|
|
|
|
for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
|
|
|
|
s32 start;
|
|
|
|
|
|
|
|
if (!data->count[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ieee80211_extend_noa_desc(data, tsf, i);
|
|
|
|
start = data->desc[i].start - tsf;
|
|
|
|
if (start <= 0)
|
|
|
|
data->absent |= BIT(i);
|
|
|
|
|
|
|
|
if (next_offset > start)
|
|
|
|
next_offset = start;
|
|
|
|
|
|
|
|
data->has_next_tsf = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data->absent)
|
|
|
|
next_offset = ieee80211_get_noa_absent_time(data, tsf);
|
|
|
|
|
|
|
|
data->next_tsf = tsf + next_offset;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_update_p2p_noa);
|
|
|
|
|
|
|
|
int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
|
|
|
|
struct ieee80211_noa_data *data, u32 tsf)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(data, 0, sizeof(*data));
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
|
|
|
|
const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
|
|
|
|
|
|
|
|
if (!desc->count || !desc->duration)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
data->count[i] = desc->count;
|
|
|
|
data->desc[i].start = le32_to_cpu(desc->start_time);
|
|
|
|
data->desc[i].duration = le32_to_cpu(desc->duration);
|
|
|
|
data->desc[i].interval = le32_to_cpu(desc->interval);
|
|
|
|
|
|
|
|
if (data->count[i] > 1 &&
|
|
|
|
data->desc[i].interval < data->desc[i].duration)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ieee80211_extend_noa_desc(data, tsf, i);
|
|
|
|
ret++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
ieee80211_update_p2p_noa(data, tsf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
|
2013-12-19 18:25:15 +00:00
|
|
|
|
|
|
|
void ieee80211_recalc_dtim(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
u64 tsf = drv_get_tsf(local, sdata);
|
|
|
|
u64 dtim_count = 0;
|
|
|
|
u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
|
|
|
|
u8 dtim_period = sdata->vif.bss_conf.dtim_period;
|
|
|
|
struct ps_data *ps;
|
|
|
|
u8 bcns_from_dtim;
|
|
|
|
|
|
|
|
if (tsf == -1ULL || !beacon_int || !dtim_period)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
|
|
|
|
if (!sdata->bss)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ps = &sdata->bss->ps;
|
|
|
|
} else if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
|
|
|
ps = &sdata->u.mesh.ps;
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* actually finds last dtim_count, mac80211 will update in
|
|
|
|
* __beacon_add_tim().
|
|
|
|
* dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
|
|
|
|
*/
|
|
|
|
do_div(tsf, beacon_int);
|
|
|
|
bcns_from_dtim = do_div(tsf, dtim_period);
|
|
|
|
/* just had a DTIM */
|
|
|
|
if (!bcns_from_dtim)
|
|
|
|
dtim_count = 0;
|
|
|
|
else
|
|
|
|
dtim_count = dtim_period - bcns_from_dtim;
|
|
|
|
|
|
|
|
ps->dtim_count = dtim_count;
|
|
|
|
}
|
2014-02-13 09:31:59 +00:00
|
|
|
|
2014-06-25 10:35:07 +00:00
|
|
|
static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_chanctx *ctx)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
u8 radar_detect = 0;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list)
|
|
|
|
if (sdata->reserved_radar_required)
|
|
|
|
radar_detect |= BIT(sdata->reserved_chandef.width);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* An in-place reservation context should not have any assigned vifs
|
|
|
|
* until it replaces the other context.
|
|
|
|
*/
|
|
|
|
WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
|
|
|
|
!list_empty(&ctx->assigned_vifs));
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list)
|
|
|
|
if (sdata->radar_required)
|
|
|
|
radar_detect |= BIT(sdata->vif.bss_conf.chandef.width);
|
|
|
|
|
|
|
|
return radar_detect;
|
|
|
|
}
|
|
|
|
|
2014-02-13 09:31:59 +00:00
|
|
|
int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
enum ieee80211_chanctx_mode chanmode,
|
|
|
|
u8 radar_detect)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *sdata_iter;
|
|
|
|
enum nl80211_iftype iftype = sdata->wdev.iftype;
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
int total = 1;
|
2016-10-12 12:55:35 +00:00
|
|
|
struct iface_combination_params params = {
|
|
|
|
.radar_detect = radar_detect,
|
|
|
|
};
|
2014-02-13 09:31:59 +00:00
|
|
|
|
|
|
|
lockdep_assert_held(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
if (WARN_ON(hweight32(radar_detect) > 1))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-02-27 09:07:21 +00:00
|
|
|
if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
|
|
|
|
!chandef->chan))
|
2014-02-13 09:31:59 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-10-21 12:25:14 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
|
|
|
|
/*
|
|
|
|
* always passing this is harmless, since it'll be the
|
|
|
|
* same value that cfg80211 finds if it finds the same
|
|
|
|
* interface ... and that's always allowed
|
|
|
|
*/
|
|
|
|
params.new_beacon_int = sdata->vif.bss_conf.beacon_int;
|
|
|
|
}
|
|
|
|
|
2014-02-13 09:31:59 +00:00
|
|
|
/* Always allow software iftypes */
|
2019-05-08 09:25:33 +00:00
|
|
|
if (local->hw.wiphy->software_iftypes & BIT(iftype) ||
|
|
|
|
(iftype == NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
local->hw.wiphy->flags & WIPHY_FLAG_4ADDR_AP)) {
|
2014-02-13 09:31:59 +00:00
|
|
|
if (radar_detect)
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
if (chandef)
|
|
|
|
params.num_different_channels = 1;
|
2014-02-13 09:31:59 +00:00
|
|
|
|
|
|
|
if (iftype != NL80211_IFTYPE_UNSPECIFIED)
|
2016-10-12 12:55:35 +00:00
|
|
|
params.iftype_num[iftype] = 1;
|
2014-02-13 09:31:59 +00:00
|
|
|
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list) {
|
2014-06-25 10:35:06 +00:00
|
|
|
if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
|
|
|
|
continue;
|
2016-10-12 12:55:35 +00:00
|
|
|
params.radar_detect |=
|
|
|
|
ieee80211_chanctx_radar_detect(local, ctx);
|
2014-02-13 09:31:59 +00:00
|
|
|
if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) {
|
2016-10-12 12:55:35 +00:00
|
|
|
params.num_different_channels++;
|
2014-02-13 09:31:59 +00:00
|
|
|
continue;
|
|
|
|
}
|
2014-02-27 09:07:21 +00:00
|
|
|
if (chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
|
2014-02-13 09:31:59 +00:00
|
|
|
cfg80211_chandef_compatible(chandef,
|
|
|
|
&ctx->conf.def))
|
|
|
|
continue;
|
2016-10-12 12:55:35 +00:00
|
|
|
params.num_different_channels++;
|
2014-02-13 09:31:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) {
|
|
|
|
struct wireless_dev *wdev_iter;
|
|
|
|
|
|
|
|
wdev_iter = &sdata_iter->wdev;
|
|
|
|
|
|
|
|
if (sdata_iter == sdata ||
|
2015-03-12 06:53:30 +00:00
|
|
|
!ieee80211_sdata_running(sdata_iter) ||
|
2014-02-13 09:31:59 +00:00
|
|
|
local->hw.wiphy->software_iftypes & BIT(wdev_iter->iftype))
|
|
|
|
continue;
|
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
params.iftype_num[wdev_iter->iftype]++;
|
2014-02-13 09:31:59 +00:00
|
|
|
total++;
|
|
|
|
}
|
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
if (total == 1 && !params.radar_detect)
|
2014-02-13 09:31:59 +00:00
|
|
|
return 0;
|
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
return cfg80211_check_combinations(local->hw.wiphy, ¶ms);
|
2014-02-13 09:31:59 +00:00
|
|
|
}
|
2014-04-09 13:29:23 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
u32 *max_num_different_channels = data;
|
|
|
|
|
|
|
|
*max_num_different_channels = max(*max_num_different_channels,
|
|
|
|
c->num_different_channels);
|
|
|
|
}
|
|
|
|
|
|
|
|
int ieee80211_max_num_channels(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_chanctx *ctx;
|
|
|
|
u32 max_num_different_channels = 1;
|
|
|
|
int err;
|
2016-10-12 12:55:35 +00:00
|
|
|
struct iface_combination_params params = {0};
|
2014-04-09 13:29:23 +00:00
|
|
|
|
|
|
|
lockdep_assert_held(&local->chanctx_mtx);
|
|
|
|
|
|
|
|
list_for_each_entry(ctx, &local->chanctx_list, list) {
|
2014-06-25 10:35:06 +00:00
|
|
|
if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
|
|
|
|
continue;
|
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
params.num_different_channels++;
|
2014-04-09 13:29:23 +00:00
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
params.radar_detect |=
|
|
|
|
ieee80211_chanctx_radar_detect(local, ctx);
|
2014-04-09 13:29:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list)
|
2016-10-12 12:55:35 +00:00
|
|
|
params.iftype_num[sdata->wdev.iftype]++;
|
2014-04-09 13:29:23 +00:00
|
|
|
|
2016-10-12 12:55:35 +00:00
|
|
|
err = cfg80211_iter_combinations(local->hw.wiphy, ¶ms,
|
|
|
|
ieee80211_iter_max_chans,
|
2014-04-09 13:29:23 +00:00
|
|
|
&max_num_different_channels);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return max_num_different_channels;
|
|
|
|
}
|
2014-07-17 14:14:23 +00:00
|
|
|
|
|
|
|
u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo)
|
|
|
|
{
|
|
|
|
*buf++ = WLAN_EID_VENDOR_SPECIFIC;
|
|
|
|
*buf++ = 7; /* len */
|
|
|
|
*buf++ = 0x00; /* Microsoft OUI 00:50:F2 */
|
|
|
|
*buf++ = 0x50;
|
|
|
|
*buf++ = 0xf2;
|
|
|
|
*buf++ = 2; /* WME */
|
|
|
|
*buf++ = 0; /* WME info */
|
|
|
|
*buf++ = 1; /* WME ver */
|
|
|
|
*buf++ = qosinfo; /* U-APSD no in use */
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
2015-03-27 20:30:37 +00:00
|
|
|
|
2016-01-27 14:26:12 +00:00
|
|
|
void ieee80211_txq_get_depth(struct ieee80211_txq *txq,
|
|
|
|
unsigned long *frame_cnt,
|
|
|
|
unsigned long *byte_cnt)
|
|
|
|
{
|
|
|
|
struct txq_info *txqi = to_txq_info(txq);
|
2016-09-22 17:04:20 +00:00
|
|
|
u32 frag_cnt = 0, frag_bytes = 0;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
skb_queue_walk(&txqi->frags, skb) {
|
|
|
|
frag_cnt++;
|
|
|
|
frag_bytes += skb->len;
|
|
|
|
}
|
2016-01-27 14:26:12 +00:00
|
|
|
|
|
|
|
if (frame_cnt)
|
2016-09-22 17:04:20 +00:00
|
|
|
*frame_cnt = txqi->tin.backlog_packets + frag_cnt;
|
2016-01-27 14:26:12 +00:00
|
|
|
|
|
|
|
if (byte_cnt)
|
2016-09-22 17:04:20 +00:00
|
|
|
*byte_cnt = txqi->tin.backlog_bytes + frag_bytes;
|
2016-01-27 14:26:12 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_txq_get_depth);
|
2016-10-18 20:12:12 +00:00
|
|
|
|
|
|
|
const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS] = {
|
|
|
|
IEEE80211_WMM_IE_STA_QOSINFO_AC_VO,
|
|
|
|
IEEE80211_WMM_IE_STA_QOSINFO_AC_VI,
|
|
|
|
IEEE80211_WMM_IE_STA_QOSINFO_AC_BE,
|
|
|
|
IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
|
|
|
|
};
|