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