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