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