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 <linux/export.h>
13 #include <linux/etherdevice.h>
14 #include <net/mac80211.h>
15 #include <asm/unaligned.h>
16 #include "ieee80211_i.h"
23 void ieee80211_tx_status_irqsafe(struct ieee80211_hw
*hw
,
26 struct ieee80211_local
*local
= hw_to_local(hw
);
27 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
30 skb
->pkt_type
= IEEE80211_TX_STATUS_MSG
;
31 skb_queue_tail(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
?
32 &local
->skb_queue
: &local
->skb_queue_unreliable
, skb
);
33 tmp
= skb_queue_len(&local
->skb_queue
) +
34 skb_queue_len(&local
->skb_queue_unreliable
);
35 while (tmp
> IEEE80211_IRQSAFE_QUEUE_LIMIT
&&
36 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
37 ieee80211_free_txskb(hw
, skb
);
39 I802_DEBUG_INC(local
->tx_status_drop
);
41 tasklet_schedule(&local
->tasklet
);
43 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe
);
45 static void ieee80211_handle_filtered_frame(struct ieee80211_local
*local
,
49 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
50 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
54 * This skb 'survived' a round-trip through the driver, and
55 * hopefully the driver didn't mangle it too badly. However,
56 * we can definitely not rely on the control information
57 * being correct. Clear it so we don't get junk there, and
58 * indicate that it needs new processing, but must not be
59 * modified/encrypted again.
61 memset(&info
->control
, 0, sizeof(info
->control
));
63 info
->control
.jiffies
= jiffies
;
64 info
->control
.vif
= &sta
->sdata
->vif
;
65 info
->flags
|= IEEE80211_TX_INTFL_NEED_TXPROCESSING
|
66 IEEE80211_TX_INTFL_RETRANSMISSION
;
67 info
->flags
&= ~IEEE80211_TX_TEMPORARY_FLAGS
;
69 sta
->tx_filtered_count
++;
72 * Clear more-data bit on filtered frames, it might be set
73 * but later frames might time out so it might have to be
74 * clear again ... It's all rather unlikely (this frame
75 * should time out first, right?) but let's not confuse
76 * peers unnecessarily.
78 if (hdr
->frame_control
& cpu_to_le16(IEEE80211_FCTL_MOREDATA
))
79 hdr
->frame_control
&= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
81 if (ieee80211_is_data_qos(hdr
->frame_control
)) {
82 u8
*p
= ieee80211_get_qos_ctl(hdr
);
83 int tid
= *p
& IEEE80211_QOS_CTL_TID_MASK
;
86 * Clear EOSP if set, this could happen e.g.
87 * if an absence period (us being a P2P GO)
90 if (*p
& IEEE80211_QOS_CTL_EOSP
)
91 *p
&= ~IEEE80211_QOS_CTL_EOSP
;
92 ac
= ieee802_1d_to_ac
[tid
& 7];
98 * Clear the TX filter mask for this STA when sending the next
99 * packet. If the STA went to power save mode, this will happen
100 * when it wakes up for the next time.
102 set_sta_flag(sta
, WLAN_STA_CLEAR_PS_FILT
);
105 * This code races in the following way:
107 * (1) STA sends frame indicating it will go to sleep and does so
108 * (2) hardware/firmware adds STA to filter list, passes frame up
109 * (3) hardware/firmware processes TX fifo and suppresses a frame
110 * (4) we get TX status before having processed the frame and
111 * knowing that the STA has gone to sleep.
113 * This is actually quite unlikely even when both those events are
114 * processed from interrupts coming in quickly after one another or
115 * even at the same time because we queue both TX status events and
116 * RX frames to be processed by a tasklet and process them in the
117 * same order that they were received or TX status last. Hence, there
118 * is no race as long as the frame RX is processed before the next TX
119 * status, which drivers can ensure, see below.
121 * Note that this can only happen if the hardware or firmware can
122 * actually add STAs to the filter list, if this is done by the
123 * driver in response to set_tim() (which will only reduce the race
124 * this whole filtering tries to solve, not completely solve it)
125 * this situation cannot happen.
127 * To completely solve this race drivers need to make sure that they
128 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
130 * (b) always process RX events before TX status events if ordering
131 * can be unknown, for example with different interrupt status
133 * (c) if PS mode transitions are manual (i.e. the flag
134 * %IEEE80211_HW_AP_LINK_PS is set), always process PS state
135 * changes before calling TX status events if ordering can be
138 if (test_sta_flag(sta
, WLAN_STA_PS_STA
) &&
139 skb_queue_len(&sta
->tx_filtered
[ac
]) < STA_MAX_TX_BUFFER
) {
140 skb_queue_tail(&sta
->tx_filtered
[ac
], skb
);
141 sta_info_recalc_tim(sta
);
143 if (!timer_pending(&local
->sta_cleanup
))
144 mod_timer(&local
->sta_cleanup
,
145 round_jiffies(jiffies
+
146 STA_INFO_CLEANUP_INTERVAL
));
150 if (!test_sta_flag(sta
, WLAN_STA_PS_STA
) &&
151 !(info
->flags
& IEEE80211_TX_INTFL_RETRIED
)) {
152 /* Software retry the packet once */
153 info
->flags
|= IEEE80211_TX_INTFL_RETRIED
;
154 ieee80211_add_pending_skb(local
, skb
);
158 ps_dbg_ratelimited(sta
->sdata
,
159 "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
160 skb_queue_len(&sta
->tx_filtered
[ac
]),
161 !!test_sta_flag(sta
, WLAN_STA_PS_STA
), jiffies
);
162 ieee80211_free_txskb(&local
->hw
, skb
);
165 static void ieee80211_check_pending_bar(struct sta_info
*sta
, u8
*addr
, u8 tid
)
167 struct tid_ampdu_tx
*tid_tx
;
169 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
170 if (!tid_tx
|| !tid_tx
->bar_pending
)
173 tid_tx
->bar_pending
= false;
174 ieee80211_send_bar(&sta
->sdata
->vif
, addr
, tid
, tid_tx
->failed_bar_ssn
);
177 static void ieee80211_frame_acked(struct sta_info
*sta
, struct sk_buff
*skb
)
179 struct ieee80211_mgmt
*mgmt
= (void *) skb
->data
;
180 struct ieee80211_local
*local
= sta
->local
;
181 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
183 if (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
)
184 sta
->last_rx
= jiffies
;
186 if (ieee80211_is_data_qos(mgmt
->frame_control
)) {
187 struct ieee80211_hdr
*hdr
= (void *) skb
->data
;
188 u8
*qc
= ieee80211_get_qos_ctl(hdr
);
189 u16 tid
= qc
[0] & 0xf;
191 ieee80211_check_pending_bar(sta
, hdr
->addr1
, tid
);
194 if (ieee80211_is_action(mgmt
->frame_control
) &&
195 mgmt
->u
.action
.category
== WLAN_CATEGORY_HT
&&
196 mgmt
->u
.action
.u
.ht_smps
.action
== WLAN_HT_ACTION_SMPS
&&
197 sdata
->vif
.type
== NL80211_IFTYPE_STATION
&&
198 ieee80211_sdata_running(sdata
)) {
200 * This update looks racy, but isn't -- if we come
201 * here we've definitely got a station that we're
202 * talking to, and on a managed interface that can
203 * only be the AP. And the only other place updating
204 * this variable in managed mode is before association.
206 switch (mgmt
->u
.action
.u
.ht_smps
.smps_control
) {
207 case WLAN_HT_SMPS_CONTROL_DYNAMIC
:
208 sdata
->smps_mode
= IEEE80211_SMPS_DYNAMIC
;
210 case WLAN_HT_SMPS_CONTROL_STATIC
:
211 sdata
->smps_mode
= IEEE80211_SMPS_STATIC
;
213 case WLAN_HT_SMPS_CONTROL_DISABLED
:
214 default: /* shouldn't happen since we don't send that */
215 sdata
->smps_mode
= IEEE80211_SMPS_OFF
;
219 ieee80211_queue_work(&local
->hw
, &sdata
->recalc_smps
);
223 static void ieee80211_set_bar_pending(struct sta_info
*sta
, u8 tid
, u16 ssn
)
225 struct tid_ampdu_tx
*tid_tx
;
227 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
231 tid_tx
->failed_bar_ssn
= ssn
;
232 tid_tx
->bar_pending
= true;
235 static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info
*info
)
237 int len
= sizeof(struct ieee80211_radiotap_header
);
239 /* IEEE80211_RADIOTAP_RATE rate */
240 if (info
->status
.rates
[0].idx
>= 0 &&
241 !(info
->status
.rates
[0].flags
& (IEEE80211_TX_RC_MCS
|
242 IEEE80211_TX_RC_VHT_MCS
)))
245 /* IEEE80211_RADIOTAP_TX_FLAGS */
248 /* IEEE80211_RADIOTAP_DATA_RETRIES */
251 /* IEEE80211_RADIOTAP_MCS
252 * IEEE80211_RADIOTAP_VHT */
253 if (info
->status
.rates
[0].idx
>= 0) {
254 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_MCS
)
256 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_VHT_MCS
)
257 len
= ALIGN(len
, 2) + 12;
264 ieee80211_add_tx_radiotap_header(struct ieee80211_local
*local
,
265 struct ieee80211_supported_band
*sband
,
266 struct sk_buff
*skb
, int retry_count
,
267 int rtap_len
, int shift
)
269 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
270 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
271 struct ieee80211_radiotap_header
*rthdr
;
275 rthdr
= (struct ieee80211_radiotap_header
*) skb_push(skb
, rtap_len
);
277 memset(rthdr
, 0, rtap_len
);
278 rthdr
->it_len
= cpu_to_le16(rtap_len
);
280 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS
) |
281 (1 << IEEE80211_RADIOTAP_DATA_RETRIES
));
282 pos
= (unsigned char *)(rthdr
+ 1);
285 * XXX: Once radiotap gets the bitmap reset thing the vendor
286 * extensions proposal contains, we can actually report
287 * the whole set of tries we did.
290 /* IEEE80211_RADIOTAP_RATE */
291 if (info
->status
.rates
[0].idx
>= 0 &&
292 !(info
->status
.rates
[0].flags
& (IEEE80211_TX_RC_MCS
|
293 IEEE80211_TX_RC_VHT_MCS
))) {
296 rthdr
->it_present
|= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE
);
297 rate
= sband
->bitrates
[info
->status
.rates
[0].idx
].bitrate
;
298 *pos
= DIV_ROUND_UP(rate
, 5 * (1 << shift
));
299 /* padding for tx flags */
303 /* IEEE80211_RADIOTAP_TX_FLAGS */
305 if (!(info
->flags
& IEEE80211_TX_STAT_ACK
) &&
306 !is_multicast_ether_addr(hdr
->addr1
))
307 txflags
|= IEEE80211_RADIOTAP_F_TX_FAIL
;
309 if ((info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
) ||
310 (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
))
311 txflags
|= IEEE80211_RADIOTAP_F_TX_CTS
;
312 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
313 txflags
|= IEEE80211_RADIOTAP_F_TX_RTS
;
315 put_unaligned_le16(txflags
, pos
);
318 /* IEEE80211_RADIOTAP_DATA_RETRIES */
319 /* for now report the total retry_count */
323 if (info
->status
.rates
[0].idx
< 0)
326 /* IEEE80211_RADIOTAP_MCS
327 * IEEE80211_RADIOTAP_VHT */
328 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_MCS
) {
329 rthdr
->it_present
|= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS
);
330 pos
[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS
|
331 IEEE80211_RADIOTAP_MCS_HAVE_GI
|
332 IEEE80211_RADIOTAP_MCS_HAVE_BW
;
333 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_SHORT_GI
)
334 pos
[1] |= IEEE80211_RADIOTAP_MCS_SGI
;
335 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
336 pos
[1] |= IEEE80211_RADIOTAP_MCS_BW_40
;
337 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_GREEN_FIELD
)
338 pos
[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF
;
339 pos
[2] = info
->status
.rates
[0].idx
;
341 } else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_VHT_MCS
) {
342 u16 known
= local
->hw
.radiotap_vht_details
&
343 (IEEE80211_RADIOTAP_VHT_KNOWN_GI
|
344 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH
);
346 rthdr
->it_present
|= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT
);
348 /* required alignment from rthdr */
349 pos
= (u8
*)rthdr
+ ALIGN(pos
- (u8
*)rthdr
, 2);
351 /* u16 known - IEEE80211_RADIOTAP_VHT_KNOWN_* */
352 put_unaligned_le16(known
, pos
);
355 /* u8 flags - IEEE80211_RADIOTAP_VHT_FLAG_* */
356 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_SHORT_GI
)
357 *pos
|= IEEE80211_RADIOTAP_VHT_FLAG_SGI
;
361 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
363 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_80_MHZ_WIDTH
)
365 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_160_MHZ_WIDTH
)
367 else /* IEEE80211_TX_RC_{20_MHZ_WIDTH,FIXME:DUP_DATA} */
372 *pos
= (ieee80211_rate_get_vht_mcs(&info
->status
.rates
[0]) << 4) |
373 ieee80211_rate_get_vht_nss(&info
->status
.rates
[0]);
380 /* u16 partial_aid */
385 static void ieee80211_report_used_skb(struct ieee80211_local
*local
,
386 struct sk_buff
*skb
, bool dropped
)
388 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
389 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
390 bool acked
= info
->flags
& IEEE80211_TX_STAT_ACK
;
395 if (info
->flags
& (IEEE80211_TX_INTFL_NL80211_FRAME_TX
|
396 IEEE80211_TX_INTFL_MLME_CONN_TX
)) {
397 struct ieee80211_sub_if_data
*sdata
= NULL
;
398 struct ieee80211_sub_if_data
*iter_sdata
;
399 u64 cookie
= (unsigned long)skb
;
404 list_for_each_entry_rcu(iter_sdata
, &local
->interfaces
,
406 if (!iter_sdata
->dev
)
409 if (skb
->dev
== iter_sdata
->dev
) {
415 sdata
= rcu_dereference(local
->p2p_sdata
);
420 } else if (info
->flags
& IEEE80211_TX_INTFL_MLME_CONN_TX
) {
421 ieee80211_mgd_conn_tx_status(sdata
, hdr
->frame_control
,
423 } else if (ieee80211_is_nullfunc(hdr
->frame_control
) ||
424 ieee80211_is_qos_nullfunc(hdr
->frame_control
)) {
425 cfg80211_probe_status(sdata
->dev
, hdr
->addr1
,
426 cookie
, acked
, GFP_ATOMIC
);
428 cfg80211_mgmt_tx_status(&sdata
->wdev
, cookie
, skb
->data
,
429 skb
->len
, acked
, GFP_ATOMIC
);
435 if (unlikely(info
->ack_frame_id
)) {
436 struct sk_buff
*ack_skb
;
439 spin_lock_irqsave(&local
->ack_status_lock
, flags
);
440 ack_skb
= idr_find(&local
->ack_status_frames
,
443 idr_remove(&local
->ack_status_frames
,
445 spin_unlock_irqrestore(&local
->ack_status_lock
, flags
);
449 /* consumes ack_skb */
450 skb_complete_wifi_ack(ack_skb
, acked
);
452 dev_kfree_skb_any(ack_skb
);
459 * Use a static threshold for now, best value to be determined
461 * Should it depend on:
462 * - on # of retransmissions
463 * - current throughput (higher value for higher tpt)?
465 #define STA_LOST_PKT_THRESHOLD 50
467 void ieee80211_tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
469 struct sk_buff
*skb2
;
470 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
471 struct ieee80211_local
*local
= hw_to_local(hw
);
472 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
474 struct ieee80211_supported_band
*sband
;
475 struct ieee80211_sub_if_data
*sdata
;
476 struct net_device
*prev_dev
= NULL
;
477 struct sta_info
*sta
, *tmp
;
478 int retry_count
= -1, i
;
482 struct ieee80211_bar
*bar
;
486 for (i
= 0; i
< IEEE80211_TX_MAX_RATES
; i
++) {
487 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
488 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
489 /* just the first aggr frame carry status info */
490 info
->status
.rates
[i
].idx
= -1;
491 info
->status
.rates
[i
].count
= 0;
493 } else if (info
->status
.rates
[i
].idx
< 0) {
495 } else if (i
>= hw
->max_report_rates
) {
496 /* the HW cannot have attempted that rate */
497 info
->status
.rates
[i
].idx
= -1;
498 info
->status
.rates
[i
].count
= 0;
502 retry_count
+= info
->status
.rates
[i
].count
;
511 sband
= local
->hw
.wiphy
->bands
[info
->band
];
512 fc
= hdr
->frame_control
;
514 for_each_sta_info(local
, hdr
->addr1
, sta
, tmp
) {
515 /* skip wrong virtual interface */
516 if (!ether_addr_equal(hdr
->addr2
, sta
->sdata
->vif
.addr
))
519 shift
= ieee80211_vif_get_shift(&sta
->sdata
->vif
);
521 if (info
->flags
& IEEE80211_TX_STATUS_EOSP
)
522 clear_sta_flag(sta
, WLAN_STA_SP
);
524 acked
= !!(info
->flags
& IEEE80211_TX_STAT_ACK
);
525 if (!acked
&& test_sta_flag(sta
, WLAN_STA_PS_STA
)) {
527 * The STA is in power save mode, so assume
528 * that this TX packet failed because of that.
530 ieee80211_handle_filtered_frame(local
, sta
, skb
);
535 /* mesh Peer Service Period support */
536 if (ieee80211_vif_is_mesh(&sta
->sdata
->vif
) &&
537 ieee80211_is_data_qos(fc
))
538 ieee80211_mpsp_trigger_process(
539 ieee80211_get_qos_ctl(hdr
),
542 if ((local
->hw
.flags
& IEEE80211_HW_HAS_RATE_CONTROL
) &&
544 sta
->last_tx_rate
= info
->status
.rates
[rates_idx
];
546 if ((info
->flags
& IEEE80211_TX_STAT_AMPDU_NO_BACK
) &&
547 (ieee80211_is_data_qos(fc
))) {
551 qc
= ieee80211_get_qos_ctl(hdr
);
553 ssn
= ((le16_to_cpu(hdr
->seq_ctrl
) + 0x10)
554 & IEEE80211_SCTL_SEQ
);
555 ieee80211_send_bar(&sta
->sdata
->vif
, hdr
->addr1
,
559 if (!acked
&& ieee80211_is_back_req(fc
)) {
563 * BAR failed, store the last SSN and retry sending
564 * the BAR when the next unicast transmission on the
567 bar
= (struct ieee80211_bar
*) skb
->data
;
568 control
= le16_to_cpu(bar
->control
);
569 if (!(control
& IEEE80211_BAR_CTRL_MULTI_TID
)) {
570 u16 ssn
= le16_to_cpu(bar
->start_seq_num
);
573 IEEE80211_BAR_CTRL_TID_INFO_MASK
) >>
574 IEEE80211_BAR_CTRL_TID_INFO_SHIFT
;
576 ieee80211_set_bar_pending(sta
, tid
, ssn
);
580 if (info
->flags
& IEEE80211_TX_STAT_TX_FILTERED
) {
581 ieee80211_handle_filtered_frame(local
, sta
, skb
);
586 sta
->tx_retry_failed
++;
587 sta
->tx_retry_count
+= retry_count
;
590 rate_control_tx_status(local
, sband
, sta
, skb
);
591 if (ieee80211_vif_is_mesh(&sta
->sdata
->vif
))
592 ieee80211s_update_metric(local
, sta
, skb
);
594 if (!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) && acked
)
595 ieee80211_frame_acked(sta
, skb
);
597 if ((sta
->sdata
->vif
.type
== NL80211_IFTYPE_STATION
) &&
598 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
))
599 ieee80211_sta_tx_notify(sta
->sdata
, (void *) skb
->data
, acked
);
601 if (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) {
602 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
603 if (sta
->lost_packets
)
604 sta
->lost_packets
= 0;
605 } else if (++sta
->lost_packets
>= STA_LOST_PKT_THRESHOLD
) {
606 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
,
610 sta
->lost_packets
= 0;
615 sta
->last_ack_signal
= info
->status
.ack_signal
;
620 ieee80211_led_tx(local
);
623 * Fragments are passed to low-level drivers as separate skbs, so these
624 * are actually fragments, not frames. Update frame counters only for
625 * the first fragment of the frame. */
626 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
627 if (ieee80211_is_first_frag(hdr
->seq_ctrl
)) {
628 local
->dot11TransmittedFrameCount
++;
629 if (is_multicast_ether_addr(hdr
->addr1
))
630 local
->dot11MulticastTransmittedFrameCount
++;
632 local
->dot11RetryCount
++;
634 local
->dot11MultipleRetryCount
++;
637 /* This counter shall be incremented for an acknowledged MPDU
638 * with an individual address in the address 1 field or an MPDU
639 * with a multicast address in the address 1 field of type Data
641 if (!is_multicast_ether_addr(hdr
->addr1
) ||
642 ieee80211_is_data(fc
) ||
643 ieee80211_is_mgmt(fc
))
644 local
->dot11TransmittedFragmentCount
++;
646 if (ieee80211_is_first_frag(hdr
->seq_ctrl
))
647 local
->dot11FailedCount
++;
650 if (ieee80211_is_nullfunc(fc
) && ieee80211_has_pm(fc
) &&
651 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) &&
652 !(info
->flags
& IEEE80211_TX_CTL_INJECTED
) &&
653 local
->ps_sdata
&& !(local
->scanning
)) {
654 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
655 local
->ps_sdata
->u
.mgd
.flags
|=
656 IEEE80211_STA_NULLFUNC_ACKED
;
658 mod_timer(&local
->dynamic_ps_timer
, jiffies
+
659 msecs_to_jiffies(10));
662 ieee80211_report_used_skb(local
, skb
, false);
664 /* this was a transmitted frame, but now we want to reuse it */
667 /* Need to make a copy before skb->cb gets cleared */
668 send_to_cooked
= !!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) ||
669 !(ieee80211_is_data(fc
));
672 * This is a bit racy but we can avoid a lot of work
675 if (!local
->monitors
&& (!send_to_cooked
|| !local
->cooked_mntrs
)) {
680 /* send frame to monitor interfaces now */
681 rtap_len
= ieee80211_tx_radiotap_len(info
);
682 if (WARN_ON_ONCE(skb_headroom(skb
) < rtap_len
)) {
683 pr_err("ieee80211_tx_status: headroom too small\n");
687 ieee80211_add_tx_radiotap_header(local
, sband
, skb
, retry_count
,
690 /* XXX: is this sufficient for BPF? */
691 skb_set_mac_header(skb
, 0);
692 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
693 skb
->pkt_type
= PACKET_OTHERHOST
;
694 skb
->protocol
= htons(ETH_P_802_2
);
695 memset(skb
->cb
, 0, sizeof(skb
->cb
));
698 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
699 if (sdata
->vif
.type
== NL80211_IFTYPE_MONITOR
) {
700 if (!ieee80211_sdata_running(sdata
))
703 if ((sdata
->u
.mntr_flags
& MONITOR_FLAG_COOK_FRAMES
) &&
708 skb2
= skb_clone(skb
, GFP_ATOMIC
);
710 skb2
->dev
= prev_dev
;
715 prev_dev
= sdata
->dev
;
726 EXPORT_SYMBOL(ieee80211_tx_status
);
728 void ieee80211_report_low_ack(struct ieee80211_sta
*pubsta
, u32 num_packets
)
730 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
731 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
, sta
->sta
.addr
,
732 num_packets
, GFP_ATOMIC
);
734 EXPORT_SYMBOL(ieee80211_report_low_ack
);
736 void ieee80211_free_txskb(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
738 struct ieee80211_local
*local
= hw_to_local(hw
);
740 ieee80211_report_used_skb(local
, skb
, true);
741 dev_kfree_skb_any(skb
);
743 EXPORT_SYMBOL(ieee80211_free_txskb
);
745 void ieee80211_purge_tx_queue(struct ieee80211_hw
*hw
,
746 struct sk_buff_head
*skbs
)
750 while ((skb
= __skb_dequeue(skbs
)))
751 ieee80211_free_txskb(hw
, skb
);