drivers/net/wireless/ath/ath12k/mac.c

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