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-2009, 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"
26 * Aggregation on the TX side requires setting the hardware flag
27 * %IEEE80211_HW_AMPDU_AGGREGATION as well as, if present, the @ampdu_queues
28 * hardware parameter to the number of hardware AMPDU queues. If there are no
29 * hardware queues then the driver will (currently) have to do all frame
32 * When TX aggregation is started by some subsystem (usually the rate control
33 * algorithm would be appropriate) by calling the
34 * ieee80211_start_tx_ba_session() function, the driver will be notified via
35 * its @ampdu_action function, with the %IEEE80211_AMPDU_TX_START action.
37 * In response to that, the driver is later required to call the
38 * ieee80211_start_tx_ba_cb() (or ieee80211_start_tx_ba_cb_irqsafe())
39 * function, which will start the aggregation session.
41 * Similarly, when the aggregation session is stopped by
42 * ieee80211_stop_tx_ba_session(), the driver's @ampdu_action function will
43 * be called with the action %IEEE80211_AMPDU_TX_STOP. In this case, the
44 * call must not fail, and the driver must later call ieee80211_stop_tx_ba_cb()
45 * (or ieee80211_stop_tx_ba_cb_irqsafe()).
48 static void ieee80211_send_addba_request(struct ieee80211_sub_if_data
*sdata
,
49 const u8
*da
, u16 tid
,
50 u8 dialog_token
, u16 start_seq_num
,
51 u16 agg_size
, u16 timeout
)
53 struct ieee80211_local
*local
= sdata
->local
;
55 struct ieee80211_mgmt
*mgmt
;
58 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
);
61 printk(KERN_ERR
"%s: failed to allocate buffer "
62 "for addba request frame\n", sdata
->name
);
65 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
66 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
68 memcpy(mgmt
->da
, da
, ETH_ALEN
);
69 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
70 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
71 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
72 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
73 else if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
)
74 memcpy(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
76 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
77 IEEE80211_STYPE_ACTION
);
79 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.addba_req
));
81 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
82 mgmt
->u
.action
.u
.addba_req
.action_code
= WLAN_ACTION_ADDBA_REQ
;
84 mgmt
->u
.action
.u
.addba_req
.dialog_token
= dialog_token
;
85 capab
= (u16
)(1 << 1); /* bit 1 aggregation policy */
86 capab
|= (u16
)(tid
<< 2); /* bit 5:2 TID number */
87 capab
|= (u16
)(agg_size
<< 6); /* bit 15:6 max size of aggergation */
89 mgmt
->u
.action
.u
.addba_req
.capab
= cpu_to_le16(capab
);
91 mgmt
->u
.action
.u
.addba_req
.timeout
= cpu_to_le16(timeout
);
92 mgmt
->u
.action
.u
.addba_req
.start_seq_num
=
93 cpu_to_le16(start_seq_num
<< 4);
95 ieee80211_tx_skb(sdata
, skb
);
98 void ieee80211_send_bar(struct ieee80211_sub_if_data
*sdata
, u8
*ra
, u16 tid
, u16 ssn
)
100 struct ieee80211_local
*local
= sdata
->local
;
102 struct ieee80211_bar
*bar
;
105 skb
= dev_alloc_skb(sizeof(*bar
) + local
->hw
.extra_tx_headroom
);
107 printk(KERN_ERR
"%s: failed to allocate buffer for "
108 "bar frame\n", sdata
->name
);
111 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
112 bar
= (struct ieee80211_bar
*)skb_put(skb
, sizeof(*bar
));
113 memset(bar
, 0, sizeof(*bar
));
114 bar
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_CTL
|
115 IEEE80211_STYPE_BACK_REQ
);
116 memcpy(bar
->ra
, ra
, ETH_ALEN
);
117 memcpy(bar
->ta
, sdata
->vif
.addr
, ETH_ALEN
);
118 bar_control
|= (u16
)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL
;
119 bar_control
|= (u16
)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA
;
120 bar_control
|= (u16
)(tid
<< 12);
121 bar
->control
= cpu_to_le16(bar_control
);
122 bar
->start_seq_num
= cpu_to_le16(ssn
);
124 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
125 ieee80211_tx_skb(sdata
, skb
);
128 static void kfree_tid_tx(struct rcu_head
*rcu_head
)
130 struct tid_ampdu_tx
*tid_tx
=
131 container_of(rcu_head
, struct tid_ampdu_tx
, rcu_head
);
136 static int ___ieee80211_stop_tx_ba_session(
137 struct sta_info
*sta
, u16 tid
,
138 enum ieee80211_back_parties initiator
)
140 struct ieee80211_local
*local
= sta
->local
;
141 struct tid_ampdu_tx
*tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
144 lockdep_assert_held(&sta
->lock
);
146 if (WARN_ON(!tid_tx
))
149 #ifdef CONFIG_MAC80211_HT_DEBUG
150 printk(KERN_DEBUG
"Tx BA session stop requested for %pM tid %u\n",
152 #endif /* CONFIG_MAC80211_HT_DEBUG */
154 set_bit(HT_AGG_STATE_STOPPING
, &tid_tx
->state
);
157 * After this packets are no longer handed right through
158 * to the driver but are put onto tid_tx->pending instead,
159 * with locking to ensure proper access.
161 clear_bit(HT_AGG_STATE_OPERATIONAL
, &tid_tx
->state
);
163 tid_tx
->stop_initiator
= initiator
;
165 ret
= drv_ampdu_action(local
, sta
->sdata
,
166 IEEE80211_AMPDU_TX_STOP
,
167 &sta
->sta
, tid
, NULL
);
169 /* HW shall not deny going back to legacy */
172 * We may have pending packets get stuck in this case...
173 * Not bothering with a workaround for now.
181 * After sending add Block Ack request we activated a timer until
182 * add Block Ack response will arrive from the recipient.
183 * If this timer expires sta_addba_resp_timer_expired will be executed.
185 static void sta_addba_resp_timer_expired(unsigned long data
)
187 /* not an elegant detour, but there is no choice as the timer passes
188 * only one argument, and both sta_info and TID are needed, so init
189 * flow in sta_info_create gives the TID as data, while the timer_to_id
190 * array gives the sta through container_of */
191 u16 tid
= *(u8
*)data
;
192 struct sta_info
*sta
= container_of((void *)data
,
193 struct sta_info
, timer_to_tid
[tid
]);
194 struct tid_ampdu_tx
*tid_tx
;
196 /* check if the TID waits for addBA response */
197 spin_lock_bh(&sta
->lock
);
198 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
200 test_bit(HT_AGG_STATE_RESPONSE_RECEIVED
, &tid_tx
->state
)) {
201 spin_unlock_bh(&sta
->lock
);
202 #ifdef CONFIG_MAC80211_HT_DEBUG
203 printk(KERN_DEBUG
"timer expired on tid %d but we are not "
204 "(or no longer) expecting addBA response there\n",
210 #ifdef CONFIG_MAC80211_HT_DEBUG
211 printk(KERN_DEBUG
"addBA response timer expired on tid %d\n", tid
);
214 ___ieee80211_stop_tx_ba_session(sta
, tid
, WLAN_BACK_INITIATOR
);
215 spin_unlock_bh(&sta
->lock
);
218 static inline int ieee80211_ac_from_tid(int tid
)
220 return ieee802_1d_to_ac
[tid
& 7];
223 int ieee80211_start_tx_ba_session(struct ieee80211_sta
*pubsta
, u16 tid
)
225 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
226 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
227 struct ieee80211_local
*local
= sdata
->local
;
228 struct tid_ampdu_tx
*tid_tx
;
232 trace_api_start_tx_ba_session(pubsta
, tid
);
234 if (WARN_ON(!local
->ops
->ampdu_action
))
237 if ((tid
>= STA_TID_NUM
) ||
238 !(local
->hw
.flags
& IEEE80211_HW_AMPDU_AGGREGATION
))
241 #ifdef CONFIG_MAC80211_HT_DEBUG
242 printk(KERN_DEBUG
"Open BA session requested for %pM tid %u\n",
244 #endif /* CONFIG_MAC80211_HT_DEBUG */
247 * The aggregation code is not prepared to handle
248 * anything but STA/AP due to the BSSID handling.
249 * IBSS could work in the code but isn't supported
250 * by drivers or the standard.
252 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
&&
253 sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
&&
254 sdata
->vif
.type
!= NL80211_IFTYPE_AP
)
257 if (test_sta_flags(sta
, WLAN_STA_BLOCK_BA
)) {
258 #ifdef CONFIG_MAC80211_HT_DEBUG
259 printk(KERN_DEBUG
"BA sessions blocked. "
260 "Denying BA session request\n");
265 spin_lock_bh(&sta
->lock
);
266 spin_lock(&local
->ampdu_lock
);
268 /* we have tried too many times, receiver does not want A-MPDU */
269 if (sta
->ampdu_mlme
.addba_req_num
[tid
] > HT_AGG_MAX_RETRIES
) {
274 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
275 /* check if the TID is not in aggregation flow already */
277 #ifdef CONFIG_MAC80211_HT_DEBUG
278 printk(KERN_DEBUG
"BA request denied - session is not "
279 "idle on tid %u\n", tid
);
280 #endif /* CONFIG_MAC80211_HT_DEBUG */
286 * While we're asking the driver about the aggregation,
287 * stop the AC queue so that we don't have to worry
288 * about frames that came in while we were doing that,
289 * which would require us to put them to the AC pending
290 * afterwards which just makes the code more complex.
292 ieee80211_stop_queue_by_reason(
293 &local
->hw
, ieee80211_ac_from_tid(tid
),
294 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
296 /* prepare A-MPDU MLME for Tx aggregation */
297 tid_tx
= kzalloc(sizeof(struct tid_ampdu_tx
), GFP_ATOMIC
);
299 #ifdef CONFIG_MAC80211_HT_DEBUG
301 printk(KERN_ERR
"allocate tx mlme to tid %d failed\n",
308 skb_queue_head_init(&tid_tx
->pending
);
311 tid_tx
->addba_resp_timer
.function
= sta_addba_resp_timer_expired
;
312 tid_tx
->addba_resp_timer
.data
= (unsigned long)&sta
->timer_to_tid
[tid
];
313 init_timer(&tid_tx
->addba_resp_timer
);
315 start_seq_num
= sta
->tid_seq
[tid
] >> 4;
317 ret
= drv_ampdu_action(local
, sdata
, IEEE80211_AMPDU_TX_START
,
318 pubsta
, tid
, &start_seq_num
);
320 #ifdef CONFIG_MAC80211_HT_DEBUG
321 printk(KERN_DEBUG
"BA request denied - HW unavailable for"
323 #endif /* CONFIG_MAC80211_HT_DEBUG */
327 rcu_assign_pointer(sta
->ampdu_mlme
.tid_tx
[tid
], tid_tx
);
329 /* Driver vetoed or OKed, but we can take packets again now */
330 ieee80211_wake_queue_by_reason(
331 &local
->hw
, ieee80211_ac_from_tid(tid
),
332 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
334 spin_unlock(&local
->ampdu_lock
);
336 /* activate the timer for the recipient's addBA response */
337 tid_tx
->addba_resp_timer
.expires
= jiffies
+ ADDBA_RESP_INTERVAL
;
338 add_timer(&tid_tx
->addba_resp_timer
);
339 #ifdef CONFIG_MAC80211_HT_DEBUG
340 printk(KERN_DEBUG
"activated addBA response timer on tid %d\n", tid
);
343 /* prepare tid data */
344 sta
->ampdu_mlme
.dialog_token_allocator
++;
345 tid_tx
->dialog_token
= sta
->ampdu_mlme
.dialog_token_allocator
;
346 tid_tx
->ssn
= start_seq_num
;
348 sta
->ampdu_mlme
.addba_req_num
[tid
]++;
350 spin_unlock_bh(&sta
->lock
);
352 /* send AddBA request */
353 ieee80211_send_addba_request(sdata
, pubsta
->addr
, tid
,
354 tid_tx
->dialog_token
, tid_tx
->ssn
,
361 ieee80211_wake_queue_by_reason(
362 &local
->hw
, ieee80211_ac_from_tid(tid
),
363 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
365 spin_unlock(&local
->ampdu_lock
);
366 spin_unlock_bh(&sta
->lock
);
369 EXPORT_SYMBOL(ieee80211_start_tx_ba_session
);
372 * splice packets from the STA's pending to the local pending,
373 * requires a call to ieee80211_agg_splice_finish and holding
374 * local->ampdu_lock across both calls.
376 static void ieee80211_agg_splice_packets(struct ieee80211_local
*local
,
377 struct tid_ampdu_tx
*tid_tx
,
381 u16 queue
= ieee80211_ac_from_tid(tid
);
383 ieee80211_stop_queue_by_reason(
385 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
387 if (WARN(!tid_tx
, "TID %d gone but expected when splicing aggregates"
388 " from the pending queue\n", tid
))
391 if (!skb_queue_empty(&tid_tx
->pending
)) {
392 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
393 /* copy over remaining packets */
394 skb_queue_splice_tail_init(&tid_tx
->pending
,
395 &local
->pending
[queue
]);
396 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
400 static void ieee80211_agg_splice_finish(struct ieee80211_local
*local
, u16 tid
)
402 ieee80211_wake_queue_by_reason(
403 &local
->hw
, ieee80211_ac_from_tid(tid
),
404 IEEE80211_QUEUE_STOP_REASON_AGGREGATION
);
407 /* caller must hold sta->lock */
408 static void ieee80211_agg_tx_operational(struct ieee80211_local
*local
,
409 struct sta_info
*sta
, u16 tid
)
411 lockdep_assert_held(&sta
->lock
);
413 #ifdef CONFIG_MAC80211_HT_DEBUG
414 printk(KERN_DEBUG
"Aggregation is on for tid %d\n", tid
);
417 spin_lock(&local
->ampdu_lock
);
418 ieee80211_agg_splice_packets(local
, sta
->ampdu_mlme
.tid_tx
[tid
], tid
);
420 * Now mark as operational. This will be visible
421 * in the TX path, and lets it go lock-free in
424 set_bit(HT_AGG_STATE_OPERATIONAL
, &sta
->ampdu_mlme
.tid_tx
[tid
]->state
);
425 ieee80211_agg_splice_finish(local
, tid
);
426 spin_unlock(&local
->ampdu_lock
);
428 drv_ampdu_action(local
, sta
->sdata
,
429 IEEE80211_AMPDU_TX_OPERATIONAL
,
430 &sta
->sta
, tid
, NULL
);
433 void ieee80211_start_tx_ba_cb(struct ieee80211_vif
*vif
, u8
*ra
, u16 tid
)
435 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
436 struct ieee80211_local
*local
= sdata
->local
;
437 struct sta_info
*sta
;
438 struct tid_ampdu_tx
*tid_tx
;
440 trace_api_start_tx_ba_cb(sdata
, ra
, tid
);
442 if (tid
>= STA_TID_NUM
) {
443 #ifdef CONFIG_MAC80211_HT_DEBUG
444 printk(KERN_DEBUG
"Bad TID value: tid = %d (>= %d)\n",
451 sta
= sta_info_get(sdata
, ra
);
454 #ifdef CONFIG_MAC80211_HT_DEBUG
455 printk(KERN_DEBUG
"Could not find station: %pM\n", ra
);
460 spin_lock_bh(&sta
->lock
);
461 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
463 if (WARN_ON(!tid_tx
)) {
464 #ifdef CONFIG_MAC80211_HT_DEBUG
465 printk(KERN_DEBUG
"addBA was not requested!\n");
467 spin_unlock_bh(&sta
->lock
);
472 if (WARN_ON(test_and_set_bit(HT_AGG_STATE_DRV_READY
, &tid_tx
->state
)))
475 if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED
, &tid_tx
->state
))
476 ieee80211_agg_tx_operational(local
, sta
, tid
);
479 spin_unlock_bh(&sta
->lock
);
482 EXPORT_SYMBOL(ieee80211_start_tx_ba_cb
);
484 void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif
*vif
,
485 const u8
*ra
, u16 tid
)
487 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
488 struct ieee80211_local
*local
= sdata
->local
;
489 struct ieee80211_ra_tid
*ra_tid
;
490 struct sk_buff
*skb
= dev_alloc_skb(0);
492 if (unlikely(!skb
)) {
493 #ifdef CONFIG_MAC80211_HT_DEBUG
495 printk(KERN_WARNING
"%s: Not enough memory, "
496 "dropping start BA session", sdata
->name
);
500 ra_tid
= (struct ieee80211_ra_tid
*) &skb
->cb
;
501 memcpy(&ra_tid
->ra
, ra
, ETH_ALEN
);
504 skb
->pkt_type
= IEEE80211_SDATA_QUEUE_AGG_START
;
505 skb_queue_tail(&sdata
->skb_queue
, skb
);
506 ieee80211_queue_work(&local
->hw
, &sdata
->work
);
508 EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe
);
510 int __ieee80211_stop_tx_ba_session(struct sta_info
*sta
, u16 tid
,
511 enum ieee80211_back_parties initiator
)
513 struct tid_ampdu_tx
*tid_tx
;
516 spin_lock_bh(&sta
->lock
);
517 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
519 /* check if the TID is in aggregation */
520 if (!tid_tx
|| !test_bit(HT_AGG_STATE_OPERATIONAL
, &tid_tx
->state
)) {
525 ret
= ___ieee80211_stop_tx_ba_session(sta
, tid
, initiator
);
528 spin_unlock_bh(&sta
->lock
);
532 int ieee80211_stop_tx_ba_session(struct ieee80211_sta
*pubsta
, u16 tid
)
534 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
535 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
536 struct ieee80211_local
*local
= sdata
->local
;
538 trace_api_stop_tx_ba_session(pubsta
, tid
);
540 if (!local
->ops
->ampdu_action
)
543 if (tid
>= STA_TID_NUM
)
546 return __ieee80211_stop_tx_ba_session(sta
, tid
, WLAN_BACK_INITIATOR
);
548 EXPORT_SYMBOL(ieee80211_stop_tx_ba_session
);
550 void ieee80211_stop_tx_ba_cb(struct ieee80211_vif
*vif
, u8
*ra
, u8 tid
)
552 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
553 struct ieee80211_local
*local
= sdata
->local
;
554 struct sta_info
*sta
;
555 struct tid_ampdu_tx
*tid_tx
;
557 trace_api_stop_tx_ba_cb(sdata
, ra
, tid
);
559 if (tid
>= STA_TID_NUM
) {
560 #ifdef CONFIG_MAC80211_HT_DEBUG
561 printk(KERN_DEBUG
"Bad TID value: tid = %d (>= %d)\n",
567 #ifdef CONFIG_MAC80211_HT_DEBUG
568 printk(KERN_DEBUG
"Stopping Tx BA session for %pM tid %d\n",
570 #endif /* CONFIG_MAC80211_HT_DEBUG */
573 sta
= sta_info_get(sdata
, ra
);
575 #ifdef CONFIG_MAC80211_HT_DEBUG
576 printk(KERN_DEBUG
"Could not find station: %pM\n", ra
);
582 spin_lock_bh(&sta
->lock
);
583 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
585 if (!tid_tx
|| !test_bit(HT_AGG_STATE_STOPPING
, &tid_tx
->state
)) {
586 #ifdef CONFIG_MAC80211_HT_DEBUG
587 printk(KERN_DEBUG
"unexpected callback to A-MPDU stop\n");
589 spin_unlock_bh(&sta
->lock
);
594 if (tid_tx
->stop_initiator
== WLAN_BACK_INITIATOR
)
595 ieee80211_send_delba(sta
->sdata
, ra
, tid
,
596 WLAN_BACK_INITIATOR
, WLAN_REASON_QSTA_NOT_USE
);
599 * When we get here, the TX path will not be lockless any more wrt.
600 * aggregation, since the OPERATIONAL bit has long been cleared.
601 * Thus it will block on getting the lock, if it occurs. So if we
602 * stop the queue now, we will not get any more packets, and any
603 * that might be being processed will wait for us here, thereby
604 * guaranteeing that no packets go to the tid_tx pending queue any
608 spin_lock(&local
->ampdu_lock
);
609 ieee80211_agg_splice_packets(local
, tid_tx
, tid
);
611 /* future packets must not find the tid_tx struct any more */
612 rcu_assign_pointer(sta
->ampdu_mlme
.tid_tx
[tid
], NULL
);
614 ieee80211_agg_splice_finish(local
, tid
);
616 call_rcu(&tid_tx
->rcu_head
, kfree_tid_tx
);
617 spin_unlock(&local
->ampdu_lock
);
619 spin_unlock_bh(&sta
->lock
);
622 EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb
);
624 void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif
*vif
,
625 const u8
*ra
, u16 tid
)
627 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
628 struct ieee80211_local
*local
= sdata
->local
;
629 struct ieee80211_ra_tid
*ra_tid
;
630 struct sk_buff
*skb
= dev_alloc_skb(0);
632 if (unlikely(!skb
)) {
633 #ifdef CONFIG_MAC80211_HT_DEBUG
635 printk(KERN_WARNING
"%s: Not enough memory, "
636 "dropping stop BA session", sdata
->name
);
640 ra_tid
= (struct ieee80211_ra_tid
*) &skb
->cb
;
641 memcpy(&ra_tid
->ra
, ra
, ETH_ALEN
);
644 skb
->pkt_type
= IEEE80211_SDATA_QUEUE_AGG_STOP
;
645 skb_queue_tail(&sdata
->skb_queue
, skb
);
646 ieee80211_queue_work(&local
->hw
, &sdata
->work
);
648 EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe
);
651 void ieee80211_process_addba_resp(struct ieee80211_local
*local
,
652 struct sta_info
*sta
,
653 struct ieee80211_mgmt
*mgmt
,
656 struct tid_ampdu_tx
*tid_tx
;
659 capab
= le16_to_cpu(mgmt
->u
.action
.u
.addba_resp
.capab
);
660 tid
= (capab
& IEEE80211_ADDBA_PARAM_TID_MASK
) >> 2;
662 spin_lock_bh(&sta
->lock
);
664 tid_tx
= sta
->ampdu_mlme
.tid_tx
[tid
];
669 if (mgmt
->u
.action
.u
.addba_resp
.dialog_token
!= tid_tx
->dialog_token
) {
670 #ifdef CONFIG_MAC80211_HT_DEBUG
671 printk(KERN_DEBUG
"wrong addBA response token, tid %d\n", tid
);
676 del_timer(&tid_tx
->addba_resp_timer
);
678 #ifdef CONFIG_MAC80211_HT_DEBUG
679 printk(KERN_DEBUG
"switched off addBA timer for tid %d\n", tid
);
682 if (le16_to_cpu(mgmt
->u
.action
.u
.addba_resp
.status
)
683 == WLAN_STATUS_SUCCESS
) {
684 if (test_and_set_bit(HT_AGG_STATE_RESPONSE_RECEIVED
,
686 /* ignore duplicate response */
690 if (test_bit(HT_AGG_STATE_DRV_READY
, &tid_tx
->state
))
691 ieee80211_agg_tx_operational(local
, sta
, tid
);
693 sta
->ampdu_mlme
.addba_req_num
[tid
] = 0;
695 ___ieee80211_stop_tx_ba_session(sta
, tid
, WLAN_BACK_INITIATOR
);
699 spin_unlock_bh(&sta
->lock
);