linux/net/mac80211/util.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright 2002-2005, Instant802 Networks, Inc.
   4 * Copyright 2005-2006, Devicescape Software, Inc.
   5 * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
   6 * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
   7 * Copyright 2013-2014  Intel Mobile Communications GmbH
   8 * Copyright (C) 2015-2017      Intel Deutschland GmbH
   9 * Copyright (C) 2018-2021 Intel Corporation
  10 *
  11 * utilities for mac80211
  12 */
  13
  14#include <net/mac80211.h>
  15#include <linux/netdevice.h>
  16#include <linux/export.h>
  17#include <linux/types.h>
  18#include <linux/slab.h>
  19#include <linux/skbuff.h>
  20#include <linux/etherdevice.h>
  21#include <linux/if_arp.h>
  22#include <linux/bitmap.h>
  23#include <linux/crc32.h>
  24#include <net/net_namespace.h>
  25#include <net/cfg80211.h>
  26#include <net/rtnetlink.h>
  27
  28#include "ieee80211_i.h"
  29#include "driver-ops.h"
  30#include "rate.h"
  31#include "mesh.h"
  32#include "wme.h"
  33#include "led.h"
  34#include "wep.h"
  35
  36/* privid for wiphys to determine whether they belong to us or not */
  37const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
  38
  39struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
  40{
  41        struct ieee80211_local *local;
  42
  43        local = wiphy_priv(wiphy);
  44        return &local->hw;
  45}
  46EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
  47
  48u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
  49                        enum nl80211_iftype type)
  50{
  51        __le16 fc = hdr->frame_control;
  52
  53        if (ieee80211_is_data(fc)) {
  54                if (len < 24) /* drop incorrect hdr len (data) */
  55                        return NULL;
  56
  57                if (ieee80211_has_a4(fc))
  58                        return NULL;
  59                if (ieee80211_has_tods(fc))
  60                        return hdr->addr1;
  61                if (ieee80211_has_fromds(fc))
  62                        return hdr->addr2;
  63
  64                return hdr->addr3;
  65        }
  66
  67        if (ieee80211_is_s1g_beacon(fc)) {
  68                struct ieee80211_ext *ext = (void *) hdr;
  69
  70                return ext->u.s1g_beacon.sa;
  71        }
  72
  73        if (ieee80211_is_mgmt(fc)) {
  74                if (len < 24) /* drop incorrect hdr len (mgmt) */
  75                        return NULL;
  76                return hdr->addr3;
  77        }
  78
  79        if (ieee80211_is_ctl(fc)) {
  80                if (ieee80211_is_pspoll(fc))
  81                        return hdr->addr1;
  82
  83                if (ieee80211_is_back_req(fc)) {
  84                        switch (type) {
  85                        case NL80211_IFTYPE_STATION:
  86                                return hdr->addr2;
  87                        case NL80211_IFTYPE_AP:
  88                        case NL80211_IFTYPE_AP_VLAN:
  89                                return hdr->addr1;
  90                        default:
  91                                break; /* fall through to the return */
  92                        }
  93                }
  94        }
  95
  96        return NULL;
  97}
  98EXPORT_SYMBOL(ieee80211_get_bssid);
  99
 100void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
 101{
 102        struct sk_buff *skb;
 103        struct ieee80211_hdr *hdr;
 104
 105        skb_queue_walk(&tx->skbs, skb) {
 106                hdr = (struct ieee80211_hdr *) skb->data;
 107                hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
 108        }
 109}
 110
 111int ieee80211_frame_duration(enum nl80211_band band, size_t len,
 112                             int rate, int erp, int short_preamble,
 113                             int shift)
 114{
 115        int dur;
 116
 117        /* calculate duration (in microseconds, rounded up to next higher
 118         * integer if it includes a fractional microsecond) to send frame of
 119         * len bytes (does not include FCS) at the given rate. Duration will
 120         * also include SIFS.
 121         *
 122         * rate is in 100 kbps, so divident is multiplied by 10 in the
 123         * DIV_ROUND_UP() operations.
 124         *
 125         * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
 126         * is assumed to be 0 otherwise.
 127         */
 128
 129        if (band == NL80211_BAND_5GHZ || erp) {
 130                /*
 131                 * OFDM:
 132                 *
 133                 * N_DBPS = DATARATE x 4
 134                 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
 135                 *      (16 = SIGNAL time, 6 = tail bits)
 136                 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
 137                 *
 138                 * T_SYM = 4 usec
 139                 * 802.11a - 18.5.2: aSIFSTime = 16 usec
 140                 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
 141                 *      signal ext = 6 usec
 142                 */
 143                dur = 16; /* SIFS + signal ext */
 144                dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
 145                dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
 146
 147                /* IEEE 802.11-2012 18.3.2.4: all values above are:
 148                 *  * times 4 for 5 MHz
 149                 *  * times 2 for 10 MHz
 150                 */
 151                dur *= 1 << shift;
 152
 153                /* rates should already consider the channel bandwidth,
 154                 * don't apply divisor again.
 155                 */
 156                dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
 157                                        4 * rate); /* T_SYM x N_SYM */
 158        } else {
 159                /*
 160                 * 802.11b or 802.11g with 802.11b compatibility:
 161                 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
 162                 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
 163                 *
 164                 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
 165                 * aSIFSTime = 10 usec
 166                 * aPreambleLength = 144 usec or 72 usec with short preamble
 167                 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
 168                 */
 169                dur = 10; /* aSIFSTime = 10 usec */
 170                dur += short_preamble ? (72 + 24) : (144 + 48);
 171
 172                dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
 173        }
 174
 175        return dur;
 176}
 177
 178/* Exported duration function for driver use */
 179__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
 180                                        struct ieee80211_vif *vif,
 181                                        enum nl80211_band band,
 182                                        size_t frame_len,
 183                                        struct ieee80211_rate *rate)
 184{
 185        struct ieee80211_sub_if_data *sdata;
 186        u16 dur;
 187        int erp, shift = 0;
 188        bool short_preamble = false;
 189
 190        erp = 0;
 191        if (vif) {
 192                sdata = vif_to_sdata(vif);
 193                short_preamble = sdata->vif.bss_conf.use_short_preamble;
 194                if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
 195                        erp = rate->flags & IEEE80211_RATE_ERP_G;
 196                shift = ieee80211_vif_get_shift(vif);
 197        }
 198
 199        dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
 200                                       short_preamble, shift);
 201
 202        return cpu_to_le16(dur);
 203}
 204EXPORT_SYMBOL(ieee80211_generic_frame_duration);
 205
 206__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
 207                              struct ieee80211_vif *vif, size_t frame_len,
 208                              const struct ieee80211_tx_info *frame_txctl)
 209{
 210        struct ieee80211_local *local = hw_to_local(hw);
 211        struct ieee80211_rate *rate;
 212        struct ieee80211_sub_if_data *sdata;
 213        bool short_preamble;
 214        int erp, shift = 0, bitrate;
 215        u16 dur;
 216        struct ieee80211_supported_band *sband;
 217
 218        sband = local->hw.wiphy->bands[frame_txctl->band];
 219
 220        short_preamble = false;
 221
 222        rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
 223
 224        erp = 0;
 225        if (vif) {
 226                sdata = vif_to_sdata(vif);
 227                short_preamble = sdata->vif.bss_conf.use_short_preamble;
 228                if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
 229                        erp = rate->flags & IEEE80211_RATE_ERP_G;
 230                shift = ieee80211_vif_get_shift(vif);
 231        }
 232
 233        bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
 234
 235        /* CTS duration */
 236        dur = ieee80211_frame_duration(sband->band, 10, bitrate,
 237                                       erp, short_preamble, shift);
 238        /* Data frame duration */
 239        dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
 240                                        erp, short_preamble, shift);
 241        /* ACK duration */
 242        dur += ieee80211_frame_duration(sband->band, 10, bitrate,
 243                                        erp, short_preamble, shift);
 244
 245        return cpu_to_le16(dur);
 246}
 247EXPORT_SYMBOL(ieee80211_rts_duration);
 248
 249__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
 250                                    struct ieee80211_vif *vif,
 251                                    size_t frame_len,
 252                                    const struct ieee80211_tx_info *frame_txctl)
 253{
 254        struct ieee80211_local *local = hw_to_local(hw);
 255        struct ieee80211_rate *rate;
 256        struct ieee80211_sub_if_data *sdata;
 257        bool short_preamble;
 258        int erp, shift = 0, bitrate;
 259        u16 dur;
 260        struct ieee80211_supported_band *sband;
 261
 262        sband = local->hw.wiphy->bands[frame_txctl->band];
 263
 264        short_preamble = false;
 265
 266        rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
 267        erp = 0;
 268        if (vif) {
 269                sdata = vif_to_sdata(vif);
 270                short_preamble = sdata->vif.bss_conf.use_short_preamble;
 271                if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
 272                        erp = rate->flags & IEEE80211_RATE_ERP_G;
 273                shift = ieee80211_vif_get_shift(vif);
 274        }
 275
 276        bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
 277
 278        /* Data frame duration */
 279        dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
 280                                       erp, short_preamble, shift);
 281        if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
 282                /* ACK duration */
 283                dur += ieee80211_frame_duration(sband->band, 10, bitrate,
 284                                                erp, short_preamble, shift);
 285        }
 286
 287        return cpu_to_le16(dur);
 288}
 289EXPORT_SYMBOL(ieee80211_ctstoself_duration);
 290
 291static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac)
 292{
 293        struct ieee80211_local *local = sdata->local;
 294        struct ieee80211_vif *vif = &sdata->vif;
 295        struct fq *fq = &local->fq;
 296        struct ps_data *ps = NULL;
 297        struct txq_info *txqi;
 298        struct sta_info *sta;
 299        int i;
 300
 301        local_bh_disable();
 302        spin_lock(&fq->lock);
 303
 304        if (sdata->vif.type == NL80211_IFTYPE_AP)
 305                ps = &sdata->bss->ps;
 306
 307        sdata->vif.txqs_stopped[ac] = false;
 308
 309        list_for_each_entry_rcu(sta, &local->sta_list, list) {
 310                if (sdata != sta->sdata)
 311                        continue;
 312
 313                for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
 314                        struct ieee80211_txq *txq = sta->sta.txq[i];
 315
 316                        if (!txq)
 317                                continue;
 318
 319                        txqi = to_txq_info(txq);
 320
 321                        if (ac != txq->ac)
 322                                continue;
 323
 324                        if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX,
 325                                                &txqi->flags))
 326                                continue;
 327
 328                        spin_unlock(&fq->lock);
 329                        drv_wake_tx_queue(local, txqi);
 330                        spin_lock(&fq->lock);
 331                }
 332        }
 333
 334        if (!vif->txq)
 335                goto out;
 336
 337        txqi = to_txq_info(vif->txq);
 338
 339        if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX, &txqi->flags) ||
 340            (ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac)
 341                goto out;
 342
 343        spin_unlock(&fq->lock);
 344
 345        drv_wake_tx_queue(local, txqi);
 346        local_bh_enable();
 347        return;
 348out:
 349        spin_unlock(&fq->lock);
 350        local_bh_enable();
 351}
 352
 353static void
 354__releases(&local->queue_stop_reason_lock)
 355__acquires(&local->queue_stop_reason_lock)
 356_ieee80211_wake_txqs(struct ieee80211_local *local, unsigned long *flags)
 357{
 358        struct ieee80211_sub_if_data *sdata;
 359        int n_acs = IEEE80211_NUM_ACS;
 360        int i;
 361
 362        rcu_read_lock();
 363
 364        if (local->hw.queues < IEEE80211_NUM_ACS)
 365                n_acs = 1;
 366
 367        for (i = 0; i < local->hw.queues; i++) {
 368                if (local->queue_stop_reasons[i])
 369                        continue;
 370
 371                spin_unlock_irqrestore(&local->queue_stop_reason_lock, *flags);
 372                list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 373                        int ac;
 374
 375                        for (ac = 0; ac < n_acs; ac++) {
 376                                int ac_queue = sdata->vif.hw_queue[ac];
 377
 378                                if (ac_queue == i ||
 379                                    sdata->vif.cab_queue == i)
 380                                        __ieee80211_wake_txqs(sdata, ac);
 381                        }
 382                }
 383                spin_lock_irqsave(&local->queue_stop_reason_lock, *flags);
 384        }
 385
 386        rcu_read_unlock();
 387}
 388
 389void ieee80211_wake_txqs(struct tasklet_struct *t)
 390{
 391        struct ieee80211_local *local = from_tasklet(local, t,
 392                                                     wake_txqs_tasklet);
 393        unsigned long flags;
 394
 395        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 396        _ieee80211_wake_txqs(local, &flags);
 397        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 398}
 399
 400void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
 401{
 402        struct ieee80211_sub_if_data *sdata;
 403        int n_acs = IEEE80211_NUM_ACS;
 404
 405        if (local->ops->wake_tx_queue)
 406                return;
 407
 408        if (local->hw.queues < IEEE80211_NUM_ACS)
 409                n_acs = 1;
 410
 411        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 412                int ac;
 413
 414                if (!sdata->dev)
 415                        continue;
 416
 417                if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
 418                    local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
 419                        continue;
 420
 421                for (ac = 0; ac < n_acs; ac++) {
 422                        int ac_queue = sdata->vif.hw_queue[ac];
 423
 424                        if (ac_queue == queue ||
 425                            (sdata->vif.cab_queue == queue &&
 426                             local->queue_stop_reasons[ac_queue] == 0 &&
 427                             skb_queue_empty(&local->pending[ac_queue])))
 428                                netif_wake_subqueue(sdata->dev, ac);
 429                }
 430        }
 431}
 432
 433static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
 434                                   enum queue_stop_reason reason,
 435                                   bool refcounted,
 436                                   unsigned long *flags)
 437{
 438        struct ieee80211_local *local = hw_to_local(hw);
 439
 440        trace_wake_queue(local, queue, reason);
 441
 442        if (WARN_ON(queue >= hw->queues))
 443                return;
 444
 445        if (!test_bit(reason, &local->queue_stop_reasons[queue]))
 446                return;
 447
 448        if (!refcounted) {
 449                local->q_stop_reasons[queue][reason] = 0;
 450        } else {
 451                local->q_stop_reasons[queue][reason]--;
 452                if (WARN_ON(local->q_stop_reasons[queue][reason] < 0))
 453                        local->q_stop_reasons[queue][reason] = 0;
 454        }
 455
 456        if (local->q_stop_reasons[queue][reason] == 0)
 457                __clear_bit(reason, &local->queue_stop_reasons[queue]);
 458
 459        if (local->queue_stop_reasons[queue] != 0)
 460                /* someone still has this queue stopped */
 461                return;
 462
 463        if (skb_queue_empty(&local->pending[queue])) {
 464                rcu_read_lock();
 465                ieee80211_propagate_queue_wake(local, queue);
 466                rcu_read_unlock();
 467        } else
 468                tasklet_schedule(&local->tx_pending_tasklet);
 469
 470        /*
 471         * Calling _ieee80211_wake_txqs here can be a problem because it may
 472         * release queue_stop_reason_lock which has been taken by
 473         * __ieee80211_wake_queue's caller. It is certainly not very nice to
 474         * release someone's lock, but it is fine because all the callers of
 475         * __ieee80211_wake_queue call it right before releasing the lock.
 476         */
 477        if (local->ops->wake_tx_queue) {
 478                if (reason == IEEE80211_QUEUE_STOP_REASON_DRIVER)
 479                        tasklet_schedule(&local->wake_txqs_tasklet);
 480                else
 481                        _ieee80211_wake_txqs(local, flags);
 482        }
 483}
 484
 485void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
 486                                    enum queue_stop_reason reason,
 487                                    bool refcounted)
 488{
 489        struct ieee80211_local *local = hw_to_local(hw);
 490        unsigned long flags;
 491
 492        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 493        __ieee80211_wake_queue(hw, queue, reason, refcounted, &flags);
 494        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 495}
 496
 497void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
 498{
 499        ieee80211_wake_queue_by_reason(hw, queue,
 500                                       IEEE80211_QUEUE_STOP_REASON_DRIVER,
 501                                       false);
 502}
 503EXPORT_SYMBOL(ieee80211_wake_queue);
 504
 505static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
 506                                   enum queue_stop_reason reason,
 507                                   bool refcounted)
 508{
 509        struct ieee80211_local *local = hw_to_local(hw);
 510        struct ieee80211_sub_if_data *sdata;
 511        int n_acs = IEEE80211_NUM_ACS;
 512
 513        trace_stop_queue(local, queue, reason);
 514
 515        if (WARN_ON(queue >= hw->queues))
 516                return;
 517
 518        if (!refcounted)
 519                local->q_stop_reasons[queue][reason] = 1;
 520        else
 521                local->q_stop_reasons[queue][reason]++;
 522
 523        if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue]))
 524                return;
 525
 526        if (local->hw.queues < IEEE80211_NUM_ACS)
 527                n_acs = 1;
 528
 529        rcu_read_lock();
 530        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 531                int ac;
 532
 533                if (!sdata->dev)
 534                        continue;
 535
 536                for (ac = 0; ac < n_acs; ac++) {
 537                        if (sdata->vif.hw_queue[ac] == queue ||
 538                            sdata->vif.cab_queue == queue) {
 539                                if (!local->ops->wake_tx_queue) {
 540                                        netif_stop_subqueue(sdata->dev, ac);
 541                                        continue;
 542                                }
 543                                spin_lock(&local->fq.lock);
 544                                sdata->vif.txqs_stopped[ac] = true;
 545                                spin_unlock(&local->fq.lock);
 546                        }
 547                }
 548        }
 549        rcu_read_unlock();
 550}
 551
 552void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
 553                                    enum queue_stop_reason reason,
 554                                    bool refcounted)
 555{
 556        struct ieee80211_local *local = hw_to_local(hw);
 557        unsigned long flags;
 558
 559        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 560        __ieee80211_stop_queue(hw, queue, reason, refcounted);
 561        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 562}
 563
 564void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
 565{
 566        ieee80211_stop_queue_by_reason(hw, queue,
 567                                       IEEE80211_QUEUE_STOP_REASON_DRIVER,
 568                                       false);
 569}
 570EXPORT_SYMBOL(ieee80211_stop_queue);
 571
 572void ieee80211_add_pending_skb(struct ieee80211_local *local,
 573                               struct sk_buff *skb)
 574{
 575        struct ieee80211_hw *hw = &local->hw;
 576        unsigned long flags;
 577        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 578        int queue = info->hw_queue;
 579
 580        if (WARN_ON(!info->control.vif)) {
 581                ieee80211_free_txskb(&local->hw, skb);
 582                return;
 583        }
 584
 585        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 586        __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 587                               false);
 588        __skb_queue_tail(&local->pending[queue], skb);
 589        __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 590                               false, &flags);
 591        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 592}
 593
 594void ieee80211_add_pending_skbs(struct ieee80211_local *local,
 595                                struct sk_buff_head *skbs)
 596{
 597        struct ieee80211_hw *hw = &local->hw;
 598        struct sk_buff *skb;
 599        unsigned long flags;
 600        int queue, i;
 601
 602        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 603        while ((skb = skb_dequeue(skbs))) {
 604                struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 605
 606                if (WARN_ON(!info->control.vif)) {
 607                        ieee80211_free_txskb(&local->hw, skb);
 608                        continue;
 609                }
 610
 611                queue = info->hw_queue;
 612
 613                __ieee80211_stop_queue(hw, queue,
 614                                IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 615                                false);
 616
 617                __skb_queue_tail(&local->pending[queue], skb);
 618        }
 619
 620        for (i = 0; i < hw->queues; i++)
 621                __ieee80211_wake_queue(hw, i,
 622                        IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 623                        false, &flags);
 624        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 625}
 626
 627void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
 628                                     unsigned long queues,
 629                                     enum queue_stop_reason reason,
 630                                     bool refcounted)
 631{
 632        struct ieee80211_local *local = hw_to_local(hw);
 633        unsigned long flags;
 634        int i;
 635
 636        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 637
 638        for_each_set_bit(i, &queues, hw->queues)
 639                __ieee80211_stop_queue(hw, i, reason, refcounted);
 640
 641        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 642}
 643
 644void ieee80211_stop_queues(struct ieee80211_hw *hw)
 645{
 646        ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
 647                                        IEEE80211_QUEUE_STOP_REASON_DRIVER,
 648                                        false);
 649}
 650EXPORT_SYMBOL(ieee80211_stop_queues);
 651
 652int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
 653{
 654        struct ieee80211_local *local = hw_to_local(hw);
 655        unsigned long flags;
 656        int ret;
 657
 658        if (WARN_ON(queue >= hw->queues))
 659                return true;
 660
 661        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 662        ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
 663                       &local->queue_stop_reasons[queue]);
 664        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 665        return ret;
 666}
 667EXPORT_SYMBOL(ieee80211_queue_stopped);
 668
 669void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
 670                                     unsigned long queues,
 671                                     enum queue_stop_reason reason,
 672                                     bool refcounted)
 673{
 674        struct ieee80211_local *local = hw_to_local(hw);
 675        unsigned long flags;
 676        int i;
 677
 678        spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 679
 680        for_each_set_bit(i, &queues, hw->queues)
 681                __ieee80211_wake_queue(hw, i, reason, refcounted, &flags);
 682
 683        spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 684}
 685
 686void ieee80211_wake_queues(struct ieee80211_hw *hw)
 687{
 688        ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
 689                                        IEEE80211_QUEUE_STOP_REASON_DRIVER,
 690                                        false);
 691}
 692EXPORT_SYMBOL(ieee80211_wake_queues);
 693
 694static unsigned int
 695ieee80211_get_vif_queues(struct ieee80211_local *local,
 696                         struct ieee80211_sub_if_data *sdata)
 697{
 698        unsigned int queues;
 699
 700        if (sdata && ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) {
 701                int ac;
 702
 703                queues = 0;
 704
 705                for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
 706                        queues |= BIT(sdata->vif.hw_queue[ac]);
 707                if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
 708                        queues |= BIT(sdata->vif.cab_queue);
 709        } else {
 710                /* all queues */
 711                queues = BIT(local->hw.queues) - 1;
 712        }
 713
 714        return queues;
 715}
 716
 717void __ieee80211_flush_queues(struct ieee80211_local *local,
 718                              struct ieee80211_sub_if_data *sdata,
 719                              unsigned int queues, bool drop)
 720{
 721        if (!local->ops->flush)
 722                return;
 723
 724        /*
 725         * If no queue was set, or if the HW doesn't support
 726         * IEEE80211_HW_QUEUE_CONTROL - flush all queues
 727         */
 728        if (!queues || !ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
 729                queues = ieee80211_get_vif_queues(local, sdata);
 730
 731        ieee80211_stop_queues_by_reason(&local->hw, queues,
 732                                        IEEE80211_QUEUE_STOP_REASON_FLUSH,
 733                                        false);
 734
 735        drv_flush(local, sdata, queues, drop);
 736
 737        ieee80211_wake_queues_by_reason(&local->hw, queues,
 738                                        IEEE80211_QUEUE_STOP_REASON_FLUSH,
 739                                        false);
 740}
 741
 742void ieee80211_flush_queues(struct ieee80211_local *local,
 743                            struct ieee80211_sub_if_data *sdata, bool drop)
 744{
 745        __ieee80211_flush_queues(local, sdata, 0, drop);
 746}
 747
 748void ieee80211_stop_vif_queues(struct ieee80211_local *local,
 749                               struct ieee80211_sub_if_data *sdata,
 750                               enum queue_stop_reason reason)
 751{
 752        ieee80211_stop_queues_by_reason(&local->hw,
 753                                        ieee80211_get_vif_queues(local, sdata),
 754                                        reason, true);
 755}
 756
 757void ieee80211_wake_vif_queues(struct ieee80211_local *local,
 758                               struct ieee80211_sub_if_data *sdata,
 759                               enum queue_stop_reason reason)
 760{
 761        ieee80211_wake_queues_by_reason(&local->hw,
 762                                        ieee80211_get_vif_queues(local, sdata),
 763                                        reason, true);
 764}
 765
 766static void __iterate_interfaces(struct ieee80211_local *local,
 767                                 u32 iter_flags,
 768                                 void (*iterator)(void *data, u8 *mac,
 769                                                  struct ieee80211_vif *vif),
 770                                 void *data)
 771{
 772        struct ieee80211_sub_if_data *sdata;
 773        bool active_only = iter_flags & IEEE80211_IFACE_ITER_ACTIVE;
 774
 775        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 776                switch (sdata->vif.type) {
 777                case NL80211_IFTYPE_MONITOR:
 778                        if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
 779                                continue;
 780                        break;
 781                case NL80211_IFTYPE_AP_VLAN:
 782                        continue;
 783                default:
 784                        break;
 785                }
 786                if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
 787                    active_only && !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 788                        continue;
 789                if ((iter_flags & IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER) &&
 790                    !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 791                        continue;
 792                if (ieee80211_sdata_running(sdata) || !active_only)
 793                        iterator(data, sdata->vif.addr,
 794                                 &sdata->vif);
 795        }
 796
 797        sdata = rcu_dereference_check(local->monitor_sdata,
 798                                      lockdep_is_held(&local->iflist_mtx) ||
 799                                      lockdep_rtnl_is_held());
 800        if (sdata &&
 801            (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || !active_only ||
 802             sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 803                iterator(data, sdata->vif.addr, &sdata->vif);
 804}
 805
 806void ieee80211_iterate_interfaces(
 807        struct ieee80211_hw *hw, u32 iter_flags,
 808        void (*iterator)(void *data, u8 *mac,
 809                         struct ieee80211_vif *vif),
 810        void *data)
 811{
 812        struct ieee80211_local *local = hw_to_local(hw);
 813
 814        mutex_lock(&local->iflist_mtx);
 815        __iterate_interfaces(local, iter_flags, iterator, data);
 816        mutex_unlock(&local->iflist_mtx);
 817}
 818EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces);
 819
 820void ieee80211_iterate_active_interfaces_atomic(
 821        struct ieee80211_hw *hw, u32 iter_flags,
 822        void (*iterator)(void *data, u8 *mac,
 823                         struct ieee80211_vif *vif),
 824        void *data)
 825{
 826        struct ieee80211_local *local = hw_to_local(hw);
 827
 828        rcu_read_lock();
 829        __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
 830                             iterator, data);
 831        rcu_read_unlock();
 832}
 833EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
 834
 835void ieee80211_iterate_active_interfaces_mtx(
 836        struct ieee80211_hw *hw, u32 iter_flags,
 837        void (*iterator)(void *data, u8 *mac,
 838                         struct ieee80211_vif *vif),
 839        void *data)
 840{
 841        struct ieee80211_local *local = hw_to_local(hw);
 842
 843        lockdep_assert_wiphy(hw->wiphy);
 844
 845        __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
 846                             iterator, data);
 847}
 848EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_mtx);
 849
 850static void __iterate_stations(struct ieee80211_local *local,
 851                               void (*iterator)(void *data,
 852                                                struct ieee80211_sta *sta),
 853                               void *data)
 854{
 855        struct sta_info *sta;
 856
 857        list_for_each_entry_rcu(sta, &local->sta_list, list) {
 858                if (!sta->uploaded)
 859                        continue;
 860
 861                iterator(data, &sta->sta);
 862        }
 863}
 864
 865void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
 866                        void (*iterator)(void *data,
 867                                         struct ieee80211_sta *sta),
 868                        void *data)
 869{
 870        struct ieee80211_local *local = hw_to_local(hw);
 871
 872        rcu_read_lock();
 873        __iterate_stations(local, iterator, data);
 874        rcu_read_unlock();
 875}
 876EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);
 877
 878struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
 879{
 880        struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 881
 882        if (!ieee80211_sdata_running(sdata) ||
 883            !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 884                return NULL;
 885        return &sdata->vif;
 886}
 887EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
 888
 889struct wireless_dev *ieee80211_vif_to_wdev(struct ieee80211_vif *vif)
 890{
 891        if (!vif)
 892                return NULL;
 893
 894        return &vif_to_sdata(vif)->wdev;
 895}
 896EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev);
 897
 898/*
 899 * Nothing should have been stuffed into the workqueue during
 900 * the suspend->resume cycle. Since we can't check each caller
 901 * of this function if we are already quiescing / suspended,
 902 * check here and don't WARN since this can actually happen when
 903 * the rx path (for example) is racing against __ieee80211_suspend
 904 * and suspending / quiescing was set after the rx path checked
 905 * them.
 906 */
 907static bool ieee80211_can_queue_work(struct ieee80211_local *local)
 908{
 909        if (local->quiescing || (local->suspended && !local->resuming)) {
 910                pr_warn("queueing ieee80211 work while going to suspend\n");
 911                return false;
 912        }
 913
 914        return true;
 915}
 916
 917void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
 918{
 919        struct ieee80211_local *local = hw_to_local(hw);
 920
 921        if (!ieee80211_can_queue_work(local))
 922                return;
 923
 924        queue_work(local->workqueue, work);
 925}
 926EXPORT_SYMBOL(ieee80211_queue_work);
 927
 928void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
 929                                  struct delayed_work *dwork,
 930                                  unsigned long delay)
 931{
 932        struct ieee80211_local *local = hw_to_local(hw);
 933
 934        if (!ieee80211_can_queue_work(local))
 935                return;
 936
 937        queue_delayed_work(local->workqueue, dwork, delay);
 938}
 939EXPORT_SYMBOL(ieee80211_queue_delayed_work);
 940
 941static void ieee80211_parse_extension_element(u32 *crc,
 942                                              const struct element *elem,
 943                                              struct ieee802_11_elems *elems)
 944{
 945        const void *data = elem->data + 1;
 946        u8 len = elem->datalen - 1;
 947
 948        switch (elem->data[0]) {
 949        case WLAN_EID_EXT_HE_MU_EDCA:
 950                if (len >= sizeof(*elems->mu_edca_param_set)) {
 951                        elems->mu_edca_param_set = data;
 952                        if (crc)
 953                                *crc = crc32_be(*crc, (void *)elem,
 954                                                elem->datalen + 2);
 955                }
 956                break;
 957        case WLAN_EID_EXT_HE_CAPABILITY:
 958                elems->he_cap = data;
 959                elems->he_cap_len = len;
 960                break;
 961        case WLAN_EID_EXT_HE_OPERATION:
 962                if (len >= sizeof(*elems->he_operation) &&
 963                    len >= ieee80211_he_oper_size(data) - 1) {
 964                        if (crc)
 965                                *crc = crc32_be(*crc, (void *)elem,
 966                                                elem->datalen + 2);
 967                        elems->he_operation = data;
 968                }
 969                break;
 970        case WLAN_EID_EXT_UORA:
 971                if (len >= 1)
 972                        elems->uora_element = data;
 973                break;
 974        case WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME:
 975                if (len == 3)
 976                        elems->max_channel_switch_time = data;
 977                break;
 978        case WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION:
 979                if (len >= sizeof(*elems->mbssid_config_ie))
 980                        elems->mbssid_config_ie = data;
 981                break;
 982        case WLAN_EID_EXT_HE_SPR:
 983                if (len >= sizeof(*elems->he_spr) &&
 984                    len >= ieee80211_he_spr_size(data))
 985                        elems->he_spr = data;
 986                break;
 987        case WLAN_EID_EXT_HE_6GHZ_CAPA:
 988                if (len >= sizeof(*elems->he_6ghz_capa))
 989                        elems->he_6ghz_capa = data;
 990                break;
 991        }
 992}
 993
 994static u32
 995_ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
 996                            struct ieee802_11_elems *elems,
 997                            u64 filter, u32 crc,
 998                            const struct element *check_inherit)
 999{
1000        const struct element *elem;
1001        bool calc_crc = filter != 0;
1002        DECLARE_BITMAP(seen_elems, 256);
1003        const u8 *ie;
1004
1005        bitmap_zero(seen_elems, 256);
1006
1007        for_each_element(elem, start, len) {
1008                bool elem_parse_failed;
1009                u8 id = elem->id;
1010                u8 elen = elem->datalen;
1011                const u8 *pos = elem->data;
1012
1013                if (check_inherit &&
1014                    !cfg80211_is_element_inherited(elem,
1015                                                   check_inherit))
1016                        continue;
1017
1018                switch (id) {
1019                case WLAN_EID_SSID:
1020                case WLAN_EID_SUPP_RATES:
1021                case WLAN_EID_FH_PARAMS:
1022                case WLAN_EID_DS_PARAMS:
1023                case WLAN_EID_CF_PARAMS:
1024                case WLAN_EID_TIM:
1025                case WLAN_EID_IBSS_PARAMS:
1026                case WLAN_EID_CHALLENGE:
1027                case WLAN_EID_RSN:
1028                case WLAN_EID_ERP_INFO:
1029                case WLAN_EID_EXT_SUPP_RATES:
1030                case WLAN_EID_HT_CAPABILITY:
1031                case WLAN_EID_HT_OPERATION:
1032                case WLAN_EID_VHT_CAPABILITY:
1033                case WLAN_EID_VHT_OPERATION:
1034                case WLAN_EID_MESH_ID:
1035                case WLAN_EID_MESH_CONFIG:
1036                case WLAN_EID_PEER_MGMT:
1037                case WLAN_EID_PREQ:
1038                case WLAN_EID_PREP:
1039                case WLAN_EID_PERR:
1040                case WLAN_EID_RANN:
1041                case WLAN_EID_CHANNEL_SWITCH:
1042                case WLAN_EID_EXT_CHANSWITCH_ANN:
1043                case WLAN_EID_COUNTRY:
1044                case WLAN_EID_PWR_CONSTRAINT:
1045                case WLAN_EID_TIMEOUT_INTERVAL:
1046                case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
1047                case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
1048                case WLAN_EID_CHAN_SWITCH_PARAM:
1049                case WLAN_EID_EXT_CAPABILITY:
1050                case WLAN_EID_CHAN_SWITCH_TIMING:
1051                case WLAN_EID_LINK_ID:
1052                case WLAN_EID_BSS_MAX_IDLE_PERIOD:
1053                case WLAN_EID_RSNX:
1054                case WLAN_EID_S1G_BCN_COMPAT:
1055                case WLAN_EID_S1G_CAPABILITIES:
1056                case WLAN_EID_S1G_OPERATION:
1057                case WLAN_EID_AID_RESPONSE:
1058                case WLAN_EID_S1G_SHORT_BCN_INTERVAL:
1059                /*
1060                 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
1061                 * that if the content gets bigger it might be needed more than once
1062                 */
1063                        if (test_bit(id, seen_elems)) {
1064                                elems->parse_error = true;
1065                                continue;
1066                        }
1067                        break;
1068                }
1069
1070                if (calc_crc && id < 64 && (filter & (1ULL << id)))
1071                        crc = crc32_be(crc, pos - 2, elen + 2);
1072
1073                elem_parse_failed = false;
1074
1075                switch (id) {
1076                case WLAN_EID_LINK_ID:
1077                        if (elen + 2 < sizeof(struct ieee80211_tdls_lnkie)) {
1078                                elem_parse_failed = true;
1079                                break;
1080                        }
1081                        elems->lnk_id = (void *)(pos - 2);
1082                        break;
1083                case WLAN_EID_CHAN_SWITCH_TIMING:
1084                        if (elen < sizeof(struct ieee80211_ch_switch_timing)) {
1085                                elem_parse_failed = true;
1086                                break;
1087                        }
1088                        elems->ch_sw_timing = (void *)pos;
1089                        break;
1090                case WLAN_EID_EXT_CAPABILITY:
1091                        elems->ext_capab = pos;
1092                        elems->ext_capab_len = elen;
1093                        break;
1094                case WLAN_EID_SSID:
1095                        elems->ssid = pos;
1096                        elems->ssid_len = elen;
1097                        break;
1098                case WLAN_EID_SUPP_RATES:
1099                        elems->supp_rates = pos;
1100                        elems->supp_rates_len = elen;
1101                        break;
1102                case WLAN_EID_DS_PARAMS:
1103                        if (elen >= 1)
1104                                elems->ds_params = pos;
1105                        else
1106                                elem_parse_failed = true;
1107                        break;
1108                case WLAN_EID_TIM:
1109                        if (elen >= sizeof(struct ieee80211_tim_ie)) {
1110                                elems->tim = (void *)pos;
1111                                elems->tim_len = elen;
1112                        } else
1113                                elem_parse_failed = true;
1114                        break;
1115                case WLAN_EID_CHALLENGE:
1116                        elems->challenge = pos;
1117                        elems->challenge_len = elen;
1118                        break;
1119                case WLAN_EID_VENDOR_SPECIFIC:
1120                        if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
1121                            pos[2] == 0xf2) {
1122                                /* Microsoft OUI (00:50:F2) */
1123
1124                                if (calc_crc)
1125                                        crc = crc32_be(crc, pos - 2, elen + 2);
1126
1127                                if (elen >= 5 && pos[3] == 2) {
1128                                        /* OUI Type 2 - WMM IE */
1129                                        if (pos[4] == 0) {
1130                                                elems->wmm_info = pos;
1131                                                elems->wmm_info_len = elen;
1132                                        } else if (pos[4] == 1) {
1133                                                elems->wmm_param = pos;
1134                                                elems->wmm_param_len = elen;
1135                                        }
1136                                }
1137                        }
1138                        break;
1139                case WLAN_EID_RSN:
1140                        elems->rsn = pos;
1141                        elems->rsn_len = elen;
1142                        break;
1143                case WLAN_EID_ERP_INFO:
1144                        if (elen >= 1)
1145                                elems->erp_info = pos;
1146                        else
1147                                elem_parse_failed = true;
1148                        break;
1149                case WLAN_EID_EXT_SUPP_RATES:
1150                        elems->ext_supp_rates = pos;
1151                        elems->ext_supp_rates_len = elen;
1152                        break;
1153                case WLAN_EID_HT_CAPABILITY:
1154                        if (elen >= sizeof(struct ieee80211_ht_cap))
1155                                elems->ht_cap_elem = (void *)pos;
1156                        else
1157                                elem_parse_failed = true;
1158                        break;
1159                case WLAN_EID_HT_OPERATION:
1160                        if (elen >= sizeof(struct ieee80211_ht_operation))
1161                                elems->ht_operation = (void *)pos;
1162                        else
1163                                elem_parse_failed = true;
1164                        break;
1165                case WLAN_EID_VHT_CAPABILITY:
1166                        if (elen >= sizeof(struct ieee80211_vht_cap))
1167                                elems->vht_cap_elem = (void *)pos;
1168                        else
1169                                elem_parse_failed = true;
1170                        break;
1171                case WLAN_EID_VHT_OPERATION:
1172                        if (elen >= sizeof(struct ieee80211_vht_operation)) {
1173                                elems->vht_operation = (void *)pos;
1174                                if (calc_crc)
1175                                        crc = crc32_be(crc, pos - 2, elen + 2);
1176                                break;
1177                        }
1178                        elem_parse_failed = true;
1179                        break;
1180                case WLAN_EID_OPMODE_NOTIF:
1181                        if (elen > 0) {
1182                                elems->opmode_notif = pos;
1183                                if (calc_crc)
1184                                        crc = crc32_be(crc, pos - 2, elen + 2);
1185                                break;
1186                        }
1187                        elem_parse_failed = true;
1188                        break;
1189                case WLAN_EID_MESH_ID:
1190                        elems->mesh_id = pos;
1191                        elems->mesh_id_len = elen;
1192                        break;
1193                case WLAN_EID_MESH_CONFIG:
1194                        if (elen >= sizeof(struct ieee80211_meshconf_ie))
1195                                elems->mesh_config = (void *)pos;
1196                        else
1197                                elem_parse_failed = true;
1198                        break;
1199                case WLAN_EID_PEER_MGMT:
1200                        elems->peering = pos;
1201                        elems->peering_len = elen;
1202                        break;
1203                case WLAN_EID_MESH_AWAKE_WINDOW:
1204                        if (elen >= 2)
1205                                elems->awake_window = (void *)pos;
1206                        break;
1207                case WLAN_EID_PREQ:
1208                        elems->preq = pos;
1209                        elems->preq_len = elen;
1210                        break;
1211                case WLAN_EID_PREP:
1212                        elems->prep = pos;
1213                        elems->prep_len = elen;
1214                        break;
1215                case WLAN_EID_PERR:
1216                        elems->perr = pos;
1217                        elems->perr_len = elen;
1218                        break;
1219                case WLAN_EID_RANN:
1220                        if (elen >= sizeof(struct ieee80211_rann_ie))
1221                                elems->rann = (void *)pos;
1222                        else
1223                                elem_parse_failed = true;
1224                        break;
1225                case WLAN_EID_CHANNEL_SWITCH:
1226                        if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
1227                                elem_parse_failed = true;
1228                                break;
1229                        }
1230                        elems->ch_switch_ie = (void *)pos;
1231                        break;
1232                case WLAN_EID_EXT_CHANSWITCH_ANN:
1233                        if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
1234                                elem_parse_failed = true;
1235                                break;
1236                        }
1237                        elems->ext_chansw_ie = (void *)pos;
1238                        break;
1239                case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
1240                        if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
1241                                elem_parse_failed = true;
1242                                break;
1243                        }
1244                        elems->sec_chan_offs = (void *)pos;
1245                        break;
1246                case WLAN_EID_CHAN_SWITCH_PARAM:
1247                        if (elen <
1248                            sizeof(*elems->mesh_chansw_params_ie)) {
1249                                elem_parse_failed = true;
1250                                break;
1251                        }
1252                        elems->mesh_chansw_params_ie = (void *)pos;
1253                        break;
1254                case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
1255                        if (!action ||
1256                            elen < sizeof(*elems->wide_bw_chansw_ie)) {
1257                                elem_parse_failed = true;
1258                                break;
1259                        }
1260                        elems->wide_bw_chansw_ie = (void *)pos;
1261                        break;
1262                case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
1263                        if (action) {
1264                                elem_parse_failed = true;
1265                                break;
1266                        }
1267                        /*
1268                         * This is a bit tricky, but as we only care about
1269                         * the wide bandwidth channel switch element, so
1270                         * just parse it out manually.
1271                         */
1272                        ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
1273                                              pos, elen);
1274                        if (ie) {
1275                                if (ie[1] >= sizeof(*elems->wide_bw_chansw_ie))
1276                                        elems->wide_bw_chansw_ie =
1277                                                (void *)(ie + 2);
1278                                else
1279                                        elem_parse_failed = true;
1280                        }
1281                        break;
1282                case WLAN_EID_COUNTRY:
1283                        elems->country_elem = pos;
1284                        elems->country_elem_len = elen;
1285                        break;
1286                case WLAN_EID_PWR_CONSTRAINT:
1287                        if (elen != 1) {
1288                                elem_parse_failed = true;
1289                                break;
1290                        }
1291                        elems->pwr_constr_elem = pos;
1292                        break;
1293                case WLAN_EID_CISCO_VENDOR_SPECIFIC:
1294                        /* Lots of different options exist, but we only care
1295                         * about the Dynamic Transmit Power Control element.
1296                         * First check for the Cisco OUI, then for the DTPC
1297                         * tag (0x00).
1298                         */
1299                        if (elen < 4) {
1300                                elem_parse_failed = true;
1301                                break;
1302                        }
1303
1304                        if (pos[0] != 0x00 || pos[1] != 0x40 ||
1305                            pos[2] != 0x96 || pos[3] != 0x00)
1306                                break;
1307
1308                        if (elen != 6) {
1309                                elem_parse_failed = true;
1310                                break;
1311                        }
1312
1313                        if (calc_crc)
1314                                crc = crc32_be(crc, pos - 2, elen + 2);
1315
1316                        elems->cisco_dtpc_elem = pos;
1317                        break;
1318                case WLAN_EID_ADDBA_EXT:
1319                        if (elen < sizeof(struct ieee80211_addba_ext_ie)) {
1320                                elem_parse_failed = true;
1321                                break;
1322                        }
1323                        elems->addba_ext_ie = (void *)pos;
1324                        break;
1325                case WLAN_EID_TIMEOUT_INTERVAL:
1326                        if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
1327                                elems->timeout_int = (void *)pos;
1328                        else
1329                                elem_parse_failed = true;
1330                        break;
1331                case WLAN_EID_BSS_MAX_IDLE_PERIOD:
1332                        if (elen >= sizeof(*elems->max_idle_period_ie))
1333                                elems->max_idle_period_ie = (void *)pos;
1334                        break;
1335                case WLAN_EID_RSNX:
1336                        elems->rsnx = pos;
1337                        elems->rsnx_len = elen;
1338                        break;
1339                case WLAN_EID_EXTENSION:
1340                        ieee80211_parse_extension_element(calc_crc ?
1341                                                                &crc : NULL,
1342                                                          elem, elems);
1343                        break;
1344                case WLAN_EID_S1G_CAPABILITIES:
1345                        if (elen >= sizeof(*elems->s1g_capab))
1346                                elems->s1g_capab = (void *)pos;
1347                        else
1348                                elem_parse_failed = true;
1349                        break;
1350                case WLAN_EID_S1G_OPERATION:
1351                        if (elen == sizeof(*elems->s1g_oper))
1352                                elems->s1g_oper = (void *)pos;
1353                        else
1354                                elem_parse_failed = true;
1355                        break;
1356                case WLAN_EID_S1G_BCN_COMPAT:
1357                        if (elen == sizeof(*elems->s1g_bcn_compat))
1358                                elems->s1g_bcn_compat = (void *)pos;
1359                        else
1360                                elem_parse_failed = true;
1361                        break;
1362                case WLAN_EID_AID_RESPONSE:
1363                        if (elen == sizeof(struct ieee80211_aid_response_ie))
1364                                elems->aid_resp = (void *)pos;
1365                        else
1366                                elem_parse_failed = true;
1367                        break;
1368                default:
1369                        break;
1370                }
1371
1372                if (elem_parse_failed)
1373                        elems->parse_error = true;
1374                else
1375                        __set_bit(id, seen_elems);
1376        }
1377
1378        if (!for_each_element_completed(elem, start, len))
1379                elems->parse_error = true;
1380
1381        return crc;
1382}
1383
1384static size_t ieee802_11_find_bssid_profile(const u8 *start, size_t len,
1385                                            struct ieee802_11_elems *elems,
1386                                            u8 *transmitter_bssid,
1387                                            u8 *bss_bssid,
1388                                            u8 *nontransmitted_profile)
1389{
1390        const struct element *elem, *sub;
1391        size_t profile_len = 0;
1392        bool found = false;
1393
1394        if (!bss_bssid || !transmitter_bssid)
1395                return profile_len;
1396
1397        for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID, start, len) {
1398                if (elem->datalen < 2)
1399                        continue;
1400
1401                for_each_element(sub, elem->data + 1, elem->datalen - 1) {
1402                        u8 new_bssid[ETH_ALEN];
1403                        const u8 *index;
1404
1405                        if (sub->id != 0 || sub->datalen < 4) {
1406                                /* not a valid BSS profile */
1407                                continue;
1408                        }
1409
1410                        if (sub->data[0] != WLAN_EID_NON_TX_BSSID_CAP ||
1411                            sub->data[1] != 2) {
1412                                /* The first element of the
1413                                 * Nontransmitted BSSID Profile is not
1414                                 * the Nontransmitted BSSID Capability
1415                                 * element.
1416                                 */
1417                                continue;
1418                        }
1419
1420                        memset(nontransmitted_profile, 0, len);
1421                        profile_len = cfg80211_merge_profile(start, len,
1422                                                             elem,
1423                                                             sub,
1424                                                             nontransmitted_profile,
1425                                                             len);
1426
1427                        /* found a Nontransmitted BSSID Profile */
1428                        index = cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX,
1429                                                 nontransmitted_profile,
1430                                                 profile_len);
1431                        if (!index || index[1] < 1 || index[2] == 0) {
1432                                /* Invalid MBSSID Index element */
1433                                continue;
1434                        }
1435
1436                        cfg80211_gen_new_bssid(transmitter_bssid,
1437                                               elem->data[0],
1438                                               index[2],
1439                                               new_bssid);
1440                        if (ether_addr_equal(new_bssid, bss_bssid)) {
1441                                found = true;
1442                                elems->bssid_index_len = index[1];
1443                                elems->bssid_index = (void *)&index[2];
1444                                break;
1445                        }
1446                }
1447        }
1448
1449        return found ? profile_len : 0;
1450}
1451
1452u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
1453                               struct ieee802_11_elems *elems,
1454                               u64 filter, u32 crc, u8 *transmitter_bssid,
1455                               u8 *bss_bssid)
1456{
1457        const struct element *non_inherit = NULL;
1458        u8 *nontransmitted_profile;
1459        int nontransmitted_profile_len = 0;
1460
1461        memset(elems, 0, sizeof(*elems));
1462        elems->ie_start = start;
1463        elems->total_len = len;
1464
1465        nontransmitted_profile = kmalloc(len, GFP_ATOMIC);
1466        if (nontransmitted_profile) {
1467                nontransmitted_profile_len =
1468                        ieee802_11_find_bssid_profile(start, len, elems,
1469                                                      transmitter_bssid,
1470                                                      bss_bssid,
1471                                                      nontransmitted_profile);
1472                non_inherit =
1473                        cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE,
1474                                               nontransmitted_profile,
1475                                               nontransmitted_profile_len);
1476        }
1477
1478        crc = _ieee802_11_parse_elems_crc(start, len, action, elems, filter,
1479                                          crc, non_inherit);
1480
1481        /* Override with nontransmitted profile, if found */
1482        if (nontransmitted_profile_len)
1483                _ieee802_11_parse_elems_crc(nontransmitted_profile,
1484                                            nontransmitted_profile_len,
1485                                            action, elems, 0, 0, NULL);
1486
1487        if (elems->tim && !elems->parse_error) {
1488                const struct ieee80211_tim_ie *tim_ie = elems->tim;
1489
1490                elems->dtim_period = tim_ie->dtim_period;
1491                elems->dtim_count = tim_ie->dtim_count;
1492        }
1493
1494        /* Override DTIM period and count if needed */
1495        if (elems->bssid_index &&
1496            elems->bssid_index_len >=
1497            offsetofend(struct ieee80211_bssid_index, dtim_period))
1498                elems->dtim_period = elems->bssid_index->dtim_period;
1499
1500        if (elems->bssid_index &&
1501            elems->bssid_index_len >=
1502            offsetofend(struct ieee80211_bssid_index, dtim_count))
1503                elems->dtim_count = elems->bssid_index->dtim_count;
1504
1505        kfree(nontransmitted_profile);
1506
1507        return crc;
1508}
1509
1510void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
1511                                           struct ieee80211_tx_queue_params
1512                                           *qparam, int ac)
1513{
1514        struct ieee80211_chanctx_conf *chanctx_conf;
1515        const struct ieee80211_reg_rule *rrule;
1516        const struct ieee80211_wmm_ac *wmm_ac;
1517        u16 center_freq = 0;
1518
1519        if (sdata->vif.type != NL80211_IFTYPE_AP &&
1520            sdata->vif.type != NL80211_IFTYPE_STATION)
1521                return;
1522
1523        rcu_read_lock();
1524        chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1525        if (chanctx_conf)
1526                center_freq = chanctx_conf->def.chan->center_freq;
1527
1528        if (!center_freq) {
1529                rcu_read_unlock();
1530                return;
1531        }
1532
1533        rrule = freq_reg_info(sdata->wdev.wiphy, MHZ_TO_KHZ(center_freq));
1534
1535        if (IS_ERR_OR_NULL(rrule) || !rrule->has_wmm) {
1536                rcu_read_unlock();
1537                return;
1538        }
1539
1540        if (sdata->vif.type == NL80211_IFTYPE_AP)
1541                wmm_ac = &rrule->wmm_rule.ap[ac];
1542        else
1543                wmm_ac = &rrule->wmm_rule.client[ac];
1544        qparam->cw_min = max_t(u16, qparam->cw_min, wmm_ac->cw_min);
1545        qparam->cw_max = max_t(u16, qparam->cw_max, wmm_ac->cw_max);
1546        qparam->aifs = max_t(u8, qparam->aifs, wmm_ac->aifsn);
1547        qparam->txop = min_t(u16, qparam->txop, wmm_ac->cot / 32);
1548        rcu_read_unlock();
1549}
1550
1551void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
1552                               bool bss_notify, bool enable_qos)
1553{
1554        struct ieee80211_local *local = sdata->local;
1555        struct ieee80211_tx_queue_params qparam;
1556        struct ieee80211_chanctx_conf *chanctx_conf;
1557        int ac;
1558        bool use_11b;
1559        bool is_ocb; /* Use another EDCA parameters if dot11OCBActivated=true */
1560        int aCWmin, aCWmax;
1561
1562        if (!local->ops->conf_tx)
1563                return;
1564
1565        if (local->hw.queues < IEEE80211_NUM_ACS)
1566                return;
1567
1568        memset(&qparam, 0, sizeof(qparam));
1569
1570        rcu_read_lock();
1571        chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1572        use_11b = (chanctx_conf &&
1573                   chanctx_conf->def.chan->band == NL80211_BAND_2GHZ) &&
1574                 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
1575        rcu_read_unlock();
1576
1577        is_ocb = (sdata->vif.type == NL80211_IFTYPE_OCB);
1578
1579        /* Set defaults according to 802.11-2007 Table 7-37 */
1580        aCWmax = 1023;
1581        if (use_11b)
1582                aCWmin = 31;
1583        else
1584                aCWmin = 15;
1585
1586        /* Confiure old 802.11b/g medium access rules. */
1587        qparam.cw_max = aCWmax;
1588        qparam.cw_min = aCWmin;
1589        qparam.txop = 0;
1590        qparam.aifs = 2;
1591
1592        for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1593                /* Update if QoS is enabled. */
1594                if (enable_qos) {
1595                        switch (ac) {
1596                        case IEEE80211_AC_BK:
1597                                qparam.cw_max = aCWmax;
1598                                qparam.cw_min = aCWmin;
1599                                qparam.txop = 0;
1600                                if (is_ocb)
1601                                        qparam.aifs = 9;
1602                                else
1603                                        qparam.aifs = 7;
1604                                break;
1605                        /* never happens but let's not leave undefined */
1606                        default:
1607                        case IEEE80211_AC_BE:
1608                                qparam.cw_max = aCWmax;
1609                                qparam.cw_min = aCWmin;
1610                                qparam.txop = 0;
1611                                if (is_ocb)
1612                                        qparam.aifs = 6;
1613                                else
1614                                        qparam.aifs = 3;
1615                                break;
1616                        case IEEE80211_AC_VI:
1617                                qparam.cw_max = aCWmin;
1618                                qparam.cw_min = (aCWmin + 1) / 2 - 1;
1619                                if (is_ocb)
1620                                        qparam.txop = 0;
1621                                else if (use_11b)
1622                                        qparam.txop = 6016/32;
1623                                else
1624                                        qparam.txop = 3008/32;
1625
1626                                if (is_ocb)
1627                                        qparam.aifs = 3;
1628                                else
1629                                        qparam.aifs = 2;
1630                                break;
1631                        case IEEE80211_AC_VO:
1632                                qparam.cw_max = (aCWmin + 1) / 2 - 1;
1633                                qparam.cw_min = (aCWmin + 1) / 4 - 1;
1634                                if (is_ocb)
1635                                        qparam.txop = 0;
1636                                else if (use_11b)
1637                                        qparam.txop = 3264/32;
1638                                else
1639                                        qparam.txop = 1504/32;
1640                                qparam.aifs = 2;
1641                                break;
1642                        }
1643                }
1644                ieee80211_regulatory_limit_wmm_params(sdata, &qparam, ac);
1645
1646                qparam.uapsd = false;
1647
1648                sdata->tx_conf[ac] = qparam;
1649                drv_conf_tx(local, sdata, ac, &qparam);
1650        }
1651
1652        if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1653            sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
1654            sdata->vif.type != NL80211_IFTYPE_NAN) {
1655                sdata->vif.bss_conf.qos = enable_qos;
1656                if (bss_notify)
1657                        ieee80211_bss_info_change_notify(sdata,
1658                                                         BSS_CHANGED_QOS);
1659        }
1660}
1661
1662void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1663                         u16 transaction, u16 auth_alg, u16 status,
1664                         const u8 *extra, size_t extra_len, const u8 *da,
1665                         const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
1666                         u32 tx_flags)
1667{
1668        struct ieee80211_local *local = sdata->local;
1669        struct sk_buff *skb;
1670        struct ieee80211_mgmt *mgmt;
1671        int err;
1672
1673        /* 24 + 6 = header + auth_algo + auth_transaction + status_code */
1674        skb = dev_alloc_skb(local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN +
1675                            24 + 6 + extra_len + IEEE80211_WEP_ICV_LEN);
1676        if (!skb)
1677                return;
1678
1679        skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN);
1680
1681        mgmt = skb_put_zero(skb, 24 + 6);
1682        mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1683                                          IEEE80211_STYPE_AUTH);
1684        memcpy(mgmt->da, da, ETH_ALEN);
1685        memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1686        memcpy(mgmt->bssid, bssid, ETH_ALEN);
1687        mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
1688        mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
1689        mgmt->u.auth.status_code = cpu_to_le16(status);
1690        if (extra)
1691                skb_put_data(skb, extra, extra_len);
1692
1693        if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
1694                mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1695                err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
1696                if (WARN_ON(err)) {
1697                        kfree_skb(skb);
1698                        return;
1699                }
1700        }
1701
1702        IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1703                                        tx_flags;
1704        ieee80211_tx_skb(sdata, skb);
1705}
1706
1707void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
1708                                    const u8 *da, const u8 *bssid,
1709                                    u16 stype, u16 reason,
1710                                    bool send_frame, u8 *frame_buf)
1711{
1712        struct ieee80211_local *local = sdata->local;
1713        struct sk_buff *skb;
1714        struct ieee80211_mgmt *mgmt = (void *)frame_buf;
1715
1716        /* build frame */
1717        mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1718        mgmt->duration = 0; /* initialize only */
1719        mgmt->seq_ctrl = 0; /* initialize only */
1720        memcpy(mgmt->da, da, ETH_ALEN);
1721        memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1722        memcpy(mgmt->bssid, bssid, ETH_ALEN);
1723        /* u.deauth.reason_code == u.disassoc.reason_code */
1724        mgmt->u.deauth.reason_code = cpu_to_le16(reason);
1725
1726        if (send_frame) {
1727                skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1728                                    IEEE80211_DEAUTH_FRAME_LEN);
1729                if (!skb)
1730                        return;
1731
1732                skb_reserve(skb, local->hw.extra_tx_headroom);
1733
1734                /* copy in frame */
1735                skb_put_data(skb, mgmt, IEEE80211_DEAUTH_FRAME_LEN);
1736
1737                if (sdata->vif.type != NL80211_IFTYPE_STATION ||
1738                    !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
1739                        IEEE80211_SKB_CB(skb)->flags |=
1740                                IEEE80211_TX_INTFL_DONT_ENCRYPT;
1741
1742                ieee80211_tx_skb(sdata, skb);
1743        }
1744}
1745
1746static u8 *ieee80211_write_he_6ghz_cap(u8 *pos, __le16 cap, u8 *end)
1747{
1748        if ((end - pos) < 5)
1749                return pos;
1750
1751        *pos++ = WLAN_EID_EXTENSION;
1752        *pos++ = 1 + sizeof(cap);
1753        *pos++ = WLAN_EID_EXT_HE_6GHZ_CAPA;
1754        memcpy(pos, &cap, sizeof(cap));
1755
1756        return pos + 2;
1757}
1758
1759static int ieee80211_build_preq_ies_band(struct ieee80211_sub_if_data *sdata,
1760                                         u8 *buffer, size_t buffer_len,
1761                                         const u8 *ie, size_t ie_len,
1762                                         enum nl80211_band band,
1763                                         u32 rate_mask,
1764                                         struct cfg80211_chan_def *chandef,
1765                                         size_t *offset, u32 flags)
1766{
1767        struct ieee80211_local *local = sdata->local;
1768        struct ieee80211_supported_band *sband;
1769        const struct ieee80211_sta_he_cap *he_cap;
1770        u8 *pos = buffer, *end = buffer + buffer_len;
1771        size_t noffset;
1772        int supp_rates_len, i;
1773        u8 rates[32];
1774        int num_rates;
1775        int ext_rates_len;
1776        int shift;
1777        u32 rate_flags;
1778        bool have_80mhz = false;
1779
1780        *offset = 0;
1781
1782        sband = local->hw.wiphy->bands[band];
1783        if (WARN_ON_ONCE(!sband))
1784                return 0;
1785
1786        rate_flags = ieee80211_chandef_rate_flags(chandef);
1787        shift = ieee80211_chandef_get_shift(chandef);
1788
1789        num_rates = 0;
1790        for (i = 0; i < sband->n_bitrates; i++) {
1791                if ((BIT(i) & rate_mask) == 0)
1792                        continue; /* skip rate */
1793                if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1794                        continue;
1795
1796                rates[num_rates++] =
1797                        (u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
1798                                          (1 << shift) * 5);
1799        }
1800
1801        supp_rates_len = min_t(int, num_rates, 8);
1802
1803        if (end - pos < 2 + supp_rates_len)
1804                goto out_err;
1805        *pos++ = WLAN_EID_SUPP_RATES;
1806        *pos++ = supp_rates_len;
1807        memcpy(pos, rates, supp_rates_len);
1808        pos += supp_rates_len;
1809
1810        /* insert "request information" if in custom IEs */
1811        if (ie && ie_len) {
1812                static const u8 before_extrates[] = {
1813                        WLAN_EID_SSID,
1814                        WLAN_EID_SUPP_RATES,
1815                        WLAN_EID_REQUEST,
1816                };
1817                noffset = ieee80211_ie_split(ie, ie_len,
1818                                             before_extrates,
1819                                             ARRAY_SIZE(before_extrates),
1820                                             *offset);
1821                if (end - pos < noffset - *offset)
1822                        goto out_err;
1823                memcpy(pos, ie + *offset, noffset - *offset);
1824                pos += noffset - *offset;
1825                *offset = noffset;
1826        }
1827
1828        ext_rates_len = num_rates - supp_rates_len;
1829        if (ext_rates_len > 0) {
1830                if (end - pos < 2 + ext_rates_len)
1831                        goto out_err;
1832                *pos++ = WLAN_EID_EXT_SUPP_RATES;
1833                *pos++ = ext_rates_len;
1834                memcpy(pos, rates + supp_rates_len, ext_rates_len);
1835                pos += ext_rates_len;
1836        }
1837
1838        if (chandef->chan && sband->band == NL80211_BAND_2GHZ) {
1839                if (end - pos < 3)
1840                        goto out_err;
1841                *pos++ = WLAN_EID_DS_PARAMS;
1842                *pos++ = 1;
1843                *pos++ = ieee80211_frequency_to_channel(
1844                                chandef->chan->center_freq);
1845        }
1846
1847        if (flags & IEEE80211_PROBE_FLAG_MIN_CONTENT)
1848                goto done;
1849
1850        /* insert custom IEs that go before HT */
1851        if (ie && ie_len) {
1852                static const u8 before_ht[] = {
1853                        /*
1854                         * no need to list the ones split off already
1855                         * (or generated here)
1856                         */
1857                        WLAN_EID_DS_PARAMS,
1858                        WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1859                };
1860                noffset = ieee80211_ie_split(ie, ie_len,
1861                                             before_ht, ARRAY_SIZE(before_ht),
1862                                             *offset);
1863                if (end - pos < noffset - *offset)
1864                        goto out_err;
1865                memcpy(pos, ie + *offset, noffset - *offset);
1866                pos += noffset - *offset;
1867                *offset = noffset;
1868        }
1869
1870        if (sband->ht_cap.ht_supported) {
1871                if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
1872                        goto out_err;
1873                pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1874                                                sband->ht_cap.cap);
1875        }
1876
1877        /* insert custom IEs that go before VHT */
1878        if (ie && ie_len) {
1879                static const u8 before_vht[] = {
1880                        /*
1881                         * no need to list the ones split off already
1882                         * (or generated here)
1883                         */
1884                        WLAN_EID_BSS_COEX_2040,
1885                        WLAN_EID_EXT_CAPABILITY,
1886                        WLAN_EID_SSID_LIST,
1887                        WLAN_EID_CHANNEL_USAGE,
1888                        WLAN_EID_INTERWORKING,
1889                        WLAN_EID_MESH_ID,
1890                        /* 60 GHz (Multi-band, DMG, MMS) can't happen */
1891                };
1892                noffset = ieee80211_ie_split(ie, ie_len,
1893                                             before_vht, ARRAY_SIZE(before_vht),
1894                                             *offset);
1895                if (end - pos < noffset - *offset)
1896                        goto out_err;
1897                memcpy(pos, ie + *offset, noffset - *offset);
1898                pos += noffset - *offset;
1899                *offset = noffset;
1900        }
1901
1902        /* Check if any channel in this sband supports at least 80 MHz */
1903        for (i = 0; i < sband->n_channels; i++) {
1904                if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
1905                                                IEEE80211_CHAN_NO_80MHZ))
1906                        continue;
1907
1908                have_80mhz = true;
1909                break;
1910        }
1911
1912        if (sband->vht_cap.vht_supported && have_80mhz) {
1913                if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
1914                        goto out_err;
1915                pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1916                                                 sband->vht_cap.cap);
1917        }
1918
1919        /* insert custom IEs that go before HE */
1920        if (ie && ie_len) {
1921                static const u8 before_he[] = {
1922                        /*
1923                         * no need to list the ones split off before VHT
1924                         * or generated here
1925                         */
1926                        WLAN_EID_EXTENSION, WLAN_EID_EXT_FILS_REQ_PARAMS,
1927                        WLAN_EID_AP_CSN,
1928                        /* TODO: add 11ah/11aj/11ak elements */
1929                };
1930                noffset = ieee80211_ie_split(ie, ie_len,
1931                                             before_he, ARRAY_SIZE(before_he),
1932                                             *offset);
1933                if (end - pos < noffset - *offset)
1934                        goto out_err;
1935                memcpy(pos, ie + *offset, noffset - *offset);
1936                pos += noffset - *offset;
1937                *offset = noffset;
1938        }
1939
1940        he_cap = ieee80211_get_he_iftype_cap(sband,
1941                                             ieee80211_vif_type_p2p(&sdata->vif));
1942        if (he_cap &&
1943            cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band),
1944                                         IEEE80211_CHAN_NO_HE)) {
1945                pos = ieee80211_ie_build_he_cap(pos, he_cap, end);
1946                if (!pos)
1947                        goto out_err;
1948        }
1949
1950        if (cfg80211_any_usable_channels(local->hw.wiphy,
1951                                         BIT(NL80211_BAND_6GHZ),
1952                                         IEEE80211_CHAN_NO_HE)) {
1953                struct ieee80211_supported_band *sband6;
1954
1955                sband6 = local->hw.wiphy->bands[NL80211_BAND_6GHZ];
1956                he_cap = ieee80211_get_he_iftype_cap(sband6,
1957                                ieee80211_vif_type_p2p(&sdata->vif));
1958
1959                if (he_cap) {
1960                        enum nl80211_iftype iftype =
1961                                ieee80211_vif_type_p2p(&sdata->vif);
1962                        __le16 cap = ieee80211_get_he_6ghz_capa(sband, iftype);
1963
1964                        pos = ieee80211_write_he_6ghz_cap(pos, cap, end);
1965                }
1966        }
1967
1968        /*
1969         * If adding more here, adjust code in main.c
1970         * that calculates local->scan_ies_len.
1971         */
1972
1973        return pos - buffer;
1974 out_err:
1975        WARN_ONCE(1, "not enough space for preq IEs\n");
1976 done:
1977        return pos - buffer;
1978}
1979
1980int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, u8 *buffer,
1981                             size_t buffer_len,
1982                             struct ieee80211_scan_ies *ie_desc,
1983                             const u8 *ie, size_t ie_len,
1984                             u8 bands_used, u32 *rate_masks,
1985                             struct cfg80211_chan_def *chandef,
1986                             u32 flags)
1987{
1988        size_t pos = 0, old_pos = 0, custom_ie_offset = 0;
1989        int i;
1990
1991        memset(ie_desc, 0, sizeof(*ie_desc));
1992
1993        for (i = 0; i < NUM_NL80211_BANDS; i++) {
1994                if (bands_used & BIT(i)) {
1995                        pos += ieee80211_build_preq_ies_band(sdata,
1996                                                             buffer + pos,
1997                                                             buffer_len - pos,
1998                                                             ie, ie_len, i,
1999                                                             rate_masks[i],
2000                                                             chandef,
2001                                                             &custom_ie_offset,
2002                                                             flags);
2003                        ie_desc->ies[i] = buffer + old_pos;
2004                        ie_desc->len[i] = pos - old_pos;
2005                        old_pos = pos;
2006                }
2007        }
2008
2009        /* add any remaining custom IEs */
2010        if (ie && ie_len) {
2011                if (WARN_ONCE(buffer_len - pos < ie_len - custom_ie_offset,
2012                              "not enough space for preq custom IEs\n"))
2013                        return pos;
2014                memcpy(buffer + pos, ie + custom_ie_offset,
2015                       ie_len - custom_ie_offset);
2016                ie_desc->common_ies = buffer + pos;
2017                ie_desc->common_ie_len = ie_len - custom_ie_offset;
2018                pos += ie_len - custom_ie_offset;
2019        }
2020
2021        return pos;
2022};
2023
2024struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
2025                                          const u8 *src, const u8 *dst,
2026                                          u32 ratemask,
2027                                          struct ieee80211_channel *chan,
2028                                          const u8 *ssid, size_t ssid_len,
2029                                          const u8 *ie, size_t ie_len,
2030                                          u32 flags)
2031{
2032        struct ieee80211_local *local = sdata->local;
2033        struct cfg80211_chan_def chandef;
2034        struct sk_buff *skb;
2035        struct ieee80211_mgmt *mgmt;
2036        int ies_len;
2037        u32 rate_masks[NUM_NL80211_BANDS] = {};
2038        struct ieee80211_scan_ies dummy_ie_desc;
2039
2040        /*
2041         * Do not send DS Channel parameter for directed probe requests
2042         * in order to maximize the chance that we get a response.  Some
2043         * badly-behaved APs don't respond when this parameter is included.
2044         */
2045        chandef.width = sdata->vif.bss_conf.chandef.width;
2046        if (flags & IEEE80211_PROBE_FLAG_DIRECTED)
2047                chandef.chan = NULL;
2048        else
2049                chandef.chan = chan;
2050
2051        skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
2052                                     100 + ie_len);
2053        if (!skb)
2054                return NULL;
2055
2056        rate_masks[chan->band] = ratemask;
2057        ies_len = ieee80211_build_preq_ies(sdata, skb_tail_pointer(skb),
2058                                           skb_tailroom(skb), &dummy_ie_desc,
2059                                           ie, ie_len, BIT(chan->band),
2060                                           rate_masks, &chandef, flags);
2061        skb_put(skb, ies_len);
2062
2063        if (dst) {
2064                mgmt = (struct ieee80211_mgmt *) skb->data;
2065                memcpy(mgmt->da, dst, ETH_ALEN);
2066                memcpy(mgmt->bssid, dst, ETH_ALEN);
2067        }
2068
2069        IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
2070
2071        return skb;
2072}
2073
2074u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
2075                            struct ieee802_11_elems *elems,
2076                            enum nl80211_band band, u32 *basic_rates)
2077{
2078        struct ieee80211_supported_band *sband;
2079        size_t num_rates;
2080        u32 supp_rates, rate_flags;
2081        int i, j, shift;
2082
2083        sband = sdata->local->hw.wiphy->bands[band];
2084        if (WARN_ON(!sband))
2085                return 1;
2086
2087        rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
2088        shift = ieee80211_vif_get_shift(&sdata->vif);
2089
2090        num_rates = sband->n_bitrates;
2091        supp_rates = 0;
2092        for (i = 0; i < elems->supp_rates_len +
2093                     elems->ext_supp_rates_len; i++) {
2094                u8 rate = 0;
2095                int own_rate;
2096                bool is_basic;
2097                if (i < elems->supp_rates_len)
2098                        rate = elems->supp_rates[i];
2099                else if (elems->ext_supp_rates)
2100                        rate = elems->ext_supp_rates
2101                                [i - elems->supp_rates_len];
2102                own_rate = 5 * (rate & 0x7f);
2103                is_basic = !!(rate & 0x80);
2104
2105                if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
2106                        continue;
2107
2108                for (j = 0; j < num_rates; j++) {
2109                        int brate;
2110                        if ((rate_flags & sband->bitrates[j].flags)
2111                            != rate_flags)
2112                                continue;
2113
2114                        brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
2115                                             1 << shift);
2116
2117                        if (brate == own_rate) {
2118                                supp_rates |= BIT(j);
2119                                if (basic_rates && is_basic)
2120                                        *basic_rates |= BIT(j);
2121                        }
2122                }
2123        }
2124        return supp_rates;
2125}
2126
2127void ieee80211_stop_device(struct ieee80211_local *local)
2128{
2129        ieee80211_led_radio(local, false);
2130        ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
2131
2132        cancel_work_sync(&local->reconfig_filter);
2133
2134        flush_workqueue(local->workqueue);
2135        drv_stop(local);
2136}
2137
2138static void ieee80211_flush_completed_scan(struct ieee80211_local *local,
2139                                           bool aborted)
2140{
2141        /* It's possible that we don't handle the scan completion in
2142         * time during suspend, so if it's still marked as completed
2143         * here, queue the work and flush it to clean things up.
2144         * Instead of calling the worker function directly here, we
2145         * really queue it to avoid potential races with other flows
2146         * scheduling the same work.
2147         */
2148        if (test_bit(SCAN_COMPLETED, &local->scanning)) {
2149                /* If coming from reconfiguration failure, abort the scan so
2150                 * we don't attempt to continue a partial HW scan - which is
2151                 * possible otherwise if (e.g.) the 2.4 GHz portion was the
2152                 * completed scan, and a 5 GHz portion is still pending.
2153                 */
2154                if (aborted)
2155                        set_bit(SCAN_ABORTED, &local->scanning);
2156                ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
2157                flush_delayed_work(&local->scan_work);
2158        }
2159}
2160
2161static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
2162{
2163        struct ieee80211_sub_if_data *sdata;
2164        struct ieee80211_chanctx *ctx;
2165
2166        /*
2167         * We get here if during resume the device can't be restarted properly.
2168         * We might also get here if this happens during HW reset, which is a
2169         * slightly different situation and we need to drop all connections in
2170         * the latter case.
2171         *
2172         * Ask cfg80211 to turn off all interfaces, this will result in more
2173         * warnings but at least we'll then get into a clean stopped state.
2174         */
2175
2176        local->resuming = false;
2177        local->suspended = false;
2178        local->in_reconfig = false;
2179
2180        ieee80211_flush_completed_scan(local, true);
2181
2182        /* scheduled scan clearly can't be running any more, but tell
2183         * cfg80211 and clear local state
2184         */
2185        ieee80211_sched_scan_end(local);
2186
2187        list_for_each_entry(sdata, &local->interfaces, list)
2188                sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
2189
2190        /* Mark channel contexts as not being in the driver any more to avoid
2191         * removing them from the driver during the shutdown process...
2192         */
2193        mutex_lock(&local->chanctx_mtx);
2194        list_for_each_entry(ctx, &local->chanctx_list, list)
2195                ctx->driver_present = false;
2196        mutex_unlock(&local->chanctx_mtx);
2197}
2198
2199static void ieee80211_assign_chanctx(struct ieee80211_local *local,
2200                                     struct ieee80211_sub_if_data *sdata)
2201{
2202        struct ieee80211_chanctx_conf *conf;
2203        struct ieee80211_chanctx *ctx;
2204
2205        if (!local->use_chanctx)
2206                return;
2207
2208        mutex_lock(&local->chanctx_mtx);
2209        conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2210                                         lockdep_is_held(&local->chanctx_mtx));
2211        if (conf) {
2212                ctx = container_of(conf, struct ieee80211_chanctx, conf);
2213                drv_assign_vif_chanctx(local, sdata, ctx);
2214        }
2215        mutex_unlock(&local->chanctx_mtx);
2216}
2217
2218static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata)
2219{
2220        struct ieee80211_local *local = sdata->local;
2221        struct sta_info *sta;
2222
2223        /* add STAs back */
2224        mutex_lock(&local->sta_mtx);
2225        list_for_each_entry(sta, &local->sta_list, list) {
2226                enum ieee80211_sta_state state;
2227
2228                if (!sta->uploaded || sta->sdata != sdata)
2229                        continue;
2230
2231                for (state = IEEE80211_STA_NOTEXIST;
2232                     state < sta->sta_state; state++)
2233                        WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
2234                                              state + 1));
2235        }
2236        mutex_unlock(&local->sta_mtx);
2237}
2238
2239static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata)
2240{
2241        struct cfg80211_nan_func *func, **funcs;
2242        int res, id, i = 0;
2243
2244        res = drv_start_nan(sdata->local, sdata,
2245                            &sdata->u.nan.conf);
2246        if (WARN_ON(res))
2247                return res;
2248
2249        funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1,
2250                        sizeof(*funcs),
2251                        GFP_KERNEL);
2252        if (!funcs)
2253                return -ENOMEM;
2254
2255        /* Add all the functions:
2256         * This is a little bit ugly. We need to call a potentially sleeping
2257         * callback for each NAN function, so we can't hold the spinlock.
2258         */
2259        spin_lock_bh(&sdata->u.nan.func_lock);
2260
2261        idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id)
2262                funcs[i++] = func;
2263
2264        spin_unlock_bh(&sdata->u.nan.func_lock);
2265
2266        for (i = 0; funcs[i]; i++) {
2267                res = drv_add_nan_func(sdata->local, sdata, funcs[i]);
2268                if (WARN_ON(res))
2269                        ieee80211_nan_func_terminated(&sdata->vif,
2270                                                      funcs[i]->instance_id,
2271                                                      NL80211_NAN_FUNC_TERM_REASON_ERROR,
2272                                                      GFP_KERNEL);
2273        }
2274
2275        kfree(funcs);
2276
2277        return 0;
2278}
2279
2280int ieee80211_reconfig(struct ieee80211_local *local)
2281{
2282        struct ieee80211_hw *hw = &local->hw;
2283        struct ieee80211_sub_if_data *sdata;
2284        struct ieee80211_chanctx *ctx;
2285        struct sta_info *sta;
2286        int res, i;
2287        bool reconfig_due_to_wowlan = false;
2288        struct ieee80211_sub_if_data *sched_scan_sdata;
2289        struct cfg80211_sched_scan_request *sched_scan_req;
2290        bool sched_scan_stopped = false;
2291        bool suspended = local->suspended;
2292
2293        /* nothing to do if HW shouldn't run */
2294        if (!local->open_count)
2295                goto wake_up;
2296
2297#ifdef CONFIG_PM
2298        if (suspended)
2299                local->resuming = true;
2300
2301        if (local->wowlan) {
2302                /*
2303                 * In the wowlan case, both mac80211 and the device
2304                 * are functional when the resume op is called, so
2305                 * clear local->suspended so the device could operate
2306                 * normally (e.g. pass rx frames).
2307                 */
2308                local->suspended = false;
2309                res = drv_resume(local);
2310                local->wowlan = false;
2311                if (res < 0) {
2312                        local->resuming = false;
2313                        return res;
2314                }
2315                if (res == 0)
2316                        goto wake_up;
2317                WARN_ON(res > 1);
2318                /*
2319                 * res is 1, which means the driver requested
2320                 * to go through a regular reset on wakeup.
2321                 * restore local->suspended in this case.
2322                 */
2323                reconfig_due_to_wowlan = true;
2324                local->suspended = true;
2325        }
2326#endif
2327
2328        /*
2329         * In case of hw_restart during suspend (without wowlan),
2330         * cancel restart work, as we are reconfiguring the device
2331         * anyway.
2332         * Note that restart_work is scheduled on a frozen workqueue,
2333         * so we can't deadlock in this case.
2334         */
2335        if (suspended && local->in_reconfig && !reconfig_due_to_wowlan)
2336                cancel_work_sync(&local->restart_work);
2337
2338        local->started = false;
2339
2340        /*
2341         * Upon resume hardware can sometimes be goofy due to
2342         * various platform / driver / bus issues, so restarting
2343         * the device may at times not work immediately. Propagate
2344         * the error.
2345         */
2346        res = drv_start(local);
2347        if (res) {
2348                if (suspended)
2349                        WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
2350                else
2351                        WARN(1, "Hardware became unavailable during restart.\n");
2352                ieee80211_handle_reconfig_failure(local);
2353                return res;
2354        }
2355
2356        /* setup fragmentation threshold */
2357        drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
2358
2359        /* setup RTS threshold */
2360        drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
2361
2362        /* reset coverage class */
2363        drv_set_coverage_class(local, hw->wiphy->coverage_class);
2364
2365        ieee80211_led_radio(local, true);
2366        ieee80211_mod_tpt_led_trig(local,
2367                                   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
2368
2369        /* add interfaces */
2370        sdata = rtnl_dereference(local->monitor_sdata);
2371        if (sdata) {
2372                /* in HW restart it exists already */
2373                WARN_ON(local->resuming);
2374                res = drv_add_interface(local, sdata);
2375                if (WARN_ON(res)) {
2376                        RCU_INIT_POINTER(local->monitor_sdata, NULL);
2377                        synchronize_net();
2378                        kfree(sdata);
2379                }
2380        }
2381
2382        list_for_each_entry(sdata, &local->interfaces, list) {
2383                if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2384                    sdata->vif.type != NL80211_IFTYPE_MONITOR &&
2385                    ieee80211_sdata_running(sdata)) {
2386                        res = drv_add_interface(local, sdata);
2387                        if (WARN_ON(res))
2388                                break;
2389                }
2390        }
2391
2392        /* If adding any of the interfaces failed above, roll back and
2393         * report failure.
2394         */
2395        if (res) {
2396                list_for_each_entry_continue_reverse(sdata, &local->interfaces,
2397                                                     list)
2398                        if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2399                            sdata->vif.type != NL80211_IFTYPE_MONITOR &&
2400                            ieee80211_sdata_running(sdata))
2401                                drv_remove_interface(local, sdata);
2402                ieee80211_handle_reconfig_failure(local);
2403                return res;
2404        }
2405
2406        /* add channel contexts */
2407        if (local->use_chanctx) {
2408                mutex_lock(&local->chanctx_mtx);
2409                list_for_each_entry(ctx, &local->chanctx_list, list)
2410                        if (ctx->replace_state !=
2411                            IEEE80211_CHANCTX_REPLACES_OTHER)
2412                                WARN_ON(drv_add_chanctx(local, ctx));
2413                mutex_unlock(&local->chanctx_mtx);
2414
2415                sdata = rtnl_dereference(local->monitor_sdata);
2416                if (sdata && ieee80211_sdata_running(sdata))
2417                        ieee80211_assign_chanctx(local, sdata);
2418        }
2419
2420        /* reconfigure hardware */
2421        ieee80211_hw_config(local, ~0);
2422
2423        ieee80211_configure_filter(local);
2424
2425        /* Finally also reconfigure all the BSS information */
2426        list_for_each_entry(sdata, &local->interfaces, list) {
2427                u32 changed;
2428
2429                if (!ieee80211_sdata_running(sdata))
2430                        continue;
2431
2432                ieee80211_assign_chanctx(local, sdata);
2433
2434                switch (sdata->vif.type) {
2435                case NL80211_IFTYPE_AP_VLAN:
2436                case NL80211_IFTYPE_MONITOR:
2437                        break;
2438                case NL80211_IFTYPE_ADHOC:
2439                        if (sdata->vif.bss_conf.ibss_joined)
2440                                WARN_ON(drv_join_ibss(local, sdata));
2441                        fallthrough;
2442                default:
2443                        ieee80211_reconfig_stations(sdata);
2444                        fallthrough;
2445                case NL80211_IFTYPE_AP: /* AP stations are handled later */
2446                        for (i = 0; i < IEEE80211_NUM_ACS; i++)
2447                                drv_conf_tx(local, sdata, i,
2448                                            &sdata->tx_conf[i]);
2449                        break;
2450                }
2451
2452                /* common change flags for all interface types */
2453                changed = BSS_CHANGED_ERP_CTS_PROT |
2454                          BSS_CHANGED_ERP_PREAMBLE |
2455                          BSS_CHANGED_ERP_SLOT |
2456                          BSS_CHANGED_HT |
2457                          BSS_CHANGED_BASIC_RATES |
2458                          BSS_CHANGED_BEACON_INT |
2459                          BSS_CHANGED_BSSID |
2460                          BSS_CHANGED_CQM |
2461                          BSS_CHANGED_QOS |
2462                          BSS_CHANGED_IDLE |
2463                          BSS_CHANGED_TXPOWER |
2464                          BSS_CHANGED_MCAST_RATE;
2465
2466                if (sdata->vif.mu_mimo_owner)
2467                        changed |= BSS_CHANGED_MU_GROUPS;
2468
2469                switch (sdata->vif.type) {
2470                case NL80211_IFTYPE_STATION:
2471                        changed |= BSS_CHANGED_ASSOC |
2472                                   BSS_CHANGED_ARP_FILTER |
2473                                   BSS_CHANGED_PS;
2474
2475                        /* Re-send beacon info report to the driver */
2476                        if (sdata->u.mgd.have_beacon)
2477                                changed |= BSS_CHANGED_BEACON_INFO;
2478
2479                        if (sdata->vif.bss_conf.max_idle_period ||
2480                            sdata->vif.bss_conf.protected_keep_alive)
2481                                changed |= BSS_CHANGED_KEEP_ALIVE;
2482
2483                        sdata_lock(sdata);
2484                        ieee80211_bss_info_change_notify(sdata, changed);
2485                        sdata_unlock(sdata);
2486                        break;
2487                case NL80211_IFTYPE_OCB:
2488                        changed |= BSS_CHANGED_OCB;
2489                        ieee80211_bss_info_change_notify(sdata, changed);
2490                        break;
2491                case NL80211_IFTYPE_ADHOC:
2492                        changed |= BSS_CHANGED_IBSS;
2493                        fallthrough;
2494                case NL80211_IFTYPE_AP:
2495                        changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
2496
2497                        if (sdata->vif.bss_conf.ftm_responder == 1 &&
2498                            wiphy_ext_feature_isset(sdata->local->hw.wiphy,
2499                                        NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
2500                                changed |= BSS_CHANGED_FTM_RESPONDER;
2501
2502                        if (sdata->vif.type == NL80211_IFTYPE_AP) {
2503                                changed |= BSS_CHANGED_AP_PROBE_RESP;
2504
2505                                if (rcu_access_pointer(sdata->u.ap.beacon))
2506                                        drv_start_ap(local, sdata);
2507                        }
2508                        fallthrough;
2509                case NL80211_IFTYPE_MESH_POINT:
2510                        if (sdata->vif.bss_conf.enable_beacon) {
2511                                changed |= BSS_CHANGED_BEACON |
2512                                           BSS_CHANGED_BEACON_ENABLED;
2513                                ieee80211_bss_info_change_notify(sdata, changed);
2514                        }
2515                        break;
2516                case NL80211_IFTYPE_NAN:
2517                        res = ieee80211_reconfig_nan(sdata);
2518                        if (res < 0) {
2519                                ieee80211_handle_reconfig_failure(local);
2520                                return res;
2521                        }
2522                        break;
2523                case NL80211_IFTYPE_AP_VLAN:
2524                case NL80211_IFTYPE_MONITOR:
2525                case NL80211_IFTYPE_P2P_DEVICE:
2526                        /* nothing to do */
2527                        break;
2528                case NL80211_IFTYPE_UNSPECIFIED:
2529                case NUM_NL80211_IFTYPES:
2530                case NL80211_IFTYPE_P2P_CLIENT:
2531                case NL80211_IFTYPE_P2P_GO:
2532                case NL80211_IFTYPE_WDS:
2533                        WARN_ON(1);
2534                        break;
2535                }
2536        }
2537
2538        ieee80211_recalc_ps(local);
2539
2540        /*
2541         * The sta might be in psm against the ap (e.g. because
2542         * this was the state before a hw restart), so we
2543         * explicitly send a null packet in order to make sure
2544         * it'll sync against the ap (and get out of psm).
2545         */
2546        if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
2547                list_for_each_entry(sdata, &local->interfaces, list) {
2548                        if (sdata->vif.type != NL80211_IFTYPE_STATION)
2549                                continue;
2550                        if (!sdata->u.mgd.associated)
2551                                continue;
2552
2553                        ieee80211_send_nullfunc(local, sdata, false);
2554                }
2555        }
2556
2557        /* APs are now beaconing, add back stations */
2558        mutex_lock(&local->sta_mtx);
2559        list_for_each_entry(sta, &local->sta_list, list) {
2560                enum ieee80211_sta_state state;
2561
2562                if (!sta->uploaded)
2563                        continue;
2564
2565                if (sta->sdata->vif.type != NL80211_IFTYPE_AP &&
2566                    sta->sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
2567                        continue;
2568
2569                for (state = IEEE80211_STA_NOTEXIST;
2570                     state < sta->sta_state; state++)
2571                        WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
2572                                              state + 1));
2573        }
2574        mutex_unlock(&local->sta_mtx);
2575
2576        /* add back keys */
2577        list_for_each_entry(sdata, &local->interfaces, list)
2578                ieee80211_reenable_keys(sdata);
2579
2580        /* Reconfigure sched scan if it was interrupted by FW restart */
2581        mutex_lock(&local->mtx);
2582        sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
2583                                                lockdep_is_held(&local->mtx));
2584        sched_scan_req = rcu_dereference_protected(local->sched_scan_req,
2585                                                lockdep_is_held(&local->mtx));
2586        if (sched_scan_sdata && sched_scan_req)
2587                /*
2588                 * Sched scan stopped, but we don't want to report it. Instead,
2589                 * we're trying to reschedule. However, if more than one scan
2590                 * plan was set, we cannot reschedule since we don't know which
2591                 * scan plan was currently running (and some scan plans may have
2592                 * already finished).
2593                 */
2594                if (sched_scan_req->n_scan_plans > 1 ||
2595                    __ieee80211_request_sched_scan_start(sched_scan_sdata,
2596                                                         sched_scan_req)) {
2597                        RCU_INIT_POINTER(local->sched_scan_sdata, NULL);
2598                        RCU_INIT_POINTER(local->sched_scan_req, NULL);
2599                        sched_scan_stopped = true;
2600                }
2601        mutex_unlock(&local->mtx);
2602
2603        if (sched_scan_stopped)
2604                cfg80211_sched_scan_stopped_locked(local->hw.wiphy, 0);
2605
2606 wake_up:
2607
2608        if (local->monitors == local->open_count && local->monitors > 0)
2609                ieee80211_add_virtual_monitor(local);
2610
2611        /*
2612         * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
2613         * sessions can be established after a resume.
2614         *
2615         * Also tear down aggregation sessions since reconfiguring
2616         * them in a hardware restart scenario is not easily done
2617         * right now, and the hardware will have lost information
2618         * about the sessions, but we and the AP still think they
2619         * are active. This is really a workaround though.
2620         */
2621        if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) {
2622                mutex_lock(&local->sta_mtx);
2623
2624                list_for_each_entry(sta, &local->sta_list, list) {
2625                        if (!local->resuming)
2626                                ieee80211_sta_tear_down_BA_sessions(
2627                                                sta, AGG_STOP_LOCAL_REQUEST);
2628                        clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
2629                }
2630
2631                mutex_unlock(&local->sta_mtx);
2632        }
2633
2634        if (local->in_reconfig) {
2635                local->in_reconfig = false;
2636                barrier();
2637
2638                /* Restart deferred ROCs */
2639                mutex_lock(&local->mtx);
2640                ieee80211_start_next_roc(local);
2641                mutex_unlock(&local->mtx);
2642
2643                /* Requeue all works */
2644                list_for_each_entry(sdata, &local->interfaces, list)
2645                        ieee80211_queue_work(&local->hw, &sdata->work);
2646        }
2647
2648        ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
2649                                        IEEE80211_QUEUE_STOP_REASON_SUSPEND,
2650                                        false);
2651
2652        /*
2653         * If this is for hw restart things are still running.
2654         * We may want to change that later, however.
2655         */
2656        if (local->open_count && (!suspended || reconfig_due_to_wowlan))
2657                drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
2658
2659        if (!suspended)
2660                return 0;
2661
2662#ifdef CONFIG_PM
2663        /* first set suspended false, then resuming */
2664        local->suspended = false;
2665        mb();
2666        local->resuming = false;
2667
2668        ieee80211_flush_completed_scan(local, false);
2669
2670        if (local->open_count && !reconfig_due_to_wowlan)
2671                drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND);
2672
2673        list_for_each_entry(sdata, &local->interfaces, list) {
2674                if (!ieee80211_sdata_running(sdata))
2675                        continue;
2676                if (sdata->vif.type == NL80211_IFTYPE_STATION)
2677                        ieee80211_sta_restart(sdata);
2678        }
2679
2680        mod_timer(&local->sta_cleanup, jiffies + 1);
2681#else
2682        WARN_ON(1);
2683#endif
2684
2685        return 0;
2686}
2687
2688void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
2689{
2690        struct ieee80211_sub_if_data *sdata;
2691        struct ieee80211_local *local;
2692        struct ieee80211_key *key;
2693
2694        if (WARN_ON(!vif))
2695                return;
2696
2697        sdata = vif_to_sdata(vif);
2698        local = sdata->local;
2699
2700        if (WARN_ON(!local->resuming))
2701                return;
2702
2703        if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2704                return;
2705
2706        sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
2707
2708        mutex_lock(&local->key_mtx);
2709        list_for_each_entry(key, &sdata->key_list, list)
2710                key->flags |= KEY_FLAG_TAINTED;
2711        mutex_unlock(&local->key_mtx);
2712}
2713EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
2714
2715void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
2716{
2717        struct ieee80211_local *local = sdata->local;
2718        struct ieee80211_chanctx_conf *chanctx_conf;
2719        struct ieee80211_chanctx *chanctx;
2720
2721        mutex_lock(&local->chanctx_mtx);
2722
2723        chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2724                                        lockdep_is_held(&local->chanctx_mtx));
2725
2726        /*
2727         * This function can be called from a work, thus it may be possible
2728         * that the chanctx_conf is removed (due to a disconnection, for
2729         * example).
2730         * So nothing should be done in such case.
2731         */
2732        if (!chanctx_conf)
2733                goto unlock;
2734
2735        chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2736        ieee80211_recalc_smps_chanctx(local, chanctx);
2737 unlock:
2738        mutex_unlock(&local->chanctx_mtx);
2739}
2740
2741void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
2742{
2743        struct ieee80211_local *local = sdata->local;
2744        struct ieee80211_chanctx_conf *chanctx_conf;
2745        struct ieee80211_chanctx *chanctx;
2746
2747        mutex_lock(&local->chanctx_mtx);
2748
2749        chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2750                                        lockdep_is_held(&local->chanctx_mtx));
2751
2752        if (WARN_ON_ONCE(!chanctx_conf))
2753                goto unlock;
2754
2755        chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2756        ieee80211_recalc_chanctx_min_def(local, chanctx);
2757 unlock:
2758        mutex_unlock(&local->chanctx_mtx);
2759}
2760
2761size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
2762{
2763        size_t pos = offset;
2764
2765        while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
2766                pos += 2 + ies[pos + 1];
2767
2768        return pos;
2769}
2770
2771static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
2772                                            int rssi_min_thold,
2773                                            int rssi_max_thold)
2774{
2775        trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
2776
2777        if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2778                return;
2779
2780        /*
2781         * Scale up threshold values before storing it, as the RSSI averaging
2782         * algorithm uses a scaled up value as well. Change this scaling
2783         * factor if the RSSI averaging algorithm changes.
2784         */
2785        sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
2786        sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
2787}
2788
2789void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
2790                                    int rssi_min_thold,
2791                                    int rssi_max_thold)
2792{
2793        struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2794
2795        WARN_ON(rssi_min_thold == rssi_max_thold ||
2796                rssi_min_thold > rssi_max_thold);
2797
2798        _ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
2799                                       rssi_max_thold);
2800}
2801EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
2802
2803void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
2804{
2805        struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2806
2807        _ieee80211_enable_rssi_reports(sdata, 0, 0);
2808}
2809EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
2810
2811u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2812                              u16 cap)
2813{
2814        __le16 tmp;
2815
2816        *pos++ = WLAN_EID_HT_CAPABILITY;
2817        *pos++ = sizeof(struct ieee80211_ht_cap);
2818        memset(pos, 0, sizeof(struct ieee80211_ht_cap));
2819
2820        /* capability flags */
2821        tmp = cpu_to_le16(cap);
2822        memcpy(pos, &tmp, sizeof(u16));
2823        pos += sizeof(u16);
2824
2825        /* AMPDU parameters */
2826        *pos++ = ht_cap->ampdu_factor |
2827                 (ht_cap->ampdu_density <<
2828                        IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
2829
2830        /* MCS set */
2831        memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
2832        pos += sizeof(ht_cap->mcs);
2833
2834        /* extended capabilities */
2835        pos += sizeof(__le16);
2836
2837        /* BF capabilities */
2838        pos += sizeof(__le32);
2839
2840        /* antenna selection */
2841        pos += sizeof(u8);
2842
2843        return pos;
2844}
2845
2846u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2847                               u32 cap)
2848{
2849        __le32 tmp;
2850
2851        *pos++ = WLAN_EID_VHT_CAPABILITY;
2852        *pos++ = sizeof(struct ieee80211_vht_cap);
2853        memset(pos, 0, sizeof(struct ieee80211_vht_cap));
2854
2855        /* capability flags */
2856        tmp = cpu_to_le32(cap);
2857        memcpy(pos, &tmp, sizeof(u32));
2858        pos += sizeof(u32);
2859
2860        /* VHT MCS set */
2861        memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
2862        pos += sizeof(vht_cap->vht_mcs);
2863
2864        return pos;
2865}
2866
2867u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata, u8 iftype)
2868{
2869        const struct ieee80211_sta_he_cap *he_cap;
2870        struct ieee80211_supported_band *sband;
2871        u8 n;
2872
2873        sband = ieee80211_get_sband(sdata);
2874        if (!sband)
2875                return 0;
2876
2877        he_cap = ieee80211_get_he_iftype_cap(sband, iftype);
2878        if (!he_cap)
2879                return 0;
2880
2881        n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
2882        return 2 + 1 +
2883               sizeof(he_cap->he_cap_elem) + n +
2884               ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2885                                     he_cap->he_cap_elem.phy_cap_info);
2886}
2887
2888u8 *ieee80211_ie_build_he_cap(u8 *pos,
2889                              const struct ieee80211_sta_he_cap *he_cap,
2890                              u8 *end)
2891{
2892        u8 n;
2893        u8 ie_len;
2894        u8 *orig_pos = pos;
2895
2896        /* Make sure we have place for the IE */
2897        /*
2898         * TODO: the 1 added is because this temporarily is under the EXTENSION
2899         * IE. Get rid of it when it moves.
2900         */
2901        if (!he_cap)
2902                return orig_pos;
2903
2904        n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
2905        ie_len = 2 + 1 +
2906                 sizeof(he_cap->he_cap_elem) + n +
2907                 ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2908                                       he_cap->he_cap_elem.phy_cap_info);
2909
2910        if ((end - pos) < ie_len)
2911                return orig_pos;
2912
2913        *pos++ = WLAN_EID_EXTENSION;
2914        pos++; /* We'll set the size later below */
2915        *pos++ = WLAN_EID_EXT_HE_CAPABILITY;
2916
2917        /* Fixed data */
2918        memcpy(pos, &he_cap->he_cap_elem, sizeof(he_cap->he_cap_elem));
2919        pos += sizeof(he_cap->he_cap_elem);
2920
2921        memcpy(pos, &he_cap->he_mcs_nss_supp, n);
2922        pos += n;
2923
2924        /* Check if PPE Threshold should be present */
2925        if ((he_cap->he_cap_elem.phy_cap_info[6] &
2926             IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0)
2927                goto end;
2928
2929        /*
2930         * Calculate how many PPET16/PPET8 pairs are to come. Algorithm:
2931         * (NSS_M1 + 1) x (num of 1 bits in RU_INDEX_BITMASK)
2932         */
2933        n = hweight8(he_cap->ppe_thres[0] &
2934                     IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
2935        n *= (1 + ((he_cap->ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) >>
2936                   IEEE80211_PPE_THRES_NSS_POS));
2937
2938        /*
2939         * Each pair is 6 bits, and we need to add the 7 "header" bits to the
2940         * total size.
2941         */
2942        n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7;
2943        n = DIV_ROUND_UP(n, 8);
2944
2945        /* Copy PPE Thresholds */
2946        memcpy(pos, &he_cap->ppe_thres, n);
2947        pos += n;
2948
2949end:
2950        orig_pos[1] = (pos - orig_pos) - 2;
2951        return pos;
2952}
2953
2954void ieee80211_ie_build_he_6ghz_cap(struct ieee80211_sub_if_data *sdata,
2955                                    struct sk_buff *skb)
2956{
2957        struct ieee80211_supported_band *sband;
2958        const struct ieee80211_sband_iftype_data *iftd;
2959        enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif);
2960        u8 *pos;
2961        u16 cap;
2962
2963        if (!cfg80211_any_usable_channels(sdata->local->hw.wiphy,
2964                                          BIT(NL80211_BAND_6GHZ),
2965                                          IEEE80211_CHAN_NO_HE))
2966                return;
2967
2968        sband = sdata->local->hw.wiphy->bands[NL80211_BAND_6GHZ];
2969
2970        iftd = ieee80211_get_sband_iftype_data(sband, iftype);
2971        if (!iftd)
2972                return;
2973
2974        /* Check for device HE 6 GHz capability before adding element */
2975        if (!iftd->he_6ghz_capa.capa)
2976                return;
2977
2978        cap = le16_to_cpu(iftd->he_6ghz_capa.capa);
2979        cap &= ~IEEE80211_HE_6GHZ_CAP_SM_PS;
2980
2981        switch (sdata->smps_mode) {
2982        case IEEE80211_SMPS_AUTOMATIC:
2983        case IEEE80211_SMPS_NUM_MODES:
2984                WARN_ON(1);
2985                fallthrough;
2986        case IEEE80211_SMPS_OFF:
2987                cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED,
2988                                       IEEE80211_HE_6GHZ_CAP_SM_PS);
2989                break;
2990        case IEEE80211_SMPS_STATIC:
2991                cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_STATIC,
2992                                       IEEE80211_HE_6GHZ_CAP_SM_PS);
2993                break;
2994        case IEEE80211_SMPS_DYNAMIC:
2995                cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC,
2996                                       IEEE80211_HE_6GHZ_CAP_SM_PS);
2997                break;
2998        }
2999
3000        pos = skb_put(skb, 2 + 1 + sizeof(cap));
3001        ieee80211_write_he_6ghz_cap(pos, cpu_to_le16(cap),
3002                                    pos + 2 + 1 + sizeof(cap));
3003}
3004
3005u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
3006                               const struct cfg80211_chan_def *chandef,
3007                               u16 prot_mode, bool rifs_mode)
3008{
3009        struct ieee80211_ht_operation *ht_oper;
3010        /* Build HT Information */
3011        *pos++ = WLAN_EID_HT_OPERATION;
3012        *pos++ = sizeof(struct ieee80211_ht_operation);
3013        ht_oper = (struct ieee80211_ht_operation *)pos;
3014        ht_oper->primary_chan = ieee80211_frequency_to_channel(
3015                                        chandef->chan->center_freq);
3016        switch (chandef->width) {
3017        case NL80211_CHAN_WIDTH_160:
3018        case NL80211_CHAN_WIDTH_80P80:
3019        case NL80211_CHAN_WIDTH_80:
3020        case NL80211_CHAN_WIDTH_40:
3021                if (chandef->center_freq1 > chandef->chan->center_freq)
3022                        ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
3023                else
3024                        ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
3025                break;
3026        default:
3027                ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
3028                break;
3029        }
3030        if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
3031            chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
3032            chandef->width != NL80211_CHAN_WIDTH_20)
3033                ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
3034
3035        if (rifs_mode)
3036                ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
3037
3038        ht_oper->operation_mode = cpu_to_le16(prot_mode);
3039        ht_oper->stbc_param = 0x0000;
3040
3041        /* It seems that Basic MCS set and Supported MCS set
3042           are identical for the first 10 bytes */
3043        memset(&ht_oper->basic_set, 0, 16);
3044        memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
3045
3046        return pos + sizeof(struct ieee80211_ht_operation);
3047}
3048
3049void ieee80211_ie_build_wide_bw_cs(u8 *pos,
3050                                   const struct cfg80211_chan_def *chandef)
3051{
3052        *pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH;       /* EID */
3053        *pos++ = 3;                                     /* IE length */
3054        /* New channel width */
3055        switch (chandef->width) {
3056        case NL80211_CHAN_WIDTH_80:
3057                *pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ;
3058                break;
3059        case NL80211_CHAN_WIDTH_160:
3060                *pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ;
3061                break;
3062        case NL80211_CHAN_WIDTH_80P80:
3063                *pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ;
3064                break;
3065        default:
3066                *pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT;
3067        }
3068
3069        /* new center frequency segment 0 */
3070        *pos++ = ieee80211_frequency_to_channel(chandef->center_freq1);
3071        /* new center frequency segment 1 */
3072        if (chandef->center_freq2)
3073                *pos++ = ieee80211_frequency_to_channel(chandef->center_freq2);
3074        else
3075                *pos++ = 0;
3076}
3077
3078u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
3079                                const struct cfg80211_chan_def *chandef)
3080{
3081        struct ieee80211_vht_operation *vht_oper;
3082
3083        *pos++ = WLAN_EID_VHT_OPERATION;
3084        *pos++ = sizeof(struct ieee80211_vht_operation);
3085        vht_oper = (struct ieee80211_vht_operation *)pos;
3086        vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel(
3087                                                        chandef->center_freq1);
3088        if (chandef->center_freq2)
3089                vht_oper->center_freq_seg1_idx =
3090                        ieee80211_frequency_to_channel(chandef->center_freq2);
3091        else
3092                vht_oper->center_freq_seg1_idx = 0x00;
3093
3094        switch (chandef->width) {
3095        case NL80211_CHAN_WIDTH_160:
3096                /*
3097                 * Convert 160 MHz channel width to new style as interop
3098                 * workaround.
3099                 */
3100                vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
3101                vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx;
3102                if (chandef->chan->center_freq < chandef->center_freq1)
3103                        vht_oper->center_freq_seg0_idx -= 8;
3104                else
3105                        vht_oper->center_freq_seg0_idx += 8;
3106                break;
3107        case NL80211_CHAN_WIDTH_80P80:
3108                /*
3109                 * Convert 80+80 MHz channel width to new style as interop
3110                 * workaround.
3111                 */
3112                vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
3113                break;
3114        case NL80211_CHAN_WIDTH_80:
3115                vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
3116                break;
3117        default:
3118                vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT;
3119                break;
3120        }
3121
3122        /* don't require special VHT peer rates */
3123        vht_oper->basic_mcs_set = cpu_to_le16(0xffff);
3124
3125        return pos + sizeof(struct ieee80211_vht_operation);
3126}
3127
3128u8 *ieee80211_ie_build_he_oper(u8 *pos, struct cfg80211_chan_def *chandef)
3129{
3130        struct ieee80211_he_operation *he_oper;
3131        struct ieee80211_he_6ghz_oper *he_6ghz_op;
3132        u32 he_oper_params;
3133        u8 ie_len = 1 + sizeof(struct ieee80211_he_operation);
3134
3135        if (chandef->chan->band == NL80211_BAND_6GHZ)
3136                ie_len += sizeof(struct ieee80211_he_6ghz_oper);
3137
3138        *pos++ = WLAN_EID_EXTENSION;
3139        *pos++ = ie_len;
3140        *pos++ = WLAN_EID_EXT_HE_OPERATION;
3141
3142        he_oper_params = 0;
3143        he_oper_params |= u32_encode_bits(1023, /* disabled */
3144                                IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK);
3145        he_oper_params |= u32_encode_bits(1,
3146                                IEEE80211_HE_OPERATION_ER_SU_DISABLE);
3147        he_oper_params |= u32_encode_bits(1,
3148                                IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED);
3149        if (chandef->chan->band == NL80211_BAND_6GHZ)
3150                he_oper_params |= u32_encode_bits(1,
3151                                IEEE80211_HE_OPERATION_6GHZ_OP_INFO);
3152
3153        he_oper = (struct ieee80211_he_operation *)pos;
3154        he_oper->he_oper_params = cpu_to_le32(he_oper_params);
3155
3156        /* don't require special HE peer rates */
3157        he_oper->he_mcs_nss_set = cpu_to_le16(0xffff);
3158        pos += sizeof(struct ieee80211_he_operation);
3159
3160        if (chandef->chan->band != NL80211_BAND_6GHZ)
3161                goto out;
3162
3163        /* TODO add VHT operational */
3164        he_6ghz_op = (struct ieee80211_he_6ghz_oper *)pos;
3165        he_6ghz_op->minrate = 6; /* 6 Mbps */
3166        he_6ghz_op->primary =
3167                ieee80211_frequency_to_channel(chandef->chan->center_freq);
3168        he_6ghz_op->ccfs0 =
3169                ieee80211_frequency_to_channel(chandef->center_freq1);
3170        if (chandef->center_freq2)
3171                he_6ghz_op->ccfs1 =
3172                        ieee80211_frequency_to_channel(chandef->center_freq2);
3173        else
3174                he_6ghz_op->ccfs1 = 0;
3175
3176        switch (chandef->width) {
3177        case NL80211_CHAN_WIDTH_160:
3178                /* Convert 160 MHz channel width to new style as interop
3179                 * workaround.
3180                 */
3181                he_6ghz_op->control =
3182                        IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
3183                he_6ghz_op->ccfs1 = he_6ghz_op->ccfs0;
3184                if (chandef->chan->center_freq < chandef->center_freq1)
3185                        he_6ghz_op->ccfs0 -= 8;
3186                else
3187                        he_6ghz_op->ccfs0 += 8;
3188                fallthrough;
3189        case NL80211_CHAN_WIDTH_80P80:
3190                he_6ghz_op->control =
3191                        IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
3192                break;
3193        case NL80211_CHAN_WIDTH_80:
3194                he_6ghz_op->control =
3195                        IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ;
3196                break;
3197        case NL80211_CHAN_WIDTH_40:
3198                he_6ghz_op->control =
3199                        IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ;
3200                break;
3201        default:
3202                he_6ghz_op->control =
3203                        IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ;
3204                break;
3205        }
3206
3207        pos += sizeof(struct ieee80211_he_6ghz_oper);
3208
3209out:
3210        return pos;
3211}
3212
3213bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
3214                               struct cfg80211_chan_def *chandef)
3215{
3216        enum nl80211_channel_type channel_type;
3217
3218        if (!ht_oper)
3219                return false;
3220
3221        switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
3222        case IEEE80211_HT_PARAM_CHA_SEC_NONE:
3223                channel_type = NL80211_CHAN_HT20;
3224                break;
3225        case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
3226                channel_type = NL80211_CHAN_HT40PLUS;
3227                break;
3228        case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
3229                channel_type = NL80211_CHAN_HT40MINUS;
3230                break;
3231        default:
3232                channel_type = NL80211_CHAN_NO_HT;
3233                return false;
3234        }
3235
3236        cfg80211_chandef_create(chandef, chandef->chan, channel_type);
3237        return true;
3238}
3239
3240bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info,
3241                                const struct ieee80211_vht_operation *oper,
3242                                const struct ieee80211_ht_operation *htop,
3243                                struct cfg80211_chan_def *chandef)
3244{
3245        struct cfg80211_chan_def new = *chandef;
3246        int cf0, cf1;
3247        int ccfs0, ccfs1, ccfs2;
3248        int ccf0, ccf1;
3249        u32 vht_cap;
3250        bool support_80_80 = false;
3251        bool support_160 = false;
3252        u8 ext_nss_bw_supp = u32_get_bits(vht_cap_info,
3253                                          IEEE80211_VHT_CAP_EXT_NSS_BW_MASK);
3254        u8 supp_chwidth = u32_get_bits(vht_cap_info,
3255                                       IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK);
3256
3257        if (!oper || !htop)
3258                return false;
3259
3260        vht_cap = hw->wiphy->bands[chandef->chan->band]->vht_cap.cap;
3261        support_160 = (vht_cap & (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK |
3262                                  IEEE80211_VHT_CAP_EXT_NSS_BW_MASK));
3263        support_80_80 = ((vht_cap &
3264                         IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
3265                        (vht_cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
3266                         vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
3267                        ((vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) >>
3268                                    IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT > 1));
3269        ccfs0 = oper->center_freq_seg0_idx;
3270        ccfs1 = oper->center_freq_seg1_idx;
3271        ccfs2 = (le16_to_cpu(htop->operation_mode) &
3272                                IEEE80211_HT_OP_MODE_CCFS2_MASK)
3273                        >> IEEE80211_HT_OP_MODE_CCFS2_SHIFT;
3274
3275        ccf0 = ccfs0;
3276
3277        /* if not supported, parse as though we didn't understand it */
3278        if (!ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW))
3279                ext_nss_bw_supp = 0;
3280
3281        /*
3282         * Cf. IEEE 802.11 Table 9-250
3283         *
3284         * We really just consider that because it's inefficient to connect
3285         * at a higher bandwidth than we'll actually be able to use.
3286         */
3287        switch ((supp_chwidth << 4) | ext_nss_bw_supp) {
3288        default:
3289        case 0x00:
3290                ccf1 = 0;
3291                support_160 = false;
3292                support_80_80 = false;
3293                break;
3294        case 0x01:
3295                support_80_80 = false;
3296                fallthrough;
3297        case 0x02:
3298        case 0x03:
3299                ccf1 = ccfs2;
3300                break;
3301        case 0x10:
3302                ccf1 = ccfs1;
3303                break;
3304        case 0x11:
3305        case 0x12:
3306                if (!ccfs1)
3307                        ccf1 = ccfs2;
3308                else
3309                        ccf1 = ccfs1;
3310                break;
3311        case 0x13:
3312        case 0x20:
3313        case 0x23:
3314                ccf1 = ccfs1;
3315                break;
3316        }
3317
3318        cf0 = ieee80211_channel_to_frequency(ccf0, chandef->chan->band);
3319        cf1 = ieee80211_channel_to_frequency(ccf1, chandef->chan->band);
3320
3321        switch (oper->chan_width) {
3322        case IEEE80211_VHT_CHANWIDTH_USE_HT:
3323                /* just use HT information directly */
3324                break;
3325        case IEEE80211_VHT_CHANWIDTH_80MHZ:
3326                new.width = NL80211_CHAN_WIDTH_80;
3327                new.center_freq1 = cf0;
3328                /* If needed, adjust based on the newer interop workaround. */
3329                if (ccf1) {
3330                        unsigned int diff;
3331
3332                        diff = abs(ccf1 - ccf0);
3333                        if ((diff == 8) && support_160) {
3334                                new.width = NL80211_CHAN_WIDTH_160;
3335                                new.center_freq1 = cf1;
3336                        } else if ((diff > 8) && support_80_80) {
3337                                new.width = NL80211_CHAN_WIDTH_80P80;
3338                                new.center_freq2 = cf1;
3339                        }
3340                }
3341                break;
3342        case IEEE80211_VHT_CHANWIDTH_160MHZ:
3343                /* deprecated encoding */
3344                new.width = NL80211_CHAN_WIDTH_160;
3345                new.center_freq1 = cf0;
3346                break;
3347        case IEEE80211_VHT_CHANWIDTH_80P80MHZ:
3348                /* deprecated encoding */
3349                new.width = NL80211_CHAN_WIDTH_80P80;
3350                new.center_freq1 = cf0;
3351                new.center_freq2 = cf1;
3352                break;
3353        default:
3354                return false;
3355        }
3356
3357        if (!cfg80211_chandef_valid(&new))
3358                return false;
3359
3360        *chandef = new;
3361        return true;
3362}
3363
3364bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_sub_if_data *sdata,
3365                                    const struct ieee80211_he_operation *he_oper,
3366                                    struct cfg80211_chan_def *chandef)
3367{
3368        struct ieee80211_local *local = sdata->local;
3369        struct ieee80211_supported_band *sband;
3370        enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif);
3371        const struct ieee80211_sta_he_cap *he_cap;
3372        struct cfg80211_chan_def he_chandef = *chandef;
3373        const struct ieee80211_he_6ghz_oper *he_6ghz_oper;
3374        bool support_80_80, support_160;
3375        u8 he_phy_cap;
3376        u32 freq;
3377
3378        if (chandef->chan->band != NL80211_BAND_6GHZ)
3379                return true;
3380
3381        sband = local->hw.wiphy->bands[NL80211_BAND_6GHZ];
3382
3383        he_cap = ieee80211_get_he_iftype_cap(sband, iftype);
3384        if (!he_cap) {
3385                sdata_info(sdata, "Missing iftype sband data/HE cap");
3386                return false;
3387        }
3388
3389        he_phy_cap = he_cap->he_cap_elem.phy_cap_info[0];
3390        support_160 =
3391                he_phy_cap &
3392                IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G;
3393        support_80_80 =
3394                he_phy_cap &
3395                IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G;
3396
3397        if (!he_oper) {
3398                sdata_info(sdata,
3399                           "HE is not advertised on (on %d MHz), expect issues\n",
3400                           chandef->chan->center_freq);
3401                return false;
3402        }
3403
3404        he_6ghz_oper = ieee80211_he_6ghz_oper(he_oper);
3405
3406        if (!he_6ghz_oper) {
3407                sdata_info(sdata,
3408                           "HE 6GHz operation missing (on %d MHz), expect issues\n",
3409                           chandef->chan->center_freq);
3410                return false;
3411        }
3412
3413        freq = ieee80211_channel_to_frequency(he_6ghz_oper->primary,
3414                                              NL80211_BAND_6GHZ);
3415        he_chandef.chan = ieee80211_get_channel(sdata->local->hw.wiphy, freq);
3416
3417        switch (u8_get_bits(he_6ghz_oper->control,
3418                            IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH)) {
3419        case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ:
3420                he_chandef.width = NL80211_CHAN_WIDTH_20;
3421                break;
3422        case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ:
3423                he_chandef.width = NL80211_CHAN_WIDTH_40;
3424                break;
3425        case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ:
3426                he_chandef.width = NL80211_CHAN_WIDTH_80;
3427                break;
3428        case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ:
3429                he_chandef.width = NL80211_CHAN_WIDTH_80;
3430                if (!he_6ghz_oper->ccfs1)
3431                        break;
3432                if (abs(he_6ghz_oper->ccfs1 - he_6ghz_oper->ccfs0) == 8) {
3433                        if (support_160)
3434                                he_chandef.width = NL80211_CHAN_WIDTH_160;
3435                } else {
3436                        if (support_80_80)
3437                                he_chandef.width = NL80211_CHAN_WIDTH_80P80;
3438                }
3439                break;
3440        }
3441
3442        if (he_chandef.width == NL80211_CHAN_WIDTH_160) {
3443                he_chandef.center_freq1 =
3444                        ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3445                                                       NL80211_BAND_6GHZ);
3446        } else {
3447                he_chandef.center_freq1 =
3448                        ieee80211_channel_to_frequency(he_6ghz_oper->ccfs0,
3449                                                       NL80211_BAND_6GHZ);
3450                if (support_80_80 || support_160)
3451                        he_chandef.center_freq2 =
3452                                ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3453                                                               NL80211_BAND_6GHZ);
3454        }
3455
3456        if (!cfg80211_chandef_valid(&he_chandef)) {
3457                sdata_info(sdata,
3458                           "HE 6GHz operation resulted in invalid chandef: %d MHz/%d/%d MHz/%d MHz\n",
3459                           he_chandef.chan ? he_chandef.chan->center_freq : 0,
3460                           he_chandef.width,
3461                           he_chandef.center_freq1,
3462                           he_chandef.center_freq2);
3463                return false;
3464        }
3465
3466        *chandef = he_chandef;
3467
3468        return true;
3469}
3470
3471bool ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie *oper,
3472                                struct cfg80211_chan_def *chandef)
3473{
3474        u32 oper_freq;
3475
3476        if (!oper)
3477                return false;
3478
3479        switch (FIELD_GET(S1G_OPER_CH_WIDTH_OPER, oper->ch_width)) {
3480        case IEEE80211_S1G_CHANWIDTH_1MHZ:
3481                chandef->width = NL80211_CHAN_WIDTH_1;
3482                break;
3483        case IEEE80211_S1G_CHANWIDTH_2MHZ:
3484                chandef->width = NL80211_CHAN_WIDTH_2;
3485                break;
3486        case IEEE80211_S1G_CHANWIDTH_4MHZ:
3487                chandef->width = NL80211_CHAN_WIDTH_4;
3488                break;
3489        case IEEE80211_S1G_CHANWIDTH_8MHZ:
3490                chandef->width = NL80211_CHAN_WIDTH_8;
3491                break;
3492        case IEEE80211_S1G_CHANWIDTH_16MHZ:
3493                chandef->width = NL80211_CHAN_WIDTH_16;
3494                break;
3495        default:
3496                return false;
3497        }
3498
3499        oper_freq = ieee80211_channel_to_freq_khz(oper->oper_ch,
3500                                                  NL80211_BAND_S1GHZ);
3501        chandef->center_freq1 = KHZ_TO_MHZ(oper_freq);
3502        chandef->freq1_offset = oper_freq % 1000;
3503
3504        return true;
3505}
3506
3507int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
3508                             const struct ieee80211_supported_band *sband,
3509                             const u8 *srates, int srates_len, u32 *rates)
3510{
3511        u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
3512        int shift = ieee80211_chandef_get_shift(chandef);
3513        struct ieee80211_rate *br;
3514        int brate, rate, i, j, count = 0;
3515
3516        *rates = 0;
3517
3518        for (i = 0; i < srates_len; i++) {
3519                rate = srates[i] & 0x7f;
3520
3521                for (j = 0; j < sband->n_bitrates; j++) {
3522                        br = &sband->bitrates[j];
3523                        if ((rate_flags & br->flags) != rate_flags)
3524                                continue;
3525
3526                        brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
3527                        if (brate == rate) {
3528                                *rates |= BIT(j);
3529                                count++;
3530                                break;
3531                        }
3532                }
3533        }
3534        return count;
3535}
3536
3537int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
3538                            struct sk_buff *skb, bool need_basic,
3539                            enum nl80211_band band)
3540{
3541        struct ieee80211_local *local = sdata->local;
3542        struct ieee80211_supported_band *sband;
3543        int rate, shift;
3544        u8 i, rates, *pos;
3545        u32 basic_rates = sdata->vif.bss_conf.basic_rates;
3546        u32 rate_flags;
3547
3548        shift = ieee80211_vif_get_shift(&sdata->vif);
3549        rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
3550        sband = local->hw.wiphy->bands[band];
3551        rates = 0;
3552        for (i = 0; i < sband->n_bitrates; i++) {
3553                if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3554                        continue;
3555                rates++;
3556        }
3557        if (rates > 8)
3558                rates = 8;
3559
3560        if (skb_tailroom(skb) < rates + 2)
3561                return -ENOMEM;
3562
3563        pos = skb_put(skb, rates + 2);
3564        *pos++ = WLAN_EID_SUPP_RATES;
3565        *pos++ = rates;
3566        for (i = 0; i < rates; i++) {
3567                u8 basic = 0;
3568                if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3569                        continue;
3570
3571                if (need_basic && basic_rates & BIT(i))
3572                        basic = 0x80;
3573                rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
3574                                    5 * (1 << shift));
3575                *pos++ = basic | (u8) rate;
3576        }
3577
3578        return 0;
3579}
3580
3581int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
3582                                struct sk_buff *skb, bool need_basic,
3583                                enum nl80211_band band)
3584{
3585        struct ieee80211_local *local = sdata->local;
3586        struct ieee80211_supported_band *sband;
3587        int rate, shift;
3588        u8 i, exrates, *pos;
3589        u32 basic_rates = sdata->vif.bss_conf.basic_rates;
3590        u32 rate_flags;
3591
3592        rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
3593        shift = ieee80211_vif_get_shift(&sdata->vif);
3594
3595        sband = local->hw.wiphy->bands[band];
3596        exrates = 0;
3597        for (i = 0; i < sband->n_bitrates; i++) {
3598                if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3599                        continue;
3600                exrates++;
3601        }
3602
3603        if (exrates > 8)
3604                exrates -= 8;
3605        else
3606                exrates = 0;
3607
3608        if (skb_tailroom(skb) < exrates + 2)
3609                return -ENOMEM;
3610
3611        if (exrates) {
3612                pos = skb_put(skb, exrates + 2);
3613                *pos++ = WLAN_EID_EXT_SUPP_RATES;
3614                *pos++ = exrates;
3615                for (i = 8; i < sband->n_bitrates; i++) {
3616                        u8 basic = 0;
3617                        if ((rate_flags & sband->bitrates[i].flags)
3618                            != rate_flags)
3619                                continue;
3620                        if (need_basic && basic_rates & BIT(i))
3621                                basic = 0x80;
3622                        rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
3623                                            5 * (1 << shift));
3624                        *pos++ = basic | (u8) rate;
3625                }
3626        }
3627        return 0;
3628}
3629
3630int ieee80211_ave_rssi(struct ieee80211_vif *vif)
3631{
3632        struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3633        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3634
3635        if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
3636                /* non-managed type inferfaces */
3637                return 0;
3638        }
3639        return -ewma_beacon_signal_read(&ifmgd->ave_beacon_signal);
3640}
3641EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
3642
3643u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
3644{
3645        if (!mcs)
3646                return 1;
3647
3648        /* TODO: consider rx_highest */
3649
3650        if (mcs->rx_mask[3])
3651                return 4;
3652        if (mcs->rx_mask[2])
3653                return 3;
3654        if (mcs->rx_mask[1])
3655                return 2;
3656        return 1;
3657}
3658
3659/**
3660 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
3661 * @local: mac80211 hw info struct
3662 * @status: RX status
3663 * @mpdu_len: total MPDU length (including FCS)
3664 * @mpdu_offset: offset into MPDU to calculate timestamp at
3665 *
3666 * This function calculates the RX timestamp at the given MPDU offset, taking
3667 * into account what the RX timestamp was. An offset of 0 will just normalize
3668 * the timestamp to TSF at beginning of MPDU reception.
3669 */
3670u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
3671                                     struct ieee80211_rx_status *status,
3672                                     unsigned int mpdu_len,
3673                                     unsigned int mpdu_offset)
3674{
3675        u64 ts = status->mactime;
3676        struct rate_info ri;
3677        u16 rate;
3678        u8 n_ltf;
3679
3680        if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
3681                return 0;
3682
3683        memset(&ri, 0, sizeof(ri));
3684
3685        ri.bw = status->bw;
3686
3687        /* Fill cfg80211 rate info */
3688        switch (status->encoding) {
3689        case RX_ENC_HE:
3690                ri.flags |= RATE_INFO_FLAGS_HE_MCS;
3691                ri.mcs = status->rate_idx;
3692                ri.nss = status->nss;
3693                ri.he_ru_alloc = status->he_ru;
3694                if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3695                        ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3696
3697                /*
3698                 * See P802.11ax_D6.0, section 27.3.4 for
3699                 * VHT PPDU format.
3700                 */
3701                if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3702                        mpdu_offset += 2;
3703                        ts += 36;
3704
3705                        /*
3706                         * TODO:
3707                         * For HE MU PPDU, add the HE-SIG-B.
3708                         * For HE ER PPDU, add 8us for the HE-SIG-A.
3709                         * For HE TB PPDU, add 4us for the HE-STF.
3710                         * Add the HE-LTF durations - variable.
3711                         */
3712                }
3713
3714                break;
3715        case RX_ENC_HT:
3716                ri.mcs = status->rate_idx;
3717                ri.flags |= RATE_INFO_FLAGS_MCS;
3718                if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3719                        ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3720
3721                /*
3722                 * See P802.11REVmd_D3.0, section 19.3.2 for
3723                 * HT PPDU format.
3724                 */
3725                if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3726                        mpdu_offset += 2;
3727                        if (status->enc_flags & RX_ENC_FLAG_HT_GF)
3728                                ts += 24;
3729                        else
3730                                ts += 32;
3731
3732                        /*
3733                         * Add Data HT-LTFs per streams
3734                         * TODO: add Extension HT-LTFs, 4us per LTF
3735                         */
3736                        n_ltf = ((ri.mcs >> 3) & 3) + 1;
3737                        n_ltf = n_ltf == 3 ? 4 : n_ltf;
3738                        ts += n_ltf * 4;
3739                }
3740
3741                break;
3742        case RX_ENC_VHT:
3743                ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
3744                ri.mcs = status->rate_idx;
3745                ri.nss = status->nss;
3746                if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3747                        ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3748
3749                /*
3750                 * See P802.11REVmd_D3.0, section 21.3.2 for
3751                 * VHT PPDU format.
3752                 */
3753                if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3754                        mpdu_offset += 2;
3755                        ts += 36;
3756
3757                        /*
3758                         * Add VHT-LTFs per streams
3759                         */
3760                        n_ltf = (ri.nss != 1) && (ri.nss % 2) ?
3761                                ri.nss + 1 : ri.nss;
3762                        ts += 4 * n_ltf;
3763                }
3764
3765                break;
3766        default:
3767                WARN_ON(1);
3768                fallthrough;
3769        case RX_ENC_LEGACY: {
3770                struct ieee80211_supported_band *sband;
3771                int shift = 0;
3772                int bitrate;
3773
3774                switch (status->bw) {
3775                case RATE_INFO_BW_10:
3776                        shift = 1;
3777                        break;
3778                case RATE_INFO_BW_5:
3779                        shift = 2;
3780                        break;
3781                }
3782
3783                sband = local->hw.wiphy->bands[status->band];
3784                bitrate = sband->bitrates[status->rate_idx].bitrate;
3785                ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
3786
3787                if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3788                        if (status->band == NL80211_BAND_5GHZ) {
3789                                ts += 20 << shift;
3790                                mpdu_offset += 2;
3791                        } else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) {
3792                                ts += 96;
3793                        } else {
3794                                ts += 192;
3795                        }
3796                }
3797                break;
3798                }
3799        }
3800
3801        rate = cfg80211_calculate_bitrate(&ri);
3802        if (WARN_ONCE(!rate,
3803                      "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
3804                      (unsigned long long)status->flag, status->rate_idx,
3805                      status->nss))
3806                return 0;
3807
3808        /* rewind from end of MPDU */
3809        if (status->flag & RX_FLAG_MACTIME_END)
3810                ts -= mpdu_len * 8 * 10 / rate;
3811
3812        ts += mpdu_offset * 8 * 10 / rate;
3813
3814        return ts;
3815}
3816
3817void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
3818{
3819        struct ieee80211_sub_if_data *sdata;
3820        struct cfg80211_chan_def chandef;
3821
3822        /* for interface list, to avoid linking iflist_mtx and chanctx_mtx */
3823        lockdep_assert_wiphy(local->hw.wiphy);
3824
3825        mutex_lock(&local->mtx);
3826        list_for_each_entry(sdata, &local->interfaces, list) {
3827                /* it might be waiting for the local->mtx, but then
3828                 * by the time it gets it, sdata->wdev.cac_started
3829                 * will no longer be true
3830                 */
3831                cancel_delayed_work(&sdata->dfs_cac_timer_work);
3832
3833                if (sdata->wdev.cac_started) {
3834                        chandef = sdata->vif.bss_conf.chandef;
3835                        ieee80211_vif_release_channel(sdata);
3836                        cfg80211_cac_event(sdata->dev,
3837                                           &chandef,
3838                                           NL80211_RADAR_CAC_ABORTED,
3839                                           GFP_KERNEL);
3840                }
3841        }
3842        mutex_unlock(&local->mtx);
3843}
3844
3845void ieee80211_dfs_radar_detected_work(struct work_struct *work)
3846{
3847        struct ieee80211_local *local =
3848                container_of(work, struct ieee80211_local, radar_detected_work);
3849        struct cfg80211_chan_def chandef = local->hw.conf.chandef;
3850        struct ieee80211_chanctx *ctx;
3851        int num_chanctx = 0;
3852
3853        mutex_lock(&local->chanctx_mtx);
3854        list_for_each_entry(ctx, &local->chanctx_list, list) {
3855                if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
3856                        continue;
3857
3858                num_chanctx++;
3859                chandef = ctx->conf.def;
3860        }
3861        mutex_unlock(&local->chanctx_mtx);
3862
3863        wiphy_lock(local->hw.wiphy);
3864        ieee80211_dfs_cac_cancel(local);
3865        wiphy_unlock(local->hw.wiphy);
3866
3867        if (num_chanctx > 1)
3868                /* XXX: multi-channel is not supported yet */
3869                WARN_ON(1);
3870        else
3871                cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
3872}
3873
3874void ieee80211_radar_detected(struct ieee80211_hw *hw)
3875{
3876        struct ieee80211_local *local = hw_to_local(hw);
3877
3878        trace_api_radar_detected(local);
3879
3880        schedule_work(&local->radar_detected_work);
3881}
3882EXPORT_SYMBOL(ieee80211_radar_detected);
3883
3884u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
3885{
3886        u32 ret;
3887        int tmp;
3888
3889        switch (c->width) {
3890        case NL80211_CHAN_WIDTH_20:
3891                c->width = NL80211_CHAN_WIDTH_20_NOHT;
3892                ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
3893                break;
3894        case NL80211_CHAN_WIDTH_40:
3895                c->width = NL80211_CHAN_WIDTH_20;
3896                c->center_freq1 = c->chan->center_freq;
3897                ret = IEEE80211_STA_DISABLE_40MHZ |
3898                      IEEE80211_STA_DISABLE_VHT;
3899                break;
3900        case NL80211_CHAN_WIDTH_80:
3901                tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
3902                /* n_P40 */
3903                tmp /= 2;
3904                /* freq_P40 */
3905                c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
3906                c->width = NL80211_CHAN_WIDTH_40;
3907                ret = IEEE80211_STA_DISABLE_VHT;
3908                break;
3909        case NL80211_CHAN_WIDTH_80P80:
3910                c->center_freq2 = 0;
3911                c->width = NL80211_CHAN_WIDTH_80;
3912                ret = IEEE80211_STA_DISABLE_80P80MHZ |
3913                      IEEE80211_STA_DISABLE_160MHZ;
3914                break;
3915        case NL80211_CHAN_WIDTH_160:
3916                /* n_P20 */
3917                tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
3918                /* n_P80 */
3919                tmp /= 4;
3920                c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
3921                c->width = NL80211_CHAN_WIDTH_80;
3922                ret = IEEE80211_STA_DISABLE_80P80MHZ |
3923                      IEEE80211_STA_DISABLE_160MHZ;
3924                break;
3925        default:
3926        case NL80211_CHAN_WIDTH_20_NOHT:
3927                WARN_ON_ONCE(1);
3928                c->width = NL80211_CHAN_WIDTH_20_NOHT;
3929                ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
3930                break;
3931        case NL80211_CHAN_WIDTH_1:
3932        case NL80211_CHAN_WIDTH_2:
3933        case NL80211_CHAN_WIDTH_4:
3934        case NL80211_CHAN_WIDTH_8:
3935        case NL80211_CHAN_WIDTH_16:
3936        case NL80211_CHAN_WIDTH_5:
3937        case NL80211_CHAN_WIDTH_10:
3938                WARN_ON_ONCE(1);
3939                /* keep c->width */
3940                ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
3941                break;
3942        }
3943
3944        WARN_ON_ONCE(!cfg80211_chandef_valid(c));
3945
3946        return ret;
3947}
3948
3949/*
3950 * Returns true if smps_mode_new is strictly more restrictive than
3951 * smps_mode_old.
3952 */
3953bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
3954                                   enum ieee80211_smps_mode smps_mode_new)
3955{
3956        if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC ||
3957                         smps_mode_new == IEEE80211_SMPS_AUTOMATIC))
3958                return false;
3959
3960        switch (smps_mode_old) {
3961        case IEEE80211_SMPS_STATIC:
3962                return false;
3963        case IEEE80211_SMPS_DYNAMIC:
3964                return smps_mode_new == IEEE80211_SMPS_STATIC;
3965        case IEEE80211_SMPS_OFF:
3966                return smps_mode_new != IEEE80211_SMPS_OFF;
3967        default:
3968                WARN_ON(1);
3969        }
3970
3971        return false;
3972}
3973
3974int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
3975                              struct cfg80211_csa_settings *csa_settings)
3976{
3977        struct sk_buff *skb;
3978        struct ieee80211_mgmt *mgmt;
3979        struct ieee80211_local *local = sdata->local;
3980        int freq;
3981        int hdr_len = offsetofend(struct ieee80211_mgmt,
3982                                  u.action.u.chan_switch);
3983        u8 *pos;
3984
3985        if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3986            sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
3987                return -EOPNOTSUPP;
3988
3989        skb = dev_alloc_skb(local->tx_headroom + hdr_len +
3990                            5 + /* channel switch announcement element */
3991                            3 + /* secondary channel offset element */
3992                            5 + /* wide bandwidth channel switch announcement */
3993                            8); /* mesh channel switch parameters element */
3994        if (!skb)
3995                return -ENOMEM;
3996
3997        skb_reserve(skb, local->tx_headroom);
3998        mgmt = skb_put_zero(skb, hdr_len);
3999        mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
4000                                          IEEE80211_STYPE_ACTION);
4001
4002        eth_broadcast_addr(mgmt->da);
4003        memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
4004        if (ieee80211_vif_is_mesh(&sdata->vif)) {
4005                memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
4006        } else {
4007                struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
4008                memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
4009        }
4010        mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
4011        mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
4012        pos = skb_put(skb, 5);
4013        *pos++ = WLAN_EID_CHANNEL_SWITCH;                       /* EID */
4014        *pos++ = 3;                                             /* IE length */
4015        *pos++ = csa_settings->block_tx ? 1 : 0;                /* CSA mode */
4016        freq = csa_settings->chandef.chan->center_freq;
4017        *pos++ = ieee80211_frequency_to_channel(freq);          /* channel */
4018        *pos++ = csa_settings->count;                           /* count */
4019
4020        if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
4021                enum nl80211_channel_type ch_type;
4022
4023                skb_put(skb, 3);
4024                *pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET;     /* EID */
4025                *pos++ = 1;                                     /* IE length */
4026                ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
4027                if (ch_type == NL80211_CHAN_HT40PLUS)
4028                        *pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
4029                else
4030                        *pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
4031        }
4032
4033        if (ieee80211_vif_is_mesh(&sdata->vif)) {
4034                struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
4035
4036                skb_put(skb, 8);
4037                *pos++ = WLAN_EID_CHAN_SWITCH_PARAM;            /* EID */
4038                *pos++ = 6;                                     /* IE length */
4039                *pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL;     /* Mesh TTL */
4040                *pos = 0x00;    /* Mesh Flag: Tx Restrict, Initiator, Reason */
4041                *pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
4042                *pos++ |= csa_settings->block_tx ?
4043                          WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
4044                put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
4045                pos += 2;
4046                put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
4047                pos += 2;
4048        }
4049
4050        if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 ||
4051            csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 ||
4052            csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) {
4053                skb_put(skb, 5);
4054                ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef);
4055        }
4056
4057        ieee80211_tx_skb(sdata, skb);
4058        return 0;
4059}
4060
4061bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
4062{
4063        return !(cs == NULL || cs->cipher == 0 ||
4064                 cs->hdr_len < cs->pn_len + cs->pn_off ||
4065                 cs->hdr_len <= cs->key_idx_off ||
4066                 cs->key_idx_shift > 7 ||
4067                 cs->key_idx_mask == 0);
4068}
4069
4070bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
4071{
4072        int i;
4073
4074        /* Ensure we have enough iftype bitmap space for all iftype values */
4075        WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));
4076
4077        for (i = 0; i < n; i++)
4078                if (!ieee80211_cs_valid(&cs[i]))
4079                        return false;
4080
4081        return true;
4082}
4083
4084const struct ieee80211_cipher_scheme *
4085ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
4086                 enum nl80211_iftype iftype)
4087{
4088        const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
4089        int n = local->hw.n_cipher_schemes;
4090        int i;
4091        const struct ieee80211_cipher_scheme *cs = NULL;
4092
4093        for (i = 0; i < n; i++) {
4094                if (l[i].cipher == cipher) {
4095                        cs = &l[i];
4096                        break;
4097                }
4098        }
4099
4100        if (!cs || !(cs->iftype & BIT(iftype)))
4101                return NULL;
4102
4103        return cs;
4104}
4105
4106int ieee80211_cs_headroom(struct ieee80211_local *local,
4107                          struct cfg80211_crypto_settings *crypto,
4108                          enum nl80211_iftype iftype)
4109{
4110        const struct ieee80211_cipher_scheme *cs;
4111        int headroom = IEEE80211_ENCRYPT_HEADROOM;
4112        int i;
4113
4114        for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
4115                cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
4116                                      iftype);
4117
4118                if (cs && headroom < cs->hdr_len)
4119                        headroom = cs->hdr_len;
4120        }
4121
4122        cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
4123        if (cs && headroom < cs->hdr_len)
4124                headroom = cs->hdr_len;
4125
4126        return headroom;
4127}
4128
4129static bool
4130ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
4131{
4132        s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
4133        int skip;
4134
4135        if (end > 0)
4136                return false;
4137
4138        /* One shot NOA  */
4139        if (data->count[i] == 1)
4140                return false;
4141
4142        if (data->desc[i].interval == 0)
4143                return false;
4144
4145        /* End time is in the past, check for repetitions */
4146        skip = DIV_ROUND_UP(-end, data->desc[i].interval);
4147        if (data->count[i] < 255) {
4148                if (data->count[i] <= skip) {
4149                        data->count[i] = 0;
4150                        return false;
4151                }
4152
4153                data->count[i] -= skip;
4154        }
4155
4156        data->desc[i].start += skip * data->desc[i].interval;
4157
4158        return true;
4159}
4160
4161static bool
4162ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
4163                             s32 *offset)
4164{
4165        bool ret = false;
4166        int i;
4167
4168        for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
4169                s32 cur;
4170
4171                if (!data->count[i])
4172                        continue;
4173
4174                if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
4175                        ret = true;
4176
4177                cur = data->desc[i].start - tsf;
4178                if (cur > *offset)
4179                        continue;
4180
4181                cur = data->desc[i].start + data->desc[i].duration - tsf;
4182                if (cur > *offset)
4183                        *offset = cur;
4184        }
4185
4186        return ret;
4187}
4188
4189static u32
4190ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
4191{
4192        s32 offset = 0;
4193        int tries = 0;
4194        /*
4195         * arbitrary limit, used to avoid infinite loops when combined NoA
4196         * descriptors cover the full time period.
4197         */
4198        int max_tries = 5;
4199
4200        ieee80211_extend_absent_time(data, tsf, &offset);
4201        do {
4202                if (!ieee80211_extend_absent_time(data, tsf, &offset))
4203                        break;
4204
4205                tries++;
4206        } while (tries < max_tries);
4207
4208        return offset;
4209}
4210
4211void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
4212{
4213        u32 next_offset = BIT(31) - 1;
4214        int i;
4215
4216        data->absent = 0;
4217        data->has_next_tsf = false;
4218        for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
4219                s32 start;
4220
4221                if (!data->count[i])
4222                        continue;
4223
4224                ieee80211_extend_noa_desc(data, tsf, i);
4225                start = data->desc[i].start - tsf;
4226                if (start <= 0)
4227                        data->absent |= BIT(i);
4228
4229                if (next_offset > start)
4230                        next_offset = start;
4231
4232                data->has_next_tsf = true;
4233        }
4234
4235        if (data->absent)
4236                next_offset = ieee80211_get_noa_absent_time(data, tsf);
4237
4238        data->next_tsf = tsf + next_offset;
4239}
4240EXPORT_SYMBOL(ieee80211_update_p2p_noa);
4241
4242int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
4243                            struct ieee80211_noa_data *data, u32 tsf)
4244{
4245        int ret = 0;
4246        int i;
4247
4248        memset(data, 0, sizeof(*data));
4249
4250        for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
4251                const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
4252
4253                if (!desc->count || !desc->duration)
4254                        continue;
4255
4256                data->count[i] = desc->count;
4257                data->desc[i].start = le32_to_cpu(desc->start_time);
4258                data->desc[i].duration = le32_to_cpu(desc->duration);
4259                data->desc[i].interval = le32_to_cpu(desc->interval);
4260
4261                if (data->count[i] > 1 &&
4262                    data->desc[i].interval < data->desc[i].duration)
4263                        continue;
4264
4265                ieee80211_extend_noa_desc(data, tsf, i);
4266                ret++;
4267        }
4268
4269        if (ret)
4270                ieee80211_update_p2p_noa(data, tsf);
4271
4272        return ret;
4273}
4274EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
4275
4276void ieee80211_recalc_dtim(struct ieee80211_local *local,
4277                           struct ieee80211_sub_if_data *sdata)
4278{
4279        u64 tsf = drv_get_tsf(local, sdata);
4280        u64 dtim_count = 0;
4281        u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
4282        u8 dtim_period = sdata->vif.bss_conf.dtim_period;
4283        struct ps_data *ps;
4284        u8 bcns_from_dtim;
4285
4286        if (tsf == -1ULL || !beacon_int || !dtim_period)
4287                return;
4288
4289        if (sdata->vif.type == NL80211_IFTYPE_AP ||
4290            sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
4291                if (!sdata->bss)
4292                        return;
4293
4294                ps = &sdata->bss->ps;
4295        } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
4296                ps = &sdata->u.mesh.ps;
4297        } else {
4298                return;
4299        }
4300
4301        /*
4302         * actually finds last dtim_count, mac80211 will update in
4303         * __beacon_add_tim().
4304         * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
4305         */
4306        do_div(tsf, beacon_int);
4307        bcns_from_dtim = do_div(tsf, dtim_period);
4308        /* just had a DTIM */
4309        if (!bcns_from_dtim)
4310                dtim_count = 0;
4311        else
4312                dtim_count = dtim_period - bcns_from_dtim;
4313
4314        ps->dtim_count = dtim_count;
4315}
4316
4317static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
4318                                         struct ieee80211_chanctx *ctx)
4319{
4320        struct ieee80211_sub_if_data *sdata;
4321        u8 radar_detect = 0;
4322
4323        lockdep_assert_held(&local->chanctx_mtx);
4324
4325        if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
4326                return 0;
4327
4328        list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list)
4329                if (sdata->reserved_radar_required)
4330                        radar_detect |= BIT(sdata->reserved_chandef.width);
4331
4332        /*
4333         * An in-place reservation context should not have any assigned vifs
4334         * until it replaces the other context.
4335         */
4336        WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
4337                !list_empty(&ctx->assigned_vifs));
4338
4339        list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list)
4340                if (sdata->radar_required)
4341                        radar_detect |= BIT(sdata->vif.bss_conf.chandef.width);
4342
4343        return radar_detect;
4344}
4345
4346int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
4347                                 const struct cfg80211_chan_def *chandef,
4348                                 enum ieee80211_chanctx_mode chanmode,
4349                                 u8 radar_detect)
4350{
4351        struct ieee80211_local *local = sdata->local;
4352        struct ieee80211_sub_if_data *sdata_iter;
4353        enum nl80211_iftype iftype = sdata->wdev.iftype;
4354        struct ieee80211_chanctx *ctx;
4355        int total = 1;
4356        struct iface_combination_params params = {
4357                .radar_detect = radar_detect,
4358        };
4359
4360        lockdep_assert_held(&local->chanctx_mtx);
4361
4362        if (WARN_ON(hweight32(radar_detect) > 1))
4363                return -EINVAL;
4364
4365        if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
4366                    !chandef->chan))
4367                return -EINVAL;
4368
4369        if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
4370                return -EINVAL;
4371
4372        if (sdata->vif.type == NL80211_IFTYPE_AP ||
4373            sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
4374                /*
4375                 * always passing this is harmless, since it'll be the
4376                 * same value that cfg80211 finds if it finds the same
4377                 * interface ... and that's always allowed
4378                 */
4379                params.new_beacon_int = sdata->vif.bss_conf.beacon_int;
4380        }
4381
4382        /* Always allow software iftypes */
4383        if (cfg80211_iftype_allowed(local->hw.wiphy, iftype, 0, 1)) {
4384                if (radar_detect)
4385                        return -EINVAL;
4386                return 0;
4387        }
4388
4389        if (chandef)
4390                params.num_different_channels = 1;
4391
4392        if (iftype != NL80211_IFTYPE_UNSPECIFIED)
4393                params.iftype_num[iftype] = 1;
4394
4395        list_for_each_entry(ctx, &local->chanctx_list, list) {
4396                if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
4397                        continue;
4398                params.radar_detect |=
4399                        ieee80211_chanctx_radar_detect(local, ctx);
4400                if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) {
4401                        params.num_different_channels++;
4402                        continue;
4403                }
4404                if (chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
4405                    cfg80211_chandef_compatible(chandef,
4406                                                &ctx->conf.def))
4407                        continue;
4408                params.num_different_channels++;
4409        }
4410
4411        list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) {
4412                struct wireless_dev *wdev_iter;
4413
4414                wdev_iter = &sdata_iter->wdev;
4415
4416                if (sdata_iter == sdata ||
4417                    !ieee80211_sdata_running(sdata_iter) ||
4418                    cfg80211_iftype_allowed(local->hw.wiphy,
4419                                            wdev_iter->iftype, 0, 1))
4420                        continue;
4421
4422                params.iftype_num[wdev_iter->iftype]++;
4423                total++;
4424        }
4425
4426        if (total == 1 && !params.radar_detect)
4427                return 0;
4428
4429        return cfg80211_check_combinations(local->hw.wiphy, &params);
4430}
4431
4432static void
4433ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
4434                         void *data)
4435{
4436        u32 *max_num_different_channels = data;
4437
4438        *max_num_different_channels = max(*max_num_different_channels,
4439                                          c->num_different_channels);
4440}
4441
4442int ieee80211_max_num_channels(struct ieee80211_local *local)
4443{
4444        struct ieee80211_sub_if_data *sdata;
4445        struct ieee80211_chanctx *ctx;
4446        u32 max_num_different_channels = 1;
4447        int err;
4448        struct iface_combination_params params = {0};
4449
4450        lockdep_assert_held(&local->chanctx_mtx);
4451
4452        list_for_each_entry(ctx, &local->chanctx_list, list) {
4453                if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
4454                        continue;
4455
4456                params.num_different_channels++;
4457
4458                params.radar_detect |=
4459                        ieee80211_chanctx_radar_detect(local, ctx);
4460        }
4461
4462        list_for_each_entry_rcu(sdata, &local->interfaces, list)
4463                params.iftype_num[sdata->wdev.iftype]++;
4464
4465        err = cfg80211_iter_combinations(local->hw.wiphy, &params,
4466                                         ieee80211_iter_max_chans,
4467                                         &max_num_different_channels);