drivers/net/wireless/ath/ath11k/mac.c

   1 // SPDX-License-Identifier: BSD-3-Clause-Clear
   2 /*
   3  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
   4  * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
   5  */
   6
   7 #include <net/mac80211.h>
   8 #include <net/cfg80211.h>
   9 #include <linux/etherdevice.h>
  10 #include <linux/bitfield.h>
  11 #include <linux/inetdevice.h>
  12 #include <net/if_inet6.h>
  13 #include <net/ipv6.h>
  14
  15 #include "mac.h"
  16 #include "core.h"
  17 #include "debug.h"
  18 #include "wmi.h"
  19 #include "hw.h"
  20 #include "dp_tx.h"
  21 #include "dp_rx.h"
  22 #include "testmode.h"
  23 #include "peer.h"
  24 #include "debugfs_sta.h"
  25 #include "hif.h"
  26 #include "wow.h"
  27
  28 #define CHAN2G(_channel, _freq, _flags) { \
  29         .band                   = NL80211_BAND_2GHZ, \
  30         .hw_value               = (_channel), \
  31         .center_freq            = (_freq), \
  32         .flags                  = (_flags), \
  33         .max_antenna_gain       = 0, \
  34         .max_power              = 30, \
  35 }
  36
  37 #define CHAN5G(_channel, _freq, _flags) { \
  38         .band                   = NL80211_BAND_5GHZ, \
  39         .hw_value               = (_channel), \
  40         .center_freq            = (_freq), \
  41         .flags                  = (_flags), \
  42         .max_antenna_gain       = 0, \
  43         .max_power              = 30, \
  44 }
  45
  46 #define CHAN6G(_channel, _freq, _flags) { \
  47         .band                   = NL80211_BAND_6GHZ, \
  48         .hw_value               = (_channel), \
  49         .center_freq            = (_freq), \
  50         .flags                  = (_flags), \
  51         .max_antenna_gain       = 0, \
  52         .max_power              = 30, \
  53 }
  54
  55 static const struct ieee80211_channel ath11k_2ghz_channels[] = {
  56         CHAN2G(1, 2412, 0),
  57         CHAN2G(2, 2417, 0),
  58         CHAN2G(3, 2422, 0),
  59         CHAN2G(4, 2427, 0),
  60         CHAN2G(5, 2432, 0),
  61         CHAN2G(6, 2437, 0),
  62         CHAN2G(7, 2442, 0),
  63         CHAN2G(8, 2447, 0),
  64         CHAN2G(9, 2452, 0),
  65         CHAN2G(10, 2457, 0),
  66         CHAN2G(11, 2462, 0),
  67         CHAN2G(12, 2467, 0),
  68         CHAN2G(13, 2472, 0),
  69         CHAN2G(14, 2484, 0),
  70 };
  71
  72 static const struct ieee80211_channel ath11k_5ghz_channels[] = {
  73         CHAN5G(36, 5180, 0),
  74         CHAN5G(40, 5200, 0),
  75         CHAN5G(44, 5220, 0),
  76         CHAN5G(48, 5240, 0),
  77         CHAN5G(52, 5260, 0),
  78         CHAN5G(56, 5280, 0),
  79         CHAN5G(60, 5300, 0),
  80         CHAN5G(64, 5320, 0),
  81         CHAN5G(100, 5500, 0),
  82         CHAN5G(104, 5520, 0),
  83         CHAN5G(108, 5540, 0),
  84         CHAN5G(112, 5560, 0),
  85         CHAN5G(116, 5580, 0),
  86         CHAN5G(120, 5600, 0),
  87         CHAN5G(124, 5620, 0),
  88         CHAN5G(128, 5640, 0),
  89         CHAN5G(132, 5660, 0),
  90         CHAN5G(136, 5680, 0),
  91         CHAN5G(140, 5700, 0),
  92         CHAN5G(144, 5720, 0),
  93         CHAN5G(149, 5745, 0),
  94         CHAN5G(153, 5765, 0),
  95         CHAN5G(157, 5785, 0),
  96         CHAN5G(161, 5805, 0),
  97         CHAN5G(165, 5825, 0),
  98         CHAN5G(169, 5845, 0),
  99         CHAN5G(173, 5865, 0),
 100         CHAN5G(177, 5885, 0),
 101 };
 102
 103 static const struct ieee80211_channel ath11k_6ghz_channels[] = {
 104         CHAN6G(1, 5955, 0),
 105         CHAN6G(5, 5975, 0),
 106         CHAN6G(9, 5995, 0),
 107         CHAN6G(13, 6015, 0),
 108         CHAN6G(17, 6035, 0),
 109         CHAN6G(21, 6055, 0),
 110         CHAN6G(25, 6075, 0),
 111         CHAN6G(29, 6095, 0),
 112         CHAN6G(33, 6115, 0),
 113         CHAN6G(37, 6135, 0),
 114         CHAN6G(41, 6155, 0),
 115         CHAN6G(45, 6175, 0),
 116         CHAN6G(49, 6195, 0),
 117         CHAN6G(53, 6215, 0),
 118         CHAN6G(57, 6235, 0),
 119         CHAN6G(61, 6255, 0),
 120         CHAN6G(65, 6275, 0),
 121         CHAN6G(69, 6295, 0),
 122         CHAN6G(73, 6315, 0),
 123         CHAN6G(77, 6335, 0),
 124         CHAN6G(81, 6355, 0),
 125         CHAN6G(85, 6375, 0),
 126         CHAN6G(89, 6395, 0),
 127         CHAN6G(93, 6415, 0),
 128         CHAN6G(97, 6435, 0),
 129         CHAN6G(101, 6455, 0),
 130         CHAN6G(105, 6475, 0),
 131         CHAN6G(109, 6495, 0),
 132         CHAN6G(113, 6515, 0),
 133         CHAN6G(117, 6535, 0),
 134         CHAN6G(121, 6555, 0),
 135         CHAN6G(125, 6575, 0),
 136         CHAN6G(129, 6595, 0),
 137         CHAN6G(133, 6615, 0),
 138         CHAN6G(137, 6635, 0),
 139         CHAN6G(141, 6655, 0),
 140         CHAN6G(145, 6675, 0),
 141         CHAN6G(149, 6695, 0),
 142         CHAN6G(153, 6715, 0),
 143         CHAN6G(157, 6735, 0),
 144         CHAN6G(161, 6755, 0),
 145         CHAN6G(165, 6775, 0),
 146         CHAN6G(169, 6795, 0),
 147         CHAN6G(173, 6815, 0),
 148         CHAN6G(177, 6835, 0),
 149         CHAN6G(181, 6855, 0),
 150         CHAN6G(185, 6875, 0),
 151         CHAN6G(189, 6895, 0),
 152         CHAN6G(193, 6915, 0),
 153         CHAN6G(197, 6935, 0),
 154         CHAN6G(201, 6955, 0),
 155         CHAN6G(205, 6975, 0),
 156         CHAN6G(209, 6995, 0),
 157         CHAN6G(213, 7015, 0),
 158         CHAN6G(217, 7035, 0),
 159         CHAN6G(221, 7055, 0),
 160         CHAN6G(225, 7075, 0),
 161         CHAN6G(229, 7095, 0),
 162         CHAN6G(233, 7115, 0),
 163
 164         /* new addition in IEEE Std 802.11ax-2021 */
 165         CHAN6G(2, 5935, 0),
 166 };
 167
 168 static struct ieee80211_rate ath11k_legacy_rates[] = {
 169         { .bitrate = 10,
 170           .hw_value = ATH11K_HW_RATE_CCK_LP_1M },
 171         { .bitrate = 20,
 172           .hw_value = ATH11K_HW_RATE_CCK_LP_2M,
 173           .hw_value_short = ATH11K_HW_RATE_CCK_SP_2M,
 174           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 175         { .bitrate = 55,
 176           .hw_value = ATH11K_HW_RATE_CCK_LP_5_5M,
 177           .hw_value_short = ATH11K_HW_RATE_CCK_SP_5_5M,
 178           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 179         { .bitrate = 110,
 180           .hw_value = ATH11K_HW_RATE_CCK_LP_11M,
 181           .hw_value_short = ATH11K_HW_RATE_CCK_SP_11M,
 182           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 183
 184         { .bitrate = 60, .hw_value = ATH11K_HW_RATE_OFDM_6M },
 185         { .bitrate = 90, .hw_value = ATH11K_HW_RATE_OFDM_9M },
 186         { .bitrate = 120, .hw_value = ATH11K_HW_RATE_OFDM_12M },
 187         { .bitrate = 180, .hw_value = ATH11K_HW_RATE_OFDM_18M },
 188         { .bitrate = 240, .hw_value = ATH11K_HW_RATE_OFDM_24M },
 189         { .bitrate = 360, .hw_value = ATH11K_HW_RATE_OFDM_36M },
 190         { .bitrate = 480, .hw_value = ATH11K_HW_RATE_OFDM_48M },
 191         { .bitrate = 540, .hw_value = ATH11K_HW_RATE_OFDM_54M },
 192 };
 193
 194 static const int
 195 ath11k_phymodes[NUM_NL80211_BANDS][ATH11K_CHAN_WIDTH_NUM] = {
 196         [NL80211_BAND_2GHZ] = {
 197                         [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
 198                         [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
 199                         [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20_2G,
 200                         [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20_2G,
 201                         [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40_2G,
 202                         [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80_2G,
 203                         [NL80211_CHAN_WIDTH_80P80] = MODE_UNKNOWN,
 204                         [NL80211_CHAN_WIDTH_160] = MODE_UNKNOWN,
 205         },
 206         [NL80211_BAND_5GHZ] = {
 207                         [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
 208                         [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
 209                         [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
 210                         [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
 211                         [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
 212                         [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
 213                         [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
 214                         [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
 215         },
 216         [NL80211_BAND_6GHZ] = {
 217                         [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
 218                         [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
 219                         [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
 220                         [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
 221                         [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
 222                         [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
 223                         [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
 224                         [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
 225         },
 226
 227 };
 228
 229 const struct htt_rx_ring_tlv_filter ath11k_mac_mon_status_filter_default = {
 230         .rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START |
 231                      HTT_RX_FILTER_TLV_FLAGS_PPDU_END |
 232                      HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE,
 233         .pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0,
 234         .pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1,
 235         .pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2,
 236         .pkt_filter_flags3 = HTT_RX_FP_DATA_FILTER_FLASG3 |
 237                              HTT_RX_FP_CTRL_FILTER_FLASG3
 238 };
 239
 240 #define ATH11K_MAC_FIRST_OFDM_RATE_IDX 4
 241 #define ath11k_g_rates ath11k_legacy_rates
 242 #define ath11k_g_rates_size (ARRAY_SIZE(ath11k_legacy_rates))
 243 #define ath11k_a_rates (ath11k_legacy_rates + 4)
 244 #define ath11k_a_rates_size (ARRAY_SIZE(ath11k_legacy_rates) - 4)
 245
 246 #define ATH11K_MAC_SCAN_CMD_EVT_OVERHEAD                200 /* in msecs */
 247
 248 /* Overhead due to the processing of channel switch events from FW */
 249 #define ATH11K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD     10 /* in msecs */
 250
 251 static const u32 ath11k_smps_map[] = {
 252         [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
 253         [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
 254         [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
 255         [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
 256 };
 257
 258 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
 259                                    struct ieee80211_vif *vif);
 260
 261 enum nl80211_he_ru_alloc ath11k_mac_phy_he_ru_to_nl80211_he_ru_alloc(u16 ru_phy)
 262 {
 263         enum nl80211_he_ru_alloc ret;
 264
 265         switch (ru_phy) {
 266         case RU_26:
 267                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
 268                 break;
 269         case RU_52:
 270                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
 271                 break;
 272         case RU_106:
 273                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
 274                 break;
 275         case RU_242:
 276                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
 277                 break;
 278         case RU_484:
 279                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
 280                 break;
 281         case RU_996:
 282                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
 283                 break;
 284         default:
 285                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
 286                 break;
 287         }
 288
 289         return ret;
 290 }
 291
 292 enum nl80211_he_ru_alloc ath11k_mac_he_ru_tones_to_nl80211_he_ru_alloc(u16 ru_tones)
 293 {
 294         enum nl80211_he_ru_alloc ret;
 295
 296         switch (ru_tones) {
 297         case 26:
 298                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
 299                 break;
 300         case 52:
 301                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
 302                 break;
 303         case 106:
 304                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
 305                 break;
 306         case 242:
 307                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
 308                 break;
 309         case 484:
 310                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
 311                 break;
 312         case 996:
 313                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
 314                 break;
 315         case (996 * 2):
 316                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_2x996;
 317                 break;
 318         default:
 319                 ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
 320                 break;
 321         }
 322
 323         return ret;
 324 }
 325
 326 enum nl80211_he_gi ath11k_mac_he_gi_to_nl80211_he_gi(u8 sgi)
 327 {
 328         enum nl80211_he_gi ret;
 329
 330         switch (sgi) {
 331         case RX_MSDU_START_SGI_0_8_US:
 332                 ret = NL80211_RATE_INFO_HE_GI_0_8;
 333                 break;
 334         case RX_MSDU_START_SGI_1_6_US:
 335                 ret = NL80211_RATE_INFO_HE_GI_1_6;
 336                 break;
 337         case RX_MSDU_START_SGI_3_2_US:
 338                 ret = NL80211_RATE_INFO_HE_GI_3_2;
 339                 break;
 340         default:
 341                 ret = NL80211_RATE_INFO_HE_GI_0_8;
 342                 break;
 343         }
 344
 345         return ret;
 346 }
 347
 348 u8 ath11k_mac_bw_to_mac80211_bw(u8 bw)
 349 {
 350         u8 ret = 0;
 351
 352         switch (bw) {
 353         case ATH11K_BW_20:
 354                 ret = RATE_INFO_BW_20;
 355                 break;
 356         case ATH11K_BW_40:
 357                 ret = RATE_INFO_BW_40;
 358                 break;
 359         case ATH11K_BW_80:
 360                 ret = RATE_INFO_BW_80;
 361                 break;
 362         case ATH11K_BW_160:
 363                 ret = RATE_INFO_BW_160;
 364                 break;
 365         }
 366
 367         return ret;
 368 }
 369
 370 enum ath11k_supported_bw ath11k_mac_mac80211_bw_to_ath11k_bw(enum rate_info_bw bw)
 371 {
 372         switch (bw) {
 373         case RATE_INFO_BW_20:
 374                 return ATH11K_BW_20;
 375         case RATE_INFO_BW_40:
 376                 return ATH11K_BW_40;
 377         case RATE_INFO_BW_80:
 378                 return ATH11K_BW_80;
 379         case RATE_INFO_BW_160:
 380                 return ATH11K_BW_160;
 381         default:
 382                 return ATH11K_BW_20;
 383         }
 384 }
 385
 386 int ath11k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx,
 387                                           u16 *rate)
 388 {
 389         /* As default, it is OFDM rates */
 390         int i = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
 391         int max_rates_idx = ath11k_g_rates_size;
 392
 393         if (preamble == WMI_RATE_PREAMBLE_CCK) {
 394                 hw_rc &= ~ATH11k_HW_RATECODE_CCK_SHORT_PREAM_MASK;
 395                 i = 0;
 396                 max_rates_idx = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
 397         }
 398
 399         while (i < max_rates_idx) {
 400                 if (hw_rc == ath11k_legacy_rates[i].hw_value) {
 401                         *rateidx = i;
 402                         *rate = ath11k_legacy_rates[i].bitrate;
 403                         return 0;
 404                 }
 405                 i++;
 406         }
 407
 408         return -EINVAL;
 409 }
 410
 411 static int get_num_chains(u32 mask)
 412 {
 413         int num_chains = 0;
 414
 415         while (mask) {
 416                 if (mask & BIT(0))
 417                         num_chains++;
 418                 mask >>= 1;
 419         }
 420
 421         return num_chains;
 422 }
 423
 424 u8 ath11k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
 425                              u32 bitrate)
 426 {
 427         int i;
 428
 429         for (i = 0; i < sband->n_bitrates; i++)
 430                 if (sband->bitrates[i].bitrate == bitrate)
 431                         return i;
 432
 433         return 0;
 434 }
 435
 436 static u32
 437 ath11k_mac_max_ht_nss(const u8 *ht_mcs_mask)
 438 {
 439         int nss;
 440
 441         for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
 442                 if (ht_mcs_mask[nss])
 443                         return nss + 1;
 444
 445         return 1;
 446 }
 447
 448 static u32
 449 ath11k_mac_max_vht_nss(const u16 *vht_mcs_mask)
 450 {
 451         int nss;
 452
 453         for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
 454                 if (vht_mcs_mask[nss])
 455                         return nss + 1;
 456
 457         return 1;
 458 }
 459
 460 static u32
 461 ath11k_mac_max_he_nss(const u16 *he_mcs_mask)
 462 {
 463         int nss;
 464
 465         for (nss = NL80211_HE_NSS_MAX - 1; nss >= 0; nss--)
 466                 if (he_mcs_mask[nss])
 467                         return nss + 1;
 468
 469         return 1;
 470 }
 471
 472 static u8 ath11k_parse_mpdudensity(u8 mpdudensity)
 473 {
 474 /* 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
 475  *   0 for no restriction
 476  *   1 for 1/4 us
 477  *   2 for 1/2 us
 478  *   3 for 1 us
 479  *   4 for 2 us
 480  *   5 for 4 us
 481  *   6 for 8 us
 482  *   7 for 16 us
 483  */
 484         switch (mpdudensity) {
 485         case 0:
 486                 return 0;
 487         case 1:
 488         case 2:
 489         case 3:
 490         /* Our lower layer calculations limit our precision to
 491          * 1 microsecond
 492          */
 493                 return 1;
 494         case 4:
 495                 return 2;
 496         case 5:
 497                 return 4;
 498         case 6:
 499                 return 8;
 500         case 7:
 501                 return 16;
 502         default:
 503                 return 0;
 504         }
 505 }
 506
 507 static int ath11k_mac_vif_chan(struct ieee80211_vif *vif,
 508                                struct cfg80211_chan_def *def)
 509 {
 510         struct ieee80211_chanctx_conf *conf;
 511
 512         rcu_read_lock();
 513         conf = rcu_dereference(vif->bss_conf.chanctx_conf);
 514         if (!conf) {
 515                 rcu_read_unlock();
 516                 return -ENOENT;
 517         }
 518
 519         *def = conf->def;
 520         rcu_read_unlock();
 521
 522         return 0;
 523 }
 524
 525 static bool ath11k_mac_bitrate_is_cck(int bitrate)
 526 {
 527         switch (bitrate) {
 528         case 10:
 529         case 20:
 530         case 55:
 531         case 110:
 532                 return true;
 533         }
 534
 535         return false;
 536 }
 537
 538 u8 ath11k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
 539                              u8 hw_rate, bool cck)
 540 {
 541         const struct ieee80211_rate *rate;
 542         int i;
 543
 544         for (i = 0; i < sband->n_bitrates; i++) {
 545                 rate = &sband->bitrates[i];
 546
 547                 if (ath11k_mac_bitrate_is_cck(rate->bitrate) != cck)
 548                         continue;
 549
 550                 if (rate->hw_value == hw_rate)
 551                         return i;
 552                 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
 553                          rate->hw_value_short == hw_rate)
 554                         return i;
 555         }
 556
 557         return 0;
 558 }
 559
 560 static u8 ath11k_mac_bitrate_to_rate(int bitrate)
 561 {
 562         return DIV_ROUND_UP(bitrate, 5) |
 563                (ath11k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
 564 }
 565
 566 static void ath11k_get_arvif_iter(void *data, u8 *mac,
 567                                   struct ieee80211_vif *vif)
 568 {
 569         struct ath11k_vif_iter *arvif_iter = data;
 570         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
 571
 572         if (arvif->vdev_id == arvif_iter->vdev_id)
 573                 arvif_iter->arvif = arvif;
 574 }
 575
 576 struct ath11k_vif *ath11k_mac_get_arvif(struct ath11k *ar, u32 vdev_id)
 577 {
 578         struct ath11k_vif_iter arvif_iter;
 579         u32 flags;
 580
 581         memset(&arvif_iter, 0, sizeof(struct ath11k_vif_iter));
 582         arvif_iter.vdev_id = vdev_id;
 583
 584         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
 585         ieee80211_iterate_active_interfaces_atomic(ar->hw,
 586                                                    flags,
 587                                                    ath11k_get_arvif_iter,
 588                                                    &arvif_iter);
 589         if (!arvif_iter.arvif) {
 590                 ath11k_warn(ar->ab, "No VIF found for vdev %d\n", vdev_id);
 591                 return NULL;
 592         }
 593
 594         return arvif_iter.arvif;
 595 }
 596
 597 struct ath11k_vif *ath11k_mac_get_arvif_by_vdev_id(struct ath11k_base *ab,
 598                                                    u32 vdev_id)
 599 {
 600         int i;
 601         struct ath11k_pdev *pdev;
 602         struct ath11k_vif *arvif;
 603
 604         for (i = 0; i < ab->num_radios; i++) {
 605                 pdev = rcu_dereference(ab->pdevs_active[i]);
 606                 if (pdev && pdev->ar &&
 607                     (pdev->ar->allocated_vdev_map & (1LL << vdev_id))) {
 608                         arvif = ath11k_mac_get_arvif(pdev->ar, vdev_id);
 609                         if (arvif)
 610                                 return arvif;
 611                 }
 612         }
 613
 614         return NULL;
 615 }
 616
 617 struct ath11k *ath11k_mac_get_ar_by_vdev_id(struct ath11k_base *ab, u32 vdev_id)
 618 {
 619         int i;
 620         struct ath11k_pdev *pdev;
 621
 622         for (i = 0; i < ab->num_radios; i++) {
 623                 pdev = rcu_dereference(ab->pdevs_active[i]);
 624                 if (pdev && pdev->ar) {
 625                         if (pdev->ar->allocated_vdev_map & (1LL << vdev_id))
 626                                 return pdev->ar;
 627                 }
 628         }
 629
 630         return NULL;
 631 }
 632
 633 struct ath11k *ath11k_mac_get_ar_by_pdev_id(struct ath11k_base *ab, u32 pdev_id)
 634 {
 635         int i;
 636         struct ath11k_pdev *pdev;
 637
 638         if (ab->hw_params.single_pdev_only) {
 639                 pdev = rcu_dereference(ab->pdevs_active[0]);
 640                 return pdev ? pdev->ar : NULL;
 641         }
 642
 643         if (WARN_ON(pdev_id > ab->num_radios))
 644                 return NULL;
 645
 646         for (i = 0; i < ab->num_radios; i++) {
 647                 if (ab->fw_mode == ATH11K_FIRMWARE_MODE_FTM)
 648                         pdev = &ab->pdevs[i];
 649                 else
 650                         pdev = rcu_dereference(ab->pdevs_active[i]);
 651
 652                 if (pdev && pdev->pdev_id == pdev_id)
 653                         return (pdev->ar ? pdev->ar : NULL);
 654         }
 655
 656         return NULL;
 657 }
 658
 659 struct ath11k_vif *ath11k_mac_get_vif_up(struct ath11k_base *ab)
 660 {
 661         struct ath11k *ar;
 662         struct ath11k_pdev *pdev;
 663         struct ath11k_vif *arvif;
 664         int i;
 665
 666         for (i = 0; i < ab->num_radios; i++) {
 667                 pdev = &ab->pdevs[i];
 668                 ar = pdev->ar;
 669                 list_for_each_entry(arvif, &ar->arvifs, list) {
 670                         if (arvif->is_up)
 671                                 return arvif;
 672                 }
 673         }
 674
 675         return NULL;
 676 }
 677
 678 static bool ath11k_mac_band_match(enum nl80211_band band1, enum WMI_HOST_WLAN_BAND band2)
 679 {
 680         return (((band1 == NL80211_BAND_2GHZ) && (band2 & WMI_HOST_WLAN_2G_CAP)) ||
 681                 (((band1 == NL80211_BAND_5GHZ) || (band1 == NL80211_BAND_6GHZ)) &&
 682                    (band2 & WMI_HOST_WLAN_5G_CAP)));
 683 }
 684
 685 u8 ath11k_mac_get_target_pdev_id_from_vif(struct ath11k_vif *arvif)
 686 {
 687         struct ath11k *ar = arvif->ar;
 688         struct ath11k_base *ab = ar->ab;
 689         struct ieee80211_vif *vif = arvif->vif;
 690         struct cfg80211_chan_def def;
 691         enum nl80211_band band;
 692         u8 pdev_id = ab->target_pdev_ids[0].pdev_id;
 693         int i;
 694
 695         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
 696                 return pdev_id;
 697
 698         band = def.chan->band;
 699
 700         for (i = 0; i < ab->target_pdev_count; i++) {
 701                 if (ath11k_mac_band_match(band, ab->target_pdev_ids[i].supported_bands))
 702                         return ab->target_pdev_ids[i].pdev_id;
 703         }
 704
 705         return pdev_id;
 706 }
 707
 708 u8 ath11k_mac_get_target_pdev_id(struct ath11k *ar)
 709 {
 710         struct ath11k_vif *arvif;
 711
 712         arvif = ath11k_mac_get_vif_up(ar->ab);
 713
 714         if (arvif)
 715                 return ath11k_mac_get_target_pdev_id_from_vif(arvif);
 716         else
 717                 return ar->ab->target_pdev_ids[0].pdev_id;
 718 }
 719
 720 static void ath11k_pdev_caps_update(struct ath11k *ar)
 721 {
 722         struct ath11k_base *ab = ar->ab;
 723
 724         ar->max_tx_power = ab->target_caps.hw_max_tx_power;
 725
 726         /* FIXME Set min_tx_power to ab->target_caps.hw_min_tx_power.
 727          * But since the received value in svcrdy is same as hw_max_tx_power,
 728          * we can set ar->min_tx_power to 0 currently until
 729          * this is fixed in firmware
 730          */
 731         ar->min_tx_power = 0;
 732
 733         ar->txpower_limit_2g = ar->max_tx_power;
 734         ar->txpower_limit_5g = ar->max_tx_power;
 735         ar->txpower_scale = WMI_HOST_TP_SCALE_MAX;
 736 }
 737
 738 static int ath11k_mac_txpower_recalc(struct ath11k *ar)
 739 {
 740         struct ath11k_pdev *pdev = ar->pdev;
 741         struct ath11k_vif *arvif;
 742         int ret, txpower = -1;
 743         u32 param;
 744
 745         lockdep_assert_held(&ar->conf_mutex);
 746
 747         list_for_each_entry(arvif, &ar->arvifs, list) {
 748                 if (arvif->txpower <= 0)
 749                         continue;
 750
 751                 if (txpower == -1)
 752                         txpower = arvif->txpower;
 753                 else
 754                         txpower = min(txpower, arvif->txpower);
 755         }
 756
 757         if (txpower == -1)
 758                 return 0;
 759
 760         /* txpwr is set as 2 units per dBm in FW*/
 761         txpower = min_t(u32, max_t(u32, ar->min_tx_power, txpower),
 762                         ar->max_tx_power) * 2;
 763
 764         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower to set in hw %d\n",
 765                    txpower / 2);
 766
 767         if ((pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) &&
 768             ar->txpower_limit_2g != txpower) {
 769                 param = WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
 770                 ret = ath11k_wmi_pdev_set_param(ar, param,
 771                                                 txpower, ar->pdev->pdev_id);
 772                 if (ret)
 773                         goto fail;
 774                 ar->txpower_limit_2g = txpower;
 775         }
 776
 777         if ((pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) &&
 778             ar->txpower_limit_5g != txpower) {
 779                 param = WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
 780                 ret = ath11k_wmi_pdev_set_param(ar, param,
 781                                                 txpower, ar->pdev->pdev_id);
 782                 if (ret)
 783                         goto fail;
 784                 ar->txpower_limit_5g = txpower;
 785         }
 786
 787         return 0;
 788
 789 fail:
 790         ath11k_warn(ar->ab, "failed to recalc txpower limit %d using pdev param %d: %d\n",
 791                     txpower / 2, param, ret);
 792         return ret;
 793 }
 794
 795 static int ath11k_recalc_rtscts_prot(struct ath11k_vif *arvif)
 796 {
 797         struct ath11k *ar = arvif->ar;
 798         u32 vdev_param, rts_cts = 0;
 799         int ret;
 800
 801         lockdep_assert_held(&ar->conf_mutex);
 802
 803         vdev_param = WMI_VDEV_PARAM_ENABLE_RTSCTS;
 804
 805         /* Enable RTS/CTS protection for sw retries (when legacy stations
 806          * are in BSS) or by default only for second rate series.
 807          * TODO: Check if we need to enable CTS 2 Self in any case
 808          */
 809         rts_cts = WMI_USE_RTS_CTS;
 810
 811         if (arvif->num_legacy_stations > 0)
 812                 rts_cts |= WMI_RTSCTS_ACROSS_SW_RETRIES << 4;
 813         else
 814                 rts_cts |= WMI_RTSCTS_FOR_SECOND_RATESERIES << 4;
 815
 816         /* Need not send duplicate param value to firmware */
 817         if (arvif->rtscts_prot_mode == rts_cts)
 818                 return 0;
 819
 820         arvif->rtscts_prot_mode = rts_cts;
 821
 822         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %d recalc rts/cts prot %d\n",
 823                    arvif->vdev_id, rts_cts);
 824
 825         ret =  ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
 826                                              vdev_param, rts_cts);
 827         if (ret)
 828                 ath11k_warn(ar->ab, "failed to recalculate rts/cts prot for vdev %d: %d\n",
 829                             arvif->vdev_id, ret);
 830
 831         return ret;
 832 }
 833
 834 static int ath11k_mac_set_kickout(struct ath11k_vif *arvif)
 835 {
 836         struct ath11k *ar = arvif->ar;
 837         u32 param;
 838         int ret;
 839
 840         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_STA_KICKOUT_TH,
 841                                         ATH11K_KICKOUT_THRESHOLD,
 842                                         ar->pdev->pdev_id);
 843         if (ret) {
 844                 ath11k_warn(ar->ab, "failed to set kickout threshold on vdev %i: %d\n",
 845                             arvif->vdev_id, ret);
 846                 return ret;
 847         }
 848
 849         param = WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS;
 850         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
 851                                             ATH11K_KEEPALIVE_MIN_IDLE);
 852         if (ret) {
 853                 ath11k_warn(ar->ab, "failed to set keepalive minimum idle time on vdev %i: %d\n",
 854                             arvif->vdev_id, ret);
 855                 return ret;
 856         }
 857
 858         param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS;
 859         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
 860                                             ATH11K_KEEPALIVE_MAX_IDLE);
 861         if (ret) {
 862                 ath11k_warn(ar->ab, "failed to set keepalive maximum idle time on vdev %i: %d\n",
 863                             arvif->vdev_id, ret);
 864                 return ret;
 865         }
 866
 867         param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS;
 868         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
 869                                             ATH11K_KEEPALIVE_MAX_UNRESPONSIVE);
 870         if (ret) {
 871                 ath11k_warn(ar->ab, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
 872                             arvif->vdev_id, ret);
 873                 return ret;
 874         }
 875
 876         return 0;
 877 }
 878
 879 void ath11k_mac_peer_cleanup_all(struct ath11k *ar)
 880 {
 881         struct ath11k_peer *peer, *tmp;
 882         struct ath11k_base *ab = ar->ab;
 883
 884         lockdep_assert_held(&ar->conf_mutex);
 885
 886         mutex_lock(&ab->tbl_mtx_lock);
 887         spin_lock_bh(&ab->base_lock);
 888         list_for_each_entry_safe(peer, tmp, &ab->peers, list) {
 889                 ath11k_peer_rx_tid_cleanup(ar, peer);
 890                 ath11k_peer_rhash_delete(ab, peer);
 891                 list_del(&peer->list);
 892                 kfree(peer);
 893         }
 894         spin_unlock_bh(&ab->base_lock);
 895         mutex_unlock(&ab->tbl_mtx_lock);
 896
 897         ar->num_peers = 0;
 898         ar->num_stations = 0;
 899 }
 900
 901 static inline int ath11k_mac_vdev_setup_sync(struct ath11k *ar)
 902 {
 903         lockdep_assert_held(&ar->conf_mutex);
 904
 905         if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
 906                 return -ESHUTDOWN;
 907
 908         if (!wait_for_completion_timeout(&ar->vdev_setup_done,
 909                                          ATH11K_VDEV_SETUP_TIMEOUT_HZ))
 910                 return -ETIMEDOUT;
 911
 912         return ar->last_wmi_vdev_start_status ? -EINVAL : 0;
 913 }
 914
 915 static void
 916 ath11k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
 917                                 struct ieee80211_chanctx_conf *conf,
 918                                 void *data)
 919 {
 920         struct cfg80211_chan_def **def = data;
 921
 922         *def = &conf->def;
 923 }
 924
 925 static int ath11k_mac_monitor_vdev_start(struct ath11k *ar, int vdev_id,
 926                                          struct cfg80211_chan_def *chandef)
 927 {
 928         struct ieee80211_channel *channel;
 929         struct wmi_vdev_start_req_arg arg = {};
 930         int ret;
 931
 932         lockdep_assert_held(&ar->conf_mutex);
 933
 934         channel = chandef->chan;
 935
 936         arg.vdev_id = vdev_id;
 937         arg.channel.freq = channel->center_freq;
 938         arg.channel.band_center_freq1 = chandef->center_freq1;
 939         arg.channel.band_center_freq2 = chandef->center_freq2;
 940
 941         arg.channel.mode = ath11k_phymodes[chandef->chan->band][chandef->width];
 942         arg.channel.chan_radar = !!(channel->flags & IEEE80211_CHAN_RADAR);
 943
 944         arg.channel.min_power = 0;
 945         arg.channel.max_power = channel->max_power;
 946         arg.channel.max_reg_power = channel->max_reg_power;
 947         arg.channel.max_antenna_gain = channel->max_antenna_gain;
 948
 949         arg.pref_tx_streams = ar->num_tx_chains;
 950         arg.pref_rx_streams = ar->num_rx_chains;
 951
 952         arg.channel.passive = !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
 953
 954         reinit_completion(&ar->vdev_setup_done);
 955         reinit_completion(&ar->vdev_delete_done);
 956
 957         ret = ath11k_wmi_vdev_start(ar, &arg, false);
 958         if (ret) {
 959                 ath11k_warn(ar->ab, "failed to request monitor vdev %i start: %d\n",
 960                             vdev_id, ret);
 961                 return ret;
 962         }
 963
 964         ret = ath11k_mac_vdev_setup_sync(ar);
 965         if (ret) {
 966                 ath11k_warn(ar->ab, "failed to synchronize setup for monitor vdev %i start: %d\n",
 967                             vdev_id, ret);
 968                 return ret;
 969         }
 970
 971         ret = ath11k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr, NULL, 0, 0);
 972         if (ret) {
 973                 ath11k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n",
 974                             vdev_id, ret);
 975                 goto vdev_stop;
 976         }
 977
 978         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %i started\n",
 979                    vdev_id);
 980
 981         return 0;
 982
 983 vdev_stop:
 984         reinit_completion(&ar->vdev_setup_done);
 985
 986         ret = ath11k_wmi_vdev_stop(ar, vdev_id);
 987         if (ret) {
 988                 ath11k_warn(ar->ab, "failed to stop monitor vdev %i after start failure: %d\n",
 989                             vdev_id, ret);
 990                 return ret;
 991         }
 992
 993         ret = ath11k_mac_vdev_setup_sync(ar);
 994         if (ret) {
 995                 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i stop: %d\n",
 996                             vdev_id, ret);
 997                 return ret;
 998         }
 999
1000         return -EIO;
1001 }
1002
1003 static int ath11k_mac_monitor_vdev_stop(struct ath11k *ar)
1004 {
1005         int ret;
1006
1007         lockdep_assert_held(&ar->conf_mutex);
1008
1009         reinit_completion(&ar->vdev_setup_done);
1010
1011         ret = ath11k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1012         if (ret) {
1013                 ath11k_warn(ar->ab, "failed to request monitor vdev %i stop: %d\n",
1014                             ar->monitor_vdev_id, ret);
1015                 return ret;
1016         }
1017
1018         ret = ath11k_mac_vdev_setup_sync(ar);
1019         if (ret) {
1020                 ath11k_warn(ar->ab, "failed to synchronize monitor vdev %i stop: %d\n",
1021                             ar->monitor_vdev_id, ret);
1022                 return ret;
1023         }
1024
1025         ret = ath11k_wmi_vdev_down(ar, ar->monitor_vdev_id);
1026         if (ret) {
1027                 ath11k_warn(ar->ab, "failed to put down monitor vdev %i: %d\n",
1028                             ar->monitor_vdev_id, ret);
1029                 return ret;
1030         }
1031
1032         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %i stopped\n",
1033                    ar->monitor_vdev_id);
1034
1035         return 0;
1036 }
1037
1038 static int ath11k_mac_monitor_vdev_create(struct ath11k *ar)
1039 {
1040         struct ath11k_pdev *pdev = ar->pdev;
1041         struct vdev_create_params param = {};
1042         int bit, ret;
1043         u8 tmp_addr[6] = {0};
1044         u16 nss;
1045
1046         lockdep_assert_held(&ar->conf_mutex);
1047
1048         if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
1049                 return 0;
1050
1051         if (ar->ab->free_vdev_map == 0) {
1052                 ath11k_warn(ar->ab, "failed to find free vdev id for monitor vdev\n");
1053                 return -ENOMEM;
1054         }
1055
1056         bit = __ffs64(ar->ab->free_vdev_map);
1057
1058         ar->monitor_vdev_id = bit;
1059
1060         param.if_id = ar->monitor_vdev_id;
1061         param.type = WMI_VDEV_TYPE_MONITOR;
1062         param.subtype = WMI_VDEV_SUBTYPE_NONE;
1063         param.pdev_id = pdev->pdev_id;
1064
1065         if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
1066                 param.chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
1067                 param.chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
1068         }
1069         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
1070                 param.chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
1071                 param.chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
1072         }
1073
1074         ret = ath11k_wmi_vdev_create(ar, tmp_addr, &param);
1075         if (ret) {
1076                 ath11k_warn(ar->ab, "failed to request monitor vdev %i creation: %d\n",
1077                             ar->monitor_vdev_id, ret);
1078                 ar->monitor_vdev_id = -1;
1079                 return ret;
1080         }
1081
1082         nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
1083         ret = ath11k_wmi_vdev_set_param_cmd(ar, ar->monitor_vdev_id,
1084                                             WMI_VDEV_PARAM_NSS, nss);
1085         if (ret) {
1086                 ath11k_warn(ar->ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
1087                             ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret);
1088                 goto err_vdev_del;
1089         }
1090
1091         ret = ath11k_mac_txpower_recalc(ar);
1092         if (ret) {
1093                 ath11k_warn(ar->ab, "failed to recalc txpower for monitor vdev %d: %d\n",
1094                             ar->monitor_vdev_id, ret);
1095                 goto err_vdev_del;
1096         }
1097
1098         ar->allocated_vdev_map |= 1LL << ar->monitor_vdev_id;
1099         ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1100         ar->num_created_vdevs++;
1101         set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
1102
1103         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %d created\n",
1104                    ar->monitor_vdev_id);
1105
1106         return 0;
1107
1108 err_vdev_del:
1109         ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1110         ar->monitor_vdev_id = -1;
1111         return ret;
1112 }
1113
1114 static int ath11k_mac_monitor_vdev_delete(struct ath11k *ar)
1115 {
1116         int ret;
1117         unsigned long time_left;
1118
1119         lockdep_assert_held(&ar->conf_mutex);
1120
1121         if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
1122                 return 0;
1123
1124         reinit_completion(&ar->vdev_delete_done);
1125
1126         ret = ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1127         if (ret) {
1128                 ath11k_warn(ar->ab, "failed to request wmi monitor vdev %i removal: %d\n",
1129                             ar->monitor_vdev_id, ret);
1130                 return ret;
1131         }
1132
1133         time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
1134                                                 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
1135         if (time_left == 0) {
1136                 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
1137         } else {
1138                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor vdev %d deleted\n",
1139                            ar->monitor_vdev_id);
1140
1141                 ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1142                 ar->ab->free_vdev_map |= 1LL << (ar->monitor_vdev_id);
1143                 ar->num_created_vdevs--;
1144                 ar->monitor_vdev_id = -1;
1145                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
1146         }
1147
1148         return ret;
1149 }
1150
1151 static int ath11k_mac_monitor_start(struct ath11k *ar)
1152 {
1153         struct cfg80211_chan_def *chandef = NULL;
1154         int ret;
1155
1156         lockdep_assert_held(&ar->conf_mutex);
1157
1158         if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
1159                 return 0;
1160
1161         ieee80211_iter_chan_contexts_atomic(ar->hw,
1162                                             ath11k_mac_get_any_chandef_iter,
1163                                             &chandef);
1164         if (!chandef)
1165                 return 0;
1166
1167         ret = ath11k_mac_monitor_vdev_start(ar, ar->monitor_vdev_id, chandef);
1168         if (ret) {
1169                 ath11k_warn(ar->ab, "failed to start monitor vdev: %d\n", ret);
1170                 ath11k_mac_monitor_vdev_delete(ar);
1171                 return ret;
1172         }
1173
1174         set_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
1175
1176         ar->num_started_vdevs++;
1177         ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, false);
1178         if (ret) {
1179                 ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during start: %d",
1180                             ret);
1181                 return ret;
1182         }
1183
1184         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor started\n");
1185
1186         return 0;
1187 }
1188
1189 static int ath11k_mac_monitor_stop(struct ath11k *ar)
1190 {
1191         int ret;
1192
1193         lockdep_assert_held(&ar->conf_mutex);
1194
1195         if (!test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
1196                 return 0;
1197
1198         ret = ath11k_mac_monitor_vdev_stop(ar);
1199         if (ret) {
1200                 ath11k_warn(ar->ab, "failed to stop monitor vdev: %d\n", ret);
1201                 return ret;
1202         }
1203
1204         clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
1205         ar->num_started_vdevs--;
1206
1207         ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, true);
1208         if (ret) {
1209                 ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during stop: %d",
1210                             ret);
1211                 return ret;
1212         }
1213
1214         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "monitor stopped ret %d\n", ret);
1215
1216         return 0;
1217 }
1218
1219 static int ath11k_mac_vif_setup_ps(struct ath11k_vif *arvif)
1220 {
1221         struct ath11k *ar = arvif->ar;
1222         struct ieee80211_vif *vif = arvif->vif;
1223         struct ieee80211_conf *conf = &ar->hw->conf;
1224         enum wmi_sta_powersave_param param;
1225         enum wmi_sta_ps_mode psmode;
1226         int ret;
1227         int timeout;
1228         bool enable_ps;
1229
1230         lockdep_assert_held(&arvif->ar->conf_mutex);
1231
1232         if (arvif->vif->type != NL80211_IFTYPE_STATION)
1233                 return 0;
1234
1235         enable_ps = arvif->ps;
1236
1237         if (!arvif->is_started) {
1238                 /* mac80211 can update vif powersave state while disconnected.
1239                  * Firmware doesn't behave nicely and consumes more power than
1240                  * necessary if PS is disabled on a non-started vdev. Hence
1241                  * force-enable PS for non-running vdevs.
1242                  */
1243                 psmode = WMI_STA_PS_MODE_ENABLED;
1244         } else if (enable_ps) {
1245                 psmode = WMI_STA_PS_MODE_ENABLED;
1246                 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1247
1248                 timeout = conf->dynamic_ps_timeout;
1249                 if (timeout == 0) {
1250                         /* firmware doesn't like 0 */
1251                         timeout = ieee80211_tu_to_usec(vif->bss_conf.beacon_int) / 1000;
1252                 }
1253
1254                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1255                                                   timeout);
1256                 if (ret) {
1257                         ath11k_warn(ar->ab, "failed to set inactivity time for vdev %d: %i\n",
1258                                     arvif->vdev_id, ret);
1259                         return ret;
1260                 }
1261         } else {
1262                 psmode = WMI_STA_PS_MODE_DISABLED;
1263         }
1264
1265         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %d psmode %s\n",
1266                    arvif->vdev_id, psmode ? "enable" : "disable");
1267
1268         ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, psmode);
1269         if (ret) {
1270                 ath11k_warn(ar->ab, "failed to set sta power save mode %d for vdev %d: %d\n",
1271                             psmode, arvif->vdev_id, ret);
1272                 return ret;
1273         }
1274
1275         return 0;
1276 }
1277
1278 static int ath11k_mac_config_ps(struct ath11k *ar)
1279 {
1280         struct ath11k_vif *arvif;
1281         int ret = 0;
1282
1283         lockdep_assert_held(&ar->conf_mutex);
1284
1285         list_for_each_entry(arvif, &ar->arvifs, list) {
1286                 ret = ath11k_mac_vif_setup_ps(arvif);
1287                 if (ret) {
1288                         ath11k_warn(ar->ab, "failed to setup powersave: %d\n", ret);
1289                         break;
1290                 }
1291         }
1292
1293         return ret;
1294 }
1295
1296 static int ath11k_mac_op_config(struct ieee80211_hw *hw, u32 changed)
1297 {
1298         struct ath11k *ar = hw->priv;
1299         struct ieee80211_conf *conf = &hw->conf;
1300         int ret = 0;
1301
1302         mutex_lock(&ar->conf_mutex);
1303
1304         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1305                 if (conf->flags & IEEE80211_CONF_MONITOR) {
1306                         set_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);
1307
1308                         if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
1309                                      &ar->monitor_flags))
1310                                 goto out;
1311
1312                         ret = ath11k_mac_monitor_vdev_create(ar);
1313                         if (ret) {
1314                                 ath11k_warn(ar->ab, "failed to create monitor vdev: %d",
1315                                             ret);
1316                                 goto out;
1317                         }
1318
1319                         ret = ath11k_mac_monitor_start(ar);
1320                         if (ret) {
1321                                 ath11k_warn(ar->ab, "failed to start monitor: %d",
1322                                             ret);
1323                                 goto err_mon_del;
1324                         }
1325                 } else {
1326                         clear_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);
1327
1328                         if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
1329                                       &ar->monitor_flags))
1330                                 goto out;
1331
1332                         ret = ath11k_mac_monitor_stop(ar);
1333                         if (ret) {
1334                                 ath11k_warn(ar->ab, "failed to stop monitor: %d",
1335                                             ret);
1336                                 goto out;
1337                         }
1338
1339                         ret = ath11k_mac_monitor_vdev_delete(ar);
1340                         if (ret) {
1341                                 ath11k_warn(ar->ab, "failed to delete monitor vdev: %d",
1342                                             ret);
1343                                 goto out;
1344                         }
1345                 }
1346         }
1347
1348 out:
1349         mutex_unlock(&ar->conf_mutex);
1350         return ret;
1351
1352 err_mon_del:
1353         ath11k_mac_monitor_vdev_delete(ar);
1354         mutex_unlock(&ar->conf_mutex);
1355         return ret;
1356 }
1357
1358 static void ath11k_mac_setup_nontx_vif_rsnie(struct ath11k_vif *arvif,
1359                                              bool tx_arvif_rsnie_present,
1360                                              const u8 *profile, u8 profile_len)
1361 {
1362         if (cfg80211_find_ie(WLAN_EID_RSN, profile, profile_len)) {
1363                 arvif->rsnie_present = true;
1364         } else if (tx_arvif_rsnie_present) {
1365                 int i;
1366                 u8 nie_len;
1367                 const u8 *nie = cfg80211_find_ext_ie(WLAN_EID_EXT_NON_INHERITANCE,
1368                                                      profile, profile_len);
1369                 if (!nie)
1370                         return;
1371
1372                 nie_len = nie[1];
1373                 nie += 2;
1374                 for (i = 0; i < nie_len; i++) {
1375                         if (nie[i] == WLAN_EID_RSN) {
1376                                 arvif->rsnie_present = false;
1377                                 break;
1378                         }
1379                 }
1380         }
1381 }
1382
1383 static bool ath11k_mac_set_nontx_vif_params(struct ath11k_vif *tx_arvif,
1384                                             struct ath11k_vif *arvif,
1385                                             struct sk_buff *bcn)
1386 {
1387         struct ieee80211_mgmt *mgmt;
1388         const u8 *ies, *profile, *next_profile;
1389         int ies_len;
1390
1391         ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
1392         mgmt = (struct ieee80211_mgmt *)bcn->data;
1393         ies += sizeof(mgmt->u.beacon);
1394         ies_len = skb_tail_pointer(bcn) - ies;
1395
1396         ies = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ies, ies_len);
1397         arvif->rsnie_present = tx_arvif->rsnie_present;
1398
1399         while (ies) {
1400                 u8 mbssid_len;
1401
1402                 ies_len -= (2 + ies[1]);
1403                 mbssid_len = ies[1] - 1;
1404                 profile = &ies[3];
1405
1406                 while (mbssid_len) {
1407                         u8 profile_len;
1408
1409                         profile_len = profile[1];
1410                         next_profile = profile + (2 + profile_len);
1411                         mbssid_len -= (2 + profile_len);
1412
1413                         profile += 2;
1414                         profile_len -= (2 + profile[1]);
1415                         profile += (2 + profile[1]); /* nontx capabilities */
1416                         profile_len -= (2 + profile[1]);
1417                         profile += (2 + profile[1]); /* SSID */
1418                         if (profile[2] == arvif->vif->bss_conf.bssid_index) {
1419                                 profile_len -= 5;
1420                                 profile = profile + 5;
1421                                 ath11k_mac_setup_nontx_vif_rsnie(arvif,
1422                                                                  tx_arvif->rsnie_present,
1423                                                                  profile,
1424                                                                  profile_len);
1425                                 return true;
1426                         }
1427                         profile = next_profile;
1428                 }
1429                 ies = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, profile,
1430                                        ies_len);
1431         }
1432
1433         return false;
1434 }
1435
1436 static void ath11k_mac_set_vif_params(struct ath11k_vif *arvif,
1437                                       struct sk_buff *bcn)
1438 {
1439         struct ieee80211_mgmt *mgmt;
1440         u8 *ies;
1441
1442         ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
1443         mgmt = (struct ieee80211_mgmt *)bcn->data;
1444         ies += sizeof(mgmt->u.beacon);
1445
1446         if (cfg80211_find_ie(WLAN_EID_RSN, ies, (skb_tail_pointer(bcn) - ies)))
1447                 arvif->rsnie_present = true;
1448         else
1449                 arvif->rsnie_present = false;
1450
1451         if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1452                                     WLAN_OUI_TYPE_MICROSOFT_WPA,
1453                                     ies, (skb_tail_pointer(bcn) - ies)))
1454                 arvif->wpaie_present = true;
1455         else
1456                 arvif->wpaie_present = false;
1457 }
1458
1459 static int ath11k_mac_setup_bcn_tmpl_ema(struct ath11k_vif *arvif)
1460 {
1461         struct ath11k_vif *tx_arvif;
1462         struct ieee80211_ema_beacons *beacons;
1463         int ret = 0;
1464         bool nontx_vif_params_set = false;
1465         u32 params = 0;
1466         u8 i = 0;
1467
1468         tx_arvif = ath11k_vif_to_arvif(arvif->vif->mbssid_tx_vif);
1469
1470         beacons = ieee80211_beacon_get_template_ema_list(tx_arvif->ar->hw,
1471                                                          tx_arvif->vif, 0);
1472         if (!beacons || !beacons->cnt) {
1473                 ath11k_warn(arvif->ar->ab,
1474                             "failed to get ema beacon templates from mac80211\n");
1475                 return -EPERM;
1476         }
1477
1478         if (tx_arvif == arvif)
1479                 ath11k_mac_set_vif_params(tx_arvif, beacons->bcn[0].skb);
1480         else
1481                 arvif->wpaie_present = tx_arvif->wpaie_present;
1482
1483         for (i = 0; i < beacons->cnt; i++) {
1484                 if (tx_arvif != arvif && !nontx_vif_params_set)
1485                         nontx_vif_params_set =
1486                                 ath11k_mac_set_nontx_vif_params(tx_arvif, arvif,
1487                                                                 beacons->bcn[i].skb);
1488
1489                 params = beacons->cnt;
1490                 params |= (i << WMI_EMA_TMPL_IDX_SHIFT);
1491                 params |= ((!i ? 1 : 0) << WMI_EMA_FIRST_TMPL_SHIFT);
1492                 params |= ((i + 1 == beacons->cnt ? 1 : 0) << WMI_EMA_LAST_TMPL_SHIFT);
1493
1494                 ret = ath11k_wmi_bcn_tmpl(tx_arvif->ar, tx_arvif->vdev_id,
1495                                           &beacons->bcn[i].offs,
1496                                           beacons->bcn[i].skb, params);
1497                 if (ret) {
1498                         ath11k_warn(tx_arvif->ar->ab,
1499                                     "failed to set ema beacon template id %i error %d\n",
1500                                     i, ret);
1501                         break;
1502                 }
1503         }
1504
1505         ieee80211_beacon_free_ema_list(beacons);
1506
1507         if (tx_arvif != arvif && !nontx_vif_params_set)
1508                 return -EINVAL; /* Profile not found in the beacons */
1509
1510         return ret;
1511 }
1512
1513 static int ath11k_mac_setup_bcn_tmpl_mbssid(struct ath11k_vif *arvif)
1514 {
1515         struct ath11k *ar = arvif->ar;
1516         struct ath11k_base *ab = ar->ab;
1517         struct ath11k_vif *tx_arvif = arvif;
1518         struct ieee80211_hw *hw = ar->hw;
1519         struct ieee80211_vif *vif = arvif->vif;
1520         struct ieee80211_mutable_offsets offs = {};
1521         struct sk_buff *bcn;
1522         int ret;
1523
1524         if (vif->mbssid_tx_vif) {
1525                 tx_arvif = ath11k_vif_to_arvif(vif->mbssid_tx_vif);
1526                 if (tx_arvif != arvif) {
1527                         ar = tx_arvif->ar;
1528                         ab = ar->ab;
1529                         hw = ar->hw;
1530                         vif = tx_arvif->vif;
1531                 }
1532         }
1533
1534         bcn = ieee80211_beacon_get_template(hw, vif, &offs, 0);
1535         if (!bcn) {
1536                 ath11k_warn(ab, "failed to get beacon template from mac80211\n");
1537                 return -EPERM;
1538         }
1539
1540         if (tx_arvif == arvif)
1541                 ath11k_mac_set_vif_params(tx_arvif, bcn);
1542         else if (!ath11k_mac_set_nontx_vif_params(tx_arvif, arvif, bcn))
1543                 return -EINVAL;
1544
1545         ret = ath11k_wmi_bcn_tmpl(ar, arvif->vdev_id, &offs, bcn, 0);
1546         kfree_skb(bcn);
1547
1548         if (ret)
1549                 ath11k_warn(ab, "failed to submit beacon template command: %d\n",
1550                             ret);
1551
1552         return ret;
1553 }
1554
1555 static int ath11k_mac_setup_bcn_tmpl(struct ath11k_vif *arvif)
1556 {
1557         struct ieee80211_vif *vif = arvif->vif;
1558
1559         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1560                 return 0;
1561
1562         /* Target does not expect beacon templates for the already up
1563          * non-transmitting interfaces, and results in a crash if sent.
1564          */
1565         if (vif->mbssid_tx_vif &&
1566             arvif != ath11k_vif_to_arvif(vif->mbssid_tx_vif) && arvif->is_up)
1567                 return 0;
1568
1569         if (vif->bss_conf.ema_ap && vif->mbssid_tx_vif)
1570                 return ath11k_mac_setup_bcn_tmpl_ema(arvif);
1571
1572         return ath11k_mac_setup_bcn_tmpl_mbssid(arvif);
1573 }
1574
1575 void ath11k_mac_bcn_tx_event(struct ath11k_vif *arvif)
1576 {
1577         struct ieee80211_vif *vif = arvif->vif;
1578
1579         if (!vif->bss_conf.color_change_active && !arvif->bcca_zero_sent)
1580                 return;
1581
1582         if (vif->bss_conf.color_change_active &&
1583             ieee80211_beacon_cntdwn_is_complete(vif)) {
1584                 arvif->bcca_zero_sent = true;
1585                 ieee80211_color_change_finish(vif);
1586                 return;
1587         }
1588
1589         arvif->bcca_zero_sent = false;
1590
1591         if (vif->bss_conf.color_change_active)
1592                 ieee80211_beacon_update_cntdwn(vif);
1593         ath11k_mac_setup_bcn_tmpl(arvif);
1594 }
1595
1596 static void ath11k_control_beaconing(struct ath11k_vif *arvif,
1597                                      struct ieee80211_bss_conf *info)
1598 {
1599         struct ath11k *ar = arvif->ar;
1600         struct ath11k_vif *tx_arvif = NULL;
1601         int ret = 0;
1602
1603         lockdep_assert_held(&arvif->ar->conf_mutex);
1604
1605         if (!info->enable_beacon) {
1606                 ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
1607                 if (ret)
1608                         ath11k_warn(ar->ab, "failed to down vdev_id %i: %d\n",
1609                                     arvif->vdev_id, ret);
1610
1611                 arvif->is_up = false;
1612                 return;
1613         }
1614
1615         /* Install the beacon template to the FW */
1616         ret = ath11k_mac_setup_bcn_tmpl(arvif);
1617         if (ret) {
1618                 ath11k_warn(ar->ab, "failed to update bcn tmpl during vdev up: %d\n",
1619                             ret);
1620                 return;
1621         }
1622
1623         arvif->tx_seq_no = 0x1000;
1624
1625         arvif->aid = 0;
1626
1627         ether_addr_copy(arvif->bssid, info->bssid);
1628
1629         if (arvif->vif->mbssid_tx_vif)
1630                 tx_arvif = ath11k_vif_to_arvif(arvif->vif->mbssid_tx_vif);
1631
1632         ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1633                                  arvif->bssid,
1634                                  tx_arvif ? tx_arvif->bssid : NULL,
1635                                  info->bssid_index,
1636                                  1 << info->bssid_indicator);
1637         if (ret) {
1638                 ath11k_warn(ar->ab, "failed to bring up vdev %d: %i\n",
1639                             arvif->vdev_id, ret);
1640                 return;
1641         }
1642
1643         arvif->is_up = true;
1644
1645         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %d up\n", arvif->vdev_id);
1646 }
1647
1648 static void ath11k_mac_handle_beacon_iter(void *data, u8 *mac,
1649                                           struct ieee80211_vif *vif)
1650 {
1651         struct sk_buff *skb = data;
1652         struct ieee80211_mgmt *mgmt = (void *)skb->data;
1653         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1654
1655         if (vif->type != NL80211_IFTYPE_STATION)
1656                 return;
1657
1658         if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1659                 return;
1660
1661         cancel_delayed_work(&arvif->connection_loss_work);
1662 }
1663
1664 void ath11k_mac_handle_beacon(struct ath11k *ar, struct sk_buff *skb)
1665 {
1666         ieee80211_iterate_active_interfaces_atomic(ar->hw,
1667                                                    IEEE80211_IFACE_ITER_NORMAL,
1668                                                    ath11k_mac_handle_beacon_iter,
1669                                                    skb);
1670 }
1671
1672 static void ath11k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1673                                                struct ieee80211_vif *vif)
1674 {
1675         u32 *vdev_id = data;
1676         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1677         struct ath11k *ar = arvif->ar;
1678         struct ieee80211_hw *hw = ar->hw;
1679
1680         if (arvif->vdev_id != *vdev_id)
1681                 return;
1682
1683         if (!arvif->is_up)
1684                 return;
1685
1686         ieee80211_beacon_loss(vif);
1687
1688         /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1689          * (done by mac80211) succeeds but beacons do not resume then it
1690          * doesn't make sense to continue operation. Queue connection loss work
1691          * which can be cancelled when beacon is received.
1692          */
1693         ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1694                                      ATH11K_CONNECTION_LOSS_HZ);
1695 }
1696
1697 void ath11k_mac_handle_beacon_miss(struct ath11k *ar, u32 vdev_id)
1698 {
1699         ieee80211_iterate_active_interfaces_atomic(ar->hw,
1700                                                    IEEE80211_IFACE_ITER_NORMAL,
1701                                                    ath11k_mac_handle_beacon_miss_iter,
1702                                                    &vdev_id);
1703 }
1704
1705 static void ath11k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1706 {
1707         struct ath11k_vif *arvif = container_of(work, struct ath11k_vif,
1708                                                 connection_loss_work.work);
1709         struct ieee80211_vif *vif = arvif->vif;
1710
1711         if (!arvif->is_up)
1712                 return;
1713
1714         ieee80211_connection_loss(vif);
1715 }
1716
1717 static void ath11k_peer_assoc_h_basic(struct ath11k *ar,
1718                                       struct ieee80211_vif *vif,
1719                                       struct ieee80211_sta *sta,
1720                                       struct peer_assoc_params *arg)
1721 {
1722         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1723         u32 aid;
1724
1725         lockdep_assert_held(&ar->conf_mutex);
1726
1727         if (vif->type == NL80211_IFTYPE_STATION)
1728                 aid = vif->cfg.aid;
1729         else
1730                 aid = sta->aid;
1731
1732         ether_addr_copy(arg->peer_mac, sta->addr);
1733         arg->vdev_id = arvif->vdev_id;
1734         arg->peer_associd = aid;
1735         arg->auth_flag = true;
1736         /* TODO: STA WAR in ath10k for listen interval required? */
1737         arg->peer_listen_intval = ar->hw->conf.listen_interval;
1738         arg->peer_nss = 1;
1739         arg->peer_caps = vif->bss_conf.assoc_capability;
1740 }
1741
1742 static void ath11k_peer_assoc_h_crypto(struct ath11k *ar,
1743                                        struct ieee80211_vif *vif,
1744                                        struct ieee80211_sta *sta,
1745                                        struct peer_assoc_params *arg)
1746 {
1747         struct ieee80211_bss_conf *info = &vif->bss_conf;
1748         struct cfg80211_chan_def def;
1749         struct cfg80211_bss *bss;
1750         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1751         const u8 *rsnie = NULL;
1752         const u8 *wpaie = NULL;
1753
1754         lockdep_assert_held(&ar->conf_mutex);
1755
1756         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1757                 return;
1758
1759         bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1760                                IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1761
1762         if (arvif->rsnie_present || arvif->wpaie_present) {
1763                 arg->need_ptk_4_way = true;
1764                 if (arvif->wpaie_present)
1765                         arg->need_gtk_2_way = true;
1766         } else if (bss) {
1767                 const struct cfg80211_bss_ies *ies;
1768
1769                 rcu_read_lock();
1770                 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1771
1772                 ies = rcu_dereference(bss->ies);
1773
1774                 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1775                                                 WLAN_OUI_TYPE_MICROSOFT_WPA,
1776                                                 ies->data,
1777                                                 ies->len);
1778                 rcu_read_unlock();
1779                 cfg80211_put_bss(ar->hw->wiphy, bss);
1780         }
1781
1782         /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1783         if (rsnie || wpaie) {
1784                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1785                            "%s: rsn ie found\n", __func__);
1786                 arg->need_ptk_4_way = true;
1787         }
1788
1789         if (wpaie) {
1790                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1791                            "%s: wpa ie found\n", __func__);
1792                 arg->need_gtk_2_way = true;
1793         }
1794
1795         if (sta->mfp) {
1796                 /* TODO: Need to check if FW supports PMF? */
1797                 arg->is_pmf_enabled = true;
1798         }
1799
1800         /* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */
1801 }
1802
1803 static void ath11k_peer_assoc_h_rates(struct ath11k *ar,
1804                                       struct ieee80211_vif *vif,
1805                                       struct ieee80211_sta *sta,
1806                                       struct peer_assoc_params *arg)
1807 {
1808         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1809         struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1810         struct cfg80211_chan_def def;
1811         const struct ieee80211_supported_band *sband;
1812         const struct ieee80211_rate *rates;
1813         enum nl80211_band band;
1814         u32 ratemask;
1815         u8 rate;
1816         int i;
1817
1818         lockdep_assert_held(&ar->conf_mutex);
1819
1820         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1821                 return;
1822
1823         band = def.chan->band;
1824         sband = ar->hw->wiphy->bands[band];
1825         ratemask = sta->deflink.supp_rates[band];
1826         ratemask &= arvif->bitrate_mask.control[band].legacy;
1827         rates = sband->bitrates;
1828
1829         rateset->num_rates = 0;
1830
1831         for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1832                 if (!(ratemask & 1))
1833                         continue;
1834
1835                 rate = ath11k_mac_bitrate_to_rate(rates->bitrate);
1836                 rateset->rates[rateset->num_rates] = rate;
1837                 rateset->num_rates++;
1838         }
1839 }
1840
1841 static bool
1842 ath11k_peer_assoc_h_ht_masked(const u8 *ht_mcs_mask)
1843 {
1844         int nss;
1845
1846         for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
1847                 if (ht_mcs_mask[nss])
1848                         return false;
1849
1850         return true;
1851 }
1852
1853 static bool
1854 ath11k_peer_assoc_h_vht_masked(const u16 *vht_mcs_mask)
1855 {
1856         int nss;
1857
1858         for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
1859                 if (vht_mcs_mask[nss])
1860                         return false;
1861
1862         return true;
1863 }
1864
1865 static void ath11k_peer_assoc_h_ht(struct ath11k *ar,
1866                                    struct ieee80211_vif *vif,
1867                                    struct ieee80211_sta *sta,
1868                                    struct peer_assoc_params *arg)
1869 {
1870         const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
1871         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1872         struct cfg80211_chan_def def;
1873         enum nl80211_band band;
1874         const u8 *ht_mcs_mask;
1875         int i, n;
1876         u8 max_nss;
1877         u32 stbc;
1878
1879         lockdep_assert_held(&ar->conf_mutex);
1880
1881         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1882                 return;
1883
1884         if (!ht_cap->ht_supported)
1885                 return;
1886
1887         band = def.chan->band;
1888         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
1889
1890         if (ath11k_peer_assoc_h_ht_masked(ht_mcs_mask))
1891                 return;
1892
1893         arg->ht_flag = true;
1894
1895         arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1896                                     ht_cap->ampdu_factor)) - 1;
1897
1898         arg->peer_mpdu_density =
1899                 ath11k_parse_mpdudensity(ht_cap->ampdu_density);
1900
1901         arg->peer_ht_caps = ht_cap->cap;
1902         arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG;
1903
1904         if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1905                 arg->ldpc_flag = true;
1906
1907         if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {
1908                 arg->bw_40 = true;
1909                 arg->peer_rate_caps |= WMI_HOST_RC_CW40_FLAG;
1910         }
1911
1912         /* As firmware handles this two flags (IEEE80211_HT_CAP_SGI_20
1913          * and IEEE80211_HT_CAP_SGI_40) for enabling SGI, we reset
1914          * both flags if guard interval is Default GI
1915          */
1916         if (arvif->bitrate_mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI)
1917                 arg->peer_ht_caps &= ~(IEEE80211_HT_CAP_SGI_20 |
1918                                 IEEE80211_HT_CAP_SGI_40);
1919
1920         if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
1921                 if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 |
1922                     IEEE80211_HT_CAP_SGI_40))
1923                         arg->peer_rate_caps |= WMI_HOST_RC_SGI_FLAG;
1924         }
1925
1926         if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1927                 arg->peer_rate_caps |= WMI_HOST_RC_TX_STBC_FLAG;
1928                 arg->stbc_flag = true;
1929         }
1930
1931         if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1932                 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1933                 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1934                 stbc = stbc << WMI_HOST_RC_RX_STBC_FLAG_S;
1935                 arg->peer_rate_caps |= stbc;
1936                 arg->stbc_flag = true;
1937         }
1938
1939         if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1940                 arg->peer_rate_caps |= WMI_HOST_RC_TS_FLAG;
1941         else if (ht_cap->mcs.rx_mask[1])
1942                 arg->peer_rate_caps |= WMI_HOST_RC_DS_FLAG;
1943
1944         for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
1945                 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
1946                     (ht_mcs_mask[i / 8] & BIT(i % 8))) {
1947                         max_nss = (i / 8) + 1;
1948                         arg->peer_ht_rates.rates[n++] = i;
1949                 }
1950
1951         /* This is a workaround for HT-enabled STAs which break the spec
1952          * and have no HT capabilities RX mask (no HT RX MCS map).
1953          *
1954          * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1955          * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1956          *
1957          * Firmware asserts if such situation occurs.
1958          */
1959         if (n == 0) {
1960                 arg->peer_ht_rates.num_rates = 8;
1961                 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1962                         arg->peer_ht_rates.rates[i] = i;
1963         } else {
1964                 arg->peer_ht_rates.num_rates = n;
1965                 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1966         }
1967
1968         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "ht peer %pM mcs cnt %d nss %d\n",
1969                    arg->peer_mac,
1970                    arg->peer_ht_rates.num_rates,
1971                    arg->peer_nss);
1972 }
1973
1974 static int ath11k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
1975 {
1976         switch ((mcs_map >> (2 * nss)) & 0x3) {
1977         case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
1978         case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
1979         case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
1980         }
1981         return 0;
1982 }
1983
1984 static u16
1985 ath11k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
1986                               const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
1987 {
1988         int idx_limit;
1989         int nss;
1990         u16 mcs_map;
1991         u16 mcs;
1992
1993         for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
1994                 mcs_map = ath11k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
1995                           vht_mcs_limit[nss];
1996
1997                 if (mcs_map)
1998                         idx_limit = fls(mcs_map) - 1;
1999                 else
2000                         idx_limit = -1;
2001
2002                 switch (idx_limit) {
2003                 case 0:
2004                 case 1:
2005                 case 2:
2006                 case 3:
2007                 case 4:
2008                 case 5:
2009                 case 6:
2010                 case 7:
2011                         mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2012                         break;
2013                 case 8:
2014                         mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2015                         break;
2016                 case 9:
2017                         mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2018                         break;
2019                 default:
2020                         WARN_ON(1);
2021                         fallthrough;
2022                 case -1:
2023                         mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2024                         break;
2025                 }
2026
2027                 tx_mcs_set &= ~(0x3 << (nss * 2));
2028                 tx_mcs_set |= mcs << (nss * 2);
2029         }
2030
2031         return tx_mcs_set;
2032 }
2033
2034 static u8 ath11k_get_nss_160mhz(struct ath11k *ar,
2035                                 u8 max_nss)
2036 {
2037         u8 nss_ratio_info = ar->pdev->cap.nss_ratio_info;
2038         u8 max_sup_nss = 0;
2039
2040         switch (nss_ratio_info) {
2041         case WMI_NSS_RATIO_1BY2_NSS:
2042                 max_sup_nss = max_nss >> 1;
2043                 break;
2044         case WMI_NSS_RATIO_3BY4_NSS:
2045                 ath11k_warn(ar->ab, "WMI_NSS_RATIO_3BY4_NSS not supported\n");
2046                 break;
2047         case WMI_NSS_RATIO_1_NSS:
2048                 max_sup_nss = max_nss;
2049                 break;
2050         case WMI_NSS_RATIO_2_NSS:
2051                 ath11k_warn(ar->ab, "WMI_NSS_RATIO_2_NSS not supported\n");
2052                 break;
2053         default:
2054                 ath11k_warn(ar->ab, "invalid nss ratio received from firmware: %d\n",
2055                             nss_ratio_info);
2056                 break;
2057         }
2058
2059         return max_sup_nss;
2060 }
2061
2062 static void ath11k_peer_assoc_h_vht(struct ath11k *ar,
2063                                     struct ieee80211_vif *vif,
2064                                     struct ieee80211_sta *sta,
2065                                     struct peer_assoc_params *arg)
2066 {
2067         const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
2068         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2069         struct cfg80211_chan_def def;
2070         enum nl80211_band band;
2071         u16 *vht_mcs_mask;
2072         u8 ampdu_factor;
2073         u8 max_nss, vht_mcs;
2074         int i, vht_nss, nss_idx;
2075         bool user_rate_valid = true;
2076         u32 rx_nss, tx_nss, nss_160;
2077
2078         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2079                 return;
2080
2081         if (!vht_cap->vht_supported)
2082                 return;
2083
2084         band = def.chan->band;
2085         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2086
2087         if (ath11k_peer_assoc_h_vht_masked(vht_mcs_mask))
2088                 return;
2089
2090         arg->vht_flag = true;
2091
2092         /* TODO: similar flags required? */
2093         arg->vht_capable = true;
2094
2095         if (def.chan->band == NL80211_BAND_2GHZ)
2096                 arg->vht_ng_flag = true;
2097
2098         arg->peer_vht_caps = vht_cap->cap;
2099
2100         ampdu_factor = (vht_cap->cap &
2101                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2102                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2103
2104         /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2105          * zero in VHT IE. Using it would result in degraded throughput.
2106          * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2107          * it if VHT max_mpdu is smaller.
2108          */
2109         arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2110                                  (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2111                                         ampdu_factor)) - 1);
2112
2113         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2114                 arg->bw_80 = true;
2115
2116         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2117                 arg->bw_160 = true;
2118
2119         vht_nss =  ath11k_mac_max_vht_nss(vht_mcs_mask);
2120
2121         if (vht_nss > sta->deflink.rx_nss) {
2122                 user_rate_valid = false;
2123                 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2124                         if (vht_mcs_mask[nss_idx]) {
2125                                 user_rate_valid = true;
2126                                 break;
2127                         }
2128                 }
2129         }
2130
2131         if (!user_rate_valid) {
2132                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting vht range mcs value to peer supported nss %d for peer %pM\n",
2133                            sta->deflink.rx_nss, sta->addr);
2134                 vht_mcs_mask[sta->deflink.rx_nss - 1] = vht_mcs_mask[vht_nss - 1];
2135         }
2136
2137         /* Calculate peer NSS capability from VHT capabilities if STA
2138          * supports VHT.
2139          */
2140         for (i = 0, max_nss = 0; i < NL80211_VHT_NSS_MAX; i++) {
2141                 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
2142                           (2 * i) & 3;
2143
2144                 if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED &&
2145                     vht_mcs_mask[i])
2146                         max_nss = i + 1;
2147         }
2148         arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2149         arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2150         arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2151         arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2152         arg->tx_mcs_set = ath11k_peer_assoc_h_vht_limit(
2153                 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2154
2155         /* In IPQ8074 platform, VHT mcs rate 10 and 11 is enabled by default.
2156          * VHT mcs rate 10 and 11 is not suppoerted in 11ac standard.
2157          * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode.
2158          */
2159         arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK;
2160         arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11;
2161
2162         if ((arg->tx_mcs_set & IEEE80211_VHT_MCS_NOT_SUPPORTED) ==
2163                         IEEE80211_VHT_MCS_NOT_SUPPORTED)
2164                 arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
2165
2166         /* TODO:  Check */
2167         arg->tx_max_mcs_nss = 0xFF;
2168
2169         if (arg->peer_phymode == MODE_11AC_VHT160 ||
2170             arg->peer_phymode == MODE_11AC_VHT80_80) {
2171                 tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2172                 rx_nss = min(arg->peer_nss, tx_nss);
2173                 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2174
2175                 if (!rx_nss) {
2176                         ath11k_warn(ar->ab, "invalid max_nss\n");
2177                         return;
2178                 }
2179
2180                 if (arg->peer_phymode == MODE_11AC_VHT160)
2181                         nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2182                 else
2183                         nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2184
2185                 arg->peer_bw_rxnss_override |= nss_160;
2186         }
2187
2188         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2189                    "vht peer %pM max_mpdu %d flags 0x%x nss_override 0x%x\n",
2190                    sta->addr, arg->peer_max_mpdu, arg->peer_flags,
2191                    arg->peer_bw_rxnss_override);
2192 }
2193
2194 static int ath11k_mac_get_max_he_mcs_map(u16 mcs_map, int nss)
2195 {
2196         switch ((mcs_map >> (2 * nss)) & 0x3) {
2197         case IEEE80211_HE_MCS_SUPPORT_0_7: return BIT(8) - 1;
2198         case IEEE80211_HE_MCS_SUPPORT_0_9: return BIT(10) - 1;
2199         case IEEE80211_HE_MCS_SUPPORT_0_11: return BIT(12) - 1;
2200         }
2201         return 0;
2202 }
2203
2204 static u16 ath11k_peer_assoc_h_he_limit(u16 tx_mcs_set,
2205                                         const u16 he_mcs_limit[NL80211_HE_NSS_MAX])
2206 {
2207         int idx_limit;
2208         int nss;
2209         u16 mcs_map;
2210         u16 mcs;
2211
2212         for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) {
2213                 mcs_map = ath11k_mac_get_max_he_mcs_map(tx_mcs_set, nss) &
2214                         he_mcs_limit[nss];
2215
2216                 if (mcs_map)
2217                         idx_limit = fls(mcs_map) - 1;
2218                 else
2219                         idx_limit = -1;
2220
2221                 switch (idx_limit) {
2222                 case 0 ... 7:
2223                         mcs = IEEE80211_HE_MCS_SUPPORT_0_7;
2224                         break;
2225                 case 8:
2226                 case 9:
2227                         mcs = IEEE80211_HE_MCS_SUPPORT_0_9;
2228                         break;
2229                 case 10:
2230                 case 11:
2231                         mcs = IEEE80211_HE_MCS_SUPPORT_0_11;
2232                         break;
2233                 default:
2234                         WARN_ON(1);
2235                         fallthrough;
2236                 case -1:
2237                         mcs = IEEE80211_HE_MCS_NOT_SUPPORTED;
2238                         break;
2239                 }
2240
2241                 tx_mcs_set &= ~(0x3 << (nss * 2));
2242                 tx_mcs_set |= mcs << (nss * 2);
2243         }
2244
2245         return tx_mcs_set;
2246 }
2247
2248 static bool
2249 ath11k_peer_assoc_h_he_masked(const u16 *he_mcs_mask)
2250 {
2251         int nss;
2252
2253         for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++)
2254                 if (he_mcs_mask[nss])
2255                         return false;
2256
2257         return true;
2258 }
2259
2260 static void ath11k_peer_assoc_h_he(struct ath11k *ar,
2261                                    struct ieee80211_vif *vif,
2262                                    struct ieee80211_sta *sta,
2263                                    struct peer_assoc_params *arg)
2264 {
2265         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2266         struct cfg80211_chan_def def;
2267         const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2268         enum nl80211_band band;
2269         u16 he_mcs_mask[NL80211_HE_NSS_MAX];
2270         u8 max_nss, he_mcs;
2271         u16 he_tx_mcs = 0, v = 0;
2272         int i, he_nss, nss_idx;
2273         bool user_rate_valid = true;
2274         u32 rx_nss, tx_nss, nss_160;
2275         u8 ampdu_factor, rx_mcs_80, rx_mcs_160;
2276         u16 mcs_160_map, mcs_80_map;
2277         bool support_160;
2278
2279         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2280                 return;
2281
2282         if (!he_cap->has_he)
2283                 return;
2284
2285         band = def.chan->band;
2286         memcpy(he_mcs_mask, arvif->bitrate_mask.control[band].he_mcs,
2287                sizeof(he_mcs_mask));
2288
2289         if (ath11k_peer_assoc_h_he_masked(he_mcs_mask))
2290                 return;
2291
2292         arg->he_flag = true;
2293         support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] &
2294                   IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G);
2295
2296         /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */
2297         mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2298         mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2299
2300         if (support_160) {
2301                 for (i = 7; i >= 0; i--) {
2302                         u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;
2303
2304                         if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2305                                 rx_mcs_160 = i + 1;
2306                                 break;
2307                         }
2308                 }
2309         }
2310
2311         for (i = 7; i >= 0; i--) {
2312                 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;
2313
2314                 if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2315                         rx_mcs_80 = i + 1;
2316                         break;
2317                 }
2318         }
2319
2320         if (support_160)
2321                 max_nss = min(rx_mcs_80, rx_mcs_160);
2322         else
2323                 max_nss = rx_mcs_80;
2324
2325         arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2326
2327         memcpy_and_pad(&arg->peer_he_cap_macinfo,
2328                        sizeof(arg->peer_he_cap_macinfo),
2329                        he_cap->he_cap_elem.mac_cap_info,
2330                        sizeof(he_cap->he_cap_elem.mac_cap_info),
2331                        0);
2332         memcpy_and_pad(&arg->peer_he_cap_phyinfo,
2333                        sizeof(arg->peer_he_cap_phyinfo),
2334                        he_cap->he_cap_elem.phy_cap_info,
2335                        sizeof(he_cap->he_cap_elem.phy_cap_info),
2336                        0);
2337         arg->peer_he_ops = vif->bss_conf.he_oper.params;
2338
2339         /* the top most byte is used to indicate BSS color info */
2340         arg->peer_he_ops &= 0xffffff;
2341
2342         /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension
2343          * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing
2344          * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present).
2345          *
2346          * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps,
2347          * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
2348          * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
2349          * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
2350          * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
2351          * length.
2352          */
2353         ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3],
2354                                    IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK);
2355
2356         if (ampdu_factor) {
2357                 if (sta->deflink.vht_cap.vht_supported)
2358                         arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
2359                                                     ampdu_factor)) - 1;
2360                 else if (sta->deflink.ht_cap.ht_supported)
2361                         arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
2362                                                     ampdu_factor)) - 1;
2363         }
2364
2365         if (he_cap->he_cap_elem.phy_cap_info[6] &
2366             IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
2367                 int bit = 7;
2368                 int nss, ru;
2369
2370                 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
2371                                           IEEE80211_PPE_THRES_NSS_MASK;
2372                 arg->peer_ppet.ru_bit_mask =
2373                         (he_cap->ppe_thres[0] &
2374                          IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
2375                         IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
2376
2377                 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
2378                         for (ru = 0; ru < 4; ru++) {
2379                                 u32 val = 0;
2380                                 int i;
2381
2382                                 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
2383                                         continue;
2384                                 for (i = 0; i < 6; i++) {
2385                                         val >>= 1;
2386                                         val |= ((he_cap->ppe_thres[bit / 8] >>
2387                                                  (bit % 8)) & 0x1) << 5;
2388                                         bit++;
2389                                 }
2390                                 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
2391                                                                 val << (ru * 6);
2392                         }
2393                 }
2394         }
2395
2396         if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
2397                 arg->twt_responder = true;
2398         if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
2399                 arg->twt_requester = true;
2400
2401         he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
2402
2403         if (he_nss > sta->deflink.rx_nss) {
2404                 user_rate_valid = false;
2405                 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2406                         if (he_mcs_mask[nss_idx]) {
2407                                 user_rate_valid = true;
2408                                 break;
2409                         }
2410                 }
2411         }
2412
2413         if (!user_rate_valid) {
2414                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting he range mcs value to peer supported nss %d for peer %pM\n",
2415                            sta->deflink.rx_nss, sta->addr);
2416                 he_mcs_mask[sta->deflink.rx_nss - 1] = he_mcs_mask[he_nss - 1];
2417         }
2418
2419         switch (sta->deflink.bandwidth) {
2420         case IEEE80211_STA_RX_BW_160:
2421                 if (he_cap->he_cap_elem.phy_cap_info[0] &
2422                     IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2423                         v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
2424                         v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2425                         arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2426
2427                         v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
2428                         arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2429
2430                         arg->peer_he_mcs_count++;
2431                         he_tx_mcs = v;
2432                 }
2433                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2434                 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2435
2436                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
2437                 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2438                 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2439
2440                 arg->peer_he_mcs_count++;
2441                 if (!he_tx_mcs)
2442                         he_tx_mcs = v;
2443                 fallthrough;
2444
2445         default:
2446                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2447                 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2448
2449                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
2450                 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2451                 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2452
2453                 arg->peer_he_mcs_count++;
2454                 if (!he_tx_mcs)
2455                         he_tx_mcs = v;
2456                 break;
2457         }
2458
2459         /* Calculate peer NSS capability from HE capabilities if STA
2460          * supports HE.
2461          */
2462         for (i = 0, max_nss = 0; i < NL80211_HE_NSS_MAX; i++) {
2463                 he_mcs = he_tx_mcs >> (2 * i) & 3;
2464
2465                 /* In case of fixed rates, MCS Range in he_tx_mcs might have
2466                  * unsupported range, with he_mcs_mask set, so check either of them
2467                  * to find nss.
2468                  */
2469                 if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
2470                     he_mcs_mask[i])
2471                         max_nss = i + 1;
2472         }
2473         arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2474
2475         if (arg->peer_phymode == MODE_11AX_HE160 ||
2476             arg->peer_phymode == MODE_11AX_HE80_80) {
2477                 tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2478                 rx_nss = min(arg->peer_nss, tx_nss);
2479                 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2480
2481                 if (!rx_nss) {
2482                         ath11k_warn(ar->ab, "invalid max_nss\n");
2483                         return;
2484                 }
2485
2486                 if (arg->peer_phymode == MODE_11AX_HE160)
2487                         nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2488                 else
2489                         nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2490
2491                 arg->peer_bw_rxnss_override |= nss_160;
2492         }
2493
2494         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2495                    "he peer %pM nss %d mcs cnt %d nss_override 0x%x\n",
2496                    sta->addr, arg->peer_nss,
2497                    arg->peer_he_mcs_count,
2498                    arg->peer_bw_rxnss_override);
2499 }
2500
2501 static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar,
2502                                         struct ieee80211_vif *vif,
2503                                         struct ieee80211_sta *sta,
2504                                         struct peer_assoc_params *arg)
2505 {
2506         const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2507         struct cfg80211_chan_def def;
2508         enum nl80211_band band;
2509         u8  ampdu_factor;
2510
2511         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2512                 return;
2513
2514         band = def.chan->band;
2515
2516         if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->deflink.he_6ghz_capa.capa)
2517                 return;
2518
2519         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2520                 arg->bw_40 = true;
2521
2522         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2523                 arg->bw_80 = true;
2524
2525         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2526                 arg->bw_160 = true;
2527
2528         arg->peer_he_caps_6ghz = le16_to_cpu(sta->deflink.he_6ghz_capa.capa);
2529         arg->peer_mpdu_density =
2530                 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
2531                                                    arg->peer_he_caps_6ghz));
2532
2533         /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
2534          * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
2535          * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
2536          * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
2537          * Band Capabilities element in the 6 GHz band.
2538          *
2539          * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
2540          * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
2541          */
2542         ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
2543                                  he_cap->he_cap_elem.mac_cap_info[3]) +
2544                         FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
2545                                   arg->peer_he_caps_6ghz);
2546
2547         arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
2548                                      ampdu_factor)) - 1;
2549 }
2550
2551 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
2552                                      struct peer_assoc_params *arg)
2553 {
2554         const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2555         int smps;
2556
2557         if (!ht_cap->ht_supported && !sta->deflink.he_6ghz_capa.capa)
2558                 return;
2559
2560         if (ht_cap->ht_supported) {
2561                 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2562                 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2563         } else {
2564                 smps = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
2565                                      IEEE80211_HE_6GHZ_CAP_SM_PS);
2566         }
2567
2568         switch (smps) {
2569         case WLAN_HT_CAP_SM_PS_STATIC:
2570                 arg->static_mimops_flag = true;
2571                 break;
2572         case WLAN_HT_CAP_SM_PS_DYNAMIC:
2573                 arg->dynamic_mimops_flag = true;
2574                 break;
2575         case WLAN_HT_CAP_SM_PS_DISABLED:
2576                 arg->spatial_mux_flag = true;
2577                 break;
2578         default:
2579                 break;
2580         }
2581 }
2582
2583 static void ath11k_peer_assoc_h_qos(struct ath11k *ar,
2584                                     struct ieee80211_vif *vif,
2585                                     struct ieee80211_sta *sta,
2586                                     struct peer_assoc_params *arg)
2587 {
2588         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2589
2590         switch (arvif->vdev_type) {
2591         case WMI_VDEV_TYPE_AP:
2592                 if (sta->wme) {
2593                         /* TODO: Check WME vs QoS */
2594                         arg->is_wme_set = true;
2595                         arg->qos_flag = true;
2596                 }
2597
2598                 if (sta->wme && sta->uapsd_queues) {
2599                         /* TODO: Check WME vs QoS */
2600                         arg->is_wme_set = true;
2601                         arg->apsd_flag = true;
2602                         arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
2603                 }
2604                 break;
2605         case WMI_VDEV_TYPE_STA:
2606                 if (sta->wme) {
2607                         arg->is_wme_set = true;
2608                         arg->qos_flag = true;
2609                 }
2610                 break;
2611         default:
2612                 break;
2613         }
2614
2615         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "peer %pM qos %d\n",
2616                    sta->addr, arg->qos_flag);
2617 }
2618
2619 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar,
2620                                     struct ath11k_vif *arvif,
2621                                     struct ieee80211_sta *sta)
2622 {
2623         struct ap_ps_params params;
2624         u32 max_sp;
2625         u32 uapsd;
2626         int ret;
2627
2628         lockdep_assert_held(&ar->conf_mutex);
2629
2630         params.vdev_id = arvif->vdev_id;
2631
2632         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "uapsd_queues 0x%x max_sp %d\n",
2633                    sta->uapsd_queues, sta->max_sp);
2634
2635         uapsd = 0;
2636         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2637                 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2638                          WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2639         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2640                 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2641                          WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2642         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2643                 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2644                          WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2645         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2646                 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2647                          WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2648
2649         max_sp = 0;
2650         if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2651                 max_sp = sta->max_sp;
2652
2653         params.param = WMI_AP_PS_PEER_PARAM_UAPSD;
2654         params.value = uapsd;
2655         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2656         if (ret)
2657                 goto err;
2658
2659         params.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
2660         params.value = max_sp;
2661         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2662         if (ret)
2663                 goto err;
2664
2665         /* TODO revisit during testing */
2666         params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
2667         params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2668         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2669         if (ret)
2670                 goto err;
2671
2672         params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
2673         params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2674         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2675         if (ret)
2676                 goto err;
2677
2678         return 0;
2679
2680 err:
2681         ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
2682                     params.param, arvif->vdev_id, ret);
2683         return ret;
2684 }
2685
2686 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2687 {
2688         return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2689                ATH11K_MAC_FIRST_OFDM_RATE_IDX;
2690 }
2691
2692 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar,
2693                                                     struct ieee80211_sta *sta)
2694 {
2695         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2696                 switch (sta->deflink.vht_cap.cap &
2697                         IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2698                 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2699                         return MODE_11AC_VHT160;
2700                 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2701                         return MODE_11AC_VHT80_80;
2702                 default:
2703                         /* not sure if this is a valid case? */
2704                         return MODE_11AC_VHT160;
2705                 }
2706         }
2707
2708         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2709                 return MODE_11AC_VHT80;
2710
2711         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2712                 return MODE_11AC_VHT40;
2713
2714         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2715                 return MODE_11AC_VHT20;
2716
2717         return MODE_UNKNOWN;
2718 }
2719
2720 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar,
2721                                                    struct ieee80211_sta *sta)
2722 {
2723         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2724                 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2725                      IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
2726                         return MODE_11AX_HE160;
2727                 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2728                          IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
2729                         return MODE_11AX_HE80_80;
2730                 /* not sure if this is a valid case? */
2731                 return MODE_11AX_HE160;
2732         }
2733
2734         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2735                 return MODE_11AX_HE80;
2736
2737         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2738                 return MODE_11AX_HE40;
2739
2740         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2741                 return MODE_11AX_HE20;
2742
2743         return MODE_UNKNOWN;
2744 }
2745
2746 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar,
2747                                         struct ieee80211_vif *vif,
2748                                         struct ieee80211_sta *sta,
2749                                         struct peer_assoc_params *arg)
2750 {
2751         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2752         struct cfg80211_chan_def def;
2753         enum nl80211_band band;
2754         const u8 *ht_mcs_mask;
2755         const u16 *vht_mcs_mask;
2756         const u16 *he_mcs_mask;
2757         enum wmi_phy_mode phymode = MODE_UNKNOWN;
2758
2759         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2760                 return;
2761
2762         band = def.chan->band;
2763         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2764         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2765         he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2766
2767         switch (band) {
2768         case NL80211_BAND_2GHZ:
2769                 if (sta->deflink.he_cap.has_he &&
2770                     !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2771                         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2772                                 phymode = MODE_11AX_HE80_2G;
2773                         else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2774                                 phymode = MODE_11AX_HE40_2G;
2775                         else
2776                                 phymode = MODE_11AX_HE20_2G;
2777                 } else if (sta->deflink.vht_cap.vht_supported &&
2778                            !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2779                         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2780                                 phymode = MODE_11AC_VHT40;
2781                         else
2782                                 phymode = MODE_11AC_VHT20;
2783                 } else if (sta->deflink.ht_cap.ht_supported &&
2784                            !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2785                         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2786                                 phymode = MODE_11NG_HT40;
2787                         else
2788                                 phymode = MODE_11NG_HT20;
2789                 } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
2790                         phymode = MODE_11G;
2791                 } else {
2792                         phymode = MODE_11B;
2793                 }
2794                 break;
2795         case NL80211_BAND_5GHZ:
2796         case NL80211_BAND_6GHZ:
2797                 /* Check HE first */
2798                 if (sta->deflink.he_cap.has_he &&
2799                     !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2800                         phymode = ath11k_mac_get_phymode_he(ar, sta);
2801                 } else if (sta->deflink.vht_cap.vht_supported &&
2802                            !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2803                         phymode = ath11k_mac_get_phymode_vht(ar, sta);
2804                 } else if (sta->deflink.ht_cap.ht_supported &&
2805                            !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2806                         if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2807                                 phymode = MODE_11NA_HT40;
2808                         else
2809                                 phymode = MODE_11NA_HT20;
2810                 } else {
2811                         phymode = MODE_11A;
2812                 }
2813                 break;
2814         default:
2815                 break;
2816         }
2817
2818         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "peer %pM phymode %s\n",
2819                    sta->addr, ath11k_wmi_phymode_str(phymode));
2820
2821         arg->peer_phymode = phymode;
2822         WARN_ON(phymode == MODE_UNKNOWN);
2823 }
2824
2825 static void ath11k_peer_assoc_prepare(struct ath11k *ar,
2826                                       struct ieee80211_vif *vif,
2827                                       struct ieee80211_sta *sta,
2828                                       struct peer_assoc_params *arg,
2829                                       bool reassoc)
2830 {
2831         struct ath11k_sta *arsta;
2832
2833         lockdep_assert_held(&ar->conf_mutex);
2834
2835         arsta = ath11k_sta_to_arsta(sta);
2836
2837         memset(arg, 0, sizeof(*arg));
2838
2839         reinit_completion(&ar->peer_assoc_done);
2840
2841         arg->peer_new_assoc = !reassoc;
2842         ath11k_peer_assoc_h_basic(ar, vif, sta, arg);
2843         ath11k_peer_assoc_h_crypto(ar, vif, sta, arg);
2844         ath11k_peer_assoc_h_rates(ar, vif, sta, arg);
2845         ath11k_peer_assoc_h_phymode(ar, vif, sta, arg);
2846         ath11k_peer_assoc_h_ht(ar, vif, sta, arg);
2847         ath11k_peer_assoc_h_vht(ar, vif, sta, arg);
2848         ath11k_peer_assoc_h_he(ar, vif, sta, arg);
2849         ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg);
2850         ath11k_peer_assoc_h_qos(ar, vif, sta, arg);
2851         ath11k_peer_assoc_h_smps(sta, arg);
2852
2853         arsta->peer_nss = arg->peer_nss;
2854
2855         /* TODO: amsdu_disable req? */
2856 }
2857
2858 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif,
2859                                   const u8 *addr,
2860                                   const struct ieee80211_sta_ht_cap *ht_cap,
2861                                   u16 he_6ghz_capa)
2862 {
2863         int smps;
2864
2865         if (!ht_cap->ht_supported && !he_6ghz_capa)
2866                 return 0;
2867
2868         if (ht_cap->ht_supported) {
2869                 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2870                 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2871         } else {
2872                 smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa);
2873         }
2874
2875         if (smps >= ARRAY_SIZE(ath11k_smps_map))
2876                 return -EINVAL;
2877
2878         return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
2879                                          WMI_PEER_MIMO_PS_STATE,
2880                                          ath11k_smps_map[smps]);
2881 }
2882
2883 static bool ath11k_mac_set_he_txbf_conf(struct ath11k_vif *arvif)
2884 {
2885         struct ath11k *ar = arvif->ar;
2886         u32 param, value;
2887         int ret;
2888
2889         if (!arvif->vif->bss_conf.he_support)
2890                 return true;
2891
2892         param = WMI_VDEV_PARAM_SET_HEMU_MODE;
2893         value = 0;
2894         if (arvif->vif->bss_conf.he_su_beamformer) {
2895                 value |= FIELD_PREP(HE_MODE_SU_TX_BFER, HE_SU_BFER_ENABLE);
2896                 if (arvif->vif->bss_conf.he_mu_beamformer &&
2897                     arvif->vdev_type == WMI_VDEV_TYPE_AP)
2898                         value |= FIELD_PREP(HE_MODE_MU_TX_BFER, HE_MU_BFER_ENABLE);
2899         }
2900
2901         if (arvif->vif->type != NL80211_IFTYPE_MESH_POINT) {
2902                 value |= FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
2903                          FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
2904
2905                 if (arvif->vif->bss_conf.he_full_ul_mumimo)
2906                         value |= FIELD_PREP(HE_MODE_UL_MUMIMO, HE_UL_MUMIMO_ENABLE);
2907
2908                 if (arvif->vif->bss_conf.he_su_beamformee)
2909                         value |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2910         }
2911
2912         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, value);
2913         if (ret) {
2914                 ath11k_warn(ar->ab, "failed to set vdev %d HE MU mode: %d\n",
2915                             arvif->vdev_id, ret);
2916                 return false;
2917         }
2918
2919         param = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
2920         value = FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
2921                 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
2922                            HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
2923         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2924                                             param, value);
2925         if (ret) {
2926                 ath11k_warn(ar->ab, "failed to set vdev %d sounding mode: %d\n",
2927                             arvif->vdev_id, ret);
2928                 return false;
2929         }
2930         return true;
2931 }
2932
2933 static bool ath11k_mac_vif_recalc_sta_he_txbf(struct ath11k *ar,
2934                                               struct ieee80211_vif *vif,
2935                                               struct ieee80211_sta_he_cap *he_cap)
2936 {
2937         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
2938         struct ieee80211_he_cap_elem he_cap_elem = {0};
2939         struct ieee80211_sta_he_cap *cap_band = NULL;
2940         struct cfg80211_chan_def def;
2941         u32 param = WMI_VDEV_PARAM_SET_HEMU_MODE;
2942         u32 hemode = 0;
2943         int ret;
2944
2945         if (!vif->bss_conf.he_support)
2946                 return true;
2947
2948         if (vif->type != NL80211_IFTYPE_STATION)
2949                 return false;
2950
2951         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2952                 return false;
2953
2954         if (def.chan->band == NL80211_BAND_2GHZ)
2955                 cap_band = &ar->mac.iftype[NL80211_BAND_2GHZ][vif->type].he_cap;
2956         else
2957                 cap_band = &ar->mac.iftype[NL80211_BAND_5GHZ][vif->type].he_cap;
2958
2959         memcpy(&he_cap_elem, &cap_band->he_cap_elem, sizeof(he_cap_elem));
2960
2961         if (HECAP_PHY_SUBFME_GET(he_cap_elem.phy_cap_info)) {
2962                 if (HECAP_PHY_SUBFMR_GET(he_cap->he_cap_elem.phy_cap_info))
2963                         hemode |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2964                 if (HECAP_PHY_MUBFMR_GET(he_cap->he_cap_elem.phy_cap_info))
2965                         hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
2966         }
2967
2968         if (vif->type != NL80211_IFTYPE_MESH_POINT) {
2969                 hemode |= FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
2970                           FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
2971
2972                 if (HECAP_PHY_ULMUMIMO_GET(he_cap_elem.phy_cap_info))
2973                         if (HECAP_PHY_ULMUMIMO_GET(he_cap->he_cap_elem.phy_cap_info))
2974                                 hemode |= FIELD_PREP(HE_MODE_UL_MUMIMO,
2975                                                      HE_UL_MUMIMO_ENABLE);
2976
2977                 if (FIELD_GET(HE_MODE_MU_TX_BFEE, hemode))
2978                         hemode |= FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE);
2979
2980                 if (FIELD_GET(HE_MODE_MU_TX_BFER, hemode))
2981                         hemode |= FIELD_PREP(HE_MODE_SU_TX_BFER, HE_SU_BFER_ENABLE);
2982         }
2983
2984         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param, hemode);
2985         if (ret) {
2986                 ath11k_warn(ar->ab, "failed to submit vdev param txbf 0x%x: %d\n",
2987                             hemode, ret);
2988                 return false;
2989         }
2990
2991         return true;
2992 }
2993
2994 static void ath11k_bss_assoc(struct ieee80211_hw *hw,
2995                              struct ieee80211_vif *vif,
2996                              struct ieee80211_bss_conf *bss_conf)
2997 {
2998         struct ath11k *ar = hw->priv;
2999         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3000         struct peer_assoc_params peer_arg;
3001         struct ieee80211_sta *ap_sta;
3002         struct ath11k_peer *peer;
3003         bool is_auth = false;
3004         struct ieee80211_sta_he_cap  he_cap;
3005         int ret;
3006
3007         lockdep_assert_held(&ar->conf_mutex);
3008
3009         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i assoc bssid %pM aid %d\n",
3010                    arvif->vdev_id, arvif->bssid, arvif->aid);
3011
3012         rcu_read_lock();
3013
3014         ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
3015         if (!ap_sta) {
3016                 ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
3017                             bss_conf->bssid, arvif->vdev_id);
3018                 rcu_read_unlock();
3019                 return;
3020         }
3021
3022         /* he_cap here is updated at assoc success for sta mode only */
3023         he_cap  = ap_sta->deflink.he_cap;
3024
3025         ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);
3026
3027         rcu_read_unlock();
3028
3029         peer_arg.is_assoc = true;
3030         ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
3031         if (ret) {
3032                 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
3033                             bss_conf->bssid, arvif->vdev_id, ret);
3034                 return;
3035         }
3036
3037         if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
3038                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
3039                             bss_conf->bssid, arvif->vdev_id);
3040                 return;
3041         }
3042
3043         ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid,
3044                                      &ap_sta->deflink.ht_cap,
3045                                      le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa));
3046         if (ret) {
3047                 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
3048                             arvif->vdev_id, ret);
3049                 return;
3050         }
3051
3052         if (!ath11k_mac_vif_recalc_sta_he_txbf(ar, vif, &he_cap)) {
3053                 ath11k_warn(ar->ab, "failed to recalc he txbf for vdev %i on bss %pM\n",
3054                             arvif->vdev_id, bss_conf->bssid);
3055                 return;
3056         }
3057
3058         WARN_ON(arvif->is_up);
3059
3060         arvif->aid = vif->cfg.aid;
3061         ether_addr_copy(arvif->bssid, bss_conf->bssid);
3062
3063         ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid,
3064                                  NULL, 0, 0);
3065         if (ret) {
3066                 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
3067                             arvif->vdev_id, ret);
3068                 return;
3069         }
3070
3071         arvif->is_up = true;
3072         arvif->rekey_data.enable_offload = false;
3073
3074         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3075                    "vdev %d up (associated) bssid %pM aid %d\n",
3076                    arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
3077
3078         spin_lock_bh(&ar->ab->base_lock);
3079
3080         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
3081         if (peer && peer->is_authorized)
3082                 is_auth = true;
3083
3084         spin_unlock_bh(&ar->ab->base_lock);
3085
3086         if (is_auth) {
3087                 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid,
3088                                                 arvif->vdev_id,
3089                                                 WMI_PEER_AUTHORIZE,
3090                                                 1);
3091                 if (ret)
3092                         ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
3093         }
3094
3095         ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
3096                                            &bss_conf->he_obss_pd);
3097         if (ret)
3098                 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
3099                             arvif->vdev_id, ret);
3100
3101         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3102                                             WMI_VDEV_PARAM_DTIM_POLICY,
3103                                             WMI_DTIM_POLICY_STICK);
3104         if (ret)
3105                 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n",
3106                             arvif->vdev_id, ret);
3107
3108         ath11k_mac_11d_scan_stop_all(ar->ab);
3109 }
3110
3111 static void ath11k_bss_disassoc(struct ieee80211_hw *hw,
3112                                 struct ieee80211_vif *vif)
3113 {
3114         struct ath11k *ar = hw->priv;
3115         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3116         int ret;
3117
3118         lockdep_assert_held(&ar->conf_mutex);
3119
3120         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %i disassoc bssid %pM\n",
3121                    arvif->vdev_id, arvif->bssid);
3122
3123         ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
3124         if (ret)
3125                 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n",
3126                             arvif->vdev_id, ret);
3127
3128         arvif->is_up = false;
3129
3130         memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data));
3131
3132         cancel_delayed_work_sync(&arvif->connection_loss_work);
3133 }
3134
3135 static u32 ath11k_mac_get_rate_hw_value(int bitrate)
3136 {
3137         u32 preamble;
3138         u16 hw_value;
3139         int rate;
3140         size_t i;
3141
3142         if (ath11k_mac_bitrate_is_cck(bitrate))
3143                 preamble = WMI_RATE_PREAMBLE_CCK;
3144         else
3145                 preamble = WMI_RATE_PREAMBLE_OFDM;
3146
3147         for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) {
3148                 if (ath11k_legacy_rates[i].bitrate != bitrate)
3149                         continue;
3150
3151                 hw_value = ath11k_legacy_rates[i].hw_value;
3152                 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3153
3154                 return rate;
3155         }
3156
3157         return -EINVAL;
3158 }
3159
3160 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar,
3161                                          struct ieee80211_vif *vif,
3162                                          struct cfg80211_chan_def *def)
3163 {
3164         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3165         const struct ieee80211_supported_band *sband;
3166         u8 basic_rate_idx;
3167         int hw_rate_code;
3168         u32 vdev_param;
3169         u16 bitrate;
3170         int ret;
3171
3172         lockdep_assert_held(&ar->conf_mutex);
3173
3174         sband = ar->hw->wiphy->bands[def->chan->band];
3175         basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
3176         bitrate = sband->bitrates[basic_rate_idx].bitrate;
3177
3178         hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate);
3179         if (hw_rate_code < 0) {
3180                 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
3181                 return;
3182         }
3183
3184         vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
3185         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
3186                                             hw_rate_code);
3187         if (ret)
3188                 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
3189
3190         /* For WCN6855, firmware will clear this param when vdev starts, hence
3191          * cache it here so that we can reconfigure it once vdev starts.
3192          */
3193         ar->hw_rate_code = hw_rate_code;
3194
3195         vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
3196         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
3197                                             hw_rate_code);
3198         if (ret)
3199                 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
3200 }
3201
3202 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif,
3203                                      struct ieee80211_bss_conf *info)
3204 {
3205         struct ath11k *ar = arvif->ar;
3206         struct sk_buff *tmpl;
3207         int ret;
3208         u32 interval;
3209         bool unsol_bcast_probe_resp_enabled = false;
3210
3211         if (info->fils_discovery.max_interval) {
3212                 interval = info->fils_discovery.max_interval;
3213
3214                 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
3215                 if (tmpl)
3216                         ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
3217                                                              tmpl);
3218         } else if (info->unsol_bcast_probe_resp_interval) {
3219                 unsol_bcast_probe_resp_enabled = 1;
3220                 interval = info->unsol_bcast_probe_resp_interval;
3221
3222                 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
3223                                                                  arvif->vif);
3224                 if (tmpl)
3225                         ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
3226                                                          tmpl);
3227         } else { /* Disable */
3228                 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
3229         }
3230
3231         if (!tmpl) {
3232                 ath11k_warn(ar->ab,
3233                             "mac vdev %i failed to retrieve %s template\n",
3234                             arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
3235                             "unsolicited broadcast probe response" :
3236                             "FILS discovery"));
3237                 return -EPERM;
3238         }
3239         kfree_skb(tmpl);
3240
3241         if (!ret)
3242                 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
3243                                                 unsol_bcast_probe_resp_enabled);
3244
3245         return ret;
3246 }
3247
3248 static int ath11k_mac_config_obss_pd(struct ath11k *ar,
3249                                      struct ieee80211_he_obss_pd *he_obss_pd)
3250 {
3251         u32 bitmap[2], param_id, param_val, pdev_id;
3252         int ret;
3253         s8 non_srg_th = 0, srg_th = 0;
3254
3255         pdev_id = ar->pdev->pdev_id;
3256
3257         /* Set and enable SRG/non-SRG OBSS PD Threshold */
3258         param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD;
3259         if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
3260                 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id);
3261                 if (ret)
3262                         ath11k_warn(ar->ab,
3263                                     "failed to set obss_pd_threshold for pdev: %u\n",
3264                                     pdev_id);
3265                 return ret;
3266         }
3267
3268         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3269                    "obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n",
3270                    he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset,
3271                    he_obss_pd->max_offset);
3272
3273         param_val = 0;
3274
3275         if (he_obss_pd->sr_ctrl &
3276             IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) {
3277                 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD;
3278         } else {
3279                 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
3280                         non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD +
3281                                       he_obss_pd->non_srg_max_offset);
3282                 else
3283                         non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD;
3284
3285                 param_val |= ATH11K_OBSS_PD_NON_SRG_EN;
3286         }
3287
3288         if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) {
3289                 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset;
3290                 param_val |= ATH11K_OBSS_PD_SRG_EN;
3291         }
3292
3293         if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3294                      ar->ab->wmi_ab.svc_map)) {
3295                 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM;
3296                 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th);
3297         } else {
3298                 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR;
3299                 /* SRG not supported and threshold in dB */
3300                 param_val &= ~(ATH11K_OBSS_PD_SRG_EN |
3301                                ATH11K_OBSS_PD_THRESHOLD_IN_DBM);
3302         }
3303
3304         param_val |= (non_srg_th & GENMASK(7, 0));
3305         ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3306         if (ret) {
3307                 ath11k_warn(ar->ab,
3308                             "failed to set obss_pd_threshold for pdev: %u\n",
3309                             pdev_id);
3310                 return ret;
3311         }
3312
3313         /* Enable OBSS PD for all access category */
3314         param_id  = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC;
3315         param_val = 0xf;
3316         ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3317         if (ret) {
3318                 ath11k_warn(ar->ab,
3319                             "failed to set obss_pd_per_ac for pdev: %u\n",
3320                             pdev_id);
3321                 return ret;
3322         }
3323
3324         /* Set SR Prohibit */
3325         param_id  = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT;
3326         param_val = !!(he_obss_pd->sr_ctrl &
3327                        IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED);
3328         ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3329         if (ret) {
3330                 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n",
3331                             pdev_id);
3332                 return ret;
3333         }
3334
3335         if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3336                       ar->ab->wmi_ab.svc_map))
3337                 return 0;
3338
3339         /* Set SRG BSS Color Bitmap */
3340         memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));
3341         ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap);
3342         if (ret) {
3343                 ath11k_warn(ar->ab,
3344                             "failed to set bss_color_bitmap for pdev: %u\n",
3345                             pdev_id);
3346                 return ret;
3347         }
3348
3349         /* Set SRG Partial BSSID Bitmap */
3350         memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));
3351         ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap);
3352         if (ret) {
3353                 ath11k_warn(ar->ab,
3354                             "failed to set partial_bssid_bitmap for pdev: %u\n",
3355                             pdev_id);
3356                 return ret;
3357         }
3358
3359         memset(bitmap, 0xff, sizeof(bitmap));
3360
3361         /* Enable all BSS Colors for SRG */
3362         ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap);
3363         if (ret) {
3364                 ath11k_warn(ar->ab,
3365                             "failed to set srg_color_en_bitmap pdev: %u\n",
3366                             pdev_id);
3367                 return ret;
3368         }
3369
3370         /* Enable all partial BSSID mask for SRG */
3371         ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap);
3372         if (ret) {
3373                 ath11k_warn(ar->ab,
3374                             "failed to set srg_bssid_en_bitmap pdev: %u\n",
3375                             pdev_id);
3376                 return ret;
3377         }
3378
3379         /* Enable all BSS Colors for non-SRG */
3380         ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap);
3381         if (ret) {
3382                 ath11k_warn(ar->ab,
3383                             "failed to set non_srg_color_en_bitmap pdev: %u\n",
3384                             pdev_id);
3385                 return ret;
3386         }
3387
3388         /* Enable all partial BSSID mask for non-SRG */
3389         ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap);
3390         if (ret) {
3391                 ath11k_warn(ar->ab,
3392                             "failed to set non_srg_bssid_en_bitmap pdev: %u\n",
3393                             pdev_id);
3394                 return ret;
3395         }
3396
3397         return 0;
3398 }
3399
3400 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw,
3401                                            struct ieee80211_vif *vif,
3402                                            struct ieee80211_bss_conf *info,
3403                                            u64 changed)
3404 {
3405         struct ath11k *ar = hw->priv;
3406         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3407         struct cfg80211_chan_def def;
3408         u32 param_id, param_value;
3409         enum nl80211_band band;
3410         u32 vdev_param;
3411         int mcast_rate;
3412         u32 preamble;
3413         u16 hw_value;
3414         u16 bitrate;
3415         int ret = 0;
3416         u8 rateidx;
3417         u32 rate, param;
3418         u32 ipv4_cnt;
3419
3420         mutex_lock(&ar->conf_mutex);
3421
3422         if (changed & BSS_CHANGED_BEACON_INT) {
3423                 arvif->beacon_interval = info->beacon_int;
3424
3425                 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL;
3426                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3427                                                     param_id,
3428                                                     arvif->beacon_interval);
3429                 if (ret)
3430                         ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n",
3431                                     arvif->vdev_id);
3432                 else
3433                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3434                                    "Beacon interval: %d set for VDEV: %d\n",
3435                                    arvif->beacon_interval, arvif->vdev_id);
3436         }
3437
3438         if (changed & BSS_CHANGED_BEACON) {
3439                 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE;
3440                 param_value = WMI_BEACON_STAGGERED_MODE;
3441                 ret = ath11k_wmi_pdev_set_param(ar, param_id,
3442                                                 param_value, ar->pdev->pdev_id);
3443                 if (ret)
3444                         ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n",
3445                                     arvif->vdev_id);
3446                 else
3447                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3448                                    "Set staggered beacon mode for VDEV: %d\n",
3449                                    arvif->vdev_id);
3450
3451                 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) {
3452                         ret = ath11k_mac_setup_bcn_tmpl(arvif);
3453                         if (ret)
3454                                 ath11k_warn(ar->ab, "failed to update bcn template: %d\n",
3455                                             ret);
3456                 }
3457
3458                 if (arvif->bcca_zero_sent)
3459                         arvif->do_not_send_tmpl = true;
3460                 else
3461                         arvif->do_not_send_tmpl = false;
3462
3463                 if (vif->bss_conf.he_support) {
3464                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3465                                                             WMI_VDEV_PARAM_BA_MODE,
3466                                                             WMI_BA_MODE_BUFFER_SIZE_256);
3467                         if (ret)
3468                                 ath11k_warn(ar->ab,
3469                                             "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
3470                                             arvif->vdev_id);
3471                         else
3472                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3473                                            "Set BA BUFFER SIZE 256 for VDEV: %d\n",
3474                                            arvif->vdev_id);
3475                 }
3476         }
3477
3478         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3479                 arvif->dtim_period = info->dtim_period;
3480
3481                 param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
3482                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3483                                                     param_id,
3484                                                     arvif->dtim_period);
3485
3486                 if (ret)
3487                         ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
3488                                     arvif->vdev_id, ret);
3489                 else
3490                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3491                                    "DTIM period: %d set for VDEV: %d\n",
3492                                    arvif->dtim_period, arvif->vdev_id);
3493         }
3494
3495         if (changed & BSS_CHANGED_SSID &&
3496             vif->type == NL80211_IFTYPE_AP) {
3497                 arvif->u.ap.ssid_len = vif->cfg.ssid_len;
3498                 if (vif->cfg.ssid_len)
3499                         memcpy(arvif->u.ap.ssid, vif->cfg.ssid,
3500                                vif->cfg.ssid_len);
3501                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3502         }
3503
3504         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3505                 ether_addr_copy(arvif->bssid, info->bssid);
3506
3507         if (changed & BSS_CHANGED_BEACON_ENABLED) {
3508                 if (info->enable_beacon)
3509                         ath11k_mac_set_he_txbf_conf(arvif);
3510                 ath11k_control_beaconing(arvif, info);
3511
3512                 if (arvif->is_up && vif->bss_conf.he_support &&
3513                     vif->bss_conf.he_oper.params) {
3514                         param_id = WMI_VDEV_PARAM_HEOPS_0_31;
3515                         param_value = vif->bss_conf.he_oper.params;
3516                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3517                                                             param_id, param_value);
3518                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3519                                    "he oper param: %x set for VDEV: %d\n",
3520                                    param_value, arvif->vdev_id);
3521
3522                         if (ret)
3523                                 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
3524                                             param_value, arvif->vdev_id, ret);
3525                 }
3526         }
3527
3528         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3529                 u32 cts_prot;
3530
3531                 cts_prot = !!(info->use_cts_prot);
3532                 param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
3533
3534                 if (arvif->is_started) {
3535                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3536                                                             param_id, cts_prot);
3537                         if (ret)
3538                                 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
3539                                             arvif->vdev_id);
3540                         else
3541                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
3542                                            cts_prot, arvif->vdev_id);
3543                 } else {
3544                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
3545                 }
3546         }
3547
3548         if (changed & BSS_CHANGED_ERP_SLOT) {
3549                 u32 slottime;
3550
3551                 if (info->use_short_slot)
3552                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3553
3554                 else
3555                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3556
3557                 param_id = WMI_VDEV_PARAM_SLOT_TIME;
3558                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3559                                                     param_id, slottime);
3560                 if (ret)
3561                         ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
3562                                     arvif->vdev_id);
3563                 else
3564                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3565                                    "Set slottime: %d for VDEV: %d\n",
3566                                    slottime, arvif->vdev_id);
3567         }
3568
3569         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3570                 u32 preamble;
3571
3572                 if (info->use_short_preamble)
3573                         preamble = WMI_VDEV_PREAMBLE_SHORT;
3574                 else
3575                         preamble = WMI_VDEV_PREAMBLE_LONG;
3576
3577                 param_id = WMI_VDEV_PARAM_PREAMBLE;
3578                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3579                                                     param_id, preamble);
3580                 if (ret)
3581                         ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
3582                                     arvif->vdev_id);
3583                 else
3584                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3585                                    "Set preamble: %d for VDEV: %d\n",
3586                                    preamble, arvif->vdev_id);
3587         }
3588
3589         if (changed & BSS_CHANGED_ASSOC) {
3590                 if (vif->cfg.assoc)
3591                         ath11k_bss_assoc(hw, vif, info);
3592                 else
3593                         ath11k_bss_disassoc(hw, vif);
3594         }
3595
3596         if (changed & BSS_CHANGED_TXPOWER) {
3597                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev_id %i txpower %d\n",
3598                            arvif->vdev_id, info->txpower);
3599
3600                 arvif->txpower = info->txpower;
3601                 ath11k_mac_txpower_recalc(ar);
3602         }
3603
3604         if (changed & BSS_CHANGED_PS &&
3605             ar->ab->hw_params.supports_sta_ps) {
3606                 arvif->ps = vif->cfg.ps;
3607
3608                 ret = ath11k_mac_config_ps(ar);
3609                 if (ret)
3610                         ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n",
3611                                     arvif->vdev_id, ret);
3612         }
3613
3614         if (changed & BSS_CHANGED_MCAST_RATE &&
3615             !ath11k_mac_vif_chan(arvif->vif, &def)) {
3616                 band = def.chan->band;
3617                 mcast_rate = vif->bss_conf.mcast_rate[band];
3618
3619                 if (mcast_rate > 0)
3620                         rateidx = mcast_rate - 1;
3621                 else
3622                         rateidx = ffs(vif->bss_conf.basic_rates) - 1;
3623
3624                 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
3625                         rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
3626
3627                 bitrate = ath11k_legacy_rates[rateidx].bitrate;
3628                 hw_value = ath11k_legacy_rates[rateidx].hw_value;
3629
3630                 if (ath11k_mac_bitrate_is_cck(bitrate))
3631                         preamble = WMI_RATE_PREAMBLE_CCK;
3632                 else
3633                         preamble = WMI_RATE_PREAMBLE_OFDM;
3634
3635                 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3636
3637                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3638                            "vdev %d mcast_rate %x\n",
3639                            arvif->vdev_id, rate);
3640
3641                 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
3642                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3643                                                     vdev_param, rate);
3644                 if (ret)
3645                         ath11k_warn(ar->ab,
3646                                     "failed to set mcast rate on vdev %i: %d\n",
3647                                     arvif->vdev_id,  ret);
3648
3649                 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
3650                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3651                                                     vdev_param, rate);
3652                 if (ret)
3653                         ath11k_warn(ar->ab,
3654                                     "failed to set bcast rate on vdev %i: %d\n",
3655                                     arvif->vdev_id,  ret);
3656         }
3657
3658         if (changed & BSS_CHANGED_BASIC_RATES &&
3659             !ath11k_mac_vif_chan(arvif->vif, &def))
3660                 ath11k_recalculate_mgmt_rate(ar, vif, &def);
3661
3662         if (changed & BSS_CHANGED_TWT) {
3663                 struct wmi_twt_enable_params twt_params = {0};
3664
3665                 if (info->twt_requester || info->twt_responder) {
3666                         ath11k_wmi_fill_default_twt_params(&twt_params);
3667                         ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id,
3668                                                        &twt_params);
3669                 } else {
3670                         ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
3671                 }
3672         }
3673
3674         if (changed & BSS_CHANGED_HE_OBSS_PD)
3675                 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd);
3676
3677         if (changed & BSS_CHANGED_HE_BSS_COLOR) {
3678                 if (vif->type == NL80211_IFTYPE_AP) {
3679                         ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3680                                 ar, arvif->vdev_id, info->he_bss_color.color,
3681                                 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS,
3682                                 info->he_bss_color.enabled);
3683                         if (ret)
3684                                 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3685                                             arvif->vdev_id,  ret);
3686
3687                         param_id = WMI_VDEV_PARAM_BSS_COLOR;
3688                         if (info->he_bss_color.enabled)
3689                                 param_value = info->he_bss_color.color <<
3690                                                 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET;
3691                         else
3692                                 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED;
3693
3694                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3695                                                             param_id,
3696                                                             param_value);
3697                         if (ret)
3698                                 ath11k_warn(ar->ab,
3699                                             "failed to set bss color param on vdev %i: %d\n",
3700                                             arvif->vdev_id,  ret);
3701
3702                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3703                                    "bss color param 0x%x set on vdev %i\n",
3704                                    param_value, arvif->vdev_id);
3705                 } else if (vif->type == NL80211_IFTYPE_STATION) {
3706                         ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar,
3707                                                                           arvif->vdev_id,
3708                                                                           1);
3709                         if (ret)
3710                                 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
3711                                             arvif->vdev_id,  ret);
3712                         ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3713                                 ar, arvif->vdev_id, 0,
3714                                 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1);
3715                         if (ret)
3716                                 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3717                                             arvif->vdev_id,  ret);
3718                 }
3719         }
3720
3721         if (changed & BSS_CHANGED_FTM_RESPONDER &&
3722             arvif->ftm_responder != info->ftm_responder &&
3723             test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map) &&
3724             (vif->type == NL80211_IFTYPE_AP ||
3725              vif->type == NL80211_IFTYPE_MESH_POINT)) {
3726                 arvif->ftm_responder = info->ftm_responder;
3727                 param = WMI_VDEV_PARAM_ENABLE_DISABLE_RTT_RESPONDER_ROLE;
3728                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
3729                                                     arvif->ftm_responder);
3730                 if (ret)
3731                         ath11k_warn(ar->ab, "Failed to set ftm responder %i: %d\n",
3732                                     arvif->vdev_id, ret);
3733         }
3734
3735         if (changed & BSS_CHANGED_FILS_DISCOVERY ||
3736             changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
3737                 ath11k_mac_fils_discovery(arvif, info);
3738
3739         if (changed & BSS_CHANGED_ARP_FILTER) {
3740                 ipv4_cnt = min(vif->cfg.arp_addr_cnt, ATH11K_IPV4_MAX_COUNT);
3741                 memcpy(arvif->arp_ns_offload.ipv4_addr,
3742                        vif->cfg.arp_addr_list,
3743                        ipv4_cnt * sizeof(u32));
3744                 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN);
3745                 arvif->arp_ns_offload.ipv4_count = ipv4_cnt;
3746
3747                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
3748                            vif->cfg.arp_addr_cnt,
3749                            vif->addr, arvif->arp_ns_offload.ipv4_addr);
3750         }
3751
3752         mutex_unlock(&ar->conf_mutex);
3753 }
3754
3755 void __ath11k_mac_scan_finish(struct ath11k *ar)
3756 {
3757         lockdep_assert_held(&ar->data_lock);
3758
3759         switch (ar->scan.state) {
3760         case ATH11K_SCAN_IDLE:
3761                 break;
3762         case ATH11K_SCAN_RUNNING:
3763         case ATH11K_SCAN_ABORTING:
3764                 if (ar->scan.is_roc && ar->scan.roc_notify)
3765                         ieee80211_remain_on_channel_expired(ar->hw);
3766                 fallthrough;
3767         case ATH11K_SCAN_STARTING:
3768                 if (!ar->scan.is_roc) {
3769                         struct cfg80211_scan_info info = {
3770                                 .aborted = ((ar->scan.state ==
3771                                             ATH11K_SCAN_ABORTING) ||
3772                                             (ar->scan.state ==
3773                                             ATH11K_SCAN_STARTING)),
3774                         };
3775
3776                         ieee80211_scan_completed(ar->hw, &info);
3777                 }
3778
3779                 ar->scan.state = ATH11K_SCAN_IDLE;
3780                 ar->scan_channel = NULL;
3781                 ar->scan.roc_freq = 0;
3782                 cancel_delayed_work(&ar->scan.timeout);
3783                 complete_all(&ar->scan.completed);
3784                 break;
3785         }
3786 }
3787
3788 void ath11k_mac_scan_finish(struct ath11k *ar)
3789 {
3790         spin_lock_bh(&ar->data_lock);
3791         __ath11k_mac_scan_finish(ar);
3792         spin_unlock_bh(&ar->data_lock);
3793 }
3794
3795 static int ath11k_scan_stop(struct ath11k *ar)
3796 {
3797         struct scan_cancel_param arg = {
3798                 .req_type = WLAN_SCAN_CANCEL_SINGLE,
3799                 .scan_id = ATH11K_SCAN_ID,
3800         };
3801         int ret;
3802
3803         lockdep_assert_held(&ar->conf_mutex);
3804
3805         /* TODO: Fill other STOP Params */
3806         arg.pdev_id = ar->pdev->pdev_id;
3807
3808         ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg);
3809         if (ret) {
3810                 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
3811                 goto out;
3812         }
3813
3814         ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
3815         if (ret == 0) {
3816                 ath11k_warn(ar->ab,
3817                             "failed to receive scan abort comple: timed out\n");
3818                 ret = -ETIMEDOUT;
3819         } else if (ret > 0) {
3820                 ret = 0;
3821         }
3822
3823 out:
3824         /* Scan state should be updated upon scan completion but in case
3825          * firmware fails to deliver the event (for whatever reason) it is
3826          * desired to clean up scan state anyway. Firmware may have just
3827          * dropped the scan completion event delivery due to transport pipe
3828          * being overflown with data and/or it can recover on its own before
3829          * next scan request is submitted.
3830          */
3831         spin_lock_bh(&ar->data_lock);
3832         if (ar->scan.state != ATH11K_SCAN_IDLE)
3833                 __ath11k_mac_scan_finish(ar);
3834         spin_unlock_bh(&ar->data_lock);
3835
3836         return ret;
3837 }
3838
3839 static void ath11k_scan_abort(struct ath11k *ar)
3840 {
3841         int ret;
3842
3843         lockdep_assert_held(&ar->conf_mutex);
3844
3845         spin_lock_bh(&ar->data_lock);
3846
3847         switch (ar->scan.state) {
3848         case ATH11K_SCAN_IDLE:
3849                 /* This can happen if timeout worker kicked in and called
3850                  * abortion while scan completion was being processed.
3851                  */
3852                 break;
3853         case ATH11K_SCAN_STARTING:
3854         case ATH11K_SCAN_ABORTING:
3855                 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
3856                             ar->scan.state);
3857                 break;
3858         case ATH11K_SCAN_RUNNING:
3859                 ar->scan.state = ATH11K_SCAN_ABORTING;
3860                 spin_unlock_bh(&ar->data_lock);
3861
3862                 ret = ath11k_scan_stop(ar);
3863                 if (ret)
3864                         ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret);
3865
3866                 spin_lock_bh(&ar->data_lock);
3867                 break;
3868         }
3869
3870         spin_unlock_bh(&ar->data_lock);
3871 }
3872
3873 static void ath11k_scan_timeout_work(struct work_struct *work)
3874 {
3875         struct ath11k *ar = container_of(work, struct ath11k,
3876                                          scan.timeout.work);
3877
3878         mutex_lock(&ar->conf_mutex);
3879         ath11k_scan_abort(ar);
3880         mutex_unlock(&ar->conf_mutex);
3881 }
3882
3883 static int ath11k_start_scan(struct ath11k *ar,
3884                              struct scan_req_params *arg)
3885 {
3886         int ret;
3887         unsigned long timeout = 1 * HZ;
3888
3889         lockdep_assert_held(&ar->conf_mutex);
3890
3891         if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND)
3892                 ath11k_spectral_reset_buffer(ar);
3893
3894         ret = ath11k_wmi_send_scan_start_cmd(ar, arg);
3895         if (ret)
3896                 return ret;
3897
3898         if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) {
3899                 timeout = 5 * HZ;
3900
3901                 if (ar->supports_6ghz)
3902                         timeout += 5 * HZ;
3903         }
3904
3905         ret = wait_for_completion_timeout(&ar->scan.started, timeout);
3906         if (ret == 0) {
3907                 ret = ath11k_scan_stop(ar);
3908                 if (ret)
3909                         ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
3910
3911                 return -ETIMEDOUT;
3912         }
3913
3914         /* If we failed to start the scan, return error code at
3915          * this point.  This is probably due to some issue in the
3916          * firmware, but no need to wedge the driver due to that...
3917          */
3918         spin_lock_bh(&ar->data_lock);
3919         if (ar->scan.state == ATH11K_SCAN_IDLE) {
3920                 spin_unlock_bh(&ar->data_lock);
3921                 return -EINVAL;
3922         }
3923         spin_unlock_bh(&ar->data_lock);
3924
3925         return 0;
3926 }
3927
3928 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw,
3929                                  struct ieee80211_vif *vif,
3930                                  struct ieee80211_scan_request *hw_req)
3931 {
3932         struct ath11k *ar = hw->priv;
3933         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3934         struct cfg80211_scan_request *req = &hw_req->req;
3935         struct scan_req_params *arg = NULL;
3936         int ret = 0;
3937         int i;
3938         u32 scan_timeout;
3939
3940         /* Firmwares advertising the support of triggering 11D algorithm
3941          * on the scan results of a regular scan expects driver to send
3942          * WMI_11D_SCAN_START_CMDID before sending WMI_START_SCAN_CMDID.
3943          * With this feature, separate 11D scan can be avoided since
3944          * regdomain can be determined with the scan results of the
3945          * regular scan.
3946          */
3947         if (ar->state_11d == ATH11K_11D_PREPARING &&
3948             test_bit(WMI_TLV_SERVICE_SUPPORT_11D_FOR_HOST_SCAN,
3949                      ar->ab->wmi_ab.svc_map))
3950                 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
3951
3952         mutex_lock(&ar->conf_mutex);
3953
3954         spin_lock_bh(&ar->data_lock);
3955         switch (ar->scan.state) {
3956         case ATH11K_SCAN_IDLE:
3957                 reinit_completion(&ar->scan.started);
3958                 reinit_completion(&ar->scan.completed);
3959                 ar->scan.state = ATH11K_SCAN_STARTING;
3960                 ar->scan.is_roc = false;
3961                 ar->scan.vdev_id = arvif->vdev_id;
3962                 ret = 0;
3963                 break;
3964         case ATH11K_SCAN_STARTING:
3965         case ATH11K_SCAN_RUNNING:
3966         case ATH11K_SCAN_ABORTING:
3967                 ret = -EBUSY;
3968                 break;
3969         }
3970         spin_unlock_bh(&ar->data_lock);
3971
3972         if (ret)
3973                 goto exit;
3974
3975         arg = kzalloc(sizeof(*arg), GFP_KERNEL);
3976
3977         if (!arg) {
3978                 ret = -ENOMEM;
3979                 goto exit;
3980         }
3981
3982         ath11k_wmi_start_scan_init(ar, arg);
3983         arg->vdev_id = arvif->vdev_id;
3984         arg->scan_id = ATH11K_SCAN_ID;
3985
3986         if (req->ie_len) {
3987                 arg->extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
3988                 if (!arg->extraie.ptr) {
3989                         ret = -ENOMEM;
3990                         goto exit;
3991                 }
3992                 arg->extraie.len = req->ie_len;
3993         }
3994
3995         if (req->n_ssids) {
3996                 arg->num_ssids = req->n_ssids;
3997                 for (i = 0; i < arg->num_ssids; i++) {
3998                         arg->ssid[i].length  = req->ssids[i].ssid_len;
3999                         memcpy(&arg->ssid[i].ssid, req->ssids[i].ssid,
4000                                req->ssids[i].ssid_len);
4001                 }
4002         } else {
4003                 arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE;
4004         }
4005
4006         if (req->n_channels) {
4007                 arg->num_chan = req->n_channels;
4008                 arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list),
4009                                          GFP_KERNEL);
4010
4011                 if (!arg->chan_list) {
4012                         ret = -ENOMEM;
4013                         goto exit;
4014                 }
4015
4016                 for (i = 0; i < arg->num_chan; i++) {
4017                         if (test_bit(WMI_TLV_SERVICE_SCAN_CONFIG_PER_CHANNEL,
4018                                      ar->ab->wmi_ab.svc_map)) {
4019                                 arg->chan_list[i] =
4020                                         u32_encode_bits(req->channels[i]->center_freq,
4021                                                         WMI_SCAN_CONFIG_PER_CHANNEL_MASK);
4022
4023                                 /* If NL80211_SCAN_FLAG_COLOCATED_6GHZ is set in scan
4024                                  * flags, then scan all PSC channels in 6 GHz band and
4025                                  * those non-PSC channels where RNR IE is found during
4026                                  * the legacy 2.4/5 GHz scan.
4027                                  * If NL80211_SCAN_FLAG_COLOCATED_6GHZ is not set,
4028                                  * then all channels in 6 GHz will be scanned.
4029                                  */
4030                                 if (req->channels[i]->band == NL80211_BAND_6GHZ &&
4031                                     req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ &&
4032                                     !cfg80211_channel_is_psc(req->channels[i]))
4033                                         arg->chan_list[i] |=
4034                                                 WMI_SCAN_CH_FLAG_SCAN_ONLY_IF_RNR_FOUND;
4035                         } else {
4036                                 arg->chan_list[i] = req->channels[i]->center_freq;
4037                         }
4038                 }
4039         }
4040
4041         if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
4042                 arg->scan_f_add_spoofed_mac_in_probe = 1;
4043                 ether_addr_copy(arg->mac_addr.addr, req->mac_addr);
4044                 ether_addr_copy(arg->mac_mask.addr, req->mac_addr_mask);
4045         }
4046
4047         /* if duration is set, default dwell times will be overwritten */
4048         if (req->duration) {
4049                 arg->dwell_time_active = req->duration;
4050                 arg->dwell_time_active_2g = req->duration;
4051                 arg->dwell_time_active_6g = req->duration;
4052                 arg->dwell_time_passive = req->duration;
4053                 arg->dwell_time_passive_6g = req->duration;
4054                 arg->burst_duration = req->duration;
4055
4056                 scan_timeout = min_t(u32, arg->max_rest_time *
4057                                 (arg->num_chan - 1) + (req->duration +
4058                                 ATH11K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) *
4059                                 arg->num_chan, arg->max_scan_time);
4060         } else {
4061                 scan_timeout = arg->max_scan_time;
4062         }
4063
4064         /* Add a margin to account for event/command processing */
4065         scan_timeout += ATH11K_MAC_SCAN_CMD_EVT_OVERHEAD;
4066
4067         ret = ath11k_start_scan(ar, arg);
4068         if (ret) {
4069                 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
4070                 spin_lock_bh(&ar->data_lock);
4071                 ar->scan.state = ATH11K_SCAN_IDLE;
4072                 spin_unlock_bh(&ar->data_lock);
4073         }
4074
4075         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4076                                      msecs_to_jiffies(scan_timeout));
4077
4078 exit:
4079         if (arg) {
4080                 kfree(arg->chan_list);
4081                 kfree(arg->extraie.ptr);
4082                 kfree(arg);
4083         }
4084
4085         mutex_unlock(&ar->conf_mutex);
4086
4087         if (ar->state_11d == ATH11K_11D_PREPARING)
4088                 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
4089
4090         return ret;
4091 }
4092
4093 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
4094                                          struct ieee80211_vif *vif)
4095 {
4096         struct ath11k *ar = hw->priv;
4097
4098         mutex_lock(&ar->conf_mutex);
4099         ath11k_scan_abort(ar);
4100         mutex_unlock(&ar->conf_mutex);
4101
4102         cancel_delayed_work_sync(&ar->scan.timeout);
4103 }
4104
4105 static int ath11k_install_key(struct ath11k_vif *arvif,
4106                               struct ieee80211_key_conf *key,
4107                               enum set_key_cmd cmd,
4108                               const u8 *macaddr, u32 flags)
4109 {
4110         int ret;
4111         struct ath11k *ar = arvif->ar;
4112         struct wmi_vdev_install_key_arg arg = {
4113                 .vdev_id = arvif->vdev_id,
4114                 .key_idx = key->keyidx,
4115                 .key_len = key->keylen,
4116                 .key_data = key->key,
4117                 .key_flags = flags,
4118                 .macaddr = macaddr,
4119         };
4120
4121         lockdep_assert_held(&arvif->ar->conf_mutex);
4122
4123         reinit_completion(&ar->install_key_done);
4124
4125         if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
4126                 return 0;
4127
4128         if (cmd == DISABLE_KEY) {
4129                 arg.key_cipher = WMI_CIPHER_NONE;
4130                 arg.key_data = NULL;
4131                 goto install;
4132         }
4133
4134         switch (key->cipher) {
4135         case WLAN_CIPHER_SUITE_CCMP:
4136                 arg.key_cipher = WMI_CIPHER_AES_CCM;
4137                 /* TODO: Re-check if flag is valid */
4138                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
4139                 break;
4140         case WLAN_CIPHER_SUITE_TKIP:
4141                 arg.key_cipher = WMI_CIPHER_TKIP;
4142                 arg.key_txmic_len = 8;
4143                 arg.key_rxmic_len = 8;
4144                 break;
4145         case WLAN_CIPHER_SUITE_CCMP_256:
4146                 arg.key_cipher = WMI_CIPHER_AES_CCM;
4147                 break;
4148         case WLAN_CIPHER_SUITE_GCMP:
4149         case WLAN_CIPHER_SUITE_GCMP_256:
4150                 arg.key_cipher = WMI_CIPHER_AES_GCM;
4151                 break;
4152         default:
4153                 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
4154                 return -EOPNOTSUPP;
4155         }
4156
4157         if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags))
4158                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
4159                               IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
4160
4161 install:
4162         ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg);
4163
4164         if (ret)
4165                 return ret;
4166
4167         if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
4168                 return -ETIMEDOUT;
4169
4170         return ar->install_key_status ? -EINVAL : 0;
4171 }
4172
4173 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif,
4174                                   const u8 *addr)
4175 {
4176         struct ath11k *ar = arvif->ar;
4177         struct ath11k_base *ab = ar->ab;
4178         struct ath11k_peer *peer;
4179         int first_errno = 0;
4180         int ret;
4181         int i;
4182         u32 flags = 0;
4183
4184         lockdep_assert_held(&ar->conf_mutex);
4185
4186         spin_lock_bh(&ab->base_lock);
4187         peer = ath11k_peer_find(ab, arvif->vdev_id, addr);
4188         spin_unlock_bh(&ab->base_lock);
4189
4190         if (!peer)
4191                 return -ENOENT;
4192
4193         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
4194                 if (!peer->keys[i])
4195                         continue;
4196
4197                 /* key flags are not required to delete the key */
4198                 ret = ath11k_install_key(arvif, peer->keys[i],
4199                                          DISABLE_KEY, addr, flags);
4200                 if (ret < 0 && first_errno == 0)
4201                         first_errno = ret;
4202
4203                 if (ret < 0)
4204                         ath11k_warn(ab, "failed to remove peer key %d: %d\n",
4205                                     i, ret);
4206
4207                 spin_lock_bh(&ab->base_lock);
4208                 peer->keys[i] = NULL;
4209                 spin_unlock_bh(&ab->base_lock);
4210         }
4211
4212         return first_errno;
4213 }
4214
4215 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4216                                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
4217                                  struct ieee80211_key_conf *key)
4218 {
4219         struct ath11k *ar = hw->priv;
4220         struct ath11k_base *ab = ar->ab;
4221         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4222         struct ath11k_peer *peer;
4223         struct ath11k_sta *arsta;
4224         const u8 *peer_addr;
4225         int ret = 0;
4226         u32 flags = 0;
4227
4228         /* BIP needs to be done in software */
4229         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
4230             key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
4231             key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
4232             key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
4233                 return 1;
4234
4235         if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
4236                 return 1;
4237
4238         if (key->keyidx > WMI_MAX_KEY_INDEX)
4239                 return -ENOSPC;
4240
4241         mutex_lock(&ar->conf_mutex);
4242
4243         if (sta)
4244                 peer_addr = sta->addr;
4245         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
4246                 peer_addr = vif->bss_conf.bssid;
4247         else
4248                 peer_addr = vif->addr;
4249
4250         key->hw_key_idx = key->keyidx;
4251
4252         /* the peer should not disappear in mid-way (unless FW goes awry) since
4253          * we already hold conf_mutex. we just make sure its there now.
4254          */
4255         spin_lock_bh(&ab->base_lock);
4256         peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
4257
4258         /* flush the fragments cache during key (re)install to
4259          * ensure all frags in the new frag list belong to the same key.
4260          */
4261         if (peer && sta && cmd == SET_KEY)
4262                 ath11k_peer_frags_flush(ar, peer);
4263         spin_unlock_bh(&ab->base_lock);
4264
4265         if (!peer) {
4266                 if (cmd == SET_KEY) {
4267                         ath11k_warn(ab, "cannot install key for non-existent peer %pM\n",
4268                                     peer_addr);
4269                         ret = -EOPNOTSUPP;
4270                         goto exit;
4271                 } else {
4272                         /* if the peer doesn't exist there is no key to disable
4273                          * anymore
4274                          */
4275                         goto exit;
4276                 }
4277         }
4278
4279         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4280                 flags |= WMI_KEY_PAIRWISE;
4281         else
4282                 flags |= WMI_KEY_GROUP;
4283
4284         ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags);
4285         if (ret) {
4286                 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret);
4287                 goto exit;
4288         }
4289
4290         ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key);
4291         if (ret) {
4292                 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret);
4293                 goto exit;
4294         }
4295
4296         spin_lock_bh(&ab->base_lock);
4297         peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
4298         if (peer && cmd == SET_KEY) {
4299                 peer->keys[key->keyidx] = key;
4300                 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
4301                         peer->ucast_keyidx = key->keyidx;
4302                         peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher);
4303                 } else {
4304                         peer->mcast_keyidx = key->keyidx;
4305                         peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher);
4306                 }
4307         } else if (peer && cmd == DISABLE_KEY) {
4308                 peer->keys[key->keyidx] = NULL;
4309                 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4310                         peer->ucast_keyidx = 0;
4311                 else
4312                         peer->mcast_keyidx = 0;
4313         } else if (!peer)
4314                 /* impossible unless FW goes crazy */
4315                 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr);
4316
4317         if (sta) {
4318                 arsta = ath11k_sta_to_arsta(sta);
4319
4320                 switch (key->cipher) {
4321                 case WLAN_CIPHER_SUITE_TKIP:
4322                 case WLAN_CIPHER_SUITE_CCMP:
4323                 case WLAN_CIPHER_SUITE_CCMP_256:
4324                 case WLAN_CIPHER_SUITE_GCMP:
4325                 case WLAN_CIPHER_SUITE_GCMP_256:
4326                         if (cmd == SET_KEY)
4327                                 arsta->pn_type = HAL_PN_TYPE_WPA;
4328                         else
4329                                 arsta->pn_type = HAL_PN_TYPE_NONE;
4330                         break;
4331                 default:
4332                         arsta->pn_type = HAL_PN_TYPE_NONE;
4333                         break;
4334                 }
4335         }
4336
4337         spin_unlock_bh(&ab->base_lock);
4338
4339 exit:
4340         mutex_unlock(&ar->conf_mutex);
4341         return ret;
4342 }
4343
4344 static int
4345 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
4346                                      enum nl80211_band band,
4347                                      const struct cfg80211_bitrate_mask *mask)
4348 {
4349         int num_rates = 0;
4350         int i;
4351
4352         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
4353                 num_rates += hweight8(mask->control[band].ht_mcs[i]);
4354
4355         return num_rates;
4356 }
4357
4358 static int
4359 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar,
4360                                       enum nl80211_band band,
4361                                       const struct cfg80211_bitrate_mask *mask)
4362 {
4363         int num_rates = 0;
4364         int i;
4365
4366         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
4367                 num_rates += hweight16(mask->control[band].vht_mcs[i]);
4368
4369         return num_rates;
4370 }
4371
4372 static int
4373 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar,
4374                                      enum nl80211_band band,
4375                                      const struct cfg80211_bitrate_mask *mask)
4376 {
4377         int num_rates = 0;
4378         int i;
4379
4380         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++)
4381                 num_rates += hweight16(mask->control[band].he_mcs[i]);
4382
4383         return num_rates;
4384 }
4385
4386 static int
4387 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif,
4388                                    struct ieee80211_sta *sta,
4389                                    const struct cfg80211_bitrate_mask *mask,
4390                                    enum nl80211_band band)
4391 {
4392         struct ath11k *ar = arvif->ar;
4393         u8 vht_rate, nss;
4394         u32 rate_code;
4395         int ret, i;
4396
4397         lockdep_assert_held(&ar->conf_mutex);
4398
4399         nss = 0;
4400
4401         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
4402                 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
4403                         nss = i + 1;
4404                         vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4405                 }
4406         }
4407
4408         if (!nss) {
4409                 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
4410                             sta->addr);
4411                 return -EINVAL;
4412         }
4413
4414         /* Avoid updating invalid nss as fixed rate*/
4415         if (nss > sta->deflink.rx_nss)
4416                 return -EINVAL;
4417
4418         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4419                    "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
4420                    sta->addr);
4421
4422         rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1,
4423                                         WMI_RATE_PREAMBLE_VHT);
4424         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4425                                         arvif->vdev_id,
4426                                         WMI_PEER_PARAM_FIXED_RATE,
4427                                         rate_code);
4428         if (ret)
4429                 ath11k_warn(ar->ab,
4430                             "failed to update STA %pM Fixed Rate %d: %d\n",
4431                              sta->addr, rate_code, ret);
4432
4433         return ret;
4434 }
4435
4436 static int
4437 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif,
4438                                   struct ieee80211_sta *sta,
4439                                   const struct cfg80211_bitrate_mask *mask,
4440                                   enum nl80211_band band)
4441 {
4442         struct ath11k *ar = arvif->ar;
4443         u8 he_rate, nss;
4444         u32 rate_code;
4445         int ret, i;
4446
4447         lockdep_assert_held(&ar->conf_mutex);
4448
4449         nss = 0;
4450
4451         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
4452                 if (hweight16(mask->control[band].he_mcs[i]) == 1) {
4453                         nss = i + 1;
4454                         he_rate = ffs(mask->control[band].he_mcs[i]) - 1;
4455                 }
4456         }
4457
4458         if (!nss) {
4459                 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM",
4460                             sta->addr);
4461                 return -EINVAL;
4462         }
4463
4464         /* Avoid updating invalid nss as fixed rate */
4465         if (nss > sta->deflink.rx_nss)
4466                 return -EINVAL;
4467
4468         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4469                    "setting fixed he rate for peer %pM, device will not switch to any other selected rates",
4470                    sta->addr);
4471
4472         rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1,
4473                                         WMI_RATE_PREAMBLE_HE);
4474
4475         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4476                                         arvif->vdev_id,
4477                                         WMI_PEER_PARAM_FIXED_RATE,
4478                                         rate_code);
4479         if (ret)
4480                 ath11k_warn(ar->ab,
4481                             "failed to update sta %pM fixed rate %d: %d\n",
4482                             sta->addr, rate_code, ret);
4483
4484         return ret;
4485 }
4486
4487 static int
4488 ath11k_mac_set_peer_ht_fixed_rate(struct ath11k_vif *arvif,
4489                                   struct ieee80211_sta *sta,
4490                                   const struct cfg80211_bitrate_mask *mask,
4491                                   enum nl80211_band band)
4492 {
4493         struct ath11k *ar = arvif->ar;
4494         u8 ht_rate, nss = 0;
4495         u32 rate_code;
4496         int ret, i;
4497
4498         lockdep_assert_held(&ar->conf_mutex);
4499
4500         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
4501                 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
4502                         nss = i + 1;
4503                         ht_rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4504                 }
4505         }
4506
4507         if (!nss) {
4508                 ath11k_warn(ar->ab, "No single HT Fixed rate found to set for %pM",
4509                             sta->addr);
4510                 return -EINVAL;
4511         }
4512
4513         /* Avoid updating invalid nss as fixed rate*/
4514         if (nss > sta->deflink.rx_nss)
4515                 return -EINVAL;
4516
4517         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4518                    "Setting Fixed HT Rate for peer %pM. Device will not switch to any other selected rates",
4519                    sta->addr);
4520
4521         rate_code = ATH11K_HW_RATE_CODE(ht_rate, nss - 1,
4522                                         WMI_RATE_PREAMBLE_HT);
4523         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4524                                         arvif->vdev_id,
4525                                         WMI_PEER_PARAM_FIXED_RATE,
4526                                         rate_code);
4527         if (ret)
4528                 ath11k_warn(ar->ab,
4529                             "failed to update STA %pM HT Fixed Rate %d: %d\n",
4530                             sta->addr, rate_code, ret);
4531
4532         return ret;
4533 }
4534
4535 static int ath11k_station_assoc(struct ath11k *ar,
4536                                 struct ieee80211_vif *vif,
4537                                 struct ieee80211_sta *sta,
4538                                 bool reassoc)
4539 {
4540         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4541         struct peer_assoc_params peer_arg;
4542         int ret = 0;
4543         struct cfg80211_chan_def def;
4544         enum nl80211_band band;
4545         struct cfg80211_bitrate_mask *mask;
4546         u8 num_ht_rates, num_vht_rates, num_he_rates;
4547
4548         lockdep_assert_held(&ar->conf_mutex);
4549
4550         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
4551                 return -EPERM;
4552
4553         band = def.chan->band;
4554         mask = &arvif->bitrate_mask;
4555
4556         ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
4557
4558         peer_arg.is_assoc = true;
4559         ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4560         if (ret) {
4561                 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4562                             sta->addr, arvif->vdev_id, ret);
4563                 return ret;
4564         }
4565
4566         if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4567                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4568                             sta->addr, arvif->vdev_id);
4569                 return -ETIMEDOUT;
4570         }
4571
4572         num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
4573         num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask);
4574         num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask);
4575
4576         /* If single VHT/HE rate is configured (by set_bitrate_mask()),
4577          * peer_assoc will disable VHT/HE. This is now enabled by a peer specific
4578          * fixed param.
4579          * Note that all other rates and NSS will be disabled for this peer.
4580          */
4581         if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4582                 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4583                                                          band);
4584                 if (ret)
4585                         return ret;
4586         } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4587                 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4588                                                         band);
4589                 if (ret)
4590                         return ret;
4591         } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) {
4592                 ret = ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask,
4593                                                         band);
4594                 if (ret)
4595                         return ret;
4596         }
4597
4598         /* Re-assoc is run only to update supported rates for given station. It
4599          * doesn't make much sense to reconfigure the peer completely.
4600          */
4601         if (reassoc)
4602                 return 0;
4603
4604         ret = ath11k_setup_peer_smps(ar, arvif, sta->addr,
4605                                      &sta->deflink.ht_cap,
4606                                      le16_to_cpu(sta->deflink.he_6ghz_capa.capa));
4607         if (ret) {
4608                 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
4609                             arvif->vdev_id, ret);
4610                 return ret;
4611         }
4612
4613         if (!sta->wme) {
4614                 arvif->num_legacy_stations++;
4615                 ret = ath11k_recalc_rtscts_prot(arvif);
4616                 if (ret)
4617                         return ret;
4618         }
4619
4620         if (sta->wme && sta->uapsd_queues) {
4621                 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta);
4622                 if (ret) {
4623                         ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
4624                                     sta->addr, arvif->vdev_id, ret);
4625                         return ret;
4626                 }
4627         }
4628
4629         return 0;
4630 }
4631
4632 static int ath11k_station_disassoc(struct ath11k *ar,
4633                                    struct ieee80211_vif *vif,
4634                                    struct ieee80211_sta *sta)
4635 {
4636         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4637         int ret = 0;
4638
4639         lockdep_assert_held(&ar->conf_mutex);
4640
4641         if (!sta->wme) {
4642                 arvif->num_legacy_stations--;
4643                 ret = ath11k_recalc_rtscts_prot(arvif);
4644                 if (ret)
4645                         return ret;
4646         }
4647
4648         ret = ath11k_clear_peer_keys(arvif, sta->addr);
4649         if (ret) {
4650                 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
4651                             arvif->vdev_id, ret);
4652                 return ret;
4653         }
4654         return 0;
4655 }
4656
4657 static u32 ath11k_mac_max_nss(const u8 *ht_mcs_mask, const u16 *vht_mcs_mask,
4658                               const u16 *he_mcs_mask)
4659 {
4660         return max3(ath11k_mac_max_ht_nss(ht_mcs_mask),
4661                     ath11k_mac_max_vht_nss(vht_mcs_mask),
4662                     ath11k_mac_max_he_nss(he_mcs_mask));
4663 }
4664
4665 static void ath11k_sta_rc_update_wk(struct work_struct *wk)
4666 {
4667         struct ath11k *ar;
4668         struct ath11k_vif *arvif;
4669         struct ath11k_sta *arsta;
4670         struct ieee80211_sta *sta;
4671         struct cfg80211_chan_def def;
4672         enum nl80211_band band;
4673         const u8 *ht_mcs_mask;
4674         const u16 *vht_mcs_mask;
4675         const u16 *he_mcs_mask;
4676         u32 changed, bw, nss, smps, bw_prev;
4677         int err, num_ht_rates, num_vht_rates, num_he_rates;
4678         const struct cfg80211_bitrate_mask *mask;
4679         struct peer_assoc_params peer_arg;
4680         enum wmi_phy_mode peer_phymode;
4681
4682         arsta = container_of(wk, struct ath11k_sta, update_wk);
4683         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4684         arvif = arsta->arvif;
4685         ar = arvif->ar;
4686
4687         if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def)))
4688                 return;
4689
4690         band = def.chan->band;
4691         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4692         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
4693         he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
4694
4695         spin_lock_bh(&ar->data_lock);
4696
4697         changed = arsta->changed;
4698         arsta->changed = 0;
4699
4700         bw = arsta->bw;
4701         bw_prev = arsta->bw_prev;
4702         nss = arsta->nss;
4703         smps = arsta->smps;
4704
4705         spin_unlock_bh(&ar->data_lock);
4706
4707         mutex_lock(&ar->conf_mutex);
4708
4709         nss = max_t(u32, 1, nss);
4710         nss = min(nss, ath11k_mac_max_nss(ht_mcs_mask, vht_mcs_mask, he_mcs_mask));
4711
4712         if (changed & IEEE80211_RC_BW_CHANGED) {
4713                 /* Get the peer phymode */
4714                 ath11k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg);
4715                 peer_phymode = peer_arg.peer_phymode;
4716
4717                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM peer bw %d phymode %d\n",
4718                            sta->addr, bw, peer_phymode);
4719
4720                 if (bw > bw_prev) {
4721                         /* BW is upgraded. In this case we send WMI_PEER_PHYMODE
4722                          * followed by WMI_PEER_CHWIDTH
4723                          */
4724                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW upgrade for sta %pM new BW %d, old BW %d\n",
4725                                    sta->addr, bw, bw_prev);
4726
4727                         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4728                                                         WMI_PEER_PHYMODE, peer_phymode);
4729
4730                         if (err) {
4731                                 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n",
4732                                             sta->addr, peer_phymode, err);
4733                                 goto err_rc_bw_changed;
4734                         }
4735
4736                         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4737                                                         WMI_PEER_CHWIDTH, bw);
4738
4739                         if (err)
4740                                 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4741                                             sta->addr, bw, err);
4742                 } else {
4743                         /* BW is downgraded. In this case we send WMI_PEER_CHWIDTH
4744                          * followed by WMI_PEER_PHYMODE
4745                          */
4746                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "BW downgrade for sta %pM new BW %d,old BW %d\n",
4747                                    sta->addr, bw, bw_prev);
4748
4749                         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4750                                                         WMI_PEER_CHWIDTH, bw);
4751
4752                         if (err) {
4753                                 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4754                                             sta->addr, bw, err);
4755                                 goto err_rc_bw_changed;
4756                         }
4757
4758                         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4759                                                         WMI_PEER_PHYMODE, peer_phymode);
4760
4761                         if (err)
4762                                 ath11k_warn(ar->ab, "failed to update STA %pM peer phymode %d: %d\n",
4763                                             sta->addr, peer_phymode, err);
4764                 }
4765         }
4766
4767         if (changed & IEEE80211_RC_NSS_CHANGED) {
4768                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM nss %d\n",
4769                            sta->addr, nss);
4770
4771                 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4772                                                 WMI_PEER_NSS, nss);
4773                 if (err)
4774                         ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
4775                                     sta->addr, nss, err);
4776         }
4777
4778         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4779                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "update sta %pM smps %d\n",
4780                            sta->addr, smps);
4781
4782                 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4783                                                 WMI_PEER_MIMO_PS_STATE, smps);
4784                 if (err)
4785                         ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
4786                                     sta->addr, smps, err);
4787         }
4788
4789         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
4790                 mask = &arvif->bitrate_mask;
4791                 num_ht_rates = ath11k_mac_bitrate_mask_num_ht_rates(ar, band,
4792                                                                     mask);
4793                 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
4794                                                                       mask);
4795                 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
4796                                                                     mask);
4797
4798                 /* Peer_assoc_prepare will reject vht rates in
4799                  * bitrate_mask if its not available in range format and
4800                  * sets vht tx_rateset as unsupported. So multiple VHT MCS
4801                  * setting(eg. MCS 4,5,6) per peer is not supported here.
4802                  * But, Single rate in VHT mask can be set as per-peer
4803                  * fixed rate. But even if any HT rates are configured in
4804                  * the bitrate mask, device will not switch to those rates
4805                  * when per-peer Fixed rate is set.
4806                  * TODO: Check RATEMASK_CMDID to support auto rates selection
4807                  * across HT/VHT and for multiple VHT MCS support.
4808                  */
4809                 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4810                         ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4811                                                            band);
4812                 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4813                         ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4814                                                           band);
4815                 } else if (sta->deflink.ht_cap.ht_supported && num_ht_rates == 1) {
4816                         ath11k_mac_set_peer_ht_fixed_rate(arvif, sta, mask,
4817                                                           band);
4818                 } else {
4819                         /* If the peer is non-VHT/HE or no fixed VHT/HE rate
4820                          * is provided in the new bitrate mask we set the
4821                          * other rates using peer_assoc command. Also clear
4822                          * the peer fixed rate settings as it has higher proprity
4823                          * than peer assoc
4824                          */
4825                         err = ath11k_wmi_set_peer_param(ar, sta->addr,
4826                                                         arvif->vdev_id,
4827                                                         WMI_PEER_PARAM_FIXED_RATE,
4828                                                         WMI_FIXED_RATE_NONE);
4829                         if (err)
4830                                 ath11k_warn(ar->ab,
4831                                             "failed to disable peer fixed rate for sta %pM: %d\n",
4832                                             sta->addr, err);
4833
4834                         ath11k_peer_assoc_prepare(ar, arvif->vif, sta,
4835                                                   &peer_arg, true);
4836
4837                         peer_arg.is_assoc = false;
4838                         err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4839                         if (err)
4840                                 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4841                                             sta->addr, arvif->vdev_id, err);
4842
4843                         if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
4844                                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4845                                             sta->addr, arvif->vdev_id);
4846                 }
4847         }
4848
4849 err_rc_bw_changed:
4850         mutex_unlock(&ar->conf_mutex);
4851 }
4852
4853 static void ath11k_sta_set_4addr_wk(struct work_struct *wk)
4854 {
4855         struct ath11k *ar;
4856         struct ath11k_vif *arvif;
4857         struct ath11k_sta *arsta;
4858         struct ieee80211_sta *sta;
4859         int ret = 0;
4860
4861         arsta = container_of(wk, struct ath11k_sta, set_4addr_wk);
4862         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4863         arvif = arsta->arvif;
4864         ar = arvif->ar;
4865
4866         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4867                    "setting USE_4ADDR for peer %pM\n", sta->addr);
4868
4869         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4870                                         arvif->vdev_id,
4871                                         WMI_PEER_USE_4ADDR, 1);
4872
4873         if (ret)
4874                 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n",
4875                             sta->addr, ret);
4876 }
4877
4878 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif,
4879                                        struct ieee80211_sta *sta)
4880 {
4881         struct ath11k *ar = arvif->ar;
4882
4883         lockdep_assert_held(&ar->conf_mutex);
4884
4885         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4886                 return 0;
4887
4888         if (ar->num_stations >= ar->max_num_stations)
4889                 return -ENOBUFS;
4890
4891         ar->num_stations++;
4892
4893         return 0;
4894 }
4895
4896 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif,
4897                                         struct ieee80211_sta *sta)
4898 {
4899         struct ath11k *ar = arvif->ar;
4900
4901         lockdep_assert_held(&ar->conf_mutex);
4902
4903         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4904                 return;
4905
4906         ar->num_stations--;
4907 }
4908
4909 static int ath11k_mac_station_add(struct ath11k *ar,
4910                                   struct ieee80211_vif *vif,
4911                                   struct ieee80211_sta *sta)
4912 {
4913         struct ath11k_base *ab = ar->ab;
4914         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4915         struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
4916         struct peer_create_params peer_param;
4917         int ret;
4918
4919         lockdep_assert_held(&ar->conf_mutex);
4920
4921         ret = ath11k_mac_inc_num_stations(arvif, sta);
4922         if (ret) {
4923                 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
4924                             ar->max_num_stations);
4925                 goto exit;
4926         }
4927
4928         arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
4929         if (!arsta->rx_stats) {
4930                 ret = -ENOMEM;
4931                 goto dec_num_station;
4932         }
4933
4934         peer_param.vdev_id = arvif->vdev_id;
4935         peer_param.peer_addr = sta->addr;
4936         peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
4937
4938         ret = ath11k_peer_create(ar, arvif, sta, &peer_param);
4939         if (ret) {
4940                 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
4941                             sta->addr, arvif->vdev_id);
4942                 goto free_rx_stats;
4943         }
4944
4945         ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
4946                    sta->addr, arvif->vdev_id);
4947
4948         if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) {
4949                 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL);
4950                 if (!arsta->tx_stats) {
4951                         ret = -ENOMEM;
4952                         goto free_peer;
4953                 }
4954         }
4955
4956         if (ieee80211_vif_is_mesh(vif)) {
4957                 ath11k_dbg(ab, ATH11K_DBG_MAC,
4958                            "setting USE_4ADDR for mesh STA %pM\n", sta->addr);
4959                 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4960                                                 arvif->vdev_id,
4961                                                 WMI_PEER_USE_4ADDR, 1);
4962                 if (ret) {
4963                         ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n",
4964                                     sta->addr, ret);
4965                         goto free_tx_stats;
4966                 }
4967         }
4968
4969         ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
4970         if (ret) {
4971                 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
4972                             sta->addr, arvif->vdev_id, ret);
4973                 goto free_tx_stats;
4974         }
4975
4976         if (ab->hw_params.vdev_start_delay &&
4977             !arvif->is_started &&
4978             arvif->vdev_type != WMI_VDEV_TYPE_AP) {
4979                 ret = ath11k_start_vdev_delay(ar->hw, vif);
4980                 if (ret) {
4981                         ath11k_warn(ab, "failed to delay vdev start: %d\n", ret);
4982                         goto free_tx_stats;
4983                 }
4984         }
4985
4986         ewma_avg_rssi_init(&arsta->avg_rssi);
4987         return 0;
4988
4989 free_tx_stats:
4990         kfree(arsta->tx_stats);
4991         arsta->tx_stats = NULL;
4992 free_peer:
4993         ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4994 free_rx_stats:
4995         kfree(arsta->rx_stats);
4996         arsta->rx_stats = NULL;
4997 dec_num_station:
4998         ath11k_mac_dec_num_stations(arvif, sta);
4999 exit:
5000         return ret;
5001 }
5002
5003 static u32 ath11k_mac_ieee80211_sta_bw_to_wmi(struct ath11k *ar,
5004                                               struct ieee80211_sta *sta)
5005 {
5006         u32 bw = WMI_PEER_CHWIDTH_20MHZ;
5007
5008         switch (sta->deflink.bandwidth) {
5009         case IEEE80211_STA_RX_BW_20:
5010                 bw = WMI_PEER_CHWIDTH_20MHZ;
5011                 break;
5012         case IEEE80211_STA_RX_BW_40:
5013                 bw = WMI_PEER_CHWIDTH_40MHZ;
5014                 break;
5015         case IEEE80211_STA_RX_BW_80:
5016                 bw = WMI_PEER_CHWIDTH_80MHZ;
5017                 break;
5018         case IEEE80211_STA_RX_BW_160:
5019                 bw = WMI_PEER_CHWIDTH_160MHZ;
5020                 break;
5021         default:
5022                 ath11k_warn(ar->ab, "Invalid bandwidth %d for %pM\n",
5023                             sta->deflink.bandwidth, sta->addr);
5024                 bw = WMI_PEER_CHWIDTH_20MHZ;
5025                 break;
5026         }
5027
5028         return bw;
5029 }
5030
5031 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
5032                                    struct ieee80211_vif *vif,
5033                                    struct ieee80211_sta *sta,
5034                                    enum ieee80211_sta_state old_state,
5035                                    enum ieee80211_sta_state new_state)
5036 {
5037         struct ath11k *ar = hw->priv;
5038         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5039         struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5040         struct ath11k_peer *peer;
5041         int ret = 0;
5042
5043         /* cancel must be done outside the mutex to avoid deadlock */
5044         if ((old_state == IEEE80211_STA_NONE &&
5045              new_state == IEEE80211_STA_NOTEXIST)) {
5046                 cancel_work_sync(&arsta->update_wk);
5047                 cancel_work_sync(&arsta->set_4addr_wk);
5048         }
5049
5050         mutex_lock(&ar->conf_mutex);
5051
5052         if (old_state == IEEE80211_STA_NOTEXIST &&
5053             new_state == IEEE80211_STA_NONE) {
5054                 memset(arsta, 0, sizeof(*arsta));
5055                 arsta->arvif = arvif;
5056                 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
5057                 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
5058                 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
5059
5060                 ret = ath11k_mac_station_add(ar, vif, sta);
5061                 if (ret)
5062                         ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
5063                                     sta->addr, arvif->vdev_id);
5064         } else if ((old_state == IEEE80211_STA_NONE &&
5065                     new_state == IEEE80211_STA_NOTEXIST)) {
5066                 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay &&
5067                         vif->type == NL80211_IFTYPE_STATION;
5068
5069                 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
5070
5071                 if (!skip_peer_delete) {
5072                         ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
5073                         if (ret)
5074                                 ath11k_warn(ar->ab,
5075                                             "Failed to delete peer: %pM for VDEV: %d\n",
5076                                             sta->addr, arvif->vdev_id);
5077                         else
5078                                 ath11k_dbg(ar->ab,
5079                                            ATH11K_DBG_MAC,
5080                                            "Removed peer: %pM for VDEV: %d\n",
5081                                            sta->addr, arvif->vdev_id);
5082                 }
5083
5084                 ath11k_mac_dec_num_stations(arvif, sta);
5085                 mutex_lock(&ar->ab->tbl_mtx_lock);
5086                 spin_lock_bh(&ar->ab->base_lock);
5087                 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5088                 if (skip_peer_delete && peer) {
5089                         peer->sta = NULL;
5090                 } else if (peer && peer->sta == sta) {
5091                         ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
5092                                     vif->addr, arvif->vdev_id);
5093                         ath11k_peer_rhash_delete(ar->ab, peer);
5094                         peer->sta = NULL;
5095                         list_del(&peer->list);
5096                         kfree(peer);
5097                         ar->num_peers--;
5098                 }
5099                 spin_unlock_bh(&ar->ab->base_lock);
5100                 mutex_unlock(&ar->ab->tbl_mtx_lock);
5101
5102                 kfree(arsta->tx_stats);
5103                 arsta->tx_stats = NULL;
5104
5105                 kfree(arsta->rx_stats);
5106                 arsta->rx_stats = NULL;
5107         } else if (old_state == IEEE80211_STA_AUTH &&
5108                    new_state == IEEE80211_STA_ASSOC &&
5109                    (vif->type == NL80211_IFTYPE_AP ||
5110                     vif->type == NL80211_IFTYPE_MESH_POINT ||
5111                     vif->type == NL80211_IFTYPE_ADHOC)) {
5112                 ret = ath11k_station_assoc(ar, vif, sta, false);
5113                 if (ret)
5114                         ath11k_warn(ar->ab, "Failed to associate station: %pM\n",
5115                                     sta->addr);
5116
5117                 spin_lock_bh(&ar->data_lock);
5118                 /* Set arsta bw and prev bw */
5119                 arsta->bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
5120                 arsta->bw_prev = arsta->bw;
5121                 spin_unlock_bh(&ar->data_lock);
5122         } else if (old_state == IEEE80211_STA_ASSOC &&
5123                    new_state == IEEE80211_STA_AUTHORIZED) {
5124                 spin_lock_bh(&ar->ab->base_lock);
5125
5126                 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5127                 if (peer)
5128                         peer->is_authorized = true;
5129
5130                 spin_unlock_bh(&ar->ab->base_lock);
5131
5132                 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
5133                         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
5134                                                         arvif->vdev_id,
5135                                                         WMI_PEER_AUTHORIZE,
5136                                                         1);
5137                         if (ret)
5138                                 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
5139                                             sta->addr, arvif->vdev_id, ret);
5140                 }
5141         } else if (old_state == IEEE80211_STA_AUTHORIZED &&
5142                    new_state == IEEE80211_STA_ASSOC) {
5143                 spin_lock_bh(&ar->ab->base_lock);
5144
5145                 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5146                 if (peer)
5147                         peer->is_authorized = false;
5148
5149                 spin_unlock_bh(&ar->ab->base_lock);
5150         } else if (old_state == IEEE80211_STA_ASSOC &&
5151                    new_state == IEEE80211_STA_AUTH &&
5152                    (vif->type == NL80211_IFTYPE_AP ||
5153                     vif->type == NL80211_IFTYPE_MESH_POINT ||
5154                     vif->type == NL80211_IFTYPE_ADHOC)) {
5155                 ret = ath11k_station_disassoc(ar, vif, sta);
5156                 if (ret)
5157                         ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n",
5158                                     sta->addr);
5159         }
5160
5161         mutex_unlock(&ar->conf_mutex);
5162         return ret;
5163 }
5164
5165 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
5166                                        struct ieee80211_vif *vif,
5167                                        struct ieee80211_sta *sta)
5168 {
5169         struct ath11k *ar = hw->priv;
5170         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5171         int ret = 0;
5172         s16 txpwr;
5173
5174         if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
5175                 txpwr = 0;
5176         } else {
5177                 txpwr = sta->deflink.txpwr.power;
5178                 if (!txpwr)
5179                         return -EINVAL;
5180         }
5181
5182         if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL)
5183                 return -EINVAL;
5184
5185         mutex_lock(&ar->conf_mutex);
5186
5187         ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
5188                                         WMI_PEER_USE_FIXED_PWR, txpwr);
5189         if (ret) {
5190                 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
5191                             ret);
5192                 goto out;
5193         }
5194
5195 out:
5196         mutex_unlock(&ar->conf_mutex);
5197         return ret;
5198 }
5199
5200 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw,
5201                                         struct ieee80211_vif *vif,
5202                                         struct ieee80211_sta *sta, bool enabled)
5203 {
5204         struct ath11k *ar = hw->priv;
5205         struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5206
5207         if (enabled && !arsta->use_4addr_set) {
5208                 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk);
5209                 arsta->use_4addr_set = true;
5210         }
5211 }
5212
5213 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
5214                                         struct ieee80211_vif *vif,
5215                                         struct ieee80211_sta *sta,
5216                                         u32 changed)
5217 {
5218         struct ath11k *ar = hw->priv;
5219         struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
5220         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5221         struct ath11k_peer *peer;
5222         u32 bw, smps;
5223
5224         spin_lock_bh(&ar->ab->base_lock);
5225
5226         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
5227         if (!peer) {
5228                 spin_unlock_bh(&ar->ab->base_lock);
5229                 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
5230                             sta->addr, arvif->vdev_id);
5231                 return;
5232         }
5233
5234         spin_unlock_bh(&ar->ab->base_lock);
5235
5236         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5237                    "sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
5238                    sta->addr, changed, sta->deflink.bandwidth,
5239                    sta->deflink.rx_nss,
5240                    sta->deflink.smps_mode);
5241
5242         spin_lock_bh(&ar->data_lock);
5243
5244         if (changed & IEEE80211_RC_BW_CHANGED) {
5245                 bw = ath11k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
5246                 arsta->bw_prev = arsta->bw;
5247                 arsta->bw = bw;
5248         }
5249
5250         if (changed & IEEE80211_RC_NSS_CHANGED)
5251                 arsta->nss = sta->deflink.rx_nss;
5252
5253         if (changed & IEEE80211_RC_SMPS_CHANGED) {
5254                 smps = WMI_PEER_SMPS_PS_NONE;
5255
5256                 switch (sta->deflink.smps_mode) {
5257                 case IEEE80211_SMPS_AUTOMATIC:
5258                 case IEEE80211_SMPS_OFF:
5259                         smps = WMI_PEER_SMPS_PS_NONE;
5260                         break;
5261                 case IEEE80211_SMPS_STATIC:
5262                         smps = WMI_PEER_SMPS_STATIC;
5263                         break;
5264                 case IEEE80211_SMPS_DYNAMIC:
5265                         smps = WMI_PEER_SMPS_DYNAMIC;
5266                         break;
5267                 default:
5268                         ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
5269                                     sta->deflink.smps_mode, sta->addr);
5270                         smps = WMI_PEER_SMPS_PS_NONE;
5271                         break;
5272                 }
5273
5274                 arsta->smps = smps;
5275         }
5276
5277         arsta->changed |= changed;
5278
5279         spin_unlock_bh(&ar->data_lock);
5280
5281         ieee80211_queue_work(hw, &arsta->update_wk);
5282 }
5283
5284 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif,
5285                                 u16 ac, bool enable)
5286 {
5287         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5288         u32 value = 0;
5289         int ret = 0;
5290
5291         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5292                 return 0;
5293
5294         switch (ac) {
5295         case IEEE80211_AC_VO:
5296                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5297                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5298                 break;
5299         case IEEE80211_AC_VI:
5300                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5301                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5302                 break;
5303         case IEEE80211_AC_BE:
5304                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5305                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5306                 break;
5307         case IEEE80211_AC_BK:
5308                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5309                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5310                 break;
5311         }
5312
5313         if (enable)
5314                 arvif->u.sta.uapsd |= value;
5315         else
5316                 arvif->u.sta.uapsd &= ~value;
5317
5318         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5319                                           WMI_STA_PS_PARAM_UAPSD,
5320                                           arvif->u.sta.uapsd);
5321         if (ret) {
5322                 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret);
5323                 goto exit;
5324         }
5325
5326         if (arvif->u.sta.uapsd)
5327                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5328         else
5329                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5330
5331         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5332                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5333                                           value);
5334         if (ret)
5335                 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret);
5336
5337 exit:
5338         return ret;
5339 }
5340
5341 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw,
5342                                  struct ieee80211_vif *vif,
5343                                  unsigned int link_id, u16 ac,
5344                                  const struct ieee80211_tx_queue_params *params)
5345 {
5346         struct ath11k *ar = hw->priv;
5347         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5348         struct wmi_wmm_params_arg *p = NULL;
5349         int ret;
5350
5351         mutex_lock(&ar->conf_mutex);
5352
5353         switch (ac) {
5354         case IEEE80211_AC_VO:
5355                 p = &arvif->wmm_params.ac_vo;
5356                 break;
5357         case IEEE80211_AC_VI:
5358                 p = &arvif->wmm_params.ac_vi;
5359                 break;
5360         case IEEE80211_AC_BE:
5361                 p = &arvif->wmm_params.ac_be;
5362                 break;
5363         case IEEE80211_AC_BK:
5364                 p = &arvif->wmm_params.ac_bk;
5365                 break;
5366         }
5367
5368         if (WARN_ON(!p)) {
5369                 ret = -EINVAL;
5370                 goto exit;
5371         }
5372
5373         p->cwmin = params->cw_min;
5374         p->cwmax = params->cw_max;
5375         p->aifs = params->aifs;
5376         p->txop = params->txop;
5377
5378         ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
5379                                                  &arvif->wmm_params);
5380         if (ret) {
5381                 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
5382                 goto exit;
5383         }
5384
5385         ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5386
5387         if (ret)
5388                 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
5389
5390 exit:
5391         mutex_unlock(&ar->conf_mutex);
5392         return ret;
5393 }
5394
5395 static struct ieee80211_sta_ht_cap
5396 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
5397 {
5398         int i;
5399         struct ieee80211_sta_ht_cap ht_cap = {0};
5400         u32 ar_vht_cap = ar->pdev->cap.vht_cap;
5401
5402         if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
5403                 return ht_cap;
5404
5405         ht_cap.ht_supported = 1;
5406         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5407         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
5408         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5409         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5410         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
5411
5412         if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
5413                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5414
5415         if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
5416                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5417
5418         if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
5419                 u32 smps;
5420
5421                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
5422                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
5423
5424                 ht_cap.cap |= smps;
5425         }
5426
5427         if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
5428                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
5429
5430         if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
5431                 u32 stbc;
5432
5433                 stbc   = ar_ht_cap;
5434                 stbc  &= WMI_HT_CAP_RX_STBC;
5435                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
5436                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
5437                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
5438
5439                 ht_cap.cap |= stbc;
5440         }
5441
5442         if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
5443                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
5444
5445         if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
5446                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
5447
5448         if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
5449                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
5450
5451         for (i = 0; i < ar->num_rx_chains; i++) {
5452                 if (rate_cap_rx_chainmask & BIT(i))
5453                         ht_cap.mcs.rx_mask[i] = 0xFF;
5454         }
5455
5456         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
5457
5458         return ht_cap;
5459 }
5460
5461 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
5462 {
5463         u32 value = 0;
5464         struct ath11k *ar = arvif->ar;
5465         int nsts;
5466         int sound_dim;
5467         u32 vht_cap = ar->pdev->cap.vht_cap;
5468         u32 vdev_param = WMI_VDEV_PARAM_TXBF;
5469
5470         if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
5471                 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5472                 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5473                 if (nsts > (ar->num_rx_chains - 1))
5474                         nsts = ar->num_rx_chains - 1;
5475                 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
5476         }
5477
5478         if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
5479                 sound_dim = vht_cap &
5480                             IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5481                 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5482                 if (sound_dim > (ar->num_tx_chains - 1))
5483                         sound_dim = ar->num_tx_chains - 1;
5484                 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
5485         }
5486
5487         if (!value)
5488                 return 0;
5489
5490         if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
5491                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
5492
5493                 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
5494                     arvif->vdev_type == WMI_VDEV_TYPE_AP)
5495                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
5496         }
5497
5498         /* TODO: SUBFEE not validated in HK, disable here until validated? */
5499
5500         if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
5501                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
5502
5503                 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
5504                     arvif->vdev_type == WMI_VDEV_TYPE_STA)
5505                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
5506         }
5507
5508         return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5509                                              vdev_param, value);
5510 }
5511
5512 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
5513 {
5514         bool subfer, subfee;
5515         int sound_dim = 0, nsts = 0;
5516
5517         subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
5518         subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
5519
5520         if (ar->num_tx_chains < 2) {
5521                 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
5522                 subfer = false;
5523         }
5524
5525         if (ar->num_rx_chains < 2) {
5526                 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
5527                 subfee = false;
5528         }
5529
5530         /* If SU Beaformer is not set, then disable MU Beamformer Capability */
5531         if (!subfer)
5532                 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
5533
5534         /* If SU Beaformee is not set, then disable MU Beamformee Capability */
5535         if (!subfee)
5536                 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5537
5538         sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5539         sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5540         *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5541
5542         nsts = (*vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5543         nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5544         *vht_cap &= ~IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5545
5546         /* Enable Sounding Dimension Field only if SU BF is enabled */
5547         if (subfer) {
5548                 if (sound_dim > (ar->num_tx_chains - 1))
5549                         sound_dim = ar->num_tx_chains - 1;
5550
5551                 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5552                 sound_dim &=  IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5553                 *vht_cap |= sound_dim;
5554         }
5555
5556         /* Enable Beamformee STS Field only if SU BF is enabled */
5557         if (subfee) {
5558                 if (nsts > (ar->num_rx_chains - 1))
5559                         nsts = ar->num_rx_chains - 1;
5560
5561                 nsts <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
5562                 nsts &=  IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
5563                 *vht_cap |= nsts;
5564         }
5565 }
5566
5567 static struct ieee80211_sta_vht_cap
5568 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5569                       u32 rate_cap_rx_chainmask)
5570 {
5571         struct ieee80211_sta_vht_cap vht_cap = {0};
5572         u16 txmcs_map, rxmcs_map;
5573         int i;
5574
5575         vht_cap.vht_supported = 1;
5576         vht_cap.cap = ar->pdev->cap.vht_cap;
5577
5578         if (ar->pdev->cap.nss_ratio_enabled)
5579                 vht_cap.vht_mcs.tx_highest |=
5580                         cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5581
5582         ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5583
5584         rxmcs_map = 0;
5585         txmcs_map = 0;
5586         for (i = 0; i < 8; i++) {
5587                 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5588                         txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5589                 else
5590                         txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5591
5592                 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5593                         rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5594                 else
5595                         rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5596         }
5597
5598         if (rate_cap_tx_chainmask <= 1)
5599                 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5600
5601         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5602         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5603
5604         return vht_cap;
5605 }
5606
5607 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5608                                         struct ath11k_pdev_cap *cap,
5609                                         u32 *ht_cap_info)
5610 {
5611         struct ieee80211_supported_band *band;
5612         u32 rate_cap_tx_chainmask;
5613         u32 rate_cap_rx_chainmask;
5614         u32 ht_cap;
5615
5616         rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5617         rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5618
5619         if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5620                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5621                 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5622                 if (ht_cap_info)
5623                         *ht_cap_info = ht_cap;
5624                 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5625                                                     rate_cap_rx_chainmask);
5626         }
5627
5628         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5629             (ar->ab->hw_params.single_pdev_only ||
5630              !ar->supports_6ghz)) {
5631                 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5632                 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
5633                 if (ht_cap_info)
5634                         *ht_cap_info = ht_cap;
5635                 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5636                                                     rate_cap_rx_chainmask);
5637                 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5638                                                       rate_cap_rx_chainmask);
5639         }
5640 }
5641
5642 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5643 {
5644         /* TODO: Check the request chainmask against the supported
5645          * chainmask table which is advertised in extented_service_ready event
5646          */
5647
5648         return 0;
5649 }
5650
5651 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5652                                   u8 *he_ppet)
5653 {
5654         int nss, ru;
5655         u8 bit = 7;
5656
5657         he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5658         he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5659                        IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5660                       IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5661         for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5662                 for (ru = 0; ru < 4; ru++) {
5663                         u8 val;
5664                         int i;
5665
5666                         if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5667                                 continue;
5668                         val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5669                                0x3f;
5670                         val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5671                         for (i = 5; i >= 0; i--) {
5672                                 he_ppet[bit / 8] |=
5673                                         ((val >> i) & 0x1) << ((bit % 8));
5674                                 bit++;
5675                         }
5676                 }
5677         }
5678 }
5679
5680 static void
5681 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5682 {
5683         u8 m;
5684
5685         m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5686             IEEE80211_HE_MAC_CAP0_TWT_REQ;
5687         he_cap_elem->mac_cap_info[0] &= ~m;
5688
5689         m = IEEE80211_HE_MAC_CAP2_TRS |
5690             IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5691             IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5692         he_cap_elem->mac_cap_info[2] &= ~m;
5693
5694         m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5695             IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5696             IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5697         he_cap_elem->mac_cap_info[3] &= ~m;
5698
5699         m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5700             IEEE80211_HE_MAC_CAP4_BQR;
5701         he_cap_elem->mac_cap_info[4] &= ~m;
5702
5703         m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
5704             IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5705             IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5706             IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5707         he_cap_elem->mac_cap_info[5] &= ~m;
5708
5709         m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5710             IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5711         he_cap_elem->phy_cap_info[2] &= ~m;
5712
5713         m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
5714             IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5715             IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5716         he_cap_elem->phy_cap_info[3] &= ~m;
5717
5718         m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5719         he_cap_elem->phy_cap_info[4] &= ~m;
5720
5721         m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5722         he_cap_elem->phy_cap_info[5] &= ~m;
5723
5724         m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
5725             IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
5726             IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5727             IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5728         he_cap_elem->phy_cap_info[6] &= ~m;
5729
5730         m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5731             IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
5732             IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5733             IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5734         he_cap_elem->phy_cap_info[7] &= ~m;
5735
5736         m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5737             IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5738             IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5739             IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5740         he_cap_elem->phy_cap_info[8] &= ~m;
5741
5742         m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5743             IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5744             IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5745             IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5746             IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5747             IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5748         he_cap_elem->phy_cap_info[9] &= ~m;
5749 }
5750
5751 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5752                                            struct ath11k_band_cap *bcap)
5753 {
5754         u8 val;
5755
5756         bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5757         if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5758                 bcap->he_6ghz_capa |=
5759                         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5760                                    WLAN_HT_CAP_SM_PS_DYNAMIC);
5761         else
5762                 bcap->he_6ghz_capa |=
5763                         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5764                                    WLAN_HT_CAP_SM_PS_DISABLED);
5765         val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5766                         pcap->vht_cap);
5767         bcap->he_6ghz_capa |=
5768                 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5769         val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5770         bcap->he_6ghz_capa |=
5771                 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5772         if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5773                 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5774         if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5775                 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5776
5777         return cpu_to_le16(bcap->he_6ghz_capa);
5778 }
5779
5780 static void ath11k_mac_set_hemcsmap(struct ath11k *ar,
5781                                     struct ath11k_pdev_cap *cap,
5782                                     struct ieee80211_sta_he_cap *he_cap,
5783                                     int band)
5784 {
5785         u16 txmcs_map, rxmcs_map;
5786         u32 i;
5787
5788         rxmcs_map = 0;
5789         txmcs_map = 0;
5790         for (i = 0; i < 8; i++) {
5791                 if (i < ar->num_tx_chains &&
5792                     (ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift) & BIT(i))
5793                         txmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2);
5794                 else
5795                         txmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2);
5796
5797                 if (i < ar->num_rx_chains &&
5798                     (ar->cfg_rx_chainmask >> cap->tx_chain_mask_shift) & BIT(i))
5799                         rxmcs_map |= IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2);
5800                 else
5801                         rxmcs_map |= IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2);
5802         }
5803         he_cap->he_mcs_nss_supp.rx_mcs_80 =
5804                 cpu_to_le16(rxmcs_map & 0xffff);
5805         he_cap->he_mcs_nss_supp.tx_mcs_80 =
5806                 cpu_to_le16(txmcs_map & 0xffff);
5807         he_cap->he_mcs_nss_supp.rx_mcs_160 =
5808                 cpu_to_le16(rxmcs_map & 0xffff);
5809         he_cap->he_mcs_nss_supp.tx_mcs_160 =
5810                 cpu_to_le16(txmcs_map & 0xffff);
5811         he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5812                 cpu_to_le16(rxmcs_map & 0xffff);
5813         he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5814                 cpu_to_le16(txmcs_map & 0xffff);
5815 }
5816
5817 static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5818                                   struct ath11k_pdev_cap *cap,
5819                                   struct ieee80211_sband_iftype_data *data,
5820                                   int band)
5821 {
5822         int i, idx = 0;
5823
5824         for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5825                 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5826                 struct ath11k_band_cap *band_cap = &cap->band[band];
5827                 struct ieee80211_he_cap_elem *he_cap_elem =
5828                                 &he_cap->he_cap_elem;
5829
5830                 switch (i) {
5831                 case NL80211_IFTYPE_STATION:
5832                 case NL80211_IFTYPE_AP:
5833                 case NL80211_IFTYPE_MESH_POINT:
5834                         break;
5835
5836                 default:
5837                         continue;
5838                 }
5839
5840                 data[idx].types_mask = BIT(i);
5841                 he_cap->has_he = true;
5842                 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5843                        sizeof(he_cap_elem->mac_cap_info));
5844                 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5845                        sizeof(he_cap_elem->phy_cap_info));
5846
5847                 he_cap_elem->mac_cap_info[1] &=
5848                         IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
5849
5850                 he_cap_elem->phy_cap_info[5] &=
5851                         ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
5852                 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5853
5854                 switch (i) {
5855                 case NL80211_IFTYPE_AP:
5856                         he_cap_elem->phy_cap_info[3] &=
5857                                 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
5858                         he_cap_elem->phy_cap_info[9] |=
5859                                 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5860                         break;
5861                 case NL80211_IFTYPE_STATION:
5862                         he_cap_elem->mac_cap_info[0] &=
5863                                 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5864                         he_cap_elem->mac_cap_info[0] |=
5865                                 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5866                         he_cap_elem->phy_cap_info[9] |=
5867                                 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5868                         break;
5869                 case NL80211_IFTYPE_MESH_POINT:
5870                         ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5871                         break;
5872                 }
5873
5874                 ath11k_mac_set_hemcsmap(ar, cap, he_cap, band);
5875
5876                 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5877                 if (he_cap_elem->phy_cap_info[6] &
5878                     IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5879                         ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5880                                               he_cap->ppe_thres);
5881
5882                 if (band == NL80211_BAND_6GHZ) {
5883                         data[idx].he_6ghz_capa.capa =
5884                                 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5885                 }
5886                 idx++;
5887         }
5888
5889         return idx;
5890 }
5891
5892 static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5893                                     struct ath11k_pdev_cap *cap)
5894 {
5895         struct ieee80211_supported_band *band;
5896         int count;
5897
5898         if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5899                 count = ath11k_mac_copy_he_cap(ar, cap,
5900                                                ar->mac.iftype[NL80211_BAND_2GHZ],
5901                                                NL80211_BAND_2GHZ);
5902                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5903                 _ieee80211_set_sband_iftype_data(band,
5904                                                  ar->mac.iftype[NL80211_BAND_2GHZ],
5905                                                  count);
5906         }
5907
5908         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5909                 count = ath11k_mac_copy_he_cap(ar, cap,
5910                                                ar->mac.iftype[NL80211_BAND_5GHZ],
5911                                                NL80211_BAND_5GHZ);
5912                 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5913                 _ieee80211_set_sband_iftype_data(band,
5914                                                  ar->mac.iftype[NL80211_BAND_5GHZ],
5915                                                  count);
5916         }
5917
5918         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5919             ar->supports_6ghz) {
5920                 count = ath11k_mac_copy_he_cap(ar, cap,
5921                                                ar->mac.iftype[NL80211_BAND_6GHZ],
5922                                                NL80211_BAND_6GHZ);
5923                 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5924                 _ieee80211_set_sband_iftype_data(band,
5925                                                  ar->mac.iftype[NL80211_BAND_6GHZ],
5926                                                  count);
5927         }
5928 }
5929
5930 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5931 {
5932         int ret;
5933
5934         lockdep_assert_held(&ar->conf_mutex);
5935
5936         if (ath11k_check_chain_mask(ar, tx_ant, true))
5937                 return -EINVAL;
5938
5939         if (ath11k_check_chain_mask(ar, rx_ant, false))
5940                 return -EINVAL;
5941
5942         ar->cfg_tx_chainmask = tx_ant;
5943         ar->cfg_rx_chainmask = rx_ant;
5944
5945         if (ar->state != ATH11K_STATE_ON &&
5946             ar->state != ATH11K_STATE_RESTARTED)
5947                 return 0;
5948
5949         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5950                                         tx_ant, ar->pdev->pdev_id);
5951         if (ret) {
5952                 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5953                             ret, tx_ant);
5954                 return ret;
5955         }
5956
5957         ar->num_tx_chains = get_num_chains(tx_ant);
5958
5959         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5960                                         rx_ant, ar->pdev->pdev_id);
5961         if (ret) {
5962                 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5963                             ret, rx_ant);
5964                 return ret;
5965         }
5966
5967         ar->num_rx_chains = get_num_chains(rx_ant);
5968
5969         /* Reload HT/VHT/HE capability */
5970         ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
5971         ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
5972
5973         return 0;
5974 }
5975
5976 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5977 {
5978         int num_mgmt;
5979
5980         ieee80211_free_txskb(ar->hw, skb);
5981
5982         num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5983
5984         if (num_mgmt < 0)
5985                 WARN_ON_ONCE(1);
5986
5987         if (!num_mgmt)
5988                 wake_up(&ar->txmgmt_empty_waitq);
5989 }
5990
5991 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
5992 {
5993         struct sk_buff *msdu;
5994         struct ieee80211_tx_info *info;
5995
5996         spin_lock_bh(&ar->txmgmt_idr_lock);
5997         msdu = idr_remove(&ar->txmgmt_idr, buf_id);
5998         spin_unlock_bh(&ar->txmgmt_idr_lock);
5999
6000         if (!msdu)
6001                 return;
6002
6003         dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
6004                          DMA_TO_DEVICE);
6005
6006         info = IEEE80211_SKB_CB(msdu);
6007         memset(&info->status, 0, sizeof(info->status));
6008
6009         ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
6010 }
6011
6012 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
6013 {
6014         struct ath11k *ar = ctx;
6015
6016         ath11k_mac_tx_mgmt_free(ar, buf_id);
6017
6018         return 0;
6019 }
6020
6021 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
6022 {
6023         struct ieee80211_vif *vif = ctx;
6024         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6025         struct ath11k *ar = skb_cb->ar;
6026
6027         if (skb_cb->vif == vif)
6028                 ath11k_mac_tx_mgmt_free(ar, buf_id);
6029
6030         return 0;
6031 }
6032
6033 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
6034                                   struct sk_buff *skb)
6035 {
6036         struct ath11k_base *ab = ar->ab;
6037         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
6038         struct ieee80211_tx_info *info;
6039         dma_addr_t paddr;
6040         int buf_id;
6041         int ret;
6042
6043         ATH11K_SKB_CB(skb)->ar = ar;
6044
6045         spin_lock_bh(&ar->txmgmt_idr_lock);
6046         buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
6047                            ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
6048         spin_unlock_bh(&ar->txmgmt_idr_lock);
6049
6050         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
6051                    "tx mgmt frame, buf id %d\n", buf_id);
6052
6053         if (buf_id < 0)
6054                 return -ENOSPC;
6055
6056         info = IEEE80211_SKB_CB(skb);
6057         if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
6058                 if ((ieee80211_is_action(hdr->frame_control) ||
6059                      ieee80211_is_deauth(hdr->frame_control) ||
6060                      ieee80211_is_disassoc(hdr->frame_control)) &&
6061                      ieee80211_has_protected(hdr->frame_control)) {
6062                         skb_put(skb, IEEE80211_CCMP_MIC_LEN);
6063                 }
6064         }
6065
6066         paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
6067         if (dma_mapping_error(ab->dev, paddr)) {
6068                 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
6069                 ret = -EIO;
6070                 goto err_free_idr;
6071         }
6072
6073         ATH11K_SKB_CB(skb)->paddr = paddr;
6074
6075         ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
6076         if (ret) {
6077                 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
6078                 goto err_unmap_buf;
6079         }
6080
6081         return 0;
6082
6083 err_unmap_buf:
6084         dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
6085                          skb->len, DMA_TO_DEVICE);
6086 err_free_idr:
6087         spin_lock_bh(&ar->txmgmt_idr_lock);
6088         idr_remove(&ar->txmgmt_idr, buf_id);
6089         spin_unlock_bh(&ar->txmgmt_idr_lock);
6090
6091         return ret;
6092 }
6093
6094 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
6095 {
6096         struct sk_buff *skb;
6097
6098         while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
6099                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6100 }
6101
6102 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
6103 {
6104         struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
6105         struct ath11k_skb_cb *skb_cb;
6106         struct ath11k_vif *arvif;
6107         struct sk_buff *skb;
6108         int ret;
6109
6110         while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
6111                 skb_cb = ATH11K_SKB_CB(skb);
6112                 if (!skb_cb->vif) {
6113                         ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
6114                         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6115                         continue;
6116                 }
6117
6118                 arvif = ath11k_vif_to_arvif(skb_cb->vif);
6119                 mutex_lock(&ar->conf_mutex);
6120                 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) {
6121                         ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
6122                         if (ret) {
6123                                 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
6124                                             arvif->vdev_id, ret);
6125                                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6126                         } else {
6127                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
6128                                            "tx mgmt frame, vdev_id %d\n",
6129                                            arvif->vdev_id);
6130                         }
6131                 } else {
6132                         ath11k_warn(ar->ab,
6133                                     "dropping mgmt frame for vdev %d, is_started %d\n",
6134                                     arvif->vdev_id,
6135                                     arvif->is_started);
6136                         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
6137                 }
6138                 mutex_unlock(&ar->conf_mutex);
6139         }
6140 }
6141
6142 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
6143                               bool is_prb_rsp)
6144 {
6145         struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
6146
6147         if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
6148                 return -ESHUTDOWN;
6149
6150         /* Drop probe response packets when the pending management tx
6151          * count has reached a certain threshold, so as to prioritize
6152          * other mgmt packets like auth and assoc to be sent on time
6153          * for establishing successful connections.
6154          */
6155         if (is_prb_rsp &&
6156             atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
6157                 ath11k_warn(ar->ab,
6158                             "dropping probe response as pending queue is almost full\n");
6159                 return -ENOSPC;
6160         }
6161
6162         if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
6163                 ath11k_warn(ar->ab, "mgmt tx queue is full\n");
6164                 return -ENOSPC;
6165         }
6166
6167         skb_queue_tail(q, skb);
6168         atomic_inc(&ar->num_pending_mgmt_tx);
6169         queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work);
6170
6171         return 0;
6172 }
6173
6174 static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
6175                              struct ieee80211_tx_control *control,
6176                              struct sk_buff *skb)
6177 {
6178         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
6179         struct ath11k *ar = hw->priv;
6180         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
6181         struct ieee80211_vif *vif = info->control.vif;
6182         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6183         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
6184         struct ieee80211_key_conf *key = info->control.hw_key;
6185         struct ath11k_sta *arsta = NULL;
6186         u32 info_flags = info->flags;
6187         bool is_prb_rsp;
6188         int ret;
6189
6190         memset(skb_cb, 0, sizeof(*skb_cb));
6191         skb_cb->vif = vif;
6192
6193         if (key) {
6194                 skb_cb->cipher = key->cipher;
6195                 skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
6196         }
6197
6198         if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
6199                 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
6200         } else if (ieee80211_is_mgmt(hdr->frame_control)) {
6201                 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
6202                 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
6203                 if (ret) {
6204                         ath11k_warn(ar->ab, "failed to queue management frame %d\n",
6205                                     ret);
6206                         ieee80211_free_txskb(ar->hw, skb);
6207                 }
6208                 return;
6209         }
6210
6211         if (control->sta)
6212                 arsta = ath11k_sta_to_arsta(control->sta);
6213
6214         ret = ath11k_dp_tx(ar, arvif, arsta, skb);
6215         if (unlikely(ret)) {
6216                 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
6217                 ieee80211_free_txskb(ar->hw, skb);
6218         }
6219 }
6220
6221 void ath11k_mac_drain_tx(struct ath11k *ar)
6222 {
6223         /* make sure rcu-protected mac80211 tx path itself is drained */
6224         synchronize_net();
6225
6226         cancel_work_sync(&ar->wmi_mgmt_tx_work);
6227         ath11k_mgmt_over_wmi_tx_purge(ar);
6228 }
6229
6230 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
6231 {
6232         struct htt_rx_ring_tlv_filter tlv_filter = {0};
6233         struct ath11k_base *ab = ar->ab;
6234         int i, ret = 0;
6235         u32 ring_id;
6236
6237         if (enable) {
6238                 tlv_filter = ath11k_mac_mon_status_filter_default;
6239                 if (ath11k_debugfs_rx_filter(ar))
6240                         tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
6241         }
6242
6243         for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
6244                 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
6245                 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
6246                                                        ar->dp.mac_id + i,
6247                                                        HAL_RXDMA_MONITOR_STATUS,
6248                                                        DP_RX_BUFFER_SIZE,
6249                                                        &tlv_filter);
6250         }
6251
6252         if (enable && !ar->ab->hw_params.rxdma1_enable)
6253                 mod_timer(&ar->ab->mon_reap_timer, jiffies +
6254                           msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
6255
6256         return ret;
6257 }
6258
6259 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
6260 {
6261         int recovery_start_count;
6262
6263         if (!ab->is_reset)
6264                 return;
6265
6266         recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
6267         ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
6268
6269         if (recovery_start_count == ab->num_radios) {
6270                 complete(&ab->recovery_start);
6271                 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
6272         }
6273
6274         ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
6275
6276         wait_for_completion_timeout(&ab->reconfigure_complete,
6277                                     ATH11K_RECONFIGURE_TIMEOUT_HZ);
6278 }
6279
6280 static int ath11k_mac_op_start(struct ieee80211_hw *hw)
6281 {
6282         struct ath11k *ar = hw->priv;
6283         struct ath11k_base *ab = ar->ab;
6284         struct ath11k_pdev *pdev = ar->pdev;
6285         int ret;
6286
6287         if (ath11k_ftm_mode) {
6288                 ath11k_warn(ab, "mac operations not supported in factory test mode\n");
6289                 return -EOPNOTSUPP;
6290         }
6291
6292         ath11k_mac_drain_tx(ar);
6293         mutex_lock(&ar->conf_mutex);
6294
6295         switch (ar->state) {
6296         case ATH11K_STATE_OFF:
6297                 ar->state = ATH11K_STATE_ON;
6298                 break;
6299         case ATH11K_STATE_RESTARTING:
6300                 ar->state = ATH11K_STATE_RESTARTED;
6301                 ath11k_mac_wait_reconfigure(ab);
6302                 break;
6303         case ATH11K_STATE_RESTARTED:
6304         case ATH11K_STATE_WEDGED:
6305         case ATH11K_STATE_ON:
6306         case ATH11K_STATE_FTM:
6307                 WARN_ON(1);
6308                 ret = -EINVAL;
6309                 goto err;
6310         }
6311
6312         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
6313                                         1, pdev->pdev_id);
6314
6315         if (ret) {
6316                 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
6317                 goto err;
6318         }
6319
6320         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
6321                                         pdev->pdev_id);
6322         if (ret) {
6323                 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
6324                 goto err;
6325         }
6326
6327         if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
6328                 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
6329                 if (ret) {
6330                         ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
6331                         goto err;
6332                 }
6333         }
6334
6335         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
6336                                         0, pdev->pdev_id);
6337         if (ret) {
6338                 ath11k_err(ab, "failed to set ac override for ARP: %d\n",
6339                            ret);
6340                 goto err;
6341         }
6342
6343         ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
6344         if (ret) {
6345                 ath11k_err(ab, "failed to offload radar detection: %d\n",
6346                            ret);
6347                 goto err;
6348         }
6349
6350         ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
6351                                                   HTT_PPDU_STATS_TAG_DEFAULT);
6352         if (ret) {
6353                 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
6354                 goto err;
6355         }
6356
6357         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
6358                                         1, pdev->pdev_id);
6359
6360         if (ret) {
6361                 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
6362                 goto err;
6363         }
6364
6365         __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
6366
6367         /* TODO: Do we need to enable ANI? */
6368
6369         ath11k_reg_update_chan_list(ar, false);
6370
6371         ar->num_started_vdevs = 0;
6372         ar->num_created_vdevs = 0;
6373         ar->num_peers = 0;
6374         ar->allocated_vdev_map = 0;
6375
6376         /* Configure monitor status ring with default rx_filter to get rx status
6377          * such as rssi, rx_duration.
6378          */
6379         ret = ath11k_mac_config_mon_status_default(ar, true);
6380         if (ret) {
6381                 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
6382                            ret);
6383                 goto err;
6384         }
6385
6386         /* Configure the hash seed for hash based reo dest ring selection */
6387         ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
6388
6389         /* allow device to enter IMPS */
6390         if (ab->hw_params.idle_ps) {
6391                 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
6392                                                 1, pdev->pdev_id);
6393                 if (ret) {
6394                         ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
6395                         goto err;
6396                 }
6397         }
6398
6399         mutex_unlock(&ar->conf_mutex);
6400
6401         rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
6402                            &ab->pdevs[ar->pdev_idx]);
6403
6404         return 0;
6405
6406 err:
6407         ar->state = ATH11K_STATE_OFF;
6408         mutex_unlock(&ar->conf_mutex);
6409
6410         return ret;
6411 }
6412
6413 static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
6414 {
6415         struct ath11k *ar = hw->priv;
6416         struct htt_ppdu_stats_info *ppdu_stats, *tmp;
6417         int ret;
6418
6419         ath11k_mac_drain_tx(ar);
6420
6421         mutex_lock(&ar->conf_mutex);
6422         ret = ath11k_mac_config_mon_status_default(ar, false);
6423         if (ret)
6424                 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
6425                            ret);
6426
6427         clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6428         ar->state = ATH11K_STATE_OFF;
6429         mutex_unlock(&ar->conf_mutex);
6430
6431         cancel_delayed_work_sync(&ar->scan.timeout);
6432         cancel_work_sync(&ar->regd_update_work);
6433         cancel_work_sync(&ar->ab->update_11d_work);
6434
6435         if (ar->state_11d == ATH11K_11D_PREPARING) {
6436                 ar->state_11d = ATH11K_11D_IDLE;
6437                 complete(&ar->completed_11d_scan);
6438         }
6439
6440         spin_lock_bh(&ar->data_lock);
6441         list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
6442                 list_del(&ppdu_stats->list);
6443                 kfree(ppdu_stats);
6444         }
6445         spin_unlock_bh(&ar->data_lock);
6446
6447         rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
6448
6449         synchronize_rcu();
6450
6451         atomic_set(&ar->num_pending_mgmt_tx, 0);
6452 }
6453
6454 static int ath11k_mac_setup_vdev_params_mbssid(struct ath11k_vif *arvif,
6455                                                u32 *flags, u32 *tx_vdev_id)
6456 {
6457         struct ath11k *ar = arvif->ar;
6458         struct ath11k_vif *tx_arvif;
6459         struct ieee80211_vif *tx_vif;
6460
6461         *tx_vdev_id = 0;
6462         tx_vif = arvif->vif->mbssid_tx_vif;
6463         if (!tx_vif) {
6464                 *flags = WMI_HOST_VDEV_FLAGS_NON_MBSSID_AP;
6465                 return 0;
6466         }
6467
6468         tx_arvif = ath11k_vif_to_arvif(tx_vif);
6469
6470         if (arvif->vif->bss_conf.nontransmitted) {
6471                 if (ar->hw->wiphy != ieee80211_vif_to_wdev(tx_vif)->wiphy)
6472                         return -EINVAL;
6473
6474                 *flags = WMI_HOST_VDEV_FLAGS_NON_TRANSMIT_AP;
6475                 *tx_vdev_id = ath11k_vif_to_arvif(tx_vif)->vdev_id;
6476         } else if (tx_arvif == arvif) {
6477                 *flags = WMI_HOST_VDEV_FLAGS_TRANSMIT_AP;
6478         } else {
6479                 return -EINVAL;
6480         }
6481
6482         if (arvif->vif->bss_conf.ema_ap)
6483                 *flags |= WMI_HOST_VDEV_FLAGS_EMA_MODE;
6484
6485         return 0;
6486 }
6487
6488 static int ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
6489                                                struct vdev_create_params *params)
6490 {
6491         struct ath11k *ar = arvif->ar;
6492         struct ath11k_pdev *pdev = ar->pdev;
6493         int ret;
6494
6495         params->if_id = arvif->vdev_id;
6496         params->type = arvif->vdev_type;
6497         params->subtype = arvif->vdev_subtype;
6498         params->pdev_id = pdev->pdev_id;
6499         params->mbssid_flags = 0;
6500         params->mbssid_tx_vdev_id = 0;
6501
6502         if (!test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT,
6503                       ar->ab->wmi_ab.svc_map)) {
6504                 ret = ath11k_mac_setup_vdev_params_mbssid(arvif,
6505                                                           &params->mbssid_flags,
6506                                                           &params->mbssid_tx_vdev_id);
6507                 if (ret)
6508                         return ret;
6509         }
6510
6511         if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
6512                 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
6513                 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
6514         }
6515         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
6516                 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
6517                 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
6518         }
6519         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
6520             ar->supports_6ghz) {
6521                 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
6522                 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
6523         }
6524         return 0;
6525 }
6526
6527 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
6528                                              struct ieee80211_vif *vif)
6529 {
6530         struct ath11k *ar = hw->priv;
6531         struct ath11k_base *ab = ar->ab;
6532         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6533         u32 param_id, param_value;
6534         int ret;
6535
6536         param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
6537         if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
6538             (vif->type != NL80211_IFTYPE_STATION &&
6539              vif->type != NL80211_IFTYPE_AP))
6540                 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
6541                                         IEEE80211_OFFLOAD_DECAP_ENABLED);
6542
6543         if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
6544                 param_value = ATH11K_HW_TXRX_ETHERNET;
6545         else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6546                 param_value = ATH11K_HW_TXRX_RAW;
6547         else
6548                 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6549
6550         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6551                                             param_id, param_value);
6552         if (ret) {
6553                 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6554                             arvif->vdev_id, ret);
6555                 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6556         }
6557
6558         param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6559         if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6560                 param_value = ATH11K_HW_TXRX_ETHERNET;
6561         else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6562                 param_value = ATH11K_HW_TXRX_RAW;
6563         else
6564                 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6565
6566         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6567                                             param_id, param_value);
6568         if (ret) {
6569                 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6570                             arvif->vdev_id, ret);
6571                 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6572         }
6573 }
6574
6575 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6576 {
6577         struct ath11k *ar;
6578         struct ath11k_pdev *pdev;
6579         struct ath11k_vif *arvif;
6580         int i;
6581
6582         for (i = 0; i < ab->num_radios; i++) {
6583                 pdev = &ab->pdevs[i];
6584                 ar = pdev->ar;
6585                 list_for_each_entry(arvif, &ar->arvifs, list) {
6586                         if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6587                                 return true;
6588                 }
6589         }
6590         return false;
6591 }
6592
6593 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
6594 {
6595         struct wmi_11d_scan_start_params param;
6596         int ret;
6597
6598         mutex_lock(&ar->ab->vdev_id_11d_lock);
6599
6600         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev id for 11d scan %d\n",
6601                    ar->vdev_id_11d_scan);
6602
6603         if (ar->regdom_set_by_user)
6604                 goto fin;
6605
6606         if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6607                 goto fin;
6608
6609         if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6610                 goto fin;
6611
6612         if (ath11k_mac_vif_ap_active_any(ar->ab))
6613                 goto fin;
6614
6615         param.vdev_id = vdev_id;
6616         param.start_interval_msec = 0;
6617         param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6618
6619         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "start 11d scan\n");
6620
6621         ret = ath11k_wmi_send_11d_scan_start_cmd(ar, &param);
6622         if (ret) {
6623                 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6624                             vdev_id, ret);
6625         } else {
6626                 ar->vdev_id_11d_scan = vdev_id;
6627                 if (ar->state_11d == ATH11K_11D_PREPARING)
6628                         ar->state_11d = ATH11K_11D_RUNNING;
6629         }
6630
6631 fin:
6632         if (ar->state_11d == ATH11K_11D_PREPARING) {
6633                 ar->state_11d = ATH11K_11D_IDLE;
6634                 complete(&ar->completed_11d_scan);
6635         }
6636
6637         mutex_unlock(&ar->ab->vdev_id_11d_lock);
6638 }
6639
6640 void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6641 {
6642         int ret;
6643         u32 vdev_id;
6644
6645         if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6646                 return;
6647
6648         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d scan\n");
6649
6650         mutex_lock(&ar->ab->vdev_id_11d_lock);
6651
6652         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "stop 11d vdev id %d\n",
6653                    ar->vdev_id_11d_scan);
6654
6655         if (ar->state_11d == ATH11K_11D_PREPARING) {
6656                 ar->state_11d = ATH11K_11D_IDLE;
6657                 complete(&ar->completed_11d_scan);
6658         }
6659
6660         if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6661                 vdev_id = ar->vdev_id_11d_scan;
6662
6663                 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
6664                 if (ret) {
6665                         ath11k_warn(ar->ab,
6666                                     "failed to stopt 11d scan vdev %d ret: %d\n",
6667                                     vdev_id, ret);
6668                 } else {
6669                         ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
6670                         ar->state_11d = ATH11K_11D_IDLE;
6671                         complete(&ar->completed_11d_scan);
6672                 }
6673         }
6674         mutex_unlock(&ar->ab->vdev_id_11d_lock);
6675 }
6676
6677 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6678 {
6679         struct ath11k *ar;
6680         struct ath11k_pdev *pdev;
6681         int i;
6682
6683         ath11k_dbg(ab, ATH11K_DBG_MAC, "stop soc 11d scan\n");
6684
6685         for (i = 0; i < ab->num_radios; i++) {
6686                 pdev = &ab->pdevs[i];
6687                 ar = pdev->ar;
6688
6689                 ath11k_mac_11d_scan_stop(ar);
6690         }
6691 }
6692
6693 static int ath11k_mac_vdev_delete(struct ath11k *ar, struct ath11k_vif *arvif)
6694 {
6695         unsigned long time_left;
6696         struct ieee80211_vif *vif = arvif->vif;
6697         int ret = 0;
6698
6699         lockdep_assert_held(&ar->conf_mutex);
6700
6701         reinit_completion(&ar->vdev_delete_done);
6702
6703         ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6704         if (ret) {
6705                 ath11k_warn(ar->ab, "failed to delete WMI vdev %d: %d\n",
6706                             arvif->vdev_id, ret);
6707                 return ret;
6708         }
6709
6710         time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6711                                                 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6712         if (time_left == 0) {
6713                 ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
6714                 return -ETIMEDOUT;
6715         }
6716
6717         ar->ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6718         ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6719         ar->num_created_vdevs--;
6720
6721         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6722                    vif->addr, arvif->vdev_id);
6723
6724         return ret;
6725 }
6726
6727 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6728                                        struct ieee80211_vif *vif)
6729 {
6730         struct ath11k *ar = hw->priv;
6731         struct ath11k_base *ab = ar->ab;
6732         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6733         struct vdev_create_params vdev_param = {0};
6734         struct peer_create_params peer_param;
6735         u32 param_id, param_value;
6736         u16 nss;
6737         int i;
6738         int ret, fbret;
6739         int bit;
6740
6741         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6742
6743         mutex_lock(&ar->conf_mutex);
6744
6745         if (vif->type == NL80211_IFTYPE_AP &&
6746             ar->num_peers > (ar->max_num_peers - 1)) {
6747                 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6748                 ret = -ENOBUFS;
6749                 goto err;
6750         }
6751
6752         if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
6753                 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
6754                             ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
6755                 ret = -EBUSY;
6756                 goto err;
6757         }
6758
6759         /* In the case of hardware recovery, debugfs files are
6760          * not deleted since ieee80211_ops.remove_interface() is
6761          * not invoked. In such cases, try to delete the files.
6762          * These will be re-created later.
6763          */
6764         ath11k_debugfs_remove_interface(arvif);
6765
6766         memset(arvif, 0, sizeof(*arvif));
6767
6768         arvif->ar = ar;
6769         arvif->vif = vif;
6770
6771         INIT_LIST_HEAD(&arvif->list);
6772         INIT_DELAYED_WORK(&arvif->connection_loss_work,
6773                           ath11k_mac_vif_sta_connection_loss_work);
6774
6775         for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6776                 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
6777                 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
6778                 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6779                        sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6780                 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6781                        sizeof(arvif->bitrate_mask.control[i].vht_mcs));
6782                 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6783                        sizeof(arvif->bitrate_mask.control[i].he_mcs));
6784         }
6785
6786         bit = __ffs64(ab->free_vdev_map);
6787
6788         arvif->vdev_id = bit;
6789         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6790
6791         switch (vif->type) {
6792         case NL80211_IFTYPE_UNSPECIFIED:
6793         case NL80211_IFTYPE_STATION:
6794                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
6795                 break;
6796         case NL80211_IFTYPE_MESH_POINT:
6797                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
6798                 fallthrough;
6799         case NL80211_IFTYPE_AP:
6800                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
6801                 break;
6802         case NL80211_IFTYPE_MONITOR:
6803                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
6804                 ar->monitor_vdev_id = bit;
6805                 break;
6806         default:
6807                 WARN_ON(1);
6808                 break;
6809         }
6810
6811         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "add interface id %d type %d subtype %d map %llx\n",
6812                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6813                    ab->free_vdev_map);
6814
6815         vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6816         for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6817                 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6818
6819         ret = ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6820         if (ret) {
6821                 ath11k_warn(ab, "failed to create vdev parameters %d: %d\n",
6822                             arvif->vdev_id, ret);
6823                 goto err;
6824         }
6825
6826         ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6827         if (ret) {
6828                 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6829                             arvif->vdev_id, ret);
6830                 goto err;
6831         }
6832
6833         ar->num_created_vdevs++;
6834         ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6835                    vif->addr, arvif->vdev_id);
6836         ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
6837         ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
6838
6839         spin_lock_bh(&ar->data_lock);
6840         list_add(&arvif->list, &ar->arvifs);
6841         spin_unlock_bh(&ar->data_lock);
6842
6843         ath11k_mac_op_update_vif_offload(hw, vif);
6844
6845         nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6846         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6847                                             WMI_VDEV_PARAM_NSS, nss);
6848         if (ret) {
6849                 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6850                             arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6851                 goto err_vdev_del;
6852         }
6853
6854         switch (arvif->vdev_type) {
6855         case WMI_VDEV_TYPE_AP:
6856                 peer_param.vdev_id = arvif->vdev_id;
6857                 peer_param.peer_addr = vif->addr;
6858                 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6859                 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6860                 if (ret) {
6861                         ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6862                                     arvif->vdev_id, ret);
6863                         goto err_vdev_del;
6864                 }
6865
6866                 ret = ath11k_mac_set_kickout(arvif);
6867                 if (ret) {
6868                         ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6869                                     arvif->vdev_id, ret);
6870                         goto err_peer_del;
6871                 }
6872
6873                 ath11k_mac_11d_scan_stop_all(ar->ab);
6874                 break;
6875         case WMI_VDEV_TYPE_STA:
6876                 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6877                 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6878                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6879                                                   param_id, param_value);
6880                 if (ret) {
6881                         ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6882                                     arvif->vdev_id, ret);
6883                         goto err_peer_del;
6884                 }
6885
6886                 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6887                 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6888                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6889                                                   param_id, param_value);
6890                 if (ret) {
6891                         ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6892                                     arvif->vdev_id, ret);
6893                         goto err_peer_del;
6894                 }
6895
6896                 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6897                 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6898                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6899                                                   param_id, param_value);
6900                 if (ret) {
6901                         ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6902                                     arvif->vdev_id, ret);
6903                         goto err_peer_del;
6904                 }
6905
6906                 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6907                                                   WMI_STA_PS_MODE_DISABLED);
6908                 if (ret) {
6909                         ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6910                                     arvif->vdev_id, ret);
6911                         goto err_peer_del;
6912                 }
6913
6914                 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6915                         reinit_completion(&ar->completed_11d_scan);
6916                         ar->state_11d = ATH11K_11D_PREPARING;
6917                 }
6918                 break;
6919         case WMI_VDEV_TYPE_MONITOR:
6920                 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6921                 break;
6922         default:
6923                 break;
6924         }
6925
6926         arvif->txpower = vif->bss_conf.txpower;
6927         ret = ath11k_mac_txpower_recalc(ar);
6928         if (ret)
6929                 goto err_peer_del;
6930
6931         param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6932         param_value = ar->hw->wiphy->rts_threshold;
6933         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6934                                             param_id, param_value);
6935         if (ret) {
6936                 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6937                             arvif->vdev_id, ret);
6938         }
6939
6940         ath11k_dp_vdev_tx_attach(ar, arvif);
6941
6942         ath11k_debugfs_add_interface(arvif);
6943
6944         if (vif->type != NL80211_IFTYPE_MONITOR &&
6945             test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6946                 ret = ath11k_mac_monitor_vdev_create(ar);
6947                 if (ret)
6948                         ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6949                                     ret);
6950         }
6951
6952         mutex_unlock(&ar->conf_mutex);
6953
6954         return 0;
6955
6956 err_peer_del:
6957         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6958                 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6959                 if (fbret) {
6960                         ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6961                                     vif->addr, arvif->vdev_id, fbret);
6962                         goto err;
6963                 }
6964         }
6965
6966 err_vdev_del:
6967         ath11k_mac_vdev_delete(ar, arvif);
6968         spin_lock_bh(&ar->data_lock);
6969         list_del(&arvif->list);
6970         spin_unlock_bh(&ar->data_lock);
6971
6972 err:
6973         mutex_unlock(&ar->conf_mutex);
6974
6975         return ret;
6976 }
6977
6978 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6979 {
6980         struct ieee80211_vif *vif = ctx;
6981         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
6982
6983         if (skb_cb->vif == vif)
6984                 skb_cb->vif = NULL;
6985
6986         return 0;
6987 }
6988
6989 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6990                                            struct ieee80211_vif *vif)
6991 {
6992         struct ath11k *ar = hw->priv;
6993         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6994         struct ath11k_base *ab = ar->ab;
6995         int ret;
6996         int i;
6997
6998         cancel_delayed_work_sync(&arvif->connection_loss_work);
6999
7000         mutex_lock(&ar->conf_mutex);
7001
7002         ath11k_dbg(ab, ATH11K_DBG_MAC, "remove interface (vdev %d)\n",
7003                    arvif->vdev_id);
7004
7005         ret = ath11k_spectral_vif_stop(arvif);
7006         if (ret)
7007                 ath11k_warn(ab, "failed to stop spectral for vdev %i: %d\n",
7008                             arvif->vdev_id, ret);
7009
7010         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7011                 ath11k_mac_11d_scan_stop(ar);
7012
7013         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
7014                 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
7015                 if (ret)
7016                         ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
7017                                     arvif->vdev_id, ret);
7018         }
7019
7020         ret = ath11k_mac_vdev_delete(ar, arvif);
7021         if (ret) {
7022                 ath11k_warn(ab, "failed to delete vdev %d: %d\n",
7023                             arvif->vdev_id, ret);
7024                 goto err_vdev_del;
7025         }
7026
7027         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7028                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
7029                 ar->monitor_vdev_id = -1;
7030         } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
7031                    !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
7032                 ret = ath11k_mac_monitor_vdev_delete(ar);
7033                 if (ret)
7034                         /* continue even if there's an error */
7035                         ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
7036                                     ret);
7037         }
7038
7039 err_vdev_del:
7040         spin_lock_bh(&ar->data_lock);
7041         list_del(&arvif->list);
7042         spin_unlock_bh(&ar->data_lock);
7043
7044         ath11k_peer_cleanup(ar, arvif->vdev_id);
7045
7046         idr_for_each(&ar->txmgmt_idr,
7047                      ath11k_mac_vif_txmgmt_idr_remove, vif);
7048
7049         for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
7050                 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
7051                 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
7052                              ath11k_mac_vif_unref, vif);
7053                 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
7054         }
7055
7056         /* Recalc txpower for remaining vdev */
7057         ath11k_mac_txpower_recalc(ar);
7058
7059         ath11k_debugfs_remove_interface(arvif);
7060
7061         /* TODO: recal traffic pause state based on the available vdevs */
7062
7063         mutex_unlock(&ar->conf_mutex);
7064 }
7065
7066 /* FIXME: Has to be verified. */
7067 #define SUPPORTED_FILTERS                       \
7068         (FIF_ALLMULTI |                         \
7069         FIF_CONTROL |                           \
7070         FIF_PSPOLL |                            \
7071         FIF_OTHER_BSS |                         \
7072         FIF_BCN_PRBRESP_PROMISC |               \
7073         FIF_PROBE_REQ |                         \
7074         FIF_FCSFAIL)
7075
7076 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
7077                                            unsigned int changed_flags,
7078                                            unsigned int *total_flags,
7079                                            u64 multicast)
7080 {
7081         struct ath11k *ar = hw->priv;
7082
7083         mutex_lock(&ar->conf_mutex);
7084
7085         *total_flags &= SUPPORTED_FILTERS;
7086         ar->filter_flags = *total_flags;
7087
7088         mutex_unlock(&ar->conf_mutex);
7089 }
7090
7091 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
7092 {
7093         struct ath11k *ar = hw->priv;
7094
7095         mutex_lock(&ar->conf_mutex);
7096
7097         *tx_ant = ar->cfg_tx_chainmask;
7098         *rx_ant = ar->cfg_rx_chainmask;
7099
7100         mutex_unlock(&ar->conf_mutex);
7101
7102         return 0;
7103 }
7104
7105 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
7106 {
7107         struct ath11k *ar = hw->priv;
7108         int ret;
7109
7110         mutex_lock(&ar->conf_mutex);
7111         ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
7112         mutex_unlock(&ar->conf_mutex);
7113
7114         return ret;
7115 }
7116
7117 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
7118                                       struct ieee80211_vif *vif,
7119                                       struct ieee80211_ampdu_params *params)
7120 {
7121         struct ath11k *ar = hw->priv;
7122         int ret = -EINVAL;
7123
7124         mutex_lock(&ar->conf_mutex);
7125
7126         switch (params->action) {
7127         case IEEE80211_AMPDU_RX_START:
7128                 ret = ath11k_dp_rx_ampdu_start(ar, params);
7129                 break;
7130         case IEEE80211_AMPDU_RX_STOP:
7131                 ret = ath11k_dp_rx_ampdu_stop(ar, params);
7132                 break;
7133         case IEEE80211_AMPDU_TX_START:
7134         case IEEE80211_AMPDU_TX_STOP_CONT:
7135         case IEEE80211_AMPDU_TX_STOP_FLUSH:
7136         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
7137         case IEEE80211_AMPDU_TX_OPERATIONAL:
7138                 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
7139                  * Tx aggregation requests.
7140                  */
7141                 ret = -EOPNOTSUPP;
7142                 break;
7143         }
7144
7145         mutex_unlock(&ar->conf_mutex);
7146
7147         return ret;
7148 }
7149
7150 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
7151                                      struct ieee80211_chanctx_conf *ctx)
7152 {
7153         struct ath11k *ar = hw->priv;
7154         struct ath11k_base *ab = ar->ab;
7155
7156         ath11k_dbg(ab, ATH11K_DBG_MAC,
7157                    "chanctx add freq %u width %d ptr %p\n",
7158                    ctx->def.chan->center_freq, ctx->def.width, ctx);
7159
7160         mutex_lock(&ar->conf_mutex);
7161
7162         spin_lock_bh(&ar->data_lock);
7163         /* TODO: In case of multiple channel context, populate rx_channel from
7164          * Rx PPDU desc information.
7165          */
7166         ar->rx_channel = ctx->def.chan;
7167         spin_unlock_bh(&ar->data_lock);
7168
7169         mutex_unlock(&ar->conf_mutex);
7170
7171         return 0;
7172 }
7173
7174 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
7175                                          struct ieee80211_chanctx_conf *ctx)
7176 {
7177         struct ath11k *ar = hw->priv;
7178         struct ath11k_base *ab = ar->ab;
7179
7180         ath11k_dbg(ab, ATH11K_DBG_MAC,
7181                    "chanctx remove freq %u width %d ptr %p\n",
7182                    ctx->def.chan->center_freq, ctx->def.width, ctx);
7183
7184         mutex_lock(&ar->conf_mutex);
7185
7186         spin_lock_bh(&ar->data_lock);
7187         /* TODO: In case of there is one more channel context left, populate
7188          * rx_channel with the channel of that remaining channel context.
7189          */
7190         ar->rx_channel = NULL;
7191         spin_unlock_bh(&ar->data_lock);
7192
7193         mutex_unlock(&ar->conf_mutex);
7194 }
7195
7196 static int
7197 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
7198                               struct ieee80211_chanctx_conf *ctx,
7199                               bool restart)
7200 {
7201         struct ath11k *ar = arvif->ar;
7202         struct ath11k_base *ab = ar->ab;
7203         struct wmi_vdev_start_req_arg arg = {};
7204         const struct cfg80211_chan_def *chandef = &ctx->def;
7205         int ret = 0;
7206         unsigned int dfs_cac_time;
7207
7208         lockdep_assert_held(&ar->conf_mutex);
7209
7210         reinit_completion(&ar->vdev_setup_done);
7211
7212         arg.vdev_id = arvif->vdev_id;
7213         arg.dtim_period = arvif->dtim_period;
7214         arg.bcn_intval = arvif->beacon_interval;
7215
7216         arg.channel.freq = chandef->chan->center_freq;
7217         arg.channel.band_center_freq1 = chandef->center_freq1;
7218         arg.channel.band_center_freq2 = chandef->center_freq2;
7219         arg.channel.mode =
7220                 ath11k_phymodes[chandef->chan->band][chandef->width];
7221
7222         arg.channel.min_power = 0;
7223         arg.channel.max_power = chandef->chan->max_power;
7224         arg.channel.max_reg_power = chandef->chan->max_reg_power;
7225         arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
7226
7227         arg.pref_tx_streams = ar->num_tx_chains;
7228         arg.pref_rx_streams = ar->num_rx_chains;
7229
7230         arg.mbssid_flags = 0;
7231         arg.mbssid_tx_vdev_id = 0;
7232         if (test_bit(WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT,
7233                      ar->ab->wmi_ab.svc_map)) {
7234                 ret = ath11k_mac_setup_vdev_params_mbssid(arvif,
7235                                                           &arg.mbssid_flags,
7236                                                           &arg.mbssid_tx_vdev_id);
7237                 if (ret)
7238                         return ret;
7239         }
7240
7241         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
7242                 arg.ssid = arvif->u.ap.ssid;
7243                 arg.ssid_len = arvif->u.ap.ssid_len;
7244                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
7245
7246                 /* For now allow DFS for AP mode */
7247                 arg.channel.chan_radar =
7248                         !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
7249
7250                 arg.channel.freq2_radar = ctx->radar_enabled;
7251
7252                 arg.channel.passive = arg.channel.chan_radar;
7253
7254                 spin_lock_bh(&ab->base_lock);
7255                 arg.regdomain = ar->ab->dfs_region;
7256                 spin_unlock_bh(&ab->base_lock);
7257         }
7258
7259         arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
7260
7261         ath11k_dbg(ab, ATH11K_DBG_MAC,
7262                    "vdev %d start center_freq %d phymode %s\n",
7263                    arg.vdev_id, arg.channel.freq,
7264                    ath11k_wmi_phymode_str(arg.channel.mode));
7265
7266         ret = ath11k_wmi_vdev_start(ar, &arg, restart);
7267         if (ret) {
7268                 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
7269                             restart ? "restart" : "start", arg.vdev_id);
7270                 return ret;
7271         }
7272
7273         ret = ath11k_mac_vdev_setup_sync(ar);
7274         if (ret) {
7275                 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
7276                             arg.vdev_id, restart ? "restart" : "start", ret);
7277                 return ret;
7278         }
7279
7280         if (!restart)
7281                 ar->num_started_vdevs++;
7282
7283         ath11k_dbg(ab, ATH11K_DBG_MAC,  "vdev %pM started, vdev_id %d\n",
7284                    arvif->vif->addr, arvif->vdev_id);
7285
7286         /* Enable CAC Flag in the driver by checking the all sub-channel's DFS
7287          * state as NL80211_DFS_USABLE which indicates CAC needs to be
7288          * done before channel usage. This flags is used to drop rx packets.
7289          * during CAC.
7290          */
7291         /* TODO Set the flag for other interface types as required */
7292         if (arvif->vdev_type == WMI_VDEV_TYPE_AP && ctx->radar_enabled &&
7293             cfg80211_chandef_dfs_usable(ar->hw->wiphy, chandef)) {
7294                 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
7295                 dfs_cac_time = cfg80211_chandef_dfs_cac_time(ar->hw->wiphy,
7296                                                              chandef);
7297                 ath11k_dbg(ab, ATH11K_DBG_MAC,
7298                            "cac started dfs_cac_time %u center_freq %d center_freq1 %d for vdev %d\n",
7299                            dfs_cac_time, arg.channel.freq, chandef->center_freq1,
7300                            arg.vdev_id);
7301         }
7302
7303         ret = ath11k_mac_set_txbf_conf(arvif);
7304         if (ret)
7305                 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
7306                             arvif->vdev_id, ret);
7307
7308         return 0;
7309 }
7310
7311 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
7312 {
7313         struct ath11k *ar = arvif->ar;
7314         int ret;
7315
7316         lockdep_assert_held(&ar->conf_mutex);
7317
7318         reinit_completion(&ar->vdev_setup_done);
7319
7320         ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
7321         if (ret) {
7322                 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
7323                             arvif->vdev_id, ret);
7324                 goto err;
7325         }
7326
7327         ret = ath11k_mac_vdev_setup_sync(ar);
7328         if (ret) {
7329                 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
7330                             arvif->vdev_id, ret);
7331                 goto err;
7332         }
7333
7334         WARN_ON(ar->num_started_vdevs == 0);
7335
7336         ar->num_started_vdevs--;
7337         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
7338                    arvif->vif->addr, arvif->vdev_id);
7339
7340         if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
7341                 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
7342                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
7343                            arvif->vdev_id);
7344         }
7345
7346         return 0;
7347 err:
7348         return ret;
7349 }
7350
7351 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
7352                                  struct ieee80211_chanctx_conf *ctx)
7353 {
7354         return ath11k_mac_vdev_start_restart(arvif, ctx, false);
7355 }
7356
7357 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
7358                                    struct ieee80211_chanctx_conf *ctx)
7359 {
7360         return ath11k_mac_vdev_start_restart(arvif, ctx, true);
7361 }
7362
7363 struct ath11k_mac_change_chanctx_arg {
7364         struct ieee80211_chanctx_conf *ctx;
7365         struct ieee80211_vif_chanctx_switch *vifs;
7366         int n_vifs;
7367         int next_vif;
7368 };
7369
7370 static void
7371 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
7372                                    struct ieee80211_vif *vif)
7373 {
7374         struct ath11k_mac_change_chanctx_arg *arg = data;
7375
7376         if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
7377                 return;
7378
7379         arg->n_vifs++;
7380 }
7381
7382 static void
7383 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
7384                                     struct ieee80211_vif *vif)
7385 {
7386         struct ath11k_mac_change_chanctx_arg *arg = data;
7387         struct ieee80211_chanctx_conf *ctx;
7388
7389         ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
7390         if (ctx != arg->ctx)
7391                 return;
7392
7393         if (WARN_ON(arg->next_vif == arg->n_vifs))
7394                 return;
7395
7396         arg->vifs[arg->next_vif].vif = vif;
7397         arg->vifs[arg->next_vif].old_ctx = ctx;
7398         arg->vifs[arg->next_vif].new_ctx = ctx;
7399         arg->next_vif++;
7400 }
7401
7402 static void
7403 ath11k_mac_update_vif_chan(struct ath11k *ar,
7404                            struct ieee80211_vif_chanctx_switch *vifs,
7405                            int n_vifs)
7406 {
7407         struct ath11k_base *ab = ar->ab;
7408         struct ath11k_vif *arvif, *tx_arvif = NULL;
7409         struct ieee80211_vif *mbssid_tx_vif;
7410         int ret;
7411         int i;
7412         bool monitor_vif = false;
7413
7414         lockdep_assert_held(&ar->conf_mutex);
7415
7416         /* Associated channel resources of all relevant vdevs
7417          * should be available for the channel switch now.
7418          */
7419
7420         /* TODO: Update ar->rx_channel */
7421
7422         for (i = 0; i < n_vifs; i++) {
7423                 arvif = ath11k_vif_to_arvif(vifs[i].vif);
7424
7425                 if (WARN_ON(!arvif->is_started))
7426                         continue;
7427
7428                 /* change_chanctx can be called even before vdev_up from
7429                  * ieee80211_start_ap->ieee80211_vif_use_channel->
7430                  * ieee80211_recalc_radar_chanctx.
7431                  *
7432                  * Firmware expect vdev_restart only if vdev is up.
7433                  * If vdev is down then it expect vdev_stop->vdev_start.
7434                  */
7435                 if (arvif->is_up) {
7436                         ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
7437                         if (ret) {
7438                                 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
7439                                             arvif->vdev_id, ret);
7440                                 continue;
7441                         }
7442                 } else {
7443                         ret = ath11k_mac_vdev_stop(arvif);
7444                         if (ret) {
7445                                 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
7446                                             arvif->vdev_id, ret);
7447                                 continue;
7448                         }
7449
7450                         ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
7451                         if (ret)
7452                                 ath11k_warn(ab, "failed to start vdev %d: %d\n",
7453                                             arvif->vdev_id, ret);
7454
7455                         continue;
7456                 }
7457
7458                 ret = ath11k_mac_setup_bcn_tmpl(arvif);
7459                 if (ret)
7460                         ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
7461                                     ret);
7462
7463                 mbssid_tx_vif = arvif->vif->mbssid_tx_vif;
7464                 if (mbssid_tx_vif)
7465                         tx_arvif = ath11k_vif_to_arvif(mbssid_tx_vif);
7466
7467                 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
7468                                          arvif->bssid,
7469                                          tx_arvif ? tx_arvif->bssid : NULL,
7470                                          arvif->vif->bss_conf.bssid_index,
7471                                          1 << arvif->vif->bss_conf.bssid_indicator);
7472                 if (ret) {
7473                         ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
7474                                     arvif->vdev_id, ret);
7475                         continue;
7476                 }
7477         }
7478
7479         /* Restart the internal monitor vdev on new channel */
7480         if (!monitor_vif &&
7481             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7482                 ret = ath11k_mac_monitor_stop(ar);
7483                 if (ret) {
7484                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
7485                                     ret);
7486                         return;
7487                 }
7488
7489                 ret = ath11k_mac_monitor_start(ar);
7490                 if (ret) {
7491                         ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
7492                                     ret);
7493                         return;
7494                 }
7495         }
7496 }
7497
7498 static void
7499 ath11k_mac_update_active_vif_chan(struct ath11k *ar,
7500                                   struct ieee80211_chanctx_conf *ctx)
7501 {
7502         struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
7503
7504         lockdep_assert_held(&ar->conf_mutex);
7505
7506         ieee80211_iterate_active_interfaces_atomic(ar->hw,
7507                                                    IEEE80211_IFACE_ITER_NORMAL,
7508                                                    ath11k_mac_change_chanctx_cnt_iter,
7509                                                    &arg);
7510         if (arg.n_vifs == 0)
7511                 return;
7512
7513         arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
7514         if (!arg.vifs)
7515                 return;
7516
7517         ieee80211_iterate_active_interfaces_atomic(ar->hw,
7518                                                    IEEE80211_IFACE_ITER_NORMAL,
7519                                                    ath11k_mac_change_chanctx_fill_iter,
7520                                                    &arg);
7521
7522         ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
7523
7524         kfree(arg.vifs);
7525 }
7526
7527 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
7528                                          struct ieee80211_chanctx_conf *ctx,
7529                                          u32 changed)
7530 {
7531         struct ath11k *ar = hw->priv;
7532         struct ath11k_base *ab = ar->ab;
7533
7534         mutex_lock(&ar->conf_mutex);
7535
7536         ath11k_dbg(ab, ATH11K_DBG_MAC,
7537                    "chanctx change freq %u width %d ptr %p changed %x\n",
7538                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
7539
7540         /* This shouldn't really happen because channel switching should use
7541          * switch_vif_chanctx().
7542          */
7543         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
7544                 goto unlock;
7545
7546         if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
7547             changed & IEEE80211_CHANCTX_CHANGE_RADAR)
7548                 ath11k_mac_update_active_vif_chan(ar, ctx);
7549
7550         /* TODO: Recalc radar detection */
7551
7552 unlock:
7553         mutex_unlock(&ar->conf_mutex);
7554 }
7555
7556 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
7557                                    struct ieee80211_vif *vif)
7558 {
7559         struct ath11k *ar = hw->priv;
7560         struct ath11k_base *ab = ar->ab;
7561         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7562         int ret;
7563
7564         if (WARN_ON(arvif->is_started))
7565                 return -EBUSY;
7566
7567         ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
7568         if (ret) {
7569                 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7570                             arvif->vdev_id, vif->addr,
7571                             arvif->chanctx.def.chan->center_freq, ret);
7572                 return ret;
7573         }
7574
7575         /* Reconfigure hardware rate code since it is cleared by firmware.
7576          */
7577         if (ar->hw_rate_code > 0) {
7578                 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
7579
7580                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
7581                                                     ar->hw_rate_code);
7582                 if (ret) {
7583                         ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
7584                         return ret;
7585                 }
7586         }
7587
7588         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7589                 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr,
7590                                          NULL, 0, 0);
7591                 if (ret) {
7592                         ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7593                         return ret;
7594                 }
7595         }
7596
7597         arvif->is_started = true;
7598
7599         /* TODO: Setup ps and cts/rts protection */
7600         return 0;
7601 }
7602
7603 static int
7604 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7605                                  struct ieee80211_vif *vif,
7606                                  struct ieee80211_bss_conf *link_conf,
7607                                  struct ieee80211_chanctx_conf *ctx)
7608 {
7609         struct ath11k *ar = hw->priv;
7610         struct ath11k_base *ab = ar->ab;
7611         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7612         int ret;
7613         struct peer_create_params param;
7614
7615         mutex_lock(&ar->conf_mutex);
7616
7617         ath11k_dbg(ab, ATH11K_DBG_MAC,
7618                    "chanctx assign ptr %p vdev_id %i\n",
7619                    ctx, arvif->vdev_id);
7620
7621         /* for QCA6390 bss peer must be created before vdev_start */
7622         if (ab->hw_params.vdev_start_delay &&
7623             arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7624             arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7625             !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
7626                 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
7627                 ret = 0;
7628                 goto out;
7629         }
7630
7631         if (WARN_ON(arvif->is_started)) {
7632                 ret = -EBUSY;
7633                 goto out;
7634         }
7635
7636         if (ab->hw_params.vdev_start_delay &&
7637             arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7638             arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
7639                 param.vdev_id = arvif->vdev_id;
7640                 param.peer_type = WMI_PEER_TYPE_DEFAULT;
7641                 param.peer_addr = ar->mac_addr;
7642
7643                 ret = ath11k_peer_create(ar, arvif, NULL, &param);
7644                 if (ret) {
7645                         ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7646                                     ret);
7647                         goto out;
7648                 }
7649         }
7650
7651         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7652                 ret = ath11k_mac_monitor_start(ar);
7653                 if (ret) {
7654                         ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7655                                     ret);
7656                         goto out;
7657                 }
7658
7659                 arvif->is_started = true;
7660                 goto out;
7661         }
7662
7663         ret = ath11k_mac_vdev_start(arvif, ctx);
7664         if (ret) {
7665                 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7666                             arvif->vdev_id, vif->addr,
7667                             ctx->def.chan->center_freq, ret);
7668                 goto out;
7669         }
7670
7671         arvif->is_started = true;
7672
7673         if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7674             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7675                 ret = ath11k_mac_monitor_start(ar);
7676                 if (ret) {
7677                         ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7678                                     ret);
7679                         goto out;
7680                 }
7681         }
7682
7683         /* TODO: Setup ps and cts/rts protection */
7684
7685         ret = 0;
7686
7687 out:
7688         mutex_unlock(&ar->conf_mutex);
7689
7690         return ret;
7691 }
7692
7693 static void
7694 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7695                                    struct ieee80211_vif *vif,
7696                                    struct ieee80211_bss_conf *link_conf,
7697                                    struct ieee80211_chanctx_conf *ctx)
7698 {
7699         struct ath11k *ar = hw->priv;
7700         struct ath11k_base *ab = ar->ab;
7701         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
7702         struct ath11k_peer *peer;
7703         int ret;
7704
7705         mutex_lock(&ar->conf_mutex);
7706
7707         ath11k_dbg(ab, ATH11K_DBG_MAC,
7708                    "chanctx unassign ptr %p vdev_id %i\n",
7709                    ctx, arvif->vdev_id);
7710
7711         WARN_ON(!arvif->is_started);
7712
7713         if (ab->hw_params.vdev_start_delay &&
7714             arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7715                 spin_lock_bh(&ab->base_lock);
7716                 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7717                 spin_unlock_bh(&ab->base_lock);
7718                 if (peer)
7719                         ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7720         }
7721
7722         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7723                 ret = ath11k_mac_monitor_stop(ar);
7724                 if (ret) {
7725                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7726                                     ret);
7727                         mutex_unlock(&ar->conf_mutex);
7728                         return;
7729                 }
7730
7731                 arvif->is_started = false;
7732                 mutex_unlock(&ar->conf_mutex);
7733                 return;
7734         }
7735
7736         ret = ath11k_mac_vdev_stop(arvif);
7737         if (ret)
7738                 ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7739                             arvif->vdev_id, ret);
7740
7741         arvif->is_started = false;
7742
7743         if (ab->hw_params.vdev_start_delay &&
7744             arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7745                 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7746                 if (ret)
7747                         ath11k_warn(ar->ab,
7748                                     "failed to delete peer %pM for vdev %d: %d\n",
7749                                     arvif->bssid, arvif->vdev_id, ret);
7750                 else
7751                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7752                                    "removed peer %pM  vdev %d after vdev stop\n",
7753                                    arvif->bssid, arvif->vdev_id);
7754         }
7755
7756         if (ab->hw_params.vdev_start_delay &&
7757             arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7758                 ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7759
7760         if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7761             ar->num_started_vdevs == 1 &&
7762             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7763                 ret = ath11k_mac_monitor_stop(ar);
7764                 if (ret)
7765                         /* continue even if there's an error */
7766                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7767                                     ret);
7768         }
7769
7770         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7771                 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
7772
7773         mutex_unlock(&ar->conf_mutex);
7774 }
7775
7776 static int
7777 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7778                                  struct ieee80211_vif_chanctx_switch *vifs,
7779                                  int n_vifs,
7780                                  enum ieee80211_chanctx_switch_mode mode)
7781 {
7782         struct ath11k *ar = hw->priv;
7783
7784         mutex_lock(&ar->conf_mutex);
7785
7786         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7787                    "chanctx switch n_vifs %d mode %d\n",
7788                    n_vifs, mode);
7789         ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7790
7791         mutex_unlock(&ar->conf_mutex);
7792
7793         return 0;
7794 }
7795
7796 static int
7797 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7798 {
7799         struct ath11k_vif *arvif;
7800         int ret = 0;
7801
7802         mutex_lock(&ar->conf_mutex);
7803         list_for_each_entry(arvif, &ar->arvifs, list) {
7804                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7805                            param, arvif->vdev_id, value);
7806
7807                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7808                                                     param, value);
7809                 if (ret) {
7810                         ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7811                                     param, arvif->vdev_id, ret);
7812                         break;
7813                 }
7814         }
7815         mutex_unlock(&ar->conf_mutex);
7816         return ret;
7817 }
7818
7819 /* mac80211 stores device specific RTS/Fragmentation threshold value,
7820  * this is set interface specific to firmware from ath11k driver
7821  */
7822 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7823 {
7824         struct ath11k *ar = hw->priv;
7825         int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7826
7827         return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7828 }
7829
7830 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7831 {
7832         /* Even though there's a WMI vdev param for fragmentation threshold no
7833          * known firmware actually implements it. Moreover it is not possible to
7834          * rely frame fragmentation to mac80211 because firmware clears the
7835          * "more fragments" bit in frame control making it impossible for remote
7836          * devices to reassemble frames.
7837          *
7838          * Hence implement a dummy callback just to say fragmentation isn't
7839          * supported. This effectively prevents mac80211 from doing frame
7840          * fragmentation in software.
7841          */
7842         return -EOPNOTSUPP;
7843 }
7844
7845 static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
7846 {
7847         long time_left;
7848         int ret = 0;
7849
7850         time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7851                                        (atomic_read(&ar->dp.num_tx_pending) == 0),
7852                                        ATH11K_FLUSH_TIMEOUT);
7853         if (time_left == 0) {
7854                 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7855                             atomic_read(&ar->dp.num_tx_pending));
7856                 ret = -ETIMEDOUT;
7857         }
7858
7859         time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7860                                        (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7861                                        ATH11K_FLUSH_TIMEOUT);
7862         if (time_left == 0) {
7863                 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7864                             atomic_read(&ar->num_pending_mgmt_tx));
7865                 ret = -ETIMEDOUT;
7866         }
7867
7868         return ret;
7869 }
7870
7871 int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7872 {
7873         ath11k_mac_drain_tx(ar);
7874         return ath11k_mac_flush_tx_complete(ar);
7875 }
7876
7877 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7878                                 u32 queues, bool drop)
7879 {
7880         struct ath11k *ar = hw->priv;
7881
7882         if (drop)
7883                 return;
7884
7885         ath11k_mac_flush_tx_complete(ar);
7886 }
7887
7888 static bool
7889 ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7890                                   enum nl80211_band band,
7891                                   const struct cfg80211_bitrate_mask *mask)
7892 {
7893         int num_rates = 0;
7894
7895         num_rates = hweight32(mask->control[band].legacy);
7896
7897         if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7898                 return false;
7899
7900         if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7901                 return false;
7902
7903         if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7904                 return false;
7905
7906         return num_rates == 1;
7907 }
7908
7909 static __le16
7910 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7911 {
7912         if (he_cap->he_cap_elem.phy_cap_info[0] &
7913             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7914                 return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7915
7916         if (he_cap->he_cap_elem.phy_cap_info[0] &
7917             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7918                 return he_cap->he_mcs_nss_supp.tx_mcs_160;
7919
7920         return he_cap->he_mcs_nss_supp.tx_mcs_80;
7921 }
7922
7923 static bool
7924 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7925                                        struct ath11k_vif *arvif,
7926                                        enum nl80211_band band,
7927                                        const struct cfg80211_bitrate_mask *mask,
7928                                        int *nss)
7929 {
7930         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7931         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7932         const struct ieee80211_sta_he_cap *he_cap;
7933         u16 he_mcs_map = 0;
7934         u8 ht_nss_mask = 0;
7935         u8 vht_nss_mask = 0;
7936         u8 he_nss_mask = 0;
7937         int i;
7938
7939         /* No need to consider legacy here. Basic rates are always present
7940          * in bitrate mask
7941          */
7942
7943         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7944                 if (mask->control[band].ht_mcs[i] == 0)
7945                         continue;
7946                 else if (mask->control[band].ht_mcs[i] ==
7947                          sband->ht_cap.mcs.rx_mask[i])
7948                         ht_nss_mask |= BIT(i);
7949                 else
7950                         return false;
7951         }
7952
7953         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7954                 if (mask->control[band].vht_mcs[i] == 0)
7955                         continue;
7956                 else if (mask->control[band].vht_mcs[i] ==
7957                          ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7958                         vht_nss_mask |= BIT(i);
7959                 else
7960                         return false;
7961         }
7962
7963         he_cap = ieee80211_get_he_iftype_cap_vif(sband, arvif->vif);
7964         if (!he_cap)
7965                 return false;
7966
7967         he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(he_cap));
7968
7969         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7970                 if (mask->control[band].he_mcs[i] == 0)
7971                         continue;
7972
7973                 if (mask->control[band].he_mcs[i] ==
7974                     ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7975                         he_nss_mask |= BIT(i);
7976                 else
7977                         return false;
7978         }
7979
7980         if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
7981                 return false;
7982
7983         if (ht_nss_mask == 0)
7984                 return false;
7985
7986         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7987                 return false;
7988
7989         *nss = fls(ht_nss_mask);
7990
7991         return true;
7992 }
7993
7994 static int
7995 ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7996                                   enum nl80211_band band,
7997                                   const struct cfg80211_bitrate_mask *mask,
7998                                   u32 *rate, u8 *nss)
7999 {
8000         int rate_idx;
8001         u16 bitrate;
8002         u8 preamble;
8003         u8 hw_rate;
8004
8005         if (hweight32(mask->control[band].legacy) != 1)
8006                 return -EINVAL;
8007
8008         rate_idx = ffs(mask->control[band].legacy) - 1;
8009
8010         if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
8011                 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
8012
8013         hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
8014         bitrate = ath11k_legacy_rates[rate_idx].bitrate;
8015
8016         if (ath11k_mac_bitrate_is_cck(bitrate))
8017                 preamble = WMI_RATE_PREAMBLE_CCK;
8018         else
8019                 preamble = WMI_RATE_PREAMBLE_OFDM;
8020
8021         *nss = 1;
8022         *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
8023
8024         return 0;
8025 }
8026
8027 static int
8028 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
8029 {
8030         struct ath11k *ar = arvif->ar;
8031         int ret;
8032
8033         /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
8034         if (he_gi && he_gi != 0xFF)
8035                 he_gi += 1;
8036
8037         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8038                                             WMI_VDEV_PARAM_SGI, he_gi);
8039         if (ret) {
8040                 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
8041                             he_gi, ret);
8042                 return ret;
8043         }
8044         /* start from 1 */
8045         if (he_ltf != 0xFF)
8046                 he_ltf += 1;
8047
8048         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8049                                             WMI_VDEV_PARAM_HE_LTF, he_ltf);
8050         if (ret) {
8051                 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
8052                             he_ltf, ret);
8053                 return ret;
8054         }
8055
8056         return 0;
8057 }
8058
8059 static int
8060 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
8061 {
8062         struct ath11k *ar = arvif->ar;
8063         int ret;
8064         u32 he_ar_gi_ltf;
8065
8066         if (he_gi != 0xFF) {
8067                 switch (he_gi) {
8068                 case NL80211_RATE_INFO_HE_GI_0_8:
8069                         he_gi = WMI_AUTORATE_800NS_GI;
8070                         break;
8071                 case NL80211_RATE_INFO_HE_GI_1_6:
8072                         he_gi = WMI_AUTORATE_1600NS_GI;
8073                         break;
8074                 case NL80211_RATE_INFO_HE_GI_3_2:
8075                         he_gi = WMI_AUTORATE_3200NS_GI;
8076                         break;
8077                 default:
8078                         ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
8079                         return -EINVAL;
8080                 }
8081         }
8082
8083         if (he_ltf != 0xFF) {
8084                 switch (he_ltf) {
8085                 case NL80211_RATE_INFO_HE_1XLTF:
8086                         he_ltf = WMI_HE_AUTORATE_LTF_1X;
8087                         break;
8088                 case NL80211_RATE_INFO_HE_2XLTF:
8089                         he_ltf = WMI_HE_AUTORATE_LTF_2X;
8090                         break;
8091                 case NL80211_RATE_INFO_HE_4XLTF:
8092                         he_ltf = WMI_HE_AUTORATE_LTF_4X;
8093                         break;
8094                 default:
8095                         ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
8096                         return -EINVAL;
8097                 }
8098         }
8099
8100         he_ar_gi_ltf = he_gi | he_ltf;
8101         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8102                                             WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
8103                                             he_ar_gi_ltf);
8104         if (ret) {
8105                 ath11k_warn(ar->ab,
8106                             "failed to set he autorate gi %u ltf %u: %d\n",
8107                             he_gi, he_ltf, ret);
8108                 return ret;
8109         }
8110
8111         return 0;
8112 }
8113
8114 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
8115                                       u32 rate, u8 nss, u8 sgi, u8 ldpc,
8116                                       u8 he_gi, u8 he_ltf, bool he_fixed_rate)
8117 {
8118         struct ath11k *ar = arvif->ar;
8119         u32 vdev_param;
8120         int ret;
8121
8122         lockdep_assert_held(&ar->conf_mutex);
8123
8124         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8125                    "set rate params vdev %i rate 0x%02x nss 0x%02x sgi 0x%02x ldpc 0x%02x he_gi 0x%02x he_ltf 0x%02x he_fixed_rate %d\n",
8126                    arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
8127                    he_ltf, he_fixed_rate);
8128
8129         if (!arvif->vif->bss_conf.he_support) {
8130                 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
8131                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8132                                                     vdev_param, rate);
8133                 if (ret) {
8134                         ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
8135                                     rate, ret);
8136                         return ret;
8137                 }
8138         }
8139
8140         vdev_param = WMI_VDEV_PARAM_NSS;
8141         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8142                                             vdev_param, nss);
8143         if (ret) {
8144                 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
8145                             nss, ret);
8146                 return ret;
8147         }
8148
8149         vdev_param = WMI_VDEV_PARAM_LDPC;
8150         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8151                                             vdev_param, ldpc);
8152         if (ret) {
8153                 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
8154                             ldpc, ret);
8155                 return ret;
8156         }
8157
8158         if (arvif->vif->bss_conf.he_support) {
8159                 if (he_fixed_rate) {
8160                         ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
8161                                                                he_ltf);
8162                         if (ret) {
8163                                 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
8164                                             ret);
8165                                 return ret;
8166                         }
8167                 } else {
8168                         ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
8169                                                               he_ltf);
8170                         if (ret) {
8171                                 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
8172                                             ret);
8173                                 return ret;
8174                         }
8175                 }
8176         } else {
8177                 vdev_param = WMI_VDEV_PARAM_SGI;
8178                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
8179                                                     vdev_param, sgi);
8180                 if (ret) {
8181                         ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
8182                                     sgi, ret);
8183                         return ret;
8184                 }
8185         }
8186
8187         return 0;
8188 }
8189
8190 static bool
8191 ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
8192                                  enum nl80211_band band,
8193                                  const struct cfg80211_bitrate_mask *mask)
8194 {
8195         int i;
8196         u16 vht_mcs;
8197
8198         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8199                 vht_mcs = mask->control[band].vht_mcs[i];
8200
8201                 switch (vht_mcs) {
8202                 case 0:
8203                 case BIT(8) - 1:
8204                 case BIT(9) - 1:
8205                 case BIT(10) - 1:
8206                         break;
8207                 default:
8208                         return false;
8209                 }
8210         }
8211
8212         return true;
8213 }
8214
8215 static bool
8216 ath11k_mac_he_mcs_range_present(struct ath11k *ar,
8217                                 enum nl80211_band band,
8218                                 const struct cfg80211_bitrate_mask *mask)
8219 {
8220         int i;
8221         u16 he_mcs;
8222
8223         for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
8224                 he_mcs = mask->control[band].he_mcs[i];
8225
8226                 switch (he_mcs) {
8227                 case 0:
8228                 case BIT(8) - 1:
8229                 case BIT(10) - 1:
8230                 case BIT(12) - 1:
8231                         break;
8232                 default:
8233                         return false;
8234                 }
8235         }
8236
8237         return true;
8238 }
8239
8240 static void ath11k_mac_set_bitrate_mask_iter(void *data,
8241                                              struct ieee80211_sta *sta)
8242 {
8243         struct ath11k_vif *arvif = data;
8244         struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
8245         struct ath11k *ar = arvif->ar;
8246
8247         spin_lock_bh(&ar->data_lock);
8248         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
8249         spin_unlock_bh(&ar->data_lock);
8250
8251         ieee80211_queue_work(ar->hw, &arsta->update_wk);
8252 }
8253
8254 static void ath11k_mac_disable_peer_fixed_rate(void *data,
8255                                                struct ieee80211_sta *sta)
8256 {
8257         struct ath11k_vif *arvif = data;
8258         struct ath11k *ar = arvif->ar;
8259         int ret;
8260
8261         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
8262                                         arvif->vdev_id,
8263                                         WMI_PEER_PARAM_FIXED_RATE,
8264                                         WMI_FIXED_RATE_NONE);
8265         if (ret)
8266                 ath11k_warn(ar->ab,
8267                             "failed to disable peer fixed rate for STA %pM ret %d\n",
8268                             sta->addr, ret);
8269 }
8270
8271 static bool
8272 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
8273                                                const struct cfg80211_bitrate_mask *mask)
8274 {
8275         bool he_fixed_rate = false, vht_fixed_rate = false;
8276         struct ath11k_peer *peer;
8277         const u16 *vht_mcs_mask, *he_mcs_mask;
8278         struct ieee80211_link_sta *deflink;
8279         u8 vht_nss, he_nss;
8280         bool ret = true;
8281
8282         vht_mcs_mask = mask->control[band].vht_mcs;
8283         he_mcs_mask = mask->control[band].he_mcs;
8284
8285         if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
8286                 vht_fixed_rate = true;
8287
8288         if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
8289                 he_fixed_rate = true;
8290
8291         if (!vht_fixed_rate && !he_fixed_rate)
8292                 return true;
8293
8294         vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
8295         he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
8296
8297         rcu_read_lock();
8298         spin_lock_bh(&ar->ab->base_lock);
8299         list_for_each_entry(peer, &ar->ab->peers, list) {
8300                 if (peer->sta) {
8301                         deflink = &peer->sta->deflink;
8302
8303                         if (vht_fixed_rate && (!deflink->vht_cap.vht_supported ||
8304                                                deflink->rx_nss < vht_nss)) {
8305                                 ret = false;
8306                                 goto out;
8307                         }
8308
8309                         if (he_fixed_rate && (!deflink->he_cap.has_he ||
8310                                               deflink->rx_nss < he_nss)) {
8311                                 ret = false;
8312                                 goto out;
8313                         }
8314                 }
8315         }
8316
8317 out:
8318         spin_unlock_bh(&ar->ab->base_lock);
8319         rcu_read_unlock();
8320         return ret;
8321 }
8322
8323 static int
8324 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
8325                                struct ieee80211_vif *vif,
8326                                const struct cfg80211_bitrate_mask *mask)
8327 {
8328         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8329         struct cfg80211_chan_def def;
8330         struct ath11k_pdev_cap *cap;
8331         struct ath11k *ar = arvif->ar;
8332         enum nl80211_band band;
8333         const u8 *ht_mcs_mask;
8334         const u16 *vht_mcs_mask;
8335         const u16 *he_mcs_mask;
8336         u8 he_ltf = 0;
8337         u8 he_gi = 0;
8338         u32 rate;
8339         u8 nss;
8340         u8 sgi;
8341         u8 ldpc;
8342         int single_nss;
8343         int ret;
8344         int num_rates;
8345         bool he_fixed_rate = false;
8346
8347         if (ath11k_mac_vif_chan(vif, &def))
8348                 return -EPERM;
8349
8350         band = def.chan->band;
8351         cap = &ar->pdev->cap;
8352         ht_mcs_mask = mask->control[band].ht_mcs;
8353         vht_mcs_mask = mask->control[band].vht_mcs;
8354         he_mcs_mask = mask->control[band].he_mcs;
8355         ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC);
8356
8357         sgi = mask->control[band].gi;
8358         if (sgi == NL80211_TXRATE_FORCE_LGI)
8359                 return -EINVAL;
8360
8361         he_gi = mask->control[band].he_gi;
8362         he_ltf = mask->control[band].he_ltf;
8363
8364         /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
8365          * requires passing at least one of used basic rates along with them.
8366          * Fixed rate setting across different preambles(legacy, HT, VHT) is
8367          * not supported by the FW. Hence use of FIXED_RATE vdev param is not
8368          * suitable for setting single HT/VHT rates.
8369          * But, there could be a single basic rate passed from userspace which
8370          * can be done through the FIXED_RATE param.
8371          */
8372         if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
8373                 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
8374                                                         &nss);
8375                 if (ret) {
8376                         ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
8377                                     arvif->vdev_id, ret);
8378                         return ret;
8379                 }
8380                 ieee80211_iterate_stations_atomic(ar->hw,
8381                                                   ath11k_mac_disable_peer_fixed_rate,
8382                                                   arvif);
8383         } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, arvif, band, mask,
8384                                                           &single_nss)) {
8385                 rate = WMI_FIXED_RATE_NONE;
8386                 nss = single_nss;
8387                 mutex_lock(&ar->conf_mutex);
8388                 arvif->bitrate_mask = *mask;
8389                 ieee80211_iterate_stations_atomic(ar->hw,
8390                                                   ath11k_mac_set_bitrate_mask_iter,
8391                                                   arvif);
8392                 mutex_unlock(&ar->conf_mutex);
8393         } else {
8394                 rate = WMI_FIXED_RATE_NONE;
8395
8396                 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
8397                         ath11k_warn(ar->ab,
8398                                     "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
8399                 nss = min_t(u32, ar->num_tx_chains,
8400                             ath11k_mac_max_nss(ht_mcs_mask, vht_mcs_mask, he_mcs_mask));
8401
8402                 /* If multiple rates across different preambles are given
8403                  * we can reconfigure this info with all peers using PEER_ASSOC
8404                  * command with the below exception cases.
8405                  * - Single VHT Rate : peer_assoc command accommodates only MCS
8406                  * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
8407                  * mandates passing basic rates along with HT/VHT rates, FW
8408                  * doesn't allow switching from VHT to Legacy. Hence instead of
8409                  * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
8410                  * we could set this VHT rate as peer fixed rate param, which
8411                  * will override FIXED rate and FW rate control algorithm.
8412                  * If single VHT rate is passed along with HT rates, we select
8413                  * the VHT rate as fixed rate for vht peers.
8414                  * - Multiple VHT Rates : When Multiple VHT rates are given,this
8415                  * can be set using RATEMASK CMD which uses FW rate-ctl alg.
8416                  * TODO: Setting multiple VHT MCS and replacing peer_assoc with
8417                  * RATEMASK_CMDID can cover all use cases of setting rates
8418                  * across multiple preambles and rates within same type.
8419                  * But requires more validation of the command at this point.
8420                  */
8421
8422                 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
8423                                                                   mask);
8424
8425                 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
8426                     num_rates > 1) {
8427                         /* TODO: Handle multiple VHT MCS values setting using
8428                          * RATEMASK CMD
8429                          */
8430                         ath11k_warn(ar->ab,
8431                                     "setting %d mcs values in bitrate mask not supported\n",
8432                                 num_rates);
8433                         return -EINVAL;
8434                 }
8435
8436                 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
8437                                                                  mask);
8438                 if (num_rates == 1)
8439                         he_fixed_rate = true;
8440
8441                 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
8442                     num_rates > 1) {
8443                         ath11k_warn(ar->ab,
8444                                     "Setting more than one HE MCS Value in bitrate mask not supported\n");
8445                         return -EINVAL;
8446                 }
8447
8448                 mutex_lock(&ar->conf_mutex);
8449                 ieee80211_iterate_stations_atomic(ar->hw,
8450                                                   ath11k_mac_disable_peer_fixed_rate,
8451                                                   arvif);
8452
8453                 arvif->bitrate_mask = *mask;
8454                 ieee80211_iterate_stations_atomic(ar->hw,
8455                                                   ath11k_mac_set_bitrate_mask_iter,
8456                                                   arvif);
8457
8458                 mutex_unlock(&ar->conf_mutex);
8459         }
8460
8461         mutex_lock(&ar->conf_mutex);
8462
8463         ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
8464                                          he_ltf, he_fixed_rate);
8465         if (ret) {
8466                 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
8467                             arvif->vdev_id, ret);
8468         }
8469
8470         mutex_unlock(&ar->conf_mutex);
8471
8472         return ret;
8473 }
8474
8475 static void
8476 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
8477                                 enum ieee80211_reconfig_type reconfig_type)
8478 {
8479         struct ath11k *ar = hw->priv;
8480         struct ath11k_base *ab = ar->ab;
8481         int recovery_count;
8482         struct ath11k_vif *arvif;
8483
8484         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
8485                 return;
8486
8487         mutex_lock(&ar->conf_mutex);
8488
8489         if (ar->state == ATH11K_STATE_RESTARTED) {
8490                 ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
8491                             ar->pdev->pdev_id);
8492                 ar->state = ATH11K_STATE_ON;
8493                 ieee80211_wake_queues(ar->hw);
8494
8495                 if (ar->ab->hw_params.current_cc_support &&
8496                     ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
8497                         struct wmi_set_current_country_params set_current_param = {};
8498
8499                         memcpy(&set_current_param.alpha2, ar->alpha2, 2);
8500                         ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
8501                 }
8502
8503                 if (ab->is_reset) {
8504                         recovery_count = atomic_inc_return(&ab->recovery_count);
8505                         ath11k_dbg(ab, ATH11K_DBG_BOOT,
8506                                    "recovery count %d\n", recovery_count);
8507                         /* When there are multiple radios in an SOC,
8508                          * the recovery has to be done for each radio
8509                          */
8510                         if (recovery_count == ab->num_radios) {
8511                                 atomic_dec(&ab->reset_count);
8512                                 complete(&ab->reset_complete);
8513                                 ab->is_reset = false;
8514                                 atomic_set(&ab->fail_cont_count, 0);
8515                                 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
8516                         }
8517                 }
8518                 if (ar->ab->hw_params.support_fw_mac_sequence) {
8519                         list_for_each_entry(arvif, &ar->arvifs, list) {
8520                                 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)
8521                                         ieee80211_hw_restart_disconnect(arvif->vif);
8522                         }
8523                 }
8524         }
8525
8526         mutex_unlock(&ar->conf_mutex);
8527 }
8528
8529 static void
8530 ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
8531                                   struct ieee80211_channel *channel)
8532 {
8533         int ret;
8534         enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
8535
8536         lockdep_assert_held(&ar->conf_mutex);
8537
8538         if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
8539             ar->rx_channel != channel)
8540                 return;
8541
8542         if (ar->scan.state != ATH11K_SCAN_IDLE) {
8543                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8544                            "ignoring bss chan info req while scanning..\n");
8545                 return;
8546         }
8547
8548         reinit_completion(&ar->bss_survey_done);
8549
8550         ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
8551         if (ret) {
8552                 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
8553                 return;
8554         }
8555
8556         ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8557         if (ret == 0)
8558                 ath11k_warn(ar->ab, "bss channel survey timed out\n");
8559 }
8560
8561 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
8562                                     struct survey_info *survey)
8563 {
8564         struct ath11k *ar = hw->priv;
8565         struct ieee80211_supported_band *sband;
8566         struct survey_info *ar_survey;
8567         int ret = 0;
8568
8569         if (idx >= ATH11K_NUM_CHANS)
8570                 return -ENOENT;
8571
8572         ar_survey = &ar->survey[idx];
8573
8574         mutex_lock(&ar->conf_mutex);
8575
8576         sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8577         if (sband && idx >= sband->n_channels) {
8578                 idx -= sband->n_channels;
8579                 sband = NULL;
8580         }
8581
8582         if (!sband)
8583                 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8584         if (sband && idx >= sband->n_channels) {
8585                 idx -= sband->n_channels;
8586                 sband = NULL;
8587         }
8588
8589         if (!sband)
8590                 sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
8591         if (!sband || idx >= sband->n_channels) {
8592                 ret = -ENOENT;
8593                 goto exit;
8594         }
8595
8596         ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8597
8598         spin_lock_bh(&ar->data_lock);
8599         memcpy(survey, ar_survey, sizeof(*survey));
8600         spin_unlock_bh(&ar->data_lock);
8601
8602         survey->channel = &sband->channels[idx];
8603
8604         if (ar->rx_channel == survey->channel)
8605                 survey->filled |= SURVEY_INFO_IN_USE;
8606
8607 exit:
8608         mutex_unlock(&ar->conf_mutex);
8609         return ret;
8610 }
8611
8612 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8613                                       struct ath11k_sta *arsta,
8614                                       char *pre,
8615                                       bool clear)
8616 {
8617         struct ath11k *ar = arsta->arvif->ar;
8618         int i;
8619         s8 rssi;
8620
8621         for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8622                 sinfo->chains &= ~BIT(i);
8623                 rssi = arsta->chain_signal[i];
8624                 if (clear)
8625                         arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8626
8627                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8628                            "sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8629
8630                 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8631                     rssi != ATH11K_INVALID_RSSI_FULL &&
8632                     rssi != ATH11K_INVALID_RSSI_EMPTY &&
8633                     rssi != 0) {
8634                         sinfo->chain_signal[i] = rssi;
8635                         sinfo->chains |= BIT(i);
8636                         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8637                 }
8638         }
8639 }
8640
8641 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8642                                          struct ieee80211_vif *vif,
8643                                          struct ieee80211_sta *sta,
8644                                          struct station_info *sinfo)
8645 {
8646         struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
8647         struct ath11k *ar = arsta->arvif->ar;
8648         s8 signal;
8649         bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8650                                ar->ab->wmi_ab.svc_map);
8651
8652         sinfo->rx_duration = arsta->rx_duration;
8653         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8654
8655         sinfo->tx_duration = arsta->tx_duration;
8656         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8657
8658         if (arsta->txrate.legacy || arsta->txrate.nss) {
8659                 if (arsta->txrate.legacy) {
8660                         sinfo->txrate.legacy = arsta->txrate.legacy;
8661                 } else {
8662                         sinfo->txrate.mcs = arsta->txrate.mcs;
8663                         sinfo->txrate.nss = arsta->txrate.nss;
8664                         sinfo->txrate.bw = arsta->txrate.bw;
8665                         sinfo->txrate.he_gi = arsta->txrate.he_gi;
8666                         sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8667                         sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8668                 }
8669                 sinfo->txrate.flags = arsta->txrate.flags;
8670                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8671         }
8672
8673         ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8674
8675         if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8676             arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8677             ar->ab->hw_params.supports_rssi_stats &&
8678             !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8679                                          WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8680                 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8681         }
8682
8683         signal = arsta->rssi_comb;
8684         if (!signal &&
8685             arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8686             ar->ab->hw_params.supports_rssi_stats &&
8687             !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8688                                         WMI_REQUEST_VDEV_STAT)))
8689                 signal = arsta->rssi_beacon;
8690
8691         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8692                    "sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8693                    db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8694
8695         if (signal) {
8696                 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8697                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8698         }
8699
8700         sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) +
8701                 ATH11K_DEFAULT_NOISE_FLOOR;
8702         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
8703 }
8704
8705 #if IS_ENABLED(CONFIG_IPV6)
8706 static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8707                                        struct ath11k_arp_ns_offload *offload)
8708 {
8709         int i;
8710
8711         for (i = 0; i < offload->ipv6_count; i++) {
8712                 offload->self_ipv6_addr[i][0] = 0xff;
8713                 offload->self_ipv6_addr[i][1] = 0x02;
8714                 offload->self_ipv6_addr[i][11] = 0x01;
8715                 offload->self_ipv6_addr[i][12] = 0xff;
8716                 offload->self_ipv6_addr[i][13] =
8717                                         offload->ipv6_addr[i][13];
8718                 offload->self_ipv6_addr[i][14] =
8719                                         offload->ipv6_addr[i][14];
8720                 offload->self_ipv6_addr[i][15] =
8721                                         offload->ipv6_addr[i][15];
8722                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8723                            offload->self_ipv6_addr[i]);
8724         }
8725 }
8726
8727 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8728                                        struct ieee80211_vif *vif,
8729                                        struct inet6_dev *idev)
8730 {
8731         struct ath11k *ar = hw->priv;
8732         struct ath11k_arp_ns_offload *offload;
8733         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8734         struct inet6_ifaddr *ifa6;
8735         struct ifacaddr6 *ifaca6;
8736         struct list_head *p;
8737         u32 count, scope;
8738
8739         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "op ipv6 changed\n");
8740
8741         offload = &arvif->arp_ns_offload;
8742         count = 0;
8743
8744         read_lock_bh(&idev->lock);
8745
8746         memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8747         memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8748         memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8749
8750         /* get unicast address */
8751         list_for_each(p, &idev->addr_list) {
8752                 if (count >= ATH11K_IPV6_MAX_COUNT)
8753                         goto generate;
8754
8755                 ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8756                 if (ifa6->flags & IFA_F_DADFAILED)
8757                         continue;
8758                 scope = ipv6_addr_src_scope(&ifa6->addr);
8759                 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8760                     scope == IPV6_ADDR_SCOPE_GLOBAL) {
8761                         memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8762                                sizeof(ifa6->addr.s6_addr));
8763                         offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8764                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 uc %pI6 scope %d\n",
8765                                    count, offload->ipv6_addr[count],
8766                                    scope);
8767                         count++;
8768                 } else {
8769                         ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8770                 }
8771         }
8772
8773         /* get anycast address */
8774         for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8775                 if (count >= ATH11K_IPV6_MAX_COUNT)
8776                         goto generate;
8777
8778                 scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8779                 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8780                     scope == IPV6_ADDR_SCOPE_GLOBAL) {
8781                         memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8782                                sizeof(ifaca6->aca_addr));
8783                         offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8784                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "count %d ipv6 ac %pI6 scope %d\n",
8785                                    count, offload->ipv6_addr[count],
8786                                    scope);
8787                         count++;
8788                 } else {
8789                         ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8790                 }
8791         }
8792
8793 generate:
8794         offload->ipv6_count = count;
8795         read_unlock_bh(&idev->lock);
8796
8797         /* generate ns multicast address */
8798         ath11k_generate_ns_mc_addr(ar, offload);
8799 }
8800 #endif
8801
8802 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8803                                          struct ieee80211_vif *vif,
8804                                          struct cfg80211_gtk_rekey_data *data)
8805 {
8806         struct ath11k *ar = hw->priv;
8807         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8808         struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8809
8810         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "set rekey data vdev %d\n",
8811                    arvif->vdev_id);
8812
8813         mutex_lock(&ar->conf_mutex);
8814
8815         memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8816         memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8817
8818         /* The supplicant works on big-endian, the firmware expects it on
8819          * little endian.
8820          */
8821         rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8822
8823         arvif->rekey_data.enable_offload = true;
8824
8825         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8826                         rekey_data->kck, NL80211_KCK_LEN);
8827         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8828                         rekey_data->kck, NL80211_KEK_LEN);
8829         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8830                         &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8831
8832         mutex_unlock(&ar->conf_mutex);
8833 }
8834
8835 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8836                                             const struct cfg80211_sar_specs *sar)
8837 {
8838         struct ath11k *ar = hw->priv;
8839         const struct cfg80211_sar_sub_specs *sspec;
8840         int ret, index;
8841         u8 *sar_tbl;
8842         u32 i;
8843
8844         if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8845             sar->num_sub_specs == 0)
8846                 return -EINVAL;
8847
8848         mutex_lock(&ar->conf_mutex);
8849
8850         if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8851             !ar->ab->hw_params.bios_sar_capa) {
8852                 ret = -EOPNOTSUPP;
8853                 goto exit;
8854         }
8855
8856         ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8857         if (ret) {
8858                 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8859                 goto exit;
8860         }
8861
8862         sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8863         if (!sar_tbl) {
8864                 ret = -ENOMEM;
8865                 goto exit;
8866         }
8867
8868         sspec = sar->sub_specs;
8869         for (i = 0; i < sar->num_sub_specs; i++) {
8870                 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8871                         ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8872                                     sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8873                         continue;
8874                 }
8875
8876                 /* chain0 and chain1 share same power setting */
8877                 sar_tbl[sspec->freq_range_index] = sspec->power;
8878                 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8879                 sar_tbl[index] = sspec->power;
8880                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8881                            sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8882                 sspec++;
8883         }
8884
8885         ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8886         if (ret)
8887                 ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8888
8889         kfree(sar_tbl);
8890 exit:
8891         mutex_unlock(&ar->conf_mutex);
8892
8893         return ret;
8894 }
8895
8896 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
8897                                                   struct ieee80211_vif *vif)
8898 {
8899         struct ath11k *ar = hw->priv;
8900
8901         mutex_lock(&ar->conf_mutex);
8902
8903         spin_lock_bh(&ar->data_lock);
8904         ar->scan.roc_notify = false;
8905         spin_unlock_bh(&ar->data_lock);
8906
8907         ath11k_scan_abort(ar);
8908
8909         mutex_unlock(&ar->conf_mutex);
8910
8911         cancel_delayed_work_sync(&ar->scan.timeout);
8912
8913         return 0;
8914 }
8915
8916 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
8917                                            struct ieee80211_vif *vif,
8918                                            struct ieee80211_channel *chan,
8919                                            int duration,
8920                                            enum ieee80211_roc_type type)
8921 {
8922         struct ath11k *ar = hw->priv;
8923         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8924         struct scan_req_params *arg;
8925         int ret;
8926         u32 scan_time_msec;
8927
8928         mutex_lock(&ar->conf_mutex);
8929
8930         spin_lock_bh(&ar->data_lock);
8931         switch (ar->scan.state) {
8932         case ATH11K_SCAN_IDLE:
8933                 reinit_completion(&ar->scan.started);
8934                 reinit_completion(&ar->scan.completed);
8935                 reinit_completion(&ar->scan.on_channel);
8936                 ar->scan.state = ATH11K_SCAN_STARTING;
8937                 ar->scan.is_roc = true;
8938                 ar->scan.vdev_id = arvif->vdev_id;
8939                 ar->scan.roc_freq = chan->center_freq;
8940                 ar->scan.roc_notify = true;
8941                 ret = 0;
8942                 break;
8943         case ATH11K_SCAN_STARTING:
8944         case ATH11K_SCAN_RUNNING:
8945         case ATH11K_SCAN_ABORTING:
8946                 ret = -EBUSY;
8947                 break;
8948         }
8949         spin_unlock_bh(&ar->data_lock);
8950
8951         if (ret)
8952                 goto exit;
8953
8954         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
8955
8956         arg = kzalloc(sizeof(*arg), GFP_KERNEL);
8957         if (!arg) {
8958                 ret = -ENOMEM;
8959                 goto exit;
8960         }
8961         ath11k_wmi_start_scan_init(ar, arg);
8962         arg->num_chan = 1;
8963         arg->chan_list = kcalloc(arg->num_chan, sizeof(*arg->chan_list),
8964                                  GFP_KERNEL);
8965         if (!arg->chan_list) {
8966                 ret = -ENOMEM;
8967                 goto free_arg;
8968         }
8969
8970         arg->vdev_id = arvif->vdev_id;
8971         arg->scan_id = ATH11K_SCAN_ID;
8972         arg->chan_list[0] = chan->center_freq;
8973         arg->dwell_time_active = scan_time_msec;
8974         arg->dwell_time_passive = scan_time_msec;
8975         arg->max_scan_time = scan_time_msec;
8976         arg->scan_flags |= WMI_SCAN_FLAG_PASSIVE;
8977         arg->scan_flags |= WMI_SCAN_FILTER_PROBE_REQ;
8978         arg->burst_duration = duration;
8979
8980         ret = ath11k_start_scan(ar, arg);
8981         if (ret) {
8982                 ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret);
8983
8984                 spin_lock_bh(&ar->data_lock);
8985                 ar->scan.state = ATH11K_SCAN_IDLE;
8986                 spin_unlock_bh(&ar->data_lock);
8987                 goto free_chan_list;
8988         }
8989
8990         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
8991         if (ret == 0) {
8992                 ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n");
8993                 ret = ath11k_scan_stop(ar);
8994                 if (ret)
8995                         ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
8996                 ret = -ETIMEDOUT;
8997                 goto free_chan_list;
8998         }
8999
9000         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
9001                                      msecs_to_jiffies(duration));
9002
9003         ret = 0;
9004
9005 free_chan_list:
9006         kfree(arg->chan_list);
9007 free_arg:
9008         kfree(arg);
9009 exit:
9010         mutex_unlock(&ar->conf_mutex);
9011         return ret;
9012 }
9013
9014 static int ath11k_fw_stats_request(struct ath11k *ar,
9015                                    struct stats_request_params *req_param)
9016 {
9017         struct ath11k_base *ab = ar->ab;
9018         unsigned long time_left;
9019         int ret;
9020
9021         lockdep_assert_held(&ar->conf_mutex);
9022
9023         spin_lock_bh(&ar->data_lock);
9024         ar->fw_stats_done = false;
9025         ath11k_fw_stats_pdevs_free(&ar->fw_stats.pdevs);
9026         spin_unlock_bh(&ar->data_lock);
9027
9028         reinit_completion(&ar->fw_stats_complete);
9029
9030         ret = ath11k_wmi_send_stats_request_cmd(ar, req_param);
9031         if (ret) {
9032                 ath11k_warn(ab, "could not request fw stats (%d)\n",
9033                             ret);
9034                 return ret;
9035         }
9036
9037         time_left = wait_for_completion_timeout(&ar->fw_stats_complete,
9038                                                 1 * HZ);
9039
9040         if (!time_left)
9041                 return -ETIMEDOUT;
9042
9043         return 0;
9044 }
9045
9046 static int ath11k_mac_op_get_txpower(struct ieee80211_hw *hw,
9047                                      struct ieee80211_vif *vif,
9048                                      int *dbm)
9049 {
9050         struct ath11k *ar = hw->priv;
9051         struct ath11k_base *ab = ar->ab;
9052         struct stats_request_params req_param = {0};
9053         struct ath11k_fw_stats_pdev *pdev;
9054         int ret;
9055
9056         /* Final Tx power is minimum of Target Power, CTL power, Regulatory
9057          * Power, PSD EIRP Power. We just know the Regulatory power from the
9058          * regulatory rules obtained. FW knows all these power and sets the min
9059          * of these. Hence, we request the FW pdev stats in which FW reports
9060          * the minimum of all vdev's channel Tx power.
9061          */
9062         mutex_lock(&ar->conf_mutex);
9063
9064         if (ar->state != ATH11K_STATE_ON)
9065                 goto err_fallback;
9066
9067         /* Firmware doesn't provide Tx power during CAC hence no need to fetch
9068          * the stats.
9069          */
9070         if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
9071                 mutex_unlock(&ar->conf_mutex);
9072                 return -EAGAIN;
9073         }
9074
9075         req_param.pdev_id = ar->pdev->pdev_id;
9076         req_param.stats_id = WMI_REQUEST_PDEV_STAT;
9077
9078         ret = ath11k_fw_stats_request(ar, &req_param);
9079         if (ret) {
9080                 ath11k_warn(ab, "failed to request fw pdev stats: %d\n", ret);
9081                 goto err_fallback;
9082         }
9083
9084         spin_lock_bh(&ar->data_lock);
9085         pdev = list_first_entry_or_null(&ar->fw_stats.pdevs,
9086                                         struct ath11k_fw_stats_pdev, list);
9087         if (!pdev) {
9088                 spin_unlock_bh(&ar->data_lock);
9089                 goto err_fallback;
9090         }
9091
9092         /* tx power is set as 2 units per dBm in FW. */
9093         *dbm = pdev->chan_tx_power / 2;
9094
9095         spin_unlock_bh(&ar->data_lock);
9096         mutex_unlock(&ar->conf_mutex);
9097
9098         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware %d, reported %d dBm\n",
9099                    pdev->chan_tx_power, *dbm);
9100         return 0;
9101
9102 err_fallback:
9103         mutex_unlock(&ar->conf_mutex);
9104         /* We didn't get txpower from FW. Hence, relying on vif->bss_conf.txpower */
9105         *dbm = vif->bss_conf.txpower;
9106         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower from firmware NaN, reported %d dBm\n",
9107                    *dbm);
9108         return 0;
9109 }
9110
9111 static const struct ieee80211_ops ath11k_ops = {
9112         .tx                             = ath11k_mac_op_tx,
9113         .wake_tx_queue                  = ieee80211_handle_wake_tx_queue,
9114         .start                          = ath11k_mac_op_start,
9115         .stop                           = ath11k_mac_op_stop,
9116         .reconfig_complete              = ath11k_mac_op_reconfig_complete,
9117         .add_interface                  = ath11k_mac_op_add_interface,
9118         .remove_interface               = ath11k_mac_op_remove_interface,
9119         .update_vif_offload             = ath11k_mac_op_update_vif_offload,
9120         .config                         = ath11k_mac_op_config,
9121         .bss_info_changed               = ath11k_mac_op_bss_info_changed,
9122         .configure_filter               = ath11k_mac_op_configure_filter,
9123         .hw_scan                        = ath11k_mac_op_hw_scan,
9124         .cancel_hw_scan                 = ath11k_mac_op_cancel_hw_scan,
9125         .set_key                        = ath11k_mac_op_set_key,
9126         .set_rekey_data                 = ath11k_mac_op_set_rekey_data,
9127         .sta_state                      = ath11k_mac_op_sta_state,
9128         .sta_set_4addr                  = ath11k_mac_op_sta_set_4addr,
9129         .sta_set_txpwr                  = ath11k_mac_op_sta_set_txpwr,
9130         .sta_rc_update                  = ath11k_mac_op_sta_rc_update,
9131         .conf_tx                        = ath11k_mac_op_conf_tx,
9132         .set_antenna                    = ath11k_mac_op_set_antenna,
9133         .get_antenna                    = ath11k_mac_op_get_antenna,
9134         .ampdu_action                   = ath11k_mac_op_ampdu_action,
9135         .add_chanctx                    = ath11k_mac_op_add_chanctx,
9136         .remove_chanctx                 = ath11k_mac_op_remove_chanctx,
9137         .change_chanctx                 = ath11k_mac_op_change_chanctx,
9138         .assign_vif_chanctx             = ath11k_mac_op_assign_vif_chanctx,
9139         .unassign_vif_chanctx           = ath11k_mac_op_unassign_vif_chanctx,
9140         .switch_vif_chanctx             = ath11k_mac_op_switch_vif_chanctx,
9141         .set_rts_threshold              = ath11k_mac_op_set_rts_threshold,
9142         .set_frag_threshold             = ath11k_mac_op_set_frag_threshold,
9143         .set_bitrate_mask               = ath11k_mac_op_set_bitrate_mask,
9144         .get_survey                     = ath11k_mac_op_get_survey,
9145         .flush                          = ath11k_mac_op_flush,
9146         .sta_statistics                 = ath11k_mac_op_sta_statistics,
9147         CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
9148
9149 #ifdef CONFIG_PM
9150         .suspend                        = ath11k_wow_op_suspend,
9151         .resume                         = ath11k_wow_op_resume,
9152         .set_wakeup                     = ath11k_wow_op_set_wakeup,
9153 #endif
9154
9155 #ifdef CONFIG_ATH11K_DEBUGFS
9156         .sta_add_debugfs                = ath11k_debugfs_sta_op_add,
9157 #endif
9158
9159 #if IS_ENABLED(CONFIG_IPV6)
9160         .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
9161 #endif
9162         .get_txpower                    = ath11k_mac_op_get_txpower,
9163
9164         .set_sar_specs                  = ath11k_mac_op_set_bios_sar_specs,
9165         .remain_on_channel              = ath11k_mac_op_remain_on_channel,
9166         .cancel_remain_on_channel       = ath11k_mac_op_cancel_remain_on_channel,
9167 };
9168
9169 static void ath11k_mac_update_ch_list(struct ath11k *ar,
9170                                       struct ieee80211_supported_band *band,
9171                                       u32 freq_low, u32 freq_high)
9172 {
9173         int i;
9174
9175         if (!(freq_low && freq_high))
9176                 return;
9177
9178         for (i = 0; i < band->n_channels; i++) {
9179                 if (band->channels[i].center_freq < freq_low ||
9180                     band->channels[i].center_freq > freq_high)
9181                         band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
9182         }
9183 }
9184
9185 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
9186 {
9187         struct ath11k_pdev *pdev = ar->pdev;
9188         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
9189
9190         if (band == WMI_HOST_WLAN_2G_CAP)
9191                 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
9192
9193         if (band == WMI_HOST_WLAN_5G_CAP)
9194                 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
9195
9196         ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
9197
9198         return 0;
9199 }
9200
9201 static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
9202                                            u32 supported_bands)
9203 {
9204         struct ieee80211_supported_band *band;
9205         struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
9206         void *channels;
9207         u32 phy_id;
9208
9209         BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
9210                       ARRAY_SIZE(ath11k_5ghz_channels) +
9211                       ARRAY_SIZE(ath11k_6ghz_channels)) !=
9212                      ATH11K_NUM_CHANS);
9213
9214         reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
9215         temp_reg_cap = reg_cap;
9216
9217         if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
9218                 channels = kmemdup(ath11k_2ghz_channels,
9219                                    sizeof(ath11k_2ghz_channels),
9220                                    GFP_KERNEL);
9221                 if (!channels)
9222                         return -ENOMEM;
9223
9224                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
9225                 band->band = NL80211_BAND_2GHZ;
9226                 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
9227                 band->channels = channels;
9228                 band->n_bitrates = ath11k_g_rates_size;
9229                 band->bitrates = ath11k_g_rates;
9230                 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
9231
9232                 if (ar->ab->hw_params.single_pdev_only) {
9233                         phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
9234                         temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9235                 }
9236                 ath11k_mac_update_ch_list(ar, band,
9237                                           temp_reg_cap->low_2ghz_chan,
9238                                           temp_reg_cap->high_2ghz_chan);
9239         }
9240
9241         if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
9242                 if (reg_cap->high_5ghz_chan >= ATH11K_MIN_6G_FREQ) {
9243                         channels = kmemdup(ath11k_6ghz_channels,
9244                                            sizeof(ath11k_6ghz_channels), GFP_KERNEL);
9245                         if (!channels) {
9246                                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9247                                 return -ENOMEM;
9248                         }
9249
9250                         ar->supports_6ghz = true;
9251                         band = &ar->mac.sbands[NL80211_BAND_6GHZ];
9252                         band->band = NL80211_BAND_6GHZ;
9253                         band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
9254                         band->channels = channels;
9255                         band->n_bitrates = ath11k_a_rates_size;
9256                         band->bitrates = ath11k_a_rates;
9257                         ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
9258
9259                         if (ar->ab->hw_params.single_pdev_only) {
9260                                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
9261                                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9262                         }
9263
9264                         ath11k_mac_update_ch_list(ar, band,
9265                                                   temp_reg_cap->low_5ghz_chan,
9266                                                   temp_reg_cap->high_5ghz_chan);
9267                 }
9268
9269                 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
9270                         channels = kmemdup(ath11k_5ghz_channels,
9271                                            sizeof(ath11k_5ghz_channels),
9272                                            GFP_KERNEL);
9273                         if (!channels) {
9274                                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9275                                 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9276                                 return -ENOMEM;
9277                         }
9278
9279                         band = &ar->mac.sbands[NL80211_BAND_5GHZ];
9280                         band->band = NL80211_BAND_5GHZ;
9281                         band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
9282                         band->channels = channels;
9283                         band->n_bitrates = ath11k_a_rates_size;
9284                         band->bitrates = ath11k_a_rates;
9285                         ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
9286
9287                         if (ar->ab->hw_params.single_pdev_only) {
9288                                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
9289                                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
9290                         }
9291
9292                         ath11k_mac_update_ch_list(ar, band,
9293                                                   temp_reg_cap->low_5ghz_chan,
9294                                                   temp_reg_cap->high_5ghz_chan);
9295                 }
9296         }
9297
9298         return 0;
9299 }
9300
9301 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
9302 {
9303         struct ath11k_base *ab = ar->ab;
9304         struct ieee80211_iface_combination *combinations;
9305         struct ieee80211_iface_limit *limits;
9306         int n_limits;
9307
9308         combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
9309         if (!combinations)
9310                 return -ENOMEM;
9311
9312         n_limits = 2;
9313
9314         limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
9315         if (!limits) {
9316                 kfree(combinations);
9317                 return -ENOMEM;
9318         }
9319
9320         limits[0].max = 1;
9321         limits[0].types |= BIT(NL80211_IFTYPE_STATION);
9322
9323         limits[1].max = 16;
9324         limits[1].types |= BIT(NL80211_IFTYPE_AP);
9325
9326         if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
9327             ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
9328                 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
9329
9330         combinations[0].limits = limits;
9331         combinations[0].n_limits = n_limits;
9332         combinations[0].max_interfaces = 16;
9333         combinations[0].num_different_channels = 1;
9334         combinations[0].beacon_int_infra_match = true;
9335         combinations[0].beacon_int_min_gcd = 100;
9336         combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9337                                                 BIT(NL80211_CHAN_WIDTH_20) |
9338                                                 BIT(NL80211_CHAN_WIDTH_40) |
9339                                                 BIT(NL80211_CHAN_WIDTH_80) |
9340                                                 BIT(NL80211_CHAN_WIDTH_80P80) |
9341                                                 BIT(NL80211_CHAN_WIDTH_160);
9342
9343         ar->hw->wiphy->iface_combinations = combinations;
9344         ar->hw->wiphy->n_iface_combinations = 1;
9345
9346         return 0;
9347 }
9348
9349 static const u8 ath11k_if_types_ext_capa[] = {
9350         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9351         [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9352         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9353 };
9354
9355 static const u8 ath11k_if_types_ext_capa_sta[] = {
9356         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9357         [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9358         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9359         [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
9360 };
9361
9362 static const u8 ath11k_if_types_ext_capa_ap[] = {
9363         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
9364         [2] = WLAN_EXT_CAPA3_MULTI_BSSID_SUPPORT,
9365         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
9366         [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
9367         [10] = WLAN_EXT_CAPA11_EMA_SUPPORT,
9368 };
9369
9370 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
9371         {
9372                 .extended_capabilities = ath11k_if_types_ext_capa,
9373                 .extended_capabilities_mask = ath11k_if_types_ext_capa,
9374                 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
9375         }, {
9376                 .iftype = NL80211_IFTYPE_STATION,
9377                 .extended_capabilities = ath11k_if_types_ext_capa_sta,
9378                 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
9379                 .extended_capabilities_len =
9380                                 sizeof(ath11k_if_types_ext_capa_sta),
9381         }, {
9382                 .iftype = NL80211_IFTYPE_AP,
9383                 .extended_capabilities = ath11k_if_types_ext_capa_ap,
9384                 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
9385                 .extended_capabilities_len =
9386                                 sizeof(ath11k_if_types_ext_capa_ap),
9387         },
9388 };
9389
9390 static void __ath11k_mac_unregister(struct ath11k *ar)
9391 {
9392         cancel_work_sync(&ar->regd_update_work);
9393
9394         ieee80211_unregister_hw(ar->hw);
9395
9396         idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
9397         idr_destroy(&ar->txmgmt_idr);
9398
9399         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9400         kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9401         kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9402
9403         kfree(ar->hw->wiphy->iface_combinations[0].limits);
9404         kfree(ar->hw->wiphy->iface_combinations);
9405
9406         SET_IEEE80211_DEV(ar->hw, NULL);
9407 }
9408
9409 void ath11k_mac_unregister(struct ath11k_base *ab)
9410 {
9411         struct ath11k *ar;
9412         struct ath11k_pdev *pdev;
9413         int i;
9414
9415         for (i = 0; i < ab->num_radios; i++) {
9416                 pdev = &ab->pdevs[i];
9417                 ar = pdev->ar;
9418                 if (!ar)
9419                         continue;
9420
9421                 __ath11k_mac_unregister(ar);
9422         }
9423
9424         ath11k_peer_rhash_tbl_destroy(ab);
9425 }
9426
9427 static int __ath11k_mac_register(struct ath11k *ar)
9428 {
9429         struct ath11k_base *ab = ar->ab;
9430         struct ath11k_pdev_cap *cap = &ar->pdev->cap;
9431         static const u32 cipher_suites[] = {
9432                 WLAN_CIPHER_SUITE_TKIP,
9433                 WLAN_CIPHER_SUITE_CCMP,
9434                 WLAN_CIPHER_SUITE_AES_CMAC,
9435                 WLAN_CIPHER_SUITE_BIP_CMAC_256,
9436                 WLAN_CIPHER_SUITE_BIP_GMAC_128,
9437                 WLAN_CIPHER_SUITE_BIP_GMAC_256,
9438                 WLAN_CIPHER_SUITE_GCMP,
9439                 WLAN_CIPHER_SUITE_GCMP_256,
9440                 WLAN_CIPHER_SUITE_CCMP_256,
9441         };
9442         int ret;
9443         u32 ht_cap = 0;
9444
9445         ath11k_pdev_caps_update(ar);
9446
9447         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
9448
9449         SET_IEEE80211_DEV(ar->hw, ab->dev);
9450
9451         ret = ath11k_mac_setup_channels_rates(ar,
9452                                               cap->supported_bands);
9453         if (ret)
9454                 goto err;
9455
9456         ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
9457         ath11k_mac_setup_he_cap(ar, cap);
9458
9459         ret = ath11k_mac_setup_iface_combinations(ar);
9460         if (ret) {
9461                 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
9462                 goto err_free_channels;
9463         }
9464
9465         ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
9466         ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
9467
9468         ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
9469
9470         if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
9471                 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
9472
9473         if (ab->hw_params.supports_multi_bssid) {
9474                 ieee80211_hw_set(ar->hw, SUPPORTS_MULTI_BSSID);
9475                 ieee80211_hw_set(ar->hw, SUPPORTS_ONLY_HE_MULTI_BSSID);
9476         }
9477
9478         ieee80211_hw_set(ar->hw, SIGNAL_DBM);
9479         ieee80211_hw_set(ar->hw, SUPPORTS_PS);
9480         ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
9481         ieee80211_hw_set(ar->hw, MFP_CAPABLE);
9482         ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
9483         ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
9484         ieee80211_hw_set(ar->hw, AP_LINK_PS);
9485         ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
9486         ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
9487         ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
9488         ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
9489         ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
9490         ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
9491         ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
9492         ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
9493
9494         if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
9495                 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
9496                 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
9497         }
9498
9499         if (cap->nss_ratio_enabled)
9500                 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
9501
9502         if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
9503                 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
9504                 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
9505                 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
9506                 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
9507                 ieee80211_hw_set(ar->hw, USES_RSS);
9508         }
9509
9510         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
9511         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
9512
9513         /* TODO: Check if HT capability advertised from firmware is different
9514          * for each band for a dual band capable radio. It will be tricky to
9515          * handle it when the ht capability different for each band.
9516          */
9517         if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
9518             (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
9519                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
9520
9521         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
9522         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
9523
9524         ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
9525
9526         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
9527         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
9528         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
9529
9530         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
9531         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
9532                                    NL80211_FEATURE_AP_SCAN;
9533
9534         ar->max_num_stations = TARGET_NUM_STATIONS(ab);
9535         ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
9536
9537         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
9538
9539         if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
9540                 ar->hw->wiphy->features |=
9541                         NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
9542         }
9543
9544         if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
9545                 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
9546                 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
9547                 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
9548                 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
9549                 ar->hw->wiphy->max_sched_scan_plan_interval =
9550                         WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
9551                 ar->hw->wiphy->max_sched_scan_plan_iterations =
9552                         WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
9553                 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
9554         }
9555
9556         ret = ath11k_wow_init(ar);
9557         if (ret) {
9558                 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
9559                 goto err_free_if_combs;
9560         }
9561
9562         if (test_bit(WMI_TLV_SERVICE_TX_DATA_MGMT_ACK_RSSI,
9563                      ar->ab->wmi_ab.svc_map))
9564                 wiphy_ext_feature_set(ar->hw->wiphy,
9565                                       NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT);
9566
9567         ar->hw->queues = ATH11K_HW_MAX_QUEUES;
9568         ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
9569         ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
9570         ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
9571
9572         ar->hw->vif_data_size = sizeof(struct ath11k_vif);
9573         ar->hw->sta_data_size = sizeof(struct ath11k_sta);
9574
9575         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
9576         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
9577         if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD,
9578                      ar->ab->wmi_ab.svc_map)) {
9579                 wiphy_ext_feature_set(ar->hw->wiphy,
9580                                       NL80211_EXT_FEATURE_BSS_COLOR);
9581                 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION);
9582         }
9583
9584         ar->hw->wiphy->cipher_suites = cipher_suites;
9585         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
9586
9587         ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
9588         ar->hw->wiphy->num_iftype_ext_capab =
9589                 ARRAY_SIZE(ath11k_iftypes_ext_capa);
9590
9591         if (ar->supports_6ghz) {
9592                 wiphy_ext_feature_set(ar->hw->wiphy,
9593                                       NL80211_EXT_FEATURE_FILS_DISCOVERY);
9594                 wiphy_ext_feature_set(ar->hw->wiphy,
9595                                       NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
9596         }
9597
9598         wiphy_ext_feature_set(ar->hw->wiphy,
9599                               NL80211_EXT_FEATURE_SET_SCAN_DWELL);
9600
9601         if (test_bit(WMI_TLV_SERVICE_RTT, ar->ab->wmi_ab.svc_map))
9602                 wiphy_ext_feature_set(ar->hw->wiphy,
9603                                       NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);
9604
9605         ar->hw->wiphy->mbssid_max_interfaces = TARGET_NUM_VDEVS(ab);
9606         ar->hw->wiphy->ema_max_profile_periodicity = TARGET_EMA_MAX_PROFILE_PERIOD;
9607
9608         ath11k_reg_init(ar);
9609
9610         if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
9611                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
9612                 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
9613                 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
9614         }
9615
9616         if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
9617             ab->hw_params.bios_sar_capa)
9618                 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
9619
9620         ret = ieee80211_register_hw(ar->hw);
9621         if (ret) {
9622                 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
9623                 goto err_free_if_combs;
9624         }
9625
9626         if (!ab->hw_params.supports_monitor)
9627                 /* There's a race between calling ieee80211_register_hw()
9628                  * and here where the monitor mode is enabled for a little
9629                  * while. But that time is so short and in practise it make
9630                  * a difference in real life.
9631                  */
9632                 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
9633
9634         /* Apply the regd received during initialization */
9635         ret = ath11k_regd_update(ar);
9636         if (ret) {
9637                 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
9638                 goto err_unregister_hw;
9639         }
9640
9641         if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) {
9642                 struct wmi_set_current_country_params set_current_param = {};
9643
9644                 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2);
9645                 memcpy(&ar->alpha2, ab->new_alpha2, 2);
9646                 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
9647                 if (ret)
9648                         ath11k_warn(ar->ab,
9649                                     "failed set cc code for mac register: %d\n", ret);
9650         }
9651
9652         ret = ath11k_debugfs_register(ar);
9653         if (ret) {
9654                 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
9655                 goto err_unregister_hw;
9656         }
9657
9658         return 0;
9659
9660 err_unregister_hw:
9661         ieee80211_unregister_hw(ar->hw);
9662
9663 err_free_if_combs:
9664         kfree(ar->hw->wiphy->iface_combinations[0].limits);
9665         kfree(ar->hw->wiphy->iface_combinations);
9666
9667 err_free_channels:
9668         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9669         kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9670         kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9671
9672 err:
9673         SET_IEEE80211_DEV(ar->hw, NULL);
9674         return ret;
9675 }
9676
9677 int ath11k_mac_register(struct ath11k_base *ab)
9678 {
9679         struct ath11k *ar;
9680         struct ath11k_pdev *pdev;
9681         int i;
9682         int ret;
9683         u8 mac_addr[ETH_ALEN] = {0};
9684
9685         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9686                 return 0;
9687
9688         /* Initialize channel counters frequency value in hertz */
9689         ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
9690         ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
9691
9692         ret = ath11k_peer_rhash_tbl_init(ab);
9693         if (ret)
9694                 return ret;
9695
9696         device_get_mac_address(ab->dev, mac_addr);
9697
9698         for (i = 0; i < ab->num_radios; i++) {
9699                 pdev = &ab->pdevs[i];
9700                 ar = pdev->ar;
9701                 if (ab->pdevs_macaddr_valid) {
9702                         ether_addr_copy(ar->mac_addr, pdev->mac_addr);
9703                 } else {
9704                         if (is_zero_ether_addr(mac_addr))
9705                                 ether_addr_copy(ar->mac_addr, ab->mac_addr);
9706                         else
9707                                 ether_addr_copy(ar->mac_addr, mac_addr);
9708                         ar->mac_addr[4] += i;
9709                 }
9710
9711                 idr_init(&ar->txmgmt_idr);
9712                 spin_lock_init(&ar->txmgmt_idr_lock);
9713
9714                 ret = __ath11k_mac_register(ar);
9715                 if (ret)
9716                         goto err_cleanup;
9717
9718                 init_waitqueue_head(&ar->txmgmt_empty_waitq);
9719         }
9720
9721         return 0;
9722
9723 err_cleanup:
9724         for (i = i - 1; i >= 0; i--) {
9725                 pdev = &ab->pdevs[i];
9726                 ar = pdev->ar;
9727                 __ath11k_mac_unregister(ar);
9728         }
9729
9730         ath11k_peer_rhash_tbl_destroy(ab);
9731
9732         return ret;
9733 }
9734
9735 int ath11k_mac_allocate(struct ath11k_base *ab)
9736 {
9737         struct ieee80211_hw *hw;
9738         struct ath11k *ar;
9739         struct ath11k_pdev *pdev;
9740         int ret;
9741         int i;
9742
9743         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9744                 return 0;
9745
9746         for (i = 0; i < ab->num_radios; i++) {
9747                 pdev = &ab->pdevs[i];
9748                 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
9749                 if (!hw) {
9750                         ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
9751                         ret = -ENOMEM;
9752                         goto err_free_mac;
9753                 }
9754
9755                 ar = hw->priv;
9756                 ar->hw = hw;
9757                 ar->ab = ab;
9758                 ar->pdev = pdev;
9759                 ar->pdev_idx = i;
9760                 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
9761
9762                 ar->wmi = &ab->wmi_ab.wmi[i];
9763                 /* FIXME wmi[0] is already initialized during attach,
9764                  * Should we do this again?
9765                  */
9766                 ath11k_wmi_pdev_attach(ab, i);
9767
9768                 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
9769                 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
9770                 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
9771                 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
9772
9773                 pdev->ar = ar;
9774                 spin_lock_init(&ar->data_lock);
9775                 INIT_LIST_HEAD(&ar->arvifs);
9776                 INIT_LIST_HEAD(&ar->ppdu_stats_info);
9777                 mutex_init(&ar->conf_mutex);
9778                 init_completion(&ar->vdev_setup_done);
9779                 init_completion(&ar->vdev_delete_done);
9780                 init_completion(&ar->peer_assoc_done);
9781                 init_completion(&ar->peer_delete_done);
9782                 init_completion(&ar->install_key_done);
9783                 init_completion(&ar->bss_survey_done);
9784                 init_completion(&ar->scan.started);
9785                 init_completion(&ar->scan.completed);
9786                 init_completion(&ar->scan.on_channel);
9787                 init_completion(&ar->thermal.wmi_sync);
9788
9789                 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
9790                 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
9791
9792                 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
9793                 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
9794
9795                 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
9796
9797                 ar->monitor_vdev_id = -1;
9798                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9799                 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
9800                 init_completion(&ar->completed_11d_scan);
9801
9802                 ath11k_fw_stats_init(ar);
9803         }
9804
9805         return 0;
9806
9807 err_free_mac:
9808         ath11k_mac_destroy(ab);
9809
9810         return ret;
9811 }
9812
9813 void ath11k_mac_destroy(struct ath11k_base *ab)
9814 {
9815         struct ath11k *ar;
9816         struct ath11k_pdev *pdev;
9817         int i;
9818
9819         for (i = 0; i < ab->num_radios; i++) {
9820                 pdev = &ab->pdevs[i];
9821                 ar = pdev->ar;
9822                 if (!ar)
9823                         continue;
9824
9825                 ath11k_fw_stats_free(&ar->fw_stats);
9826                 ieee80211_free_hw(ar->hw);
9827                 pdev->ar = NULL;
9828         }
9829 }
9830
9831 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif,
9832                                  enum wmi_sta_keepalive_method method,
9833                                  u32 interval)
9834 {
9835         struct ath11k *ar = arvif->ar;
9836         struct wmi_sta_keepalive_arg arg = {};
9837         int ret;
9838
9839         lockdep_assert_held(&ar->conf_mutex);
9840
9841         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
9842                 return 0;
9843
9844         if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
9845                 return 0;
9846
9847         arg.vdev_id = arvif->vdev_id;
9848         arg.enabled = 1;
9849         arg.method = method;
9850         arg.interval = interval;
9851
9852         ret = ath11k_wmi_sta_keepalive(ar, &arg);
9853         if (ret) {
9854                 ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
9855                             arvif->vdev_id, ret);
9856                 return ret;
9857         }
9858
9859         return 0;
9860 }