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>
9 * Copyright 2007-2010, Intel Corporation
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.
16 #include <linux/ieee80211.h>
17 #include <linux/slab.h>
18 #include <net/mac80211.h>
19 #include "ieee80211_i.h"
20 #include "driver-ops.h"
24 * DOC: TX A-MPDU aggregation
26 * Aggregation on the TX side requires setting the hardware flag
27 * %IEEE80211_HW_AMPDU_AGGREGATION. The driver will then be handed
28 * packets with a flag indicating A-MPDU aggregation. The driver
29 * or device is responsible for actually aggregating the frames,
30 * as well as deciding how many and which to aggregate.
32 * When TX aggregation is started by some subsystem (usually the rate
33 * control algorithm would be appropriate) by calling the
34 * ieee80211_start_tx_ba_session() function, the driver will be
35 * notified via its @ampdu_action function, with the
36 * %IEEE80211_AMPDU_TX_START action.
38 * In response to that, the driver is later required to call the
39 * ieee80211_start_tx_ba_cb_irqsafe() function, which will really
40 * start the aggregation session after the peer has also responded.
41 * If the peer responds negatively, the session will be stopped
42 * again right away. Note that it is possible for the aggregation
43 * session to be stopped before the driver has indicated that it
44 * is done setting it up, in which case it must not indicate the
47 * Also note that, since we also need to wait for a response from
48 * the peer, the driver is notified of the completion of the
49 * handshake by the %IEEE80211_AMPDU_TX_OPERATIONAL action to the
50 * @ampdu_action callback.
52 * Similarly, when the aggregation session is stopped by the peer
53 * or something calling ieee80211_stop_tx_ba_session(), the driver's
54 * @ampdu_action function will be called with the action
55 * %IEEE80211_AMPDU_TX_STOP. In this case, the call must not fail,
56 * and the driver must later call ieee80211_stop_tx_ba_cb_irqsafe().
59 static void ieee80211_send_addba_request(struct ieee80211_sub_if_data
*sdata
,
60 const u8
*da
, u16 tid
,
61 u8 dialog_token
, u16 start_seq_num
,
62 u16 agg_size
, u16 timeout
)
64 struct ieee80211_local
*local
= sdata
->local
;
66 struct ieee80211_mgmt
*mgmt
;
69 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
);
72 printk(KERN_ERR
"%s: failed to allocate buffer "
73 "for addba request frame\n", sdata
->name
);
76 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
77 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
79 memcpy(mgmt
->da
, da
, ETH_ALEN
);
80 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
81 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
82 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
83 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
84 else if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
)
85 memcpy(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
87 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
88 IEEE80211_STYPE_ACTION
);
90 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.addba_req
));
92 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
93 mgmt
->u
.action
.u
.addba_req
.action_code
= WLAN_ACTION_ADDBA_REQ
;
95 mgmt
->u
.action
.u
.addba_req
.dialog_token
= dialog_token
;
96 capab
= (u16
)(1 << 1); /* bit 1 aggregation policy */
97 capab
|= (u16
)(tid
<< 2); /* bit 5:2 TID number */
98 capab
|= (u16
)(agg_size
<< 6); /* bit 15:6 max size of aggergation */
100 mgmt
->u
.action
.u
.addba_req
.capab
= cpu_to_le16(capab
);
102 mgmt
->u
.action
.u
.addba_req
.timeout
= cpu_to_le16(timeout
);
103 mgmt
->u
.action
.u
.addba_req
.start_seq_num
=
104 cpu_to_le16(start_seq_num
<< 4);
106 ieee80211_tx_skb(sdata
, skb
);
109 void ieee80211_send_bar(struct ieee80211_sub_if_data
*sdata
, u8
*ra
, u16 tid
, u16 ssn
)
111 struct ieee80211_local
*local
= sdata
->local
;
113 struct ieee80211_bar
*bar
;
116 skb
= dev_alloc_skb(sizeof(*bar
) + local
->hw
.extra_tx_headroom
);
118 printk(KERN_ERR
"%s: failed to allocate buffer for "
119 "bar frame\n", sdata
->name
);
122 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
123 bar
= (struct ieee80211_bar
*)skb_put(skb
, sizeof(*bar
));
124 memset(bar
, 0, sizeof(*bar
));
125 bar
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_CTL
|
126 IEEE80211_STYPE_BACK_REQ
);
127 memcpy(bar
->ra
, ra
, ETH_ALEN
);
128 memcpy(bar
->ta
, sdata
->vif
.addr
, ETH_ALEN
);
129 bar_control
|= (u16
)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL
;
130 bar_control
|= (u16
)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA
;
131 bar_control
|= (u16
)(tid
<< 12);
132 bar
->control
= cpu_to_le16(bar_control
);
133 bar
->start_seq_num
= cpu_to_le16(ssn
);
135 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
136 ieee80211_tx_skb(sdata
, skb
);
139 static void kfree_tid_tx(struct rcu_head
*rcu_head
)
141 struct tid_ampdu_tx
*tid_tx
=
142 container_of(rcu_head
, struct tid_ampdu_tx
, rcu_head
);
147 int ___ieee80211_stop_tx_ba_session(struct sta_info
*sta
, u16 tid
,
148 enum ieee80211_back_parties initiator
)
150 struct ieee80211_local
*local
= sta
->local
;
151 struct tid_ampdu_tx
*tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
154 lockdep_assert_held(&sta
->ampdu_mlme
.mtx
);
159 spin_lock_bh(&sta
->lock
);
161 if (test_bit(HT_AGG_STATE_WANT_START
, &tid_tx
->state
)) {
162 /* not even started yet! */
163 rcu_assign_pointer(sta
->ampdu_mlme
.tid_tx
[tid
], NULL
);
164 spin_unlock_bh(&sta
->lock
);
165 call_rcu(&tid_tx
->rcu_head
, kfree_tid_tx
);
169 spin_unlock_bh(&sta
->lock
);
171 #ifdef CONFIG_MAC80211_HT_DEBUG
172 printk(KERN_DEBUG
"Tx BA session stop requested for %pM tid %u\n",
174 #endif /* CONFIG_MAC80211_HT_DEBUG */
176 set_bit(HT_AGG_STATE_STOPPING
, &tid_tx
->state
);
178 del_timer_sync(&tid_tx
->addba_resp_timer
);
181 * After this packets are no longer handed right through
182 * to the driver but are put onto tid_tx->pending instead,
183 * with locking to ensure proper access.
185 clear_bit(HT_AGG_STATE_OPERATIONAL
, &tid_tx
->state
);
187 tid_tx
->stop_initiator
= initiator
;
189 ret
= drv_ampdu_action(local
, sta
->sdata
,
190 IEEE80211_AMPDU_TX_STOP
,
191 &sta
->sta
, tid
, NULL
);
193 /* HW shall not deny going back to legacy */
201 * After sending add Block Ack request we activated a timer until
202 * add Block Ack response will arrive from the recipient.
203 * If this timer expires sta_addba_resp_timer_expired will be executed.
205 static void sta_addba_resp_timer_expired(unsigned long data
)
207 /* not an elegant detour, but there is no choice as the timer passes
208 * only one argument, and both sta_info and TID are needed, so init
209 * flow in sta_info_create gives the TID as data, while the timer_to_id
210 * array gives the sta through container_of */
211 u16 tid
= *(u8
*)data
;
212 struct sta_info
*sta
= container_of((void *)data
,
213 struct sta_info
, timer_to_tid
[tid
]);
214 struct tid_ampdu_tx
*tid_tx
;
216 /* check if the TID waits for addBA response */
218 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
220 test_bit(HT_AGG_STATE_RESPONSE_RECEIVED
, &tid_tx
->state
)) {
222 #ifdef CONFIG_MAC80211_HT_DEBUG
223 printk(KERN_DEBUG
"timer expired on tid %d but we are not "
224 "(or no longer) expecting addBA response there\n",
230 #ifdef CONFIG_MAC80211_HT_DEBUG
231 printk(KERN_DEBUG
"addBA response timer expired on tid %d\n", tid
);
234 ieee80211_stop_tx_ba_session(&sta
->sta
, tid
);
238 static inline int ieee80211_ac_from_tid(int tid
)
240 return ieee802_1d_to_ac
[tid
& 7];
244 * When multiple aggregation sessions on multiple stations
245 * are being created/destroyed simultaneously, we need to
246 * refcount the global queue stop caused by that in order
247 * to not get into a situation where one of the aggregation
248 * setup or teardown re-enables queues before the other is
249 * ready to handle that.
251 * These two functions take care of this issue by keeping
252 * a global "agg_queue_stop" refcount.
254 static void __acquires(agg_queue
)
255 ieee80211_stop_queue_agg(struct ieee80211_local
*local
, int tid
)
257 int queue
= ieee80211_ac_from_tid(tid
);
259 if (atomic_inc_return(&local
->agg_queue_stop
[queue
]) == 1)
260 ieee80211_stop_queue_by_reason(
262 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
263 __acquire(agg_queue
);
266 static void __releases(agg_queue
)
267 ieee80211_wake_queue_agg(struct ieee80211_local
*local
, int tid
)
269 int queue
= ieee80211_ac_from_tid(tid
);
271 if (atomic_dec_return(&local
->agg_queue_stop
[queue
]) == 0)
272 ieee80211_wake_queue_by_reason(
274 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
275 __release(agg_queue
);
278 void ieee80211_tx_ba_session_handle_start(struct sta_info
*sta
, int tid
)
280 struct tid_ampdu_tx
*tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
281 struct ieee80211_local
*local
= sta
->local
;
282 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
286 lockdep_assert_held(&sta
->ampdu_mlme
.mtx
);
289 * While we're asking the driver about the aggregation,
290 * stop the AC queue so that we don't have to worry
291 * about frames that came in while we were doing that,
292 * which would require us to put them to the AC pending
293 * afterwards which just makes the code more complex.
295 ieee80211_stop_queue_agg(local
, tid
);
297 clear_bit(HT_AGG_STATE_WANT_START
, &tid_tx
->state
);
300 * make sure no packets are being processed to get
301 * valid starting sequence number
305 start_seq_num
= sta
->tid_seq
[tid
] >> 4;
307 ret
= drv_ampdu_action(local
, sdata
, IEEE80211_AMPDU_TX_START
,
308 &sta
->sta
, tid
, &start_seq_num
);
310 #ifdef CONFIG_MAC80211_HT_DEBUG
311 printk(KERN_DEBUG
"BA request denied - HW unavailable for"
314 spin_lock_bh(&sta
->lock
);
315 rcu_assign_pointer(sta
->ampdu_mlme
.tid_tx
[tid
], NULL
);
316 spin_unlock_bh(&sta
->lock
);
318 ieee80211_wake_queue_agg(local
, tid
);
319 call_rcu(&tid_tx
->rcu_head
, kfree_tid_tx
);
323 /* we can take packets again now */
324 ieee80211_wake_queue_agg(local
, tid
);
326 /* activate the timer for the recipient's addBA response */
327 mod_timer(&tid_tx
->addba_resp_timer
, jiffies
+ ADDBA_RESP_INTERVAL
);
328 #ifdef CONFIG_MAC80211_HT_DEBUG
329 printk(KERN_DEBUG
"activated addBA response timer on tid %d\n", tid
);
332 spin_lock_bh(&sta
->lock
);
333 sta
->ampdu_mlme
.addba_req_num
[tid
]++;
334 spin_unlock_bh(&sta
->lock
);
336 /* send AddBA request */
337 ieee80211_send_addba_request(sdata
, sta
->sta
.addr
, tid
,
338 tid_tx
->dialog_token
, start_seq_num
,
342 int ieee80211_start_tx_ba_session(struct ieee80211_sta
*pubsta
, u16 tid
)
344 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
345 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
346 struct ieee80211_local
*local
= sdata
->local
;
347 struct tid_ampdu_tx
*tid_tx
;
350 trace_api_start_tx_ba_session(pubsta
, tid
);
352 if (WARN_ON(!local
->ops
->ampdu_action
))
355 if ((tid
>= STA_TID_NUM
) ||
356 !(local
->hw
.flags
& IEEE80211_HW_AMPDU_AGGREGATION
))
359 #ifdef CONFIG_MAC80211_HT_DEBUG
360 printk(KERN_DEBUG
"Open BA session requested for %pM tid %u\n",
362 #endif /* CONFIG_MAC80211_HT_DEBUG */
365 * The aggregation code is not prepared to handle
366 * anything but STA/AP due to the BSSID handling.
367 * IBSS could work in the code but isn't supported
368 * by drivers or the standard.
370 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
&&
371 sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
&&
372 sdata
->vif
.type
!= NL80211_IFTYPE_AP
)
375 if (test_sta_flags(sta
, WLAN_STA_BLOCK_BA
)) {
376 #ifdef CONFIG_MAC80211_HT_DEBUG
377 printk(KERN_DEBUG
"BA sessions blocked. "
378 "Denying BA session request\n");
383 spin_lock_bh(&sta
->lock
);
385 /* we have tried too many times, receiver does not want A-MPDU */
386 if (sta
->ampdu_mlme
.addba_req_num
[tid
] > HT_AGG_MAX_RETRIES
) {
391 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
392 /* check if the TID is not in aggregation flow already */
394 #ifdef CONFIG_MAC80211_HT_DEBUG
395 printk(KERN_DEBUG
"BA request denied - session is not "
396 "idle on tid %u\n", tid
);
397 #endif /* CONFIG_MAC80211_HT_DEBUG */
402 /* prepare A-MPDU MLME for Tx aggregation */
403 tid_tx
= kzalloc(sizeof(struct tid_ampdu_tx
), GFP_ATOMIC
);
405 #ifdef CONFIG_MAC80211_HT_DEBUG
407 printk(KERN_ERR
"allocate tx mlme to tid %d failed\n",
414 skb_queue_head_init(&tid_tx
->pending
);
415 __set_bit(HT_AGG_STATE_WANT_START
, &tid_tx
->state
);
418 tid_tx
->addba_resp_timer
.function
= sta_addba_resp_timer_expired
;
419 tid_tx
->addba_resp_timer
.data
= (unsigned long)&sta
->timer_to_tid
[tid
];
420 init_timer(&tid_tx
->addba_resp_timer
);
422 /* assign a dialog token */
423 sta
->ampdu_mlme
.dialog_token_allocator
++;
424 tid_tx
->dialog_token
= sta
->ampdu_mlme
.dialog_token_allocator
;
426 /* finally, assign it to the array */
427 rcu_assign_pointer(sta
->ampdu_mlme
.tid_tx
[tid
], tid_tx
);
429 ieee80211_queue_work(&local
->hw
, &sta
->ampdu_mlme
.work
);
431 /* this flow continues off the work */
433 spin_unlock_bh(&sta
->lock
);
436 EXPORT_SYMBOL(ieee80211_start_tx_ba_session
);
439 * splice packets from the STA's pending to the local pending,
440 * requires a call to ieee80211_agg_splice_finish later
442 static void __acquires(agg_queue
)
443 ieee80211_agg_splice_packets(struct ieee80211_local
*local
,
444 struct tid_ampdu_tx
*tid_tx
, u16 tid
)
446 int queue
= ieee80211_ac_from_tid(tid
);
449 ieee80211_stop_queue_agg(local
, tid
);
451 if (WARN(!tid_tx
, "TID %d gone but expected when splicing aggregates"
452 " from the pending queue\n", tid
))
455 if (!skb_queue_empty(&tid_tx
->pending
)) {
456 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
457 /* copy over remaining packets */
458 skb_queue_splice_tail_init(&tid_tx
->pending
,
459 &local
->pending
[queue
]);
460 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
464 static void __releases(agg_queue
)
465 ieee80211_agg_splice_finish(struct ieee80211_local
*local
, u16 tid
)
467 ieee80211_wake_queue_agg(local
, tid
);
470 static void ieee80211_agg_tx_operational(struct ieee80211_local
*local
,
471 struct sta_info
*sta
, u16 tid
)
473 lockdep_assert_held(&sta
->ampdu_mlme
.mtx
);
475 #ifdef CONFIG_MAC80211_HT_DEBUG
476 printk(KERN_DEBUG
"Aggregation is on for tid %d\n", tid
);
479 drv_ampdu_action(local
, sta
->sdata
,
480 IEEE80211_AMPDU_TX_OPERATIONAL
,
481 &sta
->sta
, tid
, NULL
);
484 * synchronize with TX path, while splicing the TX path
485 * should block so it won't put more packets onto pending.
487 spin_lock_bh(&sta
->lock
);
489 ieee80211_agg_splice_packets(local
, sta
->ampdu_mlme
.tid_tx
[tid
], tid
);
491 * Now mark as operational. This will be visible
492 * in the TX path, and lets it go lock-free in
495 set_bit(HT_AGG_STATE_OPERATIONAL
, &sta
->ampdu_mlme
.tid_tx
[tid
]->state
);
496 ieee80211_agg_splice_finish(local
, tid
);
498 spin_unlock_bh(&sta
->lock
);
501 void ieee80211_start_tx_ba_cb(struct ieee80211_vif
*vif
, u8
*ra
, u16 tid
)
503 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
504 struct ieee80211_local
*local
= sdata
->local
;
505 struct sta_info
*sta
;
506 struct tid_ampdu_tx
*tid_tx
;
508 trace_api_start_tx_ba_cb(sdata
, ra
, tid
);
510 if (tid
>= STA_TID_NUM
) {
511 #ifdef CONFIG_MAC80211_HT_DEBUG
512 printk(KERN_DEBUG
"Bad TID value: tid = %d (>= %d)\n",
518 mutex_lock(&local
->sta_mtx
);
519 sta
= sta_info_get(sdata
, ra
);
521 mutex_unlock(&local
->sta_mtx
);
522 #ifdef CONFIG_MAC80211_HT_DEBUG
523 printk(KERN_DEBUG
"Could not find station: %pM\n", ra
);
528 mutex_lock(&sta
->ampdu_mlme
.mtx
);
529 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
531 if (WARN_ON(!tid_tx
)) {
532 #ifdef CONFIG_MAC80211_HT_DEBUG
533 printk(KERN_DEBUG
"addBA was not requested!\n");
538 if (WARN_ON(test_and_set_bit(HT_AGG_STATE_DRV_READY
, &tid_tx
->state
)))
541 if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED
, &tid_tx
->state
))
542 ieee80211_agg_tx_operational(local
, sta
, tid
);
545 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
546 mutex_unlock(&local
->sta_mtx
);
549 void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif
*vif
,
550 const u8
*ra
, u16 tid
)
552 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
553 struct ieee80211_local
*local
= sdata
->local
;
554 struct ieee80211_ra_tid
*ra_tid
;
555 struct sk_buff
*skb
= dev_alloc_skb(0);
557 if (unlikely(!skb
)) {
558 #ifdef CONFIG_MAC80211_HT_DEBUG
560 printk(KERN_WARNING
"%s: Not enough memory, "
561 "dropping start BA session", sdata
->name
);
565 ra_tid
= (struct ieee80211_ra_tid
*) &skb
->cb
;
566 memcpy(&ra_tid
->ra
, ra
, ETH_ALEN
);
569 skb
->pkt_type
= IEEE80211_SDATA_QUEUE_AGG_START
;
570 skb_queue_tail(&sdata
->skb_queue
, skb
);
571 ieee80211_queue_work(&local
->hw
, &sdata
->work
);
573 EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe
);
575 int __ieee80211_stop_tx_ba_session(struct sta_info
*sta
, u16 tid
,
576 enum ieee80211_back_parties initiator
)
580 mutex_lock(&sta
->ampdu_mlme
.mtx
);
582 ret
= ___ieee80211_stop_tx_ba_session(sta
, tid
, initiator
);
584 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
589 int ieee80211_stop_tx_ba_session(struct ieee80211_sta
*pubsta
, u16 tid
)
591 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
592 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
593 struct ieee80211_local
*local
= sdata
->local
;
594 struct tid_ampdu_tx
*tid_tx
;
597 trace_api_stop_tx_ba_session(pubsta
, tid
);
599 if (!local
->ops
->ampdu_action
)
602 if (tid
>= STA_TID_NUM
)
605 spin_lock_bh(&sta
->lock
);
606 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
613 if (test_bit(HT_AGG_STATE_STOPPING
, &tid_tx
->state
)) {
614 /* already in progress stopping it */
619 set_bit(HT_AGG_STATE_WANT_STOP
, &tid_tx
->state
);
620 ieee80211_queue_work(&local
->hw
, &sta
->ampdu_mlme
.work
);
623 spin_unlock_bh(&sta
->lock
);
626 EXPORT_SYMBOL(ieee80211_stop_tx_ba_session
);
628 void ieee80211_stop_tx_ba_cb(struct ieee80211_vif
*vif
, u8
*ra
, u8 tid
)
630 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
631 struct ieee80211_local
*local
= sdata
->local
;
632 struct sta_info
*sta
;
633 struct tid_ampdu_tx
*tid_tx
;
635 trace_api_stop_tx_ba_cb(sdata
, ra
, tid
);
637 if (tid
>= STA_TID_NUM
) {
638 #ifdef CONFIG_MAC80211_HT_DEBUG
639 printk(KERN_DEBUG
"Bad TID value: tid = %d (>= %d)\n",
645 #ifdef CONFIG_MAC80211_HT_DEBUG
646 printk(KERN_DEBUG
"Stopping Tx BA session for %pM tid %d\n",
648 #endif /* CONFIG_MAC80211_HT_DEBUG */
650 mutex_lock(&local
->sta_mtx
);
652 sta
= sta_info_get(sdata
, ra
);
654 #ifdef CONFIG_MAC80211_HT_DEBUG
655 printk(KERN_DEBUG
"Could not find station: %pM\n", ra
);
660 mutex_lock(&sta
->ampdu_mlme
.mtx
);
661 spin_lock_bh(&sta
->lock
);
662 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
664 if (!tid_tx
|| !test_bit(HT_AGG_STATE_STOPPING
, &tid_tx
->state
)) {
665 #ifdef CONFIG_MAC80211_HT_DEBUG
666 printk(KERN_DEBUG
"unexpected callback to A-MPDU stop\n");
671 if (tid_tx
->stop_initiator
== WLAN_BACK_INITIATOR
)
672 ieee80211_send_delba(sta
->sdata
, ra
, tid
,
673 WLAN_BACK_INITIATOR
, WLAN_REASON_QSTA_NOT_USE
);
676 * When we get here, the TX path will not be lockless any more wrt.
677 * aggregation, since the OPERATIONAL bit has long been cleared.
678 * Thus it will block on getting the lock, if it occurs. So if we
679 * stop the queue now, we will not get any more packets, and any
680 * that might be being processed will wait for us here, thereby
681 * guaranteeing that no packets go to the tid_tx pending queue any
685 ieee80211_agg_splice_packets(local
, tid_tx
, tid
);
687 /* future packets must not find the tid_tx struct any more */
688 rcu_assign_pointer(sta
->ampdu_mlme
.tid_tx
[tid
], NULL
);
690 ieee80211_agg_splice_finish(local
, tid
);
692 call_rcu(&tid_tx
->rcu_head
, kfree_tid_tx
);
695 spin_unlock_bh(&sta
->lock
);
696 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
698 mutex_unlock(&local
->sta_mtx
);
701 void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif
*vif
,
702 const u8
*ra
, u16 tid
)
704 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
705 struct ieee80211_local
*local
= sdata
->local
;
706 struct ieee80211_ra_tid
*ra_tid
;
707 struct sk_buff
*skb
= dev_alloc_skb(0);
709 if (unlikely(!skb
)) {
710 #ifdef CONFIG_MAC80211_HT_DEBUG
712 printk(KERN_WARNING
"%s: Not enough memory, "
713 "dropping stop BA session", sdata
->name
);
717 ra_tid
= (struct ieee80211_ra_tid
*) &skb
->cb
;
718 memcpy(&ra_tid
->ra
, ra
, ETH_ALEN
);
721 skb
->pkt_type
= IEEE80211_SDATA_QUEUE_AGG_STOP
;
722 skb_queue_tail(&sdata
->skb_queue
, skb
);
723 ieee80211_queue_work(&local
->hw
, &sdata
->work
);
725 EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe
);
728 void ieee80211_process_addba_resp(struct ieee80211_local
*local
,
729 struct sta_info
*sta
,
730 struct ieee80211_mgmt
*mgmt
,
733 struct tid_ampdu_tx
*tid_tx
;
736 capab
= le16_to_cpu(mgmt
->u
.action
.u
.addba_resp
.capab
);
737 tid
= (capab
& IEEE80211_ADDBA_PARAM_TID_MASK
) >> 2;
739 mutex_lock(&sta
->ampdu_mlme
.mtx
);
741 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
745 if (mgmt
->u
.action
.u
.addba_resp
.dialog_token
!= tid_tx
->dialog_token
) {
746 #ifdef CONFIG_MAC80211_HT_DEBUG
747 printk(KERN_DEBUG
"wrong addBA response token, tid %d\n", tid
);
752 del_timer(&tid_tx
->addba_resp_timer
);
754 #ifdef CONFIG_MAC80211_HT_DEBUG
755 printk(KERN_DEBUG
"switched off addBA timer for tid %d\n", tid
);
758 if (le16_to_cpu(mgmt
->u
.action
.u
.addba_resp
.status
)
759 == WLAN_STATUS_SUCCESS
) {
760 if (test_and_set_bit(HT_AGG_STATE_RESPONSE_RECEIVED
,
762 /* ignore duplicate response */
766 if (test_bit(HT_AGG_STATE_DRV_READY
, &tid_tx
->state
))
767 ieee80211_agg_tx_operational(local
, sta
, tid
);
769 sta
->ampdu_mlme
.addba_req_num
[tid
] = 0;
771 ___ieee80211_stop_tx_ba_session(sta
, tid
, WLAN_BACK_INITIATOR
);
775 mutex_unlock(&sta
->ampdu_mlme
.mtx
);