2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5 * Copyright 2008-2010 Johannes Berg <johannes@sipsolutions.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <net/mac80211.h>
13 #include "ieee80211_i.h"
19 void ieee80211_tx_status_irqsafe(struct ieee80211_hw
*hw
,
22 struct ieee80211_local
*local
= hw_to_local(hw
);
23 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
26 skb
->pkt_type
= IEEE80211_TX_STATUS_MSG
;
27 skb_queue_tail(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
?
28 &local
->skb_queue
: &local
->skb_queue_unreliable
, skb
);
29 tmp
= skb_queue_len(&local
->skb_queue
) +
30 skb_queue_len(&local
->skb_queue_unreliable
);
31 while (tmp
> IEEE80211_IRQSAFE_QUEUE_LIMIT
&&
32 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
33 dev_kfree_skb_irq(skb
);
35 I802_DEBUG_INC(local
->tx_status_drop
);
37 tasklet_schedule(&local
->tasklet
);
39 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe
);
41 static void ieee80211_handle_filtered_frame(struct ieee80211_local
*local
,
45 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
48 * This skb 'survived' a round-trip through the driver, and
49 * hopefully the driver didn't mangle it too badly. However,
50 * we can definitely not rely on the control information
51 * being correct. Clear it so we don't get junk there, and
52 * indicate that it needs new processing, but must not be
53 * modified/encrypted again.
55 memset(&info
->control
, 0, sizeof(info
->control
));
57 info
->control
.jiffies
= jiffies
;
58 info
->control
.vif
= &sta
->sdata
->vif
;
59 info
->flags
|= IEEE80211_TX_INTFL_NEED_TXPROCESSING
|
60 IEEE80211_TX_INTFL_RETRANSMISSION
;
61 info
->flags
&= ~IEEE80211_TX_TEMPORARY_FLAGS
;
63 sta
->tx_filtered_count
++;
66 * Clear the TX filter mask for this STA when sending the next
67 * packet. If the STA went to power save mode, this will happen
68 * when it wakes up for the next time.
70 set_sta_flags(sta
, WLAN_STA_CLEAR_PS_FILT
);
73 * This code races in the following way:
75 * (1) STA sends frame indicating it will go to sleep and does so
76 * (2) hardware/firmware adds STA to filter list, passes frame up
77 * (3) hardware/firmware processes TX fifo and suppresses a frame
78 * (4) we get TX status before having processed the frame and
79 * knowing that the STA has gone to sleep.
81 * This is actually quite unlikely even when both those events are
82 * processed from interrupts coming in quickly after one another or
83 * even at the same time because we queue both TX status events and
84 * RX frames to be processed by a tasklet and process them in the
85 * same order that they were received or TX status last. Hence, there
86 * is no race as long as the frame RX is processed before the next TX
87 * status, which drivers can ensure, see below.
89 * Note that this can only happen if the hardware or firmware can
90 * actually add STAs to the filter list, if this is done by the
91 * driver in response to set_tim() (which will only reduce the race
92 * this whole filtering tries to solve, not completely solve it)
93 * this situation cannot happen.
95 * To completely solve this race drivers need to make sure that they
96 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
98 * (b) always process RX events before TX status events if ordering
99 * can be unknown, for example with different interrupt status
101 * (c) if PS mode transitions are manual (i.e. the flag
102 * %IEEE80211_HW_AP_LINK_PS is set), always process PS state
103 * changes before calling TX status events if ordering can be
106 if (test_sta_flags(sta
, WLAN_STA_PS_STA
) &&
107 skb_queue_len(&sta
->tx_filtered
) < STA_MAX_TX_BUFFER
) {
108 skb_queue_tail(&sta
->tx_filtered
, skb
);
112 if (!test_sta_flags(sta
, WLAN_STA_PS_STA
) &&
113 !(info
->flags
& IEEE80211_TX_INTFL_RETRIED
)) {
114 /* Software retry the packet once */
115 info
->flags
|= IEEE80211_TX_INTFL_RETRIED
;
116 ieee80211_add_pending_skb(local
, skb
);
120 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
122 wiphy_debug(local
->hw
.wiphy
,
123 "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
124 skb_queue_len(&sta
->tx_filtered
),
125 !!test_sta_flags(sta
, WLAN_STA_PS_STA
), jiffies
);
130 static void ieee80211_check_pending_bar(struct sta_info
*sta
, u8
*addr
, u8 tid
)
132 struct tid_ampdu_tx
*tid_tx
;
134 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
135 if (!tid_tx
|| !tid_tx
->bar_pending
)
138 tid_tx
->bar_pending
= false;
139 ieee80211_send_bar(&sta
->sdata
->vif
, addr
, tid
, tid_tx
->failed_bar_ssn
);
142 static void ieee80211_frame_acked(struct sta_info
*sta
, struct sk_buff
*skb
)
144 struct ieee80211_mgmt
*mgmt
= (void *) skb
->data
;
145 struct ieee80211_local
*local
= sta
->local
;
146 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
148 if (ieee80211_is_data_qos(mgmt
->frame_control
)) {
149 struct ieee80211_hdr
*hdr
= (void *) skb
->data
;
150 u8
*qc
= ieee80211_get_qos_ctl(hdr
);
151 u16 tid
= qc
[0] & 0xf;
153 ieee80211_check_pending_bar(sta
, hdr
->addr1
, tid
);
156 if (ieee80211_is_action(mgmt
->frame_control
) &&
157 sdata
->vif
.type
== NL80211_IFTYPE_STATION
&&
158 mgmt
->u
.action
.category
== WLAN_CATEGORY_HT
&&
159 mgmt
->u
.action
.u
.ht_smps
.action
== WLAN_HT_ACTION_SMPS
) {
161 * This update looks racy, but isn't -- if we come
162 * here we've definitely got a station that we're
163 * talking to, and on a managed interface that can
164 * only be the AP. And the only other place updating
165 * this variable is before we're associated.
167 switch (mgmt
->u
.action
.u
.ht_smps
.smps_control
) {
168 case WLAN_HT_SMPS_CONTROL_DYNAMIC
:
169 sta
->sdata
->u
.mgd
.ap_smps
= IEEE80211_SMPS_DYNAMIC
;
171 case WLAN_HT_SMPS_CONTROL_STATIC
:
172 sta
->sdata
->u
.mgd
.ap_smps
= IEEE80211_SMPS_STATIC
;
174 case WLAN_HT_SMPS_CONTROL_DISABLED
:
175 default: /* shouldn't happen since we don't send that */
176 sta
->sdata
->u
.mgd
.ap_smps
= IEEE80211_SMPS_OFF
;
180 ieee80211_queue_work(&local
->hw
, &local
->recalc_smps
);
184 static void ieee80211_set_bar_pending(struct sta_info
*sta
, u8 tid
, u16 ssn
)
186 struct tid_ampdu_tx
*tid_tx
;
188 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
192 tid_tx
->failed_bar_ssn
= ssn
;
193 tid_tx
->bar_pending
= true;
197 * Use a static threshold for now, best value to be determined
199 * Should it depend on:
200 * - on # of retransmissions
201 * - current throughput (higher value for higher tpt)?
203 #define STA_LOST_PKT_THRESHOLD 50
205 void ieee80211_tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
207 struct sk_buff
*skb2
;
208 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
209 struct ieee80211_local
*local
= hw_to_local(hw
);
210 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
213 struct ieee80211_supported_band
*sband
;
214 struct ieee80211_tx_status_rtap_hdr
*rthdr
;
215 struct ieee80211_sub_if_data
*sdata
;
216 struct net_device
*prev_dev
= NULL
;
217 struct sta_info
*sta
, *tmp
;
218 int retry_count
= -1, i
;
222 struct ieee80211_bar
*bar
;
225 for (i
= 0; i
< IEEE80211_TX_MAX_RATES
; i
++) {
226 if (info
->status
.rates
[i
].idx
< 0) {
228 } else if (i
>= hw
->max_report_rates
) {
229 /* the HW cannot have attempted that rate */
230 info
->status
.rates
[i
].idx
= -1;
231 info
->status
.rates
[i
].count
= 0;
235 retry_count
+= info
->status
.rates
[i
].count
;
244 sband
= local
->hw
.wiphy
->bands
[info
->band
];
245 fc
= hdr
->frame_control
;
247 for_each_sta_info(local
, hdr
->addr1
, sta
, tmp
) {
248 /* skip wrong virtual interface */
249 if (memcmp(hdr
->addr2
, sta
->sdata
->vif
.addr
, ETH_ALEN
))
252 acked
= !!(info
->flags
& IEEE80211_TX_STAT_ACK
);
253 if (!acked
&& test_sta_flags(sta
, WLAN_STA_PS_STA
)) {
255 * The STA is in power save mode, so assume
256 * that this TX packet failed because of that.
258 ieee80211_handle_filtered_frame(local
, sta
, skb
);
263 if ((local
->hw
.flags
& IEEE80211_HW_HAS_RATE_CONTROL
) &&
265 sta
->last_tx_rate
= info
->status
.rates
[rates_idx
];
267 if ((info
->flags
& IEEE80211_TX_STAT_AMPDU_NO_BACK
) &&
268 (ieee80211_is_data_qos(fc
))) {
272 qc
= ieee80211_get_qos_ctl(hdr
);
274 ssn
= ((le16_to_cpu(hdr
->seq_ctrl
) + 0x10)
275 & IEEE80211_SCTL_SEQ
);
276 ieee80211_send_bar(&sta
->sdata
->vif
, hdr
->addr1
,
280 if (!acked
&& ieee80211_is_back_req(fc
)) {
282 * BAR failed, let's tear down the BA session as a
283 * last resort as some STAs (Intel 5100 on Windows)
284 * can get stuck when the BA window isn't flushed
287 bar
= (struct ieee80211_bar
*) skb
->data
;
288 if (!(bar
->control
& IEEE80211_BAR_CTRL_MULTI_TID
)) {
289 u16 ssn
= le16_to_cpu(bar
->start_seq_num
);
291 tid
= (bar
->control
&
292 IEEE80211_BAR_CTRL_TID_INFO_MASK
) >>
293 IEEE80211_BAR_CTRL_TID_INFO_SHIFT
;
295 ieee80211_set_bar_pending(sta
, tid
, ssn
);
299 if (info
->flags
& IEEE80211_TX_STAT_TX_FILTERED
) {
300 ieee80211_handle_filtered_frame(local
, sta
, skb
);
305 sta
->tx_retry_failed
++;
306 sta
->tx_retry_count
+= retry_count
;
309 rate_control_tx_status(local
, sband
, sta
, skb
);
310 if (ieee80211_vif_is_mesh(&sta
->sdata
->vif
))
311 ieee80211s_update_metric(local
, sta
, skb
);
313 if (!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) && acked
)
314 ieee80211_frame_acked(sta
, skb
);
316 if ((sta
->sdata
->vif
.type
== NL80211_IFTYPE_STATION
) &&
317 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
))
318 ieee80211_sta_tx_notify(sta
->sdata
, (void *) skb
->data
, acked
);
320 if (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) {
321 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
322 if (sta
->lost_packets
)
323 sta
->lost_packets
= 0;
324 } else if (++sta
->lost_packets
>= STA_LOST_PKT_THRESHOLD
) {
325 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
,
329 sta
->lost_packets
= 0;
336 ieee80211_led_tx(local
, 0);
339 * Fragments are passed to low-level drivers as separate skbs, so these
340 * are actually fragments, not frames. Update frame counters only for
341 * the first fragment of the frame. */
343 frag
= le16_to_cpu(hdr
->seq_ctrl
) & IEEE80211_SCTL_FRAG
;
344 type
= le16_to_cpu(hdr
->frame_control
) & IEEE80211_FCTL_FTYPE
;
346 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
348 local
->dot11TransmittedFrameCount
++;
349 if (is_multicast_ether_addr(hdr
->addr1
))
350 local
->dot11MulticastTransmittedFrameCount
++;
352 local
->dot11RetryCount
++;
354 local
->dot11MultipleRetryCount
++;
357 /* This counter shall be incremented for an acknowledged MPDU
358 * with an individual address in the address 1 field or an MPDU
359 * with a multicast address in the address 1 field of type Data
361 if (!is_multicast_ether_addr(hdr
->addr1
) ||
362 type
== IEEE80211_FTYPE_DATA
||
363 type
== IEEE80211_FTYPE_MGMT
)
364 local
->dot11TransmittedFragmentCount
++;
367 local
->dot11FailedCount
++;
370 if (ieee80211_is_nullfunc(fc
) && ieee80211_has_pm(fc
) &&
371 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) &&
372 !(info
->flags
& IEEE80211_TX_CTL_INJECTED
) &&
373 local
->ps_sdata
&& !(local
->scanning
)) {
374 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
375 local
->ps_sdata
->u
.mgd
.flags
|=
376 IEEE80211_STA_NULLFUNC_ACKED
;
378 mod_timer(&local
->dynamic_ps_timer
, jiffies
+
379 msecs_to_jiffies(10));
382 if (info
->flags
& IEEE80211_TX_INTFL_NL80211_FRAME_TX
) {
383 struct ieee80211_work
*wk
;
384 u64 cookie
= (unsigned long)skb
;
387 list_for_each_entry_rcu(wk
, &local
->work_list
, list
) {
388 if (wk
->type
!= IEEE80211_WORK_OFFCHANNEL_TX
)
390 if (wk
->offchan_tx
.frame
!= skb
)
392 wk
->offchan_tx
.frame
= NULL
;
396 if (local
->hw_roc_skb_for_status
== skb
) {
397 cookie
= local
->hw_roc_cookie
^ 2;
398 local
->hw_roc_skb_for_status
= NULL
;
401 cfg80211_mgmt_tx_status(
402 skb
->dev
, cookie
, skb
->data
, skb
->len
,
403 !!(info
->flags
& IEEE80211_TX_STAT_ACK
), GFP_ATOMIC
);
406 /* this was a transmitted frame, but now we want to reuse it */
409 /* Need to make a copy before skb->cb gets cleared */
410 send_to_cooked
= !!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) ||
411 (type
!= IEEE80211_FTYPE_DATA
);
414 * This is a bit racy but we can avoid a lot of work
417 if (!local
->monitors
&& (!send_to_cooked
|| !local
->cooked_mntrs
)) {
422 /* send frame to monitor interfaces now */
424 if (skb_headroom(skb
) < sizeof(*rthdr
)) {
425 printk(KERN_ERR
"ieee80211_tx_status: headroom too small\n");
430 rthdr
= (struct ieee80211_tx_status_rtap_hdr
*)
431 skb_push(skb
, sizeof(*rthdr
));
433 memset(rthdr
, 0, sizeof(*rthdr
));
434 rthdr
->hdr
.it_len
= cpu_to_le16(sizeof(*rthdr
));
435 rthdr
->hdr
.it_present
=
436 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS
) |
437 (1 << IEEE80211_RADIOTAP_DATA_RETRIES
) |
438 (1 << IEEE80211_RADIOTAP_RATE
));
440 if (!(info
->flags
& IEEE80211_TX_STAT_ACK
) &&
441 !is_multicast_ether_addr(hdr
->addr1
))
442 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL
);
445 * XXX: Once radiotap gets the bitmap reset thing the vendor
446 * extensions proposal contains, we can actually report
447 * the whole set of tries we did.
449 if ((info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
) ||
450 (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
))
451 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS
);
452 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
453 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS
);
454 if (info
->status
.rates
[0].idx
>= 0 &&
455 !(info
->status
.rates
[0].flags
& IEEE80211_TX_RC_MCS
))
456 rthdr
->rate
= sband
->bitrates
[
457 info
->status
.rates
[0].idx
].bitrate
/ 5;
459 /* for now report the total retry_count */
460 rthdr
->data_retries
= retry_count
;
462 /* XXX: is this sufficient for BPF? */
463 skb_set_mac_header(skb
, 0);
464 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
465 skb
->pkt_type
= PACKET_OTHERHOST
;
466 skb
->protocol
= htons(ETH_P_802_2
);
467 memset(skb
->cb
, 0, sizeof(skb
->cb
));
470 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
471 if (sdata
->vif
.type
== NL80211_IFTYPE_MONITOR
) {
472 if (!ieee80211_sdata_running(sdata
))
475 if ((sdata
->u
.mntr_flags
& MONITOR_FLAG_COOK_FRAMES
) &&
480 skb2
= skb_clone(skb
, GFP_ATOMIC
);
482 skb2
->dev
= prev_dev
;
487 prev_dev
= sdata
->dev
;
498 EXPORT_SYMBOL(ieee80211_tx_status
);
500 void ieee80211_report_low_ack(struct ieee80211_sta
*pubsta
, u32 num_packets
)
502 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
503 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
, sta
->sta
.addr
,
504 num_packets
, GFP_ATOMIC
);
506 EXPORT_SYMBOL(ieee80211_report_low_ack
);