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