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