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 (ieee80211_hw_check(&local->hw, AP_LINK_PS))
 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 & ieee80211_ac_to_qos_mask[ac])
 713                         continue;
 714
 715                 indicate_tim |= !skb_queue_empty(&sta->tx_filtered[ac]) ||
 716                                 !skb_queue_empty(&sta->ps_tx_buf[ac]);
 717                 if (indicate_tim)
 718                         break;
 719
 720                 tids = ieee80211_tids_for_ac(ac);
 721
 722                 indicate_tim |=
 723                         sta->driver_buffered_tids & tids;
 724                 indicate_tim |=
 725                         sta->txq_buffered_tids & tids;
 726         }
 727
 728  done:
 729         spin_lock_bh(&local->tim_lock);
 730
 731         if (indicate_tim == __bss_tim_get(ps->tim, id))
 732                 goto out_unlock;
 733
 734         if (indicate_tim)
 735                 __bss_tim_set(ps->tim, id);
 736         else
 737                 __bss_tim_clear(ps->tim, id);
 738
 739         if (local->ops->set_tim && !WARN_ON(sta->dead)) {
 740                 local->tim_in_locked_section = true;
 741                 drv_set_tim(local, &sta->sta, indicate_tim);
 742                 local->tim_in_locked_section = false;
 743         }
 744
 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                         if (!txq_has_queue(sta->sta.txq[i]))
