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.
17 * DOC: RX A-MPDU aggregation
19 * Aggregation on the RX side requires only implementing the
20 * @ampdu_action callback that is invoked to start/stop any
21 * block-ack sessions for RX aggregation.
23 * When RX aggregation is started by the peer, the driver is
24 * notified via @ampdu_action function, with the
25 * %IEEE80211_AMPDU_RX_START action, and may reject the request
26 * in which case a negative response is sent to the peer, if it
27 * accepts it a positive response is sent.
29 * While the session is active, the device/driver are required
30 * to de-aggregate frames and pass them up one by one to mac80211,
31 * which will handle the reorder buffer.
33 * When the aggregation session is stopped again by the peer or
34 * ourselves, the driver's @ampdu_action function will be called
35 * with the action %IEEE80211_AMPDU_RX_STOP. In this case, the
39 #include <linux/ieee80211.h>
40 #include <linux/slab.h>
41 #include <net/mac80211.h>
42 #include "ieee80211_i.h"
43 #include "driver-ops.h"
45 static void ieee80211_free_tid_rx(struct rcu_head
*h
)
47 struct tid_ampdu_rx
*tid_rx
=
48 container_of(h
, struct tid_ampdu_rx
, rcu_head
);
51 for (i
= 0; i
< tid_rx
->buf_size
; i
++)
52 dev_kfree_skb(tid_rx
->reorder_buf
[i
]);
53 kfree(tid_rx
->reorder_buf
);
54 kfree(tid_rx
->reorder_time
);
58 void ___ieee80211_stop_rx_ba_session(struct sta_info
*sta
, u16 tid
,
59 u16 initiator
, u16 reason
, bool tx
)
61 struct ieee80211_local
*local
= sta
->local
;
62 struct tid_ampdu_rx
*tid_rx
;
64 lockdep_assert_held(&sta
->ampdu_mlme
.mtx
);
66 tid_rx
= rcu_dereference_protected(sta
->ampdu_mlme
.tid_rx
[tid
],
67 lockdep_is_held(&sta
->ampdu_mlme
.mtx
));
72 rcu_assign_pointer(sta
->ampdu_mlme
.tid_rx
[tid
], NULL
);
74 #ifdef CONFIG_MAC80211_HT_DEBUG
75 printk(KERN_DEBUG
"Rx BA session stop requested for %pM tid %u\n",
77 #endif /* CONFIG_MAC80211_HT_DEBUG */
79 if (drv_ampdu_action(local
, sta
->sdata
, IEEE80211_AMPDU_RX_STOP
,
80 &sta
->sta
, tid
, NULL
, 0))
81 printk(KERN_DEBUG
"HW problem - can not stop rx "
82 "aggregation for tid %d\n", tid
);
84 /* check if this is a self generated aggregation halt */
85 if (initiator
== WLAN_BACK_RECIPIENT
&& tx
)
86 ieee80211_send_delba(sta
->sdata
, sta
->sta
.addr
,
89 del_timer_sync(&tid_rx
->session_timer
);
90 del_timer_sync(&tid_rx
->reorder_timer
);
92 call_rcu(&tid_rx
->rcu_head
, ieee80211_free_tid_rx
);
95 void __ieee80211_stop_rx_ba_session(struct sta_info
*sta
, u16 tid
,
96 u16 initiator
, u16 reason
, bool tx
)
98 mutex_lock(&sta
->ampdu_mlme
.mtx
);
99 ___ieee80211_stop_rx_ba_session(sta
, tid
, initiator
, reason
, tx
);
100 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
103 void ieee80211_stop_rx_ba_session(struct ieee80211_vif
*vif
, u16 ba_rx_bitmap
,
106 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
107 struct sta_info
*sta
= sta_info_get(sdata
, addr
);
110 for (i
= 0; i
< STA_TID_NUM
; i
++)
111 if (ba_rx_bitmap
& BIT(i
))
112 set_bit(i
, sta
->ampdu_mlme
.tid_rx_stop_requested
);
114 ieee80211_queue_work(&sta
->local
->hw
, &sta
->ampdu_mlme
.work
);
116 EXPORT_SYMBOL(ieee80211_stop_rx_ba_session
);
119 * After accepting the AddBA Request we activated a timer,
120 * resetting it after each frame that arrives from the originator.
122 static void sta_rx_agg_session_timer_expired(unsigned long data
)
124 /* not an elegant detour, but there is no choice as the timer passes
125 * only one argument, and various sta_info are needed here, so init
126 * flow in sta_info_create gives the TID as data, while the timer_to_id
127 * array gives the sta through container_of */
128 u8
*ptid
= (u8
*)data
;
129 u8
*timer_to_id
= ptid
- *ptid
;
130 struct sta_info
*sta
= container_of(timer_to_id
, struct sta_info
,
133 #ifdef CONFIG_MAC80211_HT_DEBUG
134 printk(KERN_DEBUG
"rx session timer expired on tid %d\n", (u16
)*ptid
);
136 set_bit(*ptid
, sta
->ampdu_mlme
.tid_rx_timer_expired
);
137 ieee80211_queue_work(&sta
->local
->hw
, &sta
->ampdu_mlme
.work
);
140 static void sta_rx_agg_reorder_timer_expired(unsigned long data
)
142 u8
*ptid
= (u8
*)data
;
143 u8
*timer_to_id
= ptid
- *ptid
;
144 struct sta_info
*sta
= container_of(timer_to_id
, struct sta_info
,
148 ieee80211_release_reorder_timeout(sta
, *ptid
);
152 static void ieee80211_send_addba_resp(struct ieee80211_sub_if_data
*sdata
, u8
*da
, u16 tid
,
153 u8 dialog_token
, u16 status
, u16 policy
,
154 u16 buf_size
, u16 timeout
)
156 struct ieee80211_local
*local
= sdata
->local
;
158 struct ieee80211_mgmt
*mgmt
;
161 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
);
164 printk(KERN_DEBUG
"%s: failed to allocate buffer "
165 "for addba resp frame\n", sdata
->name
);
169 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
170 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
172 memcpy(mgmt
->da
, da
, ETH_ALEN
);
173 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
174 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
175 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
176 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
177 else if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
)
178 memcpy(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
180 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
181 IEEE80211_STYPE_ACTION
);
183 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.addba_resp
));
184 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
185 mgmt
->u
.action
.u
.addba_resp
.action_code
= WLAN_ACTION_ADDBA_RESP
;
186 mgmt
->u
.action
.u
.addba_resp
.dialog_token
= dialog_token
;
188 capab
= (u16
)(policy
<< 1); /* bit 1 aggregation policy */
189 capab
|= (u16
)(tid
<< 2); /* bit 5:2 TID number */
190 capab
|= (u16
)(buf_size
<< 6); /* bit 15:6 max size of aggregation */
192 mgmt
->u
.action
.u
.addba_resp
.capab
= cpu_to_le16(capab
);
193 mgmt
->u
.action
.u
.addba_resp
.timeout
= cpu_to_le16(timeout
);
194 mgmt
->u
.action
.u
.addba_resp
.status
= cpu_to_le16(status
);
196 ieee80211_tx_skb(sdata
, skb
);
199 void ieee80211_process_addba_request(struct ieee80211_local
*local
,
200 struct sta_info
*sta
,
201 struct ieee80211_mgmt
*mgmt
,
204 struct tid_ampdu_rx
*tid_agg_rx
;
205 u16 capab
, tid
, timeout
, ba_policy
, buf_size
, start_seq_num
, status
;
207 int ret
= -EOPNOTSUPP
;
209 /* extract session parameters from addba request frame */
210 dialog_token
= mgmt
->u
.action
.u
.addba_req
.dialog_token
;
211 timeout
= le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.timeout
);
213 le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.start_seq_num
) >> 4;
215 capab
= le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.capab
);
216 ba_policy
= (capab
& IEEE80211_ADDBA_PARAM_POLICY_MASK
) >> 1;
217 tid
= (capab
& IEEE80211_ADDBA_PARAM_TID_MASK
) >> 2;
218 buf_size
= (capab
& IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK
) >> 6;
220 status
= WLAN_STATUS_REQUEST_DECLINED
;
222 if (test_sta_flags(sta
, WLAN_STA_BLOCK_BA
)) {
223 #ifdef CONFIG_MAC80211_HT_DEBUG
224 printk(KERN_DEBUG
"Suspend in progress. "
225 "Denying ADDBA request\n");
230 /* sanity check for incoming parameters:
231 * check if configuration can support the BA policy
232 * and if buffer size does not exceeds max value */
233 /* XXX: check own ht delayed BA capability?? */
234 if (((ba_policy
!= 1) &&
235 (!(sta
->sta
.ht_cap
.cap
& IEEE80211_HT_CAP_DELAY_BA
))) ||
236 (buf_size
> IEEE80211_MAX_AMPDU_BUF
)) {
237 status
= WLAN_STATUS_INVALID_QOS_PARAM
;
238 #ifdef CONFIG_MAC80211_HT_DEBUG
240 printk(KERN_DEBUG
"AddBA Req with bad params from "
241 "%pM on tid %u. policy %d, buffer size %d\n",
242 mgmt
->sa
, tid
, ba_policy
,
244 #endif /* CONFIG_MAC80211_HT_DEBUG */
247 /* determine default buffer size */
249 buf_size
= IEEE80211_MAX_AMPDU_BUF
;
251 /* make sure the size doesn't exceed the maximum supported by the hw */
252 if (buf_size
> local
->hw
.max_rx_aggregation_subframes
)
253 buf_size
= local
->hw
.max_rx_aggregation_subframes
;
255 /* examine state machine */
256 mutex_lock(&sta
->ampdu_mlme
.mtx
);
258 if (sta
->ampdu_mlme
.tid_rx
[tid
]) {
259 #ifdef CONFIG_MAC80211_HT_DEBUG
261 printk(KERN_DEBUG
"unexpected AddBA Req from "
264 #endif /* CONFIG_MAC80211_HT_DEBUG */
266 /* delete existing Rx BA session on the same tid */
267 ___ieee80211_stop_rx_ba_session(sta
, tid
, WLAN_BACK_RECIPIENT
,
268 WLAN_STATUS_UNSPECIFIED_QOS
,
272 /* prepare A-MPDU MLME for Rx aggregation */
273 tid_agg_rx
= kmalloc(sizeof(struct tid_ampdu_rx
), GFP_KERNEL
);
275 #ifdef CONFIG_MAC80211_HT_DEBUG
277 printk(KERN_ERR
"allocate rx mlme to tid %d failed\n",
283 spin_lock_init(&tid_agg_rx
->reorder_lock
);
286 tid_agg_rx
->session_timer
.function
= sta_rx_agg_session_timer_expired
;
287 tid_agg_rx
->session_timer
.data
= (unsigned long)&sta
->timer_to_tid
[tid
];
288 init_timer(&tid_agg_rx
->session_timer
);
290 /* rx reorder timer */
291 tid_agg_rx
->reorder_timer
.function
= sta_rx_agg_reorder_timer_expired
;
292 tid_agg_rx
->reorder_timer
.data
= (unsigned long)&sta
->timer_to_tid
[tid
];
293 init_timer(&tid_agg_rx
->reorder_timer
);
295 /* prepare reordering buffer */
296 tid_agg_rx
->reorder_buf
=
297 kcalloc(buf_size
, sizeof(struct sk_buff
*), GFP_KERNEL
);
298 tid_agg_rx
->reorder_time
=
299 kcalloc(buf_size
, sizeof(unsigned long), GFP_KERNEL
);
300 if (!tid_agg_rx
->reorder_buf
|| !tid_agg_rx
->reorder_time
) {
301 #ifdef CONFIG_MAC80211_HT_DEBUG
303 printk(KERN_ERR
"can not allocate reordering buffer "
306 kfree(tid_agg_rx
->reorder_buf
);
307 kfree(tid_agg_rx
->reorder_time
);
312 ret
= drv_ampdu_action(local
, sta
->sdata
, IEEE80211_AMPDU_RX_START
,
313 &sta
->sta
, tid
, &start_seq_num
, 0);
314 #ifdef CONFIG_MAC80211_HT_DEBUG
315 printk(KERN_DEBUG
"Rx A-MPDU request on tid %d result %d\n", tid
, ret
);
316 #endif /* CONFIG_MAC80211_HT_DEBUG */
319 kfree(tid_agg_rx
->reorder_buf
);
320 kfree(tid_agg_rx
->reorder_time
);
326 tid_agg_rx
->dialog_token
= dialog_token
;
327 tid_agg_rx
->ssn
= start_seq_num
;
328 tid_agg_rx
->head_seq_num
= start_seq_num
;
329 tid_agg_rx
->buf_size
= buf_size
;
330 tid_agg_rx
->timeout
= timeout
;
331 tid_agg_rx
->stored_mpdu_num
= 0;
332 status
= WLAN_STATUS_SUCCESS
;
334 /* activate it for RX */
335 rcu_assign_pointer(sta
->ampdu_mlme
.tid_rx
[tid
], tid_agg_rx
);
338 mod_timer(&tid_agg_rx
->session_timer
, TU_TO_EXP_TIME(timeout
));
341 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
344 ieee80211_send_addba_resp(sta
->sdata
, sta
->sta
.addr
, tid
,
345 dialog_token
, status
, 1, buf_size
, timeout
);