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"
20 void ieee80211_tx_status_irqsafe(struct ieee80211_hw
*hw
,
23 struct ieee80211_local
*local
= hw_to_local(hw
);
24 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
27 skb
->pkt_type
= IEEE80211_TX_STATUS_MSG
;
28 skb_queue_tail(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
?
29 &local
->skb_queue
: &local
->skb_queue_unreliable
, skb
);
30 tmp
= skb_queue_len(&local
->skb_queue
) +
31 skb_queue_len(&local
->skb_queue_unreliable
);
32 while (tmp
> IEEE80211_IRQSAFE_QUEUE_LIMIT
&&
33 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
34 dev_kfree_skb_irq(skb
);
36 I802_DEBUG_INC(local
->tx_status_drop
);
38 tasklet_schedule(&local
->tasklet
);
40 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe
);
42 static void ieee80211_handle_filtered_frame(struct ieee80211_local
*local
,
46 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
47 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
51 * This skb 'survived' a round-trip through the driver, and
52 * hopefully the driver didn't mangle it too badly. However,
53 * we can definitely not rely on the control information
54 * being correct. Clear it so we don't get junk there, and
55 * indicate that it needs new processing, but must not be
56 * modified/encrypted again.
58 memset(&info
->control
, 0, sizeof(info
->control
));
60 info
->control
.jiffies
= jiffies
;
61 info
->control
.vif
= &sta
->sdata
->vif
;
62 info
->flags
|= IEEE80211_TX_INTFL_NEED_TXPROCESSING
|
63 IEEE80211_TX_INTFL_RETRANSMISSION
;
64 info
->flags
&= ~IEEE80211_TX_TEMPORARY_FLAGS
;
66 sta
->tx_filtered_count
++;
69 * Clear more-data bit on filtered frames, it might be set
70 * but later frames might time out so it might have to be
71 * clear again ... It's all rather unlikely (this frame
72 * should time out first, right?) but let's not confuse
73 * peers unnecessarily.
75 if (hdr
->frame_control
& cpu_to_le16(IEEE80211_FCTL_MOREDATA
))
76 hdr
->frame_control
&= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
78 if (ieee80211_is_data_qos(hdr
->frame_control
)) {
79 int tid
= *ieee80211_get_qos_ctl(hdr
) &
80 IEEE80211_QOS_CTL_TID_MASK
;
81 ac
= ieee802_1d_to_ac
[tid
& 7];
87 * Clear the TX filter mask for this STA when sending the next
88 * packet. If the STA went to power save mode, this will happen
89 * when it wakes up for the next time.
91 set_sta_flags(sta
, WLAN_STA_CLEAR_PS_FILT
);
94 * This code races in the following way:
96 * (1) STA sends frame indicating it will go to sleep and does so
97 * (2) hardware/firmware adds STA to filter list, passes frame up
98 * (3) hardware/firmware processes TX fifo and suppresses a frame
99 * (4) we get TX status before having processed the frame and
100 * knowing that the STA has gone to sleep.
102 * This is actually quite unlikely even when both those events are
103 * processed from interrupts coming in quickly after one another or
104 * even at the same time because we queue both TX status events and
105 * RX frames to be processed by a tasklet and process them in the
106 * same order that they were received or TX status last. Hence, there
107 * is no race as long as the frame RX is processed before the next TX
108 * status, which drivers can ensure, see below.
110 * Note that this can only happen if the hardware or firmware can
111 * actually add STAs to the filter list, if this is done by the
112 * driver in response to set_tim() (which will only reduce the race
113 * this whole filtering tries to solve, not completely solve it)
114 * this situation cannot happen.
116 * To completely solve this race drivers need to make sure that they
117 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
119 * (b) always process RX events before TX status events if ordering
120 * can be unknown, for example with different interrupt status
122 * (c) if PS mode transitions are manual (i.e. the flag
123 * %IEEE80211_HW_AP_LINK_PS is set), always process PS state
124 * changes before calling TX status events if ordering can be
127 if (test_sta_flags(sta
, WLAN_STA_PS_STA
) &&
128 skb_queue_len(&sta
->tx_filtered
[ac
]) < STA_MAX_TX_BUFFER
) {
129 skb_queue_tail(&sta
->tx_filtered
[ac
], skb
);
130 sta_info_recalc_tim(sta
);
132 if (!timer_pending(&local
->sta_cleanup
))
133 mod_timer(&local
->sta_cleanup
,
134 round_jiffies(jiffies
+
135 STA_INFO_CLEANUP_INTERVAL
));
139 if (!test_sta_flags(sta
, WLAN_STA_PS_STA
) &&
140 !(info
->flags
& IEEE80211_TX_INTFL_RETRIED
)) {
141 /* Software retry the packet once */
142 info
->flags
|= IEEE80211_TX_INTFL_RETRIED
;
143 ieee80211_add_pending_skb(local
, skb
);
147 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
149 wiphy_debug(local
->hw
.wiphy
,
150 "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
151 skb_queue_len(&sta
->tx_filtered
[ac
]),
152 !!test_sta_flags(sta
, WLAN_STA_PS_STA
), jiffies
);
157 static void ieee80211_check_pending_bar(struct sta_info
*sta
, u8
*addr
, u8 tid
)
159 struct tid_ampdu_tx
*tid_tx
;
161 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
162 if (!tid_tx
|| !tid_tx
->bar_pending
)
165 tid_tx
->bar_pending
= false;
166 ieee80211_send_bar(&sta
->sdata
->vif
, addr
, tid
, tid_tx
->failed_bar_ssn
);
169 static void ieee80211_frame_acked(struct sta_info
*sta
, struct sk_buff
*skb
)
171 struct ieee80211_mgmt
*mgmt
= (void *) skb
->data
;
172 struct ieee80211_local
*local
= sta
->local
;
173 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
175 if (ieee80211_is_data_qos(mgmt
->frame_control
)) {
176 struct ieee80211_hdr
*hdr
= (void *) skb
->data
;
177 u8
*qc
= ieee80211_get_qos_ctl(hdr
);
178 u16 tid
= qc
[0] & 0xf;
180 ieee80211_check_pending_bar(sta
, hdr
->addr1
, tid
);
183 if (ieee80211_is_action(mgmt
->frame_control
) &&
184 sdata
->vif
.type
== NL80211_IFTYPE_STATION
&&
185 mgmt
->u
.action
.category
== WLAN_CATEGORY_HT
&&
186 mgmt
->u
.action
.u
.ht_smps
.action
== WLAN_HT_ACTION_SMPS
) {
188 * This update looks racy, but isn't -- if we come
189 * here we've definitely got a station that we're
190 * talking to, and on a managed interface that can
191 * only be the AP. And the only other place updating
192 * this variable is before we're associated.
194 switch (mgmt
->u
.action
.u
.ht_smps
.smps_control
) {
195 case WLAN_HT_SMPS_CONTROL_DYNAMIC
:
196 sta
->sdata
->u
.mgd
.ap_smps
= IEEE80211_SMPS_DYNAMIC
;
198 case WLAN_HT_SMPS_CONTROL_STATIC
:
199 sta
->sdata
->u
.mgd
.ap_smps
= IEEE80211_SMPS_STATIC
;
201 case WLAN_HT_SMPS_CONTROL_DISABLED
:
202 default: /* shouldn't happen since we don't send that */
203 sta
->sdata
->u
.mgd
.ap_smps
= IEEE80211_SMPS_OFF
;
207 ieee80211_queue_work(&local
->hw
, &local
->recalc_smps
);
211 static void ieee80211_set_bar_pending(struct sta_info
*sta
, u8 tid
, u16 ssn
)
213 struct tid_ampdu_tx
*tid_tx
;
215 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
219 tid_tx
->failed_bar_ssn
= ssn
;
220 tid_tx
->bar_pending
= true;
224 * Use a static threshold for now, best value to be determined
226 * Should it depend on:
227 * - on # of retransmissions
228 * - current throughput (higher value for higher tpt)?
230 #define STA_LOST_PKT_THRESHOLD 50
232 void ieee80211_tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
234 struct sk_buff
*skb2
;
235 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
236 struct ieee80211_local
*local
= hw_to_local(hw
);
237 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
240 struct ieee80211_supported_band
*sband
;
241 struct ieee80211_tx_status_rtap_hdr
*rthdr
;
242 struct ieee80211_sub_if_data
*sdata
;
243 struct net_device
*prev_dev
= NULL
;
244 struct sta_info
*sta
, *tmp
;
245 int retry_count
= -1, i
;
249 struct ieee80211_bar
*bar
;
252 for (i
= 0; i
< IEEE80211_TX_MAX_RATES
; i
++) {
253 if (info
->status
.rates
[i
].idx
< 0) {
255 } else if (i
>= hw
->max_report_rates
) {
256 /* the HW cannot have attempted that rate */
257 info
->status
.rates
[i
].idx
= -1;
258 info
->status
.rates
[i
].count
= 0;
262 retry_count
+= info
->status
.rates
[i
].count
;
271 sband
= local
->hw
.wiphy
->bands
[info
->band
];
272 fc
= hdr
->frame_control
;
274 for_each_sta_info(local
, hdr
->addr1
, sta
, tmp
) {
275 /* skip wrong virtual interface */
276 if (memcmp(hdr
->addr2
, sta
->sdata
->vif
.addr
, ETH_ALEN
))
279 acked
= !!(info
->flags
& IEEE80211_TX_STAT_ACK
);
280 if (!acked
&& test_sta_flags(sta
, WLAN_STA_PS_STA
)) {
282 * The STA is in power save mode, so assume
283 * that this TX packet failed because of that.
285 ieee80211_handle_filtered_frame(local
, sta
, skb
);
290 if ((local
->hw
.flags
& IEEE80211_HW_HAS_RATE_CONTROL
) &&
292 sta
->last_tx_rate
= info
->status
.rates
[rates_idx
];
294 if ((info
->flags
& IEEE80211_TX_STAT_AMPDU_NO_BACK
) &&
295 (ieee80211_is_data_qos(fc
))) {
299 qc
= ieee80211_get_qos_ctl(hdr
);
301 ssn
= ((le16_to_cpu(hdr
->seq_ctrl
) + 0x10)
302 & IEEE80211_SCTL_SEQ
);
303 ieee80211_send_bar(&sta
->sdata
->vif
, hdr
->addr1
,
307 if (!acked
&& ieee80211_is_back_req(fc
)) {
311 * BAR failed, store the last SSN and retry sending
312 * the BAR when the next unicast transmission on the
315 bar
= (struct ieee80211_bar
*) skb
->data
;
316 control
= le16_to_cpu(bar
->control
);
317 if (!(control
& IEEE80211_BAR_CTRL_MULTI_TID
)) {
318 u16 ssn
= le16_to_cpu(bar
->start_seq_num
);
321 IEEE80211_BAR_CTRL_TID_INFO_MASK
) >>
322 IEEE80211_BAR_CTRL_TID_INFO_SHIFT
;
324 ieee80211_set_bar_pending(sta
, tid
, ssn
);
328 if (info
->flags
& IEEE80211_TX_STAT_TX_FILTERED
) {
329 ieee80211_handle_filtered_frame(local
, sta
, skb
);
334 sta
->tx_retry_failed
++;
335 sta
->tx_retry_count
+= retry_count
;
338 rate_control_tx_status(local
, sband
, sta
, skb
);
339 if (ieee80211_vif_is_mesh(&sta
->sdata
->vif
))
340 ieee80211s_update_metric(local
, sta
, skb
);
342 if (!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) && acked
)
343 ieee80211_frame_acked(sta
, skb
);
345 if ((sta
->sdata
->vif
.type
== NL80211_IFTYPE_STATION
) &&
346 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
))
347 ieee80211_sta_tx_notify(sta
->sdata
, (void *) skb
->data
, acked
);
349 if (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) {
350 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
351 if (sta
->lost_packets
)
352 sta
->lost_packets
= 0;
353 } else if (++sta
->lost_packets
>= STA_LOST_PKT_THRESHOLD
) {
354 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
,
358 sta
->lost_packets
= 0;
365 ieee80211_led_tx(local
, 0);
368 * Fragments are passed to low-level drivers as separate skbs, so these
369 * are actually fragments, not frames. Update frame counters only for
370 * the first fragment of the frame. */
372 frag
= le16_to_cpu(hdr
->seq_ctrl
) & IEEE80211_SCTL_FRAG
;
373 type
= le16_to_cpu(hdr
->frame_control
) & IEEE80211_FCTL_FTYPE
;
375 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
377 local
->dot11TransmittedFrameCount
++;
378 if (is_multicast_ether_addr(hdr
->addr1
))
379 local
->dot11MulticastTransmittedFrameCount
++;
381 local
->dot11RetryCount
++;
383 local
->dot11MultipleRetryCount
++;
386 /* This counter shall be incremented for an acknowledged MPDU
387 * with an individual address in the address 1 field or an MPDU
388 * with a multicast address in the address 1 field of type Data
390 if (!is_multicast_ether_addr(hdr
->addr1
) ||
391 type
== IEEE80211_FTYPE_DATA
||
392 type
== IEEE80211_FTYPE_MGMT
)
393 local
->dot11TransmittedFragmentCount
++;
396 local
->dot11FailedCount
++;
399 if (ieee80211_is_nullfunc(fc
) && ieee80211_has_pm(fc
) &&
400 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) &&
401 !(info
->flags
& IEEE80211_TX_CTL_INJECTED
) &&
402 local
->ps_sdata
&& !(local
->scanning
)) {
403 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
404 local
->ps_sdata
->u
.mgd
.flags
|=
405 IEEE80211_STA_NULLFUNC_ACKED
;
407 mod_timer(&local
->dynamic_ps_timer
, jiffies
+
408 msecs_to_jiffies(10));
411 if (info
->flags
& IEEE80211_TX_INTFL_NL80211_FRAME_TX
) {
412 struct ieee80211_work
*wk
;
413 u64 cookie
= (unsigned long)skb
;
416 list_for_each_entry_rcu(wk
, &local
->work_list
, list
) {
417 if (wk
->type
!= IEEE80211_WORK_OFFCHANNEL_TX
)
419 if (wk
->offchan_tx
.frame
!= skb
)
421 wk
->offchan_tx
.frame
= NULL
;
425 if (local
->hw_roc_skb_for_status
== skb
) {
426 cookie
= local
->hw_roc_cookie
^ 2;
427 local
->hw_roc_skb_for_status
= NULL
;
430 cfg80211_mgmt_tx_status(
431 skb
->dev
, cookie
, skb
->data
, skb
->len
,
432 !!(info
->flags
& IEEE80211_TX_STAT_ACK
), GFP_ATOMIC
);
435 /* this was a transmitted frame, but now we want to reuse it */
438 /* Need to make a copy before skb->cb gets cleared */
439 send_to_cooked
= !!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) ||
440 (type
!= IEEE80211_FTYPE_DATA
);
443 * This is a bit racy but we can avoid a lot of work
446 if (!local
->monitors
&& (!send_to_cooked
|| !local
->cooked_mntrs
)) {
451 /* send frame to monitor interfaces now */
453 if (skb_headroom(skb
) < sizeof(*rthdr
)) {
454 printk(KERN_ERR
"ieee80211_tx_status: headroom too small\n");
459 rthdr
= (struct ieee80211_tx_status_rtap_hdr
*)
460 skb_push(skb
, sizeof(*rthdr
));
462 memset(rthdr
, 0, sizeof(*rthdr
));
463 rthdr
->hdr
.it_len
= cpu_to_le16(sizeof(*rthdr
));
464 rthdr
->hdr
.it_present
=
465 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS
) |
466 (1 << IEEE80211_RADIOTAP_DATA_RETRIES
) |
467 (1 << IEEE80211_RADIOTAP_RATE
));
469 if (!(info
->flags
& IEEE80211_TX_STAT_ACK
) &&
470 !is_multicast_ether_addr(hdr
->addr1
))
471 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL
);
474 * XXX: Once radiotap gets the bitmap reset thing the vendor
475 * extensions proposal contains, we can actually report
476 * the whole set of tries we did.
478 if ((info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
) ||
479 (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
))
480 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS
);
481 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
482 rthdr
->tx_flags
|= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS
);
483 if (info
->status
.rates
[0].idx
>= 0 &&
484 !(info
->status
.rates
[0].flags
& IEEE80211_TX_RC_MCS
))
485 rthdr
->rate
= sband
->bitrates
[
486 info
->status
.rates
[0].idx
].bitrate
/ 5;
488 /* for now report the total retry_count */
489 rthdr
->data_retries
= retry_count
;
491 /* XXX: is this sufficient for BPF? */
492 skb_set_mac_header(skb
, 0);
493 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
494 skb
->pkt_type
= PACKET_OTHERHOST
;
495 skb
->protocol
= htons(ETH_P_802_2
);
496 memset(skb
->cb
, 0, sizeof(skb
->cb
));
499 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
500 if (sdata
->vif
.type
== NL80211_IFTYPE_MONITOR
) {
501 if (!ieee80211_sdata_running(sdata
))
504 if ((sdata
->u
.mntr_flags
& MONITOR_FLAG_COOK_FRAMES
) &&
509 skb2
= skb_clone(skb
, GFP_ATOMIC
);
511 skb2
->dev
= prev_dev
;
516 prev_dev
= sdata
->dev
;
527 EXPORT_SYMBOL(ieee80211_tx_status
);
529 void ieee80211_report_low_ack(struct ieee80211_sta
*pubsta
, u32 num_packets
)
531 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
532 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
, sta
->sta
.addr
,
533 num_packets
, GFP_ATOMIC
);
535 EXPORT_SYMBOL(ieee80211_report_low_ack
);