This source file includes following definitions.
- ieee80211_tx_status_irqsafe
- ieee80211_handle_filtered_frame
- ieee80211_check_pending_bar
- ieee80211_frame_acked
- ieee80211_set_bar_pending
- ieee80211_tx_radiotap_len
- ieee80211_add_tx_radiotap_header
- ieee80211_tdls_td_tx_handle
- ieee80211_sdata_from_skb
- ieee80211_report_ack_skb
- ieee80211_report_used_skb
- ieee80211_lost_packet
- ieee80211_tx_get_rates
- ieee80211_tx_monitor
- __ieee80211_tx_status
- ieee80211_tx_status
- ieee80211_tx_status_ext
- ieee80211_tx_rate_update
- ieee80211_report_low_ack
- ieee80211_free_txskb
- ieee80211_purge_tx_queue
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
21 void 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 }
41 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
42
43 static 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
170 static 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
182 static 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
245 static 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
257 static 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
300 static void
301 ieee80211_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
569 static 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
604 static struct ieee80211_sub_if_data *
605 ieee80211_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
624 static 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
668 static 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 struct ieee80211_hdr *hdr = (void *)skb->data;
673 bool acked = info->flags & IEEE80211_TX_STAT_ACK;
674
675 if (dropped)
676 acked = false;
677
678 if (info->flags & IEEE80211_TX_INTFL_MLME_CONN_TX) {
679 struct ieee80211_sub_if_data *sdata;
680
681 rcu_read_lock();
682
683 sdata = ieee80211_sdata_from_skb(local, skb);
684
685 if (!sdata) {
686 skb->dev = NULL;
687 } else {
688 unsigned int hdr_size =
689 ieee80211_hdrlen(hdr->frame_control);
690
691
692 if (ieee80211_is_data(hdr->frame_control) &&
693 (ieee80211_get_tdls_action(skb, hdr_size) ==
694 WLAN_TDLS_TEARDOWN))
695 ieee80211_tdls_td_tx_handle(local, sdata, skb,
696 info->flags);
697 else
698 ieee80211_mgd_conn_tx_status(sdata,
699 hdr->frame_control,
700 acked);
701 }
702
703 rcu_read_unlock();
704 } else if (info->ack_frame_id) {
705 ieee80211_report_ack_skb(local, info, acked, dropped);
706 }
707
708 if (!dropped && skb->destructor) {
709 skb->wifi_acked_valid = 1;
710 skb->wifi_acked = acked;
711 }
712
713 ieee80211_led_tx(local);
714
715 if (skb_has_frag_list(skb)) {
716 kfree_skb_list(skb_shinfo(skb)->frag_list);
717 skb_shinfo(skb)->frag_list = NULL;
718 }
719 }
720
721
722
723
724
725
726
727
728 #define STA_LOST_PKT_THRESHOLD 50
729 #define STA_LOST_TDLS_PKT_THRESHOLD 10
730 #define STA_LOST_TDLS_PKT_TIME (10*HZ)
731
732 static void ieee80211_lost_packet(struct sta_info *sta,
733 struct ieee80211_tx_info *info)
734 {
735
736
737
738 if (ieee80211_hw_check(&sta->local->hw, REPORTS_LOW_ACK))
739 return;
740
741
742 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
743 !(info->flags & IEEE80211_TX_STAT_AMPDU))
744 return;
745
746 sta->status_stats.lost_packets++;
747 if (!sta->sta.tdls &&
748 sta->status_stats.lost_packets < STA_LOST_PKT_THRESHOLD)
749 return;
750
751
752
753
754
755
756
757 if (sta->sta.tdls &&
758 (sta->status_stats.lost_packets < STA_LOST_TDLS_PKT_THRESHOLD ||
759 time_before(jiffies,
760 sta->status_stats.last_tdls_pkt_time +
761 STA_LOST_TDLS_PKT_TIME)))
762 return;
763
764 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
765 sta->status_stats.lost_packets, GFP_ATOMIC);
766 sta->status_stats.lost_packets = 0;
767 }
768
769 static int ieee80211_tx_get_rates(struct ieee80211_hw *hw,
770 struct ieee80211_tx_info *info,
771 int *retry_count)
772 {
773 int rates_idx = -1;
774 int count = -1;
775 int i;
776
777 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
778 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
779 !(info->flags & IEEE80211_TX_STAT_AMPDU)) {
780
781 info->status.rates[i].idx = -1;
782 info->status.rates[i].count = 0;
783 break;
784 } else if (info->status.rates[i].idx < 0) {
785 break;
786 } else if (i >= hw->max_report_rates) {
787
788 info->status.rates[i].idx = -1;
789 info->status.rates[i].count = 0;
790 break;
791 }
792
793 count += info->status.rates[i].count;
794 }
795 rates_idx = i - 1;
796
797 if (count < 0)
798 count = 0;
799
800 *retry_count = count;
801 return rates_idx;
802 }
803
804 void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
805 struct ieee80211_supported_band *sband,
806 int retry_count, int shift, bool send_to_cooked,
807 struct ieee80211_tx_status *status)
808 {
809 struct sk_buff *skb2;
810 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
811 struct ieee80211_sub_if_data *sdata;
812 struct net_device *prev_dev = NULL;
813 int rtap_len;
814
815
816 rtap_len = ieee80211_tx_radiotap_len(info, status);
817 if (WARN_ON_ONCE(skb_headroom(skb) < rtap_len)) {
818 pr_err("ieee80211_tx_status: headroom too small\n");
819 dev_kfree_skb(skb);
820 return;
821 }
822 ieee80211_add_tx_radiotap_header(local, sband, skb, retry_count,
823 rtap_len, shift, status);
824
825
826 skb_reset_mac_header(skb);
827 skb->ip_summed = CHECKSUM_UNNECESSARY;
828 skb->pkt_type = PACKET_OTHERHOST;
829 skb->protocol = htons(ETH_P_802_2);
830 memset(skb->cb, 0, sizeof(skb->cb));
831
832 rcu_read_lock();
833 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
834 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
835 if (!ieee80211_sdata_running(sdata))
836 continue;
837
838 if ((sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) &&
839 !send_to_cooked)
840 continue;
841
842 if (prev_dev) {
843 skb2 = skb_clone(skb, GFP_ATOMIC);
844 if (skb2) {
845 skb2->dev = prev_dev;
846 netif_rx(skb2);
847 }
848 }
849
850 prev_dev = sdata->dev;
851 }
852 }
853 if (prev_dev) {
854 skb->dev = prev_dev;
855 netif_rx(skb);
856 skb = NULL;
857 }
858 rcu_read_unlock();
859 dev_kfree_skb(skb);
860 }
861
862 static void __ieee80211_tx_status(struct ieee80211_hw *hw,
863 struct ieee80211_tx_status *status)
864 {
865 struct sk_buff *skb = status->skb;
866 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
867 struct ieee80211_local *local = hw_to_local(hw);
868 struct ieee80211_tx_info *info = status->info;
869 struct sta_info *sta;
870 __le16 fc;
871 struct ieee80211_supported_band *sband;
872 int retry_count;
873 int rates_idx;
874 bool send_to_cooked;
875 bool acked;
876 struct ieee80211_bar *bar;
877 int shift = 0;
878 int tid = IEEE80211_NUM_TIDS;
879
880 rates_idx = ieee80211_tx_get_rates(hw, info, &retry_count);
881
882 sband = local->hw.wiphy->bands[info->band];
883 fc = hdr->frame_control;
884
885 if (status->sta) {
886 sta = container_of(status->sta, struct sta_info, sta);
887 shift = ieee80211_vif_get_shift(&sta->sdata->vif);
888
889 if (info->flags & IEEE80211_TX_STATUS_EOSP)
890 clear_sta_flag(sta, WLAN_STA_SP);
891
892 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
893
894
895 if (ieee80211_vif_is_mesh(&sta->sdata->vif) &&
896 ieee80211_is_data_qos(fc))
897 ieee80211_mpsp_trigger_process(
898 ieee80211_get_qos_ctl(hdr), sta, true, acked);
899
900 if (!acked && test_sta_flag(sta, WLAN_STA_PS_STA)) {
901
902
903
904
905 ieee80211_handle_filtered_frame(local, sta, skb);
906 return;
907 }
908
909 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL) &&
910 (ieee80211_is_data(hdr->frame_control)) &&
911 (rates_idx != -1))
912 sta->tx_stats.last_rate =
913 info->status.rates[rates_idx];
914
915 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
916 (ieee80211_is_data_qos(fc))) {
917 u16 ssn;
918 u8 *qc;
919
920 qc = ieee80211_get_qos_ctl(hdr);
921 tid = qc[0] & 0xf;
922 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
923 & IEEE80211_SCTL_SEQ);
924 ieee80211_send_bar(&sta->sdata->vif, hdr->addr1,
925 tid, ssn);
926 } else if (ieee80211_is_data_qos(fc)) {
927 u8 *qc = ieee80211_get_qos_ctl(hdr);
928
929 tid = qc[0] & 0xf;
930 }
931
932 if (!acked && ieee80211_is_back_req(fc)) {
933 u16 control;
934
935
936
937
938
939
940 bar = (struct ieee80211_bar *) skb->data;
941 control = le16_to_cpu(bar->control);
942 if (!(control & IEEE80211_BAR_CTRL_MULTI_TID)) {
943 u16 ssn = le16_to_cpu(bar->start_seq_num);
944
945 tid = (control &
946 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
947 IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
948
949 ieee80211_set_bar_pending(sta, tid, ssn);
950 }
951 }
952
953 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
954 ieee80211_handle_filtered_frame(local, sta, skb);
955 return;
956 } else {
957 if (!acked)
958 sta->status_stats.retry_failed++;
959 sta->status_stats.retry_count += retry_count;
960
961 if (ieee80211_is_data_present(fc)) {
962 if (!acked)
963 sta->status_stats.msdu_failed[tid]++;
964
965 sta->status_stats.msdu_retries[tid] +=
966 retry_count;
967 }
968 }
969
970 rate_control_tx_status(local, sband, status);
971 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
972 ieee80211s_update_metric(local, sta, status);
973
974 if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
975 ieee80211_frame_acked(sta, skb);
976
977 if ((sta->sdata->vif.type == NL80211_IFTYPE_STATION) &&
978 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS))
979 ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data,
980 acked, info->status.tx_time);
981
982 if (info->status.tx_time &&
983 wiphy_ext_feature_isset(local->hw.wiphy,
984 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
985 ieee80211_sta_register_airtime(&sta->sta, tid,
986 info->status.tx_time, 0);
987
988 if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
989 if (info->flags & IEEE80211_TX_STAT_ACK) {
990 if (sta->status_stats.lost_packets)
991 sta->status_stats.lost_packets = 0;
992
993
994 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
995 sta->status_stats.last_tdls_pkt_time =
996 jiffies;
997 } else {
998 ieee80211_lost_packet(sta, info);
999 }
1000 }
1001 }
1002
1003
1004
1005
1006
1007 if ((info->flags & IEEE80211_TX_STAT_ACK) ||
1008 (info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED)) {
1009 if (ieee80211_is_first_frag(hdr->seq_ctrl)) {
1010 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
1011 if (is_multicast_ether_addr(ieee80211_get_DA(hdr)))
1012 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
1013 if (retry_count > 0)
1014 I802_DEBUG_INC(local->dot11RetryCount);
1015 if (retry_count > 1)
1016 I802_DEBUG_INC(local->dot11MultipleRetryCount);
1017 }
1018
1019
1020
1021
1022
1023 if (!is_multicast_ether_addr(hdr->addr1) ||
1024 ieee80211_is_data(fc) ||
1025 ieee80211_is_mgmt(fc))
1026 I802_DEBUG_INC(local->dot11TransmittedFragmentCount);
1027 } else {
1028 if (ieee80211_is_first_frag(hdr->seq_ctrl))
1029 I802_DEBUG_INC(local->dot11FailedCount);
1030 }
1031
1032 if (ieee80211_is_any_nullfunc(fc) &&
1033 ieee80211_has_pm(fc) &&
1034 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS) &&
1035 !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
1036 local->ps_sdata && !(local->scanning)) {
1037 if (info->flags & IEEE80211_TX_STAT_ACK) {
1038 local->ps_sdata->u.mgd.flags |=
1039 IEEE80211_STA_NULLFUNC_ACKED;
1040 } else
1041 mod_timer(&local->dynamic_ps_timer, jiffies +
1042 msecs_to_jiffies(10));
1043 }
1044
1045 ieee80211_report_used_skb(local, skb, false);
1046
1047
1048 skb_orphan(skb);
1049
1050
1051 send_to_cooked = !!(info->flags & IEEE80211_TX_CTL_INJECTED) ||
1052 !(ieee80211_is_data(fc));
1053
1054
1055
1056
1057
1058 if (!local->monitors && (!send_to_cooked || !local->cooked_mntrs)) {
1059 dev_kfree_skb(skb);
1060 return;
1061 }
1062
1063
1064 ieee80211_tx_monitor(local, skb, sband, retry_count, shift,
1065 send_to_cooked, status);
1066 }
1067
1068 void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
1069 {
1070 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1071 struct ieee80211_local *local = hw_to_local(hw);
1072 struct ieee80211_tx_status status = {
1073 .skb = skb,
1074 .info = IEEE80211_SKB_CB(skb),
1075 };
1076 struct rhlist_head *tmp;
1077 struct sta_info *sta;
1078
1079 rcu_read_lock();
1080
1081 for_each_sta_info(local, hdr->addr1, sta, tmp) {
1082
1083 if (!ether_addr_equal(hdr->addr2, sta->sdata->vif.addr))
1084 continue;
1085
1086 status.sta = &sta->sta;
1087 break;
1088 }
1089
1090 __ieee80211_tx_status(hw, &status);
1091 rcu_read_unlock();
1092 }
1093 EXPORT_SYMBOL(ieee80211_tx_status);
1094
1095 void ieee80211_tx_status_ext(struct ieee80211_hw *hw,
1096 struct ieee80211_tx_status *status)
1097 {
1098 struct ieee80211_local *local = hw_to_local(hw);
1099 struct ieee80211_tx_info *info = status->info;
1100 struct ieee80211_sta *pubsta = status->sta;
1101 struct ieee80211_supported_band *sband;
1102 int retry_count;
1103 bool acked, noack_success;
1104
1105 if (status->skb)
1106 return __ieee80211_tx_status(hw, status);
1107
1108 if (!status->sta)
1109 return;
1110
1111 ieee80211_tx_get_rates(hw, info, &retry_count);
1112
1113 sband = hw->wiphy->bands[info->band];
1114
1115 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
1116 noack_success = !!(info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED);
1117
1118 if (pubsta) {
1119 struct sta_info *sta;
1120
1121 sta = container_of(pubsta, struct sta_info, sta);
1122
1123 if (!acked)
1124 sta->status_stats.retry_failed++;
1125 sta->status_stats.retry_count += retry_count;
1126
1127 if (acked) {
1128 sta->status_stats.last_ack = jiffies;
1129
1130 if (sta->status_stats.lost_packets)
1131 sta->status_stats.lost_packets = 0;
1132
1133
1134 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
1135 sta->status_stats.last_tdls_pkt_time = jiffies;
1136 } else if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
1137 return;
1138 } else {
1139 ieee80211_lost_packet(sta, info);
1140 }
1141
1142 rate_control_tx_status(local, sband, status);
1143 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
1144 ieee80211s_update_metric(local, sta, status);
1145 }
1146
1147 if (acked || noack_success) {
1148 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
1149 if (!pubsta)
1150 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
1151 if (retry_count > 0)
1152 I802_DEBUG_INC(local->dot11RetryCount);
1153 if (retry_count > 1)
1154 I802_DEBUG_INC(local->dot11MultipleRetryCount);
1155 } else {
1156 I802_DEBUG_INC(local->dot11FailedCount);
1157 }
1158 }
1159 EXPORT_SYMBOL(ieee80211_tx_status_ext);
1160
1161 void ieee80211_tx_rate_update(struct ieee80211_hw *hw,
1162 struct ieee80211_sta *pubsta,
1163 struct ieee80211_tx_info *info)
1164 {
1165 struct ieee80211_local *local = hw_to_local(hw);
1166 struct ieee80211_supported_band *sband = hw->wiphy->bands[info->band];
1167 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1168 struct ieee80211_tx_status status = {
1169 .info = info,
1170 .sta = pubsta,
1171 };
1172
1173 rate_control_tx_status(local, sband, &status);
1174
1175 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
1176 sta->tx_stats.last_rate = info->status.rates[0];
1177 }
1178 EXPORT_SYMBOL(ieee80211_tx_rate_update);
1179
1180 void ieee80211_report_low_ack(struct ieee80211_sta *pubsta, u32 num_packets)
1181 {
1182 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1183 cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
1184 num_packets, GFP_ATOMIC);
1185 }
1186 EXPORT_SYMBOL(ieee80211_report_low_ack);
1187
1188 void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
1189 {
1190 struct ieee80211_local *local = hw_to_local(hw);
1191
1192 ieee80211_report_used_skb(local, skb, true);
1193 dev_kfree_skb_any(skb);
1194 }
1195 EXPORT_SYMBOL(ieee80211_free_txskb);
1196
1197 void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
1198 struct sk_buff_head *skbs)
1199 {
1200 struct sk_buff *skb;
1201
1202 while ((skb = __skb_dequeue(skbs)))
1203 ieee80211_free_txskb(hw, skb);
1204 }