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