?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 5.1.15
[linux/fpc-iii.git] / net / mac80211 / sta_info.c
blob11f058987a54393edd87b7e04f88c74084bd70de
1 /*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
4 * Copyright 2013-2014 Intel Mobile Communications GmbH
5 * Copyright (C) 2015 - 2017 Intel Deutschland GmbH
6 * Copyright (C) 2018 Intel Corporation
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/etherdevice.h>
16 #include <linux/netdevice.h>
17 #include <linux/types.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/if_arp.h>
21 #include <linux/timer.h>
22 #include <linux/rtnetlink.h>
23
24 #include <net/codel.h>
25 #include <net/mac80211.h>
26 #include "ieee80211_i.h"
27 #include "driver-ops.h"
28 #include "rate.h"
29 #include "sta_info.h"
30 #include "debugfs_sta.h"
31 #include "mesh.h"
32 #include "wme.h"
33
34 /**
35 * DOC: STA information lifetime rules
36 *
37 * STA info structures (&struct sta_info) are managed in a hash table
38 * for faster lookup and a list for iteration. They are managed using
39 * RCU, i.e. access to the list and hash table is protected by RCU.
40 *
41 * Upon allocating a STA info structure with sta_info_alloc(), the caller
42 * owns that structure. It must then insert it into the hash table using
43 * either sta_info_insert() or sta_info_insert_rcu(); only in the latter
44 * case (which acquires an rcu read section but must not be called from
45 * within one) will the pointer still be valid after the call. Note that
46 * the caller may not do much with the STA info before inserting it, in
47 * particular, it may not start any mesh peer link management or add
48 * encryption keys.
49 *
50 * When the insertion fails (sta_info_insert()) returns non-zero), the
51 * structure will have been freed by sta_info_insert()!
52 *
53 * Station entries are added by mac80211 when you establish a link with a
54 * peer. This means different things for the different type of interfaces
55 * we support. For a regular station this mean we add the AP sta when we
56 * receive an association response from the AP. For IBSS this occurs when
57 * get to know about a peer on the same IBSS. For WDS we add the sta for
58 * the peer immediately upon device open. When using AP mode we add stations
59 * for each respective station upon request from userspace through nl80211.
60 *
61 * In order to remove a STA info structure, various sta_info_destroy_*()
62 * calls are available.
63 *
64 * There is no concept of ownership on a STA entry, each structure is
65 * owned by the global hash table/list until it is removed. All users of
66 * the structure need to be RCU protected so that the structure won't be
67 * freed before they are done using it.
68 */
69
70 static const struct rhashtable_params sta_rht_params = {
71 .nelem_hint = 3, /* start small */
72 .automatic_shrinking = true,
73 .head_offset = offsetof(struct sta_info, hash_node),
74 .key_offset = offsetof(struct sta_info, addr),
75 .key_len = ETH_ALEN,
76 .max_size = CONFIG_MAC80211_STA_HASH_MAX_SIZE,
77 };
78
79 /* Caller must hold local->sta_mtx */
80 static int sta_info_hash_del(struct ieee80211_local *local,
81 struct sta_info *sta)
82 {
83 return rhltable_remove(&local->sta_hash, &sta->hash_node,
84 sta_rht_params);
85 }
86
87 static void __cleanup_single_sta(struct sta_info *sta)
88 {
89 int ac, i;
90 struct tid_ampdu_tx *tid_tx;
91 struct ieee80211_sub_if_data *sdata = sta->sdata;
92 struct ieee80211_local *local = sdata->local;
93 struct ps_data *ps;
94
95 if (test_sta_flag(sta, WLAN_STA_PS_STA) ||
96 test_sta_flag(sta, WLAN_STA_PS_DRIVER) ||
97 test_sta_flag(sta, WLAN_STA_PS_DELIVER)) {
98 if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
99 sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
100 ps = &sdata->bss->ps;
101 else if (ieee80211_vif_is_mesh(&sdata->vif))
102 ps = &sdata->u.mesh.ps;
103 else
104 return;
105
106 clear_sta_flag(sta, WLAN_STA_PS_STA);
107 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
108 clear_sta_flag(sta, WLAN_STA_PS_DELIVER);
109
110 atomic_dec(&ps->num_sta_ps);
111 }
112
113 if (sta->sta.txq[0]) {
114 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
115 struct txq_info *txqi;
116
117 if (!sta->sta.txq[i])
118 continue;
119
120 txqi = to_txq_info(sta->sta.txq[i]);
121
122 ieee80211_txq_purge(local, txqi);
123 }
124 }
125
126 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
127 local->total_ps_buffered -= skb_queue_len(&sta->ps_tx_buf[ac]);
128 ieee80211_purge_tx_queue(&local->hw, &sta->ps_tx_buf[ac]);
129 ieee80211_purge_tx_queue(&local->hw, &sta->tx_filtered[ac]);
130 }
131
132 if (ieee80211_vif_is_mesh(&sdata->vif))
133 mesh_sta_cleanup(sta);
134
135 cancel_work_sync(&sta->drv_deliver_wk);
136
137 /*
138 * Destroy aggregation state here. It would be nice to wait for the
139 * driver to finish aggregation stop and then clean up, but for now
140 * drivers have to handle aggregation stop being requested, followed
141 * directly by station destruction.
142 */
143 for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
144 kfree(sta->ampdu_mlme.tid_start_tx[i]);
145 tid_tx = rcu_dereference_raw(sta->ampdu_mlme.tid_tx[i]);
146 if (!tid_tx)
147 continue;
148 ieee80211_purge_tx_queue(&local->hw, &tid_tx->pending);
149 kfree(tid_tx);
150 }
151 }
152
153 static void cleanup_single_sta(struct sta_info *sta)
154 {
155 struct ieee80211_sub_if_data *sdata = sta->sdata;
156 struct ieee80211_local *local = sdata->local;
157
158 __cleanup_single_sta(sta);
159 sta_info_free(local, sta);
160 }
161
162 struct rhlist_head *sta_info_hash_lookup(struct ieee80211_local *local,
163 const u8 *addr)
164 {
165 return rhltable_lookup(&local->sta_hash, addr, sta_rht_params);
166 }
167
168 /* protected by RCU */
169 struct sta_info *sta_info_get(struct ieee80211_sub_if_data *sdata,
170 const u8 *addr)
171 {
172 struct ieee80211_local *local = sdata->local;
173 struct rhlist_head *tmp;
174 struct sta_info *sta;
175
176 rcu_read_lock();
177 for_each_sta_info(local, addr, sta, tmp) {
178 if (sta->sdata == sdata) {
179 rcu_read_unlock();
180 /* this is safe as the caller must already hold
181 * another rcu read section or the mutex
182 */
183 return sta;
184 }
185 }
186 rcu_read_unlock();
187 return NULL;
188 }
189
190 /*
191 * Get sta info either from the specified interface
192 * or from one of its vlans
193 */
194 struct sta_info *sta_info_get_bss(struct ieee80211_sub_if_data *sdata,
195 const u8 *addr)
196 {
197 struct ieee80211_local *local = sdata->local;
198 struct rhlist_head *tmp;
199 struct sta_info *sta;
200
201 rcu_read_lock();
202 for_each_sta_info(local, addr, sta, tmp) {
203 if (sta->sdata == sdata ||
204 (sta->sdata->bss && sta->sdata->bss == sdata->bss)) {
205 rcu_read_unlock();
206 /* this is safe as the caller must already hold
207 * another rcu read section or the mutex
208 */
209 return sta;
210 }
211 }
212 rcu_read_unlock();
213 return NULL;
214 }
215
216 struct sta_info *sta_info_get_by_idx(struct ieee80211_sub_if_data *sdata,
217 int idx)
218 {
219 struct ieee80211_local *local = sdata->local;
220 struct sta_info *sta;
221 int i = 0;
222
223 list_for_each_entry_rcu(sta, &local->sta_list, list) {
224 if (sdata != sta->sdata)
225 continue;
226 if (i < idx) {
227 ++i;
228 continue;
229 }
230 return sta;
231 }
232
233 return NULL;
234 }
235
236 /**
237 * sta_info_free - free STA
238 *
239 * @local: pointer to the global information
240 * @sta: STA info to free
241 *
242 * This function must undo everything done by sta_info_alloc()
243 * that may happen before sta_info_insert(). It may only be
244 * called when sta_info_insert() has not been attempted (and
245 * if that fails, the station is freed anyway.)
246 */
247 void sta_info_free(struct ieee80211_local *local, struct sta_info *sta)
248 {
249 if (sta->rate_ctrl)
250 rate_control_free_sta(sta);
251
252 sta_dbg(sta->sdata, "Destroyed STA %pM\n", sta->sta.addr);
253
254 if (sta->sta.txq[0])
255 kfree(to_txq_info(sta->sta.txq[0]));
256 kfree(rcu_dereference_raw(sta->sta.rates));
257 #ifdef CONFIG_MAC80211_MESH
258 kfree(sta->mesh);
259 #endif
260 free_percpu(sta->pcpu_rx_stats);
261 kfree(sta);
262 }
263
264 /* Caller must hold local->sta_mtx */
265 static int sta_info_hash_add(struct ieee80211_local *local,
266 struct sta_info *sta)
267 {
268 return rhltable_insert(&local->sta_hash, &sta->hash_node,
269 sta_rht_params);
270 }
271
272 static void sta_deliver_ps_frames(struct work_struct *wk)
273 {
274 struct sta_info *sta;
275
276 sta = container_of(wk, struct sta_info, drv_deliver_wk);
277
278 if (sta->dead)
279 return;
280
281 local_bh_disable();
282 if (!test_sta_flag(sta, WLAN_STA_PS_STA))
283 ieee80211_sta_ps_deliver_wakeup(sta);
284 else if (test_and_clear_sta_flag(sta, WLAN_STA_PSPOLL))
285 ieee80211_sta_ps_deliver_poll_response(sta);
286 else if (test_and_clear_sta_flag(sta, WLAN_STA_UAPSD))
287 ieee80211_sta_ps_deliver_uapsd(sta);
288 local_bh_enable();
289 }
290
291 static int sta_prepare_rate_control(struct ieee80211_local *local,
292 struct sta_info *sta, gfp_t gfp)
293 {
294 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
295 return 0;
296
297 sta->rate_ctrl = local->rate_ctrl;
298 sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl,
299 sta, gfp);
300 if (!sta->rate_ctrl_priv)
301 return -ENOMEM;
302
303 return 0;
304 }
305
306 struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
307 const u8 *addr, gfp_t gfp)
308 {
309 struct ieee80211_local *local = sdata->local;
310 struct ieee80211_hw *hw = &local->hw;
311 struct sta_info *sta;
312 int i;
313
314 sta = kzalloc(sizeof(*sta) + hw->sta_data_size, gfp);
315 if (!sta)
316 return NULL;
317
318 if (ieee80211_hw_check(hw, USES_RSS)) {
319 sta->pcpu_rx_stats =
320 alloc_percpu_gfp(struct ieee80211_sta_rx_stats, gfp);
321 if (!sta->pcpu_rx_stats)
322 goto free;
323 }
324
325 spin_lock_init(&sta->lock);
326 spin_lock_init(&sta->ps_lock);
327 INIT_WORK(&sta->drv_deliver_wk, sta_deliver_ps_frames);
328 INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work);
329 mutex_init(&sta->ampdu_mlme.mtx);
330 #ifdef CONFIG_MAC80211_MESH
331 if (ieee80211_vif_is_mesh(&sdata->vif)) {
332 sta->mesh = kzalloc(sizeof(*sta->mesh), gfp);
333 if (!sta->mesh)
334 goto free;
335 sta->mesh->plink_sta = sta;
336 spin_lock_init(&sta->mesh->plink_lock);
337 if (ieee80211_vif_is_mesh(&sdata->vif) &&
338 !sdata->u.mesh.user_mpm)
339 timer_setup(&sta->mesh->plink_timer, mesh_plink_timer,
340 0);
341 sta->mesh->nonpeer_pm = NL80211_MESH_POWER_ACTIVE;
342 }
343 #endif
344
345 memcpy(sta->addr, addr, ETH_ALEN);
346 memcpy(sta->sta.addr, addr, ETH_ALEN);
347 sta->sta.max_rx_aggregation_subframes =
348 local->hw.max_rx_aggregation_subframes;
349
350 sta->local = local;
351 sta->sdata = sdata;
352 sta->rx_stats.last_rx = jiffies;
353
354 u64_stats_init(&sta->rx_stats.syncp);
355
356 sta->sta_state = IEEE80211_STA_NONE;
357
358 /* Mark TID as unreserved */
359 sta->reserved_tid = IEEE80211_TID_UNRESERVED;
360
361 sta->last_connected = ktime_get_seconds();
362 ewma_signal_init(&sta->rx_stats_avg.signal);
363 ewma_avg_signal_init(&sta->status_stats.avg_ack_signal);
364 for (i = 0; i < ARRAY_SIZE(sta->rx_stats_avg.chain_signal); i++)
365 ewma_signal_init(&sta->rx_stats_avg.chain_signal[i]);
366
367 if (local->ops->wake_tx_queue) {
368 void *txq_data;
369 int size = sizeof(struct txq_info) +
370 ALIGN(hw->txq_data_size, sizeof(void *));
371
372 txq_data = kcalloc(ARRAY_SIZE(sta->sta.txq), size, gfp);
373 if (!txq_data)
374 goto free;
375
376 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
377 struct txq_info *txq = txq_data + i * size;
378
379 /* might not do anything for the bufferable MMPDU TXQ */
380 ieee80211_txq_init(sdata, sta, txq, i);
381 }
382 }
383
384 if (sta_prepare_rate_control(local, sta, gfp))
385 goto free_txq;
386
387 sta->airtime_weight = IEEE80211_DEFAULT_AIRTIME_WEIGHT;
388
389 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
390 skb_queue_head_init(&sta->ps_tx_buf[i]);
391 skb_queue_head_init(&sta->tx_filtered[i]);
392 sta->airtime[i].deficit = sta->airtime_weight;
393 }
394
395 for (i = 0; i < IEEE80211_NUM_TIDS; i++)
396 sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX);
397
398 sta->sta.smps_mode = IEEE80211_SMPS_OFF;
399 if (sdata->vif.type == NL80211_IFTYPE_AP ||
400 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
401 struct ieee80211_supported_band *sband;
402 u8 smps;
403
404 sband = ieee80211_get_sband(sdata);
405 if (!sband)
406 goto free_txq;
407
408 smps = (sband->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >>
409 IEEE80211_HT_CAP_SM_PS_SHIFT;
410 /*
411 * Assume that hostapd advertises our caps in the beacon and
412 * this is the known_smps_mode for a station that just assciated
413 */
414 switch (smps) {
415 case WLAN_HT_SMPS_CONTROL_DISABLED:
416 sta->known_smps_mode = IEEE80211_SMPS_OFF;
417 break;
418 case WLAN_HT_SMPS_CONTROL_STATIC:
419 sta->known_smps_mode = IEEE80211_SMPS_STATIC;
420 break;
421 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
422 sta->known_smps_mode = IEEE80211_SMPS_DYNAMIC;
423 break;
424 default:
425 WARN_ON(1);
426 }
427 }
428
429 sta->sta.max_rc_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_BA;
430
431 sta->cparams.ce_threshold = CODEL_DISABLED_THRESHOLD;
432 sta->cparams.target = MS2TIME(20);
433 sta->cparams.interval = MS2TIME(100);
434 sta->cparams.ecn = true;
435
436 sta_dbg(sdata, "Allocated STA %pM\n", sta->sta.addr);
437
438 return sta;
439
440 free_txq:
441 if (sta->sta.txq[0])
442 kfree(to_txq_info(sta->sta.txq[0]));
443 free:
444 free_percpu(sta->pcpu_rx_stats);
445 #ifdef CONFIG_MAC80211_MESH
446 kfree(sta->mesh);
447 #endif
448 kfree(sta);
449 return NULL;
450 }
451
452 static int sta_info_insert_check(struct sta_info *sta)
453 {
454 struct ieee80211_sub_if_data *sdata = sta->sdata;
455
456 /*
457 * Can't be a WARN_ON because it can be triggered through a race:
458 * something inserts a STA (on one CPU) without holding the RTNL
459 * and another CPU turns off the net device.
460 */
461 if (unlikely(!ieee80211_sdata_running(sdata)))
462 return -ENETDOWN;
463
464 if (WARN_ON(ether_addr_equal(sta->sta.addr, sdata->vif.addr) ||
465 is_multicast_ether_addr(sta->sta.addr)))
466 return -EINVAL;
467
468 /* The RCU read lock is required by rhashtable due to
469 * asynchronous resize/rehash. We also require the mutex
470 * for correctness.
471 */
472 rcu_read_lock();
473 lockdep_assert_held(&sdata->local->sta_mtx);
474 if (ieee80211_hw_check(&sdata->local->hw, NEEDS_UNIQUE_STA_ADDR) &&
475 ieee80211_find_sta_by_ifaddr(&sdata->local->hw, sta->addr, NULL)) {
476 rcu_read_unlock();
477 return -ENOTUNIQ;
478 }
479 rcu_read_unlock();
480
481 return 0;
482 }
483
484 static int sta_info_insert_drv_state(struct ieee80211_local *local,
485 struct ieee80211_sub_if_data *sdata,
486 struct sta_info *sta)
487 {
488 enum ieee80211_sta_state state;
489 int err = 0;
490
491 for (state = IEEE80211_STA_NOTEXIST; state < sta->sta_state; state++) {
492 err = drv_sta_state(local, sdata, sta, state, state + 1);
493 if (err)
494 break;
495 }
496
497 if (!err) {
498 /*
499 * Drivers using legacy sta_add/sta_remove callbacks only
500 * get uploaded set to true after sta_add is called.
501 */
502 if (!local->ops->sta_add)
503 sta->uploaded = true;
504 return 0;
505 }
506
507 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
508 sdata_info(sdata,
509 "failed to move IBSS STA %pM to state %d (%d) - keeping it anyway\n",
510 sta->sta.addr, state + 1, err);
511 err = 0;
512 }
513
514 /* unwind on error */
515 for (; state > IEEE80211_STA_NOTEXIST; state--)
516 WARN_ON(drv_sta_state(local, sdata, sta, state, state - 1));
517
518 return err;
519 }
520
521 static void
522 ieee80211_recalc_p2p_go_ps_allowed(struct ieee80211_sub_if_data *sdata)
523 {
524 struct ieee80211_local *local = sdata->local;
525 bool allow_p2p_go_ps = sdata->vif.p2p;
526 struct sta_info *sta;
527
528 rcu_read_lock();
529 list_for_each_entry_rcu(sta, &local->sta_list, list) {
530 if (sdata != sta->sdata ||
531 !test_sta_flag(sta, WLAN_STA_ASSOC))
532 continue;
533 if (!sta->sta.support_p2p_ps) {
534 allow_p2p_go_ps = false;
535 break;
536 }
537 }
538 rcu_read_unlock();
539
540 if (allow_p2p_go_ps != sdata->vif.bss_conf.allow_p2p_go_ps) {
541 sdata->vif.bss_conf.allow_p2p_go_ps = allow_p2p_go_ps;
542 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_P2P_PS);
543 }
544 }
545
546 /*
547 * should be called with sta_mtx locked
548 * this function replaces the mutex lock
549 * with a RCU lock
550 */
551 static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU)
552 {
553 struct ieee80211_local *local = sta->local;
554 struct ieee80211_sub_if_data *sdata = sta->sdata;
555 struct station_info *sinfo = NULL;
556 int err = 0;
557
558 lockdep_assert_held(&local->sta_mtx);
559
560 /* check if STA exists already */
561 if (sta_info_get_bss(sdata, sta->sta.addr)) {
562 err = -EEXIST;
563 goto out_err;
564 }
565
566 sinfo = kzalloc(sizeof(struct station_info), GFP_KERNEL);
567 if (!sinfo) {
568 err = -ENOMEM;
569 goto out_err;
570 }
571
572 local->num_sta++;
573 local->sta_generation++;
574 smp_mb();
575
576 /* simplify things and don't accept BA sessions yet */
577 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
578
579 /* make the station visible */
580 err = sta_info_hash_add(local, sta);
581 if (err)
582 goto out_drop_sta;
583
584 list_add_tail_rcu(&sta->list, &local->sta_list);
585
586 /* notify driver */
587 err = sta_info_insert_drv_state(local, sdata, sta);
588 if (err)
589 goto out_remove;
590
591 set_sta_flag(sta, WLAN_STA_INSERTED);
592
593 if (sta->sta_state >= IEEE80211_STA_ASSOC) {
594 ieee80211_recalc_min_chandef(sta->sdata);
595 if (!sta->sta.support_p2p_ps)
596 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
597 }
598
599 /* accept BA sessions now */
600 clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
601
602 ieee80211_sta_debugfs_add(sta);
603 rate_control_add_sta_debugfs(sta);
604
605 sinfo->generation = local->sta_generation;
606 cfg80211_new_sta(sdata->dev, sta->sta.addr, sinfo, GFP_KERNEL);
607 kfree(sinfo);
608
609 sta_dbg(sdata, "Inserted STA %pM\n", sta->sta.addr);
610
611 /* move reference to rcu-protected */
612 rcu_read_lock();
613 mutex_unlock(&local->sta_mtx);
614
615 if (ieee80211_vif_is_mesh(&sdata->vif))
616 mesh_accept_plinks_update(sdata);
617
618 return 0;
619 out_remove:
620 sta_info_hash_del(local, sta);
621 list_del_rcu(&sta->list);
622 out_drop_sta:
623 local->num_sta--;
624 synchronize_net();
625 __cleanup_single_sta(sta);
626 out_err:
627 mutex_unlock(&local->sta_mtx);
628 kfree(sinfo);
629 rcu_read_lock();
630 return err;
631 }
632
633 int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU)
634 {
635 struct ieee80211_local *local = sta->local;
636 int err;
637
638 might_sleep();
639
640 mutex_lock(&local->sta_mtx);
641
642 err = sta_info_insert_check(sta);
643 if (err) {
644 mutex_unlock(&local->sta_mtx);
645 rcu_read_lock();
646 goto out_free;
647 }
648
649 err = sta_info_insert_finish(sta);
650 if (err)
651 goto out_free;
652
653 return 0;
654 out_free:
655 sta_info_free(local, sta);
656 return err;
657 }
658
659 int sta_info_insert(struct sta_info *sta)
660 {
661 int err = sta_info_insert_rcu(sta);
662
663 rcu_read_unlock();
664
665 return err;
666 }
667
668 static inline void __bss_tim_set(u8 *tim, u16 id)
669 {
670 /*
671 * This format has been mandated by the IEEE specifications,
672 * so this line may not be changed to use the __set_bit() format.
673 */
674 tim[id / 8] |= (1 << (id % 8));
675 }
676
677 static inline void __bss_tim_clear(u8 *tim, u16 id)
678 {
679 /*
680 * This format has been mandated by the IEEE specifications,
681 * so this line may not be changed to use the __clear_bit() format.
682 */
683 tim[id / 8] &= ~(1 << (id % 8));
684 }
685
686 static inline bool __bss_tim_get(u8 *tim, u16 id)
687 {
688 /*
689 * This format has been mandated by the IEEE specifications,
690 * so this line may not be changed to use the test_bit() format.
691 */
692 return tim[id / 8] & (1 << (id % 8));
693 }
694
695 static unsigned long ieee80211_tids_for_ac(int ac)
696 {
697 /* If we ever support TIDs > 7, this obviously needs to be adjusted */
698 switch (ac) {
699 case IEEE80211_AC_VO:
700 return BIT(6) | BIT(7);
701 case IEEE80211_AC_VI:
702 return BIT(4) | BIT(5);
703 case IEEE80211_AC_BE:
704 return BIT(0) | BIT(3);
705 case IEEE80211_AC_BK:
706 return BIT(1) | BIT(2);
707 default:
708 WARN_ON(1);
709 return 0;
710 }
711 }
712
713 static void __sta_info_recalc_tim(struct sta_info *sta, bool ignore_pending)
714 {
715 struct ieee80211_local *local = sta->local;
716 struct ps_data *ps;
717 bool indicate_tim = false;
718 u8 ignore_for_tim = sta->sta.uapsd_queues;
719 int ac;
720 u16 id = sta->sta.aid;
721
722 if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
723 sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
724 if (WARN_ON_ONCE(!sta->sdata->bss))
725 return;
726
727 ps = &sta->sdata->bss->ps;
728 #ifdef CONFIG_MAC80211_MESH
729 } else if (ieee80211_vif_is_mesh(&sta->sdata->vif)) {
730 ps = &sta->sdata->u.mesh.ps;
731 #endif
732 } else {
733 return;
734 }
735
736 /* No need to do anything if the driver does all */
737 if (ieee80211_hw_check(&local->hw, AP_LINK_PS) && !local->ops->set_tim)
738 return;
739
740 if (sta->dead)
741 goto done;
742
743 /*
744 * If all ACs are delivery-enabled then we should build
745 * the TIM bit for all ACs anyway; if only some are then
746 * we ignore those and build the TIM bit using only the
747 * non-enabled ones.
748 */
749 if (ignore_for_tim == BIT(IEEE80211_NUM_ACS) - 1)
750 ignore_for_tim = 0;
751
752 if (ignore_pending)
753 ignore_for_tim = BIT(IEEE80211_NUM_ACS) - 1;
754
755 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
756 unsigned long tids;
757
758 if (ignore_for_tim & ieee80211_ac_to_qos_mask[ac])
759 continue;
760
761 indicate_tim |= !skb_queue_empty(&sta->tx_filtered[ac]) ||
762 !skb_queue_empty(&sta->ps_tx_buf[ac]);
763 if (indicate_tim)
764 break;
765
766 tids = ieee80211_tids_for_ac(ac);
767
768 indicate_tim |=
769 sta->driver_buffered_tids & tids;
770 indicate_tim |=
771 sta->txq_buffered_tids & tids;
772 }
773
774 done:
775 spin_lock_bh(&local->tim_lock);
776
777 if (indicate_tim == __bss_tim_get(ps->tim, id))
778 goto out_unlock;
779
780 if (indicate_tim)
781 __bss_tim_set(ps->tim, id);
782 else
783 __bss_tim_clear(ps->tim, id);
784
785 if (local->ops->set_tim && !WARN_ON(sta->dead)) {
786 local->tim_in_locked_section = true;
787 drv_set_tim(local, &sta->sta, indicate_tim);
788 local->tim_in_locked_section = false;
789 }
790
791 out_unlock:
792 spin_unlock_bh(&local->tim_lock);
793 }
794
795 void sta_info_recalc_tim(struct sta_info *sta)
796 {
797 __sta_info_recalc_tim(sta, false);
798 }
799
800 static bool sta_info_buffer_expired(struct sta_info *sta, struct sk_buff *skb)
801 {
802 struct ieee80211_tx_info *info;
803 int timeout;
804
805 if (!skb)
806 return false;
807
808 info = IEEE80211_SKB_CB(skb);
809
810 /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */
811 timeout = (sta->listen_interval *
812 sta->sdata->vif.bss_conf.beacon_int *
813 32 / 15625) * HZ;
814 if (timeout < STA_TX_BUFFER_EXPIRE)
815 timeout = STA_TX_BUFFER_EXPIRE;
816 return time_after(jiffies, info->control.jiffies + timeout);
817 }
818
819
820 static bool sta_info_cleanup_expire_buffered_ac(struct ieee80211_local *local,
821 struct sta_info *sta, int ac)
822 {
823 unsigned long flags;
824 struct sk_buff *skb;
825
826 /*
827 * First check for frames that should expire on the filtered
828 * queue. Frames here were rejected by the driver and are on
829 * a separate queue to avoid reordering with normal PS-buffered
830 * frames. They also aren't accounted for right now in the
831 * total_ps_buffered counter.
832 */
833 for (;;) {
834 spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags);
835 skb = skb_peek(&sta->tx_filtered[ac]);
836 if (sta_info_buffer_expired(sta, skb))
837 skb = __skb_dequeue(&sta->tx_filtered[ac]);
838 else
839 skb = NULL;
840 spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags);
841
842 /*
843 * Frames are queued in order, so if this one
844 * hasn't expired yet we can stop testing. If
845 * we actually reached the end of the queue we
846 * also need to stop, of course.
847 */
848 if (!skb)
849 break;
850 ieee80211_free_txskb(&local->hw, skb);
851 }
852
853 /*
854 * Now also check the normal PS-buffered queue, this will
855 * only find something if the filtered queue was emptied
856 * since the filtered frames are all before the normal PS
857 * buffered frames.
858 */
859 for (;;) {
860 spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags);
861 skb = skb_peek(&sta->ps_tx_buf[ac]);
862 if (sta_info_buffer_expired(sta, skb))
863 skb = __skb_dequeue(&sta->ps_tx_buf[ac]);
864 else
865 skb = NULL;
866 spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags);
867
868 /*
869 * frames are queued in order, so if this one
870 * hasn't expired yet (or we reached the end of
871 * the queue) we can stop testing
872 */
873 if (!skb)
874 break;
875
876 local->total_ps_buffered--;
877 ps_dbg(sta->sdata, "Buffered frame expired (STA %pM)\n",
878 sta->sta.addr);
879 ieee80211_free_txskb(&local->hw, skb);
880 }
881
882 /*
883 * Finally, recalculate the TIM bit for this station -- it might
884 * now be clear because the station was too slow to retrieve its
885 * frames.
886 */
887 sta_info_recalc_tim(sta);
888
889 /*
890 * Return whether there are any frames still buffered, this is
891 * used to check whether the cleanup timer still needs to run,
892 * if there are no frames we don't need to rearm the timer.
893 */
894 return !(skb_queue_empty(&sta->ps_tx_buf[ac]) &&
895 skb_queue_empty(&sta->tx_filtered[ac]));
896 }
897
898 static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
899 struct sta_info *sta)
900 {
901 bool have_buffered = false;
902 int ac;
903
904 /* This is only necessary for stations on BSS/MBSS interfaces */
905 if (!sta->sdata->bss &&
906 !ieee80211_vif_is_mesh(&sta->sdata->vif))
907 return false;
908
909 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
910 have_buffered |=
911 sta_info_cleanup_expire_buffered_ac(local, sta, ac);
912
913 return have_buffered;
914 }
915
916 static int __must_check __sta_info_destroy_part1(struct sta_info *sta)
917 {
918 struct ieee80211_local *local;
919 struct ieee80211_sub_if_data *sdata;
920 int ret;
921
922 might_sleep();
923
924 if (!sta)
925 return -ENOENT;
926
927 local = sta->local;
928 sdata = sta->sdata;
929
930 lockdep_assert_held(&local->sta_mtx);
931
932 /*
933 * Before removing the station from the driver and
934 * rate control, it might still start new aggregation
935 * sessions -- block that to make sure the tear-down
936 * will be sufficient.
937 */
938 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
939 ieee80211_sta_tear_down_BA_sessions(sta, AGG_STOP_DESTROY_STA);
940
941 /*
942 * Before removing the station from the driver there might be pending
943 * rx frames on RSS queues sent prior to the disassociation - wait for
944 * all such frames to be processed.
945 */
946 drv_sync_rx_queues(local, sta);
947
948 ret = sta_info_hash_del(local, sta);
949 if (WARN_ON(ret))
950 return ret;
951
952 /*
953 * for TDLS peers, make sure to return to the base channel before
954 * removal.
955 */
956 if (test_sta_flag(sta, WLAN_STA_TDLS_OFF_CHANNEL)) {
957 drv_tdls_cancel_channel_switch(local, sdata, &sta->sta);
958 clear_sta_flag(sta, WLAN_STA_TDLS_OFF_CHANNEL);
959 }
960
961 list_del_rcu(&sta->list);
962 sta->removed = true;
963
964 drv_sta_pre_rcu_remove(local, sta->sdata, sta);
965
966 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
967 rcu_access_pointer(sdata->u.vlan.sta) == sta)
968 RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
969
970 return 0;
971 }
972
973 static void __sta_info_destroy_part2(struct sta_info *sta)
974 {
975 struct ieee80211_local *local = sta->local;
976 struct ieee80211_sub_if_data *sdata = sta->sdata;
977 struct station_info *sinfo;
978 int ret;
979
980 /*
981 * NOTE: This assumes at least synchronize_net() was done
982 * after _part1 and before _part2!
983 */
984
985 might_sleep();
986 lockdep_assert_held(&local->sta_mtx);
987
988 /* now keys can no longer be reached */
989 ieee80211_free_sta_keys(local, sta);
990
991 /* disable TIM bit - last chance to tell driver */
992 __sta_info_recalc_tim(sta, true);
993
994 sta->dead = true;
995
996 local->num_sta--;
997 local->sta_generation++;
998
999 while (sta->sta_state > IEEE80211_STA_NONE) {
1000 ret = sta_info_move_state(sta, sta->sta_state - 1);
1001 if (ret) {
1002 WARN_ON_ONCE(1);
1003 break;
1004 }
1005 }
1006
1007 if (sta->uploaded) {
1008 ret = drv_sta_state(local, sdata, sta, IEEE80211_STA_NONE,
1009 IEEE80211_STA_NOTEXIST);
1010 WARN_ON_ONCE(ret != 0);
1011 }
1012
1013 sta_dbg(sdata, "Removed STA %pM\n", sta->sta.addr);
1014
1015 sinfo = kzalloc(sizeof(*sinfo), GFP_KERNEL);
1016 if (sinfo)
1017 sta_set_sinfo(sta, sinfo, true);
1018 cfg80211_del_sta_sinfo(sdata->dev, sta->sta.addr, sinfo, GFP_KERNEL);
1019 kfree(sinfo);
1020
1021 rate_control_remove_sta_debugfs(sta);
1022 ieee80211_sta_debugfs_remove(sta);
1023
1024 cleanup_single_sta(sta);
1025 }
1026
1027 int __must_check __sta_info_destroy(struct sta_info *sta)
1028 {
1029 int err = __sta_info_destroy_part1(sta);
1030
1031 if (err)
1032 return err;
1033
1034 synchronize_net();
1035
1036 __sta_info_destroy_part2(sta);
1037
1038 return 0;
1039 }
1040
1041 int sta_info_destroy_addr(struct ieee80211_sub_if_data *sdata, const u8 *addr)
1042 {
1043 struct sta_info *sta;
1044 int ret;
1045
1046 mutex_lock(&sdata->local->sta_mtx);
1047 sta = sta_info_get(sdata, addr);
1048 ret = __sta_info_destroy(sta);
1049 mutex_unlock(&sdata->local->sta_mtx);
1050
1051 return ret;
1052 }
1053
1054 int sta_info_destroy_addr_bss(struct ieee80211_sub_if_data *sdata,
1055 const u8 *addr)
1056 {
1057 struct sta_info *sta;
1058 int ret;
1059
1060 mutex_lock(&sdata->local->sta_mtx);
1061 sta = sta_info_get_bss(sdata, addr);
1062 ret = __sta_info_destroy(sta);
1063 mutex_unlock(&sdata->local->sta_mtx);
1064
1065 return ret;
1066 }
1067
1068 static void sta_info_cleanup(struct timer_list *t)
1069 {
1070 struct ieee80211_local *local = from_timer(local, t, sta_cleanup);
1071 struct sta_info *sta;
1072 bool timer_needed = false;
1073
1074 rcu_read_lock();
1075 list_for_each_entry_rcu(sta, &local->sta_list, list)
1076 if (sta_info_cleanup_expire_buffered(local, sta))
1077 timer_needed = true;
1078 rcu_read_unlock();
1079
1080 if (local->quiescing)
1081 return;
1082
1083 if (!timer_needed)
1084 return;
1085
1086 mod_timer(&local->sta_cleanup,
1087 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL));
1088 }
1089
1090 int sta_info_init(struct ieee80211_local *local)
1091 {
1092 int err;
1093
1094 err = rhltable_init(&local->sta_hash, &sta_rht_params);
1095 if (err)
1096 return err;
1097
1098 spin_lock_init(&local->tim_lock);
1099 mutex_init(&local->sta_mtx);
1100 INIT_LIST_HEAD(&local->sta_list);
1101
1102 timer_setup(&local->sta_cleanup, sta_info_cleanup, 0);
1103 return 0;
1104 }
1105
1106 void sta_info_stop(struct ieee80211_local *local)
1107 {
1108 del_timer_sync(&local->sta_cleanup);
1109 rhltable_destroy(&local->sta_hash);
1110 }
1111
1112
1113 int __sta_info_flush(struct ieee80211_sub_if_data *sdata, bool vlans)
1114 {
1115 struct ieee80211_local *local = sdata->local;
1116 struct sta_info *sta, *tmp;
1117 LIST_HEAD(free_list);
1118 int ret = 0;
1119
1120 might_sleep();
1121
1122 WARN_ON(vlans && sdata->vif.type != NL80211_IFTYPE_AP);
1123 WARN_ON(vlans && !sdata->bss);
1124
1125 mutex_lock(&local->sta_mtx);
1126 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1127 if (sdata == sta->sdata ||
1128 (vlans && sdata->bss == sta->sdata->bss)) {
1129 if (!WARN_ON(__sta_info_destroy_part1(sta)))
1130 list_add(&sta->free_list, &free_list);
1131 ret++;
1132 }
1133 }
1134
1135 if (!list_empty(&free_list)) {
1136 synchronize_net();
1137 list_for_each_entry_safe(sta, tmp, &free_list, free_list)
1138 __sta_info_destroy_part2(sta);
1139 }
1140 mutex_unlock(&local->sta_mtx);
1141
1142 return ret;
1143 }
1144
1145 void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
1146 unsigned long exp_time)
1147 {
1148 struct ieee80211_local *local = sdata->local;
1149 struct sta_info *sta, *tmp;
1150
1151 mutex_lock(&local->sta_mtx);
1152
1153 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1154 unsigned long last_active = ieee80211_sta_last_active(sta);
1155
1156 if (sdata != sta->sdata)
1157 continue;
1158
1159 if (time_is_before_jiffies(last_active + exp_time)) {
1160 sta_dbg(sta->sdata, "expiring inactive STA %pM\n",
1161 sta->sta.addr);
1162
1163 if (ieee80211_vif_is_mesh(&sdata->vif) &&
1164 test_sta_flag(sta, WLAN_STA_PS_STA))
1165 atomic_dec(&sdata->u.mesh.ps.num_sta_ps);
1166
1167 WARN_ON(__sta_info_destroy(sta));
1168 }
1169 }
1170
1171 mutex_unlock(&local->sta_mtx);
1172 }
1173
1174 struct ieee80211_sta *ieee80211_find_sta_by_ifaddr(struct ieee80211_hw *hw,
1175 const u8 *addr,
1176 const u8 *localaddr)
1177 {
1178 struct ieee80211_local *local = hw_to_local(hw);
1179 struct rhlist_head *tmp;
1180 struct sta_info *sta;
1181
1182 /*
1183 * Just return a random station if localaddr is NULL
1184 * ... first in list.
1185 */
1186 for_each_sta_info(local, addr, sta, tmp) {
1187 if (localaddr &&
1188 !ether_addr_equal(sta->sdata->vif.addr, localaddr))
1189 continue;
1190 if (!sta->uploaded)
1191 return NULL;
1192 return &sta->sta;
1193 }
1194
1195 return NULL;
1196 }
1197 EXPORT_SYMBOL_GPL(ieee80211_find_sta_by_ifaddr);
1198
1199 struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_vif *vif,
1200 const u8 *addr)
1201 {
1202 struct sta_info *sta;
1203
1204 if (!vif)
1205 return NULL;
1206
1207 sta = sta_info_get_bss(vif_to_sdata(vif), addr);
1208 if (!sta)
1209 return NULL;
1210
1211 if (!sta->uploaded)
1212 return NULL;
1213
1214 return &sta->sta;
1215 }
1216 EXPORT_SYMBOL(ieee80211_find_sta);
1217
1218 /* powersave support code */
1219 void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)
1220 {
1221 struct ieee80211_sub_if_data *sdata = sta->sdata;
1222 struct ieee80211_local *local = sdata->local;
1223 struct sk_buff_head pending;
1224 int filtered = 0, buffered = 0, ac, i;
1225 unsigned long flags;
1226 struct ps_data *ps;
1227
1228 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1229 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
1230 u.ap);
1231
1232 if (sdata->vif.type == NL80211_IFTYPE_AP)
1233 ps = &sdata->bss->ps;
1234 else if (ieee80211_vif_is_mesh(&sdata->vif))
1235 ps = &sdata->u.mesh.ps;
1236 else
1237 return;
1238
1239 clear_sta_flag(sta, WLAN_STA_SP);
1240
1241 BUILD_BUG_ON(BITS_TO_LONGS(IEEE80211_NUM_TIDS) > 1);
1242 sta->driver_buffered_tids = 0;
1243 sta->txq_buffered_tids = 0;
1244
1245 if (!ieee80211_hw_check(&local->hw, AP_LINK_PS))
1246 drv_sta_notify(local, sdata, STA_NOTIFY_AWAKE, &sta->sta);
1247
1248 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
1249 if (!sta->sta.txq[i] || !txq_has_queue(sta->sta.txq[i]))
1250 continue;
1251
1252 schedule_and_wake_txq(local, to_txq_info(sta->sta.txq[i]));
1253 }
1254
1255 skb_queue_head_init(&pending);
1256
1257 /* sync with ieee80211_tx_h_unicast_ps_buf */
1258 spin_lock(&sta->ps_lock);
1259 /* Send all buffered frames to the station */
1260 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1261 int count = skb_queue_len(&pending), tmp;
1262
1263 spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags);
1264 skb_queue_splice_tail_init(&sta->tx_filtered[ac], &pending);
1265 spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags);
1266 tmp = skb_queue_len(&pending);
1267 filtered += tmp - count;
1268 count = tmp;
1269
1270 spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags);
1271 skb_queue_splice_tail_init(&sta->ps_tx_buf[ac], &pending);
1272 spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags);
1273 tmp = skb_queue_len(&pending);
1274 buffered += tmp - count;
1275 }
1276
1277 ieee80211_add_pending_skbs(local, &pending);
1278
1279 /* now we're no longer in the deliver code */
1280 clear_sta_flag(sta, WLAN_STA_PS_DELIVER);
1281
1282 /* The station might have polled and then woken up before we responded,
1283 * so clear these flags now to avoid them sticking around.
1284 */
1285 clear_sta_flag(sta, WLAN_STA_PSPOLL);
1286 clear_sta_flag(sta, WLAN_STA_UAPSD);
1287 spin_unlock(&sta->ps_lock);
1288
1289 atomic_dec(&ps->num_sta_ps);
1290
1291 /* This station just woke up and isn't aware of our SMPS state */
1292 if (!ieee80211_vif_is_mesh(&sdata->vif) &&
1293 !ieee80211_smps_is_restrictive(sta->known_smps_mode,
1294 sdata->smps_mode) &&
1295 sta->known_smps_mode != sdata->bss->req_smps &&
1296 sta_info_tx_streams(sta) != 1) {
1297 ht_dbg(sdata,
1298 "%pM just woke up and MIMO capable - update SMPS\n",
1299 sta->sta.addr);
1300 ieee80211_send_smps_action(sdata, sdata->bss->req_smps,
1301 sta->sta.addr,
1302 sdata->vif.bss_conf.bssid);
1303 }
1304
1305 local->total_ps_buffered -= buffered;
1306
1307 sta_info_recalc_tim(sta);
1308
1309 ps_dbg(sdata,
1310 "STA %pM aid %d sending %d filtered/%d PS frames since STA woke up\n",
1311 sta->sta.addr, sta->sta.aid, filtered, buffered);
1312
1313 ieee80211_check_fast_xmit(sta);
1314 }
1315
1316 static void ieee80211_send_null_response(struct sta_info *sta, int tid,
1317 enum ieee80211_frame_release_type reason,
1318 bool call_driver, bool more_data)
1319 {
1320 struct ieee80211_sub_if_data *sdata = sta->sdata;
1321 struct ieee80211_local *local = sdata->local;
1322 struct ieee80211_qos_hdr *nullfunc;
1323 struct sk_buff *skb;
1324 int size = sizeof(*nullfunc);
1325 __le16 fc;
1326 bool qos = sta->sta.wme;
1327 struct ieee80211_tx_info *info;
1328 struct ieee80211_chanctx_conf *chanctx_conf;
1329
1330 /* Don't send NDPs when STA is connected HE */
1331 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1332 !(sdata->u.mgd.flags & IEEE80211_STA_DISABLE_HE))
1333 return;
1334
1335 if (qos) {
1336 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
1337 IEEE80211_STYPE_QOS_NULLFUNC |
1338 IEEE80211_FCTL_FROMDS);
1339 } else {
1340 size -= 2;
1341 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
1342 IEEE80211_STYPE_NULLFUNC |
1343 IEEE80211_FCTL_FROMDS);
1344 }
1345
1346 skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
1347 if (!skb)
1348 return;
1349
1350 skb_reserve(skb, local->hw.extra_tx_headroom);
1351
1352 nullfunc = skb_put(skb, size);
1353 nullfunc->frame_control = fc;
1354 nullfunc->duration_id = 0;
1355 memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
1356 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
1357 memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
1358 nullfunc->seq_ctrl = 0;
1359
1360 skb->priority = tid;
1361 skb_set_queue_mapping(skb, ieee802_1d_to_ac[tid]);
1362 if (qos) {
1363 nullfunc->qos_ctrl = cpu_to_le16(tid);
1364
1365 if (reason == IEEE80211_FRAME_RELEASE_UAPSD) {
1366 nullfunc->qos_ctrl |=
1367 cpu_to_le16(IEEE80211_QOS_CTL_EOSP);
1368 if (more_data)
1369 nullfunc->frame_control |=
1370 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1371 }
1372 }
1373
1374 info = IEEE80211_SKB_CB(skb);
1375
1376 /*
1377 * Tell TX path to send this frame even though the
1378 * STA may still remain is PS mode after this frame
1379 * exchange. Also set EOSP to indicate this packet
1380 * ends the poll/service period.
1381 */
1382 info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER |
1383 IEEE80211_TX_STATUS_EOSP |
1384 IEEE80211_TX_CTL_REQ_TX_STATUS;
1385
1386 info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
1387
1388 if (call_driver)
1389 drv_allow_buffered_frames(local, sta, BIT(tid), 1,
1390 reason, false);
1391
1392 skb->dev = sdata->dev;
1393
1394 rcu_read_lock();
1395 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1396 if (WARN_ON(!chanctx_conf)) {
1397 rcu_read_unlock();
1398 kfree_skb(skb);
1399 return;
1400 }
1401
1402 info->band = chanctx_conf->def.chan->band;
1403 ieee80211_xmit(sdata, sta, skb, 0);
1404 rcu_read_unlock();
1405 }
1406
1407 static int find_highest_prio_tid(unsigned long tids)
1408 {
1409 /* lower 3 TIDs aren't ordered perfectly */
1410 if (tids & 0xF8)
1411 return fls(tids) - 1;
1412 /* TID 0 is BE just like TID 3 */
1413 if (tids & BIT(0))
1414 return 0;
1415 return fls(tids) - 1;
1416 }
1417
1418 /* Indicates if the MORE_DATA bit should be set in the last
1419 * frame obtained by ieee80211_sta_ps_get_frames.
1420 * Note that driver_release_tids is relevant only if
1421 * reason = IEEE80211_FRAME_RELEASE_PSPOLL
1422 */
1423 static bool
1424 ieee80211_sta_ps_more_data(struct sta_info *sta, u8 ignored_acs,
1425 enum ieee80211_frame_release_type reason,
1426 unsigned long driver_release_tids)
1427 {
1428 int ac;
1429
1430 /* If the driver has data on more than one TID then
1431 * certainly there's more data if we release just a
1432 * single frame now (from a single TID). This will
1433 * only happen for PS-Poll.
1434 */
1435 if (reason == IEEE80211_FRAME_RELEASE_PSPOLL &&
1436 hweight16(driver_release_tids) > 1)
1437 return true;
1438
1439 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1440 if (ignored_acs & ieee80211_ac_to_qos_mask[ac])
1441 continue;
1442
1443 if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
1444 !skb_queue_empty(&sta->ps_tx_buf[ac]))
1445 return true;
1446 }
1447
1448 return false;
1449 }
1450
1451 static void
1452 ieee80211_sta_ps_get_frames(struct sta_info *sta, int n_frames, u8 ignored_acs,
1453 enum ieee80211_frame_release_type reason,
1454 struct sk_buff_head *frames,
1455 unsigned long *driver_release_tids)
1456 {
1457 struct ieee80211_sub_if_data *sdata = sta->sdata;
1458 struct ieee80211_local *local = sdata->local;
1459 int ac;
1460
1461 /* Get response frame(s) and more data bit for the last one. */
1462 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1463 unsigned long tids;
1464
1465 if (ignored_acs & ieee80211_ac_to_qos_mask[ac])
1466 continue;
1467
1468 tids = ieee80211_tids_for_ac(ac);
1469
1470 /* if we already have frames from software, then we can't also
1471 * release from hardware queues
1472 */
1473 if (skb_queue_empty(frames)) {
1474 *driver_release_tids |=
1475 sta->driver_buffered_tids & tids;
1476 *driver_release_tids |= sta->txq_buffered_tids & tids;
1477 }
1478
1479 if (!*driver_release_tids) {
1480 struct sk_buff *skb;
1481
1482 while (n_frames > 0) {
1483 skb = skb_dequeue(&sta->tx_filtered[ac]);
1484 if (!skb) {
1485 skb = skb_dequeue(
1486 &sta->ps_tx_buf[ac]);
1487 if (skb)
1488 local->total_ps_buffered--;
1489 }
1490 if (!skb)
1491 break;
1492 n_frames--;
1493 __skb_queue_tail(frames, skb);
1494 }
1495 }
1496
1497 /* If we have more frames buffered on this AC, then abort the
1498 * loop since we can't send more data from other ACs before
1499 * the buffered frames from this.
1500 */
1501 if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
1502 !skb_queue_empty(&sta->ps_tx_buf[ac]))
1503 break;
1504 }
1505 }
1506
1507 static void
1508 ieee80211_sta_ps_deliver_response(struct sta_info *sta,
1509 int n_frames, u8 ignored_acs,
1510 enum ieee80211_frame_release_type reason)
1511 {
1512 struct ieee80211_sub_if_data *sdata = sta->sdata;
1513 struct ieee80211_local *local = sdata->local;
1514 unsigned long driver_release_tids = 0;
1515 struct sk_buff_head frames;
1516 bool more_data;
1517
1518 /* Service or PS-Poll period starts */
1519 set_sta_flag(sta, WLAN_STA_SP);
1520
1521 __skb_queue_head_init(&frames);
1522
1523 ieee80211_sta_ps_get_frames(sta, n_frames, ignored_acs, reason,
1524 &frames, &driver_release_tids);
1525
1526 more_data = ieee80211_sta_ps_more_data(sta, ignored_acs, reason, driver_release_tids);
1527
1528 if (driver_release_tids && reason == IEEE80211_FRAME_RELEASE_PSPOLL)
1529 driver_release_tids =
1530 BIT(find_highest_prio_tid(driver_release_tids));
1531
1532 if (skb_queue_empty(&frames) && !driver_release_tids) {
1533 int tid, ac;
1534
1535 /*
1536 * For PS-Poll, this can only happen due to a race condition
1537 * when we set the TIM bit and the station notices it, but
1538 * before it can poll for the frame we expire it.
1539 *
1540 * For uAPSD, this is said in the standard (11.2.1.5 h):
1541 * At each unscheduled SP for a non-AP STA, the AP shall
1542 * attempt to transmit at least one MSDU or MMPDU, but no
1543 * more than the value specified in the Max SP Length field
1544 * in the QoS Capability element from delivery-enabled ACs,
1545 * that are destined for the non-AP STA.
1546 *
1547 * Since we have no other MSDU/MMPDU, transmit a QoS null frame.
1548 */
1549
1550 /* This will evaluate to 1, 3, 5 or 7. */
1551 for (ac = IEEE80211_AC_VO; ac < IEEE80211_NUM_ACS; ac++)
1552 if (!(ignored_acs & ieee80211_ac_to_qos_mask[ac]))
1553 break;
1554 tid = 7 - 2 * ac;
1555
1556 ieee80211_send_null_response(sta, tid, reason, true, false);
1557 } else if (!driver_release_tids) {
1558 struct sk_buff_head pending;
1559 struct sk_buff *skb;
1560 int num = 0;
1561 u16 tids = 0;
1562 bool need_null = false;
1563
1564 skb_queue_head_init(&pending);
1565
1566 while ((skb = __skb_dequeue(&frames))) {
1567 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1568 struct ieee80211_hdr *hdr = (void *) skb->data;
1569 u8 *qoshdr = NULL;
1570
1571 num++;
1572
1573 /*
1574 * Tell TX path to send this frame even though the
1575 * STA may still remain is PS mode after this frame
1576 * exchange.
1577 */
1578 info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
1579 info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
1580
1581 /*
1582 * Use MoreData flag to indicate whether there are
1583 * more buffered frames for this STA
1584 */
1585 if (more_data || !skb_queue_empty(&frames))
1586 hdr->frame_control |=
1587 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1588 else
1589 hdr->frame_control &=
1590 cpu_to_le16(~IEEE80211_FCTL_MOREDATA);
1591
1592 if (ieee80211_is_data_qos(hdr->frame_control) ||
1593 ieee80211_is_qos_nullfunc(hdr->frame_control))
1594 qoshdr = ieee80211_get_qos_ctl(hdr);
1595
1596 tids |= BIT(skb->priority);
1597
1598 __skb_queue_tail(&pending, skb);
1599
1600 /* end service period after last frame or add one */
1601 if (!skb_queue_empty(&frames))
1602 continue;
1603
1604 if (reason != IEEE80211_FRAME_RELEASE_UAPSD) {
1605 /* for PS-Poll, there's only one frame */
1606 info->flags |= IEEE80211_TX_STATUS_EOSP |
1607 IEEE80211_TX_CTL_REQ_TX_STATUS;
1608 break;
1609 }
1610
1611 /* For uAPSD, things are a bit more complicated. If the
1612 * last frame has a QoS header (i.e. is a QoS-data or
1613 * QoS-nulldata frame) then just set the EOSP bit there
1614 * and be done.
1615 * If the frame doesn't have a QoS header (which means
1616 * it should be a bufferable MMPDU) then we can't set
1617 * the EOSP bit in the QoS header; add a QoS-nulldata
1618 * frame to the list to send it after the MMPDU.
1619 *
1620 * Note that this code is only in the mac80211-release
1621 * code path, we assume that the driver will not buffer
1622 * anything but QoS-data frames, or if it does, will
1623 * create the QoS-nulldata frame by itself if needed.
1624 *
1625 * Cf. 802.11-2012 10.2.1.10 (c).
1626 */
1627 if (qoshdr) {
1628 *qoshdr |= IEEE80211_QOS_CTL_EOSP;
1629
1630 info->flags |= IEEE80211_TX_STATUS_EOSP |
1631 IEEE80211_TX_CTL_REQ_TX_STATUS;
1632 } else {
1633 /* The standard isn't completely clear on this
1634 * as it says the more-data bit should be set
1635 * if there are more BUs. The QoS-Null frame
1636 * we're about to send isn't buffered yet, we
1637 * only create it below, but let's pretend it
1638 * was buffered just in case some clients only
1639 * expect more-data=0 when eosp=1.
1640 */
1641 hdr->frame_control |=
1642 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1643 need_null = true;
1644 num++;
1645 }
1646 break;
1647 }
1648
1649 drv_allow_buffered_frames(local, sta, tids, num,
1650 reason, more_data);
1651
1652 ieee80211_add_pending_skbs(local, &pending);
1653
1654 if (need_null)
1655 ieee80211_send_null_response(
1656 sta, find_highest_prio_tid(tids),
1657 reason, false, false);
1658
1659 sta_info_recalc_tim(sta);
1660 } else {
1661 int tid;
1662
1663 /*
1664 * We need to release a frame that is buffered somewhere in the
1665 * driver ... it'll have to handle that.
1666 * Note that the driver also has to check the number of frames
1667 * on the TIDs we're releasing from - if there are more than
1668 * n_frames it has to set the more-data bit (if we didn't ask
1669 * it to set it anyway due to other buffered frames); if there
1670 * are fewer than n_frames it has to make sure to adjust that
1671 * to allow the service period to end properly.
1672 */
1673 drv_release_buffered_frames(local, sta, driver_release_tids,
1674 n_frames, reason, more_data);
1675
1676 /*
1677 * Note that we don't recalculate the TIM bit here as it would
1678 * most likely have no effect at all unless the driver told us
1679 * that the TID(s) became empty before returning here from the
1680 * release function.
1681 * Either way, however, when the driver tells us that the TID(s)
1682 * became empty or we find that a txq became empty, we'll do the
1683 * TIM recalculation.
1684 */
1685
1686 if (!sta->sta.txq[0])
1687 return;
1688
1689 for (tid = 0; tid < ARRAY_SIZE(sta->sta.txq); tid++) {
1690 if (!sta->sta.txq[tid] ||
1691 !(driver_release_tids & BIT(tid)) ||
1692 txq_has_queue(sta->sta.txq[tid]))
1693 continue;
1694
1695 sta_info_recalc_tim(sta);
1696 break;
1697 }
1698 }
1699 }
1700
1701 void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta)
1702 {
1703 u8 ignore_for_response = sta->sta.uapsd_queues;
1704
1705 /*
1706 * If all ACs are delivery-enabled then we should reply
1707 * from any of them, if only some are enabled we reply
1708 * only from the non-enabled ones.
1709 */
1710 if (ignore_for_response == BIT(IEEE80211_NUM_ACS) - 1)
1711 ignore_for_response = 0;
1712
1713 ieee80211_sta_ps_deliver_response(sta, 1, ignore_for_response,
1714 IEEE80211_FRAME_RELEASE_PSPOLL);
1715 }
1716
1717 void ieee80211_sta_ps_deliver_uapsd(struct sta_info *sta)
1718 {
1719 int n_frames = sta->sta.max_sp;
1720 u8 delivery_enabled = sta->sta.uapsd_queues;
1721
1722 /*
1723 * If we ever grow support for TSPEC this might happen if
1724 * the TSPEC update from hostapd comes in between a trigger
1725 * frame setting WLAN_STA_UAPSD in the RX path and this
1726 * actually getting called.
1727 */
1728 if (!delivery_enabled)
1729 return;
1730
1731 switch (sta->sta.max_sp) {
1732 case 1:
1733 n_frames = 2;
1734 break;
1735 case 2:
1736 n_frames = 4;
1737 break;
1738 case 3:
1739 n_frames = 6;
1740 break;
1741 case 0:
1742 /* XXX: what is a good value? */
1743 n_frames = 128;
1744 break;
1745 }
1746
1747 ieee80211_sta_ps_deliver_response(sta, n_frames, ~delivery_enabled,
1748 IEEE80211_FRAME_RELEASE_UAPSD);
1749 }
1750
1751 void ieee80211_sta_block_awake(struct ieee80211_hw *hw,
1752 struct ieee80211_sta *pubsta, bool block)
1753 {
1754 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1755
1756 trace_api_sta_block_awake(sta->local, pubsta, block);
1757
1758 if (block) {
1759 set_sta_flag(sta, WLAN_STA_PS_DRIVER);
1760 ieee80211_clear_fast_xmit(sta);
1761 return;
1762 }
1763
1764 if (!test_sta_flag(sta, WLAN_STA_PS_DRIVER))
1765 return;
1766
1767 if (!test_sta_flag(sta, WLAN_STA_PS_STA)) {
1768 set_sta_flag(sta, WLAN_STA_PS_DELIVER);
1769 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1770 ieee80211_queue_work(hw, &sta->drv_deliver_wk);
1771 } else if (test_sta_flag(sta, WLAN_STA_PSPOLL) ||
1772 test_sta_flag(sta, WLAN_STA_UAPSD)) {
1773 /* must be asleep in this case */
1774 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1775 ieee80211_queue_work(hw, &sta->drv_deliver_wk);
1776 } else {
1777 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1778 ieee80211_check_fast_xmit(sta);
1779 }
1780 }
1781 EXPORT_SYMBOL(ieee80211_sta_block_awake);
1782
1783 void ieee80211_sta_eosp(struct ieee80211_sta *pubsta)
1784 {
1785 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1786 struct ieee80211_local *local = sta->local;
1787
1788 trace_api_eosp(local, pubsta);
1789
1790 clear_sta_flag(sta, WLAN_STA_SP);
1791 }
1792 EXPORT_SYMBOL(ieee80211_sta_eosp);
1793
1794 void ieee80211_send_eosp_nullfunc(struct ieee80211_sta *pubsta, int tid)
1795 {
1796 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1797 enum ieee80211_frame_release_type reason;
1798 bool more_data;
1799
1800 trace_api_send_eosp_nullfunc(sta->local, pubsta, tid);
1801
1802 reason = IEEE80211_FRAME_RELEASE_UAPSD;
1803 more_data = ieee80211_sta_ps_more_data(sta, ~sta->sta.uapsd_queues,
1804 reason, 0);
1805
1806 ieee80211_send_null_response(sta, tid, reason, false, more_data);
1807 }
1808 EXPORT_SYMBOL(ieee80211_send_eosp_nullfunc);
1809
1810 void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta,
1811 u8 tid, bool buffered)
1812 {
1813 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1814
1815 if (WARN_ON(tid >= IEEE80211_NUM_TIDS))
1816 return;
1817
1818 trace_api_sta_set_buffered(sta->local, pubsta, tid, buffered);
1819
1820 if (buffered)
1821 set_bit(tid, &sta->driver_buffered_tids);
1822 else
1823 clear_bit(tid, &sta->driver_buffered_tids);
1824
1825 sta_info_recalc_tim(sta);
1826 }
1827 EXPORT_SYMBOL(ieee80211_sta_set_buffered);
1828
1829 void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid,
1830 u32 tx_airtime, u32 rx_airtime)
1831 {
1832 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1833 struct ieee80211_local *local = sta->sdata->local;
1834 u8 ac = ieee80211_ac_from_tid(tid);
1835 u32 airtime = 0;
1836
1837 if (sta->local->airtime_flags & AIRTIME_USE_TX)
1838 airtime += tx_airtime;
1839 if (sta->local->airtime_flags & AIRTIME_USE_RX)
1840 airtime += rx_airtime;
1841
1842 spin_lock_bh(&local->active_txq_lock[ac]);
1843 sta->airtime[ac].tx_airtime += tx_airtime;
1844 sta->airtime[ac].rx_airtime += rx_airtime;
1845 sta->airtime[ac].deficit -= airtime;
1846 spin_unlock_bh(&local->active_txq_lock[ac]);
1847 }
1848 EXPORT_SYMBOL(ieee80211_sta_register_airtime);
1849
1850 int sta_info_move_state(struct sta_info *sta,
1851 enum ieee80211_sta_state new_state)
1852 {
1853 might_sleep();
1854
1855 if (sta->sta_state == new_state)
1856 return 0;
1857
1858 /* check allowed transitions first */
1859
1860 switch (new_state) {
1861 case IEEE80211_STA_NONE:
1862 if (sta->sta_state != IEEE80211_STA_AUTH)
1863 return -EINVAL;
1864 break;
1865 case IEEE80211_STA_AUTH:
1866 if (sta->sta_state != IEEE80211_STA_NONE &&
1867 sta->sta_state != IEEE80211_STA_ASSOC)
1868 return -EINVAL;
1869 break;
1870 case IEEE80211_STA_ASSOC:
1871 if (sta->sta_state != IEEE80211_STA_AUTH &&
1872 sta->sta_state != IEEE80211_STA_AUTHORIZED)
1873 return -EINVAL;
1874 break;
1875 case IEEE80211_STA_AUTHORIZED:
1876 if (sta->sta_state != IEEE80211_STA_ASSOC)
1877 return -EINVAL;
1878 break;
1879 default:
1880 WARN(1, "invalid state %d", new_state);
1881 return -EINVAL;
1882 }
1883
1884 sta_dbg(sta->sdata, "moving STA %pM to state %d\n",
1885 sta->sta.addr, new_state);
1886
1887 /*
1888 * notify the driver before the actual changes so it can
1889 * fail the transition
1890 */
1891 if (test_sta_flag(sta, WLAN_STA_INSERTED)) {
1892 int err = drv_sta_state(sta->local, sta->sdata, sta,
1893 sta->sta_state, new_state);
1894 if (err)
1895 return err;
1896 }
1897
1898 /* reflect the change in all state variables */
1899
1900 switch (new_state) {
1901 case IEEE80211_STA_NONE:
1902 if (sta->sta_state == IEEE80211_STA_AUTH)
1903 clear_bit(WLAN_STA_AUTH, &sta->_flags);
1904 break;
1905 case IEEE80211_STA_AUTH:
1906 if (sta->sta_state == IEEE80211_STA_NONE) {
1907 set_bit(WLAN_STA_AUTH, &sta->_flags);
1908 } else if (sta->sta_state == IEEE80211_STA_ASSOC) {
1909 clear_bit(WLAN_STA_ASSOC, &sta->_flags);
1910 ieee80211_recalc_min_chandef(sta->sdata);
1911 if (!sta->sta.support_p2p_ps)
1912 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
1913 }
1914 break;
1915 case IEEE80211_STA_ASSOC:
1916 if (sta->sta_state == IEEE80211_STA_AUTH) {
1917 set_bit(WLAN_STA_ASSOC, &sta->_flags);
1918 ieee80211_recalc_min_chandef(sta->sdata);
1919 if (!sta->sta.support_p2p_ps)
1920 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
1921 } else if (sta->sta_state == IEEE80211_STA_AUTHORIZED) {
1922 ieee80211_vif_dec_num_mcast(sta->sdata);
1923 clear_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
1924 ieee80211_clear_fast_xmit(sta);
1925 ieee80211_clear_fast_rx(sta);
1926 }
1927 break;
1928 case IEEE80211_STA_AUTHORIZED:
1929 if (sta->sta_state == IEEE80211_STA_ASSOC) {
1930 ieee80211_vif_inc_num_mcast(sta->sdata);
1931 set_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
1932 ieee80211_check_fast_xmit(sta);
1933 ieee80211_check_fast_rx(sta);
1934 }
1935 break;
1936 default:
1937 break;
1938 }
1939
1940 sta->sta_state = new_state;
1941
1942 return 0;
1943 }
1944
1945 u8 sta_info_tx_streams(struct sta_info *sta)
1946 {
1947 struct ieee80211_sta_ht_cap *ht_cap = &sta->sta.ht_cap;
1948 u8 rx_streams;
1949
1950 if (!sta->sta.ht_cap.ht_supported)
1951 return 1;
1952
1953 if (sta->sta.vht_cap.vht_supported) {
1954 int i;
1955 u16 tx_mcs_map =
1956 le16_to_cpu(sta->sta.vht_cap.vht_mcs.tx_mcs_map);
1957
1958 for (i = 7; i >= 0; i--)
1959 if ((tx_mcs_map & (0x3 << (i * 2))) !=
1960 IEEE80211_VHT_MCS_NOT_SUPPORTED)
1961 return i + 1;
1962 }
1963
1964 if (ht_cap->mcs.rx_mask[3])
1965 rx_streams = 4;
1966 else if (ht_cap->mcs.rx_mask[2])
1967 rx_streams = 3;
1968 else if (ht_cap->mcs.rx_mask[1])
1969 rx_streams = 2;
1970 else
1971 rx_streams = 1;
1972
1973 if (!(ht_cap->mcs.tx_params & IEEE80211_HT_MCS_TX_RX_DIFF))
1974 return rx_streams;
1975
1976 return ((ht_cap->mcs.tx_params & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
1977 >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1;
1978 }
1979
1980 static struct ieee80211_sta_rx_stats *
1981 sta_get_last_rx_stats(struct sta_info *sta)
1982 {
1983 struct ieee80211_sta_rx_stats *stats = &sta->rx_stats;
1984 struct ieee80211_local *local = sta->local;
1985 int cpu;
1986
1987 if (!ieee80211_hw_check(&local->hw, USES_RSS))
1988 return stats;
1989
1990 for_each_possible_cpu(cpu) {
1991 struct ieee80211_sta_rx_stats *cpustats;
1992
1993 cpustats = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
1994
1995 if (time_after(cpustats->last_rx, stats->last_rx))
1996 stats = cpustats;
1997 }
1998
1999 return stats;
2000 }
2001
2002 static void sta_stats_decode_rate(struct ieee80211_local *local, u32 rate,
2003 struct rate_info *rinfo)
2004 {
2005 rinfo->bw = STA_STATS_GET(BW, rate);
2006
2007 switch (STA_STATS_GET(TYPE, rate)) {
2008 case STA_STATS_RATE_TYPE_VHT:
2009 rinfo->flags = RATE_INFO_FLAGS_VHT_MCS;
2010 rinfo->mcs = STA_STATS_GET(VHT_MCS, rate);
2011 rinfo->nss = STA_STATS_GET(VHT_NSS, rate);
2012 if (STA_STATS_GET(SGI, rate))
2013 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
2014 break;
2015 case STA_STATS_RATE_TYPE_HT:
2016 rinfo->flags = RATE_INFO_FLAGS_MCS;
2017 rinfo->mcs = STA_STATS_GET(HT_MCS, rate);
2018 if (STA_STATS_GET(SGI, rate))
2019 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
2020 break;
2021 case STA_STATS_RATE_TYPE_LEGACY: {
2022 struct ieee80211_supported_band *sband;
2023 u16 brate;
2024 unsigned int shift;
2025 int band = STA_STATS_GET(LEGACY_BAND, rate);
2026 int rate_idx = STA_STATS_GET(LEGACY_IDX, rate);
2027
2028 sband = local->hw.wiphy->bands[band];
2029 brate = sband->bitrates[rate_idx].bitrate;
2030 if (rinfo->bw == RATE_INFO_BW_5)
2031 shift = 2;
2032 else if (rinfo->bw == RATE_INFO_BW_10)
2033 shift = 1;
2034 else
2035 shift = 0;
2036 rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
2037 break;
2038 }
2039 case STA_STATS_RATE_TYPE_HE:
2040 rinfo->flags = RATE_INFO_FLAGS_HE_MCS;
2041 rinfo->mcs = STA_STATS_GET(HE_MCS, rate);
2042 rinfo->nss = STA_STATS_GET(HE_NSS, rate);
2043 rinfo->he_gi = STA_STATS_GET(HE_GI, rate);
2044 rinfo->he_ru_alloc = STA_STATS_GET(HE_RU, rate);
2045 rinfo->he_dcm = STA_STATS_GET(HE_DCM, rate);
2046 break;
2047 }
2048 }
2049
2050 static int sta_set_rate_info_rx(struct sta_info *sta, struct rate_info *rinfo)
2051 {
2052 u16 rate = READ_ONCE(sta_get_last_rx_stats(sta)->last_rate);
2053
2054 if (rate == STA_STATS_RATE_INVALID)
2055 return -EINVAL;
2056
2057 sta_stats_decode_rate(sta->local, rate, rinfo);
2058 return 0;
2059 }
2060
2061 static void sta_set_tidstats(struct sta_info *sta,
2062 struct cfg80211_tid_stats *tidstats,
2063 int tid)
2064 {
2065 struct ieee80211_local *local = sta->local;
2066
2067 if (!(tidstats->filled & BIT(NL80211_TID_STATS_RX_MSDU))) {
2068 unsigned int start;
2069
2070 do {
2071 start = u64_stats_fetch_begin(&sta->rx_stats.syncp);
2072 tidstats->rx_msdu = sta->rx_stats.msdu[tid];
2073 } while (u64_stats_fetch_retry(&sta->rx_stats.syncp, start));
2074
2075 tidstats->filled |= BIT(NL80211_TID_STATS_RX_MSDU);
2076 }
2077
2078 if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU))) {
2079 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU);
2080 tidstats->tx_msdu = sta->tx_stats.msdu[tid];
2081 }
2082
2083 if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU_RETRIES)) &&
2084 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
2085 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU_RETRIES);
2086 tidstats->tx_msdu_retries = sta->status_stats.msdu_retries[tid];
2087 }
2088
2089 if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU_FAILED)) &&
2090 ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
2091 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU_FAILED);
2092 tidstats->tx_msdu_failed = sta->status_stats.msdu_failed[tid];
2093 }
2094
2095 if (local->ops->wake_tx_queue && tid < IEEE80211_NUM_TIDS) {
2096 spin_lock_bh(&local->fq.lock);
2097 rcu_read_lock();
2098
2099 tidstats->filled |= BIT(NL80211_TID_STATS_TXQ_STATS);
2100 ieee80211_fill_txq_stats(&tidstats->txq_stats,
2101 to_txq_info(sta->sta.txq[tid]));
2102
2103 rcu_read_unlock();
2104 spin_unlock_bh(&local->fq.lock);
2105 }
2106 }
2107
2108 static inline u64 sta_get_stats_bytes(struct ieee80211_sta_rx_stats *rxstats)
2109 {
2110 unsigned int start;
2111 u64 value;
2112
2113 do {
2114 start = u64_stats_fetch_begin(&rxstats->syncp);
2115 value = rxstats->bytes;
2116 } while (u64_stats_fetch_retry(&rxstats->syncp, start));
2117
2118 return value;
2119 }
2120
2121 void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo,
2122 bool tidstats)
2123 {
2124 struct ieee80211_sub_if_data *sdata = sta->sdata;
2125 struct ieee80211_local *local = sdata->local;
2126 u32 thr = 0;
2127 int i, ac, cpu;
2128 struct ieee80211_sta_rx_stats *last_rxstats;
2129
2130 last_rxstats = sta_get_last_rx_stats(sta);
2131
2132 sinfo->generation = sdata->local->sta_generation;
2133
2134 /* do before driver, so beacon filtering drivers have a
2135 * chance to e.g. just add the number of filtered beacons
2136 * (or just modify the value entirely, of course)
2137 */
2138 if (sdata->vif.type == NL80211_IFTYPE_STATION)
2139 sinfo->rx_beacon = sdata->u.mgd.count_beacon_signal;
2140
2141 drv_sta_statistics(local, sdata, &sta->sta, sinfo);
2142
2143 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME) |
2144 BIT_ULL(NL80211_STA_INFO_STA_FLAGS) |
2145 BIT_ULL(NL80211_STA_INFO_BSS_PARAM) |
2146 BIT_ULL(NL80211_STA_INFO_CONNECTED_TIME) |
2147 BIT_ULL(NL80211_STA_INFO_RX_DROP_MISC);
2148
2149 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
2150 sinfo->beacon_loss_count = sdata->u.mgd.beacon_loss_count;
2151 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_LOSS);
2152 }
2153
2154 sinfo->connected_time = ktime_get_seconds() - sta->last_connected;
2155 sinfo->inactive_time =
2156 jiffies_to_msecs(jiffies - ieee80211_sta_last_active(sta));
2157
2158 if (!(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES64) |
2159 BIT_ULL(NL80211_STA_INFO_TX_BYTES)))) {
2160 sinfo->tx_bytes = 0;
2161 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2162 sinfo->tx_bytes += sta->tx_stats.bytes[ac];
2163 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES64);
2164 }
2165
2166 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_PACKETS))) {
2167 sinfo->tx_packets = 0;
2168 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2169 sinfo->tx_packets += sta->tx_stats.packets[ac];
2170 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
2171 }
2172
2173 if (!(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES64) |
2174 BIT_ULL(NL80211_STA_INFO_RX_BYTES)))) {
2175 sinfo->rx_bytes += sta_get_stats_bytes(&sta->rx_stats);
2176
2177 if (sta->pcpu_rx_stats) {
2178 for_each_possible_cpu(cpu) {
2179 struct ieee80211_sta_rx_stats *cpurxs;
2180
2181 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2182 sinfo->rx_bytes += sta_get_stats_bytes(cpurxs);
2183 }
2184 }
2185
2186 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES64);
2187 }
2188
2189 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_PACKETS))) {
2190 sinfo->rx_packets = sta->rx_stats.packets;
2191 if (sta->pcpu_rx_stats) {
2192 for_each_possible_cpu(cpu) {
2193 struct ieee80211_sta_rx_stats *cpurxs;
2194
2195 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2196 sinfo->rx_packets += cpurxs->packets;
2197 }
2198 }
2199 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
2200 }
2201
2202 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_RETRIES))) {
2203 sinfo->tx_retries = sta->status_stats.retry_count;
2204 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);
2205 }
2206
2207 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_FAILED))) {
2208 sinfo->tx_failed = sta->status_stats.retry_failed;
2209 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
2210 }
2211
2212 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_DURATION))) {
2213 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2214 sinfo->rx_duration += sta->airtime[ac].rx_airtime;
2215 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
2216 }
2217
2218 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_DURATION))) {
2219 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2220 sinfo->tx_duration += sta->airtime[ac].tx_airtime;
2221 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
2222 }
2223
2224 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_AIRTIME_WEIGHT))) {
2225 sinfo->airtime_weight = sta->airtime_weight;
2226 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_AIRTIME_WEIGHT);
2227 }
2228
2229 sinfo->rx_dropped_misc = sta->rx_stats.dropped;
2230 if (sta->pcpu_rx_stats) {
2231 for_each_possible_cpu(cpu) {
2232 struct ieee80211_sta_rx_stats *cpurxs;
2233
2234 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2235 sinfo->rx_dropped_misc += cpurxs->dropped;
2236 }
2237 }
2238
2239 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
2240 !(sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)) {
2241 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_RX) |
2242 BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
2243 sinfo->rx_beacon_signal_avg = ieee80211_ave_rssi(&sdata->vif);
2244 }
2245
2246 if (ieee80211_hw_check(&sta->local->hw, SIGNAL_DBM) ||
2247 ieee80211_hw_check(&sta->local->hw, SIGNAL_UNSPEC)) {
2248 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_SIGNAL))) {
2249 sinfo->signal = (s8)last_rxstats->last_signal;
2250 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
2251 }
2252
2253 if (!sta->pcpu_rx_stats &&
2254 !(sinfo->filled & BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG))) {
2255 sinfo->signal_avg =
2256 -ewma_signal_read(&sta->rx_stats_avg.signal);
2257 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
2258 }
2259 }
2260
2261 /* for the average - if pcpu_rx_stats isn't set - rxstats must point to
2262 * the sta->rx_stats struct, so the check here is fine with and without
2263 * pcpu statistics
2264 */
2265 if (last_rxstats->chains &&
2266 !(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL) |
2267 BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)))) {
2268 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
2269 if (!sta->pcpu_rx_stats)
2270 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG);
2271
2272 sinfo->chains = last_rxstats->chains;
2273
2274 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
2275 sinfo->chain_signal[i] =
2276 last_rxstats->chain_signal_last[i];
2277 sinfo->chain_signal_avg[i] =
2278 -ewma_signal_read(&sta->rx_stats_avg.chain_signal[i]);
2279 }
2280 }
2281
2282 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE))) {
2283 sta_set_rate_info_tx(sta, &sta->tx_stats.last_rate,
2284 &sinfo->txrate);
2285 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
2286 }
2287
2288 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE))) {
2289 if (sta_set_rate_info_rx(sta, &sinfo->rxrate) == 0)
2290 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
2291 }
2292
2293 if (tidstats && !cfg80211_sinfo_alloc_tid_stats(sinfo, GFP_KERNEL)) {
2294 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
2295 sta_set_tidstats(sta, &sinfo->pertid[i], i);
2296 }
2297
2298 if (ieee80211_vif_is_mesh(&sdata->vif)) {
2299 #ifdef CONFIG_MAC80211_MESH
2300 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_LLID) |
2301 BIT_ULL(NL80211_STA_INFO_PLID) |
2302 BIT_ULL(NL80211_STA_INFO_PLINK_STATE) |
2303 BIT_ULL(NL80211_STA_INFO_LOCAL_PM) |
2304 BIT_ULL(NL80211_STA_INFO_PEER_PM) |
2305 BIT_ULL(NL80211_STA_INFO_NONPEER_PM) |
2306 BIT_ULL(NL80211_STA_INFO_CONNECTED_TO_GATE);
2307
2308 sinfo->llid = sta->mesh->llid;
2309 sinfo->plid = sta->mesh->plid;
2310 sinfo->plink_state = sta->mesh->plink_state;
2311 if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
2312 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_T_OFFSET);
2313 sinfo->t_offset = sta->mesh->t_offset;
2314 }
2315 sinfo->local_pm = sta->mesh->local_pm;
2316 sinfo->peer_pm = sta->mesh->peer_pm;
2317 sinfo->nonpeer_pm = sta->mesh->nonpeer_pm;
2318 sinfo->connected_to_gate = sta->mesh->connected_to_gate;
2319 #endif
2320 }
2321
2322 sinfo->bss_param.flags = 0;
2323 if (sdata->vif.bss_conf.use_cts_prot)
2324 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
2325 if (sdata->vif.bss_conf.use_short_preamble)
2326 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
2327 if (sdata->vif.bss_conf.use_short_slot)
2328 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
2329 sinfo->bss_param.dtim_period = sdata->vif.bss_conf.dtim_period;
2330 sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
2331
2332 sinfo->sta_flags.set = 0;
2333 sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2334 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2335 BIT(NL80211_STA_FLAG_WME) |
2336 BIT(NL80211_STA_FLAG_MFP) |
2337 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2338 BIT(NL80211_STA_FLAG_ASSOCIATED) |
2339 BIT(NL80211_STA_FLAG_TDLS_PEER);
2340 if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
2341 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
2342 if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
2343 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
2344 if (sta->sta.wme)
2345 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
2346 if (test_sta_flag(sta, WLAN_STA_MFP))
2347 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
2348 if (test_sta_flag(sta, WLAN_STA_AUTH))
2349 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
2350 if (test_sta_flag(sta, WLAN_STA_ASSOC))
2351 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
2352 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
2353 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2354
2355 thr = sta_get_expected_throughput(sta);
2356
2357 if (thr != 0) {
2358 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_EXPECTED_THROUGHPUT);
2359 sinfo->expected_throughput = thr;
2360 }
2361
2362 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL)) &&
2363 sta->status_stats.ack_signal_filled) {
2364 sinfo->ack_signal = sta->status_stats.last_ack_signal;
2365 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL);
2366 }
2367
2368 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL_AVG)) &&
2369 sta->status_stats.ack_signal_filled) {
2370 sinfo->avg_ack_signal =
2371 -(s8)ewma_avg_signal_read(
2372 &sta->status_stats.avg_ack_signal);
2373 sinfo->filled |=
2374 BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL_AVG);
2375 }
2376 }
2377
2378 u32 sta_get_expected_throughput(struct sta_info *sta)
2379 {
2380 struct ieee80211_sub_if_data *sdata = sta->sdata;
2381 struct ieee80211_local *local = sdata->local;
2382 struct rate_control_ref *ref = NULL;
2383 u32 thr = 0;
2384
2385 if (test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
2386 ref = local->rate_ctrl;
2387
2388 /* check if the driver has a SW RC implementation */
2389 if (ref && ref->ops->get_expected_throughput)
2390 thr = ref->ops->get_expected_throughput(sta->rate_ctrl_priv);
2391 else
2392 thr = drv_get_expected_throughput(local, sta);
2393
2394 return thr;
2395 }
2396
2397 unsigned long ieee80211_sta_last_active(struct sta_info *sta)
2398 {
2399 struct ieee80211_sta_rx_stats *stats = sta_get_last_rx_stats(sta);
2400
2401 if (time_after(stats->last_rx, sta->status_stats.last_ack))
2402 return stats->last_rx;
2403 return sta->status_stats.last_ack;
2404 }
2405
2406 static void sta_update_codel_params(struct sta_info *sta, u32 thr)
2407 {
2408 if (!sta->sdata->local->ops->wake_tx_queue)
2409 return;
2410
2411 if (thr && thr < STA_SLOW_THRESHOLD * sta->local->num_sta) {
2412 sta->cparams.target = MS2TIME(50);
2413 sta->cparams.interval = MS2TIME(300);
2414 sta->cparams.ecn = false;
2415 } else {
2416 sta->cparams.target = MS2TIME(20);
2417 sta->cparams.interval = MS2TIME(100);
2418 sta->cparams.ecn = true;
2419 }
2420 }
2421
2422 void ieee80211_sta_set_expected_throughput(struct ieee80211_sta *pubsta,
2423 u32 thr)
2424 {
2425 struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
2426
2427 sta_update_codel_params(sta, thr);
2428 }
Linux with added FPC-III support