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 <linux/time.h>
15 #include <net/mac80211.h>
16 #include <asm/unaligned.h>
17 #include "ieee80211_i.h"
24 void ieee80211_tx_status_irqsafe(struct ieee80211_hw
*hw
,
27 struct ieee80211_local
*local
= hw_to_local(hw
);
28 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
31 skb
->pkt_type
= IEEE80211_TX_STATUS_MSG
;
32 skb_queue_tail(info
->flags
& IEEE80211_TX_CTL_REQ_TX_STATUS
?
33 &local
->skb_queue
: &local
->skb_queue_unreliable
, skb
);
34 tmp
= skb_queue_len(&local
->skb_queue
) +
35 skb_queue_len(&local
->skb_queue_unreliable
);
36 while (tmp
> IEEE80211_IRQSAFE_QUEUE_LIMIT
&&
37 (skb
= skb_dequeue(&local
->skb_queue_unreliable
))) {
38 ieee80211_free_txskb(hw
, skb
);
40 I802_DEBUG_INC(local
->tx_status_drop
);
42 tasklet_schedule(&local
->tasklet
);
44 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe
);
46 static void ieee80211_handle_filtered_frame(struct ieee80211_local
*local
,
50 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
51 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
55 * This skb 'survived' a round-trip through the driver, and
56 * hopefully the driver didn't mangle it too badly. However,
57 * we can definitely not rely on the control information
58 * being correct. Clear it so we don't get junk there, and
59 * indicate that it needs new processing, but must not be
60 * modified/encrypted again.
62 memset(&info
->control
, 0, sizeof(info
->control
));
64 info
->control
.jiffies
= jiffies
;
65 info
->control
.vif
= &sta
->sdata
->vif
;
66 info
->flags
|= IEEE80211_TX_INTFL_NEED_TXPROCESSING
|
67 IEEE80211_TX_INTFL_RETRANSMISSION
;
68 info
->flags
&= ~IEEE80211_TX_TEMPORARY_FLAGS
;
70 sta
->tx_filtered_count
++;
73 * Clear more-data bit on filtered frames, it might be set
74 * but later frames might time out so it might have to be
75 * clear again ... It's all rather unlikely (this frame
76 * should time out first, right?) but let's not confuse
77 * peers unnecessarily.
79 if (hdr
->frame_control
& cpu_to_le16(IEEE80211_FCTL_MOREDATA
))
80 hdr
->frame_control
&= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
82 if (ieee80211_is_data_qos(hdr
->frame_control
)) {
83 u8
*p
= ieee80211_get_qos_ctl(hdr
);
84 int tid
= *p
& IEEE80211_QOS_CTL_TID_MASK
;
87 * Clear EOSP if set, this could happen e.g.
88 * if an absence period (us being a P2P GO)
91 if (*p
& IEEE80211_QOS_CTL_EOSP
)
92 *p
&= ~IEEE80211_QOS_CTL_EOSP
;
93 ac
= ieee802_1d_to_ac
[tid
& 7];
99 * Clear the TX filter mask for this STA when sending the next
100 * packet. If the STA went to power save mode, this will happen
101 * when it wakes up for the next time.
103 set_sta_flag(sta
, WLAN_STA_CLEAR_PS_FILT
);
106 * This code races in the following way:
108 * (1) STA sends frame indicating it will go to sleep and does so
109 * (2) hardware/firmware adds STA to filter list, passes frame up
110 * (3) hardware/firmware processes TX fifo and suppresses a frame
111 * (4) we get TX status before having processed the frame and
112 * knowing that the STA has gone to sleep.
114 * This is actually quite unlikely even when both those events are
115 * processed from interrupts coming in quickly after one another or
116 * even at the same time because we queue both TX status events and
117 * RX frames to be processed by a tasklet and process them in the
118 * same order that they were received or TX status last. Hence, there
119 * is no race as long as the frame RX is processed before the next TX
120 * status, which drivers can ensure, see below.
122 * Note that this can only happen if the hardware or firmware can
123 * actually add STAs to the filter list, if this is done by the
124 * driver in response to set_tim() (which will only reduce the race
125 * this whole filtering tries to solve, not completely solve it)
126 * this situation cannot happen.
128 * To completely solve this race drivers need to make sure that they
129 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
131 * (b) always process RX events before TX status events if ordering
132 * can be unknown, for example with different interrupt status
134 * (c) if PS mode transitions are manual (i.e. the flag
135 * %IEEE80211_HW_AP_LINK_PS is set), always process PS state
136 * changes before calling TX status events if ordering can be
139 if (test_sta_flag(sta
, WLAN_STA_PS_STA
) &&
140 skb_queue_len(&sta
->tx_filtered
[ac
]) < STA_MAX_TX_BUFFER
) {
141 skb_queue_tail(&sta
->tx_filtered
[ac
], skb
);
142 sta_info_recalc_tim(sta
);
144 if (!timer_pending(&local
->sta_cleanup
))
145 mod_timer(&local
->sta_cleanup
,
146 round_jiffies(jiffies
+
147 STA_INFO_CLEANUP_INTERVAL
));
151 if (!test_sta_flag(sta
, WLAN_STA_PS_STA
) &&
152 !(info
->flags
& IEEE80211_TX_INTFL_RETRIED
)) {
153 /* Software retry the packet once */
154 info
->flags
|= IEEE80211_TX_INTFL_RETRIED
;
155 ieee80211_add_pending_skb(local
, skb
);
159 ps_dbg_ratelimited(sta
->sdata
,
160 "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
161 skb_queue_len(&sta
->tx_filtered
[ac
]),
162 !!test_sta_flag(sta
, WLAN_STA_PS_STA
), jiffies
);
163 ieee80211_free_txskb(&local
->hw
, skb
);
166 static void ieee80211_check_pending_bar(struct sta_info
*sta
, u8
*addr
, u8 tid
)
168 struct tid_ampdu_tx
*tid_tx
;
170 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
171 if (!tid_tx
|| !tid_tx
->bar_pending
)
174 tid_tx
->bar_pending
= false;
175 ieee80211_send_bar(&sta
->sdata
->vif
, addr
, tid
, tid_tx
->failed_bar_ssn
);
178 static void ieee80211_frame_acked(struct sta_info
*sta
, struct sk_buff
*skb
)
180 struct ieee80211_mgmt
*mgmt
= (void *) skb
->data
;
181 struct ieee80211_local
*local
= sta
->local
;
182 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
184 if (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
)
185 sta
->last_rx
= jiffies
;
187 if (ieee80211_is_data_qos(mgmt
->frame_control
)) {
188 struct ieee80211_hdr
*hdr
= (void *) skb
->data
;
189 u8
*qc
= ieee80211_get_qos_ctl(hdr
);
190 u16 tid
= qc
[0] & 0xf;
192 ieee80211_check_pending_bar(sta
, hdr
->addr1
, tid
);
195 if (ieee80211_is_action(mgmt
->frame_control
) &&
196 mgmt
->u
.action
.category
== WLAN_CATEGORY_HT
&&
197 mgmt
->u
.action
.u
.ht_smps
.action
== WLAN_HT_ACTION_SMPS
&&
198 ieee80211_sdata_running(sdata
)) {
199 enum ieee80211_smps_mode smps_mode
;
201 switch (mgmt
->u
.action
.u
.ht_smps
.smps_control
) {
202 case WLAN_HT_SMPS_CONTROL_DYNAMIC
:
203 smps_mode
= IEEE80211_SMPS_DYNAMIC
;
205 case WLAN_HT_SMPS_CONTROL_STATIC
:
206 smps_mode
= IEEE80211_SMPS_STATIC
;
208 case WLAN_HT_SMPS_CONTROL_DISABLED
:
209 default: /* shouldn't happen since we don't send that */
210 smps_mode
= IEEE80211_SMPS_OFF
;
214 if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
) {
216 * This update looks racy, but isn't -- if we come
217 * here we've definitely got a station that we're
218 * talking to, and on a managed interface that can
219 * only be the AP. And the only other place updating
220 * this variable in managed mode is before association.
222 sdata
->smps_mode
= smps_mode
;
223 ieee80211_queue_work(&local
->hw
, &sdata
->recalc_smps
);
224 } else if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
225 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
) {
226 sta
->known_smps_mode
= smps_mode
;
231 static void ieee80211_set_bar_pending(struct sta_info
*sta
, u8 tid
, u16 ssn
)
233 struct tid_ampdu_tx
*tid_tx
;
235 tid_tx
= rcu_dereference(sta
->ampdu_mlme
.tid_tx
[tid
]);
239 tid_tx
->failed_bar_ssn
= ssn
;
240 tid_tx
->bar_pending
= true;
243 static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info
*info
)
245 int len
= sizeof(struct ieee80211_radiotap_header
);
247 /* IEEE80211_RADIOTAP_RATE rate */
248 if (info
->status
.rates
[0].idx
>= 0 &&
249 !(info
->status
.rates
[0].flags
& (IEEE80211_TX_RC_MCS
|
250 IEEE80211_TX_RC_VHT_MCS
)))
253 /* IEEE80211_RADIOTAP_TX_FLAGS */
256 /* IEEE80211_RADIOTAP_DATA_RETRIES */
259 /* IEEE80211_RADIOTAP_MCS
260 * IEEE80211_RADIOTAP_VHT */
261 if (info
->status
.rates
[0].idx
>= 0) {
262 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_MCS
)
264 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_VHT_MCS
)
265 len
= ALIGN(len
, 2) + 12;
272 ieee80211_add_tx_radiotap_header(struct ieee80211_local
*local
,
273 struct ieee80211_supported_band
*sband
,
274 struct sk_buff
*skb
, int retry_count
,
275 int rtap_len
, int shift
)
277 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
278 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
279 struct ieee80211_radiotap_header
*rthdr
;
283 rthdr
= (struct ieee80211_radiotap_header
*) skb_push(skb
, rtap_len
);
285 memset(rthdr
, 0, rtap_len
);
286 rthdr
->it_len
= cpu_to_le16(rtap_len
);
288 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS
) |
289 (1 << IEEE80211_RADIOTAP_DATA_RETRIES
));
290 pos
= (unsigned char *)(rthdr
+ 1);
293 * XXX: Once radiotap gets the bitmap reset thing the vendor
294 * extensions proposal contains, we can actually report
295 * the whole set of tries we did.
298 /* IEEE80211_RADIOTAP_RATE */
299 if (info
->status
.rates
[0].idx
>= 0 &&
300 !(info
->status
.rates
[0].flags
& (IEEE80211_TX_RC_MCS
|
301 IEEE80211_TX_RC_VHT_MCS
))) {
304 rthdr
->it_present
|= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE
);
305 rate
= sband
->bitrates
[info
->status
.rates
[0].idx
].bitrate
;
306 *pos
= DIV_ROUND_UP(rate
, 5 * (1 << shift
));
307 /* padding for tx flags */
311 /* IEEE80211_RADIOTAP_TX_FLAGS */
313 if (!(info
->flags
& IEEE80211_TX_STAT_ACK
) &&
314 !is_multicast_ether_addr(hdr
->addr1
))
315 txflags
|= IEEE80211_RADIOTAP_F_TX_FAIL
;
317 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
)
318 txflags
|= IEEE80211_RADIOTAP_F_TX_CTS
;
319 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
320 txflags
|= IEEE80211_RADIOTAP_F_TX_RTS
;
322 put_unaligned_le16(txflags
, pos
);
325 /* IEEE80211_RADIOTAP_DATA_RETRIES */
326 /* for now report the total retry_count */
330 if (info
->status
.rates
[0].idx
< 0)
333 /* IEEE80211_RADIOTAP_MCS
334 * IEEE80211_RADIOTAP_VHT */
335 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_MCS
) {
336 rthdr
->it_present
|= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS
);
337 pos
[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS
|
338 IEEE80211_RADIOTAP_MCS_HAVE_GI
|
339 IEEE80211_RADIOTAP_MCS_HAVE_BW
;
340 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_SHORT_GI
)
341 pos
[1] |= IEEE80211_RADIOTAP_MCS_SGI
;
342 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
343 pos
[1] |= IEEE80211_RADIOTAP_MCS_BW_40
;
344 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_GREEN_FIELD
)
345 pos
[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF
;
346 pos
[2] = info
->status
.rates
[0].idx
;
348 } else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_VHT_MCS
) {
349 u16 known
= local
->hw
.radiotap_vht_details
&
350 (IEEE80211_RADIOTAP_VHT_KNOWN_GI
|
351 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH
);
353 rthdr
->it_present
|= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT
);
355 /* required alignment from rthdr */
356 pos
= (u8
*)rthdr
+ ALIGN(pos
- (u8
*)rthdr
, 2);
358 /* u16 known - IEEE80211_RADIOTAP_VHT_KNOWN_* */
359 put_unaligned_le16(known
, pos
);
362 /* u8 flags - IEEE80211_RADIOTAP_VHT_FLAG_* */
363 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_SHORT_GI
)
364 *pos
|= IEEE80211_RADIOTAP_VHT_FLAG_SGI
;
368 if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
370 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_80_MHZ_WIDTH
)
372 else if (info
->status
.rates
[0].flags
& IEEE80211_TX_RC_160_MHZ_WIDTH
)
374 else /* IEEE80211_TX_RC_{20_MHZ_WIDTH,FIXME:DUP_DATA} */
379 *pos
= (ieee80211_rate_get_vht_mcs(&info
->status
.rates
[0]) << 4) |
380 ieee80211_rate_get_vht_nss(&info
->status
.rates
[0]);
387 /* u16 partial_aid */
392 static void ieee80211_report_used_skb(struct ieee80211_local
*local
,
393 struct sk_buff
*skb
, bool dropped
)
395 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
396 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
397 bool acked
= info
->flags
& IEEE80211_TX_STAT_ACK
;
402 if (info
->flags
& (IEEE80211_TX_INTFL_NL80211_FRAME_TX
|
403 IEEE80211_TX_INTFL_MLME_CONN_TX
)) {
404 struct ieee80211_sub_if_data
*sdata
= NULL
;
405 struct ieee80211_sub_if_data
*iter_sdata
;
406 u64 cookie
= (unsigned long)skb
;
411 list_for_each_entry_rcu(iter_sdata
, &local
->interfaces
,
413 if (!iter_sdata
->dev
)
416 if (skb
->dev
== iter_sdata
->dev
) {
422 sdata
= rcu_dereference(local
->p2p_sdata
);
427 } else if (info
->flags
& IEEE80211_TX_INTFL_MLME_CONN_TX
) {
428 ieee80211_mgd_conn_tx_status(sdata
, hdr
->frame_control
,
430 } else if (ieee80211_is_nullfunc(hdr
->frame_control
) ||
431 ieee80211_is_qos_nullfunc(hdr
->frame_control
)) {
432 cfg80211_probe_status(sdata
->dev
, hdr
->addr1
,
433 cookie
, acked
, GFP_ATOMIC
);
435 cfg80211_mgmt_tx_status(&sdata
->wdev
, cookie
, skb
->data
,
436 skb
->len
, acked
, GFP_ATOMIC
);
442 if (unlikely(info
->ack_frame_id
)) {
443 struct sk_buff
*ack_skb
;
446 spin_lock_irqsave(&local
->ack_status_lock
, flags
);
447 ack_skb
= idr_find(&local
->ack_status_frames
,
450 idr_remove(&local
->ack_status_frames
,
452 spin_unlock_irqrestore(&local
->ack_status_lock
, flags
);
456 /* consumes ack_skb */
457 skb_complete_wifi_ack(ack_skb
, acked
);
459 dev_kfree_skb_any(ack_skb
);
466 * Measure Tx frame completion and removal time for Tx latency statistics
467 * calculation. A single Tx frame latency should be measured from when it
468 * is entering the Kernel until we receive Tx complete confirmation indication
469 * and remove the skb.
471 static void ieee80211_tx_latency_end_msrmnt(struct ieee80211_local
*local
,
473 struct sta_info
*sta
,
474 struct ieee80211_hdr
*hdr
)
479 int i
, bin_range_count
;
482 struct ieee80211_tx_latency_stat
*tx_lat
;
483 struct ieee80211_tx_latency_bin_ranges
*tx_latency
;
484 ktime_t skb_arv
= skb
->tstamp
;
486 tx_latency
= rcu_dereference(local
->tx_latency
);
488 /* assert Tx latency stats are enabled & frame arrived when enabled */
489 if (!tx_latency
|| !ktime_to_ns(skb_arv
))
492 fc
= hdr
->frame_control
;
494 if (!ieee80211_is_data(fc
)) /* make sure it is a data frame */
498 if (ieee80211_is_data_qos(hdr
->frame_control
)) {
499 qc
= ieee80211_get_qos_ctl(hdr
);
500 tid
= qc
[0] & IEEE80211_QOS_CTL_TID_MASK
;
505 tx_lat
= &sta
->tx_lat
[tid
];
507 /* Calculate the latency */
508 msrmnt
= ktime_to_ms(ktime_sub(ktime_get(), skb_arv
));
510 if (tx_lat
->max
< msrmnt
) /* update stats */
511 tx_lat
->max
= msrmnt
;
513 tx_lat
->sum
+= msrmnt
;
515 if (!tx_lat
->bins
) /* bins not activated */
518 /* count how many Tx frames transmitted with the appropriate latency */
519 bin_range_count
= tx_latency
->n_ranges
;
520 bin_ranges
= tx_latency
->ranges
;
522 for (i
= 0; i
< bin_range_count
; i
++) {
523 if (msrmnt
<= bin_ranges
[i
]) {
528 if (i
== bin_range_count
) /* msrmnt is bigger than the biggest range */
533 * Use a static threshold for now, best value to be determined
535 * Should it depend on:
536 * - on # of retransmissions
537 * - current throughput (higher value for higher tpt)?
539 #define STA_LOST_PKT_THRESHOLD 50
541 static void ieee80211_lost_packet(struct sta_info
*sta
, struct sk_buff
*skb
)
543 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
545 /* This packet was aggregated but doesn't carry status info */
546 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
547 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
550 if (++sta
->lost_packets
< STA_LOST_PKT_THRESHOLD
)
553 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
, sta
->sta
.addr
,
554 sta
->lost_packets
, GFP_ATOMIC
);
555 sta
->lost_packets
= 0;
558 void ieee80211_tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
560 struct sk_buff
*skb2
;
561 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
562 struct ieee80211_local
*local
= hw_to_local(hw
);
563 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
565 struct ieee80211_supported_band
*sband
;
566 struct ieee80211_sub_if_data
*sdata
;
567 struct net_device
*prev_dev
= NULL
;
568 struct sta_info
*sta
, *tmp
;
569 int retry_count
= -1, i
;
573 struct ieee80211_bar
*bar
;
577 for (i
= 0; i
< IEEE80211_TX_MAX_RATES
; i
++) {
578 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
579 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
580 /* just the first aggr frame carry status info */
581 info
->status
.rates
[i
].idx
= -1;
582 info
->status
.rates
[i
].count
= 0;
584 } else if (info
->status
.rates
[i
].idx
< 0) {
586 } else if (i
>= hw
->max_report_rates
) {
587 /* the HW cannot have attempted that rate */
588 info
->status
.rates
[i
].idx
= -1;
589 info
->status
.rates
[i
].count
= 0;
593 retry_count
+= info
->status
.rates
[i
].count
;
602 sband
= local
->hw
.wiphy
->bands
[info
->band
];
603 fc
= hdr
->frame_control
;
605 for_each_sta_info(local
, hdr
->addr1
, sta
, tmp
) {
606 /* skip wrong virtual interface */
607 if (!ether_addr_equal(hdr
->addr2
, sta
->sdata
->vif
.addr
))
610 shift
= ieee80211_vif_get_shift(&sta
->sdata
->vif
);
612 if (info
->flags
& IEEE80211_TX_STATUS_EOSP
)
613 clear_sta_flag(sta
, WLAN_STA_SP
);
615 acked
= !!(info
->flags
& IEEE80211_TX_STAT_ACK
);
616 if (!acked
&& test_sta_flag(sta
, WLAN_STA_PS_STA
)) {
618 * The STA is in power save mode, so assume
619 * that this TX packet failed because of that.
621 ieee80211_handle_filtered_frame(local
, sta
, skb
);
626 /* mesh Peer Service Period support */
627 if (ieee80211_vif_is_mesh(&sta
->sdata
->vif
) &&
628 ieee80211_is_data_qos(fc
))
629 ieee80211_mpsp_trigger_process(
630 ieee80211_get_qos_ctl(hdr
),
633 if ((local
->hw
.flags
& IEEE80211_HW_HAS_RATE_CONTROL
) &&
634 (ieee80211_is_data(hdr
->frame_control
)) &&
636 sta
->last_tx_rate
= info
->status
.rates
[rates_idx
];
638 if ((info
->flags
& IEEE80211_TX_STAT_AMPDU_NO_BACK
) &&
639 (ieee80211_is_data_qos(fc
))) {
643 qc
= ieee80211_get_qos_ctl(hdr
);
645 ssn
= ((le16_to_cpu(hdr
->seq_ctrl
) + 0x10)
646 & IEEE80211_SCTL_SEQ
);
647 ieee80211_send_bar(&sta
->sdata
->vif
, hdr
->addr1
,
651 if (!acked
&& ieee80211_is_back_req(fc
)) {
655 * BAR failed, store the last SSN and retry sending
656 * the BAR when the next unicast transmission on the
659 bar
= (struct ieee80211_bar
*) skb
->data
;
660 control
= le16_to_cpu(bar
->control
);
661 if (!(control
& IEEE80211_BAR_CTRL_MULTI_TID
)) {
662 u16 ssn
= le16_to_cpu(bar
->start_seq_num
);
665 IEEE80211_BAR_CTRL_TID_INFO_MASK
) >>
666 IEEE80211_BAR_CTRL_TID_INFO_SHIFT
;
668 ieee80211_set_bar_pending(sta
, tid
, ssn
);
672 if (info
->flags
& IEEE80211_TX_STAT_TX_FILTERED
) {
673 ieee80211_handle_filtered_frame(local
, sta
, skb
);
678 sta
->tx_retry_failed
++;
679 sta
->tx_retry_count
+= retry_count
;
682 rate_control_tx_status(local
, sband
, sta
, skb
);
683 if (ieee80211_vif_is_mesh(&sta
->sdata
->vif
))
684 ieee80211s_update_metric(local
, sta
, skb
);
686 if (!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) && acked
)
687 ieee80211_frame_acked(sta
, skb
);
689 if ((sta
->sdata
->vif
.type
== NL80211_IFTYPE_STATION
) &&
690 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
))
691 ieee80211_sta_tx_notify(sta
->sdata
, (void *) skb
->data
, acked
);
693 if (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) {
694 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
695 if (sta
->lost_packets
)
696 sta
->lost_packets
= 0;
698 ieee80211_lost_packet(sta
, skb
);
703 sta
->last_ack_signal
= info
->status
.ack_signal
;
706 * Measure frame removal for tx latency
707 * statistics calculation
709 ieee80211_tx_latency_end_msrmnt(local
, skb
, sta
, hdr
);
714 ieee80211_led_tx(local
);
717 * Fragments are passed to low-level drivers as separate skbs, so these
718 * are actually fragments, not frames. Update frame counters only for
719 * the first fragment of the frame. */
720 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
721 if (ieee80211_is_first_frag(hdr
->seq_ctrl
)) {
722 local
->dot11TransmittedFrameCount
++;
723 if (is_multicast_ether_addr(hdr
->addr1
))
724 local
->dot11MulticastTransmittedFrameCount
++;
726 local
->dot11RetryCount
++;
728 local
->dot11MultipleRetryCount
++;
731 /* This counter shall be incremented for an acknowledged MPDU
732 * with an individual address in the address 1 field or an MPDU
733 * with a multicast address in the address 1 field of type Data
735 if (!is_multicast_ether_addr(hdr
->addr1
) ||
736 ieee80211_is_data(fc
) ||
737 ieee80211_is_mgmt(fc
))
738 local
->dot11TransmittedFragmentCount
++;
740 if (ieee80211_is_first_frag(hdr
->seq_ctrl
))
741 local
->dot11FailedCount
++;
744 if (ieee80211_is_nullfunc(fc
) && ieee80211_has_pm(fc
) &&
745 (local
->hw
.flags
& IEEE80211_HW_REPORTS_TX_ACK_STATUS
) &&
746 !(info
->flags
& IEEE80211_TX_CTL_INJECTED
) &&
747 local
->ps_sdata
&& !(local
->scanning
)) {
748 if (info
->flags
& IEEE80211_TX_STAT_ACK
) {
749 local
->ps_sdata
->u
.mgd
.flags
|=
750 IEEE80211_STA_NULLFUNC_ACKED
;
752 mod_timer(&local
->dynamic_ps_timer
, jiffies
+
753 msecs_to_jiffies(10));
756 ieee80211_report_used_skb(local
, skb
, false);
758 /* this was a transmitted frame, but now we want to reuse it */
761 /* Need to make a copy before skb->cb gets cleared */
762 send_to_cooked
= !!(info
->flags
& IEEE80211_TX_CTL_INJECTED
) ||
763 !(ieee80211_is_data(fc
));
766 * This is a bit racy but we can avoid a lot of work
769 if (!local
->monitors
&& (!send_to_cooked
|| !local
->cooked_mntrs
)) {
774 /* send frame to monitor interfaces now */
775 rtap_len
= ieee80211_tx_radiotap_len(info
);
776 if (WARN_ON_ONCE(skb_headroom(skb
) < rtap_len
)) {
777 pr_err("ieee80211_tx_status: headroom too small\n");
781 ieee80211_add_tx_radiotap_header(local
, sband
, skb
, retry_count
,
784 /* XXX: is this sufficient for BPF? */
785 skb_set_mac_header(skb
, 0);
786 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
787 skb
->pkt_type
= PACKET_OTHERHOST
;
788 skb
->protocol
= htons(ETH_P_802_2
);
789 memset(skb
->cb
, 0, sizeof(skb
->cb
));
792 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
793 if (sdata
->vif
.type
== NL80211_IFTYPE_MONITOR
) {
794 if (!ieee80211_sdata_running(sdata
))
797 if ((sdata
->u
.mntr_flags
& MONITOR_FLAG_COOK_FRAMES
) &&
802 skb2
= skb_clone(skb
, GFP_ATOMIC
);
804 skb2
->dev
= prev_dev
;
809 prev_dev
= sdata
->dev
;
820 EXPORT_SYMBOL(ieee80211_tx_status
);
822 void ieee80211_report_low_ack(struct ieee80211_sta
*pubsta
, u32 num_packets
)
824 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
825 cfg80211_cqm_pktloss_notify(sta
->sdata
->dev
, sta
->sta
.addr
,
826 num_packets
, GFP_ATOMIC
);
828 EXPORT_SYMBOL(ieee80211_report_low_ack
);
830 void ieee80211_free_txskb(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
832 struct ieee80211_local
*local
= hw_to_local(hw
);
834 ieee80211_report_used_skb(local
, skb
, true);
835 dev_kfree_skb_any(skb
);
837 EXPORT_SYMBOL(ieee80211_free_txskb
);
839 void ieee80211_purge_tx_queue(struct ieee80211_hw
*hw
,
840 struct sk_buff_head
*skbs
)
844 while ((skb
= __skb_dequeue(skbs
)))
845 ieee80211_free_txskb(hw
, skb
);