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

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