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;
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         he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2102
2103         if (ath11k_peer_assoc_h_he_masked(he_mcs_mask))
2104                 return;
2105
2106         arg->he_flag = true;
2107         support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] &
2108                   IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G);
2109
2110         /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */
2111         mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2112         mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2113
2114         if (support_160) {
2115                 for (i = 7; i >= 0; i--) {
2116                         u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;
2117
2118                         if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2119                                 rx_mcs_160 = i + 1;
2120                                 break;
2121                         }
2122                 }
2123         }
2124
2125         for (i = 7; i >= 0; i--) {
2126                 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;
2127
2128                 if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2129                         rx_mcs_80 = i + 1;
2130                         break;
2131                 }
2132         }
2133
2134         if (support_160)
2135                 max_nss = min(rx_mcs_80, rx_mcs_160);
2136         else
2137                 max_nss = rx_mcs_80;
2138
2139         arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2140
2141         memcpy_and_pad(&arg->peer_he_cap_macinfo,
2142                        sizeof(arg->peer_he_cap_macinfo),
2143                        he_cap->he_cap_elem.mac_cap_info,
2144                        sizeof(he_cap->he_cap_elem.mac_cap_info),
2145                        0);
2146         memcpy_and_pad(&arg->peer_he_cap_phyinfo,
2147                        sizeof(arg->peer_he_cap_phyinfo),
2148                        he_cap->he_cap_elem.phy_cap_info,
2149                        sizeof(he_cap->he_cap_elem.phy_cap_info),
2150                        0);
2151         arg->peer_he_ops = vif->bss_conf.he_oper.params;
2152
2153         /* the top most byte is used to indicate BSS color info */
2154         arg->peer_he_ops &= 0xffffff;
2155
2156         /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension
2157          * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing
2158          * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present).
2159          *
2160          * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps,
2161          * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
2162          * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
2163          * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
2164          * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
2165          * length.
2166          */
2167         ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3],
2168                                    IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK);
2169
2170         if (ampdu_factor) {
2171                 if (sta->deflink.vht_cap.vht_supported)
2172                         arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
2173                                                     ampdu_factor)) - 1;
2174                 else if (sta->deflink.ht_cap.ht_supported)
2175                         arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
2176                                                     ampdu_factor)) - 1;
2177         }
2178
2179         if (he_cap->he_cap_elem.phy_cap_info[6] &
2180             IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
2181                 int bit = 7;
2182                 int nss, ru;
2183
2184                 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
2185                                           IEEE80211_PPE_THRES_NSS_MASK;
2186                 arg->peer_ppet.ru_bit_mask =
2187                         (he_cap->ppe_thres[0] &
2188                          IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
2189                         IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
2190
2191                 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
2192                         for (ru = 0; ru < 4; ru++) {
2193                                 u32 val = 0;
2194                                 int i;
2195
2196                                 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
2197                                         continue;
2198                                 for (i = 0; i < 6; i++) {
2199                                         val >>= 1;
2200                                         val |= ((he_cap->ppe_thres[bit / 8] >>
2201                                                  (bit % 8)) & 0x1) << 5;
2202                                         bit++;
2203                                 }
2204                                 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
2205                                                                 val << (ru * 6);
2206                         }
2207                 }
2208         }
2209
2210         if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
2211                 arg->twt_responder = true;
2212         if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
2213                 arg->twt_requester = true;
2214
2215         he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
2216
2217         if (he_nss > sta->deflink.rx_nss) {
2218                 user_rate_valid = false;
2219                 for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2220                         if (he_mcs_mask[nss_idx]) {
2221                                 user_rate_valid = true;
2222                                 break;
2223                         }
2224                 }
2225         }
2226
2227         if (!user_rate_valid) {
2228                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting he range mcs value to peer supported nss %d for peer %pM\n",
2229                            sta->deflink.rx_nss, sta->addr);
2230                 he_mcs_mask[sta->deflink.rx_nss - 1] = he_mcs_mask[he_nss - 1];
2231         }
2232
2233         switch (sta->deflink.bandwidth) {
2234         case IEEE80211_STA_RX_BW_160:
2235                 if (he_cap->he_cap_elem.phy_cap_info[0] &
2236                     IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2237                         v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
2238                         v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2239                         arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2240
2241                         v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
2242                         arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2243
2244                         arg->peer_he_mcs_count++;
2245                         he_tx_mcs = v;
2246                 }
2247                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2248                 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2249
2250                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
2251                 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2252                 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2253
2254                 arg->peer_he_mcs_count++;
2255                 if (!he_tx_mcs)
2256                         he_tx_mcs = v;
2257                 fallthrough;
2258
2259         default:
2260                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2261                 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2262
2263                 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
2264                 v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2265                 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2266
2267                 arg->peer_he_mcs_count++;
2268                 if (!he_tx_mcs)
2269                         he_tx_mcs = v;
2270                 break;
2271         }
2272
2273         /* Calculate peer NSS capability from HE capabilities if STA
2274          * supports HE.
2275          */
2276         for (i = 0, max_nss = 0; i < NL80211_HE_NSS_MAX; i++) {
2277                 he_mcs = he_tx_mcs >> (2 * i) & 3;
2278
2279                 /* In case of fixed rates, MCS Range in he_tx_mcs might have
2280                  * unsupported range, with he_mcs_mask set, so check either of them
2281                  * to find nss.
2282                  */
2283                 if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
2284                     he_mcs_mask[i])
2285                         max_nss = i + 1;
2286         }
2287         arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2288
2289         if (arg->peer_phymode == MODE_11AX_HE160 ||
2290             arg->peer_phymode == MODE_11AX_HE80_80) {
2291                 tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2292                 rx_nss = min(arg->peer_nss, tx_nss);
2293                 arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2294
2295                 if (!rx_nss) {
2296                         ath11k_warn(ar->ab, "invalid max_nss\n");
2297                         return;
2298                 }
2299
2300                 if (arg->peer_phymode == MODE_11AX_HE160)
2301                         nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2302                 else
2303                         nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2304
2305                 arg->peer_bw_rxnss_override |= nss_160;
2306         }
2307
2308         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2309                    "mac he peer %pM nss %d mcs cnt %d nss_override 0x%x\n",
2310                    sta->addr, arg->peer_nss,
2311                    arg->peer_he_mcs_count,
2312                    arg->peer_bw_rxnss_override);
2313 }
2314
2315 static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar,
2316                                         struct ieee80211_vif *vif,
2317                                         struct ieee80211_sta *sta,
2318                                         struct peer_assoc_params *arg)
2319 {
2320         const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2321         struct cfg80211_chan_def def;
2322         enum nl80211_band band;
2323         u8  ampdu_factor;
2324
2325         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2326                 return;
2327
2328         band = def.chan->band;
2329
2330         if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->deflink.he_6ghz_capa.capa)
2331                 return;
2332
2333         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2334                 arg->bw_40 = true;
2335
2336         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2337                 arg->bw_80 = true;
2338
2339         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2340                 arg->bw_160 = true;
2341
2342         arg->peer_he_caps_6ghz = le16_to_cpu(sta->deflink.he_6ghz_capa.capa);
2343         arg->peer_mpdu_density =
2344                 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
2345                                                    arg->peer_he_caps_6ghz));
2346
2347         /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
2348          * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
2349          * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
2350          * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
2351          * Band Capabilities element in the 6 GHz band.
2352          *
2353          * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
2354          * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
2355          */
2356         ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
2357                                  he_cap->he_cap_elem.mac_cap_info[3]) +
2358                         FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
2359                                   arg->peer_he_caps_6ghz);
2360
2361         arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
2362                                      ampdu_factor)) - 1;
2363 }
2364
2365 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
2366                                      struct peer_assoc_params *arg)
2367 {
2368         const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2369         int smps;
2370
2371         if (!ht_cap->ht_supported && !sta->deflink.he_6ghz_capa.capa)
2372                 return;
2373
2374         if (ht_cap->ht_supported) {
2375                 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2376                 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2377         } else {
2378                 smps = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
2379                                      IEEE80211_HE_6GHZ_CAP_SM_PS);
2380         }
2381
2382         switch (smps) {
2383         case WLAN_HT_CAP_SM_PS_STATIC:
2384                 arg->static_mimops_flag = true;
2385                 break;
2386         case WLAN_HT_CAP_SM_PS_DYNAMIC:
2387                 arg->dynamic_mimops_flag = true;
2388                 break;
2389         case WLAN_HT_CAP_SM_PS_DISABLED:
2390                 arg->spatial_mux_flag = true;
2391                 break;
2392         default:
2393                 break;
2394         }
2395 }
2396
2397 static void ath11k_peer_assoc_h_qos(struct ath11k *ar,
2398                                     struct ieee80211_vif *vif,
2399                                     struct ieee80211_sta *sta,
2400                                     struct peer_assoc_params *arg)
2401 {
2402         struct ath11k_vif *arvif = (void *)vif->drv_priv;
2403
2404         switch (arvif->vdev_type) {
2405         case WMI_VDEV_TYPE_AP:
2406                 if (sta->wme) {
2407                         /* TODO: Check WME vs QoS */
2408                         arg->is_wme_set = true;
2409                         arg->qos_flag = true;
2410                 }
2411
2412                 if (sta->wme && sta->uapsd_queues) {
2413                         /* TODO: Check WME vs QoS */
2414                         arg->is_wme_set = true;
2415                         arg->apsd_flag = true;
2416                         arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
2417                 }
2418                 break;
2419         case WMI_VDEV_TYPE_STA:
2420                 if (sta->wme) {
2421                         arg->is_wme_set = true;
2422                         arg->qos_flag = true;
2423                 }
2424                 break;
2425         default:
2426                 break;
2427         }
2428
2429         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM qos %d\n",
2430                    sta->addr, arg->qos_flag);
2431 }
2432
2433 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar,
2434                                     struct ath11k_vif *arvif,
2435                                     struct ieee80211_sta *sta)
2436 {
2437         struct ap_ps_params params;
2438         u32 max_sp;
2439         u32 uapsd;
2440         int ret;
2441
2442         lockdep_assert_held(&ar->conf_mutex);
2443
2444         params.vdev_id = arvif->vdev_id;
2445
2446         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2447                    sta->uapsd_queues, sta->max_sp);
2448
2449         uapsd = 0;
2450         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2451                 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2452                          WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2453         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2454                 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2455                          WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2456         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2457                 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2458                          WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2459         if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2460                 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2461                          WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2462
2463         max_sp = 0;
2464         if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2465                 max_sp = sta->max_sp;
2466
2467         params.param = WMI_AP_PS_PEER_PARAM_UAPSD;
2468         params.value = uapsd;
2469         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2470         if (ret)
2471                 goto err;
2472
2473         params.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
2474         params.value = max_sp;
2475         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2476         if (ret)
2477                 goto err;
2478
2479         /* TODO revisit during testing */
2480         params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
2481         params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2482         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2483         if (ret)
2484                 goto err;
2485
2486         params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
2487         params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2488         ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2489         if (ret)
2490                 goto err;
2491
2492         return 0;
2493
2494 err:
2495         ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
2496                     params.param, arvif->vdev_id, ret);
2497         return ret;
2498 }
2499
2500 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2501 {
2502         return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2503                ATH11K_MAC_FIRST_OFDM_RATE_IDX;
2504 }
2505
2506 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar,
2507                                                     struct ieee80211_sta *sta)
2508 {
2509         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2510                 switch (sta->deflink.vht_cap.cap &
2511                         IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2512                 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2513                         return MODE_11AC_VHT160;
2514                 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2515                         return MODE_11AC_VHT80_80;
2516                 default:
2517                         /* not sure if this is a valid case? */
2518                         return MODE_11AC_VHT160;
2519                 }
2520         }
2521
2522         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2523                 return MODE_11AC_VHT80;
2524
2525         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2526                 return MODE_11AC_VHT40;
2527
2528         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2529                 return MODE_11AC_VHT20;
2530
2531         return MODE_UNKNOWN;
2532 }
2533
2534 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar,
2535                                                    struct ieee80211_sta *sta)
2536 {
2537         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2538                 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2539                      IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
2540                         return MODE_11AX_HE160;
2541                 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2542                          IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
2543                         return MODE_11AX_HE80_80;
2544                 /* not sure if this is a valid case? */
2545                 return MODE_11AX_HE160;
2546         }
2547
2548         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2549                 return MODE_11AX_HE80;
2550
2551         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2552                 return MODE_11AX_HE40;
2553
2554         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2555                 return MODE_11AX_HE20;
2556
2557         return MODE_UNKNOWN;
2558 }
2559
2560 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar,
2561                                         struct ieee80211_vif *vif,
2562                                         struct ieee80211_sta *sta,
2563                                         struct peer_assoc_params *arg)
2564 {
2565         struct ath11k_vif *arvif = (void *)vif->drv_priv;
2566         struct cfg80211_chan_def def;
2567         enum nl80211_band band;
2568         const u8 *ht_mcs_mask;
2569         const u16 *vht_mcs_mask;
2570         const u16 *he_mcs_mask;
2571         enum wmi_phy_mode phymode = MODE_UNKNOWN;
2572
2573         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2574                 return;
2575
2576         band = def.chan->band;
2577         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2578         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2579         he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2580
2581         switch (band) {
2582         case NL80211_BAND_2GHZ:
2583                 if (sta->deflink.he_cap.has_he &&
2584                     !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2585                         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2586                                 phymode = MODE_11AX_HE80_2G;
2587                         else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2588                                 phymode = MODE_11AX_HE40_2G;
2589                         else
2590                                 phymode = MODE_11AX_HE20_2G;
2591                 } else if (sta->deflink.vht_cap.vht_supported &&
2592                            !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2593                         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2594                                 phymode = MODE_11AC_VHT40;
2595                         else
2596                                 phymode = MODE_11AC_VHT20;
2597                 } else if (sta->deflink.ht_cap.ht_supported &&
2598                            !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2599                         if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2600                                 phymode = MODE_11NG_HT40;
2601                         else
2602                                 phymode = MODE_11NG_HT20;
2603                 } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
2604                         phymode = MODE_11G;
2605                 } else {
2606                         phymode = MODE_11B;
2607                 }
2608                 break;
2609         case NL80211_BAND_5GHZ:
2610         case NL80211_BAND_6GHZ:
2611                 /* Check HE first */
2612                 if (sta->deflink.he_cap.has_he &&
2613                     !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2614                         phymode = ath11k_mac_get_phymode_he(ar, sta);
2615                 } else if (sta->deflink.vht_cap.vht_supported &&
2616                            !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2617                         phymode = ath11k_mac_get_phymode_vht(ar, sta);
2618                 } else if (sta->deflink.ht_cap.ht_supported &&
2619                            !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2620                         if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2621                                 phymode = MODE_11NA_HT40;
2622                         else
2623                                 phymode = MODE_11NA_HT20;
2624                 } else {
2625                         phymode = MODE_11A;
2626                 }
2627                 break;
2628         default:
2629                 break;
2630         }
2631
2632         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM phymode %s\n",
2633                    sta->addr, ath11k_wmi_phymode_str(phymode));
2634
2635         arg->peer_phymode = phymode;
2636         WARN_ON(phymode == MODE_UNKNOWN);
2637 }
2638
2639 static void ath11k_peer_assoc_prepare(struct ath11k *ar,
2640                                       struct ieee80211_vif *vif,
2641                                       struct ieee80211_sta *sta,
2642                                       struct peer_assoc_params *arg,
2643                                       bool reassoc)
2644 {
2645         struct ath11k_sta *arsta;
2646
2647         lockdep_assert_held(&ar->conf_mutex);
2648
2649         arsta = (struct ath11k_sta *)sta->drv_priv;
2650
2651         memset(arg, 0, sizeof(*arg));
2652
2653         reinit_completion(&ar->peer_assoc_done);
2654
2655         arg->peer_new_assoc = !reassoc;
2656         ath11k_peer_assoc_h_basic(ar, vif, sta, arg);
2657         ath11k_peer_assoc_h_crypto(ar, vif, sta, arg);
2658         ath11k_peer_assoc_h_rates(ar, vif, sta, arg);
2659         ath11k_peer_assoc_h_phymode(ar, vif, sta, arg);
2660         ath11k_peer_assoc_h_ht(ar, vif, sta, arg);
2661         ath11k_peer_assoc_h_vht(ar, vif, sta, arg);
2662         ath11k_peer_assoc_h_he(ar, vif, sta, arg);
2663         ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg);
2664         ath11k_peer_assoc_h_qos(ar, vif, sta, arg);
2665         ath11k_peer_assoc_h_smps(sta, arg);
2666
2667         arsta->peer_nss = arg->peer_nss;
2668
2669         /* TODO: amsdu_disable req? */
2670 }
2671
2672 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif,
2673                                   const u8 *addr,
2674                                   const struct ieee80211_sta_ht_cap *ht_cap,
2675                                   u16 he_6ghz_capa)
2676 {
2677         int smps;
2678
2679         if (!ht_cap->ht_supported && !he_6ghz_capa)
2680                 return 0;
2681
2682         if (ht_cap->ht_supported) {
2683                 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2684                 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2685         } else {
2686                 smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa);
2687         }
2688
2689         if (smps >= ARRAY_SIZE(ath11k_smps_map))
2690                 return -EINVAL;
2691
2692         return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
2693                                          WMI_PEER_MIMO_PS_STATE,
2694                                          ath11k_smps_map[smps]);
2695 }
2696
2697 static void ath11k_bss_assoc(struct ieee80211_hw *hw,
2698                              struct ieee80211_vif *vif,
2699                              struct ieee80211_bss_conf *bss_conf)
2700 {
2701         struct ath11k *ar = hw->priv;
2702         struct ath11k_vif *arvif = (void *)vif->drv_priv;
2703         struct peer_assoc_params peer_arg;
2704         struct ieee80211_sta *ap_sta;
2705         struct ath11k_peer *peer;
2706         bool is_auth = false;
2707         int ret;
2708
2709         lockdep_assert_held(&ar->conf_mutex);
2710
2711         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2712                    arvif->vdev_id, arvif->bssid, arvif->aid);
2713
2714         rcu_read_lock();
2715
2716         ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2717         if (!ap_sta) {
2718                 ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
2719                             bss_conf->bssid, arvif->vdev_id);
2720                 rcu_read_unlock();
2721                 return;
2722         }
2723
2724         ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);
2725
2726         rcu_read_unlock();
2727
2728         peer_arg.is_assoc = true;
2729         ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
2730         if (ret) {
2731                 ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
2732                             bss_conf->bssid, arvif->vdev_id, ret);
2733                 return;
2734         }
2735
2736         if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
2737                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
2738                             bss_conf->bssid, arvif->vdev_id);
2739                 return;
2740         }
2741
2742         ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid,
2743                                      &ap_sta->deflink.ht_cap,
2744                                      le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa));
2745         if (ret) {
2746                 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
2747                             arvif->vdev_id, ret);
2748                 return;
2749         }
2750
2751         WARN_ON(arvif->is_up);
2752
2753         arvif->aid = vif->cfg.aid;
2754         ether_addr_copy(arvif->bssid, bss_conf->bssid);
2755
2756         ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2757         if (ret) {
2758                 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
2759                             arvif->vdev_id, ret);
2760                 return;
2761         }
2762
2763         arvif->is_up = true;
2764         arvif->rekey_data.enable_offload = false;
2765
2766         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2767                    "mac vdev %d up (associated) bssid %pM aid %d\n",
2768                    arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
2769
2770         spin_lock_bh(&ar->ab->base_lock);
2771
2772         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
2773         if (peer && peer->is_authorized)
2774                 is_auth = true;
2775
2776         spin_unlock_bh(&ar->ab->base_lock);
2777
2778         if (is_auth) {
2779                 ret = ath11k_wmi_set_peer_param(ar, arvif->bssid,
2780                                                 arvif->vdev_id,
2781                                                 WMI_PEER_AUTHORIZE,
2782                                                 1);
2783                 if (ret)
2784                         ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
2785         }
2786
2787         ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
2788                                            &bss_conf->he_obss_pd);
2789         if (ret)
2790                 ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
2791                             arvif->vdev_id, ret);
2792
2793         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2794                                             WMI_VDEV_PARAM_DTIM_POLICY,
2795                                             WMI_DTIM_POLICY_STICK);
2796         if (ret)
2797                 ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n",
2798                             arvif->vdev_id, ret);
2799
2800         ath11k_mac_11d_scan_stop_all(ar->ab);
2801 }
2802
2803 static void ath11k_bss_disassoc(struct ieee80211_hw *hw,
2804                                 struct ieee80211_vif *vif)
2805 {
2806         struct ath11k *ar = hw->priv;
2807         struct ath11k_vif *arvif = (void *)vif->drv_priv;
2808         int ret;
2809
2810         lockdep_assert_held(&ar->conf_mutex);
2811
2812         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2813                    arvif->vdev_id, arvif->bssid);
2814
2815         ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
2816         if (ret)
2817                 ath11k_warn(ar->ab, "failed to down vdev %i: %d\n",
2818                             arvif->vdev_id, ret);
2819
2820         arvif->is_up = false;
2821
2822         memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data));
2823
2824         cancel_delayed_work_sync(&arvif->connection_loss_work);
2825 }
2826
2827 static u32 ath11k_mac_get_rate_hw_value(int bitrate)
2828 {
2829         u32 preamble;
2830         u16 hw_value;
2831         int rate;
2832         size_t i;
2833
2834         if (ath11k_mac_bitrate_is_cck(bitrate))
2835                 preamble = WMI_RATE_PREAMBLE_CCK;
2836         else
2837                 preamble = WMI_RATE_PREAMBLE_OFDM;
2838
2839         for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) {
2840                 if (ath11k_legacy_rates[i].bitrate != bitrate)
2841                         continue;
2842
2843                 hw_value = ath11k_legacy_rates[i].hw_value;
2844                 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
2845
2846                 return rate;
2847         }
2848
2849         return -EINVAL;
2850 }
2851
2852 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar,
2853                                          struct ieee80211_vif *vif,
2854                                          struct cfg80211_chan_def *def)
2855 {
2856         struct ath11k_vif *arvif = (void *)vif->drv_priv;
2857         const struct ieee80211_supported_band *sband;
2858         u8 basic_rate_idx;
2859         int hw_rate_code;
2860         u32 vdev_param;
2861         u16 bitrate;
2862         int ret;
2863
2864         lockdep_assert_held(&ar->conf_mutex);
2865
2866         sband = ar->hw->wiphy->bands[def->chan->band];
2867         basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
2868         bitrate = sband->bitrates[basic_rate_idx].bitrate;
2869
2870         hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate);
2871         if (hw_rate_code < 0) {
2872                 ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
2873                 return;
2874         }
2875
2876         vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
2877         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
2878                                             hw_rate_code);
2879         if (ret)
2880                 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
2881
2882         /* For WCN6855, firmware will clear this param when vdev starts, hence
2883          * cache it here so that we can reconfigure it once vdev starts.
2884          */
2885         ar->hw_rate_code = hw_rate_code;
2886
2887         vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
2888         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
2889                                             hw_rate_code);
2890         if (ret)
2891                 ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
2892 }
2893
2894 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif,
2895                                      struct ieee80211_bss_conf *info)
2896 {
2897         struct ath11k *ar = arvif->ar;
2898         struct sk_buff *tmpl;
2899         int ret;
2900         u32 interval;
2901         bool unsol_bcast_probe_resp_enabled = false;
2902
2903         if (info->fils_discovery.max_interval) {
2904                 interval = info->fils_discovery.max_interval;
2905
2906                 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
2907                 if (tmpl)
2908                         ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
2909                                                              tmpl);
2910         } else if (info->unsol_bcast_probe_resp_interval) {
2911                 unsol_bcast_probe_resp_enabled = 1;
2912                 interval = info->unsol_bcast_probe_resp_interval;
2913
2914                 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
2915                                                                  arvif->vif);
2916                 if (tmpl)
2917                         ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
2918                                                          tmpl);
2919         } else { /* Disable */
2920                 return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
2921         }
2922
2923         if (!tmpl) {
2924                 ath11k_warn(ar->ab,
2925                             "mac vdev %i failed to retrieve %s template\n",
2926                             arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
2927                             "unsolicited broadcast probe response" :
2928                             "FILS discovery"));
2929                 return -EPERM;
2930         }
2931         kfree_skb(tmpl);
2932
2933         if (!ret)
2934                 ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
2935                                                 unsol_bcast_probe_resp_enabled);
2936
2937         return ret;
2938 }
2939
2940 static int ath11k_mac_config_obss_pd(struct ath11k *ar,
2941                                      struct ieee80211_he_obss_pd *he_obss_pd)
2942 {
2943         u32 bitmap[2], param_id, param_val, pdev_id;
2944         int ret;
2945         s8 non_srg_th = 0, srg_th = 0;
2946
2947         pdev_id = ar->pdev->pdev_id;
2948
2949         /* Set and enable SRG/non-SRG OBSS PD Threshold */
2950         param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD;
2951         if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
2952                 ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id);
2953                 if (ret)
2954                         ath11k_warn(ar->ab,
2955                                     "failed to set obss_pd_threshold for pdev: %u\n",
2956                                     pdev_id);
2957                 return ret;
2958         }
2959
2960         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2961                    "mac obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n",
2962                    he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset,
2963                    he_obss_pd->max_offset);
2964
2965         param_val = 0;
2966
2967         if (he_obss_pd->sr_ctrl &
2968             IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) {
2969                 non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD;
2970         } else {
2971                 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
2972                         non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD +
2973                                       he_obss_pd->non_srg_max_offset);
2974                 else
2975                         non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD;
2976
2977                 param_val |= ATH11K_OBSS_PD_NON_SRG_EN;
2978         }
2979
2980         if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) {
2981                 srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset;
2982                 param_val |= ATH11K_OBSS_PD_SRG_EN;
2983         }
2984
2985         if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
2986                      ar->ab->wmi_ab.svc_map)) {
2987                 param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM;
2988                 param_val |= FIELD_PREP(GENMASK(15, 8), srg_th);
2989         } else {
2990                 non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR;
2991                 /* SRG not supported and threshold in dB */
2992                 param_val &= ~(ATH11K_OBSS_PD_SRG_EN |
2993                                ATH11K_OBSS_PD_THRESHOLD_IN_DBM);
2994         }
2995
2996         param_val |= (non_srg_th & GENMASK(7, 0));
2997         ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
2998         if (ret) {
2999                 ath11k_warn(ar->ab,
3000                             "failed to set obss_pd_threshold for pdev: %u\n",
3001                             pdev_id);
3002                 return ret;
3003         }
3004
3005         /* Enable OBSS PD for all access category */
3006         param_id  = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC;
3007         param_val = 0xf;
3008         ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3009         if (ret) {
3010                 ath11k_warn(ar->ab,
3011                             "failed to set obss_pd_per_ac for pdev: %u\n",
3012                             pdev_id);
3013                 return ret;
3014         }
3015
3016         /* Set SR Prohibit */
3017         param_id  = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT;
3018         param_val = !!(he_obss_pd->sr_ctrl &
3019                        IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED);
3020         ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3021         if (ret) {
3022                 ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n",
3023                             pdev_id);
3024                 return ret;
3025         }
3026
3027         if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3028                       ar->ab->wmi_ab.svc_map))
3029                 return 0;
3030
3031         /* Set SRG BSS Color Bitmap */
3032         memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));
3033         ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap);
3034         if (ret) {
3035                 ath11k_warn(ar->ab,
3036                             "failed to set bss_color_bitmap for pdev: %u\n",
3037                             pdev_id);
3038                 return ret;
3039         }
3040
3041         /* Set SRG Partial BSSID Bitmap */
3042         memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));
3043         ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap);
3044         if (ret) {
3045                 ath11k_warn(ar->ab,
3046                             "failed to set partial_bssid_bitmap for pdev: %u\n",
3047                             pdev_id);
3048                 return ret;
3049         }
3050
3051         memset(bitmap, 0xff, sizeof(bitmap));
3052
3053         /* Enable all BSS Colors for SRG */
3054         ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap);
3055         if (ret) {
3056                 ath11k_warn(ar->ab,
3057                             "failed to set srg_color_en_bitmap pdev: %u\n",
3058                             pdev_id);
3059                 return ret;
3060         }
3061
3062         /* Enable all patial BSSID mask for SRG */
3063         ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap);
3064         if (ret) {
3065                 ath11k_warn(ar->ab,
3066                             "failed to set srg_bssid_en_bitmap pdev: %u\n",
3067                             pdev_id);
3068                 return ret;
3069         }
3070
3071         /* Enable all BSS Colors for non-SRG */
3072         ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap);
3073         if (ret) {
3074                 ath11k_warn(ar->ab,
3075                             "failed to set non_srg_color_en_bitmap pdev: %u\n",
3076                             pdev_id);
3077                 return ret;
3078         }
3079
3080         /* Enable all patial BSSID mask for non-SRG */
3081         ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap);
3082         if (ret) {
3083                 ath11k_warn(ar->ab,
3084                             "failed to set non_srg_bssid_en_bitmap pdev: %u\n",
3085                             pdev_id);
3086                 return ret;
3087         }
3088
3089         return 0;
3090 }
3091
3092 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw,
3093                                            struct ieee80211_vif *vif,
3094                                            struct ieee80211_bss_conf *info,
3095                                            u64 changed)
3096 {
3097         struct ath11k *ar = hw->priv;
3098         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3099         struct cfg80211_chan_def def;
3100         u32 param_id, param_value;
3101         enum nl80211_band band;
3102         u32 vdev_param;
3103         int mcast_rate;
3104         u32 preamble;
3105         u16 hw_value;
3106         u16 bitrate;
3107         int ret = 0;
3108         u8 rateidx;
3109         u32 rate;
3110         u32 ipv4_cnt;
3111
3112         mutex_lock(&ar->conf_mutex);
3113
3114         if (changed & BSS_CHANGED_BEACON_INT) {
3115                 arvif->beacon_interval = info->beacon_int;
3116
3117                 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL;
3118                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3119                                                     param_id,
3120                                                     arvif->beacon_interval);
3121                 if (ret)
3122                         ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n",
3123                                     arvif->vdev_id);
3124                 else
3125                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3126                                    "Beacon interval: %d set for VDEV: %d\n",
3127                                    arvif->beacon_interval, arvif->vdev_id);
3128         }
3129
3130         if (changed & BSS_CHANGED_BEACON) {
3131                 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE;
3132                 param_value = WMI_BEACON_STAGGERED_MODE;
3133                 ret = ath11k_wmi_pdev_set_param(ar, param_id,
3134                                                 param_value, ar->pdev->pdev_id);
3135                 if (ret)
3136                         ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n",
3137                                     arvif->vdev_id);
3138                 else
3139                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3140                                    "Set staggered beacon mode for VDEV: %d\n",
3141                                    arvif->vdev_id);
3142
3143                 if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) {
3144                         ret = ath11k_mac_setup_bcn_tmpl(arvif);
3145                         if (ret)
3146                                 ath11k_warn(ar->ab, "failed to update bcn template: %d\n",
3147                                             ret);
3148                 }
3149
3150                 if (arvif->bcca_zero_sent)
3151                         arvif->do_not_send_tmpl = true;
3152                 else
3153                         arvif->do_not_send_tmpl = false;
3154
3155                 if (vif->bss_conf.he_support) {
3156                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3157                                                             WMI_VDEV_PARAM_BA_MODE,
3158                                                             WMI_BA_MODE_BUFFER_SIZE_256);
3159                         if (ret)
3160                                 ath11k_warn(ar->ab,
3161                                             "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
3162                                             arvif->vdev_id);
3163                         else
3164                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3165                                            "Set BA BUFFER SIZE 256 for VDEV: %d\n",
3166                                            arvif->vdev_id);
3167                 }
3168         }
3169
3170         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3171                 arvif->dtim_period = info->dtim_period;
3172
3173                 param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
3174                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3175                                                     param_id,
3176                                                     arvif->dtim_period);
3177
3178                 if (ret)
3179                         ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
3180                                     arvif->vdev_id, ret);
3181                 else
3182                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3183                                    "DTIM period: %d set for VDEV: %d\n",
3184                                    arvif->dtim_period, arvif->vdev_id);
3185         }
3186
3187         if (changed & BSS_CHANGED_SSID &&
3188             vif->type == NL80211_IFTYPE_AP) {
3189                 arvif->u.ap.ssid_len = vif->cfg.ssid_len;
3190                 if (vif->cfg.ssid_len)
3191                         memcpy(arvif->u.ap.ssid, vif->cfg.ssid,
3192                                vif->cfg.ssid_len);
3193                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3194         }
3195
3196         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3197                 ether_addr_copy(arvif->bssid, info->bssid);
3198
3199         if (changed & BSS_CHANGED_BEACON_ENABLED) {
3200                 ath11k_control_beaconing(arvif, info);
3201
3202                 if (arvif->is_up && vif->bss_conf.he_support &&
3203                     vif->bss_conf.he_oper.params) {
3204                         param_id = WMI_VDEV_PARAM_HEOPS_0_31;
3205                         param_value = vif->bss_conf.he_oper.params;
3206                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3207                                                             param_id, param_value);
3208                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3209                                    "he oper param: %x set for VDEV: %d\n",
3210                                    param_value, arvif->vdev_id);
3211
3212                         if (ret)
3213                                 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
3214                                             param_value, arvif->vdev_id, ret);
3215                 }
3216         }
3217
3218         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3219                 u32 cts_prot;
3220
3221                 cts_prot = !!(info->use_cts_prot);
3222                 param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
3223
3224                 if (arvif->is_started) {
3225                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3226                                                             param_id, cts_prot);
3227                         if (ret)
3228                                 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
3229                                             arvif->vdev_id);
3230                         else
3231                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
3232                                            cts_prot, arvif->vdev_id);
3233                 } else {
3234                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
3235                 }
3236         }
3237
3238         if (changed & BSS_CHANGED_ERP_SLOT) {
3239                 u32 slottime;
3240
3241                 if (info->use_short_slot)
3242                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3243
3244                 else
3245                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3246
3247                 param_id = WMI_VDEV_PARAM_SLOT_TIME;
3248                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3249                                                     param_id, slottime);
3250                 if (ret)
3251                         ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
3252                                     arvif->vdev_id);
3253                 else
3254                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3255                                    "Set slottime: %d for VDEV: %d\n",
3256                                    slottime, arvif->vdev_id);
3257         }
3258
3259         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3260                 u32 preamble;
3261
3262                 if (info->use_short_preamble)
3263                         preamble = WMI_VDEV_PREAMBLE_SHORT;
3264                 else
3265                         preamble = WMI_VDEV_PREAMBLE_LONG;
3266
3267                 param_id = WMI_VDEV_PARAM_PREAMBLE;
3268                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3269                                                     param_id, preamble);
3270                 if (ret)
3271                         ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
3272                                     arvif->vdev_id);
3273                 else
3274                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3275                                    "Set preamble: %d for VDEV: %d\n",
3276                                    preamble, arvif->vdev_id);
3277         }
3278
3279         if (changed & BSS_CHANGED_ASSOC) {
3280                 if (vif->cfg.assoc)
3281                         ath11k_bss_assoc(hw, vif, info);
3282                 else
3283                         ath11k_bss_disassoc(hw, vif);
3284         }
3285
3286         if (changed & BSS_CHANGED_TXPOWER) {
3287                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3288                            arvif->vdev_id, info->txpower);
3289
3290                 arvif->txpower = info->txpower;
3291                 ath11k_mac_txpower_recalc(ar);
3292         }
3293
3294         if (changed & BSS_CHANGED_PS &&
3295             ar->ab->hw_params.supports_sta_ps) {
3296                 arvif->ps = vif->cfg.ps;
3297
3298                 ret = ath11k_mac_config_ps(ar);
3299                 if (ret)
3300                         ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n",
3301                                     arvif->vdev_id, ret);
3302         }
3303
3304         if (changed & BSS_CHANGED_MCAST_RATE &&
3305             !ath11k_mac_vif_chan(arvif->vif, &def)) {
3306                 band = def.chan->band;
3307                 mcast_rate = vif->bss_conf.mcast_rate[band];
3308
3309                 if (mcast_rate > 0)
3310                         rateidx = mcast_rate - 1;
3311                 else
3312                         rateidx = ffs(vif->bss_conf.basic_rates) - 1;
3313
3314                 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
3315                         rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
3316
3317                 bitrate = ath11k_legacy_rates[rateidx].bitrate;
3318                 hw_value = ath11k_legacy_rates[rateidx].hw_value;
3319
3320                 if (ath11k_mac_bitrate_is_cck(bitrate))
3321                         preamble = WMI_RATE_PREAMBLE_CCK;
3322                 else
3323                         preamble = WMI_RATE_PREAMBLE_OFDM;
3324
3325                 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3326
3327                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3328                            "mac vdev %d mcast_rate %x\n",
3329                            arvif->vdev_id, rate);
3330
3331                 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
3332                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3333                                                     vdev_param, rate);
3334                 if (ret)
3335                         ath11k_warn(ar->ab,
3336                                     "failed to set mcast rate on vdev %i: %d\n",
3337                                     arvif->vdev_id,  ret);
3338
3339                 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
3340                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3341                                                     vdev_param, rate);
3342                 if (ret)
3343                         ath11k_warn(ar->ab,
3344                                     "failed to set bcast rate on vdev %i: %d\n",
3345                                     arvif->vdev_id,  ret);
3346         }
3347
3348         if (changed & BSS_CHANGED_BASIC_RATES &&
3349             !ath11k_mac_vif_chan(arvif->vif, &def))
3350                 ath11k_recalculate_mgmt_rate(ar, vif, &def);
3351
3352         if (changed & BSS_CHANGED_TWT) {
3353                 if (info->twt_requester || info->twt_responder)
3354                         ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id);
3355                 else
3356                         ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
3357         }
3358
3359         if (changed & BSS_CHANGED_HE_OBSS_PD)
3360                 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd);
3361
3362         if (changed & BSS_CHANGED_HE_BSS_COLOR) {
3363                 if (vif->type == NL80211_IFTYPE_AP) {
3364                         ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3365                                 ar, arvif->vdev_id, info->he_bss_color.color,
3366                                 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS,
3367                                 info->he_bss_color.enabled);
3368                         if (ret)
3369                                 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3370                                             arvif->vdev_id,  ret);
3371
3372                         param_id = WMI_VDEV_PARAM_BSS_COLOR;
3373                         if (info->he_bss_color.enabled)
3374                                 param_value = info->he_bss_color.color <<
3375                                                 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET;
3376                         else
3377                                 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED;
3378
3379                         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3380                                                             param_id,
3381                                                             param_value);
3382                         if (ret)
3383                                 ath11k_warn(ar->ab,
3384                                             "failed to set bss color param on vdev %i: %d\n",
3385                                             arvif->vdev_id,  ret);
3386
3387                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3388                                    "bss color param 0x%x set on vdev %i\n",
3389                                    param_value, arvif->vdev_id);
3390                 } else if (vif->type == NL80211_IFTYPE_STATION) {
3391                         ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar,
3392                                                                           arvif->vdev_id,
3393                                                                           1);
3394                         if (ret)
3395                                 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
3396                                             arvif->vdev_id,  ret);
3397                         ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3398                                 ar, arvif->vdev_id, 0,
3399                                 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1);
3400                         if (ret)
3401                                 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3402                                             arvif->vdev_id,  ret);
3403                 }
3404         }
3405
3406         if (changed & BSS_CHANGED_FILS_DISCOVERY ||
3407             changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
3408                 ath11k_mac_fils_discovery(arvif, info);
3409
3410         if (changed & BSS_CHANGED_ARP_FILTER) {
3411                 ipv4_cnt = min(vif->cfg.arp_addr_cnt, ATH11K_IPV4_MAX_COUNT);
3412                 memcpy(arvif->arp_ns_offload.ipv4_addr,
3413                        vif->cfg.arp_addr_list,
3414                        ipv4_cnt * sizeof(u32));
3415                 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN);
3416                 arvif->arp_ns_offload.ipv4_count = ipv4_cnt;
3417
3418                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
3419                            vif->cfg.arp_addr_cnt,
3420                            vif->addr, arvif->arp_ns_offload.ipv4_addr);
3421         }
3422
3423         mutex_unlock(&ar->conf_mutex);
3424 }
3425
3426 void __ath11k_mac_scan_finish(struct ath11k *ar)
3427 {
3428         lockdep_assert_held(&ar->data_lock);
3429
3430         switch (ar->scan.state) {
3431         case ATH11K_SCAN_IDLE:
3432                 break;
3433         case ATH11K_SCAN_RUNNING:
3434         case ATH11K_SCAN_ABORTING:
3435                 if (ar->scan.is_roc && ar->scan.roc_notify)
3436                         ieee80211_remain_on_channel_expired(ar->hw);
3437                 fallthrough;
3438         case ATH11K_SCAN_STARTING:
3439                 if (!ar->scan.is_roc) {
3440                         struct cfg80211_scan_info info = {
3441                                 .aborted = ((ar->scan.state ==
3442                                             ATH11K_SCAN_ABORTING) ||
3443                                             (ar->scan.state ==
3444                                             ATH11K_SCAN_STARTING)),
3445                         };
3446
3447                         ieee80211_scan_completed(ar->hw, &info);
3448                 }
3449
3450                 ar->scan.state = ATH11K_SCAN_IDLE;
3451                 ar->scan_channel = NULL;
3452                 ar->scan.roc_freq = 0;
3453                 cancel_delayed_work(&ar->scan.timeout);
3454                 complete(&ar->scan.completed);
3455                 break;
3456         }
3457 }
3458
3459 void ath11k_mac_scan_finish(struct ath11k *ar)
3460 {
3461         spin_lock_bh(&ar->data_lock);
3462         __ath11k_mac_scan_finish(ar);
3463         spin_unlock_bh(&ar->data_lock);
3464 }
3465
3466 static int ath11k_scan_stop(struct ath11k *ar)
3467 {
3468         struct scan_cancel_param arg = {
3469                 .req_type = WLAN_SCAN_CANCEL_SINGLE,
3470                 .scan_id = ATH11K_SCAN_ID,
3471         };
3472         int ret;
3473
3474         lockdep_assert_held(&ar->conf_mutex);
3475
3476         /* TODO: Fill other STOP Params */
3477         arg.pdev_id = ar->pdev->pdev_id;
3478
3479         ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg);
3480         if (ret) {
3481                 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
3482                 goto out;
3483         }
3484
3485         ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
3486         if (ret == 0) {
3487                 ath11k_warn(ar->ab,
3488                             "failed to receive scan abort comple: timed out\n");
3489                 ret = -ETIMEDOUT;
3490         } else if (ret > 0) {
3491                 ret = 0;
3492         }
3493
3494 out:
3495         /* Scan state should be updated upon scan completion but in case
3496          * firmware fails to deliver the event (for whatever reason) it is
3497          * desired to clean up scan state anyway. Firmware may have just
3498          * dropped the scan completion event delivery due to transport pipe
3499          * being overflown with data and/or it can recover on its own before
3500          * next scan request is submitted.
3501          */
3502         spin_lock_bh(&ar->data_lock);
3503         if (ar->scan.state != ATH11K_SCAN_IDLE)
3504                 __ath11k_mac_scan_finish(ar);
3505         spin_unlock_bh(&ar->data_lock);
3506
3507         return ret;
3508 }
3509
3510 static void ath11k_scan_abort(struct ath11k *ar)
3511 {
3512         int ret;
3513
3514         lockdep_assert_held(&ar->conf_mutex);
3515
3516         spin_lock_bh(&ar->data_lock);
3517
3518         switch (ar->scan.state) {
3519         case ATH11K_SCAN_IDLE:
3520                 /* This can happen if timeout worker kicked in and called
3521                  * abortion while scan completion was being processed.
3522                  */
3523                 break;
3524         case ATH11K_SCAN_STARTING:
3525         case ATH11K_SCAN_ABORTING:
3526                 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
3527                             ar->scan.state);
3528                 break;
3529         case ATH11K_SCAN_RUNNING:
3530                 ar->scan.state = ATH11K_SCAN_ABORTING;
3531                 spin_unlock_bh(&ar->data_lock);
3532
3533                 ret = ath11k_scan_stop(ar);
3534                 if (ret)
3535                         ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret);
3536
3537                 spin_lock_bh(&ar->data_lock);
3538                 break;
3539         }
3540
3541         spin_unlock_bh(&ar->data_lock);
3542 }
3543
3544 static void ath11k_scan_timeout_work(struct work_struct *work)
3545 {
3546         struct ath11k *ar = container_of(work, struct ath11k,
3547                                          scan.timeout.work);
3548
3549         mutex_lock(&ar->conf_mutex);
3550         ath11k_scan_abort(ar);
3551         mutex_unlock(&ar->conf_mutex);
3552 }
3553
3554 static int ath11k_start_scan(struct ath11k *ar,
3555                              struct scan_req_params *arg)
3556 {
3557         int ret;
3558         unsigned long timeout = 1 * HZ;
3559
3560         lockdep_assert_held(&ar->conf_mutex);
3561
3562         if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND)
3563                 ath11k_spectral_reset_buffer(ar);
3564
3565         ret = ath11k_wmi_send_scan_start_cmd(ar, arg);
3566         if (ret)
3567                 return ret;
3568
3569         if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) {
3570                 timeout = 5 * HZ;
3571
3572                 if (ar->supports_6ghz)
3573                         timeout += 5 * HZ;
3574         }
3575
3576         ret = wait_for_completion_timeout(&ar->scan.started, timeout);
3577         if (ret == 0) {
3578                 ret = ath11k_scan_stop(ar);
3579                 if (ret)
3580                         ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
3581
3582                 return -ETIMEDOUT;
3583         }
3584
3585         /* If we failed to start the scan, return error code at
3586          * this point.  This is probably due to some issue in the
3587          * firmware, but no need to wedge the driver due to that...
3588          */
3589         spin_lock_bh(&ar->data_lock);
3590         if (ar->scan.state == ATH11K_SCAN_IDLE) {
3591                 spin_unlock_bh(&ar->data_lock);
3592                 return -EINVAL;
3593         }
3594         spin_unlock_bh(&ar->data_lock);
3595
3596         return 0;
3597 }
3598
3599 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw,
3600                                  struct ieee80211_vif *vif,
3601                                  struct ieee80211_scan_request *hw_req)
3602 {
3603         struct ath11k *ar = hw->priv;
3604         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3605         struct cfg80211_scan_request *req = &hw_req->req;
3606         struct scan_req_params arg;
3607         int ret = 0;
3608         int i;
3609
3610         mutex_lock(&ar->conf_mutex);
3611
3612         spin_lock_bh(&ar->data_lock);
3613         switch (ar->scan.state) {
3614         case ATH11K_SCAN_IDLE:
3615                 reinit_completion(&ar->scan.started);
3616                 reinit_completion(&ar->scan.completed);
3617                 ar->scan.state = ATH11K_SCAN_STARTING;
3618                 ar->scan.is_roc = false;
3619                 ar->scan.vdev_id = arvif->vdev_id;
3620                 ret = 0;
3621                 break;
3622         case ATH11K_SCAN_STARTING:
3623         case ATH11K_SCAN_RUNNING:
3624         case ATH11K_SCAN_ABORTING:
3625                 ret = -EBUSY;
3626                 break;
3627         }
3628         spin_unlock_bh(&ar->data_lock);
3629
3630         if (ret)
3631                 goto exit;
3632
3633         memset(&arg, 0, sizeof(arg));
3634         ath11k_wmi_start_scan_init(ar, &arg);
3635         arg.vdev_id = arvif->vdev_id;
3636         arg.scan_id = ATH11K_SCAN_ID;
3637
3638         if (req->ie_len) {
3639                 arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
3640                 if (!arg.extraie.ptr) {
3641                         ret = -ENOMEM;
3642                         goto exit;
3643                 }
3644                 arg.extraie.len = req->ie_len;
3645         }
3646
3647         if (req->n_ssids) {
3648                 arg.num_ssids = req->n_ssids;
3649                 for (i = 0; i < arg.num_ssids; i++) {
3650                         arg.ssid[i].length  = req->ssids[i].ssid_len;
3651                         memcpy(&arg.ssid[i].ssid, req->ssids[i].ssid,
3652                                req->ssids[i].ssid_len);
3653                 }
3654         } else {
3655                 arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
3656         }
3657
3658         if (req->n_channels) {
3659                 arg.num_chan = req->n_channels;
3660                 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
3661                                         GFP_KERNEL);
3662
3663                 if (!arg.chan_list) {
3664                         ret = -ENOMEM;
3665                         goto exit;
3666                 }
3667
3668                 for (i = 0; i < arg.num_chan; i++)
3669                         arg.chan_list[i] = req->channels[i]->center_freq;
3670         }
3671
3672         if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
3673                 arg.scan_f_add_spoofed_mac_in_probe = 1;
3674                 ether_addr_copy(arg.mac_addr.addr, req->mac_addr);
3675                 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask);
3676         }
3677
3678         ret = ath11k_start_scan(ar, &arg);
3679         if (ret) {
3680                 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
3681                 spin_lock_bh(&ar->data_lock);
3682                 ar->scan.state = ATH11K_SCAN_IDLE;
3683                 spin_unlock_bh(&ar->data_lock);
3684         }
3685
3686         /* Add a 200ms margin to account for event/command processing */
3687         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
3688                                      msecs_to_jiffies(arg.max_scan_time +
3689                                                       ATH11K_MAC_SCAN_TIMEOUT_MSECS));
3690
3691 exit:
3692         kfree(arg.chan_list);
3693
3694         if (req->ie_len)
3695                 kfree(arg.extraie.ptr);
3696
3697         mutex_unlock(&ar->conf_mutex);
3698
3699         if (ar->state_11d == ATH11K_11D_PREPARING)
3700                 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
3701
3702         return ret;
3703 }
3704
3705 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
3706                                          struct ieee80211_vif *vif)
3707 {
3708         struct ath11k *ar = hw->priv;
3709
3710         mutex_lock(&ar->conf_mutex);
3711         ath11k_scan_abort(ar);
3712         mutex_unlock(&ar->conf_mutex);
3713
3714         cancel_delayed_work_sync(&ar->scan.timeout);
3715 }
3716
3717 static int ath11k_install_key(struct ath11k_vif *arvif,
3718                               struct ieee80211_key_conf *key,
3719                               enum set_key_cmd cmd,
3720                               const u8 *macaddr, u32 flags)
3721 {
3722         int ret;
3723         struct ath11k *ar = arvif->ar;
3724         struct wmi_vdev_install_key_arg arg = {
3725                 .vdev_id = arvif->vdev_id,
3726                 .key_idx = key->keyidx,
3727                 .key_len = key->keylen,
3728                 .key_data = key->key,
3729                 .key_flags = flags,
3730                 .macaddr = macaddr,
3731         };
3732
3733         lockdep_assert_held(&arvif->ar->conf_mutex);
3734
3735         reinit_completion(&ar->install_key_done);
3736
3737         if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3738                 return 0;
3739
3740         if (cmd == DISABLE_KEY) {
3741                 arg.key_cipher = WMI_CIPHER_NONE;
3742                 arg.key_data = NULL;
3743                 goto install;
3744         }
3745
3746         switch (key->cipher) {
3747         case WLAN_CIPHER_SUITE_CCMP:
3748                 arg.key_cipher = WMI_CIPHER_AES_CCM;
3749                 /* TODO: Re-check if flag is valid */
3750                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
3751                 break;
3752         case WLAN_CIPHER_SUITE_TKIP:
3753                 arg.key_cipher = WMI_CIPHER_TKIP;
3754                 arg.key_txmic_len = 8;
3755                 arg.key_rxmic_len = 8;
3756                 break;
3757         case WLAN_CIPHER_SUITE_CCMP_256:
3758                 arg.key_cipher = WMI_CIPHER_AES_CCM;
3759                 break;
3760         case WLAN_CIPHER_SUITE_GCMP:
3761         case WLAN_CIPHER_SUITE_GCMP_256:
3762                 arg.key_cipher = WMI_CIPHER_AES_GCM;
3763                 break;
3764         default:
3765                 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
3766                 return -EOPNOTSUPP;
3767         }
3768
3769         if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags))
3770                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
3771                               IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
3772
3773 install:
3774         ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg);
3775
3776         if (ret)
3777                 return ret;
3778
3779         if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
3780                 return -ETIMEDOUT;
3781
3782         return ar->install_key_status ? -EINVAL : 0;
3783 }
3784
3785 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif,
3786                                   const u8 *addr)
3787 {
3788         struct ath11k *ar = arvif->ar;
3789         struct ath11k_base *ab = ar->ab;
3790         struct ath11k_peer *peer;
3791         int first_errno = 0;
3792         int ret;
3793         int i;
3794         u32 flags = 0;
3795
3796         lockdep_assert_held(&ar->conf_mutex);
3797
3798         spin_lock_bh(&ab->base_lock);
3799         peer = ath11k_peer_find(ab, arvif->vdev_id, addr);
3800         spin_unlock_bh(&ab->base_lock);
3801
3802         if (!peer)
3803                 return -ENOENT;
3804
3805         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
3806                 if (!peer->keys[i])
3807                         continue;
3808
3809                 /* key flags are not required to delete the key */
3810                 ret = ath11k_install_key(arvif, peer->keys[i],
3811                                          DISABLE_KEY, addr, flags);
3812                 if (ret < 0 && first_errno == 0)
3813                         first_errno = ret;
3814
3815                 if (ret < 0)
3816                         ath11k_warn(ab, "failed to remove peer key %d: %d\n",
3817                                     i, ret);
3818
3819                 spin_lock_bh(&ab->base_lock);
3820                 peer->keys[i] = NULL;
3821                 spin_unlock_bh(&ab->base_lock);
3822         }
3823
3824         return first_errno;
3825 }
3826
3827 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3828                                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3829                                  struct ieee80211_key_conf *key)
3830 {
3831         struct ath11k *ar = hw->priv;
3832         struct ath11k_base *ab = ar->ab;
3833         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3834         struct ath11k_peer *peer;
3835         struct ath11k_sta *arsta;
3836         const u8 *peer_addr;
3837         int ret = 0;
3838         u32 flags = 0;
3839
3840         /* BIP needs to be done in software */
3841         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
3842             key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
3843             key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
3844             key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
3845                 return 1;
3846
3847         if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3848                 return 1;
3849
3850         if (key->keyidx > WMI_MAX_KEY_INDEX)
3851                 return -ENOSPC;
3852
3853         mutex_lock(&ar->conf_mutex);
3854
3855         if (sta)
3856                 peer_addr = sta->addr;
3857         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3858                 peer_addr = vif->bss_conf.bssid;
3859         else
3860                 peer_addr = vif->addr;
3861
3862         key->hw_key_idx = key->keyidx;
3863
3864         /* the peer should not disappear in mid-way (unless FW goes awry) since
3865          * we already hold conf_mutex. we just make sure its there now.
3866          */
3867         spin_lock_bh(&ab->base_lock);
3868         peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
3869
3870         /* flush the fragments cache during key (re)install to
3871          * ensure all frags in the new frag list belong to the same key.
3872          */
3873         if (peer && sta && cmd == SET_KEY)
3874                 ath11k_peer_frags_flush(ar, peer);
3875         spin_unlock_bh(&ab->base_lock);
3876
3877         if (!peer) {
3878                 if (cmd == SET_KEY) {
3879                         ath11k_warn(ab, "cannot install key for non-existent peer %pM\n",
3880                                     peer_addr);
3881                         ret = -EOPNOTSUPP;
3882                         goto exit;
3883                 } else {
3884                         /* if the peer doesn't exist there is no key to disable
3885                          * anymore
3886                          */
3887                         goto exit;
3888                 }
3889         }
3890
3891         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3892                 flags |= WMI_KEY_PAIRWISE;
3893         else
3894                 flags |= WMI_KEY_GROUP;
3895
3896         ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags);
3897         if (ret) {
3898                 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret);
3899                 goto exit;
3900         }
3901
3902         ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key);
3903         if (ret) {
3904                 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret);
3905                 goto exit;
3906         }
3907
3908         spin_lock_bh(&ab->base_lock);
3909         peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
3910         if (peer && cmd == SET_KEY) {
3911                 peer->keys[key->keyidx] = key;
3912                 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
3913                         peer->ucast_keyidx = key->keyidx;
3914                         peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher);
3915                 } else {
3916                         peer->mcast_keyidx = key->keyidx;
3917                         peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher);
3918                 }
3919         } else if (peer && cmd == DISABLE_KEY) {
3920                 peer->keys[key->keyidx] = NULL;
3921                 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3922                         peer->ucast_keyidx = 0;
3923                 else
3924                         peer->mcast_keyidx = 0;
3925         } else if (!peer)
3926                 /* impossible unless FW goes crazy */
3927                 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr);
3928
3929         if (sta) {
3930                 arsta = (struct ath11k_sta *)sta->drv_priv;
3931
3932                 switch (key->cipher) {
3933                 case WLAN_CIPHER_SUITE_TKIP:
3934                 case WLAN_CIPHER_SUITE_CCMP:
3935                 case WLAN_CIPHER_SUITE_CCMP_256:
3936                 case WLAN_CIPHER_SUITE_GCMP:
3937                 case WLAN_CIPHER_SUITE_GCMP_256:
3938                         if (cmd == SET_KEY)
3939                                 arsta->pn_type = HAL_PN_TYPE_WPA;
3940                         else
3941                                 arsta->pn_type = HAL_PN_TYPE_NONE;
3942                         break;
3943                 default:
3944                         arsta->pn_type = HAL_PN_TYPE_NONE;
3945                         break;
3946                 }
3947         }
3948
3949         spin_unlock_bh(&ab->base_lock);
3950
3951 exit:
3952         mutex_unlock(&ar->conf_mutex);
3953         return ret;
3954 }
3955
3956 static int
3957 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar,
3958                                       enum nl80211_band band,
3959                                       const struct cfg80211_bitrate_mask *mask)
3960 {
3961         int num_rates = 0;
3962         int i;
3963
3964         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
3965                 num_rates += hweight16(mask->control[band].vht_mcs[i]);
3966
3967         return num_rates;
3968 }
3969
3970 static int
3971 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar,
3972                                      enum nl80211_band band,
3973                                      const struct cfg80211_bitrate_mask *mask)
3974 {
3975         int num_rates = 0;
3976         int i;
3977
3978         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++)
3979                 num_rates += hweight16(mask->control[band].he_mcs[i]);
3980
3981         return num_rates;
3982 }
3983
3984 static int
3985 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif,
3986                                    struct ieee80211_sta *sta,
3987                                    const struct cfg80211_bitrate_mask *mask,
3988                                    enum nl80211_band band)
3989 {
3990         struct ath11k *ar = arvif->ar;
3991         u8 vht_rate, nss;
3992         u32 rate_code;
3993         int ret, i;
3994
3995         lockdep_assert_held(&ar->conf_mutex);
3996
3997         nss = 0;
3998
3999         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
4000                 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
4001                         nss = i + 1;
4002                         vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4003                 }
4004         }
4005
4006         if (!nss) {
4007                 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
4008                             sta->addr);
4009                 return -EINVAL;
4010         }
4011
4012         /* Avoid updating invalid nss as fixed rate*/
4013         if (nss > sta->deflink.rx_nss)
4014                 return -EINVAL;
4015
4016         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4017                    "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
4018                    sta->addr);
4019
4020         rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1,
4021                                         WMI_RATE_PREAMBLE_VHT);
4022         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4023                                         arvif->vdev_id,
4024                                         WMI_PEER_PARAM_FIXED_RATE,
4025                                         rate_code);
4026         if (ret)
4027                 ath11k_warn(ar->ab,
4028                             "failed to update STA %pM Fixed Rate %d: %d\n",
4029                              sta->addr, rate_code, ret);
4030
4031         return ret;
4032 }
4033
4034 static int
4035 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif,
4036                                   struct ieee80211_sta *sta,
4037                                   const struct cfg80211_bitrate_mask *mask,
4038                                   enum nl80211_band band)
4039 {
4040         struct ath11k *ar = arvif->ar;
4041         u8 he_rate, nss;
4042         u32 rate_code;
4043         int ret, i;
4044
4045         lockdep_assert_held(&ar->conf_mutex);
4046
4047         nss = 0;
4048
4049         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
4050                 if (hweight16(mask->control[band].he_mcs[i]) == 1) {
4051                         nss = i + 1;
4052                         he_rate = ffs(mask->control[band].he_mcs[i]) - 1;
4053                 }
4054         }
4055
4056         if (!nss) {
4057                 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM",
4058                             sta->addr);
4059                 return -EINVAL;
4060         }
4061
4062         /* Avoid updating invalid nss as fixed rate */
4063         if (nss > sta->deflink.rx_nss)
4064                 return -EINVAL;
4065
4066         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4067                    "mac setting fixed he rate for peer %pM, device will not switch to any other selected rates",
4068                    sta->addr);
4069
4070         rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1,
4071                                         WMI_RATE_PREAMBLE_HE);
4072
4073         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4074                                         arvif->vdev_id,
4075                                         WMI_PEER_PARAM_FIXED_RATE,
4076                                         rate_code);
4077         if (ret)
4078                 ath11k_warn(ar->ab,
4079                             "failed to update sta %pM fixed rate %d: %d\n",
4080                             sta->addr, rate_code, ret);
4081
4082         return ret;
4083 }
4084
4085 static int ath11k_station_assoc(struct ath11k *ar,
4086                                 struct ieee80211_vif *vif,
4087                                 struct ieee80211_sta *sta,
4088                                 bool reassoc)
4089 {
4090         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4091         struct peer_assoc_params peer_arg;
4092         int ret = 0;
4093         struct cfg80211_chan_def def;
4094         enum nl80211_band band;
4095         struct cfg80211_bitrate_mask *mask;
4096         u8 num_vht_rates, num_he_rates;
4097
4098         lockdep_assert_held(&ar->conf_mutex);
4099
4100         if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
4101                 return -EPERM;
4102
4103         band = def.chan->band;
4104         mask = &arvif->bitrate_mask;
4105
4106         ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
4107
4108         peer_arg.is_assoc = true;
4109         ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4110         if (ret) {
4111                 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4112                             sta->addr, arvif->vdev_id, ret);
4113                 return ret;
4114         }
4115
4116         if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4117                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4118                             sta->addr, arvif->vdev_id);
4119                 return -ETIMEDOUT;
4120         }
4121
4122         num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
4123         num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask);
4124
4125         /* If single VHT/HE rate is configured (by set_bitrate_mask()),
4126          * peer_assoc will disable VHT/HE. This is now enabled by a peer specific
4127          * fixed param.
4128          * Note that all other rates and NSS will be disabled for this peer.
4129          */
4130         if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4131                 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4132                                                          band);
4133                 if (ret)
4134                         return ret;
4135         } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4136                 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4137                                                         band);
4138                 if (ret)
4139                         return ret;
4140         }
4141
4142         /* Re-assoc is run only to update supported rates for given station. It
4143          * doesn't make much sense to reconfigure the peer completely.
4144          */
4145         if (reassoc)
4146                 return 0;
4147
4148         ret = ath11k_setup_peer_smps(ar, arvif, sta->addr,
4149                                      &sta->deflink.ht_cap,
4150                                      le16_to_cpu(sta->deflink.he_6ghz_capa.capa));
4151         if (ret) {
4152                 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
4153                             arvif->vdev_id, ret);
4154                 return ret;
4155         }
4156
4157         if (!sta->wme) {
4158                 arvif->num_legacy_stations++;
4159                 ret = ath11k_recalc_rtscts_prot(arvif);
4160                 if (ret)
4161                         return ret;
4162         }
4163
4164         if (sta->wme && sta->uapsd_queues) {
4165                 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta);
4166                 if (ret) {
4167                         ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
4168                                     sta->addr, arvif->vdev_id, ret);
4169                         return ret;
4170                 }
4171         }
4172
4173         return 0;
4174 }
4175
4176 static int ath11k_station_disassoc(struct ath11k *ar,
4177                                    struct ieee80211_vif *vif,
4178                                    struct ieee80211_sta *sta)
4179 {
4180         struct ath11k_vif *arvif = (void *)vif->drv_priv;
4181         int ret = 0;
4182
4183         lockdep_assert_held(&ar->conf_mutex);
4184
4185         if (!sta->wme) {
4186                 arvif->num_legacy_stations--;
4187                 ret = ath11k_recalc_rtscts_prot(arvif);
4188                 if (ret)
4189                         return ret;
4190         }
4191
4192         ret = ath11k_clear_peer_keys(arvif, sta->addr);
4193         if (ret) {
4194                 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
4195                             arvif->vdev_id, ret);
4196                 return ret;
4197         }
4198         return 0;
4199 }
4200
4201 static void ath11k_sta_rc_update_wk(struct work_struct *wk)
4202 {
4203         struct ath11k *ar;
4204         struct ath11k_vif *arvif;
4205         struct ath11k_sta *arsta;
4206         struct ieee80211_sta *sta;
4207         struct cfg80211_chan_def def;
4208         enum nl80211_band band;
4209         const u8 *ht_mcs_mask;
4210         const u16 *vht_mcs_mask;
4211         const u16 *he_mcs_mask;
4212         u32 changed, bw, nss, smps;
4213         int err, num_vht_rates, num_he_rates;
4214         const struct cfg80211_bitrate_mask *mask;
4215         struct peer_assoc_params peer_arg;
4216
4217         arsta = container_of(wk, struct ath11k_sta, update_wk);
4218         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4219         arvif = arsta->arvif;
4220         ar = arvif->ar;
4221
4222         if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def)))
4223                 return;
4224
4225         band = def.chan->band;
4226         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4227         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
4228         he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
4229
4230         spin_lock_bh(&ar->data_lock);
4231
4232         changed = arsta->changed;
4233         arsta->changed = 0;
4234
4235         bw = arsta->bw;
4236         nss = arsta->nss;
4237         smps = arsta->smps;
4238
4239         spin_unlock_bh(&ar->data_lock);
4240
4241         mutex_lock(&ar->conf_mutex);
4242
4243         nss = max_t(u32, 1, nss);
4244         nss = min(nss, max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
4245                                ath11k_mac_max_vht_nss(vht_mcs_mask)),
4246                            ath11k_mac_max_he_nss(he_mcs_mask)));
4247
4248         if (changed & IEEE80211_RC_BW_CHANGED) {
4249                 /* Send peer assoc command before set peer bandwidth param to
4250                  * avoid the mismatch between the peer phymode and the peer
4251                  * bandwidth.
4252                  */
4253                 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, &peer_arg, true);
4254
4255                 peer_arg.is_assoc = false;
4256                 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4257                 if (err) {
4258                         ath11k_warn(ar->ab, "failed to send peer assoc for STA %pM vdev %i: %d\n",
4259                                     sta->addr, arvif->vdev_id, err);
4260                 } else if (wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4261                         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4262                                                         WMI_PEER_CHWIDTH, bw);
4263                         if (err)
4264                                 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4265                                             sta->addr, bw, err);
4266                 } else {
4267                         ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4268                                     sta->addr, arvif->vdev_id);
4269                 }
4270         }
4271
4272         if (changed & IEEE80211_RC_NSS_CHANGED) {
4273                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM nss %d\n",
4274                            sta->addr, nss);
4275
4276                 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4277                                                 WMI_PEER_NSS, nss);
4278                 if (err)
4279                         ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
4280                                     sta->addr, nss, err);
4281         }
4282
4283         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4284                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM smps %d\n",
4285                            sta->addr, smps);
4286
4287                 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4288                                                 WMI_PEER_MIMO_PS_STATE, smps);
4289                 if (err)
4290                         ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
4291                                     sta->addr, smps, err);
4292         }
4293
4294         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
4295                 mask = &arvif->bitrate_mask;
4296                 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
4297                                                                       mask);
4298                 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
4299                                                                     mask);
4300
4301                 /* Peer_assoc_prepare will reject vht rates in
4302                  * bitrate_mask if its not available in range format and
4303                  * sets vht tx_rateset as unsupported. So multiple VHT MCS
4304                  * setting(eg. MCS 4,5,6) per peer is not supported here.
4305                  * But, Single rate in VHT mask can be set as per-peer
4306                  * fixed rate. But even if any HT rates are configured in
4307                  * the bitrate mask, device will not switch to those rates
4308                  * when per-peer Fixed rate is set.
4309                  * TODO: Check RATEMASK_CMDID to support auto rates selection
4310                  * across HT/VHT and for multiple VHT MCS support.
4311                  */
4312                 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4313                         ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4314                                                            band);
4315                 } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4316                         ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4317                                                           band);
4318                 } else {
4319                         /* If the peer is non-VHT/HE or no fixed VHT/HE rate
4320                          * is provided in the new bitrate mask we set the
4321                          * other rates using peer_assoc command. Also clear
4322                          * the peer fixed rate settings as it has higher proprity
4323                          * than peer assoc
4324                          */
4325                         err = ath11k_wmi_set_peer_param(ar, sta->addr,
4326                                                         arvif->vdev_id,
4327                                                         WMI_PEER_PARAM_FIXED_RATE,
4328                                                         WMI_FIXED_RATE_NONE);
4329                         if (err)
4330                                 ath11k_warn(ar->ab,
4331                                             "failed to disable peer fixed rate for sta %pM: %d\n",
4332                                             sta->addr, err);
4333
4334                         ath11k_peer_assoc_prepare(ar, arvif->vif, sta,
4335                                                   &peer_arg, true);
4336
4337                         peer_arg.is_assoc = false;
4338                         err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4339                         if (err)
4340                                 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4341                                             sta->addr, arvif->vdev_id, err);
4342
4343                         if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
4344                                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4345                                             sta->addr, arvif->vdev_id);
4346                 }
4347         }
4348
4349         mutex_unlock(&ar->conf_mutex);
4350 }
4351
4352 static void ath11k_sta_set_4addr_wk(struct work_struct *wk)
4353 {
4354         struct ath11k *ar;
4355         struct ath11k_vif *arvif;
4356         struct ath11k_sta *arsta;
4357         struct ieee80211_sta *sta;
4358         int ret = 0;
4359
4360         arsta = container_of(wk, struct ath11k_sta, set_4addr_wk);
4361         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4362         arvif = arsta->arvif;
4363         ar = arvif->ar;
4364
4365         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4366                    "setting USE_4ADDR for peer %pM\n", sta->addr);
4367
4368         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4369                                         arvif->vdev_id,
4370                                         WMI_PEER_USE_4ADDR, 1);
4371
4372         if (ret)
4373                 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n",
4374                             sta->addr, ret);
4375 }
4376
4377 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif,
4378                                        struct ieee80211_sta *sta)
4379 {
4380         struct ath11k *ar = arvif->ar;
4381
4382         lockdep_assert_held(&ar->conf_mutex);
4383
4384         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4385                 return 0;
4386
4387         if (ar->num_stations >= ar->max_num_stations)
4388                 return -ENOBUFS;
4389
4390         ar->num_stations++;
4391
4392         return 0;
4393 }
4394
4395 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif,
4396                                         struct ieee80211_sta *sta)
4397 {
4398         struct ath11k *ar = arvif->ar;
4399
4400         lockdep_assert_held(&ar->conf_mutex);
4401
4402         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4403                 return;
4404
4405         ar->num_stations--;
4406 }
4407
4408 static int ath11k_mac_station_add(struct ath11k *ar,
4409                                   struct ieee80211_vif *vif,
4410                                   struct ieee80211_sta *sta)
4411 {
4412         struct ath11k_base *ab = ar->ab;
4413         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4414         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4415         struct peer_create_params peer_param;
4416         int ret;
4417
4418         lockdep_assert_held(&ar->conf_mutex);
4419
4420         ret = ath11k_mac_inc_num_stations(arvif, sta);
4421         if (ret) {
4422                 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
4423                             ar->max_num_stations);
4424                 goto exit;
4425         }
4426
4427         arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
4428         if (!arsta->rx_stats) {
4429                 ret = -ENOMEM;
4430                 goto dec_num_station;
4431         }
4432
4433         peer_param.vdev_id = arvif->vdev_id;
4434         peer_param.peer_addr = sta->addr;
4435         peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
4436
4437         ret = ath11k_peer_create(ar, arvif, sta, &peer_param);
4438         if (ret) {
4439                 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
4440                             sta->addr, arvif->vdev_id);
4441                 goto free_rx_stats;
4442         }
4443
4444         ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
4445                    sta->addr, arvif->vdev_id);
4446
4447         if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) {
4448                 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL);
4449                 if (!arsta->tx_stats) {
4450                         ret = -ENOMEM;
4451                         goto free_peer;
4452                 }
4453         }
4454
4455         if (ieee80211_vif_is_mesh(vif)) {
4456                 ath11k_dbg(ab, ATH11K_DBG_MAC,
4457                            "setting USE_4ADDR for mesh STA %pM\n", sta->addr);
4458                 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4459                                                 arvif->vdev_id,
4460                                                 WMI_PEER_USE_4ADDR, 1);
4461                 if (ret) {
4462                         ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n",
4463                                     sta->addr, ret);
4464                         goto free_tx_stats;
4465                 }
4466         }
4467
4468         ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
4469         if (ret) {
4470                 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
4471                             sta->addr, arvif->vdev_id, ret);
4472                 goto free_tx_stats;
4473         }
4474
4475         if (ab->hw_params.vdev_start_delay &&
4476             !arvif->is_started &&
4477             arvif->vdev_type != WMI_VDEV_TYPE_AP) {
4478                 ret = ath11k_start_vdev_delay(ar->hw, vif);
4479                 if (ret) {
4480                         ath11k_warn(ab, "failed to delay vdev start: %d\n", ret);
4481                         goto free_tx_stats;
4482                 }
4483         }
4484
4485         ewma_avg_rssi_init(&arsta->avg_rssi);
4486         return 0;
4487
4488 free_tx_stats:
4489         kfree(arsta->tx_stats);
4490         arsta->tx_stats = NULL;
4491 free_peer:
4492         ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4493 free_rx_stats:
4494         kfree(arsta->rx_stats);
4495         arsta->rx_stats = NULL;
4496 dec_num_station:
4497         ath11k_mac_dec_num_stations(arvif, sta);
4498 exit:
4499         return ret;
4500 }
4501
4502 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
4503                                    struct ieee80211_vif *vif,
4504                                    struct ieee80211_sta *sta,
4505                                    enum ieee80211_sta_state old_state,
4506                                    enum ieee80211_sta_state new_state)
4507 {
4508         struct ath11k *ar = hw->priv;
4509         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4510         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4511         struct ath11k_peer *peer;
4512         int ret = 0;
4513
4514         /* cancel must be done outside the mutex to avoid deadlock */
4515         if ((old_state == IEEE80211_STA_NONE &&
4516              new_state == IEEE80211_STA_NOTEXIST)) {
4517                 cancel_work_sync(&arsta->update_wk);
4518                 cancel_work_sync(&arsta->set_4addr_wk);
4519         }
4520
4521         mutex_lock(&ar->conf_mutex);
4522
4523         if (old_state == IEEE80211_STA_NOTEXIST &&
4524             new_state == IEEE80211_STA_NONE) {
4525                 memset(arsta, 0, sizeof(*arsta));
4526                 arsta->arvif = arvif;
4527                 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
4528                 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
4529
4530                 ret = ath11k_mac_station_add(ar, vif, sta);
4531                 if (ret)
4532                         ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
4533                                     sta->addr, arvif->vdev_id);
4534         } else if ((old_state == IEEE80211_STA_NONE &&
4535                     new_state == IEEE80211_STA_NOTEXIST)) {
4536                 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay &&
4537                         vif->type == NL80211_IFTYPE_STATION;
4538
4539                 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
4540
4541                 if (!skip_peer_delete) {
4542                         ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4543                         if (ret)
4544                                 ath11k_warn(ar->ab,
4545                                             "Failed to delete peer: %pM for VDEV: %d\n",
4546                                             sta->addr, arvif->vdev_id);
4547                         else
4548                                 ath11k_dbg(ar->ab,
4549                                            ATH11K_DBG_MAC,
4550                                            "Removed peer: %pM for VDEV: %d\n",
4551                                            sta->addr, arvif->vdev_id);
4552                 }
4553
4554                 ath11k_mac_dec_num_stations(arvif, sta);
4555                 mutex_lock(&ar->ab->tbl_mtx_lock);
4556                 spin_lock_bh(&ar->ab->base_lock);
4557                 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4558                 if (skip_peer_delete && peer) {
4559                         peer->sta = NULL;
4560                 } else if (peer && peer->sta == sta) {
4561                         ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
4562                                     vif->addr, arvif->vdev_id);
4563                         ath11k_peer_rhash_delete(ar->ab, peer);
4564                         peer->sta = NULL;
4565                         list_del(&peer->list);
4566                         kfree(peer);
4567                         ar->num_peers--;
4568                 }
4569                 spin_unlock_bh(&ar->ab->base_lock);
4570                 mutex_unlock(&ar->ab->tbl_mtx_lock);
4571
4572                 kfree(arsta->tx_stats);
4573                 arsta->tx_stats = NULL;
4574
4575                 kfree(arsta->rx_stats);
4576                 arsta->rx_stats = NULL;
4577         } else if (old_state == IEEE80211_STA_AUTH &&
4578                    new_state == IEEE80211_STA_ASSOC &&
4579                    (vif->type == NL80211_IFTYPE_AP ||
4580                     vif->type == NL80211_IFTYPE_MESH_POINT ||
4581                     vif->type == NL80211_IFTYPE_ADHOC)) {
4582                 ret = ath11k_station_assoc(ar, vif, sta, false);
4583                 if (ret)
4584                         ath11k_warn(ar->ab, "Failed to associate station: %pM\n",
4585                                     sta->addr);
4586         } else if (old_state == IEEE80211_STA_ASSOC &&
4587                    new_state == IEEE80211_STA_AUTHORIZED) {
4588                 spin_lock_bh(&ar->ab->base_lock);
4589
4590                 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4591                 if (peer)
4592                         peer->is_authorized = true;
4593
4594                 spin_unlock_bh(&ar->ab->base_lock);
4595
4596                 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
4597                         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4598                                                         arvif->vdev_id,
4599                                                         WMI_PEER_AUTHORIZE,
4600                                                         1);
4601                         if (ret)
4602                                 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
4603                                             sta->addr, arvif->vdev_id, ret);
4604                 }
4605         } else if (old_state == IEEE80211_STA_AUTHORIZED &&
4606                    new_state == IEEE80211_STA_ASSOC) {
4607                 spin_lock_bh(&ar->ab->base_lock);
4608
4609                 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4610                 if (peer)
4611                         peer->is_authorized = false;
4612
4613                 spin_unlock_bh(&ar->ab->base_lock);
4614         } else if (old_state == IEEE80211_STA_ASSOC &&
4615                    new_state == IEEE80211_STA_AUTH &&
4616                    (vif->type == NL80211_IFTYPE_AP ||
4617                     vif->type == NL80211_IFTYPE_MESH_POINT ||
4618                     vif->type == NL80211_IFTYPE_ADHOC)) {
4619                 ret = ath11k_station_disassoc(ar, vif, sta);
4620                 if (ret)
4621                         ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n",
4622                                     sta->addr);
4623         }
4624
4625         mutex_unlock(&ar->conf_mutex);
4626         return ret;
4627 }
4628
4629 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
4630                                        struct ieee80211_vif *vif,
4631                                        struct ieee80211_sta *sta)
4632 {
4633         struct ath11k *ar = hw->priv;
4634         struct ath11k_vif *arvif = (void *)vif->drv_priv;
4635         int ret = 0;
4636         s16 txpwr;
4637
4638         if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
4639                 txpwr = 0;
4640         } else {
4641                 txpwr = sta->deflink.txpwr.power;
4642                 if (!txpwr)
4643                         return -EINVAL;
4644         }
4645
4646         if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL)
4647                 return -EINVAL;
4648
4649         mutex_lock(&ar->conf_mutex);
4650
4651         ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4652                                         WMI_PEER_USE_FIXED_PWR, txpwr);
4653         if (ret) {
4654                 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
4655                             ret);
4656                 goto out;
4657         }
4658
4659 out:
4660         mutex_unlock(&ar->conf_mutex);
4661         return ret;
4662 }
4663
4664 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw,
4665                                         struct ieee80211_vif *vif,
4666                                         struct ieee80211_sta *sta, bool enabled)
4667 {
4668         struct ath11k *ar = hw->priv;
4669         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4670
4671         if (enabled && !arsta->use_4addr_set) {
4672                 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk);
4673                 arsta->use_4addr_set = true;
4674         }
4675 }
4676
4677 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
4678                                         struct ieee80211_vif *vif,
4679                                         struct ieee80211_sta *sta,
4680                                         u32 changed)
4681 {
4682         struct ath11k *ar = hw->priv;
4683         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4684         struct ath11k_vif *arvif = (void *)vif->drv_priv;
4685         struct ath11k_peer *peer;
4686         u32 bw, smps;
4687
4688         spin_lock_bh(&ar->ab->base_lock);
4689
4690         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4691         if (!peer) {
4692                 spin_unlock_bh(&ar->ab->base_lock);
4693                 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
4694                             sta->addr, arvif->vdev_id);
4695                 return;
4696         }
4697
4698         spin_unlock_bh(&ar->ab->base_lock);
4699
4700         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4701                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4702                    sta->addr, changed, sta->deflink.bandwidth,
4703                    sta->deflink.rx_nss,
4704                    sta->smps_mode);
4705
4706         spin_lock_bh(&ar->data_lock);
4707
4708         if (changed & IEEE80211_RC_BW_CHANGED) {
4709                 bw = WMI_PEER_CHWIDTH_20MHZ;
4710
4711                 switch (sta->deflink.bandwidth) {
4712                 case IEEE80211_STA_RX_BW_20:
4713                         bw = WMI_PEER_CHWIDTH_20MHZ;
4714                         break;
4715                 case IEEE80211_STA_RX_BW_40:
4716                         bw = WMI_PEER_CHWIDTH_40MHZ;
4717                         break;
4718                 case IEEE80211_STA_RX_BW_80:
4719                         bw = WMI_PEER_CHWIDTH_80MHZ;
4720                         break;
4721                 case IEEE80211_STA_RX_BW_160:
4722                         bw = WMI_PEER_CHWIDTH_160MHZ;
4723                         break;
4724                 default:
4725                         ath11k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n",
4726                                     sta->deflink.bandwidth, sta->addr);
4727                         bw = WMI_PEER_CHWIDTH_20MHZ;
4728                         break;
4729                 }
4730
4731                 arsta->bw = bw;
4732         }
4733
4734         if (changed & IEEE80211_RC_NSS_CHANGED)
4735                 arsta->nss = sta->deflink.rx_nss;
4736
4737         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4738                 smps = WMI_PEER_SMPS_PS_NONE;
4739
4740                 switch (sta->smps_mode) {
4741                 case IEEE80211_SMPS_AUTOMATIC:
4742                 case IEEE80211_SMPS_OFF:
4743                         smps = WMI_PEER_SMPS_PS_NONE;
4744                         break;
4745                 case IEEE80211_SMPS_STATIC:
4746                         smps = WMI_PEER_SMPS_STATIC;
4747                         break;
4748                 case IEEE80211_SMPS_DYNAMIC:
4749                         smps = WMI_PEER_SMPS_DYNAMIC;
4750                         break;
4751                 default:
4752                         ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
4753                                     sta->smps_mode, sta->addr);
4754                         smps = WMI_PEER_SMPS_PS_NONE;
4755                         break;
4756                 }
4757
4758                 arsta->smps = smps;
4759         }
4760
4761         arsta->changed |= changed;
4762
4763         spin_unlock_bh(&ar->data_lock);
4764
4765         ieee80211_queue_work(hw, &arsta->update_wk);
4766 }
4767
4768 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif,
4769                                 u16 ac, bool enable)
4770 {
4771         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4772         u32 value = 0;
4773         int ret = 0;
4774
4775         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
4776                 return 0;
4777
4778         switch (ac) {
4779         case IEEE80211_AC_VO:
4780                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
4781                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
4782                 break;
4783         case IEEE80211_AC_VI:
4784                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
4785                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
4786                 break;
4787         case IEEE80211_AC_BE:
4788                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
4789                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
4790                 break;
4791         case IEEE80211_AC_BK:
4792                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
4793                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
4794                 break;
4795         }
4796
4797         if (enable)
4798                 arvif->u.sta.uapsd |= value;
4799         else
4800                 arvif->u.sta.uapsd &= ~value;
4801
4802         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4803                                           WMI_STA_PS_PARAM_UAPSD,
4804                                           arvif->u.sta.uapsd);
4805         if (ret) {
4806                 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret);
4807                 goto exit;
4808         }
4809
4810         if (arvif->u.sta.uapsd)
4811                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
4812         else
4813                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4814
4815         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4816                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
4817                                           value);
4818         if (ret)
4819                 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret);
4820
4821 exit:
4822         return ret;
4823 }
4824
4825 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw,
4826                                  struct ieee80211_vif *vif,
4827                                  unsigned int link_id, u16 ac,
4828                                  const struct ieee80211_tx_queue_params *params)
4829 {
4830         struct ath11k *ar = hw->priv;
4831         struct ath11k_vif *arvif = (void *)vif->drv_priv;
4832         struct wmi_wmm_params_arg *p = NULL;
4833         int ret;
4834
4835         mutex_lock(&ar->conf_mutex);
4836
4837         switch (ac) {
4838         case IEEE80211_AC_VO:
4839                 p = &arvif->wmm_params.ac_vo;
4840                 break;
4841         case IEEE80211_AC_VI:
4842                 p = &arvif->wmm_params.ac_vi;
4843                 break;
4844         case IEEE80211_AC_BE:
4845                 p = &arvif->wmm_params.ac_be;
4846                 break;
4847         case IEEE80211_AC_BK:
4848                 p = &arvif->wmm_params.ac_bk;
4849                 break;
4850         }
4851
4852         if (WARN_ON(!p)) {
4853                 ret = -EINVAL;
4854                 goto exit;
4855         }
4856
4857         p->cwmin = params->cw_min;
4858         p->cwmax = params->cw_max;
4859         p->aifs = params->aifs;
4860         p->txop = params->txop;
4861
4862         ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
4863                                                  &arvif->wmm_params);
4864         if (ret) {
4865                 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
4866                 goto exit;
4867         }
4868
4869         ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
4870
4871         if (ret)
4872                 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
4873
4874 exit:
4875         mutex_unlock(&ar->conf_mutex);
4876         return ret;
4877 }
4878
4879 static struct ieee80211_sta_ht_cap
4880 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
4881 {
4882         int i;
4883         struct ieee80211_sta_ht_cap ht_cap = {0};
4884         u32 ar_vht_cap = ar->pdev->cap.vht_cap;
4885
4886         if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
4887                 return ht_cap;
4888
4889         ht_cap.ht_supported = 1;
4890         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4891         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
4892         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4893         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4894         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4895
4896         if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
4897                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4898
4899         if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
4900                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4901
4902         if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
4903                 u32 smps;
4904
4905                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4906                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4907
4908                 ht_cap.cap |= smps;
4909         }
4910
4911         if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
4912                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4913
4914         if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
4915                 u32 stbc;
4916
4917                 stbc   = ar_ht_cap;
4918                 stbc  &= WMI_HT_CAP_RX_STBC;
4919                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4920                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4921                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
4922
4923                 ht_cap.cap |= stbc;
4924         }
4925
4926         if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
4927                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4928
4929         if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
4930                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4931
4932         if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4933                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4934
4935         for (i = 0; i < ar->num_rx_chains; i++) {
4936                 if (rate_cap_rx_chainmask & BIT(i))
4937                         ht_cap.mcs.rx_mask[i] = 0xFF;
4938         }
4939
4940         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4941
4942         return ht_cap;
4943 }
4944
4945 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
4946 {
4947         u32 value = 0;
4948         struct ath11k *ar = arvif->ar;
4949         int nsts;
4950         int sound_dim;
4951         u32 vht_cap = ar->pdev->cap.vht_cap;
4952         u32 vdev_param = WMI_VDEV_PARAM_TXBF;
4953
4954         if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
4955                 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4956                 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4957                 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4958         }
4959
4960         if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
4961                 sound_dim = vht_cap &
4962                             IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4963                 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4964                 if (sound_dim > (ar->num_tx_chains - 1))
4965                         sound_dim = ar->num_tx_chains - 1;
4966                 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4967         }
4968
4969         if (!value)
4970                 return 0;
4971
4972         if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
4973                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4974
4975                 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
4976                     arvif->vdev_type == WMI_VDEV_TYPE_AP)
4977                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
4978         }
4979
4980         /* TODO: SUBFEE not validated in HK, disable here until validated? */
4981
4982         if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
4983                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4984
4985                 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
4986                     arvif->vdev_type == WMI_VDEV_TYPE_STA)
4987                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
4988         }
4989
4990         return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
4991                                              vdev_param, value);
4992 }
4993
4994 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
4995 {
4996         bool subfer, subfee;
4997         int sound_dim = 0;
4998
4999         subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
5000         subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
5001
5002         if (ar->num_tx_chains < 2) {
5003                 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
5004                 subfer = false;
5005         }
5006
5007         /* If SU Beaformer is not set, then disable MU Beamformer Capability */
5008         if (!subfer)
5009                 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
5010
5011         /* If SU Beaformee is not set, then disable MU Beamformee Capability */
5012         if (!subfee)
5013                 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5014
5015         sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5016         sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5017         *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5018
5019         /* TODO: Need to check invalid STS and Sound_dim values set by FW? */
5020
5021         /* Enable Sounding Dimension Field only if SU BF is enabled */
5022         if (subfer) {
5023                 if (sound_dim > (ar->num_tx_chains - 1))
5024                         sound_dim = ar->num_tx_chains - 1;
5025
5026                 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5027                 sound_dim &=  IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5028                 *vht_cap |= sound_dim;
5029         }
5030
5031         /* Use the STS advertised by FW unless SU Beamformee is not supported*/
5032         if (!subfee)
5033                 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5034 }
5035
5036 static struct ieee80211_sta_vht_cap
5037 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5038                       u32 rate_cap_rx_chainmask)
5039 {
5040         struct ieee80211_sta_vht_cap vht_cap = {0};
5041         u16 txmcs_map, rxmcs_map;
5042         int i;
5043
5044         vht_cap.vht_supported = 1;
5045         vht_cap.cap = ar->pdev->cap.vht_cap;
5046
5047         if (ar->pdev->cap.nss_ratio_enabled)
5048                 vht_cap.vht_mcs.tx_highest |=
5049                         cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5050
5051         ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5052
5053         rxmcs_map = 0;
5054         txmcs_map = 0;
5055         for (i = 0; i < 8; i++) {
5056                 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5057                         txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5058                 else
5059                         txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5060
5061                 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5062                         rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5063                 else
5064                         rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5065         }
5066
5067         if (rate_cap_tx_chainmask <= 1)
5068                 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5069
5070         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5071         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5072
5073         return vht_cap;
5074 }
5075
5076 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5077                                         struct ath11k_pdev_cap *cap,
5078                                         u32 *ht_cap_info)
5079 {
5080         struct ieee80211_supported_band *band;
5081         u32 rate_cap_tx_chainmask;
5082         u32 rate_cap_rx_chainmask;
5083         u32 ht_cap;
5084
5085         rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5086         rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5087
5088         if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5089                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5090                 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5091                 if (ht_cap_info)
5092                         *ht_cap_info = ht_cap;
5093                 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5094                                                     rate_cap_rx_chainmask);
5095         }
5096
5097         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5098             (ar->ab->hw_params.single_pdev_only ||
5099              !ar->supports_6ghz)) {
5100                 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5101                 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
5102                 if (ht_cap_info)
5103                         *ht_cap_info = ht_cap;
5104                 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5105                                                     rate_cap_rx_chainmask);
5106                 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5107                                                       rate_cap_rx_chainmask);
5108         }
5109 }
5110
5111 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5112 {
5113         /* TODO: Check the request chainmask against the supported
5114          * chainmask table which is advertised in extented_service_ready event
5115          */
5116
5117         return 0;
5118 }
5119
5120 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5121                                   u8 *he_ppet)
5122 {
5123         int nss, ru;
5124         u8 bit = 7;
5125
5126         he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5127         he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5128                        IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5129                       IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5130         for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5131                 for (ru = 0; ru < 4; ru++) {
5132                         u8 val;
5133                         int i;
5134
5135                         if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5136                                 continue;
5137                         val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5138                                0x3f;
5139                         val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5140                         for (i = 5; i >= 0; i--) {
5141                                 he_ppet[bit / 8] |=
5142                                         ((val >> i) & 0x1) << ((bit % 8));
5143                                 bit++;
5144                         }
5145                 }
5146         }
5147 }
5148
5149 static void
5150 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5151 {
5152         u8 m;
5153
5154         m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5155             IEEE80211_HE_MAC_CAP0_TWT_REQ;
5156         he_cap_elem->mac_cap_info[0] &= ~m;
5157
5158         m = IEEE80211_HE_MAC_CAP2_TRS |
5159             IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5160             IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5161         he_cap_elem->mac_cap_info[2] &= ~m;
5162
5163         m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5164             IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5165             IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5166         he_cap_elem->mac_cap_info[3] &= ~m;
5167
5168         m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5169             IEEE80211_HE_MAC_CAP4_BQR;
5170         he_cap_elem->mac_cap_info[4] &= ~m;
5171
5172         m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
5173             IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5174             IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5175             IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5176         he_cap_elem->mac_cap_info[5] &= ~m;
5177
5178         m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5179             IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5180         he_cap_elem->phy_cap_info[2] &= ~m;
5181
5182         m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
5183             IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5184             IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5185         he_cap_elem->phy_cap_info[3] &= ~m;
5186
5187         m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5188         he_cap_elem->phy_cap_info[4] &= ~m;
5189
5190         m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5191         he_cap_elem->phy_cap_info[5] &= ~m;
5192
5193         m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
5194             IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
5195             IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5196             IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5197         he_cap_elem->phy_cap_info[6] &= ~m;
5198
5199         m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5200             IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
5201             IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5202             IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5203         he_cap_elem->phy_cap_info[7] &= ~m;
5204
5205         m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5206             IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5207             IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5208             IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5209         he_cap_elem->phy_cap_info[8] &= ~m;
5210
5211         m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5212             IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5213             IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5214             IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5215             IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5216             IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5217         he_cap_elem->phy_cap_info[9] &= ~m;
5218 }
5219
5220 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5221                                            struct ath11k_band_cap *bcap)
5222 {
5223         u8 val;
5224
5225         bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5226         if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5227                 bcap->he_6ghz_capa |=
5228                         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5229                                    WLAN_HT_CAP_SM_PS_DYNAMIC);
5230         else
5231                 bcap->he_6ghz_capa |=
5232                         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5233                                    WLAN_HT_CAP_SM_PS_DISABLED);
5234         val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5235                         pcap->vht_cap);
5236         bcap->he_6ghz_capa |=
5237                 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5238         val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5239         bcap->he_6ghz_capa |=
5240                 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5241         if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5242                 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5243         if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5244                 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5245
5246         return cpu_to_le16(bcap->he_6ghz_capa);
5247 }
5248
5249 static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5250                                   struct ath11k_pdev_cap *cap,
5251                                   struct ieee80211_sband_iftype_data *data,
5252                                   int band)
5253 {
5254         int i, idx = 0;
5255
5256         for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5257                 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5258                 struct ath11k_band_cap *band_cap = &cap->band[band];
5259                 struct ieee80211_he_cap_elem *he_cap_elem =
5260                                 &he_cap->he_cap_elem;
5261
5262                 switch (i) {
5263                 case NL80211_IFTYPE_STATION:
5264                 case NL80211_IFTYPE_AP:
5265                 case NL80211_IFTYPE_MESH_POINT:
5266                         break;
5267
5268                 default:
5269                         continue;
5270                 }
5271
5272                 data[idx].types_mask = BIT(i);
5273                 he_cap->has_he = true;
5274                 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5275                        sizeof(he_cap_elem->mac_cap_info));
5276                 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5277                        sizeof(he_cap_elem->phy_cap_info));
5278
5279                 he_cap_elem->mac_cap_info[1] &=
5280                         IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
5281
5282                 he_cap_elem->phy_cap_info[5] &=
5283                         ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
5284                 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5285
5286                 switch (i) {
5287                 case NL80211_IFTYPE_AP:
5288                         he_cap_elem->phy_cap_info[3] &=
5289                                 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
5290                         he_cap_elem->phy_cap_info[9] |=
5291                                 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5292                         break;
5293                 case NL80211_IFTYPE_STATION:
5294                         he_cap_elem->mac_cap_info[0] &=
5295                                 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5296                         he_cap_elem->mac_cap_info[0] |=
5297                                 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5298                         he_cap_elem->phy_cap_info[9] |=
5299                                 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5300                         break;
5301                 case NL80211_IFTYPE_MESH_POINT:
5302                         ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5303                         break;
5304                 }
5305
5306                 he_cap->he_mcs_nss_supp.rx_mcs_80 =
5307                         cpu_to_le16(band_cap->he_mcs & 0xffff);
5308                 he_cap->he_mcs_nss_supp.tx_mcs_80 =
5309                         cpu_to_le16(band_cap->he_mcs & 0xffff);
5310                 he_cap->he_mcs_nss_supp.rx_mcs_160 =
5311                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5312                 he_cap->he_mcs_nss_supp.tx_mcs_160 =
5313                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5314                 he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5315                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5316                 he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5317                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5318
5319                 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5320                 if (he_cap_elem->phy_cap_info[6] &
5321                     IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5322                         ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5323                                               he_cap->ppe_thres);
5324
5325                 if (band == NL80211_BAND_6GHZ) {
5326                         data[idx].he_6ghz_capa.capa =
5327                                 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5328                 }
5329                 idx++;
5330         }
5331
5332         return idx;
5333 }
5334
5335 static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5336                                     struct ath11k_pdev_cap *cap)
5337 {
5338         struct ieee80211_supported_band *band;
5339         int count;
5340
5341         if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5342                 count = ath11k_mac_copy_he_cap(ar, cap,
5343                                                ar->mac.iftype[NL80211_BAND_2GHZ],
5344                                                NL80211_BAND_2GHZ);
5345                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5346                 band->iftype_data = ar->mac.iftype[NL80211_BAND_2GHZ];
5347                 band->n_iftype_data = count;
5348         }
5349
5350         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5351                 count = ath11k_mac_copy_he_cap(ar, cap,
5352                                                ar->mac.iftype[NL80211_BAND_5GHZ],
5353                                                NL80211_BAND_5GHZ);
5354                 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5355                 band->iftype_data = ar->mac.iftype[NL80211_BAND_5GHZ];
5356                 band->n_iftype_data = count;
5357         }
5358
5359         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5360             ar->supports_6ghz) {
5361                 count = ath11k_mac_copy_he_cap(ar, cap,
5362                                                ar->mac.iftype[NL80211_BAND_6GHZ],
5363                                                NL80211_BAND_6GHZ);
5364                 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5365                 band->iftype_data = ar->mac.iftype[NL80211_BAND_6GHZ];
5366                 band->n_iftype_data = count;
5367         }
5368 }
5369
5370 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5371 {
5372         int ret;
5373
5374         lockdep_assert_held(&ar->conf_mutex);
5375
5376         if (ath11k_check_chain_mask(ar, tx_ant, true))
5377                 return -EINVAL;
5378
5379         if (ath11k_check_chain_mask(ar, rx_ant, false))
5380                 return -EINVAL;
5381
5382         ar->cfg_tx_chainmask = tx_ant;
5383         ar->cfg_rx_chainmask = rx_ant;
5384
5385         if (ar->state != ATH11K_STATE_ON &&
5386             ar->state != ATH11K_STATE_RESTARTED)
5387                 return 0;
5388
5389         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5390                                         tx_ant, ar->pdev->pdev_id);
5391         if (ret) {
5392                 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5393                             ret, tx_ant);
5394                 return ret;
5395         }
5396
5397         ar->num_tx_chains = get_num_chains(tx_ant);
5398
5399         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5400                                         rx_ant, ar->pdev->pdev_id);
5401         if (ret) {
5402                 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5403                             ret, rx_ant);
5404                 return ret;
5405         }
5406
5407         ar->num_rx_chains = get_num_chains(rx_ant);
5408
5409         /* Reload HT/VHT/HE capability */
5410         ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
5411         ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
5412
5413         return 0;
5414 }
5415
5416 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5417 {
5418         int num_mgmt;
5419
5420         ieee80211_free_txskb(ar->hw, skb);
5421
5422         num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5423
5424         if (num_mgmt < 0)
5425                 WARN_ON_ONCE(1);
5426
5427         if (!num_mgmt)
5428                 wake_up(&ar->txmgmt_empty_waitq);
5429 }
5430
5431 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
5432 {
5433         struct sk_buff *msdu;
5434         struct ieee80211_tx_info *info;
5435
5436         spin_lock_bh(&ar->txmgmt_idr_lock);
5437         msdu = idr_remove(&ar->txmgmt_idr, buf_id);
5438         spin_unlock_bh(&ar->txmgmt_idr_lock);
5439
5440         if (!msdu)
5441                 return;
5442
5443         dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
5444                          DMA_TO_DEVICE);
5445
5446         info = IEEE80211_SKB_CB(msdu);
5447         memset(&info->status, 0, sizeof(info->status));
5448
5449         ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
5450 }
5451
5452 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
5453 {
5454         struct ath11k *ar = ctx;
5455
5456         ath11k_mac_tx_mgmt_free(ar, buf_id);
5457
5458         return 0;
5459 }
5460
5461 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
5462 {
5463         struct ieee80211_vif *vif = ctx;
5464         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
5465         struct ath11k *ar = skb_cb->ar;
5466
5467         if (skb_cb->vif == vif)
5468                 ath11k_mac_tx_mgmt_free(ar, buf_id);
5469
5470         return 0;
5471 }
5472
5473 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
5474                                   struct sk_buff *skb)
5475 {
5476         struct ath11k_base *ab = ar->ab;
5477         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5478         struct ieee80211_tx_info *info;
5479         dma_addr_t paddr;
5480         int buf_id;
5481         int ret;
5482
5483         ATH11K_SKB_CB(skb)->ar = ar;
5484
5485         spin_lock_bh(&ar->txmgmt_idr_lock);
5486         buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
5487                            ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
5488         spin_unlock_bh(&ar->txmgmt_idr_lock);
5489
5490         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5491                    "mac tx mgmt frame, buf id %d\n", buf_id);
5492
5493         if (buf_id < 0)
5494                 return -ENOSPC;
5495
5496         info = IEEE80211_SKB_CB(skb);
5497         if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
5498                 if ((ieee80211_is_action(hdr->frame_control) ||
5499                      ieee80211_is_deauth(hdr->frame_control) ||
5500                      ieee80211_is_disassoc(hdr->frame_control)) &&
5501                      ieee80211_has_protected(hdr->frame_control)) {
5502                         skb_put(skb, IEEE80211_CCMP_MIC_LEN);
5503                 }
5504         }
5505
5506         paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
5507         if (dma_mapping_error(ab->dev, paddr)) {
5508                 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
5509                 ret = -EIO;
5510                 goto err_free_idr;
5511         }
5512
5513         ATH11K_SKB_CB(skb)->paddr = paddr;
5514
5515         ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
5516         if (ret) {
5517                 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
5518                 goto err_unmap_buf;
5519         }
5520
5521         return 0;
5522
5523 err_unmap_buf:
5524         dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
5525                          skb->len, DMA_TO_DEVICE);
5526 err_free_idr:
5527         spin_lock_bh(&ar->txmgmt_idr_lock);
5528         idr_remove(&ar->txmgmt_idr, buf_id);
5529         spin_unlock_bh(&ar->txmgmt_idr_lock);
5530
5531         return ret;
5532 }
5533
5534 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
5535 {
5536         struct sk_buff *skb;
5537
5538         while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
5539                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5540 }
5541
5542 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
5543 {
5544         struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
5545         struct ath11k_skb_cb *skb_cb;
5546         struct ath11k_vif *arvif;
5547         struct sk_buff *skb;
5548         int ret;
5549
5550         while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
5551                 skb_cb = ATH11K_SKB_CB(skb);
5552                 if (!skb_cb->vif) {
5553                         ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
5554                         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5555                         continue;
5556                 }
5557
5558                 arvif = ath11k_vif_to_arvif(skb_cb->vif);
5559                 mutex_lock(&ar->conf_mutex);
5560                 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) {
5561                         ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
5562                         if (ret) {
5563                                 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
5564                                             arvif->vdev_id, ret);
5565                                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5566                         } else {
5567                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5568                                            "mac tx mgmt frame, vdev_id %d\n",
5569                                            arvif->vdev_id);
5570                         }
5571                 } else {
5572                         ath11k_warn(ar->ab,
5573                                     "dropping mgmt frame for vdev %d, is_started %d\n",
5574                                     arvif->vdev_id,
5575                                     arvif->is_started);
5576                         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5577                 }
5578                 mutex_unlock(&ar->conf_mutex);
5579         }
5580 }
5581
5582 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
5583                               bool is_prb_rsp)
5584 {
5585         struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
5586
5587         if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
5588                 return -ESHUTDOWN;
5589
5590         /* Drop probe response packets when the pending management tx
5591          * count has reached a certain threshold, so as to prioritize
5592          * other mgmt packets like auth and assoc to be sent on time
5593          * for establishing successful connections.
5594          */
5595         if (is_prb_rsp &&
5596             atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
5597                 ath11k_warn(ar->ab,
5598                             "dropping probe response as pending queue is almost full\n");
5599                 return -ENOSPC;
5600         }
5601
5602         if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
5603                 ath11k_warn(ar->ab, "mgmt tx queue is full\n");
5604                 return -ENOSPC;
5605         }
5606
5607         skb_queue_tail(q, skb);
5608         atomic_inc(&ar->num_pending_mgmt_tx);
5609         queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work);
5610
5611         return 0;
5612 }
5613
5614 static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
5615                              struct ieee80211_tx_control *control,
5616                              struct sk_buff *skb)
5617 {
5618         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
5619         struct ath11k *ar = hw->priv;
5620         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
5621         struct ieee80211_vif *vif = info->control.vif;
5622         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5623         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5624         struct ieee80211_key_conf *key = info->control.hw_key;
5625         struct ath11k_sta *arsta = NULL;
5626         u32 info_flags = info->flags;
5627         bool is_prb_rsp;
5628         int ret;
5629
5630         memset(skb_cb, 0, sizeof(*skb_cb));
5631         skb_cb->vif = vif;
5632
5633         if (key) {
5634                 skb_cb->cipher = key->cipher;
5635                 skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
5636         }
5637
5638         if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
5639                 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
5640         } else if (ieee80211_is_mgmt(hdr->frame_control)) {
5641                 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
5642                 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
5643                 if (ret) {
5644                         ath11k_warn(ar->ab, "failed to queue management frame %d\n",
5645                                     ret);
5646                         ieee80211_free_txskb(ar->hw, skb);
5647                 }
5648                 return;
5649         }
5650
5651         if (control->sta)
5652                 arsta = (struct ath11k_sta *)control->sta->drv_priv;
5653
5654         ret = ath11k_dp_tx(ar, arvif, arsta, skb);
5655         if (unlikely(ret)) {
5656                 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
5657                 ieee80211_free_txskb(ar->hw, skb);
5658         }
5659 }
5660
5661 void ath11k_mac_drain_tx(struct ath11k *ar)
5662 {
5663         /* make sure rcu-protected mac80211 tx path itself is drained */
5664         synchronize_net();
5665
5666         cancel_work_sync(&ar->wmi_mgmt_tx_work);
5667         ath11k_mgmt_over_wmi_tx_purge(ar);
5668 }
5669
5670 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
5671 {
5672         struct htt_rx_ring_tlv_filter tlv_filter = {0};
5673         struct ath11k_base *ab = ar->ab;
5674         int i, ret = 0;
5675         u32 ring_id;
5676
5677         if (enable) {
5678                 tlv_filter = ath11k_mac_mon_status_filter_default;
5679                 if (ath11k_debugfs_rx_filter(ar))
5680                         tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
5681         }
5682
5683         for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
5684                 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
5685                 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
5686                                                        ar->dp.mac_id + i,
5687                                                        HAL_RXDMA_MONITOR_STATUS,
5688                                                        DP_RX_BUFFER_SIZE,
5689                                                        &tlv_filter);
5690         }
5691
5692         if (enable && !ar->ab->hw_params.rxdma1_enable)
5693                 mod_timer(&ar->ab->mon_reap_timer, jiffies +
5694                           msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
5695
5696         return ret;
5697 }
5698
5699 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
5700 {
5701         int recovery_start_count;
5702
5703         if (!ab->is_reset)
5704                 return;
5705
5706         recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
5707         ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
5708
5709         if (recovery_start_count == ab->num_radios) {
5710                 complete(&ab->recovery_start);
5711                 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
5712         }
5713
5714         ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
5715
5716         wait_for_completion_timeout(&ab->reconfigure_complete,
5717                                     ATH11K_RECONFIGURE_TIMEOUT_HZ);
5718 }
5719
5720 static int ath11k_mac_op_start(struct ieee80211_hw *hw)
5721 {
5722         struct ath11k *ar = hw->priv;
5723         struct ath11k_base *ab = ar->ab;
5724         struct ath11k_pdev *pdev = ar->pdev;
5725         int ret;
5726
5727         ath11k_mac_drain_tx(ar);
5728         mutex_lock(&ar->conf_mutex);
5729
5730         switch (ar->state) {
5731         case ATH11K_STATE_OFF:
5732                 ar->state = ATH11K_STATE_ON;
5733                 break;
5734         case ATH11K_STATE_RESTARTING:
5735                 ar->state = ATH11K_STATE_RESTARTED;
5736                 ath11k_mac_wait_reconfigure(ab);
5737                 break;
5738         case ATH11K_STATE_RESTARTED:
5739         case ATH11K_STATE_WEDGED:
5740         case ATH11K_STATE_ON:
5741                 WARN_ON(1);
5742                 ret = -EINVAL;
5743                 goto err;
5744         }
5745
5746         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
5747                                         1, pdev->pdev_id);
5748
5749         if (ret) {
5750                 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
5751                 goto err;
5752         }
5753
5754         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
5755                                         pdev->pdev_id);
5756         if (ret) {
5757                 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
5758                 goto err;
5759         }
5760
5761         if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
5762                 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
5763                 if (ret) {
5764                         ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
5765                         goto err;
5766                 }
5767         }
5768
5769         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
5770                                         0, pdev->pdev_id);
5771         if (ret) {
5772                 ath11k_err(ab, "failed to set ac override for ARP: %d\n",
5773                            ret);
5774                 goto err;
5775         }
5776
5777         ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
5778         if (ret) {
5779                 ath11k_err(ab, "failed to offload radar detection: %d\n",
5780                            ret);
5781                 goto err;
5782         }
5783
5784         ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
5785                                                   HTT_PPDU_STATS_TAG_DEFAULT);
5786         if (ret) {
5787                 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
5788                 goto err;
5789         }
5790
5791         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
5792                                         1, pdev->pdev_id);
5793
5794         if (ret) {
5795                 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
5796                 goto err;
5797         }
5798
5799         __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5800
5801         /* TODO: Do we need to enable ANI? */
5802
5803         ath11k_reg_update_chan_list(ar, false);
5804
5805         ar->num_started_vdevs = 0;
5806         ar->num_created_vdevs = 0;
5807         ar->num_peers = 0;
5808         ar->allocated_vdev_map = 0;
5809
5810         /* Configure monitor status ring with default rx_filter to get rx status
5811          * such as rssi, rx_duration.
5812          */
5813         ret = ath11k_mac_config_mon_status_default(ar, true);
5814         if (ret) {
5815                 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
5816                            ret);
5817                 goto err;
5818         }
5819
5820         /* Configure the hash seed for hash based reo dest ring selection */
5821         ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
5822
5823         /* allow device to enter IMPS */
5824         if (ab->hw_params.idle_ps) {
5825                 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
5826                                                 1, pdev->pdev_id);
5827                 if (ret) {
5828                         ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
5829                         goto err;
5830                 }
5831         }
5832
5833         mutex_unlock(&ar->conf_mutex);
5834
5835         rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
5836                            &ab->pdevs[ar->pdev_idx]);
5837
5838         return 0;
5839
5840 err:
5841         ar->state = ATH11K_STATE_OFF;
5842         mutex_unlock(&ar->conf_mutex);
5843
5844         return ret;
5845 }
5846
5847 static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
5848 {
5849         struct ath11k *ar = hw->priv;
5850         struct htt_ppdu_stats_info *ppdu_stats, *tmp;
5851         int ret;
5852
5853         ath11k_mac_drain_tx(ar);
5854
5855         mutex_lock(&ar->conf_mutex);
5856         ret = ath11k_mac_config_mon_status_default(ar, false);
5857         if (ret)
5858                 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
5859                            ret);
5860
5861         clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
5862         ar->state = ATH11K_STATE_OFF;
5863         mutex_unlock(&ar->conf_mutex);
5864
5865         cancel_delayed_work_sync(&ar->scan.timeout);
5866         cancel_work_sync(&ar->regd_update_work);
5867         cancel_work_sync(&ar->ab->update_11d_work);
5868
5869         if (ar->state_11d == ATH11K_11D_PREPARING) {
5870                 ar->state_11d = ATH11K_11D_IDLE;
5871                 complete(&ar->completed_11d_scan);
5872         }
5873
5874         spin_lock_bh(&ar->data_lock);
5875         list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
5876                 list_del(&ppdu_stats->list);
5877                 kfree(ppdu_stats);
5878         }
5879         spin_unlock_bh(&ar->data_lock);
5880
5881         rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
5882
5883         synchronize_rcu();
5884
5885         atomic_set(&ar->num_pending_mgmt_tx, 0);
5886 }
5887
5888 static void
5889 ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
5890                                     struct vdev_create_params *params)
5891 {
5892         struct ath11k *ar = arvif->ar;
5893         struct ath11k_pdev *pdev = ar->pdev;
5894
5895         params->if_id = arvif->vdev_id;
5896         params->type = arvif->vdev_type;
5897         params->subtype = arvif->vdev_subtype;
5898         params->pdev_id = pdev->pdev_id;
5899
5900         if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
5901                 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
5902                 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
5903         }
5904         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
5905                 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
5906                 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
5907         }
5908         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
5909             ar->supports_6ghz) {
5910                 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
5911                 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
5912         }
5913 }
5914
5915 static u32
5916 ath11k_mac_prepare_he_mode(struct ath11k_pdev *pdev, u32 viftype)
5917 {
5918         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
5919         struct ath11k_band_cap *cap_band = NULL;
5920         u32 *hecap_phy_ptr = NULL;
5921         u32 hemode = 0;
5922
5923         if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP)
5924                 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
5925         else
5926                 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
5927
5928         hecap_phy_ptr = &cap_band->he_cap_phy_info[0];
5929
5930         hemode = FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE) |
5931                  FIELD_PREP(HE_MODE_SU_TX_BFER, HECAP_PHY_SUBFMR_GET(hecap_phy_ptr)) |
5932                  FIELD_PREP(HE_MODE_UL_MUMIMO, HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr));
5933
5934         /* TODO WDS and other modes */
5935         if (viftype == NL80211_IFTYPE_AP) {
5936                 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFER,
5937                           HECAP_PHY_MUBFMR_GET(hecap_phy_ptr)) |
5938                           FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
5939                           FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
5940         } else {
5941                 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
5942         }
5943
5944         return hemode;
5945 }
5946
5947 static int ath11k_set_he_mu_sounding_mode(struct ath11k *ar,
5948                                           struct ath11k_vif *arvif)
5949 {
5950         u32 param_id, param_value;
5951         struct ath11k_base *ab = ar->ab;
5952         int ret = 0;
5953
5954         param_id = WMI_VDEV_PARAM_SET_HEMU_MODE;
5955         param_value = ath11k_mac_prepare_he_mode(ar->pdev, arvif->vif->type);
5956         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5957                                             param_id, param_value);
5958         if (ret) {
5959                 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n",
5960                             arvif->vdev_id, ret, param_value);
5961                 return ret;
5962         }
5963         param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
5964         param_value =
5965                 FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
5966                 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
5967                            HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
5968         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5969                                             param_id, param_value);
5970         if (ret) {
5971                 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d\n",
5972                             arvif->vdev_id, ret);
5973                 return ret;
5974         }
5975         return ret;
5976 }
5977
5978 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
5979                                              struct ieee80211_vif *vif)
5980 {
5981         struct ath11k *ar = hw->priv;
5982         struct ath11k_base *ab = ar->ab;
5983         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5984         u32 param_id, param_value;
5985         int ret;
5986
5987         param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
5988         if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
5989             (vif->type != NL80211_IFTYPE_STATION &&
5990              vif->type != NL80211_IFTYPE_AP))
5991                 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
5992                                         IEEE80211_OFFLOAD_DECAP_ENABLED);
5993
5994         if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
5995                 param_value = ATH11K_HW_TXRX_ETHERNET;
5996         else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
5997                 param_value = ATH11K_HW_TXRX_RAW;
5998         else
5999                 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6000
6001         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6002                                             param_id, param_value);
6003         if (ret) {
6004                 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6005                             arvif->vdev_id, ret);
6006                 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6007         }
6008
6009         param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6010         if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6011                 param_value = ATH11K_HW_TXRX_ETHERNET;
6012         else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6013                 param_value = ATH11K_HW_TXRX_RAW;
6014         else
6015                 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6016
6017         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6018                                             param_id, param_value);
6019         if (ret) {
6020                 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6021                             arvif->vdev_id, ret);
6022                 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6023         }
6024 }
6025
6026 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6027 {
6028         struct ath11k *ar;
6029         struct ath11k_pdev *pdev;
6030         struct ath11k_vif *arvif;
6031         int i;
6032
6033         for (i = 0; i < ab->num_radios; i++) {
6034                 pdev = &ab->pdevs[i];
6035                 ar = pdev->ar;
6036                 list_for_each_entry(arvif, &ar->arvifs, list) {
6037                         if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6038                                 return true;
6039                 }
6040         }
6041         return false;
6042 }
6043
6044 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
6045 {
6046         struct wmi_11d_scan_start_params param;
6047         int ret;
6048
6049         mutex_lock(&ar->ab->vdev_id_11d_lock);
6050
6051         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev id for 11d scan %d\n",
6052                    ar->vdev_id_11d_scan);
6053
6054         if (ar->regdom_set_by_user)
6055                 goto fin;
6056
6057         if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6058                 goto fin;
6059
6060         if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6061                 goto fin;
6062
6063         if (ath11k_mac_vif_ap_active_any(ar->ab))
6064                 goto fin;
6065
6066         param.vdev_id = vdev_id;
6067         param.start_interval_msec = 0;
6068         param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6069
6070         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac start 11d scan\n");
6071
6072         ret = ath11k_wmi_send_11d_scan_start_cmd(ar, &param);
6073         if (ret) {
6074                 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6075                             vdev_id, ret);
6076         } else {
6077                 ar->vdev_id_11d_scan = vdev_id;
6078                 if (ar->state_11d == ATH11K_11D_PREPARING)
6079                         ar->state_11d = ATH11K_11D_RUNNING;
6080         }
6081
6082 fin:
6083         if (ar->state_11d == ATH11K_11D_PREPARING) {
6084                 ar->state_11d = ATH11K_11D_IDLE;
6085                 complete(&ar->completed_11d_scan);
6086         }
6087
6088         mutex_unlock(&ar->ab->vdev_id_11d_lock);
6089 }
6090
6091 void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6092 {
6093         int ret;
6094         u32 vdev_id;
6095
6096         if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6097                 return;
6098
6099         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d scan\n");
6100
6101         mutex_lock(&ar->ab->vdev_id_11d_lock);
6102
6103         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d vdev id %d\n",
6104                    ar->vdev_id_11d_scan);
6105
6106         if (ar->state_11d == ATH11K_11D_PREPARING) {
6107                 ar->state_11d = ATH11K_11D_IDLE;
6108                 complete(&ar->completed_11d_scan);
6109         }
6110
6111         if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6112                 vdev_id = ar->vdev_id_11d_scan;
6113
6114                 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
6115                 if (ret) {
6116                         ath11k_warn(ar->ab,
6117                                     "failed to stopt 11d scan vdev %d ret: %d\n",
6118                                     vdev_id, ret);
6119                 } else {
6120                         ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
6121                         ar->state_11d = ATH11K_11D_IDLE;
6122                         complete(&ar->completed_11d_scan);
6123                 }
6124         }
6125         mutex_unlock(&ar->ab->vdev_id_11d_lock);
6126 }
6127
6128 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6129 {
6130         struct ath11k *ar;
6131         struct ath11k_pdev *pdev;
6132         int i;
6133
6134         ath11k_dbg(ab, ATH11K_DBG_MAC, "mac stop soc 11d scan\n");
6135
6136         for (i = 0; i < ab->num_radios; i++) {
6137                 pdev = &ab->pdevs[i];
6138                 ar = pdev->ar;
6139
6140                 ath11k_mac_11d_scan_stop(ar);
6141         }
6142 }
6143
6144 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6145                                        struct ieee80211_vif *vif)
6146 {
6147         struct ath11k *ar = hw->priv;
6148         struct ath11k_base *ab = ar->ab;
6149         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6150         struct vdev_create_params vdev_param = {0};
6151         struct peer_create_params peer_param;
6152         u32 param_id, param_value;
6153         u16 nss;
6154         int i;
6155         int ret, fbret;
6156         int bit;
6157
6158         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6159
6160         mutex_lock(&ar->conf_mutex);
6161
6162         if (vif->type == NL80211_IFTYPE_AP &&
6163             ar->num_peers > (ar->max_num_peers - 1)) {
6164                 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6165                 ret = -ENOBUFS;
6166                 goto err;
6167         }
6168
6169         if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
6170                 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
6171                             ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
6172                 ret = -EBUSY;
6173                 goto err;
6174         }
6175
6176         memset(arvif, 0, sizeof(*arvif));
6177
6178         arvif->ar = ar;
6179         arvif->vif = vif;
6180
6181         INIT_LIST_HEAD(&arvif->list);
6182         INIT_DELAYED_WORK(&arvif->connection_loss_work,
6183                           ath11k_mac_vif_sta_connection_loss_work);
6184
6185         for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6186                 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
6187                 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
6188                 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6189                        sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6190                 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6191                        sizeof(arvif->bitrate_mask.control[i].vht_mcs));
6192                 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6193                        sizeof(arvif->bitrate_mask.control[i].he_mcs));
6194         }
6195
6196         bit = __ffs64(ab->free_vdev_map);
6197
6198         arvif->vdev_id = bit;
6199         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6200
6201         switch (vif->type) {
6202         case NL80211_IFTYPE_UNSPECIFIED:
6203         case NL80211_IFTYPE_STATION:
6204                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
6205                 break;
6206         case NL80211_IFTYPE_MESH_POINT:
6207                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
6208                 fallthrough;
6209         case NL80211_IFTYPE_AP:
6210                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
6211                 break;
6212         case NL80211_IFTYPE_MONITOR:
6213                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
6214                 ar->monitor_vdev_id = bit;
6215                 break;
6216         default:
6217                 WARN_ON(1);
6218                 break;
6219         }
6220
6221         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n",
6222                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6223                    ab->free_vdev_map);
6224
6225         vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6226         for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6227                 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6228
6229         ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6230
6231         ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6232         if (ret) {
6233                 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6234                             arvif->vdev_id, ret);
6235                 goto err;
6236         }
6237
6238         ar->num_created_vdevs++;
6239         ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6240                    vif->addr, arvif->vdev_id);
6241         ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
6242         ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
6243
6244         spin_lock_bh(&ar->data_lock);
6245         list_add(&arvif->list, &ar->arvifs);
6246         spin_unlock_bh(&ar->data_lock);
6247
6248         ath11k_mac_op_update_vif_offload(hw, vif);
6249
6250         nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6251         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6252                                             WMI_VDEV_PARAM_NSS, nss);
6253         if (ret) {
6254                 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6255                             arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6256                 goto err_vdev_del;
6257         }
6258
6259         switch (arvif->vdev_type) {
6260         case WMI_VDEV_TYPE_AP:
6261                 peer_param.vdev_id = arvif->vdev_id;
6262                 peer_param.peer_addr = vif->addr;
6263                 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6264                 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6265                 if (ret) {
6266                         ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6267                                     arvif->vdev_id, ret);
6268                         goto err_vdev_del;
6269                 }
6270
6271                 ret = ath11k_mac_set_kickout(arvif);
6272                 if (ret) {
6273                         ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6274                                     arvif->vdev_id, ret);
6275                         goto err_peer_del;
6276                 }
6277
6278                 ath11k_mac_11d_scan_stop_all(ar->ab);
6279                 break;
6280         case WMI_VDEV_TYPE_STA:
6281                 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6282                 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6283                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6284                                                   param_id, param_value);
6285                 if (ret) {
6286                         ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6287                                     arvif->vdev_id, ret);
6288                         goto err_peer_del;
6289                 }
6290
6291                 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6292                 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6293                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6294                                                   param_id, param_value);
6295                 if (ret) {
6296                         ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6297                                     arvif->vdev_id, ret);
6298                         goto err_peer_del;
6299                 }
6300
6301                 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6302                 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6303                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6304                                                   param_id, param_value);
6305                 if (ret) {
6306                         ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6307                                     arvif->vdev_id, ret);
6308                         goto err_peer_del;
6309                 }
6310
6311                 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6312                                                   WMI_STA_PS_MODE_DISABLED);
6313                 if (ret) {
6314                         ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6315                                     arvif->vdev_id, ret);
6316                         goto err_peer_del;
6317                 }
6318
6319                 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6320                         reinit_completion(&ar->completed_11d_scan);
6321                         ar->state_11d = ATH11K_11D_PREPARING;
6322                 }
6323                 break;
6324         case WMI_VDEV_TYPE_MONITOR:
6325                 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6326                 break;
6327         default:
6328                 break;
6329         }
6330
6331         arvif->txpower = vif->bss_conf.txpower;
6332         ret = ath11k_mac_txpower_recalc(ar);
6333         if (ret)
6334                 goto err_peer_del;
6335
6336         param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6337         param_value = ar->hw->wiphy->rts_threshold;
6338         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6339                                             param_id, param_value);
6340         if (ret) {
6341                 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6342                             arvif->vdev_id, ret);
6343         }
6344
6345         ath11k_dp_vdev_tx_attach(ar, arvif);
6346
6347         if (vif->type != NL80211_IFTYPE_MONITOR &&
6348             test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6349                 ret = ath11k_mac_monitor_vdev_create(ar);
6350                 if (ret) {
6351                         ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6352                                     ret);
6353                         goto err_peer_del;
6354                 }
6355         }
6356
6357         ret = ath11k_debugfs_add_interface(arvif);
6358         if (ret)
6359                 goto err_peer_del;
6360
6361         mutex_unlock(&ar->conf_mutex);
6362
6363         return 0;
6364
6365 err_peer_del:
6366         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6367                 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6368                 if (fbret) {
6369                         ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6370                                     vif->addr, arvif->vdev_id, fbret);
6371                         goto err;
6372                 }
6373         }
6374
6375 err_vdev_del:
6376         ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6377         ar->num_created_vdevs--;
6378         ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6379         ab->free_vdev_map |= 1LL << arvif->vdev_id;
6380         spin_lock_bh(&ar->data_lock);
6381         list_del(&arvif->list);
6382         spin_unlock_bh(&ar->data_lock);
6383
6384 err:
6385         ath11k_debugfs_remove_interface(arvif);
6386         mutex_unlock(&ar->conf_mutex);
6387
6388         return ret;
6389 }
6390
6391 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6392 {
6393         struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx;
6394         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6395
6396         if (skb_cb->vif == vif)
6397                 skb_cb->vif = NULL;
6398
6399         return 0;
6400 }
6401
6402 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6403                                            struct ieee80211_vif *vif)
6404 {
6405         struct ath11k *ar = hw->priv;
6406         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6407         struct ath11k_base *ab = ar->ab;
6408         unsigned long time_left;
6409         int ret;
6410         int i;
6411
6412         cancel_delayed_work_sync(&arvif->connection_loss_work);
6413
6414         mutex_lock(&ar->conf_mutex);
6415
6416         ath11k_dbg(ab, ATH11K_DBG_MAC, "mac remove interface (vdev %d)\n",
6417                    arvif->vdev_id);
6418
6419         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
6420                 ath11k_mac_11d_scan_stop(ar);
6421
6422         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6423                 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6424                 if (ret)
6425                         ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
6426                                     arvif->vdev_id, ret);
6427         }
6428
6429         reinit_completion(&ar->vdev_delete_done);
6430
6431         ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6432         if (ret) {
6433                 ath11k_warn(ab, "failed to delete WMI vdev %d: %d\n",
6434                             arvif->vdev_id, ret);
6435                 goto err_vdev_del;
6436         }
6437
6438         time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6439                                                 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6440         if (time_left == 0) {
6441                 ath11k_warn(ab, "Timeout in receiving vdev delete response\n");
6442                 goto err_vdev_del;
6443         }
6444
6445         ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6446         ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6447         ar->num_created_vdevs--;
6448
6449         ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6450                    vif->addr, arvif->vdev_id);
6451
6452         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6453                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6454                 ar->monitor_vdev_id = -1;
6455         } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
6456                    !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
6457                 ret = ath11k_mac_monitor_vdev_delete(ar);
6458                 if (ret)
6459                         /* continue even if there's an error */
6460                         ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
6461                                     ret);
6462         }
6463
6464 err_vdev_del:
6465         spin_lock_bh(&ar->data_lock);
6466         list_del(&arvif->list);
6467         spin_unlock_bh(&ar->data_lock);
6468
6469         ath11k_peer_cleanup(ar, arvif->vdev_id);
6470
6471         idr_for_each(&ar->txmgmt_idr,
6472                      ath11k_mac_vif_txmgmt_idr_remove, vif);
6473
6474         for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
6475                 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6476                 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
6477                              ath11k_mac_vif_unref, vif);
6478                 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6479         }
6480
6481         /* Recalc txpower for remaining vdev */
6482         ath11k_mac_txpower_recalc(ar);
6483
6484         ath11k_debugfs_remove_interface(arvif);
6485
6486         /* TODO: recal traffic pause state based on the available vdevs */
6487
6488         mutex_unlock(&ar->conf_mutex);
6489 }
6490
6491 /* FIXME: Has to be verified. */
6492 #define SUPPORTED_FILTERS                       \
6493         (FIF_ALLMULTI |                         \
6494         FIF_CONTROL |                           \
6495         FIF_PSPOLL |                            \
6496         FIF_OTHER_BSS |                         \
6497         FIF_BCN_PRBRESP_PROMISC |               \
6498         FIF_PROBE_REQ |                         \
6499         FIF_FCSFAIL)
6500
6501 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
6502                                            unsigned int changed_flags,
6503                                            unsigned int *total_flags,
6504                                            u64 multicast)
6505 {
6506         struct ath11k *ar = hw->priv;
6507
6508         mutex_lock(&ar->conf_mutex);
6509
6510         *total_flags &= SUPPORTED_FILTERS;
6511         ar->filter_flags = *total_flags;
6512
6513         mutex_unlock(&ar->conf_mutex);
6514 }
6515
6516 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
6517 {
6518         struct ath11k *ar = hw->priv;
6519
6520         mutex_lock(&ar->conf_mutex);
6521
6522         *tx_ant = ar->cfg_tx_chainmask;
6523         *rx_ant = ar->cfg_rx_chainmask;
6524
6525         mutex_unlock(&ar->conf_mutex);
6526
6527         return 0;
6528 }
6529
6530 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
6531 {
6532         struct ath11k *ar = hw->priv;
6533         int ret;
6534
6535         mutex_lock(&ar->conf_mutex);
6536         ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
6537         mutex_unlock(&ar->conf_mutex);
6538
6539         return ret;
6540 }
6541
6542 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
6543                                       struct ieee80211_vif *vif,
6544                                       struct ieee80211_ampdu_params *params)
6545 {
6546         struct ath11k *ar = hw->priv;
6547         int ret = -EINVAL;
6548
6549         mutex_lock(&ar->conf_mutex);
6550
6551         switch (params->action) {
6552         case IEEE80211_AMPDU_RX_START:
6553                 ret = ath11k_dp_rx_ampdu_start(ar, params);
6554                 break;
6555         case IEEE80211_AMPDU_RX_STOP:
6556                 ret = ath11k_dp_rx_ampdu_stop(ar, params);
6557                 break;
6558         case IEEE80211_AMPDU_TX_START:
6559         case IEEE80211_AMPDU_TX_STOP_CONT:
6560         case IEEE80211_AMPDU_TX_STOP_FLUSH:
6561         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6562         case IEEE80211_AMPDU_TX_OPERATIONAL:
6563                 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
6564                  * Tx aggregation requests.
6565                  */
6566                 ret = -EOPNOTSUPP;
6567                 break;
6568         }
6569
6570         mutex_unlock(&ar->conf_mutex);
6571
6572         return ret;
6573 }
6574
6575 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6576                                      struct ieee80211_chanctx_conf *ctx)
6577 {
6578         struct ath11k *ar = hw->priv;
6579         struct ath11k_base *ab = ar->ab;
6580
6581         ath11k_dbg(ab, ATH11K_DBG_MAC,
6582                    "mac chanctx add freq %u width %d ptr %pK\n",
6583                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6584
6585         mutex_lock(&ar->conf_mutex);
6586
6587         spin_lock_bh(&ar->data_lock);
6588         /* TODO: In case of multiple channel context, populate rx_channel from
6589          * Rx PPDU desc information.
6590          */
6591         ar->rx_channel = ctx->def.chan;
6592         spin_unlock_bh(&ar->data_lock);
6593
6594         mutex_unlock(&ar->conf_mutex);
6595
6596         return 0;
6597 }
6598
6599 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6600                                          struct ieee80211_chanctx_conf *ctx)
6601 {
6602         struct ath11k *ar = hw->priv;
6603         struct ath11k_base *ab = ar->ab;
6604
6605         ath11k_dbg(ab, ATH11K_DBG_MAC,
6606                    "mac chanctx remove freq %u width %d ptr %pK\n",
6607                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6608
6609         mutex_lock(&ar->conf_mutex);
6610
6611         spin_lock_bh(&ar->data_lock);
6612         /* TODO: In case of there is one more channel context left, populate
6613          * rx_channel with the channel of that remaining channel context.
6614          */
6615         ar->rx_channel = NULL;
6616         spin_unlock_bh(&ar->data_lock);
6617
6618         mutex_unlock(&ar->conf_mutex);
6619 }
6620
6621 static int
6622 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
6623                               struct ieee80211_chanctx_conf *ctx,
6624                               bool restart)
6625 {
6626         struct ath11k *ar = arvif->ar;
6627         struct ath11k_base *ab = ar->ab;
6628         struct wmi_vdev_start_req_arg arg = {};
6629         const struct cfg80211_chan_def *chandef = &ctx->def;
6630         int he_support = arvif->vif->bss_conf.he_support;
6631         int ret = 0;
6632
6633         lockdep_assert_held(&ar->conf_mutex);
6634
6635         reinit_completion(&ar->vdev_setup_done);
6636
6637         arg.vdev_id = arvif->vdev_id;
6638         arg.dtim_period = arvif->dtim_period;
6639         arg.bcn_intval = arvif->beacon_interval;
6640
6641         arg.channel.freq = chandef->chan->center_freq;
6642         arg.channel.band_center_freq1 = chandef->center_freq1;
6643         arg.channel.band_center_freq2 = chandef->center_freq2;
6644         arg.channel.mode =
6645                 ath11k_phymodes[chandef->chan->band][chandef->width];
6646
6647         arg.channel.min_power = 0;
6648         arg.channel.max_power = chandef->chan->max_power;
6649         arg.channel.max_reg_power = chandef->chan->max_reg_power;
6650         arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
6651
6652         arg.pref_tx_streams = ar->num_tx_chains;
6653         arg.pref_rx_streams = ar->num_rx_chains;
6654
6655         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6656                 arg.ssid = arvif->u.ap.ssid;
6657                 arg.ssid_len = arvif->u.ap.ssid_len;
6658                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
6659
6660                 /* For now allow DFS for AP mode */
6661                 arg.channel.chan_radar =
6662                         !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
6663
6664                 arg.channel.freq2_radar = ctx->radar_enabled;
6665
6666                 arg.channel.passive = arg.channel.chan_radar;
6667
6668                 spin_lock_bh(&ab->base_lock);
6669                 arg.regdomain = ar->ab->dfs_region;
6670                 spin_unlock_bh(&ab->base_lock);
6671
6672                 if (he_support) {
6673                         ret = ath11k_set_he_mu_sounding_mode(ar, arvif);
6674                         if (ret) {
6675                                 ath11k_warn(ar->ab, "failed to set he mode vdev %i\n",
6676                                             arg.vdev_id);
6677                                 return ret;
6678                         }
6679                 }
6680         }
6681
6682         arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
6683
6684         ath11k_dbg(ab, ATH11K_DBG_MAC,
6685                    "mac vdev %d start center_freq %d phymode %s\n",
6686                    arg.vdev_id, arg.channel.freq,
6687                    ath11k_wmi_phymode_str(arg.channel.mode));
6688
6689         ret = ath11k_wmi_vdev_start(ar, &arg, restart);
6690         if (ret) {
6691                 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
6692                             restart ? "restart" : "start", arg.vdev_id);
6693                 return ret;
6694         }
6695
6696         ret = ath11k_mac_vdev_setup_sync(ar);
6697         if (ret) {
6698                 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
6699                             arg.vdev_id, restart ? "restart" : "start", ret);
6700                 return ret;
6701         }
6702
6703         if (!restart)
6704                 ar->num_started_vdevs++;
6705
6706         ath11k_dbg(ab, ATH11K_DBG_MAC,  "vdev %pM started, vdev_id %d\n",
6707                    arvif->vif->addr, arvif->vdev_id);
6708
6709         /* Enable CAC Flag in the driver by checking the channel DFS cac time,
6710          * i.e dfs_cac_ms value which will be valid only for radar channels
6711          * and state as NL80211_DFS_USABLE which indicates CAC needs to be
6712          * done before channel usage. This flags is used to drop rx packets.
6713          * during CAC.
6714          */
6715         /* TODO Set the flag for other interface types as required */
6716         if (arvif->vdev_type == WMI_VDEV_TYPE_AP &&
6717             chandef->chan->dfs_cac_ms &&
6718             chandef->chan->dfs_state == NL80211_DFS_USABLE) {
6719                 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6720                 ath11k_dbg(ab, ATH11K_DBG_MAC,
6721                            "CAC Started in chan_freq %d for vdev %d\n",
6722                            arg.channel.freq, arg.vdev_id);
6723         }
6724
6725         ret = ath11k_mac_set_txbf_conf(arvif);
6726         if (ret)
6727                 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
6728                             arvif->vdev_id, ret);
6729
6730         return 0;
6731 }
6732
6733 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
6734 {
6735         struct ath11k *ar = arvif->ar;
6736         int ret;
6737
6738         lockdep_assert_held(&ar->conf_mutex);
6739
6740         reinit_completion(&ar->vdev_setup_done);
6741
6742         ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
6743         if (ret) {
6744                 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
6745                             arvif->vdev_id, ret);
6746                 goto err;
6747         }
6748
6749         ret = ath11k_mac_vdev_setup_sync(ar);
6750         if (ret) {
6751                 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
6752                             arvif->vdev_id, ret);
6753                 goto err;
6754         }
6755
6756         WARN_ON(ar->num_started_vdevs == 0);
6757
6758         ar->num_started_vdevs--;
6759         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
6760                    arvif->vif->addr, arvif->vdev_id);
6761
6762         if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
6763                 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6764                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
6765                            arvif->vdev_id);
6766         }
6767
6768         return 0;
6769 err:
6770         return ret;
6771 }
6772
6773 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
6774                                  struct ieee80211_chanctx_conf *ctx)
6775 {
6776         return ath11k_mac_vdev_start_restart(arvif, ctx, false);
6777 }
6778
6779 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
6780                                    struct ieee80211_chanctx_conf *ctx)
6781 {
6782         return ath11k_mac_vdev_start_restart(arvif, ctx, true);
6783 }
6784
6785 struct ath11k_mac_change_chanctx_arg {
6786         struct ieee80211_chanctx_conf *ctx;
6787         struct ieee80211_vif_chanctx_switch *vifs;
6788         int n_vifs;
6789         int next_vif;
6790 };
6791
6792 static void
6793 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6794                                    struct ieee80211_vif *vif)
6795 {
6796         struct ath11k_mac_change_chanctx_arg *arg = data;
6797
6798         if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
6799                 return;
6800
6801         arg->n_vifs++;
6802 }
6803
6804 static void
6805 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6806                                     struct ieee80211_vif *vif)
6807 {
6808         struct ath11k_mac_change_chanctx_arg *arg = data;
6809         struct ieee80211_chanctx_conf *ctx;
6810
6811         ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
6812         if (ctx != arg->ctx)
6813                 return;
6814
6815         if (WARN_ON(arg->next_vif == arg->n_vifs))
6816                 return;
6817
6818         arg->vifs[arg->next_vif].vif = vif;
6819         arg->vifs[arg->next_vif].old_ctx = ctx;
6820         arg->vifs[arg->next_vif].new_ctx = ctx;
6821         arg->next_vif++;
6822 }
6823
6824 static void
6825 ath11k_mac_update_vif_chan(struct ath11k *ar,
6826                            struct ieee80211_vif_chanctx_switch *vifs,
6827                            int n_vifs)
6828 {
6829         struct ath11k_base *ab = ar->ab;
6830         struct ath11k_vif *arvif;
6831         int ret;
6832         int i;
6833         bool monitor_vif = false;
6834
6835         lockdep_assert_held(&ar->conf_mutex);
6836
6837         /* Associated channel resources of all relevant vdevs
6838          * should be available for the channel switch now.
6839          */
6840
6841         /* TODO: Update ar->rx_channel */
6842
6843         for (i = 0; i < n_vifs; i++) {
6844                 arvif = (void *)vifs[i].vif->drv_priv;
6845
6846                 if (WARN_ON(!arvif->is_started))
6847                         continue;
6848
6849                 /* change_chanctx can be called even before vdev_up from
6850                  * ieee80211_start_ap->ieee80211_vif_use_channel->
6851                  * ieee80211_recalc_radar_chanctx.
6852                  *
6853                  * Firmware expect vdev_restart only if vdev is up.
6854                  * If vdev is down then it expect vdev_stop->vdev_start.
6855                  */
6856                 if (arvif->is_up) {
6857                         ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
6858                         if (ret) {
6859                                 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
6860                                             arvif->vdev_id, ret);
6861                                 continue;
6862                         }
6863                 } else {
6864                         ret = ath11k_mac_vdev_stop(arvif);
6865                         if (ret) {
6866                                 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
6867                                             arvif->vdev_id, ret);
6868                                 continue;
6869                         }
6870
6871                         ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
6872                         if (ret)
6873                                 ath11k_warn(ab, "failed to start vdev %d: %d\n",
6874                                             arvif->vdev_id, ret);
6875
6876                         continue;
6877                 }
6878
6879                 ret = ath11k_mac_setup_bcn_tmpl(arvif);
6880                 if (ret)
6881                         ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
6882                                     ret);
6883
6884                 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6885                                          arvif->bssid);
6886                 if (ret) {
6887                         ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
6888                                     arvif->vdev_id, ret);
6889                         continue;
6890                 }
6891         }
6892
6893         /* Restart the internal monitor vdev on new channel */
6894         if (!monitor_vif &&
6895             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
6896                 ret = ath11k_mac_monitor_stop(ar);
6897                 if (ret) {
6898                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
6899                                     ret);
6900                         return;
6901                 }
6902
6903                 ret = ath11k_mac_monitor_start(ar);
6904                 if (ret) {
6905                         ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
6906                                     ret);
6907                         return;
6908                 }
6909         }
6910 }
6911
6912 static void
6913 ath11k_mac_update_active_vif_chan(struct ath11k *ar,
6914                                   struct ieee80211_chanctx_conf *ctx)
6915 {
6916         struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
6917
6918         lockdep_assert_held(&ar->conf_mutex);
6919
6920         ieee80211_iterate_active_interfaces_atomic(ar->hw,
6921                                                    IEEE80211_IFACE_ITER_NORMAL,
6922                                                    ath11k_mac_change_chanctx_cnt_iter,
6923                                                    &arg);
6924         if (arg.n_vifs == 0)
6925                 return;
6926
6927         arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
6928         if (!arg.vifs)
6929                 return;
6930
6931         ieee80211_iterate_active_interfaces_atomic(ar->hw,
6932                                                    IEEE80211_IFACE_ITER_NORMAL,
6933                                                    ath11k_mac_change_chanctx_fill_iter,
6934                                                    &arg);
6935
6936         ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6937
6938         kfree(arg.vifs);
6939 }
6940
6941 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6942                                          struct ieee80211_chanctx_conf *ctx,
6943                                          u32 changed)
6944 {
6945         struct ath11k *ar = hw->priv;
6946         struct ath11k_base *ab = ar->ab;
6947
6948         mutex_lock(&ar->conf_mutex);
6949
6950         ath11k_dbg(ab, ATH11K_DBG_MAC,
6951                    "mac chanctx change freq %u width %d ptr %pK changed %x\n",
6952                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6953
6954         /* This shouldn't really happen because channel switching should use
6955          * switch_vif_chanctx().
6956          */
6957         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6958                 goto unlock;
6959
6960         if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
6961             changed & IEEE80211_CHANCTX_CHANGE_RADAR)
6962                 ath11k_mac_update_active_vif_chan(ar, ctx);
6963
6964         /* TODO: Recalc radar detection */
6965
6966 unlock:
6967         mutex_unlock(&ar->conf_mutex);
6968 }
6969
6970 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
6971                                    struct ieee80211_vif *vif)
6972 {
6973         struct ath11k *ar = hw->priv;
6974         struct ath11k_base *ab = ar->ab;
6975         struct ath11k_vif *arvif = (void *)vif->drv_priv;
6976         int ret;
6977
6978         if (WARN_ON(arvif->is_started))
6979                 return -EBUSY;
6980
6981         ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
6982         if (ret) {
6983                 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
6984                             arvif->vdev_id, vif->addr,
6985                             arvif->chanctx.def.chan->center_freq, ret);
6986                 return ret;
6987         }
6988
6989         /* Reconfigure hardware rate code since it is cleared by firmware.
6990          */
6991         if (ar->hw_rate_code > 0) {
6992                 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
6993
6994                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
6995                                                     ar->hw_rate_code);
6996                 if (ret) {
6997                         ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
6998                         return ret;
6999                 }
7000         }
7001
7002         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7003                 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr);
7004                 if (ret) {
7005                         ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7006                         return ret;
7007                 }
7008         }
7009
7010         arvif->is_started = true;
7011
7012         /* TODO: Setup ps and cts/rts protection */
7013         return 0;
7014 }
7015
7016 static int
7017 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7018                                  struct ieee80211_vif *vif,
7019                                  struct ieee80211_bss_conf *link_conf,
7020                                  struct ieee80211_chanctx_conf *ctx)
7021 {
7022         struct ath11k *ar = hw->priv;
7023         struct ath11k_base *ab = ar->ab;
7024         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7025         int ret;
7026         struct peer_create_params param;
7027
7028         mutex_lock(&ar->conf_mutex);
7029
7030         ath11k_dbg(ab, ATH11K_DBG_MAC,
7031                    "mac chanctx assign ptr %pK vdev_id %i\n",
7032                    ctx, arvif->vdev_id);
7033
7034         /* for QCA6390 bss peer must be created before vdev_start */
7035         if (ab->hw_params.vdev_start_delay &&
7036             arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7037             arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7038             !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
7039                 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
7040                 ret = 0;
7041                 goto out;
7042         }
7043
7044         if (WARN_ON(arvif->is_started)) {
7045                 ret = -EBUSY;
7046                 goto out;
7047         }
7048
7049         if (ab->hw_params.vdev_start_delay &&
7050             arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7051             arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
7052                 param.vdev_id = arvif->vdev_id;
7053                 param.peer_type = WMI_PEER_TYPE_DEFAULT;
7054                 param.peer_addr = ar->mac_addr;
7055
7056                 ret = ath11k_peer_create(ar, arvif, NULL, &param);
7057                 if (ret) {
7058                         ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7059                                     ret);
7060                         goto out;
7061                 }
7062         }
7063
7064         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7065                 ret = ath11k_mac_monitor_start(ar);
7066                 if (ret) {
7067                         ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7068                                     ret);
7069                         goto out;
7070                 }
7071
7072                 arvif->is_started = true;
7073                 goto out;
7074         }
7075
7076         ret = ath11k_mac_vdev_start(arvif, ctx);
7077         if (ret) {
7078                 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7079                             arvif->vdev_id, vif->addr,
7080                             ctx->def.chan->center_freq, ret);
7081                 goto out;
7082         }
7083
7084         arvif->is_started = true;
7085
7086         if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7087             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7088                 ret = ath11k_mac_monitor_start(ar);
7089                 if (ret) {
7090                         ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7091                                     ret);
7092                         goto out;
7093                 }
7094         }
7095
7096         /* TODO: Setup ps and cts/rts protection */
7097
7098         ret = 0;
7099
7100 out:
7101         mutex_unlock(&ar->conf_mutex);
7102
7103         return ret;
7104 }
7105
7106 static void
7107 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7108                                    struct ieee80211_vif *vif,
7109                                    struct ieee80211_bss_conf *link_conf,
7110                                    struct ieee80211_chanctx_conf *ctx)
7111 {
7112         struct ath11k *ar = hw->priv;
7113         struct ath11k_base *ab = ar->ab;
7114         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7115         struct ath11k_peer *peer;
7116         int ret;
7117
7118         mutex_lock(&ar->conf_mutex);
7119
7120         ath11k_dbg(ab, ATH11K_DBG_MAC,
7121                    "mac chanctx unassign ptr %pK vdev_id %i\n",
7122                    ctx, arvif->vdev_id);
7123
7124         WARN_ON(!arvif->is_started);
7125
7126         if (ab->hw_params.vdev_start_delay &&
7127             arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7128                 spin_lock_bh(&ab->base_lock);
7129                 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7130                 spin_unlock_bh(&ab->base_lock);
7131                 if (peer)
7132                         ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7133         }
7134
7135         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7136                 ret = ath11k_mac_monitor_stop(ar);
7137                 if (ret) {
7138                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7139                                     ret);
7140                         mutex_unlock(&ar->conf_mutex);
7141                         return;
7142                 }
7143
7144                 arvif->is_started = false;
7145                 mutex_unlock(&ar->conf_mutex);
7146                 return;
7147         }
7148
7149         ret = ath11k_mac_vdev_stop(arvif);
7150         if (ret)
7151                 ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7152                             arvif->vdev_id, ret);
7153
7154         arvif->is_started = false;
7155
7156         if (ab->hw_params.vdev_start_delay &&
7157             arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7158                 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7159                 if (ret)
7160                         ath11k_warn(ar->ab,
7161                                     "failed to delete peer %pM for vdev %d: %d\n",
7162                                     arvif->bssid, arvif->vdev_id, ret);
7163                 else
7164                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7165                                    "mac removed peer %pM  vdev %d after vdev stop\n",
7166                                    arvif->bssid, arvif->vdev_id);
7167         }
7168
7169         if (ab->hw_params.vdev_start_delay &&
7170             arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7171                 ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7172
7173         if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7174             ar->num_started_vdevs == 1 &&
7175             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7176                 ret = ath11k_mac_monitor_stop(ar);
7177                 if (ret)
7178                         /* continue even if there's an error */
7179                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7180                                     ret);
7181         }
7182
7183         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7184                 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
7185
7186         mutex_unlock(&ar->conf_mutex);
7187 }
7188
7189 static int
7190 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7191                                  struct ieee80211_vif_chanctx_switch *vifs,
7192                                  int n_vifs,
7193                                  enum ieee80211_chanctx_switch_mode mode)
7194 {
7195         struct ath11k *ar = hw->priv;
7196
7197         mutex_lock(&ar->conf_mutex);
7198
7199         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7200                    "mac chanctx switch n_vifs %d mode %d\n",
7201                    n_vifs, mode);
7202         ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7203
7204         mutex_unlock(&ar->conf_mutex);
7205
7206         return 0;
7207 }
7208
7209 static int
7210 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7211 {
7212         struct ath11k_vif *arvif;
7213         int ret = 0;
7214
7215         mutex_lock(&ar->conf_mutex);
7216         list_for_each_entry(arvif, &ar->arvifs, list) {
7217                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7218                            param, arvif->vdev_id, value);
7219
7220                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7221                                                     param, value);
7222                 if (ret) {
7223                         ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7224                                     param, arvif->vdev_id, ret);
7225                         break;
7226                 }
7227         }
7228         mutex_unlock(&ar->conf_mutex);
7229         return ret;
7230 }
7231
7232 /* mac80211 stores device specific RTS/Fragmentation threshold value,
7233  * this is set interface specific to firmware from ath11k driver
7234  */
7235 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7236 {
7237         struct ath11k *ar = hw->priv;
7238         int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7239
7240         return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7241 }
7242
7243 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7244 {
7245         /* Even though there's a WMI vdev param for fragmentation threshold no
7246          * known firmware actually implements it. Moreover it is not possible to
7247          * rely frame fragmentation to mac80211 because firmware clears the
7248          * "more fragments" bit in frame control making it impossible for remote
7249          * devices to reassemble frames.
7250          *
7251          * Hence implement a dummy callback just to say fragmentation isn't
7252          * supported. This effectively prevents mac80211 from doing frame
7253          * fragmentation in software.
7254          */
7255         return -EOPNOTSUPP;
7256 }
7257
7258 static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
7259 {
7260         long time_left;
7261         int ret = 0;
7262
7263         time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7264                                        (atomic_read(&ar->dp.num_tx_pending) == 0),
7265                                        ATH11K_FLUSH_TIMEOUT);
7266         if (time_left == 0) {
7267                 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7268                             atomic_read(&ar->dp.num_tx_pending));
7269                 ret = -ETIMEDOUT;
7270         }
7271
7272         time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7273                                        (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7274                                        ATH11K_FLUSH_TIMEOUT);
7275         if (time_left == 0) {
7276                 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7277                             atomic_read(&ar->num_pending_mgmt_tx));
7278                 ret = -ETIMEDOUT;
7279         }
7280
7281         return ret;
7282 }
7283
7284 int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7285 {
7286         ath11k_mac_drain_tx(ar);
7287         return ath11k_mac_flush_tx_complete(ar);
7288 }
7289
7290 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7291                                 u32 queues, bool drop)
7292 {
7293         struct ath11k *ar = hw->priv;
7294
7295         if (drop)
7296                 return;
7297
7298         ath11k_mac_flush_tx_complete(ar);
7299 }
7300
7301 static int
7302 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
7303                                      enum nl80211_band band,
7304                                      const struct cfg80211_bitrate_mask *mask)
7305 {
7306         int num_rates = 0;
7307         int i;
7308
7309         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
7310                 num_rates += hweight16(mask->control[band].ht_mcs[i]);
7311
7312         return num_rates;
7313 }
7314
7315 static bool
7316 ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7317                                   enum nl80211_band band,
7318                                   const struct cfg80211_bitrate_mask *mask)
7319 {
7320         int num_rates = 0;
7321
7322         num_rates = hweight32(mask->control[band].legacy);
7323
7324         if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7325                 return false;
7326
7327         if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7328                 return false;
7329
7330         if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7331                 return false;
7332
7333         return num_rates == 1;
7334 }
7335
7336 static __le16
7337 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7338 {
7339         if (he_cap->he_cap_elem.phy_cap_info[0] &
7340             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7341                 return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7342
7343         if (he_cap->he_cap_elem.phy_cap_info[0] &
7344             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7345                 return he_cap->he_mcs_nss_supp.tx_mcs_160;
7346
7347         return he_cap->he_mcs_nss_supp.tx_mcs_80;
7348 }
7349
7350 static bool
7351 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7352                                        enum nl80211_band band,
7353                                        const struct cfg80211_bitrate_mask *mask,
7354                                        int *nss)
7355 {
7356         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7357         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7358         u16 he_mcs_map = 0;
7359         u8 ht_nss_mask = 0;
7360         u8 vht_nss_mask = 0;
7361         u8 he_nss_mask = 0;
7362         int i;
7363
7364         /* No need to consider legacy here. Basic rates are always present
7365          * in bitrate mask
7366          */
7367
7368         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7369                 if (mask->control[band].ht_mcs[i] == 0)
7370                         continue;
7371                 else if (mask->control[band].ht_mcs[i] ==
7372                          sband->ht_cap.mcs.rx_mask[i])
7373                         ht_nss_mask |= BIT(i);
7374                 else
7375                         return false;
7376         }
7377
7378         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7379                 if (mask->control[band].vht_mcs[i] == 0)
7380                         continue;
7381                 else if (mask->control[band].vht_mcs[i] ==
7382                          ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7383                         vht_nss_mask |= BIT(i);
7384                 else
7385                         return false;
7386         }
7387
7388         he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap));
7389
7390         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7391                 if (mask->control[band].he_mcs[i] == 0)
7392                         continue;
7393
7394                 if (mask->control[band].he_mcs[i] ==
7395                     ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7396                         he_nss_mask |= BIT(i);
7397                 else
7398                         return false;
7399         }
7400
7401         if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
7402                 return false;
7403
7404         if (ht_nss_mask == 0)
7405                 return false;
7406
7407         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7408                 return false;
7409
7410         *nss = fls(ht_nss_mask);
7411
7412         return true;
7413 }
7414
7415 static int
7416 ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7417                                   enum nl80211_band band,
7418                                   const struct cfg80211_bitrate_mask *mask,
7419                                   u32 *rate, u8 *nss)
7420 {
7421         int rate_idx;
7422         u16 bitrate;
7423         u8 preamble;
7424         u8 hw_rate;
7425
7426         if (hweight32(mask->control[band].legacy) != 1)
7427                 return -EINVAL;
7428
7429         rate_idx = ffs(mask->control[band].legacy) - 1;
7430
7431         if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
7432                 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
7433
7434         hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
7435         bitrate = ath11k_legacy_rates[rate_idx].bitrate;
7436
7437         if (ath11k_mac_bitrate_is_cck(bitrate))
7438                 preamble = WMI_RATE_PREAMBLE_CCK;
7439         else
7440                 preamble = WMI_RATE_PREAMBLE_OFDM;
7441
7442         *nss = 1;
7443         *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
7444
7445         return 0;
7446 }
7447
7448 static int
7449 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
7450 {
7451         struct ath11k *ar = arvif->ar;
7452         int ret;
7453
7454         /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
7455         if (he_gi && he_gi != 0xFF)
7456                 he_gi += 1;
7457
7458         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7459                                             WMI_VDEV_PARAM_SGI, he_gi);
7460         if (ret) {
7461                 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
7462                             he_gi, ret);
7463                 return ret;
7464         }
7465         /* start from 1 */
7466         if (he_ltf != 0xFF)
7467                 he_ltf += 1;
7468
7469         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7470                                             WMI_VDEV_PARAM_HE_LTF, he_ltf);
7471         if (ret) {
7472                 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
7473                             he_ltf, ret);
7474                 return ret;
7475         }
7476
7477         return 0;
7478 }
7479
7480 static int
7481 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
7482 {
7483         struct ath11k *ar = arvif->ar;
7484         int ret;
7485         u32 he_ar_gi_ltf;
7486
7487         if (he_gi != 0xFF) {
7488                 switch (he_gi) {
7489                 case NL80211_RATE_INFO_HE_GI_0_8:
7490                         he_gi = WMI_AUTORATE_800NS_GI;
7491                         break;
7492                 case NL80211_RATE_INFO_HE_GI_1_6:
7493                         he_gi = WMI_AUTORATE_1600NS_GI;
7494                         break;
7495                 case NL80211_RATE_INFO_HE_GI_3_2:
7496                         he_gi = WMI_AUTORATE_3200NS_GI;
7497                         break;
7498                 default:
7499                         ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
7500                         return -EINVAL;
7501                 }
7502         }
7503
7504         if (he_ltf != 0xFF) {
7505                 switch (he_ltf) {
7506                 case NL80211_RATE_INFO_HE_1XLTF:
7507                         he_ltf = WMI_HE_AUTORATE_LTF_1X;
7508                         break;
7509                 case NL80211_RATE_INFO_HE_2XLTF:
7510                         he_ltf = WMI_HE_AUTORATE_LTF_2X;
7511                         break;
7512                 case NL80211_RATE_INFO_HE_4XLTF:
7513                         he_ltf = WMI_HE_AUTORATE_LTF_4X;
7514                         break;
7515                 default:
7516                         ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
7517                         return -EINVAL;
7518                 }
7519         }
7520
7521         he_ar_gi_ltf = he_gi | he_ltf;
7522         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7523                                             WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
7524                                             he_ar_gi_ltf);
7525         if (ret) {
7526                 ath11k_warn(ar->ab,
7527                             "failed to set he autorate gi %u ltf %u: %d\n",
7528                             he_gi, he_ltf, ret);
7529                 return ret;
7530         }
7531
7532         return 0;
7533 }
7534
7535 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
7536                                       u32 rate, u8 nss, u8 sgi, u8 ldpc,
7537                                       u8 he_gi, u8 he_ltf, bool he_fixed_rate)
7538 {
7539         struct ath11k *ar = arvif->ar;
7540         u32 vdev_param;
7541         int ret;
7542
7543         lockdep_assert_held(&ar->conf_mutex);
7544
7545         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7546                    "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",
7547                    arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
7548                    he_ltf, he_fixed_rate);
7549
7550         if (!arvif->vif->bss_conf.he_support) {
7551                 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
7552                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7553                                                     vdev_param, rate);
7554                 if (ret) {
7555                         ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
7556                                     rate, ret);
7557                         return ret;
7558                 }
7559         }
7560
7561         vdev_param = WMI_VDEV_PARAM_NSS;
7562         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7563                                             vdev_param, nss);
7564         if (ret) {
7565                 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
7566                             nss, ret);
7567                 return ret;
7568         }
7569
7570         vdev_param = WMI_VDEV_PARAM_LDPC;
7571         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7572                                             vdev_param, ldpc);
7573         if (ret) {
7574                 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
7575                             ldpc, ret);
7576                 return ret;
7577         }
7578
7579         if (arvif->vif->bss_conf.he_support) {
7580                 if (he_fixed_rate) {
7581                         ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
7582                                                                he_ltf);
7583                         if (ret) {
7584                                 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
7585                                             ret);
7586                                 return ret;
7587                         }
7588                 } else {
7589                         ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
7590                                                               he_ltf);
7591                         if (ret) {
7592                                 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
7593                                             ret);
7594                                 return ret;
7595                         }
7596                 }
7597         } else {
7598                 vdev_param = WMI_VDEV_PARAM_SGI;
7599                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7600                                                     vdev_param, sgi);
7601                 if (ret) {
7602                         ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
7603                                     sgi, ret);
7604                         return ret;
7605                 }
7606         }
7607
7608         return 0;
7609 }
7610
7611 static bool
7612 ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
7613                                  enum nl80211_band band,
7614                                  const struct cfg80211_bitrate_mask *mask)
7615 {
7616         int i;
7617         u16 vht_mcs;
7618
7619         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
7620                 vht_mcs = mask->control[band].vht_mcs[i];
7621
7622                 switch (vht_mcs) {
7623                 case 0:
7624                 case BIT(8) - 1:
7625                 case BIT(9) - 1:
7626                 case BIT(10) - 1:
7627                         break;
7628                 default:
7629                         return false;
7630                 }
7631         }
7632
7633         return true;
7634 }
7635
7636 static bool
7637 ath11k_mac_he_mcs_range_present(struct ath11k *ar,
7638                                 enum nl80211_band band,
7639                                 const struct cfg80211_bitrate_mask *mask)
7640 {
7641         int i;
7642         u16 he_mcs;
7643
7644         for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
7645                 he_mcs = mask->control[band].he_mcs[i];
7646
7647                 switch (he_mcs) {
7648                 case 0:
7649                 case BIT(8) - 1:
7650                 case BIT(10) - 1:
7651                 case BIT(12) - 1:
7652                         break;
7653                 default:
7654                         return false;
7655                 }
7656         }
7657
7658         return true;
7659 }
7660
7661 static void ath11k_mac_set_bitrate_mask_iter(void *data,
7662                                              struct ieee80211_sta *sta)
7663 {
7664         struct ath11k_vif *arvif = data;
7665         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
7666         struct ath11k *ar = arvif->ar;
7667
7668         spin_lock_bh(&ar->data_lock);
7669         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
7670         spin_unlock_bh(&ar->data_lock);
7671
7672         ieee80211_queue_work(ar->hw, &arsta->update_wk);
7673 }
7674
7675 static void ath11k_mac_disable_peer_fixed_rate(void *data,
7676                                                struct ieee80211_sta *sta)
7677 {
7678         struct ath11k_vif *arvif = data;
7679         struct ath11k *ar = arvif->ar;
7680         int ret;
7681
7682         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
7683                                         arvif->vdev_id,
7684                                         WMI_PEER_PARAM_FIXED_RATE,
7685                                         WMI_FIXED_RATE_NONE);
7686         if (ret)
7687                 ath11k_warn(ar->ab,
7688                             "failed to disable peer fixed rate for STA %pM ret %d\n",
7689                             sta->addr, ret);
7690 }
7691
7692 static bool
7693 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
7694                                                const struct cfg80211_bitrate_mask *mask)
7695 {
7696         bool he_fixed_rate = false, vht_fixed_rate = false;
7697         struct ath11k_peer *peer, *tmp;
7698         const u16 *vht_mcs_mask, *he_mcs_mask;
7699         struct ieee80211_link_sta *deflink;
7700         u8 vht_nss, he_nss;
7701         bool ret = true;
7702
7703         vht_mcs_mask = mask->control[band].vht_mcs;
7704         he_mcs_mask = mask->control[band].he_mcs;
7705
7706         if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
7707                 vht_fixed_rate = true;
7708
7709         if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
7710                 he_fixed_rate = true;
7711
7712         if (!vht_fixed_rate && !he_fixed_rate)
7713                 return true;
7714
7715         vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
7716         he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
7717
7718         rcu_read_lock();
7719         spin_lock_bh(&ar->ab->base_lock);
7720         list_for_each_entry_safe(peer, tmp, &ar->ab->peers, list) {
7721                 if (peer->sta) {
7722                         deflink = &peer->sta->deflink;
7723
7724                         if (vht_fixed_rate && (!deflink->vht_cap.vht_supported ||
7725                                                deflink->rx_nss < vht_nss)) {
7726                                 ret = false;
7727                                 goto out;
7728                         }
7729
7730                         if (he_fixed_rate && (!deflink->he_cap.has_he ||
7731                                               deflink->rx_nss < he_nss)) {
7732                                 ret = false;
7733                                 goto out;
7734                         }
7735                 }
7736         }
7737
7738 out:
7739         spin_unlock_bh(&ar->ab->base_lock);
7740         rcu_read_unlock();
7741         return ret;
7742 }
7743
7744 static int
7745 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
7746                                struct ieee80211_vif *vif,
7747                                const struct cfg80211_bitrate_mask *mask)
7748 {
7749         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7750         struct cfg80211_chan_def def;
7751         struct ath11k_pdev_cap *cap;
7752         struct ath11k *ar = arvif->ar;
7753         enum nl80211_band band;
7754         const u8 *ht_mcs_mask;
7755         const u16 *vht_mcs_mask;
7756         const u16 *he_mcs_mask;
7757         u8 he_ltf = 0;
7758         u8 he_gi = 0;
7759         u32 rate;
7760         u8 nss;
7761         u8 sgi;
7762         u8 ldpc;
7763         int single_nss;
7764         int ret;
7765         int num_rates;
7766         bool he_fixed_rate = false;
7767
7768         if (ath11k_mac_vif_chan(vif, &def))
7769                 return -EPERM;
7770
7771         band = def.chan->band;
7772         cap = &ar->pdev->cap;
7773         ht_mcs_mask = mask->control[band].ht_mcs;
7774         vht_mcs_mask = mask->control[band].vht_mcs;
7775         he_mcs_mask = mask->control[band].he_mcs;
7776         ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC);
7777
7778         sgi = mask->control[band].gi;
7779         if (sgi == NL80211_TXRATE_FORCE_LGI)
7780                 return -EINVAL;
7781
7782         he_gi = mask->control[band].he_gi;
7783         he_ltf = mask->control[band].he_ltf;
7784
7785         /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
7786          * requires passing at least one of used basic rates along with them.
7787          * Fixed rate setting across different preambles(legacy, HT, VHT) is
7788          * not supported by the FW. Hence use of FIXED_RATE vdev param is not
7789          * suitable for setting single HT/VHT rates.
7790          * But, there could be a single basic rate passed from userspace which
7791          * can be done through the FIXED_RATE param.
7792          */
7793         if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
7794                 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
7795                                                         &nss);
7796                 if (ret) {
7797                         ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
7798                                     arvif->vdev_id, ret);
7799                         return ret;
7800                 }
7801                 ieee80211_iterate_stations_atomic(ar->hw,
7802                                                   ath11k_mac_disable_peer_fixed_rate,
7803                                                   arvif);
7804         } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask,
7805                                                           &single_nss)) {
7806                 rate = WMI_FIXED_RATE_NONE;
7807                 nss = single_nss;
7808                 mutex_lock(&ar->conf_mutex);
7809                 arvif->bitrate_mask = *mask;
7810                 ieee80211_iterate_stations_atomic(ar->hw,
7811                                                   ath11k_mac_set_bitrate_mask_iter,
7812                                                   arvif);
7813                 mutex_unlock(&ar->conf_mutex);
7814         } else {
7815                 rate = WMI_FIXED_RATE_NONE;
7816
7817                 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
7818                         ath11k_warn(ar->ab,
7819                                     "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
7820                 nss = min_t(u32, ar->num_tx_chains,
7821                             max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
7822                                     ath11k_mac_max_vht_nss(vht_mcs_mask)),
7823                                 ath11k_mac_max_he_nss(he_mcs_mask)));
7824
7825                 /* If multiple rates across different preambles are given
7826                  * we can reconfigure this info with all peers using PEER_ASSOC
7827                  * command with the below exception cases.
7828                  * - Single VHT Rate : peer_assoc command accommodates only MCS
7829                  * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
7830                  * mandates passing basic rates along with HT/VHT rates, FW
7831                  * doesn't allow switching from VHT to Legacy. Hence instead of
7832                  * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
7833                  * we could set this VHT rate as peer fixed rate param, which
7834                  * will override FIXED rate and FW rate control algorithm.
7835                  * If single VHT rate is passed along with HT rates, we select
7836                  * the VHT rate as fixed rate for vht peers.
7837                  * - Multiple VHT Rates : When Multiple VHT rates are given,this
7838                  * can be set using RATEMASK CMD which uses FW rate-ctl alg.
7839                  * TODO: Setting multiple VHT MCS and replacing peer_assoc with
7840                  * RATEMASK_CMDID can cover all use cases of setting rates
7841                  * across multiple preambles and rates within same type.
7842                  * But requires more validation of the command at this point.
7843                  */
7844
7845                 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
7846                                                                   mask);
7847
7848                 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
7849                     num_rates > 1) {
7850                         /* TODO: Handle multiple VHT MCS values setting using
7851                          * RATEMASK CMD
7852                          */
7853                         ath11k_warn(ar->ab,
7854                                     "setting %d mcs values in bitrate mask not supported\n",
7855                                 num_rates);
7856                         return -EINVAL;
7857                 }
7858
7859                 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
7860                                                                  mask);
7861                 if (num_rates == 1)
7862                         he_fixed_rate = true;
7863
7864                 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
7865                     num_rates > 1) {
7866                         ath11k_warn(ar->ab,
7867                                     "Setting more than one HE MCS Value in bitrate mask not supported\n");
7868                         return -EINVAL;
7869                 }
7870
7871                 mutex_lock(&ar->conf_mutex);
7872                 ieee80211_iterate_stations_atomic(ar->hw,
7873                                                   ath11k_mac_disable_peer_fixed_rate,
7874                                                   arvif);
7875
7876                 arvif->bitrate_mask = *mask;
7877                 ieee80211_iterate_stations_atomic(ar->hw,
7878                                                   ath11k_mac_set_bitrate_mask_iter,
7879                                                   arvif);
7880
7881                 mutex_unlock(&ar->conf_mutex);
7882         }
7883
7884         mutex_lock(&ar->conf_mutex);
7885
7886         ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
7887                                          he_ltf, he_fixed_rate);
7888         if (ret) {
7889                 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
7890                             arvif->vdev_id, ret);
7891         }
7892
7893         mutex_unlock(&ar->conf_mutex);
7894
7895         return ret;
7896 }
7897
7898 static void
7899 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
7900                                 enum ieee80211_reconfig_type reconfig_type)
7901 {
7902         struct ath11k *ar = hw->priv;
7903         struct ath11k_base *ab = ar->ab;
7904         int recovery_count;
7905
7906         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
7907                 return;
7908
7909         mutex_lock(&ar->conf_mutex);
7910
7911         if (ar->state == ATH11K_STATE_RESTARTED) {
7912                 ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
7913                             ar->pdev->pdev_id);
7914                 ar->state = ATH11K_STATE_ON;
7915                 ieee80211_wake_queues(ar->hw);
7916
7917                 if (ar->ab->hw_params.current_cc_support &&
7918                     ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
7919                         struct wmi_set_current_country_params set_current_param = {};
7920
7921                         memcpy(&set_current_param.alpha2, ar->alpha2, 2);
7922                         ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
7923                 }
7924
7925                 if (ab->is_reset) {
7926                         recovery_count = atomic_inc_return(&ab->recovery_count);
7927                         ath11k_dbg(ab, ATH11K_DBG_BOOT,
7928                                    "recovery count %d\n", recovery_count);
7929                         /* When there are multiple radios in an SOC,
7930                          * the recovery has to be done for each radio
7931                          */
7932                         if (recovery_count == ab->num_radios) {
7933                                 atomic_dec(&ab->reset_count);
7934                                 complete(&ab->reset_complete);
7935                                 ab->is_reset = false;
7936                                 atomic_set(&ab->fail_cont_count, 0);
7937                                 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
7938                         }
7939                 }
7940         }
7941
7942         mutex_unlock(&ar->conf_mutex);
7943 }
7944
7945 static void
7946 ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
7947                                   struct ieee80211_channel *channel)
7948 {
7949         int ret;
7950         enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
7951
7952         lockdep_assert_held(&ar->conf_mutex);
7953
7954         if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
7955             ar->rx_channel != channel)
7956                 return;
7957
7958         if (ar->scan.state != ATH11K_SCAN_IDLE) {
7959                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7960                            "ignoring bss chan info req while scanning..\n");
7961                 return;
7962         }
7963
7964         reinit_completion(&ar->bss_survey_done);
7965
7966         ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
7967         if (ret) {
7968                 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
7969                 return;
7970         }
7971
7972         ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
7973         if (ret == 0)
7974                 ath11k_warn(ar->ab, "bss channel survey timed out\n");
7975 }
7976
7977 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
7978                                     struct survey_info *survey)
7979 {
7980         struct ath11k *ar = hw->priv;
7981         struct ieee80211_supported_band *sband;
7982         struct survey_info *ar_survey;
7983         int ret = 0;
7984
7985         if (idx >= ATH11K_NUM_CHANS)
7986                 return -ENOENT;
7987
7988         ar_survey = &ar->survey[idx];
7989
7990         mutex_lock(&ar->conf_mutex);
7991
7992         sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
7993         if (sband && idx >= sband->n_channels) {
7994                 idx -= sband->n_channels;
7995                 sband = NULL;
7996         }
7997
7998         if (!sband)
7999                 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8000         if (sband && idx >= sband->n_channels) {
8001                 idx -= sband->n_channels;
8002                 sband = NULL;
8003         }
8004
8005         if (!sband)
8006                 sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
8007         if (!sband || idx >= sband->n_channels) {
8008                 ret = -ENOENT;
8009                 goto exit;
8010         }
8011
8012         ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8013
8014         spin_lock_bh(&ar->data_lock);
8015         memcpy(survey, ar_survey, sizeof(*survey));
8016         spin_unlock_bh(&ar->data_lock);
8017
8018         survey->channel = &sband->channels[idx];
8019
8020         if (ar->rx_channel == survey->channel)
8021                 survey->filled |= SURVEY_INFO_IN_USE;
8022
8023 exit:
8024         mutex_unlock(&ar->conf_mutex);
8025         return ret;
8026 }
8027
8028 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8029                                       struct ath11k_sta *arsta,
8030                                       char *pre,
8031                                       bool clear)
8032 {
8033         struct ath11k *ar = arsta->arvif->ar;
8034         int i;
8035         s8 rssi;
8036
8037         for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8038                 sinfo->chains &= ~BIT(i);
8039                 rssi = arsta->chain_signal[i];
8040                 if (clear)
8041                         arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8042
8043                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8044                            "mac sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8045
8046                 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8047                     rssi != ATH11K_INVALID_RSSI_FULL &&
8048                     rssi != ATH11K_INVALID_RSSI_EMPTY &&
8049                     rssi != 0) {
8050                         sinfo->chain_signal[i] = rssi;
8051                         sinfo->chains |= BIT(i);
8052                         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8053                 }
8054         }
8055 }
8056
8057 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8058                                          struct ieee80211_vif *vif,
8059                                          struct ieee80211_sta *sta,
8060                                          struct station_info *sinfo)
8061 {
8062         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
8063         struct ath11k *ar = arsta->arvif->ar;
8064         s8 signal;
8065         bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8066                                ar->ab->wmi_ab.svc_map);
8067
8068         sinfo->rx_duration = arsta->rx_duration;
8069         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8070
8071         sinfo->tx_duration = arsta->tx_duration;
8072         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8073
8074         if (arsta->txrate.legacy || arsta->txrate.nss) {
8075                 if (arsta->txrate.legacy) {
8076                         sinfo->txrate.legacy = arsta->txrate.legacy;
8077                 } else {
8078                         sinfo->txrate.mcs = arsta->txrate.mcs;
8079                         sinfo->txrate.nss = arsta->txrate.nss;
8080                         sinfo->txrate.bw = arsta->txrate.bw;
8081                         sinfo->txrate.he_gi = arsta->txrate.he_gi;
8082                         sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8083                         sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8084                 }
8085                 sinfo->txrate.flags = arsta->txrate.flags;
8086                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8087         }
8088
8089         ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8090
8091         if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8092             arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8093             ar->ab->hw_params.supports_rssi_stats &&
8094             !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8095                                          WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8096                 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8097         }
8098
8099         signal = arsta->rssi_comb;
8100         if (!signal &&
8101             arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8102             ar->ab->hw_params.supports_rssi_stats &&
8103             !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8104                                         WMI_REQUEST_VDEV_STAT)))
8105                 signal = arsta->rssi_beacon;
8106
8107         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8108                    "mac sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8109                    db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8110
8111         if (signal) {
8112                 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8113                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8114         }
8115
8116         sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) +
8117                 ATH11K_DEFAULT_NOISE_FLOOR;
8118         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
8119 }
8120
8121 #if IS_ENABLED(CONFIG_IPV6)
8122 static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8123                                        struct ath11k_arp_ns_offload *offload)
8124 {
8125         int i;
8126
8127         for (i = 0; i < offload->ipv6_count; i++) {
8128                 offload->self_ipv6_addr[i][0] = 0xff;
8129                 offload->self_ipv6_addr[i][1] = 0x02;
8130                 offload->self_ipv6_addr[i][11] = 0x01;
8131                 offload->self_ipv6_addr[i][12] = 0xff;
8132                 offload->self_ipv6_addr[i][13] =
8133                                         offload->ipv6_addr[i][13];
8134                 offload->self_ipv6_addr[i][14] =
8135                                         offload->ipv6_addr[i][14];
8136                 offload->self_ipv6_addr[i][15] =
8137                                         offload->ipv6_addr[i][15];
8138                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8139                            offload->self_ipv6_addr[i]);
8140         }
8141 }
8142
8143 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8144                                        struct ieee80211_vif *vif,
8145                                        struct inet6_dev *idev)
8146 {
8147         struct ath11k *ar = hw->priv;
8148         struct ath11k_arp_ns_offload *offload;
8149         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8150         struct inet6_ifaddr *ifa6;
8151         struct ifacaddr6 *ifaca6;
8152         struct list_head *p;
8153         u32 count, scope;
8154
8155         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac op ipv6 changed\n");
8156
8157         offload = &arvif->arp_ns_offload;
8158         count = 0;
8159
8160         read_lock_bh(&idev->lock);
8161
8162         memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8163         memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8164         memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8165
8166         /* get unicast address */
8167         list_for_each(p, &idev->addr_list) {
8168                 if (count >= ATH11K_IPV6_MAX_COUNT)
8169                         goto generate;
8170
8171                 ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8172                 if (ifa6->flags & IFA_F_DADFAILED)
8173                         continue;
8174                 scope = ipv6_addr_src_scope(&ifa6->addr);
8175                 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8176                     scope == IPV6_ADDR_SCOPE_GLOBAL) {
8177                         memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8178                                sizeof(ifa6->addr.s6_addr));
8179                         offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8180                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 uc %pI6 scope %d\n",
8181                                    count, offload->ipv6_addr[count],
8182                                    scope);
8183                         count++;
8184                 } else {
8185                         ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8186                 }
8187         }
8188
8189         /* get anycast address */
8190         for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8191                 if (count >= ATH11K_IPV6_MAX_COUNT)
8192                         goto generate;
8193
8194                 scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8195                 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8196                     scope == IPV6_ADDR_SCOPE_GLOBAL) {
8197                         memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8198                                sizeof(ifaca6->aca_addr));
8199                         offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8200                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 ac %pI6 scope %d\n",
8201                                    count, offload->ipv6_addr[count],
8202                                    scope);
8203                         count++;
8204                 } else {
8205                         ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8206                 }
8207         }
8208
8209 generate:
8210         offload->ipv6_count = count;
8211         read_unlock_bh(&idev->lock);
8212
8213         /* generate ns multicast address */
8214         ath11k_generate_ns_mc_addr(ar, offload);
8215 }
8216 #endif
8217
8218 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8219                                          struct ieee80211_vif *vif,
8220                                          struct cfg80211_gtk_rekey_data *data)
8221 {
8222         struct ath11k *ar = hw->priv;
8223         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8224         struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8225
8226         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac set rekey data vdev %d\n",
8227                    arvif->vdev_id);
8228
8229         mutex_lock(&ar->conf_mutex);
8230
8231         memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8232         memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8233
8234         /* The supplicant works on big-endian, the firmware expects it on
8235          * little endian.
8236          */
8237         rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8238
8239         arvif->rekey_data.enable_offload = true;
8240
8241         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8242                         rekey_data->kck, NL80211_KCK_LEN);
8243         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8244                         rekey_data->kck, NL80211_KEK_LEN);
8245         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8246                         &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8247
8248         mutex_unlock(&ar->conf_mutex);
8249 }
8250
8251 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8252                                             const struct cfg80211_sar_specs *sar)
8253 {
8254         struct ath11k *ar = hw->priv;
8255         const struct cfg80211_sar_sub_specs *sspec;
8256         int ret, index;
8257         u8 *sar_tbl;
8258         u32 i;
8259
8260         if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8261             sar->num_sub_specs == 0)
8262                 return -EINVAL;
8263
8264         mutex_lock(&ar->conf_mutex);
8265
8266         if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8267             !ar->ab->hw_params.bios_sar_capa) {
8268                 ret = -EOPNOTSUPP;
8269                 goto exit;
8270         }
8271
8272         ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8273         if (ret) {
8274                 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8275                 goto exit;
8276         }
8277
8278         sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8279         if (!sar_tbl) {
8280                 ret = -ENOMEM;
8281                 goto exit;
8282         }
8283
8284         sspec = sar->sub_specs;
8285         for (i = 0; i < sar->num_sub_specs; i++) {
8286                 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8287                         ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8288                                     sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8289                         continue;
8290                 }
8291
8292                 /* chain0 and chain1 share same power setting */
8293                 sar_tbl[sspec->freq_range_index] = sspec->power;
8294                 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8295                 sar_tbl[index] = sspec->power;
8296                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8297                            sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8298                 sspec++;
8299         }
8300
8301         ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8302         if (ret)
8303                 ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8304
8305         kfree(sar_tbl);
8306 exit:
8307         mutex_unlock(&ar->conf_mutex);
8308
8309         return ret;
8310 }
8311
8312 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
8313                                                   struct ieee80211_vif *vif)
8314 {
8315         struct ath11k *ar = hw->priv;
8316
8317         mutex_lock(&ar->conf_mutex);
8318
8319         spin_lock_bh(&ar->data_lock);
8320         ar->scan.roc_notify = false;
8321         spin_unlock_bh(&ar->data_lock);
8322
8323         ath11k_scan_abort(ar);
8324
8325         mutex_unlock(&ar->conf_mutex);
8326
8327         cancel_delayed_work_sync(&ar->scan.timeout);
8328
8329         return 0;
8330 }
8331
8332 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
8333                                            struct ieee80211_vif *vif,
8334                                            struct ieee80211_channel *chan,
8335                                            int duration,
8336                                            enum ieee80211_roc_type type)
8337 {
8338         struct ath11k *ar = hw->priv;
8339         struct ath11k_vif *arvif = (void *)vif->drv_priv;
8340         struct scan_req_params arg;
8341         int ret;
8342         u32 scan_time_msec;
8343
8344         mutex_lock(&ar->conf_mutex);
8345
8346         spin_lock_bh(&ar->data_lock);
8347         switch (ar->scan.state) {
8348         case ATH11K_SCAN_IDLE:
8349                 reinit_completion(&ar->scan.started);
8350                 reinit_completion(&ar->scan.completed);
8351                 reinit_completion(&ar->scan.on_channel);
8352                 ar->scan.state = ATH11K_SCAN_STARTING;
8353                 ar->scan.is_roc = true;
8354                 ar->scan.vdev_id = arvif->vdev_id;
8355                 ar->scan.roc_freq = chan->center_freq;
8356                 ar->scan.roc_notify = true;
8357                 ret = 0;
8358                 break;
8359         case ATH11K_SCAN_STARTING:
8360         case ATH11K_SCAN_RUNNING:
8361         case ATH11K_SCAN_ABORTING:
8362                 ret = -EBUSY;
8363                 break;
8364         }
8365         spin_unlock_bh(&ar->data_lock);
8366
8367         if (ret)
8368                 goto exit;
8369
8370         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
8371
8372         memset(&arg, 0, sizeof(arg));
8373         ath11k_wmi_start_scan_init(ar, &arg);
8374         arg.num_chan = 1;
8375         arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
8376                                 GFP_KERNEL);
8377         if (!arg.chan_list) {
8378                 ret = -ENOMEM;
8379                 goto exit;
8380         }
8381
8382         arg.vdev_id = arvif->vdev_id;
8383         arg.scan_id = ATH11K_SCAN_ID;
8384         arg.chan_list[0] = chan->center_freq;
8385         arg.dwell_time_active = scan_time_msec;
8386         arg.dwell_time_passive = scan_time_msec;
8387         arg.max_scan_time = scan_time_msec;
8388         arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
8389         arg.scan_flags |= WMI_SCAN_FILTER_PROBE_REQ;
8390         arg.burst_duration = duration;
8391
8392         ret = ath11k_start_scan(ar, &arg);
8393         if (ret) {
8394                 ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret);
8395
8396                 spin_lock_bh(&ar->data_lock);
8397                 ar->scan.state = ATH11K_SCAN_IDLE;
8398                 spin_unlock_bh(&ar->data_lock);
8399                 goto free_chan_list;
8400         }
8401
8402         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
8403         if (ret == 0) {
8404                 ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n");
8405                 ret = ath11k_scan_stop(ar);
8406                 if (ret)
8407                         ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
8408                 ret = -ETIMEDOUT;
8409                 goto free_chan_list;
8410         }
8411
8412         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
8413                                      msecs_to_jiffies(duration));
8414
8415         ret = 0;
8416
8417 free_chan_list:
8418         kfree(arg.chan_list);
8419 exit:
8420         mutex_unlock(&ar->conf_mutex);
8421         return ret;
8422 }
8423
8424 static const struct ieee80211_ops ath11k_ops = {
8425         .tx                             = ath11k_mac_op_tx,
8426         .start                          = ath11k_mac_op_start,
8427         .stop                           = ath11k_mac_op_stop,
8428         .reconfig_complete              = ath11k_mac_op_reconfig_complete,
8429         .add_interface                  = ath11k_mac_op_add_interface,
8430         .remove_interface               = ath11k_mac_op_remove_interface,
8431         .update_vif_offload             = ath11k_mac_op_update_vif_offload,
8432         .config                         = ath11k_mac_op_config,
8433         .bss_info_changed               = ath11k_mac_op_bss_info_changed,
8434         .configure_filter               = ath11k_mac_op_configure_filter,
8435         .hw_scan                        = ath11k_mac_op_hw_scan,
8436         .cancel_hw_scan                 = ath11k_mac_op_cancel_hw_scan,
8437         .set_key                        = ath11k_mac_op_set_key,
8438         .set_rekey_data                 = ath11k_mac_op_set_rekey_data,
8439         .sta_state                      = ath11k_mac_op_sta_state,
8440         .sta_set_4addr                  = ath11k_mac_op_sta_set_4addr,
8441         .sta_set_txpwr                  = ath11k_mac_op_sta_set_txpwr,
8442         .sta_rc_update                  = ath11k_mac_op_sta_rc_update,
8443         .conf_tx                        = ath11k_mac_op_conf_tx,
8444         .set_antenna                    = ath11k_mac_op_set_antenna,
8445         .get_antenna                    = ath11k_mac_op_get_antenna,
8446         .ampdu_action                   = ath11k_mac_op_ampdu_action,
8447         .add_chanctx                    = ath11k_mac_op_add_chanctx,
8448         .remove_chanctx                 = ath11k_mac_op_remove_chanctx,
8449         .change_chanctx                 = ath11k_mac_op_change_chanctx,
8450         .assign_vif_chanctx             = ath11k_mac_op_assign_vif_chanctx,
8451         .unassign_vif_chanctx           = ath11k_mac_op_unassign_vif_chanctx,
8452         .switch_vif_chanctx             = ath11k_mac_op_switch_vif_chanctx,
8453         .set_rts_threshold              = ath11k_mac_op_set_rts_threshold,
8454         .set_frag_threshold             = ath11k_mac_op_set_frag_threshold,
8455         .set_bitrate_mask               = ath11k_mac_op_set_bitrate_mask,
8456         .get_survey                     = ath11k_mac_op_get_survey,
8457         .flush                          = ath11k_mac_op_flush,
8458         .sta_statistics                 = ath11k_mac_op_sta_statistics,
8459         CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
8460
8461 #ifdef CONFIG_PM
8462         .suspend                        = ath11k_wow_op_suspend,
8463         .resume                         = ath11k_wow_op_resume,
8464         .set_wakeup                     = ath11k_wow_op_set_wakeup,
8465 #endif
8466
8467 #ifdef CONFIG_ATH11K_DEBUGFS
8468         .sta_add_debugfs                = ath11k_debugfs_sta_op_add,
8469 #endif
8470
8471 #if IS_ENABLED(CONFIG_IPV6)
8472         .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
8473 #endif
8474
8475         .set_sar_specs                  = ath11k_mac_op_set_bios_sar_specs,
8476         .remain_on_channel              = ath11k_mac_op_remain_on_channel,
8477         .cancel_remain_on_channel       = ath11k_mac_op_cancel_remain_on_channel,
8478 };
8479
8480 static void ath11k_mac_update_ch_list(struct ath11k *ar,
8481                                       struct ieee80211_supported_band *band,
8482                                       u32 freq_low, u32 freq_high)
8483 {
8484         int i;
8485
8486         if (!(freq_low && freq_high))
8487                 return;
8488
8489         for (i = 0; i < band->n_channels; i++) {
8490                 if (band->channels[i].center_freq < freq_low ||
8491                     band->channels[i].center_freq > freq_high)
8492                         band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
8493         }
8494 }
8495
8496 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
8497 {
8498         struct ath11k_pdev *pdev = ar->pdev;
8499         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
8500
8501         if (band == WMI_HOST_WLAN_2G_CAP)
8502                 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
8503
8504         if (band == WMI_HOST_WLAN_5G_CAP)
8505                 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
8506
8507         ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
8508
8509         return 0;
8510 }
8511
8512 static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
8513                                            u32 supported_bands)
8514 {
8515         struct ieee80211_supported_band *band;
8516         struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
8517         void *channels;
8518         u32 phy_id;
8519
8520         BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
8521                       ARRAY_SIZE(ath11k_5ghz_channels) +
8522                       ARRAY_SIZE(ath11k_6ghz_channels)) !=
8523                      ATH11K_NUM_CHANS);
8524
8525         reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
8526         temp_reg_cap = reg_cap;
8527
8528         if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
8529                 channels = kmemdup(ath11k_2ghz_channels,
8530                                    sizeof(ath11k_2ghz_channels),
8531                                    GFP_KERNEL);
8532                 if (!channels)
8533                         return -ENOMEM;
8534
8535                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
8536                 band->band = NL80211_BAND_2GHZ;
8537                 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
8538                 band->channels = channels;
8539                 band->n_bitrates = ath11k_g_rates_size;
8540                 band->bitrates = ath11k_g_rates;
8541                 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
8542
8543                 if (ar->ab->hw_params.single_pdev_only) {
8544                         phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
8545                         temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8546                 }
8547                 ath11k_mac_update_ch_list(ar, band,
8548                                           temp_reg_cap->low_2ghz_chan,
8549                                           temp_reg_cap->high_2ghz_chan);
8550         }
8551
8552         if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
8553                 if (reg_cap->high_5ghz_chan >= ATH11K_MAX_6G_FREQ) {
8554                         channels = kmemdup(ath11k_6ghz_channels,
8555                                            sizeof(ath11k_6ghz_channels), GFP_KERNEL);
8556                         if (!channels) {
8557                                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8558                                 return -ENOMEM;
8559                         }
8560
8561                         ar->supports_6ghz = true;
8562                         band = &ar->mac.sbands[NL80211_BAND_6GHZ];
8563                         band->band = NL80211_BAND_6GHZ;
8564                         band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
8565                         band->channels = channels;
8566                         band->n_bitrates = ath11k_a_rates_size;
8567                         band->bitrates = ath11k_a_rates;
8568                         ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
8569
8570                         if (ar->ab->hw_params.single_pdev_only) {
8571                                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8572                                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8573                         }
8574
8575                         ath11k_mac_update_ch_list(ar, band,
8576                                                   temp_reg_cap->low_5ghz_chan,
8577                                                   temp_reg_cap->high_5ghz_chan);
8578                 }
8579
8580                 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
8581                         channels = kmemdup(ath11k_5ghz_channels,
8582                                            sizeof(ath11k_5ghz_channels),
8583                                            GFP_KERNEL);
8584                         if (!channels) {
8585                                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8586                                 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8587                                 return -ENOMEM;
8588                         }
8589
8590                         band = &ar->mac.sbands[NL80211_BAND_5GHZ];
8591                         band->band = NL80211_BAND_5GHZ;
8592                         band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
8593                         band->channels = channels;
8594                         band->n_bitrates = ath11k_a_rates_size;
8595                         band->bitrates = ath11k_a_rates;
8596                         ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
8597
8598                         if (ar->ab->hw_params.single_pdev_only) {
8599                                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8600                                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8601                         }
8602
8603                         ath11k_mac_update_ch_list(ar, band,
8604                                                   temp_reg_cap->low_5ghz_chan,
8605                                                   temp_reg_cap->high_5ghz_chan);
8606                 }
8607         }
8608
8609         return 0;
8610 }
8611
8612 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
8613 {
8614         struct ath11k_base *ab = ar->ab;
8615         struct ieee80211_iface_combination *combinations;
8616         struct ieee80211_iface_limit *limits;
8617         int n_limits;
8618
8619         combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
8620         if (!combinations)
8621                 return -ENOMEM;
8622
8623         n_limits = 2;
8624
8625         limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
8626         if (!limits) {
8627                 kfree(combinations);
8628                 return -ENOMEM;
8629         }
8630
8631         limits[0].max = 1;
8632         limits[0].types |= BIT(NL80211_IFTYPE_STATION);
8633
8634         limits[1].max = 16;
8635         limits[1].types |= BIT(NL80211_IFTYPE_AP);
8636
8637         if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
8638             ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
8639                 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
8640
8641         combinations[0].limits = limits;
8642         combinations[0].n_limits = n_limits;
8643         combinations[0].max_interfaces = 16;
8644         combinations[0].num_different_channels = 1;
8645         combinations[0].beacon_int_infra_match = true;
8646         combinations[0].beacon_int_min_gcd = 100;
8647         combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
8648                                                 BIT(NL80211_CHAN_WIDTH_20) |
8649                                                 BIT(NL80211_CHAN_WIDTH_40) |
8650                                                 BIT(NL80211_CHAN_WIDTH_80) |
8651                                                 BIT(NL80211_CHAN_WIDTH_80P80) |
8652                                                 BIT(NL80211_CHAN_WIDTH_160);
8653
8654         ar->hw->wiphy->iface_combinations = combinations;
8655         ar->hw->wiphy->n_iface_combinations = 1;
8656
8657         return 0;
8658 }
8659
8660 static const u8 ath11k_if_types_ext_capa[] = {
8661         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8662         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8663 };
8664
8665 static const u8 ath11k_if_types_ext_capa_sta[] = {
8666         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8667         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8668         [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
8669 };
8670
8671 static const u8 ath11k_if_types_ext_capa_ap[] = {
8672         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8673         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8674         [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
8675 };
8676
8677 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
8678         {
8679                 .extended_capabilities = ath11k_if_types_ext_capa,
8680                 .extended_capabilities_mask = ath11k_if_types_ext_capa,
8681                 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
8682         }, {
8683                 .iftype = NL80211_IFTYPE_STATION,
8684                 .extended_capabilities = ath11k_if_types_ext_capa_sta,
8685                 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
8686                 .extended_capabilities_len =
8687                                 sizeof(ath11k_if_types_ext_capa_sta),
8688         }, {
8689                 .iftype = NL80211_IFTYPE_AP,
8690                 .extended_capabilities = ath11k_if_types_ext_capa_ap,
8691                 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
8692                 .extended_capabilities_len =
8693                                 sizeof(ath11k_if_types_ext_capa_ap),
8694         },
8695 };
8696
8697 static void __ath11k_mac_unregister(struct ath11k *ar)
8698 {
8699         cancel_work_sync(&ar->regd_update_work);
8700
8701         ieee80211_unregister_hw(ar->hw);
8702
8703         idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
8704         idr_destroy(&ar->txmgmt_idr);
8705
8706         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8707         kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
8708         kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8709
8710         kfree(ar->hw->wiphy->iface_combinations[0].limits);
8711         kfree(ar->hw->wiphy->iface_combinations);
8712
8713         SET_IEEE80211_DEV(ar->hw, NULL);
8714 }
8715
8716 void ath11k_mac_unregister(struct ath11k_base *ab)
8717 {
8718         struct ath11k *ar;
8719         struct ath11k_pdev *pdev;
8720         int i;
8721
8722         for (i = 0; i < ab->num_radios; i++) {
8723                 pdev = &ab->pdevs[i];
8724                 ar = pdev->ar;
8725                 if (!ar)
8726                         continue;
8727
8728                 __ath11k_mac_unregister(ar);
8729         }
8730
8731         ath11k_peer_rhash_tbl_destroy(ab);
8732 }
8733
8734 static int __ath11k_mac_register(struct ath11k *ar)
8735 {
8736         struct ath11k_base *ab = ar->ab;
8737         struct ath11k_pdev_cap *cap = &ar->pdev->cap;
8738         static const u32 cipher_suites[] = {
8739                 WLAN_CIPHER_SUITE_TKIP,
8740                 WLAN_CIPHER_SUITE_CCMP,
8741                 WLAN_CIPHER_SUITE_AES_CMAC,
8742                 WLAN_CIPHER_SUITE_BIP_CMAC_256,
8743                 WLAN_CIPHER_SUITE_BIP_GMAC_128,
8744                 WLAN_CIPHER_SUITE_BIP_GMAC_256,
8745                 WLAN_CIPHER_SUITE_GCMP,
8746                 WLAN_CIPHER_SUITE_GCMP_256,
8747                 WLAN_CIPHER_SUITE_CCMP_256,
8748         };
8749         int ret;
8750         u32 ht_cap = 0;
8751
8752         ath11k_pdev_caps_update(ar);
8753
8754         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
8755
8756         SET_IEEE80211_DEV(ar->hw, ab->dev);
8757
8758         ret = ath11k_mac_setup_channels_rates(ar,
8759                                               cap->supported_bands);
8760         if (ret)
8761                 goto err;
8762
8763         ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
8764         ath11k_mac_setup_he_cap(ar, cap);
8765
8766         ret = ath11k_mac_setup_iface_combinations(ar);
8767         if (ret) {
8768                 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
8769                 goto err_free_channels;
8770         }
8771
8772         ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
8773         ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
8774
8775         ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
8776
8777         if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
8778                 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
8779
8780         ieee80211_hw_set(ar->hw, SIGNAL_DBM);
8781         ieee80211_hw_set(ar->hw, SUPPORTS_PS);
8782         ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
8783         ieee80211_hw_set(ar->hw, MFP_CAPABLE);
8784         ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
8785         ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
8786         ieee80211_hw_set(ar->hw, AP_LINK_PS);
8787         ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
8788         ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
8789         ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
8790         ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
8791         ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
8792         ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
8793         ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
8794         ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
8795
8796         if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
8797                 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
8798                 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
8799         }
8800
8801         if (cap->nss_ratio_enabled)
8802                 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
8803
8804         if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
8805                 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
8806                 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
8807                 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
8808                 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
8809                 ieee80211_hw_set(ar->hw, USES_RSS);
8810         }
8811
8812         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
8813         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
8814
8815         /* TODO: Check if HT capability advertised from firmware is different
8816          * for each band for a dual band capable radio. It will be tricky to
8817          * handle it when the ht capability different for each band.
8818          */
8819         if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
8820             (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
8821                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
8822
8823         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
8824         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
8825
8826         ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
8827
8828         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
8829         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
8830         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
8831
8832         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
8833         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
8834                                    NL80211_FEATURE_AP_SCAN;
8835
8836         ar->max_num_stations = TARGET_NUM_STATIONS(ab);
8837         ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
8838
8839         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
8840
8841         if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
8842                 ar->hw->wiphy->features |=
8843                         NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
8844         }
8845
8846         if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
8847                 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
8848                 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
8849                 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
8850                 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
8851                 ar->hw->wiphy->max_sched_scan_plan_interval =
8852                         WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
8853                 ar->hw->wiphy->max_sched_scan_plan_iterations =
8854                         WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
8855                 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
8856         }
8857
8858         ret = ath11k_wow_init(ar);
8859         if (ret) {
8860                 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
8861                 goto err_free_if_combs;
8862         }
8863
8864         ar->hw->queues = ATH11K_HW_MAX_QUEUES;
8865         ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
8866         ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
8867         ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
8868
8869         ar->hw->vif_data_size = sizeof(struct ath11k_vif);
8870         ar->hw->sta_data_size = sizeof(struct ath11k_sta);
8871
8872         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
8873         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
8874         if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD,
8875                      ar->ab->wmi_ab.svc_map)) {
8876                 wiphy_ext_feature_set(ar->hw->wiphy,
8877                                       NL80211_EXT_FEATURE_BSS_COLOR);
8878                 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION);
8879         }
8880
8881         ar->hw->wiphy->cipher_suites = cipher_suites;
8882         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
8883
8884         ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
8885         ar->hw->wiphy->num_iftype_ext_capab =
8886                 ARRAY_SIZE(ath11k_iftypes_ext_capa);
8887
8888         if (ar->supports_6ghz) {
8889                 wiphy_ext_feature_set(ar->hw->wiphy,
8890                                       NL80211_EXT_FEATURE_FILS_DISCOVERY);
8891                 wiphy_ext_feature_set(ar->hw->wiphy,
8892                                       NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
8893         }
8894
8895         ath11k_reg_init(ar);
8896
8897         if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
8898                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
8899                 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
8900                 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
8901         }
8902
8903         if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
8904             ab->hw_params.bios_sar_capa)
8905                 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
8906
8907         ret = ieee80211_register_hw(ar->hw);
8908         if (ret) {
8909                 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
8910                 goto err_free_if_combs;
8911         }
8912
8913         if (!ab->hw_params.supports_monitor)
8914                 /* There's a race between calling ieee80211_register_hw()
8915                  * and here where the monitor mode is enabled for a little
8916                  * while. But that time is so short and in practise it make
8917                  * a difference in real life.
8918                  */
8919                 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
8920
8921         /* Apply the regd received during initialization */
8922         ret = ath11k_regd_update(ar);
8923         if (ret) {
8924                 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
8925                 goto err_unregister_hw;
8926         }
8927
8928         if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) {
8929                 struct wmi_set_current_country_params set_current_param = {};
8930
8931                 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2);
8932                 memcpy(&ar->alpha2, ab->new_alpha2, 2);
8933                 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
8934                 if (ret)
8935                         ath11k_warn(ar->ab,
8936                                     "failed set cc code for mac register: %d\n", ret);
8937         }
8938
8939         ret = ath11k_debugfs_register(ar);
8940         if (ret) {
8941                 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
8942                 goto err_unregister_hw;
8943         }
8944
8945         return 0;
8946
8947 err_unregister_hw:
8948         ieee80211_unregister_hw(ar->hw);
8949
8950 err_free_if_combs:
8951         kfree(ar->hw->wiphy->iface_combinations[0].limits);
8952         kfree(ar->hw->wiphy->iface_combinations);
8953
8954 err_free_channels:
8955         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8956         kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
8957         kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8958
8959 err:
8960         SET_IEEE80211_DEV(ar->hw, NULL);
8961         return ret;
8962 }
8963
8964 int ath11k_mac_register(struct ath11k_base *ab)
8965 {
8966         struct ath11k *ar;
8967         struct ath11k_pdev *pdev;
8968         int i;
8969         int ret;
8970
8971         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
8972                 return 0;
8973
8974         /* Initialize channel counters frequency value in hertz */
8975         ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
8976         ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
8977
8978         ret = ath11k_peer_rhash_tbl_init(ab);
8979         if (ret)
8980                 return ret;
8981
8982         for (i = 0; i < ab->num_radios; i++) {
8983                 pdev = &ab->pdevs[i];
8984                 ar = pdev->ar;
8985                 if (ab->pdevs_macaddr_valid) {
8986                         ether_addr_copy(ar->mac_addr, pdev->mac_addr);
8987                 } else {
8988                         ether_addr_copy(ar->mac_addr, ab->mac_addr);
8989                         ar->mac_addr[4] += i;
8990                 }
8991
8992                 idr_init(&ar->txmgmt_idr);
8993                 spin_lock_init(&ar->txmgmt_idr_lock);
8994
8995                 ret = __ath11k_mac_register(ar);
8996                 if (ret)
8997                         goto err_cleanup;
8998
8999                 init_waitqueue_head(&ar->txmgmt_empty_waitq);
9000         }
9001
9002         return 0;
9003
9004 err_cleanup:
9005         for (i = i - 1; i >= 0; i--) {
9006                 pdev = &ab->pdevs[i];
9007                 ar = pdev->ar;
9008                 __ath11k_mac_unregister(ar);
9009         }
9010
9011         ath11k_peer_rhash_tbl_destroy(ab);
9012
9013         return ret;
9014 }
9015
9016 int ath11k_mac_allocate(struct ath11k_base *ab)
9017 {
9018         struct ieee80211_hw *hw;
9019         struct ath11k *ar;
9020         struct ath11k_pdev *pdev;
9021         int ret;
9022         int i;
9023
9024         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9025                 return 0;
9026
9027         for (i = 0; i < ab->num_radios; i++) {
9028                 pdev = &ab->pdevs[i];
9029                 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
9030                 if (!hw) {
9031                         ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
9032                         ret = -ENOMEM;
9033                         goto err_free_mac;
9034                 }
9035
9036                 ar = hw->priv;
9037                 ar->hw = hw;
9038                 ar->ab = ab;
9039                 ar->pdev = pdev;
9040                 ar->pdev_idx = i;
9041                 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
9042
9043                 ar->wmi = &ab->wmi_ab.wmi[i];
9044                 /* FIXME wmi[0] is already initialized during attach,
9045                  * Should we do this again?
9046                  */
9047                 ath11k_wmi_pdev_attach(ab, i);
9048
9049                 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
9050                 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
9051                 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
9052                 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
9053
9054                 pdev->ar = ar;
9055                 spin_lock_init(&ar->data_lock);
9056                 INIT_LIST_HEAD(&ar->arvifs);
9057                 INIT_LIST_HEAD(&ar->ppdu_stats_info);
9058                 mutex_init(&ar->conf_mutex);
9059                 init_completion(&ar->vdev_setup_done);
9060                 init_completion(&ar->vdev_delete_done);
9061                 init_completion(&ar->peer_assoc_done);
9062                 init_completion(&ar->peer_delete_done);
9063                 init_completion(&ar->install_key_done);
9064                 init_completion(&ar->bss_survey_done);
9065                 init_completion(&ar->scan.started);
9066                 init_completion(&ar->scan.completed);
9067                 init_completion(&ar->scan.on_channel);
9068                 init_completion(&ar->thermal.wmi_sync);
9069
9070                 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
9071                 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
9072
9073                 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
9074                 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
9075
9076                 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
9077
9078                 ar->monitor_vdev_id = -1;
9079                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9080                 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
9081                 init_completion(&ar->completed_11d_scan);
9082         }
9083
9084         return 0;
9085
9086 err_free_mac:
9087         ath11k_mac_destroy(ab);
9088
9089         return ret;
9090 }
9091
9092 void ath11k_mac_destroy(struct ath11k_base *ab)
9093 {
9094         struct ath11k *ar;
9095         struct ath11k_pdev *pdev;
9096         int i;
9097
9098         for (i = 0; i < ab->num_radios; i++) {
9099                 pdev = &ab->pdevs[i];
9100                 ar = pdev->ar;
9101                 if (!ar)
9102                         continue;
9103
9104                 ieee80211_free_hw(ar->hw);
9105                 pdev->ar = NULL;
9106         }
9107 }
9108
9109 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif,
9110                                  enum wmi_sta_keepalive_method method,
9111                                  u32 interval)
9112 {
9113         struct ath11k *ar = arvif->ar;
9114         struct wmi_sta_keepalive_arg arg = {};
9115         int ret;
9116
9117         lockdep_assert_held(&ar->conf_mutex);
9118
9119         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
9120                 return 0;
9121
9122         if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
9123                 return 0;
9124
9125         arg.vdev_id = arvif->vdev_id;
9126         arg.enabled = 1;
9127         arg.method = method;
9128         arg.interval = interval;
9129
9130         ret = ath11k_wmi_sta_keepalive(ar, &arg);
9131         if (ret) {
9132                 ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
9133                             arvif->vdev_id, ret);
9134                 return ret;
9135         }
9136
9137         return 0;
9138 }