1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/etherdevice.h>
13#include <linux/netdevice.h>
14#include <linux/types.h>
15#include <linux/slab.h>
16#include <linux/skbuff.h>
17#include <linux/if_arp.h>
18#include <linux/timer.h>
19#include <linux/rtnetlink.h>
20
21#include <net/codel.h>
22#include <net/mac80211.h>
23#include "ieee80211_i.h"
24#include "driver-ops.h"
25#include "rate.h"
26#include "sta_info.h"
27#include "debugfs_sta.h"
28#include "mesh.h"
29#include "wme.h"
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67static const struct rhashtable_params sta_rht_params = {
68 .nelem_hint = 3,
69 .automatic_shrinking = true,
70 .head_offset = offsetof(struct sta_info, hash_node),
71 .key_offset = offsetof(struct sta_info, addr),
72 .key_len = ETH_ALEN,
73 .max_size = CONFIG_MAC80211_STA_HASH_MAX_SIZE,
74};
75
76
77static int sta_info_hash_del(struct ieee80211_local *local,
78 struct sta_info *sta)
79{
80 return rhltable_remove(&local->sta_hash, &sta->hash_node,
81 sta_rht_params);
82}
83
84static void __cleanup_single_sta(struct sta_info *sta)
85{
86 int ac, i;
87 struct tid_ampdu_tx *tid_tx;
88 struct ieee80211_sub_if_data *sdata = sta->sdata;
89 struct ieee80211_local *local = sdata->local;
90 struct ps_data *ps;
91
92 if (test_sta_flag(sta, WLAN_STA_PS_STA) ||
93 test_sta_flag(sta, WLAN_STA_PS_DRIVER) ||
94 test_sta_flag(sta, WLAN_STA_PS_DELIVER)) {
95 if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
96 sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
97 ps = &sdata->bss->ps;
98 else if (ieee80211_vif_is_mesh(&sdata->vif))
99 ps = &sdata->u.mesh.ps;
100 else
101 return;
102
103 clear_sta_flag(sta, WLAN_STA_PS_STA);
104 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
105 clear_sta_flag(sta, WLAN_STA_PS_DELIVER);
106
107 atomic_dec(&ps->num_sta_ps);
108 }
109
110 if (sta->sta.txq[0]) {
111 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
112 struct txq_info *txqi;
113
114 if (!sta->sta.txq[i])
115 continue;
116
117 txqi = to_txq_info(sta->sta.txq[i]);
118
119 ieee80211_txq_purge(local, txqi);
120 }
121 }
122
123 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
124 local->total_ps_buffered -= skb_queue_len(&sta->ps_tx_buf[ac]);
125 ieee80211_purge_tx_queue(&local->hw, &sta->ps_tx_buf[ac]);
126 ieee80211_purge_tx_queue(&local->hw, &sta->tx_filtered[ac]);
127 }
128
129 if (ieee80211_vif_is_mesh(&sdata->vif))
130 mesh_sta_cleanup(sta);
131
132 cancel_work_sync(&sta->drv_deliver_wk);
133
134
135
136
137
138
139
140 for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
141 kfree(sta->ampdu_mlme.tid_start_tx[i]);
142 tid_tx = rcu_dereference_raw(sta->ampdu_mlme.tid_tx[i]);
143 if (!tid_tx)
144 continue;
145 ieee80211_purge_tx_queue(&local->hw, &tid_tx->pending);
146 kfree(tid_tx);
147 }
148}
149
150static void cleanup_single_sta(struct sta_info *sta)
151{
152 struct ieee80211_sub_if_data *sdata = sta->sdata;
153 struct ieee80211_local *local = sdata->local;
154
155 __cleanup_single_sta(sta);
156 sta_info_free(local, sta);
157}
158
159struct rhlist_head *sta_info_hash_lookup(struct ieee80211_local *local,
160 const u8 *addr)
161{
162 return rhltable_lookup(&local->sta_hash, addr, sta_rht_params);
163}
164
165
166struct sta_info *sta_info_get(struct ieee80211_sub_if_data *sdata,
167 const u8 *addr)
168{
169 struct ieee80211_local *local = sdata->local;
170 struct rhlist_head *tmp;
171 struct sta_info *sta;
172
173 rcu_read_lock();
174 for_each_sta_info(local, addr, sta, tmp) {
175 if (sta->sdata == sdata) {
176 rcu_read_unlock();
177
178
179
180 return sta;
181 }
182 }
183 rcu_read_unlock();
184 return NULL;
185}
186
187
188
189
190
191struct sta_info *sta_info_get_bss(struct ieee80211_sub_if_data *sdata,
192 const u8 *addr)
193{
194 struct ieee80211_local *local = sdata->local;
195 struct rhlist_head *tmp;
196 struct sta_info *sta;
197
198 rcu_read_lock();
199 for_each_sta_info(local, addr, sta, tmp) {
200 if (sta->sdata == sdata ||
201 (sta->sdata->bss && sta->sdata->bss == sdata->bss)) {
202 rcu_read_unlock();
203
204
205
206 return sta;
207 }
208 }
209 rcu_read_unlock();
210 return NULL;
211}
212
213struct sta_info *sta_info_get_by_addrs(struct ieee80211_local *local,
214 const u8 *sta_addr, const u8 *vif_addr)
215{
216 struct rhlist_head *tmp;
217 struct sta_info *sta;
218
219 for_each_sta_info(local, sta_addr, sta, tmp) {
220 if (ether_addr_equal(vif_addr, sta->sdata->vif.addr))
221 return sta;
222 }
223
224 return NULL;
225}
226
227struct sta_info *sta_info_get_by_idx(struct ieee80211_sub_if_data *sdata,
228 int idx)
229{
230 struct ieee80211_local *local = sdata->local;
231 struct sta_info *sta;
232 int i = 0;
233
234 list_for_each_entry_rcu(sta, &local->sta_list, list,
235 lockdep_is_held(&local->sta_mtx)) {
236 if (sdata != sta->sdata)
237 continue;
238 if (i < idx) {
239 ++i;
240 continue;
241 }
242 return sta;
243 }
244
245 return NULL;
246}
247
248
249
250
251
252
253
254
255
256
257
258
259void sta_info_free(struct ieee80211_local *local, struct sta_info *sta)
260{
261
262
263
264
265
266
267
268
269 while (sta->sta_state > IEEE80211_STA_NONE) {
270 int ret;
271
272 WARN_ON_ONCE(test_sta_flag(sta, WLAN_STA_INSERTED));
273
274 ret = sta_info_move_state(sta, sta->sta_state - 1);
275 if (WARN_ONCE(ret, "sta_info_move_state() returned %d\n", ret))
276 break;
277 }
278
279 if (sta->rate_ctrl)
280 rate_control_free_sta(sta);
281
282 sta_dbg(sta->sdata, "Destroyed STA %pM\n", sta->sta.addr);
283
284 if (sta->sta.txq[0])
285 kfree(to_txq_info(sta->sta.txq[0]));
286 kfree(rcu_dereference_raw(sta->sta.rates));
287#ifdef CONFIG_MAC80211_MESH
288 kfree(sta->mesh);
289#endif
290 free_percpu(sta->pcpu_rx_stats);
291 kfree(sta);
292}
293
294
295static int sta_info_hash_add(struct ieee80211_local *local,
296 struct sta_info *sta)
297{
298 return rhltable_insert(&local->sta_hash, &sta->hash_node,
299 sta_rht_params);
300}
301
302static void sta_deliver_ps_frames(struct work_struct *wk)
303{
304 struct sta_info *sta;
305
306 sta = container_of(wk, struct sta_info, drv_deliver_wk);
307
308 if (sta->dead)
309 return;
310
311 local_bh_disable();
312 if (!test_sta_flag(sta, WLAN_STA_PS_STA))
313 ieee80211_sta_ps_deliver_wakeup(sta);
314 else if (test_and_clear_sta_flag(sta, WLAN_STA_PSPOLL))
315 ieee80211_sta_ps_deliver_poll_response(sta);
316 else if (test_and_clear_sta_flag(sta, WLAN_STA_UAPSD))
317 ieee80211_sta_ps_deliver_uapsd(sta);
318 local_bh_enable();
319}
320
321static int sta_prepare_rate_control(struct ieee80211_local *local,
322 struct sta_info *sta, gfp_t gfp)
323{
324 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
325 return 0;
326
327 sta->rate_ctrl = local->rate_ctrl;
328 sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl,
329 sta, gfp);
330 if (!sta->rate_ctrl_priv)
331 return -ENOMEM;
332
333 return 0;
334}
335
336struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
337 const u8 *addr, gfp_t gfp)
338{
339 struct ieee80211_local *local = sdata->local;
340 struct ieee80211_hw *hw = &local->hw;
341 struct sta_info *sta;
342 int i;
343
344 sta = kzalloc(sizeof(*sta) + hw->sta_data_size, gfp);
345 if (!sta)
346 return NULL;
347
348 if (ieee80211_hw_check(hw, USES_RSS)) {
349 sta->pcpu_rx_stats =
350 alloc_percpu_gfp(struct ieee80211_sta_rx_stats, gfp);
351 if (!sta->pcpu_rx_stats)
352 goto free;
353 }
354
355 spin_lock_init(&sta->lock);
356 spin_lock_init(&sta->ps_lock);
357 INIT_WORK(&sta->drv_deliver_wk, sta_deliver_ps_frames);
358 INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work);
359 mutex_init(&sta->ampdu_mlme.mtx);
360#ifdef CONFIG_MAC80211_MESH
361 if (ieee80211_vif_is_mesh(&sdata->vif)) {
362 sta->mesh = kzalloc(sizeof(*sta->mesh), gfp);
363 if (!sta->mesh)
364 goto free;
365 sta->mesh->plink_sta = sta;
366 spin_lock_init(&sta->mesh->plink_lock);
367 if (!sdata->u.mesh.user_mpm)
368 timer_setup(&sta->mesh->plink_timer, mesh_plink_timer,
369 0);
370 sta->mesh->nonpeer_pm = NL80211_MESH_POWER_ACTIVE;
371 }
372#endif
373
374 memcpy(sta->addr, addr, ETH_ALEN);
375 memcpy(sta->sta.addr, addr, ETH_ALEN);
376 sta->sta.max_rx_aggregation_subframes =
377 local->hw.max_rx_aggregation_subframes;
378
379
380
381
382
383
384
385 BUILD_BUG_ON(ARRAY_SIZE(sta->ptk) <= INVALID_PTK_KEYIDX);
386 sta->ptk_idx = INVALID_PTK_KEYIDX;
387
388 sta->local = local;
389 sta->sdata = sdata;
390 sta->rx_stats.last_rx = jiffies;
391
392 u64_stats_init(&sta->rx_stats.syncp);
393
394 ieee80211_init_frag_cache(&sta->frags);
395
396 sta->sta_state = IEEE80211_STA_NONE;
397
398
399 sta->reserved_tid = IEEE80211_TID_UNRESERVED;
400
401 sta->last_connected = ktime_get_seconds();
402 ewma_signal_init(&sta->rx_stats_avg.signal);
403 ewma_avg_signal_init(&sta->status_stats.avg_ack_signal);
404 for (i = 0; i < ARRAY_SIZE(sta->rx_stats_avg.chain_signal); i++)
405 ewma_signal_init(&sta->rx_stats_avg.chain_signal[i]);
406
407 if (local->ops->wake_tx_queue) {
408 void *txq_data;
409 int size = sizeof(struct txq_info) +
410 ALIGN(hw->txq_data_size, sizeof(void *));
411
412 txq_data = kcalloc(ARRAY_SIZE(sta->sta.txq), size, gfp);
413 if (!txq_data)
414 goto free;
415
416 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
417 struct txq_info *txq = txq_data + i * size;
418
419
420 ieee80211_txq_init(sdata, sta, txq, i);
421 }
422 }
423
424 if (sta_prepare_rate_control(local, sta, gfp))
425 goto free_txq;
426
427
428 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
429 skb_queue_head_init(&sta->ps_tx_buf[i]);
430 skb_queue_head_init(&sta->tx_filtered[i]);
431 init_airtime_info(&sta->airtime[i], &local->airtime[i]);
432 }
433
434 for (i = 0; i < IEEE80211_NUM_TIDS; i++)
435 sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX);
436
437 for (i = 0; i < NUM_NL80211_BANDS; i++) {
438 u32 mandatory = 0;
439 int r;
440
441 if (!hw->wiphy->bands[i])
442 continue;
443
444 switch (i) {
445 case NL80211_BAND_2GHZ:
446 case NL80211_BAND_LC:
447
448
449
450
451
452
453
454
455
456 mandatory = IEEE80211_RATE_MANDATORY_B |
457 IEEE80211_RATE_MANDATORY_G;
458 break;
459 case NL80211_BAND_5GHZ:
460 mandatory = IEEE80211_RATE_MANDATORY_A;
461 break;
462 case NL80211_BAND_60GHZ:
463 WARN_ON(1);
464 mandatory = 0;
465 break;
466 }
467
468 for (r = 0; r < hw->wiphy->bands[i]->n_bitrates; r++) {
469 struct ieee80211_rate *rate;
470
471 rate = &hw->wiphy->bands[i]->bitrates[r];
472
473 if (!(rate->flags & mandatory))
474 continue;
475 sta->sta.supp_rates[i] |= BIT(r);
476 }
477 }
478
479 sta->sta.smps_mode = IEEE80211_SMPS_OFF;
480 if (sdata->vif.type == NL80211_IFTYPE_AP ||
481 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
482 struct ieee80211_supported_band *sband;
483 u8 smps;
484
485 sband = ieee80211_get_sband(sdata);
486 if (!sband)
487 goto free_txq;
488
489 smps = (sband->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >>
490 IEEE80211_HT_CAP_SM_PS_SHIFT;
491
492
493
494
495 switch (smps) {
496 case WLAN_HT_SMPS_CONTROL_DISABLED:
497 sta->known_smps_mode = IEEE80211_SMPS_OFF;
498 break;
499 case WLAN_HT_SMPS_CONTROL_STATIC:
500 sta->known_smps_mode = IEEE80211_SMPS_STATIC;
501 break;
502 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
503 sta->known_smps_mode = IEEE80211_SMPS_DYNAMIC;
504 break;
505 default:
506 WARN_ON(1);
507 }
508 }
509
510 sta->sta.max_rc_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_BA;
511
512 sta->cparams.ce_threshold = CODEL_DISABLED_THRESHOLD;
513 sta->cparams.target = MS2TIME(20);
514 sta->cparams.interval = MS2TIME(100);
515 sta->cparams.ecn = true;
516 sta->cparams.ce_threshold_selector = 0;
517 sta->cparams.ce_threshold_mask = 0;
518
519 sta_dbg(sdata, "Allocated STA %pM\n", sta->sta.addr);
520
521 return sta;
522
523free_txq:
524 if (sta->sta.txq[0])
525 kfree(to_txq_info(sta->sta.txq[0]));
526free:
527 free_percpu(sta->pcpu_rx_stats);
528#ifdef CONFIG_MAC80211_MESH
529 kfree(sta->mesh);
530#endif
531 kfree(sta);
532 return NULL;
533}
534
535static int sta_info_insert_check(struct sta_info *sta)
536{
537 struct ieee80211_sub_if_data *sdata = sta->sdata;
538
539
540
541
542
543
544 if (unlikely(!ieee80211_sdata_running(sdata)))
545 return -ENETDOWN;
546
547 if (WARN_ON(ether_addr_equal(sta->sta.addr, sdata->vif.addr) ||
548 !is_valid_ether_addr(sta->sta.addr)))
549 return -EINVAL;
550
551
552
553
554
555 rcu_read_lock();
556 lockdep_assert_held(&sdata->local->sta_mtx);
557 if (ieee80211_hw_check(&sdata->local->hw, NEEDS_UNIQUE_STA_ADDR) &&
558 ieee80211_find_sta_by_ifaddr(&sdata->local->hw, sta->addr, NULL)) {
559 rcu_read_unlock();
560 return -ENOTUNIQ;
561 }
562 rcu_read_unlock();
563
564 return 0;
565}
566
567static int sta_info_insert_drv_state(struct ieee80211_local *local,
568 struct ieee80211_sub_if_data *sdata,
569 struct sta_info *sta)
570{
571 enum ieee80211_sta_state state;
572 int err = 0;
573
574 for (state = IEEE80211_STA_NOTEXIST; state < sta->sta_state; state++) {
575 err = drv_sta_state(local, sdata, sta, state, state + 1);
576 if (err)
577 break;
578 }
579
580 if (!err) {
581
582
583
584
585 if (!local->ops->sta_add)
586 sta->uploaded = true;
587 return 0;
588 }
589
590 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
591 sdata_info(sdata,
592 "failed to move IBSS STA %pM to state %d (%d) - keeping it anyway\n",
593 sta->sta.addr, state + 1, err);
594 err = 0;
595 }
596
597
598 for (; state > IEEE80211_STA_NOTEXIST; state--)
599 WARN_ON(drv_sta_state(local, sdata, sta, state, state - 1));
600
601 return err;
602}
603
604static void
605ieee80211_recalc_p2p_go_ps_allowed(struct ieee80211_sub_if_data *sdata)
606{
607 struct ieee80211_local *local = sdata->local;
608 bool allow_p2p_go_ps = sdata->vif.p2p;
609 struct sta_info *sta;
610
611 rcu_read_lock();
612 list_for_each_entry_rcu(sta, &local->sta_list, list) {
613 if (sdata != sta->sdata ||
614 !test_sta_flag(sta, WLAN_STA_ASSOC))
615 continue;
616 if (!sta->sta.support_p2p_ps) {
617 allow_p2p_go_ps = false;
618 break;
619 }
620 }
621 rcu_read_unlock();
622
623 if (allow_p2p_go_ps != sdata->vif.bss_conf.allow_p2p_go_ps) {
624 sdata->vif.bss_conf.allow_p2p_go_ps = allow_p2p_go_ps;
625 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_P2P_PS);
626 }
627}
628
629
630
631
632
633
634static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU)
635{
636 struct ieee80211_local *local = sta->local;
637 struct ieee80211_sub_if_data *sdata = sta->sdata;
638 struct station_info *sinfo = NULL;
639 int err = 0;
640
641 lockdep_assert_held(&local->sta_mtx);
642
643
644 if (sta_info_get_bss(sdata, sta->sta.addr)) {
645 err = -EEXIST;
646 goto out_cleanup;
647 }
648
649 sinfo = kzalloc(sizeof(struct station_info), GFP_KERNEL);
650 if (!sinfo) {
651 err = -ENOMEM;
652 goto out_cleanup;
653 }
654
655 local->num_sta++;
656 local->sta_generation++;
657 smp_mb();
658
659
660 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
661
662
663 err = sta_info_hash_add(local, sta);
664 if (err)
665 goto out_drop_sta;
666
667 list_add_tail_rcu(&sta->list, &local->sta_list);
668
669
670
671
672 if (sta->sta_state >= IEEE80211_STA_ASSOC) {
673 ieee80211_recalc_min_chandef(sta->sdata);
674 if (!sta->sta.support_p2p_ps)
675 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
676 }
677
678
679 err = sta_info_insert_drv_state(local, sdata, sta);
680 if (err)
681 goto out_remove;
682
683 set_sta_flag(sta, WLAN_STA_INSERTED);
684
685
686 clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
687
688 ieee80211_sta_debugfs_add(sta);
689 rate_control_add_sta_debugfs(sta);
690
691 sinfo->generation = local->sta_generation;
692 cfg80211_new_sta(sdata->dev, sta->sta.addr, sinfo, GFP_KERNEL);
693 kfree(sinfo);
694
695 sta_dbg(sdata, "Inserted STA %pM\n", sta->sta.addr);
696
697
698 rcu_read_lock();
699 mutex_unlock(&local->sta_mtx);
700
701 if (ieee80211_vif_is_mesh(&sdata->vif))
702 mesh_accept_plinks_update(sdata);
703
704 return 0;
705 out_remove:
706 sta_info_hash_del(local, sta);
707 list_del_rcu(&sta->list);
708 out_drop_sta:
709 local->num_sta--;
710 synchronize_net();
711 out_cleanup:
712 cleanup_single_sta(sta);
713 mutex_unlock(&local->sta_mtx);
714 kfree(sinfo);
715 rcu_read_lock();
716 return err;
717}
718
719int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU)
720{
721 struct ieee80211_local *local = sta->local;
722 int err;
723
724 might_sleep();
725
726 mutex_lock(&local->sta_mtx);
727
728 err = sta_info_insert_check(sta);
729 if (err) {
730 sta_info_free(local, sta);
731 mutex_unlock(&local->sta_mtx);
732 rcu_read_lock();
733 return err;
734 }
735
736 return sta_info_insert_finish(sta);
737}
738
739int sta_info_insert(struct sta_info *sta)
740{
741 int err = sta_info_insert_rcu(sta);
742
743 rcu_read_unlock();
744
745 return err;
746}
747
748static inline void __bss_tim_set(u8 *tim, u16 id)
749{
750
751
752
753
754 tim[id / 8] |= (1 << (id % 8));
755}
756
757static inline void __bss_tim_clear(u8 *tim, u16 id)
758{
759
760
761
762
763 tim[id / 8] &= ~(1 << (id % 8));
764}
765
766static inline bool __bss_tim_get(u8 *tim, u16 id)
767{
768
769
770
771
772 return tim[id / 8] & (1 << (id % 8));
773}
774
775static unsigned long ieee80211_tids_for_ac(int ac)
776{
777
778 switch (ac) {
779 case IEEE80211_AC_VO:
780 return BIT(6) | BIT(7);
781 case IEEE80211_AC_VI:
782 return BIT(4) | BIT(5);
783 case IEEE80211_AC_BE:
784 return BIT(0) | BIT(3);
785 case IEEE80211_AC_BK:
786 return BIT(1) | BIT(2);
787 default:
788 WARN_ON(1);
789 return 0;
790 }
791}
792
793static void __sta_info_recalc_tim(struct sta_info *sta, bool ignore_pending)
794{
795 struct ieee80211_local *local = sta->local;
796 struct ps_data *ps;
797 bool indicate_tim = false;
798 u8 ignore_for_tim = sta->sta.uapsd_queues;
799 int ac;
800 u16 id = sta->sta.aid;
801
802 if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
803 sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
804 if (WARN_ON_ONCE(!sta->sdata->bss))
805 return;
806
807 ps = &sta->sdata->bss->ps;
808#ifdef CONFIG_MAC80211_MESH
809 } else if (ieee80211_vif_is_mesh(&sta->sdata->vif)) {
810 ps = &sta->sdata->u.mesh.ps;
811#endif
812 } else {
813 return;
814 }
815
816
817 if (ieee80211_hw_check(&local->hw, AP_LINK_PS) && !local->ops->set_tim)
818 return;
819
820 if (sta->dead)
821 goto done;
822
823
824
825
826
827
828
829 if (ignore_for_tim == BIT(IEEE80211_NUM_ACS) - 1)
830 ignore_for_tim = 0;
831
832 if (ignore_pending)
833 ignore_for_tim = BIT(IEEE80211_NUM_ACS) - 1;
834
835 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
836 unsigned long tids;
837
838 if (ignore_for_tim & ieee80211_ac_to_qos_mask[ac])
839 continue;
840
841 indicate_tim |= !skb_queue_empty(&sta->tx_filtered[ac]) ||
842 !skb_queue_empty(&sta->ps_tx_buf[ac]);
843 if (indicate_tim)
844 break;
845
846 tids = ieee80211_tids_for_ac(ac);
847
848 indicate_tim |=
849 sta->driver_buffered_tids & tids;
850 indicate_tim |=
851 sta->txq_buffered_tids & tids;
852 }
853
854 done:
855 spin_lock_bh(&local->tim_lock);
856
857 if (indicate_tim == __bss_tim_get(ps->tim, id))
858 goto out_unlock;
859
860 if (indicate_tim)
861 __bss_tim_set(ps->tim, id);
862 else
863 __bss_tim_clear(ps->tim, id);
864
865 if (local->ops->set_tim && !WARN_ON(sta->dead)) {
866 local->tim_in_locked_section = true;
867 drv_set_tim(local, &sta->sta, indicate_tim);
868 local->tim_in_locked_section = false;
869 }
870
871out_unlock:
872 spin_unlock_bh(&local->tim_lock);
873}
874
875void sta_info_recalc_tim(struct sta_info *sta)
876{
877 __sta_info_recalc_tim(sta, false);
878}
879
880static bool sta_info_buffer_expired(struct sta_info *sta, struct sk_buff *skb)
881{
882 struct ieee80211_tx_info *info;
883 int timeout;
884
885 if (!skb)
886 return false;
887
888 info = IEEE80211_SKB_CB(skb);
889
890
891 timeout = (sta->listen_interval *
892 sta->sdata->vif.bss_conf.beacon_int *
893 32 / 15625) * HZ;
894 if (timeout < STA_TX_BUFFER_EXPIRE)
895 timeout = STA_TX_BUFFER_EXPIRE;
896 return time_after(jiffies, info->control.jiffies + timeout);
897}
898
899
900static bool sta_info_cleanup_expire_buffered_ac(struct ieee80211_local *local,
901 struct sta_info *sta, int ac)
902{
903 unsigned long flags;
904 struct sk_buff *skb;
905
906
907
908
909
910
911
912
913 for (;;) {
914 spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags);
915 skb = skb_peek(&sta->tx_filtered[ac]);
916 if (sta_info_buffer_expired(sta, skb))
917 skb = __skb_dequeue(&sta->tx_filtered[ac]);
918 else
919 skb = NULL;
920 spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags);
921
922
923
924
925
926
927
928 if (!skb)
929 break;
930 ieee80211_free_txskb(&local->hw, skb);
931 }
932
933
934
935
936
937
938
939 for (;;) {
940 spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags);
941 skb = skb_peek(&sta->ps_tx_buf[ac]);
942 if (sta_info_buffer_expired(sta, skb))
943 skb = __skb_dequeue(&sta->ps_tx_buf[ac]);
944 else
945 skb = NULL;
946 spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags);
947
948
949
950
951
952
953 if (!skb)
954 break;
955
956 local->total_ps_buffered--;
957 ps_dbg(sta->sdata, "Buffered frame expired (STA %pM)\n",
958 sta->sta.addr);
959 ieee80211_free_txskb(&local->hw, skb);
960 }
961
962
963
964
965
966
967 sta_info_recalc_tim(sta);
968
969
970
971
972
973
974 return !(skb_queue_empty(&sta->ps_tx_buf[ac]) &&
975 skb_queue_empty(&sta->tx_filtered[ac]));
976}
977
978static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
979 struct sta_info *sta)
980{
981 bool have_buffered = false;
982 int ac;
983
984
985 if (!sta->sdata->bss &&
986 !ieee80211_vif_is_mesh(&sta->sdata->vif))
987 return false;
988
989 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
990 have_buffered |=
991 sta_info_cleanup_expire_buffered_ac(local, sta, ac);
992
993 return have_buffered;
994}
995
996static int __must_check __sta_info_destroy_part1(struct sta_info *sta)
997{
998 struct ieee80211_local *local;
999 struct ieee80211_sub_if_data *sdata;
1000 int ret;
1001
1002 might_sleep();
1003
1004 if (!sta)
1005 return -ENOENT;
1006
1007 local = sta->local;
1008 sdata = sta->sdata;
1009
1010 lockdep_assert_held(&local->sta_mtx);
1011
1012
1013
1014
1015
1016
1017
1018 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
1019 ieee80211_sta_tear_down_BA_sessions(sta, AGG_STOP_DESTROY_STA);
1020
1021
1022
1023
1024
1025
1026 drv_sync_rx_queues(local, sta);
1027
1028 ret = sta_info_hash_del(local, sta);
1029 if (WARN_ON(ret))
1030 return ret;
1031
1032
1033
1034
1035
1036 if (test_sta_flag(sta, WLAN_STA_TDLS_OFF_CHANNEL)) {
1037 drv_tdls_cancel_channel_switch(local, sdata, &sta->sta);
1038 clear_sta_flag(sta, WLAN_STA_TDLS_OFF_CHANNEL);
1039 }
1040
1041 list_del_rcu(&sta->list);
1042 sta->removed = true;
1043
1044 drv_sta_pre_rcu_remove(local, sta->sdata, sta);
1045
1046 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1047 rcu_access_pointer(sdata->u.vlan.sta) == sta)
1048 RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
1049
1050 return 0;
1051}
1052
1053static void __sta_info_destroy_part2(struct sta_info *sta)
1054{
1055 struct ieee80211_local *local = sta->local;
1056 struct ieee80211_sub_if_data *sdata = sta->sdata;
1057 struct station_info *sinfo;
1058 int ret;
1059
1060
1061
1062
1063
1064
1065 might_sleep();
1066 lockdep_assert_held(&local->sta_mtx);
1067
1068 if (sta->sta_state == IEEE80211_STA_AUTHORIZED) {
1069 ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1070 WARN_ON_ONCE(ret);
1071 }
1072
1073
1074 ieee80211_free_sta_keys(local, sta);
1075
1076
1077 __sta_info_recalc_tim(sta, true);
1078
1079 sta->dead = true;
1080
1081 local->num_sta--;
1082 local->sta_generation++;
1083
1084 while (sta->sta_state > IEEE80211_STA_NONE) {
1085 ret = sta_info_move_state(sta, sta->sta_state - 1);
1086 if (ret) {
1087 WARN_ON_ONCE(1);
1088 break;
1089 }
1090 }
1091
1092 if (sta->uploaded) {
1093 ret = drv_sta_state(local, sdata, sta, IEEE80211_STA_NONE,
1094 IEEE80211_STA_NOTEXIST);
1095 WARN_ON_ONCE(ret != 0);
1096 }
1097
1098 sta_dbg(sdata, "Removed STA %pM\n", sta->sta.addr);
1099
1100 sinfo = kzalloc(sizeof(*sinfo), GFP_KERNEL);
1101 if (sinfo)
1102 sta_set_sinfo(sta, sinfo, true);
1103 cfg80211_del_sta_sinfo(sdata->dev, sta->sta.addr, sinfo, GFP_KERNEL);
1104 kfree(sinfo);
1105
1106 ieee80211_sta_debugfs_remove(sta);
1107
1108 ieee80211_destroy_frag_cache(&sta->frags);
1109
1110 cleanup_single_sta(sta);
1111}
1112
1113int __must_check __sta_info_destroy(struct sta_info *sta)
1114{
1115 int err = __sta_info_destroy_part1(sta);
1116
1117 if (err)
1118 return err;
1119
1120 synchronize_net();
1121
1122 __sta_info_destroy_part2(sta);
1123
1124 return 0;
1125}
1126
1127int sta_info_destroy_addr(struct ieee80211_sub_if_data *sdata, const u8 *addr)
1128{
1129 struct sta_info *sta;
1130 int ret;
1131
1132 mutex_lock(&sdata->local->sta_mtx);
1133 sta = sta_info_get(sdata, addr);
1134 ret = __sta_info_destroy(sta);
1135 mutex_unlock(&sdata->local->sta_mtx);
1136
1137 return ret;
1138}
1139
1140int sta_info_destroy_addr_bss(struct ieee80211_sub_if_data *sdata,
1141 const u8 *addr)
1142{
1143 struct sta_info *sta;
1144 int ret;
1145
1146 mutex_lock(&sdata->local->sta_mtx);
1147 sta = sta_info_get_bss(sdata, addr);
1148 ret = __sta_info_destroy(sta);
1149 mutex_unlock(&sdata->local->sta_mtx);
1150
1151 return ret;
1152}
1153
1154static void sta_info_cleanup(struct timer_list *t)
1155{
1156 struct ieee80211_local *local = from_timer(local, t, sta_cleanup);
1157 struct sta_info *sta;
1158 bool timer_needed = false;
1159
1160 rcu_read_lock();
1161 list_for_each_entry_rcu(sta, &local->sta_list, list)
1162 if (sta_info_cleanup_expire_buffered(local, sta))
1163 timer_needed = true;
1164 rcu_read_unlock();
1165
1166 if (local->quiescing)
1167 return;
1168
1169 if (!timer_needed)
1170 return;
1171
1172 mod_timer(&local->sta_cleanup,
1173 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL));
1174}
1175
1176int sta_info_init(struct ieee80211_local *local)
1177{
1178 int err;
1179
1180 err = rhltable_init(&local->sta_hash, &sta_rht_params);
1181 if (err)
1182 return err;
1183
1184 spin_lock_init(&local->tim_lock);
1185 mutex_init(&local->sta_mtx);
1186 INIT_LIST_HEAD(&local->sta_list);
1187
1188 timer_setup(&local->sta_cleanup, sta_info_cleanup, 0);
1189 return 0;
1190}
1191
1192void sta_info_stop(struct ieee80211_local *local)
1193{
1194 del_timer_sync(&local->sta_cleanup);
1195 rhltable_destroy(&local->sta_hash);
1196}
1197
1198
1199int __sta_info_flush(struct ieee80211_sub_if_data *sdata, bool vlans)
1200{
1201 struct ieee80211_local *local = sdata->local;
1202 struct sta_info *sta, *tmp;
1203 LIST_HEAD(free_list);
1204 int ret = 0;
1205
1206 might_sleep();
1207
1208 WARN_ON(vlans && sdata->vif.type != NL80211_IFTYPE_AP);
1209 WARN_ON(vlans && !sdata->bss);
1210
1211 mutex_lock(&local->sta_mtx);
1212 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1213 if (sdata == sta->sdata ||
1214 (vlans && sdata->bss == sta->sdata->bss)) {
1215 if (!WARN_ON(__sta_info_destroy_part1(sta)))
1216 list_add(&sta->free_list, &free_list);
1217 ret++;
1218 }
1219 }
1220
1221 if (!list_empty(&free_list)) {
1222 synchronize_net();
1223 list_for_each_entry_safe(sta, tmp, &free_list, free_list)
1224 __sta_info_destroy_part2(sta);
1225 }
1226 mutex_unlock(&local->sta_mtx);
1227
1228 return ret;
1229}
1230
1231void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
1232 unsigned long exp_time)
1233{
1234 struct ieee80211_local *local = sdata->local;
1235 struct sta_info *sta, *tmp;
1236
1237 mutex_lock(&local->sta_mtx);
1238
1239 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1240 unsigned long last_active = ieee80211_sta_last_active(sta);
1241
1242 if (sdata != sta->sdata)
1243 continue;
1244
1245 if (time_is_before_jiffies(last_active + exp_time)) {
1246 sta_dbg(sta->sdata, "expiring inactive STA %pM\n",
1247 sta->sta.addr);
1248
1249 if (ieee80211_vif_is_mesh(&sdata->vif) &&
1250 test_sta_flag(sta, WLAN_STA_PS_STA))
1251 atomic_dec(&sdata->u.mesh.ps.num_sta_ps);
1252
1253 WARN_ON(__sta_info_destroy(sta));
1254 }
1255 }
1256
1257 mutex_unlock(&local->sta_mtx);
1258}
1259
1260struct ieee80211_sta *ieee80211_find_sta_by_ifaddr(struct ieee80211_hw *hw,
1261 const u8 *addr,
1262 const u8 *localaddr)
1263{
1264 struct ieee80211_local *local = hw_to_local(hw);
1265 struct rhlist_head *tmp;
1266 struct sta_info *sta;
1267
1268
1269
1270
1271
1272 for_each_sta_info(local, addr, sta, tmp) {
1273 if (localaddr &&
1274 !ether_addr_equal(sta->sdata->vif.addr, localaddr))
1275 continue;
1276 if (!sta->uploaded)
1277 return NULL;
1278 return &sta->sta;
1279 }
1280
1281 return NULL;
1282}
1283EXPORT_SYMBOL_GPL(ieee80211_find_sta_by_ifaddr);
1284
1285struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_vif *vif,
1286 const u8 *addr)
1287{
1288 struct sta_info *sta;
1289
1290 if (!vif)
1291 return NULL;
1292
1293 sta = sta_info_get_bss(vif_to_sdata(vif), addr);
1294 if (!sta)
1295 return NULL;
1296
1297 if (!sta->uploaded)
1298 return NULL;
1299
1300 return &sta->sta;
1301}
1302EXPORT_SYMBOL(ieee80211_find_sta);
1303
1304
1305void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)
1306{
1307 struct ieee80211_sub_if_data *sdata = sta->sdata;
1308 struct ieee80211_local *local = sdata->local;
1309 struct sk_buff_head pending;
1310 int filtered = 0, buffered = 0, ac, i;
1311 unsigned long flags;
1312 struct ps_data *ps;
1313
1314 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1315 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
1316 u.ap);
1317
1318 if (sdata->vif.type == NL80211_IFTYPE_AP)
1319 ps = &sdata->bss->ps;
1320 else if (ieee80211_vif_is_mesh(&sdata->vif))
1321 ps = &sdata->u.mesh.ps;
1322 else
1323 return;
1324
1325 clear_sta_flag(sta, WLAN_STA_SP);
1326
1327 BUILD_BUG_ON(BITS_TO_LONGS(IEEE80211_NUM_TIDS) > 1);
1328 sta->driver_buffered_tids = 0;
1329 sta->txq_buffered_tids = 0;
1330
1331 if (!ieee80211_hw_check(&local->hw, AP_LINK_PS))
1332 drv_sta_notify(local, sdata, STA_NOTIFY_AWAKE, &sta->sta);
1333
1334 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
1335 if (!sta->sta.txq[i] || !txq_has_queue(sta->sta.txq[i]))
1336 continue;
1337
1338 schedule_and_wake_txq(local, to_txq_info(sta->sta.txq[i]));
1339 }
1340
1341 skb_queue_head_init(&pending);
1342
1343
1344 spin_lock(&sta->ps_lock);
1345
1346 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1347 int count = skb_queue_len(&pending), tmp;
1348
1349 spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags);
1350 skb_queue_splice_tail_init(&sta->tx_filtered[ac], &pending);
1351 spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags);
1352 tmp = skb_queue_len(&pending);
1353 filtered += tmp - count;
1354 count = tmp;
1355
1356 spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags);
1357 skb_queue_splice_tail_init(&sta->ps_tx_buf[ac], &pending);
1358 spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags);
1359 tmp = skb_queue_len(&pending);
1360 buffered += tmp - count;
1361 }
1362
1363 ieee80211_add_pending_skbs(local, &pending);
1364
1365
1366 clear_sta_flag(sta, WLAN_STA_PS_DELIVER);
1367
1368
1369
1370
1371 clear_sta_flag(sta, WLAN_STA_PSPOLL);
1372 clear_sta_flag(sta, WLAN_STA_UAPSD);
1373 spin_unlock(&sta->ps_lock);
1374
1375 atomic_dec(&ps->num_sta_ps);
1376
1377 local->total_ps_buffered -= buffered;
1378
1379 sta_info_recalc_tim(sta);
1380
1381 ps_dbg(sdata,
1382 "STA %pM aid %d sending %d filtered/%d PS frames since STA woke up\n",
1383 sta->sta.addr, sta->sta.aid, filtered, buffered);
1384
1385 ieee80211_check_fast_xmit(sta);
1386}
1387
1388static void ieee80211_send_null_response(struct sta_info *sta, int tid,
1389 enum ieee80211_frame_release_type reason,
1390 bool call_driver, bool more_data)
1391{
1392 struct ieee80211_sub_if_data *sdata = sta->sdata;
1393 struct ieee80211_local *local = sdata->local;
1394 struct ieee80211_qos_hdr *nullfunc;
1395 struct sk_buff *skb;
1396 int size = sizeof(*nullfunc);
1397 __le16 fc;
1398 bool qos = sta->sta.wme;
1399 struct ieee80211_tx_info *info;
1400 struct ieee80211_chanctx_conf *chanctx_conf;
1401
1402 if (qos) {
1403 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
1404 IEEE80211_STYPE_QOS_NULLFUNC |
1405 IEEE80211_FCTL_FROMDS);
1406 } else {
1407 size -= 2;
1408 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
1409 IEEE80211_STYPE_NULLFUNC |
1410 IEEE80211_FCTL_FROMDS);
1411 }
1412
1413 skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
1414 if (!skb)
1415 return;
1416
1417 skb_reserve(skb, local->hw.extra_tx_headroom);
1418
1419 nullfunc = skb_put(skb, size);
1420 nullfunc->frame_control = fc;
1421 nullfunc->duration_id = 0;
1422 memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
1423 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
1424 memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
1425 nullfunc->seq_ctrl = 0;
1426
1427 skb->priority = tid;
1428 skb_set_queue_mapping(skb, ieee802_1d_to_ac[tid]);
1429 if (qos) {
1430 nullfunc->qos_ctrl = cpu_to_le16(tid);
1431
1432 if (reason == IEEE80211_FRAME_RELEASE_UAPSD) {
1433 nullfunc->qos_ctrl |=
1434 cpu_to_le16(IEEE80211_QOS_CTL_EOSP);
1435 if (more_data)
1436 nullfunc->frame_control |=
1437 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1438 }
1439 }
1440
1441 info = IEEE80211_SKB_CB(skb);
1442
1443
1444
1445
1446
1447
1448
1449 info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER |
1450 IEEE80211_TX_STATUS_EOSP |
1451 IEEE80211_TX_CTL_REQ_TX_STATUS;
1452
1453 info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
1454
1455 if (call_driver)
1456 drv_allow_buffered_frames(local, sta, BIT(tid), 1,
1457 reason, false);
1458
1459 skb->dev = sdata->dev;
1460
1461 rcu_read_lock();
1462 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1463 if (WARN_ON(!chanctx_conf)) {
1464 rcu_read_unlock();
1465 kfree_skb(skb);
1466 return;
1467 }
1468
1469 info->band = chanctx_conf->def.chan->band;
1470 ieee80211_xmit(sdata, sta, skb);
1471 rcu_read_unlock();
1472}
1473
1474static int find_highest_prio_tid(unsigned long tids)
1475{
1476
1477 if (tids & 0xF8)
1478 return fls(tids) - 1;
1479
1480 if (tids & BIT(0))
1481 return 0;
1482 return fls(tids) - 1;
1483}
1484
1485
1486
1487
1488
1489
1490static bool
1491ieee80211_sta_ps_more_data(struct sta_info *sta, u8 ignored_acs,
1492 enum ieee80211_frame_release_type reason,
1493 unsigned long driver_release_tids)
1494{
1495 int ac;
1496
1497
1498
1499
1500
1501
1502 if (reason == IEEE80211_FRAME_RELEASE_PSPOLL &&
1503 hweight16(driver_release_tids) > 1)
1504 return true;
1505
1506 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1507 if (ignored_acs & ieee80211_ac_to_qos_mask[ac])
1508 continue;
1509
1510 if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
1511 !skb_queue_empty(&sta->ps_tx_buf[ac]))
1512 return true;
1513 }
1514
1515 return false;
1516}
1517
1518static void
1519ieee80211_sta_ps_get_frames(struct sta_info *sta, int n_frames, u8 ignored_acs,
1520 enum ieee80211_frame_release_type reason,
1521 struct sk_buff_head *frames,
1522 unsigned long *driver_release_tids)
1523{
1524 struct ieee80211_sub_if_data *sdata = sta->sdata;
1525 struct ieee80211_local *local = sdata->local;
1526 int ac;
1527
1528
1529 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1530 unsigned long tids;
1531
1532 if (ignored_acs & ieee80211_ac_to_qos_mask[ac])
1533 continue;
1534
1535 tids = ieee80211_tids_for_ac(ac);
1536
1537
1538
1539
1540 if (skb_queue_empty(frames)) {
1541 *driver_release_tids |=
1542 sta->driver_buffered_tids & tids;
1543 *driver_release_tids |= sta->txq_buffered_tids & tids;
1544 }
1545
1546 if (!*driver_release_tids) {
1547 struct sk_buff *skb;
1548
1549 while (n_frames > 0) {
1550 skb = skb_dequeue(&sta->tx_filtered[ac]);
1551 if (!skb) {
1552 skb = skb_dequeue(
1553 &sta->ps_tx_buf[ac]);
1554 if (skb)
1555 local->total_ps_buffered--;
1556 }
1557 if (!skb)
1558 break;
1559 n_frames--;
1560 __skb_queue_tail(frames, skb);
1561 }
1562 }
1563
1564
1565
1566
1567
1568 if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
1569 !skb_queue_empty(&sta->ps_tx_buf[ac]))
1570 break;
1571 }
1572}
1573
1574static void
1575ieee80211_sta_ps_deliver_response(struct sta_info *sta,
1576 int n_frames, u8 ignored_acs,
1577 enum ieee80211_frame_release_type reason)
1578{
1579 struct ieee80211_sub_if_data *sdata = sta->sdata;
1580 struct ieee80211_local *local = sdata->local;
1581 unsigned long driver_release_tids = 0;
1582 struct sk_buff_head frames;
1583 bool more_data;
1584
1585
1586 set_sta_flag(sta, WLAN_STA_SP);
1587
1588 __skb_queue_head_init(&frames);
1589
1590 ieee80211_sta_ps_get_frames(sta, n_frames, ignored_acs, reason,
1591 &frames, &driver_release_tids);
1592
1593 more_data = ieee80211_sta_ps_more_data(sta, ignored_acs, reason, driver_release_tids);
1594
1595 if (driver_release_tids && reason == IEEE80211_FRAME_RELEASE_PSPOLL)
1596 driver_release_tids =
1597 BIT(find_highest_prio_tid(driver_release_tids));
1598
1599 if (skb_queue_empty(&frames) && !driver_release_tids) {
1600 int tid, ac;
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618 for (ac = IEEE80211_AC_VO; ac < IEEE80211_NUM_ACS; ac++)
1619 if (!(ignored_acs & ieee80211_ac_to_qos_mask[ac]))
1620 break;
1621 tid = 7 - 2 * ac;
1622
1623 ieee80211_send_null_response(sta, tid, reason, true, false);
1624 } else if (!driver_release_tids) {
1625 struct sk_buff_head pending;
1626 struct sk_buff *skb;
1627 int num = 0;
1628 u16 tids = 0;
1629 bool need_null = false;
1630
1631 skb_queue_head_init(&pending);
1632
1633 while ((skb = __skb_dequeue(&frames))) {
1634 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1635 struct ieee80211_hdr *hdr = (void *) skb->data;
1636 u8 *qoshdr = NULL;
1637
1638 num++;
1639
1640
1641
1642
1643
1644
1645 info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
1646 info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
1647
1648
1649
1650
1651
1652 if (more_data || !skb_queue_empty(&frames))
1653 hdr->frame_control |=
1654 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1655 else
1656 hdr->frame_control &=
1657 cpu_to_le16(~IEEE80211_FCTL_MOREDATA);
1658
1659 if (ieee80211_is_data_qos(hdr->frame_control) ||
1660 ieee80211_is_qos_nullfunc(hdr->frame_control))
1661 qoshdr = ieee80211_get_qos_ctl(hdr);
1662
1663 tids |= BIT(skb->priority);
1664
1665 __skb_queue_tail(&pending, skb);
1666
1667
1668 if (!skb_queue_empty(&frames))
1669 continue;
1670
1671 if (reason != IEEE80211_FRAME_RELEASE_UAPSD) {
1672
1673 info->flags |= IEEE80211_TX_STATUS_EOSP |
1674 IEEE80211_TX_CTL_REQ_TX_STATUS;
1675 break;
1676 }
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694 if (qoshdr) {
1695 *qoshdr |= IEEE80211_QOS_CTL_EOSP;
1696
1697 info->flags |= IEEE80211_TX_STATUS_EOSP |
1698 IEEE80211_TX_CTL_REQ_TX_STATUS;
1699 } else {
1700
1701
1702
1703
1704
1705
1706
1707
1708 hdr->frame_control |=
1709 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1710 need_null = true;
1711 num++;
1712 }
1713 break;
1714 }
1715
1716 drv_allow_buffered_frames(local, sta, tids, num,
1717 reason, more_data);
1718
1719 ieee80211_add_pending_skbs(local, &pending);
1720
1721 if (need_null)
1722 ieee80211_send_null_response(
1723 sta, find_highest_prio_tid(tids),
1724 reason, false, false);
1725
1726 sta_info_recalc_tim(sta);
1727 } else {
1728 int tid;
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740 drv_release_buffered_frames(local, sta, driver_release_tids,
1741 n_frames, reason, more_data);
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753 if (!sta->sta.txq[0])
1754 return;
1755
1756 for (tid = 0; tid < ARRAY_SIZE(sta->sta.txq); tid++) {
1757 if (!sta->sta.txq[tid] ||
1758 !(driver_release_tids & BIT(tid)) ||
1759 txq_has_queue(sta->sta.txq[tid]))
1760 continue;
1761
1762 sta_info_recalc_tim(sta);
1763 break;
1764 }
1765 }
1766}
1767
1768void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta)
1769{
1770 u8 ignore_for_response = sta->sta.uapsd_queues;
1771
1772
1773
1774
1775
1776
1777 if (ignore_for_response == BIT(IEEE80211_NUM_ACS) - 1)
1778 ignore_for_response = 0;
1779
1780 ieee80211_sta_ps_deliver_response(sta, 1, ignore_for_response,
1781 IEEE80211_FRAME_RELEASE_PSPOLL);
1782}
1783
1784void ieee80211_sta_ps_deliver_uapsd(struct sta_info *sta)
1785{
1786 int n_frames = sta->sta.max_sp;
1787 u8 delivery_enabled = sta->sta.uapsd_queues;
1788
1789
1790
1791
1792
1793
1794
1795 if (!delivery_enabled)
1796 return;
1797
1798 switch (sta->sta.max_sp) {
1799 case 1:
1800 n_frames = 2;
1801 break;
1802 case 2:
1803 n_frames = 4;
1804 break;
1805 case 3:
1806 n_frames = 6;
1807 break;
1808 case 0:
1809
1810 n_frames = 128;
1811 break;
1812 }
1813
1814 ieee80211_sta_ps_deliver_response(sta, n_frames, ~delivery_enabled,
1815 IEEE80211_FRAME_RELEASE_UAPSD);
1816}
1817
1818void ieee80211_sta_block_awake(struct ieee80211_hw *hw,
1819 struct ieee80211_sta *pubsta, bool block)
1820{
1821 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1822
1823 trace_api_sta_block_awake(sta->local, pubsta, block);
1824
1825 if (block) {
1826 set_sta_flag(sta, WLAN_STA_PS_DRIVER);
1827 ieee80211_clear_fast_xmit(sta);
1828 return;
1829 }
1830
1831 if (!test_sta_flag(sta, WLAN_STA_PS_DRIVER))
1832 return;
1833
1834 if (!test_sta_flag(sta, WLAN_STA_PS_STA)) {
1835 set_sta_flag(sta, WLAN_STA_PS_DELIVER);
1836 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1837 ieee80211_queue_work(hw, &sta->drv_deliver_wk);
1838 } else if (test_sta_flag(sta, WLAN_STA_PSPOLL) ||
1839 test_sta_flag(sta, WLAN_STA_UAPSD)) {
1840
1841 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1842 ieee80211_queue_work(hw, &sta->drv_deliver_wk);
1843 } else {
1844 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1845 ieee80211_check_fast_xmit(sta);
1846 }
1847}
1848EXPORT_SYMBOL(ieee80211_sta_block_awake);
1849
1850void ieee80211_sta_eosp(struct ieee80211_sta *pubsta)
1851{
1852 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1853 struct ieee80211_local *local = sta->local;
1854
1855 trace_api_eosp(local, pubsta);
1856
1857 clear_sta_flag(sta, WLAN_STA_SP);
1858}
1859EXPORT_SYMBOL(ieee80211_sta_eosp);
1860
1861void ieee80211_send_eosp_nullfunc(struct ieee80211_sta *pubsta, int tid)
1862{
1863 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1864 enum ieee80211_frame_release_type reason;
1865 bool more_data;
1866
1867 trace_api_send_eosp_nullfunc(sta->local, pubsta, tid);
1868
1869 reason = IEEE80211_FRAME_RELEASE_UAPSD;
1870 more_data = ieee80211_sta_ps_more_data(sta, ~sta->sta.uapsd_queues,
1871 reason, 0);
1872
1873 ieee80211_send_null_response(sta, tid, reason, false, more_data);
1874}
1875EXPORT_SYMBOL(ieee80211_send_eosp_nullfunc);
1876
1877void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta,
1878 u8 tid, bool buffered)
1879{
1880 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1881
1882 if (WARN_ON(tid >= IEEE80211_NUM_TIDS))
1883 return;
1884
1885 trace_api_sta_set_buffered(sta->local, pubsta, tid, buffered);
1886
1887 if (buffered)
1888 set_bit(tid, &sta->driver_buffered_tids);
1889 else
1890 clear_bit(tid, &sta->driver_buffered_tids);
1891
1892 sta_info_recalc_tim(sta);
1893}
1894EXPORT_SYMBOL(ieee80211_sta_set_buffered);
1895
1896void ieee80211_register_airtime(struct ieee80211_txq *txq,
1897 u32 tx_airtime, u32 rx_airtime)
1898{
1899 struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->vif);
1900 struct ieee80211_local *local = sdata->local;
1901 u64 weight_sum, weight_sum_reciprocal;
1902 struct airtime_sched_info *air_sched;
1903 struct airtime_info *air_info;
1904 u32 airtime = 0;
1905
1906 air_sched = &local->airtime[txq->ac];
1907 air_info = to_airtime_info(txq);
1908
1909 if (local->airtime_flags & AIRTIME_USE_TX)
1910 airtime += tx_airtime;
1911 if (local->airtime_flags & AIRTIME_USE_RX)
1912 airtime += rx_airtime;
1913
1914
1915 airtime <<= 8;
1916
1917 spin_lock_bh(&air_sched->lock);
1918
1919 air_info->tx_airtime += tx_airtime;
1920 air_info->rx_airtime += rx_airtime;
1921
1922 if (air_sched->weight_sum) {
1923 weight_sum = air_sched->weight_sum;
1924 weight_sum_reciprocal = air_sched->weight_sum_reciprocal;
1925 } else {
1926 weight_sum = air_info->weight;
1927 weight_sum_reciprocal = air_info->weight_reciprocal;
1928 }
1929
1930
1931 air_sched->v_t += (u64)((airtime + (weight_sum >> 1)) *
1932 weight_sum_reciprocal) >> IEEE80211_RECIPROCAL_SHIFT_64;
1933 air_info->v_t += (u32)((airtime + (air_info->weight >> 1)) *
1934 air_info->weight_reciprocal) >> IEEE80211_RECIPROCAL_SHIFT_32;
1935 ieee80211_resort_txq(&local->hw, txq);
1936
1937 spin_unlock_bh(&air_sched->lock);
1938}
1939
1940void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid,
1941 u32 tx_airtime, u32 rx_airtime)
1942{
1943 struct ieee80211_txq *txq = pubsta->txq[tid];
1944
1945 if (!txq)
1946 return;
1947
1948 ieee80211_register_airtime(txq, tx_airtime, rx_airtime);
1949}
1950EXPORT_SYMBOL(ieee80211_sta_register_airtime);
1951
1952void ieee80211_sta_update_pending_airtime(struct ieee80211_local *local,
1953 struct sta_info *sta, u8 ac,
1954 u16 tx_airtime, bool tx_completed)
1955{
1956 int tx_pending;
1957
1958 if (!wiphy_ext_feature_isset(local->hw.wiphy, NL80211_EXT_FEATURE_AQL))
1959 return;
1960
1961 if (!tx_completed) {
1962 if (sta)
1963 atomic_add(tx_airtime,
1964 &sta->airtime[ac].aql_tx_pending);
1965
1966 atomic_add(tx_airtime, &local->aql_total_pending_airtime);
1967 return;
1968 }
1969
1970 if (sta) {
1971 tx_pending = atomic_sub_return(tx_airtime,
1972 &sta->airtime[ac].aql_tx_pending);
1973 if (tx_pending < 0)
1974 atomic_cmpxchg(&sta->airtime[ac].aql_tx_pending,
1975 tx_pending, 0);
1976 }
1977
1978 tx_pending = atomic_sub_return(tx_airtime,
1979 &local->aql_total_pending_airtime);
1980 if (WARN_ONCE(tx_pending < 0,
1981 "Device %s AC %d pending airtime underflow: %u, %u",
1982 wiphy_name(local->hw.wiphy), ac, tx_pending,
1983 tx_airtime))
1984 atomic_cmpxchg(&local->aql_total_pending_airtime,
1985 tx_pending, 0);
1986}
1987
1988int sta_info_move_state(struct sta_info *sta,
1989 enum ieee80211_sta_state new_state)
1990{
1991 might_sleep();
1992
1993 if (sta->sta_state == new_state)
1994 return 0;
1995
1996
1997
1998 switch (new_state) {
1999 case IEEE80211_STA_NONE:
2000 if (sta->sta_state != IEEE80211_STA_AUTH)
2001 return -EINVAL;
2002 break;
2003 case IEEE80211_STA_AUTH:
2004 if (sta->sta_state != IEEE80211_STA_NONE &&
2005 sta->sta_state != IEEE80211_STA_ASSOC)
2006 return -EINVAL;
2007 break;
2008 case IEEE80211_STA_ASSOC:
2009 if (sta->sta_state != IEEE80211_STA_AUTH &&
2010 sta->sta_state != IEEE80211_STA_AUTHORIZED)
2011 return -EINVAL;
2012 break;
2013 case IEEE80211_STA_AUTHORIZED:
2014 if (sta->sta_state != IEEE80211_STA_ASSOC)
2015 return -EINVAL;
2016 break;
2017 default:
2018 WARN(1, "invalid state %d", new_state);
2019 return -EINVAL;
2020 }
2021
2022 sta_dbg(sta->sdata, "moving STA %pM to state %d\n",
2023 sta->sta.addr, new_state);
2024
2025
2026
2027
2028
2029 if (test_sta_flag(sta, WLAN_STA_INSERTED)) {
2030 int err = drv_sta_state(sta->local, sta->sdata, sta,
2031 sta->sta_state, new_state);
2032 if (err)
2033 return err;
2034 }
2035
2036
2037
2038 switch (new_state) {
2039 case IEEE80211_STA_NONE:
2040 if (sta->sta_state == IEEE80211_STA_AUTH)
2041 clear_bit(WLAN_STA_AUTH, &sta->_flags);
2042 break;
2043 case IEEE80211_STA_AUTH:
2044 if (sta->sta_state == IEEE80211_STA_NONE) {
2045 set_bit(WLAN_STA_AUTH, &sta->_flags);
2046 } else if (sta->sta_state == IEEE80211_STA_ASSOC) {
2047 clear_bit(WLAN_STA_ASSOC, &sta->_flags);
2048 ieee80211_recalc_min_chandef(sta->sdata);
2049 if (!sta->sta.support_p2p_ps)
2050 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
2051 }
2052 break;
2053 case IEEE80211_STA_ASSOC:
2054 if (sta->sta_state == IEEE80211_STA_AUTH) {
2055 set_bit(WLAN_STA_ASSOC, &sta->_flags);
2056 sta->assoc_at = ktime_get_boottime_ns();
2057 ieee80211_recalc_min_chandef(sta->sdata);
2058 if (!sta->sta.support_p2p_ps)
2059 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
2060 } else if (sta->sta_state == IEEE80211_STA_AUTHORIZED) {
2061 ieee80211_vif_dec_num_mcast(sta->sdata);
2062 clear_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
2063 ieee80211_clear_fast_xmit(sta);
2064 ieee80211_clear_fast_rx(sta);
2065 }
2066 break;
2067 case IEEE80211_STA_AUTHORIZED:
2068 if (sta->sta_state == IEEE80211_STA_ASSOC) {
2069 ieee80211_vif_inc_num_mcast(sta->sdata);
2070 set_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
2071 ieee80211_check_fast_xmit(sta);
2072 ieee80211_check_fast_rx(sta);
2073 }
2074 if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
2075 sta->sdata->vif.type == NL80211_IFTYPE_AP)
2076 cfg80211_send_layer2_update(sta->sdata->dev,
2077 sta->sta.addr);
2078 break;
2079 default:
2080 break;
2081 }
2082
2083 sta->sta_state = new_state;
2084
2085 return 0;
2086}
2087
2088u8 sta_info_tx_streams(struct sta_info *sta)
2089{
2090 struct ieee80211_sta_ht_cap *ht_cap = &sta->sta.ht_cap;
2091 u8 rx_streams;
2092
2093 if (!sta->sta.ht_cap.ht_supported)
2094 return 1;
2095
2096 if (sta->sta.vht_cap.vht_supported) {
2097 int i;
2098 u16 tx_mcs_map =
2099 le16_to_cpu(sta->sta.vht_cap.vht_mcs.tx_mcs_map);
2100
2101 for (i = 7; i >= 0; i--)
2102 if ((tx_mcs_map & (0x3 << (i * 2))) !=
2103 IEEE80211_VHT_MCS_NOT_SUPPORTED)
2104 return i + 1;
2105 }
2106
2107 if (ht_cap->mcs.rx_mask[3])
2108 rx_streams = 4;
2109 else if (ht_cap->mcs.rx_mask[2])
2110 rx_streams = 3;
2111 else if (ht_cap->mcs.rx_mask[1])
2112 rx_streams = 2;
2113 else
2114 rx_streams = 1;
2115
2116 if (!(ht_cap->mcs.tx_params & IEEE80211_HT_MCS_TX_RX_DIFF))
2117 return rx_streams;
2118
2119 return ((ht_cap->mcs.tx_params & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
2120 >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1;
2121}
2122
2123static struct ieee80211_sta_rx_stats *
2124sta_get_last_rx_stats(struct sta_info *sta)
2125{
2126 struct ieee80211_sta_rx_stats *stats = &sta->rx_stats;
2127 int cpu;
2128
2129 if (!sta->pcpu_rx_stats)
2130 return stats;
2131
2132 for_each_possible_cpu(cpu) {
2133 struct ieee80211_sta_rx_stats *cpustats;
2134
2135 cpustats = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2136
2137 if (time_after(cpustats->last_rx, stats->last_rx))
2138 stats = cpustats;
2139 }
2140
2141 return stats;
2142}
2143
2144static void sta_stats_decode_rate(struct ieee80211_local *local, u32 rate,
2145 struct rate_info *rinfo)
2146{
2147 rinfo->bw = STA_STATS_GET(BW, rate);
2148
2149 switch (STA_STATS_GET(TYPE, rate)) {
2150 case STA_STATS_RATE_TYPE_VHT:
2151 rinfo->flags = RATE_INFO_FLAGS_VHT_MCS;
2152 rinfo->mcs = STA_STATS_GET(VHT_MCS, rate);
2153 rinfo->nss = STA_STATS_GET(VHT_NSS, rate);
2154 if (STA_STATS_GET(SGI, rate))
2155 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
2156 break;
2157 case STA_STATS_RATE_TYPE_HT:
2158 rinfo->flags = RATE_INFO_FLAGS_MCS;
2159 rinfo->mcs = STA_STATS_GET(HT_MCS, rate);
2160 if (STA_STATS_GET(SGI, rate))
2161 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
2162 break;
2163 case STA_STATS_RATE_TYPE_LEGACY: {
2164 struct ieee80211_supported_band *sband;
2165 u16 brate;
2166 unsigned int shift;
2167 int band = STA_STATS_GET(LEGACY_BAND, rate);
2168 int rate_idx = STA_STATS_GET(LEGACY_IDX, rate);
2169
2170 sband = local->hw.wiphy->bands[band];
2171
2172 if (WARN_ON_ONCE(!sband->bitrates))
2173 break;
2174
2175 brate = sband->bitrates[rate_idx].bitrate;
2176 if (rinfo->bw == RATE_INFO_BW_5)
2177 shift = 2;
2178 else if (rinfo->bw == RATE_INFO_BW_10)
2179 shift = 1;
2180 else
2181 shift = 0;
2182 rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
2183 break;
2184 }
2185 case STA_STATS_RATE_TYPE_HE:
2186 rinfo->flags = RATE_INFO_FLAGS_HE_MCS;
2187 rinfo->mcs = STA_STATS_GET(HE_MCS, rate);
2188 rinfo->nss = STA_STATS_GET(HE_NSS, rate);
2189 rinfo->he_gi = STA_STATS_GET(HE_GI, rate);
2190 rinfo->he_ru_alloc = STA_STATS_GET(HE_RU, rate);
2191 rinfo->he_dcm = STA_STATS_GET(HE_DCM, rate);
2192 break;
2193 }
2194}
2195
2196static int sta_set_rate_info_rx(struct sta_info *sta, struct rate_info *rinfo)
2197{
2198 u16 rate = READ_ONCE(sta_get_last_rx_stats(sta)->last_rate);
2199
2200 if (rate == STA_STATS_RATE_INVALID)
2201 return -EINVAL;
2202
2203 sta_stats_decode_rate(sta->local, rate, rinfo);
2204 return 0;
2205}
2206
2207static inline u64 sta_get_tidstats_msdu(struct ieee80211_sta_rx_stats *rxstats,
2208 int tid)
2209{
2210 unsigned int start;
2211 u64 value;
2212
2213 do {
2214 start = u64_stats_fetch_begin(&rxstats->syncp);
2215 value = rxstats->msdu[tid];
2216 } while (u64_stats_fetch_retry(&rxstats->syncp, start));
2217
2218 return value;
2219}
2220
2221static void sta_set_tidstats(struct sta_info *sta,
2222 struct cfg80211_tid_stats *tidstats,
2223 int tid)
2224{
2225 struct ieee80211_local *local = sta->local;
2226 int cpu;
2227
2228 if (!(tidstats->filled & BIT(NL80211_TID_STATS_RX_MSDU))) {
2229 tidstats->rx_msdu += sta_get_tidstats_msdu(&sta->rx_stats, tid);
2230
2231 if (sta->pcpu_rx_stats) {
2232 for_each_possible_cpu(cpu) {
2233 struct ieee80211_sta_rx_stats *cpurxs;
2234
2235 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2236 tidstats->rx_msdu +=
2237 sta_get_tidstats_msdu(cpurxs, tid);
2238 }
2239 }
2240
2241 tidstats->filled |= BIT(NL80211_TID_STATS_RX_MSDU);
2242 }
2243
2244 if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU))) {
2245 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU);
2246 tidstats->tx_msdu = sta->tx_stats.msdu[tid];
2247 }
2248
2249 if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU_RETRIES)) &&
2250 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
2251 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU_RETRIES);
2252 tidstats->tx_msdu_retries = sta->status_stats.msdu_retries[tid];
2253 }
2254
2255 if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU_FAILED)) &&
2256 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
2257 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU_FAILED);
2258 tidstats->tx_msdu_failed = sta->status_stats.msdu_failed[tid];
2259 }
2260
2261 if (local->ops->wake_tx_queue && tid < IEEE80211_NUM_TIDS) {
2262 spin_lock_bh(&local->fq.lock);
2263 rcu_read_lock();
2264
2265 tidstats->filled |= BIT(NL80211_TID_STATS_TXQ_STATS);
2266 ieee80211_fill_txq_stats(&tidstats->txq_stats,
2267 to_txq_info(sta->sta.txq[tid]));
2268
2269 rcu_read_unlock();
2270 spin_unlock_bh(&local->fq.lock);
2271 }
2272}
2273
2274static inline u64 sta_get_stats_bytes(struct ieee80211_sta_rx_stats *rxstats)
2275{
2276 unsigned int start;
2277 u64 value;
2278
2279 do {
2280 start = u64_stats_fetch_begin(&rxstats->syncp);
2281 value = rxstats->bytes;
2282 } while (u64_stats_fetch_retry(&rxstats->syncp, start));
2283
2284 return value;
2285}
2286
2287void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo,
2288 bool tidstats)
2289{
2290 struct ieee80211_sub_if_data *sdata = sta->sdata;
2291 struct ieee80211_local *local = sdata->local;
2292 u32 thr = 0;
2293 int i, ac, cpu;
2294 struct ieee80211_sta_rx_stats *last_rxstats;
2295
2296 last_rxstats = sta_get_last_rx_stats(sta);
2297
2298 sinfo->generation = sdata->local->sta_generation;
2299
2300
2301
2302
2303
2304 if (sdata->vif.type == NL80211_IFTYPE_STATION)
2305 sinfo->rx_beacon = sdata->u.mgd.count_beacon_signal;
2306
2307 drv_sta_statistics(local, sdata, &sta->sta, sinfo);
2308 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME) |
2309 BIT_ULL(NL80211_STA_INFO_STA_FLAGS) |
2310 BIT_ULL(NL80211_STA_INFO_BSS_PARAM) |
2311 BIT_ULL(NL80211_STA_INFO_CONNECTED_TIME) |
2312 BIT_ULL(NL80211_STA_INFO_ASSOC_AT_BOOTTIME) |
2313 BIT_ULL(NL80211_STA_INFO_RX_DROP_MISC);
2314
2315 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
2316 sinfo->beacon_loss_count = sdata->u.mgd.beacon_loss_count;
2317 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_LOSS);
2318 }
2319
2320 sinfo->connected_time = ktime_get_seconds() - sta->last_connected;
2321 sinfo->assoc_at = sta->assoc_at;
2322 sinfo->inactive_time =
2323 jiffies_to_msecs(jiffies - ieee80211_sta_last_active(sta));
2324
2325 if (!(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES64) |
2326 BIT_ULL(NL80211_STA_INFO_TX_BYTES)))) {
2327 sinfo->tx_bytes = 0;
2328 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2329 sinfo->tx_bytes += sta->tx_stats.bytes[ac];
2330 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES64);
2331 }
2332
2333 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_PACKETS))) {
2334 sinfo->tx_packets = 0;
2335 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2336 sinfo->tx_packets += sta->tx_stats.packets[ac];
2337 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
2338 }
2339
2340 if (!(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES64) |
2341 BIT_ULL(NL80211_STA_INFO_RX_BYTES)))) {
2342 sinfo->rx_bytes += sta_get_stats_bytes(&sta->rx_stats);
2343
2344 if (sta->pcpu_rx_stats) {
2345 for_each_possible_cpu(cpu) {
2346 struct ieee80211_sta_rx_stats *cpurxs;
2347
2348 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2349 sinfo->rx_bytes += sta_get_stats_bytes(cpurxs);
2350 }
2351 }
2352
2353 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES64);
2354 }
2355
2356 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_PACKETS))) {
2357 sinfo->rx_packets = sta->rx_stats.packets;
2358 if (sta->pcpu_rx_stats) {
2359 for_each_possible_cpu(cpu) {
2360 struct ieee80211_sta_rx_stats *cpurxs;
2361
2362 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2363 sinfo->rx_packets += cpurxs->packets;
2364 }
2365 }
2366 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
2367 }
2368
2369 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_RETRIES))) {
2370 sinfo->tx_retries = sta->status_stats.retry_count;
2371 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);
2372 }
2373
2374 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_FAILED))) {
2375 sinfo->tx_failed = sta->status_stats.retry_failed;
2376 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
2377 }
2378
2379 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_DURATION))) {
2380 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2381 sinfo->rx_duration += sta->airtime[ac].rx_airtime;
2382 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
2383 }
2384
2385 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_DURATION))) {
2386 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2387 sinfo->tx_duration += sta->airtime[ac].tx_airtime;
2388 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
2389 }
2390
2391 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_AIRTIME_WEIGHT))) {
2392 sinfo->airtime_weight = sta->airtime[0].weight;
2393 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_AIRTIME_WEIGHT);
2394 }
2395
2396 sinfo->rx_dropped_misc = sta->rx_stats.dropped;
2397 if (sta->pcpu_rx_stats) {
2398 for_each_possible_cpu(cpu) {
2399 struct ieee80211_sta_rx_stats *cpurxs;
2400
2401 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2402 sinfo->rx_dropped_misc += cpurxs->dropped;
2403 }
2404 }
2405
2406 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
2407 !(sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)) {
2408 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_RX) |
2409 BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
2410 sinfo->rx_beacon_signal_avg = ieee80211_ave_rssi(&sdata->vif);
2411 }
2412
2413 if (ieee80211_hw_check(&sta->local->hw, SIGNAL_DBM) ||
2414 ieee80211_hw_check(&sta->local->hw, SIGNAL_UNSPEC)) {
2415 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_SIGNAL))) {
2416 sinfo->signal = (s8)last_rxstats->last_signal;
2417 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
2418 }
2419
2420 if (!sta->pcpu_rx_stats &&
2421 !(sinfo->filled & BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG))) {
2422 sinfo->signal_avg =
2423 -ewma_signal_read(&sta->rx_stats_avg.signal);
2424 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
2425 }
2426 }
2427
2428
2429
2430
2431
2432 if (last_rxstats->chains &&
2433 !(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL) |
2434 BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)))) {
2435 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
2436 if (!sta->pcpu_rx_stats)
2437 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG);
2438
2439 sinfo->chains = last_rxstats->chains;
2440
2441 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
2442 sinfo->chain_signal[i] =
2443 last_rxstats->chain_signal_last[i];
2444 sinfo->chain_signal_avg[i] =
2445 -ewma_signal_read(&sta->rx_stats_avg.chain_signal[i]);
2446 }
2447 }
2448
2449 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE))) {
2450 sta_set_rate_info_tx(sta, &sta->tx_stats.last_rate,
2451 &sinfo->txrate);
2452 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
2453 }
2454
2455 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE))) {
2456 if (sta_set_rate_info_rx(sta, &sinfo->rxrate) == 0)
2457 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
2458 }
2459
2460 if (tidstats && !cfg80211_sinfo_alloc_tid_stats(sinfo, GFP_KERNEL)) {
2461 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
2462 sta_set_tidstats(sta, &sinfo->pertid[i], i);
2463 }
2464
2465 if (ieee80211_vif_is_mesh(&sdata->vif)) {
2466#ifdef CONFIG_MAC80211_MESH
2467 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_LLID) |
2468 BIT_ULL(NL80211_STA_INFO_PLID) |
2469 BIT_ULL(NL80211_STA_INFO_PLINK_STATE) |
2470 BIT_ULL(NL80211_STA_INFO_LOCAL_PM) |
2471 BIT_ULL(NL80211_STA_INFO_PEER_PM) |
2472 BIT_ULL(NL80211_STA_INFO_NONPEER_PM) |
2473 BIT_ULL(NL80211_STA_INFO_CONNECTED_TO_GATE) |
2474 BIT_ULL(NL80211_STA_INFO_CONNECTED_TO_AS);
2475
2476 sinfo->llid = sta->mesh->llid;
2477 sinfo->plid = sta->mesh->plid;
2478 sinfo->plink_state = sta->mesh->plink_state;
2479 if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
2480 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_T_OFFSET);
2481 sinfo->t_offset = sta->mesh->t_offset;
2482 }
2483 sinfo->local_pm = sta->mesh->local_pm;
2484 sinfo->peer_pm = sta->mesh->peer_pm;
2485 sinfo->nonpeer_pm = sta->mesh->nonpeer_pm;
2486 sinfo->connected_to_gate = sta->mesh->connected_to_gate;
2487 sinfo->connected_to_as = sta->mesh->connected_to_as;
2488#endif
2489 }
2490
2491 sinfo->bss_param.flags = 0;
2492 if (sdata->vif.bss_conf.use_cts_prot)
2493 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
2494 if (sdata->vif.bss_conf.use_short_preamble)
2495 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
2496 if (sdata->vif.bss_conf.use_short_slot)
2497 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
2498 sinfo->bss_param.dtim_period = sdata->vif.bss_conf.dtim_period;
2499 sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
2500
2501 sinfo->sta_flags.set = 0;
2502 sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2503 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2504 BIT(NL80211_STA_FLAG_WME) |
2505 BIT(NL80211_STA_FLAG_MFP) |
2506 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2507 BIT(NL80211_STA_FLAG_ASSOCIATED) |
2508 BIT(NL80211_STA_FLAG_TDLS_PEER);
2509 if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
2510 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
2511 if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
2512 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
2513 if (sta->sta.wme)
2514 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
2515 if (test_sta_flag(sta, WLAN_STA_MFP))
2516 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
2517 if (test_sta_flag(sta, WLAN_STA_AUTH))
2518 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
2519 if (test_sta_flag(sta, WLAN_STA_ASSOC))
2520 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
2521 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
2522 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2523
2524 thr = sta_get_expected_throughput(sta);
2525
2526 if (thr != 0) {
2527 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_EXPECTED_THROUGHPUT);
2528 sinfo->expected_throughput = thr;
2529 }
2530
2531 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL)) &&
2532 sta->status_stats.ack_signal_filled) {
2533 sinfo->ack_signal = sta->status_stats.last_ack_signal;
2534 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL);
2535 }
2536
2537 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL_AVG)) &&
2538 sta->status_stats.ack_signal_filled) {
2539 sinfo->avg_ack_signal =
2540 -(s8)ewma_avg_signal_read(
2541 &sta->status_stats.avg_ack_signal);
2542 sinfo->filled |=
2543 BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL_AVG);
2544 }
2545
2546 if (ieee80211_vif_is_mesh(&sdata->vif)) {
2547 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_AIRTIME_LINK_METRIC);
2548 sinfo->airtime_link_metric =
2549 airtime_link_metric_get(local, sta);
2550 }
2551}
2552
2553u32 sta_get_expected_throughput(struct sta_info *sta)
2554{
2555 struct ieee80211_sub_if_data *sdata = sta->sdata;
2556 struct ieee80211_local *local = sdata->local;
2557 struct rate_control_ref *ref = NULL;
2558 u32 thr = 0;
2559
2560 if (test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
2561 ref = local->rate_ctrl;
2562
2563
2564 if (ref && ref->ops->get_expected_throughput)
2565 thr = ref->ops->get_expected_throughput(sta->rate_ctrl_priv);
2566 else
2567 thr = drv_get_expected_throughput(local, sta);
2568
2569 return thr;
2570}
2571
2572unsigned long ieee80211_sta_last_active(struct sta_info *sta)
2573{
2574 struct ieee80211_sta_rx_stats *stats = sta_get_last_rx_stats(sta);
2575
2576 if (!sta->status_stats.last_ack ||
2577 time_after(stats->last_rx, sta->status_stats.last_ack))
2578 return stats->last_rx;
2579 return sta->status_stats.last_ack;
2580}
2581
2582static void sta_update_codel_params(struct sta_info *sta, u32 thr)
2583{
2584 if (!sta->sdata->local->ops->wake_tx_queue)
2585 return;
2586
2587 if (thr && thr < STA_SLOW_THRESHOLD * sta->local->num_sta) {
2588 sta->cparams.target = MS2TIME(50);
2589 sta->cparams.interval = MS2TIME(300);
2590 sta->cparams.ecn = false;
2591 } else {
2592 sta->cparams.target = MS2TIME(20);
2593 sta->cparams.interval = MS2TIME(100);
2594 sta->cparams.ecn = true;
2595 }
2596}
2597
2598void ieee80211_sta_set_expected_throughput(struct ieee80211_sta *pubsta,
2599 u32 thr)
2600{
2601 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
2602
2603 sta_update_codel_params(sta, thr);
2604}
2605