2009-02-10 21:25:46 +01: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>
|
|
|
|
* Copyright 2007-2009, Intel Corporation
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2009-02-10 21:25:46 +01:00
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 18:52:52 +02:00
|
|
|
#include "driver-ops.h"
|
2009-02-10 21:25:46 +01:00
|
|
|
#include "wme.h"
|
|
|
|
|
2009-02-10 21:25:49 +01:00
|
|
|
/**
|
|
|
|
* DOC: TX aggregation
|
|
|
|
*
|
|
|
|
* Aggregation on the TX side requires setting the hardware flag
|
|
|
|
* %IEEE80211_HW_AMPDU_AGGREGATION as well as, if present, the @ampdu_queues
|
|
|
|
* hardware parameter to the number of hardware AMPDU queues. If there are no
|
|
|
|
* hardware queues then the driver will (currently) have to do all frame
|
|
|
|
* buffering.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* In response to that, the driver is later required to call the
|
|
|
|
* ieee80211_start_tx_ba_cb() (or ieee80211_start_tx_ba_cb_irqsafe())
|
|
|
|
* function, which will start the aggregation session.
|
|
|
|
*
|
|
|
|
* Similarly, when the aggregation session is stopped by
|
|
|
|
* 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()
|
|
|
|
* (or ieee80211_stop_tx_ba_cb_irqsafe()).
|
|
|
|
*/
|
|
|
|
|
2009-02-10 21:25:46 +01: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);
|
|
|
|
|
|
|
|
if (!skb) {
|
|
|
|
printk(KERN_ERR "%s: failed to allocate buffer "
|
2009-11-25 17:46:19 +01:00
|
|
|
"for addba request frame\n", sdata->name);
|
2009-02-10 21:25:46 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
|
|
|
|
memset(mgmt, 0, 24);
|
|
|
|
memcpy(mgmt->da, da, ETH_ALEN);
|
2009-11-25 17:46:19 +01:00
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
2009-02-10 21:25:47 +01:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
2009-11-25 17:46:19 +01:00
|
|
|
memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
|
2009-02-15 12:44:28 +01:00
|
|
|
else if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
|
2009-02-10 21:25:46 +01: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;
|
|
|
|
capab = (u16)(1 << 1); /* bit 1 aggregation policy */
|
|
|
|
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);
|
|
|
|
|
2009-11-18 18:42:05 +01:00
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
if (!skb) {
|
|
|
|
printk(KERN_ERR "%s: failed to allocate buffer for "
|
2009-11-25 17:46:19 +01:00
|
|
|
"bar frame\n", sdata->name);
|
2009-02-10 21:25:46 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar));
|
|
|
|
memset(bar, 0, sizeof(*bar));
|
|
|
|
bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
|
|
|
|
IEEE80211_STYPE_BACK_REQ);
|
|
|
|
memcpy(bar->ra, ra, ETH_ALEN);
|
2009-11-25 17:46:19 +01:00
|
|
|
memcpy(bar->ta, sdata->vif.addr, ETH_ALEN);
|
2009-02-10 21:25:46 +01:00
|
|
|
bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
|
|
|
|
bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
|
|
|
|
bar_control |= (u16)(tid << 12);
|
|
|
|
bar->control = cpu_to_le16(bar_control);
|
|
|
|
bar->start_seq_num = cpu_to_le16(ssn);
|
|
|
|
|
2009-11-18 18:42:05 +01:00
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
|
|
|
|
2009-11-22 12:28:41 +01:00
|
|
|
int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
|
|
|
|
enum ieee80211_back_parties initiator)
|
2009-02-10 21:25:50 +01:00
|
|
|
{
|
2009-02-10 21:25:54 +01:00
|
|
|
struct ieee80211_local *local = sta->local;
|
2009-02-10 21:25:50 +01:00
|
|
|
int ret;
|
|
|
|
u8 *state;
|
|
|
|
|
2009-11-22 12:28:41 +01:00
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Tx BA session stop requested for %pM tid %u\n",
|
|
|
|
sta->sta.addr, tid);
|
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
|
|
|
|
2009-02-10 21:25:50 +01:00
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
|
|
|
|
2009-06-09 10:41:46 +02:00
|
|
|
if (*state == HT_AGG_STATE_OPERATIONAL)
|
|
|
|
sta->ampdu_mlme.addba_req_num[tid] = 0;
|
|
|
|
|
2009-02-10 21:25:50 +01:00
|
|
|
*state = HT_AGG_STATE_REQ_STOP_BA_MSK |
|
|
|
|
(initiator << HT_AGG_STATE_INITIATOR_SHIFT);
|
|
|
|
|
2009-11-25 20:30:31 +01:00
|
|
|
ret = drv_ampdu_action(local, sta->sdata,
|
2009-11-16 12:00:38 +01:00
|
|
|
IEEE80211_AMPDU_TX_STOP,
|
2009-04-23 18:52:52 +02:00
|
|
|
&sta->sta, tid, NULL);
|
2009-02-10 21:25:50 +01:00
|
|
|
|
|
|
|
/* HW shall not deny going back to legacy */
|
|
|
|
if (WARN_ON(ret)) {
|
2009-03-23 17:28:41 +01:00
|
|
|
/*
|
|
|
|
* We may have pending packets get stuck in this case...
|
|
|
|
* Not bothering with a workaround for now.
|
|
|
|
*/
|
2009-02-10 21:25:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-02-10 21:25:46 +01: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.
|
|
|
|
*/
|
|
|
|
static void sta_addba_resp_timer_expired(unsigned long data)
|
|
|
|
{
|
|
|
|
/* not an elegant detour, but there is no choice as the timer passes
|
|
|
|
* only one argument, and both sta_info and TID are needed, so init
|
|
|
|
* flow in sta_info_create gives the TID as data, while the timer_to_id
|
|
|
|
* array gives the sta through container_of */
|
|
|
|
u16 tid = *(u8 *)data;
|
2009-02-10 21:25:50 +01:00
|
|
|
struct sta_info *sta = container_of((void *)data,
|
2009-02-10 21:25:46 +01:00
|
|
|
struct sta_info, timer_to_tid[tid]);
|
|
|
|
u8 *state;
|
|
|
|
|
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
2009-02-10 21:25:50 +01:00
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
/* check if the TID waits for addBA response */
|
|
|
|
spin_lock_bh(&sta->lock);
|
2009-12-28 09:57:15 +01:00
|
|
|
if ((*state & (HT_ADDBA_REQUESTED_MSK | HT_ADDBA_RECEIVED_MSK |
|
|
|
|
HT_AGG_STATE_REQ_STOP_BA_MSK)) !=
|
2009-11-18 17:15:06 +01:00
|
|
|
HT_ADDBA_REQUESTED_MSK) {
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "timer expired on tid %d but we are not "
|
2010-04-19 11:03:13 +02:00
|
|
|
"(or no longer) expecting addBA response there\n",
|
2009-11-18 17:15:06 +01:00
|
|
|
tid);
|
2009-02-10 21:25:46 +01:00
|
|
|
#endif
|
2009-02-10 21:25:50 +01:00
|
|
|
return;
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "addBA response timer expired on tid %d\n", tid);
|
|
|
|
#endif
|
|
|
|
|
2009-02-10 21:25:54 +01:00
|
|
|
___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR);
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
}
|
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
static inline int ieee80211_ac_from_tid(int tid)
|
|
|
|
{
|
|
|
|
return ieee802_1d_to_ac[tid & 7];
|
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid)
|
2009-02-10 21:25:46 +01:00
|
|
|
{
|
2009-11-16 12:00:38 +01: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;
|
2009-02-10 21:25:46 +01:00
|
|
|
u8 *state;
|
2009-03-23 17:28:42 +01:00
|
|
|
int ret = 0;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
u16 start_seq_num;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_start_tx_ba_session(pubsta, tid);
|
|
|
|
|
2009-02-10 21:25:50 +01:00
|
|
|
if (WARN_ON(!local->ops->ampdu_action))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
if ((tid >= STA_TID_NUM) ||
|
|
|
|
!(local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION))
|
2009-02-10 21:25:46 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Open BA session requested for %pM tid %u\n",
|
2009-11-16 12:00:38 +01:00
|
|
|
pubsta->addr, tid);
|
2009-02-10 21:25:46 +01:00
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
|
|
|
|
2009-02-10 21:25:47 +01:00
|
|
|
/*
|
|
|
|
* The aggregation code is not prepared to handle
|
|
|
|
* anything but STA/AP due to the BSSID handling.
|
|
|
|
* IBSS could work in the code but isn't supported
|
|
|
|
* by drivers or the standard.
|
|
|
|
*/
|
2009-11-16 12:00:38 +01:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP)
|
|
|
|
return -EINVAL;
|
2009-02-10 21:25:47 +01:00
|
|
|
|
2010-02-10 10:22:21 +01:00
|
|
|
if (test_sta_flags(sta, WLAN_STA_DISASSOC)) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Disassociation is in progress. "
|
|
|
|
"Denying BA session request\n");
|
|
|
|
#endif
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-04-06 11:18:46 +02:00
|
|
|
if (test_sta_flags(sta, WLAN_STA_BLOCK_BA)) {
|
2009-03-17 04:20:06 +01:00
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Suspend in progress. "
|
|
|
|
"Denying BA session request\n");
|
|
|
|
#endif
|
2009-11-16 12:00:38 +01:00
|
|
|
return -EINVAL;
|
2009-03-17 04:20:06 +01:00
|
|
|
}
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_lock_bh(&sta->lock);
|
2009-03-23 17:28:41 +01:00
|
|
|
spin_lock(&local->ampdu_lock);
|
2009-02-10 21:25:46 +01:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
goto err_unlock_sta;
|
|
|
|
}
|
|
|
|
|
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
|
|
|
/* check if the TID is not in aggregation flow already */
|
|
|
|
if (*state != HT_AGG_STATE_IDLE) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "BA request denied - session is not "
|
|
|
|
"idle on tid %u\n", tid);
|
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto err_unlock_sta;
|
|
|
|
}
|
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
/*
|
|
|
|
* While we're asking the driver about the aggregation,
|
|
|
|
* stop the AC queue so that we don't have to worry
|
|
|
|
* about frames that came in while we were doing that,
|
|
|
|
* which would require us to put them to the AC pending
|
|
|
|
* afterwards which just makes the code more complex.
|
|
|
|
*/
|
|
|
|
ieee80211_stop_queue_by_reason(
|
|
|
|
&local->hw, ieee80211_ac_from_tid(tid),
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
/* prepare A-MPDU MLME for Tx aggregation */
|
|
|
|
sta->ampdu_mlme.tid_tx[tid] =
|
|
|
|
kmalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
|
|
|
|
if (!sta->ampdu_mlme.tid_tx[tid]) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_ERR "allocate tx mlme to tid %d failed\n",
|
|
|
|
tid);
|
|
|
|
#endif
|
|
|
|
ret = -ENOMEM;
|
2009-03-23 17:28:42 +01:00
|
|
|
goto err_wake_queue;
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
skb_queue_head_init(&sta->ampdu_mlme.tid_tx[tid]->pending);
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
/* Tx timer */
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.function =
|
|
|
|
sta_addba_resp_timer_expired;
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.data =
|
|
|
|
(unsigned long)&sta->timer_to_tid[tid];
|
|
|
|
init_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
|
|
|
|
|
|
|
|
/* Ok, the Addba frame hasn't been sent yet, but if the driver calls the
|
|
|
|
* call back right away, it must see that the flow has begun */
|
|
|
|
*state |= HT_ADDBA_REQUESTED_MSK;
|
|
|
|
|
2010-01-04 00:52:56 +01:00
|
|
|
start_seq_num = sta->tid_seq[tid] >> 4;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
2009-11-25 20:30:31 +01:00
|
|
|
ret = drv_ampdu_action(local, sdata, IEEE80211_AMPDU_TX_START,
|
2009-11-16 12:00:38 +01:00
|
|
|
pubsta, tid, &start_seq_num);
|
2009-02-10 21:25:46 +01:00
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "BA request denied - HW unavailable for"
|
|
|
|
" tid %d\n", tid);
|
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
|
|
|
*state = HT_AGG_STATE_IDLE;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
goto err_free;
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
/* Driver vetoed or OKed, but we can take packets again now */
|
|
|
|
ieee80211_wake_queue_by_reason(
|
|
|
|
&local->hw, ieee80211_ac_from_tid(tid),
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
|
|
|
|
|
|
|
|
spin_unlock(&local->ampdu_lock);
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
|
|
|
|
/* send an addBA request */
|
|
|
|
sta->ampdu_mlme.dialog_token_allocator++;
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->dialog_token =
|
|
|
|
sta->ampdu_mlme.dialog_token_allocator;
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num;
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
ieee80211_send_addba_request(sdata, pubsta->addr, tid,
|
2009-02-10 21:25:46 +01:00
|
|
|
sta->ampdu_mlme.tid_tx[tid]->dialog_token,
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->ssn,
|
|
|
|
0x40, 5000);
|
2009-06-09 10:41:46 +02:00
|
|
|
sta->ampdu_mlme.addba_req_num[tid]++;
|
2009-02-10 21:25:46 +01:00
|
|
|
/* activate the timer for the recipient's addBA response */
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires =
|
|
|
|
jiffies + ADDBA_RESP_INTERVAL;
|
|
|
|
add_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid);
|
|
|
|
#endif
|
2009-11-16 12:00:38 +01:00
|
|
|
return 0;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
err_free:
|
2009-02-10 21:25:46 +01:00
|
|
|
kfree(sta->ampdu_mlme.tid_tx[tid]);
|
|
|
|
sta->ampdu_mlme.tid_tx[tid] = NULL;
|
2009-03-23 17:28:42 +01:00
|
|
|
err_wake_queue:
|
2009-03-23 17:28:41 +01:00
|
|
|
ieee80211_wake_queue_by_reason(
|
|
|
|
&local->hw, ieee80211_ac_from_tid(tid),
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
err_unlock_sta:
|
2009-03-23 17:28:41 +01:00
|
|
|
spin_unlock(&local->ampdu_lock);
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
|
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
/*
|
|
|
|
* splice packets from the STA's pending to the local pending,
|
|
|
|
* requires a call to ieee80211_agg_splice_finish and holding
|
|
|
|
* local->ampdu_lock across both calls.
|
|
|
|
*/
|
|
|
|
static void ieee80211_agg_splice_packets(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta, u16 tid)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
u16 queue = ieee80211_ac_from_tid(tid);
|
|
|
|
|
|
|
|
ieee80211_stop_queue_by_reason(
|
|
|
|
&local->hw, queue,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
|
|
|
|
|
2009-08-11 22:10:33 +02:00
|
|
|
if (!(sta->ampdu_mlme.tid_state_tx[tid] & HT_ADDBA_REQUESTED_MSK))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (WARN(!sta->ampdu_mlme.tid_tx[tid],
|
|
|
|
"TID %d gone but expected when splicing aggregates from"
|
|
|
|
"the pending queue\n", tid))
|
|
|
|
return;
|
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
if (!skb_queue_empty(&sta->ampdu_mlme.tid_tx[tid]->pending)) {
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
/* copy over remaining packets */
|
|
|
|
skb_queue_splice_tail_init(
|
|
|
|
&sta->ampdu_mlme.tid_tx[tid]->pending,
|
|
|
|
&local->pending[queue]);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_agg_splice_finish(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta, u16 tid)
|
|
|
|
{
|
|
|
|
u16 queue = ieee80211_ac_from_tid(tid);
|
|
|
|
|
|
|
|
ieee80211_wake_queue_by_reason(
|
|
|
|
&local->hw, queue,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* caller must hold sta->lock */
|
2009-03-23 17:28:39 +01:00
|
|
|
static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta, u16 tid)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
2010-03-24 19:46:29 +01:00
|
|
|
printk(KERN_DEBUG "Aggregation is on for tid %d\n", tid);
|
2009-03-23 17:28:39 +01:00
|
|
|
#endif
|
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
spin_lock(&local->ampdu_lock);
|
|
|
|
ieee80211_agg_splice_packets(local, sta, tid);
|
|
|
|
/*
|
|
|
|
* NB: we rely on sta->lock being taken in the TX
|
|
|
|
* processing here when adding to the pending queue,
|
|
|
|
* otherwise we could only change the state of the
|
|
|
|
* session to OPERATIONAL _here_.
|
|
|
|
*/
|
|
|
|
ieee80211_agg_splice_finish(local, sta, tid);
|
|
|
|
spin_unlock(&local->ampdu_lock);
|
2009-03-23 17:28:39 +01:00
|
|
|
|
2009-11-25 20:30:31 +01:00
|
|
|
drv_ampdu_action(local, sta->sdata,
|
2009-11-16 12:00:38 +01:00
|
|
|
IEEE80211_AMPDU_TX_OPERATIONAL,
|
2009-04-23 18:52:52 +02:00
|
|
|
&sta->sta, tid, NULL);
|
2009-03-23 17:28:39 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
void ieee80211_start_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u16 tid)
|
2009-02-10 21:25:46 +01:00
|
|
|
{
|
2009-11-16 12:00:38 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-02-10 21:25:46 +01:00
|
|
|
struct sta_info *sta;
|
|
|
|
u8 *state;
|
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_start_tx_ba_cb(sdata, ra, tid);
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
if (tid >= STA_TID_NUM) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
|
|
|
|
tid, STA_TID_NUM);
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2009-11-25 17:46:18 +01:00
|
|
|
sta = sta_info_get(sdata, ra);
|
2009-02-10 21:25:46 +01:00
|
|
|
if (!sta) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Could not find station: %pM\n", ra);
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
if (WARN_ON(!(*state & HT_ADDBA_REQUESTED_MSK))) {
|
2009-02-10 21:25:46 +01:00
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "addBA was not requested yet, state is %d\n",
|
|
|
|
*state);
|
|
|
|
#endif
|
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
if (WARN_ON(*state & HT_ADDBA_DRV_READY_MSK))
|
|
|
|
goto out;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
|
|
|
*state |= HT_ADDBA_DRV_READY_MSK;
|
|
|
|
|
2009-03-23 17:28:39 +01:00
|
|
|
if (*state == HT_AGG_STATE_OPERATIONAL)
|
|
|
|
ieee80211_agg_tx_operational(local, sta, tid);
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
|
|
|
|
out:
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_start_tx_ba_cb);
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
|
2009-02-10 21:25:49 +01:00
|
|
|
const u8 *ra, u16 tid)
|
|
|
|
{
|
2009-11-16 12:00:38 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-02-10 21:25:49 +01:00
|
|
|
struct ieee80211_ra_tid *ra_tid;
|
|
|
|
struct sk_buff *skb = dev_alloc_skb(0);
|
|
|
|
|
|
|
|
if (unlikely(!skb)) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_WARNING "%s: Not enough memory, "
|
2009-11-25 17:46:19 +01:00
|
|
|
"dropping start BA session", sdata->name);
|
2009-02-10 21:25:49 +01:00
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
|
|
|
|
memcpy(&ra_tid->ra, ra, ETH_ALEN);
|
|
|
|
ra_tid->tid = tid;
|
2009-11-18 07:12:14 +01:00
|
|
|
ra_tid->vif = vif;
|
2009-02-10 21:25:49 +01:00
|
|
|
|
|
|
|
skb->pkt_type = IEEE80211_ADDBA_MSG;
|
|
|
|
skb_queue_tail(&local->skb_queue, skb);
|
|
|
|
tasklet_schedule(&local->tasklet);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
|
|
|
|
|
2009-02-10 21:25:54 +01:00
|
|
|
int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
|
|
|
|
enum ieee80211_back_parties initiator)
|
|
|
|
{
|
|
|
|
u8 *state;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* check if the TID is in aggregation */
|
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
|
|
|
if (*state != HT_AGG_STATE_OPERATIONAL) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ___ieee80211_stop_tx_ba_session(sta, tid, initiator);
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-02-10 21:25:46 +01:00
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
int ieee80211_stop_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
|
2009-02-10 21:25:46 +01:00
|
|
|
enum ieee80211_back_parties initiator)
|
|
|
|
{
|
2009-11-16 12:00:38 +01: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;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_stop_tx_ba_session(pubsta, tid, initiator);
|
|
|
|
|
2009-11-20 09:15:51 +01:00
|
|
|
if (!local->ops->ampdu_action)
|
2009-02-10 21:25:50 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
if (tid >= STA_TID_NUM)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
return __ieee80211_stop_tx_ba_session(sta, tid, initiator);
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
void ieee80211_stop_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u8 tid)
|
2009-02-10 21:25:46 +01:00
|
|
|
{
|
2009-11-16 12:00:38 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-02-10 21:25:46 +01:00
|
|
|
struct sta_info *sta;
|
|
|
|
u8 *state;
|
|
|
|
|
2010-04-07 16:48:40 +02:00
|
|
|
trace_api_stop_tx_ba_cb(sdata, ra, tid);
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
if (tid >= STA_TID_NUM) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
|
|
|
|
tid, STA_TID_NUM);
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Stopping Tx BA session for %pM tid %d\n",
|
|
|
|
ra, tid);
|
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2009-11-25 17:46:18 +01:00
|
|
|
sta = sta_info_get(sdata, ra);
|
2009-02-10 21:25:46 +01:00
|
|
|
if (!sta) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "Could not find station: %pM\n", ra);
|
|
|
|
#endif
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
|
|
|
|
|
|
|
/* NOTE: no need to use sta->lock in this state check, as
|
|
|
|
* ieee80211_stop_tx_ba_session will let only one stop call to
|
|
|
|
* pass through per sta/tid
|
|
|
|
*/
|
|
|
|
if ((*state & HT_AGG_STATE_REQ_STOP_BA_MSK) == 0) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "unexpected callback to A-MPDU stop\n");
|
|
|
|
#endif
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*state & HT_AGG_STATE_INITIATOR_MSK)
|
|
|
|
ieee80211_send_delba(sta->sdata, ra, tid,
|
|
|
|
WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
|
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
spin_lock_bh(&sta->lock);
|
2009-03-23 17:28:41 +01:00
|
|
|
spin_lock(&local->ampdu_lock);
|
2009-02-10 21:25:46 +01:00
|
|
|
|
2009-03-23 17:28:41 +01:00
|
|
|
ieee80211_agg_splice_packets(local, sta, tid);
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
*state = HT_AGG_STATE_IDLE;
|
2009-03-23 17:28:41 +01:00
|
|
|
/* from now on packets are no longer put onto sta->pending */
|
2009-02-10 21:25:46 +01:00
|
|
|
kfree(sta->ampdu_mlme.tid_tx[tid]);
|
|
|
|
sta->ampdu_mlme.tid_tx[tid] = NULL;
|
2009-03-23 17:28:41 +01:00
|
|
|
|
|
|
|
ieee80211_agg_splice_finish(local, sta, tid);
|
|
|
|
|
|
|
|
spin_unlock(&local->ampdu_lock);
|
2009-02-10 21:25:46 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb);
|
|
|
|
|
2009-11-16 12:00:38 +01:00
|
|
|
void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
|
2009-02-10 21:25:46 +01:00
|
|
|
const u8 *ra, u16 tid)
|
|
|
|
{
|
2009-11-16 12:00:38 +01:00
|
|
|
struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-02-10 21:25:46 +01:00
|
|
|
struct ieee80211_ra_tid *ra_tid;
|
|
|
|
struct sk_buff *skb = dev_alloc_skb(0);
|
|
|
|
|
|
|
|
if (unlikely(!skb)) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_WARNING "%s: Not enough memory, "
|
2009-11-25 17:46:19 +01:00
|
|
|
"dropping stop BA session", sdata->name);
|
2009-02-10 21:25:46 +01:00
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
|
|
|
|
memcpy(&ra_tid->ra, ra, ETH_ALEN);
|
|
|
|
ra_tid->tid = tid;
|
2009-11-18 07:12:14 +01:00
|
|
|
ra_tid->vif = vif;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
|
|
|
skb->pkt_type = IEEE80211_DELBA_MSG;
|
|
|
|
skb_queue_tail(&local->skb_queue, skb);
|
|
|
|
tasklet_schedule(&local->tasklet);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
|
|
|
|
|
2009-02-10 21:25:49 +01:00
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
void ieee80211_process_addba_resp(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct ieee80211_mgmt *mgmt,
|
|
|
|
size_t len)
|
|
|
|
{
|
2009-03-23 17:28:39 +01:00
|
|
|
u16 capab, tid;
|
2009-02-10 21:25:46 +01:00
|
|
|
u8 *state;
|
|
|
|
|
|
|
|
capab = le16_to_cpu(mgmt->u.action.u.addba_resp.capab);
|
|
|
|
tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
|
|
|
|
|
|
|
|
state = &sta->ampdu_mlme.tid_state_tx[tid];
|
|
|
|
|
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
|
2009-10-29 08:34:00 +01:00
|
|
|
if (!(*state & HT_ADDBA_REQUESTED_MSK))
|
2009-11-18 17:15:06 +01:00
|
|
|
goto out;
|
2009-02-10 21:25:46 +01:00
|
|
|
|
|
|
|
if (mgmt->u.action.u.addba_resp.dialog_token !=
|
|
|
|
sta->ampdu_mlme.tid_tx[tid]->dialog_token) {
|
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
|
|
|
printk(KERN_DEBUG "wrong addBA response token, tid %d\n", tid);
|
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
2009-11-18 17:15:06 +01:00
|
|
|
goto out;
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
|
|
|
|
2009-11-18 17:15:06 +01:00
|
|
|
del_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
#ifdef CONFIG_MAC80211_HT_DEBUG
|
2010-03-24 19:46:29 +01:00
|
|
|
printk(KERN_DEBUG "switched off addBA timer for tid %d\n", tid);
|
2009-02-10 21:25:46 +01:00
|
|
|
#endif /* CONFIG_MAC80211_HT_DEBUG */
|
2009-10-29 08:34:00 +01:00
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
|
|
|
|
== WLAN_STATUS_SUCCESS) {
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-12 00:51:53 +01:00
|
|
|
u8 curstate = *state;
|
|
|
|
|
2009-02-10 21:25:46 +01:00
|
|
|
*state |= HT_ADDBA_RECEIVED_MSK;
|
|
|
|
|
2009-03-23 17:28:39 +01:00
|
|
|
if (*state != curstate && *state == HT_AGG_STATE_OPERATIONAL)
|
|
|
|
ieee80211_agg_tx_operational(local, sta, tid);
|
2009-02-10 21:25:46 +01:00
|
|
|
|
2009-03-23 17:28:39 +01:00
|
|
|
sta->ampdu_mlme.addba_req_num[tid] = 0;
|
2009-02-10 21:25:46 +01:00
|
|
|
} else {
|
2009-02-10 21:25:54 +01:00
|
|
|
___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR);
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|
2009-10-29 08:34:00 +01:00
|
|
|
|
|
|
|
out:
|
2009-02-10 21:25:54 +01:00
|
|
|
spin_unlock_bh(&sta->lock);
|
2009-02-10 21:25:46 +01:00
|
|
|
}
|