blob: 3a8f881b22f10c983ab354a4393157e090fd6d3a [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 Berga93e3642010-06-10 10:21:46 +02009 * Copyright 2007-2010, Intel Corporation
Sara Sharon50ea05e2015-12-30 16:06:04 +020010 * Copyright(c) 2015 Intel Deutschland GmbH
Johannes Bergb8695a82009-02-10 21:25:46 +010011 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 */
16
Johannes Berg73a72a82010-06-10 10:21:50 +020017/**
18 * DOC: RX A-MPDU aggregation
19 *
20 * Aggregation on the RX side requires only implementing the
21 * @ampdu_action callback that is invoked to start/stop any
22 * block-ack sessions for RX aggregation.
23 *
24 * When RX aggregation is started by the peer, the driver is
25 * notified via @ampdu_action function, with the
26 * %IEEE80211_AMPDU_RX_START action, and may reject the request
27 * in which case a negative response is sent to the peer, if it
28 * accepts it a positive response is sent.
29 *
30 * While the session is active, the device/driver are required
31 * to de-aggregate frames and pass them up one by one to mac80211,
32 * which will handle the reorder buffer.
33 *
34 * When the aggregation session is stopped again by the peer or
35 * ourselves, the driver's @ampdu_action function will be called
36 * with the action %IEEE80211_AMPDU_RX_STOP. In this case, the
37 * call must not fail.
38 */
39
Johannes Bergb8695a82009-02-10 21:25:46 +010040#include <linux/ieee80211.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040042#include <linux/export.h>
Johannes Bergb8695a82009-02-10 21:25:46 +010043#include <net/mac80211.h>
44#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020045#include "driver-ops.h"
Johannes Bergb8695a82009-02-10 21:25:46 +010046
Johannes Berga87f7362010-06-10 10:21:38 +020047static void ieee80211_free_tid_rx(struct rcu_head *h)
48{
49 struct tid_ampdu_rx *tid_rx =
50 container_of(h, struct tid_ampdu_rx, rcu_head);
51 int i;
52
53 for (i = 0; i < tid_rx->buf_size; i++)
Michal Kazior83eb9352014-07-16 12:09:31 +020054 __skb_queue_purge(&tid_rx->reorder_buf[i]);
Johannes Berga87f7362010-06-10 10:21:38 +020055 kfree(tid_rx->reorder_buf);
56 kfree(tid_rx->reorder_time);
57 kfree(tid_rx);
58}
59
Johannes Berg7c3b1dd2010-06-10 10:21:44 +020060void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
Johannes Berg53f73c02010-10-05 19:37:40 +020061 u16 initiator, u16 reason, bool tx)
Johannes Bergb8695a82009-02-10 21:25:46 +010062{
Johannes Bergd75636e2009-02-10 21:25:53 +010063 struct ieee80211_local *local = sta->local;
Johannes Berg098a6072010-04-06 11:18:47 +020064 struct tid_ampdu_rx *tid_rx;
Sara Sharon50ea05e2015-12-30 16:06:04 +020065 struct ieee80211_ampdu_params params = {
66 .sta = &sta->sta,
67 .action = IEEE80211_AMPDU_RX_STOP,
68 .tid = tid,
69 .amsdu = false,
70 .timeout = 0,
71 .ssn = 0,
72 };
Johannes Bergb8695a82009-02-10 21:25:46 +010073
Johannes Berga93e3642010-06-10 10:21:46 +020074 lockdep_assert_held(&sta->ampdu_mlme.mtx);
Johannes Berg098a6072010-04-06 11:18:47 +020075
Johannes Berg40b275b2011-05-13 14:15:49 +020076 tid_rx = rcu_dereference_protected(sta->ampdu_mlme.tid_rx[tid],
77 lockdep_is_held(&sta->ampdu_mlme.mtx));
Johannes Berga87f7362010-06-10 10:21:38 +020078
Sara Sharon412a6d82015-12-08 19:09:05 +020079 if (!test_bit(tid, sta->ampdu_mlme.agg_session_valid))
Johannes Bergb8695a82009-02-10 21:25:46 +010080 return;
Johannes Bergd75636e2009-02-10 21:25:53 +010081
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +000082 RCU_INIT_POINTER(sta->ampdu_mlme.tid_rx[tid], NULL);
Sara Sharon412a6d82015-12-08 19:09:05 +020083 __clear_bit(tid, sta->ampdu_mlme.agg_session_valid);
Johannes Bergb8695a82009-02-10 21:25:46 +010084
Johannes Bergbdcbd8e2012-06-22 11:29:50 +020085 ht_dbg(sta->sdata,
86 "Rx BA session stop requested for %pM tid %u %s reason: %d\n",
87 sta->sta.addr, tid,
88 initiator == WLAN_BACK_RECIPIENT ? "recipient" : "inititator",
89 (int)reason);
Johannes Bergb8695a82009-02-10 21:25:46 +010090
Sara Sharon50ea05e2015-12-30 16:06:04 +020091 if (drv_ampdu_action(local, sta->sdata, &params))
Johannes Bergbdcbd8e2012-06-22 11:29:50 +020092 sdata_info(sta->sdata,
Johannes Berg0a214d32013-01-16 10:39:44 +010093 "HW problem - can not stop rx aggregation for %pM tid %d\n",
94 sta->sta.addr, tid);
Johannes Bergb8695a82009-02-10 21:25:46 +010095
Johannes Bergb8695a82009-02-10 21:25:46 +010096 /* check if this is a self generated aggregation halt */
Johannes Berg53f73c02010-10-05 19:37:40 +020097 if (initiator == WLAN_BACK_RECIPIENT && tx)
Johannes Bergd75636e2009-02-10 21:25:53 +010098 ieee80211_send_delba(sta->sdata, sta->sta.addr,
Nikolay Martynova7f39f62011-11-22 21:50:29 -050099 tid, WLAN_BACK_RECIPIENT, reason);
Johannes Bergb8695a82009-02-10 21:25:46 +0100100
Sara Sharon412a6d82015-12-08 19:09:05 +0200101 /*
102 * return here in case tid_rx is not assigned - which will happen if
103 * IEEE80211_HW_SUPPORTS_REORDERING_BUFFER is set.
104 */
105 if (!tid_rx)
106 return;
107
Johannes Berg7c3b1dd2010-06-10 10:21:44 +0200108 del_timer_sync(&tid_rx->session_timer);
Johannes Berga87f7362010-06-10 10:21:38 +0200109
Johannes Berg788211d2015-04-01 14:20:42 +0200110 /* make sure ieee80211_sta_reorder_release() doesn't re-arm the timer */
111 spin_lock_bh(&tid_rx->reorder_lock);
112 tid_rx->removed = true;
113 spin_unlock_bh(&tid_rx->reorder_lock);
114 del_timer_sync(&tid_rx->reorder_timer);
115
Johannes Berga87f7362010-06-10 10:21:38 +0200116 call_rcu(&tid_rx->rcu_head, ieee80211_free_tid_rx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100117}
118
Johannes Berg2aab4c22010-04-19 11:00:24 +0200119void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
Johannes Berg53f73c02010-10-05 19:37:40 +0200120 u16 initiator, u16 reason, bool tx)
Johannes Berg2aab4c22010-04-19 11:00:24 +0200121{
Johannes Berga93e3642010-06-10 10:21:46 +0200122 mutex_lock(&sta->ampdu_mlme.mtx);
Johannes Berg53f73c02010-10-05 19:37:40 +0200123 ___ieee80211_stop_rx_ba_session(sta, tid, initiator, reason, tx);
Johannes Berga93e3642010-06-10 10:21:46 +0200124 mutex_unlock(&sta->ampdu_mlme.mtx);
Johannes Berg2aab4c22010-04-19 11:00:24 +0200125}
126
Shahar Levif41ccd72011-05-22 16:10:21 +0300127void ieee80211_stop_rx_ba_session(struct ieee80211_vif *vif, u16 ba_rx_bitmap,
128 const u8 *addr)
129{
130 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
Eliad Peller0a557ed2011-07-19 13:14:42 +0300131 struct sta_info *sta;
Shahar Levif41ccd72011-05-22 16:10:21 +0300132 int i;
133
Eliad Peller0a557ed2011-07-19 13:14:42 +0300134 rcu_read_lock();
Felix Fietkaubc192f82011-11-23 21:09:49 +0700135 sta = sta_info_get_bss(sdata, addr);
Eliad Peller0a557ed2011-07-19 13:14:42 +0300136 if (!sta) {
137 rcu_read_unlock();
138 return;
139 }
140
Johannes Berg5a306f52012-11-14 23:22:21 +0100141 for (i = 0; i < IEEE80211_NUM_TIDS; i++)
Shahar Levif41ccd72011-05-22 16:10:21 +0300142 if (ba_rx_bitmap & BIT(i))
143 set_bit(i, sta->ampdu_mlme.tid_rx_stop_requested);
144
145 ieee80211_queue_work(&sta->local->hw, &sta->ampdu_mlme.work);
Eliad Peller0a557ed2011-07-19 13:14:42 +0300146 rcu_read_unlock();
Shahar Levif41ccd72011-05-22 16:10:21 +0300147}
148EXPORT_SYMBOL(ieee80211_stop_rx_ba_session);
149
Johannes Bergb8695a82009-02-10 21:25:46 +0100150/*
151 * After accepting the AddBA Request we activated a timer,
152 * resetting it after each frame that arrives from the originator.
Johannes Bergb8695a82009-02-10 21:25:46 +0100153 */
154static void sta_rx_agg_session_timer_expired(unsigned long data)
155{
156 /* not an elegant detour, but there is no choice as the timer passes
157 * only one argument, and various sta_info are needed here, so init
158 * flow in sta_info_create gives the TID as data, while the timer_to_id
159 * array gives the sta through container_of */
160 u8 *ptid = (u8 *)data;
161 u8 *timer_to_id = ptid - *ptid;
162 struct sta_info *sta = container_of(timer_to_id, struct sta_info,
163 timer_to_tid[0]);
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100164 struct tid_ampdu_rx *tid_rx;
165 unsigned long timeout;
166
Felix Fietkaud8c7aae2012-05-30 15:32:24 +0200167 rcu_read_lock();
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100168 tid_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[*ptid]);
Felix Fietkaud8c7aae2012-05-30 15:32:24 +0200169 if (!tid_rx) {
170 rcu_read_unlock();
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100171 return;
Felix Fietkaud8c7aae2012-05-30 15:32:24 +0200172 }
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100173
174 timeout = tid_rx->last_rx + TU_TO_JIFFIES(tid_rx->timeout);
175 if (time_is_after_jiffies(timeout)) {
176 mod_timer(&tid_rx->session_timer, timeout);
Felix Fietkaud8c7aae2012-05-30 15:32:24 +0200177 rcu_read_unlock();
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100178 return;
179 }
Felix Fietkaud8c7aae2012-05-30 15:32:24 +0200180 rcu_read_unlock();
Johannes Bergb8695a82009-02-10 21:25:46 +0100181
Johannes Berg0a214d32013-01-16 10:39:44 +0100182 ht_dbg(sta->sdata, "RX session timer expired on %pM tid %d\n",
183 sta->sta.addr, (u16)*ptid);
Joe Perchesd63e9ae2012-05-15 14:20:31 -0700184
Johannes Berg7c3b1dd2010-06-10 10:21:44 +0200185 set_bit(*ptid, sta->ampdu_mlme.tid_rx_timer_expired);
186 ieee80211_queue_work(&sta->local->hw, &sta->ampdu_mlme.work);
Johannes Bergb8695a82009-02-10 21:25:46 +0100187}
188
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200189static void sta_rx_agg_reorder_timer_expired(unsigned long data)
190{
191 u8 *ptid = (u8 *)data;
192 u8 *timer_to_id = ptid - *ptid;
193 struct sta_info *sta = container_of(timer_to_id, struct sta_info,
194 timer_to_tid[0]);
195
196 rcu_read_lock();
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200197 ieee80211_release_reorder_timeout(sta, *ptid);
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200198 rcu_read_unlock();
199}
200
Johannes Bergb8695a82009-02-10 21:25:46 +0100201static void ieee80211_send_addba_resp(struct ieee80211_sub_if_data *sdata, u8 *da, u16 tid,
202 u8 dialog_token, u16 status, u16 policy,
203 u16 buf_size, u16 timeout)
204{
Johannes Bergb8695a82009-02-10 21:25:46 +0100205 struct ieee80211_local *local = sdata->local;
206 struct sk_buff *skb;
207 struct ieee80211_mgmt *mgmt;
Emmanuel Grumbach99e7ca42015-08-15 22:39:51 +0300208 bool amsdu = ieee80211_hw_check(&local->hw, SUPPORTS_AMSDU_IN_AMPDU);
Johannes Bergb8695a82009-02-10 21:25:46 +0100209 u16 capab;
210
211 skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
Joe Perchesd15b8452011-08-29 14:17:31 -0700212 if (!skb)
Johannes Bergb8695a82009-02-10 21:25:46 +0100213 return;
Johannes Bergb8695a82009-02-10 21:25:46 +0100214
215 skb_reserve(skb, local->hw.extra_tx_headroom);
216 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
217 memset(mgmt, 0, 24);
218 memcpy(mgmt->da, da, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100219 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg8abd3f92009-02-10 21:25:47 +0100220 if (sdata->vif.type == NL80211_IFTYPE_AP ||
Thomas Pedersenae2772b2011-10-26 14:47:29 -0700221 sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
222 sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
Johannes Berg47846c92009-11-25 17:46:19 +0100223 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +0100224 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
225 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
Alexander Simon13c40c52011-11-30 16:56:34 +0100226 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
227 memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +0100228
Johannes Bergb8695a82009-02-10 21:25:46 +0100229 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
230 IEEE80211_STYPE_ACTION);
231
232 skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_resp));
233 mgmt->u.action.category = WLAN_CATEGORY_BACK;
234 mgmt->u.action.u.addba_resp.action_code = WLAN_ACTION_ADDBA_RESP;
235 mgmt->u.action.u.addba_resp.dialog_token = dialog_token;
236
Emmanuel Grumbach99e7ca42015-08-15 22:39:51 +0300237 capab = (u16)(amsdu << 0); /* bit 0 A-MSDU support */
238 capab |= (u16)(policy << 1); /* bit 1 aggregation policy */
Johannes Bergb8695a82009-02-10 21:25:46 +0100239 capab |= (u16)(tid << 2); /* bit 5:2 TID number */
240 capab |= (u16)(buf_size << 6); /* bit 15:6 max size of aggregation */
241
242 mgmt->u.action.u.addba_resp.capab = cpu_to_le16(capab);
243 mgmt->u.action.u.addba_resp.timeout = cpu_to_le16(timeout);
244 mgmt->u.action.u.addba_resp.status = cpu_to_le16(status);
245
Johannes Berg62ae67b2009-11-18 18:42:05 +0100246 ieee80211_tx_skb(sdata, skb);
Johannes Bergb8695a82009-02-10 21:25:46 +0100247}
248
Michal Kazior08cf42e2014-07-16 12:12:15 +0200249void __ieee80211_start_rx_ba_session(struct sta_info *sta,
250 u8 dialog_token, u16 timeout,
251 u16 start_seq_num, u16 ba_policy, u16 tid,
Michal Kazior4549cf22014-09-02 14:05:10 +0200252 u16 buf_size, bool tx, bool auto_seq)
Johannes Bergb8695a82009-02-10 21:25:46 +0100253{
Michal Kazior08cf42e2014-07-16 12:12:15 +0200254 struct ieee80211_local *local = sta->sdata->local;
Johannes Bergb8695a82009-02-10 21:25:46 +0100255 struct tid_ampdu_rx *tid_agg_rx;
Sara Sharon50ea05e2015-12-30 16:06:04 +0200256 struct ieee80211_ampdu_params params = {
257 .sta = &sta->sta,
258 .action = IEEE80211_AMPDU_RX_START,
259 .tid = tid,
260 .amsdu = false,
261 .timeout = timeout,
262 .ssn = start_seq_num,
263 };
264
Michal Kazior83eb9352014-07-16 12:09:31 +0200265 int i, ret = -EOPNOTSUPP;
Michal Kazior08cf42e2014-07-16 12:12:15 +0200266 u16 status = WLAN_STATUS_REQUEST_DECLINED;
Johannes Bergb8695a82009-02-10 21:25:46 +0100267
Johannes Berg8f9c77f2015-03-09 11:13:04 +0100268 if (!sta->sta.ht_cap.ht_supported) {
269 ht_dbg(sta->sdata,
270 "STA %pM erroneously requests BA session on tid %d w/o QoS\n",
271 sta->sta.addr, tid);
272 /* send a response anyway, it's an error case if we get here */
273 goto end_no_lock;
274 }
275
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200276 if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
Johannes Berg0a214d32013-01-16 10:39:44 +0100277 ht_dbg(sta->sdata,
278 "Suspend in progress - Denying ADDBA request (%pM tid %d)\n",
279 sta->sta.addr, tid);
Sujith722f0692009-03-17 08:50:06 +0530280 goto end_no_lock;
281 }
282
Johannes Bergb8695a82009-02-10 21:25:46 +0100283 /* sanity check for incoming parameters:
284 * check if configuration can support the BA policy
285 * and if buffer size does not exceeds max value */
286 /* XXX: check own ht delayed BA capability?? */
Joe Perchesf64f9e72009-11-29 16:55:45 -0800287 if (((ba_policy != 1) &&
288 (!(sta->sta.ht_cap.cap & IEEE80211_HT_CAP_DELAY_BA))) ||
289 (buf_size > IEEE80211_MAX_AMPDU_BUF)) {
Johannes Bergb8695a82009-02-10 21:25:46 +0100290 status = WLAN_STATUS_INVALID_QOS_PARAM;
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200291 ht_dbg_ratelimited(sta->sdata,
292 "AddBA Req with bad params from %pM on tid %u. policy %d, buffer size %d\n",
Michal Kazior08cf42e2014-07-16 12:12:15 +0200293 sta->sta.addr, tid, ba_policy, buf_size);
Johannes Bergb8695a82009-02-10 21:25:46 +0100294 goto end_no_lock;
295 }
296 /* determine default buffer size */
Luciano Coelho82694f72011-01-12 15:18:11 +0200297 if (buf_size == 0)
298 buf_size = IEEE80211_MAX_AMPDU_BUF;
Johannes Bergb8695a82009-02-10 21:25:46 +0100299
Luciano Coelhodf6ba5d2011-01-12 15:26:30 +0200300 /* make sure the size doesn't exceed the maximum supported by the hw */
301 if (buf_size > local->hw.max_rx_aggregation_subframes)
302 buf_size = local->hw.max_rx_aggregation_subframes;
Sara Sharon50ea05e2015-12-30 16:06:04 +0200303 params.buf_size = buf_size;
Johannes Bergb8695a82009-02-10 21:25:46 +0100304
305 /* examine state machine */
Johannes Berga93e3642010-06-10 10:21:46 +0200306 mutex_lock(&sta->ampdu_mlme.mtx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100307
Sara Sharon412a6d82015-12-08 19:09:05 +0200308 if (test_bit(tid, sta->ampdu_mlme.agg_session_valid)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200309 ht_dbg_ratelimited(sta->sdata,
310 "unexpected AddBA Req from %pM on tid %u\n",
Michal Kazior08cf42e2014-07-16 12:12:15 +0200311 sta->sta.addr, tid);
Arik Nemtsov15b4d842011-06-23 01:15:27 +0300312
313 /* delete existing Rx BA session on the same tid */
314 ___ieee80211_stop_rx_ba_session(sta, tid, WLAN_BACK_RECIPIENT,
315 WLAN_STATUS_UNSPECIFIED_QOS,
316 false);
Johannes Bergb8695a82009-02-10 21:25:46 +0100317 }
318
Sara Sharon412a6d82015-12-08 19:09:05 +0200319 if (ieee80211_hw_check(&local->hw, SUPPORTS_REORDERING_BUFFER)) {
320 ret = drv_ampdu_action(local, sta->sdata, &params);
321 ht_dbg(sta->sdata,
322 "Rx A-MPDU request on %pM tid %d result %d\n",
323 sta->sta.addr, tid, ret);
324 if (!ret)
325 status = WLAN_STATUS_SUCCESS;
326 goto end;
327 }
328
Johannes Bergb8695a82009-02-10 21:25:46 +0100329 /* prepare A-MPDU MLME for Rx aggregation */
Chris Bainbridgef39ea262016-01-27 15:46:18 +0000330 tid_agg_rx = kzalloc(sizeof(*tid_agg_rx), GFP_KERNEL);
Joe Perchesd15b8452011-08-29 14:17:31 -0700331 if (!tid_agg_rx)
Johannes Bergb8695a82009-02-10 21:25:46 +0100332 goto end;
Johannes Bergb8695a82009-02-10 21:25:46 +0100333
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200334 spin_lock_init(&tid_agg_rx->reorder_lock);
335
Johannes Berga87f7362010-06-10 10:21:38 +0200336 /* rx timer */
337 tid_agg_rx->session_timer.function = sta_rx_agg_session_timer_expired;
338 tid_agg_rx->session_timer.data = (unsigned long)&sta->timer_to_tid[tid];
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100339 init_timer_deferrable(&tid_agg_rx->session_timer);
Johannes Bergb8695a82009-02-10 21:25:46 +0100340
Christian Lamparter2bff8eb2010-08-05 01:36:41 +0200341 /* rx reorder timer */
342 tid_agg_rx->reorder_timer.function = sta_rx_agg_reorder_timer_expired;
343 tid_agg_rx->reorder_timer.data = (unsigned long)&sta->timer_to_tid[tid];
344 init_timer(&tid_agg_rx->reorder_timer);
345
Johannes Bergb8695a82009-02-10 21:25:46 +0100346 /* prepare reordering buffer */
347 tid_agg_rx->reorder_buf =
Michal Kazior83eb9352014-07-16 12:09:31 +0200348 kcalloc(buf_size, sizeof(struct sk_buff_head), GFP_KERNEL);
Jouni Malinen4d050f12009-05-05 20:35:14 +0300349 tid_agg_rx->reorder_time =
Johannes Bergdd318572010-11-29 11:09:16 +0100350 kcalloc(buf_size, sizeof(unsigned long), GFP_KERNEL);
Jouni Malinen4d050f12009-05-05 20:35:14 +0300351 if (!tid_agg_rx->reorder_buf || !tid_agg_rx->reorder_time) {
Jouni Malinen4d050f12009-05-05 20:35:14 +0300352 kfree(tid_agg_rx->reorder_buf);
353 kfree(tid_agg_rx->reorder_time);
Johannes Berga87f7362010-06-10 10:21:38 +0200354 kfree(tid_agg_rx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100355 goto end;
356 }
357
Michal Kazior83eb9352014-07-16 12:09:31 +0200358 for (i = 0; i < buf_size; i++)
359 __skb_queue_head_init(&tid_agg_rx->reorder_buf[i]);
360
Sara Sharon50ea05e2015-12-30 16:06:04 +0200361 ret = drv_ampdu_action(local, sta->sdata, &params);
Johannes Berg0a214d32013-01-16 10:39:44 +0100362 ht_dbg(sta->sdata, "Rx A-MPDU request on %pM tid %d result %d\n",
363 sta->sta.addr, tid, ret);
Johannes Bergb8695a82009-02-10 21:25:46 +0100364 if (ret) {
365 kfree(tid_agg_rx->reorder_buf);
Johannes Berga87f7362010-06-10 10:21:38 +0200366 kfree(tid_agg_rx->reorder_time);
Johannes Bergb8695a82009-02-10 21:25:46 +0100367 kfree(tid_agg_rx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100368 goto end;
369 }
370
Johannes Berga87f7362010-06-10 10:21:38 +0200371 /* update data */
Johannes Bergb8695a82009-02-10 21:25:46 +0100372 tid_agg_rx->dialog_token = dialog_token;
373 tid_agg_rx->ssn = start_seq_num;
374 tid_agg_rx->head_seq_num = start_seq_num;
375 tid_agg_rx->buf_size = buf_size;
376 tid_agg_rx->timeout = timeout;
377 tid_agg_rx->stored_mpdu_num = 0;
Michal Kazior4549cf22014-09-02 14:05:10 +0200378 tid_agg_rx->auto_seq = auto_seq;
Sara Sharon06470f72016-01-28 16:19:25 +0200379 tid_agg_rx->reorder_buf_filtered = 0;
Johannes Bergb8695a82009-02-10 21:25:46 +0100380 status = WLAN_STATUS_SUCCESS;
Johannes Berga87f7362010-06-10 10:21:38 +0200381
382 /* activate it for RX */
Eric Dumazetcf778b02012-01-12 04:41:32 +0000383 rcu_assign_pointer(sta->ampdu_mlme.tid_rx[tid], tid_agg_rx);
Johannes Bergf955ebb2010-06-10 10:21:45 +0200384
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100385 if (timeout) {
Johannes Bergf955ebb2010-06-10 10:21:45 +0200386 mod_timer(&tid_agg_rx->session_timer, TU_TO_EXP_TIME(timeout));
Felix Fietkau12d3952f2012-03-18 22:58:06 +0100387 tid_agg_rx->last_rx = jiffies;
388 }
Johannes Bergf955ebb2010-06-10 10:21:45 +0200389
Johannes Bergb8695a82009-02-10 21:25:46 +0100390end:
Sara Sharon412a6d82015-12-08 19:09:05 +0200391 if (status == WLAN_STATUS_SUCCESS)
392 __set_bit(tid, sta->ampdu_mlme.agg_session_valid);
Johannes Berga93e3642010-06-10 10:21:46 +0200393 mutex_unlock(&sta->ampdu_mlme.mtx);
Johannes Bergb8695a82009-02-10 21:25:46 +0100394
395end_no_lock:
Michal Kazior08cf42e2014-07-16 12:12:15 +0200396 if (tx)
397 ieee80211_send_addba_resp(sta->sdata, sta->sta.addr, tid,
398 dialog_token, status, 1, buf_size,
399 timeout);
Johannes Bergb8695a82009-02-10 21:25:46 +0100400}
Michal Kazior08cf42e2014-07-16 12:12:15 +0200401
402void ieee80211_process_addba_request(struct ieee80211_local *local,
403 struct sta_info *sta,
404 struct ieee80211_mgmt *mgmt,
405 size_t len)
406{
407 u16 capab, tid, timeout, ba_policy, buf_size, start_seq_num;
408 u8 dialog_token;
409
410 /* extract session parameters from addba request frame */
411 dialog_token = mgmt->u.action.u.addba_req.dialog_token;
412 timeout = le16_to_cpu(mgmt->u.action.u.addba_req.timeout);
413 start_seq_num =
414 le16_to_cpu(mgmt->u.action.u.addba_req.start_seq_num) >> 4;
415
416 capab = le16_to_cpu(mgmt->u.action.u.addba_req.capab);
417 ba_policy = (capab & IEEE80211_ADDBA_PARAM_POLICY_MASK) >> 1;
418 tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
419 buf_size = (capab & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK) >> 6;
420
421 __ieee80211_start_rx_ba_session(sta, dialog_token, timeout,
422 start_seq_num, ba_policy, tid,
Michal Kazior4549cf22014-09-02 14:05:10 +0200423 buf_size, true, false);
Michal Kazior08cf42e2014-07-16 12:12:15 +0200424}
425
426void ieee80211_start_rx_ba_session_offl(struct ieee80211_vif *vif,
427 const u8 *addr, u16 tid)
428{
429 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
430 struct ieee80211_local *local = sdata->local;
431 struct ieee80211_rx_agg *rx_agg;
432 struct sk_buff *skb = dev_alloc_skb(0);
433
434 if (unlikely(!skb))
435 return;
436
437 rx_agg = (struct ieee80211_rx_agg *) &skb->cb;
438 memcpy(&rx_agg->addr, addr, ETH_ALEN);
439 rx_agg->tid = tid;
440
441 skb->pkt_type = IEEE80211_SDATA_QUEUE_RX_AGG_START;
442 skb_queue_tail(&sdata->skb_queue, skb);
443 ieee80211_queue_work(&local->hw, &sdata->work);
444}
445EXPORT_SYMBOL(ieee80211_start_rx_ba_session_offl);
446
447void ieee80211_stop_rx_ba_session_offl(struct ieee80211_vif *vif,
448 const u8 *addr, u16 tid)
449{
450 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
451 struct ieee80211_local *local = sdata->local;
452 struct ieee80211_rx_agg *rx_agg;
453 struct sk_buff *skb = dev_alloc_skb(0);
454
455 if (unlikely(!skb))
456 return;
457
458 rx_agg = (struct ieee80211_rx_agg *) &skb->cb;
459 memcpy(&rx_agg->addr, addr, ETH_ALEN);
460 rx_agg->tid = tid;
461
462 skb->pkt_type = IEEE80211_SDATA_QUEUE_RX_AGG_STOP;
463 skb_queue_tail(&sdata->skb_queue, skb);
464 ieee80211_queue_work(&local->hw, &sdata->work);
465}
466EXPORT_SYMBOL(ieee80211_stop_rx_ba_session_offl);