1
2
3
4
5
6
7
8
9
10#include <linux/export.h>
11#include <linux/etherdevice.h>
12#include <net/mac80211.h>
13#include <asm/unaligned.h>
14#include "ieee80211_i.h"
15#include "rate.h"
16#include "mesh.h"
17#include "led.h"
18#include "wme.h"
19
20
21void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
22 struct sk_buff *skb)
23{
24 struct ieee80211_local *local = hw_to_local(hw);
25 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
26 int tmp;
27
28 skb->pkt_type = IEEE80211_TX_STATUS_MSG;
29 skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
30 &local->skb_queue : &local->skb_queue_unreliable, skb);
31 tmp = skb_queue_len(&local->skb_queue) +
32 skb_queue_len(&local->skb_queue_unreliable);
33 while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
34 (skb = skb_dequeue(&local->skb_queue_unreliable))) {
35 ieee80211_free_txskb(hw, skb);
36 tmp--;
37 I802_DEBUG_INC(local->tx_status_drop);
38 }
39 tasklet_schedule(&local->tasklet);
40}
41EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
42
43static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
44 struct sta_info *sta,
45 struct sk_buff *skb)
46{
47 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
48 struct ieee80211_hdr *hdr = (void *)skb->data;
49 int ac;
50
51 if (info->flags & (IEEE80211_TX_CTL_NO_PS_BUFFER |
52 IEEE80211_TX_CTL_AMPDU |
53 IEEE80211_TX_CTL_HW_80211_ENCAP)) {
54 ieee80211_free_txskb(&local->hw, skb);
55 return;
56 }
57
58
59
60
61
62
63
64
65
66 memset(&info->control, 0, sizeof(info->control));
67
68 info->control.jiffies = jiffies;
69 info->control.vif = &sta->sdata->vif;
70 info->control.flags |= IEEE80211_TX_INTCFL_NEED_TXPROCESSING;
71 info->flags |= IEEE80211_TX_INTFL_RETRANSMISSION;
72 info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
73
74 sta->status_stats.filtered++;
75
76
77
78
79
80
81
82
83 if (hdr->frame_control & cpu_to_le16(IEEE80211_FCTL_MOREDATA))
84 hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA);
85
86 if (ieee80211_is_data_qos(hdr->frame_control)) {
87 u8 *p = ieee80211_get_qos_ctl(hdr);
88 int tid = *p & IEEE80211_QOS_CTL_TID_MASK;
89
90
91
92
93
94
95 if (*p & IEEE80211_QOS_CTL_EOSP)
96 *p &= ~IEEE80211_QOS_CTL_EOSP;
97 ac = ieee80211_ac_from_tid(tid);
98 } else {
99 ac = IEEE80211_AC_BE;
100 }
101
102
103
104
105
106
107 set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);
108 ieee80211_clear_fast_xmit(sta);
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
141
142
143
144 if (test_sta_flag(sta, WLAN_STA_PS_STA) &&
145 skb_queue_len(&sta->tx_filtered[ac]) < STA_MAX_TX_BUFFER) {
146 skb_queue_tail(&sta->tx_filtered[ac], skb);
147 sta_info_recalc_tim(sta);
148
149 if (!timer_pending(&local->sta_cleanup))
150 mod_timer(&local->sta_cleanup,
151 round_jiffies(jiffies +
152 STA_INFO_CLEANUP_INTERVAL));
153 return;
154 }
155
156 if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
157 !(info->flags & IEEE80211_TX_INTFL_RETRIED)) {
158
159 info->flags |= IEEE80211_TX_INTFL_RETRIED;
160 ieee80211_add_pending_skb(local, skb);
161 return;
162 }
163
164 ps_dbg_ratelimited(sta->sdata,
165 "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
166 skb_queue_len(&sta->tx_filtered[ac]),
167 !!test_sta_flag(sta, WLAN_STA_PS_STA), jiffies);
168 ieee80211_free_txskb(&local->hw, skb);
169}
170
171static void ieee80211_check_pending_bar(struct sta_info *sta, u8 *addr, u8 tid)
172{
173 struct tid_ampdu_tx *tid_tx;
174
175 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
176 if (!tid_tx || !tid_tx->bar_pending)
177 return;
178
179 tid_tx->bar_pending = false;
180 ieee80211_send_bar(&sta->sdata->vif, addr, tid, tid_tx->failed_bar_ssn);
181}
182
183static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
184{
185 struct ieee80211_mgmt *mgmt = (void *) skb->data;
186 struct ieee80211_local *local = sta->local;
187 struct ieee80211_sub_if_data *sdata = sta->sdata;
188
189 if (ieee80211_is_data_qos(mgmt->frame_control)) {
190 struct ieee80211_hdr *hdr = (void *) skb->data;
191 u8 *qc = ieee80211_get_qos_ctl(hdr);
192 u16 tid = qc[0] & 0xf;
193
194 ieee80211_check_pending_bar(sta, hdr->addr1, tid);
195 }
196
197 if (ieee80211_is_action(mgmt->frame_control) &&
198 !ieee80211_has_protected(mgmt->frame_control) &&
199 mgmt->u.action.category == WLAN_CATEGORY_HT &&
200 mgmt->u.action.u.ht_smps.action == WLAN_HT_ACTION_SMPS &&
201 ieee80211_sdata_running(sdata)) {
202 enum ieee80211_smps_mode smps_mode;
203
204 switch (mgmt->u.action.u.ht_smps.smps_control) {
205 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
206 smps_mode = IEEE80211_SMPS_DYNAMIC;
207 break;
208 case WLAN_HT_SMPS_CONTROL_STATIC:
209 smps_mode = IEEE80211_SMPS_STATIC;
210 break;
211 case WLAN_HT_SMPS_CONTROL_DISABLED:
212 default:
213 smps_mode = IEEE80211_SMPS_OFF;
214 break;
215 }
216
217 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
218
219
220
221
222
223
224
225 sdata->smps_mode = smps_mode;
226 ieee80211_queue_work(&local->hw, &sdata->recalc_smps);
227 } else if (sdata->vif.type == NL80211_IFTYPE_AP ||
228 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
229 sta->known_smps_mode = smps_mode;
230 }
231 }
232}
233
234static void ieee80211_set_bar_pending(struct sta_info *sta, u8 tid, u16 ssn)
235{
236 struct tid_ampdu_tx *tid_tx;
237
238 tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
239 if (!tid_tx)
240 return;
241
242 tid_tx->failed_bar_ssn = ssn;
243 tid_tx->bar_pending = true;
244}
245
246static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info *info,
247 struct ieee80211_tx_status *status)
248{
249 int len = sizeof(struct ieee80211_radiotap_header);
250
251
252 if (status && status->rate && !(status->rate->flags &
253 (RATE_INFO_FLAGS_MCS |
254 RATE_INFO_FLAGS_DMG |
255 RATE_INFO_FLAGS_EDMG |
256 RATE_INFO_FLAGS_VHT_MCS |
257 RATE_INFO_FLAGS_HE_MCS)))
258 len += 2;
259 else if (info->status.rates[0].idx >= 0 &&
260 !(info->status.rates[0].flags &
261 (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS)))
262 len += 2;
263
264
265 len += 2;
266
267
268 len += 1;
269
270
271
272 if (status && status->rate) {
273 if (status->rate->flags & RATE_INFO_FLAGS_MCS)
274 len += 3;
275 else if (status->rate->flags & RATE_INFO_FLAGS_VHT_MCS)
276 len = ALIGN(len, 2) + 12;
277 else if (status->rate->flags & RATE_INFO_FLAGS_HE_MCS)
278 len = ALIGN(len, 2) + 12;
279 } else if (info->status.rates[0].idx >= 0) {
280 if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS)
281 len += 3;
282 else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS)
283 len = ALIGN(len, 2) + 12;
284 }
285
286 return len;
287}
288
289static void
290ieee80211_add_tx_radiotap_header(struct ieee80211_local *local,
291 struct ieee80211_supported_band *sband,
292 struct sk_buff *skb, int retry_count,
293 int rtap_len, int shift,
294 struct ieee80211_tx_status *status)
295{
296 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
297 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
298 struct ieee80211_radiotap_header *rthdr;
299 unsigned char *pos;
300 u16 legacy_rate = 0;
301 u16 txflags;
302
303 rthdr = skb_push(skb, rtap_len);
304
305 memset(rthdr, 0, rtap_len);
306 rthdr->it_len = cpu_to_le16(rtap_len);
307 rthdr->it_present =
308 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
309 (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
310 pos = (unsigned char *)(rthdr + 1);
311
312
313
314
315
316
317
318
319
320 if (status && status->rate) {
321 if (!(status->rate->flags & (RATE_INFO_FLAGS_MCS |
322 RATE_INFO_FLAGS_DMG |
323 RATE_INFO_FLAGS_EDMG |
324 RATE_INFO_FLAGS_VHT_MCS |
325 RATE_INFO_FLAGS_HE_MCS)))
326 legacy_rate = status->rate->legacy;
327 } else if (info->status.rates[0].idx >= 0 &&
328 !(info->status.rates[0].flags & (IEEE80211_TX_RC_MCS |
329 IEEE80211_TX_RC_VHT_MCS)))
330 legacy_rate =
331 sband->bitrates[info->status.rates[0].idx].bitrate;
332
333 if (legacy_rate) {
334 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
335 *pos = DIV_ROUND_UP(legacy_rate, 5 * (1 << shift));
336
337 pos += 2;
338 }
339
340
341 txflags = 0;
342 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
343 !is_multicast_ether_addr(hdr->addr1))
344 txflags |= IEEE80211_RADIOTAP_F_TX_FAIL;
345
346 if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
347 txflags |= IEEE80211_RADIOTAP_F_TX_CTS;
348 if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
349 txflags |= IEEE80211_RADIOTAP_F_TX_RTS;
350
351 put_unaligned_le16(txflags, pos);
352 pos += 2;
353
354
355
356 *pos = retry_count;
357 pos++;
358
359 if (status && status->rate &&
360 (status->rate->flags & RATE_INFO_FLAGS_MCS)) {
361 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
362 pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
363 IEEE80211_RADIOTAP_MCS_HAVE_GI |
364 IEEE80211_RADIOTAP_MCS_HAVE_BW;
365 if (status->rate->flags & RATE_INFO_FLAGS_SHORT_GI)
366 pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
367 if (status->rate->bw == RATE_INFO_BW_40)
368 pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
369 pos[2] = status->rate->mcs;
370 pos += 3;
371 } else if (status && status->rate &&
372 (status->rate->flags & RATE_INFO_FLAGS_VHT_MCS)) {
373 u16 known = local->hw.radiotap_vht_details &
374 (IEEE80211_RADIOTAP_VHT_KNOWN_GI |
375 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
376
377 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT);
378
379
380 pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
381
382
383 put_unaligned_le16(known, pos);
384 pos += 2;
385
386
387 if (status->rate->flags & RATE_INFO_FLAGS_SHORT_GI)
388 *pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
389 pos++;
390
391
392 switch (status->rate->bw) {
393 case RATE_INFO_BW_160:
394 *pos = 11;
395 break;
396 case RATE_INFO_BW_80:
397 *pos = 4;
398 break;
399 case RATE_INFO_BW_40:
400 *pos = 1;
401 break;
402 default:
403 *pos = 0;
404 break;
405 }
406 pos++;
407
408
409 *pos = (status->rate->mcs << 4) | status->rate->nss;
410 pos += 4;
411
412
413 pos++;
414
415 pos++;
416
417 pos += 2;
418 } else if (status && status->rate &&
419 (status->rate->flags & RATE_INFO_FLAGS_HE_MCS)) {
420 struct ieee80211_radiotap_he *he;
421
422 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_HE);
423
424
425 pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
426 he = (struct ieee80211_radiotap_he *)pos;
427
428 he->data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_FORMAT_SU |
429 IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
430 IEEE80211_RADIOTAP_HE_DATA1_DATA_DCM_KNOWN |
431 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN);
432
433 he->data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN);
434
435#define HE_PREP(f, val) le16_encode_bits(val, IEEE80211_RADIOTAP_HE_##f)
436
437 he->data6 |= HE_PREP(DATA6_NSTS, status->rate->nss);
438
439#define CHECK_GI(s) \
440 BUILD_BUG_ON(IEEE80211_RADIOTAP_HE_DATA5_GI_##s != \
441 (int)NL80211_RATE_INFO_HE_GI_##s)
442
443 CHECK_GI(0_8);
444 CHECK_GI(1_6);
445 CHECK_GI(3_2);
446
447 he->data3 |= HE_PREP(DATA3_DATA_MCS, status->rate->mcs);
448 he->data3 |= HE_PREP(DATA3_DATA_DCM, status->rate->he_dcm);
449
450 he->data5 |= HE_PREP(DATA5_GI, status->rate->he_gi);
451
452 switch (status->rate->bw) {
453 case RATE_INFO_BW_20:
454 he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
455 IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_20MHZ);
456 break;
457 case RATE_INFO_BW_40:
458 he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
459 IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_40MHZ);
460 break;
461 case RATE_INFO_BW_80:
462 he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
463 IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_80MHZ);
464 break;
465 case RATE_INFO_BW_160:
466 he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
467 IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_160MHZ);
468 break;
469 case RATE_INFO_BW_HE_RU:
470#define CHECK_RU_ALLOC(s) \
471 BUILD_BUG_ON(IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_##s##T != \
472 NL80211_RATE_INFO_HE_RU_ALLOC_##s + 4)
473
474 CHECK_RU_ALLOC(26);
475 CHECK_RU_ALLOC(52);
476 CHECK_RU_ALLOC(106);
477 CHECK_RU_ALLOC(242);
478 CHECK_RU_ALLOC(484);
479 CHECK_RU_ALLOC(996);
480 CHECK_RU_ALLOC(2x996);
481
482 he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
483 status->rate->he_ru_alloc + 4);
484 break;
485 default:
486 WARN_ONCE(1, "Invalid SU BW %d\n", status->rate->bw);
487 }
488
489 pos += sizeof(struct ieee80211_radiotap_he);
490 }
491
492 if ((status && status->rate) || info->status.rates[0].idx < 0)
493 return;
494
495
496
497 if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
498 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
499 pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
500 IEEE80211_RADIOTAP_MCS_HAVE_GI |
501 IEEE80211_RADIOTAP_MCS_HAVE_BW;
502 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
503 pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
504 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
505 pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
506 if (info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)
507 pos[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF;
508 pos[2] = info->status.rates[0].idx;
509 pos += 3;
510 } else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
511 u16 known = local->hw.radiotap_vht_details &
512 (IEEE80211_RADIOTAP_VHT_KNOWN_GI |
513 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
514
515 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT);
516
517
518 pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
519
520
521 put_unaligned_le16(known, pos);
522 pos += 2;
523
524
525 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
526 *pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
527 pos++;
528
529
530 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
531 *pos = 1;
532 else if (info->status.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
533 *pos = 4;
534 else if (info->status.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
535 *pos = 11;
536 else
537 *pos = 0;
538 pos++;
539
540
541 *pos = (ieee80211_rate_get_vht_mcs(&info->status.rates[0]) << 4) |
542 ieee80211_rate_get_vht_nss(&info->status.rates[0]);
543 pos += 4;
544
545
546 pos++;
547
548 pos++;
549
550 pos += 2;
551 }
552}
553
554
555
556
557
558static void ieee80211_tdls_td_tx_handle(struct ieee80211_local *local,
559 struct ieee80211_sub_if_data *sdata,
560 struct sk_buff *skb, u32 flags)
561{
562 struct sk_buff *teardown_skb;
563 struct sk_buff *orig_teardown_skb;
564 bool is_teardown = false;
565
566
567 spin_lock(&sdata->u.mgd.teardown_lock);
568 teardown_skb = sdata->u.mgd.teardown_skb;
569 orig_teardown_skb = sdata->u.mgd.orig_teardown_skb;
570 if ((skb == orig_teardown_skb) && teardown_skb) {
571 sdata->u.mgd.teardown_skb = NULL;
572 sdata->u.mgd.orig_teardown_skb = NULL;
573 is_teardown = true;
574 }
575 spin_unlock(&sdata->u.mgd.teardown_lock);
576
577 if (is_teardown) {
578
579 WARN_ON(!ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS));
580
581
582 if (flags & IEEE80211_TX_STAT_ACK) {
583 dev_kfree_skb_any(teardown_skb);
584 } else {
585 tdls_dbg(sdata,
586 "TDLS Resending teardown through AP\n");
587
588 ieee80211_subif_start_xmit(teardown_skb, skb->dev);
589 }
590 }
591}
592
593static struct ieee80211_sub_if_data *
594ieee80211_sdata_from_skb(struct ieee80211_local *local, struct sk_buff *skb)
595{
596 struct ieee80211_sub_if_data *sdata;
597
598 if (skb->dev) {
599 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
600 if (!sdata->dev)
601 continue;
602
603 if (skb->dev == sdata->dev)
604 return sdata;
605 }
606
607 return NULL;
608 }
609
610 return rcu_dereference(local->p2p_sdata);
611}
612
613static void ieee80211_report_ack_skb(struct ieee80211_local *local,
614 struct ieee80211_tx_info *info,
615 bool acked, bool dropped)
616{
617 struct sk_buff *skb;
618 unsigned long flags;
619
620 spin_lock_irqsave(&local->ack_status_lock, flags);
621 skb = idr_remove(&local->ack_status_frames, info->ack_frame_id);
622 spin_unlock_irqrestore(&local->ack_status_lock, flags);
623
624 if (!skb)
625 return;
626
627 if (info->flags & IEEE80211_TX_INTFL_NL80211_FRAME_TX) {
628 u64 cookie = IEEE80211_SKB_CB(skb)->ack.cookie;
629 struct ieee80211_sub_if_data *sdata;
630 struct ieee80211_hdr *hdr = (void *)skb->data;
631
632 rcu_read_lock();
633 sdata = ieee80211_sdata_from_skb(local, skb);
634 if (sdata) {
635 if (skb->protocol == sdata->control_port_protocol ||
636 skb->protocol == cpu_to_be16(ETH_P_PREAUTH))
637 cfg80211_control_port_tx_status(&sdata->wdev,
638 cookie,
639 skb->data,
640 skb->len,
641 acked,
642 GFP_ATOMIC);
643 else if (ieee80211_is_any_nullfunc(hdr->frame_control))
644 cfg80211_probe_status(sdata->dev, hdr->addr1,
645 cookie, acked,
646 info->status.ack_signal,
647 info->status.is_valid_ack_signal,
648 GFP_ATOMIC);
649 else if (ieee80211_is_mgmt(hdr->frame_control))
650 cfg80211_mgmt_tx_status(&sdata->wdev, cookie,
651 skb->data, skb->len,
652 acked, GFP_ATOMIC);
653 else
654 pr_warn("Unknown status report in ack skb\n");
655
656 }
657 rcu_read_unlock();
658
659 dev_kfree_skb_any(skb);
660 } else if (dropped) {
661 dev_kfree_skb_any(skb);
662 } else {
663
664 skb_complete_wifi_ack(skb, acked);
665 }
666}
667
668static void ieee80211_report_used_skb(struct ieee80211_local *local,
669 struct sk_buff *skb, bool dropped)
670{
671 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
672 u16 tx_time_est = ieee80211_info_get_tx_time_est(info);
673 struct ieee80211_hdr *hdr = (void *)skb->data;
674 bool acked = info->flags & IEEE80211_TX_STAT_ACK;
675
676 if (dropped)
677 acked = false;
678
679 if (tx_time_est) {
680 struct sta_info *sta;
681
682 rcu_read_lock();
683
684 sta = sta_info_get_by_addrs(local, hdr->addr1, hdr->addr2);
685 ieee80211_sta_update_pending_airtime(local, sta,
686 skb_get_queue_mapping(skb),
687 tx_time_est,
688 true);
689 rcu_read_unlock();
690 }
691
692 if (info->flags & IEEE80211_TX_INTFL_MLME_CONN_TX) {
693 struct ieee80211_sub_if_data *sdata;
694
695 rcu_read_lock();
696
697 sdata = ieee80211_sdata_from_skb(local, skb);
698
699 if (!sdata) {
700 skb->dev = NULL;
701 } else {
702 unsigned int hdr_size =
703 ieee80211_hdrlen(hdr->frame_control);
704
705
706 if (ieee80211_is_data(hdr->frame_control) &&
707 (ieee80211_get_tdls_action(skb, hdr_size) ==
708 WLAN_TDLS_TEARDOWN))
709 ieee80211_tdls_td_tx_handle(local, sdata, skb,
710 info->flags);
711 else
712 ieee80211_mgd_conn_tx_status(sdata,
713 hdr->frame_control,
714 acked);
715 }
716
717 rcu_read_unlock();
718 } else if (info->ack_frame_id) {
719 ieee80211_report_ack_skb(local, info, acked, dropped);
720 }
721
722 if (!dropped && skb->destructor) {
723 skb->wifi_acked_valid = 1;
724 skb->wifi_acked = acked;
725 }
726
727 ieee80211_led_tx(local);
728
729 if (skb_has_frag_list(skb)) {
730 kfree_skb_list(skb_shinfo(skb)->frag_list);
731 skb_shinfo(skb)->frag_list = NULL;
732 }
733}
734
735
736
737
738
739
740
741
742#define STA_LOST_PKT_THRESHOLD 50
743#define STA_LOST_PKT_TIME HZ
744#define STA_LOST_TDLS_PKT_THRESHOLD 10
745#define STA_LOST_TDLS_PKT_TIME (10*HZ)
746
747static void ieee80211_lost_packet(struct sta_info *sta,
748 struct ieee80211_tx_info *info)
749{
750 unsigned long pkt_time = STA_LOST_PKT_TIME;
751 unsigned int pkt_thr = STA_LOST_PKT_THRESHOLD;
752
753
754
755
756 if (ieee80211_hw_check(&sta->local->hw, REPORTS_LOW_ACK))
757 return;
758
759
760 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
761 !(info->flags & IEEE80211_TX_STAT_AMPDU))
762 return;
763
764 sta->status_stats.lost_packets++;
765 if (sta->sta.tdls) {
766 pkt_time = STA_LOST_TDLS_PKT_TIME;
767 pkt_thr = STA_LOST_PKT_THRESHOLD;
768 }
769
770
771
772
773
774
775
776
777 if (sta->status_stats.lost_packets < pkt_thr ||
778 !time_after(jiffies, sta->status_stats.last_pkt_time + pkt_time))
779 return;
780
781 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
782 sta->status_stats.lost_packets, GFP_ATOMIC);
783 sta->status_stats.lost_packets = 0;
784}
785
786static int ieee80211_tx_get_rates(struct ieee80211_hw *hw,
787 struct ieee80211_tx_info *info,
788 int *retry_count)
789{
790 int count = -1;
791 int i;
792
793 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
794 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
795 !(info->flags & IEEE80211_TX_STAT_AMPDU)) {
796
797 info->status.rates[i].idx = -1;
798 info->status.rates[i].count = 0;
799 break;
800 } else if (info->status.rates[i].idx < 0) {
801 break;
802 } else if (i >= hw->max_report_rates) {
803
804 info->status.rates[i].idx = -1;
805 info->status.rates[i].count = 0;
806 break;
807 }
808
809 count += info->status.rates[i].count;
810 }
811
812 if (count < 0)
813 count = 0;
814
815 *retry_count = count;
816 return i - 1;
817}
818
819void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
820 struct ieee80211_supported_band *sband,
821 int retry_count, int shift, bool send_to_cooked,
822 struct ieee80211_tx_status *status)
823{
824 struct sk_buff *skb2;
825 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
826 struct ieee80211_sub_if_data *sdata;
827 struct net_device *prev_dev = NULL;
828 int rtap_len;
829
830
831 rtap_len = ieee80211_tx_radiotap_len(info, status);
832 if (WARN_ON_ONCE(skb_headroom(skb) < rtap_len)) {
833 pr_err("ieee80211_tx_status: headroom too small\n");
834 dev_kfree_skb(skb);
835 return;
836 }
837 ieee80211_add_tx_radiotap_header(local, sband, skb, retry_count,
838 rtap_len, shift, status);
839
840
841 skb_reset_mac_header(skb);
842 skb->ip_summed = CHECKSUM_UNNECESSARY;
843 skb->pkt_type = PACKET_OTHERHOST;
844 skb->protocol = htons(ETH_P_802_2);
845 memset(skb->cb, 0, sizeof(skb->cb));
846
847 rcu_read_lock();
848 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
849 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
850 if (!ieee80211_sdata_running(sdata))
851 continue;
852
853 if ((sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) &&
854 !send_to_cooked)
855 continue;
856
857 if (prev_dev) {
858 skb2 = skb_clone(skb, GFP_ATOMIC);
859 if (skb2) {
860 skb2->dev = prev_dev;
861 netif_rx(skb2);
862 }
863 }
864
865 prev_dev = sdata->dev;
866 }
867 }
868 if (prev_dev) {
869 skb->dev = prev_dev;
870 netif_rx(skb);
871 skb = NULL;
872 }
873 rcu_read_unlock();
874 dev_kfree_skb(skb);
875}
876
877static void __ieee80211_tx_status(struct ieee80211_hw *hw,
878 struct ieee80211_tx_status *status,
879 int rates_idx, int retry_count)
880{
881 struct sk_buff *skb = status->skb;
882 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
883 struct ieee80211_local *local = hw_to_local(hw);
884 struct ieee80211_tx_info *info = status->info;
885 struct sta_info *sta;
886 __le16 fc;
887 struct ieee80211_supported_band *sband;
888 bool send_to_cooked;
889 bool acked;
890 bool noack_success;
891 struct ieee80211_bar *bar;
892 int shift = 0;
893 int tid = IEEE80211_NUM_TIDS;
894
895 sband = local->hw.wiphy->bands[info->band];
896 fc = hdr->frame_control;
897
898 if (status->sta) {
899 sta = container_of(status->sta, struct sta_info, sta);
900 shift = ieee80211_vif_get_shift(&sta->sdata->vif);
901
902 if (info->flags & IEEE80211_TX_STATUS_EOSP)
903 clear_sta_flag(sta, WLAN_STA_SP);
904
905 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
906 noack_success = !!(info->flags &
907 IEEE80211_TX_STAT_NOACK_TRANSMITTED);
908
909
910 if (ieee80211_vif_is_mesh(&sta->sdata->vif) &&
911 ieee80211_is_data_qos(fc))
912 ieee80211_mpsp_trigger_process(
913 ieee80211_get_qos_ctl(hdr), sta, true, acked);
914
915 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL) &&
916 (ieee80211_is_data(hdr->frame_control)) &&
917 (rates_idx != -1))
918 sta->tx_stats.last_rate =
919 info->status.rates[rates_idx];
920
921 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
922 (ieee80211_is_data_qos(fc))) {
923 u16 ssn;
924 u8 *qc;
925
926 qc = ieee80211_get_qos_ctl(hdr);
927 tid = qc[0] & 0xf;
928 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
929 & IEEE80211_SCTL_SEQ);
930 ieee80211_send_bar(&sta->sdata->vif, hdr->addr1,
931 tid, ssn);
932 } else if (ieee80211_is_data_qos(fc)) {
933 u8 *qc = ieee80211_get_qos_ctl(hdr);
934
935 tid = qc[0] & 0xf;
936 }
937
938 if (!acked && ieee80211_is_back_req(fc)) {
939 u16 control;
940
941
942
943
944
945
946 bar = (struct ieee80211_bar *) skb->data;
947 control = le16_to_cpu(bar->control);
948 if (!(control & IEEE80211_BAR_CTRL_MULTI_TID)) {
949 u16 ssn = le16_to_cpu(bar->start_seq_num);
950
951 tid = (control &
952 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
953 IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
954
955 ieee80211_set_bar_pending(sta, tid, ssn);
956 }
957 }
958
959 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
960 ieee80211_handle_filtered_frame(local, sta, skb);
961 return;
962 } else if (ieee80211_is_data_present(fc)) {
963 if (!acked && !noack_success)
964 sta->status_stats.msdu_failed[tid]++;
965
966 sta->status_stats.msdu_retries[tid] +=
967 retry_count;
968 }
969
970 if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
971 ieee80211_frame_acked(sta, skb);
972
973 }
974
975
976
977
978
979 if ((info->flags & IEEE80211_TX_STAT_ACK) ||
980 (info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED)) {
981 if (ieee80211_is_first_frag(hdr->seq_ctrl)) {
982 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
983 if (is_multicast_ether_addr(ieee80211_get_DA(hdr)))
984 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
985 if (retry_count > 0)
986 I802_DEBUG_INC(local->dot11RetryCount);
987 if (retry_count > 1)
988 I802_DEBUG_INC(local->dot11MultipleRetryCount);
989 }
990
991
992
993
994
995 if (!is_multicast_ether_addr(hdr->addr1) ||
996 ieee80211_is_data(fc) ||
997 ieee80211_is_mgmt(fc))
998 I802_DEBUG_INC(local->dot11TransmittedFragmentCount);
999 } else {
1000 if (ieee80211_is_first_frag(hdr->seq_ctrl))
1001 I802_DEBUG_INC(local->dot11FailedCount);
1002 }
1003
1004 if (ieee80211_is_any_nullfunc(fc) &&
1005 ieee80211_has_pm(fc) &&
1006 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS) &&
1007 !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
1008 local->ps_sdata && !(local->scanning)) {
1009 if (info->flags & IEEE80211_TX_STAT_ACK) {
1010 local->ps_sdata->u.mgd.flags |=
1011 IEEE80211_STA_NULLFUNC_ACKED;
1012 } else
1013 mod_timer(&local->dynamic_ps_timer, jiffies +
1014 msecs_to_jiffies(10));
1015 }
1016
1017 ieee80211_report_used_skb(local, skb, false);
1018
1019
1020 skb_orphan(skb);
1021
1022
1023 send_to_cooked = !!(info->flags & IEEE80211_TX_CTL_INJECTED) ||
1024 !(ieee80211_is_data(fc));
1025
1026
1027
1028
1029
1030 if (!local->monitors && (!send_to_cooked || !local->cooked_mntrs)) {
1031 if (status->free_list)
1032 list_add_tail(&skb->list, status->free_list);
1033 else
1034 dev_kfree_skb(skb);
1035 return;
1036 }
1037
1038
1039 ieee80211_tx_monitor(local, skb, sband, retry_count, shift,
1040 send_to_cooked, status);
1041}
1042
1043void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
1044{
1045 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1046 struct ieee80211_local *local = hw_to_local(hw);
1047 struct ieee80211_tx_status status = {
1048 .skb = skb,
1049 .info = IEEE80211_SKB_CB(skb),
1050 };
1051 struct sta_info *sta;
1052
1053 rcu_read_lock();
1054
1055 sta = sta_info_get_by_addrs(local, hdr->addr1, hdr->addr2);
1056 if (sta)
1057 status.sta = &sta->sta;
1058
1059 ieee80211_tx_status_ext(hw, &status);
1060 rcu_read_unlock();
1061}
1062EXPORT_SYMBOL(ieee80211_tx_status);
1063
1064void ieee80211_tx_status_ext(struct ieee80211_hw *hw,
1065 struct ieee80211_tx_status *status)
1066{
1067 struct ieee80211_local *local = hw_to_local(hw);
1068 struct ieee80211_tx_info *info = status->info;
1069 struct ieee80211_sta *pubsta = status->sta;
1070 struct sk_buff *skb = status->skb;
1071 struct ieee80211_supported_band *sband;
1072 struct sta_info *sta = NULL;
1073 int rates_idx, retry_count;
1074 bool acked, noack_success;
1075 u16 tx_time_est;
1076
1077 if (pubsta) {
1078 sta = container_of(pubsta, struct sta_info, sta);
1079
1080 if (status->rate)
1081 sta->tx_stats.last_rate_info = *status->rate;
1082 }
1083
1084 if (skb && (tx_time_est =
1085 ieee80211_info_get_tx_time_est(IEEE80211_SKB_CB(skb))) > 0) {
1086
1087
1088
1089 ieee80211_sta_update_pending_airtime(local, sta,
1090 skb_get_queue_mapping(skb),
1091 tx_time_est,
1092 true);
1093 ieee80211_info_set_tx_time_est(IEEE80211_SKB_CB(skb), 0);
1094 }
1095
1096 if (!status->info)
1097 goto free;
1098
1099 rates_idx = ieee80211_tx_get_rates(hw, info, &retry_count);
1100
1101 sband = hw->wiphy->bands[info->band];
1102
1103 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
1104 noack_success = !!(info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED);
1105
1106 if (pubsta) {
1107 struct ieee80211_sub_if_data *sdata = sta->sdata;
1108
1109 if (!acked && !noack_success)
1110 sta->status_stats.retry_failed++;
1111 sta->status_stats.retry_count += retry_count;
1112
1113 if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
1114 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1115 skb && !(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP))
1116 ieee80211_sta_tx_notify(sdata, (void *) skb->data,
1117 acked, info->status.tx_time);
1118
1119 if (acked) {
1120 sta->status_stats.last_ack = jiffies;
1121
1122 if (sta->status_stats.lost_packets)
1123 sta->status_stats.lost_packets = 0;
1124
1125
1126 sta->status_stats.last_pkt_time = jiffies;
1127
1128
1129 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1130 unlikely(sdata->u.mgd.probe_send_count > 0))
1131 sdata->u.mgd.probe_send_count = 0;
1132
1133 if (info->status.is_valid_ack_signal) {
1134 sta->status_stats.last_ack_signal =
1135 (s8)info->status.ack_signal;
1136 sta->status_stats.ack_signal_filled = true;
1137 ewma_avg_signal_add(&sta->status_stats.avg_ack_signal,
1138 -info->status.ack_signal);
1139 }
1140 } else if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
1141
1142
1143
1144
1145 if (skb)
1146 ieee80211_handle_filtered_frame(local, sta, skb);
1147 return;
1148 } else if (noack_success) {
1149
1150 } else {
1151 ieee80211_lost_packet(sta, info);
1152 }
1153 }
1154
1155 rate_control_tx_status(local, sband, status);
1156 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
1157 ieee80211s_update_metric(local, sta, status);
1158 }
1159
1160 if (skb && !(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP))
1161 return __ieee80211_tx_status(hw, status, rates_idx,
1162 retry_count);
1163
1164 if (acked || noack_success) {
1165 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
1166 if (!pubsta)
1167 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
1168 if (retry_count > 0)
1169 I802_DEBUG_INC(local->dot11RetryCount);
1170 if (retry_count > 1)
1171 I802_DEBUG_INC(local->dot11MultipleRetryCount);
1172 } else {
1173 I802_DEBUG_INC(local->dot11FailedCount);
1174 }
1175
1176free:
1177 if (!skb)
1178 return;
1179
1180 ieee80211_report_used_skb(local, skb, false);
1181 if (status->free_list)
1182 list_add_tail(&skb->list, status->free_list);
1183 else
1184 dev_kfree_skb(skb);
1185}
1186EXPORT_SYMBOL(ieee80211_tx_status_ext);
1187
1188void ieee80211_tx_rate_update(struct ieee80211_hw *hw,
1189 struct ieee80211_sta *pubsta,
1190 struct ieee80211_tx_info *info)
1191{
1192 struct ieee80211_local *local = hw_to_local(hw);
1193 struct ieee80211_supported_band *sband = hw->wiphy->bands[info->band];
1194 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1195 struct ieee80211_tx_status status = {
1196 .info = info,
1197 .sta = pubsta,
1198 };
1199
1200 rate_control_tx_status(local, sband, &status);
1201
1202 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
1203 sta->tx_stats.last_rate = info->status.rates[0];
1204}
1205EXPORT_SYMBOL(ieee80211_tx_rate_update);
1206
1207void ieee80211_tx_status_8023(struct ieee80211_hw *hw,
1208 struct ieee80211_vif *vif,
1209 struct sk_buff *skb)
1210{
1211 struct ieee80211_sub_if_data *sdata;
1212 struct ieee80211_tx_status status = {
1213 .skb = skb,
1214 .info = IEEE80211_SKB_CB(skb),
1215 };
1216 struct sta_info *sta;
1217
1218 sdata = vif_to_sdata(vif);
1219
1220 rcu_read_lock();
1221
1222 if (!ieee80211_lookup_ra_sta(sdata, skb, &sta) && !IS_ERR(sta))
1223 status.sta = &sta->sta;
1224
1225 ieee80211_tx_status_ext(hw, &status);
1226
1227 rcu_read_unlock();
1228}
1229EXPORT_SYMBOL(ieee80211_tx_status_8023);
1230
1231void ieee80211_report_low_ack(struct ieee80211_sta *pubsta, u32 num_packets)
1232{
1233 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1234 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
1235 num_packets, GFP_ATOMIC);
1236}
1237EXPORT_SYMBOL(ieee80211_report_low_ack);
1238
1239void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
1240{
1241 struct ieee80211_local *local = hw_to_local(hw);
1242
1243 ieee80211_report_used_skb(local, skb, true);
1244 dev_kfree_skb_any(skb);
1245}
1246EXPORT_SYMBOL(ieee80211_free_txskb);
1247
1248void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
1249 struct sk_buff_head *skbs)
1250{
1251 struct sk_buff *skb;
1252
1253 while ((skb = __skb_dequeue(skbs)))
1254 ieee80211_free_txskb(hw, skb);
1255}
1256