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