1206                                 continue;
1207
1208                         drv_wake_tx_queue(local, to_txq_info(sta->sta.txq[i]));
1209                 }
1210         }
1211
1212         skb_queue_head_init(&pending);
1213
1214         /* sync with ieee80211_tx_h_unicast_ps_buf */
1215         spin_lock(&sta->ps_lock);
1216         /* Send all buffered frames to the station */
1217         for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1218                 int count = skb_queue_len(&pending), tmp;
1219
1220                 spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags);
1221                 skb_queue_splice_tail_init(&sta->tx_filtered[ac], &pending);
1222                 spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags);
1223                 tmp = skb_queue_len(&pending);
1224                 filtered += tmp - count;
1225                 count = tmp;
1226
1227                 spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags);
1228                 skb_queue_splice_tail_init(&sta->ps_tx_buf[ac], &pending);
1229                 spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags);
1230                 tmp = skb_queue_len(&pending);
1231                 buffered += tmp - count;
1232         }
1233
1234         ieee80211_add_pending_skbs(local, &pending);
1235
1236         /* now we're no longer in the deliver code */
1237         clear_sta_flag(sta, WLAN_STA_PS_DELIVER);
1238
1239         /* The station might have polled and then woken up before we responded,
1240          * so clear these flags now to avoid them sticking around.
1241          */
1242         clear_sta_flag(sta, WLAN_STA_PSPOLL);
1243         clear_sta_flag(sta, WLAN_STA_UAPSD);
1244         spin_unlock(&sta->ps_lock);
1245
1246         atomic_dec(&ps->num_sta_ps);
1247
1248         /* This station just woke up and isn't aware of our SMPS state */
1249         if (!ieee80211_vif_is_mesh(&sdata->vif) &&
1250             !ieee80211_smps_is_restrictive(sta->known_smps_mode,
1251                                            sdata->smps_mode) &&
1252             sta->known_smps_mode != sdata->bss->req_smps &&
1253             sta_info_tx_streams(sta) != 1) {
1254                 ht_dbg(sdata,
1255                        "%pM just woke up and MIMO capable - update SMPS\n",
1256                        sta->sta.addr);
1257                 ieee80211_send_smps_action(sdata, sdata->bss->req_smps,
1258                                            sta->sta.addr,
1259                                            sdata->vif.bss_conf.bssid);
1260         }
1261
1262         local->total_ps_buffered -= buffered;
1263
1264         sta_info_recalc_tim(sta);
1265
1266         ps_dbg(sdata,
1267                "STA %pM aid %d sending %d filtered/%d PS frames since STA not sleeping anymore\n",
1268                sta->sta.addr, sta->sta.aid, filtered, buffered);
1269
1270         ieee80211_check_fast_xmit(sta);
1271 }
1272
1273 static void ieee80211_send_null_response(struct sta_info *sta, int tid,
1274                                          enum ieee80211_frame_release_type reason,
1275                                          bool call_driver, bool more_data)
1276 {
1277         struct ieee80211_sub_if_data *sdata = sta->sdata;
1278         struct ieee80211_local *local = sdata->local;
1279         struct ieee80211_qos_hdr *nullfunc;
1280         struct sk_buff *skb;
1281         int size = sizeof(*nullfunc);
1282         __le16 fc;
1283         bool qos = sta->sta.wme;
1284         struct ieee80211_tx_info *info;
1285         struct ieee80211_chanctx_conf *chanctx_conf;
1286
1287         if (qos) {
1288                 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
1289                                  IEEE80211_STYPE_QOS_NULLFUNC |
1290                                  IEEE80211_FCTL_FROMDS);
1291         } else {
1292                 size -= 2;
1293                 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
1294                                  IEEE80211_STYPE_NULLFUNC |
1295                                  IEEE80211_FCTL_FROMDS);
1296         }
1297
1298         skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
1299         if (!skb)
1300                 return;
1301
1302         skb_reserve(skb, local->hw.extra_tx_headroom);
1303
1304         nullfunc = (void *) skb_put(skb, size);
1305         nullfunc->frame_control = fc;
1306         nullfunc->duration_id = 0;
1307         memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
1308         memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
1309         memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
1310         nullfunc->seq_ctrl = 0;
1311
1312         skb->priority = tid;
1313         skb_set_queue_mapping(skb, ieee802_1d_to_ac[tid]);
1314         if (qos) {
1315                 nullfunc->qos_ctrl = cpu_to_le16(tid);
1316
1317                 if (reason == IEEE80211_FRAME_RELEASE_UAPSD) {
1318                         nullfunc->qos_ctrl |=
1319                                 cpu_to_le16(IEEE80211_QOS_CTL_EOSP);
1320                         if (more_data)
1321                                 nullfunc->frame_control |=
1322                                         cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1323                 }
1324         }
1325
1326         info = IEEE80211_SKB_CB(skb);
1327
1328         /*
1329          * Tell TX path to send this frame even though the
1330          * STA may still remain is PS mode after this frame
1331          * exchange. Also set EOSP to indicate this packet
1332          * ends the poll/service period.
1333          */
1334         info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER |
1335                        IEEE80211_TX_STATUS_EOSP |
1336                        IEEE80211_TX_CTL_REQ_TX_STATUS;
1337
1338         info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
1339
1340         if (call_driver)
1341                 drv_allow_buffered_frames(local, sta, BIT(tid), 1,
1342                                           reason, false);
1343
1344         skb->dev = sdata->dev;
1345
1346         rcu_read_lock();
1347         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1348         if (WARN_ON(!chanctx_conf)) {
1349                 rcu_read_unlock();
1350                 kfree_skb(skb);
1351                 return;
1352         }
1353
1354         info->band = chanctx_conf->def.chan->band;
1355         ieee80211_xmit(sdata, sta, skb);
1356         rcu_read_unlock();
1357 }
1358
1359 static int find_highest_prio_tid(unsigned long tids)
1360 {
1361         /* lower 3 TIDs aren't ordered perfectly */
1362         if (tids & 0xF8)
1363                 return fls(tids) - 1;
1364         /* TID 0 is BE just like TID 3 */
1365         if (tids & BIT(0))
1366                 return 0;
1367         return fls(tids) - 1;
1368 }
1369
1370 /* Indicates if the MORE_DATA bit should be set in the last
1371  * frame obtained by ieee80211_sta_ps_get_frames.
1372  * Note that driver_release_tids is relevant only if
1373  * reason = IEEE80211_FRAME_RELEASE_PSPOLL
1374  */
1375 static bool
1376 ieee80211_sta_ps_more_data(struct sta_info *sta, u8 ignored_acs,
1377                            enum ieee80211_frame_release_type reason,
1378                            unsigned long driver_release_tids)
1379 {
1380         int ac;
1381
1382         /* If the driver has data on more than one TID then
1383          * certainly there's more data if we release just a
1384          * single frame now (from a single TID). This will
1385          * only happen for PS-Poll.
1386          */
1387         if (reason == IEEE80211_FRAME_RELEASE_PSPOLL &&
1388             hweight16(driver_release_tids) > 1)
1389                 return true;
1390
1391         for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1392                 if (ignored_acs & ieee80211_ac_to_qos_mask[ac])
1393                         continue;
1394
1395                 if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
1396                     !skb_queue_empty(&sta->ps_tx_buf[ac]))
1397                         return true;
1398         }
1399
1400         return false;
1401 }
1402
1403 static void
1404 ieee80211_sta_ps_get_frames(struct sta_info *sta, int n_frames, u8 ignored_acs,
1405                             enum ieee80211_frame_release_type reason,
1406                             struct sk_buff_head *frames,
1407                             unsigned long *driver_release_tids)
1408 {
1409         struct ieee80211_sub_if_data *sdata = sta->sdata;
1410         struct ieee80211_local *local = sdata->local;
1411         int ac;
1412
1413         /* Get response frame(s) and more data bit for the last one. */
1414         for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1415                 unsigned long tids;
1416
1417                 if (ignored_acs & ieee80211_ac_to_qos_mask[ac])
1418                         continue;
1419
1420                 tids = ieee80211_tids_for_ac(ac);
1421
1422                 /* if we already have frames from software, then we can't also
1423                  * release from hardware queues
1424                  */
1425                 if (skb_queue_empty(frames)) {
1426                         *driver_release_tids |=
1427                                 sta->driver_buffered_tids & tids;
1428                         *driver_release_tids |= sta->txq_buffered_tids & tids;
1429                 }
1430
1431                 if (!*driver_release_tids) {
1432                         struct sk_buff *skb;
1433
1434                         while (n_frames > 0) {
1435                                 skb = skb_dequeue(&sta->tx_filtered[ac]);
1436                                 if (!skb) {
1437                                         skb = skb_dequeue(
1438                                                 &sta->ps_tx_buf[ac]);
1439                                         if (skb)
1440                                                 local->total_ps_buffered--;
1441                                 }
1442                                 if (!skb)
1443                                         break;
1444                                 n_frames--;
1445                                 __skb_queue_tail(frames, skb);
1446                         }
1447                 }
1448
1449                 /* If we have more frames buffered on this AC, then abort the
1450                  * loop since we can't send more data from other ACs before
1451                  * the buffered frames from this.
1452                  */
1453                 if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
1454                     !skb_queue_empty(&sta->ps_tx_buf[ac]))
1455                         break;
1456         }
1457 }
1458
1459 static void
1460 ieee80211_sta_ps_deliver_response(struct sta_info *sta,
1461                                   int n_frames, u8 ignored_acs,
1462                                   enum ieee80211_frame_release_type reason)
1463 {
1464         struct ieee80211_sub_if_data *sdata = sta->sdata;
1465         struct ieee80211_local *local = sdata->local;
1466         unsigned long driver_release_tids = 0;
1467         struct sk_buff_head frames;
1468         bool more_data;
1469
1470         /* Service or PS-Poll period starts */
1471         set_sta_flag(sta, WLAN_STA_SP);
1472
1473         __skb_queue_head_init(&frames);
1474
1475         ieee80211_sta_ps_get_frames(sta, n_frames, ignored_acs, reason,
1476                                     &frames, &driver_release_tids);
1477
1478         more_data = ieee80211_sta_ps_more_data(sta, ignored_acs, reason, driver_release_tids);
1479
1480         if (driver_release_tids && reason == IEEE80211_FRAME_RELEASE_PSPOLL)
1481                 driver_release_tids =
1482                         BIT(find_highest_prio_tid(driver_release_tids));
1483
1484         if (skb_queue_empty(&frames) && !driver_release_tids) {
1485                 int tid, ac;
1486
1487                 /*
1488                  * For PS-Poll, this can only happen due to a race condition
1489                  * when we set the TIM bit and the station notices it, but
1490                  * before it can poll for the frame we expire it.
1491                  *
1492                  * For uAPSD, this is said in the standard (11.2.1.5 h):
1493                  *      At each unscheduled SP for a non-AP STA, the AP shall
1494                  *      attempt to transmit at least one MSDU or MMPDU, but no
1495                  *      more than the value specified in the Max SP Length field
1496                  *      in the QoS Capability element from delivery-enabled ACs,
1497                  *      that are destined for the non-AP STA.
1498                  *
1499                  * Since we have no other MSDU/MMPDU, transmit a QoS null frame.
1500                  */
1501
1502                 /* This will evaluate to 1, 3, 5 or 7. */
1503                 for (ac = IEEE80211_AC_VO; ac < IEEE80211_NUM_ACS; ac++)
1504                         if (ignored_acs & BIT(ac))
1505                                 continue;
1506                 tid = 7 - 2 * ac;
1507
1508                 ieee80211_send_null_response(sta, tid, reason, true, false);
1509         } else if (!driver_release_tids) {
1510                 struct sk_buff_head pending;
1511                 struct sk_buff *skb;
1512                 int num = 0;
1513                 u16 tids = 0;
1514                 bool need_null = false;
1515
1516                 skb_queue_head_init(&pending);
1517
1518                 while ((skb = __skb_dequeue(&frames))) {
1519                         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1520                         struct ieee80211_hdr *hdr = (void *) skb->data;
1521                         u8 *qoshdr = NULL;
1522
1523                         num++;
1524
1525                         /*
1526                          * Tell TX path to send this frame even though the
1527                          * STA may still remain is PS mode after this frame
1528                          * exchange.
1529                          */
1530                         info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
1531                         info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
1532
1533                         /*
1534                          * Use MoreData flag to indicate whether there are
1535                          * more buffered frames for this STA
1536                          */
1537                         if (more_data || !skb_queue_empty(&frames))
1538                                 hdr->frame_control |=
1539                                         cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1540                         else
1541                                 hdr->frame_control &=
1542                                         cpu_to_le16(~IEEE80211_FCTL_MOREDATA);
1543
1544                         if (ieee80211_is_data_qos(hdr->frame_control) ||
1545                             ieee80211_is_qos_nullfunc(hdr->frame_control))
1546                                 qoshdr = ieee80211_get_qos_ctl(hdr);
1547
1548                         tids |= BIT(skb->priority);
1549
1550                         __skb_queue_tail(&pending, skb);
1551
1552                         /* end service period after last frame or add one */
1553                         if (!skb_queue_empty(&frames))
1554                                 continue;
1555
1556                         if (reason != IEEE80211_FRAME_RELEASE_UAPSD) {
1557                                 /* for PS-Poll, there's only one frame */
1558                                 info->flags |= IEEE80211_TX_STATUS_EOSP |
1559                                                IEEE80211_TX_CTL_REQ_TX_STATUS;
1560                                 break;
1561                         }
1562
1563                         /* For uAPSD, things are a bit more complicated. If the
1564                          * last frame has a QoS header (i.e. is a QoS-data or
1565                          * QoS-nulldata frame) then just set the EOSP bit there
1566                          * and be done.
1567                          * If the frame doesn't have a QoS header (which means
1568                          * it should be a bufferable MMPDU) then we can't set
1569                          * the EOSP bit in the QoS header; add a QoS-nulldata
1570                          * frame to the list to send it after the MMPDU.
1571                          *
1572                          * Note that this code is only in the mac80211-release
1573                          * code path, we assume that the driver will not buffer
1574                          * anything but QoS-data frames, or if it does, will
1575                          * create the QoS-nulldata frame by itself if needed.
1576                          *
1577                          * Cf. 802.11-2012 10.2.1.10 (c).
1578                          */
1579                         if (qoshdr) {
1580                                 *qoshdr |= IEEE80211_QOS_CTL_EOSP;
1581
1582                                 info->flags |= IEEE80211_TX_STATUS_EOSP |
1583                                                IEEE80211_TX_CTL_REQ_TX_STATUS;
1584                         } else {
1585                                 /* The standard isn't completely clear on this
1586                                  * as it says the more-data bit should be set
1587                                  * if there are more BUs. The QoS-Null frame
1588                                  * we're about to send isn't buffered yet, we
1589                                  * only create it below, but let's pretend it
1590                                  * was buffered just in case some clients only
1591                                  * expect more-data=0 when eosp=1.
1592                                  */
1593                                 hdr->frame_control |=
1594                                         cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1595                                 need_null = true;
1596                                 num++;
1597                         }
1598                         break;
1599                 }
1600
1601                 drv_allow_buffered_frames(local, sta, tids, num,
1602                                           reason, more_data);
1603
1604                 ieee80211_add_pending_skbs(local, &pending);
1605
1606                 if (need_null)
1607                         ieee80211_send_null_response(
1608                                 sta, find_highest_prio_tid(tids),
1609                                 reason, false, false);
1610
1611                 sta_info_recalc_tim(sta);
1612         } else {
1613                 int tid;
1614
1615                 /*
1616                  * We need to release a frame that is buffered somewhere in the
1617                  * driver ... it'll have to handle that.
1618                  * Note that the driver also has to check the number of frames
1619                  * on the TIDs we're releasing from - if there are more than
1620                  * n_frames it has to set the more-data bit (if we didn't ask
1621                  * it to set it anyway due to other buffered frames); if there
1622                  * are fewer than n_frames it has to make sure to adjust that
1623                  * to allow the service period to end properly.
1624                  */
1625                 drv_release_buffered_frames(local, sta, driver_release_tids,
1626                                             n_frames, reason, more_data);
1627
1628                 /*
1629                  * Note that we don't recalculate the TIM bit here as it would
1630                  * most likely have no effect at all unless the driver told us
1631                  * that the TID(s) became empty before returning here from the
1632                  * release function.
1633                  * Either way, however, when the driver tells us that the TID(s)
1634                  * became empty or we find that a txq became empty, we'll do the
1635                  * TIM recalculation.
1636                  */
1637
1638                 if (!sta->sta.txq[0])
1639                         return;
1640
1641                 for (tid = 0; tid < ARRAY_SIZE(sta->sta.txq); tid++) {
1642                         if (!(driver_release_tids & BIT(tid)) ||
1643                             txq_has_queue(sta->sta.txq[tid]))
1644                                 continue;
1645
1646                         sta_info_recalc_tim(sta);
1647                         break;
1648                 }
1649         }
1650 }
1651
1652 void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta)
1653 {
1654         u8 ignore_for_response = sta->sta.uapsd_queues;
1655
1656         /*
1657          * If all ACs are delivery-enabled then we should reply
1658          * from any of them, if only some are enabled we reply
1659          * only from the non-enabled ones.
1660          */
1661         if (ignore_for_response == BIT(IEEE80211_NUM_ACS) - 1)
1662                 ignore_for_response = 0;
1663
1664         ieee80211_sta_ps_deliver_response(sta, 1, ignore_for_response,
1665                                           IEEE80211_FRAME_RELEASE_PSPOLL);
1666 }
1667
1668 void ieee80211_sta_ps_deliver_uapsd(struct sta_info *sta)
1669 {
1670         int n_frames = sta->sta.max_sp;
1671         u8 delivery_enabled = sta->sta.uapsd_queues;
1672
1673         /*
1674          * If we ever grow support for TSPEC this might happen if
1675          * the TSPEC update from hostapd comes in between a trigger
1676          * frame setting WLAN_STA_UAPSD in the RX path and this
1677          * actually getting called.
1678          */
1679         if (!delivery_enabled)
1680                 return;
1681
1682         switch (sta->sta.max_sp) {
1683         case 1:
1684                 n_frames = 2;
1685                 break;
1686         case 2:
1687                 n_frames = 4;
1688                 break;
1689         case 3:
1690                 n_frames = 6;
1691                 break;
1692         case 0:
1693                 /* XXX: what is a good value? */
1694                 n_frames = 128;
1695                 break;
1696         }
1697
1698         ieee80211_sta_ps_deliver_response(sta, n_frames, ~delivery_enabled,
1699                                           IEEE80211_FRAME_RELEASE_UAPSD);
1700 }
1701
1702 void ieee80211_sta_block_awake(struct ieee80211_hw *hw,
1703                                struct ieee80211_sta *pubsta, bool block)
1704 {
1705         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1706
1707         trace_api_sta_block_awake(sta->local, pubsta, block);
1708
1709         if (block) {
1710                 set_sta_flag(sta, WLAN_STA_PS_DRIVER);
1711                 ieee80211_clear_fast_xmit(sta);
1712                 return;
1713         }
1714
1715         if (!test_sta_flag(sta, WLAN_STA_PS_DRIVER))
1716                 return;
1717
1718         if (!test_sta_flag(sta, WLAN_STA_PS_STA)) {
1719                 set_sta_flag(sta, WLAN_STA_PS_DELIVER);
1720                 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1721                 ieee80211_queue_work(hw, &sta->drv_deliver_wk);
1722         } else if (test_sta_flag(sta, WLAN_STA_PSPOLL) ||
1723                    test_sta_flag(sta, WLAN_STA_UAPSD)) {
1724                 /* must be asleep in this case */
1725                 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1726                 ieee80211_queue_work(hw, &sta->drv_deliver_wk);
1727         } else {
1728                 clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
1729                 ieee80211_check_fast_xmit(sta);
1730         }
1731 }
1732 EXPORT_SYMBOL(ieee80211_sta_block_awake);
1733
1734 void ieee80211_sta_eosp(struct ieee80211_sta *pubsta)
1735 {
1736         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1737         struct ieee80211_local *local = sta->local;
1738
1739         trace_api_eosp(local, pubsta);
1740
1741         clear_sta_flag(sta, WLAN_STA_SP);
1742 }
1743 EXPORT_SYMBOL(ieee80211_sta_eosp);
1744
1745 void ieee80211_send_eosp_nullfunc(struct ieee80211_sta *pubsta, int tid)
1746 {
1747         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1748         enum ieee80211_frame_release_type reason;
1749         bool more_data;
1750
1751         trace_api_send_eosp_nullfunc(sta->local, pubsta, tid);
1752
1753         reason = IEEE80211_FRAME_RELEASE_UAPSD;
1754         more_data = ieee80211_sta_ps_more_data(sta, ~sta->sta.uapsd_queues,
1755                                                reason, 0);
1756
1757         ieee80211_send_null_response(sta, tid, reason, false, more_data);
1758 }
1759 EXPORT_SYMBOL(ieee80211_send_eosp_nullfunc);
1760
1761 void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta,
1762                                 u8 tid, bool buffered)
1763 {
1764         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1765
1766         if (WARN_ON(tid >= IEEE80211_NUM_TIDS))
1767                 return;
1768
1769         trace_api_sta_set_buffered(sta->local, pubsta, tid, buffered);
1770
1771         if (buffered)
1772                 set_bit(tid, &sta->driver_buffered_tids);
1773         else
1774                 clear_bit(tid, &sta->driver_buffered_tids);
1775
1776         sta_info_recalc_tim(sta);
1777 }
1778 EXPORT_SYMBOL(ieee80211_sta_set_buffered);
1779
1780 static void
1781 ieee80211_recalc_p2p_go_ps_allowed(struct ieee80211_sub_if_data *sdata)
1782 {
1783         struct ieee80211_local *local = sdata->local;
1784         bool allow_p2p_go_ps = sdata->vif.p2p;
1785         struct sta_info *sta;
1786
1787         rcu_read_lock();
1788         list_for_each_entry_rcu(sta, &local->sta_list, list) {
1789                 if (sdata != sta->sdata ||
1790                     !test_sta_flag(sta, WLAN_STA_ASSOC))
1791                         continue;
1792                 if (!sta->sta.support_p2p_ps) {
1793                         allow_p2p_go_ps = false;
1794                         break;
1795                 }
1796         }
1797         rcu_read_unlock();
1798
1799         if (allow_p2p_go_ps != sdata->vif.bss_conf.allow_p2p_go_ps) {
1800                 sdata->vif.bss_conf.allow_p2p_go_ps = allow_p2p_go_ps;
1801                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_P2P_PS);
1802         }
1803 }
1804
1805 int sta_info_move_state(struct sta_info *sta,
1806                         enum ieee80211_sta_state new_state)
1807 {
1808         might_sleep();
1809
1810         if (sta->sta_state == new_state)
1811                 return 0;
1812
1813         /* check allowed transitions first */
1814
1815         switch (new_state) {
1816         case IEEE80211_STA_NONE:
1817                 if (sta->sta_state != IEEE80211_STA_AUTH)
1818                         return -EINVAL;
1819                 break;
1820         case IEEE80211_STA_AUTH:
1821                 if (sta->sta_state != IEEE80211_STA_NONE &&
1822                     sta->sta_state != IEEE80211_STA_ASSOC)
1823                         return -EINVAL;
1824                 break;
1825         case IEEE80211_STA_ASSOC:
1826                 if (sta->sta_state != IEEE80211_STA_AUTH &&
1827                     sta->sta_state != IEEE80211_STA_AUTHORIZED)
1828                         return -EINVAL;
1829                 break;
1830         case IEEE80211_STA_AUTHORIZED:
1831                 if (sta->sta_state != IEEE80211_STA_ASSOC)
1832                         return -EINVAL;
1833                 break;
1834         default:
1835                 WARN(1, "invalid state %d", new_state);
1836                 return -EINVAL;
1837         }
1838
1839         sta_dbg(sta->sdata, "moving STA %pM to state %d\n",
1840                 sta->sta.addr, new_state);
1841
1842         /*
1843          * notify the driver before the actual changes so it can
1844          * fail the transition
1845          */
1846         if (test_sta_flag(sta, WLAN_STA_INSERTED)) {
1847                 int err = drv_sta_state(sta->local, sta->sdata, sta,
1848                                         sta->sta_state, new_state);
1849                 if (err)
1850                         return err;
1851         }
1852
1853         /* reflect the change in all state variables */
1854
1855         switch (new_state) {
1856         case IEEE80211_STA_NONE:
1857                 if (sta->sta_state == IEEE80211_STA_AUTH)
1858                         clear_bit(WLAN_STA_AUTH, &sta->_flags);
1859                 break;
1860         case IEEE80211_STA_AUTH:
1861                 if (sta->sta_state == IEEE80211_STA_NONE) {
1862                         set_bit(WLAN_STA_AUTH, &sta->_flags);
1863                 } else if (sta->sta_state == IEEE80211_STA_ASSOC) {
1864                         clear_bit(WLAN_STA_ASSOC, &sta->_flags);
1865                         ieee80211_recalc_min_chandef(sta->sdata);
1866                         if (!sta->sta.support_p2p_ps)
1867                                 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
1868                 }
1869                 break;
1870         case IEEE80211_STA_ASSOC:
1871                 if (sta->sta_state == IEEE80211_STA_AUTH) {
1872                         set_bit(WLAN_STA_ASSOC, &sta->_flags);
1873                         ieee80211_recalc_min_chandef(sta->sdata);
1874                         if (!sta->sta.support_p2p_ps)
1875                                 ieee80211_recalc_p2p_go_ps_allowed(sta->sdata);
1876                 } else if (sta->sta_state == IEEE80211_STA_AUTHORIZED) {
1877                         ieee80211_vif_dec_num_mcast(sta->sdata);
1878                         clear_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
1879                         ieee80211_clear_fast_xmit(sta);
1880                         ieee80211_clear_fast_rx(sta);
1881                 }
1882                 break;
1883         case IEEE80211_STA_AUTHORIZED:
1884                 if (sta->sta_state == IEEE80211_STA_ASSOC) {
1885                         ieee80211_vif_inc_num_mcast(sta->sdata);
1886                         set_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
1887                         ieee80211_check_fast_xmit(sta);
1888                         ieee80211_check_fast_rx(sta);
1889                 }
1890                 break;
1891         default:
1892                 break;
1893         }
1894
1895         sta->sta_state = new_state;
1896
1897         return 0;
1898 }
1899
1900 u8 sta_info_tx_streams(struct sta_info *sta)
1901 {
1902         struct ieee80211_sta_ht_cap *ht_cap = &sta->sta.ht_cap;
1903         u8 rx_streams;
1904
1905         if (!sta->sta.ht_cap.ht_supported)
1906                 return 1;
1907
1908         if (sta->sta.vht_cap.vht_supported) {
1909                 int i;
1910                 u16 tx_mcs_map =
1911                         le16_to_cpu(sta->sta.vht_cap.vht_mcs.tx_mcs_map);
1912
1913                 for (i = 7; i >= 0; i--)
1914                         if ((tx_mcs_map & (0x3 << (i * 2))) !=
1915                             IEEE80211_VHT_MCS_NOT_SUPPORTED)
1916                                 return i + 1;
1917         }
1918
1919         if (ht_cap->mcs.rx_mask[3])
1920                 rx_streams = 4;
1921         else if (ht_cap->mcs.rx_mask[2])
1922                 rx_streams = 3;
1923         else if (ht_cap->mcs.rx_mask[1])
1924                 rx_streams = 2;
1925         else
1926                 rx_streams = 1;
1927
1928         if (!(ht_cap->mcs.tx_params & IEEE80211_HT_MCS_TX_RX_DIFF))
1929                 return rx_streams;
1930
1931         return ((ht_cap->mcs.tx_params & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
1932                         >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1;
1933 }
1934
1935 static struct ieee80211_sta_rx_stats *
1936 sta_get_last_rx_stats(struct sta_info *sta)
1937 {
1938         struct ieee80211_sta_rx_stats *stats = &sta->rx_stats;
1939         struct ieee80211_local *local = sta->local;
1940         int cpu;
1941
1942         if (!ieee80211_hw_check(&local->hw, USES_RSS))
1943                 return stats;
1944
1945         for_each_possible_cpu(cpu) {
1946                 struct ieee80211_sta_rx_stats *cpustats;
1947
1948                 cpustats = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
1949
1950                 if (time_after(cpustats->last_rx, stats->last_rx))
1951                         stats = cpustats;
1952         }
1953
1954         return stats;
1955 }
1956
1957 static void sta_stats_decode_rate(struct ieee80211_local *local, u16 rate,
1958                                   struct rate_info *rinfo)
1959 {
1960         rinfo->bw = (rate & STA_STATS_RATE_BW_MASK) >>
1961                 STA_STATS_RATE_BW_SHIFT;
1962
1963         if (rate & STA_STATS_RATE_VHT) {
1964                 rinfo->flags = RATE_INFO_FLAGS_VHT_MCS;
1965                 rinfo->mcs = rate & 0xf;
1966                 rinfo->nss = (rate & 0xf0) >> 4;
1967         } else if (rate & STA_STATS_RATE_HT) {
1968                 rinfo->flags = RATE_INFO_FLAGS_MCS;
1969                 rinfo->mcs = rate & 0xff;
1970         } else if (rate & STA_STATS_RATE_LEGACY) {
1971                 struct ieee80211_supported_band *sband;
1972                 u16 brate;
1973                 unsigned int shift;
1974
1975                 rinfo->flags = 0;
1976                 sband = local->hw.wiphy->bands[(rate >> 4) & 0xf];
1977                 brate = sband->bitrates[rate & 0xf].bitrate;
1978                 if (rinfo->bw == RATE_INFO_BW_5)
1979                         shift = 2;
1980                 else if (rinfo->bw == RATE_INFO_BW_10)
1981                         shift = 1;
1982                 else
1983                         shift = 0;
1984                 rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
1985         }
1986
1987         if (rate & STA_STATS_RATE_SGI)
1988                 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
1989 }
1990
1991 static int sta_set_rate_info_rx(struct sta_info *sta, struct rate_info *rinfo)
1992 {
1993         u16 rate = ACCESS_ONCE(sta_get_last_rx_stats(sta)->last_rate);
1994
1995         if (rate == STA_STATS_RATE_INVALID)
1996                 return -EINVAL;
1997
1998         sta_stats_decode_rate(sta->local, rate, rinfo);
1999         return 0;
2000 }
2001
2002 static void sta_set_tidstats(struct sta_info *sta,
2003                              struct cfg80211_tid_stats *tidstats,
2004                              int tid)
2005 {
2006         struct ieee80211_local *local = sta->local;
2007
2008         if (!(tidstats->filled & BIT(NL80211_TID_STATS_RX_MSDU))) {
2009                 unsigned int start;
2010
2011                 do {
2012                         start = u64_stats_fetch_begin(&sta->rx_stats.syncp);
2013                         tidstats->rx_msdu = sta->rx_stats.msdu[tid];
2014                 } while (u64_stats_fetch_retry(&sta->rx_stats.syncp, start));
2015
2016                 tidstats->filled |= BIT(NL80211_TID_STATS_RX_MSDU);
2017         }
2018
2019         if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU))) {
2020                 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU);
2021                 tidstats->tx_msdu = sta->tx_stats.msdu[tid];
2022         }
2023
2024         if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU_RETRIES)) &&
2025             ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
2026                 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU_RETRIES);
2027                 tidstats->tx_msdu_retries = sta->status_stats.msdu_retries[tid];
2028         }
2029
2030         if (!(tidstats->filled & BIT(NL80211_TID_STATS_TX_MSDU_FAILED)) &&
2031             ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
2032                 tidstats->filled |= BIT(NL80211_TID_STATS_TX_MSDU_FAILED);
2033                 tidstats->tx_msdu_failed = sta->status_stats.msdu_failed[tid];
2034         }
2035 }
2036
2037 static inline u64 sta_get_stats_bytes(struct ieee80211_sta_rx_stats *rxstats)
2038 {
2039         unsigned int start;
2040         u64 value;
2041
2042         do {
2043                 start = u64_stats_fetch_begin(&rxstats->syncp);
2044                 value = rxstats->bytes;
2045         } while (u64_stats_fetch_retry(&rxstats->syncp, start));
2046
2047         return value;
2048 }
2049
2050 void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
2051 {
2052         struct ieee80211_sub_if_data *sdata = sta->sdata;
2053         struct ieee80211_local *local = sdata->local;
2054         struct rate_control_ref *ref = NULL;
2055         u32 thr = 0;
2056         int i, ac, cpu;
2057         struct ieee80211_sta_rx_stats *last_rxstats;
2058
2059         last_rxstats = sta_get_last_rx_stats(sta);
2060
2061         if (test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
2062                 ref = local->rate_ctrl;
2063
2064         sinfo->generation = sdata->local->sta_generation;
2065
2066         /* do before driver, so beacon filtering drivers have a
2067          * chance to e.g. just add the number of filtered beacons
2068          * (or just modify the value entirely, of course)
2069          */
2070         if (sdata->vif.type == NL80211_IFTYPE_STATION)
2071                 sinfo->rx_beacon = sdata->u.mgd.count_beacon_signal;
2072
2073         drv_sta_statistics(local, sdata, &sta->sta, sinfo);
2074
2075         sinfo->filled |= BIT(NL80211_STA_INFO_INACTIVE_TIME) |
2076                          BIT(NL80211_STA_INFO_STA_FLAGS) |
2077                          BIT(NL80211_STA_INFO_BSS_PARAM) |
2078                          BIT(NL80211_STA_INFO_CONNECTED_TIME) |
2079                          BIT(NL80211_STA_INFO_RX_DROP_MISC);
2080
2081         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
2082                 sinfo->beacon_loss_count = sdata->u.mgd.beacon_loss_count;
2083                 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_LOSS);
2084         }
2085
2086         sinfo->connected_time = ktime_get_seconds() - sta->last_connected;
2087         sinfo->inactive_time =
2088                 jiffies_to_msecs(jiffies - ieee80211_sta_last_active(sta));
2089
2090         if (!(sinfo->filled & (BIT(NL80211_STA_INFO_TX_BYTES64) |
2091                                BIT(NL80211_STA_INFO_TX_BYTES)))) {
2092                 sinfo->tx_bytes = 0;
2093                 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2094                         sinfo->tx_bytes += sta->tx_stats.bytes[ac];
2095                 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BYTES64);
2096         }
2097
2098         if (!(sinfo->filled & BIT(NL80211_STA_INFO_TX_PACKETS))) {
2099                 sinfo->tx_packets = 0;
2100                 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
2101                         sinfo->tx_packets += sta->tx_stats.packets[ac];
2102                 sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
2103         }
2104
2105         if (!(sinfo->filled & (BIT(NL80211_STA_INFO_RX_BYTES64) |
2106                                BIT(NL80211_STA_INFO_RX_BYTES)))) {
2107                 sinfo->rx_bytes += sta_get_stats_bytes(&sta->rx_stats);
2108
2109                 if (sta->pcpu_rx_stats) {
2110                         for_each_possible_cpu(cpu) {
2111                                 struct ieee80211_sta_rx_stats *cpurxs;
2112
2113                                 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2114                                 sinfo->rx_bytes += sta_get_stats_bytes(cpurxs);
2115                         }
2116                 }
2117
2118                 sinfo->filled |= BIT(NL80211_STA_INFO_RX_BYTES64);
2119         }
2120
2121         if (!(sinfo->filled & BIT(NL80211_STA_INFO_RX_PACKETS))) {
2122                 sinfo->rx_packets = sta->rx_stats.packets;
2123                 if (sta->pcpu_rx_stats) {
2124                         for_each_possible_cpu(cpu) {
2125                                 struct ieee80211_sta_rx_stats *cpurxs;
2126
2127                                 cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2128                                 sinfo->rx_packets += cpurxs->packets;
2129                         }
2130                 }
2131                 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
2132         }
2133
2134         if (!(sinfo->filled & BIT(NL80211_STA_INFO_TX_RETRIES))) {
2135                 sinfo->tx_retries = sta->status_stats.retry_count;
2136                 sinfo->filled |= BIT(NL80211_STA_INFO_TX_RETRIES);
2137         }
2138
2139         if (!(sinfo->filled & BIT(NL80211_STA_INFO_TX_FAILED))) {
2140                 sinfo->tx_failed = sta->status_stats.retry_failed;
2141                 sinfo->filled |= BIT(NL80211_STA_INFO_TX_FAILED);
2142         }
2143
2144         sinfo->rx_dropped_misc = sta->rx_stats.dropped;
2145         if (sta->pcpu_rx_stats) {
2146                 for_each_possible_cpu(cpu) {
2147                         struct ieee80211_sta_rx_stats *cpurxs;
2148
2149                         cpurxs = per_cpu_ptr(sta->pcpu_rx_stats, cpu);
2150                         sinfo->rx_packets += cpurxs->dropped;
2151                 }
2152         }
2153
2154         if (sdata->vif.type == NL80211_IFTYPE_STATION &&
2155             !(sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)) {
2156                 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_RX) |
2157                                  BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
2158                 sinfo->rx_beacon_signal_avg = ieee80211_ave_rssi(&sdata->vif);
2159         }
2160
2161         if (ieee80211_hw_check(&sta->local->hw, SIGNAL_DBM) ||
2162             ieee80211_hw_check(&sta->local->hw, SIGNAL_UNSPEC)) {
2163                 if (!(sinfo->filled & BIT(NL80211_STA_INFO_SIGNAL))) {
2164                         sinfo->signal = (s8)last_rxstats->last_signal;
2165                         sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
2166                 }
2167
2168                 if (!sta->pcpu_rx_stats &&
2169                     !(sinfo->filled & BIT(NL80211_STA_INFO_SIGNAL_AVG))) {
2170                         sinfo->signal_avg =
2171                                 -ewma_signal_read(&sta->rx_stats_avg.signal);
2172                         sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL_AVG);
2173                 }
2174         }
2175
2176         /* for the average - if pcpu_rx_stats isn't set - rxstats must point to
2177          * the sta->rx_stats struct, so the check here is fine with and without
2178          * pcpu statistics
2179          */
2180         if (last_rxstats->chains &&
2181             !(sinfo->filled & (BIT(NL80211_STA_INFO_CHAIN_SIGNAL) |
2182                                BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)))) {
2183                 sinfo->filled |= BIT(NL80211_STA_INFO_CHAIN_SIGNAL);
2184                 if (!sta->pcpu_rx_stats)
2185                         sinfo->filled |= BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG);
2186
2187                 sinfo->chains = last_rxstats->chains;
2188
2189                 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
2190                         sinfo->chain_signal[i] =
2191                                 last_rxstats->chain_signal_last[i];
2192                         sinfo->chain_signal_avg[i] =
2193                                 -ewma_signal_read(&sta->rx_stats_avg.chain_signal[i]);
2194                 }
2195         }
2196
2197         if (!(sinfo->filled & BIT(NL80211_STA_INFO_TX_BITRATE))) {
2198                 sta_set_rate_info_tx(sta, &sta->tx_stats.last_rate,
2199                                      &sinfo->txrate);
2200                 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
2201         }
2202
2203         if (!(sinfo->filled & BIT(NL80211_STA_INFO_RX_BITRATE))) {
2204                 if (sta_set_rate_info_rx(sta, &sinfo->rxrate) == 0)
2205                         sinfo->filled |= BIT(NL80211_STA_INFO_RX_BITRATE);
2206         }
2207
2208         sinfo->filled |= BIT(NL80211_STA_INFO_TID_STATS);
2209         for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++) {
2210                 struct cfg80211_tid_stats *tidstats = &sinfo->pertid[i];
2211
2212                 sta_set_tidstats(sta, tidstats, i);
2213         }
2214
2215         if (ieee80211_vif_is_mesh(&sdata->vif)) {
2216 #ifdef CONFIG_MAC80211_MESH
2217                 sinfo->filled |= BIT(NL80211_STA_INFO_LLID) |
2218                                  BIT(NL80211_STA_INFO_PLID) |
2219                                  BIT(NL80211_STA_INFO_PLINK_STATE) |
2220                                  BIT(NL80211_STA_INFO_LOCAL_PM) |
2221                                  BIT(NL80211_STA_INFO_PEER_PM) |
2222                                  BIT(NL80211_STA_INFO_NONPEER_PM);
2223
2224                 sinfo->llid = sta->mesh->llid;
2225                 sinfo->plid = sta->mesh->plid;
2226                 sinfo->plink_state = sta->mesh->plink_state;
2227                 if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
2228                         sinfo->filled |= BIT(NL80211_STA_INFO_T_OFFSET);
2229                         sinfo->t_offset = sta->mesh->t_offset;
2230                 }
2231                 sinfo->local_pm = sta->mesh->local_pm;
2232                 sinfo->peer_pm = sta->mesh->peer_pm;
2233                 sinfo->nonpeer_pm = sta->mesh->nonpeer_pm;
2234 #endif
2235         }
2236
2237         sinfo->bss_param.flags = 0;
2238         if (sdata->vif.bss_conf.use_cts_prot)
2239                 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
2240         if (sdata->vif.bss_conf.use_short_preamble)
2241                 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
2242         if (sdata->vif.bss_conf.use_short_slot)
2243                 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
2244         sinfo->bss_param.dtim_period = sdata->vif.bss_conf.dtim_period;
2245         sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
2246
2247         sinfo->sta_flags.set = 0;
2248         sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2249                                 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2250                                 BIT(NL80211_STA_FLAG_WME) |
2251                                 BIT(NL80211_STA_FLAG_MFP) |
2252                                 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2253                                 BIT(NL80211_STA_FLAG_ASSOCIATED) |
2254                                 BIT(NL80211_STA_FLAG_TDLS_PEER);
2255         if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
2256                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
2257         if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
2258                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
2259         if (sta->sta.wme)
2260                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
2261         if (test_sta_flag(sta, WLAN_STA_MFP))
2262                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
2263         if (test_sta_flag(sta, WLAN_STA_AUTH))
2264                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
2265         if (test_sta_flag(sta, WLAN_STA_ASSOC))
2266                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
2267         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
2268                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2269
2270         thr = sta_get_expected_throughput(sta);
2271
2272         if (thr != 0) {
2273                 sinfo->filled |= BIT(NL80211_STA_INFO_EXPECTED_THROUGHPUT);
2274                 sinfo->expected_throughput = thr;
2275         }
2276 }
2277
2278 u32 sta_get_expected_throughput(struct sta_info *sta)
2279 {
2280         struct ieee80211_sub_if_data *sdata = sta->sdata;
2281         struct ieee80211_local *local = sdata->local;
2282         struct rate_control_ref *ref = NULL;
2283         u32 thr = 0;
2284
2285         if (test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
2286                 ref = local->rate_ctrl;
2287
2288         /* check if the driver has a SW RC implementation */
2289         if (ref && ref->ops->get_expected_throughput)
2290                 thr = ref->ops->get_expected_throughput(sta->rate_ctrl_priv);
2291         else
2292                 thr = drv_get_expected_throughput(local, sta);
2293
2294         return thr;
2295 }
2296
2297 unsigned long ieee80211_sta_last_active(struct sta_info *sta)
2298 {
2299         struct ieee80211_sta_rx_stats *stats = sta_get_last_rx_stats(sta);
2300
2301         if (time_after(stats->last_rx, sta->status_stats.last_ack))
2302                 return stats->last_rx;
2303         return sta->status_stats.last_ack;
2304 }