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