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
)
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
= sta
->ampdu_mlme
.tid_rx
[tid
];
71 rcu_assign_pointer(sta
->ampdu_mlme
.tid_rx
[tid
], NULL
);
73 #ifdef CONFIG_MAC80211_HT_DEBUG
74 printk(KERN_DEBUG
"Rx BA session stop requested for %pM tid %u\n",
76 #endif /* CONFIG_MAC80211_HT_DEBUG */
78 if (drv_ampdu_action(local
, sta
->sdata
, IEEE80211_AMPDU_RX_STOP
,
79 &sta
->sta
, tid
, NULL
))
80 printk(KERN_DEBUG
"HW problem - can not stop rx "
81 "aggregation for tid %d\n", tid
);
83 /* check if this is a self generated aggregation halt */
84 if (initiator
== WLAN_BACK_RECIPIENT
)
85 ieee80211_send_delba(sta
->sdata
, sta
->sta
.addr
,
88 del_timer_sync(&tid_rx
->session_timer
);
90 call_rcu(&tid_rx
->rcu_head
, ieee80211_free_tid_rx
);
93 void __ieee80211_stop_rx_ba_session(struct sta_info
*sta
, u16 tid
,
94 u16 initiator
, u16 reason
)
96 mutex_lock(&sta
->ampdu_mlme
.mtx
);
97 ___ieee80211_stop_rx_ba_session(sta
, tid
, initiator
, reason
);
98 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
102 * After accepting the AddBA Request we activated a timer,
103 * resetting it after each frame that arrives from the originator.
105 static void sta_rx_agg_session_timer_expired(unsigned long data
)
107 /* not an elegant detour, but there is no choice as the timer passes
108 * only one argument, and various sta_info are needed here, so init
109 * flow in sta_info_create gives the TID as data, while the timer_to_id
110 * array gives the sta through container_of */
111 u8
*ptid
= (u8
*)data
;
112 u8
*timer_to_id
= ptid
- *ptid
;
113 struct sta_info
*sta
= container_of(timer_to_id
, struct sta_info
,
116 #ifdef CONFIG_MAC80211_HT_DEBUG
117 printk(KERN_DEBUG
"rx session timer expired on tid %d\n", (u16
)*ptid
);
119 set_bit(*ptid
, sta
->ampdu_mlme
.tid_rx_timer_expired
);
120 ieee80211_queue_work(&sta
->local
->hw
, &sta
->ampdu_mlme
.work
);
123 static void ieee80211_send_addba_resp(struct ieee80211_sub_if_data
*sdata
, u8
*da
, u16 tid
,
124 u8 dialog_token
, u16 status
, u16 policy
,
125 u16 buf_size
, u16 timeout
)
127 struct ieee80211_local
*local
= sdata
->local
;
129 struct ieee80211_mgmt
*mgmt
;
132 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
);
135 printk(KERN_DEBUG
"%s: failed to allocate buffer "
136 "for addba resp frame\n", sdata
->name
);
140 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
141 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
143 memcpy(mgmt
->da
, da
, ETH_ALEN
);
144 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
145 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
146 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
147 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
148 else if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
)
149 memcpy(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
151 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
152 IEEE80211_STYPE_ACTION
);
154 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.addba_resp
));
155 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
156 mgmt
->u
.action
.u
.addba_resp
.action_code
= WLAN_ACTION_ADDBA_RESP
;
157 mgmt
->u
.action
.u
.addba_resp
.dialog_token
= dialog_token
;
159 capab
= (u16
)(policy
<< 1); /* bit 1 aggregation policy */
160 capab
|= (u16
)(tid
<< 2); /* bit 5:2 TID number */
161 capab
|= (u16
)(buf_size
<< 6); /* bit 15:6 max size of aggregation */
163 mgmt
->u
.action
.u
.addba_resp
.capab
= cpu_to_le16(capab
);
164 mgmt
->u
.action
.u
.addba_resp
.timeout
= cpu_to_le16(timeout
);
165 mgmt
->u
.action
.u
.addba_resp
.status
= cpu_to_le16(status
);
167 ieee80211_tx_skb(sdata
, skb
);
170 void ieee80211_process_addba_request(struct ieee80211_local
*local
,
171 struct sta_info
*sta
,
172 struct ieee80211_mgmt
*mgmt
,
175 struct tid_ampdu_rx
*tid_agg_rx
;
176 u16 capab
, tid
, timeout
, ba_policy
, buf_size
, start_seq_num
, status
;
178 int ret
= -EOPNOTSUPP
;
180 /* extract session parameters from addba request frame */
181 dialog_token
= mgmt
->u
.action
.u
.addba_req
.dialog_token
;
182 timeout
= le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.timeout
);
184 le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.start_seq_num
) >> 4;
186 capab
= le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.capab
);
187 ba_policy
= (capab
& IEEE80211_ADDBA_PARAM_POLICY_MASK
) >> 1;
188 tid
= (capab
& IEEE80211_ADDBA_PARAM_TID_MASK
) >> 2;
189 buf_size
= (capab
& IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK
) >> 6;
191 status
= WLAN_STATUS_REQUEST_DECLINED
;
193 if (test_sta_flags(sta
, WLAN_STA_BLOCK_BA
)) {
194 #ifdef CONFIG_MAC80211_HT_DEBUG
195 printk(KERN_DEBUG
"Suspend in progress. "
196 "Denying ADDBA request\n");
201 /* sanity check for incoming parameters:
202 * check if configuration can support the BA policy
203 * and if buffer size does not exceeds max value */
204 if (((ba_policy
!= 1) &&
205 (!(sta
->sta
.ht_cap
.cap
& IEEE80211_HT_CAP_DELAY_BA
))) ||
206 (buf_size
> IEEE80211_MAX_AMPDU_BUF
)) {
207 status
= WLAN_STATUS_INVALID_QOS_PARAM
;
208 #ifdef CONFIG_MAC80211_HT_DEBUG
210 printk(KERN_DEBUG
"AddBA Req with bad params from "
211 "%pM on tid %u. policy %d, buffer size %d\n",
212 mgmt
->sa
, tid
, ba_policy
,
214 #endif /* CONFIG_MAC80211_HT_DEBUG */
217 /* determine default buffer size */
219 buf_size
= IEEE80211_MAX_AMPDU_BUF
;
222 /* examine state machine */
223 mutex_lock(&sta
->ampdu_mlme
.mtx
);
225 if (sta
->ampdu_mlme
.tid_rx
[tid
]) {
226 #ifdef CONFIG_MAC80211_HT_DEBUG
228 printk(KERN_DEBUG
"unexpected AddBA Req from "
231 #endif /* CONFIG_MAC80211_HT_DEBUG */
235 /* prepare A-MPDU MLME for Rx aggregation */
236 tid_agg_rx
= kmalloc(sizeof(struct tid_ampdu_rx
), GFP_ATOMIC
);
238 #ifdef CONFIG_MAC80211_HT_DEBUG
240 printk(KERN_ERR
"allocate rx mlme to tid %d failed\n",
247 tid_agg_rx
->session_timer
.function
= sta_rx_agg_session_timer_expired
;
248 tid_agg_rx
->session_timer
.data
= (unsigned long)&sta
->timer_to_tid
[tid
];
249 init_timer(&tid_agg_rx
->session_timer
);
251 /* prepare reordering buffer */
252 tid_agg_rx
->reorder_buf
=
253 kcalloc(buf_size
, sizeof(struct sk_buff
*), GFP_ATOMIC
);
254 tid_agg_rx
->reorder_time
=
255 kcalloc(buf_size
, sizeof(unsigned long), GFP_ATOMIC
);
256 if (!tid_agg_rx
->reorder_buf
|| !tid_agg_rx
->reorder_time
) {
257 #ifdef CONFIG_MAC80211_HT_DEBUG
259 printk(KERN_ERR
"can not allocate reordering buffer "
262 kfree(tid_agg_rx
->reorder_buf
);
263 kfree(tid_agg_rx
->reorder_time
);
268 ret
= drv_ampdu_action(local
, sta
->sdata
, IEEE80211_AMPDU_RX_START
,
269 &sta
->sta
, tid
, &start_seq_num
);
270 #ifdef CONFIG_MAC80211_HT_DEBUG
271 printk(KERN_DEBUG
"Rx A-MPDU request on tid %d result %d\n", tid
, ret
);
272 #endif /* CONFIG_MAC80211_HT_DEBUG */
275 kfree(tid_agg_rx
->reorder_buf
);
276 kfree(tid_agg_rx
->reorder_time
);
282 tid_agg_rx
->dialog_token
= dialog_token
;
283 tid_agg_rx
->ssn
= start_seq_num
;
284 tid_agg_rx
->head_seq_num
= start_seq_num
;
285 tid_agg_rx
->buf_size
= buf_size
;
286 tid_agg_rx
->timeout
= timeout
;
287 tid_agg_rx
->stored_mpdu_num
= 0;
288 status
= WLAN_STATUS_SUCCESS
;
290 /* activate it for RX */
291 rcu_assign_pointer(sta
->ampdu_mlme
.tid_rx
[tid
], tid_agg_rx
);
294 mod_timer(&tid_agg_rx
->session_timer
, TU_TO_EXP_TIME(timeout
));
297 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
300 ieee80211_send_addba_resp(sta
->sdata
, sta
->sta
.addr
, tid
,
301 dialog_token
, status
, 1, buf_size
, timeout
);