net/mac80211/sta_info.c

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