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