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