]>
Commit | Line | Data |
---|---|---|
44d414db JB |
1 | /* |
2 | * HT handling | |
3 | * | |
4 | * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi> | |
bacac545 JB |
5 | * Copyright 2002-2005, Instant802 Networks, Inc. |
6 | * Copyright 2005-2006, Devicescape Software, Inc. | |
44d414db JB |
7 | * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> |
8 | * Copyright 2007, Michael Wu <flamingice@sourmilk.net> | |
9 | * Copyright 2007-2008, Intel Corporation | |
10 | * | |
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. | |
14 | */ | |
15 | ||
16 | #include <linux/ieee80211.h> | |
17 | #include <net/wireless.h> | |
18 | #include <net/mac80211.h> | |
19 | #include "ieee80211_i.h" | |
20 | #include "sta_info.h" | |
bacac545 | 21 | #include "wme.h" |
44d414db JB |
22 | |
23 | int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie, | |
24 | struct ieee80211_ht_info *ht_info) | |
25 | { | |
26 | ||
27 | if (ht_info == NULL) | |
28 | return -EINVAL; | |
29 | ||
30 | memset(ht_info, 0, sizeof(*ht_info)); | |
31 | ||
32 | if (ht_cap_ie) { | |
33 | u8 ampdu_info = ht_cap_ie->ampdu_params_info; | |
34 | ||
35 | ht_info->ht_supported = 1; | |
36 | ht_info->cap = le16_to_cpu(ht_cap_ie->cap_info); | |
37 | ht_info->ampdu_factor = | |
38 | ampdu_info & IEEE80211_HT_CAP_AMPDU_FACTOR; | |
39 | ht_info->ampdu_density = | |
40 | (ampdu_info & IEEE80211_HT_CAP_AMPDU_DENSITY) >> 2; | |
41 | memcpy(ht_info->supp_mcs_set, ht_cap_ie->supp_mcs_set, 16); | |
42 | } else | |
43 | ht_info->ht_supported = 0; | |
44 | ||
45 | return 0; | |
46 | } | |
47 | ||
48 | int ieee80211_ht_addt_info_ie_to_ht_bss_info( | |
49 | struct ieee80211_ht_addt_info *ht_add_info_ie, | |
50 | struct ieee80211_ht_bss_info *bss_info) | |
51 | { | |
52 | if (bss_info == NULL) | |
53 | return -EINVAL; | |
54 | ||
55 | memset(bss_info, 0, sizeof(*bss_info)); | |
56 | ||
57 | if (ht_add_info_ie) { | |
58 | u16 op_mode; | |
59 | op_mode = le16_to_cpu(ht_add_info_ie->operation_mode); | |
60 | ||
61 | bss_info->primary_channel = ht_add_info_ie->control_chan; | |
62 | bss_info->bss_cap = ht_add_info_ie->ht_param; | |
63 | bss_info->bss_op_mode = (u8)(op_mode & 0xff); | |
64 | } | |
65 | ||
66 | return 0; | |
67 | } | |
68 | ||
69 | void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata, const u8 *da, | |
70 | u16 tid, u8 dialog_token, u16 start_seq_num, | |
71 | u16 agg_size, u16 timeout) | |
72 | { | |
73 | struct ieee80211_local *local = sdata->local; | |
74 | struct ieee80211_if_sta *ifsta = &sdata->u.sta; | |
75 | struct sk_buff *skb; | |
76 | struct ieee80211_mgmt *mgmt; | |
77 | u16 capab; | |
78 | ||
79 | skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom); | |
80 | ||
81 | if (!skb) { | |
82 | printk(KERN_ERR "%s: failed to allocate buffer " | |
83 | "for addba request frame\n", sdata->dev->name); | |
84 | return; | |
85 | } | |
86 | skb_reserve(skb, local->hw.extra_tx_headroom); | |
87 | mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); | |
88 | memset(mgmt, 0, 24); | |
89 | memcpy(mgmt->da, da, ETH_ALEN); | |
90 | memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); | |
91 | if (sdata->vif.type == IEEE80211_IF_TYPE_AP) | |
92 | memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN); | |
93 | else | |
94 | memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); | |
95 | ||
96 | mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | | |
97 | IEEE80211_STYPE_ACTION); | |
98 | ||
99 | skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req)); | |
100 | ||
101 | mgmt->u.action.category = WLAN_CATEGORY_BACK; | |
102 | mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ; | |
103 | ||
104 | mgmt->u.action.u.addba_req.dialog_token = dialog_token; | |
105 | capab = (u16)(1 << 1); /* bit 1 aggregation policy */ | |
106 | capab |= (u16)(tid << 2); /* bit 5:2 TID number */ | |
107 | capab |= (u16)(agg_size << 6); /* bit 15:6 max size of aggergation */ | |
108 | ||
109 | mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab); | |
110 | ||
111 | mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout); | |
112 | mgmt->u.action.u.addba_req.start_seq_num = | |
113 | cpu_to_le16(start_seq_num << 4); | |
114 | ||
115 | ieee80211_sta_tx(sdata, skb, 0); | |
116 | } | |
117 | ||
118 | void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, const u8 *da, u16 tid, | |
119 | u16 initiator, u16 reason_code) | |
120 | { | |
121 | struct ieee80211_local *local = sdata->local; | |
122 | struct ieee80211_if_sta *ifsta = &sdata->u.sta; | |
123 | struct sk_buff *skb; | |
124 | struct ieee80211_mgmt *mgmt; | |
125 | u16 params; | |
126 | ||
127 | skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom); | |
128 | ||
129 | if (!skb) { | |
130 | printk(KERN_ERR "%s: failed to allocate buffer " | |
131 | "for delba frame\n", sdata->dev->name); | |
132 | return; | |
133 | } | |
134 | ||
135 | skb_reserve(skb, local->hw.extra_tx_headroom); | |
136 | mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); | |
137 | memset(mgmt, 0, 24); | |
138 | memcpy(mgmt->da, da, ETH_ALEN); | |
139 | memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); | |
140 | if (sdata->vif.type == IEEE80211_IF_TYPE_AP) | |
141 | memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN); | |
142 | else | |
143 | memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); | |
144 | mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | | |
145 | IEEE80211_STYPE_ACTION); | |
146 | ||
147 | skb_put(skb, 1 + sizeof(mgmt->u.action.u.delba)); | |
148 | ||
149 | mgmt->u.action.category = WLAN_CATEGORY_BACK; | |
150 | mgmt->u.action.u.delba.action_code = WLAN_ACTION_DELBA; | |
151 | params = (u16)(initiator << 11); /* bit 11 initiator */ | |
152 | params |= (u16)(tid << 12); /* bit 15:12 TID number */ | |
153 | ||
154 | mgmt->u.action.u.delba.params = cpu_to_le16(params); | |
155 | mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code); | |
156 | ||
157 | ieee80211_sta_tx(sdata, skb, 0); | |
158 | } | |
159 | ||
160 | void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn) | |
161 | { | |
162 | struct ieee80211_local *local = sdata->local; | |
163 | struct sk_buff *skb; | |
164 | struct ieee80211_bar *bar; | |
165 | u16 bar_control = 0; | |
166 | ||
167 | skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom); | |
168 | if (!skb) { | |
169 | printk(KERN_ERR "%s: failed to allocate buffer for " | |
170 | "bar frame\n", sdata->dev->name); | |
171 | return; | |
172 | } | |
173 | skb_reserve(skb, local->hw.extra_tx_headroom); | |
174 | bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar)); | |
175 | memset(bar, 0, sizeof(*bar)); | |
176 | bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | | |
177 | IEEE80211_STYPE_BACK_REQ); | |
178 | memcpy(bar->ra, ra, ETH_ALEN); | |
179 | memcpy(bar->ta, sdata->dev->dev_addr, ETH_ALEN); | |
180 | bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL; | |
181 | bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA; | |
182 | bar_control |= (u16)(tid << 12); | |
183 | bar->control = cpu_to_le16(bar_control); | |
184 | bar->start_seq_num = cpu_to_le16(ssn); | |
185 | ||
186 | ieee80211_sta_tx(sdata, skb, 0); | |
187 | } | |
188 | ||
189 | void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, | |
190 | u16 initiator, u16 reason) | |
191 | { | |
192 | struct ieee80211_local *local = sdata->local; | |
193 | struct ieee80211_hw *hw = &local->hw; | |
194 | struct sta_info *sta; | |
195 | int ret, i; | |
196 | DECLARE_MAC_BUF(mac); | |
197 | ||
198 | rcu_read_lock(); | |
199 | ||
200 | sta = sta_info_get(local, ra); | |
201 | if (!sta) { | |
202 | rcu_read_unlock(); | |
203 | return; | |
204 | } | |
205 | ||
206 | /* check if TID is in operational state */ | |
207 | spin_lock_bh(&sta->lock); | |
208 | if (sta->ampdu_mlme.tid_state_rx[tid] | |
209 | != HT_AGG_STATE_OPERATIONAL) { | |
210 | spin_unlock_bh(&sta->lock); | |
211 | rcu_read_unlock(); | |
212 | return; | |
213 | } | |
214 | sta->ampdu_mlme.tid_state_rx[tid] = | |
215 | HT_AGG_STATE_REQ_STOP_BA_MSK | | |
216 | (initiator << HT_AGG_STATE_INITIATOR_SHIFT); | |
217 | spin_unlock_bh(&sta->lock); | |
218 | ||
219 | /* stop HW Rx aggregation. ampdu_action existence | |
220 | * already verified in session init so we add the BUG_ON */ | |
221 | BUG_ON(!local->ops->ampdu_action); | |
222 | ||
223 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
224 | printk(KERN_DEBUG "Rx BA session stop requested for %s tid %u\n", | |
225 | print_mac(mac, ra), tid); | |
226 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
227 | ||
228 | ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_RX_STOP, | |
229 | ra, tid, NULL); | |
230 | if (ret) | |
231 | printk(KERN_DEBUG "HW problem - can not stop rx " | |
232 | "aggregation for tid %d\n", tid); | |
233 | ||
234 | /* shutdown timer has not expired */ | |
235 | if (initiator != WLAN_BACK_TIMER) | |
236 | del_timer_sync(&sta->ampdu_mlme.tid_rx[tid]->session_timer); | |
237 | ||
238 | /* check if this is a self generated aggregation halt */ | |
239 | if (initiator == WLAN_BACK_RECIPIENT || initiator == WLAN_BACK_TIMER) | |
240 | ieee80211_send_delba(sdata, ra, tid, 0, reason); | |
241 | ||
242 | /* free the reordering buffer */ | |
243 | for (i = 0; i < sta->ampdu_mlme.tid_rx[tid]->buf_size; i++) { | |
244 | if (sta->ampdu_mlme.tid_rx[tid]->reorder_buf[i]) { | |
245 | /* release the reordered frames */ | |
246 | dev_kfree_skb(sta->ampdu_mlme.tid_rx[tid]->reorder_buf[i]); | |
247 | sta->ampdu_mlme.tid_rx[tid]->stored_mpdu_num--; | |
248 | sta->ampdu_mlme.tid_rx[tid]->reorder_buf[i] = NULL; | |
249 | } | |
250 | } | |
251 | /* free resources */ | |
252 | kfree(sta->ampdu_mlme.tid_rx[tid]->reorder_buf); | |
253 | kfree(sta->ampdu_mlme.tid_rx[tid]); | |
254 | sta->ampdu_mlme.tid_rx[tid] = NULL; | |
255 | sta->ampdu_mlme.tid_state_rx[tid] = HT_AGG_STATE_IDLE; | |
256 | ||
257 | rcu_read_unlock(); | |
258 | } | |
259 | ||
260 | ||
261 | /* | |
262 | * After sending add Block Ack request we activated a timer until | |
263 | * add Block Ack response will arrive from the recipient. | |
264 | * If this timer expires sta_addba_resp_timer_expired will be executed. | |
265 | */ | |
266 | void sta_addba_resp_timer_expired(unsigned long data) | |
267 | { | |
268 | /* not an elegant detour, but there is no choice as the timer passes | |
269 | * only one argument, and both sta_info and TID are needed, so init | |
270 | * flow in sta_info_create gives the TID as data, while the timer_to_id | |
271 | * array gives the sta through container_of */ | |
272 | u16 tid = *(u8 *)data; | |
273 | struct sta_info *temp_sta = container_of((void *)data, | |
274 | struct sta_info, timer_to_tid[tid]); | |
275 | ||
276 | struct ieee80211_local *local = temp_sta->local; | |
277 | struct ieee80211_hw *hw = &local->hw; | |
278 | struct sta_info *sta; | |
279 | u8 *state; | |
280 | ||
281 | rcu_read_lock(); | |
282 | ||
283 | sta = sta_info_get(local, temp_sta->addr); | |
284 | if (!sta) { | |
285 | rcu_read_unlock(); | |
286 | return; | |
287 | } | |
288 | ||
289 | state = &sta->ampdu_mlme.tid_state_tx[tid]; | |
290 | /* check if the TID waits for addBA response */ | |
291 | spin_lock_bh(&sta->lock); | |
292 | if (!(*state & HT_ADDBA_REQUESTED_MSK)) { | |
293 | spin_unlock_bh(&sta->lock); | |
294 | *state = HT_AGG_STATE_IDLE; | |
295 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
296 | printk(KERN_DEBUG "timer expired on tid %d but we are not " | |
297 | "expecting addBA response there", tid); | |
298 | #endif | |
299 | goto timer_expired_exit; | |
300 | } | |
301 | ||
302 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
303 | printk(KERN_DEBUG "addBA response timer expired on tid %d\n", tid); | |
304 | #endif | |
305 | ||
306 | /* go through the state check in stop_BA_session */ | |
307 | *state = HT_AGG_STATE_OPERATIONAL; | |
308 | spin_unlock_bh(&sta->lock); | |
309 | ieee80211_stop_tx_ba_session(hw, temp_sta->addr, tid, | |
310 | WLAN_BACK_INITIATOR); | |
311 | ||
312 | timer_expired_exit: | |
313 | rcu_read_unlock(); | |
314 | } | |
315 | ||
316 | void ieee80211_sta_tear_down_BA_sessions(struct ieee80211_sub_if_data *sdata, u8 *addr) | |
317 | { | |
318 | struct ieee80211_local *local = sdata->local; | |
319 | int i; | |
320 | ||
321 | for (i = 0; i < STA_TID_NUM; i++) { | |
322 | ieee80211_stop_tx_ba_session(&local->hw, addr, i, | |
323 | WLAN_BACK_INITIATOR); | |
324 | ieee80211_sta_stop_rx_ba_session(sdata, addr, i, | |
325 | WLAN_BACK_RECIPIENT, | |
326 | WLAN_REASON_QSTA_LEAVE_QBSS); | |
327 | } | |
328 | } | |
329 | ||
bacac545 JB |
330 | int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid) |
331 | { | |
332 | struct ieee80211_local *local = hw_to_local(hw); | |
333 | struct sta_info *sta; | |
334 | struct ieee80211_sub_if_data *sdata; | |
335 | u16 start_seq_num; | |
336 | u8 *state; | |
337 | int ret; | |
338 | DECLARE_MAC_BUF(mac); | |
339 | ||
340 | if (tid >= STA_TID_NUM) | |
341 | return -EINVAL; | |
342 | ||
343 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
344 | printk(KERN_DEBUG "Open BA session requested for %s tid %u\n", | |
345 | print_mac(mac, ra), tid); | |
346 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
347 | ||
348 | rcu_read_lock(); | |
349 | ||
350 | sta = sta_info_get(local, ra); | |
351 | if (!sta) { | |
352 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
353 | printk(KERN_DEBUG "Could not find the station\n"); | |
354 | #endif | |
355 | ret = -ENOENT; | |
356 | goto exit; | |
357 | } | |
358 | ||
359 | spin_lock_bh(&sta->lock); | |
360 | ||
361 | /* we have tried too many times, receiver does not want A-MPDU */ | |
362 | if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) { | |
363 | ret = -EBUSY; | |
364 | goto err_unlock_sta; | |
365 | } | |
366 | ||
367 | state = &sta->ampdu_mlme.tid_state_tx[tid]; | |
368 | /* check if the TID is not in aggregation flow already */ | |
369 | if (*state != HT_AGG_STATE_IDLE) { | |
370 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
371 | printk(KERN_DEBUG "BA request denied - session is not " | |
372 | "idle on tid %u\n", tid); | |
373 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
374 | ret = -EAGAIN; | |
375 | goto err_unlock_sta; | |
376 | } | |
377 | ||
378 | /* prepare A-MPDU MLME for Tx aggregation */ | |
379 | sta->ampdu_mlme.tid_tx[tid] = | |
380 | kmalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC); | |
381 | if (!sta->ampdu_mlme.tid_tx[tid]) { | |
382 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
383 | if (net_ratelimit()) | |
384 | printk(KERN_ERR "allocate tx mlme to tid %d failed\n", | |
385 | tid); | |
386 | #endif | |
387 | ret = -ENOMEM; | |
388 | goto err_unlock_sta; | |
389 | } | |
390 | /* Tx timer */ | |
391 | sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.function = | |
392 | sta_addba_resp_timer_expired; | |
393 | sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.data = | |
394 | (unsigned long)&sta->timer_to_tid[tid]; | |
395 | init_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer); | |
396 | ||
397 | /* create a new queue for this aggregation */ | |
398 | ret = ieee80211_ht_agg_queue_add(local, sta, tid); | |
399 | ||
400 | /* case no queue is available to aggregation | |
401 | * don't switch to aggregation */ | |
402 | if (ret) { | |
403 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
404 | printk(KERN_DEBUG "BA request denied - queue unavailable for" | |
405 | " tid %d\n", tid); | |
406 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
407 | goto err_unlock_queue; | |
408 | } | |
409 | sdata = sta->sdata; | |
410 | ||
411 | /* Ok, the Addba frame hasn't been sent yet, but if the driver calls the | |
412 | * call back right away, it must see that the flow has begun */ | |
413 | *state |= HT_ADDBA_REQUESTED_MSK; | |
414 | ||
415 | /* This is slightly racy because the queue isn't stopped */ | |
416 | start_seq_num = sta->tid_seq[tid]; | |
417 | ||
418 | if (local->ops->ampdu_action) | |
419 | ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_START, | |
420 | ra, tid, &start_seq_num); | |
421 | ||
422 | if (ret) { | |
423 | /* No need to requeue the packets in the agg queue, since we | |
424 | * held the tx lock: no packet could be enqueued to the newly | |
425 | * allocated queue */ | |
426 | ieee80211_ht_agg_queue_remove(local, sta, tid, 0); | |
427 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
428 | printk(KERN_DEBUG "BA request denied - HW unavailable for" | |
429 | " tid %d\n", tid); | |
430 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
431 | *state = HT_AGG_STATE_IDLE; | |
432 | goto err_unlock_queue; | |
433 | } | |
434 | ||
435 | /* Will put all the packets in the new SW queue */ | |
436 | ieee80211_requeue(local, ieee802_1d_to_ac[tid]); | |
437 | spin_unlock_bh(&sta->lock); | |
438 | ||
439 | /* send an addBA request */ | |
440 | sta->ampdu_mlme.dialog_token_allocator++; | |
441 | sta->ampdu_mlme.tid_tx[tid]->dialog_token = | |
442 | sta->ampdu_mlme.dialog_token_allocator; | |
443 | sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num; | |
444 | ||
445 | ||
446 | ieee80211_send_addba_request(sta->sdata, ra, tid, | |
447 | sta->ampdu_mlme.tid_tx[tid]->dialog_token, | |
448 | sta->ampdu_mlme.tid_tx[tid]->ssn, | |
449 | 0x40, 5000); | |
450 | /* activate the timer for the recipient's addBA response */ | |
451 | sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires = | |
452 | jiffies + ADDBA_RESP_INTERVAL; | |
453 | add_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer); | |
454 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
455 | printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid); | |
456 | #endif | |
457 | goto exit; | |
458 | ||
459 | err_unlock_queue: | |
460 | kfree(sta->ampdu_mlme.tid_tx[tid]); | |
461 | sta->ampdu_mlme.tid_tx[tid] = NULL; | |
462 | ret = -EBUSY; | |
463 | err_unlock_sta: | |
464 | spin_unlock_bh(&sta->lock); | |
465 | exit: | |
466 | rcu_read_unlock(); | |
467 | return ret; | |
468 | } | |
469 | EXPORT_SYMBOL(ieee80211_start_tx_ba_session); | |
470 | ||
471 | int ieee80211_stop_tx_ba_session(struct ieee80211_hw *hw, | |
472 | u8 *ra, u16 tid, | |
473 | enum ieee80211_back_parties initiator) | |
474 | { | |
475 | struct ieee80211_local *local = hw_to_local(hw); | |
476 | struct sta_info *sta; | |
477 | u8 *state; | |
478 | int ret = 0; | |
479 | DECLARE_MAC_BUF(mac); | |
480 | ||
481 | if (tid >= STA_TID_NUM) | |
482 | return -EINVAL; | |
483 | ||
484 | rcu_read_lock(); | |
485 | sta = sta_info_get(local, ra); | |
486 | if (!sta) { | |
487 | rcu_read_unlock(); | |
488 | return -ENOENT; | |
489 | } | |
490 | ||
491 | /* check if the TID is in aggregation */ | |
492 | state = &sta->ampdu_mlme.tid_state_tx[tid]; | |
493 | spin_lock_bh(&sta->lock); | |
494 | ||
495 | if (*state != HT_AGG_STATE_OPERATIONAL) { | |
496 | ret = -ENOENT; | |
497 | goto stop_BA_exit; | |
498 | } | |
499 | ||
500 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
501 | printk(KERN_DEBUG "Tx BA session stop requested for %s tid %u\n", | |
502 | print_mac(mac, ra), tid); | |
503 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
504 | ||
505 | ieee80211_stop_queue(hw, sta->tid_to_tx_q[tid]); | |
506 | ||
507 | *state = HT_AGG_STATE_REQ_STOP_BA_MSK | | |
508 | (initiator << HT_AGG_STATE_INITIATOR_SHIFT); | |
509 | ||
510 | if (local->ops->ampdu_action) | |
511 | ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_STOP, | |
512 | ra, tid, NULL); | |
513 | ||
514 | /* case HW denied going back to legacy */ | |
515 | if (ret) { | |
516 | WARN_ON(ret != -EBUSY); | |
517 | *state = HT_AGG_STATE_OPERATIONAL; | |
518 | ieee80211_wake_queue(hw, sta->tid_to_tx_q[tid]); | |
519 | goto stop_BA_exit; | |
520 | } | |
521 | ||
522 | stop_BA_exit: | |
523 | spin_unlock_bh(&sta->lock); | |
524 | rcu_read_unlock(); | |
525 | return ret; | |
526 | } | |
527 | EXPORT_SYMBOL(ieee80211_stop_tx_ba_session); | |
528 | ||
529 | void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid) | |
530 | { | |
531 | struct ieee80211_local *local = hw_to_local(hw); | |
532 | struct sta_info *sta; | |
533 | u8 *state; | |
534 | DECLARE_MAC_BUF(mac); | |
535 | ||
536 | if (tid >= STA_TID_NUM) { | |
537 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
538 | printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n", | |
539 | tid, STA_TID_NUM); | |
540 | #endif | |
541 | return; | |
542 | } | |
543 | ||
544 | rcu_read_lock(); | |
545 | sta = sta_info_get(local, ra); | |
546 | if (!sta) { | |
547 | rcu_read_unlock(); | |
548 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
549 | printk(KERN_DEBUG "Could not find station: %s\n", | |
550 | print_mac(mac, ra)); | |
551 | #endif | |
552 | return; | |
553 | } | |
554 | ||
555 | state = &sta->ampdu_mlme.tid_state_tx[tid]; | |
556 | spin_lock_bh(&sta->lock); | |
557 | ||
558 | if (!(*state & HT_ADDBA_REQUESTED_MSK)) { | |
559 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
560 | printk(KERN_DEBUG "addBA was not requested yet, state is %d\n", | |
561 | *state); | |
562 | #endif | |
563 | spin_unlock_bh(&sta->lock); | |
564 | rcu_read_unlock(); | |
565 | return; | |
566 | } | |
567 | ||
568 | WARN_ON_ONCE(*state & HT_ADDBA_DRV_READY_MSK); | |
569 | ||
570 | *state |= HT_ADDBA_DRV_READY_MSK; | |
571 | ||
572 | if (*state == HT_AGG_STATE_OPERATIONAL) { | |
573 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
574 | printk(KERN_DEBUG "Aggregation is on for tid %d \n", tid); | |
575 | #endif | |
576 | ieee80211_wake_queue(hw, sta->tid_to_tx_q[tid]); | |
577 | } | |
578 | spin_unlock_bh(&sta->lock); | |
579 | rcu_read_unlock(); | |
580 | } | |
581 | EXPORT_SYMBOL(ieee80211_start_tx_ba_cb); | |
582 | ||
583 | void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid) | |
584 | { | |
585 | struct ieee80211_local *local = hw_to_local(hw); | |
586 | struct sta_info *sta; | |
587 | u8 *state; | |
588 | int agg_queue; | |
589 | DECLARE_MAC_BUF(mac); | |
590 | ||
591 | if (tid >= STA_TID_NUM) { | |
592 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
593 | printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n", | |
594 | tid, STA_TID_NUM); | |
595 | #endif | |
596 | return; | |
597 | } | |
598 | ||
599 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
600 | printk(KERN_DEBUG "Stopping Tx BA session for %s tid %d\n", | |
601 | print_mac(mac, ra), tid); | |
602 | #endif /* CONFIG_MAC80211_HT_DEBUG */ | |
603 | ||
604 | rcu_read_lock(); | |
605 | sta = sta_info_get(local, ra); | |
606 | if (!sta) { | |
607 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
608 | printk(KERN_DEBUG "Could not find station: %s\n", | |
609 | print_mac(mac, ra)); | |
610 | #endif | |
611 | rcu_read_unlock(); | |
612 | return; | |
613 | } | |
614 | state = &sta->ampdu_mlme.tid_state_tx[tid]; | |
615 | ||
616 | /* NOTE: no need to use sta->lock in this state check, as | |
617 | * ieee80211_stop_tx_ba_session will let only one stop call to | |
618 | * pass through per sta/tid | |
619 | */ | |
620 | if ((*state & HT_AGG_STATE_REQ_STOP_BA_MSK) == 0) { | |
621 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
622 | printk(KERN_DEBUG "unexpected callback to A-MPDU stop\n"); | |
623 | #endif | |
624 | rcu_read_unlock(); | |
625 | return; | |
626 | } | |
627 | ||
628 | if (*state & HT_AGG_STATE_INITIATOR_MSK) | |
629 | ieee80211_send_delba(sta->sdata, ra, tid, | |
630 | WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE); | |
631 | ||
632 | agg_queue = sta->tid_to_tx_q[tid]; | |
633 | ||
634 | ieee80211_ht_agg_queue_remove(local, sta, tid, 1); | |
635 | ||
636 | /* We just requeued the all the frames that were in the | |
637 | * removed queue, and since we might miss a softirq we do | |
638 | * netif_schedule_queue. ieee80211_wake_queue is not used | |
639 | * here as this queue is not necessarily stopped | |
640 | */ | |
641 | netif_schedule_queue(netdev_get_tx_queue(local->mdev, agg_queue)); | |
642 | spin_lock_bh(&sta->lock); | |
643 | *state = HT_AGG_STATE_IDLE; | |
644 | sta->ampdu_mlme.addba_req_num[tid] = 0; | |
645 | kfree(sta->ampdu_mlme.tid_tx[tid]); | |
646 | sta->ampdu_mlme.tid_tx[tid] = NULL; | |
647 | spin_unlock_bh(&sta->lock); | |
648 | ||
649 | rcu_read_unlock(); | |
650 | } | |
651 | EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb); | |
652 | ||
653 | void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, | |
654 | const u8 *ra, u16 tid) | |
655 | { | |
656 | struct ieee80211_local *local = hw_to_local(hw); | |
657 | struct ieee80211_ra_tid *ra_tid; | |
658 | struct sk_buff *skb = dev_alloc_skb(0); | |
659 | ||
660 | if (unlikely(!skb)) { | |
661 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
662 | if (net_ratelimit()) | |
663 | printk(KERN_WARNING "%s: Not enough memory, " | |
664 | "dropping start BA session", skb->dev->name); | |
665 | #endif | |
666 | return; | |
667 | } | |
668 | ra_tid = (struct ieee80211_ra_tid *) &skb->cb; | |
669 | memcpy(&ra_tid->ra, ra, ETH_ALEN); | |
670 | ra_tid->tid = tid; | |
671 | ||
672 | skb->pkt_type = IEEE80211_ADDBA_MSG; | |
673 | skb_queue_tail(&local->skb_queue, skb); | |
674 | tasklet_schedule(&local->tasklet); | |
675 | } | |
676 | EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe); | |
677 | ||
678 | void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, | |
679 | const u8 *ra, u16 tid) | |
680 | { | |
681 | struct ieee80211_local *local = hw_to_local(hw); | |
682 | struct ieee80211_ra_tid *ra_tid; | |
683 | struct sk_buff *skb = dev_alloc_skb(0); | |
684 | ||
685 | if (unlikely(!skb)) { | |
686 | #ifdef CONFIG_MAC80211_HT_DEBUG | |
687 | if (net_ratelimit()) | |
688 | printk(KERN_WARNING "%s: Not enough memory, " | |
689 | "dropping stop BA session", skb->dev->name); | |
690 | #endif | |
691 | return; | |
692 | } | |
693 | ra_tid = (struct ieee80211_ra_tid *) &skb->cb; | |
694 | memcpy(&ra_tid->ra, ra, ETH_ALEN); | |
695 | ra_tid->tid = tid; | |
696 | ||
697 | skb->pkt_type = IEEE80211_DELBA_MSG; | |
698 | skb_queue_tail(&local->skb_queue, skb); | |
699 | tasklet_schedule(&local->tasklet); | |
700 | } | |
701 | EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe); |