blob: 13b7683de5a455fe222c4148dc807471fe3b74bd [file] [log] [blame]
Johannes Bergb8695a82009-02-10 21:25:46 +01001/*
2 * HT handling
3 *
4 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
5 * Copyright 2002-2005, Instant802 Networks, Inc.
6 * Copyright 2005-2006, Devicescape Software, Inc.
7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
Johannes Bergcfcdbde2010-06-10 10:21:48 +02009 * Copyright 2007-2010, Intel Corporation
Johannes Bergb8695a82009-02-10 21:25:46 +010010 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16#include <linux/ieee80211.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040018#include <linux/export.h>
Johannes Bergb8695a82009-02-10 21:25:46 +010019#include <net/mac80211.h>
20#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020021#include "driver-ops.h"
Johannes Bergb8695a82009-02-10 21:25:46 +010022#include "wme.h"
23
Johannes Berg86ab6c52009-02-10 21:25:49 +010024/**
Johannes Berg73a72a82010-06-10 10:21:50 +020025 * DOC: TX A-MPDU aggregation
Johannes Berg86ab6c52009-02-10 21:25:49 +010026 *
27 * Aggregation on the TX side requires setting the hardware flag
Johannes Berg73a72a82010-06-10 10:21:50 +020028 * %IEEE80211_HW_AMPDU_AGGREGATION. The driver will then be handed
29 * packets with a flag indicating A-MPDU aggregation. The driver
30 * or device is responsible for actually aggregating the frames,
31 * as well as deciding how many and which to aggregate.
Johannes Berg86ab6c52009-02-10 21:25:49 +010032 *
Johannes Berg73a72a82010-06-10 10:21:50 +020033 * When TX aggregation is started by some subsystem (usually the rate
34 * control algorithm would be appropriate) by calling the
35 * ieee80211_start_tx_ba_session() function, the driver will be
36 * notified via its @ampdu_action function, with the
37 * %IEEE80211_AMPDU_TX_START action.
Johannes Berg86ab6c52009-02-10 21:25:49 +010038 *
39 * In response to that, the driver is later required to call the
Johannes Berg73a72a82010-06-10 10:21:50 +020040 * ieee80211_start_tx_ba_cb_irqsafe() function, which will really
41 * start the aggregation session after the peer has also responded.
42 * If the peer responds negatively, the session will be stopped
43 * again right away. Note that it is possible for the aggregation
44 * session to be stopped before the driver has indicated that it
45 * is done setting it up, in which case it must not indicate the
46 * setup completion.
Johannes Berg86ab6c52009-02-10 21:25:49 +010047 *
Johannes Berg73a72a82010-06-10 10:21:50 +020048 * Also note that, since we also need to wait for a response from
49 * the peer, the driver is notified of the completion of the
50 * handshake by the %IEEE80211_AMPDU_TX_OPERATIONAL action to the
51 * @ampdu_action callback.
52 *
53 * Similarly, when the aggregation session is stopped by the peer
54 * or something calling ieee80211_stop_tx_ba_session(), the driver's
55 * @ampdu_action function will be called with the action
56 * %IEEE80211_AMPDU_TX_STOP. In this case, the call must not fail,
57 * and the driver must later call ieee80211_stop_tx_ba_cb_irqsafe().
Yogesh Ashok Powar42624d42011-12-08 14:56:15 +053058 * Note that the sta can get destroyed before the BA tear down is
59 * complete.
Johannes Berg86ab6c52009-02-10 21:25:49 +010060 */
61
Johannes Bergb8695a82009-02-10 21:25:46 +010062static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
63 const u8 *da, u16 tid,
64 u8 dialog_token, u16 start_seq_num,
65 u16 agg_size, u16 timeout)
66{
67 struct ieee80211_local *local = sdata->local;
Johannes Bergb8695a82009-02-10 21:25:46 +010068 struct sk_buff *skb;
69 struct ieee80211_mgmt *mgmt;
70 u16 capab;
71
72 skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
73
Joe Perchesd15b8452011-08-29 14:17:31 -070074 if (!skb)
Johannes Bergb8695a82009-02-10 21:25:46 +010075 return;
Joe Perchesd15b8452011-08-29 14:17:31 -070076
Johannes Bergb8695a82009-02-10 21:25:46 +010077 skb_reserve(skb, local->hw.extra_tx_headroom);
78 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
79 memset(mgmt, 0, 24);
80 memcpy(mgmt->da, da, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +010081 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg8abd3f92009-02-10 21:25:47 +010082 if (sdata->vif.type == NL80211_IFTYPE_AP ||
Thomas Pedersenae2772b2011-10-26 14:47:29 -070083 sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
84 sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
Johannes Berg47846c92009-11-25 17:46:19 +010085 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +010086 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
87 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
Alexander Simon13c40c52011-11-30 16:56:34 +010088 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
89 memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
Johannes Bergb8695a82009-02-10 21:25:46 +010090
91 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
92 IEEE80211_STYPE_ACTION);
93
94 skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req));
95
96 mgmt->u.action.category = WLAN_CATEGORY_BACK;
97 mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ;
98
99 mgmt->u.action.u.addba_req.dialog_token = dialog_token;
100 capab = (u16)(1 << 1); /* bit 1 aggregation policy */
101 capab |= (u16)(tid << 2); /* bit 5:2 TID number */
102 capab |= (u16)(agg_size << 6); /* bit 15:6 max size of aggergation */
103
104 mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
105
106 mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout);
107 mgmt->u.action.u.addba_req.start_seq_num =
108 cpu_to_le16(start_seq_num << 4);
109
Helmut Schaacf6bb792011-12-15 10:18:34 +0100110 ieee80211_tx_skb_tid(sdata, skb, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100111}
112
Felix Fietkau8c771242011-08-20 15:53:55 +0200113void ieee80211_send_bar(struct ieee80211_vif *vif, u8 *ra, u16 tid, u16 ssn)
Johannes Bergb8695a82009-02-10 21:25:46 +0100114{
Felix Fietkau8c771242011-08-20 15:53:55 +0200115 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
Johannes Bergb8695a82009-02-10 21:25:46 +0100116 struct ieee80211_local *local = sdata->local;
117 struct sk_buff *skb;
118 struct ieee80211_bar *bar;
119 u16 bar_control = 0;
120
121 skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
Joe Perchesd15b8452011-08-29 14:17:31 -0700122 if (!skb)
Johannes Bergb8695a82009-02-10 21:25:46 +0100123 return;
Joe Perchesd15b8452011-08-29 14:17:31 -0700124
Johannes Bergb8695a82009-02-10 21:25:46 +0100125 skb_reserve(skb, local->hw.extra_tx_headroom);
126 bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar));
127 memset(bar, 0, sizeof(*bar));
128 bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
129 IEEE80211_STYPE_BACK_REQ);
130 memcpy(bar->ra, ra, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100131 memcpy(bar->ta, sdata->vif.addr, ETH_ALEN);
Johannes Bergb8695a82009-02-10 21:25:46 +0100132 bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
133 bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
Helmut Schaac1407b62011-08-11 16:17:41 +0200134 bar_control |= (u16)(tid << IEEE80211_BAR_CTRL_TID_INFO_SHIFT);
Johannes Bergb8695a82009-02-10 21:25:46 +0100135 bar->control = cpu_to_le16(bar_control);
136 bar->start_seq_num = cpu_to_le16(ssn);
137
Christian Lamparter2f7916f2012-07-07 15:13:08 +0200138 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
139 IEEE80211_TX_CTL_REQ_TX_STATUS;
Helmut Schaacf6bb792011-12-15 10:18:34 +0100140 ieee80211_tx_skb_tid(sdata, skb, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100141}
Felix Fietkau8c771242011-08-20 15:53:55 +0200142EXPORT_SYMBOL(ieee80211_send_bar);
Johannes Bergb8695a82009-02-10 21:25:46 +0100143
Johannes Bergec034b22011-05-13 13:35:40 +0200144void ieee80211_assign_tid_tx(struct sta_info *sta, int tid,
145 struct tid_ampdu_tx *tid_tx)
146{
147 lockdep_assert_held(&sta->ampdu_mlme.mtx);
148 lockdep_assert_held(&sta->lock);
149 rcu_assign_pointer(sta->ampdu_mlme.tid_tx[tid], tid_tx);
150}
151
Johannes Berg30bf5f12012-12-28 09:43:03 +0100152static inline int ieee80211_ac_from_tid(int tid)
153{
154 return ieee802_1d_to_ac[tid & 7];
155}
156
157/*
158 * When multiple aggregation sessions on multiple stations
159 * are being created/destroyed simultaneously, we need to
160 * refcount the global queue stop caused by that in order
161 * to not get into a situation where one of the aggregation
162 * setup or teardown re-enables queues before the other is
163 * ready to handle that.
164 *
165 * These two functions take care of this issue by keeping
166 * a global "agg_queue_stop" refcount.
167 */
168static void __acquires(agg_queue)
169ieee80211_stop_queue_agg(struct ieee80211_sub_if_data *sdata, int tid)
170{
171 int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
172
173 if (atomic_inc_return(&sdata->local->agg_queue_stop[queue]) == 1)
174 ieee80211_stop_queue_by_reason(
175 &sdata->local->hw, queue,
176 IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
177 __acquire(agg_queue);
178}
179
180static void __releases(agg_queue)
181ieee80211_wake_queue_agg(struct ieee80211_sub_if_data *sdata, int tid)
182{
183 int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
184
185 if (atomic_dec_return(&sdata->local->agg_queue_stop[queue]) == 0)
186 ieee80211_wake_queue_by_reason(
187 &sdata->local->hw, queue,
188 IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
189 __release(agg_queue);
190}
191
192/*
193 * splice packets from the STA's pending to the local pending,
194 * requires a call to ieee80211_agg_splice_finish later
195 */
196static void __acquires(agg_queue)
197ieee80211_agg_splice_packets(struct ieee80211_sub_if_data *sdata,
198 struct tid_ampdu_tx *tid_tx, u16 tid)
199{
200 struct ieee80211_local *local = sdata->local;
201 int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
202 unsigned long flags;
203
204 ieee80211_stop_queue_agg(sdata, tid);
205
206 if (WARN(!tid_tx,
207 "TID %d gone but expected when splicing aggregates from the pending queue\n",
208 tid))
209 return;
210
211 if (!skb_queue_empty(&tid_tx->pending)) {
212 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
213 /* copy over remaining packets */
214 skb_queue_splice_tail_init(&tid_tx->pending,
215 &local->pending[queue]);
216 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
217 }
218}
219
220static void __releases(agg_queue)
221ieee80211_agg_splice_finish(struct ieee80211_sub_if_data *sdata, u16 tid)
222{
223 ieee80211_wake_queue_agg(sdata, tid);
224}
225
226static void ieee80211_remove_tid_tx(struct sta_info *sta, int tid)
227{
228 struct tid_ampdu_tx *tid_tx;
229
230 lockdep_assert_held(&sta->ampdu_mlme.mtx);
231 lockdep_assert_held(&sta->lock);
232
233 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
234
235 /*
236 * When we get here, the TX path will not be lockless any more wrt.
237 * aggregation, since the OPERATIONAL bit has long been cleared.
238 * Thus it will block on getting the lock, if it occurs. So if we
239 * stop the queue now, we will not get any more packets, and any
240 * that might be being processed will wait for us here, thereby
241 * guaranteeing that no packets go to the tid_tx pending queue any
242 * more.
243 */
244
245 ieee80211_agg_splice_packets(sta->sdata, tid_tx, tid);
246
247 /* future packets must not find the tid_tx struct any more */
248 ieee80211_assign_tid_tx(sta, tid, NULL);
249
250 ieee80211_agg_splice_finish(sta->sdata, tid);
251
252 kfree_rcu(tid_tx, rcu_head);
253}
254
Johannes Berg67c282c2010-06-10 10:21:43 +0200255int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
Johannes Bergc82c4a82012-07-18 13:31:31 +0200256 enum ieee80211_agg_stop_reason reason)
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100257{
Johannes Berg849b7962009-02-10 21:25:54 +0100258 struct ieee80211_local *local = sta->local;
Johannes Berg40b275b2011-05-13 14:15:49 +0200259 struct tid_ampdu_tx *tid_tx;
Johannes Berg18b559d2012-07-18 13:51:25 +0200260 enum ieee80211_ampdu_mlme_action action;
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100261 int ret;
Johannes Berga622ab72010-06-10 10:21:39 +0200262
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200263 lockdep_assert_held(&sta->ampdu_mlme.mtx);
Johannes Berga622ab72010-06-10 10:21:39 +0200264
Johannes Berg18b559d2012-07-18 13:51:25 +0200265 switch (reason) {
266 case AGG_STOP_DECLINED:
267 case AGG_STOP_LOCAL_REQUEST:
268 case AGG_STOP_PEER_REQUEST:
269 action = IEEE80211_AMPDU_TX_STOP_CONT;
270 break;
271 case AGG_STOP_DESTROY_STA:
272 action = IEEE80211_AMPDU_TX_STOP_FLUSH;
273 break;
274 default:
275 WARN_ON_ONCE(1);
276 return -EINVAL;
277 }
278
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200279 spin_lock_bh(&sta->lock);
280
Johannes Berg40b275b2011-05-13 14:15:49 +0200281 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
282 if (!tid_tx) {
283 spin_unlock_bh(&sta->lock);
284 return -ENOENT;
285 }
286
Johannes Berg18b559d2012-07-18 13:51:25 +0200287 /*
288 * if we're already stopping ignore any new requests to stop
289 * unless we're destroying it in which case notify the driver
290 */
Johannes Berg24f50a92011-11-24 20:06:14 +0100291 if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
292 spin_unlock_bh(&sta->lock);
Johannes Berg18b559d2012-07-18 13:51:25 +0200293 if (reason != AGG_STOP_DESTROY_STA)
294 return -EALREADY;
295 ret = drv_ampdu_action(local, sta->sdata,
296 IEEE80211_AMPDU_TX_STOP_FLUSH_CONT,
297 &sta->sta, tid, NULL, 0);
298 WARN_ON_ONCE(ret);
Johannes Berg8147dc72013-01-18 23:47:05 +0100299 return 0;
Johannes Berg24f50a92011-11-24 20:06:14 +0100300 }
301
Johannes Berg0ab33702010-06-10 10:21:42 +0200302 if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
303 /* not even started yet! */
Johannes Bergec034b22011-05-13 13:35:40 +0200304 ieee80211_assign_tid_tx(sta, tid, NULL);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200305 spin_unlock_bh(&sta->lock);
Lai Jiangshan07443712011-03-15 18:02:42 +0800306 kfree_rcu(tid_tx, rcu_head);
Johannes Berg0ab33702010-06-10 10:21:42 +0200307 return 0;
308 }
309
Johannes Berg24f50a92011-11-24 20:06:14 +0100310 set_bit(HT_AGG_STATE_STOPPING, &tid_tx->state);
311
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200312 spin_unlock_bh(&sta->lock);
313
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200314 ht_dbg(sta->sdata, "Tx BA session stop requested for %pM tid %u\n",
315 sta->sta.addr, tid);
Johannes Berg827d42c2009-11-22 12:28:41 +0100316
Johannes Berg44271482010-10-05 21:40:33 +0200317 del_timer_sync(&tid_tx->addba_resp_timer);
Nikolay Martynov285fa692011-11-22 21:50:28 -0500318 del_timer_sync(&tid_tx->session_timer);
Johannes Berg44271482010-10-05 21:40:33 +0200319
Johannes Berga622ab72010-06-10 10:21:39 +0200320 /*
321 * After this packets are no longer handed right through
322 * to the driver but are put onto tid_tx->pending instead,
323 * with locking to ensure proper access.
324 */
325 clear_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
Vasanthakumar Thiagarajan736708b2009-06-09 14:11:46 +0530326
Emmanuel Grumbach2a1e0fd2011-11-27 15:29:44 +0200327 /*
328 * There might be a few packets being processed right now (on
329 * another CPU) that have already gotten past the aggregation
330 * check when it was still OPERATIONAL and consequently have
331 * IEEE80211_TX_CTL_AMPDU set. In that case, this code might
332 * call into the driver at the same time or even before the
333 * TX paths calls into it, which could confuse the driver.
334 *
335 * Wait for all currently running TX paths to finish before
336 * telling the driver. New packets will not go through since
337 * the aggregation session is no longer OPERATIONAL.
338 */
339 synchronize_net();
340
Johannes Bergc82c4a82012-07-18 13:31:31 +0200341 tid_tx->stop_initiator = reason == AGG_STOP_PEER_REQUEST ?
342 WLAN_BACK_RECIPIENT :
343 WLAN_BACK_INITIATOR;
344 tid_tx->tx_stop = reason == AGG_STOP_LOCAL_REQUEST;
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100345
Johannes Berg18b559d2012-07-18 13:51:25 +0200346 ret = drv_ampdu_action(local, sta->sdata, action,
Johannes Berg0b01f032011-01-18 13:51:05 +0100347 &sta->sta, tid, NULL, 0);
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100348
349 /* HW shall not deny going back to legacy */
350 if (WARN_ON(ret)) {
Johannes Bergcd8ffc82009-03-23 17:28:41 +0100351 /*
352 * We may have pending packets get stuck in this case...
353 * Not bothering with a workaround for now.
354 */
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100355 }
356
Johannes Berg8147dc72013-01-18 23:47:05 +0100357 /*
358 * In the case of AGG_STOP_DESTROY_STA, the driver won't
359 * necessarily call ieee80211_stop_tx_ba_cb(), so this may
360 * seem like we can leave the tid_tx data pending forever.
361 * This is true, in a way, but "forever" is only until the
362 * station struct is actually destroyed. In the meantime,
363 * leaving it around ensures that we don't transmit packets
364 * to the driver on this TID which might confuse it.
365 */
Johannes Berg18b559d2012-07-18 13:51:25 +0200366
367 return 0;
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100368}
369
Johannes Bergb8695a82009-02-10 21:25:46 +0100370/*
371 * After sending add Block Ack request we activated a timer until
372 * add Block Ack response will arrive from the recipient.
373 * If this timer expires sta_addba_resp_timer_expired will be executed.
374 */
375static void sta_addba_resp_timer_expired(unsigned long data)
376{
377 /* not an elegant detour, but there is no choice as the timer passes
378 * only one argument, and both sta_info and TID are needed, so init
379 * flow in sta_info_create gives the TID as data, while the timer_to_id
380 * array gives the sta through container_of */
381 u16 tid = *(u8 *)data;
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100382 struct sta_info *sta = container_of((void *)data,
Johannes Bergb8695a82009-02-10 21:25:46 +0100383 struct sta_info, timer_to_tid[tid]);
Johannes Berga622ab72010-06-10 10:21:39 +0200384 struct tid_ampdu_tx *tid_tx;
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100385
Johannes Bergb8695a82009-02-10 21:25:46 +0100386 /* check if the TID waits for addBA response */
Johannes Berg83a5cbf2010-06-10 10:21:47 +0200387 rcu_read_lock();
388 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
Johannes Berga622ab72010-06-10 10:21:39 +0200389 if (!tid_tx ||
390 test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state)) {
Johannes Berg83a5cbf2010-06-10 10:21:47 +0200391 rcu_read_unlock();
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200392 ht_dbg(sta->sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +0100393 "timer expired on %pM tid %d but we are not (or no longer) expecting addBA response there\n",
394 sta->sta.addr, tid);
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100395 return;
Johannes Bergb8695a82009-02-10 21:25:46 +0100396 }
397
Johannes Berg0a214d32013-01-16 10:39:44 +0100398 ht_dbg(sta->sdata, "addBA response timer expired on %pM tid %d\n",
399 sta->sta.addr, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100400
Johannes Berg83a5cbf2010-06-10 10:21:47 +0200401 ieee80211_stop_tx_ba_session(&sta->sta, tid);
402 rcu_read_unlock();
Johannes Bergb8695a82009-02-10 21:25:46 +0100403}
404
Johannes Berg67c282c2010-06-10 10:21:43 +0200405void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid)
Johannes Berg0ab33702010-06-10 10:21:42 +0200406{
Johannes Berg40b275b2011-05-13 14:15:49 +0200407 struct tid_ampdu_tx *tid_tx;
Johannes Berg0ab33702010-06-10 10:21:42 +0200408 struct ieee80211_local *local = sta->local;
409 struct ieee80211_sub_if_data *sdata = sta->sdata;
410 u16 start_seq_num;
411 int ret;
412
Johannes Berg40b275b2011-05-13 14:15:49 +0200413 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200414
Johannes Berg0ab33702010-06-10 10:21:42 +0200415 /*
Johannes Berg15062e62011-12-07 09:02:21 +0100416 * Start queuing up packets for this aggregation session.
417 * We're going to release them once the driver is OK with
418 * that.
Johannes Berg0ab33702010-06-10 10:21:42 +0200419 */
Johannes Berg0ab33702010-06-10 10:21:42 +0200420 clear_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
421
422 /*
Johannes Berg15062e62011-12-07 09:02:21 +0100423 * Make sure no packets are being processed. This ensures that
424 * we have a valid starting sequence number and that in-flight
425 * packets have been flushed out and no packets for this TID
426 * will go into the driver during the ampdu_action call.
Johannes Berg0ab33702010-06-10 10:21:42 +0200427 */
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200428 synchronize_net();
429
Johannes Berg0ab33702010-06-10 10:21:42 +0200430 start_seq_num = sta->tid_seq[tid] >> 4;
431
432 ret = drv_ampdu_action(local, sdata, IEEE80211_AMPDU_TX_START,
Johannes Berg0b01f032011-01-18 13:51:05 +0100433 &sta->sta, tid, &start_seq_num, 0);
Johannes Berg0ab33702010-06-10 10:21:42 +0200434 if (ret) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200435 ht_dbg(sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +0100436 "BA request denied - HW unavailable for %pM tid %d\n",
437 sta->sta.addr, tid);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200438 spin_lock_bh(&sta->lock);
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200439 ieee80211_agg_splice_packets(sdata, tid_tx, tid);
Johannes Bergec034b22011-05-13 13:35:40 +0200440 ieee80211_assign_tid_tx(sta, tid, NULL);
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200441 ieee80211_agg_splice_finish(sdata, tid);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200442 spin_unlock_bh(&sta->lock);
443
Lai Jiangshan07443712011-03-15 18:02:42 +0800444 kfree_rcu(tid_tx, rcu_head);
Johannes Berg0ab33702010-06-10 10:21:42 +0200445 return;
446 }
447
Johannes Berg0ab33702010-06-10 10:21:42 +0200448 /* activate the timer for the recipient's addBA response */
449 mod_timer(&tid_tx->addba_resp_timer, jiffies + ADDBA_RESP_INTERVAL);
Johannes Berg0a214d32013-01-16 10:39:44 +0100450 ht_dbg(sdata, "activated addBA response timer on %pM tid %d\n",
451 sta->sta.addr, tid);
Johannes Berg0ab33702010-06-10 10:21:42 +0200452
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200453 spin_lock_bh(&sta->lock);
Nikolay Martynov84381b42011-12-17 19:39:35 -0500454 sta->ampdu_mlme.last_addba_req_time[tid] = jiffies;
Johannes Berg0ab33702010-06-10 10:21:42 +0200455 sta->ampdu_mlme.addba_req_num[tid]++;
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200456 spin_unlock_bh(&sta->lock);
Johannes Berg0ab33702010-06-10 10:21:42 +0200457
458 /* send AddBA request */
459 ieee80211_send_addba_request(sdata, sta->sta.addr, tid,
460 tid_tx->dialog_token, start_seq_num,
Johannes Berg5dd36bc2011-01-18 13:52:23 +0100461 local->hw.max_tx_aggregation_subframes,
462 tid_tx->timeout);
Johannes Berg0ab33702010-06-10 10:21:42 +0200463}
464
Nikolay Martynov285fa692011-11-22 21:50:28 -0500465/*
466 * After accepting the AddBA Response we activated a timer,
467 * resetting it after each frame that we send.
468 */
469static void sta_tx_agg_session_timer_expired(unsigned long data)
470{
471 /* not an elegant detour, but there is no choice as the timer passes
472 * only one argument, and various sta_info are needed here, so init
473 * flow in sta_info_create gives the TID as data, while the timer_to_id
474 * array gives the sta through container_of */
475 u8 *ptid = (u8 *)data;
476 u8 *timer_to_id = ptid - *ptid;
477 struct sta_info *sta = container_of(timer_to_id, struct sta_info,
478 timer_to_tid[0]);
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100479 struct tid_ampdu_tx *tid_tx;
480 unsigned long timeout;
481
Johannes Berg9e73dee2012-05-07 17:57:36 +0200482 rcu_read_lock();
483 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[*ptid]);
484 if (!tid_tx || test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
485 rcu_read_unlock();
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100486 return;
Johannes Berg9e73dee2012-05-07 17:57:36 +0200487 }
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100488
489 timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);
490 if (time_is_after_jiffies(timeout)) {
491 mod_timer(&tid_tx->session_timer, timeout);
Johannes Berg9e73dee2012-05-07 17:57:36 +0200492 rcu_read_unlock();
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100493 return;
494 }
Nikolay Martynov285fa692011-11-22 21:50:28 -0500495
Johannes Berg9e73dee2012-05-07 17:57:36 +0200496 rcu_read_unlock();
497
Johannes Berg0a214d32013-01-16 10:39:44 +0100498 ht_dbg(sta->sdata, "tx session timer expired on %pM tid %d\n",
499 sta->sta.addr, (u16)*ptid);
Nikolay Martynov285fa692011-11-22 21:50:28 -0500500
501 ieee80211_stop_tx_ba_session(&sta->sta, *ptid);
502}
503
Sujith Manoharanbd2ce6e2010-12-15 07:47:10 +0530504int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
505 u16 timeout)
Johannes Bergb8695a82009-02-10 21:25:46 +0100506{
Johannes Bergc951ad32009-11-16 12:00:38 +0100507 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
508 struct ieee80211_sub_if_data *sdata = sta->sdata;
509 struct ieee80211_local *local = sdata->local;
Johannes Berga622ab72010-06-10 10:21:39 +0200510 struct tid_ampdu_tx *tid_tx;
Johannes Berge4e72fb2009-03-23 17:28:42 +0100511 int ret = 0;
Johannes Bergb8695a82009-02-10 21:25:46 +0100512
Johannes Bergb5878a22010-04-07 16:48:40 +0200513 trace_api_start_tx_ba_session(pubsta, tid);
514
Chaitanya50c16e22012-12-07 12:19:34 +0530515 if (WARN_ON_ONCE(!local->ops->ampdu_action))
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100516 return -EINVAL;
517
Johannes Berg5a306f52012-11-14 23:22:21 +0100518 if ((tid >= IEEE80211_NUM_TIDS) ||
Arik Nemtsovedf6b782011-08-30 09:32:38 +0300519 !(local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION) ||
520 (local->hw.flags & IEEE80211_HW_TX_AMPDU_SETUP_IN_HW))
Johannes Bergb8695a82009-02-10 21:25:46 +0100521 return -EINVAL;
522
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200523 ht_dbg(sdata, "Open BA session requested for %pM tid %u\n",
524 pubsta->addr, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100525
Johannes Bergc951ad32009-11-16 12:00:38 +0100526 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
Thomas Pedersenae2772b2011-10-26 14:47:29 -0700527 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
Johannes Bergc951ad32009-11-16 12:00:38 +0100528 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
Alexander Simon13c40c52011-11-30 16:56:34 +0100529 sdata->vif.type != NL80211_IFTYPE_AP &&
530 sdata->vif.type != NL80211_IFTYPE_ADHOC)
Johannes Bergc951ad32009-11-16 12:00:38 +0100531 return -EINVAL;
Johannes Berg8abd3f92009-02-10 21:25:47 +0100532
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200533 if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200534 ht_dbg(sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +0100535 "BA sessions blocked - Denying BA session request %pM tid %d\n",
536 sta->sta.addr, tid);
Johannes Bergc951ad32009-11-16 12:00:38 +0100537 return -EINVAL;
Sujith722f0692009-03-17 08:50:06 +0530538 }
539
Simon Wunderlichff3cc5f2011-11-30 16:56:33 +0100540 /*
541 * 802.11n-2009 11.5.1.1: If the initiating STA is an HT STA, is a
542 * member of an IBSS, and has no other existing Block Ack agreement
543 * with the recipient STA, then the initiating STA shall transmit a
544 * Probe Request frame to the recipient STA and shall not transmit an
545 * ADDBA Request frame unless it receives a Probe Response frame
546 * from the recipient within dot11ADDBAFailureTimeout.
547 *
548 * The probe request mechanism for ADDBA is currently not implemented,
549 * but we only build up Block Ack session with HT STAs. This information
550 * is set when we receive a bss info from a probe response or a beacon.
551 */
552 if (sta->sdata->vif.type == NL80211_IFTYPE_ADHOC &&
553 !sta->sta.ht_cap.ht_supported) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200554 ht_dbg(sdata,
555 "BA request denied - IBSS STA %pM does not advertise HT support\n",
556 pubsta->addr);
Simon Wunderlichff3cc5f2011-11-30 16:56:33 +0100557 return -EINVAL;
558 }
559
Johannes Bergb8695a82009-02-10 21:25:46 +0100560 spin_lock_bh(&sta->lock);
561
562 /* we have tried too many times, receiver does not want A-MPDU */
563 if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) {
564 ret = -EBUSY;
565 goto err_unlock_sta;
566 }
567
Nikolay Martynov84381b42011-12-17 19:39:35 -0500568 /*
569 * if we have tried more than HT_AGG_BURST_RETRIES times we
570 * will spread our requests in time to avoid stalling connection
571 * for too long
572 */
573 if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_BURST_RETRIES &&
574 time_before(jiffies, sta->ampdu_mlme.last_addba_req_time[tid] +
575 HT_AGG_RETRIES_PERIOD)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200576 ht_dbg(sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +0100577 "BA request denied - waiting a grace period after %d failed requests on %pM tid %u\n",
578 sta->ampdu_mlme.addba_req_num[tid], sta->sta.addr, tid);
Nikolay Martynov84381b42011-12-17 19:39:35 -0500579 ret = -EBUSY;
580 goto err_unlock_sta;
581 }
582
Johannes Berg40b275b2011-05-13 14:15:49 +0200583 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100584 /* check if the TID is not in aggregation flow already */
Johannes Bergec034b22011-05-13 13:35:40 +0200585 if (tid_tx || sta->ampdu_mlme.tid_start_tx[tid]) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200586 ht_dbg(sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +0100587 "BA request denied - session is not idle on %pM tid %u\n",
588 sta->sta.addr, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100589 ret = -EAGAIN;
590 goto err_unlock_sta;
591 }
592
593 /* prepare A-MPDU MLME for Tx aggregation */
Johannes Berga622ab72010-06-10 10:21:39 +0200594 tid_tx = kzalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
595 if (!tid_tx) {
Johannes Bergb8695a82009-02-10 21:25:46 +0100596 ret = -ENOMEM;
Johannes Berg0ab33702010-06-10 10:21:42 +0200597 goto err_unlock_sta;
Johannes Bergb8695a82009-02-10 21:25:46 +0100598 }
Johannes Berg96f5e662009-02-12 00:51:53 +0100599
Johannes Berga622ab72010-06-10 10:21:39 +0200600 skb_queue_head_init(&tid_tx->pending);
Johannes Berg0ab33702010-06-10 10:21:42 +0200601 __set_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
Johannes Bergcd8ffc82009-03-23 17:28:41 +0100602
Sujith Manoharanbd2ce6e2010-12-15 07:47:10 +0530603 tid_tx->timeout = timeout;
604
Nikolay Martynov285fa692011-11-22 21:50:28 -0500605 /* response timer */
Johannes Berga622ab72010-06-10 10:21:39 +0200606 tid_tx->addba_resp_timer.function = sta_addba_resp_timer_expired;
607 tid_tx->addba_resp_timer.data = (unsigned long)&sta->timer_to_tid[tid];
608 init_timer(&tid_tx->addba_resp_timer);
Johannes Bergb8695a82009-02-10 21:25:46 +0100609
Nikolay Martynov285fa692011-11-22 21:50:28 -0500610 /* tx timer */
611 tid_tx->session_timer.function = sta_tx_agg_session_timer_expired;
612 tid_tx->session_timer.data = (unsigned long)&sta->timer_to_tid[tid];
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100613 init_timer_deferrable(&tid_tx->session_timer);
Nikolay Martynov285fa692011-11-22 21:50:28 -0500614
Johannes Berg0ab33702010-06-10 10:21:42 +0200615 /* assign a dialog token */
Johannes Bergb8695a82009-02-10 21:25:46 +0100616 sta->ampdu_mlme.dialog_token_allocator++;
Johannes Berga622ab72010-06-10 10:21:39 +0200617 tid_tx->dialog_token = sta->ampdu_mlme.dialog_token_allocator;
Johannes Berga622ab72010-06-10 10:21:39 +0200618
Johannes Bergec034b22011-05-13 13:35:40 +0200619 /*
620 * Finally, assign it to the start array; the work item will
621 * collect it and move it to the normal array.
622 */
623 sta->ampdu_mlme.tid_start_tx[tid] = tid_tx;
Johannes Bergb8695a82009-02-10 21:25:46 +0100624
Johannes Berg0ab33702010-06-10 10:21:42 +0200625 ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
Johannes Berg51a0d382010-05-31 12:00:12 +0200626
Johannes Berg0ab33702010-06-10 10:21:42 +0200627 /* this flow continues off the work */
Johannes Berg96f5e662009-02-12 00:51:53 +0100628 err_unlock_sta:
Johannes Bergb8695a82009-02-10 21:25:46 +0100629 spin_unlock_bh(&sta->lock);
Johannes Bergb8695a82009-02-10 21:25:46 +0100630 return ret;
631}
632EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
633
Johannes Bergb1720232009-03-23 17:28:39 +0100634static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
635 struct sta_info *sta, u16 tid)
636{
Johannes Berg40b275b2011-05-13 14:15:49 +0200637 struct tid_ampdu_tx *tid_tx;
638
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200639 lockdep_assert_held(&sta->ampdu_mlme.mtx);
Johannes Berga622ab72010-06-10 10:21:39 +0200640
Johannes Berg40b275b2011-05-13 14:15:49 +0200641 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
642
Johannes Berg0a214d32013-01-16 10:39:44 +0100643 ht_dbg(sta->sdata, "Aggregation is on for %pM tid %d\n",
644 sta->sta.addr, tid);
Johannes Bergb1720232009-03-23 17:28:39 +0100645
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200646 drv_ampdu_action(local, sta->sdata,
647 IEEE80211_AMPDU_TX_OPERATIONAL,
Johannes Berg40b275b2011-05-13 14:15:49 +0200648 &sta->sta, tid, NULL, tid_tx->buf_size);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200649
650 /*
651 * synchronize with TX path, while splicing the TX path
652 * should block so it won't put more packets onto pending.
653 */
654 spin_lock_bh(&sta->lock);
655
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200656 ieee80211_agg_splice_packets(sta->sdata, tid_tx, tid);
Johannes Bergcd8ffc82009-03-23 17:28:41 +0100657 /*
Johannes Berga622ab72010-06-10 10:21:39 +0200658 * Now mark as operational. This will be visible
659 * in the TX path, and lets it go lock-free in
660 * the common case.
Johannes Bergcd8ffc82009-03-23 17:28:41 +0100661 */
Johannes Berg40b275b2011-05-13 14:15:49 +0200662 set_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200663 ieee80211_agg_splice_finish(sta->sdata, tid);
Johannes Bergb1720232009-03-23 17:28:39 +0100664
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200665 spin_unlock_bh(&sta->lock);
Johannes Bergb1720232009-03-23 17:28:39 +0100666}
667
Johannes Bergc951ad32009-11-16 12:00:38 +0100668void ieee80211_start_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u16 tid)
Johannes Bergb8695a82009-02-10 21:25:46 +0100669{
Johannes Bergc951ad32009-11-16 12:00:38 +0100670 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
671 struct ieee80211_local *local = sdata->local;
Johannes Bergb8695a82009-02-10 21:25:46 +0100672 struct sta_info *sta;
Johannes Berga622ab72010-06-10 10:21:39 +0200673 struct tid_ampdu_tx *tid_tx;
Johannes Bergb8695a82009-02-10 21:25:46 +0100674
Johannes Bergb5878a22010-04-07 16:48:40 +0200675 trace_api_start_tx_ba_cb(sdata, ra, tid);
676
Johannes Berg5a306f52012-11-14 23:22:21 +0100677 if (tid >= IEEE80211_NUM_TIDS) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200678 ht_dbg(sdata, "Bad TID value: tid = %d (>= %d)\n",
Johannes Berg5a306f52012-11-14 23:22:21 +0100679 tid, IEEE80211_NUM_TIDS);
Johannes Bergb8695a82009-02-10 21:25:46 +0100680 return;
681 }
682
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200683 mutex_lock(&local->sta_mtx);
Felix Fietkaubc192f82011-11-23 21:09:49 +0700684 sta = sta_info_get_bss(sdata, ra);
Johannes Bergb8695a82009-02-10 21:25:46 +0100685 if (!sta) {
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200686 mutex_unlock(&local->sta_mtx);
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200687 ht_dbg(sdata, "Could not find station: %pM\n", ra);
Johannes Bergb8695a82009-02-10 21:25:46 +0100688 return;
689 }
690
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200691 mutex_lock(&sta->ampdu_mlme.mtx);
Johannes Berg40b275b2011-05-13 14:15:49 +0200692 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100693
Johannes Berga622ab72010-06-10 10:21:39 +0200694 if (WARN_ON(!tid_tx)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200695 ht_dbg(sdata, "addBA was not requested!\n");
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200696 goto unlock;
Johannes Bergb8695a82009-02-10 21:25:46 +0100697 }
698
Johannes Berga622ab72010-06-10 10:21:39 +0200699 if (WARN_ON(test_and_set_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state)))
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200700 goto unlock;
Johannes Bergb8695a82009-02-10 21:25:46 +0100701
Johannes Berga622ab72010-06-10 10:21:39 +0200702 if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state))
Johannes Bergb1720232009-03-23 17:28:39 +0100703 ieee80211_agg_tx_operational(local, sta, tid);
Johannes Berg96f5e662009-02-12 00:51:53 +0100704
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200705 unlock:
706 mutex_unlock(&sta->ampdu_mlme.mtx);
707 mutex_unlock(&local->sta_mtx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100708}
Johannes Bergb8695a82009-02-10 21:25:46 +0100709
Johannes Bergc951ad32009-11-16 12:00:38 +0100710void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
Johannes Berg86ab6c52009-02-10 21:25:49 +0100711 const u8 *ra, u16 tid)
712{
Johannes Bergc951ad32009-11-16 12:00:38 +0100713 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
714 struct ieee80211_local *local = sdata->local;
Johannes Berg86ab6c52009-02-10 21:25:49 +0100715 struct ieee80211_ra_tid *ra_tid;
716 struct sk_buff *skb = dev_alloc_skb(0);
717
Joe Perchesd15b8452011-08-29 14:17:31 -0700718 if (unlikely(!skb))
Johannes Berg86ab6c52009-02-10 21:25:49 +0100719 return;
Joe Perchesd15b8452011-08-29 14:17:31 -0700720
Johannes Berg86ab6c52009-02-10 21:25:49 +0100721 ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
722 memcpy(&ra_tid->ra, ra, ETH_ALEN);
723 ra_tid->tid = tid;
724
Johannes Bergc1475ca2010-06-10 10:21:37 +0200725 skb->pkt_type = IEEE80211_SDATA_QUEUE_AGG_START;
726 skb_queue_tail(&sdata->skb_queue, skb);
727 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg86ab6c52009-02-10 21:25:49 +0100728}
729EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
730
Johannes Berg849b7962009-02-10 21:25:54 +0100731int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
Johannes Bergc82c4a82012-07-18 13:31:31 +0200732 enum ieee80211_agg_stop_reason reason)
Johannes Berg849b7962009-02-10 21:25:54 +0100733{
Johannes Berg849b7962009-02-10 21:25:54 +0100734 int ret;
735
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200736 mutex_lock(&sta->ampdu_mlme.mtx);
Johannes Berg849b7962009-02-10 21:25:54 +0100737
Johannes Bergc82c4a82012-07-18 13:31:31 +0200738 ret = ___ieee80211_stop_tx_ba_session(sta, tid, reason);
Johannes Berg849b7962009-02-10 21:25:54 +0100739
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200740 mutex_unlock(&sta->ampdu_mlme.mtx);
741
Johannes Berg849b7962009-02-10 21:25:54 +0100742 return ret;
743}
Johannes Bergb8695a82009-02-10 21:25:46 +0100744
Johannes Berg6a8579d2010-05-27 14:41:07 +0200745int ieee80211_stop_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid)
Johannes Bergb8695a82009-02-10 21:25:46 +0100746{
Johannes Bergc951ad32009-11-16 12:00:38 +0100747 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
748 struct ieee80211_sub_if_data *sdata = sta->sdata;
749 struct ieee80211_local *local = sdata->local;
Johannes Berg0ab33702010-06-10 10:21:42 +0200750 struct tid_ampdu_tx *tid_tx;
751 int ret = 0;
Johannes Bergb8695a82009-02-10 21:25:46 +0100752
Johannes Berg6a8579d2010-05-27 14:41:07 +0200753 trace_api_stop_tx_ba_session(pubsta, tid);
Johannes Bergb5878a22010-04-07 16:48:40 +0200754
Johannes Berg42531192009-11-20 09:15:51 +0100755 if (!local->ops->ampdu_action)
Johannes Berg23e6a7e2009-02-10 21:25:50 +0100756 return -EINVAL;
757
Johannes Berg5a306f52012-11-14 23:22:21 +0100758 if (tid >= IEEE80211_NUM_TIDS)
Johannes Bergb8695a82009-02-10 21:25:46 +0100759 return -EINVAL;
760
Johannes Berg0ab33702010-06-10 10:21:42 +0200761 spin_lock_bh(&sta->lock);
Johannes Berg40b275b2011-05-13 14:15:49 +0200762 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
Johannes Berg0ab33702010-06-10 10:21:42 +0200763
764 if (!tid_tx) {
765 ret = -ENOENT;
766 goto unlock;
767 }
768
769 if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
770 /* already in progress stopping it */
771 ret = 0;
772 goto unlock;
773 }
774
775 set_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state);
776 ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
777
778 unlock:
779 spin_unlock_bh(&sta->lock);
780 return ret;
Johannes Bergb8695a82009-02-10 21:25:46 +0100781}
782EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
783
Johannes Bergc951ad32009-11-16 12:00:38 +0100784void ieee80211_stop_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u8 tid)
Johannes Bergb8695a82009-02-10 21:25:46 +0100785{
Johannes Bergc951ad32009-11-16 12:00:38 +0100786 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
787 struct ieee80211_local *local = sdata->local;
Johannes Bergb8695a82009-02-10 21:25:46 +0100788 struct sta_info *sta;
Johannes Berga622ab72010-06-10 10:21:39 +0200789 struct tid_ampdu_tx *tid_tx;
Johannes Bergb8695a82009-02-10 21:25:46 +0100790
Johannes Bergb5878a22010-04-07 16:48:40 +0200791 trace_api_stop_tx_ba_cb(sdata, ra, tid);
792
Johannes Berg5a306f52012-11-14 23:22:21 +0100793 if (tid >= IEEE80211_NUM_TIDS) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200794 ht_dbg(sdata, "Bad TID value: tid = %d (>= %d)\n",
Johannes Berg5a306f52012-11-14 23:22:21 +0100795 tid, IEEE80211_NUM_TIDS);
Johannes Bergb8695a82009-02-10 21:25:46 +0100796 return;
797 }
798
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200799 ht_dbg(sdata, "Stopping Tx BA session for %pM tid %d\n", ra, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100800
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200801 mutex_lock(&local->sta_mtx);
802
Felix Fietkaubc192f82011-11-23 21:09:49 +0700803 sta = sta_info_get_bss(sdata, ra);
Johannes Bergb8695a82009-02-10 21:25:46 +0100804 if (!sta) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200805 ht_dbg(sdata, "Could not find station: %pM\n", ra);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200806 goto unlock;
Johannes Bergb8695a82009-02-10 21:25:46 +0100807 }
Johannes Bergb8695a82009-02-10 21:25:46 +0100808
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200809 mutex_lock(&sta->ampdu_mlme.mtx);
Johannes Berga622ab72010-06-10 10:21:39 +0200810 spin_lock_bh(&sta->lock);
Johannes Berg40b275b2011-05-13 14:15:49 +0200811 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
Johannes Berga622ab72010-06-10 10:21:39 +0200812
813 if (!tid_tx || !test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
Johannes Berg0a214d32013-01-16 10:39:44 +0100814 ht_dbg(sdata,
815 "unexpected callback to A-MPDU stop for %pM tid %d\n",
816 sta->sta.addr, tid);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200817 goto unlock_sta;
Johannes Bergb8695a82009-02-10 21:25:46 +0100818 }
819
Johannes Berg53f73c02010-10-05 19:37:40 +0200820 if (tid_tx->stop_initiator == WLAN_BACK_INITIATOR && tid_tx->tx_stop)
Johannes Bergb8695a82009-02-10 21:25:46 +0100821 ieee80211_send_delba(sta->sdata, ra, tid,
822 WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
823
Johannes Bergfaec12e2012-07-18 14:12:44 +0200824 ieee80211_remove_tid_tx(sta, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100825
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200826 unlock_sta:
Johannes Berga622ab72010-06-10 10:21:39 +0200827 spin_unlock_bh(&sta->lock);
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200828 mutex_unlock(&sta->ampdu_mlme.mtx);
829 unlock:
830 mutex_unlock(&local->sta_mtx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100831}
Johannes Bergb8695a82009-02-10 21:25:46 +0100832
Johannes Bergc951ad32009-11-16 12:00:38 +0100833void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
Johannes Bergb8695a82009-02-10 21:25:46 +0100834 const u8 *ra, u16 tid)
835{
Johannes Bergc951ad32009-11-16 12:00:38 +0100836 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
837 struct ieee80211_local *local = sdata->local;
Johannes Bergb8695a82009-02-10 21:25:46 +0100838 struct ieee80211_ra_tid *ra_tid;
839 struct sk_buff *skb = dev_alloc_skb(0);
840
Joe Perchesd15b8452011-08-29 14:17:31 -0700841 if (unlikely(!skb))
Johannes Bergb8695a82009-02-10 21:25:46 +0100842 return;
Joe Perchesd15b8452011-08-29 14:17:31 -0700843
Johannes Bergb8695a82009-02-10 21:25:46 +0100844 ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
845 memcpy(&ra_tid->ra, ra, ETH_ALEN);
846 ra_tid->tid = tid;
847
Johannes Bergc1475ca2010-06-10 10:21:37 +0200848 skb->pkt_type = IEEE80211_SDATA_QUEUE_AGG_STOP;
849 skb_queue_tail(&sdata->skb_queue, skb);
850 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Bergb8695a82009-02-10 21:25:46 +0100851}
852EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
853
Johannes Berg86ab6c52009-02-10 21:25:49 +0100854
Johannes Bergb8695a82009-02-10 21:25:46 +0100855void ieee80211_process_addba_resp(struct ieee80211_local *local,
856 struct sta_info *sta,
857 struct ieee80211_mgmt *mgmt,
858 size_t len)
859{
Johannes Berga622ab72010-06-10 10:21:39 +0200860 struct tid_ampdu_tx *tid_tx;
Johannes Bergb1720232009-03-23 17:28:39 +0100861 u16 capab, tid;
Johannes Berg0b01f032011-01-18 13:51:05 +0100862 u8 buf_size;
Johannes Bergb8695a82009-02-10 21:25:46 +0100863
864 capab = le16_to_cpu(mgmt->u.action.u.addba_resp.capab);
865 tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
Johannes Berg0b01f032011-01-18 13:51:05 +0100866 buf_size = (capab & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK) >> 6;
Johannes Bergb8695a82009-02-10 21:25:46 +0100867
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200868 mutex_lock(&sta->ampdu_mlme.mtx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100869
Johannes Berg40b275b2011-05-13 14:15:49 +0200870 tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
Johannes Berga622ab72010-06-10 10:21:39 +0200871 if (!tid_tx)
Johannes Berg8ade0082009-11-18 17:15:06 +0100872 goto out;
Johannes Bergb8695a82009-02-10 21:25:46 +0100873
Johannes Berga622ab72010-06-10 10:21:39 +0200874 if (mgmt->u.action.u.addba_resp.dialog_token != tid_tx->dialog_token) {
Johannes Berg0a214d32013-01-16 10:39:44 +0100875 ht_dbg(sta->sdata, "wrong addBA response token, %pM tid %d\n",
876 sta->sta.addr, tid);
Johannes Berg8ade0082009-11-18 17:15:06 +0100877 goto out;
Johannes Bergb8695a82009-02-10 21:25:46 +0100878 }
879
Nikolay Martynovd305a652011-11-28 09:18:00 +0100880 del_timer_sync(&tid_tx->addba_resp_timer);
Johannes Berg8ade0082009-11-18 17:15:06 +0100881
Johannes Berg0a214d32013-01-16 10:39:44 +0100882 ht_dbg(sta->sdata, "switched off addBA timer for %pM tid %d\n",
883 sta->sta.addr, tid);
Nikolay Martynovd305a652011-11-28 09:18:00 +0100884
885 /*
886 * addba_resp_timer may have fired before we got here, and
887 * caused WANT_STOP to be set. If the stop then was already
888 * processed further, STOPPING might be set.
889 */
890 if (test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state) ||
891 test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200892 ht_dbg(sta->sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +0100893 "got addBA resp for %pM tid %d but we already gave up\n",
894 sta->sta.addr, tid);
Nikolay Martynovd305a652011-11-28 09:18:00 +0100895 goto out;
896 }
897
Helmut Schaa3ca97882011-07-26 12:18:27 +0200898 /*
899 * IEEE 802.11-2007 7.3.1.14:
900 * In an ADDBA Response frame, when the Status Code field
901 * is set to 0, the Buffer Size subfield is set to a value
902 * of at least 1.
903 */
Johannes Bergb8695a82009-02-10 21:25:46 +0100904 if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
Helmut Schaa3ca97882011-07-26 12:18:27 +0200905 == WLAN_STATUS_SUCCESS && buf_size) {
Johannes Berga622ab72010-06-10 10:21:39 +0200906 if (test_and_set_bit(HT_AGG_STATE_RESPONSE_RECEIVED,
907 &tid_tx->state)) {
908 /* ignore duplicate response */
909 goto out;
910 }
Johannes Bergb8695a82009-02-10 21:25:46 +0100911
Johannes Berg0b01f032011-01-18 13:51:05 +0100912 tid_tx->buf_size = buf_size;
913
Johannes Berga622ab72010-06-10 10:21:39 +0200914 if (test_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state))
Johannes Bergb1720232009-03-23 17:28:39 +0100915 ieee80211_agg_tx_operational(local, sta, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +0100916
Johannes Bergb1720232009-03-23 17:28:39 +0100917 sta->ampdu_mlme.addba_req_num[tid] = 0;
Nikolay Martynov285fa692011-11-22 21:50:28 -0500918
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100919 if (tid_tx->timeout) {
Nikolay Martynov285fa692011-11-22 21:50:28 -0500920 mod_timer(&tid_tx->session_timer,
921 TU_TO_EXP_TIME(tid_tx->timeout));
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100922 tid_tx->last_tx = jiffies;
923 }
Nikolay Martynov285fa692011-11-22 21:50:28 -0500924
Johannes Bergb8695a82009-02-10 21:25:46 +0100925 } else {
Johannes Bergc82c4a82012-07-18 13:31:31 +0200926 ___ieee80211_stop_tx_ba_session(sta, tid, AGG_STOP_DECLINED);
Johannes Bergb8695a82009-02-10 21:25:46 +0100927 }
Johannes Berg2171abc2009-10-29 08:34:00 +0100928
Johannes Berg2171abc2009-10-29 08:34:00 +0100929 out:
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200930 mutex_unlock(&sta->ampdu_mlme.mtx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100931}