1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/export.h>
14#include <linux/etherdevice.h>
15#include <net/mac80211.h>
16#include <asm/unaligned.h>
17#include "ieee80211_i.h"
18#include "rate.h"
19#include "mesh.h"
20#include "led.h"
21#include "wme.h"
22
23
24void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
25 struct sk_buff *skb)
26{
27 struct ieee80211_local *local = hw_to_local(hw);
28 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
29 int tmp;
30
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);
39 tmp--;
40 I802_DEBUG_INC(local->tx_status_drop);
41 }
42 tasklet_schedule(&local->tasklet);
43}
44EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
45
46static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
47 struct sta_info *sta,
48 struct sk_buff *skb)
49{
50 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
51 struct ieee80211_hdr *hdr = (void *)skb->data;
52 int ac;
53
54
55
56
57
58
59
60
61
62 memset(&info->control, 0, sizeof(info->control));
63
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;
69
70 sta->status_stats.filtered++;
71
72
73
74
75
76
77
78
79 if (hdr->frame_control & cpu_to_le16(IEEE80211_FCTL_MOREDATA))
80 hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA);
81
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;
85
86
87
88
89
90
91 if (*p & IEEE80211_QOS_CTL_EOSP)
92 *p &= ~IEEE80211_QOS_CTL_EOSP;
93 ac = ieee802_1d_to_ac[tid & 7];
94 } else {
95 ac = IEEE80211_AC_BE;
96 }
97
98
99
100
101
102
103 set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);
104 ieee80211_clear_fast_xmit(sta);
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140 if (test_sta_flag(sta, WLAN_STA_PS_STA) &&
141 skb_queue_len(&sta->tx_filtered[ac]) < STA_MAX_TX_BUFFER) {
142 skb_queue_tail(&sta->tx_filtered[ac], skb);
143 sta_info_recalc_tim(sta);
144
145 if (!timer_pending(&local->sta_cleanup))
146 mod_timer(&local->sta_cleanup,
147 round_jiffies(jiffies +
148 STA_INFO_CLEANUP_INTERVAL));
149 return;
150 }
151
152 if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
153 !(info->flags & IEEE80211_TX_INTFL_RETRIED)) {
154
155 info->flags |= IEEE80211_TX_INTFL_RETRIED;
156 ieee80211_add_pending_skb(local, skb);
157 return;
158 }
159
160 ps_dbg_ratelimited(sta->sdata,
161 "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
162 skb_queue_len(&sta->tx_filtered[ac]),
163 !!test_sta_flag(sta, WLAN_STA_PS_STA), jiffies);
164 ieee80211_free_txskb(&local->hw, skb);
165}
166
167static void ieee80211_check_pending_bar(struct sta_info *sta, u8 *addr, u8 tid)
168{
169 struct tid_ampdu_tx *tid_tx;
170
171 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
172 if (!tid_tx || !tid_tx->bar_pending)
173 return;
174
175 tid_tx->bar_pending = false;
176 ieee80211_send_bar(&sta->sdata->vif, addr, tid, tid_tx->failed_bar_ssn);
177}
178
179static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
180{
181 struct ieee80211_mgmt *mgmt = (void *) skb->data;
182 struct ieee80211_local *local = sta->local;
183 struct ieee80211_sub_if_data *sdata = sta->sdata;
184
185 if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS))
186 sta->rx_stats.last_rx = jiffies;
187
188 if (ieee80211_is_data_qos(mgmt->frame_control)) {
189 struct ieee80211_hdr *hdr = (void *) skb->data;
190 u8 *qc = ieee80211_get_qos_ctl(hdr);
191 u16 tid = qc[0] & 0xf;
192
193 ieee80211_check_pending_bar(sta, hdr->addr1, tid);
194 }
195
196 if (ieee80211_is_action(mgmt->frame_control) &&
197 mgmt->u.action.category == WLAN_CATEGORY_HT &&
198 mgmt->u.action.u.ht_smps.action == WLAN_HT_ACTION_SMPS &&
199 ieee80211_sdata_running(sdata)) {
200 enum ieee80211_smps_mode smps_mode;
201
202 switch (mgmt->u.action.u.ht_smps.smps_control) {
203 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
204 smps_mode = IEEE80211_SMPS_DYNAMIC;
205 break;
206 case WLAN_HT_SMPS_CONTROL_STATIC:
207 smps_mode = IEEE80211_SMPS_STATIC;
208 break;
209 case WLAN_HT_SMPS_CONTROL_DISABLED:
210 default:
211 smps_mode = IEEE80211_SMPS_OFF;
212 break;
213 }
214
215 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
216
217
218
219
220
221
222
223 sdata->smps_mode = smps_mode;
224 ieee80211_queue_work(&local->hw, &sdata->recalc_smps);
225 } else if (sdata->vif.type == NL80211_IFTYPE_AP ||
226 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
227 sta->known_smps_mode = smps_mode;
228 }
229 }
230}
231
232static void ieee80211_set_bar_pending(struct sta_info *sta, u8 tid, u16 ssn)
233{
234 struct tid_ampdu_tx *tid_tx;
235
236 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
237 if (!tid_tx)
238 return;
239
240 tid_tx->failed_bar_ssn = ssn;
241 tid_tx->bar_pending = true;
242}
243
244static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info *info)
245{
246 int len = sizeof(struct ieee80211_radiotap_header);
247
248
249 if (info->status.rates[0].idx >= 0 &&
250 !(info->status.rates[0].flags & (IEEE80211_TX_RC_MCS |
251 IEEE80211_TX_RC_VHT_MCS)))
252 len += 2;
253
254
255 len += 2;
256
257
258 len += 1;
259
260
261
262 if (info->status.rates[0].idx >= 0) {
263 if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS)
264 len += 3;
265 else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS)
266 len = ALIGN(len, 2) + 12;
267 }
268
269 return len;
270}
271
272static void
273ieee80211_add_tx_radiotap_header(struct ieee80211_local *local,
274 struct ieee80211_supported_band *sband,
275 struct sk_buff *skb, int retry_count,
276 int rtap_len, int shift)
277{
278 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
279 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
280 struct ieee80211_radiotap_header *rthdr;
281 unsigned char *pos;
282 u16 txflags;
283
284 rthdr = (struct ieee80211_radiotap_header *) skb_push(skb, rtap_len);
285
286 memset(rthdr, 0, rtap_len);
287 rthdr->it_len = cpu_to_le16(rtap_len);
288 rthdr->it_present =
289 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
290 (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
291 pos = (unsigned char *)(rthdr + 1);
292
293
294
295
296
297
298
299
300 if (info->status.rates[0].idx >= 0 &&
301 !(info->status.rates[0].flags & (IEEE80211_TX_RC_MCS |
302 IEEE80211_TX_RC_VHT_MCS))) {
303 u16 rate;
304
305 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
306 rate = sband->bitrates[info->status.rates[0].idx].bitrate;
307 *pos = DIV_ROUND_UP(rate, 5 * (1 << shift));
308
309 pos += 2;
310 }
311
312
313 txflags = 0;
314 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
315 !is_multicast_ether_addr(hdr->addr1))
316 txflags |= IEEE80211_RADIOTAP_F_TX_FAIL;
317
318 if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
319 txflags |= IEEE80211_RADIOTAP_F_TX_CTS;
320 if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
321 txflags |= IEEE80211_RADIOTAP_F_TX_RTS;
322
323 put_unaligned_le16(txflags, pos);
324 pos += 2;
325
326
327
328 *pos = retry_count;
329 pos++;
330
331 if (info->status.rates[0].idx < 0)
332 return;
333
334
335
336 if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
337 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
338 pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
339 IEEE80211_RADIOTAP_MCS_HAVE_GI |
340 IEEE80211_RADIOTAP_MCS_HAVE_BW;
341 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
342 pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
343 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
344 pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
345 if (info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)
346 pos[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF;
347 pos[2] = info->status.rates[0].idx;
348 pos += 3;
349 } else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
350 u16 known = local->hw.radiotap_vht_details &
351 (IEEE80211_RADIOTAP_VHT_KNOWN_GI |
352 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
353
354 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT);
355
356
357 pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
358
359
360 put_unaligned_le16(known, pos);
361 pos += 2;
362
363
364 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
365 *pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
366 pos++;
367
368
369 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
370 *pos = 1;
371 else if (info->status.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
372 *pos = 4;
373 else if (info->status.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
374 *pos = 11;
375 else
376 *pos = 0;
377 pos++;
378
379
380 *pos = (ieee80211_rate_get_vht_mcs(&info->status.rates[0]) << 4) |
381 ieee80211_rate_get_vht_nss(&info->status.rates[0]);
382 pos += 4;
383
384
385 pos++;
386
387 pos++;
388
389 pos += 2;
390 }
391}
392
393
394
395
396
397static void ieee80211_tdls_td_tx_handle(struct ieee80211_local *local,
398 struct ieee80211_sub_if_data *sdata,
399 struct sk_buff *skb, u32 flags)
400{
401 struct sk_buff *teardown_skb;
402 struct sk_buff *orig_teardown_skb;
403 bool is_teardown = false;
404
405
406 spin_lock(&sdata->u.mgd.teardown_lock);
407 teardown_skb = sdata->u.mgd.teardown_skb;
408 orig_teardown_skb = sdata->u.mgd.orig_teardown_skb;
409 if ((skb == orig_teardown_skb) && teardown_skb) {
410 sdata->u.mgd.teardown_skb = NULL;
411 sdata->u.mgd.orig_teardown_skb = NULL;
412 is_teardown = true;
413 }
414 spin_unlock(&sdata->u.mgd.teardown_lock);
415
416 if (is_teardown) {
417
418 WARN_ON(!ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS));
419
420
421 if (flags & IEEE80211_TX_STAT_ACK) {
422 dev_kfree_skb_any(teardown_skb);
423 } else {
424 tdls_dbg(sdata,
425 "TDLS Resending teardown through AP\n");
426
427 ieee80211_subif_start_xmit(teardown_skb, skb->dev);
428 }
429 }
430}
431
432static struct ieee80211_sub_if_data *
433ieee80211_sdata_from_skb(struct ieee80211_local *local, struct sk_buff *skb)
434{
435 struct ieee80211_sub_if_data *sdata;
436
437 if (skb->dev) {
438 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
439 if (!sdata->dev)
440 continue;
441
442 if (skb->dev == sdata->dev)
443 return sdata;
444 }
445
446 return NULL;
447 }
448
449 return rcu_dereference(local->p2p_sdata);
450}
451
452static void ieee80211_report_ack_skb(struct ieee80211_local *local,
453 struct ieee80211_tx_info *info,
454 bool acked, bool dropped)
455{
456 struct sk_buff *skb;
457 unsigned long flags;
458
459 spin_lock_irqsave(&local->ack_status_lock, flags);
460 skb = idr_find(&local->ack_status_frames, info->ack_frame_id);
461 if (skb)
462 idr_remove(&local->ack_status_frames, info->ack_frame_id);
463 spin_unlock_irqrestore(&local->ack_status_lock, flags);
464
465 if (!skb)
466 return;
467
468 if (dropped) {
469 dev_kfree_skb_any(skb);
470 return;
471 }
472
473 if (info->flags & IEEE80211_TX_INTFL_NL80211_FRAME_TX) {
474 u64 cookie = IEEE80211_SKB_CB(skb)->ack.cookie;
475 struct ieee80211_sub_if_data *sdata;
476 struct ieee80211_hdr *hdr = (void *)skb->data;
477
478 rcu_read_lock();
479 sdata = ieee80211_sdata_from_skb(local, skb);
480 if (sdata) {
481 if (ieee80211_is_nullfunc(hdr->frame_control) ||
482 ieee80211_is_qos_nullfunc(hdr->frame_control))
483 cfg80211_probe_status(sdata->dev, hdr->addr1,
484 cookie, acked,
485 GFP_ATOMIC);
486 else
487 cfg80211_mgmt_tx_status(&sdata->wdev, cookie,
488 skb->data, skb->len,
489 acked, GFP_ATOMIC);
490 }
491 rcu_read_unlock();
492
493 dev_kfree_skb_any(skb);
494 } else {
495
496 skb_complete_wifi_ack(skb, acked);
497 }
498}
499
500static void ieee80211_report_used_skb(struct ieee80211_local *local,
501 struct sk_buff *skb, bool dropped)
502{
503 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
504 struct ieee80211_hdr *hdr = (void *)skb->data;
505 bool acked = info->flags & IEEE80211_TX_STAT_ACK;
506
507 if (dropped)
508 acked = false;
509
510 if (info->flags & IEEE80211_TX_INTFL_MLME_CONN_TX) {
511 struct ieee80211_sub_if_data *sdata;
512
513 rcu_read_lock();
514
515 sdata = ieee80211_sdata_from_skb(local, skb);
516
517 if (!sdata) {
518 skb->dev = NULL;
519 } else {
520 unsigned int hdr_size =
521 ieee80211_hdrlen(hdr->frame_control);
522
523
524 if (ieee80211_is_data(hdr->frame_control) &&
525 (ieee80211_get_tdls_action(skb, hdr_size) ==
526 WLAN_TDLS_TEARDOWN))
527 ieee80211_tdls_td_tx_handle(local, sdata, skb,
528 info->flags);
529 else
530 ieee80211_mgd_conn_tx_status(sdata,
531 hdr->frame_control,
532 acked);
533 }
534
535 rcu_read_unlock();
536 } else if (info->ack_frame_id) {
537 ieee80211_report_ack_skb(local, info, acked, dropped);
538 }
539}
540
541
542
543
544
545
546
547
548#define STA_LOST_PKT_THRESHOLD 50
549#define STA_LOST_TDLS_PKT_THRESHOLD 10
550#define STA_LOST_TDLS_PKT_TIME (10*HZ)
551
552static void ieee80211_lost_packet(struct sta_info *sta,
553 struct ieee80211_tx_info *info)
554{
555
556 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
557 !(info->flags & IEEE80211_TX_STAT_AMPDU))
558 return;
559
560 sta->status_stats.lost_packets++;
561 if (!sta->sta.tdls &&
562 sta->status_stats.lost_packets < STA_LOST_PKT_THRESHOLD)
563 return;
564
565
566
567
568
569
570
571 if (sta->sta.tdls &&
572 (sta->status_stats.lost_packets < STA_LOST_TDLS_PKT_THRESHOLD ||
573 time_before(jiffies,
574 sta->status_stats.last_tdls_pkt_time +
575 STA_LOST_TDLS_PKT_TIME)))
576 return;
577
578 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
579 sta->status_stats.lost_packets, GFP_ATOMIC);
580 sta->status_stats.lost_packets = 0;
581}
582
583static int ieee80211_tx_get_rates(struct ieee80211_hw *hw,
584 struct ieee80211_tx_info *info,
585 int *retry_count)
586{
587 int rates_idx = -1;
588 int count = -1;
589 int i;
590
591 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
592 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
593 !(info->flags & IEEE80211_TX_STAT_AMPDU)) {
594
595 info->status.rates[i].idx = -1;
596 info->status.rates[i].count = 0;
597 break;
598 } else if (info->status.rates[i].idx < 0) {
599 break;
600 } else if (i >= hw->max_report_rates) {
601
602 info->status.rates[i].idx = -1;
603 info->status.rates[i].count = 0;
604 break;
605 }
606
607 count += info->status.rates[i].count;
608 }
609 rates_idx = i - 1;
610
611 if (count < 0)
612 count = 0;
613
614 *retry_count = count;
615 return rates_idx;
616}
617
618void ieee80211_tx_status_noskb(struct ieee80211_hw *hw,
619 struct ieee80211_sta *pubsta,
620 struct ieee80211_tx_info *info)
621{
622 struct ieee80211_local *local = hw_to_local(hw);
623 struct ieee80211_supported_band *sband;
624 int retry_count;
625 int rates_idx;
626 bool acked, noack_success;
627
628 rates_idx = ieee80211_tx_get_rates(hw, info, &retry_count);
629
630 sband = hw->wiphy->bands[info->band];
631
632 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
633 noack_success = !!(info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED);
634
635 if (pubsta) {
636 struct sta_info *sta;
637
638 sta = container_of(pubsta, struct sta_info, sta);
639
640 if (!acked)
641 sta->status_stats.retry_failed++;
642 sta->status_stats.retry_count += retry_count;
643
644 if (acked) {
645 sta->rx_stats.last_rx = jiffies;
646
647 if (sta->status_stats.lost_packets)
648 sta->status_stats.lost_packets = 0;
649
650
651 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
652 sta->status_stats.last_tdls_pkt_time = jiffies;
653 } else {
654 ieee80211_lost_packet(sta, info);
655 }
656
657 rate_control_tx_status_noskb(local, sband, sta, info);
658 }
659
660 if (acked || noack_success) {
661 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
662 if (!pubsta)
663 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
664 if (retry_count > 0)
665 I802_DEBUG_INC(local->dot11RetryCount);
666 if (retry_count > 1)
667 I802_DEBUG_INC(local->dot11MultipleRetryCount);
668 } else {
669 I802_DEBUG_INC(local->dot11FailedCount);
670 }
671}
672EXPORT_SYMBOL(ieee80211_tx_status_noskb);
673
674void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
675 struct ieee80211_supported_band *sband,
676 int retry_count, int shift, bool send_to_cooked)
677{
678 struct sk_buff *skb2;
679 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
680 struct ieee80211_sub_if_data *sdata;
681 struct net_device *prev_dev = NULL;
682 int rtap_len;
683
684
685 rtap_len = ieee80211_tx_radiotap_len(info);
686 if (WARN_ON_ONCE(skb_headroom(skb) < rtap_len)) {
687 pr_err("ieee80211_tx_status: headroom too small\n");
688 dev_kfree_skb(skb);
689 return;
690 }
691 ieee80211_add_tx_radiotap_header(local, sband, skb, retry_count,
692 rtap_len, shift);
693
694
695 skb_set_mac_header(skb, 0);
696 skb->ip_summed = CHECKSUM_UNNECESSARY;
697 skb->pkt_type = PACKET_OTHERHOST;
698 skb->protocol = htons(ETH_P_802_2);
699 memset(skb->cb, 0, sizeof(skb->cb));
700
701 rcu_read_lock();
702 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
703 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
704 if (!ieee80211_sdata_running(sdata))
705 continue;
706
707 if ((sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) &&
708 !send_to_cooked)
709 continue;
710
711 if (prev_dev) {
712 skb2 = skb_clone(skb, GFP_ATOMIC);
713 if (skb2) {
714 skb2->dev = prev_dev;
715 netif_rx(skb2);
716 }
717 }
718
719 prev_dev = sdata->dev;
720 }
721 }
722 if (prev_dev) {
723 skb->dev = prev_dev;
724 netif_rx(skb);
725 skb = NULL;
726 }
727 rcu_read_unlock();
728 dev_kfree_skb(skb);
729}
730
731void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
732{
733 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
734 struct ieee80211_local *local = hw_to_local(hw);
735 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
736 __le16 fc;
737 struct ieee80211_supported_band *sband;
738 struct sta_info *sta;
739 struct rhash_head *tmp;
740 int retry_count;
741 int rates_idx;
742 bool send_to_cooked;
743 bool acked;
744 struct ieee80211_bar *bar;
745 int shift = 0;
746 int tid = IEEE80211_NUM_TIDS;
747 const struct bucket_table *tbl;
748
749 rates_idx = ieee80211_tx_get_rates(hw, info, &retry_count);
750
751 rcu_read_lock();
752
753 sband = local->hw.wiphy->bands[info->band];
754 fc = hdr->frame_control;
755
756 tbl = rht_dereference_rcu(local->sta_hash.tbl, &local->sta_hash);
757
758 for_each_sta_info(local, tbl, hdr->addr1, sta, tmp) {
759
760 if (!ether_addr_equal(hdr->addr2, sta->sdata->vif.addr))
761 continue;
762
763 shift = ieee80211_vif_get_shift(&sta->sdata->vif);
764
765 if (info->flags & IEEE80211_TX_STATUS_EOSP)
766 clear_sta_flag(sta, WLAN_STA_SP);
767
768 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
769 if (!acked && test_sta_flag(sta, WLAN_STA_PS_STA)) {
770
771
772
773
774 ieee80211_handle_filtered_frame(local, sta, skb);
775 rcu_read_unlock();
776 return;
777 }
778
779
780 if (ieee80211_vif_is_mesh(&sta->sdata->vif) &&
781 ieee80211_is_data_qos(fc))
782 ieee80211_mpsp_trigger_process(
783 ieee80211_get_qos_ctl(hdr),
784 sta, true, acked);
785
786 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL) &&
787 (ieee80211_is_data(hdr->frame_control)) &&
788 (rates_idx != -1))
789 sta->tx_stats.last_rate =
790 info->status.rates[rates_idx];
791
792 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
793 (ieee80211_is_data_qos(fc))) {
794 u16 ssn;
795 u8 *qc;
796
797 qc = ieee80211_get_qos_ctl(hdr);
798 tid = qc[0] & 0xf;
799 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
800 & IEEE80211_SCTL_SEQ);
801 ieee80211_send_bar(&sta->sdata->vif, hdr->addr1,
802 tid, ssn);
803 } else if (ieee80211_is_data_qos(fc)) {
804 u8 *qc = ieee80211_get_qos_ctl(hdr);
805
806 tid = qc[0] & 0xf;
807 }
808
809 if (!acked && ieee80211_is_back_req(fc)) {
810 u16 control;
811
812
813
814
815
816
817 bar = (struct ieee80211_bar *) skb->data;
818 control = le16_to_cpu(bar->control);
819 if (!(control & IEEE80211_BAR_CTRL_MULTI_TID)) {
820 u16 ssn = le16_to_cpu(bar->start_seq_num);
821
822 tid = (control &
823 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
824 IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
825
826 ieee80211_set_bar_pending(sta, tid, ssn);
827 }
828 }
829
830 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
831 ieee80211_handle_filtered_frame(local, sta, skb);
832 rcu_read_unlock();
833 return;
834 } else {
835 if (!acked)
836 sta->status_stats.retry_failed++;
837 sta->status_stats.retry_count += retry_count;
838
839 if (ieee80211_is_data_present(fc)) {
840 if (!acked)
841 sta->status_stats.msdu_failed[tid]++;
842
843 sta->status_stats.msdu_retries[tid] +=
844 retry_count;
845 }
846 }
847
848 rate_control_tx_status(local, sband, sta, skb);
849 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
850 ieee80211s_update_metric(local, sta, skb);
851
852 if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
853 ieee80211_frame_acked(sta, skb);
854
855 if ((sta->sdata->vif.type == NL80211_IFTYPE_STATION) &&
856 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS))
857 ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data,
858 acked, info->status.tx_time);
859
860 if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
861 if (info->flags & IEEE80211_TX_STAT_ACK) {
862 if (sta->status_stats.lost_packets)
863 sta->status_stats.lost_packets = 0;
864
865
866 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
867 sta->status_stats.last_tdls_pkt_time =
868 jiffies;
869 } else {
870 ieee80211_lost_packet(sta, info);
871 }
872 }
873 }
874
875 rcu_read_unlock();
876
877 ieee80211_led_tx(local);
878
879
880
881
882
883 if ((info->flags & IEEE80211_TX_STAT_ACK) ||
884 (info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED)) {
885 if (ieee80211_is_first_frag(hdr->seq_ctrl)) {
886 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
887 if (is_multicast_ether_addr(ieee80211_get_DA(hdr)))
888 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
889 if (retry_count > 0)
890 I802_DEBUG_INC(local->dot11RetryCount);
891 if (retry_count > 1)
892 I802_DEBUG_INC(local->dot11MultipleRetryCount);
893 }
894
895
896
897
898
899 if (!is_multicast_ether_addr(hdr->addr1) ||
900 ieee80211_is_data(fc) ||
901 ieee80211_is_mgmt(fc))
902 I802_DEBUG_INC(local->dot11TransmittedFragmentCount);
903 } else {
904 if (ieee80211_is_first_frag(hdr->seq_ctrl))
905 I802_DEBUG_INC(local->dot11FailedCount);
906 }
907
908 if (ieee80211_is_nullfunc(fc) && ieee80211_has_pm(fc) &&
909 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS) &&
910 !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
911 local->ps_sdata && !(local->scanning)) {
912 if (info->flags & IEEE80211_TX_STAT_ACK) {
913 local->ps_sdata->u.mgd.flags |=
914 IEEE80211_STA_NULLFUNC_ACKED;
915 } else
916 mod_timer(&local->dynamic_ps_timer, jiffies +
917 msecs_to_jiffies(10));
918 }
919
920 ieee80211_report_used_skb(local, skb, false);
921
922
923 skb_orphan(skb);
924
925
926 send_to_cooked = !!(info->flags & IEEE80211_TX_CTL_INJECTED) ||
927 !(ieee80211_is_data(fc));
928
929
930
931
932
933 if (!local->monitors && (!send_to_cooked || !local->cooked_mntrs)) {
934 dev_kfree_skb(skb);
935 return;
936 }
937
938
939 ieee80211_tx_monitor(local, skb, sband, retry_count, shift, send_to_cooked);
940}
941EXPORT_SYMBOL(ieee80211_tx_status);
942
943void ieee80211_report_low_ack(struct ieee80211_sta *pubsta, u32 num_packets)
944{
945 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
946 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
947 num_packets, GFP_ATOMIC);
948}
949EXPORT_SYMBOL(ieee80211_report_low_ack);
950
951void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
952{
953 struct ieee80211_local *local = hw_to_local(hw);
954
955 ieee80211_report_used_skb(local, skb, true);
956 dev_kfree_skb_any(skb);
957}
958EXPORT_SYMBOL(ieee80211_free_txskb);
959
960void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
961 struct sk_buff_head *skbs)
962{
963 struct sk_buff *skb;
964
965 while ((skb = __skb_dequeue(skbs)))
966 ieee80211_free_txskb(hw, skb);
967}
968