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,
4826                                  unsigned int link_id, u16 ac,
4827                                  const struct ieee80211_tx_queue_params *params)
4828 {
4829         struct ath11k *ar = hw->priv;
4830         struct ath11k_vif *arvif = (void *)vif->drv_priv;
4831         struct wmi_wmm_params_arg *p = NULL;
4832         int ret;
4833
4834         mutex_lock(&ar->conf_mutex);
4835
4836         switch (ac) {
4837         case IEEE80211_AC_VO:
4838                 p = &arvif->wmm_params.ac_vo;
4839                 break;
4840         case IEEE80211_AC_VI:
4841                 p = &arvif->wmm_params.ac_vi;
4842                 break;
4843         case IEEE80211_AC_BE:
4844                 p = &arvif->wmm_params.ac_be;
4845                 break;
4846         case IEEE80211_AC_BK:
4847                 p = &arvif->wmm_params.ac_bk;
4848                 break;
4849         }
4850
4851         if (WARN_ON(!p)) {
4852                 ret = -EINVAL;
4853                 goto exit;
4854         }
4855
4856         p->cwmin = params->cw_min;
4857         p->cwmax = params->cw_max;
4858         p->aifs = params->aifs;
4859         p->txop = params->txop;
4860
4861         ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
4862                                                  &arvif->wmm_params);
4863         if (ret) {
4864                 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
4865                 goto exit;
4866         }
4867
4868         ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
4869
4870         if (ret)
4871                 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
4872
4873 exit:
4874         mutex_unlock(&ar->conf_mutex);
4875         return ret;
4876 }
4877
4878 static struct ieee80211_sta_ht_cap
4879 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
4880 {
4881         int i;
4882         struct ieee80211_sta_ht_cap ht_cap = {0};
4883         u32 ar_vht_cap = ar->pdev->cap.vht_cap;
4884
4885         if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
4886                 return ht_cap;
4887
4888         ht_cap.ht_supported = 1;
4889         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4890         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
4891         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4892         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4893         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4894
4895         if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
4896                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4897
4898         if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
4899                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4900
4901         if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
4902                 u32 smps;
4903
4904                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4905                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4906
4907                 ht_cap.cap |= smps;
4908         }
4909
4910         if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
4911                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4912
4913         if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
4914                 u32 stbc;
4915
4916                 stbc   = ar_ht_cap;
4917                 stbc  &= WMI_HT_CAP_RX_STBC;
4918                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4919                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4920                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
4921
4922                 ht_cap.cap |= stbc;
4923         }
4924
4925         if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
4926                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4927
4928         if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
4929                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4930
4931         if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4932                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4933
4934         for (i = 0; i < ar->num_rx_chains; i++) {
4935                 if (rate_cap_rx_chainmask & BIT(i))
4936                         ht_cap.mcs.rx_mask[i] = 0xFF;
4937         }
4938
4939         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4940
4941         return ht_cap;
4942 }
4943
4944 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
4945 {
4946         u32 value = 0;
4947         struct ath11k *ar = arvif->ar;
4948         int nsts;
4949         int sound_dim;
4950         u32 vht_cap = ar->pdev->cap.vht_cap;
4951         u32 vdev_param = WMI_VDEV_PARAM_TXBF;
4952
4953         if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
4954                 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4955                 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4956                 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4957         }
4958
4959         if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
4960                 sound_dim = vht_cap &
4961                             IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4962                 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4963                 if (sound_dim > (ar->num_tx_chains - 1))
4964                         sound_dim = ar->num_tx_chains - 1;
4965                 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4966         }
4967
4968         if (!value)
4969                 return 0;
4970
4971         if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
4972                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4973
4974                 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
4975                     arvif->vdev_type == WMI_VDEV_TYPE_AP)
4976                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
4977         }
4978
4979         /* TODO: SUBFEE not validated in HK, disable here until validated? */
4980
4981         if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
4982                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4983
4984                 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
4985                     arvif->vdev_type == WMI_VDEV_TYPE_STA)
4986                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
4987         }
4988
4989         return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
4990                                              vdev_param, value);
4991 }
4992
4993 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
4994 {
4995         bool subfer, subfee;
4996         int sound_dim = 0;
4997
4998         subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
4999         subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
5000
5001         if (ar->num_tx_chains < 2) {
5002                 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
5003                 subfer = false;
5004         }
5005
5006         /* If SU Beaformer is not set, then disable MU Beamformer Capability */
5007         if (!subfer)
5008                 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
5009
5010         /* If SU Beaformee is not set, then disable MU Beamformee Capability */
5011         if (!subfee)
5012                 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5013
5014         sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5015         sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5016         *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5017
5018         /* TODO: Need to check invalid STS and Sound_dim values set by FW? */
5019
5020         /* Enable Sounding Dimension Field only if SU BF is enabled */
5021         if (subfer) {
5022                 if (sound_dim > (ar->num_tx_chains - 1))
5023                         sound_dim = ar->num_tx_chains - 1;
5024
5025                 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5026                 sound_dim &=  IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5027                 *vht_cap |= sound_dim;
5028         }
5029
5030         /* Use the STS advertised by FW unless SU Beamformee is not supported*/
5031         if (!subfee)
5032                 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5033 }
5034
5035 static struct ieee80211_sta_vht_cap
5036 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5037                       u32 rate_cap_rx_chainmask)
5038 {
5039         struct ieee80211_sta_vht_cap vht_cap = {0};
5040         u16 txmcs_map, rxmcs_map;
5041         int i;
5042
5043         vht_cap.vht_supported = 1;
5044         vht_cap.cap = ar->pdev->cap.vht_cap;
5045
5046         if (ar->pdev->cap.nss_ratio_enabled)
5047                 vht_cap.vht_mcs.tx_highest |=
5048                         cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5049
5050         ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5051
5052         rxmcs_map = 0;
5053         txmcs_map = 0;
5054         for (i = 0; i < 8; i++) {
5055                 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5056                         txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5057                 else
5058                         txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5059
5060                 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5061                         rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5062                 else
5063                         rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5064         }
5065
5066         if (rate_cap_tx_chainmask <= 1)
5067                 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5068
5069         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5070         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5071
5072         return vht_cap;
5073 }
5074
5075 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5076                                         struct ath11k_pdev_cap *cap,
5077                                         u32 *ht_cap_info)
5078 {
5079         struct ieee80211_supported_band *band;
5080         u32 rate_cap_tx_chainmask;
5081         u32 rate_cap_rx_chainmask;
5082         u32 ht_cap;
5083
5084         rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5085         rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5086
5087         if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5088                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5089                 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5090                 if (ht_cap_info)
5091                         *ht_cap_info = ht_cap;
5092                 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5093                                                     rate_cap_rx_chainmask);
5094         }
5095
5096         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5097             (ar->ab->hw_params.single_pdev_only ||
5098              !ar->supports_6ghz)) {
5099                 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5100                 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
5101                 if (ht_cap_info)
5102                         *ht_cap_info = ht_cap;
5103                 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5104                                                     rate_cap_rx_chainmask);
5105                 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5106                                                       rate_cap_rx_chainmask);
5107         }
5108 }
5109
5110 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5111 {
5112         /* TODO: Check the request chainmask against the supported
5113          * chainmask table which is advertised in extented_service_ready event
5114          */
5115
5116         return 0;
5117 }
5118
5119 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5120                                   u8 *he_ppet)
5121 {
5122         int nss, ru;
5123         u8 bit = 7;
5124
5125         he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5126         he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5127                        IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5128                       IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5129         for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5130                 for (ru = 0; ru < 4; ru++) {
5131                         u8 val;
5132                         int i;
5133
5134                         if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5135                                 continue;
5136                         val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5137                                0x3f;
5138                         val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5139                         for (i = 5; i >= 0; i--) {
5140                                 he_ppet[bit / 8] |=
5141                                         ((val >> i) & 0x1) << ((bit % 8));
5142                                 bit++;
5143                         }
5144                 }
5145         }
5146 }
5147
5148 static void
5149 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5150 {
5151         u8 m;
5152
5153         m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5154             IEEE80211_HE_MAC_CAP0_TWT_REQ;
5155         he_cap_elem->mac_cap_info[0] &= ~m;
5156
5157         m = IEEE80211_HE_MAC_CAP2_TRS |
5158             IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5159             IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5160         he_cap_elem->mac_cap_info[2] &= ~m;
5161
5162         m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5163             IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5164             IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5165         he_cap_elem->mac_cap_info[3] &= ~m;
5166
5167         m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5168             IEEE80211_HE_MAC_CAP4_BQR;
5169         he_cap_elem->mac_cap_info[4] &= ~m;
5170
5171         m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
5172             IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5173             IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5174             IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5175         he_cap_elem->mac_cap_info[5] &= ~m;
5176
5177         m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5178             IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5179         he_cap_elem->phy_cap_info[2] &= ~m;
5180
5181         m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
5182             IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5183             IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5184         he_cap_elem->phy_cap_info[3] &= ~m;
5185
5186         m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5187         he_cap_elem->phy_cap_info[4] &= ~m;
5188
5189         m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5190         he_cap_elem->phy_cap_info[5] &= ~m;
5191
5192         m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
5193             IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
5194             IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5195             IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5196         he_cap_elem->phy_cap_info[6] &= ~m;
5197
5198         m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5199             IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
5200             IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5201             IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5202         he_cap_elem->phy_cap_info[7] &= ~m;
5203
5204         m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5205             IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5206             IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5207             IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5208         he_cap_elem->phy_cap_info[8] &= ~m;
5209
5210         m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5211             IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5212             IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5213             IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5214             IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5215             IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5216         he_cap_elem->phy_cap_info[9] &= ~m;
5217 }
5218
5219 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5220                                            struct ath11k_band_cap *bcap)
5221 {
5222         u8 val;
5223
5224         bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5225         if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5226                 bcap->he_6ghz_capa |=
5227                         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5228                                    WLAN_HT_CAP_SM_PS_DYNAMIC);
5229         else
5230                 bcap->he_6ghz_capa |=
5231                         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5232                                    WLAN_HT_CAP_SM_PS_DISABLED);
5233         val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5234                         pcap->vht_cap);
5235         bcap->he_6ghz_capa |=
5236                 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5237         val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5238         bcap->he_6ghz_capa |=
5239                 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5240         if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5241                 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5242         if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5243                 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5244
5245         return cpu_to_le16(bcap->he_6ghz_capa);
5246 }
5247
5248 static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5249                                   struct ath11k_pdev_cap *cap,
5250                                   struct ieee80211_sband_iftype_data *data,
5251                                   int band)
5252 {
5253         int i, idx = 0;
5254
5255         for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5256                 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5257                 struct ath11k_band_cap *band_cap = &cap->band[band];
5258                 struct ieee80211_he_cap_elem *he_cap_elem =
5259                                 &he_cap->he_cap_elem;
5260
5261                 switch (i) {
5262                 case NL80211_IFTYPE_STATION:
5263                 case NL80211_IFTYPE_AP:
5264                 case NL80211_IFTYPE_MESH_POINT:
5265                         break;
5266
5267                 default:
5268                         continue;
5269                 }
5270
5271                 data[idx].types_mask = BIT(i);
5272                 he_cap->has_he = true;
5273                 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5274                        sizeof(he_cap_elem->mac_cap_info));
5275                 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5276                        sizeof(he_cap_elem->phy_cap_info));
5277
5278                 he_cap_elem->mac_cap_info[1] &=
5279                         IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
5280
5281                 he_cap_elem->phy_cap_info[5] &=
5282                         ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
5283                 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5284
5285                 switch (i) {
5286                 case NL80211_IFTYPE_AP:
5287                         he_cap_elem->phy_cap_info[3] &=
5288                                 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
5289                         he_cap_elem->phy_cap_info[9] |=
5290                                 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5291                         break;
5292                 case NL80211_IFTYPE_STATION:
5293                         he_cap_elem->mac_cap_info[0] &=
5294                                 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5295                         he_cap_elem->mac_cap_info[0] |=
5296                                 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5297                         he_cap_elem->phy_cap_info[9] |=
5298                                 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5299                         break;
5300                 case NL80211_IFTYPE_MESH_POINT:
5301                         ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5302                         break;
5303                 }
5304
5305                 he_cap->he_mcs_nss_supp.rx_mcs_80 =
5306                         cpu_to_le16(band_cap->he_mcs & 0xffff);
5307                 he_cap->he_mcs_nss_supp.tx_mcs_80 =
5308                         cpu_to_le16(band_cap->he_mcs & 0xffff);
5309                 he_cap->he_mcs_nss_supp.rx_mcs_160 =
5310                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5311                 he_cap->he_mcs_nss_supp.tx_mcs_160 =
5312                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5313                 he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5314                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5315                 he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5316                         cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5317
5318                 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5319                 if (he_cap_elem->phy_cap_info[6] &
5320                     IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5321                         ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5322                                               he_cap->ppe_thres);
5323
5324                 if (band == NL80211_BAND_6GHZ) {
5325                         data[idx].he_6ghz_capa.capa =
5326                                 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5327                 }
5328                 idx++;
5329         }
5330
5331         return idx;
5332 }
5333
5334 static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5335                                     struct ath11k_pdev_cap *cap)
5336 {
5337         struct ieee80211_supported_band *band;
5338         int count;
5339
5340         if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5341                 count = ath11k_mac_copy_he_cap(ar, cap,
5342                                                ar->mac.iftype[NL80211_BAND_2GHZ],
5343                                                NL80211_BAND_2GHZ);
5344                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5345                 band->iftype_data = ar->mac.iftype[NL80211_BAND_2GHZ];
5346                 band->n_iftype_data = count;
5347         }
5348
5349         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5350                 count = ath11k_mac_copy_he_cap(ar, cap,
5351                                                ar->mac.iftype[NL80211_BAND_5GHZ],
5352                                                NL80211_BAND_5GHZ);
5353                 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5354                 band->iftype_data = ar->mac.iftype[NL80211_BAND_5GHZ];
5355                 band->n_iftype_data = count;
5356         }
5357
5358         if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5359             ar->supports_6ghz) {
5360                 count = ath11k_mac_copy_he_cap(ar, cap,
5361                                                ar->mac.iftype[NL80211_BAND_6GHZ],
5362                                                NL80211_BAND_6GHZ);
5363                 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5364                 band->iftype_data = ar->mac.iftype[NL80211_BAND_6GHZ];
5365                 band->n_iftype_data = count;
5366         }
5367 }
5368
5369 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5370 {
5371         int ret;
5372
5373         lockdep_assert_held(&ar->conf_mutex);
5374
5375         if (ath11k_check_chain_mask(ar, tx_ant, true))
5376                 return -EINVAL;
5377
5378         if (ath11k_check_chain_mask(ar, rx_ant, false))
5379                 return -EINVAL;
5380
5381         ar->cfg_tx_chainmask = tx_ant;
5382         ar->cfg_rx_chainmask = rx_ant;
5383
5384         if (ar->state != ATH11K_STATE_ON &&
5385             ar->state != ATH11K_STATE_RESTARTED)
5386                 return 0;
5387
5388         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5389                                         tx_ant, ar->pdev->pdev_id);
5390         if (ret) {
5391                 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5392                             ret, tx_ant);
5393                 return ret;
5394         }
5395
5396         ar->num_tx_chains = get_num_chains(tx_ant);
5397
5398         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5399                                         rx_ant, ar->pdev->pdev_id);
5400         if (ret) {
5401                 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5402                             ret, rx_ant);
5403                 return ret;
5404         }
5405
5406         ar->num_rx_chains = get_num_chains(rx_ant);
5407
5408         /* Reload HT/VHT/HE capability */
5409         ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
5410         ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
5411
5412         return 0;
5413 }
5414
5415 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5416 {
5417         int num_mgmt;
5418
5419         ieee80211_free_txskb(ar->hw, skb);
5420
5421         num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5422
5423         if (num_mgmt < 0)
5424                 WARN_ON_ONCE(1);
5425
5426         if (!num_mgmt)
5427                 wake_up(&ar->txmgmt_empty_waitq);
5428 }
5429
5430 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
5431 {
5432         struct sk_buff *msdu;
5433         struct ieee80211_tx_info *info;
5434
5435         spin_lock_bh(&ar->txmgmt_idr_lock);
5436         msdu = idr_remove(&ar->txmgmt_idr, buf_id);
5437         spin_unlock_bh(&ar->txmgmt_idr_lock);
5438
5439         if (!msdu)
5440                 return;
5441
5442         dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
5443                          DMA_TO_DEVICE);
5444
5445         info = IEEE80211_SKB_CB(msdu);
5446         memset(&info->status, 0, sizeof(info->status));
5447
5448         ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
5449 }
5450
5451 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
5452 {
5453         struct ath11k *ar = ctx;
5454
5455         ath11k_mac_tx_mgmt_free(ar, buf_id);
5456
5457         return 0;
5458 }
5459
5460 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
5461 {
5462         struct ieee80211_vif *vif = ctx;
5463         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
5464         struct ath11k *ar = skb_cb->ar;
5465
5466         if (skb_cb->vif == vif)
5467                 ath11k_mac_tx_mgmt_free(ar, buf_id);
5468
5469         return 0;
5470 }
5471
5472 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
5473                                   struct sk_buff *skb)
5474 {
5475         struct ath11k_base *ab = ar->ab;
5476         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5477         struct ieee80211_tx_info *info;
5478         dma_addr_t paddr;
5479         int buf_id;
5480         int ret;
5481
5482         ATH11K_SKB_CB(skb)->ar = ar;
5483
5484         spin_lock_bh(&ar->txmgmt_idr_lock);
5485         buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
5486                            ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
5487         spin_unlock_bh(&ar->txmgmt_idr_lock);
5488
5489         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5490                    "mac tx mgmt frame, buf id %d\n", buf_id);
5491
5492         if (buf_id < 0)
5493                 return -ENOSPC;
5494
5495         info = IEEE80211_SKB_CB(skb);
5496         if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
5497                 if ((ieee80211_is_action(hdr->frame_control) ||
5498                      ieee80211_is_deauth(hdr->frame_control) ||
5499                      ieee80211_is_disassoc(hdr->frame_control)) &&
5500                      ieee80211_has_protected(hdr->frame_control)) {
5501                         skb_put(skb, IEEE80211_CCMP_MIC_LEN);
5502                 }
5503         }
5504
5505         paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
5506         if (dma_mapping_error(ab->dev, paddr)) {
5507                 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
5508                 ret = -EIO;
5509                 goto err_free_idr;
5510         }
5511
5512         ATH11K_SKB_CB(skb)->paddr = paddr;
5513
5514         ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
5515         if (ret) {
5516                 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
5517                 goto err_unmap_buf;
5518         }
5519
5520         return 0;
5521
5522 err_unmap_buf:
5523         dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
5524                          skb->len, DMA_TO_DEVICE);
5525 err_free_idr:
5526         spin_lock_bh(&ar->txmgmt_idr_lock);
5527         idr_remove(&ar->txmgmt_idr, buf_id);
5528         spin_unlock_bh(&ar->txmgmt_idr_lock);
5529
5530         return ret;
5531 }
5532
5533 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
5534 {
5535         struct sk_buff *skb;
5536
5537         while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
5538                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5539 }
5540
5541 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
5542 {
5543         struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
5544         struct ath11k_skb_cb *skb_cb;
5545         struct ath11k_vif *arvif;
5546         struct sk_buff *skb;
5547         int ret;
5548
5549         while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
5550                 skb_cb = ATH11K_SKB_CB(skb);
5551                 if (!skb_cb->vif) {
5552                         ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
5553                         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5554                         continue;
5555                 }
5556
5557                 arvif = ath11k_vif_to_arvif(skb_cb->vif);
5558                 mutex_lock(&ar->conf_mutex);
5559                 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) {
5560                         ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
5561                         if (ret) {
5562                                 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
5563                                             arvif->vdev_id, ret);
5564                                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5565                         } else {
5566                                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5567                                            "mac tx mgmt frame, vdev_id %d\n",
5568                                            arvif->vdev_id);
5569                         }
5570                 } else {
5571                         ath11k_warn(ar->ab,
5572                                     "dropping mgmt frame for vdev %d, is_started %d\n",
5573                                     arvif->vdev_id,
5574                                     arvif->is_started);
5575                         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5576                 }
5577                 mutex_unlock(&ar->conf_mutex);
5578         }
5579 }
5580
5581 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
5582                               bool is_prb_rsp)
5583 {
5584         struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
5585
5586         if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
5587                 return -ESHUTDOWN;
5588
5589         /* Drop probe response packets when the pending management tx
5590          * count has reached a certain threshold, so as to prioritize
5591          * other mgmt packets like auth and assoc to be sent on time
5592          * for establishing successful connections.
5593          */
5594         if (is_prb_rsp &&
5595             atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
5596                 ath11k_warn(ar->ab,
5597                             "dropping probe response as pending queue is almost full\n");
5598                 return -ENOSPC;
5599         }
5600
5601         if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
5602                 ath11k_warn(ar->ab, "mgmt tx queue is full\n");
5603                 return -ENOSPC;
5604         }
5605
5606         skb_queue_tail(q, skb);
5607         atomic_inc(&ar->num_pending_mgmt_tx);
5608         queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work);
5609
5610         return 0;
5611 }
5612
5613 int ath11k_mac_rfkill_config(struct ath11k *ar)
5614 {
5615         struct ath11k_base *ab = ar->ab;
5616         u32 param;
5617         int ret;
5618
5619         if (ab->hw_params.rfkill_pin == 0)
5620                 return -EOPNOTSUPP;
5621
5622         ath11k_dbg(ab, ATH11K_DBG_MAC,
5623                    "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d",
5624                    ab->hw_params.rfkill_pin, ab->hw_params.rfkill_cfg,
5625                    ab->hw_params.rfkill_on_level);
5626
5627         param = FIELD_PREP(WMI_RFKILL_CFG_RADIO_LEVEL,
5628                            ab->hw_params.rfkill_on_level) |
5629                 FIELD_PREP(WMI_RFKILL_CFG_GPIO_PIN_NUM,
5630                            ab->hw_params.rfkill_pin) |
5631                 FIELD_PREP(WMI_RFKILL_CFG_PIN_AS_GPIO,
5632                            ab->hw_params.rfkill_cfg);
5633
5634         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG,
5635                                         param, ar->pdev->pdev_id);
5636         if (ret) {
5637                 ath11k_warn(ab,
5638                             "failed to set rfkill config 0x%x: %d\n",
5639                             param, ret);
5640                 return ret;
5641         }
5642
5643         return 0;
5644 }
5645
5646 int ath11k_mac_rfkill_enable_radio(struct ath11k *ar, bool enable)
5647 {
5648         enum wmi_rfkill_enable_radio param;
5649         int ret;
5650
5651         if (enable)
5652                 param = WMI_RFKILL_ENABLE_RADIO_ON;
5653         else
5654                 param = WMI_RFKILL_ENABLE_RADIO_OFF;
5655
5656         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac %d rfkill enable %d",
5657                    ar->pdev_idx, param);
5658
5659         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE,
5660                                         param, ar->pdev->pdev_id);
5661         if (ret) {
5662                 ath11k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n",
5663                             param, ret);
5664                 return ret;
5665         }
5666
5667         return 0;
5668 }
5669
5670 static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
5671                              struct ieee80211_tx_control *control,
5672                              struct sk_buff *skb)
5673 {
5674         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
5675         struct ath11k *ar = hw->priv;
5676         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
5677         struct ieee80211_vif *vif = info->control.vif;
5678         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5679         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5680         struct ieee80211_key_conf *key = info->control.hw_key;
5681         struct ath11k_sta *arsta = NULL;
5682         u32 info_flags = info->flags;
5683         bool is_prb_rsp;
5684         int ret;
5685
5686         memset(skb_cb, 0, sizeof(*skb_cb));
5687         skb_cb->vif = vif;
5688
5689         if (key) {
5690                 skb_cb->cipher = key->cipher;
5691                 skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
5692         }
5693
5694         if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
5695                 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
5696         } else if (ieee80211_is_mgmt(hdr->frame_control)) {
5697                 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
5698                 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
5699                 if (ret) {
5700                         ath11k_warn(ar->ab, "failed to queue management frame %d\n",
5701                                     ret);
5702                         ieee80211_free_txskb(ar->hw, skb);
5703                 }
5704                 return;
5705         }
5706
5707         if (control->sta)
5708                 arsta = (struct ath11k_sta *)control->sta->drv_priv;
5709
5710         ret = ath11k_dp_tx(ar, arvif, arsta, skb);
5711         if (unlikely(ret)) {
5712                 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
5713                 ieee80211_free_txskb(ar->hw, skb);
5714         }
5715 }
5716
5717 void ath11k_mac_drain_tx(struct ath11k *ar)
5718 {
5719         /* make sure rcu-protected mac80211 tx path itself is drained */
5720         synchronize_net();
5721
5722         cancel_work_sync(&ar->wmi_mgmt_tx_work);
5723         ath11k_mgmt_over_wmi_tx_purge(ar);
5724 }
5725
5726 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
5727 {
5728         struct htt_rx_ring_tlv_filter tlv_filter = {0};
5729         struct ath11k_base *ab = ar->ab;
5730         int i, ret = 0;
5731         u32 ring_id;
5732
5733         if (enable) {
5734                 tlv_filter = ath11k_mac_mon_status_filter_default;
5735                 if (ath11k_debugfs_rx_filter(ar))
5736                         tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
5737         }
5738
5739         for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
5740                 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
5741                 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
5742                                                        ar->dp.mac_id + i,
5743                                                        HAL_RXDMA_MONITOR_STATUS,
5744                                                        DP_RX_BUFFER_SIZE,
5745                                                        &tlv_filter);
5746         }
5747
5748         if (enable && !ar->ab->hw_params.rxdma1_enable)
5749                 mod_timer(&ar->ab->mon_reap_timer, jiffies +
5750                           msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
5751
5752         return ret;
5753 }
5754
5755 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
5756 {
5757         int recovery_start_count;
5758
5759         if (!ab->is_reset)
5760                 return;
5761
5762         recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
5763         ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
5764
5765         if (recovery_start_count == ab->num_radios) {
5766                 complete(&ab->recovery_start);
5767                 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
5768         }
5769
5770         ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
5771
5772         wait_for_completion_timeout(&ab->reconfigure_complete,
5773                                     ATH11K_RECONFIGURE_TIMEOUT_HZ);
5774 }
5775
5776 static int ath11k_mac_op_start(struct ieee80211_hw *hw)
5777 {
5778         struct ath11k *ar = hw->priv;
5779         struct ath11k_base *ab = ar->ab;
5780         struct ath11k_pdev *pdev = ar->pdev;
5781         int ret;
5782
5783         ath11k_mac_drain_tx(ar);
5784         mutex_lock(&ar->conf_mutex);
5785
5786         switch (ar->state) {
5787         case ATH11K_STATE_OFF:
5788                 ar->state = ATH11K_STATE_ON;
5789                 break;
5790         case ATH11K_STATE_RESTARTING:
5791                 ar->state = ATH11K_STATE_RESTARTED;
5792                 ath11k_mac_wait_reconfigure(ab);
5793                 break;
5794         case ATH11K_STATE_RESTARTED:
5795         case ATH11K_STATE_WEDGED:
5796         case ATH11K_STATE_ON:
5797                 WARN_ON(1);
5798                 ret = -EINVAL;
5799                 goto err;
5800         }
5801
5802         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
5803                                         1, pdev->pdev_id);
5804
5805         if (ret) {
5806                 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
5807                 goto err;
5808         }
5809
5810         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
5811                                         pdev->pdev_id);
5812         if (ret) {
5813                 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
5814                 goto err;
5815         }
5816
5817         if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
5818                 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
5819                 if (ret) {
5820                         ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
5821                         goto err;
5822                 }
5823         }
5824
5825         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
5826                                         0, pdev->pdev_id);
5827         if (ret) {
5828                 ath11k_err(ab, "failed to set ac override for ARP: %d\n",
5829                            ret);
5830                 goto err;
5831         }
5832
5833         ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
5834         if (ret) {
5835                 ath11k_err(ab, "failed to offload radar detection: %d\n",
5836                            ret);
5837                 goto err;
5838         }
5839
5840         ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
5841                                                   HTT_PPDU_STATS_TAG_DEFAULT);
5842         if (ret) {
5843                 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
5844                 goto err;
5845         }
5846
5847         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
5848                                         1, pdev->pdev_id);
5849
5850         if (ret) {
5851                 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
5852                 goto err;
5853         }
5854
5855         __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5856
5857         /* TODO: Do we need to enable ANI? */
5858
5859         ath11k_reg_update_chan_list(ar, false);
5860
5861         ar->num_started_vdevs = 0;
5862         ar->num_created_vdevs = 0;
5863         ar->num_peers = 0;
5864         ar->allocated_vdev_map = 0;
5865
5866         /* Configure monitor status ring with default rx_filter to get rx status
5867          * such as rssi, rx_duration.
5868          */
5869         ret = ath11k_mac_config_mon_status_default(ar, true);
5870         if (ret) {
5871                 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
5872                            ret);
5873                 goto err;
5874         }
5875
5876         /* Configure the hash seed for hash based reo dest ring selection */
5877         ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
5878
5879         /* allow device to enter IMPS */
5880         if (ab->hw_params.idle_ps) {
5881                 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
5882                                                 1, pdev->pdev_id);
5883                 if (ret) {
5884                         ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
5885                         goto err;
5886                 }
5887         }
5888
5889         mutex_unlock(&ar->conf_mutex);
5890
5891         rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
5892                            &ab->pdevs[ar->pdev_idx]);
5893
5894         return 0;
5895
5896 err:
5897         ar->state = ATH11K_STATE_OFF;
5898         mutex_unlock(&ar->conf_mutex);
5899
5900         return ret;
5901 }
5902
5903 static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
5904 {
5905         struct ath11k *ar = hw->priv;
5906         struct htt_ppdu_stats_info *ppdu_stats, *tmp;
5907         int ret;
5908
5909         ath11k_mac_drain_tx(ar);
5910
5911         mutex_lock(&ar->conf_mutex);
5912         ret = ath11k_mac_config_mon_status_default(ar, false);
5913         if (ret)
5914                 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
5915                            ret);
5916
5917         clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
5918         ar->state = ATH11K_STATE_OFF;
5919         mutex_unlock(&ar->conf_mutex);
5920
5921         cancel_delayed_work_sync(&ar->scan.timeout);
5922         cancel_work_sync(&ar->regd_update_work);
5923         cancel_work_sync(&ar->ab->update_11d_work);
5924         cancel_work_sync(&ar->ab->rfkill_work);
5925
5926         if (ar->state_11d == ATH11K_11D_PREPARING) {
5927                 ar->state_11d = ATH11K_11D_IDLE;
5928                 complete(&ar->completed_11d_scan);
5929         }
5930
5931         spin_lock_bh(&ar->data_lock);
5932         list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
5933                 list_del(&ppdu_stats->list);
5934                 kfree(ppdu_stats);
5935         }
5936         spin_unlock_bh(&ar->data_lock);
5937
5938         rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
5939
5940         synchronize_rcu();
5941
5942         atomic_set(&ar->num_pending_mgmt_tx, 0);
5943 }
5944
5945 static void
5946 ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
5947                                     struct vdev_create_params *params)
5948 {
5949         struct ath11k *ar = arvif->ar;
5950         struct ath11k_pdev *pdev = ar->pdev;
5951
5952         params->if_id = arvif->vdev_id;
5953         params->type = arvif->vdev_type;
5954         params->subtype = arvif->vdev_subtype;
5955         params->pdev_id = pdev->pdev_id;
5956
5957         if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
5958                 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
5959                 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
5960         }
5961         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
5962                 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
5963                 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
5964         }
5965         if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
5966             ar->supports_6ghz) {
5967                 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
5968                 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
5969         }
5970 }
5971
5972 static u32
5973 ath11k_mac_prepare_he_mode(struct ath11k_pdev *pdev, u32 viftype)
5974 {
5975         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
5976         struct ath11k_band_cap *cap_band = NULL;
5977         u32 *hecap_phy_ptr = NULL;
5978         u32 hemode = 0;
5979
5980         if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP)
5981                 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
5982         else
5983                 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
5984
5985         hecap_phy_ptr = &cap_band->he_cap_phy_info[0];
5986
5987         hemode = FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE) |
5988                  FIELD_PREP(HE_MODE_SU_TX_BFER, HECAP_PHY_SUBFMR_GET(hecap_phy_ptr)) |
5989                  FIELD_PREP(HE_MODE_UL_MUMIMO, HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr));
5990
5991         /* TODO WDS and other modes */
5992         if (viftype == NL80211_IFTYPE_AP) {
5993                 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFER,
5994                           HECAP_PHY_MUBFMR_GET(hecap_phy_ptr)) |
5995                           FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
5996                           FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
5997         } else {
5998                 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
5999         }
6000
6001         return hemode;
6002 }
6003
6004 static int ath11k_set_he_mu_sounding_mode(struct ath11k *ar,
6005                                           struct ath11k_vif *arvif)
6006 {
6007         u32 param_id, param_value;
6008         struct ath11k_base *ab = ar->ab;
6009         int ret = 0;
6010
6011         param_id = WMI_VDEV_PARAM_SET_HEMU_MODE;
6012         param_value = ath11k_mac_prepare_he_mode(ar->pdev, arvif->vif->type);
6013         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6014                                             param_id, param_value);
6015         if (ret) {
6016                 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n",
6017                             arvif->vdev_id, ret, param_value);
6018                 return ret;
6019         }
6020         param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
6021         param_value =
6022                 FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
6023                 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
6024                            HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
6025         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6026                                             param_id, param_value);
6027         if (ret) {
6028                 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d\n",
6029                             arvif->vdev_id, ret);
6030                 return ret;
6031         }
6032         return ret;
6033 }
6034
6035 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
6036                                              struct ieee80211_vif *vif)
6037 {
6038         struct ath11k *ar = hw->priv;
6039         struct ath11k_base *ab = ar->ab;
6040         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6041         u32 param_id, param_value;
6042         int ret;
6043
6044         param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
6045         if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
6046             (vif->type != NL80211_IFTYPE_STATION &&
6047              vif->type != NL80211_IFTYPE_AP))
6048                 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
6049                                         IEEE80211_OFFLOAD_DECAP_ENABLED);
6050
6051         if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
6052                 param_value = ATH11K_HW_TXRX_ETHERNET;
6053         else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6054                 param_value = ATH11K_HW_TXRX_RAW;
6055         else
6056                 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6057
6058         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6059                                             param_id, param_value);
6060         if (ret) {
6061                 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6062                             arvif->vdev_id, ret);
6063                 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6064         }
6065
6066         param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6067         if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6068                 param_value = ATH11K_HW_TXRX_ETHERNET;
6069         else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6070                 param_value = ATH11K_HW_TXRX_RAW;
6071         else
6072                 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6073
6074         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6075                                             param_id, param_value);
6076         if (ret) {
6077                 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6078                             arvif->vdev_id, ret);
6079                 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6080         }
6081 }
6082
6083 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6084 {
6085         struct ath11k *ar;
6086         struct ath11k_pdev *pdev;
6087         struct ath11k_vif *arvif;
6088         int i;
6089
6090         for (i = 0; i < ab->num_radios; i++) {
6091                 pdev = &ab->pdevs[i];
6092                 ar = pdev->ar;
6093                 list_for_each_entry(arvif, &ar->arvifs, list) {
6094                         if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6095                                 return true;
6096                 }
6097         }
6098         return false;
6099 }
6100
6101 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
6102 {
6103         struct wmi_11d_scan_start_params param;
6104         int ret;
6105
6106         mutex_lock(&ar->ab->vdev_id_11d_lock);
6107
6108         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev id for 11d scan %d\n",
6109                    ar->vdev_id_11d_scan);
6110
6111         if (ar->regdom_set_by_user)
6112                 goto fin;
6113
6114         if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6115                 goto fin;
6116
6117         if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6118                 goto fin;
6119
6120         if (ath11k_mac_vif_ap_active_any(ar->ab))
6121                 goto fin;
6122
6123         param.vdev_id = vdev_id;
6124         param.start_interval_msec = 0;
6125         param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6126
6127         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac start 11d scan\n");
6128
6129         ret = ath11k_wmi_send_11d_scan_start_cmd(ar, &param);
6130         if (ret) {
6131                 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6132                             vdev_id, ret);
6133         } else {
6134                 ar->vdev_id_11d_scan = vdev_id;
6135                 if (ar->state_11d == ATH11K_11D_PREPARING)
6136                         ar->state_11d = ATH11K_11D_RUNNING;
6137         }
6138
6139 fin:
6140         if (ar->state_11d == ATH11K_11D_PREPARING) {
6141                 ar->state_11d = ATH11K_11D_IDLE;
6142                 complete(&ar->completed_11d_scan);
6143         }
6144
6145         mutex_unlock(&ar->ab->vdev_id_11d_lock);
6146 }
6147
6148 void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6149 {
6150         int ret;
6151         u32 vdev_id;
6152
6153         if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6154                 return;
6155
6156         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d scan\n");
6157
6158         mutex_lock(&ar->ab->vdev_id_11d_lock);
6159
6160         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d vdev id %d\n",
6161                    ar->vdev_id_11d_scan);
6162
6163         if (ar->state_11d == ATH11K_11D_PREPARING) {
6164                 ar->state_11d = ATH11K_11D_IDLE;
6165                 complete(&ar->completed_11d_scan);
6166         }
6167
6168         if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6169                 vdev_id = ar->vdev_id_11d_scan;
6170
6171                 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
6172                 if (ret) {
6173                         ath11k_warn(ar->ab,
6174                                     "failed to stopt 11d scan vdev %d ret: %d\n",
6175                                     vdev_id, ret);
6176                 } else {
6177                         ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
6178                         ar->state_11d = ATH11K_11D_IDLE;
6179                         complete(&ar->completed_11d_scan);
6180                 }
6181         }
6182         mutex_unlock(&ar->ab->vdev_id_11d_lock);
6183 }
6184
6185 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6186 {
6187         struct ath11k *ar;
6188         struct ath11k_pdev *pdev;
6189         int i;
6190
6191         ath11k_dbg(ab, ATH11K_DBG_MAC, "mac stop soc 11d scan\n");
6192
6193         for (i = 0; i < ab->num_radios; i++) {
6194                 pdev = &ab->pdevs[i];
6195                 ar = pdev->ar;
6196
6197                 ath11k_mac_11d_scan_stop(ar);
6198         }
6199 }
6200
6201 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6202                                        struct ieee80211_vif *vif)
6203 {
6204         struct ath11k *ar = hw->priv;
6205         struct ath11k_base *ab = ar->ab;
6206         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6207         struct vdev_create_params vdev_param = {0};
6208         struct peer_create_params peer_param;
6209         u32 param_id, param_value;
6210         u16 nss;
6211         int i;
6212         int ret, fbret;
6213         int bit;
6214
6215         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6216
6217         mutex_lock(&ar->conf_mutex);
6218
6219         if (vif->type == NL80211_IFTYPE_AP &&
6220             ar->num_peers > (ar->max_num_peers - 1)) {
6221                 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6222                 ret = -ENOBUFS;
6223                 goto err;
6224         }
6225
6226         if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
6227                 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
6228                             ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
6229                 ret = -EBUSY;
6230                 goto err;
6231         }
6232
6233         memset(arvif, 0, sizeof(*arvif));
6234
6235         arvif->ar = ar;
6236         arvif->vif = vif;
6237
6238         INIT_LIST_HEAD(&arvif->list);
6239         INIT_DELAYED_WORK(&arvif->connection_loss_work,
6240                           ath11k_mac_vif_sta_connection_loss_work);
6241
6242         for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6243                 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
6244                 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
6245                 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6246                        sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6247                 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6248                        sizeof(arvif->bitrate_mask.control[i].vht_mcs));
6249                 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6250                        sizeof(arvif->bitrate_mask.control[i].he_mcs));
6251         }
6252
6253         bit = __ffs64(ab->free_vdev_map);
6254
6255         arvif->vdev_id = bit;
6256         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6257
6258         switch (vif->type) {
6259         case NL80211_IFTYPE_UNSPECIFIED:
6260         case NL80211_IFTYPE_STATION:
6261                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
6262                 break;
6263         case NL80211_IFTYPE_MESH_POINT:
6264                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
6265                 fallthrough;
6266         case NL80211_IFTYPE_AP:
6267                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
6268                 break;
6269         case NL80211_IFTYPE_MONITOR:
6270                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
6271                 ar->monitor_vdev_id = bit;
6272                 break;
6273         default:
6274                 WARN_ON(1);
6275                 break;
6276         }
6277
6278         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n",
6279                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6280                    ab->free_vdev_map);
6281
6282         vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6283         for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6284                 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6285
6286         ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6287
6288         ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6289         if (ret) {
6290                 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6291                             arvif->vdev_id, ret);
6292                 goto err;
6293         }
6294
6295         ar->num_created_vdevs++;
6296         ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6297                    vif->addr, arvif->vdev_id);
6298         ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
6299         ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
6300
6301         spin_lock_bh(&ar->data_lock);
6302         list_add(&arvif->list, &ar->arvifs);
6303         spin_unlock_bh(&ar->data_lock);
6304
6305         ath11k_mac_op_update_vif_offload(hw, vif);
6306
6307         nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6308         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6309                                             WMI_VDEV_PARAM_NSS, nss);
6310         if (ret) {
6311                 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6312                             arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6313                 goto err_vdev_del;
6314         }
6315
6316         switch (arvif->vdev_type) {
6317         case WMI_VDEV_TYPE_AP:
6318                 peer_param.vdev_id = arvif->vdev_id;
6319                 peer_param.peer_addr = vif->addr;
6320                 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6321                 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6322                 if (ret) {
6323                         ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6324                                     arvif->vdev_id, ret);
6325                         goto err_vdev_del;
6326                 }
6327
6328                 ret = ath11k_mac_set_kickout(arvif);
6329                 if (ret) {
6330                         ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6331                                     arvif->vdev_id, ret);
6332                         goto err_peer_del;
6333                 }
6334
6335                 ath11k_mac_11d_scan_stop_all(ar->ab);
6336                 break;
6337         case WMI_VDEV_TYPE_STA:
6338                 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6339                 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6340                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6341                                                   param_id, param_value);
6342                 if (ret) {
6343                         ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6344                                     arvif->vdev_id, ret);
6345                         goto err_peer_del;
6346                 }
6347
6348                 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6349                 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6350                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6351                                                   param_id, param_value);
6352                 if (ret) {
6353                         ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6354                                     arvif->vdev_id, ret);
6355                         goto err_peer_del;
6356                 }
6357
6358                 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6359                 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6360                 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6361                                                   param_id, param_value);
6362                 if (ret) {
6363                         ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6364                                     arvif->vdev_id, ret);
6365                         goto err_peer_del;
6366                 }
6367
6368                 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6369                                                   WMI_STA_PS_MODE_DISABLED);
6370                 if (ret) {
6371                         ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6372                                     arvif->vdev_id, ret);
6373                         goto err_peer_del;
6374                 }
6375
6376                 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6377                         reinit_completion(&ar->completed_11d_scan);
6378                         ar->state_11d = ATH11K_11D_PREPARING;
6379                 }
6380                 break;
6381         case WMI_VDEV_TYPE_MONITOR:
6382                 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6383                 break;
6384         default:
6385                 break;
6386         }
6387
6388         arvif->txpower = vif->bss_conf.txpower;
6389         ret = ath11k_mac_txpower_recalc(ar);
6390         if (ret)
6391                 goto err_peer_del;
6392
6393         param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6394         param_value = ar->hw->wiphy->rts_threshold;
6395         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6396                                             param_id, param_value);
6397         if (ret) {
6398                 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6399                             arvif->vdev_id, ret);
6400         }
6401
6402         ath11k_dp_vdev_tx_attach(ar, arvif);
6403
6404         if (vif->type != NL80211_IFTYPE_MONITOR &&
6405             test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6406                 ret = ath11k_mac_monitor_vdev_create(ar);
6407                 if (ret) {
6408                         ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6409                                     ret);
6410                         goto err_peer_del;
6411                 }
6412         }
6413
6414         ret = ath11k_debugfs_add_interface(arvif);
6415         if (ret)
6416                 goto err_peer_del;
6417
6418         mutex_unlock(&ar->conf_mutex);
6419
6420         return 0;
6421
6422 err_peer_del:
6423         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6424                 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6425                 if (fbret) {
6426                         ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6427                                     vif->addr, arvif->vdev_id, fbret);
6428                         goto err;
6429                 }
6430         }
6431
6432 err_vdev_del:
6433         ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6434         ar->num_created_vdevs--;
6435         ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6436         ab->free_vdev_map |= 1LL << arvif->vdev_id;
6437         spin_lock_bh(&ar->data_lock);
6438         list_del(&arvif->list);
6439         spin_unlock_bh(&ar->data_lock);
6440
6441 err:
6442         ath11k_debugfs_remove_interface(arvif);
6443         mutex_unlock(&ar->conf_mutex);
6444
6445         return ret;
6446 }
6447
6448 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6449 {
6450         struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx;
6451         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6452
6453         if (skb_cb->vif == vif)
6454                 skb_cb->vif = NULL;
6455
6456         return 0;
6457 }
6458
6459 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6460                                            struct ieee80211_vif *vif)
6461 {
6462         struct ath11k *ar = hw->priv;
6463         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6464         struct ath11k_base *ab = ar->ab;
6465         unsigned long time_left;
6466         int ret;
6467         int i;
6468
6469         cancel_delayed_work_sync(&arvif->connection_loss_work);
6470
6471         mutex_lock(&ar->conf_mutex);
6472
6473         ath11k_dbg(ab, ATH11K_DBG_MAC, "mac remove interface (vdev %d)\n",
6474                    arvif->vdev_id);
6475
6476         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
6477                 ath11k_mac_11d_scan_stop(ar);
6478
6479         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6480                 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6481                 if (ret)
6482                         ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
6483                                     arvif->vdev_id, ret);
6484         }
6485
6486         reinit_completion(&ar->vdev_delete_done);
6487
6488         ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6489         if (ret) {
6490                 ath11k_warn(ab, "failed to delete WMI vdev %d: %d\n",
6491                             arvif->vdev_id, ret);
6492                 goto err_vdev_del;
6493         }
6494
6495         time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6496                                                 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6497         if (time_left == 0) {
6498                 ath11k_warn(ab, "Timeout in receiving vdev delete response\n");
6499                 goto err_vdev_del;
6500         }
6501
6502         ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6503         ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6504         ar->num_created_vdevs--;
6505
6506         ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6507                    vif->addr, arvif->vdev_id);
6508
6509         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6510                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6511                 ar->monitor_vdev_id = -1;
6512         } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
6513                    !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
6514                 ret = ath11k_mac_monitor_vdev_delete(ar);
6515                 if (ret)
6516                         /* continue even if there's an error */
6517                         ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
6518                                     ret);
6519         }
6520
6521 err_vdev_del:
6522         spin_lock_bh(&ar->data_lock);
6523         list_del(&arvif->list);
6524         spin_unlock_bh(&ar->data_lock);
6525
6526         ath11k_peer_cleanup(ar, arvif->vdev_id);
6527
6528         idr_for_each(&ar->txmgmt_idr,
6529                      ath11k_mac_vif_txmgmt_idr_remove, vif);
6530
6531         for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
6532                 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6533                 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
6534                              ath11k_mac_vif_unref, vif);
6535                 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6536         }
6537
6538         /* Recalc txpower for remaining vdev */
6539         ath11k_mac_txpower_recalc(ar);
6540
6541         ath11k_debugfs_remove_interface(arvif);
6542
6543         /* TODO: recal traffic pause state based on the available vdevs */
6544
6545         mutex_unlock(&ar->conf_mutex);
6546 }
6547
6548 /* FIXME: Has to be verified. */
6549 #define SUPPORTED_FILTERS                       \
6550         (FIF_ALLMULTI |                         \
6551         FIF_CONTROL |                           \
6552         FIF_PSPOLL |                            \
6553         FIF_OTHER_BSS |                         \
6554         FIF_BCN_PRBRESP_PROMISC |               \
6555         FIF_PROBE_REQ |                         \
6556         FIF_FCSFAIL)
6557
6558 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
6559                                            unsigned int changed_flags,
6560                                            unsigned int *total_flags,
6561                                            u64 multicast)
6562 {
6563         struct ath11k *ar = hw->priv;
6564
6565         mutex_lock(&ar->conf_mutex);
6566
6567         *total_flags &= SUPPORTED_FILTERS;
6568         ar->filter_flags = *total_flags;
6569
6570         mutex_unlock(&ar->conf_mutex);
6571 }
6572
6573 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
6574 {
6575         struct ath11k *ar = hw->priv;
6576
6577         mutex_lock(&ar->conf_mutex);
6578
6579         *tx_ant = ar->cfg_tx_chainmask;
6580         *rx_ant = ar->cfg_rx_chainmask;
6581
6582         mutex_unlock(&ar->conf_mutex);
6583
6584         return 0;
6585 }
6586
6587 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
6588 {
6589         struct ath11k *ar = hw->priv;
6590         int ret;
6591
6592         mutex_lock(&ar->conf_mutex);
6593         ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
6594         mutex_unlock(&ar->conf_mutex);
6595
6596         return ret;
6597 }
6598
6599 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
6600                                       struct ieee80211_vif *vif,
6601                                       struct ieee80211_ampdu_params *params)
6602 {
6603         struct ath11k *ar = hw->priv;
6604         int ret = -EINVAL;
6605
6606         mutex_lock(&ar->conf_mutex);
6607
6608         switch (params->action) {
6609         case IEEE80211_AMPDU_RX_START:
6610                 ret = ath11k_dp_rx_ampdu_start(ar, params);
6611                 break;
6612         case IEEE80211_AMPDU_RX_STOP:
6613                 ret = ath11k_dp_rx_ampdu_stop(ar, params);
6614                 break;
6615         case IEEE80211_AMPDU_TX_START:
6616         case IEEE80211_AMPDU_TX_STOP_CONT:
6617         case IEEE80211_AMPDU_TX_STOP_FLUSH:
6618         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6619         case IEEE80211_AMPDU_TX_OPERATIONAL:
6620                 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
6621                  * Tx aggregation requests.
6622                  */
6623                 ret = -EOPNOTSUPP;
6624                 break;
6625         }
6626
6627         mutex_unlock(&ar->conf_mutex);
6628
6629         return ret;
6630 }
6631
6632 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6633                                      struct ieee80211_chanctx_conf *ctx)
6634 {
6635         struct ath11k *ar = hw->priv;
6636         struct ath11k_base *ab = ar->ab;
6637
6638         ath11k_dbg(ab, ATH11K_DBG_MAC,
6639                    "mac chanctx add freq %u width %d ptr %pK\n",
6640                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6641
6642         mutex_lock(&ar->conf_mutex);
6643
6644         spin_lock_bh(&ar->data_lock);
6645         /* TODO: In case of multiple channel context, populate rx_channel from
6646          * Rx PPDU desc information.
6647          */
6648         ar->rx_channel = ctx->def.chan;
6649         spin_unlock_bh(&ar->data_lock);
6650
6651         mutex_unlock(&ar->conf_mutex);
6652
6653         return 0;
6654 }
6655
6656 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6657                                          struct ieee80211_chanctx_conf *ctx)
6658 {
6659         struct ath11k *ar = hw->priv;
6660         struct ath11k_base *ab = ar->ab;
6661
6662         ath11k_dbg(ab, ATH11K_DBG_MAC,
6663                    "mac chanctx remove freq %u width %d ptr %pK\n",
6664                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6665
6666         mutex_lock(&ar->conf_mutex);
6667
6668         spin_lock_bh(&ar->data_lock);
6669         /* TODO: In case of there is one more channel context left, populate
6670          * rx_channel with the channel of that remaining channel context.
6671          */
6672         ar->rx_channel = NULL;
6673         spin_unlock_bh(&ar->data_lock);
6674
6675         mutex_unlock(&ar->conf_mutex);
6676 }
6677
6678 static int
6679 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
6680                               struct ieee80211_chanctx_conf *ctx,
6681                               bool restart)
6682 {
6683         struct ath11k *ar = arvif->ar;
6684         struct ath11k_base *ab = ar->ab;
6685         struct wmi_vdev_start_req_arg arg = {};
6686         const struct cfg80211_chan_def *chandef = &ctx->def;
6687         int he_support = arvif->vif->bss_conf.he_support;
6688         int ret = 0;
6689
6690         lockdep_assert_held(&ar->conf_mutex);
6691
6692         reinit_completion(&ar->vdev_setup_done);
6693
6694         arg.vdev_id = arvif->vdev_id;
6695         arg.dtim_period = arvif->dtim_period;
6696         arg.bcn_intval = arvif->beacon_interval;
6697
6698         arg.channel.freq = chandef->chan->center_freq;
6699         arg.channel.band_center_freq1 = chandef->center_freq1;
6700         arg.channel.band_center_freq2 = chandef->center_freq2;
6701         arg.channel.mode =
6702                 ath11k_phymodes[chandef->chan->band][chandef->width];
6703
6704         arg.channel.min_power = 0;
6705         arg.channel.max_power = chandef->chan->max_power;
6706         arg.channel.max_reg_power = chandef->chan->max_reg_power;
6707         arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
6708
6709         arg.pref_tx_streams = ar->num_tx_chains;
6710         arg.pref_rx_streams = ar->num_rx_chains;
6711
6712         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6713                 arg.ssid = arvif->u.ap.ssid;
6714                 arg.ssid_len = arvif->u.ap.ssid_len;
6715                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
6716
6717                 /* For now allow DFS for AP mode */
6718                 arg.channel.chan_radar =
6719                         !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
6720
6721                 arg.channel.freq2_radar = ctx->radar_enabled;
6722
6723                 arg.channel.passive = arg.channel.chan_radar;
6724
6725                 spin_lock_bh(&ab->base_lock);
6726                 arg.regdomain = ar->ab->dfs_region;
6727                 spin_unlock_bh(&ab->base_lock);
6728
6729                 if (he_support) {
6730                         ret = ath11k_set_he_mu_sounding_mode(ar, arvif);
6731                         if (ret) {
6732                                 ath11k_warn(ar->ab, "failed to set he mode vdev %i\n",
6733                                             arg.vdev_id);
6734                                 return ret;
6735                         }
6736                 }
6737         }
6738
6739         arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
6740
6741         ath11k_dbg(ab, ATH11K_DBG_MAC,
6742                    "mac vdev %d start center_freq %d phymode %s\n",
6743                    arg.vdev_id, arg.channel.freq,
6744                    ath11k_wmi_phymode_str(arg.channel.mode));
6745
6746         ret = ath11k_wmi_vdev_start(ar, &arg, restart);
6747         if (ret) {
6748                 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
6749                             restart ? "restart" : "start", arg.vdev_id);
6750                 return ret;
6751         }
6752
6753         ret = ath11k_mac_vdev_setup_sync(ar);
6754         if (ret) {
6755                 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
6756                             arg.vdev_id, restart ? "restart" : "start", ret);
6757                 return ret;
6758         }
6759
6760         if (!restart)
6761                 ar->num_started_vdevs++;
6762
6763         ath11k_dbg(ab, ATH11K_DBG_MAC,  "vdev %pM started, vdev_id %d\n",
6764                    arvif->vif->addr, arvif->vdev_id);
6765
6766         /* Enable CAC Flag in the driver by checking the channel DFS cac time,
6767          * i.e dfs_cac_ms value which will be valid only for radar channels
6768          * and state as NL80211_DFS_USABLE which indicates CAC needs to be
6769          * done before channel usage. This flags is used to drop rx packets.
6770          * during CAC.
6771          */
6772         /* TODO Set the flag for other interface types as required */
6773         if (arvif->vdev_type == WMI_VDEV_TYPE_AP &&
6774             chandef->chan->dfs_cac_ms &&
6775             chandef->chan->dfs_state == NL80211_DFS_USABLE) {
6776                 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6777                 ath11k_dbg(ab, ATH11K_DBG_MAC,
6778                            "CAC Started in chan_freq %d for vdev %d\n",
6779                            arg.channel.freq, arg.vdev_id);
6780         }
6781
6782         ret = ath11k_mac_set_txbf_conf(arvif);
6783         if (ret)
6784                 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
6785                             arvif->vdev_id, ret);
6786
6787         return 0;
6788 }
6789
6790 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
6791 {
6792         struct ath11k *ar = arvif->ar;
6793         int ret;
6794
6795         lockdep_assert_held(&ar->conf_mutex);
6796
6797         reinit_completion(&ar->vdev_setup_done);
6798
6799         ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
6800         if (ret) {
6801                 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
6802                             arvif->vdev_id, ret);
6803                 goto err;
6804         }
6805
6806         ret = ath11k_mac_vdev_setup_sync(ar);
6807         if (ret) {
6808                 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
6809                             arvif->vdev_id, ret);
6810                 goto err;
6811         }
6812
6813         WARN_ON(ar->num_started_vdevs == 0);
6814
6815         ar->num_started_vdevs--;
6816         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
6817                    arvif->vif->addr, arvif->vdev_id);
6818
6819         if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
6820                 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6821                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
6822                            arvif->vdev_id);
6823         }
6824
6825         return 0;
6826 err:
6827         return ret;
6828 }
6829
6830 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
6831                                  struct ieee80211_chanctx_conf *ctx)
6832 {
6833         return ath11k_mac_vdev_start_restart(arvif, ctx, false);
6834 }
6835
6836 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
6837                                    struct ieee80211_chanctx_conf *ctx)
6838 {
6839         return ath11k_mac_vdev_start_restart(arvif, ctx, true);
6840 }
6841
6842 struct ath11k_mac_change_chanctx_arg {
6843         struct ieee80211_chanctx_conf *ctx;
6844         struct ieee80211_vif_chanctx_switch *vifs;
6845         int n_vifs;
6846         int next_vif;
6847 };
6848
6849 static void
6850 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6851                                    struct ieee80211_vif *vif)
6852 {
6853         struct ath11k_mac_change_chanctx_arg *arg = data;
6854
6855         if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
6856                 return;
6857
6858         arg->n_vifs++;
6859 }
6860
6861 static void
6862 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6863                                     struct ieee80211_vif *vif)
6864 {
6865         struct ath11k_mac_change_chanctx_arg *arg = data;
6866         struct ieee80211_chanctx_conf *ctx;
6867
6868         ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
6869         if (ctx != arg->ctx)
6870                 return;
6871
6872         if (WARN_ON(arg->next_vif == arg->n_vifs))
6873                 return;
6874
6875         arg->vifs[arg->next_vif].vif = vif;
6876         arg->vifs[arg->next_vif].old_ctx = ctx;
6877         arg->vifs[arg->next_vif].new_ctx = ctx;
6878         arg->next_vif++;
6879 }
6880
6881 static void
6882 ath11k_mac_update_vif_chan(struct ath11k *ar,
6883                            struct ieee80211_vif_chanctx_switch *vifs,
6884                            int n_vifs)
6885 {
6886         struct ath11k_base *ab = ar->ab;
6887         struct ath11k_vif *arvif;
6888         int ret;
6889         int i;
6890         bool monitor_vif = false;
6891
6892         lockdep_assert_held(&ar->conf_mutex);
6893
6894         /* Associated channel resources of all relevant vdevs
6895          * should be available for the channel switch now.
6896          */
6897
6898         /* TODO: Update ar->rx_channel */
6899
6900         for (i = 0; i < n_vifs; i++) {
6901                 arvif = (void *)vifs[i].vif->drv_priv;
6902
6903                 if (WARN_ON(!arvif->is_started))
6904                         continue;
6905
6906                 /* change_chanctx can be called even before vdev_up from
6907                  * ieee80211_start_ap->ieee80211_vif_use_channel->
6908                  * ieee80211_recalc_radar_chanctx.
6909                  *
6910                  * Firmware expect vdev_restart only if vdev is up.
6911                  * If vdev is down then it expect vdev_stop->vdev_start.
6912                  */
6913                 if (arvif->is_up) {
6914                         ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
6915                         if (ret) {
6916                                 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
6917                                             arvif->vdev_id, ret);
6918                                 continue;
6919                         }
6920                 } else {
6921                         ret = ath11k_mac_vdev_stop(arvif);
6922                         if (ret) {
6923                                 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
6924                                             arvif->vdev_id, ret);
6925                                 continue;
6926                         }
6927
6928                         ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
6929                         if (ret)
6930                                 ath11k_warn(ab, "failed to start vdev %d: %d\n",
6931                                             arvif->vdev_id, ret);
6932
6933                         continue;
6934                 }
6935
6936                 ret = ath11k_mac_setup_bcn_tmpl(arvif);
6937                 if (ret)
6938                         ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
6939                                     ret);
6940
6941                 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6942                                          arvif->bssid);
6943                 if (ret) {
6944                         ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
6945                                     arvif->vdev_id, ret);
6946                         continue;
6947                 }
6948         }
6949
6950         /* Restart the internal monitor vdev on new channel */
6951         if (!monitor_vif &&
6952             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
6953                 ret = ath11k_mac_monitor_stop(ar);
6954                 if (ret) {
6955                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
6956                                     ret);
6957                         return;
6958                 }
6959
6960                 ret = ath11k_mac_monitor_start(ar);
6961                 if (ret) {
6962                         ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
6963                                     ret);
6964                         return;
6965                 }
6966         }
6967 }
6968
6969 static void
6970 ath11k_mac_update_active_vif_chan(struct ath11k *ar,
6971                                   struct ieee80211_chanctx_conf *ctx)
6972 {
6973         struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
6974
6975         lockdep_assert_held(&ar->conf_mutex);
6976
6977         ieee80211_iterate_active_interfaces_atomic(ar->hw,
6978                                                    IEEE80211_IFACE_ITER_NORMAL,
6979                                                    ath11k_mac_change_chanctx_cnt_iter,
6980                                                    &arg);
6981         if (arg.n_vifs == 0)
6982                 return;
6983
6984         arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
6985         if (!arg.vifs)
6986                 return;
6987
6988         ieee80211_iterate_active_interfaces_atomic(ar->hw,
6989                                                    IEEE80211_IFACE_ITER_NORMAL,
6990                                                    ath11k_mac_change_chanctx_fill_iter,
6991                                                    &arg);
6992
6993         ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6994
6995         kfree(arg.vifs);
6996 }
6997
6998 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6999                                          struct ieee80211_chanctx_conf *ctx,
7000                                          u32 changed)
7001 {
7002         struct ath11k *ar = hw->priv;
7003         struct ath11k_base *ab = ar->ab;
7004
7005         mutex_lock(&ar->conf_mutex);
7006
7007         ath11k_dbg(ab, ATH11K_DBG_MAC,
7008                    "mac chanctx change freq %u width %d ptr %pK changed %x\n",
7009                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
7010
7011         /* This shouldn't really happen because channel switching should use
7012          * switch_vif_chanctx().
7013          */
7014         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
7015                 goto unlock;
7016
7017         if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
7018             changed & IEEE80211_CHANCTX_CHANGE_RADAR)
7019                 ath11k_mac_update_active_vif_chan(ar, ctx);
7020
7021         /* TODO: Recalc radar detection */
7022
7023 unlock:
7024         mutex_unlock(&ar->conf_mutex);
7025 }
7026
7027 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
7028                                    struct ieee80211_vif *vif)
7029 {
7030         struct ath11k *ar = hw->priv;
7031         struct ath11k_base *ab = ar->ab;
7032         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7033         int ret;
7034
7035         if (WARN_ON(arvif->is_started))
7036                 return -EBUSY;
7037
7038         ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
7039         if (ret) {
7040                 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7041                             arvif->vdev_id, vif->addr,
7042                             arvif->chanctx.def.chan->center_freq, ret);
7043                 return ret;
7044         }
7045
7046         /* Reconfigure hardware rate code since it is cleared by firmware.
7047          */
7048         if (ar->hw_rate_code > 0) {
7049                 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
7050
7051                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
7052                                                     ar->hw_rate_code);
7053                 if (ret) {
7054                         ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
7055                         return ret;
7056                 }
7057         }
7058
7059         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7060                 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr);
7061                 if (ret) {
7062                         ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7063                         return ret;
7064                 }
7065         }
7066
7067         arvif->is_started = true;
7068
7069         /* TODO: Setup ps and cts/rts protection */
7070         return 0;
7071 }
7072
7073 static int
7074 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7075                                  struct ieee80211_vif *vif,
7076                                  unsigned int link_id,
7077                                  struct ieee80211_chanctx_conf *ctx)
7078 {
7079         struct ath11k *ar = hw->priv;
7080         struct ath11k_base *ab = ar->ab;
7081         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7082         int ret;
7083         struct peer_create_params param;
7084
7085         mutex_lock(&ar->conf_mutex);
7086
7087         ath11k_dbg(ab, ATH11K_DBG_MAC,
7088                    "mac chanctx assign ptr %pK vdev_id %i\n",
7089                    ctx, arvif->vdev_id);
7090
7091         /* for QCA6390 bss peer must be created before vdev_start */
7092         if (ab->hw_params.vdev_start_delay &&
7093             arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7094             arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7095             !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
7096                 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
7097                 ret = 0;
7098                 goto out;
7099         }
7100
7101         if (WARN_ON(arvif->is_started)) {
7102                 ret = -EBUSY;
7103                 goto out;
7104         }
7105
7106         if (ab->hw_params.vdev_start_delay &&
7107             arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7108             arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
7109                 param.vdev_id = arvif->vdev_id;
7110                 param.peer_type = WMI_PEER_TYPE_DEFAULT;
7111                 param.peer_addr = ar->mac_addr;
7112
7113                 ret = ath11k_peer_create(ar, arvif, NULL, &param);
7114                 if (ret) {
7115                         ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7116                                     ret);
7117                         goto out;
7118                 }
7119         }
7120
7121         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7122                 ret = ath11k_mac_monitor_start(ar);
7123                 if (ret) {
7124                         ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7125                                     ret);
7126                         goto out;
7127                 }
7128
7129                 arvif->is_started = true;
7130                 goto out;
7131         }
7132
7133         ret = ath11k_mac_vdev_start(arvif, ctx);
7134         if (ret) {
7135                 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7136                             arvif->vdev_id, vif->addr,
7137                             ctx->def.chan->center_freq, ret);
7138                 goto out;
7139         }
7140
7141         arvif->is_started = true;
7142
7143         if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7144             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7145                 ret = ath11k_mac_monitor_start(ar);
7146                 if (ret) {
7147                         ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7148                                     ret);
7149                         goto out;
7150                 }
7151         }
7152
7153         /* TODO: Setup ps and cts/rts protection */
7154
7155         ret = 0;
7156
7157 out:
7158         mutex_unlock(&ar->conf_mutex);
7159
7160         return ret;
7161 }
7162
7163 static void
7164 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7165                                    struct ieee80211_vif *vif,
7166                                    unsigned int link_id,
7167                                    struct ieee80211_chanctx_conf *ctx)
7168 {
7169         struct ath11k *ar = hw->priv;
7170         struct ath11k_base *ab = ar->ab;
7171         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7172         struct ath11k_peer *peer;
7173         int ret;
7174
7175         mutex_lock(&ar->conf_mutex);
7176
7177         ath11k_dbg(ab, ATH11K_DBG_MAC,
7178                    "mac chanctx unassign ptr %pK vdev_id %i\n",
7179                    ctx, arvif->vdev_id);
7180
7181         WARN_ON(!arvif->is_started);
7182
7183         if (ab->hw_params.vdev_start_delay &&
7184             arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7185                 spin_lock_bh(&ab->base_lock);
7186                 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7187                 spin_unlock_bh(&ab->base_lock);
7188                 if (peer)
7189                         ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7190         }
7191
7192         if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7193                 ret = ath11k_mac_monitor_stop(ar);
7194                 if (ret) {
7195                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7196                                     ret);
7197                         mutex_unlock(&ar->conf_mutex);
7198                         return;
7199                 }
7200
7201                 arvif->is_started = false;
7202                 mutex_unlock(&ar->conf_mutex);
7203                 return;
7204         }
7205
7206         ret = ath11k_mac_vdev_stop(arvif);
7207         if (ret)
7208                 ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7209                             arvif->vdev_id, ret);
7210
7211         arvif->is_started = false;
7212
7213         if (ab->hw_params.vdev_start_delay &&
7214             arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7215                 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7216                 if (ret)
7217                         ath11k_warn(ar->ab,
7218                                     "failed to delete peer %pM for vdev %d: %d\n",
7219                                     arvif->bssid, arvif->vdev_id, ret);
7220                 else
7221                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7222                                    "mac removed peer %pM  vdev %d after vdev stop\n",
7223                                    arvif->bssid, arvif->vdev_id);
7224         }
7225
7226         if (ab->hw_params.vdev_start_delay &&
7227             arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7228                 ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7229
7230         if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7231             ar->num_started_vdevs == 1 &&
7232             test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7233                 ret = ath11k_mac_monitor_stop(ar);
7234                 if (ret)
7235                         /* continue even if there's an error */
7236                         ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7237                                     ret);
7238         }
7239
7240         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7241                 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
7242
7243         mutex_unlock(&ar->conf_mutex);
7244 }
7245
7246 static int
7247 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7248                                  struct ieee80211_vif_chanctx_switch *vifs,
7249                                  int n_vifs,
7250                                  enum ieee80211_chanctx_switch_mode mode)
7251 {
7252         struct ath11k *ar = hw->priv;
7253
7254         mutex_lock(&ar->conf_mutex);
7255
7256         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7257                    "mac chanctx switch n_vifs %d mode %d\n",
7258                    n_vifs, mode);
7259         ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7260
7261         mutex_unlock(&ar->conf_mutex);
7262
7263         return 0;
7264 }
7265
7266 static int
7267 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7268 {
7269         struct ath11k_vif *arvif;
7270         int ret = 0;
7271
7272         mutex_lock(&ar->conf_mutex);
7273         list_for_each_entry(arvif, &ar->arvifs, list) {
7274                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7275                            param, arvif->vdev_id, value);
7276
7277                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7278                                                     param, value);
7279                 if (ret) {
7280                         ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7281                                     param, arvif->vdev_id, ret);
7282                         break;
7283                 }
7284         }
7285         mutex_unlock(&ar->conf_mutex);
7286         return ret;
7287 }
7288
7289 /* mac80211 stores device specific RTS/Fragmentation threshold value,
7290  * this is set interface specific to firmware from ath11k driver
7291  */
7292 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7293 {
7294         struct ath11k *ar = hw->priv;
7295         int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7296
7297         return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7298 }
7299
7300 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7301 {
7302         /* Even though there's a WMI vdev param for fragmentation threshold no
7303          * known firmware actually implements it. Moreover it is not possible to
7304          * rely frame fragmentation to mac80211 because firmware clears the
7305          * "more fragments" bit in frame control making it impossible for remote
7306          * devices to reassemble frames.
7307          *
7308          * Hence implement a dummy callback just to say fragmentation isn't
7309          * supported. This effectively prevents mac80211 from doing frame
7310          * fragmentation in software.
7311          */
7312         return -EOPNOTSUPP;
7313 }
7314
7315 static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
7316 {
7317         long time_left;
7318         int ret = 0;
7319
7320         time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7321                                        (atomic_read(&ar->dp.num_tx_pending) == 0),
7322                                        ATH11K_FLUSH_TIMEOUT);
7323         if (time_left == 0) {
7324                 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7325                             atomic_read(&ar->dp.num_tx_pending));
7326                 ret = -ETIMEDOUT;
7327         }
7328
7329         time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7330                                        (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7331                                        ATH11K_FLUSH_TIMEOUT);
7332         if (time_left == 0) {
7333                 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7334                             atomic_read(&ar->num_pending_mgmt_tx));
7335                 ret = -ETIMEDOUT;
7336         }
7337
7338         return ret;
7339 }
7340
7341 int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7342 {
7343         ath11k_mac_drain_tx(ar);
7344         return ath11k_mac_flush_tx_complete(ar);
7345 }
7346
7347 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7348                                 u32 queues, bool drop)
7349 {
7350         struct ath11k *ar = hw->priv;
7351
7352         if (drop)
7353                 return;
7354
7355         ath11k_mac_flush_tx_complete(ar);
7356 }
7357
7358 static int
7359 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
7360                                      enum nl80211_band band,
7361                                      const struct cfg80211_bitrate_mask *mask)
7362 {
7363         int num_rates = 0;
7364         int i;
7365
7366         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
7367                 num_rates += hweight16(mask->control[band].ht_mcs[i]);
7368
7369         return num_rates;
7370 }
7371
7372 static bool
7373 ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7374                                   enum nl80211_band band,
7375                                   const struct cfg80211_bitrate_mask *mask)
7376 {
7377         int num_rates = 0;
7378
7379         num_rates = hweight32(mask->control[band].legacy);
7380
7381         if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7382                 return false;
7383
7384         if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7385                 return false;
7386
7387         if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7388                 return false;
7389
7390         return num_rates == 1;
7391 }
7392
7393 static __le16
7394 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7395 {
7396         if (he_cap->he_cap_elem.phy_cap_info[0] &
7397             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7398                 return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7399
7400         if (he_cap->he_cap_elem.phy_cap_info[0] &
7401             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7402                 return he_cap->he_mcs_nss_supp.tx_mcs_160;
7403
7404         return he_cap->he_mcs_nss_supp.tx_mcs_80;
7405 }
7406
7407 static bool
7408 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7409                                        enum nl80211_band band,
7410                                        const struct cfg80211_bitrate_mask *mask,
7411                                        int *nss)
7412 {
7413         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7414         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7415         u16 he_mcs_map = 0;
7416         u8 ht_nss_mask = 0;
7417         u8 vht_nss_mask = 0;
7418         u8 he_nss_mask = 0;
7419         int i;
7420
7421         /* No need to consider legacy here. Basic rates are always present
7422          * in bitrate mask
7423          */
7424
7425         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7426                 if (mask->control[band].ht_mcs[i] == 0)
7427                         continue;
7428                 else if (mask->control[band].ht_mcs[i] ==
7429                          sband->ht_cap.mcs.rx_mask[i])
7430                         ht_nss_mask |= BIT(i);
7431                 else
7432                         return false;
7433         }
7434
7435         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7436                 if (mask->control[band].vht_mcs[i] == 0)
7437                         continue;
7438                 else if (mask->control[band].vht_mcs[i] ==
7439                          ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7440                         vht_nss_mask |= BIT(i);
7441                 else
7442                         return false;
7443         }
7444
7445         he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap));
7446
7447         for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7448                 if (mask->control[band].he_mcs[i] == 0)
7449                         continue;
7450
7451                 if (mask->control[band].he_mcs[i] ==
7452                     ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7453                         he_nss_mask |= BIT(i);
7454                 else
7455                         return false;
7456         }
7457
7458         if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
7459                 return false;
7460
7461         if (ht_nss_mask == 0)
7462                 return false;
7463
7464         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7465                 return false;
7466
7467         *nss = fls(ht_nss_mask);
7468
7469         return true;
7470 }
7471
7472 static int
7473 ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7474                                   enum nl80211_band band,
7475                                   const struct cfg80211_bitrate_mask *mask,
7476                                   u32 *rate, u8 *nss)
7477 {
7478         int rate_idx;
7479         u16 bitrate;
7480         u8 preamble;
7481         u8 hw_rate;
7482
7483         if (hweight32(mask->control[band].legacy) != 1)
7484                 return -EINVAL;
7485
7486         rate_idx = ffs(mask->control[band].legacy) - 1;
7487
7488         if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
7489                 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
7490
7491         hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
7492         bitrate = ath11k_legacy_rates[rate_idx].bitrate;
7493
7494         if (ath11k_mac_bitrate_is_cck(bitrate))
7495                 preamble = WMI_RATE_PREAMBLE_CCK;
7496         else
7497                 preamble = WMI_RATE_PREAMBLE_OFDM;
7498
7499         *nss = 1;
7500         *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
7501
7502         return 0;
7503 }
7504
7505 static int
7506 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
7507 {
7508         struct ath11k *ar = arvif->ar;
7509         int ret;
7510
7511         /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
7512         if (he_gi && he_gi != 0xFF)
7513                 he_gi += 1;
7514
7515         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7516                                             WMI_VDEV_PARAM_SGI, he_gi);
7517         if (ret) {
7518                 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
7519                             he_gi, ret);
7520                 return ret;
7521         }
7522         /* start from 1 */
7523         if (he_ltf != 0xFF)
7524                 he_ltf += 1;
7525
7526         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7527                                             WMI_VDEV_PARAM_HE_LTF, he_ltf);
7528         if (ret) {
7529                 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
7530                             he_ltf, ret);
7531                 return ret;
7532         }
7533
7534         return 0;
7535 }
7536
7537 static int
7538 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
7539 {
7540         struct ath11k *ar = arvif->ar;
7541         int ret;
7542         u32 he_ar_gi_ltf;
7543
7544         if (he_gi != 0xFF) {
7545                 switch (he_gi) {
7546                 case NL80211_RATE_INFO_HE_GI_0_8:
7547                         he_gi = WMI_AUTORATE_800NS_GI;
7548                         break;
7549                 case NL80211_RATE_INFO_HE_GI_1_6:
7550                         he_gi = WMI_AUTORATE_1600NS_GI;
7551                         break;
7552                 case NL80211_RATE_INFO_HE_GI_3_2:
7553                         he_gi = WMI_AUTORATE_3200NS_GI;
7554                         break;
7555                 default:
7556                         ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
7557                         return -EINVAL;
7558                 }
7559         }
7560
7561         if (he_ltf != 0xFF) {
7562                 switch (he_ltf) {
7563                 case NL80211_RATE_INFO_HE_1XLTF:
7564                         he_ltf = WMI_HE_AUTORATE_LTF_1X;
7565                         break;
7566                 case NL80211_RATE_INFO_HE_2XLTF:
7567                         he_ltf = WMI_HE_AUTORATE_LTF_2X;
7568                         break;
7569                 case NL80211_RATE_INFO_HE_4XLTF:
7570                         he_ltf = WMI_HE_AUTORATE_LTF_4X;
7571                         break;
7572                 default:
7573                         ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
7574                         return -EINVAL;
7575                 }
7576         }
7577
7578         he_ar_gi_ltf = he_gi | he_ltf;
7579         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7580                                             WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
7581                                             he_ar_gi_ltf);
7582         if (ret) {
7583                 ath11k_warn(ar->ab,
7584                             "failed to set he autorate gi %u ltf %u: %d\n",
7585                             he_gi, he_ltf, ret);
7586                 return ret;
7587         }
7588
7589         return 0;
7590 }
7591
7592 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
7593                                       u32 rate, u8 nss, u8 sgi, u8 ldpc,
7594                                       u8 he_gi, u8 he_ltf, bool he_fixed_rate)
7595 {
7596         struct ath11k *ar = arvif->ar;
7597         u32 vdev_param;
7598         int ret;
7599
7600         lockdep_assert_held(&ar->conf_mutex);
7601
7602         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7603                    "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",
7604                    arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
7605                    he_ltf, he_fixed_rate);
7606
7607         if (!arvif->vif->bss_conf.he_support) {
7608                 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
7609                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7610                                                     vdev_param, rate);
7611                 if (ret) {
7612                         ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
7613                                     rate, ret);
7614                         return ret;
7615                 }
7616         }
7617
7618         vdev_param = WMI_VDEV_PARAM_NSS;
7619         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7620                                             vdev_param, nss);
7621         if (ret) {
7622                 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
7623                             nss, ret);
7624                 return ret;
7625         }
7626
7627         vdev_param = WMI_VDEV_PARAM_LDPC;
7628         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7629                                             vdev_param, ldpc);
7630         if (ret) {
7631                 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
7632                             ldpc, ret);
7633                 return ret;
7634         }
7635
7636         if (arvif->vif->bss_conf.he_support) {
7637                 if (he_fixed_rate) {
7638                         ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
7639                                                                he_ltf);
7640                         if (ret) {
7641                                 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
7642                                             ret);
7643                                 return ret;
7644                         }
7645                 } else {
7646                         ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
7647                                                               he_ltf);
7648                         if (ret) {
7649                                 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
7650                                             ret);
7651                                 return ret;
7652                         }
7653                 }
7654         } else {
7655                 vdev_param = WMI_VDEV_PARAM_SGI;
7656                 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7657                                                     vdev_param, sgi);
7658                 if (ret) {
7659                         ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
7660                                     sgi, ret);
7661                         return ret;
7662                 }
7663         }
7664
7665         return 0;
7666 }
7667
7668 static bool
7669 ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
7670                                  enum nl80211_band band,
7671                                  const struct cfg80211_bitrate_mask *mask)
7672 {
7673         int i;
7674         u16 vht_mcs;
7675
7676         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
7677                 vht_mcs = mask->control[band].vht_mcs[i];
7678
7679                 switch (vht_mcs) {
7680                 case 0:
7681                 case BIT(8) - 1:
7682                 case BIT(9) - 1:
7683                 case BIT(10) - 1:
7684                         break;
7685                 default:
7686                         return false;
7687                 }
7688         }
7689
7690         return true;
7691 }
7692
7693 static bool
7694 ath11k_mac_he_mcs_range_present(struct ath11k *ar,
7695                                 enum nl80211_band band,
7696                                 const struct cfg80211_bitrate_mask *mask)
7697 {
7698         int i;
7699         u16 he_mcs;
7700
7701         for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
7702                 he_mcs = mask->control[band].he_mcs[i];
7703
7704                 switch (he_mcs) {
7705                 case 0:
7706                 case BIT(8) - 1:
7707                 case BIT(10) - 1:
7708                 case BIT(12) - 1:
7709                         break;
7710                 default:
7711                         return false;
7712                 }
7713         }
7714
7715         return true;
7716 }
7717
7718 static void ath11k_mac_set_bitrate_mask_iter(void *data,
7719                                              struct ieee80211_sta *sta)
7720 {
7721         struct ath11k_vif *arvif = data;
7722         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
7723         struct ath11k *ar = arvif->ar;
7724
7725         spin_lock_bh(&ar->data_lock);
7726         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
7727         spin_unlock_bh(&ar->data_lock);
7728
7729         ieee80211_queue_work(ar->hw, &arsta->update_wk);
7730 }
7731
7732 static void ath11k_mac_disable_peer_fixed_rate(void *data,
7733                                                struct ieee80211_sta *sta)
7734 {
7735         struct ath11k_vif *arvif = data;
7736         struct ath11k *ar = arvif->ar;
7737         int ret;
7738
7739         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
7740                                         arvif->vdev_id,
7741                                         WMI_PEER_PARAM_FIXED_RATE,
7742                                         WMI_FIXED_RATE_NONE);
7743         if (ret)
7744                 ath11k_warn(ar->ab,
7745                             "failed to disable peer fixed rate for STA %pM ret %d\n",
7746                             sta->addr, ret);
7747 }
7748
7749 static bool
7750 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
7751                                                const struct cfg80211_bitrate_mask *mask)
7752 {
7753         bool he_fixed_rate = false, vht_fixed_rate = false;
7754         struct ath11k_peer *peer, *tmp;
7755         const u16 *vht_mcs_mask, *he_mcs_mask;
7756         struct ieee80211_link_sta *deflink;
7757         u8 vht_nss, he_nss;
7758         bool ret = true;
7759
7760         vht_mcs_mask = mask->control[band].vht_mcs;
7761         he_mcs_mask = mask->control[band].he_mcs;
7762
7763         if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
7764                 vht_fixed_rate = true;
7765
7766         if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
7767                 he_fixed_rate = true;
7768
7769         if (!vht_fixed_rate && !he_fixed_rate)
7770                 return true;
7771
7772         vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
7773         he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
7774
7775         rcu_read_lock();
7776         spin_lock_bh(&ar->ab->base_lock);
7777         list_for_each_entry_safe(peer, tmp, &ar->ab->peers, list) {
7778                 if (peer->sta) {
7779                         deflink = &peer->sta->deflink;
7780
7781                         if (vht_fixed_rate && (!deflink->vht_cap.vht_supported ||
7782                                                deflink->rx_nss < vht_nss)) {
7783                                 ret = false;
7784                                 goto out;
7785                         }
7786
7787                         if (he_fixed_rate && (!deflink->he_cap.has_he ||
7788                                               deflink->rx_nss < he_nss)) {
7789                                 ret = false;
7790                                 goto out;
7791                         }
7792                 }
7793         }
7794
7795 out:
7796         spin_unlock_bh(&ar->ab->base_lock);
7797         rcu_read_unlock();
7798         return ret;
7799 }
7800
7801 static int
7802 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
7803                                struct ieee80211_vif *vif,
7804                                const struct cfg80211_bitrate_mask *mask)
7805 {
7806         struct ath11k_vif *arvif = (void *)vif->drv_priv;
7807         struct cfg80211_chan_def def;
7808         struct ath11k_pdev_cap *cap;
7809         struct ath11k *ar = arvif->ar;
7810         enum nl80211_band band;
7811         const u8 *ht_mcs_mask;
7812         const u16 *vht_mcs_mask;
7813         const u16 *he_mcs_mask;
7814         u8 he_ltf = 0;
7815         u8 he_gi = 0;
7816         u32 rate;
7817         u8 nss;
7818         u8 sgi;
7819         u8 ldpc;
7820         int single_nss;
7821         int ret;
7822         int num_rates;
7823         bool he_fixed_rate = false;
7824
7825         if (ath11k_mac_vif_chan(vif, &def))
7826                 return -EPERM;
7827
7828         band = def.chan->band;
7829         cap = &ar->pdev->cap;
7830         ht_mcs_mask = mask->control[band].ht_mcs;
7831         vht_mcs_mask = mask->control[band].vht_mcs;
7832         he_mcs_mask = mask->control[band].he_mcs;
7833         ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC);
7834
7835         sgi = mask->control[band].gi;
7836         if (sgi == NL80211_TXRATE_FORCE_LGI)
7837                 return -EINVAL;
7838
7839         he_gi = mask->control[band].he_gi;
7840         he_ltf = mask->control[band].he_ltf;
7841
7842         /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
7843          * requires passing at least one of used basic rates along with them.
7844          * Fixed rate setting across different preambles(legacy, HT, VHT) is
7845          * not supported by the FW. Hence use of FIXED_RATE vdev param is not
7846          * suitable for setting single HT/VHT rates.
7847          * But, there could be a single basic rate passed from userspace which
7848          * can be done through the FIXED_RATE param.
7849          */
7850         if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
7851                 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
7852                                                         &nss);
7853                 if (ret) {
7854                         ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
7855                                     arvif->vdev_id, ret);
7856                         return ret;
7857                 }
7858                 ieee80211_iterate_stations_atomic(ar->hw,
7859                                                   ath11k_mac_disable_peer_fixed_rate,
7860                                                   arvif);
7861         } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask,
7862                                                           &single_nss)) {
7863                 rate = WMI_FIXED_RATE_NONE;
7864                 nss = single_nss;
7865                 mutex_lock(&ar->conf_mutex);
7866                 arvif->bitrate_mask = *mask;
7867                 ieee80211_iterate_stations_atomic(ar->hw,
7868                                                   ath11k_mac_set_bitrate_mask_iter,
7869                                                   arvif);
7870                 mutex_unlock(&ar->conf_mutex);
7871         } else {
7872                 rate = WMI_FIXED_RATE_NONE;
7873
7874                 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
7875                         ath11k_warn(ar->ab,
7876                                     "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
7877                 nss = min_t(u32, ar->num_tx_chains,
7878                             max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
7879                                     ath11k_mac_max_vht_nss(vht_mcs_mask)),
7880                                 ath11k_mac_max_he_nss(he_mcs_mask)));
7881
7882                 /* If multiple rates across different preambles are given
7883                  * we can reconfigure this info with all peers using PEER_ASSOC
7884                  * command with the below exception cases.
7885                  * - Single VHT Rate : peer_assoc command accommodates only MCS
7886                  * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
7887                  * mandates passing basic rates along with HT/VHT rates, FW
7888                  * doesn't allow switching from VHT to Legacy. Hence instead of
7889                  * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
7890                  * we could set this VHT rate as peer fixed rate param, which
7891                  * will override FIXED rate and FW rate control algorithm.
7892                  * If single VHT rate is passed along with HT rates, we select
7893                  * the VHT rate as fixed rate for vht peers.
7894                  * - Multiple VHT Rates : When Multiple VHT rates are given,this
7895                  * can be set using RATEMASK CMD which uses FW rate-ctl alg.
7896                  * TODO: Setting multiple VHT MCS and replacing peer_assoc with
7897                  * RATEMASK_CMDID can cover all use cases of setting rates
7898                  * across multiple preambles and rates within same type.
7899                  * But requires more validation of the command at this point.
7900                  */
7901
7902                 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
7903                                                                   mask);
7904
7905                 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
7906                     num_rates > 1) {
7907                         /* TODO: Handle multiple VHT MCS values setting using
7908                          * RATEMASK CMD
7909                          */
7910                         ath11k_warn(ar->ab,
7911                                     "setting %d mcs values in bitrate mask not supported\n",
7912                                 num_rates);
7913                         return -EINVAL;
7914                 }
7915
7916                 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
7917                                                                  mask);
7918                 if (num_rates == 1)
7919                         he_fixed_rate = true;
7920
7921                 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
7922                     num_rates > 1) {
7923                         ath11k_warn(ar->ab,
7924                                     "Setting more than one HE MCS Value in bitrate mask not supported\n");
7925                         return -EINVAL;
7926                 }
7927
7928                 mutex_lock(&ar->conf_mutex);
7929                 ieee80211_iterate_stations_atomic(ar->hw,
7930                                                   ath11k_mac_disable_peer_fixed_rate,
7931                                                   arvif);
7932
7933                 arvif->bitrate_mask = *mask;
7934                 ieee80211_iterate_stations_atomic(ar->hw,
7935                                                   ath11k_mac_set_bitrate_mask_iter,
7936                                                   arvif);
7937
7938                 mutex_unlock(&ar->conf_mutex);
7939         }
7940
7941         mutex_lock(&ar->conf_mutex);
7942
7943         ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
7944                                          he_ltf, he_fixed_rate);
7945         if (ret) {
7946                 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
7947                             arvif->vdev_id, ret);
7948         }
7949
7950         mutex_unlock(&ar->conf_mutex);
7951
7952         return ret;
7953 }
7954
7955 static void
7956 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
7957                                 enum ieee80211_reconfig_type reconfig_type)
7958 {
7959         struct ath11k *ar = hw->priv;
7960         struct ath11k_base *ab = ar->ab;
7961         int recovery_count;
7962
7963         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
7964                 return;
7965
7966         mutex_lock(&ar->conf_mutex);
7967
7968         if (ar->state == ATH11K_STATE_RESTARTED) {
7969                 ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
7970                             ar->pdev->pdev_id);
7971                 ar->state = ATH11K_STATE_ON;
7972                 ieee80211_wake_queues(ar->hw);
7973
7974                 if (ar->ab->hw_params.current_cc_support &&
7975                     ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
7976                         struct wmi_set_current_country_params set_current_param = {};
7977
7978                         memcpy(&set_current_param.alpha2, ar->alpha2, 2);
7979                         ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
7980                 }
7981
7982                 if (ab->is_reset) {
7983                         recovery_count = atomic_inc_return(&ab->recovery_count);
7984                         ath11k_dbg(ab, ATH11K_DBG_BOOT,
7985                                    "recovery count %d\n", recovery_count);
7986                         /* When there are multiple radios in an SOC,
7987                          * the recovery has to be done for each radio
7988                          */
7989                         if (recovery_count == ab->num_radios) {
7990                                 atomic_dec(&ab->reset_count);
7991                                 complete(&ab->reset_complete);
7992                                 ab->is_reset = false;
7993                                 atomic_set(&ab->fail_cont_count, 0);
7994                                 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
7995                         }
7996                 }
7997         }
7998
7999         mutex_unlock(&ar->conf_mutex);
8000 }
8001
8002 static void
8003 ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
8004                                   struct ieee80211_channel *channel)
8005 {
8006         int ret;
8007         enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
8008
8009         lockdep_assert_held(&ar->conf_mutex);
8010
8011         if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
8012             ar->rx_channel != channel)
8013                 return;
8014
8015         if (ar->scan.state != ATH11K_SCAN_IDLE) {
8016                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8017                            "ignoring bss chan info req while scanning..\n");
8018                 return;
8019         }
8020
8021         reinit_completion(&ar->bss_survey_done);
8022
8023         ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
8024         if (ret) {
8025                 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
8026                 return;
8027         }
8028
8029         ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8030         if (ret == 0)
8031                 ath11k_warn(ar->ab, "bss channel survey timed out\n");
8032 }
8033
8034 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
8035                                     struct survey_info *survey)
8036 {
8037         struct ath11k *ar = hw->priv;
8038         struct ieee80211_supported_band *sband;
8039         struct survey_info *ar_survey;
8040         int ret = 0;
8041
8042         if (idx >= ATH11K_NUM_CHANS)
8043                 return -ENOENT;
8044
8045         ar_survey = &ar->survey[idx];
8046
8047         mutex_lock(&ar->conf_mutex);
8048
8049         sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8050         if (sband && idx >= sband->n_channels) {
8051                 idx -= sband->n_channels;
8052                 sband = NULL;
8053         }
8054
8055         if (!sband)
8056                 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8057         if (sband && idx >= sband->n_channels) {
8058                 idx -= sband->n_channels;
8059                 sband = NULL;
8060         }
8061
8062         if (!sband)
8063                 sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
8064         if (!sband || idx >= sband->n_channels) {
8065                 ret = -ENOENT;
8066                 goto exit;
8067         }
8068
8069         ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8070
8071         spin_lock_bh(&ar->data_lock);
8072         memcpy(survey, ar_survey, sizeof(*survey));
8073         spin_unlock_bh(&ar->data_lock);
8074
8075         survey->channel = &sband->channels[idx];
8076
8077         if (ar->rx_channel == survey->channel)
8078                 survey->filled |= SURVEY_INFO_IN_USE;
8079
8080 exit:
8081         mutex_unlock(&ar->conf_mutex);
8082         return ret;
8083 }
8084
8085 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8086                                       struct ath11k_sta *arsta,
8087                                       char *pre,
8088                                       bool clear)
8089 {
8090         struct ath11k *ar = arsta->arvif->ar;
8091         int i;
8092         s8 rssi;
8093
8094         for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8095                 sinfo->chains &= ~BIT(i);
8096                 rssi = arsta->chain_signal[i];
8097                 if (clear)
8098                         arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8099
8100                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8101                            "mac sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8102
8103                 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8104                     rssi != ATH11K_INVALID_RSSI_FULL &&
8105                     rssi != ATH11K_INVALID_RSSI_EMPTY &&
8106                     rssi != 0) {
8107                         sinfo->chain_signal[i] = rssi;
8108                         sinfo->chains |= BIT(i);
8109                         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8110                 }
8111         }
8112 }
8113
8114 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8115                                          struct ieee80211_vif *vif,
8116                                          struct ieee80211_sta *sta,
8117                                          struct station_info *sinfo)
8118 {
8119         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
8120         struct ath11k *ar = arsta->arvif->ar;
8121         s8 signal;
8122         bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8123                                ar->ab->wmi_ab.svc_map);
8124
8125         sinfo->rx_duration = arsta->rx_duration;
8126         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8127
8128         sinfo->tx_duration = arsta->tx_duration;
8129         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8130
8131         if (arsta->txrate.legacy || arsta->txrate.nss) {
8132                 if (arsta->txrate.legacy) {
8133                         sinfo->txrate.legacy = arsta->txrate.legacy;
8134                 } else {
8135                         sinfo->txrate.mcs = arsta->txrate.mcs;
8136                         sinfo->txrate.nss = arsta->txrate.nss;
8137                         sinfo->txrate.bw = arsta->txrate.bw;
8138                         sinfo->txrate.he_gi = arsta->txrate.he_gi;
8139                         sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8140                         sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8141                 }
8142                 sinfo->txrate.flags = arsta->txrate.flags;
8143                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8144         }
8145
8146         ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8147
8148         if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8149             arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8150             ar->ab->hw_params.supports_rssi_stats &&
8151             !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8152                                          WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8153                 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8154         }
8155
8156         signal = arsta->rssi_comb;
8157         if (!signal &&
8158             arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8159             ar->ab->hw_params.supports_rssi_stats &&
8160             !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8161                                         WMI_REQUEST_VDEV_STAT)))
8162                 signal = arsta->rssi_beacon;
8163
8164         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8165                    "mac sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8166                    db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8167
8168         if (signal) {
8169                 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8170                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8171         }
8172
8173         sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) +
8174                 ATH11K_DEFAULT_NOISE_FLOOR;
8175         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
8176 }
8177
8178 #if IS_ENABLED(CONFIG_IPV6)
8179 static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8180                                        struct ath11k_arp_ns_offload *offload)
8181 {
8182         int i;
8183
8184         for (i = 0; i < offload->ipv6_count; i++) {
8185                 offload->self_ipv6_addr[i][0] = 0xff;
8186                 offload->self_ipv6_addr[i][1] = 0x02;
8187                 offload->self_ipv6_addr[i][11] = 0x01;
8188                 offload->self_ipv6_addr[i][12] = 0xff;
8189                 offload->self_ipv6_addr[i][13] =
8190                                         offload->ipv6_addr[i][13];
8191                 offload->self_ipv6_addr[i][14] =
8192                                         offload->ipv6_addr[i][14];
8193                 offload->self_ipv6_addr[i][15] =
8194                                         offload->ipv6_addr[i][15];
8195                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8196                            offload->self_ipv6_addr[i]);
8197         }
8198 }
8199
8200 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8201                                        struct ieee80211_vif *vif,
8202                                        struct inet6_dev *idev)
8203 {
8204         struct ath11k *ar = hw->priv;
8205         struct ath11k_arp_ns_offload *offload;
8206         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8207         struct inet6_ifaddr *ifa6;
8208         struct ifacaddr6 *ifaca6;
8209         struct list_head *p;
8210         u32 count, scope;
8211
8212         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac op ipv6 changed\n");
8213
8214         offload = &arvif->arp_ns_offload;
8215         count = 0;
8216
8217         read_lock_bh(&idev->lock);
8218
8219         memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8220         memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8221         memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8222
8223         /* get unicast address */
8224         list_for_each(p, &idev->addr_list) {
8225                 if (count >= ATH11K_IPV6_MAX_COUNT)
8226                         goto generate;
8227
8228                 ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8229                 if (ifa6->flags & IFA_F_DADFAILED)
8230                         continue;
8231                 scope = ipv6_addr_src_scope(&ifa6->addr);
8232                 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8233                     scope == IPV6_ADDR_SCOPE_GLOBAL) {
8234                         memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8235                                sizeof(ifa6->addr.s6_addr));
8236                         offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8237                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 uc %pI6 scope %d\n",
8238                                    count, offload->ipv6_addr[count],
8239                                    scope);
8240                         count++;
8241                 } else {
8242                         ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8243                 }
8244         }
8245
8246         /* get anycast address */
8247         for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8248                 if (count >= ATH11K_IPV6_MAX_COUNT)
8249                         goto generate;
8250
8251                 scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8252                 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8253                     scope == IPV6_ADDR_SCOPE_GLOBAL) {
8254                         memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8255                                sizeof(ifaca6->aca_addr));
8256                         offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8257                         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 ac %pI6 scope %d\n",
8258                                    count, offload->ipv6_addr[count],
8259                                    scope);
8260                         count++;
8261                 } else {
8262                         ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8263                 }
8264         }
8265
8266 generate:
8267         offload->ipv6_count = count;
8268         read_unlock_bh(&idev->lock);
8269
8270         /* generate ns multicast address */
8271         ath11k_generate_ns_mc_addr(ar, offload);
8272 }
8273 #endif
8274
8275 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8276                                          struct ieee80211_vif *vif,
8277                                          struct cfg80211_gtk_rekey_data *data)
8278 {
8279         struct ath11k *ar = hw->priv;
8280         struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8281         struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8282
8283         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac set rekey data vdev %d\n",
8284                    arvif->vdev_id);
8285
8286         mutex_lock(&ar->conf_mutex);
8287
8288         memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8289         memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8290
8291         /* The supplicant works on big-endian, the firmware expects it on
8292          * little endian.
8293          */
8294         rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8295
8296         arvif->rekey_data.enable_offload = true;
8297
8298         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8299                         rekey_data->kck, NL80211_KCK_LEN);
8300         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8301                         rekey_data->kck, NL80211_KEK_LEN);
8302         ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8303                         &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8304
8305         mutex_unlock(&ar->conf_mutex);
8306 }
8307
8308 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8309                                             const struct cfg80211_sar_specs *sar)
8310 {
8311         struct ath11k *ar = hw->priv;
8312         const struct cfg80211_sar_sub_specs *sspec;
8313         int ret, index;
8314         u8 *sar_tbl;
8315         u32 i;
8316
8317         if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8318             sar->num_sub_specs == 0)
8319                 return -EINVAL;
8320
8321         mutex_lock(&ar->conf_mutex);
8322
8323         if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8324             !ar->ab->hw_params.bios_sar_capa) {
8325                 ret = -EOPNOTSUPP;
8326                 goto exit;
8327         }
8328
8329         ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8330         if (ret) {
8331                 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8332                 goto exit;
8333         }
8334
8335         sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8336         if (!sar_tbl) {
8337                 ret = -ENOMEM;
8338                 goto exit;
8339         }
8340
8341         sspec = sar->sub_specs;
8342         for (i = 0; i < sar->num_sub_specs; i++) {
8343                 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8344                         ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8345                                     sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8346                         continue;
8347                 }
8348
8349                 /* chain0 and chain1 share same power setting */
8350                 sar_tbl[sspec->freq_range_index] = sspec->power;
8351                 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8352                 sar_tbl[index] = sspec->power;
8353                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8354                            sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8355                 sspec++;
8356         }
8357
8358         ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8359         if (ret)
8360                 ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8361
8362         kfree(sar_tbl);
8363 exit:
8364         mutex_unlock(&ar->conf_mutex);
8365
8366         return ret;
8367 }
8368
8369 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
8370                                                   struct ieee80211_vif *vif)
8371 {
8372         struct ath11k *ar = hw->priv;
8373
8374         mutex_lock(&ar->conf_mutex);
8375
8376         spin_lock_bh(&ar->data_lock);
8377         ar->scan.roc_notify = false;
8378         spin_unlock_bh(&ar->data_lock);
8379
8380         ath11k_scan_abort(ar);
8381
8382         mutex_unlock(&ar->conf_mutex);
8383
8384         cancel_delayed_work_sync(&ar->scan.timeout);
8385
8386         return 0;
8387 }
8388
8389 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
8390                                            struct ieee80211_vif *vif,
8391                                            struct ieee80211_channel *chan,
8392                                            int duration,
8393                                            enum ieee80211_roc_type type)
8394 {
8395         struct ath11k *ar = hw->priv;
8396         struct ath11k_vif *arvif = (void *)vif->drv_priv;
8397         struct scan_req_params arg;
8398         int ret;
8399         u32 scan_time_msec;
8400
8401         mutex_lock(&ar->conf_mutex);
8402
8403         spin_lock_bh(&ar->data_lock);
8404         switch (ar->scan.state) {
8405         case ATH11K_SCAN_IDLE:
8406                 reinit_completion(&ar->scan.started);
8407                 reinit_completion(&ar->scan.completed);
8408                 reinit_completion(&ar->scan.on_channel);
8409                 ar->scan.state = ATH11K_SCAN_STARTING;
8410                 ar->scan.is_roc = true;
8411                 ar->scan.vdev_id = arvif->vdev_id;
8412                 ar->scan.roc_freq = chan->center_freq;
8413                 ar->scan.roc_notify = true;
8414                 ret = 0;
8415                 break;
8416         case ATH11K_SCAN_STARTING:
8417         case ATH11K_SCAN_RUNNING:
8418         case ATH11K_SCAN_ABORTING:
8419                 ret = -EBUSY;
8420                 break;
8421         }
8422         spin_unlock_bh(&ar->data_lock);
8423
8424         if (ret)
8425                 goto exit;
8426
8427         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
8428
8429         memset(&arg, 0, sizeof(arg));
8430         ath11k_wmi_start_scan_init(ar, &arg);
8431         arg.num_chan = 1;
8432         arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
8433                                 GFP_KERNEL);
8434         if (!arg.chan_list) {
8435                 ret = -ENOMEM;
8436                 goto exit;
8437         }
8438
8439         arg.vdev_id = arvif->vdev_id;
8440         arg.scan_id = ATH11K_SCAN_ID;
8441         arg.chan_list[0] = chan->center_freq;
8442         arg.dwell_time_active = scan_time_msec;
8443         arg.dwell_time_passive = scan_time_msec;
8444         arg.max_scan_time = scan_time_msec;
8445         arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
8446         arg.scan_flags |= WMI_SCAN_FILTER_PROBE_REQ;
8447         arg.burst_duration = duration;
8448
8449         ret = ath11k_start_scan(ar, &arg);
8450         if (ret) {
8451                 ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret);
8452
8453                 spin_lock_bh(&ar->data_lock);
8454                 ar->scan.state = ATH11K_SCAN_IDLE;
8455                 spin_unlock_bh(&ar->data_lock);
8456                 goto free_chan_list;
8457         }
8458
8459         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
8460         if (ret == 0) {
8461                 ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n");
8462                 ret = ath11k_scan_stop(ar);
8463                 if (ret)
8464                         ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
8465                 ret = -ETIMEDOUT;
8466                 goto free_chan_list;
8467         }
8468
8469         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
8470                                      msecs_to_jiffies(duration));
8471
8472         ret = 0;
8473
8474 free_chan_list:
8475         kfree(arg.chan_list);
8476 exit:
8477         mutex_unlock(&ar->conf_mutex);
8478         return ret;
8479 }
8480
8481 static const struct ieee80211_ops ath11k_ops = {
8482         .tx                             = ath11k_mac_op_tx,
8483         .start                          = ath11k_mac_op_start,
8484         .stop                           = ath11k_mac_op_stop,
8485         .reconfig_complete              = ath11k_mac_op_reconfig_complete,
8486         .add_interface                  = ath11k_mac_op_add_interface,
8487         .remove_interface               = ath11k_mac_op_remove_interface,
8488         .update_vif_offload             = ath11k_mac_op_update_vif_offload,
8489         .config                         = ath11k_mac_op_config,
8490         .bss_info_changed               = ath11k_mac_op_bss_info_changed,
8491         .configure_filter               = ath11k_mac_op_configure_filter,
8492         .hw_scan                        = ath11k_mac_op_hw_scan,
8493         .cancel_hw_scan                 = ath11k_mac_op_cancel_hw_scan,
8494         .set_key                        = ath11k_mac_op_set_key,
8495         .set_rekey_data                 = ath11k_mac_op_set_rekey_data,
8496         .sta_state                      = ath11k_mac_op_sta_state,
8497         .sta_set_4addr                  = ath11k_mac_op_sta_set_4addr,
8498         .sta_set_txpwr                  = ath11k_mac_op_sta_set_txpwr,
8499         .sta_rc_update                  = ath11k_mac_op_sta_rc_update,
8500         .conf_tx                        = ath11k_mac_op_conf_tx,
8501         .set_antenna                    = ath11k_mac_op_set_antenna,
8502         .get_antenna                    = ath11k_mac_op_get_antenna,
8503         .ampdu_action                   = ath11k_mac_op_ampdu_action,
8504         .add_chanctx                    = ath11k_mac_op_add_chanctx,
8505         .remove_chanctx                 = ath11k_mac_op_remove_chanctx,
8506         .change_chanctx                 = ath11k_mac_op_change_chanctx,
8507         .assign_vif_chanctx             = ath11k_mac_op_assign_vif_chanctx,
8508         .unassign_vif_chanctx           = ath11k_mac_op_unassign_vif_chanctx,
8509         .switch_vif_chanctx             = ath11k_mac_op_switch_vif_chanctx,
8510         .set_rts_threshold              = ath11k_mac_op_set_rts_threshold,
8511         .set_frag_threshold             = ath11k_mac_op_set_frag_threshold,
8512         .set_bitrate_mask               = ath11k_mac_op_set_bitrate_mask,
8513         .get_survey                     = ath11k_mac_op_get_survey,
8514         .flush                          = ath11k_mac_op_flush,
8515         .sta_statistics                 = ath11k_mac_op_sta_statistics,
8516         CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
8517
8518 #ifdef CONFIG_PM
8519         .suspend                        = ath11k_wow_op_suspend,
8520         .resume                         = ath11k_wow_op_resume,
8521         .set_wakeup                     = ath11k_wow_op_set_wakeup,
8522 #endif
8523
8524 #ifdef CONFIG_ATH11K_DEBUGFS
8525         .sta_add_debugfs                = ath11k_debugfs_sta_op_add,
8526 #endif
8527
8528 #if IS_ENABLED(CONFIG_IPV6)
8529         .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
8530 #endif
8531
8532         .set_sar_specs                  = ath11k_mac_op_set_bios_sar_specs,
8533         .remain_on_channel              = ath11k_mac_op_remain_on_channel,
8534         .cancel_remain_on_channel       = ath11k_mac_op_cancel_remain_on_channel,
8535 };
8536
8537 static void ath11k_mac_update_ch_list(struct ath11k *ar,
8538                                       struct ieee80211_supported_band *band,
8539                                       u32 freq_low, u32 freq_high)
8540 {
8541         int i;
8542
8543         if (!(freq_low && freq_high))
8544                 return;
8545
8546         for (i = 0; i < band->n_channels; i++) {
8547                 if (band->channels[i].center_freq < freq_low ||
8548                     band->channels[i].center_freq > freq_high)
8549                         band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
8550         }
8551 }
8552
8553 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
8554 {
8555         struct ath11k_pdev *pdev = ar->pdev;
8556         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
8557
8558         if (band == WMI_HOST_WLAN_2G_CAP)
8559                 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
8560
8561         if (band == WMI_HOST_WLAN_5G_CAP)
8562                 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
8563
8564         ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
8565
8566         return 0;
8567 }
8568
8569 static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
8570                                            u32 supported_bands)
8571 {
8572         struct ieee80211_supported_band *band;
8573         struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
8574         void *channels;
8575         u32 phy_id;
8576
8577         BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
8578                       ARRAY_SIZE(ath11k_5ghz_channels) +
8579                       ARRAY_SIZE(ath11k_6ghz_channels)) !=
8580                      ATH11K_NUM_CHANS);
8581
8582         reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
8583         temp_reg_cap = reg_cap;
8584
8585         if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
8586                 channels = kmemdup(ath11k_2ghz_channels,
8587                                    sizeof(ath11k_2ghz_channels),
8588                                    GFP_KERNEL);
8589                 if (!channels)
8590                         return -ENOMEM;
8591
8592                 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
8593                 band->band = NL80211_BAND_2GHZ;
8594                 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
8595                 band->channels = channels;
8596                 band->n_bitrates = ath11k_g_rates_size;
8597                 band->bitrates = ath11k_g_rates;
8598                 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
8599
8600                 if (ar->ab->hw_params.single_pdev_only) {
8601                         phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
8602                         temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8603                 }
8604                 ath11k_mac_update_ch_list(ar, band,
8605                                           temp_reg_cap->low_2ghz_chan,
8606                                           temp_reg_cap->high_2ghz_chan);
8607         }
8608
8609         if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
8610                 if (reg_cap->high_5ghz_chan >= ATH11K_MAX_6G_FREQ) {
8611                         channels = kmemdup(ath11k_6ghz_channels,
8612                                            sizeof(ath11k_6ghz_channels), GFP_KERNEL);
8613                         if (!channels) {
8614                                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8615                                 return -ENOMEM;
8616                         }
8617
8618                         ar->supports_6ghz = true;
8619                         band = &ar->mac.sbands[NL80211_BAND_6GHZ];
8620                         band->band = NL80211_BAND_6GHZ;
8621                         band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
8622                         band->channels = channels;
8623                         band->n_bitrates = ath11k_a_rates_size;
8624                         band->bitrates = ath11k_a_rates;
8625                         ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
8626
8627                         if (ar->ab->hw_params.single_pdev_only) {
8628                                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8629                                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8630                         }
8631
8632                         ath11k_mac_update_ch_list(ar, band,
8633                                                   temp_reg_cap->low_5ghz_chan,
8634                                                   temp_reg_cap->high_5ghz_chan);
8635                 }
8636
8637                 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
8638                         channels = kmemdup(ath11k_5ghz_channels,
8639                                            sizeof(ath11k_5ghz_channels),
8640                                            GFP_KERNEL);
8641                         if (!channels) {
8642                                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8643                                 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8644                                 return -ENOMEM;
8645                         }
8646
8647                         band = &ar->mac.sbands[NL80211_BAND_5GHZ];
8648                         band->band = NL80211_BAND_5GHZ;
8649                         band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
8650                         band->channels = channels;
8651                         band->n_bitrates = ath11k_a_rates_size;
8652                         band->bitrates = ath11k_a_rates;
8653                         ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
8654
8655                         if (ar->ab->hw_params.single_pdev_only) {
8656                                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8657                                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8658                         }
8659
8660                         ath11k_mac_update_ch_list(ar, band,
8661                                                   temp_reg_cap->low_5ghz_chan,
8662                                                   temp_reg_cap->high_5ghz_chan);
8663                 }
8664         }
8665
8666         return 0;
8667 }
8668
8669 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
8670 {
8671         struct ath11k_base *ab = ar->ab;
8672         struct ieee80211_iface_combination *combinations;
8673         struct ieee80211_iface_limit *limits;
8674         int n_limits;
8675
8676         combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
8677         if (!combinations)
8678                 return -ENOMEM;
8679
8680         n_limits = 2;
8681
8682         limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
8683         if (!limits) {
8684                 kfree(combinations);
8685                 return -ENOMEM;
8686         }
8687
8688         limits[0].max = 1;
8689         limits[0].types |= BIT(NL80211_IFTYPE_STATION);
8690
8691         limits[1].max = 16;
8692         limits[1].types |= BIT(NL80211_IFTYPE_AP);
8693
8694         if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
8695             ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
8696                 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
8697
8698         combinations[0].limits = limits;
8699         combinations[0].n_limits = n_limits;
8700         combinations[0].max_interfaces = 16;
8701         combinations[0].num_different_channels = 1;
8702         combinations[0].beacon_int_infra_match = true;
8703         combinations[0].beacon_int_min_gcd = 100;
8704         combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
8705                                                 BIT(NL80211_CHAN_WIDTH_20) |
8706                                                 BIT(NL80211_CHAN_WIDTH_40) |
8707                                                 BIT(NL80211_CHAN_WIDTH_80) |
8708                                                 BIT(NL80211_CHAN_WIDTH_80P80) |
8709                                                 BIT(NL80211_CHAN_WIDTH_160);
8710
8711         ar->hw->wiphy->iface_combinations = combinations;
8712         ar->hw->wiphy->n_iface_combinations = 1;
8713
8714         return 0;
8715 }
8716
8717 static const u8 ath11k_if_types_ext_capa[] = {
8718         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8719         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8720 };
8721
8722 static const u8 ath11k_if_types_ext_capa_sta[] = {
8723         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8724         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8725         [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
8726 };
8727
8728 static const u8 ath11k_if_types_ext_capa_ap[] = {
8729         [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8730         [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8731         [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
8732 };
8733
8734 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
8735         {
8736                 .extended_capabilities = ath11k_if_types_ext_capa,
8737                 .extended_capabilities_mask = ath11k_if_types_ext_capa,
8738                 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
8739         }, {
8740                 .iftype = NL80211_IFTYPE_STATION,
8741                 .extended_capabilities = ath11k_if_types_ext_capa_sta,
8742                 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
8743                 .extended_capabilities_len =
8744                                 sizeof(ath11k_if_types_ext_capa_sta),
8745         }, {
8746                 .iftype = NL80211_IFTYPE_AP,
8747                 .extended_capabilities = ath11k_if_types_ext_capa_ap,
8748                 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
8749                 .extended_capabilities_len =
8750                                 sizeof(ath11k_if_types_ext_capa_ap),
8751         },
8752 };
8753
8754 static void __ath11k_mac_unregister(struct ath11k *ar)
8755 {
8756         cancel_work_sync(&ar->regd_update_work);
8757
8758         ieee80211_unregister_hw(ar->hw);
8759
8760         idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
8761         idr_destroy(&ar->txmgmt_idr);
8762
8763         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8764         kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
8765         kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8766
8767         kfree(ar->hw->wiphy->iface_combinations[0].limits);
8768         kfree(ar->hw->wiphy->iface_combinations);
8769
8770         SET_IEEE80211_DEV(ar->hw, NULL);
8771 }
8772
8773 void ath11k_mac_unregister(struct ath11k_base *ab)
8774 {
8775         struct ath11k *ar;
8776         struct ath11k_pdev *pdev;
8777         int i;
8778
8779         for (i = 0; i < ab->num_radios; i++) {
8780                 pdev = &ab->pdevs[i];
8781                 ar = pdev->ar;
8782                 if (!ar)
8783                         continue;
8784
8785                 __ath11k_mac_unregister(ar);
8786         }
8787
8788         ath11k_peer_rhash_tbl_destroy(ab);
8789 }
8790
8791 static int __ath11k_mac_register(struct ath11k *ar)
8792 {
8793         struct ath11k_base *ab = ar->ab;
8794         struct ath11k_pdev_cap *cap = &ar->pdev->cap;
8795         static const u32 cipher_suites[] = {
8796                 WLAN_CIPHER_SUITE_TKIP,
8797                 WLAN_CIPHER_SUITE_CCMP,
8798                 WLAN_CIPHER_SUITE_AES_CMAC,
8799                 WLAN_CIPHER_SUITE_BIP_CMAC_256,
8800                 WLAN_CIPHER_SUITE_BIP_GMAC_128,
8801                 WLAN_CIPHER_SUITE_BIP_GMAC_256,
8802                 WLAN_CIPHER_SUITE_GCMP,
8803                 WLAN_CIPHER_SUITE_GCMP_256,
8804                 WLAN_CIPHER_SUITE_CCMP_256,
8805         };
8806         int ret;
8807         u32 ht_cap = 0;
8808
8809         ath11k_pdev_caps_update(ar);
8810
8811         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
8812
8813         SET_IEEE80211_DEV(ar->hw, ab->dev);
8814
8815         ret = ath11k_mac_setup_channels_rates(ar,
8816                                               cap->supported_bands);
8817         if (ret)
8818                 goto err;
8819
8820         ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
8821         ath11k_mac_setup_he_cap(ar, cap);
8822
8823         ret = ath11k_mac_setup_iface_combinations(ar);
8824         if (ret) {
8825                 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
8826                 goto err_free_channels;
8827         }
8828
8829         ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
8830         ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
8831
8832         ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
8833
8834         if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
8835                 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
8836
8837         ieee80211_hw_set(ar->hw, SIGNAL_DBM);
8838         ieee80211_hw_set(ar->hw, SUPPORTS_PS);
8839         ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
8840         ieee80211_hw_set(ar->hw, MFP_CAPABLE);
8841         ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
8842         ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
8843         ieee80211_hw_set(ar->hw, AP_LINK_PS);
8844         ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
8845         ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
8846         ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
8847         ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
8848         ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
8849         ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
8850         ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
8851         ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
8852
8853         if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
8854                 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
8855                 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
8856         }
8857
8858         if (cap->nss_ratio_enabled)
8859                 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
8860
8861         if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
8862                 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
8863                 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
8864                 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
8865                 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
8866                 ieee80211_hw_set(ar->hw, USES_RSS);
8867         }
8868
8869         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
8870         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
8871
8872         /* TODO: Check if HT capability advertised from firmware is different
8873          * for each band for a dual band capable radio. It will be tricky to
8874          * handle it when the ht capability different for each band.
8875          */
8876         if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
8877             (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
8878                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
8879
8880         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
8881         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
8882
8883         ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
8884
8885         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
8886         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
8887         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
8888
8889         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
8890         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
8891                                    NL80211_FEATURE_AP_SCAN;
8892
8893         ar->max_num_stations = TARGET_NUM_STATIONS(ab);
8894         ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
8895
8896         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
8897
8898         if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
8899                 ar->hw->wiphy->features |=
8900                         NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
8901         }
8902
8903         if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
8904                 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
8905                 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
8906                 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
8907                 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
8908                 ar->hw->wiphy->max_sched_scan_plan_interval =
8909                         WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
8910                 ar->hw->wiphy->max_sched_scan_plan_iterations =
8911                         WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
8912                 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
8913         }
8914
8915         ret = ath11k_wow_init(ar);
8916         if (ret) {
8917                 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
8918                 goto err_free_if_combs;
8919         }
8920
8921         ar->hw->queues = ATH11K_HW_MAX_QUEUES;
8922         ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
8923         ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
8924         ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
8925
8926         ar->hw->vif_data_size = sizeof(struct ath11k_vif);
8927         ar->hw->sta_data_size = sizeof(struct ath11k_sta);
8928
8929         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
8930         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
8931         if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD,
8932                      ar->ab->wmi_ab.svc_map)) {
8933                 wiphy_ext_feature_set(ar->hw->wiphy,
8934                                       NL80211_EXT_FEATURE_BSS_COLOR);
8935                 ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION);
8936         }
8937
8938         ar->hw->wiphy->cipher_suites = cipher_suites;
8939         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
8940
8941         ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
8942         ar->hw->wiphy->num_iftype_ext_capab =
8943                 ARRAY_SIZE(ath11k_iftypes_ext_capa);
8944
8945         if (ar->supports_6ghz) {
8946                 wiphy_ext_feature_set(ar->hw->wiphy,
8947                                       NL80211_EXT_FEATURE_FILS_DISCOVERY);
8948                 wiphy_ext_feature_set(ar->hw->wiphy,
8949                                       NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
8950         }
8951
8952         ath11k_reg_init(ar);
8953
8954         if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
8955                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
8956                 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
8957                 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
8958         }
8959
8960         if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
8961             ab->hw_params.bios_sar_capa)
8962                 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
8963
8964         ret = ieee80211_register_hw(ar->hw);
8965         if (ret) {
8966                 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
8967                 goto err_free_if_combs;
8968         }
8969
8970         if (!ab->hw_params.supports_monitor)
8971                 /* There's a race between calling ieee80211_register_hw()
8972                  * and here where the monitor mode is enabled for a little
8973                  * while. But that time is so short and in practise it make
8974                  * a difference in real life.
8975                  */
8976                 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
8977
8978         /* Apply the regd received during initialization */
8979         ret = ath11k_regd_update(ar);
8980         if (ret) {
8981                 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
8982                 goto err_unregister_hw;
8983         }
8984
8985         if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) {
8986                 struct wmi_set_current_country_params set_current_param = {};
8987
8988                 memcpy(&set_current_param.alpha2, ab->new_alpha2, 2);
8989                 memcpy(&ar->alpha2, ab->new_alpha2, 2);
8990                 ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
8991                 if (ret)
8992                         ath11k_warn(ar->ab,
8993                                     "failed set cc code for mac register: %d\n", ret);
8994         }
8995
8996         ret = ath11k_debugfs_register(ar);
8997         if (ret) {
8998                 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
8999                 goto err_unregister_hw;
9000         }
9001
9002         return 0;
9003
9004 err_unregister_hw:
9005         ieee80211_unregister_hw(ar->hw);
9006
9007 err_free_if_combs:
9008         kfree(ar->hw->wiphy->iface_combinations[0].limits);
9009         kfree(ar->hw->wiphy->iface_combinations);
9010
9011 err_free_channels:
9012         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
9013         kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
9014         kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
9015
9016 err:
9017         SET_IEEE80211_DEV(ar->hw, NULL);
9018         return ret;
9019 }
9020
9021 int ath11k_mac_register(struct ath11k_base *ab)
9022 {
9023         struct ath11k *ar;
9024         struct ath11k_pdev *pdev;
9025         int i;
9026         int ret;
9027
9028         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9029                 return 0;
9030
9031         /* Initialize channel counters frequency value in hertz */
9032         ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
9033         ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
9034
9035         ret = ath11k_peer_rhash_tbl_init(ab);
9036         if (ret)
9037                 return ret;
9038
9039         for (i = 0; i < ab->num_radios; i++) {
9040                 pdev = &ab->pdevs[i];
9041                 ar = pdev->ar;
9042                 if (ab->pdevs_macaddr_valid) {
9043                         ether_addr_copy(ar->mac_addr, pdev->mac_addr);
9044                 } else {
9045                         ether_addr_copy(ar->mac_addr, ab->mac_addr);
9046                         ar->mac_addr[4] += i;
9047                 }
9048
9049                 idr_init(&ar->txmgmt_idr);
9050                 spin_lock_init(&ar->txmgmt_idr_lock);
9051
9052                 ret = __ath11k_mac_register(ar);
9053                 if (ret)
9054                         goto err_cleanup;
9055
9056                 init_waitqueue_head(&ar->txmgmt_empty_waitq);
9057         }
9058
9059         return 0;
9060
9061 err_cleanup:
9062         for (i = i - 1; i >= 0; i--) {
9063                 pdev = &ab->pdevs[i];
9064                 ar = pdev->ar;
9065                 __ath11k_mac_unregister(ar);
9066         }
9067
9068         ath11k_peer_rhash_tbl_destroy(ab);
9069
9070         return ret;
9071 }
9072
9073 int ath11k_mac_allocate(struct ath11k_base *ab)
9074 {
9075         struct ieee80211_hw *hw;
9076         struct ath11k *ar;
9077         struct ath11k_pdev *pdev;
9078         int ret;
9079         int i;
9080
9081         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9082                 return 0;
9083
9084         for (i = 0; i < ab->num_radios; i++) {
9085                 pdev = &ab->pdevs[i];
9086                 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
9087                 if (!hw) {
9088                         ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
9089                         ret = -ENOMEM;
9090                         goto err_free_mac;
9091                 }
9092
9093                 ar = hw->priv;
9094                 ar->hw = hw;
9095                 ar->ab = ab;
9096                 ar->pdev = pdev;
9097                 ar->pdev_idx = i;
9098                 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
9099
9100                 ar->wmi = &ab->wmi_ab.wmi[i];
9101                 /* FIXME wmi[0] is already initialized during attach,
9102                  * Should we do this again?
9103                  */
9104                 ath11k_wmi_pdev_attach(ab, i);
9105
9106                 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
9107                 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
9108                 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
9109                 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
9110
9111                 pdev->ar = ar;
9112                 spin_lock_init(&ar->data_lock);
9113                 INIT_LIST_HEAD(&ar->arvifs);
9114                 INIT_LIST_HEAD(&ar->ppdu_stats_info);
9115                 mutex_init(&ar->conf_mutex);
9116                 init_completion(&ar->vdev_setup_done);
9117                 init_completion(&ar->vdev_delete_done);
9118                 init_completion(&ar->peer_assoc_done);
9119                 init_completion(&ar->peer_delete_done);
9120                 init_completion(&ar->install_key_done);
9121                 init_completion(&ar->bss_survey_done);
9122                 init_completion(&ar->scan.started);
9123                 init_completion(&ar->scan.completed);
9124                 init_completion(&ar->scan.on_channel);
9125                 init_completion(&ar->thermal.wmi_sync);
9126
9127                 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
9128                 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
9129
9130                 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
9131                 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
9132
9133                 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
9134
9135                 ar->monitor_vdev_id = -1;
9136                 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9137                 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
9138                 init_completion(&ar->completed_11d_scan);
9139         }
9140
9141         return 0;
9142
9143 err_free_mac:
9144         ath11k_mac_destroy(ab);
9145
9146         return ret;
9147 }
9148
9149 void ath11k_mac_destroy(struct ath11k_base *ab)
9150 {
9151         struct ath11k *ar;
9152         struct ath11k_pdev *pdev;
9153         int i;
9154
9155         for (i = 0; i < ab->num_radios; i++) {
9156                 pdev = &ab->pdevs[i];
9157                 ar = pdev->ar;
9158                 if (!ar)
9159                         continue;
9160
9161                 ieee80211_free_hw(ar->hw);
9162                 pdev->ar = NULL;
9163         }
9164 }
9165
9166 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif,
9167                                  enum wmi_sta_keepalive_method method,
9168                                  u32 interval)
9169 {
9170         struct ath11k *ar = arvif->ar;
9171         struct wmi_sta_keepalive_arg arg = {};
9172         int ret;
9173
9174         lockdep_assert_held(&ar->conf_mutex);
9175
9176         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
9177                 return 0;
9178
9179         if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
9180                 return 0;
9181
9182         arg.vdev_id = arvif->vdev_id;
9183         arg.enabled = 1;
9184         arg.method = method;
9185         arg.interval = interval;
9186
9187         ret = ath11k_wmi_sta_keepalive(ar, &arg);
9188         if (ret) {
9189                 ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
9190                             arvif->vdev_id, ret);
9191                 return ret;
9192         }
9193
9194         return 0;
9195 }