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