1
2
3
4
5
6
7
8
9
10
11
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"
17#include "rate.h"
18#include "mesh.h"
19#include "led.h"
20#include "wme.h"
21
22
23void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
24 struct sk_buff *skb)
25{
26 struct ieee80211_local *local = hw_to_local(hw);
27 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
28 int tmp;
29
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);
38 tmp--;
39 I802_DEBUG_INC(local->tx_status_drop);
40 }
41 tasklet_schedule(&local->tasklet);
42}
43EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
44
45static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
46 struct sta_info *sta,
47 struct sk_buff *skb)
48{
49 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
50 struct ieee80211_hdr *hdr = (void *)skb->data;
51 int ac;
52
53
54
55
56
57
58
59
60
61 memset(&info->control, 0, sizeof(info->control));
62
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;
68
69 sta->tx_filtered_count++;
70
71
72
73
74
75
76
77
78 if (hdr->frame_control & cpu_to_le16(IEEE80211_FCTL_MOREDATA))
79 hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA);
80
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;
84
85
86
87
88
89
90 if (*p & IEEE80211_QOS_CTL_EOSP)
91 *p &= ~IEEE80211_QOS_CTL_EOSP;
92 ac = ieee802_1d_to_ac[tid & 7];
93 } else {
94 ac = IEEE80211_AC_BE;
95 }
96
97
98
99
100
101
102 set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);
103
104
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 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);
142
143 if (!timer_pending(&local->sta_cleanup))
144 mod_timer(&local->sta_cleanup,
145 round_jiffies(jiffies +
146 STA_INFO_CLEANUP_INTERVAL));
147 return;
148 }
149
150 if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
151 !(info->flags & IEEE80211_TX_INTFL_RETRIED)) {
152
153 info->flags |= IEEE80211_TX_INTFL_RETRIED;
154 ieee80211_add_pending_skb(local, skb);
155 return;
156 }
157
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);
163}
164
165static void ieee80211_check_pending_bar(struct sta_info *sta, u8 *addr, u8 tid)
166{
167 struct tid_ampdu_tx *tid_tx;
168
169 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
170 if (!tid_tx || !tid_tx->bar_pending)
171 return;
172
173 tid_tx->bar_pending = false;
174 ieee80211_send_bar(&sta->sdata->vif, addr, tid, tid_tx->failed_bar_ssn);
175}
176
177static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
178{
179 struct ieee80211_mgmt *mgmt = (void *) skb->data;
180 struct ieee80211_local *local = sta->local;
181 struct ieee80211_sub_if_data *sdata = sta->sdata;
182
183 if (ieee80211_is_data_qos(mgmt->frame_control)) {
184 struct ieee80211_hdr *hdr = (void *) skb->data;
185 u8 *qc = ieee80211_get_qos_ctl(hdr);
186 u16 tid = qc[0] & 0xf;
187
188 ieee80211_check_pending_bar(sta, hdr->addr1, tid);
189 }
190
191 if (ieee80211_is_action(mgmt->frame_control) &&
192 mgmt->u.action.category == WLAN_CATEGORY_HT &&
193 mgmt->u.action.u.ht_smps.action == WLAN_HT_ACTION_SMPS &&
194 sdata->vif.type == NL80211_IFTYPE_STATION &&
195 ieee80211_sdata_running(sdata)) {
196
197
198
199
200
201
202
203 switch (mgmt->u.action.u.ht_smps.smps_control) {
204 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
205 sdata->smps_mode = IEEE80211_SMPS_DYNAMIC;
206 break;
207 case WLAN_HT_SMPS_CONTROL_STATIC:
208 sdata->smps_mode = IEEE80211_SMPS_STATIC;
209 break;
210 case WLAN_HT_SMPS_CONTROL_DISABLED:
211 default:
212 sdata->smps_mode = IEEE80211_SMPS_OFF;
213 break;
214 }
215
216 ieee80211_queue_work(&local->hw, &sdata->recalc_smps);
217 }
218}
219
220static void ieee80211_set_bar_pending(struct sta_info *sta, u8 tid, u16 ssn)
221{
222 struct tid_ampdu_tx *tid_tx;
223
224 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
225 if (!tid_tx)
226 return;
227
228 tid_tx->failed_bar_ssn = ssn;
229 tid_tx->bar_pending = true;
230}
231
232static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info *info)
233{
234 int len = sizeof(struct ieee80211_radiotap_header);
235
236
237 if (info->status.rates[0].idx >= 0 &&
238 !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS))
239 len += 2;
240
241
242 len += 2;
243
244
245 len += 1;
246
247
248 if (info->status.rates[0].idx >= 0 &&
249 info->status.rates[0].flags & IEEE80211_TX_RC_MCS)
250 len += 3;
251
252 return len;
253}
254
255static void ieee80211_add_tx_radiotap_header(struct ieee80211_supported_band
256 *sband, struct sk_buff *skb,
257 int retry_count, int rtap_len)
258{
259 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
260 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
261 struct ieee80211_radiotap_header *rthdr;
262 unsigned char *pos;
263 u16 txflags;
264
265 rthdr = (struct ieee80211_radiotap_header *) skb_push(skb, rtap_len);
266
267 memset(rthdr, 0, rtap_len);
268 rthdr->it_len = cpu_to_le16(rtap_len);
269 rthdr->it_present =
270 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
271 (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
272 pos = (unsigned char *)(rthdr + 1);
273
274
275
276
277
278
279
280
281 if (info->status.rates[0].idx >= 0 &&
282 !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS)) {
283 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
284 *pos = sband->bitrates[info->status.rates[0].idx].bitrate / 5;
285
286 pos += 2;
287 }
288
289
290 txflags = 0;
291 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
292 !is_multicast_ether_addr(hdr->addr1))
293 txflags |= IEEE80211_RADIOTAP_F_TX_FAIL;
294
295 if ((info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
296 (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
297 txflags |= IEEE80211_RADIOTAP_F_TX_CTS;
298 else if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
299 txflags |= IEEE80211_RADIOTAP_F_TX_RTS;
300
301 put_unaligned_le16(txflags, pos);
302 pos += 2;
303
304
305
306 *pos = retry_count;
307 pos++;
308
309
310 if (info->status.rates[0].idx >= 0 &&
311 info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
312 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
313 pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
314 IEEE80211_RADIOTAP_MCS_HAVE_GI |
315 IEEE80211_RADIOTAP_MCS_HAVE_BW;
316 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
317 pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
318 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
319 pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
320 if (info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)
321 pos[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF;
322 pos[2] = info->status.rates[0].idx;
323 pos += 3;
324 }
325
326}
327
328static void ieee80211_report_used_skb(struct ieee80211_local *local,
329 struct sk_buff *skb, bool dropped)
330{
331 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
332 struct ieee80211_hdr *hdr = (void *)skb->data;
333 bool acked = info->flags & IEEE80211_TX_STAT_ACK;
334
335 if (dropped)
336 acked = false;
337
338 if (info->flags & (IEEE80211_TX_INTFL_NL80211_FRAME_TX |
339 IEEE80211_TX_INTFL_MLME_CONN_TX)) {
340 struct ieee80211_sub_if_data *sdata = NULL;
341 struct ieee80211_sub_if_data *iter_sdata;
342 u64 cookie = (unsigned long)skb;
343
344 rcu_read_lock();
345
346 if (skb->dev) {
347 list_for_each_entry_rcu(iter_sdata, &local->interfaces,
348 list) {
349 if (!iter_sdata->dev)
350 continue;
351
352 if (skb->dev == iter_sdata->dev) {
353 sdata = iter_sdata;
354 break;
355 }
356 }
357 } else {
358 sdata = rcu_dereference(local->p2p_sdata);
359 }
360
361 if (!sdata) {
362 skb->dev = NULL;
363 } else if (info->flags & IEEE80211_TX_INTFL_MLME_CONN_TX) {
364 ieee80211_mgd_conn_tx_status(sdata, hdr->frame_control,
365 acked);
366 } else if (ieee80211_is_nullfunc(hdr->frame_control) ||
367 ieee80211_is_qos_nullfunc(hdr->frame_control)) {
368 cfg80211_probe_status(sdata->dev, hdr->addr1,
369 cookie, acked, GFP_ATOMIC);
370 } else {
371 cfg80211_mgmt_tx_status(&sdata->wdev, cookie, skb->data,
372 skb->len, acked, GFP_ATOMIC);
373 }
374
375 rcu_read_unlock();
376 }
377
378 if (unlikely(info->ack_frame_id)) {
379 struct sk_buff *ack_skb;
380 unsigned long flags;
381
382 spin_lock_irqsave(&local->ack_status_lock, flags);
383 ack_skb = idr_find(&local->ack_status_frames,
384 info->ack_frame_id);
385 if (ack_skb)
386 idr_remove(&local->ack_status_frames,
387 info->ack_frame_id);
388 spin_unlock_irqrestore(&local->ack_status_lock, flags);
389
390 if (ack_skb) {
391 if (!dropped) {
392
393 skb_complete_wifi_ack(ack_skb, acked);
394 } else {
395 dev_kfree_skb_any(ack_skb);
396 }
397 }
398 }
399}
400
401
402
403
404
405
406
407
408#define STA_LOST_PKT_THRESHOLD 50
409
410void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
411{
412 struct sk_buff *skb2;
413 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
414 struct ieee80211_local *local = hw_to_local(hw);
415 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
416 __le16 fc;
417 struct ieee80211_supported_band *sband;
418 struct ieee80211_sub_if_data *sdata;
419 struct net_device *prev_dev = NULL;
420 struct sta_info *sta, *tmp;
421 int retry_count = -1, i;
422 int rates_idx = -1;
423 bool send_to_cooked;
424 bool acked;
425 struct ieee80211_bar *bar;
426 int rtap_len;
427
428 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
429 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
430 !(info->flags & IEEE80211_TX_STAT_AMPDU)) {
431
432 info->status.rates[i].idx = -1;
433 info->status.rates[i].count = 0;
434 break;
435 } else if (info->status.rates[i].idx < 0) {
436 break;
437 } else if (i >= hw->max_report_rates) {
438
439 info->status.rates[i].idx = -1;
440 info->status.rates[i].count = 0;
441 break;
442 }
443
444 retry_count += info->status.rates[i].count;
445 }
446 rates_idx = i - 1;
447
448 if (retry_count < 0)
449 retry_count = 0;
450
451 rcu_read_lock();
452
453 sband = local->hw.wiphy->bands[info->band];
454 fc = hdr->frame_control;
455
456 for_each_sta_info(local, hdr->addr1, sta, tmp) {
457
458 if (!ether_addr_equal(hdr->addr2, sta->sdata->vif.addr))
459 continue;
460
461 if (info->flags & IEEE80211_TX_STATUS_EOSP)
462 clear_sta_flag(sta, WLAN_STA_SP);
463
464 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
465 if (!acked && test_sta_flag(sta, WLAN_STA_PS_STA)) {
466
467
468
469
470 ieee80211_handle_filtered_frame(local, sta, skb);
471 rcu_read_unlock();
472 return;
473 }
474
475
476 if (ieee80211_vif_is_mesh(&sta->sdata->vif) &&
477 ieee80211_is_data_qos(fc))
478 ieee80211_mpsp_trigger_process(
479 ieee80211_get_qos_ctl(hdr),
480 sta, true, acked);
481
482 if ((local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) &&
483 (rates_idx != -1))
484 sta->last_tx_rate = info->status.rates[rates_idx];
485
486 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
487 (ieee80211_is_data_qos(fc))) {
488 u16 tid, ssn;
489 u8 *qc;
490
491 qc = ieee80211_get_qos_ctl(hdr);
492 tid = qc[0] & 0xf;
493 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
494 & IEEE80211_SCTL_SEQ);
495 ieee80211_send_bar(&sta->sdata->vif, hdr->addr1,
496 tid, ssn);
497 }
498
499 if (!acked && ieee80211_is_back_req(fc)) {
500 u16 tid, control;
501
502
503
504
505
506
507 bar = (struct ieee80211_bar *) skb->data;
508 control = le16_to_cpu(bar->control);
509 if (!(control & IEEE80211_BAR_CTRL_MULTI_TID)) {
510 u16 ssn = le16_to_cpu(bar->start_seq_num);
511
512 tid = (control &
513 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
514 IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
515
516 ieee80211_set_bar_pending(sta, tid, ssn);
517 }
518 }
519
520 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
521 ieee80211_handle_filtered_frame(local, sta, skb);
522 rcu_read_unlock();
523 return;
524 } else {
525 if (!acked)
526 sta->tx_retry_failed++;
527 sta->tx_retry_count += retry_count;
528 }
529
530 rate_control_tx_status(local, sband, sta, skb);
531 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
532 ieee80211s_update_metric(local, sta, skb);
533
534 if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
535 ieee80211_frame_acked(sta, skb);
536
537 if ((sta->sdata->vif.type == NL80211_IFTYPE_STATION) &&
538 (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
539 ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data, acked);
540
541 if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
542 if (info->flags & IEEE80211_TX_STAT_ACK) {
543 if (sta->lost_packets)
544 sta->lost_packets = 0;
545 } else if (++sta->lost_packets >= STA_LOST_PKT_THRESHOLD) {
546 cfg80211_cqm_pktloss_notify(sta->sdata->dev,
547 sta->sta.addr,
548 sta->lost_packets,
549 GFP_ATOMIC);
550 sta->lost_packets = 0;
551 }
552 }
553
554 if (acked)
555 sta->last_ack_signal = info->status.ack_signal;
556 }
557
558 rcu_read_unlock();
559
560 ieee80211_led_tx(local, 0);
561
562
563
564
565
566 if (info->flags & IEEE80211_TX_STAT_ACK) {
567 if (ieee80211_is_first_frag(hdr->seq_ctrl)) {
568 local->dot11TransmittedFrameCount++;
569 if (is_multicast_ether_addr(hdr->addr1))
570 local->dot11MulticastTransmittedFrameCount++;
571 if (retry_count > 0)
572 local->dot11RetryCount++;
573 if (retry_count > 1)
574 local->dot11MultipleRetryCount++;
575 }
576
577
578
579
580
581 if (!is_multicast_ether_addr(hdr->addr1) ||
582 ieee80211_is_data(fc) ||
583 ieee80211_is_mgmt(fc))
584 local->dot11TransmittedFragmentCount++;
585 } else {
586 if (ieee80211_is_first_frag(hdr->seq_ctrl))
587 local->dot11FailedCount++;
588 }
589
590 if (ieee80211_is_nullfunc(fc) && ieee80211_has_pm(fc) &&
591 (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) &&
592 !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
593 local->ps_sdata && !(local->scanning)) {
594 if (info->flags & IEEE80211_TX_STAT_ACK) {
595 local->ps_sdata->u.mgd.flags |=
596 IEEE80211_STA_NULLFUNC_ACKED;
597 } else
598 mod_timer(&local->dynamic_ps_timer, jiffies +
599 msecs_to_jiffies(10));
600 }
601
602 ieee80211_report_used_skb(local, skb, false);
603
604
605 skb_orphan(skb);
606
607
608 send_to_cooked = !!(info->flags & IEEE80211_TX_CTL_INJECTED) ||
609 !(ieee80211_is_data(fc));
610
611
612
613
614
615 if (!local->monitors && (!send_to_cooked || !local->cooked_mntrs)) {
616 dev_kfree_skb(skb);
617 return;
618 }
619
620
621 rtap_len = ieee80211_tx_radiotap_len(info);
622 if (WARN_ON_ONCE(skb_headroom(skb) < rtap_len)) {
623 pr_err("ieee80211_tx_status: headroom too small\n");
624 dev_kfree_skb(skb);
625 return;
626 }
627 ieee80211_add_tx_radiotap_header(sband, skb, retry_count, rtap_len);
628
629
630 skb_set_mac_header(skb, 0);
631 skb->ip_summed = CHECKSUM_UNNECESSARY;
632 skb->pkt_type = PACKET_OTHERHOST;
633 skb->protocol = htons(ETH_P_802_2);
634 memset(skb->cb, 0, sizeof(skb->cb));
635
636 rcu_read_lock();
637 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
638 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
639 if (!ieee80211_sdata_running(sdata))
640 continue;
641
642 if ((sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) &&
643 !send_to_cooked)
644 continue;
645
646 if (prev_dev) {
647 skb2 = skb_clone(skb, GFP_ATOMIC);
648 if (skb2) {
649 skb2->dev = prev_dev;
650 netif_rx(skb2);
651 }
652 }
653
654 prev_dev = sdata->dev;
655 }
656 }
657 if (prev_dev) {
658 skb->dev = prev_dev;
659 netif_rx(skb);
660 skb = NULL;
661 }
662 rcu_read_unlock();
663 dev_kfree_skb(skb);
664}
665EXPORT_SYMBOL(ieee80211_tx_status);
666
667void ieee80211_report_low_ack(struct ieee80211_sta *pubsta, u32 num_packets)
668{
669 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
670 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
671 num_packets, GFP_ATOMIC);
672}
673EXPORT_SYMBOL(ieee80211_report_low_ack);
674
675void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
676{
677 struct ieee80211_local *local = hw_to_local(hw);
678
679 ieee80211_report_used_skb(local, skb, true);
680 dev_kfree_skb_any(skb);
681}
682EXPORT_SYMBOL(ieee80211_free_txskb);
683
684void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
685 struct sk_buff_head *skbs)
686{
687 struct sk_buff *skb;
688
689 while ((skb = __skb_dequeue(skbs)))
690 ieee80211_free_txskb(hw, skb);
691}
692