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