2019-06-04 08:11:33 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2009-02-10 20:25:46 +00:00
|
|
|
/*
|
|
|
|
* HT handling
|
|
|
|
*
|
|
|
|
* Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
|
|
* Copyright 2007, Michael Wu <flamingice@sourmilk.net>
|
2010-06-10 08:21:48 +00:00
|
|
|
* Copyright 2007-2010, Intel Corporation
|
2017-05-26 22:27:25 +00:00
|
|
|
* Copyright(c) 2015-2017 Intel Deutschland GmbH
|
2019-02-06 11:17:21 +00:00
|
|
|
* Copyright (C) 2018 - 2019 Intel Corporation
|
2009-02-10 20:25:46 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/ieee80211.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-07-15 15:47:34 +00:00
|
|
|
#include <linux/export.h>
|
2009-02-10 20:25:46 +00:00
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 16:52:52 +00:00
|
|
|
#include "driver-ops.h"
|
2009-02-10 20:25:46 +00:00
|
|
|
#include "wme.h"
|
|
|
|
|
2009-02-10 20:25:49 +00:00
|
|
|
/**
|
2010-06-10 08:21:50 +00:00
|
|
|
* DOC: TX A-MPDU aggregation
|
2009-02-10 20:25:49 +00:00
|
|
|
*
|
|
|
|
* Aggregation on the TX side requires setting the hardware flag
|
2010-06-10 08:21:50 +00:00
|
|
|
* %IEEE80211_HW_AMPDU_AGGREGATION. The driver will then be handed
|
|
|
|
* packets with a flag indicating A-MPDU aggregation. The driver
|
|
|
|
* or device is responsible for actually aggregating the frames,
|
|
|
|
* as well as deciding how many and which to aggregate.
|
2009-02-10 20:25:49 +00:00
|
|
|
*
|
2010-06-10 08:21:50 +00:00
|
|
|
* When TX aggregation is started by some subsystem (usually the rate
|
|
|
|
* control algorithm would be appropriate) by calling the
|
|
|
|
* ieee80211_start_tx_ba_session() function, the driver will be
|
|
|
|
* notified via its @ampdu_action function, with the
|
|
|
|
* %IEEE80211_AMPDU_TX_START action.
|
2009-02-10 20:25:49 +00:00
|
|
|
*
|
|
|
|
* In response to that, the driver is later required to call the
|
2010-06-10 08:21:50 +00:00
|
|
|
* ieee80211_start_tx_ba_cb_irqsafe() function, which will really
|
|
|
|
* start the aggregation session after the peer has also responded.
|
|
|
|
* If the peer responds negatively, the session will be stopped
|
|
|
|
* again right away. Note that it is possible for the aggregation
|
|
|
|
* session to be stopped before the driver has indicated that it
|
|
|
|
* is done setting it up, in which case it must not indicate the
|
|
|
|
* setup completion.
|
2009-02-10 20:25:49 +00:00
|
|
|
*
|
2010-06-10 08:21:50 +00:00
|
|
|
* Also note that, since we also need to wait for a response from
|
|
|
|
* the peer, the driver is notified of the completion of the
|
|
|
|
* handshake by the %IEEE80211_AMPDU_TX_OPERATIONAL action to the
|
|
|
|
* @ampdu_action callback.
|
|
|
|
*
|
|
|
|
* Similarly, when the aggregation session is stopped by the peer
|
|
|
|
* or something calling ieee80211_stop_tx_ba_session(), the driver's
|
|
|
|
* @ampdu_action function will be called with the action
|
|
|
|
* %IEEE80211_AMPDU_TX_STOP. In this case, the call must not fail,
|
|
|
|
* and the driver must later call ieee80211_stop_tx_ba_cb_irqsafe().
|
2011-12-08 09:26:15 +00:00
|
|
|
* Note that the sta can get destroyed before the BA tear down is
|
|
|
|
* complete.
|
2009-02-10 20:25:49 +00:00
|
|
|
*/
|
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *da, u16 tid,
|
|
|
|
u8 dialog_token, u16 start_seq_num,
|
|
|
|
u16 agg_size, u16 timeout)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
|
|
|
u16 capab;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
|
|
|
|
|
2011-08-29 21:17:31 +00:00
|
|
|
if (!skb)
|
2009-02-10 20:25:46 +00:00
|
|
|
return;
|
2011-08-29 21:17:31 +00:00
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
skb_reserve(skb, local->hw.extra_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, 24);
|
2009-02-10 20:25:46 +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-10 20:25:47 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP ||
|
2011-10-26 21:47:29 +00:00
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
|
2009-11-25 16:46:19 +00:00
|
|
|
memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
|
2009-02-15 11:44:28 +00:00
|
|
|
else if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
|
2011-11-30 15:56:34 +00:00
|
|
|
else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
|
|
|
|
memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_ACTION);
|
|
|
|
|
|
|
|
skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req));
|
|
|
|
|
|
|
|
mgmt->u.action.category = WLAN_CATEGORY_BACK;
|
|
|
|
mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ;
|
|
|
|
|
|
|
|
mgmt->u.action.u.addba_req.dialog_token = dialog_token;
|
2015-08-16 08:13:22 +00:00
|
|
|
capab = (u16)(1 << 0); /* bit 0 A-MSDU support */
|
|
|
|
capab |= (u16)(1 << 1); /* bit 1 aggregation policy */
|
2009-02-10 20:25:46 +00:00
|
|
|
capab |= (u16)(tid << 2); /* bit 5:2 TID number */
|
|
|
|
capab |= (u16)(agg_size << 6); /* bit 15:6 max size of aggergation */
|
|
|
|
|
|
|
|
mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
|
|
|
|
|
|
|
|
mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout);
|
|
|
|
mgmt->u.action.u.addba_req.start_seq_num =
|
|
|
|
cpu_to_le16(start_seq_num << 4);
|
|
|
|
|
mac80211: send {ADD,DEL}BA on AC_VO like other mgmt frames, as per spec
ATM, {ADD,DEL}BA and BAR frames are sent on the AC matching the TID of
the BA parameters. In the discussion [1] about this patch, Johannes
recalled that it fixed some races with the DELBA and indeed this
behavior was introduced in [2].
While [2] is right for the BARs, the part queueing the {ADD,DEL}BAs on
their BA params TID AC violates the spec and is more a workaround for
some drivers. Helmut expressed some concerns wrt such drivers, in
particular DELBAs in rt2x00.
ATM, DELBAs are sent after a driver has called (hence "purposely")
ieee80211_start_tx_ba_cb_irqsafe and Johannes and Emmanuel gave some
details wrt intentions behind the split of the IEEE80211_AMPDU_TX_STOP_*
given to the driver ampdu_action supposed to call this function, which
could prove handy to people trying to do the right thing in faulty
drivers (if their fw/hw don't get in their way).
[1] http://mid.gmane.org/1390391564-18481-1-git-send-email-karl.beldan@gmail.com
[2] Commit: cf6bb79ad828 ("mac80211: Use appropriate TID for sending BAR, ADDBA and DELBA frames")
Signed-off-by: Karl Beldan <karl.beldan@rivierawaves.com>
Cc: Helmut Schaa <helmut.schaa@googlemail.com>
Cc: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-23 19:06:34 +00:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2011-08-20 13:53:55 +00:00
|
|
|
void ieee80211_send_bar(struct ieee80211_vif *vif, u8 *ra, u16 tid, u16 ssn)
|
2009-02-10 20:25:46 +00:00
|
|
|
{
|
2011-08-20 13:53:55 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
2009-02-10 20:25:46 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_bar *bar;
|
|
|
|
u16 bar_control = 0;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
|
2011-08-29 21:17:31 +00:00
|
|
|
if (!skb)
|
2009-02-10 20:25:46 +00:00
|
|
|
return;
|
2011-08-29 21:17:31 +00:00
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
skb_reserve(skb, local->hw.extra_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
|
|
|
bar = skb_put_zero(skb, sizeof(*bar));
|
2009-02-10 20:25:46 +00:00
|
|
|
bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
|
|
|
|
IEEE80211_STYPE_BACK_REQ);
|
|
|
|
memcpy(bar->ra, ra, ETH_ALEN);
|
2009-11-25 16:46:19 +00:00
|
|
|
memcpy(bar->ta, sdata->vif.addr, ETH_ALEN);
|
2009-02-10 20:25:46 +00:00
|
|
|
bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
|
|
|
|
bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
|
2011-08-11 14:17:41 +00:00
|
|
|
bar_control |= (u16)(tid << IEEE80211_BAR_CTRL_TID_INFO_SHIFT);
|
2009-02-10 20:25:46 +00:00
|
|
|
bar->control = cpu_to_le16(bar_control);
|
|
|
|
bar->start_seq_num = cpu_to_le16(ssn);
|
|
|
|
|
2012-07-07 13:13:08 +00:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
|
|
|
|
IEEE80211_TX_CTL_REQ_TX_STATUS;
|
2011-12-15 09:18:34 +00:00
|
|
|
ieee80211_tx_skb_tid(sdata, skb, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
2011-08-20 13:53:55 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_send_bar);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2011-05-13 11:35:40 +00:00
|
|
|
void ieee80211_assign_tid_tx(struct sta_info *sta, int tid,
|
|
|
|
struct tid_ampdu_tx *tid_tx)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&sta->ampdu_mlme.mtx);
|
|
|
|
lockdep_assert_held(&sta->lock);
|
|
|
|
rcu_assign_pointer(sta->ampdu_mlme.tid_tx[tid], tid_tx);
|
|
|
|
}
|
|
|
|
|
2012-12-28 08:43:03 +00:00
|
|
|
/*
|
|
|
|
* When multiple aggregation sessions on multiple stations
|
|
|
|
* are being created/destroyed simultaneously, we need to
|
|
|
|
* refcount the global queue stop caused by that in order
|
|
|
|
* to not get into a situation where one of the aggregation
|
|
|
|
* setup or teardown re-enables queues before the other is
|
|
|
|
* ready to handle that.
|
|
|
|
*
|
|
|
|
* These two functions take care of this issue by keeping
|
|
|
|
* a global "agg_queue_stop" refcount.
|
|
|
|
*/
|
|
|
|
static void __acquires(agg_queue)
|
|
|
|
ieee80211_stop_queue_agg(struct ieee80211_sub_if_data *sdata, int tid)
|
|
|
|
{
|
|
|
|
int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
|
|
|
|
|
2014-06-13 13:30:05 +00:00
|
|
|
/* we do refcounting here, so don't use the queue reason refcounting */
|
|
|
|
|
2012-12-28 08:43:03 +00:00
|
|
|
if (atomic_inc_return(&sdata->local->agg_queue_stop[queue]) == 1)
|
|
|
|
ieee80211_stop_queue_by_reason(
|
|
|
|
&sdata->local->hw, queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
|
|
|
|
false);
|
2012-12-28 08:43:03 +00:00
|
|
|
__acquire(agg_queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __releases(agg_queue)
|
|
|
|
ieee80211_wake_queue_agg(struct ieee80211_sub_if_data *sdata, int tid)
|
|
|
|
{
|
|
|
|
int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
|
|
|
|
|
|
|
|
if (atomic_dec_return(&sdata->local->agg_queue_stop[queue]) == 0)
|
|
|
|
ieee80211_wake_queue_by_reason(
|
|
|
|
&sdata->local->hw, queue,
|
2014-06-13 13:30:05 +00:00
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
|
|
|
|
false);
|
2012-12-28 08:43:03 +00:00
|
|
|
__release(agg_queue);
|
|
|
|
}
|
|
|
|
|
2015-03-27 20:30:37 +00:00
|
|
|
static void
|
|
|
|
ieee80211_agg_stop_txq(struct sta_info *sta, int tid)
|
|
|
|
{
|
|
|
|
struct ieee80211_txq *txq = sta->sta.txq[tid];
|
2016-05-19 08:37:49 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct fq *fq;
|
2015-03-27 20:30:37 +00:00
|
|
|
struct txq_info *txqi;
|
|
|
|
|
|
|
|
if (!txq)
|
|
|
|
return;
|
|
|
|
|
|
|
|
txqi = to_txq_info(txq);
|
2016-05-19 08:37:49 +00:00
|
|
|
sdata = vif_to_sdata(txq->vif);
|
|
|
|
fq = &sdata->local->fq;
|
2015-03-27 20:30:37 +00:00
|
|
|
|
|
|
|
/* Lock here to protect against further seqno updates on dequeue */
|
2016-05-19 08:37:49 +00:00
|
|
|
spin_lock_bh(&fq->lock);
|
2015-03-27 20:30:37 +00:00
|
|
|
set_bit(IEEE80211_TXQ_STOP, &txqi->flags);
|
2016-05-19 08:37:49 +00:00
|
|
|
spin_unlock_bh(&fq->lock);
|
2015-03-27 20:30:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ieee80211_agg_start_txq(struct sta_info *sta, int tid, bool enable)
|
|
|
|
{
|
|
|
|
struct ieee80211_txq *txq = sta->sta.txq[tid];
|
|
|
|
struct txq_info *txqi;
|
|
|
|
|
|
|
|
if (!txq)
|
|
|
|
return;
|
|
|
|
|
|
|
|
txqi = to_txq_info(txq);
|
|
|
|
|
|
|
|
if (enable)
|
|
|
|
set_bit(IEEE80211_TXQ_AMPDU, &txqi->flags);
|
|
|
|
else
|
|
|
|
clear_bit(IEEE80211_TXQ_AMPDU, &txqi->flags);
|
|
|
|
|
|
|
|
clear_bit(IEEE80211_TXQ_STOP, &txqi->flags);
|
2017-06-22 10:20:28 +00:00
|
|
|
local_bh_disable();
|
|
|
|
rcu_read_lock();
|
2018-12-19 01:02:06 +00:00
|
|
|
schedule_and_wake_txq(sta->sdata->local, txqi);
|
2017-06-22 10:20:28 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
local_bh_enable();
|
2015-03-27 20:30:37 +00:00
|
|
|
}
|
|
|
|
|
2012-12-28 08:43:03 +00:00
|
|
|
/*
|
|
|
|
* splice packets from the STA's pending to the local pending,
|
|
|
|
* requires a call to ieee80211_agg_splice_finish later
|
|
|
|
*/
|
|
|
|
static void __acquires(agg_queue)
|
|
|
|
ieee80211_agg_splice_packets(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct tid_ampdu_tx *tid_tx, u16 tid)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
ieee80211_stop_queue_agg(sdata, tid);
|
|
|
|
|
|
|
|
if (WARN(!tid_tx,
|
|
|
|
"TID %d gone but expected when splicing aggregates from the pending queue\n",
|
|
|
|
tid))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!skb_queue_empty(&tid_tx->pending)) {
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
/* copy over remaining packets */
|
|
|
|
skb_queue_splice_tail_init(&tid_tx->pending,
|
|
|
|
&local->pending[queue]);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __releases(agg_queue)
|
|
|
|
ieee80211_agg_splice_finish(struct ieee80211_sub_if_data *sdata, u16 tid)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queue_agg(sdata, tid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_remove_tid_tx(struct sta_info *sta, int tid)
|
|
|
|
{
|
|
|
|
struct tid_ampdu_tx *tid_tx;
|
|
|
|
|
|
|
|
lockdep_assert_held(&sta->ampdu_mlme.mtx);
|
|
|
|
lockdep_assert_held(&sta->lock);
|
|
|
|
|
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we get here, the TX path will not be lockless any more wrt.
|
|
|
|
* aggregation, since the OPERATIONAL bit has long been cleared.
|
|
|
|
* Thus it will block on getting the lock, if it occurs. So if we
|
|
|
|
* stop the queue now, we will not get any more packets, and any
|
|
|
|
* that might be being processed will wait for us here, thereby
|
|
|
|
* guaranteeing that no packets go to the tid_tx pending queue any
|
|
|
|
* more.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ieee80211_agg_splice_packets(sta->sdata, tid_tx, tid);
|
|
|
|
|
|
|
|
/* future packets must not find the tid_tx struct any more */
|
|
|
|
ieee80211_assign_tid_tx(sta, tid, NULL);
|
|
|
|
|
|
|
|
ieee80211_agg_splice_finish(sta->sdata, tid);
|
2015-03-27 20:30:37 +00:00
|
|
|
ieee80211_agg_start_txq(sta, tid, false);
|
2012-12-28 08:43:03 +00:00
|
|
|
|
|
|
|
kfree_rcu(tid_tx, rcu_head);
|
|
|
|
}
|
|
|
|
|
2010-06-10 08:21:43 +00:00
|
|
|
int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
|
2012-07-18 11:31:31 +00:00
|
|
|
enum ieee80211_agg_stop_reason reason)
|
2009-02-10 20:25:50 +00:00
|
|
|
{
|
2009-02-10 20:25:54 +00:00
|
|
|
struct ieee80211_local *local = sta->local;
|
2011-05-13 12:15:49 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2015-12-30 14:06:04 +00:00
|
|
|
struct ieee80211_ampdu_params params = {
|
|
|
|
.sta = &sta->sta,
|
|
|
|
.tid = tid,
|
|
|
|
.buf_size = 0,
|
|
|
|
.amsdu = false,
|
|
|
|
.timeout = 0,
|
|
|
|
.ssn = 0,
|
|
|
|
};
|
2009-02-10 20:25:50 +00:00
|
|
|
int ret;
|
2010-06-10 08:21:39 +00:00
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
lockdep_assert_held(&sta->ampdu_mlme.mtx);
|
2010-06-10 08:21:39 +00:00
|
|
|
|
2012-07-18 11:51:25 +00:00
|
|
|
switch (reason) {
|
|
|
|
case AGG_STOP_DECLINED:
|
|
|
|
case AGG_STOP_LOCAL_REQUEST:
|
|
|
|
case AGG_STOP_PEER_REQUEST:
|
2015-12-30 14:06:04 +00:00
|
|
|
params.action = IEEE80211_AMPDU_TX_STOP_CONT;
|
2012-07-18 11:51:25 +00:00
|
|
|
break;
|
|
|
|
case AGG_STOP_DESTROY_STA:
|
2015-12-30 14:06:04 +00:00
|
|
|
params.action = IEEE80211_AMPDU_TX_STOP_FLUSH;
|
2012-07-18 11:51:25 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
2017-11-13 10:33:55 +00:00
|
|
|
/* free struct pending for start, if present */
|
|
|
|
tid_tx = sta->ampdu_mlme.tid_start_tx[tid];
|
|
|
|
kfree(tid_tx);
|
|
|
|
sta->ampdu_mlme.tid_start_tx[tid] = NULL;
|
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
|
|
|
if (!tid_tx) {
|
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2012-07-18 11:51:25 +00:00
|
|
|
/*
|
|
|
|
* if we're already stopping ignore any new requests to stop
|
|
|
|
* unless we're destroying it in which case notify the driver
|
|
|
|
*/
|
2011-11-24 19:06:14 +00:00
|
|
|
if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
|
|
|
|
spin_unlock_bh(&sta->lock);
|
2012-07-18 11:51:25 +00:00
|
|
|
if (reason != AGG_STOP_DESTROY_STA)
|
|
|
|
return -EALREADY;
|
2015-12-30 14:06:04 +00:00
|
|
|
params.action = IEEE80211_AMPDU_TX_STOP_FLUSH_CONT;
|
|
|
|
ret = drv_ampdu_action(local, sta->sdata, ¶ms);
|
2012-07-18 11:51:25 +00:00
|
|
|
WARN_ON_ONCE(ret);
|
mac80211: fix aggregation state with current drivers
For drivers that don't actually flush their queues when
aggregation stop with the IEEE80211_AMPDU_TX_STOP_FLUSH
or IEEE80211_AMPDU_TX_STOP_FLUSH_CONT reasons is done,
like iwlwifi or iwlegacy, mac80211 can then transmit on
a TID that the driver still considers busy. This happens
in the following way:
- IEEE80211_AMPDU_TX_STOP_FLUSH requested
- driver marks TID as emptying
- mac80211 removes tid_tx data, this can copy packets
to the TX pending queues and also let new packets
through to the driver
- driver gets unexpected TX as it wasn't completely
converted to the new API
In iwlwifi, this lead to the following warning:
WARNING: at drivers/net/wireless/iwlwifi/dvm/tx.c:442 iwlagn_tx_skb+0xc47/0xce0
Tx while agg.state = 4
Modules linked in: [...]
Pid: 0, comm: kworker/0:0 Tainted: G W 3.1.0 #1
Call Trace:
[<c1046e42>] warn_slowpath_common+0x72/0xa0
[<c1046f13>] warn_slowpath_fmt+0x33/0x40
[<fddffa17>] iwlagn_tx_skb+0xc47/0xce0 [iwldvm]
[<fddfcaa3>] iwlagn_mac_tx+0x23/0x40 [iwldvm]
[<fd8c98b6>] __ieee80211_tx+0xf6/0x3c0 [mac80211]
[<fd8cbe00>] ieee80211_tx+0xd0/0x100 [mac80211]
[<fd8cc176>] ieee80211_xmit+0x96/0xe0 [mac80211]
[<fd8cc578>] ieee80211_subif_start_xmit+0x348/0xc80 [mac80211]
[<c1445207>] dev_hard_start_xmit+0x337/0x6d0
[<c145eee9>] sch_direct_xmit+0xa9/0x210
[<c14462c0>] dev_queue_xmit+0x1b0/0x8e0
Fortunately, solving this problem is easy as the station
is being destroyed, so such transmit packets can only
happen due to races. Instead of trying to close the race
just let the race not reach the drivers by making two
changes:
1) remove the explicit aggregation session teardown in
the managed mode code, the same thing will be done
when the station is removed, in __sta_info_destroy.
2) When aggregation stop with AGG_STOP_DESTROY_STA is
requested, leave the tid_tx data around as stopped.
It will be cleared and freed in cleanup_single_sta
later, but until then any racy packets will be put
onto the tid_tx pending queue instead of transmitted
which is fine since the station is being removed.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-01-18 22:47:05 +00:00
|
|
|
return 0;
|
2011-11-24 19:06:14 +00:00
|
|
|
}
|
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
|
|
|
|
/* not even started yet! */
|
2011-05-13 11:35:40 +00:00
|
|
|
ieee80211_assign_tid_tx(sta, tid, NULL);
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
2011-03-15 10:02:42 +00:00
|
|
|
kfree_rcu(tid_tx, rcu_head);
|
2010-06-10 08:21:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-24 19:06:14 +00:00
|
|
|
set_bit(HT_AGG_STATE_STOPPING, &tid_tx->state);
|
|
|
|
|
2019-02-06 11:17:21 +00:00
|
|
|
ieee80211_agg_stop_txq(sta, tid);
|
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sta->sdata, "Tx BA session stop requested for %pM tid %u\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-11-22 11:28:41 +00:00
|
|
|
|
2010-10-05 19:40:33 +00:00
|
|
|
del_timer_sync(&tid_tx->addba_resp_timer);
|
2011-11-23 02:50:28 +00:00
|
|
|
del_timer_sync(&tid_tx->session_timer);
|
2010-10-05 19:40:33 +00:00
|
|
|
|
2010-06-10 08:21:39 +00:00
|
|
|
/*
|
|
|
|
* After this packets are no longer handed right through
|
|
|
|
* to the driver but are put onto tid_tx->pending instead,
|
|
|
|
* with locking to ensure proper access.
|
|
|
|
*/
|
|
|
|
clear_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
|
2009-06-09 08:41:46 +00:00
|
|
|
|
2011-11-27 13:29:44 +00:00
|
|
|
/*
|
|
|
|
* There might be a few packets being processed right now (on
|
|
|
|
* another CPU) that have already gotten past the aggregation
|
|
|
|
* check when it was still OPERATIONAL and consequently have
|
|
|
|
* IEEE80211_TX_CTL_AMPDU set. In that case, this code might
|
|
|
|
* call into the driver at the same time or even before the
|
|
|
|
* TX paths calls into it, which could confuse the driver.
|
|
|
|
*
|
|
|
|
* Wait for all currently running TX paths to finish before
|
|
|
|
* telling the driver. New packets will not go through since
|
|
|
|
* the aggregation session is no longer OPERATIONAL.
|
|
|
|
*/
|
2017-10-29 09:51:08 +00:00
|
|
|
if (!local->in_reconfig)
|
|
|
|
synchronize_net();
|
2011-11-27 13:29:44 +00:00
|
|
|
|
2012-07-18 11:31:31 +00:00
|
|
|
tid_tx->stop_initiator = reason == AGG_STOP_PEER_REQUEST ?
|
|
|
|
WLAN_BACK_RECIPIENT :
|
|
|
|
WLAN_BACK_INITIATOR;
|
|
|
|
tid_tx->tx_stop = reason == AGG_STOP_LOCAL_REQUEST;
|
2009-02-10 20:25:50 +00:00
|
|
|
|
2015-12-30 14:06:04 +00:00
|
|
|
ret = drv_ampdu_action(local, sta->sdata, ¶ms);
|
2009-02-10 20:25:50 +00:00
|
|
|
|
|
|
|
/* HW shall not deny going back to legacy */
|
|
|
|
if (WARN_ON(ret)) {
|
2009-03-23 16:28:41 +00:00
|
|
|
/*
|
|
|
|
* We may have pending packets get stuck in this case...
|
|
|
|
* Not bothering with a workaround for now.
|
|
|
|
*/
|
2009-02-10 20:25:50 +00:00
|
|
|
}
|
|
|
|
|
mac80211: fix aggregation state with current drivers
For drivers that don't actually flush their queues when
aggregation stop with the IEEE80211_AMPDU_TX_STOP_FLUSH
or IEEE80211_AMPDU_TX_STOP_FLUSH_CONT reasons is done,
like iwlwifi or iwlegacy, mac80211 can then transmit on
a TID that the driver still considers busy. This happens
in the following way:
- IEEE80211_AMPDU_TX_STOP_FLUSH requested
- driver marks TID as emptying
- mac80211 removes tid_tx data, this can copy packets
to the TX pending queues and also let new packets
through to the driver
- driver gets unexpected TX as it wasn't completely
converted to the new API
In iwlwifi, this lead to the following warning:
WARNING: at drivers/net/wireless/iwlwifi/dvm/tx.c:442 iwlagn_tx_skb+0xc47/0xce0
Tx while agg.state = 4
Modules linked in: [...]
Pid: 0, comm: kworker/0:0 Tainted: G W 3.1.0 #1
Call Trace:
[<c1046e42>] warn_slowpath_common+0x72/0xa0
[<c1046f13>] warn_slowpath_fmt+0x33/0x40
[<fddffa17>] iwlagn_tx_skb+0xc47/0xce0 [iwldvm]
[<fddfcaa3>] iwlagn_mac_tx+0x23/0x40 [iwldvm]
[<fd8c98b6>] __ieee80211_tx+0xf6/0x3c0 [mac80211]
[<fd8cbe00>] ieee80211_tx+0xd0/0x100 [mac80211]
[<fd8cc176>] ieee80211_xmit+0x96/0xe0 [mac80211]
[<fd8cc578>] ieee80211_subif_start_xmit+0x348/0xc80 [mac80211]
[<c1445207>] dev_hard_start_xmit+0x337/0x6d0
[<c145eee9>] sch_direct_xmit+0xa9/0x210
[<c14462c0>] dev_queue_xmit+0x1b0/0x8e0
Fortunately, solving this problem is easy as the station
is being destroyed, so such transmit packets can only
happen due to races. Instead of trying to close the race
just let the race not reach the drivers by making two
changes:
1) remove the explicit aggregation session teardown in
the managed mode code, the same thing will be done
when the station is removed, in __sta_info_destroy.
2) When aggregation stop with AGG_STOP_DESTROY_STA is
requested, leave the tid_tx data around as stopped.
It will be cleared and freed in cleanup_single_sta
later, but until then any racy packets will be put
onto the tid_tx pending queue instead of transmitted
which is fine since the station is being removed.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-01-18 22:47:05 +00:00
|
|
|
/*
|
|
|
|
* In the case of AGG_STOP_DESTROY_STA, the driver won't
|
|
|
|
* necessarily call ieee80211_stop_tx_ba_cb(), so this may
|
|
|
|
* seem like we can leave the tid_tx data pending forever.
|
|
|
|
* This is true, in a way, but "forever" is only until the
|
|
|
|
* station struct is actually destroyed. In the meantime,
|
|
|
|
* leaving it around ensures that we don't transmit packets
|
|
|
|
* to the driver on this TID which might confuse it.
|
|
|
|
*/
|
2012-07-18 11:51:25 +00:00
|
|
|
|
|
|
|
return 0;
|
2009-02-10 20:25:50 +00:00
|
|
|
}
|
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
/*
|
|
|
|
* After sending add Block Ack request we activated a timer until
|
|
|
|
* add Block Ack response will arrive from the recipient.
|
|
|
|
* If this timer expires sta_addba_resp_timer_expired will be executed.
|
|
|
|
*/
|
2017-10-17 20:25:45 +00:00
|
|
|
static void sta_addba_resp_timer_expired(struct timer_list *t)
|
2009-02-10 20:25:46 +00:00
|
|
|
{
|
2017-10-18 11:44:23 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx = from_timer(tid_tx, t, addba_resp_timer);
|
|
|
|
struct sta_info *sta = tid_tx->sta;
|
|
|
|
u8 tid = tid_tx->tid;
|
2009-02-10 20:25:50 +00:00
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
/* check if the TID waits for addBA response */
|
2017-10-18 11:44:23 +00:00
|
|
|
if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state)) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sta->sdata,
|
2017-08-05 08:44:30 +00:00
|
|
|
"timer expired on %pM tid %d not expecting addBA response\n",
|
2013-01-16 09:39:44 +00:00
|
|
|
sta->sta.addr, tid);
|
2009-02-10 20:25:50 +00:00
|
|
|
return;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sta->sdata, "addBA response timer expired on %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-06-10 08:21:47 +00:00
|
|
|
ieee80211_stop_tx_ba_session(&sta->sta, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2010-06-10 08:21:43 +00:00
|
|
|
void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid)
|
2010-06-10 08:21:42 +00:00
|
|
|
{
|
2011-05-13 12:15:49 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2010-06-10 08:21:42 +00:00
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2015-12-30 14:06:04 +00:00
|
|
|
struct ieee80211_ampdu_params params = {
|
|
|
|
.sta = &sta->sta,
|
|
|
|
.action = IEEE80211_AMPDU_TX_START,
|
|
|
|
.tid = tid,
|
|
|
|
.buf_size = 0,
|
|
|
|
.amsdu = false,
|
|
|
|
.timeout = 0,
|
|
|
|
};
|
2010-06-10 08:21:42 +00:00
|
|
|
int ret;
|
2018-06-09 06:14:44 +00:00
|
|
|
u16 buf_size;
|
2010-06-10 08:21:42 +00:00
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
2010-06-10 08:21:48 +00:00
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
/*
|
2011-12-07 08:02:21 +00:00
|
|
|
* Start queuing up packets for this aggregation session.
|
|
|
|
* We're going to release them once the driver is OK with
|
|
|
|
* that.
|
2010-06-10 08:21:42 +00:00
|
|
|
*/
|
|
|
|
clear_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
|
|
|
|
|
2015-03-27 20:30:37 +00:00
|
|
|
ieee80211_agg_stop_txq(sta, tid);
|
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
/*
|
2011-12-07 08:02:21 +00:00
|
|
|
* Make sure no packets are being processed. This ensures that
|
|
|
|
* we have a valid starting sequence number and that in-flight
|
|
|
|
* packets have been flushed out and no packets for this TID
|
|
|
|
* will go into the driver during the ampdu_action call.
|
2010-06-10 08:21:42 +00:00
|
|
|
*/
|
2010-06-10 08:21:48 +00:00
|
|
|
synchronize_net();
|
|
|
|
|
2015-12-30 14:06:04 +00:00
|
|
|
params.ssn = sta->tid_seq[tid] >> 4;
|
|
|
|
ret = drv_ampdu_action(local, sdata, ¶ms);
|
2019-10-02 09:12:25 +00:00
|
|
|
if (ret == IEEE80211_AMPDU_TX_START_IMMEDIATE) {
|
|
|
|
/*
|
|
|
|
* We didn't send the request yet, so don't need to check
|
|
|
|
* here if we already got a response, just mark as driver
|
|
|
|
* ready immediately.
|
|
|
|
*/
|
|
|
|
set_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state);
|
|
|
|
} else if (ret) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata,
|
2013-01-16 09:39:44 +00:00
|
|
|
"BA request denied - HW unavailable for %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_lock_bh(&sta->lock);
|
2012-04-03 14:28:50 +00:00
|
|
|
ieee80211_agg_splice_packets(sdata, tid_tx, tid);
|
2011-05-13 11:35:40 +00:00
|
|
|
ieee80211_assign_tid_tx(sta, tid, NULL);
|
2012-04-03 14:28:50 +00:00
|
|
|
ieee80211_agg_splice_finish(sdata, tid);
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
|
2015-03-27 20:30:37 +00:00
|
|
|
ieee80211_agg_start_txq(sta, tid, false);
|
|
|
|
|
2011-03-15 10:02:42 +00:00
|
|
|
kfree_rcu(tid_tx, rcu_head);
|
2010-06-10 08:21:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* activate the timer for the recipient's addBA response */
|
|
|
|
mod_timer(&tid_tx->addba_resp_timer, jiffies + ADDBA_RESP_INTERVAL);
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sdata, "activated addBA response timer on %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2010-06-10 08:21:42 +00:00
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_lock_bh(&sta->lock);
|
2011-12-18 00:39:35 +00:00
|
|
|
sta->ampdu_mlme.last_addba_req_time[tid] = jiffies;
|
2010-06-10 08:21:42 +00:00
|
|
|
sta->ampdu_mlme.addba_req_num[tid]++;
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
2010-06-10 08:21:42 +00:00
|
|
|
|
2018-06-09 06:14:44 +00:00
|
|
|
if (sta->sta.he_cap.has_he) {
|
|
|
|
buf_size = local->hw.max_tx_aggregation_subframes;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We really should use what the driver told us it will
|
|
|
|
* transmit as the maximum, but certain APs (e.g. the
|
|
|
|
* LinkSys WRT120N with FW v1.0.07 build 002 Jun 18 2012)
|
|
|
|
* will crash when we use a lower number.
|
|
|
|
*/
|
|
|
|
buf_size = IEEE80211_MAX_AMPDU_BUF_HT;
|
|
|
|
}
|
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
/* send AddBA request */
|
|
|
|
ieee80211_send_addba_request(sdata, sta->sta.addr, tid,
|
2015-12-30 14:06:04 +00:00
|
|
|
tid_tx->dialog_token, params.ssn,
|
2018-06-09 06:14:44 +00:00
|
|
|
buf_size, tid_tx->timeout);
|
2010-06-10 08:21:42 +00:00
|
|
|
}
|
|
|
|
|
2011-11-23 02:50:28 +00:00
|
|
|
/*
|
|
|
|
* After accepting the AddBA Response we activated a timer,
|
|
|
|
* resetting it after each frame that we send.
|
|
|
|
*/
|
2017-10-17 20:25:45 +00:00
|
|
|
static void sta_tx_agg_session_timer_expired(struct timer_list *t)
|
2011-11-23 02:50:28 +00:00
|
|
|
{
|
2017-10-18 11:44:23 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx = from_timer(tid_tx, t, session_timer);
|
|
|
|
struct sta_info *sta = tid_tx->sta;
|
|
|
|
u8 tid = tid_tx->tid;
|
2012-03-18 21:58:06 +00:00
|
|
|
unsigned long timeout;
|
|
|
|
|
2017-10-18 11:44:23 +00:00
|
|
|
if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
|
2012-03-18 21:58:06 +00:00
|
|
|
return;
|
2012-05-07 15:57:36 +00:00
|
|
|
}
|
2012-03-18 21:58:06 +00:00
|
|
|
|
|
|
|
timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);
|
|
|
|
if (time_is_after_jiffies(timeout)) {
|
|
|
|
mod_timer(&tid_tx->session_timer, timeout);
|
|
|
|
return;
|
|
|
|
}
|
2011-11-23 02:50:28 +00:00
|
|
|
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sta->sdata, "tx session timer expired on %pM tid %d\n",
|
2017-10-17 20:25:45 +00:00
|
|
|
sta->sta.addr, tid);
|
2011-11-23 02:50:28 +00:00
|
|
|
|
2017-10-17 20:25:45 +00:00
|
|
|
ieee80211_stop_tx_ba_session(&sta->sta, tid);
|
2011-11-23 02:50:28 +00:00
|
|
|
}
|
|
|
|
|
2010-12-15 02:17:10 +00:00
|
|
|
int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
|
|
|
|
u16 timeout)
|
2009-02-10 20:25:46 +00:00
|
|
|
{
|
2009-11-16 11:00:38 +00:00
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-06-10 08:21:39 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2009-03-23 16:28:42 +00:00
|
|
|
int ret = 0;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2015-03-09 10:13:04 +00:00
|
|
|
trace_api_start_tx_ba_session(pubsta, tid);
|
|
|
|
|
2014-11-19 11:47:38 +00:00
|
|
|
if (WARN(sta->reserved_tid == tid,
|
|
|
|
"Requested to start BA session on reserved tid=%d", tid))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-03-09 10:13:04 +00:00
|
|
|
if (!pubsta->ht_cap.ht_supported)
|
|
|
|
return -EINVAL;
|
2010-04-07 14:48:40 +00:00
|
|
|
|
2012-12-07 06:49:34 +00:00
|
|
|
if (WARN_ON_ONCE(!local->ops->ampdu_action))
|
2009-02-10 20:25:50 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-11-14 22:22:21 +00:00
|
|
|
if ((tid >= IEEE80211_NUM_TIDS) ||
|
2015-06-02 19:39:54 +00:00
|
|
|
!ieee80211_hw_check(&local->hw, AMPDU_AGGREGATION) ||
|
|
|
|
ieee80211_hw_check(&local->hw, TX_AMPDU_SETUP_IN_HW))
|
2009-02-10 20:25:46 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-09-14 09:38:31 +00:00
|
|
|
if (WARN_ON(tid >= IEEE80211_FIRST_TSPEC_TSID))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata, "Open BA session requested for %pM tid %u\n",
|
|
|
|
pubsta->addr, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2009-11-16 11:00:38 +00:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION &&
|
2011-10-26 21:47:29 +00:00
|
|
|
sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
|
2009-11-16 11:00:38 +00:00
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
2011-11-30 15:56:34 +00:00
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_ADHOC)
|
2009-11-16 11:00:38 +00:00
|
|
|
return -EINVAL;
|
2009-02-10 20:25:47 +00:00
|
|
|
|
2011-09-29 14:04:36 +00:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata,
|
2013-01-16 09:39:44 +00:00
|
|
|
"BA sessions blocked - Denying BA session request %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-11-16 11:00:38 +00:00
|
|
|
return -EINVAL;
|
2009-03-17 03:20:06 +00:00
|
|
|
}
|
|
|
|
|
2011-11-30 15:56:33 +00:00
|
|
|
/*
|
|
|
|
* 802.11n-2009 11.5.1.1: If the initiating STA is an HT STA, is a
|
|
|
|
* member of an IBSS, and has no other existing Block Ack agreement
|
|
|
|
* with the recipient STA, then the initiating STA shall transmit a
|
|
|
|
* Probe Request frame to the recipient STA and shall not transmit an
|
|
|
|
* ADDBA Request frame unless it receives a Probe Response frame
|
|
|
|
* from the recipient within dot11ADDBAFailureTimeout.
|
|
|
|
*
|
|
|
|
* The probe request mechanism for ADDBA is currently not implemented,
|
|
|
|
* but we only build up Block Ack session with HT STAs. This information
|
|
|
|
* is set when we receive a bss info from a probe response or a beacon.
|
|
|
|
*/
|
|
|
|
if (sta->sdata->vif.type == NL80211_IFTYPE_ADHOC &&
|
|
|
|
!sta->sta.ht_cap.ht_supported) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata,
|
|
|
|
"BA request denied - IBSS STA %pM does not advertise HT support\n",
|
|
|
|
pubsta->addr);
|
2011-11-30 15:56:33 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
|
|
|
/* we have tried too many times, receiver does not want A-MPDU */
|
|
|
|
if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) {
|
|
|
|
ret = -EBUSY;
|
2011-12-18 00:39:35 +00:00
|
|
|
goto err_unlock_sta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if we have tried more than HT_AGG_BURST_RETRIES times we
|
|
|
|
* will spread our requests in time to avoid stalling connection
|
|
|
|
* for too long
|
|
|
|
*/
|
|
|
|
if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_BURST_RETRIES &&
|
|
|
|
time_before(jiffies, sta->ampdu_mlme.last_addba_req_time[tid] +
|
|
|
|
HT_AGG_RETRIES_PERIOD)) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata,
|
2017-08-05 08:44:30 +00:00
|
|
|
"BA request denied - %d failed requests on %pM tid %u\n",
|
2013-01-16 09:39:44 +00:00
|
|
|
sta->ampdu_mlme.addba_req_num[tid], sta->sta.addr, tid);
|
2011-12-18 00:39:35 +00:00
|
|
|
ret = -EBUSY;
|
2009-02-10 20:25:46 +00:00
|
|
|
goto err_unlock_sta;
|
|
|
|
}
|
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
/* check if the TID is not in aggregation flow already */
|
2011-05-13 11:35:40 +00:00
|
|
|
if (tid_tx || sta->ampdu_mlme.tid_start_tx[tid]) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata,
|
2013-01-16 09:39:44 +00:00
|
|
|
"BA request denied - session is not idle on %pM tid %u\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto err_unlock_sta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* prepare A-MPDU MLME for Tx aggregation */
|
2010-06-10 08:21:39 +00:00
|
|
|
tid_tx = kzalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
|
|
|
|
if (!tid_tx) {
|
2009-02-10 20:25:46 +00:00
|
|
|
ret = -ENOMEM;
|
2010-06-10 08:21:42 +00:00
|
|
|
goto err_unlock_sta;
|
2009-02-10 20:25:46 +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
|
|
|
|
2010-06-10 08:21:39 +00:00
|
|
|
skb_queue_head_init(&tid_tx->pending);
|
2010-06-10 08:21:42 +00:00
|
|
|
__set_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
|
2009-03-23 16:28:41 +00:00
|
|
|
|
2010-12-15 02:17:10 +00:00
|
|
|
tid_tx->timeout = timeout;
|
2017-10-17 20:25:45 +00:00
|
|
|
tid_tx->sta = sta;
|
|
|
|
tid_tx->tid = tid;
|
2010-12-15 02:17:10 +00:00
|
|
|
|
2011-11-23 02:50:28 +00:00
|
|
|
/* response timer */
|
2017-10-17 20:25:45 +00:00
|
|
|
timer_setup(&tid_tx->addba_resp_timer, sta_addba_resp_timer_expired, 0);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2011-11-23 02:50:28 +00:00
|
|
|
/* tx timer */
|
2017-10-17 20:25:45 +00:00
|
|
|
timer_setup(&tid_tx->session_timer,
|
|
|
|
sta_tx_agg_session_timer_expired, TIMER_DEFERRABLE);
|
2011-11-23 02:50:28 +00:00
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
/* assign a dialog token */
|
2009-02-10 20:25:46 +00:00
|
|
|
sta->ampdu_mlme.dialog_token_allocator++;
|
2010-06-10 08:21:39 +00:00
|
|
|
tid_tx->dialog_token = sta->ampdu_mlme.dialog_token_allocator;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2011-05-13 11:35:40 +00:00
|
|
|
/*
|
|
|
|
* Finally, assign it to the start array; the work item will
|
|
|
|
* collect it and move it to the normal array.
|
|
|
|
*/
|
|
|
|
sta->ampdu_mlme.tid_start_tx[tid] = tid_tx;
|
2010-05-31 10:00:12 +00:00
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
/* this flow continues off the work */
|
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
|
|
|
err_unlock_sta:
|
2009-02-10 20:25:46 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
|
|
|
|
|
2009-03-23 16:28:39 +00:00
|
|
|
static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta, u16 tid)
|
|
|
|
{
|
2011-05-13 12:15:49 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2015-12-30 14:06:04 +00:00
|
|
|
struct ieee80211_ampdu_params params = {
|
|
|
|
.sta = &sta->sta,
|
|
|
|
.action = IEEE80211_AMPDU_TX_OPERATIONAL,
|
|
|
|
.tid = tid,
|
|
|
|
.timeout = 0,
|
|
|
|
.ssn = 0,
|
|
|
|
};
|
2011-05-13 12:15:49 +00:00
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
lockdep_assert_held(&sta->ampdu_mlme.mtx);
|
2010-06-10 08:21:39 +00:00
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
2015-12-30 14:06:04 +00:00
|
|
|
params.buf_size = tid_tx->buf_size;
|
|
|
|
params.amsdu = tid_tx->amsdu;
|
2011-05-13 12:15:49 +00:00
|
|
|
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sta->sdata, "Aggregation is on for %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-03-23 16:28:39 +00:00
|
|
|
|
2015-12-30 14:06:04 +00:00
|
|
|
drv_ampdu_action(local, sta->sdata, ¶ms);
|
2010-06-10 08:21:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* synchronize with TX path, while splicing the TX path
|
|
|
|
* should block so it won't put more packets onto pending.
|
|
|
|
*/
|
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
2012-04-03 14:28:50 +00:00
|
|
|
ieee80211_agg_splice_packets(sta->sdata, tid_tx, tid);
|
2009-03-23 16:28:41 +00:00
|
|
|
/*
|
2010-06-10 08:21:39 +00:00
|
|
|
* Now mark as operational. This will be visible
|
|
|
|
* in the TX path, and lets it go lock-free in
|
|
|
|
* the common case.
|
2009-03-23 16:28:41 +00:00
|
|
|
*/
|
2011-05-13 12:15:49 +00:00
|
|
|
set_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
|
2012-04-03 14:28:50 +00:00
|
|
|
ieee80211_agg_splice_finish(sta->sdata, tid);
|
2009-03-23 16:28:39 +00:00
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
2015-03-27 20:30:37 +00:00
|
|
|
|
|
|
|
ieee80211_agg_start_txq(sta, tid, true);
|
2009-03-23 16:28:39 +00:00
|
|
|
}
|
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
void ieee80211_start_tx_ba_cb(struct sta_info *sta, int tid,
|
|
|
|
struct tid_ampdu_tx *tid_tx)
|
2009-02-10 20:25:46 +00:00
|
|
|
{
|
2017-05-26 22:27:25 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2009-11-16 11:00:38 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
if (WARN_ON(test_and_set_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state))
|
|
|
|
ieee80211_agg_tx_operational(local, sta, tid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tid_ampdu_tx *
|
|
|
|
ieee80211_lookup_tid_tx(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *ra, u16 tid, struct sta_info **sta)
|
|
|
|
{
|
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2010-04-07 14:48:40 +00:00
|
|
|
|
2012-11-14 22:22:21 +00:00
|
|
|
if (tid >= IEEE80211_NUM_TIDS) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata, "Bad TID value: tid = %d (>= %d)\n",
|
2012-11-14 22:22:21 +00:00
|
|
|
tid, IEEE80211_NUM_TIDS);
|
2017-05-26 22:27:25 +00:00
|
|
|
return NULL;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
*sta = sta_info_get_bss(sdata, ra);
|
|
|
|
if (!*sta) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata, "Could not find station: %pM\n", ra);
|
2017-05-26 22:27:25 +00:00
|
|
|
return NULL;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
tid_tx = rcu_dereference((*sta)->ampdu_mlme.tid_tx[tid]);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
if (WARN_ON(!tid_tx))
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sdata, "addBA was not requested!\n");
|
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
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
return tid_tx;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2009-11-16 11:00:38 +00:00
|
|
|
void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
|
2009-02-10 20:25:49 +00:00
|
|
|
const u8 *ra, u16 tid)
|
|
|
|
{
|
2009-11-16 11:00:38 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2017-05-26 22:27:25 +00:00
|
|
|
struct sta_info *sta;
|
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2009-02-10 20:25:49 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
trace_api_start_tx_ba_cb(sdata, ra, tid);
|
2011-08-29 21:17:31 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
tid_tx = ieee80211_lookup_tid_tx(sdata, ra, tid, &sta);
|
|
|
|
if (!tid_tx)
|
|
|
|
goto out;
|
2009-02-10 20:25:49 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
set_bit(HT_AGG_STATE_START_CB, &tid_tx->state);
|
|
|
|
ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
2009-02-10 20:25:49 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
|
|
|
|
|
2009-02-10 20:25:54 +00:00
|
|
|
int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
|
2012-07-18 11:31:31 +00:00
|
|
|
enum ieee80211_agg_stop_reason reason)
|
2009-02-10 20:25:54 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
mutex_lock(&sta->ampdu_mlme.mtx);
|
2009-02-10 20:25:54 +00:00
|
|
|
|
2012-07-18 11:31:31 +00:00
|
|
|
ret = ___ieee80211_stop_tx_ba_session(sta, tid, reason);
|
2009-02-10 20:25:54 +00:00
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
mutex_unlock(&sta->ampdu_mlme.mtx);
|
|
|
|
|
2009-02-10 20:25:54 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-05-27 12:41:07 +00:00
|
|
|
int ieee80211_stop_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid)
|
2009-02-10 20:25:46 +00:00
|
|
|
{
|
2009-11-16 11:00:38 +00:00
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-06-10 08:21:42 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
|
|
|
int ret = 0;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-05-27 12:41:07 +00:00
|
|
|
trace_api_stop_tx_ba_session(pubsta, tid);
|
2010-04-07 14:48:40 +00:00
|
|
|
|
2009-11-20 08:15:51 +00:00
|
|
|
if (!local->ops->ampdu_action)
|
2009-02-10 20:25:50 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-11-14 22:22:21 +00:00
|
|
|
if (tid >= IEEE80211_NUM_TIDS)
|
2009-02-10 20:25:46 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
spin_lock_bh(&sta->lock);
|
2011-05-13 12:15:49 +00:00
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
2010-06-10 08:21:42 +00:00
|
|
|
|
|
|
|
if (!tid_tx) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2014-11-19 11:47:38 +00:00
|
|
|
WARN(sta->reserved_tid == tid,
|
|
|
|
"Requested to stop BA session on reserved tid=%d", tid);
|
|
|
|
|
2010-06-10 08:21:42 +00:00
|
|
|
if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
|
|
|
|
/* already in progress stopping it */
|
|
|
|
ret = 0;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state);
|
|
|
|
ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
return ret;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
|
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
void ieee80211_stop_tx_ba_cb(struct sta_info *sta, int tid,
|
|
|
|
struct tid_ampdu_tx *tid_tx)
|
2009-02-10 20:25:46 +00:00
|
|
|
{
|
2017-05-26 22:27:25 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2015-03-12 18:28:31 +00:00
|
|
|
bool send_delba = false;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
ht_dbg(sdata, "Stopping Tx BA session for %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-06-10 08:21:39 +00:00
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
if (!test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sdata,
|
|
|
|
"unexpected callback to A-MPDU stop for %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2010-06-10 08:21:48 +00:00
|
|
|
goto unlock_sta;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2010-10-05 17:37:40 +00:00
|
|
|
if (tid_tx->stop_initiator == WLAN_BACK_INITIATOR && tid_tx->tx_stop)
|
2015-03-12 18:28:31 +00:00
|
|
|
send_delba = true;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2012-07-18 12:12:44 +00:00
|
|
|
ieee80211_remove_tid_tx(sta, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
unlock_sta:
|
2010-06-10 08:21:39 +00:00
|
|
|
spin_unlock_bh(&sta->lock);
|
2015-03-12 18:28:31 +00:00
|
|
|
|
|
|
|
if (send_delba)
|
2017-05-26 22:27:25 +00:00
|
|
|
ieee80211_send_delba(sdata, sta->sta.addr, tid,
|
2015-03-12 18:28:31 +00:00
|
|
|
WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2009-11-16 11:00:38 +00:00
|
|
|
void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
|
2009-02-10 20:25:46 +00:00
|
|
|
const u8 *ra, u16 tid)
|
|
|
|
{
|
2009-11-16 11:00:38 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2017-05-26 22:27:25 +00:00
|
|
|
struct sta_info *sta;
|
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
trace_api_stop_tx_ba_cb(sdata, ra, tid);
|
2011-08-29 21:17:31 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
tid_tx = ieee80211_lookup_tid_tx(sdata, ra, tid, &sta);
|
|
|
|
if (!tid_tx)
|
|
|
|
goto out;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2017-05-26 22:27:25 +00:00
|
|
|
set_bit(HT_AGG_STATE_STOP_CB, &tid_tx->state);
|
|
|
|
ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
|
|
|
|
|
2009-02-10 20:25:49 +00:00
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
void ieee80211_process_addba_resp(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len)
|
|
|
|
{
|
2010-06-10 08:21:39 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2016-03-03 21:59:00 +00:00
|
|
|
struct ieee80211_txq *txq;
|
2018-06-09 06:14:44 +00:00
|
|
|
u16 capab, tid, buf_size;
|
2015-08-16 08:13:22 +00:00
|
|
|
bool amsdu;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
|
|
|
capab = le16_to_cpu(mgmt->u.action.u.addba_resp.capab);
|
2015-08-16 08:13:22 +00:00
|
|
|
amsdu = capab & IEEE80211_ADDBA_PARAM_AMSDU_MASK;
|
2009-02-10 20:25:46 +00:00
|
|
|
tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
|
2011-01-18 12:51:05 +00:00
|
|
|
buf_size = (capab & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK) >> 6;
|
2015-11-17 08:24:38 +00:00
|
|
|
buf_size = min(buf_size, local->hw.max_tx_aggregation_subframes);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2016-03-03 21:59:00 +00:00
|
|
|
txq = sta->sta.txq[tid];
|
|
|
|
if (!amsdu && txq)
|
|
|
|
set_bit(IEEE80211_TXQ_NO_AMSDU, &to_txq_info(txq)->flags);
|
|
|
|
|
2010-06-10 08:21:48 +00:00
|
|
|
mutex_lock(&sta->ampdu_mlme.mtx);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
|
2010-06-10 08:21:39 +00:00
|
|
|
if (!tid_tx)
|
2009-11-18 16:15:06 +00:00
|
|
|
goto out;
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2010-06-10 08:21:39 +00:00
|
|
|
if (mgmt->u.action.u.addba_resp.dialog_token != tid_tx->dialog_token) {
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sta->sdata, "wrong addBA response token, %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2009-11-18 16:15:06 +00:00
|
|
|
goto out;
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
|
|
|
|
2011-11-28 08:18:00 +00:00
|
|
|
del_timer_sync(&tid_tx->addba_resp_timer);
|
2009-11-18 16:15:06 +00:00
|
|
|
|
2013-01-16 09:39:44 +00:00
|
|
|
ht_dbg(sta->sdata, "switched off addBA timer for %pM tid %d\n",
|
|
|
|
sta->sta.addr, tid);
|
2011-11-28 08:18:00 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* addba_resp_timer may have fired before we got here, and
|
|
|
|
* caused WANT_STOP to be set. If the stop then was already
|
|
|
|
* processed further, STOPPING might be set.
|
|
|
|
*/
|
|
|
|
if (test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state) ||
|
|
|
|
test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
|
2012-06-22 09:29:50 +00:00
|
|
|
ht_dbg(sta->sdata,
|
2013-01-16 09:39:44 +00:00
|
|
|
"got addBA resp for %pM tid %d but we already gave up\n",
|
|
|
|
sta->sta.addr, tid);
|
2011-11-28 08:18:00 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-07-26 10:18:27 +00:00
|
|
|
/*
|
|
|
|
* IEEE 802.11-2007 7.3.1.14:
|
|
|
|
* In an ADDBA Response frame, when the Status Code field
|
|
|
|
* is set to 0, the Buffer Size subfield is set to a value
|
|
|
|
* of at least 1.
|
|
|
|
*/
|
2009-02-10 20:25:46 +00:00
|
|
|
if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
|
2011-07-26 10:18:27 +00:00
|
|
|
== WLAN_STATUS_SUCCESS && buf_size) {
|
2010-06-10 08:21:39 +00:00
|
|
|
if (test_and_set_bit(HT_AGG_STATE_RESPONSE_RECEIVED,
|
|
|
|
&tid_tx->state)) {
|
|
|
|
/* ignore duplicate response */
|
|
|
|
goto out;
|
|
|
|
}
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2011-01-18 12:51:05 +00:00
|
|
|
tid_tx->buf_size = buf_size;
|
2015-08-16 08:13:22 +00:00
|
|
|
tid_tx->amsdu = amsdu;
|
2011-01-18 12:51:05 +00:00
|
|
|
|
2010-06-10 08:21:39 +00:00
|
|
|
if (test_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state))
|
2009-03-23 16:28:39 +00:00
|
|
|
ieee80211_agg_tx_operational(local, sta, tid);
|
2009-02-10 20:25:46 +00:00
|
|
|
|
2009-03-23 16:28:39 +00:00
|
|
|
sta->ampdu_mlme.addba_req_num[tid] = 0;
|
2011-11-23 02:50:28 +00:00
|
|
|
|
2018-04-20 10:49:19 +00:00
|
|
|
tid_tx->timeout =
|
|
|
|
le16_to_cpu(mgmt->u.action.u.addba_resp.timeout);
|
|
|
|
|
2012-03-18 21:58:06 +00:00
|
|
|
if (tid_tx->timeout) {
|
2011-11-23 02:50:28 +00:00
|
|
|
mod_timer(&tid_tx->session_timer,
|
|
|
|
TU_TO_EXP_TIME(tid_tx->timeout));
|
2012-03-18 21:58:06 +00:00
|
|
|
tid_tx->last_tx = jiffies;
|
|
|
|
}
|
2011-11-23 02:50:28 +00:00
|
|
|
|
2009-02-10 20:25:46 +00:00
|
|
|
} else {
|
2012-07-18 11:31:31 +00:00
|
|
|
___ieee80211_stop_tx_ba_session(sta, tid, AGG_STOP_DECLINED);
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|
2009-10-29 07:34:00 +00:00
|
|
|
|
|
|
|
out:
|
2010-06-10 08:21:48 +00:00
|
|
|
mutex_unlock(&sta->ampdu_mlme.mtx);
|
2009-02-10 20:25:46 +00:00
|
|
|
}
|