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