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