Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: BSD-3-Clause-Clear
0002 /*
0003  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
0004  * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
0005  */
0006 
0007 #include <net/mac80211.h>
0008 #include <linux/etherdevice.h>
0009 #include <linux/bitfield.h>
0010 #include <linux/inetdevice.h>
0011 #include <net/if_inet6.h>
0012 #include <net/ipv6.h>
0013 
0014 #include "mac.h"
0015 #include "core.h"
0016 #include "debug.h"
0017 #include "wmi.h"
0018 #include "hw.h"
0019 #include "dp_tx.h"
0020 #include "dp_rx.h"
0021 #include "testmode.h"
0022 #include "peer.h"
0023 #include "debugfs_sta.h"
0024 #include "hif.h"
0025 #include "wow.h"
0026 
0027 #define CHAN2G(_channel, _freq, _flags) { \
0028     .band                   = NL80211_BAND_2GHZ, \
0029     .hw_value               = (_channel), \
0030     .center_freq            = (_freq), \
0031     .flags                  = (_flags), \
0032     .max_antenna_gain       = 0, \
0033     .max_power              = 30, \
0034 }
0035 
0036 #define CHAN5G(_channel, _freq, _flags) { \
0037     .band                   = NL80211_BAND_5GHZ, \
0038     .hw_value               = (_channel), \
0039     .center_freq            = (_freq), \
0040     .flags                  = (_flags), \
0041     .max_antenna_gain       = 0, \
0042     .max_power              = 30, \
0043 }
0044 
0045 #define CHAN6G(_channel, _freq, _flags) { \
0046     .band                   = NL80211_BAND_6GHZ, \
0047     .hw_value               = (_channel), \
0048     .center_freq            = (_freq), \
0049     .flags                  = (_flags), \
0050     .max_antenna_gain       = 0, \
0051     .max_power              = 30, \
0052 }
0053 
0054 static const struct ieee80211_channel ath11k_2ghz_channels[] = {
0055     CHAN2G(1, 2412, 0),
0056     CHAN2G(2, 2417, 0),
0057     CHAN2G(3, 2422, 0),
0058     CHAN2G(4, 2427, 0),
0059     CHAN2G(5, 2432, 0),
0060     CHAN2G(6, 2437, 0),
0061     CHAN2G(7, 2442, 0),
0062     CHAN2G(8, 2447, 0),
0063     CHAN2G(9, 2452, 0),
0064     CHAN2G(10, 2457, 0),
0065     CHAN2G(11, 2462, 0),
0066     CHAN2G(12, 2467, 0),
0067     CHAN2G(13, 2472, 0),
0068     CHAN2G(14, 2484, 0),
0069 };
0070 
0071 static const struct ieee80211_channel ath11k_5ghz_channels[] = {
0072     CHAN5G(36, 5180, 0),
0073     CHAN5G(40, 5200, 0),
0074     CHAN5G(44, 5220, 0),
0075     CHAN5G(48, 5240, 0),
0076     CHAN5G(52, 5260, 0),
0077     CHAN5G(56, 5280, 0),
0078     CHAN5G(60, 5300, 0),
0079     CHAN5G(64, 5320, 0),
0080     CHAN5G(100, 5500, 0),
0081     CHAN5G(104, 5520, 0),
0082     CHAN5G(108, 5540, 0),
0083     CHAN5G(112, 5560, 0),
0084     CHAN5G(116, 5580, 0),
0085     CHAN5G(120, 5600, 0),
0086     CHAN5G(124, 5620, 0),
0087     CHAN5G(128, 5640, 0),
0088     CHAN5G(132, 5660, 0),
0089     CHAN5G(136, 5680, 0),
0090     CHAN5G(140, 5700, 0),
0091     CHAN5G(144, 5720, 0),
0092     CHAN5G(149, 5745, 0),
0093     CHAN5G(153, 5765, 0),
0094     CHAN5G(157, 5785, 0),
0095     CHAN5G(161, 5805, 0),
0096     CHAN5G(165, 5825, 0),
0097     CHAN5G(169, 5845, 0),
0098     CHAN5G(173, 5865, 0),
0099 };
0100 
0101 static const struct ieee80211_channel ath11k_6ghz_channels[] = {
0102     CHAN6G(1, 5955, 0),
0103     CHAN6G(5, 5975, 0),
0104     CHAN6G(9, 5995, 0),
0105     CHAN6G(13, 6015, 0),
0106     CHAN6G(17, 6035, 0),
0107     CHAN6G(21, 6055, 0),
0108     CHAN6G(25, 6075, 0),
0109     CHAN6G(29, 6095, 0),
0110     CHAN6G(33, 6115, 0),
0111     CHAN6G(37, 6135, 0),
0112     CHAN6G(41, 6155, 0),
0113     CHAN6G(45, 6175, 0),
0114     CHAN6G(49, 6195, 0),
0115     CHAN6G(53, 6215, 0),
0116     CHAN6G(57, 6235, 0),
0117     CHAN6G(61, 6255, 0),
0118     CHAN6G(65, 6275, 0),
0119     CHAN6G(69, 6295, 0),
0120     CHAN6G(73, 6315, 0),
0121     CHAN6G(77, 6335, 0),
0122     CHAN6G(81, 6355, 0),
0123     CHAN6G(85, 6375, 0),
0124     CHAN6G(89, 6395, 0),
0125     CHAN6G(93, 6415, 0),
0126     CHAN6G(97, 6435, 0),
0127     CHAN6G(101, 6455, 0),
0128     CHAN6G(105, 6475, 0),
0129     CHAN6G(109, 6495, 0),
0130     CHAN6G(113, 6515, 0),
0131     CHAN6G(117, 6535, 0),
0132     CHAN6G(121, 6555, 0),
0133     CHAN6G(125, 6575, 0),
0134     CHAN6G(129, 6595, 0),
0135     CHAN6G(133, 6615, 0),
0136     CHAN6G(137, 6635, 0),
0137     CHAN6G(141, 6655, 0),
0138     CHAN6G(145, 6675, 0),
0139     CHAN6G(149, 6695, 0),
0140     CHAN6G(153, 6715, 0),
0141     CHAN6G(157, 6735, 0),
0142     CHAN6G(161, 6755, 0),
0143     CHAN6G(165, 6775, 0),
0144     CHAN6G(169, 6795, 0),
0145     CHAN6G(173, 6815, 0),
0146     CHAN6G(177, 6835, 0),
0147     CHAN6G(181, 6855, 0),
0148     CHAN6G(185, 6875, 0),
0149     CHAN6G(189, 6895, 0),
0150     CHAN6G(193, 6915, 0),
0151     CHAN6G(197, 6935, 0),
0152     CHAN6G(201, 6955, 0),
0153     CHAN6G(205, 6975, 0),
0154     CHAN6G(209, 6995, 0),
0155     CHAN6G(213, 7015, 0),
0156     CHAN6G(217, 7035, 0),
0157     CHAN6G(221, 7055, 0),
0158     CHAN6G(225, 7075, 0),
0159     CHAN6G(229, 7095, 0),
0160     CHAN6G(233, 7115, 0),
0161 
0162     /* new addition in IEEE Std 802.11ax-2021 */
0163     CHAN6G(2, 5935, 0),
0164 };
0165 
0166 static struct ieee80211_rate ath11k_legacy_rates[] = {
0167     { .bitrate = 10,
0168       .hw_value = ATH11K_HW_RATE_CCK_LP_1M },
0169     { .bitrate = 20,
0170       .hw_value = ATH11K_HW_RATE_CCK_LP_2M,
0171       .hw_value_short = ATH11K_HW_RATE_CCK_SP_2M,
0172       .flags = IEEE80211_RATE_SHORT_PREAMBLE },
0173     { .bitrate = 55,
0174       .hw_value = ATH11K_HW_RATE_CCK_LP_5_5M,
0175       .hw_value_short = ATH11K_HW_RATE_CCK_SP_5_5M,
0176       .flags = IEEE80211_RATE_SHORT_PREAMBLE },
0177     { .bitrate = 110,
0178       .hw_value = ATH11K_HW_RATE_CCK_LP_11M,
0179       .hw_value_short = ATH11K_HW_RATE_CCK_SP_11M,
0180       .flags = IEEE80211_RATE_SHORT_PREAMBLE },
0181 
0182     { .bitrate = 60, .hw_value = ATH11K_HW_RATE_OFDM_6M },
0183     { .bitrate = 90, .hw_value = ATH11K_HW_RATE_OFDM_9M },
0184     { .bitrate = 120, .hw_value = ATH11K_HW_RATE_OFDM_12M },
0185     { .bitrate = 180, .hw_value = ATH11K_HW_RATE_OFDM_18M },
0186     { .bitrate = 240, .hw_value = ATH11K_HW_RATE_OFDM_24M },
0187     { .bitrate = 360, .hw_value = ATH11K_HW_RATE_OFDM_36M },
0188     { .bitrate = 480, .hw_value = ATH11K_HW_RATE_OFDM_48M },
0189     { .bitrate = 540, .hw_value = ATH11K_HW_RATE_OFDM_54M },
0190 };
0191 
0192 static const int
0193 ath11k_phymodes[NUM_NL80211_BANDS][ATH11K_CHAN_WIDTH_NUM] = {
0194     [NL80211_BAND_2GHZ] = {
0195             [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
0196             [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
0197             [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20_2G,
0198             [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20_2G,
0199             [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40_2G,
0200             [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80_2G,
0201             [NL80211_CHAN_WIDTH_80P80] = MODE_UNKNOWN,
0202             [NL80211_CHAN_WIDTH_160] = MODE_UNKNOWN,
0203     },
0204     [NL80211_BAND_5GHZ] = {
0205             [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
0206             [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
0207             [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
0208             [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
0209             [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
0210             [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
0211             [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
0212             [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
0213     },
0214     [NL80211_BAND_6GHZ] = {
0215             [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
0216             [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
0217             [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
0218             [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
0219             [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
0220             [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
0221             [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
0222             [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
0223     },
0224 
0225 };
0226 
0227 const struct htt_rx_ring_tlv_filter ath11k_mac_mon_status_filter_default = {
0228     .rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START |
0229              HTT_RX_FILTER_TLV_FLAGS_PPDU_END |
0230              HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE,
0231     .pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0,
0232     .pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1,
0233     .pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2,
0234     .pkt_filter_flags3 = HTT_RX_FP_DATA_FILTER_FLASG3 |
0235                  HTT_RX_FP_CTRL_FILTER_FLASG3
0236 };
0237 
0238 #define ATH11K_MAC_FIRST_OFDM_RATE_IDX 4
0239 #define ath11k_g_rates ath11k_legacy_rates
0240 #define ath11k_g_rates_size (ARRAY_SIZE(ath11k_legacy_rates))
0241 #define ath11k_a_rates (ath11k_legacy_rates + 4)
0242 #define ath11k_a_rates_size (ARRAY_SIZE(ath11k_legacy_rates) - 4)
0243 
0244 #define ATH11K_MAC_SCAN_TIMEOUT_MSECS 200 /* in msecs */
0245 
0246 static const u32 ath11k_smps_map[] = {
0247     [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
0248     [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
0249     [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
0250     [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
0251 };
0252 
0253 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
0254                    struct ieee80211_vif *vif);
0255 
0256 enum nl80211_he_ru_alloc ath11k_mac_phy_he_ru_to_nl80211_he_ru_alloc(u16 ru_phy)
0257 {
0258     enum nl80211_he_ru_alloc ret;
0259 
0260     switch (ru_phy) {
0261     case RU_26:
0262         ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
0263         break;
0264     case RU_52:
0265         ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
0266         break;
0267     case RU_106:
0268         ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
0269         break;
0270     case RU_242:
0271         ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
0272         break;
0273     case RU_484:
0274         ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
0275         break;
0276     case RU_996:
0277         ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
0278         break;
0279     default:
0280         ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
0281         break;
0282     }
0283 
0284     return ret;
0285 }
0286 
0287 enum nl80211_he_ru_alloc ath11k_mac_he_ru_tones_to_nl80211_he_ru_alloc(u16 ru_tones)
0288 {
0289     enum nl80211_he_ru_alloc ret;
0290 
0291     switch (ru_tones) {
0292     case 26:
0293         ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
0294         break;
0295     case 52:
0296         ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
0297         break;
0298     case 106:
0299         ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
0300         break;
0301     case 242:
0302         ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
0303         break;
0304     case 484:
0305         ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
0306         break;
0307     case 996:
0308         ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
0309         break;
0310     case (996 * 2):
0311         ret = NL80211_RATE_INFO_HE_RU_ALLOC_2x996;
0312         break;
0313     default:
0314         ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
0315         break;
0316     }
0317 
0318     return ret;
0319 }
0320 
0321 enum nl80211_he_gi ath11k_mac_he_gi_to_nl80211_he_gi(u8 sgi)
0322 {
0323     enum nl80211_he_gi ret;
0324 
0325     switch (sgi) {
0326     case RX_MSDU_START_SGI_0_8_US:
0327         ret = NL80211_RATE_INFO_HE_GI_0_8;
0328         break;
0329     case RX_MSDU_START_SGI_1_6_US:
0330         ret = NL80211_RATE_INFO_HE_GI_1_6;
0331         break;
0332     case RX_MSDU_START_SGI_3_2_US:
0333         ret = NL80211_RATE_INFO_HE_GI_3_2;
0334         break;
0335     default:
0336         ret = NL80211_RATE_INFO_HE_GI_0_8;
0337         break;
0338     }
0339 
0340     return ret;
0341 }
0342 
0343 u8 ath11k_mac_bw_to_mac80211_bw(u8 bw)
0344 {
0345     u8 ret = 0;
0346 
0347     switch (bw) {
0348     case ATH11K_BW_20:
0349         ret = RATE_INFO_BW_20;
0350         break;
0351     case ATH11K_BW_40:
0352         ret = RATE_INFO_BW_40;
0353         break;
0354     case ATH11K_BW_80:
0355         ret = RATE_INFO_BW_80;
0356         break;
0357     case ATH11K_BW_160:
0358         ret = RATE_INFO_BW_160;
0359         break;
0360     }
0361 
0362     return ret;
0363 }
0364 
0365 enum ath11k_supported_bw ath11k_mac_mac80211_bw_to_ath11k_bw(enum rate_info_bw bw)
0366 {
0367     switch (bw) {
0368     case RATE_INFO_BW_20:
0369         return ATH11K_BW_20;
0370     case RATE_INFO_BW_40:
0371         return ATH11K_BW_40;
0372     case RATE_INFO_BW_80:
0373         return ATH11K_BW_80;
0374     case RATE_INFO_BW_160:
0375         return ATH11K_BW_160;
0376     default:
0377         return ATH11K_BW_20;
0378     }
0379 }
0380 
0381 int ath11k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx,
0382                       u16 *rate)
0383 {
0384     /* As default, it is OFDM rates */
0385     int i = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
0386     int max_rates_idx = ath11k_g_rates_size;
0387 
0388     if (preamble == WMI_RATE_PREAMBLE_CCK) {
0389         hw_rc &= ~ATH11k_HW_RATECODE_CCK_SHORT_PREAM_MASK;
0390         i = 0;
0391         max_rates_idx = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
0392     }
0393 
0394     while (i < max_rates_idx) {
0395         if (hw_rc == ath11k_legacy_rates[i].hw_value) {
0396             *rateidx = i;
0397             *rate = ath11k_legacy_rates[i].bitrate;
0398             return 0;
0399         }
0400         i++;
0401     }
0402 
0403     return -EINVAL;
0404 }
0405 
0406 static int get_num_chains(u32 mask)
0407 {
0408     int num_chains = 0;
0409 
0410     while (mask) {
0411         if (mask & BIT(0))
0412             num_chains++;
0413         mask >>= 1;
0414     }
0415 
0416     return num_chains;
0417 }
0418 
0419 u8 ath11k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
0420                  u32 bitrate)
0421 {
0422     int i;
0423 
0424     for (i = 0; i < sband->n_bitrates; i++)
0425         if (sband->bitrates[i].bitrate == bitrate)
0426             return i;
0427 
0428     return 0;
0429 }
0430 
0431 static u32
0432 ath11k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
0433 {
0434     int nss;
0435 
0436     for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
0437         if (ht_mcs_mask[nss])
0438             return nss + 1;
0439 
0440     return 1;
0441 }
0442 
0443 static u32
0444 ath11k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
0445 {
0446     int nss;
0447 
0448     for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
0449         if (vht_mcs_mask[nss])
0450             return nss + 1;
0451 
0452     return 1;
0453 }
0454 
0455 static u32
0456 ath11k_mac_max_he_nss(const u16 he_mcs_mask[NL80211_HE_NSS_MAX])
0457 {
0458     int nss;
0459 
0460     for (nss = NL80211_HE_NSS_MAX - 1; nss >= 0; nss--)
0461         if (he_mcs_mask[nss])
0462             return nss + 1;
0463 
0464     return 1;
0465 }
0466 
0467 static u8 ath11k_parse_mpdudensity(u8 mpdudensity)
0468 {
0469 /* 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
0470  *   0 for no restriction
0471  *   1 for 1/4 us
0472  *   2 for 1/2 us
0473  *   3 for 1 us
0474  *   4 for 2 us
0475  *   5 for 4 us
0476  *   6 for 8 us
0477  *   7 for 16 us
0478  */
0479     switch (mpdudensity) {
0480     case 0:
0481         return 0;
0482     case 1:
0483     case 2:
0484     case 3:
0485     /* Our lower layer calculations limit our precision to
0486      * 1 microsecond
0487      */
0488         return 1;
0489     case 4:
0490         return 2;
0491     case 5:
0492         return 4;
0493     case 6:
0494         return 8;
0495     case 7:
0496         return 16;
0497     default:
0498         return 0;
0499     }
0500 }
0501 
0502 static int ath11k_mac_vif_chan(struct ieee80211_vif *vif,
0503                    struct cfg80211_chan_def *def)
0504 {
0505     struct ieee80211_chanctx_conf *conf;
0506 
0507     rcu_read_lock();
0508     conf = rcu_dereference(vif->bss_conf.chanctx_conf);
0509     if (!conf) {
0510         rcu_read_unlock();
0511         return -ENOENT;
0512     }
0513 
0514     *def = conf->def;
0515     rcu_read_unlock();
0516 
0517     return 0;
0518 }
0519 
0520 static bool ath11k_mac_bitrate_is_cck(int bitrate)
0521 {
0522     switch (bitrate) {
0523     case 10:
0524     case 20:
0525     case 55:
0526     case 110:
0527         return true;
0528     }
0529 
0530     return false;
0531 }
0532 
0533 u8 ath11k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
0534                  u8 hw_rate, bool cck)
0535 {
0536     const struct ieee80211_rate *rate;
0537     int i;
0538 
0539     for (i = 0; i < sband->n_bitrates; i++) {
0540         rate = &sband->bitrates[i];
0541 
0542         if (ath11k_mac_bitrate_is_cck(rate->bitrate) != cck)
0543             continue;
0544 
0545         if (rate->hw_value == hw_rate)
0546             return i;
0547         else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
0548              rate->hw_value_short == hw_rate)
0549             return i;
0550     }
0551 
0552     return 0;
0553 }
0554 
0555 static u8 ath11k_mac_bitrate_to_rate(int bitrate)
0556 {
0557     return DIV_ROUND_UP(bitrate, 5) |
0558            (ath11k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
0559 }
0560 
0561 static void ath11k_get_arvif_iter(void *data, u8 *mac,
0562                   struct ieee80211_vif *vif)
0563 {
0564     struct ath11k_vif_iter *arvif_iter = data;
0565     struct ath11k_vif *arvif = (void *)vif->drv_priv;
0566 
0567     if (arvif->vdev_id == arvif_iter->vdev_id)
0568         arvif_iter->arvif = arvif;
0569 }
0570 
0571 struct ath11k_vif *ath11k_mac_get_arvif(struct ath11k *ar, u32 vdev_id)
0572 {
0573     struct ath11k_vif_iter arvif_iter;
0574     u32 flags;
0575 
0576     memset(&arvif_iter, 0, sizeof(struct ath11k_vif_iter));
0577     arvif_iter.vdev_id = vdev_id;
0578 
0579     flags = IEEE80211_IFACE_ITER_RESUME_ALL;
0580     ieee80211_iterate_active_interfaces_atomic(ar->hw,
0581                            flags,
0582                            ath11k_get_arvif_iter,
0583                            &arvif_iter);
0584     if (!arvif_iter.arvif) {
0585         ath11k_warn(ar->ab, "No VIF found for vdev %d\n", vdev_id);
0586         return NULL;
0587     }
0588 
0589     return arvif_iter.arvif;
0590 }
0591 
0592 struct ath11k_vif *ath11k_mac_get_arvif_by_vdev_id(struct ath11k_base *ab,
0593                            u32 vdev_id)
0594 {
0595     int i;
0596     struct ath11k_pdev *pdev;
0597     struct ath11k_vif *arvif;
0598 
0599     for (i = 0; i < ab->num_radios; i++) {
0600         pdev = rcu_dereference(ab->pdevs_active[i]);
0601         if (pdev && pdev->ar &&
0602             (pdev->ar->allocated_vdev_map & (1LL << vdev_id))) {
0603             arvif = ath11k_mac_get_arvif(pdev->ar, vdev_id);
0604             if (arvif)
0605                 return arvif;
0606         }
0607     }
0608 
0609     return NULL;
0610 }
0611 
0612 struct ath11k *ath11k_mac_get_ar_by_vdev_id(struct ath11k_base *ab, u32 vdev_id)
0613 {
0614     int i;
0615     struct ath11k_pdev *pdev;
0616 
0617     for (i = 0; i < ab->num_radios; i++) {
0618         pdev = rcu_dereference(ab->pdevs_active[i]);
0619         if (pdev && pdev->ar) {
0620             if (pdev->ar->allocated_vdev_map & (1LL << vdev_id))
0621                 return pdev->ar;
0622         }
0623     }
0624 
0625     return NULL;
0626 }
0627 
0628 struct ath11k *ath11k_mac_get_ar_by_pdev_id(struct ath11k_base *ab, u32 pdev_id)
0629 {
0630     int i;
0631     struct ath11k_pdev *pdev;
0632 
0633     if (ab->hw_params.single_pdev_only) {
0634         pdev = rcu_dereference(ab->pdevs_active[0]);
0635         return pdev ? pdev->ar : NULL;
0636     }
0637 
0638     if (WARN_ON(pdev_id > ab->num_radios))
0639         return NULL;
0640 
0641     for (i = 0; i < ab->num_radios; i++) {
0642         pdev = rcu_dereference(ab->pdevs_active[i]);
0643 
0644         if (pdev && pdev->pdev_id == pdev_id)
0645             return (pdev->ar ? pdev->ar : NULL);
0646     }
0647 
0648     return NULL;
0649 }
0650 
0651 struct ath11k_vif *ath11k_mac_get_vif_up(struct ath11k_base *ab)
0652 {
0653     struct ath11k *ar;
0654     struct ath11k_pdev *pdev;
0655     struct ath11k_vif *arvif;
0656     int i;
0657 
0658     for (i = 0; i < ab->num_radios; i++) {
0659         pdev = &ab->pdevs[i];
0660         ar = pdev->ar;
0661         list_for_each_entry(arvif, &ar->arvifs, list) {
0662             if (arvif->is_up)
0663                 return arvif;
0664         }
0665     }
0666 
0667     return NULL;
0668 }
0669 
0670 static bool ath11k_mac_band_match(enum nl80211_band band1, enum WMI_HOST_WLAN_BAND band2)
0671 {
0672     return (((band1 == NL80211_BAND_2GHZ) && (band2 & WMI_HOST_WLAN_2G_CAP)) ||
0673         (((band1 == NL80211_BAND_5GHZ) || (band1 == NL80211_BAND_6GHZ)) &&
0674            (band2 & WMI_HOST_WLAN_5G_CAP)));
0675 }
0676 
0677 u8 ath11k_mac_get_target_pdev_id_from_vif(struct ath11k_vif *arvif)
0678 {
0679     struct ath11k *ar = arvif->ar;
0680     struct ath11k_base *ab = ar->ab;
0681     struct ieee80211_vif *vif = arvif->vif;
0682     struct cfg80211_chan_def def;
0683     enum nl80211_band band;
0684     u8 pdev_id = ab->target_pdev_ids[0].pdev_id;
0685     int i;
0686 
0687     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
0688         return pdev_id;
0689 
0690     band = def.chan->band;
0691 
0692     for (i = 0; i < ab->target_pdev_count; i++) {
0693         if (ath11k_mac_band_match(band, ab->target_pdev_ids[i].supported_bands))
0694             return ab->target_pdev_ids[i].pdev_id;
0695     }
0696 
0697     return pdev_id;
0698 }
0699 
0700 u8 ath11k_mac_get_target_pdev_id(struct ath11k *ar)
0701 {
0702     struct ath11k_vif *arvif;
0703 
0704     arvif = ath11k_mac_get_vif_up(ar->ab);
0705 
0706     if (arvif)
0707         return ath11k_mac_get_target_pdev_id_from_vif(arvif);
0708     else
0709         return ar->ab->target_pdev_ids[0].pdev_id;
0710 }
0711 
0712 static void ath11k_pdev_caps_update(struct ath11k *ar)
0713 {
0714     struct ath11k_base *ab = ar->ab;
0715 
0716     ar->max_tx_power = ab->target_caps.hw_max_tx_power;
0717 
0718     /* FIXME Set min_tx_power to ab->target_caps.hw_min_tx_power.
0719      * But since the received value in svcrdy is same as hw_max_tx_power,
0720      * we can set ar->min_tx_power to 0 currently until
0721      * this is fixed in firmware
0722      */
0723     ar->min_tx_power = 0;
0724 
0725     ar->txpower_limit_2g = ar->max_tx_power;
0726     ar->txpower_limit_5g = ar->max_tx_power;
0727     ar->txpower_scale = WMI_HOST_TP_SCALE_MAX;
0728 }
0729 
0730 static int ath11k_mac_txpower_recalc(struct ath11k *ar)
0731 {
0732     struct ath11k_pdev *pdev = ar->pdev;
0733     struct ath11k_vif *arvif;
0734     int ret, txpower = -1;
0735     u32 param;
0736 
0737     lockdep_assert_held(&ar->conf_mutex);
0738 
0739     list_for_each_entry(arvif, &ar->arvifs, list) {
0740         if (arvif->txpower <= 0)
0741             continue;
0742 
0743         if (txpower == -1)
0744             txpower = arvif->txpower;
0745         else
0746             txpower = min(txpower, arvif->txpower);
0747     }
0748 
0749     if (txpower == -1)
0750         return 0;
0751 
0752     /* txpwr is set as 2 units per dBm in FW*/
0753     txpower = min_t(u32, max_t(u32, ar->min_tx_power, txpower),
0754             ar->max_tx_power) * 2;
0755 
0756     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower to set in hw %d\n",
0757            txpower / 2);
0758 
0759     if ((pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) &&
0760         ar->txpower_limit_2g != txpower) {
0761         param = WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
0762         ret = ath11k_wmi_pdev_set_param(ar, param,
0763                         txpower, ar->pdev->pdev_id);
0764         if (ret)
0765             goto fail;
0766         ar->txpower_limit_2g = txpower;
0767     }
0768 
0769     if ((pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) &&
0770         ar->txpower_limit_5g != txpower) {
0771         param = WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
0772         ret = ath11k_wmi_pdev_set_param(ar, param,
0773                         txpower, ar->pdev->pdev_id);
0774         if (ret)
0775             goto fail;
0776         ar->txpower_limit_5g = txpower;
0777     }
0778 
0779     return 0;
0780 
0781 fail:
0782     ath11k_warn(ar->ab, "failed to recalc txpower limit %d using pdev param %d: %d\n",
0783             txpower / 2, param, ret);
0784     return ret;
0785 }
0786 
0787 static int ath11k_recalc_rtscts_prot(struct ath11k_vif *arvif)
0788 {
0789     struct ath11k *ar = arvif->ar;
0790     u32 vdev_param, rts_cts = 0;
0791     int ret;
0792 
0793     lockdep_assert_held(&ar->conf_mutex);
0794 
0795     vdev_param = WMI_VDEV_PARAM_ENABLE_RTSCTS;
0796 
0797     /* Enable RTS/CTS protection for sw retries (when legacy stations
0798      * are in BSS) or by default only for second rate series.
0799      * TODO: Check if we need to enable CTS 2 Self in any case
0800      */
0801     rts_cts = WMI_USE_RTS_CTS;
0802 
0803     if (arvif->num_legacy_stations > 0)
0804         rts_cts |= WMI_RTSCTS_ACROSS_SW_RETRIES << 4;
0805     else
0806         rts_cts |= WMI_RTSCTS_FOR_SECOND_RATESERIES << 4;
0807 
0808     /* Need not send duplicate param value to firmware */
0809     if (arvif->rtscts_prot_mode == rts_cts)
0810         return 0;
0811 
0812     arvif->rtscts_prot_mode = rts_cts;
0813 
0814     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n",
0815            arvif->vdev_id, rts_cts);
0816 
0817     ret =  ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
0818                          vdev_param, rts_cts);
0819     if (ret)
0820         ath11k_warn(ar->ab, "failed to recalculate rts/cts prot for vdev %d: %d\n",
0821                 arvif->vdev_id, ret);
0822 
0823     return ret;
0824 }
0825 
0826 static int ath11k_mac_set_kickout(struct ath11k_vif *arvif)
0827 {
0828     struct ath11k *ar = arvif->ar;
0829     u32 param;
0830     int ret;
0831 
0832     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_STA_KICKOUT_TH,
0833                     ATH11K_KICKOUT_THRESHOLD,
0834                     ar->pdev->pdev_id);
0835     if (ret) {
0836         ath11k_warn(ar->ab, "failed to set kickout threshold on vdev %i: %d\n",
0837                 arvif->vdev_id, ret);
0838         return ret;
0839     }
0840 
0841     param = WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS;
0842     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
0843                         ATH11K_KEEPALIVE_MIN_IDLE);
0844     if (ret) {
0845         ath11k_warn(ar->ab, "failed to set keepalive minimum idle time on vdev %i: %d\n",
0846                 arvif->vdev_id, ret);
0847         return ret;
0848     }
0849 
0850     param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS;
0851     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
0852                         ATH11K_KEEPALIVE_MAX_IDLE);
0853     if (ret) {
0854         ath11k_warn(ar->ab, "failed to set keepalive maximum idle time on vdev %i: %d\n",
0855                 arvif->vdev_id, ret);
0856         return ret;
0857     }
0858 
0859     param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS;
0860     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
0861                         ATH11K_KEEPALIVE_MAX_UNRESPONSIVE);
0862     if (ret) {
0863         ath11k_warn(ar->ab, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
0864                 arvif->vdev_id, ret);
0865         return ret;
0866     }
0867 
0868     return 0;
0869 }
0870 
0871 void ath11k_mac_peer_cleanup_all(struct ath11k *ar)
0872 {
0873     struct ath11k_peer *peer, *tmp;
0874     struct ath11k_base *ab = ar->ab;
0875 
0876     lockdep_assert_held(&ar->conf_mutex);
0877 
0878     mutex_lock(&ab->tbl_mtx_lock);
0879     spin_lock_bh(&ab->base_lock);
0880     list_for_each_entry_safe(peer, tmp, &ab->peers, list) {
0881         ath11k_peer_rx_tid_cleanup(ar, peer);
0882         ath11k_peer_rhash_delete(ab, peer);
0883         list_del(&peer->list);
0884         kfree(peer);
0885     }
0886     spin_unlock_bh(&ab->base_lock);
0887     mutex_unlock(&ab->tbl_mtx_lock);
0888 
0889     ar->num_peers = 0;
0890     ar->num_stations = 0;
0891 }
0892 
0893 static inline int ath11k_mac_vdev_setup_sync(struct ath11k *ar)
0894 {
0895     lockdep_assert_held(&ar->conf_mutex);
0896 
0897     if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
0898         return -ESHUTDOWN;
0899 
0900     if (!wait_for_completion_timeout(&ar->vdev_setup_done,
0901                      ATH11K_VDEV_SETUP_TIMEOUT_HZ))
0902         return -ETIMEDOUT;
0903 
0904     return ar->last_wmi_vdev_start_status ? -EINVAL : 0;
0905 }
0906 
0907 static void
0908 ath11k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
0909                 struct ieee80211_chanctx_conf *conf,
0910                 void *data)
0911 {
0912     struct cfg80211_chan_def **def = data;
0913 
0914     *def = &conf->def;
0915 }
0916 
0917 static int ath11k_mac_monitor_vdev_start(struct ath11k *ar, int vdev_id,
0918                      struct cfg80211_chan_def *chandef)
0919 {
0920     struct ieee80211_channel *channel;
0921     struct wmi_vdev_start_req_arg arg = {};
0922     int ret;
0923 
0924     lockdep_assert_held(&ar->conf_mutex);
0925 
0926     channel = chandef->chan;
0927 
0928     arg.vdev_id = vdev_id;
0929     arg.channel.freq = channel->center_freq;
0930     arg.channel.band_center_freq1 = chandef->center_freq1;
0931     arg.channel.band_center_freq2 = chandef->center_freq2;
0932 
0933     arg.channel.mode = ath11k_phymodes[chandef->chan->band][chandef->width];
0934     arg.channel.chan_radar = !!(channel->flags & IEEE80211_CHAN_RADAR);
0935 
0936     arg.channel.min_power = 0;
0937     arg.channel.max_power = channel->max_power;
0938     arg.channel.max_reg_power = channel->max_reg_power;
0939     arg.channel.max_antenna_gain = channel->max_antenna_gain;
0940 
0941     arg.pref_tx_streams = ar->num_tx_chains;
0942     arg.pref_rx_streams = ar->num_rx_chains;
0943 
0944     arg.channel.passive = !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
0945 
0946     reinit_completion(&ar->vdev_setup_done);
0947     reinit_completion(&ar->vdev_delete_done);
0948 
0949     ret = ath11k_wmi_vdev_start(ar, &arg, false);
0950     if (ret) {
0951         ath11k_warn(ar->ab, "failed to request monitor vdev %i start: %d\n",
0952                 vdev_id, ret);
0953         return ret;
0954     }
0955 
0956     ret = ath11k_mac_vdev_setup_sync(ar);
0957     if (ret) {
0958         ath11k_warn(ar->ab, "failed to synchronize setup for monitor vdev %i start: %d\n",
0959                 vdev_id, ret);
0960         return ret;
0961     }
0962 
0963     ret = ath11k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
0964     if (ret) {
0965         ath11k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n",
0966                 vdev_id, ret);
0967         goto vdev_stop;
0968     }
0969 
0970     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %i started\n",
0971            vdev_id);
0972 
0973     return 0;
0974 
0975 vdev_stop:
0976     reinit_completion(&ar->vdev_setup_done);
0977 
0978     ret = ath11k_wmi_vdev_stop(ar, vdev_id);
0979     if (ret) {
0980         ath11k_warn(ar->ab, "failed to stop monitor vdev %i after start failure: %d\n",
0981                 vdev_id, ret);
0982         return ret;
0983     }
0984 
0985     ret = ath11k_mac_vdev_setup_sync(ar);
0986     if (ret) {
0987         ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i stop: %d\n",
0988                 vdev_id, ret);
0989         return ret;
0990     }
0991 
0992     return -EIO;
0993 }
0994 
0995 static int ath11k_mac_monitor_vdev_stop(struct ath11k *ar)
0996 {
0997     int ret;
0998 
0999     lockdep_assert_held(&ar->conf_mutex);
1000 
1001     reinit_completion(&ar->vdev_setup_done);
1002 
1003     ret = ath11k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1004     if (ret) {
1005         ath11k_warn(ar->ab, "failed to request monitor vdev %i stop: %d\n",
1006                 ar->monitor_vdev_id, ret);
1007         return ret;
1008     }
1009 
1010     ret = ath11k_mac_vdev_setup_sync(ar);
1011     if (ret) {
1012         ath11k_warn(ar->ab, "failed to synchronize monitor vdev %i stop: %d\n",
1013                 ar->monitor_vdev_id, ret);
1014         return ret;
1015     }
1016 
1017     ret = ath11k_wmi_vdev_down(ar, ar->monitor_vdev_id);
1018     if (ret) {
1019         ath11k_warn(ar->ab, "failed to put down monitor vdev %i: %d\n",
1020                 ar->monitor_vdev_id, ret);
1021         return ret;
1022     }
1023 
1024     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %i stopped\n",
1025            ar->monitor_vdev_id);
1026 
1027     return 0;
1028 }
1029 
1030 static int ath11k_mac_monitor_vdev_create(struct ath11k *ar)
1031 {
1032     struct ath11k_pdev *pdev = ar->pdev;
1033     struct vdev_create_params param = {};
1034     int bit, ret;
1035     u8 tmp_addr[6] = {0};
1036     u16 nss;
1037 
1038     lockdep_assert_held(&ar->conf_mutex);
1039 
1040     if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
1041         return 0;
1042 
1043     if (ar->ab->free_vdev_map == 0) {
1044         ath11k_warn(ar->ab, "failed to find free vdev id for monitor vdev\n");
1045         return -ENOMEM;
1046     }
1047 
1048     bit = __ffs64(ar->ab->free_vdev_map);
1049 
1050     ar->monitor_vdev_id = bit;
1051 
1052     param.if_id = ar->monitor_vdev_id;
1053     param.type = WMI_VDEV_TYPE_MONITOR;
1054     param.subtype = WMI_VDEV_SUBTYPE_NONE;
1055     param.pdev_id = pdev->pdev_id;
1056 
1057     if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
1058         param.chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
1059         param.chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
1060     }
1061     if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
1062         param.chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
1063         param.chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
1064     }
1065 
1066     ret = ath11k_wmi_vdev_create(ar, tmp_addr, &param);
1067     if (ret) {
1068         ath11k_warn(ar->ab, "failed to request monitor vdev %i creation: %d\n",
1069                 ar->monitor_vdev_id, ret);
1070         ar->monitor_vdev_id = -1;
1071         return ret;
1072     }
1073 
1074     nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
1075     ret = ath11k_wmi_vdev_set_param_cmd(ar, ar->monitor_vdev_id,
1076                         WMI_VDEV_PARAM_NSS, nss);
1077     if (ret) {
1078         ath11k_warn(ar->ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
1079                 ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret);
1080         goto err_vdev_del;
1081     }
1082 
1083     ret = ath11k_mac_txpower_recalc(ar);
1084     if (ret) {
1085         ath11k_warn(ar->ab, "failed to recalc txpower for monitor vdev %d: %d\n",
1086                 ar->monitor_vdev_id, ret);
1087         goto err_vdev_del;
1088     }
1089 
1090     ar->allocated_vdev_map |= 1LL << ar->monitor_vdev_id;
1091     ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1092     ar->num_created_vdevs++;
1093     set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
1094 
1095     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %d created\n",
1096            ar->monitor_vdev_id);
1097 
1098     return 0;
1099 
1100 err_vdev_del:
1101     ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1102     ar->monitor_vdev_id = -1;
1103     return ret;
1104 }
1105 
1106 static int ath11k_mac_monitor_vdev_delete(struct ath11k *ar)
1107 {
1108     int ret;
1109     unsigned long time_left;
1110 
1111     lockdep_assert_held(&ar->conf_mutex);
1112 
1113     if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
1114         return 0;
1115 
1116     reinit_completion(&ar->vdev_delete_done);
1117 
1118     ret = ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1119     if (ret) {
1120         ath11k_warn(ar->ab, "failed to request wmi monitor vdev %i removal: %d\n",
1121                 ar->monitor_vdev_id, ret);
1122         return ret;
1123     }
1124 
1125     time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
1126                         ATH11K_VDEV_DELETE_TIMEOUT_HZ);
1127     if (time_left == 0) {
1128         ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
1129     } else {
1130         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %d deleted\n",
1131                ar->monitor_vdev_id);
1132 
1133         ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1134         ar->ab->free_vdev_map |= 1LL << (ar->monitor_vdev_id);
1135         ar->num_created_vdevs--;
1136         ar->monitor_vdev_id = -1;
1137         clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
1138     }
1139 
1140     return ret;
1141 }
1142 
1143 static int ath11k_mac_monitor_start(struct ath11k *ar)
1144 {
1145     struct cfg80211_chan_def *chandef = NULL;
1146     int ret;
1147 
1148     lockdep_assert_held(&ar->conf_mutex);
1149 
1150     if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
1151         return 0;
1152 
1153     ieee80211_iter_chan_contexts_atomic(ar->hw,
1154                         ath11k_mac_get_any_chandef_iter,
1155                         &chandef);
1156     if (!chandef)
1157         return 0;
1158 
1159     ret = ath11k_mac_monitor_vdev_start(ar, ar->monitor_vdev_id, chandef);
1160     if (ret) {
1161         ath11k_warn(ar->ab, "failed to start monitor vdev: %d\n", ret);
1162         ath11k_mac_monitor_vdev_delete(ar);
1163         return ret;
1164     }
1165 
1166     set_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
1167 
1168     ar->num_started_vdevs++;
1169     ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, false);
1170     if (ret) {
1171         ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during start: %d",
1172                 ret);
1173         return ret;
1174     }
1175 
1176     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor started\n");
1177 
1178     return 0;
1179 }
1180 
1181 static int ath11k_mac_monitor_stop(struct ath11k *ar)
1182 {
1183     int ret;
1184 
1185     lockdep_assert_held(&ar->conf_mutex);
1186 
1187     if (!test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
1188         return 0;
1189 
1190     ret = ath11k_mac_monitor_vdev_stop(ar);
1191     if (ret) {
1192         ath11k_warn(ar->ab, "failed to stop monitor vdev: %d\n", ret);
1193         return ret;
1194     }
1195 
1196     clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
1197     ar->num_started_vdevs--;
1198 
1199     ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, true);
1200     if (ret) {
1201         ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during stop: %d",
1202                 ret);
1203         return ret;
1204     }
1205 
1206     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor stopped ret %d\n", ret);
1207 
1208     return 0;
1209 }
1210 
1211 static int ath11k_mac_vif_setup_ps(struct ath11k_vif *arvif)
1212 {
1213     struct ath11k *ar = arvif->ar;
1214     struct ieee80211_vif *vif = arvif->vif;
1215     struct ieee80211_conf *conf = &ar->hw->conf;
1216     enum wmi_sta_powersave_param param;
1217     enum wmi_sta_ps_mode psmode;
1218     int ret;
1219     int timeout;
1220     bool enable_ps;
1221 
1222     lockdep_assert_held(&arvif->ar->conf_mutex);
1223 
1224     if (arvif->vif->type != NL80211_IFTYPE_STATION)
1225         return 0;
1226 
1227     enable_ps = arvif->ps;
1228 
1229     if (!arvif->is_started) {
1230         /* mac80211 can update vif powersave state while disconnected.
1231          * Firmware doesn't behave nicely and consumes more power than
1232          * necessary if PS is disabled on a non-started vdev. Hence
1233          * force-enable PS for non-running vdevs.
1234          */
1235         psmode = WMI_STA_PS_MODE_ENABLED;
1236     } else if (enable_ps) {
1237         psmode = WMI_STA_PS_MODE_ENABLED;
1238         param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1239 
1240         timeout = conf->dynamic_ps_timeout;
1241         if (timeout == 0) {
1242             /* firmware doesn't like 0 */
1243             timeout = ieee80211_tu_to_usec(vif->bss_conf.beacon_int) / 1000;
1244         }
1245 
1246         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1247                           timeout);
1248         if (ret) {
1249             ath11k_warn(ar->ab, "failed to set inactivity time for vdev %d: %i\n",
1250                     arvif->vdev_id, ret);
1251             return ret;
1252         }
1253     } else {
1254         psmode = WMI_STA_PS_MODE_DISABLED;
1255     }
1256 
1257     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d psmode %s\n",
1258            arvif->vdev_id, psmode ? "enable" : "disable");
1259 
1260     ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, psmode);
1261     if (ret) {
1262         ath11k_warn(ar->ab, "failed to set sta power save mode %d for vdev %d: %d\n",
1263                 psmode, arvif->vdev_id, ret);
1264         return ret;
1265     }
1266 
1267     return 0;
1268 }
1269 
1270 static int ath11k_mac_config_ps(struct ath11k *ar)
1271 {
1272     struct ath11k_vif *arvif;
1273     int ret = 0;
1274 
1275     lockdep_assert_held(&ar->conf_mutex);
1276 
1277     list_for_each_entry(arvif, &ar->arvifs, list) {
1278         ret = ath11k_mac_vif_setup_ps(arvif);
1279         if (ret) {
1280             ath11k_warn(ar->ab, "failed to setup powersave: %d\n", ret);
1281             break;
1282         }
1283     }
1284 
1285     return ret;
1286 }
1287 
1288 static int ath11k_mac_op_config(struct ieee80211_hw *hw, u32 changed)
1289 {
1290     struct ath11k *ar = hw->priv;
1291     struct ieee80211_conf *conf = &hw->conf;
1292     int ret = 0;
1293 
1294     mutex_lock(&ar->conf_mutex);
1295 
1296     if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1297         if (conf->flags & IEEE80211_CONF_MONITOR) {
1298             set_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);
1299 
1300             if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
1301                      &ar->monitor_flags))
1302                 goto out;
1303 
1304             ret = ath11k_mac_monitor_vdev_create(ar);
1305             if (ret) {
1306                 ath11k_warn(ar->ab, "failed to create monitor vdev: %d",
1307                         ret);
1308                 goto out;
1309             }
1310 
1311             ret = ath11k_mac_monitor_start(ar);
1312             if (ret) {
1313                 ath11k_warn(ar->ab, "failed to start monitor: %d",
1314                         ret);
1315                 goto err_mon_del;
1316             }
1317         } else {
1318             clear_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);
1319 
1320             if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
1321                       &ar->monitor_flags))
1322                 goto out;
1323 
1324             ret = ath11k_mac_monitor_stop(ar);
1325             if (ret) {
1326                 ath11k_warn(ar->ab, "failed to stop monitor: %d",
1327                         ret);
1328                 goto out;
1329             }
1330 
1331             ret = ath11k_mac_monitor_vdev_delete(ar);
1332             if (ret) {
1333                 ath11k_warn(ar->ab, "failed to delete monitor vdev: %d",
1334                         ret);
1335                 goto out;
1336             }
1337         }
1338     }
1339 
1340 out:
1341     mutex_unlock(&ar->conf_mutex);
1342     return ret;
1343 
1344 err_mon_del:
1345     ath11k_mac_monitor_vdev_delete(ar);
1346     mutex_unlock(&ar->conf_mutex);
1347     return ret;
1348 }
1349 
1350 static int ath11k_mac_setup_bcn_tmpl(struct ath11k_vif *arvif)
1351 {
1352     struct ath11k *ar = arvif->ar;
1353     struct ath11k_base *ab = ar->ab;
1354     struct ieee80211_hw *hw = ar->hw;
1355     struct ieee80211_vif *vif = arvif->vif;
1356     struct ieee80211_mutable_offsets offs = {};
1357     struct sk_buff *bcn;
1358     struct ieee80211_mgmt *mgmt;
1359     u8 *ies;
1360     int ret;
1361 
1362     if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1363         return 0;
1364 
1365     bcn = ieee80211_beacon_get_template(hw, vif, &offs, 0);
1366     if (!bcn) {
1367         ath11k_warn(ab, "failed to get beacon template from mac80211\n");
1368         return -EPERM;
1369     }
1370 
1371     ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
1372     ies += sizeof(mgmt->u.beacon);
1373 
1374     if (cfg80211_find_ie(WLAN_EID_RSN, ies, (skb_tail_pointer(bcn) - ies)))
1375         arvif->rsnie_present = true;
1376     else
1377         arvif->rsnie_present = false;
1378 
1379     if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1380                     WLAN_OUI_TYPE_MICROSOFT_WPA,
1381                     ies, (skb_tail_pointer(bcn) - ies)))
1382         arvif->wpaie_present = true;
1383     else
1384         arvif->wpaie_present = false;
1385 
1386     ret = ath11k_wmi_bcn_tmpl(ar, arvif->vdev_id, &offs, bcn);
1387 
1388     kfree_skb(bcn);
1389 
1390     if (ret)
1391         ath11k_warn(ab, "failed to submit beacon template command: %d\n",
1392                 ret);
1393 
1394     return ret;
1395 }
1396 
1397 void ath11k_mac_bcn_tx_event(struct ath11k_vif *arvif)
1398 {
1399     struct ieee80211_vif *vif = arvif->vif;
1400 
1401     if (!vif->bss_conf.color_change_active && !arvif->bcca_zero_sent)
1402         return;
1403 
1404     if (vif->bss_conf.color_change_active &&
1405         ieee80211_beacon_cntdwn_is_complete(vif)) {
1406         arvif->bcca_zero_sent = true;
1407         ieee80211_color_change_finish(vif);
1408         return;
1409     }
1410 
1411     arvif->bcca_zero_sent = false;
1412 
1413     if (vif->bss_conf.color_change_active)
1414         ieee80211_beacon_update_cntdwn(vif);
1415     ath11k_mac_setup_bcn_tmpl(arvif);
1416 }
1417 
1418 static void ath11k_control_beaconing(struct ath11k_vif *arvif,
1419                      struct ieee80211_bss_conf *info)
1420 {
1421     struct ath11k *ar = arvif->ar;
1422     int ret = 0;
1423 
1424     lockdep_assert_held(&arvif->ar->conf_mutex);
1425 
1426     if (!info->enable_beacon) {
1427         ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
1428         if (ret)
1429             ath11k_warn(ar->ab, "failed to down vdev_id %i: %d\n",
1430                     arvif->vdev_id, ret);
1431 
1432         arvif->is_up = false;
1433         return;
1434     }
1435 
1436     /* Install the beacon template to the FW */
1437     ret = ath11k_mac_setup_bcn_tmpl(arvif);
1438     if (ret) {
1439         ath11k_warn(ar->ab, "failed to update bcn tmpl during vdev up: %d\n",
1440                 ret);
1441         return;
1442     }
1443 
1444     arvif->tx_seq_no = 0x1000;
1445 
1446     arvif->aid = 0;
1447 
1448     ether_addr_copy(arvif->bssid, info->bssid);
1449 
1450     ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1451                  arvif->bssid);
1452     if (ret) {
1453         ath11k_warn(ar->ab, "failed to bring up vdev %d: %i\n",
1454                 arvif->vdev_id, ret);
1455         return;
1456     }
1457 
1458     arvif->is_up = true;
1459 
1460     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1461 }
1462 
1463 static void ath11k_mac_handle_beacon_iter(void *data, u8 *mac,
1464                       struct ieee80211_vif *vif)
1465 {
1466     struct sk_buff *skb = data;
1467     struct ieee80211_mgmt *mgmt = (void *)skb->data;
1468     struct ath11k_vif *arvif = (void *)vif->drv_priv;
1469 
1470     if (vif->type != NL80211_IFTYPE_STATION)
1471         return;
1472 
1473     if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1474         return;
1475 
1476     cancel_delayed_work(&arvif->connection_loss_work);
1477 }
1478 
1479 void ath11k_mac_handle_beacon(struct ath11k *ar, struct sk_buff *skb)
1480 {
1481     ieee80211_iterate_active_interfaces_atomic(ar->hw,
1482                            IEEE80211_IFACE_ITER_NORMAL,
1483                            ath11k_mac_handle_beacon_iter,
1484                            skb);
1485 }
1486 
1487 static void ath11k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1488                            struct ieee80211_vif *vif)
1489 {
1490     u32 *vdev_id = data;
1491     struct ath11k_vif *arvif = (void *)vif->drv_priv;
1492     struct ath11k *ar = arvif->ar;
1493     struct ieee80211_hw *hw = ar->hw;
1494 
1495     if (arvif->vdev_id != *vdev_id)
1496         return;
1497 
1498     if (!arvif->is_up)
1499         return;
1500 
1501     ieee80211_beacon_loss(vif);
1502 
1503     /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1504      * (done by mac80211) succeeds but beacons do not resume then it
1505      * doesn't make sense to continue operation. Queue connection loss work
1506      * which can be cancelled when beacon is received.
1507      */
1508     ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1509                      ATH11K_CONNECTION_LOSS_HZ);
1510 }
1511 
1512 void ath11k_mac_handle_beacon_miss(struct ath11k *ar, u32 vdev_id)
1513 {
1514     ieee80211_iterate_active_interfaces_atomic(ar->hw,
1515                            IEEE80211_IFACE_ITER_NORMAL,
1516                            ath11k_mac_handle_beacon_miss_iter,
1517                            &vdev_id);
1518 }
1519 
1520 static void ath11k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1521 {
1522     struct ath11k_vif *arvif = container_of(work, struct ath11k_vif,
1523                         connection_loss_work.work);
1524     struct ieee80211_vif *vif = arvif->vif;
1525 
1526     if (!arvif->is_up)
1527         return;
1528 
1529     ieee80211_connection_loss(vif);
1530 }
1531 
1532 static void ath11k_peer_assoc_h_basic(struct ath11k *ar,
1533                       struct ieee80211_vif *vif,
1534                       struct ieee80211_sta *sta,
1535                       struct peer_assoc_params *arg)
1536 {
1537     struct ath11k_vif *arvif = (void *)vif->drv_priv;
1538     u32 aid;
1539 
1540     lockdep_assert_held(&ar->conf_mutex);
1541 
1542     if (vif->type == NL80211_IFTYPE_STATION)
1543         aid = vif->cfg.aid;
1544     else
1545         aid = sta->aid;
1546 
1547     ether_addr_copy(arg->peer_mac, sta->addr);
1548     arg->vdev_id = arvif->vdev_id;
1549     arg->peer_associd = aid;
1550     arg->auth_flag = true;
1551     /* TODO: STA WAR in ath10k for listen interval required? */
1552     arg->peer_listen_intval = ar->hw->conf.listen_interval;
1553     arg->peer_nss = 1;
1554     arg->peer_caps = vif->bss_conf.assoc_capability;
1555 }
1556 
1557 static void ath11k_peer_assoc_h_crypto(struct ath11k *ar,
1558                        struct ieee80211_vif *vif,
1559                        struct ieee80211_sta *sta,
1560                        struct peer_assoc_params *arg)
1561 {
1562     struct ieee80211_bss_conf *info = &vif->bss_conf;
1563     struct cfg80211_chan_def def;
1564     struct cfg80211_bss *bss;
1565     struct ath11k_vif *arvif = (struct ath11k_vif *)vif->drv_priv;
1566     const u8 *rsnie = NULL;
1567     const u8 *wpaie = NULL;
1568 
1569     lockdep_assert_held(&ar->conf_mutex);
1570 
1571     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1572         return;
1573 
1574     bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1575                    IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1576 
1577     if (arvif->rsnie_present || arvif->wpaie_present) {
1578         arg->need_ptk_4_way = true;
1579         if (arvif->wpaie_present)
1580             arg->need_gtk_2_way = true;
1581     } else if (bss) {
1582         const struct cfg80211_bss_ies *ies;
1583 
1584         rcu_read_lock();
1585         rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1586 
1587         ies = rcu_dereference(bss->ies);
1588 
1589         wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1590                         WLAN_OUI_TYPE_MICROSOFT_WPA,
1591                         ies->data,
1592                         ies->len);
1593         rcu_read_unlock();
1594         cfg80211_put_bss(ar->hw->wiphy, bss);
1595     }
1596 
1597     /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1598     if (rsnie || wpaie) {
1599         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1600                "%s: rsn ie found\n", __func__);
1601         arg->need_ptk_4_way = true;
1602     }
1603 
1604     if (wpaie) {
1605         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1606                "%s: wpa ie found\n", __func__);
1607         arg->need_gtk_2_way = true;
1608     }
1609 
1610     if (sta->mfp) {
1611         /* TODO: Need to check if FW supports PMF? */
1612         arg->is_pmf_enabled = true;
1613     }
1614 
1615     /* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */
1616 }
1617 
1618 static void ath11k_peer_assoc_h_rates(struct ath11k *ar,
1619                       struct ieee80211_vif *vif,
1620                       struct ieee80211_sta *sta,
1621                       struct peer_assoc_params *arg)
1622 {
1623     struct ath11k_vif *arvif = (void *)vif->drv_priv;
1624     struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1625     struct cfg80211_chan_def def;
1626     const struct ieee80211_supported_band *sband;
1627     const struct ieee80211_rate *rates;
1628     enum nl80211_band band;
1629     u32 ratemask;
1630     u8 rate;
1631     int i;
1632 
1633     lockdep_assert_held(&ar->conf_mutex);
1634 
1635     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1636         return;
1637 
1638     band = def.chan->band;
1639     sband = ar->hw->wiphy->bands[band];
1640     ratemask = sta->deflink.supp_rates[band];
1641     ratemask &= arvif->bitrate_mask.control[band].legacy;
1642     rates = sband->bitrates;
1643 
1644     rateset->num_rates = 0;
1645 
1646     for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1647         if (!(ratemask & 1))
1648             continue;
1649 
1650         rate = ath11k_mac_bitrate_to_rate(rates->bitrate);
1651         rateset->rates[rateset->num_rates] = rate;
1652         rateset->num_rates++;
1653     }
1654 }
1655 
1656 static bool
1657 ath11k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
1658 {
1659     int nss;
1660 
1661     for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
1662         if (ht_mcs_mask[nss])
1663             return false;
1664 
1665     return true;
1666 }
1667 
1668 static bool
1669 ath11k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[])
1670 {
1671     int nss;
1672 
1673     for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
1674         if (vht_mcs_mask[nss])
1675             return false;
1676 
1677     return true;
1678 }
1679 
1680 static void ath11k_peer_assoc_h_ht(struct ath11k *ar,
1681                    struct ieee80211_vif *vif,
1682                    struct ieee80211_sta *sta,
1683                    struct peer_assoc_params *arg)
1684 {
1685     const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
1686     struct ath11k_vif *arvif = (void *)vif->drv_priv;
1687     struct cfg80211_chan_def def;
1688     enum nl80211_band band;
1689     const u8 *ht_mcs_mask;
1690     int i, n;
1691     u8 max_nss;
1692     u32 stbc;
1693 
1694     lockdep_assert_held(&ar->conf_mutex);
1695 
1696     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1697         return;
1698 
1699     if (!ht_cap->ht_supported)
1700         return;
1701 
1702     band = def.chan->band;
1703     ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
1704 
1705     if (ath11k_peer_assoc_h_ht_masked(ht_mcs_mask))
1706         return;
1707 
1708     arg->ht_flag = true;
1709 
1710     arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1711                     ht_cap->ampdu_factor)) - 1;
1712 
1713     arg->peer_mpdu_density =
1714         ath11k_parse_mpdudensity(ht_cap->ampdu_density);
1715 
1716     arg->peer_ht_caps = ht_cap->cap;
1717     arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG;
1718 
1719     if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1720         arg->ldpc_flag = true;
1721 
1722     if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {
1723         arg->bw_40 = true;
1724         arg->peer_rate_caps |= WMI_HOST_RC_CW40_FLAG;
1725     }
1726 
1727     /* As firmware handles this two flags (IEEE80211_HT_CAP_SGI_20
1728      * and IEEE80211_HT_CAP_SGI_40) for enabling SGI, we reset
1729      * both flags if guard interval is Default GI
1730      */
1731     if (arvif->bitrate_mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI)
1732         arg->peer_ht_caps &= ~(IEEE80211_HT_CAP_SGI_20 |
1733                 IEEE80211_HT_CAP_SGI_40);
1734 
1735     if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
1736         if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 |
1737             IEEE80211_HT_CAP_SGI_40))
1738             arg->peer_rate_caps |= WMI_HOST_RC_SGI_FLAG;
1739     }
1740 
1741     if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1742         arg->peer_rate_caps |= WMI_HOST_RC_TX_STBC_FLAG;
1743         arg->stbc_flag = true;
1744     }
1745 
1746     if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1747         stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1748         stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1749         stbc = stbc << WMI_HOST_RC_RX_STBC_FLAG_S;
1750         arg->peer_rate_caps |= stbc;
1751         arg->stbc_flag = true;
1752     }
1753 
1754     if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1755         arg->peer_rate_caps |= WMI_HOST_RC_TS_FLAG;
1756     else if (ht_cap->mcs.rx_mask[1])
1757         arg->peer_rate_caps |= WMI_HOST_RC_DS_FLAG;
1758 
1759     for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
1760         if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
1761             (ht_mcs_mask[i / 8] & BIT(i % 8))) {
1762             max_nss = (i / 8) + 1;
1763             arg->peer_ht_rates.rates[n++] = i;
1764         }
1765 
1766     /* This is a workaround for HT-enabled STAs which break the spec
1767      * and have no HT capabilities RX mask (no HT RX MCS map).
1768      *
1769      * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1770      * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1771      *
1772      * Firmware asserts if such situation occurs.
1773      */
1774     if (n == 0) {
1775         arg->peer_ht_rates.num_rates = 8;
1776         for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1777             arg->peer_ht_rates.rates[i] = i;
1778     } else {
1779         arg->peer_ht_rates.num_rates = n;
1780         arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1781     }
1782 
1783     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1784            arg->peer_mac,
1785            arg->peer_ht_rates.num_rates,
1786            arg->peer_nss);
1787 }
1788 
1789 static int ath11k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
1790 {
1791     switch ((mcs_map >> (2 * nss)) & 0x3) {
1792     case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
1793     case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
1794     case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
1795     }
1796     return 0;
1797 }
1798 
1799 static u16
1800 ath11k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
1801                   const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
1802 {
1803     int idx_limit;
1804     int nss;
1805     u16 mcs_map;
1806     u16 mcs;
1807 
1808     for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
1809         mcs_map = ath11k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
1810               vht_mcs_limit[nss];
1811 
1812         if (mcs_map)
1813             idx_limit = fls(mcs_map) - 1;
1814         else
1815             idx_limit = -1;
1816 
1817         switch (idx_limit) {
1818         case 0:
1819         case 1:
1820         case 2:
1821         case 3:
1822         case 4:
1823         case 5:
1824         case 6:
1825         case 7:
1826             mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
1827             break;
1828         case 8:
1829             mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
1830             break;
1831         case 9:
1832             mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
1833             break;
1834         default:
1835             WARN_ON(1);
1836             fallthrough;
1837         case -1:
1838             mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
1839             break;
1840         }
1841 
1842         tx_mcs_set &= ~(0x3 << (nss * 2));
1843         tx_mcs_set |= mcs << (nss * 2);
1844     }
1845 
1846     return tx_mcs_set;
1847 }
1848 
1849 static u8 ath11k_get_nss_160mhz(struct ath11k *ar,
1850                 u8 max_nss)
1851 {
1852     u8 nss_ratio_info = ar->pdev->cap.nss_ratio_info;
1853     u8 max_sup_nss = 0;
1854 
1855     switch (nss_ratio_info) {
1856     case WMI_NSS_RATIO_1BY2_NSS:
1857         max_sup_nss = max_nss >> 1;
1858         break;
1859     case WMI_NSS_RATIO_3BY4_NSS:
1860         ath11k_warn(ar->ab, "WMI_NSS_RATIO_3BY4_NSS not supported\n");
1861         break;
1862     case WMI_NSS_RATIO_1_NSS:
1863         max_sup_nss = max_nss;
1864         break;
1865     case WMI_NSS_RATIO_2_NSS:
1866         ath11k_warn(ar->ab, "WMI_NSS_RATIO_2_NSS not supported\n");
1867         break;
1868     default:
1869         ath11k_warn(ar->ab, "invalid nss ratio received from firmware: %d\n",
1870                 nss_ratio_info);
1871         break;
1872     }
1873 
1874     return max_sup_nss;
1875 }
1876 
1877 static void ath11k_peer_assoc_h_vht(struct ath11k *ar,
1878                     struct ieee80211_vif *vif,
1879                     struct ieee80211_sta *sta,
1880                     struct peer_assoc_params *arg)
1881 {
1882     const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
1883     struct ath11k_vif *arvif = (void *)vif->drv_priv;
1884     struct cfg80211_chan_def def;
1885     enum nl80211_band band;
1886     u16 *vht_mcs_mask;
1887     u8 ampdu_factor;
1888     u8 max_nss, vht_mcs;
1889     int i, vht_nss, nss_idx;
1890     bool user_rate_valid = true;
1891     u32 rx_nss, tx_nss, nss_160;
1892 
1893     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1894         return;
1895 
1896     if (!vht_cap->vht_supported)
1897         return;
1898 
1899     band = def.chan->band;
1900     vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
1901 
1902     if (ath11k_peer_assoc_h_vht_masked(vht_mcs_mask))
1903         return;
1904 
1905     arg->vht_flag = true;
1906 
1907     /* TODO: similar flags required? */
1908     arg->vht_capable = true;
1909 
1910     if (def.chan->band == NL80211_BAND_2GHZ)
1911         arg->vht_ng_flag = true;
1912 
1913     arg->peer_vht_caps = vht_cap->cap;
1914 
1915     ampdu_factor = (vht_cap->cap &
1916             IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1917                IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1918 
1919     /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1920      * zero in VHT IE. Using it would result in degraded throughput.
1921      * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1922      * it if VHT max_mpdu is smaller.
1923      */
1924     arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1925                  (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1926                     ampdu_factor)) - 1);
1927 
1928     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
1929         arg->bw_80 = true;
1930 
1931     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
1932         arg->bw_160 = true;
1933 
1934     vht_nss =  ath11k_mac_max_vht_nss(vht_mcs_mask);
1935 
1936     if (vht_nss > sta->deflink.rx_nss) {
1937         user_rate_valid = false;
1938         for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
1939             if (vht_mcs_mask[nss_idx]) {
1940                 user_rate_valid = true;
1941                 break;
1942             }
1943         }
1944     }
1945 
1946     if (!user_rate_valid) {
1947         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting vht range mcs value to peer supported nss %d for peer %pM\n",
1948                sta->deflink.rx_nss, sta->addr);
1949         vht_mcs_mask[sta->deflink.rx_nss - 1] = vht_mcs_mask[vht_nss - 1];
1950     }
1951 
1952     /* Calculate peer NSS capability from VHT capabilities if STA
1953      * supports VHT.
1954      */
1955     for (i = 0, max_nss = 0; i < NL80211_VHT_NSS_MAX; i++) {
1956         vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
1957               (2 * i) & 3;
1958 
1959         if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED &&
1960             vht_mcs_mask[i])
1961             max_nss = i + 1;
1962     }
1963     arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1964     arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1965     arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1966     arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1967     arg->tx_mcs_set = ath11k_peer_assoc_h_vht_limit(
1968         __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
1969 
1970     /* In IPQ8074 platform, VHT mcs rate 10 and 11 is enabled by default.
1971      * VHT mcs rate 10 and 11 is not suppoerted in 11ac standard.
1972      * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode.
1973      */
1974     arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK;
1975     arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11;
1976 
1977     if ((arg->tx_mcs_set & IEEE80211_VHT_MCS_NOT_SUPPORTED) ==
1978             IEEE80211_VHT_MCS_NOT_SUPPORTED)
1979         arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
1980 
1981     /* TODO:  Check */
1982     arg->tx_max_mcs_nss = 0xFF;
1983 
1984     if (arg->peer_phymode == MODE_11AC_VHT160 ||
1985         arg->peer_phymode == MODE_11AC_VHT80_80) {
1986         tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
1987         rx_nss = min(arg->peer_nss, tx_nss);
1988         arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
1989 
1990         if (!rx_nss) {
1991             ath11k_warn(ar->ab, "invalid max_nss\n");
1992             return;
1993         }
1994 
1995         if (arg->peer_phymode == MODE_11AC_VHT160)
1996             nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
1997         else
1998             nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
1999 
2000         arg->peer_bw_rxnss_override |= nss_160;
2001     }
2002 
2003     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2004            "mac vht peer %pM max_mpdu %d flags 0x%x nss_override 0x%x\n",
2005            sta->addr, arg->peer_max_mpdu, arg->peer_flags,
2006            arg->peer_bw_rxnss_override);
2007 }
2008 
2009 static int ath11k_mac_get_max_he_mcs_map(u16 mcs_map, int nss)
2010 {
2011     switch ((mcs_map >> (2 * nss)) & 0x3) {
2012     case IEEE80211_HE_MCS_SUPPORT_0_7: return BIT(8) - 1;
2013     case IEEE80211_HE_MCS_SUPPORT_0_9: return BIT(10) - 1;
2014     case IEEE80211_HE_MCS_SUPPORT_0_11: return BIT(12) - 1;
2015     }
2016     return 0;
2017 }
2018 
2019 static u16 ath11k_peer_assoc_h_he_limit(u16 tx_mcs_set,
2020                     const u16 he_mcs_limit[NL80211_HE_NSS_MAX])
2021 {
2022     int idx_limit;
2023     int nss;
2024     u16 mcs_map;
2025     u16 mcs;
2026 
2027     for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) {
2028         mcs_map = ath11k_mac_get_max_he_mcs_map(tx_mcs_set, nss) &
2029             he_mcs_limit[nss];
2030 
2031         if (mcs_map)
2032             idx_limit = fls(mcs_map) - 1;
2033         else
2034             idx_limit = -1;
2035 
2036         switch (idx_limit) {
2037         case 0 ... 7:
2038             mcs = IEEE80211_HE_MCS_SUPPORT_0_7;
2039             break;
2040         case 8:
2041         case 9:
2042             mcs = IEEE80211_HE_MCS_SUPPORT_0_9;
2043             break;
2044         case 10:
2045         case 11:
2046             mcs = IEEE80211_HE_MCS_SUPPORT_0_11;
2047             break;
2048         default:
2049             WARN_ON(1);
2050             fallthrough;
2051         case -1:
2052             mcs = IEEE80211_HE_MCS_NOT_SUPPORTED;
2053             break;
2054         }
2055 
2056         tx_mcs_set &= ~(0x3 << (nss * 2));
2057         tx_mcs_set |= mcs << (nss * 2);
2058     }
2059 
2060     return tx_mcs_set;
2061 }
2062 
2063 static bool
2064 ath11k_peer_assoc_h_he_masked(const u16 he_mcs_mask[NL80211_HE_NSS_MAX])
2065 {
2066     int nss;
2067 
2068     for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++)
2069         if (he_mcs_mask[nss])
2070             return false;
2071 
2072     return true;
2073 }
2074 
2075 static void ath11k_peer_assoc_h_he(struct ath11k *ar,
2076                    struct ieee80211_vif *vif,
2077                    struct ieee80211_sta *sta,
2078                    struct peer_assoc_params *arg)
2079 {
2080     struct ath11k_vif *arvif = (void *)vif->drv_priv;
2081     struct cfg80211_chan_def def;
2082     const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2083     enum nl80211_band band;
2084     u16 *he_mcs_mask;
2085     u8 max_nss, he_mcs;
2086     u16 he_tx_mcs = 0, v = 0;
2087     int i, he_nss, nss_idx;
2088     bool user_rate_valid = true;
2089     u32 rx_nss, tx_nss, nss_160;
2090     u8 ampdu_factor, rx_mcs_80, rx_mcs_160;
2091     u16 mcs_160_map, mcs_80_map;
2092     bool support_160;
2093 
2094     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2095         return;
2096 
2097     if (!he_cap->has_he)
2098         return;
2099 
2100     band = def.chan->band;
2101     he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2102 
2103     if (ath11k_peer_assoc_h_he_masked(he_mcs_mask))
2104         return;
2105 
2106     arg->he_flag = true;
2107     support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] &
2108           IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G);
2109 
2110     /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */
2111     mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2112     mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2113 
2114     if (support_160) {
2115         for (i = 7; i >= 0; i--) {
2116             u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;
2117 
2118             if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2119                 rx_mcs_160 = i + 1;
2120                 break;
2121             }
2122         }
2123     }
2124 
2125     for (i = 7; i >= 0; i--) {
2126         u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;
2127 
2128         if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
2129             rx_mcs_80 = i + 1;
2130             break;
2131         }
2132     }
2133 
2134     if (support_160)
2135         max_nss = min(rx_mcs_80, rx_mcs_160);
2136     else
2137         max_nss = rx_mcs_80;
2138 
2139     arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2140 
2141     memcpy_and_pad(&arg->peer_he_cap_macinfo,
2142                sizeof(arg->peer_he_cap_macinfo),
2143                he_cap->he_cap_elem.mac_cap_info,
2144                sizeof(he_cap->he_cap_elem.mac_cap_info),
2145                0);
2146     memcpy_and_pad(&arg->peer_he_cap_phyinfo,
2147                sizeof(arg->peer_he_cap_phyinfo),
2148                he_cap->he_cap_elem.phy_cap_info,
2149                sizeof(he_cap->he_cap_elem.phy_cap_info),
2150                0);
2151     arg->peer_he_ops = vif->bss_conf.he_oper.params;
2152 
2153     /* the top most byte is used to indicate BSS color info */
2154     arg->peer_he_ops &= 0xffffff;
2155 
2156     /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension
2157      * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing
2158      * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present).
2159      *
2160      * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps,
2161      * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
2162      * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
2163      * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
2164      * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
2165      * length.
2166      */
2167     ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3],
2168                    IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK);
2169 
2170     if (ampdu_factor) {
2171         if (sta->deflink.vht_cap.vht_supported)
2172             arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
2173                             ampdu_factor)) - 1;
2174         else if (sta->deflink.ht_cap.ht_supported)
2175             arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
2176                             ampdu_factor)) - 1;
2177     }
2178 
2179     if (he_cap->he_cap_elem.phy_cap_info[6] &
2180         IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
2181         int bit = 7;
2182         int nss, ru;
2183 
2184         arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
2185                       IEEE80211_PPE_THRES_NSS_MASK;
2186         arg->peer_ppet.ru_bit_mask =
2187             (he_cap->ppe_thres[0] &
2188              IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
2189             IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
2190 
2191         for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
2192             for (ru = 0; ru < 4; ru++) {
2193                 u32 val = 0;
2194                 int i;
2195 
2196                 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
2197                     continue;
2198                 for (i = 0; i < 6; i++) {
2199                     val >>= 1;
2200                     val |= ((he_cap->ppe_thres[bit / 8] >>
2201                          (bit % 8)) & 0x1) << 5;
2202                     bit++;
2203                 }
2204                 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
2205                                 val << (ru * 6);
2206             }
2207         }
2208     }
2209 
2210     if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
2211         arg->twt_responder = true;
2212     if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
2213         arg->twt_requester = true;
2214 
2215     he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
2216 
2217     if (he_nss > sta->deflink.rx_nss) {
2218         user_rate_valid = false;
2219         for (nss_idx = sta->deflink.rx_nss - 1; nss_idx >= 0; nss_idx--) {
2220             if (he_mcs_mask[nss_idx]) {
2221                 user_rate_valid = true;
2222                 break;
2223             }
2224         }
2225     }
2226 
2227     if (!user_rate_valid) {
2228         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting he range mcs value to peer supported nss %d for peer %pM\n",
2229                sta->deflink.rx_nss, sta->addr);
2230         he_mcs_mask[sta->deflink.rx_nss - 1] = he_mcs_mask[he_nss - 1];
2231     }
2232 
2233     switch (sta->deflink.bandwidth) {
2234     case IEEE80211_STA_RX_BW_160:
2235         if (he_cap->he_cap_elem.phy_cap_info[0] &
2236             IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2237             v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
2238             v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2239             arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2240 
2241             v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
2242             arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
2243 
2244             arg->peer_he_mcs_count++;
2245             he_tx_mcs = v;
2246         }
2247         v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
2248         arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2249 
2250         v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
2251         v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2252         arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
2253 
2254         arg->peer_he_mcs_count++;
2255         if (!he_tx_mcs)
2256             he_tx_mcs = v;
2257         fallthrough;
2258 
2259     default:
2260         v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
2261         arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2262 
2263         v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
2264         v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
2265         arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
2266 
2267         arg->peer_he_mcs_count++;
2268         if (!he_tx_mcs)
2269             he_tx_mcs = v;
2270         break;
2271     }
2272 
2273     /* Calculate peer NSS capability from HE capabilities if STA
2274      * supports HE.
2275      */
2276     for (i = 0, max_nss = 0; i < NL80211_HE_NSS_MAX; i++) {
2277         he_mcs = he_tx_mcs >> (2 * i) & 3;
2278 
2279         /* In case of fixed rates, MCS Range in he_tx_mcs might have
2280          * unsupported range, with he_mcs_mask set, so check either of them
2281          * to find nss.
2282          */
2283         if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
2284             he_mcs_mask[i])
2285             max_nss = i + 1;
2286     }
2287     arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
2288 
2289     if (arg->peer_phymode == MODE_11AX_HE160 ||
2290         arg->peer_phymode == MODE_11AX_HE80_80) {
2291         tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
2292         rx_nss = min(arg->peer_nss, tx_nss);
2293         arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;
2294 
2295         if (!rx_nss) {
2296             ath11k_warn(ar->ab, "invalid max_nss\n");
2297             return;
2298         }
2299 
2300         if (arg->peer_phymode == MODE_11AX_HE160)
2301             nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
2302         else
2303             nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);
2304 
2305         arg->peer_bw_rxnss_override |= nss_160;
2306     }
2307 
2308     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2309            "mac he peer %pM nss %d mcs cnt %d nss_override 0x%x\n",
2310            sta->addr, arg->peer_nss,
2311            arg->peer_he_mcs_count,
2312            arg->peer_bw_rxnss_override);
2313 }
2314 
2315 static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar,
2316                     struct ieee80211_vif *vif,
2317                     struct ieee80211_sta *sta,
2318                     struct peer_assoc_params *arg)
2319 {
2320     const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2321     struct cfg80211_chan_def def;
2322     enum nl80211_band band;
2323     u8  ampdu_factor;
2324 
2325     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2326         return;
2327 
2328     band = def.chan->band;
2329 
2330     if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->deflink.he_6ghz_capa.capa)
2331         return;
2332 
2333     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2334         arg->bw_40 = true;
2335 
2336     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2337         arg->bw_80 = true;
2338 
2339     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2340         arg->bw_160 = true;
2341 
2342     arg->peer_he_caps_6ghz = le16_to_cpu(sta->deflink.he_6ghz_capa.capa);
2343     arg->peer_mpdu_density =
2344         ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
2345                            arg->peer_he_caps_6ghz));
2346 
2347     /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
2348      * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
2349      * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
2350      * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
2351      * Band Capabilities element in the 6 GHz band.
2352      *
2353      * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
2354      * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
2355      */
2356     ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
2357                  he_cap->he_cap_elem.mac_cap_info[3]) +
2358             FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
2359                   arg->peer_he_caps_6ghz);
2360 
2361     arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
2362                      ampdu_factor)) - 1;
2363 }
2364 
2365 static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
2366                      struct peer_assoc_params *arg)
2367 {
2368     const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2369     int smps;
2370 
2371     if (!ht_cap->ht_supported && !sta->deflink.he_6ghz_capa.capa)
2372         return;
2373 
2374     if (ht_cap->ht_supported) {
2375         smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2376         smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2377     } else {
2378         smps = le16_get_bits(sta->deflink.he_6ghz_capa.capa,
2379                      IEEE80211_HE_6GHZ_CAP_SM_PS);
2380     }
2381 
2382     switch (smps) {
2383     case WLAN_HT_CAP_SM_PS_STATIC:
2384         arg->static_mimops_flag = true;
2385         break;
2386     case WLAN_HT_CAP_SM_PS_DYNAMIC:
2387         arg->dynamic_mimops_flag = true;
2388         break;
2389     case WLAN_HT_CAP_SM_PS_DISABLED:
2390         arg->spatial_mux_flag = true;
2391         break;
2392     default:
2393         break;
2394     }
2395 }
2396 
2397 static void ath11k_peer_assoc_h_qos(struct ath11k *ar,
2398                     struct ieee80211_vif *vif,
2399                     struct ieee80211_sta *sta,
2400                     struct peer_assoc_params *arg)
2401 {
2402     struct ath11k_vif *arvif = (void *)vif->drv_priv;
2403 
2404     switch (arvif->vdev_type) {
2405     case WMI_VDEV_TYPE_AP:
2406         if (sta->wme) {
2407             /* TODO: Check WME vs QoS */
2408             arg->is_wme_set = true;
2409             arg->qos_flag = true;
2410         }
2411 
2412         if (sta->wme && sta->uapsd_queues) {
2413             /* TODO: Check WME vs QoS */
2414             arg->is_wme_set = true;
2415             arg->apsd_flag = true;
2416             arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
2417         }
2418         break;
2419     case WMI_VDEV_TYPE_STA:
2420         if (sta->wme) {
2421             arg->is_wme_set = true;
2422             arg->qos_flag = true;
2423         }
2424         break;
2425     default:
2426         break;
2427     }
2428 
2429     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM qos %d\n",
2430            sta->addr, arg->qos_flag);
2431 }
2432 
2433 static int ath11k_peer_assoc_qos_ap(struct ath11k *ar,
2434                     struct ath11k_vif *arvif,
2435                     struct ieee80211_sta *sta)
2436 {
2437     struct ap_ps_params params;
2438     u32 max_sp;
2439     u32 uapsd;
2440     int ret;
2441 
2442     lockdep_assert_held(&ar->conf_mutex);
2443 
2444     params.vdev_id = arvif->vdev_id;
2445 
2446     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2447            sta->uapsd_queues, sta->max_sp);
2448 
2449     uapsd = 0;
2450     if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2451         uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2452              WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2453     if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2454         uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2455              WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2456     if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2457         uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2458              WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2459     if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2460         uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2461              WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2462 
2463     max_sp = 0;
2464     if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2465         max_sp = sta->max_sp;
2466 
2467     params.param = WMI_AP_PS_PEER_PARAM_UAPSD;
2468     params.value = uapsd;
2469     ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2470     if (ret)
2471         goto err;
2472 
2473     params.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
2474     params.value = max_sp;
2475     ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2476     if (ret)
2477         goto err;
2478 
2479     /* TODO revisit during testing */
2480     params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
2481     params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2482     ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2483     if (ret)
2484         goto err;
2485 
2486     params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
2487     params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
2488     ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
2489     if (ret)
2490         goto err;
2491 
2492     return 0;
2493 
2494 err:
2495     ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
2496             params.param, arvif->vdev_id, ret);
2497     return ret;
2498 }
2499 
2500 static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2501 {
2502     return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2503            ATH11K_MAC_FIRST_OFDM_RATE_IDX;
2504 }
2505 
2506 static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar,
2507                             struct ieee80211_sta *sta)
2508 {
2509     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2510         switch (sta->deflink.vht_cap.cap &
2511             IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2512         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2513             return MODE_11AC_VHT160;
2514         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2515             return MODE_11AC_VHT80_80;
2516         default:
2517             /* not sure if this is a valid case? */
2518             return MODE_11AC_VHT160;
2519         }
2520     }
2521 
2522     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2523         return MODE_11AC_VHT80;
2524 
2525     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2526         return MODE_11AC_VHT40;
2527 
2528     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2529         return MODE_11AC_VHT20;
2530 
2531     return MODE_UNKNOWN;
2532 }
2533 
2534 static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar,
2535                            struct ieee80211_sta *sta)
2536 {
2537     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2538         if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2539              IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
2540             return MODE_11AX_HE160;
2541         else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
2542              IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
2543             return MODE_11AX_HE80_80;
2544         /* not sure if this is a valid case? */
2545         return MODE_11AX_HE160;
2546     }
2547 
2548     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2549         return MODE_11AX_HE80;
2550 
2551     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2552         return MODE_11AX_HE40;
2553 
2554     if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2555         return MODE_11AX_HE20;
2556 
2557     return MODE_UNKNOWN;
2558 }
2559 
2560 static void ath11k_peer_assoc_h_phymode(struct ath11k *ar,
2561                     struct ieee80211_vif *vif,
2562                     struct ieee80211_sta *sta,
2563                     struct peer_assoc_params *arg)
2564 {
2565     struct ath11k_vif *arvif = (void *)vif->drv_priv;
2566     struct cfg80211_chan_def def;
2567     enum nl80211_band band;
2568     const u8 *ht_mcs_mask;
2569     const u16 *vht_mcs_mask;
2570     const u16 *he_mcs_mask;
2571     enum wmi_phy_mode phymode = MODE_UNKNOWN;
2572 
2573     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2574         return;
2575 
2576     band = def.chan->band;
2577     ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2578     vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2579     he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
2580 
2581     switch (band) {
2582     case NL80211_BAND_2GHZ:
2583         if (sta->deflink.he_cap.has_he &&
2584             !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2585             if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2586                 phymode = MODE_11AX_HE80_2G;
2587             else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2588                 phymode = MODE_11AX_HE40_2G;
2589             else
2590                 phymode = MODE_11AX_HE20_2G;
2591         } else if (sta->deflink.vht_cap.vht_supported &&
2592                !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2593             if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2594                 phymode = MODE_11AC_VHT40;
2595             else
2596                 phymode = MODE_11AC_VHT20;
2597         } else if (sta->deflink.ht_cap.ht_supported &&
2598                !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2599             if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2600                 phymode = MODE_11NG_HT40;
2601             else
2602                 phymode = MODE_11NG_HT20;
2603         } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
2604             phymode = MODE_11G;
2605         } else {
2606             phymode = MODE_11B;
2607         }
2608         break;
2609     case NL80211_BAND_5GHZ:
2610     case NL80211_BAND_6GHZ:
2611         /* Check HE first */
2612         if (sta->deflink.he_cap.has_he &&
2613             !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
2614             phymode = ath11k_mac_get_phymode_he(ar, sta);
2615         } else if (sta->deflink.vht_cap.vht_supported &&
2616                !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2617             phymode = ath11k_mac_get_phymode_vht(ar, sta);
2618         } else if (sta->deflink.ht_cap.ht_supported &&
2619                !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2620             if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2621                 phymode = MODE_11NA_HT40;
2622             else
2623                 phymode = MODE_11NA_HT20;
2624         } else {
2625             phymode = MODE_11A;
2626         }
2627         break;
2628     default:
2629         break;
2630     }
2631 
2632     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM phymode %s\n",
2633            sta->addr, ath11k_wmi_phymode_str(phymode));
2634 
2635     arg->peer_phymode = phymode;
2636     WARN_ON(phymode == MODE_UNKNOWN);
2637 }
2638 
2639 static void ath11k_peer_assoc_prepare(struct ath11k *ar,
2640                       struct ieee80211_vif *vif,
2641                       struct ieee80211_sta *sta,
2642                       struct peer_assoc_params *arg,
2643                       bool reassoc)
2644 {
2645     struct ath11k_sta *arsta;
2646 
2647     lockdep_assert_held(&ar->conf_mutex);
2648 
2649     arsta = (struct ath11k_sta *)sta->drv_priv;
2650 
2651     memset(arg, 0, sizeof(*arg));
2652 
2653     reinit_completion(&ar->peer_assoc_done);
2654 
2655     arg->peer_new_assoc = !reassoc;
2656     ath11k_peer_assoc_h_basic(ar, vif, sta, arg);
2657     ath11k_peer_assoc_h_crypto(ar, vif, sta, arg);
2658     ath11k_peer_assoc_h_rates(ar, vif, sta, arg);
2659     ath11k_peer_assoc_h_phymode(ar, vif, sta, arg);
2660     ath11k_peer_assoc_h_ht(ar, vif, sta, arg);
2661     ath11k_peer_assoc_h_vht(ar, vif, sta, arg);
2662     ath11k_peer_assoc_h_he(ar, vif, sta, arg);
2663     ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg);
2664     ath11k_peer_assoc_h_qos(ar, vif, sta, arg);
2665     ath11k_peer_assoc_h_smps(sta, arg);
2666 
2667     arsta->peer_nss = arg->peer_nss;
2668 
2669     /* TODO: amsdu_disable req? */
2670 }
2671 
2672 static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif,
2673                   const u8 *addr,
2674                   const struct ieee80211_sta_ht_cap *ht_cap,
2675                   u16 he_6ghz_capa)
2676 {
2677     int smps;
2678 
2679     if (!ht_cap->ht_supported && !he_6ghz_capa)
2680         return 0;
2681 
2682     if (ht_cap->ht_supported) {
2683         smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2684         smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2685     } else {
2686         smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa);
2687     }
2688 
2689     if (smps >= ARRAY_SIZE(ath11k_smps_map))
2690         return -EINVAL;
2691 
2692     return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
2693                      WMI_PEER_MIMO_PS_STATE,
2694                      ath11k_smps_map[smps]);
2695 }
2696 
2697 static void ath11k_bss_assoc(struct ieee80211_hw *hw,
2698                  struct ieee80211_vif *vif,
2699                  struct ieee80211_bss_conf *bss_conf)
2700 {
2701     struct ath11k *ar = hw->priv;
2702     struct ath11k_vif *arvif = (void *)vif->drv_priv;
2703     struct peer_assoc_params peer_arg;
2704     struct ieee80211_sta *ap_sta;
2705     struct ath11k_peer *peer;
2706     bool is_auth = false;
2707     int ret;
2708 
2709     lockdep_assert_held(&ar->conf_mutex);
2710 
2711     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2712            arvif->vdev_id, arvif->bssid, arvif->aid);
2713 
2714     rcu_read_lock();
2715 
2716     ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2717     if (!ap_sta) {
2718         ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
2719                 bss_conf->bssid, arvif->vdev_id);
2720         rcu_read_unlock();
2721         return;
2722     }
2723 
2724     ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);
2725 
2726     rcu_read_unlock();
2727 
2728     peer_arg.is_assoc = true;
2729     ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
2730     if (ret) {
2731         ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
2732                 bss_conf->bssid, arvif->vdev_id, ret);
2733         return;
2734     }
2735 
2736     if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
2737         ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
2738                 bss_conf->bssid, arvif->vdev_id);
2739         return;
2740     }
2741 
2742     ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid,
2743                      &ap_sta->deflink.ht_cap,
2744                      le16_to_cpu(ap_sta->deflink.he_6ghz_capa.capa));
2745     if (ret) {
2746         ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
2747                 arvif->vdev_id, ret);
2748         return;
2749     }
2750 
2751     WARN_ON(arvif->is_up);
2752 
2753     arvif->aid = vif->cfg.aid;
2754     ether_addr_copy(arvif->bssid, bss_conf->bssid);
2755 
2756     ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2757     if (ret) {
2758         ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
2759                 arvif->vdev_id, ret);
2760         return;
2761     }
2762 
2763     arvif->is_up = true;
2764     arvif->rekey_data.enable_offload = false;
2765 
2766     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2767            "mac vdev %d up (associated) bssid %pM aid %d\n",
2768            arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
2769 
2770     spin_lock_bh(&ar->ab->base_lock);
2771 
2772     peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
2773     if (peer && peer->is_authorized)
2774         is_auth = true;
2775 
2776     spin_unlock_bh(&ar->ab->base_lock);
2777 
2778     if (is_auth) {
2779         ret = ath11k_wmi_set_peer_param(ar, arvif->bssid,
2780                         arvif->vdev_id,
2781                         WMI_PEER_AUTHORIZE,
2782                         1);
2783         if (ret)
2784             ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
2785     }
2786 
2787     ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
2788                        &bss_conf->he_obss_pd);
2789     if (ret)
2790         ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
2791                 arvif->vdev_id, ret);
2792 
2793     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2794                         WMI_VDEV_PARAM_DTIM_POLICY,
2795                         WMI_DTIM_POLICY_STICK);
2796     if (ret)
2797         ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n",
2798                 arvif->vdev_id, ret);
2799 
2800     ath11k_mac_11d_scan_stop_all(ar->ab);
2801 }
2802 
2803 static void ath11k_bss_disassoc(struct ieee80211_hw *hw,
2804                 struct ieee80211_vif *vif)
2805 {
2806     struct ath11k *ar = hw->priv;
2807     struct ath11k_vif *arvif = (void *)vif->drv_priv;
2808     int ret;
2809 
2810     lockdep_assert_held(&ar->conf_mutex);
2811 
2812     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2813            arvif->vdev_id, arvif->bssid);
2814 
2815     ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
2816     if (ret)
2817         ath11k_warn(ar->ab, "failed to down vdev %i: %d\n",
2818                 arvif->vdev_id, ret);
2819 
2820     arvif->is_up = false;
2821 
2822     memset(&arvif->rekey_data, 0, sizeof(arvif->rekey_data));
2823 
2824     cancel_delayed_work_sync(&arvif->connection_loss_work);
2825 }
2826 
2827 static u32 ath11k_mac_get_rate_hw_value(int bitrate)
2828 {
2829     u32 preamble;
2830     u16 hw_value;
2831     int rate;
2832     size_t i;
2833 
2834     if (ath11k_mac_bitrate_is_cck(bitrate))
2835         preamble = WMI_RATE_PREAMBLE_CCK;
2836     else
2837         preamble = WMI_RATE_PREAMBLE_OFDM;
2838 
2839     for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) {
2840         if (ath11k_legacy_rates[i].bitrate != bitrate)
2841             continue;
2842 
2843         hw_value = ath11k_legacy_rates[i].hw_value;
2844         rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
2845 
2846         return rate;
2847     }
2848 
2849     return -EINVAL;
2850 }
2851 
2852 static void ath11k_recalculate_mgmt_rate(struct ath11k *ar,
2853                      struct ieee80211_vif *vif,
2854                      struct cfg80211_chan_def *def)
2855 {
2856     struct ath11k_vif *arvif = (void *)vif->drv_priv;
2857     const struct ieee80211_supported_band *sband;
2858     u8 basic_rate_idx;
2859     int hw_rate_code;
2860     u32 vdev_param;
2861     u16 bitrate;
2862     int ret;
2863 
2864     lockdep_assert_held(&ar->conf_mutex);
2865 
2866     sband = ar->hw->wiphy->bands[def->chan->band];
2867     basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
2868     bitrate = sband->bitrates[basic_rate_idx].bitrate;
2869 
2870     hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate);
2871     if (hw_rate_code < 0) {
2872         ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
2873         return;
2874     }
2875 
2876     vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
2877     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
2878                         hw_rate_code);
2879     if (ret)
2880         ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
2881 
2882     /* For WCN6855, firmware will clear this param when vdev starts, hence
2883      * cache it here so that we can reconfigure it once vdev starts.
2884      */
2885     ar->hw_rate_code = hw_rate_code;
2886 
2887     vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
2888     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
2889                         hw_rate_code);
2890     if (ret)
2891         ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
2892 }
2893 
2894 static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif,
2895                      struct ieee80211_bss_conf *info)
2896 {
2897     struct ath11k *ar = arvif->ar;
2898     struct sk_buff *tmpl;
2899     int ret;
2900     u32 interval;
2901     bool unsol_bcast_probe_resp_enabled = false;
2902 
2903     if (info->fils_discovery.max_interval) {
2904         interval = info->fils_discovery.max_interval;
2905 
2906         tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
2907         if (tmpl)
2908             ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
2909                                  tmpl);
2910     } else if (info->unsol_bcast_probe_resp_interval) {
2911         unsol_bcast_probe_resp_enabled = 1;
2912         interval = info->unsol_bcast_probe_resp_interval;
2913 
2914         tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
2915                                  arvif->vif);
2916         if (tmpl)
2917             ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
2918                              tmpl);
2919     } else { /* Disable */
2920         return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
2921     }
2922 
2923     if (!tmpl) {
2924         ath11k_warn(ar->ab,
2925                 "mac vdev %i failed to retrieve %s template\n",
2926                 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
2927                 "unsolicited broadcast probe response" :
2928                 "FILS discovery"));
2929         return -EPERM;
2930     }
2931     kfree_skb(tmpl);
2932 
2933     if (!ret)
2934         ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
2935                         unsol_bcast_probe_resp_enabled);
2936 
2937     return ret;
2938 }
2939 
2940 static int ath11k_mac_config_obss_pd(struct ath11k *ar,
2941                      struct ieee80211_he_obss_pd *he_obss_pd)
2942 {
2943     u32 bitmap[2], param_id, param_val, pdev_id;
2944     int ret;
2945     s8 non_srg_th = 0, srg_th = 0;
2946 
2947     pdev_id = ar->pdev->pdev_id;
2948 
2949     /* Set and enable SRG/non-SRG OBSS PD Threshold */
2950     param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD;
2951     if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
2952         ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id);
2953         if (ret)
2954             ath11k_warn(ar->ab,
2955                     "failed to set obss_pd_threshold for pdev: %u\n",
2956                     pdev_id);
2957         return ret;
2958     }
2959 
2960     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
2961            "mac obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n",
2962            he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset,
2963            he_obss_pd->max_offset);
2964 
2965     param_val = 0;
2966 
2967     if (he_obss_pd->sr_ctrl &
2968         IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) {
2969         non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD;
2970     } else {
2971         if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
2972             non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD +
2973                       he_obss_pd->non_srg_max_offset);
2974         else
2975             non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD;
2976 
2977         param_val |= ATH11K_OBSS_PD_NON_SRG_EN;
2978     }
2979 
2980     if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) {
2981         srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset;
2982         param_val |= ATH11K_OBSS_PD_SRG_EN;
2983     }
2984 
2985     if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
2986              ar->ab->wmi_ab.svc_map)) {
2987         param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM;
2988         param_val |= FIELD_PREP(GENMASK(15, 8), srg_th);
2989     } else {
2990         non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR;
2991         /* SRG not supported and threshold in dB */
2992         param_val &= ~(ATH11K_OBSS_PD_SRG_EN |
2993                    ATH11K_OBSS_PD_THRESHOLD_IN_DBM);
2994     }
2995 
2996     param_val |= (non_srg_th & GENMASK(7, 0));
2997     ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
2998     if (ret) {
2999         ath11k_warn(ar->ab,
3000                 "failed to set obss_pd_threshold for pdev: %u\n",
3001                 pdev_id);
3002         return ret;
3003     }
3004 
3005     /* Enable OBSS PD for all access category */
3006     param_id  = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC;
3007     param_val = 0xf;
3008     ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3009     if (ret) {
3010         ath11k_warn(ar->ab,
3011                 "failed to set obss_pd_per_ac for pdev: %u\n",
3012                 pdev_id);
3013         return ret;
3014     }
3015 
3016     /* Set SR Prohibit */
3017     param_id  = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT;
3018     param_val = !!(he_obss_pd->sr_ctrl &
3019                IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED);
3020     ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
3021     if (ret) {
3022         ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n",
3023                 pdev_id);
3024         return ret;
3025     }
3026 
3027     if (!test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
3028               ar->ab->wmi_ab.svc_map))
3029         return 0;
3030 
3031     /* Set SRG BSS Color Bitmap */
3032     memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));
3033     ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap);
3034     if (ret) {
3035         ath11k_warn(ar->ab,
3036                 "failed to set bss_color_bitmap for pdev: %u\n",
3037                 pdev_id);
3038         return ret;
3039     }
3040 
3041     /* Set SRG Partial BSSID Bitmap */
3042     memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));
3043     ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap);
3044     if (ret) {
3045         ath11k_warn(ar->ab,
3046                 "failed to set partial_bssid_bitmap for pdev: %u\n",
3047                 pdev_id);
3048         return ret;
3049     }
3050 
3051     memset(bitmap, 0xff, sizeof(bitmap));
3052 
3053     /* Enable all BSS Colors for SRG */
3054     ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap);
3055     if (ret) {
3056         ath11k_warn(ar->ab,
3057                 "failed to set srg_color_en_bitmap pdev: %u\n",
3058                 pdev_id);
3059         return ret;
3060     }
3061 
3062     /* Enable all patial BSSID mask for SRG */
3063     ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap);
3064     if (ret) {
3065         ath11k_warn(ar->ab,
3066                 "failed to set srg_bssid_en_bitmap pdev: %u\n",
3067                 pdev_id);
3068         return ret;
3069     }
3070 
3071     /* Enable all BSS Colors for non-SRG */
3072     ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap);
3073     if (ret) {
3074         ath11k_warn(ar->ab,
3075                 "failed to set non_srg_color_en_bitmap pdev: %u\n",
3076                 pdev_id);
3077         return ret;
3078     }
3079 
3080     /* Enable all patial BSSID mask for non-SRG */
3081     ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap);
3082     if (ret) {
3083         ath11k_warn(ar->ab,
3084                 "failed to set non_srg_bssid_en_bitmap pdev: %u\n",
3085                 pdev_id);
3086         return ret;
3087     }
3088 
3089     return 0;
3090 }
3091 
3092 static void ath11k_mac_op_bss_info_changed(struct ieee80211_hw *hw,
3093                        struct ieee80211_vif *vif,
3094                        struct ieee80211_bss_conf *info,
3095                        u64 changed)
3096 {
3097     struct ath11k *ar = hw->priv;
3098     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3099     struct cfg80211_chan_def def;
3100     u32 param_id, param_value;
3101     enum nl80211_band band;
3102     u32 vdev_param;
3103     int mcast_rate;
3104     u32 preamble;
3105     u16 hw_value;
3106     u16 bitrate;
3107     int ret = 0;
3108     u8 rateidx;
3109     u32 rate;
3110     u32 ipv4_cnt;
3111 
3112     mutex_lock(&ar->conf_mutex);
3113 
3114     if (changed & BSS_CHANGED_BEACON_INT) {
3115         arvif->beacon_interval = info->beacon_int;
3116 
3117         param_id = WMI_VDEV_PARAM_BEACON_INTERVAL;
3118         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3119                             param_id,
3120                             arvif->beacon_interval);
3121         if (ret)
3122             ath11k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n",
3123                     arvif->vdev_id);
3124         else
3125             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3126                    "Beacon interval: %d set for VDEV: %d\n",
3127                    arvif->beacon_interval, arvif->vdev_id);
3128     }
3129 
3130     if (changed & BSS_CHANGED_BEACON) {
3131         param_id = WMI_PDEV_PARAM_BEACON_TX_MODE;
3132         param_value = WMI_BEACON_STAGGERED_MODE;
3133         ret = ath11k_wmi_pdev_set_param(ar, param_id,
3134                         param_value, ar->pdev->pdev_id);
3135         if (ret)
3136             ath11k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n",
3137                     arvif->vdev_id);
3138         else
3139             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3140                    "Set staggered beacon mode for VDEV: %d\n",
3141                    arvif->vdev_id);
3142 
3143         if (!arvif->do_not_send_tmpl || !arvif->bcca_zero_sent) {
3144             ret = ath11k_mac_setup_bcn_tmpl(arvif);
3145             if (ret)
3146                 ath11k_warn(ar->ab, "failed to update bcn template: %d\n",
3147                         ret);
3148         }
3149 
3150         if (arvif->bcca_zero_sent)
3151             arvif->do_not_send_tmpl = true;
3152         else
3153             arvif->do_not_send_tmpl = false;
3154 
3155         if (vif->bss_conf.he_support) {
3156             ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3157                                 WMI_VDEV_PARAM_BA_MODE,
3158                                 WMI_BA_MODE_BUFFER_SIZE_256);
3159             if (ret)
3160                 ath11k_warn(ar->ab,
3161                         "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
3162                         arvif->vdev_id);
3163             else
3164                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3165                        "Set BA BUFFER SIZE 256 for VDEV: %d\n",
3166                        arvif->vdev_id);
3167         }
3168     }
3169 
3170     if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3171         arvif->dtim_period = info->dtim_period;
3172 
3173         param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
3174         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3175                             param_id,
3176                             arvif->dtim_period);
3177 
3178         if (ret)
3179             ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
3180                     arvif->vdev_id, ret);
3181         else
3182             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3183                    "DTIM period: %d set for VDEV: %d\n",
3184                    arvif->dtim_period, arvif->vdev_id);
3185     }
3186 
3187     if (changed & BSS_CHANGED_SSID &&
3188         vif->type == NL80211_IFTYPE_AP) {
3189         arvif->u.ap.ssid_len = vif->cfg.ssid_len;
3190         if (vif->cfg.ssid_len)
3191             memcpy(arvif->u.ap.ssid, vif->cfg.ssid,
3192                    vif->cfg.ssid_len);
3193         arvif->u.ap.hidden_ssid = info->hidden_ssid;
3194     }
3195 
3196     if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3197         ether_addr_copy(arvif->bssid, info->bssid);
3198 
3199     if (changed & BSS_CHANGED_BEACON_ENABLED) {
3200         ath11k_control_beaconing(arvif, info);
3201 
3202         if (arvif->is_up && vif->bss_conf.he_support &&
3203             vif->bss_conf.he_oper.params) {
3204             param_id = WMI_VDEV_PARAM_HEOPS_0_31;
3205             param_value = vif->bss_conf.he_oper.params;
3206             ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3207                                 param_id, param_value);
3208             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3209                    "he oper param: %x set for VDEV: %d\n",
3210                    param_value, arvif->vdev_id);
3211 
3212             if (ret)
3213                 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
3214                         param_value, arvif->vdev_id, ret);
3215         }
3216     }
3217 
3218     if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3219         u32 cts_prot;
3220 
3221         cts_prot = !!(info->use_cts_prot);
3222         param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
3223 
3224         if (arvif->is_started) {
3225             ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3226                                 param_id, cts_prot);
3227             if (ret)
3228                 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
3229                         arvif->vdev_id);
3230             else
3231                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
3232                        cts_prot, arvif->vdev_id);
3233         } else {
3234             ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
3235         }
3236     }
3237 
3238     if (changed & BSS_CHANGED_ERP_SLOT) {
3239         u32 slottime;
3240 
3241         if (info->use_short_slot)
3242             slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3243 
3244         else
3245             slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3246 
3247         param_id = WMI_VDEV_PARAM_SLOT_TIME;
3248         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3249                             param_id, slottime);
3250         if (ret)
3251             ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
3252                     arvif->vdev_id);
3253         else
3254             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3255                    "Set slottime: %d for VDEV: %d\n",
3256                    slottime, arvif->vdev_id);
3257     }
3258 
3259     if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3260         u32 preamble;
3261 
3262         if (info->use_short_preamble)
3263             preamble = WMI_VDEV_PREAMBLE_SHORT;
3264         else
3265             preamble = WMI_VDEV_PREAMBLE_LONG;
3266 
3267         param_id = WMI_VDEV_PARAM_PREAMBLE;
3268         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3269                             param_id, preamble);
3270         if (ret)
3271             ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
3272                     arvif->vdev_id);
3273         else
3274             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3275                    "Set preamble: %d for VDEV: %d\n",
3276                    preamble, arvif->vdev_id);
3277     }
3278 
3279     if (changed & BSS_CHANGED_ASSOC) {
3280         if (vif->cfg.assoc)
3281             ath11k_bss_assoc(hw, vif, info);
3282         else
3283             ath11k_bss_disassoc(hw, vif);
3284     }
3285 
3286     if (changed & BSS_CHANGED_TXPOWER) {
3287         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3288                arvif->vdev_id, info->txpower);
3289 
3290         arvif->txpower = info->txpower;
3291         ath11k_mac_txpower_recalc(ar);
3292     }
3293 
3294     if (changed & BSS_CHANGED_PS &&
3295         ar->ab->hw_params.supports_sta_ps) {
3296         arvif->ps = vif->cfg.ps;
3297 
3298         ret = ath11k_mac_config_ps(ar);
3299         if (ret)
3300             ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n",
3301                     arvif->vdev_id, ret);
3302     }
3303 
3304     if (changed & BSS_CHANGED_MCAST_RATE &&
3305         !ath11k_mac_vif_chan(arvif->vif, &def)) {
3306         band = def.chan->band;
3307         mcast_rate = vif->bss_conf.mcast_rate[band];
3308 
3309         if (mcast_rate > 0)
3310             rateidx = mcast_rate - 1;
3311         else
3312             rateidx = ffs(vif->bss_conf.basic_rates) - 1;
3313 
3314         if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
3315             rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
3316 
3317         bitrate = ath11k_legacy_rates[rateidx].bitrate;
3318         hw_value = ath11k_legacy_rates[rateidx].hw_value;
3319 
3320         if (ath11k_mac_bitrate_is_cck(bitrate))
3321             preamble = WMI_RATE_PREAMBLE_CCK;
3322         else
3323             preamble = WMI_RATE_PREAMBLE_OFDM;
3324 
3325         rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3326 
3327         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3328                "mac vdev %d mcast_rate %x\n",
3329                arvif->vdev_id, rate);
3330 
3331         vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
3332         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3333                             vdev_param, rate);
3334         if (ret)
3335             ath11k_warn(ar->ab,
3336                     "failed to set mcast rate on vdev %i: %d\n",
3337                     arvif->vdev_id,  ret);
3338 
3339         vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
3340         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3341                             vdev_param, rate);
3342         if (ret)
3343             ath11k_warn(ar->ab,
3344                     "failed to set bcast rate on vdev %i: %d\n",
3345                     arvif->vdev_id,  ret);
3346     }
3347 
3348     if (changed & BSS_CHANGED_BASIC_RATES &&
3349         !ath11k_mac_vif_chan(arvif->vif, &def))
3350         ath11k_recalculate_mgmt_rate(ar, vif, &def);
3351 
3352     if (changed & BSS_CHANGED_TWT) {
3353         if (info->twt_requester || info->twt_responder)
3354             ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id);
3355         else
3356             ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
3357     }
3358 
3359     if (changed & BSS_CHANGED_HE_OBSS_PD)
3360         ath11k_mac_config_obss_pd(ar, &info->he_obss_pd);
3361 
3362     if (changed & BSS_CHANGED_HE_BSS_COLOR) {
3363         if (vif->type == NL80211_IFTYPE_AP) {
3364             ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3365                 ar, arvif->vdev_id, info->he_bss_color.color,
3366                 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS,
3367                 info->he_bss_color.enabled);
3368             if (ret)
3369                 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3370                         arvif->vdev_id,  ret);
3371 
3372             param_id = WMI_VDEV_PARAM_BSS_COLOR;
3373             if (info->he_bss_color.enabled)
3374                 param_value = info->he_bss_color.color <<
3375                         IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET;
3376             else
3377                 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED;
3378 
3379             ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3380                                 param_id,
3381                                 param_value);
3382             if (ret)
3383                 ath11k_warn(ar->ab,
3384                         "failed to set bss color param on vdev %i: %d\n",
3385                         arvif->vdev_id,  ret);
3386 
3387             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3388                    "bss color param 0x%x set on vdev %i\n",
3389                    param_value, arvif->vdev_id);
3390         } else if (vif->type == NL80211_IFTYPE_STATION) {
3391             ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar,
3392                                       arvif->vdev_id,
3393                                       1);
3394             if (ret)
3395                 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
3396                         arvif->vdev_id,  ret);
3397             ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3398                 ar, arvif->vdev_id, 0,
3399                 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1);
3400             if (ret)
3401                 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3402                         arvif->vdev_id,  ret);
3403         }
3404     }
3405 
3406     if (changed & BSS_CHANGED_FILS_DISCOVERY ||
3407         changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
3408         ath11k_mac_fils_discovery(arvif, info);
3409 
3410     if (changed & BSS_CHANGED_ARP_FILTER) {
3411         ipv4_cnt = min(vif->cfg.arp_addr_cnt, ATH11K_IPV4_MAX_COUNT);
3412         memcpy(arvif->arp_ns_offload.ipv4_addr,
3413                vif->cfg.arp_addr_list,
3414                ipv4_cnt * sizeof(u32));
3415         memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN);
3416         arvif->arp_ns_offload.ipv4_count = ipv4_cnt;
3417 
3418         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
3419                vif->cfg.arp_addr_cnt,
3420                vif->addr, arvif->arp_ns_offload.ipv4_addr);
3421     }
3422 
3423     mutex_unlock(&ar->conf_mutex);
3424 }
3425 
3426 void __ath11k_mac_scan_finish(struct ath11k *ar)
3427 {
3428     lockdep_assert_held(&ar->data_lock);
3429 
3430     switch (ar->scan.state) {
3431     case ATH11K_SCAN_IDLE:
3432         break;
3433     case ATH11K_SCAN_RUNNING:
3434     case ATH11K_SCAN_ABORTING:
3435         if (ar->scan.is_roc && ar->scan.roc_notify)
3436             ieee80211_remain_on_channel_expired(ar->hw);
3437         fallthrough;
3438     case ATH11K_SCAN_STARTING:
3439         if (!ar->scan.is_roc) {
3440             struct cfg80211_scan_info info = {
3441                 .aborted = ((ar->scan.state ==
3442                         ATH11K_SCAN_ABORTING) ||
3443                         (ar->scan.state ==
3444                         ATH11K_SCAN_STARTING)),
3445             };
3446 
3447             ieee80211_scan_completed(ar->hw, &info);
3448         }
3449 
3450         ar->scan.state = ATH11K_SCAN_IDLE;
3451         ar->scan_channel = NULL;
3452         ar->scan.roc_freq = 0;
3453         cancel_delayed_work(&ar->scan.timeout);
3454         complete(&ar->scan.completed);
3455         break;
3456     }
3457 }
3458 
3459 void ath11k_mac_scan_finish(struct ath11k *ar)
3460 {
3461     spin_lock_bh(&ar->data_lock);
3462     __ath11k_mac_scan_finish(ar);
3463     spin_unlock_bh(&ar->data_lock);
3464 }
3465 
3466 static int ath11k_scan_stop(struct ath11k *ar)
3467 {
3468     struct scan_cancel_param arg = {
3469         .req_type = WLAN_SCAN_CANCEL_SINGLE,
3470         .scan_id = ATH11K_SCAN_ID,
3471     };
3472     int ret;
3473 
3474     lockdep_assert_held(&ar->conf_mutex);
3475 
3476     /* TODO: Fill other STOP Params */
3477     arg.pdev_id = ar->pdev->pdev_id;
3478 
3479     ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg);
3480     if (ret) {
3481         ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
3482         goto out;
3483     }
3484 
3485     ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
3486     if (ret == 0) {
3487         ath11k_warn(ar->ab,
3488                 "failed to receive scan abort comple: timed out\n");
3489         ret = -ETIMEDOUT;
3490     } else if (ret > 0) {
3491         ret = 0;
3492     }
3493 
3494 out:
3495     /* Scan state should be updated upon scan completion but in case
3496      * firmware fails to deliver the event (for whatever reason) it is
3497      * desired to clean up scan state anyway. Firmware may have just
3498      * dropped the scan completion event delivery due to transport pipe
3499      * being overflown with data and/or it can recover on its own before
3500      * next scan request is submitted.
3501      */
3502     spin_lock_bh(&ar->data_lock);
3503     if (ar->scan.state != ATH11K_SCAN_IDLE)
3504         __ath11k_mac_scan_finish(ar);
3505     spin_unlock_bh(&ar->data_lock);
3506 
3507     return ret;
3508 }
3509 
3510 static void ath11k_scan_abort(struct ath11k *ar)
3511 {
3512     int ret;
3513 
3514     lockdep_assert_held(&ar->conf_mutex);
3515 
3516     spin_lock_bh(&ar->data_lock);
3517 
3518     switch (ar->scan.state) {
3519     case ATH11K_SCAN_IDLE:
3520         /* This can happen if timeout worker kicked in and called
3521          * abortion while scan completion was being processed.
3522          */
3523         break;
3524     case ATH11K_SCAN_STARTING:
3525     case ATH11K_SCAN_ABORTING:
3526         ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
3527                 ar->scan.state);
3528         break;
3529     case ATH11K_SCAN_RUNNING:
3530         ar->scan.state = ATH11K_SCAN_ABORTING;
3531         spin_unlock_bh(&ar->data_lock);
3532 
3533         ret = ath11k_scan_stop(ar);
3534         if (ret)
3535             ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret);
3536 
3537         spin_lock_bh(&ar->data_lock);
3538         break;
3539     }
3540 
3541     spin_unlock_bh(&ar->data_lock);
3542 }
3543 
3544 static void ath11k_scan_timeout_work(struct work_struct *work)
3545 {
3546     struct ath11k *ar = container_of(work, struct ath11k,
3547                      scan.timeout.work);
3548 
3549     mutex_lock(&ar->conf_mutex);
3550     ath11k_scan_abort(ar);
3551     mutex_unlock(&ar->conf_mutex);
3552 }
3553 
3554 static int ath11k_start_scan(struct ath11k *ar,
3555                  struct scan_req_params *arg)
3556 {
3557     int ret;
3558     unsigned long timeout = 1 * HZ;
3559 
3560     lockdep_assert_held(&ar->conf_mutex);
3561 
3562     if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND)
3563         ath11k_spectral_reset_buffer(ar);
3564 
3565     ret = ath11k_wmi_send_scan_start_cmd(ar, arg);
3566     if (ret)
3567         return ret;
3568 
3569     if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) {
3570         timeout = 5 * HZ;
3571 
3572         if (ar->supports_6ghz)
3573             timeout += 5 * HZ;
3574     }
3575 
3576     ret = wait_for_completion_timeout(&ar->scan.started, timeout);
3577     if (ret == 0) {
3578         ret = ath11k_scan_stop(ar);
3579         if (ret)
3580             ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
3581 
3582         return -ETIMEDOUT;
3583     }
3584 
3585     /* If we failed to start the scan, return error code at
3586      * this point.  This is probably due to some issue in the
3587      * firmware, but no need to wedge the driver due to that...
3588      */
3589     spin_lock_bh(&ar->data_lock);
3590     if (ar->scan.state == ATH11K_SCAN_IDLE) {
3591         spin_unlock_bh(&ar->data_lock);
3592         return -EINVAL;
3593     }
3594     spin_unlock_bh(&ar->data_lock);
3595 
3596     return 0;
3597 }
3598 
3599 static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw,
3600                  struct ieee80211_vif *vif,
3601                  struct ieee80211_scan_request *hw_req)
3602 {
3603     struct ath11k *ar = hw->priv;
3604     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3605     struct cfg80211_scan_request *req = &hw_req->req;
3606     struct scan_req_params arg;
3607     int ret = 0;
3608     int i;
3609 
3610     mutex_lock(&ar->conf_mutex);
3611 
3612     spin_lock_bh(&ar->data_lock);
3613     switch (ar->scan.state) {
3614     case ATH11K_SCAN_IDLE:
3615         reinit_completion(&ar->scan.started);
3616         reinit_completion(&ar->scan.completed);
3617         ar->scan.state = ATH11K_SCAN_STARTING;
3618         ar->scan.is_roc = false;
3619         ar->scan.vdev_id = arvif->vdev_id;
3620         ret = 0;
3621         break;
3622     case ATH11K_SCAN_STARTING:
3623     case ATH11K_SCAN_RUNNING:
3624     case ATH11K_SCAN_ABORTING:
3625         ret = -EBUSY;
3626         break;
3627     }
3628     spin_unlock_bh(&ar->data_lock);
3629 
3630     if (ret)
3631         goto exit;
3632 
3633     memset(&arg, 0, sizeof(arg));
3634     ath11k_wmi_start_scan_init(ar, &arg);
3635     arg.vdev_id = arvif->vdev_id;
3636     arg.scan_id = ATH11K_SCAN_ID;
3637 
3638     if (req->ie_len) {
3639         arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
3640         if (!arg.extraie.ptr) {
3641             ret = -ENOMEM;
3642             goto exit;
3643         }
3644         arg.extraie.len = req->ie_len;
3645     }
3646 
3647     if (req->n_ssids) {
3648         arg.num_ssids = req->n_ssids;
3649         for (i = 0; i < arg.num_ssids; i++) {
3650             arg.ssid[i].length  = req->ssids[i].ssid_len;
3651             memcpy(&arg.ssid[i].ssid, req->ssids[i].ssid,
3652                    req->ssids[i].ssid_len);
3653         }
3654     } else {
3655         arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
3656     }
3657 
3658     if (req->n_channels) {
3659         arg.num_chan = req->n_channels;
3660         arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
3661                     GFP_KERNEL);
3662 
3663         if (!arg.chan_list) {
3664             ret = -ENOMEM;
3665             goto exit;
3666         }
3667 
3668         for (i = 0; i < arg.num_chan; i++)
3669             arg.chan_list[i] = req->channels[i]->center_freq;
3670     }
3671 
3672     if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
3673         arg.scan_f_add_spoofed_mac_in_probe = 1;
3674         ether_addr_copy(arg.mac_addr.addr, req->mac_addr);
3675         ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask);
3676     }
3677 
3678     ret = ath11k_start_scan(ar, &arg);
3679     if (ret) {
3680         ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
3681         spin_lock_bh(&ar->data_lock);
3682         ar->scan.state = ATH11K_SCAN_IDLE;
3683         spin_unlock_bh(&ar->data_lock);
3684     }
3685 
3686     /* Add a 200ms margin to account for event/command processing */
3687     ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
3688                      msecs_to_jiffies(arg.max_scan_time +
3689                               ATH11K_MAC_SCAN_TIMEOUT_MSECS));
3690 
3691 exit:
3692     kfree(arg.chan_list);
3693 
3694     if (req->ie_len)
3695         kfree(arg.extraie.ptr);
3696 
3697     mutex_unlock(&ar->conf_mutex);
3698 
3699     if (ar->state_11d == ATH11K_11D_PREPARING)
3700         ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
3701 
3702     return ret;
3703 }
3704 
3705 static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
3706                      struct ieee80211_vif *vif)
3707 {
3708     struct ath11k *ar = hw->priv;
3709 
3710     mutex_lock(&ar->conf_mutex);
3711     ath11k_scan_abort(ar);
3712     mutex_unlock(&ar->conf_mutex);
3713 
3714     cancel_delayed_work_sync(&ar->scan.timeout);
3715 }
3716 
3717 static int ath11k_install_key(struct ath11k_vif *arvif,
3718                   struct ieee80211_key_conf *key,
3719                   enum set_key_cmd cmd,
3720                   const u8 *macaddr, u32 flags)
3721 {
3722     int ret;
3723     struct ath11k *ar = arvif->ar;
3724     struct wmi_vdev_install_key_arg arg = {
3725         .vdev_id = arvif->vdev_id,
3726         .key_idx = key->keyidx,
3727         .key_len = key->keylen,
3728         .key_data = key->key,
3729         .key_flags = flags,
3730         .macaddr = macaddr,
3731     };
3732 
3733     lockdep_assert_held(&arvif->ar->conf_mutex);
3734 
3735     reinit_completion(&ar->install_key_done);
3736 
3737     if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3738         return 0;
3739 
3740     if (cmd == DISABLE_KEY) {
3741         arg.key_cipher = WMI_CIPHER_NONE;
3742         arg.key_data = NULL;
3743         goto install;
3744     }
3745 
3746     switch (key->cipher) {
3747     case WLAN_CIPHER_SUITE_CCMP:
3748         arg.key_cipher = WMI_CIPHER_AES_CCM;
3749         /* TODO: Re-check if flag is valid */
3750         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
3751         break;
3752     case WLAN_CIPHER_SUITE_TKIP:
3753         arg.key_cipher = WMI_CIPHER_TKIP;
3754         arg.key_txmic_len = 8;
3755         arg.key_rxmic_len = 8;
3756         break;
3757     case WLAN_CIPHER_SUITE_CCMP_256:
3758         arg.key_cipher = WMI_CIPHER_AES_CCM;
3759         break;
3760     case WLAN_CIPHER_SUITE_GCMP:
3761     case WLAN_CIPHER_SUITE_GCMP_256:
3762         arg.key_cipher = WMI_CIPHER_AES_GCM;
3763         break;
3764     default:
3765         ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
3766         return -EOPNOTSUPP;
3767     }
3768 
3769     if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags))
3770         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
3771                   IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
3772 
3773 install:
3774     ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg);
3775 
3776     if (ret)
3777         return ret;
3778 
3779     if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
3780         return -ETIMEDOUT;
3781 
3782     return ar->install_key_status ? -EINVAL : 0;
3783 }
3784 
3785 static int ath11k_clear_peer_keys(struct ath11k_vif *arvif,
3786                   const u8 *addr)
3787 {
3788     struct ath11k *ar = arvif->ar;
3789     struct ath11k_base *ab = ar->ab;
3790     struct ath11k_peer *peer;
3791     int first_errno = 0;
3792     int ret;
3793     int i;
3794     u32 flags = 0;
3795 
3796     lockdep_assert_held(&ar->conf_mutex);
3797 
3798     spin_lock_bh(&ab->base_lock);
3799     peer = ath11k_peer_find(ab, arvif->vdev_id, addr);
3800     spin_unlock_bh(&ab->base_lock);
3801 
3802     if (!peer)
3803         return -ENOENT;
3804 
3805     for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
3806         if (!peer->keys[i])
3807             continue;
3808 
3809         /* key flags are not required to delete the key */
3810         ret = ath11k_install_key(arvif, peer->keys[i],
3811                      DISABLE_KEY, addr, flags);
3812         if (ret < 0 && first_errno == 0)
3813             first_errno = ret;
3814 
3815         if (ret < 0)
3816             ath11k_warn(ab, "failed to remove peer key %d: %d\n",
3817                     i, ret);
3818 
3819         spin_lock_bh(&ab->base_lock);
3820         peer->keys[i] = NULL;
3821         spin_unlock_bh(&ab->base_lock);
3822     }
3823 
3824     return first_errno;
3825 }
3826 
3827 static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3828                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3829                  struct ieee80211_key_conf *key)
3830 {
3831     struct ath11k *ar = hw->priv;
3832     struct ath11k_base *ab = ar->ab;
3833     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3834     struct ath11k_peer *peer;
3835     struct ath11k_sta *arsta;
3836     const u8 *peer_addr;
3837     int ret = 0;
3838     u32 flags = 0;
3839 
3840     /* BIP needs to be done in software */
3841     if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
3842         key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
3843         key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
3844         key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
3845         return 1;
3846 
3847     if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3848         return 1;
3849 
3850     if (key->keyidx > WMI_MAX_KEY_INDEX)
3851         return -ENOSPC;
3852 
3853     mutex_lock(&ar->conf_mutex);
3854 
3855     if (sta)
3856         peer_addr = sta->addr;
3857     else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3858         peer_addr = vif->bss_conf.bssid;
3859     else
3860         peer_addr = vif->addr;
3861 
3862     key->hw_key_idx = key->keyidx;
3863 
3864     /* the peer should not disappear in mid-way (unless FW goes awry) since
3865      * we already hold conf_mutex. we just make sure its there now.
3866      */
3867     spin_lock_bh(&ab->base_lock);
3868     peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
3869 
3870     /* flush the fragments cache during key (re)install to
3871      * ensure all frags in the new frag list belong to the same key.
3872      */
3873     if (peer && sta && cmd == SET_KEY)
3874         ath11k_peer_frags_flush(ar, peer);
3875     spin_unlock_bh(&ab->base_lock);
3876 
3877     if (!peer) {
3878         if (cmd == SET_KEY) {
3879             ath11k_warn(ab, "cannot install key for non-existent peer %pM\n",
3880                     peer_addr);
3881             ret = -EOPNOTSUPP;
3882             goto exit;
3883         } else {
3884             /* if the peer doesn't exist there is no key to disable
3885              * anymore
3886              */
3887             goto exit;
3888         }
3889     }
3890 
3891     if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3892         flags |= WMI_KEY_PAIRWISE;
3893     else
3894         flags |= WMI_KEY_GROUP;
3895 
3896     ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags);
3897     if (ret) {
3898         ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret);
3899         goto exit;
3900     }
3901 
3902     ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key);
3903     if (ret) {
3904         ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret);
3905         goto exit;
3906     }
3907 
3908     spin_lock_bh(&ab->base_lock);
3909     peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
3910     if (peer && cmd == SET_KEY) {
3911         peer->keys[key->keyidx] = key;
3912         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
3913             peer->ucast_keyidx = key->keyidx;
3914             peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher);
3915         } else {
3916             peer->mcast_keyidx = key->keyidx;
3917             peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher);
3918         }
3919     } else if (peer && cmd == DISABLE_KEY) {
3920         peer->keys[key->keyidx] = NULL;
3921         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3922             peer->ucast_keyidx = 0;
3923         else
3924             peer->mcast_keyidx = 0;
3925     } else if (!peer)
3926         /* impossible unless FW goes crazy */
3927         ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr);
3928 
3929     if (sta) {
3930         arsta = (struct ath11k_sta *)sta->drv_priv;
3931 
3932         switch (key->cipher) {
3933         case WLAN_CIPHER_SUITE_TKIP:
3934         case WLAN_CIPHER_SUITE_CCMP:
3935         case WLAN_CIPHER_SUITE_CCMP_256:
3936         case WLAN_CIPHER_SUITE_GCMP:
3937         case WLAN_CIPHER_SUITE_GCMP_256:
3938             if (cmd == SET_KEY)
3939                 arsta->pn_type = HAL_PN_TYPE_WPA;
3940             else
3941                 arsta->pn_type = HAL_PN_TYPE_NONE;
3942             break;
3943         default:
3944             arsta->pn_type = HAL_PN_TYPE_NONE;
3945             break;
3946         }
3947     }
3948 
3949     spin_unlock_bh(&ab->base_lock);
3950 
3951 exit:
3952     mutex_unlock(&ar->conf_mutex);
3953     return ret;
3954 }
3955 
3956 static int
3957 ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar,
3958                       enum nl80211_band band,
3959                       const struct cfg80211_bitrate_mask *mask)
3960 {
3961     int num_rates = 0;
3962     int i;
3963 
3964     for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
3965         num_rates += hweight16(mask->control[band].vht_mcs[i]);
3966 
3967     return num_rates;
3968 }
3969 
3970 static int
3971 ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar,
3972                      enum nl80211_band band,
3973                      const struct cfg80211_bitrate_mask *mask)
3974 {
3975     int num_rates = 0;
3976     int i;
3977 
3978     for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++)
3979         num_rates += hweight16(mask->control[band].he_mcs[i]);
3980 
3981     return num_rates;
3982 }
3983 
3984 static int
3985 ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif,
3986                    struct ieee80211_sta *sta,
3987                    const struct cfg80211_bitrate_mask *mask,
3988                    enum nl80211_band band)
3989 {
3990     struct ath11k *ar = arvif->ar;
3991     u8 vht_rate, nss;
3992     u32 rate_code;
3993     int ret, i;
3994 
3995     lockdep_assert_held(&ar->conf_mutex);
3996 
3997     nss = 0;
3998 
3999     for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
4000         if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
4001             nss = i + 1;
4002             vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4003         }
4004     }
4005 
4006     if (!nss) {
4007         ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
4008                 sta->addr);
4009         return -EINVAL;
4010     }
4011 
4012     /* Avoid updating invalid nss as fixed rate*/
4013     if (nss > sta->deflink.rx_nss)
4014         return -EINVAL;
4015 
4016     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4017            "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
4018            sta->addr);
4019 
4020     rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1,
4021                     WMI_RATE_PREAMBLE_VHT);
4022     ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4023                     arvif->vdev_id,
4024                     WMI_PEER_PARAM_FIXED_RATE,
4025                     rate_code);
4026     if (ret)
4027         ath11k_warn(ar->ab,
4028                 "failed to update STA %pM Fixed Rate %d: %d\n",
4029                  sta->addr, rate_code, ret);
4030 
4031     return ret;
4032 }
4033 
4034 static int
4035 ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif,
4036                   struct ieee80211_sta *sta,
4037                   const struct cfg80211_bitrate_mask *mask,
4038                   enum nl80211_band band)
4039 {
4040     struct ath11k *ar = arvif->ar;
4041     u8 he_rate, nss;
4042     u32 rate_code;
4043     int ret, i;
4044 
4045     lockdep_assert_held(&ar->conf_mutex);
4046 
4047     nss = 0;
4048 
4049     for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
4050         if (hweight16(mask->control[band].he_mcs[i]) == 1) {
4051             nss = i + 1;
4052             he_rate = ffs(mask->control[band].he_mcs[i]) - 1;
4053         }
4054     }
4055 
4056     if (!nss) {
4057         ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM",
4058                 sta->addr);
4059         return -EINVAL;
4060     }
4061 
4062     /* Avoid updating invalid nss as fixed rate */
4063     if (nss > sta->deflink.rx_nss)
4064         return -EINVAL;
4065 
4066     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4067            "mac setting fixed he rate for peer %pM, device will not switch to any other selected rates",
4068            sta->addr);
4069 
4070     rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1,
4071                     WMI_RATE_PREAMBLE_HE);
4072 
4073     ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4074                     arvif->vdev_id,
4075                     WMI_PEER_PARAM_FIXED_RATE,
4076                     rate_code);
4077     if (ret)
4078         ath11k_warn(ar->ab,
4079                 "failed to update sta %pM fixed rate %d: %d\n",
4080                 sta->addr, rate_code, ret);
4081 
4082     return ret;
4083 }
4084 
4085 static int ath11k_station_assoc(struct ath11k *ar,
4086                 struct ieee80211_vif *vif,
4087                 struct ieee80211_sta *sta,
4088                 bool reassoc)
4089 {
4090     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4091     struct peer_assoc_params peer_arg;
4092     int ret = 0;
4093     struct cfg80211_chan_def def;
4094     enum nl80211_band band;
4095     struct cfg80211_bitrate_mask *mask;
4096     u8 num_vht_rates, num_he_rates;
4097 
4098     lockdep_assert_held(&ar->conf_mutex);
4099 
4100     if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
4101         return -EPERM;
4102 
4103     band = def.chan->band;
4104     mask = &arvif->bitrate_mask;
4105 
4106     ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
4107 
4108     peer_arg.is_assoc = true;
4109     ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4110     if (ret) {
4111         ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4112                 sta->addr, arvif->vdev_id, ret);
4113         return ret;
4114     }
4115 
4116     if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4117         ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4118                 sta->addr, arvif->vdev_id);
4119         return -ETIMEDOUT;
4120     }
4121 
4122     num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
4123     num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask);
4124 
4125     /* If single VHT/HE rate is configured (by set_bitrate_mask()),
4126      * peer_assoc will disable VHT/HE. This is now enabled by a peer specific
4127      * fixed param.
4128      * Note that all other rates and NSS will be disabled for this peer.
4129      */
4130     if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4131         ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4132                              band);
4133         if (ret)
4134             return ret;
4135     } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4136         ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4137                             band);
4138         if (ret)
4139             return ret;
4140     }
4141 
4142     /* Re-assoc is run only to update supported rates for given station. It
4143      * doesn't make much sense to reconfigure the peer completely.
4144      */
4145     if (reassoc)
4146         return 0;
4147 
4148     ret = ath11k_setup_peer_smps(ar, arvif, sta->addr,
4149                      &sta->deflink.ht_cap,
4150                      le16_to_cpu(sta->deflink.he_6ghz_capa.capa));
4151     if (ret) {
4152         ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
4153                 arvif->vdev_id, ret);
4154         return ret;
4155     }
4156 
4157     if (!sta->wme) {
4158         arvif->num_legacy_stations++;
4159         ret = ath11k_recalc_rtscts_prot(arvif);
4160         if (ret)
4161             return ret;
4162     }
4163 
4164     if (sta->wme && sta->uapsd_queues) {
4165         ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta);
4166         if (ret) {
4167             ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
4168                     sta->addr, arvif->vdev_id, ret);
4169             return ret;
4170         }
4171     }
4172 
4173     return 0;
4174 }
4175 
4176 static int ath11k_station_disassoc(struct ath11k *ar,
4177                    struct ieee80211_vif *vif,
4178                    struct ieee80211_sta *sta)
4179 {
4180     struct ath11k_vif *arvif = (void *)vif->drv_priv;
4181     int ret = 0;
4182 
4183     lockdep_assert_held(&ar->conf_mutex);
4184 
4185     if (!sta->wme) {
4186         arvif->num_legacy_stations--;
4187         ret = ath11k_recalc_rtscts_prot(arvif);
4188         if (ret)
4189             return ret;
4190     }
4191 
4192     ret = ath11k_clear_peer_keys(arvif, sta->addr);
4193     if (ret) {
4194         ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
4195                 arvif->vdev_id, ret);
4196         return ret;
4197     }
4198     return 0;
4199 }
4200 
4201 static void ath11k_sta_rc_update_wk(struct work_struct *wk)
4202 {
4203     struct ath11k *ar;
4204     struct ath11k_vif *arvif;
4205     struct ath11k_sta *arsta;
4206     struct ieee80211_sta *sta;
4207     struct cfg80211_chan_def def;
4208     enum nl80211_band band;
4209     const u8 *ht_mcs_mask;
4210     const u16 *vht_mcs_mask;
4211     const u16 *he_mcs_mask;
4212     u32 changed, bw, nss, smps;
4213     int err, num_vht_rates, num_he_rates;
4214     const struct cfg80211_bitrate_mask *mask;
4215     struct peer_assoc_params peer_arg;
4216 
4217     arsta = container_of(wk, struct ath11k_sta, update_wk);
4218     sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4219     arvif = arsta->arvif;
4220     ar = arvif->ar;
4221 
4222     if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def)))
4223         return;
4224 
4225     band = def.chan->band;
4226     ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4227     vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
4228     he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
4229 
4230     spin_lock_bh(&ar->data_lock);
4231 
4232     changed = arsta->changed;
4233     arsta->changed = 0;
4234 
4235     bw = arsta->bw;
4236     nss = arsta->nss;
4237     smps = arsta->smps;
4238 
4239     spin_unlock_bh(&ar->data_lock);
4240 
4241     mutex_lock(&ar->conf_mutex);
4242 
4243     nss = max_t(u32, 1, nss);
4244     nss = min(nss, max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
4245                    ath11k_mac_max_vht_nss(vht_mcs_mask)),
4246                ath11k_mac_max_he_nss(he_mcs_mask)));
4247 
4248     if (changed & IEEE80211_RC_BW_CHANGED) {
4249         /* Send peer assoc command before set peer bandwidth param to
4250          * avoid the mismatch between the peer phymode and the peer
4251          * bandwidth.
4252          */
4253         ath11k_peer_assoc_prepare(ar, arvif->vif, sta, &peer_arg, true);
4254 
4255         peer_arg.is_assoc = false;
4256         err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4257         if (err) {
4258             ath11k_warn(ar->ab, "failed to send peer assoc for STA %pM vdev %i: %d\n",
4259                     sta->addr, arvif->vdev_id, err);
4260         } else if (wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4261             err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4262                             WMI_PEER_CHWIDTH, bw);
4263             if (err)
4264                 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4265                         sta->addr, bw, err);
4266         } else {
4267             ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4268                     sta->addr, arvif->vdev_id);
4269         }
4270     }
4271 
4272     if (changed & IEEE80211_RC_NSS_CHANGED) {
4273         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM nss %d\n",
4274                sta->addr, nss);
4275 
4276         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4277                         WMI_PEER_NSS, nss);
4278         if (err)
4279             ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
4280                     sta->addr, nss, err);
4281     }
4282 
4283     if (changed & IEEE80211_RC_SMPS_CHANGED) {
4284         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM smps %d\n",
4285                sta->addr, smps);
4286 
4287         err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4288                         WMI_PEER_MIMO_PS_STATE, smps);
4289         if (err)
4290             ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
4291                     sta->addr, smps, err);
4292     }
4293 
4294     if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
4295         mask = &arvif->bitrate_mask;
4296         num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
4297                                       mask);
4298         num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
4299                                     mask);
4300 
4301         /* Peer_assoc_prepare will reject vht rates in
4302          * bitrate_mask if its not available in range format and
4303          * sets vht tx_rateset as unsupported. So multiple VHT MCS
4304          * setting(eg. MCS 4,5,6) per peer is not supported here.
4305          * But, Single rate in VHT mask can be set as per-peer
4306          * fixed rate. But even if any HT rates are configured in
4307          * the bitrate mask, device will not switch to those rates
4308          * when per-peer Fixed rate is set.
4309          * TODO: Check RATEMASK_CMDID to support auto rates selection
4310          * across HT/VHT and for multiple VHT MCS support.
4311          */
4312         if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
4313             ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4314                                band);
4315         } else if (sta->deflink.he_cap.has_he && num_he_rates == 1) {
4316             ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4317                               band);
4318         } else {
4319             /* If the peer is non-VHT/HE or no fixed VHT/HE rate
4320              * is provided in the new bitrate mask we set the
4321              * other rates using peer_assoc command. Also clear
4322              * the peer fixed rate settings as it has higher proprity
4323              * than peer assoc
4324              */
4325             err = ath11k_wmi_set_peer_param(ar, sta->addr,
4326                             arvif->vdev_id,
4327                             WMI_PEER_PARAM_FIXED_RATE,
4328                             WMI_FIXED_RATE_NONE);
4329             if (err)
4330                 ath11k_warn(ar->ab,
4331                         "failed to disable peer fixed rate for sta %pM: %d\n",
4332                         sta->addr, err);
4333 
4334             ath11k_peer_assoc_prepare(ar, arvif->vif, sta,
4335                           &peer_arg, true);
4336 
4337             peer_arg.is_assoc = false;
4338             err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4339             if (err)
4340                 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4341                         sta->addr, arvif->vdev_id, err);
4342 
4343             if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
4344                 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4345                         sta->addr, arvif->vdev_id);
4346         }
4347     }
4348 
4349     mutex_unlock(&ar->conf_mutex);
4350 }
4351 
4352 static void ath11k_sta_set_4addr_wk(struct work_struct *wk)
4353 {
4354     struct ath11k *ar;
4355     struct ath11k_vif *arvif;
4356     struct ath11k_sta *arsta;
4357     struct ieee80211_sta *sta;
4358     int ret = 0;
4359 
4360     arsta = container_of(wk, struct ath11k_sta, set_4addr_wk);
4361     sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4362     arvif = arsta->arvif;
4363     ar = arvif->ar;
4364 
4365     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4366            "setting USE_4ADDR for peer %pM\n", sta->addr);
4367 
4368     ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4369                     arvif->vdev_id,
4370                     WMI_PEER_USE_4ADDR, 1);
4371 
4372     if (ret)
4373         ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n",
4374                 sta->addr, ret);
4375 }
4376 
4377 static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif,
4378                        struct ieee80211_sta *sta)
4379 {
4380     struct ath11k *ar = arvif->ar;
4381 
4382     lockdep_assert_held(&ar->conf_mutex);
4383 
4384     if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4385         return 0;
4386 
4387     if (ar->num_stations >= ar->max_num_stations)
4388         return -ENOBUFS;
4389 
4390     ar->num_stations++;
4391 
4392     return 0;
4393 }
4394 
4395 static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif,
4396                     struct ieee80211_sta *sta)
4397 {
4398     struct ath11k *ar = arvif->ar;
4399 
4400     lockdep_assert_held(&ar->conf_mutex);
4401 
4402     if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4403         return;
4404 
4405     ar->num_stations--;
4406 }
4407 
4408 static int ath11k_mac_station_add(struct ath11k *ar,
4409                   struct ieee80211_vif *vif,
4410                   struct ieee80211_sta *sta)
4411 {
4412     struct ath11k_base *ab = ar->ab;
4413     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4414     struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4415     struct peer_create_params peer_param;
4416     int ret;
4417 
4418     lockdep_assert_held(&ar->conf_mutex);
4419 
4420     ret = ath11k_mac_inc_num_stations(arvif, sta);
4421     if (ret) {
4422         ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
4423                 ar->max_num_stations);
4424         goto exit;
4425     }
4426 
4427     arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
4428     if (!arsta->rx_stats) {
4429         ret = -ENOMEM;
4430         goto dec_num_station;
4431     }
4432 
4433     peer_param.vdev_id = arvif->vdev_id;
4434     peer_param.peer_addr = sta->addr;
4435     peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
4436 
4437     ret = ath11k_peer_create(ar, arvif, sta, &peer_param);
4438     if (ret) {
4439         ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
4440                 sta->addr, arvif->vdev_id);
4441         goto free_rx_stats;
4442     }
4443 
4444     ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
4445            sta->addr, arvif->vdev_id);
4446 
4447     if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) {
4448         arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL);
4449         if (!arsta->tx_stats) {
4450             ret = -ENOMEM;
4451             goto free_peer;
4452         }
4453     }
4454 
4455     if (ieee80211_vif_is_mesh(vif)) {
4456         ath11k_dbg(ab, ATH11K_DBG_MAC,
4457                "setting USE_4ADDR for mesh STA %pM\n", sta->addr);
4458         ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4459                         arvif->vdev_id,
4460                         WMI_PEER_USE_4ADDR, 1);
4461         if (ret) {
4462             ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n",
4463                     sta->addr, ret);
4464             goto free_tx_stats;
4465         }
4466     }
4467 
4468     ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
4469     if (ret) {
4470         ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
4471                 sta->addr, arvif->vdev_id, ret);
4472         goto free_tx_stats;
4473     }
4474 
4475     if (ab->hw_params.vdev_start_delay &&
4476         !arvif->is_started &&
4477         arvif->vdev_type != WMI_VDEV_TYPE_AP) {
4478         ret = ath11k_start_vdev_delay(ar->hw, vif);
4479         if (ret) {
4480             ath11k_warn(ab, "failed to delay vdev start: %d\n", ret);
4481             goto free_tx_stats;
4482         }
4483     }
4484 
4485     ewma_avg_rssi_init(&arsta->avg_rssi);
4486     return 0;
4487 
4488 free_tx_stats:
4489     kfree(arsta->tx_stats);
4490     arsta->tx_stats = NULL;
4491 free_peer:
4492     ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4493 free_rx_stats:
4494     kfree(arsta->rx_stats);
4495     arsta->rx_stats = NULL;
4496 dec_num_station:
4497     ath11k_mac_dec_num_stations(arvif, sta);
4498 exit:
4499     return ret;
4500 }
4501 
4502 static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
4503                    struct ieee80211_vif *vif,
4504                    struct ieee80211_sta *sta,
4505                    enum ieee80211_sta_state old_state,
4506                    enum ieee80211_sta_state new_state)
4507 {
4508     struct ath11k *ar = hw->priv;
4509     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4510     struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4511     struct ath11k_peer *peer;
4512     int ret = 0;
4513 
4514     /* cancel must be done outside the mutex to avoid deadlock */
4515     if ((old_state == IEEE80211_STA_NONE &&
4516          new_state == IEEE80211_STA_NOTEXIST)) {
4517         cancel_work_sync(&arsta->update_wk);
4518         cancel_work_sync(&arsta->set_4addr_wk);
4519     }
4520 
4521     mutex_lock(&ar->conf_mutex);
4522 
4523     if (old_state == IEEE80211_STA_NOTEXIST &&
4524         new_state == IEEE80211_STA_NONE) {
4525         memset(arsta, 0, sizeof(*arsta));
4526         arsta->arvif = arvif;
4527         INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
4528         INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
4529 
4530         ret = ath11k_mac_station_add(ar, vif, sta);
4531         if (ret)
4532             ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
4533                     sta->addr, arvif->vdev_id);
4534     } else if ((old_state == IEEE80211_STA_NONE &&
4535             new_state == IEEE80211_STA_NOTEXIST)) {
4536         bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay &&
4537             vif->type == NL80211_IFTYPE_STATION;
4538 
4539         ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
4540 
4541         if (!skip_peer_delete) {
4542             ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4543             if (ret)
4544                 ath11k_warn(ar->ab,
4545                         "Failed to delete peer: %pM for VDEV: %d\n",
4546                         sta->addr, arvif->vdev_id);
4547             else
4548                 ath11k_dbg(ar->ab,
4549                        ATH11K_DBG_MAC,
4550                        "Removed peer: %pM for VDEV: %d\n",
4551                        sta->addr, arvif->vdev_id);
4552         }
4553 
4554         ath11k_mac_dec_num_stations(arvif, sta);
4555         mutex_lock(&ar->ab->tbl_mtx_lock);
4556         spin_lock_bh(&ar->ab->base_lock);
4557         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4558         if (skip_peer_delete && peer) {
4559             peer->sta = NULL;
4560         } else if (peer && peer->sta == sta) {
4561             ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
4562                     vif->addr, arvif->vdev_id);
4563             ath11k_peer_rhash_delete(ar->ab, peer);
4564             peer->sta = NULL;
4565             list_del(&peer->list);
4566             kfree(peer);
4567             ar->num_peers--;
4568         }
4569         spin_unlock_bh(&ar->ab->base_lock);
4570         mutex_unlock(&ar->ab->tbl_mtx_lock);
4571 
4572         kfree(arsta->tx_stats);
4573         arsta->tx_stats = NULL;
4574 
4575         kfree(arsta->rx_stats);
4576         arsta->rx_stats = NULL;
4577     } else if (old_state == IEEE80211_STA_AUTH &&
4578            new_state == IEEE80211_STA_ASSOC &&
4579            (vif->type == NL80211_IFTYPE_AP ||
4580             vif->type == NL80211_IFTYPE_MESH_POINT ||
4581             vif->type == NL80211_IFTYPE_ADHOC)) {
4582         ret = ath11k_station_assoc(ar, vif, sta, false);
4583         if (ret)
4584             ath11k_warn(ar->ab, "Failed to associate station: %pM\n",
4585                     sta->addr);
4586     } else if (old_state == IEEE80211_STA_ASSOC &&
4587            new_state == IEEE80211_STA_AUTHORIZED) {
4588         spin_lock_bh(&ar->ab->base_lock);
4589 
4590         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4591         if (peer)
4592             peer->is_authorized = true;
4593 
4594         spin_unlock_bh(&ar->ab->base_lock);
4595 
4596         if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
4597             ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4598                             arvif->vdev_id,
4599                             WMI_PEER_AUTHORIZE,
4600                             1);
4601             if (ret)
4602                 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
4603                         sta->addr, arvif->vdev_id, ret);
4604         }
4605     } else if (old_state == IEEE80211_STA_AUTHORIZED &&
4606            new_state == IEEE80211_STA_ASSOC) {
4607         spin_lock_bh(&ar->ab->base_lock);
4608 
4609         peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4610         if (peer)
4611             peer->is_authorized = false;
4612 
4613         spin_unlock_bh(&ar->ab->base_lock);
4614     } else if (old_state == IEEE80211_STA_ASSOC &&
4615            new_state == IEEE80211_STA_AUTH &&
4616            (vif->type == NL80211_IFTYPE_AP ||
4617             vif->type == NL80211_IFTYPE_MESH_POINT ||
4618             vif->type == NL80211_IFTYPE_ADHOC)) {
4619         ret = ath11k_station_disassoc(ar, vif, sta);
4620         if (ret)
4621             ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n",
4622                     sta->addr);
4623     }
4624 
4625     mutex_unlock(&ar->conf_mutex);
4626     return ret;
4627 }
4628 
4629 static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
4630                        struct ieee80211_vif *vif,
4631                        struct ieee80211_sta *sta)
4632 {
4633     struct ath11k *ar = hw->priv;
4634     struct ath11k_vif *arvif = (void *)vif->drv_priv;
4635     int ret = 0;
4636     s16 txpwr;
4637 
4638     if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
4639         txpwr = 0;
4640     } else {
4641         txpwr = sta->deflink.txpwr.power;
4642         if (!txpwr)
4643             return -EINVAL;
4644     }
4645 
4646     if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL)
4647         return -EINVAL;
4648 
4649     mutex_lock(&ar->conf_mutex);
4650 
4651     ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4652                     WMI_PEER_USE_FIXED_PWR, txpwr);
4653     if (ret) {
4654         ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
4655                 ret);
4656         goto out;
4657     }
4658 
4659 out:
4660     mutex_unlock(&ar->conf_mutex);
4661     return ret;
4662 }
4663 
4664 static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw,
4665                     struct ieee80211_vif *vif,
4666                     struct ieee80211_sta *sta, bool enabled)
4667 {
4668     struct ath11k *ar = hw->priv;
4669     struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4670 
4671     if (enabled && !arsta->use_4addr_set) {
4672         ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk);
4673         arsta->use_4addr_set = true;
4674     }
4675 }
4676 
4677 static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
4678                     struct ieee80211_vif *vif,
4679                     struct ieee80211_sta *sta,
4680                     u32 changed)
4681 {
4682     struct ath11k *ar = hw->priv;
4683     struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4684     struct ath11k_vif *arvif = (void *)vif->drv_priv;
4685     struct ath11k_peer *peer;
4686     u32 bw, smps;
4687 
4688     spin_lock_bh(&ar->ab->base_lock);
4689 
4690     peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4691     if (!peer) {
4692         spin_unlock_bh(&ar->ab->base_lock);
4693         ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
4694                 sta->addr, arvif->vdev_id);
4695         return;
4696     }
4697 
4698     spin_unlock_bh(&ar->ab->base_lock);
4699 
4700     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4701            "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4702            sta->addr, changed, sta->deflink.bandwidth,
4703            sta->deflink.rx_nss,
4704            sta->smps_mode);
4705 
4706     spin_lock_bh(&ar->data_lock);
4707 
4708     if (changed & IEEE80211_RC_BW_CHANGED) {
4709         bw = WMI_PEER_CHWIDTH_20MHZ;
4710 
4711         switch (sta->deflink.bandwidth) {
4712         case IEEE80211_STA_RX_BW_20:
4713             bw = WMI_PEER_CHWIDTH_20MHZ;
4714             break;
4715         case IEEE80211_STA_RX_BW_40:
4716             bw = WMI_PEER_CHWIDTH_40MHZ;
4717             break;
4718         case IEEE80211_STA_RX_BW_80:
4719             bw = WMI_PEER_CHWIDTH_80MHZ;
4720             break;
4721         case IEEE80211_STA_RX_BW_160:
4722             bw = WMI_PEER_CHWIDTH_160MHZ;
4723             break;
4724         default:
4725             ath11k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n",
4726                     sta->deflink.bandwidth, sta->addr);
4727             bw = WMI_PEER_CHWIDTH_20MHZ;
4728             break;
4729         }
4730 
4731         arsta->bw = bw;
4732     }
4733 
4734     if (changed & IEEE80211_RC_NSS_CHANGED)
4735         arsta->nss = sta->deflink.rx_nss;
4736 
4737     if (changed & IEEE80211_RC_SMPS_CHANGED) {
4738         smps = WMI_PEER_SMPS_PS_NONE;
4739 
4740         switch (sta->smps_mode) {
4741         case IEEE80211_SMPS_AUTOMATIC:
4742         case IEEE80211_SMPS_OFF:
4743             smps = WMI_PEER_SMPS_PS_NONE;
4744             break;
4745         case IEEE80211_SMPS_STATIC:
4746             smps = WMI_PEER_SMPS_STATIC;
4747             break;
4748         case IEEE80211_SMPS_DYNAMIC:
4749             smps = WMI_PEER_SMPS_DYNAMIC;
4750             break;
4751         default:
4752             ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
4753                     sta->smps_mode, sta->addr);
4754             smps = WMI_PEER_SMPS_PS_NONE;
4755             break;
4756         }
4757 
4758         arsta->smps = smps;
4759     }
4760 
4761     arsta->changed |= changed;
4762 
4763     spin_unlock_bh(&ar->data_lock);
4764 
4765     ieee80211_queue_work(hw, &arsta->update_wk);
4766 }
4767 
4768 static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif,
4769                 u16 ac, bool enable)
4770 {
4771     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4772     u32 value = 0;
4773     int ret = 0;
4774 
4775     if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
4776         return 0;
4777 
4778     switch (ac) {
4779     case IEEE80211_AC_VO:
4780         value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
4781             WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
4782         break;
4783     case IEEE80211_AC_VI:
4784         value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
4785             WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
4786         break;
4787     case IEEE80211_AC_BE:
4788         value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
4789             WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
4790         break;
4791     case IEEE80211_AC_BK:
4792         value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
4793             WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
4794         break;
4795     }
4796 
4797     if (enable)
4798         arvif->u.sta.uapsd |= value;
4799     else
4800         arvif->u.sta.uapsd &= ~value;
4801 
4802     ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4803                       WMI_STA_PS_PARAM_UAPSD,
4804                       arvif->u.sta.uapsd);
4805     if (ret) {
4806         ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret);
4807         goto exit;
4808     }
4809 
4810     if (arvif->u.sta.uapsd)
4811         value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
4812     else
4813         value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4814 
4815     ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4816                       WMI_STA_PS_PARAM_RX_WAKE_POLICY,
4817                       value);
4818     if (ret)
4819         ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret);
4820 
4821 exit:
4822     return ret;
4823 }
4824 
4825 static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw,
4826                  struct ieee80211_vif *vif,
4827                  unsigned int link_id, u16 ac,
4828                  const struct ieee80211_tx_queue_params *params)
4829 {
4830     struct ath11k *ar = hw->priv;
4831     struct ath11k_vif *arvif = (void *)vif->drv_priv;
4832     struct wmi_wmm_params_arg *p = NULL;
4833     int ret;
4834 
4835     mutex_lock(&ar->conf_mutex);
4836 
4837     switch (ac) {
4838     case IEEE80211_AC_VO:
4839         p = &arvif->wmm_params.ac_vo;
4840         break;
4841     case IEEE80211_AC_VI:
4842         p = &arvif->wmm_params.ac_vi;
4843         break;
4844     case IEEE80211_AC_BE:
4845         p = &arvif->wmm_params.ac_be;
4846         break;
4847     case IEEE80211_AC_BK:
4848         p = &arvif->wmm_params.ac_bk;
4849         break;
4850     }
4851 
4852     if (WARN_ON(!p)) {
4853         ret = -EINVAL;
4854         goto exit;
4855     }
4856 
4857     p->cwmin = params->cw_min;
4858     p->cwmax = params->cw_max;
4859     p->aifs = params->aifs;
4860     p->txop = params->txop;
4861 
4862     ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
4863                          &arvif->wmm_params);
4864     if (ret) {
4865         ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
4866         goto exit;
4867     }
4868 
4869     ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
4870 
4871     if (ret)
4872         ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
4873 
4874 exit:
4875     mutex_unlock(&ar->conf_mutex);
4876     return ret;
4877 }
4878 
4879 static struct ieee80211_sta_ht_cap
4880 ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
4881 {
4882     int i;
4883     struct ieee80211_sta_ht_cap ht_cap = {0};
4884     u32 ar_vht_cap = ar->pdev->cap.vht_cap;
4885 
4886     if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
4887         return ht_cap;
4888 
4889     ht_cap.ht_supported = 1;
4890     ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4891     ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
4892     ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4893     ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4894     ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4895 
4896     if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
4897         ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4898 
4899     if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
4900         ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4901 
4902     if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
4903         u32 smps;
4904 
4905         smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4906         smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4907 
4908         ht_cap.cap |= smps;
4909     }
4910 
4911     if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
4912         ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4913 
4914     if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
4915         u32 stbc;
4916 
4917         stbc   = ar_ht_cap;
4918         stbc  &= WMI_HT_CAP_RX_STBC;
4919         stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4920         stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4921         stbc  &= IEEE80211_HT_CAP_RX_STBC;
4922 
4923         ht_cap.cap |= stbc;
4924     }
4925 
4926     if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
4927         ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4928 
4929     if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
4930         ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4931 
4932     if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4933         ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4934 
4935     for (i = 0; i < ar->num_rx_chains; i++) {
4936         if (rate_cap_rx_chainmask & BIT(i))
4937             ht_cap.mcs.rx_mask[i] = 0xFF;
4938     }
4939 
4940     ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4941 
4942     return ht_cap;
4943 }
4944 
4945 static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
4946 {
4947     u32 value = 0;
4948     struct ath11k *ar = arvif->ar;
4949     int nsts;
4950     int sound_dim;
4951     u32 vht_cap = ar->pdev->cap.vht_cap;
4952     u32 vdev_param = WMI_VDEV_PARAM_TXBF;
4953 
4954     if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
4955         nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4956         nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4957         value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4958     }
4959 
4960     if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
4961         sound_dim = vht_cap &
4962                 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4963         sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4964         if (sound_dim > (ar->num_tx_chains - 1))
4965             sound_dim = ar->num_tx_chains - 1;
4966         value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4967     }
4968 
4969     if (!value)
4970         return 0;
4971 
4972     if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
4973         value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4974 
4975         if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
4976             arvif->vdev_type == WMI_VDEV_TYPE_AP)
4977             value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
4978     }
4979 
4980     /* TODO: SUBFEE not validated in HK, disable here until validated? */
4981 
4982     if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
4983         value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4984 
4985         if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
4986             arvif->vdev_type == WMI_VDEV_TYPE_STA)
4987             value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
4988     }
4989 
4990     return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
4991                          vdev_param, value);
4992 }
4993 
4994 static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
4995 {
4996     bool subfer, subfee;
4997     int sound_dim = 0;
4998 
4999     subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
5000     subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
5001 
5002     if (ar->num_tx_chains < 2) {
5003         *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
5004         subfer = false;
5005     }
5006 
5007     /* If SU Beaformer is not set, then disable MU Beamformer Capability */
5008     if (!subfer)
5009         *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
5010 
5011     /* If SU Beaformee is not set, then disable MU Beamformee Capability */
5012     if (!subfee)
5013         *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5014 
5015     sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5016     sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5017     *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5018 
5019     /* TODO: Need to check invalid STS and Sound_dim values set by FW? */
5020 
5021     /* Enable Sounding Dimension Field only if SU BF is enabled */
5022     if (subfer) {
5023         if (sound_dim > (ar->num_tx_chains - 1))
5024             sound_dim = ar->num_tx_chains - 1;
5025 
5026         sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5027         sound_dim &=  IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5028         *vht_cap |= sound_dim;
5029     }
5030 
5031     /* Use the STS advertised by FW unless SU Beamformee is not supported*/
5032     if (!subfee)
5033         *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5034 }
5035 
5036 static struct ieee80211_sta_vht_cap
5037 ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5038               u32 rate_cap_rx_chainmask)
5039 {
5040     struct ieee80211_sta_vht_cap vht_cap = {0};
5041     u16 txmcs_map, rxmcs_map;
5042     int i;
5043 
5044     vht_cap.vht_supported = 1;
5045     vht_cap.cap = ar->pdev->cap.vht_cap;
5046 
5047     if (ar->pdev->cap.nss_ratio_enabled)
5048         vht_cap.vht_mcs.tx_highest |=
5049             cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5050 
5051     ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5052 
5053     rxmcs_map = 0;
5054     txmcs_map = 0;
5055     for (i = 0; i < 8; i++) {
5056         if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5057             txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5058         else
5059             txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5060 
5061         if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5062             rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5063         else
5064             rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5065     }
5066 
5067     if (rate_cap_tx_chainmask <= 1)
5068         vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5069 
5070     vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5071     vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5072 
5073     return vht_cap;
5074 }
5075 
5076 static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5077                     struct ath11k_pdev_cap *cap,
5078                     u32 *ht_cap_info)
5079 {
5080     struct ieee80211_supported_band *band;
5081     u32 rate_cap_tx_chainmask;
5082     u32 rate_cap_rx_chainmask;
5083     u32 ht_cap;
5084 
5085     rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5086     rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5087 
5088     if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5089         band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5090         ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5091         if (ht_cap_info)
5092             *ht_cap_info = ht_cap;
5093         band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5094                             rate_cap_rx_chainmask);
5095     }
5096 
5097     if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5098         (ar->ab->hw_params.single_pdev_only ||
5099          !ar->supports_6ghz)) {
5100         band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5101         ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
5102         if (ht_cap_info)
5103             *ht_cap_info = ht_cap;
5104         band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5105                             rate_cap_rx_chainmask);
5106         band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5107                               rate_cap_rx_chainmask);
5108     }
5109 }
5110 
5111 static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5112 {
5113     /* TODO: Check the request chainmask against the supported
5114      * chainmask table which is advertised in extented_service_ready event
5115      */
5116 
5117     return 0;
5118 }
5119 
5120 static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5121                   u8 *he_ppet)
5122 {
5123     int nss, ru;
5124     u8 bit = 7;
5125 
5126     he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5127     he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5128                IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5129               IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5130     for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5131         for (ru = 0; ru < 4; ru++) {
5132             u8 val;
5133             int i;
5134 
5135             if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5136                 continue;
5137             val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5138                    0x3f;
5139             val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5140             for (i = 5; i >= 0; i--) {
5141                 he_ppet[bit / 8] |=
5142                     ((val >> i) & 0x1) << ((bit % 8));
5143                 bit++;
5144             }
5145         }
5146     }
5147 }
5148 
5149 static void
5150 ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5151 {
5152     u8 m;
5153 
5154     m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5155         IEEE80211_HE_MAC_CAP0_TWT_REQ;
5156     he_cap_elem->mac_cap_info[0] &= ~m;
5157 
5158     m = IEEE80211_HE_MAC_CAP2_TRS |
5159         IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5160         IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5161     he_cap_elem->mac_cap_info[2] &= ~m;
5162 
5163     m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5164         IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5165         IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5166     he_cap_elem->mac_cap_info[3] &= ~m;
5167 
5168     m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5169         IEEE80211_HE_MAC_CAP4_BQR;
5170     he_cap_elem->mac_cap_info[4] &= ~m;
5171 
5172     m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
5173         IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5174         IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5175         IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5176     he_cap_elem->mac_cap_info[5] &= ~m;
5177 
5178     m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5179         IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5180     he_cap_elem->phy_cap_info[2] &= ~m;
5181 
5182     m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
5183         IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5184         IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5185     he_cap_elem->phy_cap_info[3] &= ~m;
5186 
5187     m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5188     he_cap_elem->phy_cap_info[4] &= ~m;
5189 
5190     m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5191     he_cap_elem->phy_cap_info[5] &= ~m;
5192 
5193     m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
5194         IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
5195         IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5196         IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5197     he_cap_elem->phy_cap_info[6] &= ~m;
5198 
5199     m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5200         IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
5201         IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5202         IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5203     he_cap_elem->phy_cap_info[7] &= ~m;
5204 
5205     m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5206         IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5207         IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5208         IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5209     he_cap_elem->phy_cap_info[8] &= ~m;
5210 
5211     m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5212         IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5213         IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5214         IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5215         IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5216         IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5217     he_cap_elem->phy_cap_info[9] &= ~m;
5218 }
5219 
5220 static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5221                        struct ath11k_band_cap *bcap)
5222 {
5223     u8 val;
5224 
5225     bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5226     if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5227         bcap->he_6ghz_capa |=
5228             FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5229                    WLAN_HT_CAP_SM_PS_DYNAMIC);
5230     else
5231         bcap->he_6ghz_capa |=
5232             FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5233                    WLAN_HT_CAP_SM_PS_DISABLED);
5234     val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5235             pcap->vht_cap);
5236     bcap->he_6ghz_capa |=
5237         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5238     val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5239     bcap->he_6ghz_capa |=
5240         FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5241     if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5242         bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5243     if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5244         bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5245 
5246     return cpu_to_le16(bcap->he_6ghz_capa);
5247 }
5248 
5249 static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5250                   struct ath11k_pdev_cap *cap,
5251                   struct ieee80211_sband_iftype_data *data,
5252                   int band)
5253 {
5254     int i, idx = 0;
5255 
5256     for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5257         struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5258         struct ath11k_band_cap *band_cap = &cap->band[band];
5259         struct ieee80211_he_cap_elem *he_cap_elem =
5260                 &he_cap->he_cap_elem;
5261 
5262         switch (i) {
5263         case NL80211_IFTYPE_STATION:
5264         case NL80211_IFTYPE_AP:
5265         case NL80211_IFTYPE_MESH_POINT:
5266             break;
5267 
5268         default:
5269             continue;
5270         }
5271 
5272         data[idx].types_mask = BIT(i);
5273         he_cap->has_he = true;
5274         memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5275                sizeof(he_cap_elem->mac_cap_info));
5276         memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5277                sizeof(he_cap_elem->phy_cap_info));
5278 
5279         he_cap_elem->mac_cap_info[1] &=
5280             IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
5281 
5282         he_cap_elem->phy_cap_info[5] &=
5283             ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
5284         he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5285 
5286         switch (i) {
5287         case NL80211_IFTYPE_AP:
5288             he_cap_elem->phy_cap_info[3] &=
5289                 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
5290             he_cap_elem->phy_cap_info[9] |=
5291                 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5292             break;
5293         case NL80211_IFTYPE_STATION:
5294             he_cap_elem->mac_cap_info[0] &=
5295                 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5296             he_cap_elem->mac_cap_info[0] |=
5297                 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5298             he_cap_elem->phy_cap_info[9] |=
5299                 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5300             break;
5301         case NL80211_IFTYPE_MESH_POINT:
5302             ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5303             break;
5304         }
5305 
5306         he_cap->he_mcs_nss_supp.rx_mcs_80 =
5307             cpu_to_le16(band_cap->he_mcs & 0xffff);
5308         he_cap->he_mcs_nss_supp.tx_mcs_80 =
5309             cpu_to_le16(band_cap->he_mcs & 0xffff);
5310         he_cap->he_mcs_nss_supp.rx_mcs_160 =
5311             cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5312         he_cap->he_mcs_nss_supp.tx_mcs_160 =
5313             cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5314         he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5315             cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5316         he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5317             cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5318 
5319         memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5320         if (he_cap_elem->phy_cap_info[6] &
5321             IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5322             ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5323                           he_cap->ppe_thres);
5324 
5325         if (band == NL80211_BAND_6GHZ) {
5326             data[idx].he_6ghz_capa.capa =
5327                 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5328         }
5329         idx++;
5330     }
5331 
5332     return idx;
5333 }
5334 
5335 static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5336                     struct ath11k_pdev_cap *cap)
5337 {
5338     struct ieee80211_supported_band *band;
5339     int count;
5340 
5341     if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5342         count = ath11k_mac_copy_he_cap(ar, cap,
5343                            ar->mac.iftype[NL80211_BAND_2GHZ],
5344                            NL80211_BAND_2GHZ);
5345         band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5346         band->iftype_data = ar->mac.iftype[NL80211_BAND_2GHZ];
5347         band->n_iftype_data = count;
5348     }
5349 
5350     if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5351         count = ath11k_mac_copy_he_cap(ar, cap,
5352                            ar->mac.iftype[NL80211_BAND_5GHZ],
5353                            NL80211_BAND_5GHZ);
5354         band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5355         band->iftype_data = ar->mac.iftype[NL80211_BAND_5GHZ];
5356         band->n_iftype_data = count;
5357     }
5358 
5359     if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5360         ar->supports_6ghz) {
5361         count = ath11k_mac_copy_he_cap(ar, cap,
5362                            ar->mac.iftype[NL80211_BAND_6GHZ],
5363                            NL80211_BAND_6GHZ);
5364         band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5365         band->iftype_data = ar->mac.iftype[NL80211_BAND_6GHZ];
5366         band->n_iftype_data = count;
5367     }
5368 }
5369 
5370 static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5371 {
5372     int ret;
5373 
5374     lockdep_assert_held(&ar->conf_mutex);
5375 
5376     if (ath11k_check_chain_mask(ar, tx_ant, true))
5377         return -EINVAL;
5378 
5379     if (ath11k_check_chain_mask(ar, rx_ant, false))
5380         return -EINVAL;
5381 
5382     ar->cfg_tx_chainmask = tx_ant;
5383     ar->cfg_rx_chainmask = rx_ant;
5384 
5385     if (ar->state != ATH11K_STATE_ON &&
5386         ar->state != ATH11K_STATE_RESTARTED)
5387         return 0;
5388 
5389     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5390                     tx_ant, ar->pdev->pdev_id);
5391     if (ret) {
5392         ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5393                 ret, tx_ant);
5394         return ret;
5395     }
5396 
5397     ar->num_tx_chains = get_num_chains(tx_ant);
5398 
5399     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5400                     rx_ant, ar->pdev->pdev_id);
5401     if (ret) {
5402         ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5403                 ret, rx_ant);
5404         return ret;
5405     }
5406 
5407     ar->num_rx_chains = get_num_chains(rx_ant);
5408 
5409     /* Reload HT/VHT/HE capability */
5410     ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
5411     ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
5412 
5413     return 0;
5414 }
5415 
5416 static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5417 {
5418     int num_mgmt;
5419 
5420     ieee80211_free_txskb(ar->hw, skb);
5421 
5422     num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5423 
5424     if (num_mgmt < 0)
5425         WARN_ON_ONCE(1);
5426 
5427     if (!num_mgmt)
5428         wake_up(&ar->txmgmt_empty_waitq);
5429 }
5430 
5431 static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
5432 {
5433     struct sk_buff *msdu;
5434     struct ieee80211_tx_info *info;
5435 
5436     spin_lock_bh(&ar->txmgmt_idr_lock);
5437     msdu = idr_remove(&ar->txmgmt_idr, buf_id);
5438     spin_unlock_bh(&ar->txmgmt_idr_lock);
5439 
5440     if (!msdu)
5441         return;
5442 
5443     dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
5444              DMA_TO_DEVICE);
5445 
5446     info = IEEE80211_SKB_CB(msdu);
5447     memset(&info->status, 0, sizeof(info->status));
5448 
5449     ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
5450 }
5451 
5452 int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
5453 {
5454     struct ath11k *ar = ctx;
5455 
5456     ath11k_mac_tx_mgmt_free(ar, buf_id);
5457 
5458     return 0;
5459 }
5460 
5461 static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
5462 {
5463     struct ieee80211_vif *vif = ctx;
5464     struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
5465     struct ath11k *ar = skb_cb->ar;
5466 
5467     if (skb_cb->vif == vif)
5468         ath11k_mac_tx_mgmt_free(ar, buf_id);
5469 
5470     return 0;
5471 }
5472 
5473 static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
5474                   struct sk_buff *skb)
5475 {
5476     struct ath11k_base *ab = ar->ab;
5477     struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5478     struct ieee80211_tx_info *info;
5479     dma_addr_t paddr;
5480     int buf_id;
5481     int ret;
5482 
5483     ATH11K_SKB_CB(skb)->ar = ar;
5484 
5485     spin_lock_bh(&ar->txmgmt_idr_lock);
5486     buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
5487                ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
5488     spin_unlock_bh(&ar->txmgmt_idr_lock);
5489 
5490     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5491            "mac tx mgmt frame, buf id %d\n", buf_id);
5492 
5493     if (buf_id < 0)
5494         return -ENOSPC;
5495 
5496     info = IEEE80211_SKB_CB(skb);
5497     if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
5498         if ((ieee80211_is_action(hdr->frame_control) ||
5499              ieee80211_is_deauth(hdr->frame_control) ||
5500              ieee80211_is_disassoc(hdr->frame_control)) &&
5501              ieee80211_has_protected(hdr->frame_control)) {
5502             skb_put(skb, IEEE80211_CCMP_MIC_LEN);
5503         }
5504     }
5505 
5506     paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
5507     if (dma_mapping_error(ab->dev, paddr)) {
5508         ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
5509         ret = -EIO;
5510         goto err_free_idr;
5511     }
5512 
5513     ATH11K_SKB_CB(skb)->paddr = paddr;
5514 
5515     ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
5516     if (ret) {
5517         ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
5518         goto err_unmap_buf;
5519     }
5520 
5521     return 0;
5522 
5523 err_unmap_buf:
5524     dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
5525              skb->len, DMA_TO_DEVICE);
5526 err_free_idr:
5527     spin_lock_bh(&ar->txmgmt_idr_lock);
5528     idr_remove(&ar->txmgmt_idr, buf_id);
5529     spin_unlock_bh(&ar->txmgmt_idr_lock);
5530 
5531     return ret;
5532 }
5533 
5534 static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
5535 {
5536     struct sk_buff *skb;
5537 
5538     while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
5539         ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5540 }
5541 
5542 static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
5543 {
5544     struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
5545     struct ath11k_skb_cb *skb_cb;
5546     struct ath11k_vif *arvif;
5547     struct sk_buff *skb;
5548     int ret;
5549 
5550     while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
5551         skb_cb = ATH11K_SKB_CB(skb);
5552         if (!skb_cb->vif) {
5553             ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
5554             ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5555             continue;
5556         }
5557 
5558         arvif = ath11k_vif_to_arvif(skb_cb->vif);
5559         mutex_lock(&ar->conf_mutex);
5560         if (ar->allocated_vdev_map & (1LL << arvif->vdev_id)) {
5561             ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
5562             if (ret) {
5563                 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
5564                         arvif->vdev_id, ret);
5565                 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5566             } else {
5567                 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5568                        "mac tx mgmt frame, vdev_id %d\n",
5569                        arvif->vdev_id);
5570             }
5571         } else {
5572             ath11k_warn(ar->ab,
5573                     "dropping mgmt frame for vdev %d, is_started %d\n",
5574                     arvif->vdev_id,
5575                     arvif->is_started);
5576             ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5577         }
5578         mutex_unlock(&ar->conf_mutex);
5579     }
5580 }
5581 
5582 static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
5583                   bool is_prb_rsp)
5584 {
5585     struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
5586 
5587     if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
5588         return -ESHUTDOWN;
5589 
5590     /* Drop probe response packets when the pending management tx
5591      * count has reached a certain threshold, so as to prioritize
5592      * other mgmt packets like auth and assoc to be sent on time
5593      * for establishing successful connections.
5594      */
5595     if (is_prb_rsp &&
5596         atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
5597         ath11k_warn(ar->ab,
5598                 "dropping probe response as pending queue is almost full\n");
5599         return -ENOSPC;
5600     }
5601 
5602     if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
5603         ath11k_warn(ar->ab, "mgmt tx queue is full\n");
5604         return -ENOSPC;
5605     }
5606 
5607     skb_queue_tail(q, skb);
5608     atomic_inc(&ar->num_pending_mgmt_tx);
5609     queue_work(ar->ab->workqueue_aux, &ar->wmi_mgmt_tx_work);
5610 
5611     return 0;
5612 }
5613 
5614 static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
5615                  struct ieee80211_tx_control *control,
5616                  struct sk_buff *skb)
5617 {
5618     struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
5619     struct ath11k *ar = hw->priv;
5620     struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
5621     struct ieee80211_vif *vif = info->control.vif;
5622     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5623     struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5624     struct ieee80211_key_conf *key = info->control.hw_key;
5625     struct ath11k_sta *arsta = NULL;
5626     u32 info_flags = info->flags;
5627     bool is_prb_rsp;
5628     int ret;
5629 
5630     memset(skb_cb, 0, sizeof(*skb_cb));
5631     skb_cb->vif = vif;
5632 
5633     if (key) {
5634         skb_cb->cipher = key->cipher;
5635         skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
5636     }
5637 
5638     if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
5639         skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
5640     } else if (ieee80211_is_mgmt(hdr->frame_control)) {
5641         is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
5642         ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
5643         if (ret) {
5644             ath11k_warn(ar->ab, "failed to queue management frame %d\n",
5645                     ret);
5646             ieee80211_free_txskb(ar->hw, skb);
5647         }
5648         return;
5649     }
5650 
5651     if (control->sta)
5652         arsta = (struct ath11k_sta *)control->sta->drv_priv;
5653 
5654     ret = ath11k_dp_tx(ar, arvif, arsta, skb);
5655     if (unlikely(ret)) {
5656         ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
5657         ieee80211_free_txskb(ar->hw, skb);
5658     }
5659 }
5660 
5661 void ath11k_mac_drain_tx(struct ath11k *ar)
5662 {
5663     /* make sure rcu-protected mac80211 tx path itself is drained */
5664     synchronize_net();
5665 
5666     cancel_work_sync(&ar->wmi_mgmt_tx_work);
5667     ath11k_mgmt_over_wmi_tx_purge(ar);
5668 }
5669 
5670 static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
5671 {
5672     struct htt_rx_ring_tlv_filter tlv_filter = {0};
5673     struct ath11k_base *ab = ar->ab;
5674     int i, ret = 0;
5675     u32 ring_id;
5676 
5677     if (enable) {
5678         tlv_filter = ath11k_mac_mon_status_filter_default;
5679         if (ath11k_debugfs_rx_filter(ar))
5680             tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
5681     }
5682 
5683     for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
5684         ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
5685         ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
5686                                ar->dp.mac_id + i,
5687                                HAL_RXDMA_MONITOR_STATUS,
5688                                DP_RX_BUFFER_SIZE,
5689                                &tlv_filter);
5690     }
5691 
5692     if (enable && !ar->ab->hw_params.rxdma1_enable)
5693         mod_timer(&ar->ab->mon_reap_timer, jiffies +
5694               msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
5695 
5696     return ret;
5697 }
5698 
5699 static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
5700 {
5701     int recovery_start_count;
5702 
5703     if (!ab->is_reset)
5704         return;
5705 
5706     recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
5707     ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
5708 
5709     if (recovery_start_count == ab->num_radios) {
5710         complete(&ab->recovery_start);
5711         ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
5712     }
5713 
5714     ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
5715 
5716     wait_for_completion_timeout(&ab->reconfigure_complete,
5717                     ATH11K_RECONFIGURE_TIMEOUT_HZ);
5718 }
5719 
5720 static int ath11k_mac_op_start(struct ieee80211_hw *hw)
5721 {
5722     struct ath11k *ar = hw->priv;
5723     struct ath11k_base *ab = ar->ab;
5724     struct ath11k_pdev *pdev = ar->pdev;
5725     int ret;
5726 
5727     ath11k_mac_drain_tx(ar);
5728     mutex_lock(&ar->conf_mutex);
5729 
5730     switch (ar->state) {
5731     case ATH11K_STATE_OFF:
5732         ar->state = ATH11K_STATE_ON;
5733         break;
5734     case ATH11K_STATE_RESTARTING:
5735         ar->state = ATH11K_STATE_RESTARTED;
5736         ath11k_mac_wait_reconfigure(ab);
5737         break;
5738     case ATH11K_STATE_RESTARTED:
5739     case ATH11K_STATE_WEDGED:
5740     case ATH11K_STATE_ON:
5741         WARN_ON(1);
5742         ret = -EINVAL;
5743         goto err;
5744     }
5745 
5746     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
5747                     1, pdev->pdev_id);
5748 
5749     if (ret) {
5750         ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
5751         goto err;
5752     }
5753 
5754     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
5755                     pdev->pdev_id);
5756     if (ret) {
5757         ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
5758         goto err;
5759     }
5760 
5761     if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
5762         ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
5763         if (ret) {
5764             ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
5765             goto err;
5766         }
5767     }
5768 
5769     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
5770                     0, pdev->pdev_id);
5771     if (ret) {
5772         ath11k_err(ab, "failed to set ac override for ARP: %d\n",
5773                ret);
5774         goto err;
5775     }
5776 
5777     ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
5778     if (ret) {
5779         ath11k_err(ab, "failed to offload radar detection: %d\n",
5780                ret);
5781         goto err;
5782     }
5783 
5784     ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
5785                           HTT_PPDU_STATS_TAG_DEFAULT);
5786     if (ret) {
5787         ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
5788         goto err;
5789     }
5790 
5791     ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
5792                     1, pdev->pdev_id);
5793 
5794     if (ret) {
5795         ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
5796         goto err;
5797     }
5798 
5799     __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5800 
5801     /* TODO: Do we need to enable ANI? */
5802 
5803     ath11k_reg_update_chan_list(ar, false);
5804 
5805     ar->num_started_vdevs = 0;
5806     ar->num_created_vdevs = 0;
5807     ar->num_peers = 0;
5808     ar->allocated_vdev_map = 0;
5809 
5810     /* Configure monitor status ring with default rx_filter to get rx status
5811      * such as rssi, rx_duration.
5812      */
5813     ret = ath11k_mac_config_mon_status_default(ar, true);
5814     if (ret) {
5815         ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
5816                ret);
5817         goto err;
5818     }
5819 
5820     /* Configure the hash seed for hash based reo dest ring selection */
5821     ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
5822 
5823     /* allow device to enter IMPS */
5824     if (ab->hw_params.idle_ps) {
5825         ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
5826                         1, pdev->pdev_id);
5827         if (ret) {
5828             ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
5829             goto err;
5830         }
5831     }
5832 
5833     mutex_unlock(&ar->conf_mutex);
5834 
5835     rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
5836                &ab->pdevs[ar->pdev_idx]);
5837 
5838     return 0;
5839 
5840 err:
5841     ar->state = ATH11K_STATE_OFF;
5842     mutex_unlock(&ar->conf_mutex);
5843 
5844     return ret;
5845 }
5846 
5847 static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
5848 {
5849     struct ath11k *ar = hw->priv;
5850     struct htt_ppdu_stats_info *ppdu_stats, *tmp;
5851     int ret;
5852 
5853     ath11k_mac_drain_tx(ar);
5854 
5855     mutex_lock(&ar->conf_mutex);
5856     ret = ath11k_mac_config_mon_status_default(ar, false);
5857     if (ret)
5858         ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
5859                ret);
5860 
5861     clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
5862     ar->state = ATH11K_STATE_OFF;
5863     mutex_unlock(&ar->conf_mutex);
5864 
5865     cancel_delayed_work_sync(&ar->scan.timeout);
5866     cancel_work_sync(&ar->regd_update_work);
5867     cancel_work_sync(&ar->ab->update_11d_work);
5868 
5869     if (ar->state_11d == ATH11K_11D_PREPARING) {
5870         ar->state_11d = ATH11K_11D_IDLE;
5871         complete(&ar->completed_11d_scan);
5872     }
5873 
5874     spin_lock_bh(&ar->data_lock);
5875     list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
5876         list_del(&ppdu_stats->list);
5877         kfree(ppdu_stats);
5878     }
5879     spin_unlock_bh(&ar->data_lock);
5880 
5881     rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
5882 
5883     synchronize_rcu();
5884 
5885     atomic_set(&ar->num_pending_mgmt_tx, 0);
5886 }
5887 
5888 static void
5889 ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
5890                     struct vdev_create_params *params)
5891 {
5892     struct ath11k *ar = arvif->ar;
5893     struct ath11k_pdev *pdev = ar->pdev;
5894 
5895     params->if_id = arvif->vdev_id;
5896     params->type = arvif->vdev_type;
5897     params->subtype = arvif->vdev_subtype;
5898     params->pdev_id = pdev->pdev_id;
5899 
5900     if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
5901         params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
5902         params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
5903     }
5904     if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
5905         params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
5906         params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
5907     }
5908     if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
5909         ar->supports_6ghz) {
5910         params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
5911         params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
5912     }
5913 }
5914 
5915 static u32
5916 ath11k_mac_prepare_he_mode(struct ath11k_pdev *pdev, u32 viftype)
5917 {
5918     struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
5919     struct ath11k_band_cap *cap_band = NULL;
5920     u32 *hecap_phy_ptr = NULL;
5921     u32 hemode = 0;
5922 
5923     if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP)
5924         cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
5925     else
5926         cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
5927 
5928     hecap_phy_ptr = &cap_band->he_cap_phy_info[0];
5929 
5930     hemode = FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE) |
5931          FIELD_PREP(HE_MODE_SU_TX_BFER, HECAP_PHY_SUBFMR_GET(hecap_phy_ptr)) |
5932          FIELD_PREP(HE_MODE_UL_MUMIMO, HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr));
5933 
5934     /* TODO WDS and other modes */
5935     if (viftype == NL80211_IFTYPE_AP) {
5936         hemode |= FIELD_PREP(HE_MODE_MU_TX_BFER,
5937               HECAP_PHY_MUBFMR_GET(hecap_phy_ptr)) |
5938               FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
5939               FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
5940     } else {
5941         hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
5942     }
5943 
5944     return hemode;
5945 }
5946 
5947 static int ath11k_set_he_mu_sounding_mode(struct ath11k *ar,
5948                       struct ath11k_vif *arvif)
5949 {
5950     u32 param_id, param_value;
5951     struct ath11k_base *ab = ar->ab;
5952     int ret = 0;
5953 
5954     param_id = WMI_VDEV_PARAM_SET_HEMU_MODE;
5955     param_value = ath11k_mac_prepare_he_mode(ar->pdev, arvif->vif->type);
5956     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5957                         param_id, param_value);
5958     if (ret) {
5959         ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n",
5960                 arvif->vdev_id, ret, param_value);
5961         return ret;
5962     }
5963     param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
5964     param_value =
5965         FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
5966         FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
5967                HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
5968     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5969                         param_id, param_value);
5970     if (ret) {
5971         ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d\n",
5972                 arvif->vdev_id, ret);
5973         return ret;
5974     }
5975     return ret;
5976 }
5977 
5978 static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
5979                          struct ieee80211_vif *vif)
5980 {
5981     struct ath11k *ar = hw->priv;
5982     struct ath11k_base *ab = ar->ab;
5983     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5984     u32 param_id, param_value;
5985     int ret;
5986 
5987     param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
5988     if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
5989         (vif->type != NL80211_IFTYPE_STATION &&
5990          vif->type != NL80211_IFTYPE_AP))
5991         vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
5992                     IEEE80211_OFFLOAD_DECAP_ENABLED);
5993 
5994     if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
5995         param_value = ATH11K_HW_TXRX_ETHERNET;
5996     else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
5997         param_value = ATH11K_HW_TXRX_RAW;
5998     else
5999         param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6000 
6001     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6002                         param_id, param_value);
6003     if (ret) {
6004         ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6005                 arvif->vdev_id, ret);
6006         vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6007     }
6008 
6009     param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6010     if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6011         param_value = ATH11K_HW_TXRX_ETHERNET;
6012     else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6013         param_value = ATH11K_HW_TXRX_RAW;
6014     else
6015         param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6016 
6017     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6018                         param_id, param_value);
6019     if (ret) {
6020         ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6021                 arvif->vdev_id, ret);
6022         vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6023     }
6024 }
6025 
6026 static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6027 {
6028     struct ath11k *ar;
6029     struct ath11k_pdev *pdev;
6030     struct ath11k_vif *arvif;
6031     int i;
6032 
6033     for (i = 0; i < ab->num_radios; i++) {
6034         pdev = &ab->pdevs[i];
6035         ar = pdev->ar;
6036         list_for_each_entry(arvif, &ar->arvifs, list) {
6037             if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6038                 return true;
6039         }
6040     }
6041     return false;
6042 }
6043 
6044 void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
6045 {
6046     struct wmi_11d_scan_start_params param;
6047     int ret;
6048 
6049     mutex_lock(&ar->ab->vdev_id_11d_lock);
6050 
6051     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev id for 11d scan %d\n",
6052            ar->vdev_id_11d_scan);
6053 
6054     if (ar->regdom_set_by_user)
6055         goto fin;
6056 
6057     if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6058         goto fin;
6059 
6060     if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6061         goto fin;
6062 
6063     if (ath11k_mac_vif_ap_active_any(ar->ab))
6064         goto fin;
6065 
6066     param.vdev_id = vdev_id;
6067     param.start_interval_msec = 0;
6068     param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6069 
6070     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac start 11d scan\n");
6071 
6072     ret = ath11k_wmi_send_11d_scan_start_cmd(ar, &param);
6073     if (ret) {
6074         ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6075                 vdev_id, ret);
6076     } else {
6077         ar->vdev_id_11d_scan = vdev_id;
6078         if (ar->state_11d == ATH11K_11D_PREPARING)
6079             ar->state_11d = ATH11K_11D_RUNNING;
6080     }
6081 
6082 fin:
6083     if (ar->state_11d == ATH11K_11D_PREPARING) {
6084         ar->state_11d = ATH11K_11D_IDLE;
6085         complete(&ar->completed_11d_scan);
6086     }
6087 
6088     mutex_unlock(&ar->ab->vdev_id_11d_lock);
6089 }
6090 
6091 void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6092 {
6093     int ret;
6094     u32 vdev_id;
6095 
6096     if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6097         return;
6098 
6099     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d scan\n");
6100 
6101     mutex_lock(&ar->ab->vdev_id_11d_lock);
6102 
6103     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d vdev id %d\n",
6104            ar->vdev_id_11d_scan);
6105 
6106     if (ar->state_11d == ATH11K_11D_PREPARING) {
6107         ar->state_11d = ATH11K_11D_IDLE;
6108         complete(&ar->completed_11d_scan);
6109     }
6110 
6111     if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6112         vdev_id = ar->vdev_id_11d_scan;
6113 
6114         ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
6115         if (ret) {
6116             ath11k_warn(ar->ab,
6117                     "failed to stopt 11d scan vdev %d ret: %d\n",
6118                     vdev_id, ret);
6119         } else {
6120             ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
6121             ar->state_11d = ATH11K_11D_IDLE;
6122             complete(&ar->completed_11d_scan);
6123         }
6124     }
6125     mutex_unlock(&ar->ab->vdev_id_11d_lock);
6126 }
6127 
6128 void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6129 {
6130     struct ath11k *ar;
6131     struct ath11k_pdev *pdev;
6132     int i;
6133 
6134     ath11k_dbg(ab, ATH11K_DBG_MAC, "mac stop soc 11d scan\n");
6135 
6136     for (i = 0; i < ab->num_radios; i++) {
6137         pdev = &ab->pdevs[i];
6138         ar = pdev->ar;
6139 
6140         ath11k_mac_11d_scan_stop(ar);
6141     }
6142 }
6143 
6144 static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6145                        struct ieee80211_vif *vif)
6146 {
6147     struct ath11k *ar = hw->priv;
6148     struct ath11k_base *ab = ar->ab;
6149     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6150     struct vdev_create_params vdev_param = {0};
6151     struct peer_create_params peer_param;
6152     u32 param_id, param_value;
6153     u16 nss;
6154     int i;
6155     int ret, fbret;
6156     int bit;
6157 
6158     vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6159 
6160     mutex_lock(&ar->conf_mutex);
6161 
6162     if (vif->type == NL80211_IFTYPE_AP &&
6163         ar->num_peers > (ar->max_num_peers - 1)) {
6164         ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6165         ret = -ENOBUFS;
6166         goto err;
6167     }
6168 
6169     if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
6170         ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
6171                 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
6172         ret = -EBUSY;
6173         goto err;
6174     }
6175 
6176     memset(arvif, 0, sizeof(*arvif));
6177 
6178     arvif->ar = ar;
6179     arvif->vif = vif;
6180 
6181     INIT_LIST_HEAD(&arvif->list);
6182     INIT_DELAYED_WORK(&arvif->connection_loss_work,
6183               ath11k_mac_vif_sta_connection_loss_work);
6184 
6185     for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6186         arvif->bitrate_mask.control[i].legacy = 0xffffffff;
6187         arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
6188         memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6189                sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6190         memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6191                sizeof(arvif->bitrate_mask.control[i].vht_mcs));
6192         memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6193                sizeof(arvif->bitrate_mask.control[i].he_mcs));
6194     }
6195 
6196     bit = __ffs64(ab->free_vdev_map);
6197 
6198     arvif->vdev_id = bit;
6199     arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6200 
6201     switch (vif->type) {
6202     case NL80211_IFTYPE_UNSPECIFIED:
6203     case NL80211_IFTYPE_STATION:
6204         arvif->vdev_type = WMI_VDEV_TYPE_STA;
6205         break;
6206     case NL80211_IFTYPE_MESH_POINT:
6207         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
6208         fallthrough;
6209     case NL80211_IFTYPE_AP:
6210         arvif->vdev_type = WMI_VDEV_TYPE_AP;
6211         break;
6212     case NL80211_IFTYPE_MONITOR:
6213         arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
6214         ar->monitor_vdev_id = bit;
6215         break;
6216     default:
6217         WARN_ON(1);
6218         break;
6219     }
6220 
6221     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n",
6222            arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6223            ab->free_vdev_map);
6224 
6225     vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6226     for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6227         vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6228 
6229     ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6230 
6231     ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6232     if (ret) {
6233         ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6234                 arvif->vdev_id, ret);
6235         goto err;
6236     }
6237 
6238     ar->num_created_vdevs++;
6239     ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6240            vif->addr, arvif->vdev_id);
6241     ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
6242     ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
6243 
6244     spin_lock_bh(&ar->data_lock);
6245     list_add(&arvif->list, &ar->arvifs);
6246     spin_unlock_bh(&ar->data_lock);
6247 
6248     ath11k_mac_op_update_vif_offload(hw, vif);
6249 
6250     nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6251     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6252                         WMI_VDEV_PARAM_NSS, nss);
6253     if (ret) {
6254         ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6255                 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6256         goto err_vdev_del;
6257     }
6258 
6259     switch (arvif->vdev_type) {
6260     case WMI_VDEV_TYPE_AP:
6261         peer_param.vdev_id = arvif->vdev_id;
6262         peer_param.peer_addr = vif->addr;
6263         peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6264         ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6265         if (ret) {
6266             ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6267                     arvif->vdev_id, ret);
6268             goto err_vdev_del;
6269         }
6270 
6271         ret = ath11k_mac_set_kickout(arvif);
6272         if (ret) {
6273             ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6274                     arvif->vdev_id, ret);
6275             goto err_peer_del;
6276         }
6277 
6278         ath11k_mac_11d_scan_stop_all(ar->ab);
6279         break;
6280     case WMI_VDEV_TYPE_STA:
6281         param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6282         param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6283         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6284                           param_id, param_value);
6285         if (ret) {
6286             ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6287                     arvif->vdev_id, ret);
6288             goto err_peer_del;
6289         }
6290 
6291         param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6292         param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6293         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6294                           param_id, param_value);
6295         if (ret) {
6296             ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6297                     arvif->vdev_id, ret);
6298             goto err_peer_del;
6299         }
6300 
6301         param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6302         param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6303         ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6304                           param_id, param_value);
6305         if (ret) {
6306             ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6307                     arvif->vdev_id, ret);
6308             goto err_peer_del;
6309         }
6310 
6311         ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6312                           WMI_STA_PS_MODE_DISABLED);
6313         if (ret) {
6314             ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6315                     arvif->vdev_id, ret);
6316             goto err_peer_del;
6317         }
6318 
6319         if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6320             reinit_completion(&ar->completed_11d_scan);
6321             ar->state_11d = ATH11K_11D_PREPARING;
6322         }
6323         break;
6324     case WMI_VDEV_TYPE_MONITOR:
6325         set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6326         break;
6327     default:
6328         break;
6329     }
6330 
6331     arvif->txpower = vif->bss_conf.txpower;
6332     ret = ath11k_mac_txpower_recalc(ar);
6333     if (ret)
6334         goto err_peer_del;
6335 
6336     param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6337     param_value = ar->hw->wiphy->rts_threshold;
6338     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6339                         param_id, param_value);
6340     if (ret) {
6341         ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6342                 arvif->vdev_id, ret);
6343     }
6344 
6345     ath11k_dp_vdev_tx_attach(ar, arvif);
6346 
6347     if (vif->type != NL80211_IFTYPE_MONITOR &&
6348         test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6349         ret = ath11k_mac_monitor_vdev_create(ar);
6350         if (ret) {
6351             ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6352                     ret);
6353             goto err_peer_del;
6354         }
6355     }
6356 
6357     ret = ath11k_debugfs_add_interface(arvif);
6358     if (ret)
6359         goto err_peer_del;
6360 
6361     mutex_unlock(&ar->conf_mutex);
6362 
6363     return 0;
6364 
6365 err_peer_del:
6366     if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6367         fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6368         if (fbret) {
6369             ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6370                     vif->addr, arvif->vdev_id, fbret);
6371             goto err;
6372         }
6373     }
6374 
6375 err_vdev_del:
6376     ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6377     ar->num_created_vdevs--;
6378     ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6379     ab->free_vdev_map |= 1LL << arvif->vdev_id;
6380     spin_lock_bh(&ar->data_lock);
6381     list_del(&arvif->list);
6382     spin_unlock_bh(&ar->data_lock);
6383 
6384 err:
6385     ath11k_debugfs_remove_interface(arvif);
6386     mutex_unlock(&ar->conf_mutex);
6387 
6388     return ret;
6389 }
6390 
6391 static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6392 {
6393     struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx;
6394     struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6395 
6396     if (skb_cb->vif == vif)
6397         skb_cb->vif = NULL;
6398 
6399     return 0;
6400 }
6401 
6402 static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6403                        struct ieee80211_vif *vif)
6404 {
6405     struct ath11k *ar = hw->priv;
6406     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6407     struct ath11k_base *ab = ar->ab;
6408     unsigned long time_left;
6409     int ret;
6410     int i;
6411 
6412     cancel_delayed_work_sync(&arvif->connection_loss_work);
6413 
6414     mutex_lock(&ar->conf_mutex);
6415 
6416     ath11k_dbg(ab, ATH11K_DBG_MAC, "mac remove interface (vdev %d)\n",
6417            arvif->vdev_id);
6418 
6419     if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
6420         ath11k_mac_11d_scan_stop(ar);
6421 
6422     if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6423         ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6424         if (ret)
6425             ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
6426                     arvif->vdev_id, ret);
6427     }
6428 
6429     reinit_completion(&ar->vdev_delete_done);
6430 
6431     ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6432     if (ret) {
6433         ath11k_warn(ab, "failed to delete WMI vdev %d: %d\n",
6434                 arvif->vdev_id, ret);
6435         goto err_vdev_del;
6436     }
6437 
6438     time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6439                         ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6440     if (time_left == 0) {
6441         ath11k_warn(ab, "Timeout in receiving vdev delete response\n");
6442         goto err_vdev_del;
6443     }
6444 
6445     ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6446     ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
6447     ar->num_created_vdevs--;
6448 
6449     ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6450            vif->addr, arvif->vdev_id);
6451 
6452     if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6453         clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6454         ar->monitor_vdev_id = -1;
6455     } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
6456            !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
6457         ret = ath11k_mac_monitor_vdev_delete(ar);
6458         if (ret)
6459             /* continue even if there's an error */
6460             ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
6461                     ret);
6462     }
6463 
6464 err_vdev_del:
6465     spin_lock_bh(&ar->data_lock);
6466     list_del(&arvif->list);
6467     spin_unlock_bh(&ar->data_lock);
6468 
6469     ath11k_peer_cleanup(ar, arvif->vdev_id);
6470 
6471     idr_for_each(&ar->txmgmt_idr,
6472              ath11k_mac_vif_txmgmt_idr_remove, vif);
6473 
6474     for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
6475         spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6476         idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
6477                  ath11k_mac_vif_unref, vif);
6478         spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6479     }
6480 
6481     /* Recalc txpower for remaining vdev */
6482     ath11k_mac_txpower_recalc(ar);
6483 
6484     ath11k_debugfs_remove_interface(arvif);
6485 
6486     /* TODO: recal traffic pause state based on the available vdevs */
6487 
6488     mutex_unlock(&ar->conf_mutex);
6489 }
6490 
6491 /* FIXME: Has to be verified. */
6492 #define SUPPORTED_FILTERS           \
6493     (FIF_ALLMULTI |             \
6494     FIF_CONTROL |               \
6495     FIF_PSPOLL |                \
6496     FIF_OTHER_BSS |             \
6497     FIF_BCN_PRBRESP_PROMISC |       \
6498     FIF_PROBE_REQ |             \
6499     FIF_FCSFAIL)
6500 
6501 static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
6502                        unsigned int changed_flags,
6503                        unsigned int *total_flags,
6504                        u64 multicast)
6505 {
6506     struct ath11k *ar = hw->priv;
6507 
6508     mutex_lock(&ar->conf_mutex);
6509 
6510     *total_flags &= SUPPORTED_FILTERS;
6511     ar->filter_flags = *total_flags;
6512 
6513     mutex_unlock(&ar->conf_mutex);
6514 }
6515 
6516 static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
6517 {
6518     struct ath11k *ar = hw->priv;
6519 
6520     mutex_lock(&ar->conf_mutex);
6521 
6522     *tx_ant = ar->cfg_tx_chainmask;
6523     *rx_ant = ar->cfg_rx_chainmask;
6524 
6525     mutex_unlock(&ar->conf_mutex);
6526 
6527     return 0;
6528 }
6529 
6530 static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
6531 {
6532     struct ath11k *ar = hw->priv;
6533     int ret;
6534 
6535     mutex_lock(&ar->conf_mutex);
6536     ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
6537     mutex_unlock(&ar->conf_mutex);
6538 
6539     return ret;
6540 }
6541 
6542 static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
6543                       struct ieee80211_vif *vif,
6544                       struct ieee80211_ampdu_params *params)
6545 {
6546     struct ath11k *ar = hw->priv;
6547     int ret = -EINVAL;
6548 
6549     mutex_lock(&ar->conf_mutex);
6550 
6551     switch (params->action) {
6552     case IEEE80211_AMPDU_RX_START:
6553         ret = ath11k_dp_rx_ampdu_start(ar, params);
6554         break;
6555     case IEEE80211_AMPDU_RX_STOP:
6556         ret = ath11k_dp_rx_ampdu_stop(ar, params);
6557         break;
6558     case IEEE80211_AMPDU_TX_START:
6559     case IEEE80211_AMPDU_TX_STOP_CONT:
6560     case IEEE80211_AMPDU_TX_STOP_FLUSH:
6561     case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6562     case IEEE80211_AMPDU_TX_OPERATIONAL:
6563         /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
6564          * Tx aggregation requests.
6565          */
6566         ret = -EOPNOTSUPP;
6567         break;
6568     }
6569 
6570     mutex_unlock(&ar->conf_mutex);
6571 
6572     return ret;
6573 }
6574 
6575 static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6576                      struct ieee80211_chanctx_conf *ctx)
6577 {
6578     struct ath11k *ar = hw->priv;
6579     struct ath11k_base *ab = ar->ab;
6580 
6581     ath11k_dbg(ab, ATH11K_DBG_MAC,
6582            "mac chanctx add freq %u width %d ptr %pK\n",
6583            ctx->def.chan->center_freq, ctx->def.width, ctx);
6584 
6585     mutex_lock(&ar->conf_mutex);
6586 
6587     spin_lock_bh(&ar->data_lock);
6588     /* TODO: In case of multiple channel context, populate rx_channel from
6589      * Rx PPDU desc information.
6590      */
6591     ar->rx_channel = ctx->def.chan;
6592     spin_unlock_bh(&ar->data_lock);
6593 
6594     mutex_unlock(&ar->conf_mutex);
6595 
6596     return 0;
6597 }
6598 
6599 static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6600                      struct ieee80211_chanctx_conf *ctx)
6601 {
6602     struct ath11k *ar = hw->priv;
6603     struct ath11k_base *ab = ar->ab;
6604 
6605     ath11k_dbg(ab, ATH11K_DBG_MAC,
6606            "mac chanctx remove freq %u width %d ptr %pK\n",
6607            ctx->def.chan->center_freq, ctx->def.width, ctx);
6608 
6609     mutex_lock(&ar->conf_mutex);
6610 
6611     spin_lock_bh(&ar->data_lock);
6612     /* TODO: In case of there is one more channel context left, populate
6613      * rx_channel with the channel of that remaining channel context.
6614      */
6615     ar->rx_channel = NULL;
6616     spin_unlock_bh(&ar->data_lock);
6617 
6618     mutex_unlock(&ar->conf_mutex);
6619 }
6620 
6621 static int
6622 ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
6623                   struct ieee80211_chanctx_conf *ctx,
6624                   bool restart)
6625 {
6626     struct ath11k *ar = arvif->ar;
6627     struct ath11k_base *ab = ar->ab;
6628     struct wmi_vdev_start_req_arg arg = {};
6629     const struct cfg80211_chan_def *chandef = &ctx->def;
6630     int he_support = arvif->vif->bss_conf.he_support;
6631     int ret = 0;
6632 
6633     lockdep_assert_held(&ar->conf_mutex);
6634 
6635     reinit_completion(&ar->vdev_setup_done);
6636 
6637     arg.vdev_id = arvif->vdev_id;
6638     arg.dtim_period = arvif->dtim_period;
6639     arg.bcn_intval = arvif->beacon_interval;
6640 
6641     arg.channel.freq = chandef->chan->center_freq;
6642     arg.channel.band_center_freq1 = chandef->center_freq1;
6643     arg.channel.band_center_freq2 = chandef->center_freq2;
6644     arg.channel.mode =
6645         ath11k_phymodes[chandef->chan->band][chandef->width];
6646 
6647     arg.channel.min_power = 0;
6648     arg.channel.max_power = chandef->chan->max_power;
6649     arg.channel.max_reg_power = chandef->chan->max_reg_power;
6650     arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
6651 
6652     arg.pref_tx_streams = ar->num_tx_chains;
6653     arg.pref_rx_streams = ar->num_rx_chains;
6654 
6655     if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6656         arg.ssid = arvif->u.ap.ssid;
6657         arg.ssid_len = arvif->u.ap.ssid_len;
6658         arg.hidden_ssid = arvif->u.ap.hidden_ssid;
6659 
6660         /* For now allow DFS for AP mode */
6661         arg.channel.chan_radar =
6662             !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
6663 
6664         arg.channel.freq2_radar = ctx->radar_enabled;
6665 
6666         arg.channel.passive = arg.channel.chan_radar;
6667 
6668         spin_lock_bh(&ab->base_lock);
6669         arg.regdomain = ar->ab->dfs_region;
6670         spin_unlock_bh(&ab->base_lock);
6671 
6672         if (he_support) {
6673             ret = ath11k_set_he_mu_sounding_mode(ar, arvif);
6674             if (ret) {
6675                 ath11k_warn(ar->ab, "failed to set he mode vdev %i\n",
6676                         arg.vdev_id);
6677                 return ret;
6678             }
6679         }
6680     }
6681 
6682     arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
6683 
6684     ath11k_dbg(ab, ATH11K_DBG_MAC,
6685            "mac vdev %d start center_freq %d phymode %s\n",
6686            arg.vdev_id, arg.channel.freq,
6687            ath11k_wmi_phymode_str(arg.channel.mode));
6688 
6689     ret = ath11k_wmi_vdev_start(ar, &arg, restart);
6690     if (ret) {
6691         ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
6692                 restart ? "restart" : "start", arg.vdev_id);
6693         return ret;
6694     }
6695 
6696     ret = ath11k_mac_vdev_setup_sync(ar);
6697     if (ret) {
6698         ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
6699                 arg.vdev_id, restart ? "restart" : "start", ret);
6700         return ret;
6701     }
6702 
6703     if (!restart)
6704         ar->num_started_vdevs++;
6705 
6706     ath11k_dbg(ab, ATH11K_DBG_MAC,  "vdev %pM started, vdev_id %d\n",
6707            arvif->vif->addr, arvif->vdev_id);
6708 
6709     /* Enable CAC Flag in the driver by checking the channel DFS cac time,
6710      * i.e dfs_cac_ms value which will be valid only for radar channels
6711      * and state as NL80211_DFS_USABLE which indicates CAC needs to be
6712      * done before channel usage. This flags is used to drop rx packets.
6713      * during CAC.
6714      */
6715     /* TODO Set the flag for other interface types as required */
6716     if (arvif->vdev_type == WMI_VDEV_TYPE_AP &&
6717         chandef->chan->dfs_cac_ms &&
6718         chandef->chan->dfs_state == NL80211_DFS_USABLE) {
6719         set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6720         ath11k_dbg(ab, ATH11K_DBG_MAC,
6721                "CAC Started in chan_freq %d for vdev %d\n",
6722                arg.channel.freq, arg.vdev_id);
6723     }
6724 
6725     ret = ath11k_mac_set_txbf_conf(arvif);
6726     if (ret)
6727         ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
6728                 arvif->vdev_id, ret);
6729 
6730     return 0;
6731 }
6732 
6733 static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
6734 {
6735     struct ath11k *ar = arvif->ar;
6736     int ret;
6737 
6738     lockdep_assert_held(&ar->conf_mutex);
6739 
6740     reinit_completion(&ar->vdev_setup_done);
6741 
6742     ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
6743     if (ret) {
6744         ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
6745                 arvif->vdev_id, ret);
6746         goto err;
6747     }
6748 
6749     ret = ath11k_mac_vdev_setup_sync(ar);
6750     if (ret) {
6751         ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
6752                 arvif->vdev_id, ret);
6753         goto err;
6754     }
6755 
6756     WARN_ON(ar->num_started_vdevs == 0);
6757 
6758     ar->num_started_vdevs--;
6759     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
6760            arvif->vif->addr, arvif->vdev_id);
6761 
6762     if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
6763         clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6764         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
6765                arvif->vdev_id);
6766     }
6767 
6768     return 0;
6769 err:
6770     return ret;
6771 }
6772 
6773 static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
6774                  struct ieee80211_chanctx_conf *ctx)
6775 {
6776     return ath11k_mac_vdev_start_restart(arvif, ctx, false);
6777 }
6778 
6779 static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
6780                    struct ieee80211_chanctx_conf *ctx)
6781 {
6782     return ath11k_mac_vdev_start_restart(arvif, ctx, true);
6783 }
6784 
6785 struct ath11k_mac_change_chanctx_arg {
6786     struct ieee80211_chanctx_conf *ctx;
6787     struct ieee80211_vif_chanctx_switch *vifs;
6788     int n_vifs;
6789     int next_vif;
6790 };
6791 
6792 static void
6793 ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6794                    struct ieee80211_vif *vif)
6795 {
6796     struct ath11k_mac_change_chanctx_arg *arg = data;
6797 
6798     if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
6799         return;
6800 
6801     arg->n_vifs++;
6802 }
6803 
6804 static void
6805 ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6806                     struct ieee80211_vif *vif)
6807 {
6808     struct ath11k_mac_change_chanctx_arg *arg = data;
6809     struct ieee80211_chanctx_conf *ctx;
6810 
6811     ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
6812     if (ctx != arg->ctx)
6813         return;
6814 
6815     if (WARN_ON(arg->next_vif == arg->n_vifs))
6816         return;
6817 
6818     arg->vifs[arg->next_vif].vif = vif;
6819     arg->vifs[arg->next_vif].old_ctx = ctx;
6820     arg->vifs[arg->next_vif].new_ctx = ctx;
6821     arg->next_vif++;
6822 }
6823 
6824 static void
6825 ath11k_mac_update_vif_chan(struct ath11k *ar,
6826                struct ieee80211_vif_chanctx_switch *vifs,
6827                int n_vifs)
6828 {
6829     struct ath11k_base *ab = ar->ab;
6830     struct ath11k_vif *arvif;
6831     int ret;
6832     int i;
6833     bool monitor_vif = false;
6834 
6835     lockdep_assert_held(&ar->conf_mutex);
6836 
6837     /* Associated channel resources of all relevant vdevs
6838      * should be available for the channel switch now.
6839      */
6840 
6841     /* TODO: Update ar->rx_channel */
6842 
6843     for (i = 0; i < n_vifs; i++) {
6844         arvif = (void *)vifs[i].vif->drv_priv;
6845 
6846         if (WARN_ON(!arvif->is_started))
6847             continue;
6848 
6849         /* change_chanctx can be called even before vdev_up from
6850          * ieee80211_start_ap->ieee80211_vif_use_channel->
6851          * ieee80211_recalc_radar_chanctx.
6852          *
6853          * Firmware expect vdev_restart only if vdev is up.
6854          * If vdev is down then it expect vdev_stop->vdev_start.
6855          */
6856         if (arvif->is_up) {
6857             ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
6858             if (ret) {
6859                 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
6860                         arvif->vdev_id, ret);
6861                 continue;
6862             }
6863         } else {
6864             ret = ath11k_mac_vdev_stop(arvif);
6865             if (ret) {
6866                 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
6867                         arvif->vdev_id, ret);
6868                 continue;
6869             }
6870 
6871             ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
6872             if (ret)
6873                 ath11k_warn(ab, "failed to start vdev %d: %d\n",
6874                         arvif->vdev_id, ret);
6875 
6876             continue;
6877         }
6878 
6879         ret = ath11k_mac_setup_bcn_tmpl(arvif);
6880         if (ret)
6881             ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
6882                     ret);
6883 
6884         ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6885                      arvif->bssid);
6886         if (ret) {
6887             ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
6888                     arvif->vdev_id, ret);
6889             continue;
6890         }
6891     }
6892 
6893     /* Restart the internal monitor vdev on new channel */
6894     if (!monitor_vif &&
6895         test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
6896         ret = ath11k_mac_monitor_stop(ar);
6897         if (ret) {
6898             ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
6899                     ret);
6900             return;
6901         }
6902 
6903         ret = ath11k_mac_monitor_start(ar);
6904         if (ret) {
6905             ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
6906                     ret);
6907             return;
6908         }
6909     }
6910 }
6911 
6912 static void
6913 ath11k_mac_update_active_vif_chan(struct ath11k *ar,
6914                   struct ieee80211_chanctx_conf *ctx)
6915 {
6916     struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
6917 
6918     lockdep_assert_held(&ar->conf_mutex);
6919 
6920     ieee80211_iterate_active_interfaces_atomic(ar->hw,
6921                            IEEE80211_IFACE_ITER_NORMAL,
6922                            ath11k_mac_change_chanctx_cnt_iter,
6923                            &arg);
6924     if (arg.n_vifs == 0)
6925         return;
6926 
6927     arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
6928     if (!arg.vifs)
6929         return;
6930 
6931     ieee80211_iterate_active_interfaces_atomic(ar->hw,
6932                            IEEE80211_IFACE_ITER_NORMAL,
6933                            ath11k_mac_change_chanctx_fill_iter,
6934                            &arg);
6935 
6936     ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6937 
6938     kfree(arg.vifs);
6939 }
6940 
6941 static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6942                      struct ieee80211_chanctx_conf *ctx,
6943                      u32 changed)
6944 {
6945     struct ath11k *ar = hw->priv;
6946     struct ath11k_base *ab = ar->ab;
6947 
6948     mutex_lock(&ar->conf_mutex);
6949 
6950     ath11k_dbg(ab, ATH11K_DBG_MAC,
6951            "mac chanctx change freq %u width %d ptr %pK changed %x\n",
6952            ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6953 
6954     /* This shouldn't really happen because channel switching should use
6955      * switch_vif_chanctx().
6956      */
6957     if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6958         goto unlock;
6959 
6960     if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
6961         changed & IEEE80211_CHANCTX_CHANGE_RADAR)
6962         ath11k_mac_update_active_vif_chan(ar, ctx);
6963 
6964     /* TODO: Recalc radar detection */
6965 
6966 unlock:
6967     mutex_unlock(&ar->conf_mutex);
6968 }
6969 
6970 static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
6971                    struct ieee80211_vif *vif)
6972 {
6973     struct ath11k *ar = hw->priv;
6974     struct ath11k_base *ab = ar->ab;
6975     struct ath11k_vif *arvif = (void *)vif->drv_priv;
6976     int ret;
6977 
6978     if (WARN_ON(arvif->is_started))
6979         return -EBUSY;
6980 
6981     ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
6982     if (ret) {
6983         ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
6984                 arvif->vdev_id, vif->addr,
6985                 arvif->chanctx.def.chan->center_freq, ret);
6986         return ret;
6987     }
6988 
6989     /* Reconfigure hardware rate code since it is cleared by firmware.
6990      */
6991     if (ar->hw_rate_code > 0) {
6992         u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
6993 
6994         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
6995                             ar->hw_rate_code);
6996         if (ret) {
6997             ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
6998             return ret;
6999         }
7000     }
7001 
7002     if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7003         ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr);
7004         if (ret) {
7005             ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7006             return ret;
7007         }
7008     }
7009 
7010     arvif->is_started = true;
7011 
7012     /* TODO: Setup ps and cts/rts protection */
7013     return 0;
7014 }
7015 
7016 static int
7017 ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7018                  struct ieee80211_vif *vif,
7019                  struct ieee80211_bss_conf *link_conf,
7020                  struct ieee80211_chanctx_conf *ctx)
7021 {
7022     struct ath11k *ar = hw->priv;
7023     struct ath11k_base *ab = ar->ab;
7024     struct ath11k_vif *arvif = (void *)vif->drv_priv;
7025     int ret;
7026     struct peer_create_params param;
7027 
7028     mutex_lock(&ar->conf_mutex);
7029 
7030     ath11k_dbg(ab, ATH11K_DBG_MAC,
7031            "mac chanctx assign ptr %pK vdev_id %i\n",
7032            ctx, arvif->vdev_id);
7033 
7034     /* for QCA6390 bss peer must be created before vdev_start */
7035     if (ab->hw_params.vdev_start_delay &&
7036         arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7037         arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7038         !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
7039         memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
7040         ret = 0;
7041         goto out;
7042     }
7043 
7044     if (WARN_ON(arvif->is_started)) {
7045         ret = -EBUSY;
7046         goto out;
7047     }
7048 
7049     if (ab->hw_params.vdev_start_delay &&
7050         arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7051         arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
7052         param.vdev_id = arvif->vdev_id;
7053         param.peer_type = WMI_PEER_TYPE_DEFAULT;
7054         param.peer_addr = ar->mac_addr;
7055 
7056         ret = ath11k_peer_create(ar, arvif, NULL, &param);
7057         if (ret) {
7058             ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7059                     ret);
7060             goto out;
7061         }
7062     }
7063 
7064     if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7065         ret = ath11k_mac_monitor_start(ar);
7066         if (ret) {
7067             ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7068                     ret);
7069             goto out;
7070         }
7071 
7072         arvif->is_started = true;
7073         goto out;
7074     }
7075 
7076     ret = ath11k_mac_vdev_start(arvif, ctx);
7077     if (ret) {
7078         ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7079                 arvif->vdev_id, vif->addr,
7080                 ctx->def.chan->center_freq, ret);
7081         goto out;
7082     }
7083 
7084     arvif->is_started = true;
7085 
7086     if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7087         test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7088         ret = ath11k_mac_monitor_start(ar);
7089         if (ret) {
7090             ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7091                     ret);
7092             goto out;
7093         }
7094     }
7095 
7096     /* TODO: Setup ps and cts/rts protection */
7097 
7098     ret = 0;
7099 
7100 out:
7101     mutex_unlock(&ar->conf_mutex);
7102 
7103     return ret;
7104 }
7105 
7106 static void
7107 ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7108                    struct ieee80211_vif *vif,
7109                    struct ieee80211_bss_conf *link_conf,
7110                    struct ieee80211_chanctx_conf *ctx)
7111 {
7112     struct ath11k *ar = hw->priv;
7113     struct ath11k_base *ab = ar->ab;
7114     struct ath11k_vif *arvif = (void *)vif->drv_priv;
7115     struct ath11k_peer *peer;
7116     int ret;
7117 
7118     mutex_lock(&ar->conf_mutex);
7119 
7120     ath11k_dbg(ab, ATH11K_DBG_MAC,
7121            "mac chanctx unassign ptr %pK vdev_id %i\n",
7122            ctx, arvif->vdev_id);
7123 
7124     WARN_ON(!arvif->is_started);
7125 
7126     if (ab->hw_params.vdev_start_delay &&
7127         arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7128         spin_lock_bh(&ab->base_lock);
7129         peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7130         spin_unlock_bh(&ab->base_lock);
7131         if (peer)
7132             ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7133     }
7134 
7135     if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7136         ret = ath11k_mac_monitor_stop(ar);
7137         if (ret) {
7138             ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7139                     ret);
7140             mutex_unlock(&ar->conf_mutex);
7141             return;
7142         }
7143 
7144         arvif->is_started = false;
7145         mutex_unlock(&ar->conf_mutex);
7146         return;
7147     }
7148 
7149     ret = ath11k_mac_vdev_stop(arvif);
7150     if (ret)
7151         ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7152                 arvif->vdev_id, ret);
7153 
7154     arvif->is_started = false;
7155 
7156     if (ab->hw_params.vdev_start_delay &&
7157         arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7158         ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7159         if (ret)
7160             ath11k_warn(ar->ab,
7161                     "failed to delete peer %pM for vdev %d: %d\n",
7162                     arvif->bssid, arvif->vdev_id, ret);
7163         else
7164             ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7165                    "mac removed peer %pM  vdev %d after vdev stop\n",
7166                    arvif->bssid, arvif->vdev_id);
7167     }
7168 
7169     if (ab->hw_params.vdev_start_delay &&
7170         arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7171         ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7172 
7173     if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7174         ar->num_started_vdevs == 1 &&
7175         test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7176         ret = ath11k_mac_monitor_stop(ar);
7177         if (ret)
7178             /* continue even if there's an error */
7179             ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7180                     ret);
7181     }
7182 
7183     if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
7184         ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
7185 
7186     mutex_unlock(&ar->conf_mutex);
7187 }
7188 
7189 static int
7190 ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7191                  struct ieee80211_vif_chanctx_switch *vifs,
7192                  int n_vifs,
7193                  enum ieee80211_chanctx_switch_mode mode)
7194 {
7195     struct ath11k *ar = hw->priv;
7196 
7197     mutex_lock(&ar->conf_mutex);
7198 
7199     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7200            "mac chanctx switch n_vifs %d mode %d\n",
7201            n_vifs, mode);
7202     ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7203 
7204     mutex_unlock(&ar->conf_mutex);
7205 
7206     return 0;
7207 }
7208 
7209 static int
7210 ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7211 {
7212     struct ath11k_vif *arvif;
7213     int ret = 0;
7214 
7215     mutex_lock(&ar->conf_mutex);
7216     list_for_each_entry(arvif, &ar->arvifs, list) {
7217         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7218                param, arvif->vdev_id, value);
7219 
7220         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7221                             param, value);
7222         if (ret) {
7223             ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7224                     param, arvif->vdev_id, ret);
7225             break;
7226         }
7227     }
7228     mutex_unlock(&ar->conf_mutex);
7229     return ret;
7230 }
7231 
7232 /* mac80211 stores device specific RTS/Fragmentation threshold value,
7233  * this is set interface specific to firmware from ath11k driver
7234  */
7235 static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7236 {
7237     struct ath11k *ar = hw->priv;
7238     int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7239 
7240     return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7241 }
7242 
7243 static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7244 {
7245     /* Even though there's a WMI vdev param for fragmentation threshold no
7246      * known firmware actually implements it. Moreover it is not possible to
7247      * rely frame fragmentation to mac80211 because firmware clears the
7248      * "more fragments" bit in frame control making it impossible for remote
7249      * devices to reassemble frames.
7250      *
7251      * Hence implement a dummy callback just to say fragmentation isn't
7252      * supported. This effectively prevents mac80211 from doing frame
7253      * fragmentation in software.
7254      */
7255     return -EOPNOTSUPP;
7256 }
7257 
7258 static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
7259 {
7260     long time_left;
7261     int ret = 0;
7262 
7263     time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7264                        (atomic_read(&ar->dp.num_tx_pending) == 0),
7265                        ATH11K_FLUSH_TIMEOUT);
7266     if (time_left == 0) {
7267         ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7268                 atomic_read(&ar->dp.num_tx_pending));
7269         ret = -ETIMEDOUT;
7270     }
7271 
7272     time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7273                        (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7274                        ATH11K_FLUSH_TIMEOUT);
7275     if (time_left == 0) {
7276         ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7277                 atomic_read(&ar->num_pending_mgmt_tx));
7278         ret = -ETIMEDOUT;
7279     }
7280 
7281     return ret;
7282 }
7283 
7284 int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7285 {
7286     ath11k_mac_drain_tx(ar);
7287     return ath11k_mac_flush_tx_complete(ar);
7288 }
7289 
7290 static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7291                 u32 queues, bool drop)
7292 {
7293     struct ath11k *ar = hw->priv;
7294 
7295     if (drop)
7296         return;
7297 
7298     ath11k_mac_flush_tx_complete(ar);
7299 }
7300 
7301 static int
7302 ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
7303                      enum nl80211_band band,
7304                      const struct cfg80211_bitrate_mask *mask)
7305 {
7306     int num_rates = 0;
7307     int i;
7308 
7309     for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
7310         num_rates += hweight16(mask->control[band].ht_mcs[i]);
7311 
7312     return num_rates;
7313 }
7314 
7315 static bool
7316 ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7317                   enum nl80211_band band,
7318                   const struct cfg80211_bitrate_mask *mask)
7319 {
7320     int num_rates = 0;
7321 
7322     num_rates = hweight32(mask->control[band].legacy);
7323 
7324     if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7325         return false;
7326 
7327     if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7328         return false;
7329 
7330     if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7331         return false;
7332 
7333     return num_rates == 1;
7334 }
7335 
7336 static __le16
7337 ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7338 {
7339     if (he_cap->he_cap_elem.phy_cap_info[0] &
7340         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7341         return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7342 
7343     if (he_cap->he_cap_elem.phy_cap_info[0] &
7344         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7345         return he_cap->he_mcs_nss_supp.tx_mcs_160;
7346 
7347     return he_cap->he_mcs_nss_supp.tx_mcs_80;
7348 }
7349 
7350 static bool
7351 ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7352                        enum nl80211_band band,
7353                        const struct cfg80211_bitrate_mask *mask,
7354                        int *nss)
7355 {
7356     struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7357     u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7358     u16 he_mcs_map = 0;
7359     u8 ht_nss_mask = 0;
7360     u8 vht_nss_mask = 0;
7361     u8 he_nss_mask = 0;
7362     int i;
7363 
7364     /* No need to consider legacy here. Basic rates are always present
7365      * in bitrate mask
7366      */
7367 
7368     for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7369         if (mask->control[band].ht_mcs[i] == 0)
7370             continue;
7371         else if (mask->control[band].ht_mcs[i] ==
7372              sband->ht_cap.mcs.rx_mask[i])
7373             ht_nss_mask |= BIT(i);
7374         else
7375             return false;
7376     }
7377 
7378     for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7379         if (mask->control[band].vht_mcs[i] == 0)
7380             continue;
7381         else if (mask->control[band].vht_mcs[i] ==
7382              ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7383             vht_nss_mask |= BIT(i);
7384         else
7385             return false;
7386     }
7387 
7388     he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap));
7389 
7390     for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7391         if (mask->control[band].he_mcs[i] == 0)
7392             continue;
7393 
7394         if (mask->control[band].he_mcs[i] ==
7395             ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7396             he_nss_mask |= BIT(i);
7397         else
7398             return false;
7399     }
7400 
7401     if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
7402         return false;
7403 
7404     if (ht_nss_mask == 0)
7405         return false;
7406 
7407     if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7408         return false;
7409 
7410     *nss = fls(ht_nss_mask);
7411 
7412     return true;
7413 }
7414 
7415 static int
7416 ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7417                   enum nl80211_band band,
7418                   const struct cfg80211_bitrate_mask *mask,
7419                   u32 *rate, u8 *nss)
7420 {
7421     int rate_idx;
7422     u16 bitrate;
7423     u8 preamble;
7424     u8 hw_rate;
7425 
7426     if (hweight32(mask->control[band].legacy) != 1)
7427         return -EINVAL;
7428 
7429     rate_idx = ffs(mask->control[band].legacy) - 1;
7430 
7431     if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
7432         rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
7433 
7434     hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
7435     bitrate = ath11k_legacy_rates[rate_idx].bitrate;
7436 
7437     if (ath11k_mac_bitrate_is_cck(bitrate))
7438         preamble = WMI_RATE_PREAMBLE_CCK;
7439     else
7440         preamble = WMI_RATE_PREAMBLE_OFDM;
7441 
7442     *nss = 1;
7443     *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
7444 
7445     return 0;
7446 }
7447 
7448 static int
7449 ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
7450 {
7451     struct ath11k *ar = arvif->ar;
7452     int ret;
7453 
7454     /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
7455     if (he_gi && he_gi != 0xFF)
7456         he_gi += 1;
7457 
7458     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7459                         WMI_VDEV_PARAM_SGI, he_gi);
7460     if (ret) {
7461         ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
7462                 he_gi, ret);
7463         return ret;
7464     }
7465     /* start from 1 */
7466     if (he_ltf != 0xFF)
7467         he_ltf += 1;
7468 
7469     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7470                         WMI_VDEV_PARAM_HE_LTF, he_ltf);
7471     if (ret) {
7472         ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
7473                 he_ltf, ret);
7474         return ret;
7475     }
7476 
7477     return 0;
7478 }
7479 
7480 static int
7481 ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
7482 {
7483     struct ath11k *ar = arvif->ar;
7484     int ret;
7485     u32 he_ar_gi_ltf;
7486 
7487     if (he_gi != 0xFF) {
7488         switch (he_gi) {
7489         case NL80211_RATE_INFO_HE_GI_0_8:
7490             he_gi = WMI_AUTORATE_800NS_GI;
7491             break;
7492         case NL80211_RATE_INFO_HE_GI_1_6:
7493             he_gi = WMI_AUTORATE_1600NS_GI;
7494             break;
7495         case NL80211_RATE_INFO_HE_GI_3_2:
7496             he_gi = WMI_AUTORATE_3200NS_GI;
7497             break;
7498         default:
7499             ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
7500             return -EINVAL;
7501         }
7502     }
7503 
7504     if (he_ltf != 0xFF) {
7505         switch (he_ltf) {
7506         case NL80211_RATE_INFO_HE_1XLTF:
7507             he_ltf = WMI_HE_AUTORATE_LTF_1X;
7508             break;
7509         case NL80211_RATE_INFO_HE_2XLTF:
7510             he_ltf = WMI_HE_AUTORATE_LTF_2X;
7511             break;
7512         case NL80211_RATE_INFO_HE_4XLTF:
7513             he_ltf = WMI_HE_AUTORATE_LTF_4X;
7514             break;
7515         default:
7516             ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
7517             return -EINVAL;
7518         }
7519     }
7520 
7521     he_ar_gi_ltf = he_gi | he_ltf;
7522     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7523                         WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
7524                         he_ar_gi_ltf);
7525     if (ret) {
7526         ath11k_warn(ar->ab,
7527                 "failed to set he autorate gi %u ltf %u: %d\n",
7528                 he_gi, he_ltf, ret);
7529         return ret;
7530     }
7531 
7532     return 0;
7533 }
7534 
7535 static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
7536                       u32 rate, u8 nss, u8 sgi, u8 ldpc,
7537                       u8 he_gi, u8 he_ltf, bool he_fixed_rate)
7538 {
7539     struct ath11k *ar = arvif->ar;
7540     u32 vdev_param;
7541     int ret;
7542 
7543     lockdep_assert_held(&ar->conf_mutex);
7544 
7545     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7546            "mac set rate params vdev %i rate 0x%02x nss 0x%02x sgi 0x%02x ldpc 0x%02x he_gi 0x%02x he_ltf 0x%02x he_fixed_rate %d\n",
7547            arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
7548            he_ltf, he_fixed_rate);
7549 
7550     if (!arvif->vif->bss_conf.he_support) {
7551         vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
7552         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7553                             vdev_param, rate);
7554         if (ret) {
7555             ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
7556                     rate, ret);
7557             return ret;
7558         }
7559     }
7560 
7561     vdev_param = WMI_VDEV_PARAM_NSS;
7562     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7563                         vdev_param, nss);
7564     if (ret) {
7565         ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
7566                 nss, ret);
7567         return ret;
7568     }
7569 
7570     vdev_param = WMI_VDEV_PARAM_LDPC;
7571     ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7572                         vdev_param, ldpc);
7573     if (ret) {
7574         ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
7575                 ldpc, ret);
7576         return ret;
7577     }
7578 
7579     if (arvif->vif->bss_conf.he_support) {
7580         if (he_fixed_rate) {
7581             ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
7582                                    he_ltf);
7583             if (ret) {
7584                 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
7585                         ret);
7586                 return ret;
7587             }
7588         } else {
7589             ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
7590                                   he_ltf);
7591             if (ret) {
7592                 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
7593                         ret);
7594                 return ret;
7595             }
7596         }
7597     } else {
7598         vdev_param = WMI_VDEV_PARAM_SGI;
7599         ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7600                             vdev_param, sgi);
7601         if (ret) {
7602             ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
7603                     sgi, ret);
7604             return ret;
7605         }
7606     }
7607 
7608     return 0;
7609 }
7610 
7611 static bool
7612 ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
7613                  enum nl80211_band band,
7614                  const struct cfg80211_bitrate_mask *mask)
7615 {
7616     int i;
7617     u16 vht_mcs;
7618 
7619     for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
7620         vht_mcs = mask->control[band].vht_mcs[i];
7621 
7622         switch (vht_mcs) {
7623         case 0:
7624         case BIT(8) - 1:
7625         case BIT(9) - 1:
7626         case BIT(10) - 1:
7627             break;
7628         default:
7629             return false;
7630         }
7631     }
7632 
7633     return true;
7634 }
7635 
7636 static bool
7637 ath11k_mac_he_mcs_range_present(struct ath11k *ar,
7638                 enum nl80211_band band,
7639                 const struct cfg80211_bitrate_mask *mask)
7640 {
7641     int i;
7642     u16 he_mcs;
7643 
7644     for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
7645         he_mcs = mask->control[band].he_mcs[i];
7646 
7647         switch (he_mcs) {
7648         case 0:
7649         case BIT(8) - 1:
7650         case BIT(10) - 1:
7651         case BIT(12) - 1:
7652             break;
7653         default:
7654             return false;
7655         }
7656     }
7657 
7658     return true;
7659 }
7660 
7661 static void ath11k_mac_set_bitrate_mask_iter(void *data,
7662                          struct ieee80211_sta *sta)
7663 {
7664     struct ath11k_vif *arvif = data;
7665     struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
7666     struct ath11k *ar = arvif->ar;
7667 
7668     spin_lock_bh(&ar->data_lock);
7669     arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
7670     spin_unlock_bh(&ar->data_lock);
7671 
7672     ieee80211_queue_work(ar->hw, &arsta->update_wk);
7673 }
7674 
7675 static void ath11k_mac_disable_peer_fixed_rate(void *data,
7676                            struct ieee80211_sta *sta)
7677 {
7678     struct ath11k_vif *arvif = data;
7679     struct ath11k *ar = arvif->ar;
7680     int ret;
7681 
7682     ret = ath11k_wmi_set_peer_param(ar, sta->addr,
7683                     arvif->vdev_id,
7684                     WMI_PEER_PARAM_FIXED_RATE,
7685                     WMI_FIXED_RATE_NONE);
7686     if (ret)
7687         ath11k_warn(ar->ab,
7688                 "failed to disable peer fixed rate for STA %pM ret %d\n",
7689                 sta->addr, ret);
7690 }
7691 
7692 static bool
7693 ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
7694                            const struct cfg80211_bitrate_mask *mask)
7695 {
7696     bool he_fixed_rate = false, vht_fixed_rate = false;
7697     struct ath11k_peer *peer, *tmp;
7698     const u16 *vht_mcs_mask, *he_mcs_mask;
7699     struct ieee80211_link_sta *deflink;
7700     u8 vht_nss, he_nss;
7701     bool ret = true;
7702 
7703     vht_mcs_mask = mask->control[band].vht_mcs;
7704     he_mcs_mask = mask->control[band].he_mcs;
7705 
7706     if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
7707         vht_fixed_rate = true;
7708 
7709     if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
7710         he_fixed_rate = true;
7711 
7712     if (!vht_fixed_rate && !he_fixed_rate)
7713         return true;
7714 
7715     vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
7716     he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);
7717 
7718     rcu_read_lock();
7719     spin_lock_bh(&ar->ab->base_lock);
7720     list_for_each_entry_safe(peer, tmp, &ar->ab->peers, list) {
7721         if (peer->sta) {
7722             deflink = &peer->sta->deflink;
7723 
7724             if (vht_fixed_rate && (!deflink->vht_cap.vht_supported ||
7725                            deflink->rx_nss < vht_nss)) {
7726                 ret = false;
7727                 goto out;
7728             }
7729 
7730             if (he_fixed_rate && (!deflink->he_cap.has_he ||
7731                           deflink->rx_nss < he_nss)) {
7732                 ret = false;
7733                 goto out;
7734             }
7735         }
7736     }
7737 
7738 out:
7739     spin_unlock_bh(&ar->ab->base_lock);
7740     rcu_read_unlock();
7741     return ret;
7742 }
7743 
7744 static int
7745 ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
7746                    struct ieee80211_vif *vif,
7747                    const struct cfg80211_bitrate_mask *mask)
7748 {
7749     struct ath11k_vif *arvif = (void *)vif->drv_priv;
7750     struct cfg80211_chan_def def;
7751     struct ath11k_pdev_cap *cap;
7752     struct ath11k *ar = arvif->ar;
7753     enum nl80211_band band;
7754     const u8 *ht_mcs_mask;
7755     const u16 *vht_mcs_mask;
7756     const u16 *he_mcs_mask;
7757     u8 he_ltf = 0;
7758     u8 he_gi = 0;
7759     u32 rate;
7760     u8 nss;
7761     u8 sgi;
7762     u8 ldpc;
7763     int single_nss;
7764     int ret;
7765     int num_rates;
7766     bool he_fixed_rate = false;
7767 
7768     if (ath11k_mac_vif_chan(vif, &def))
7769         return -EPERM;
7770 
7771     band = def.chan->band;
7772     cap = &ar->pdev->cap;
7773     ht_mcs_mask = mask->control[band].ht_mcs;
7774     vht_mcs_mask = mask->control[band].vht_mcs;
7775     he_mcs_mask = mask->control[band].he_mcs;
7776     ldpc = !!(cap->band[band].ht_cap_info & WMI_HT_CAP_TX_LDPC);
7777 
7778     sgi = mask->control[band].gi;
7779     if (sgi == NL80211_TXRATE_FORCE_LGI)
7780         return -EINVAL;
7781 
7782     he_gi = mask->control[band].he_gi;
7783     he_ltf = mask->control[band].he_ltf;
7784 
7785     /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
7786      * requires passing at least one of used basic rates along with them.
7787      * Fixed rate setting across different preambles(legacy, HT, VHT) is
7788      * not supported by the FW. Hence use of FIXED_RATE vdev param is not
7789      * suitable for setting single HT/VHT rates.
7790      * But, there could be a single basic rate passed from userspace which
7791      * can be done through the FIXED_RATE param.
7792      */
7793     if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
7794         ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
7795                             &nss);
7796         if (ret) {
7797             ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
7798                     arvif->vdev_id, ret);
7799             return ret;
7800         }
7801         ieee80211_iterate_stations_atomic(ar->hw,
7802                           ath11k_mac_disable_peer_fixed_rate,
7803                           arvif);
7804     } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask,
7805                               &single_nss)) {
7806         rate = WMI_FIXED_RATE_NONE;
7807         nss = single_nss;
7808         mutex_lock(&ar->conf_mutex);
7809         arvif->bitrate_mask = *mask;
7810         ieee80211_iterate_stations_atomic(ar->hw,
7811                           ath11k_mac_set_bitrate_mask_iter,
7812                           arvif);
7813         mutex_unlock(&ar->conf_mutex);
7814     } else {
7815         rate = WMI_FIXED_RATE_NONE;
7816 
7817         if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
7818             ath11k_warn(ar->ab,
7819                     "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
7820         nss = min_t(u32, ar->num_tx_chains,
7821                 max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
7822                     ath11k_mac_max_vht_nss(vht_mcs_mask)),
7823                 ath11k_mac_max_he_nss(he_mcs_mask)));
7824 
7825         /* If multiple rates across different preambles are given
7826          * we can reconfigure this info with all peers using PEER_ASSOC
7827          * command with the below exception cases.
7828          * - Single VHT Rate : peer_assoc command accommodates only MCS
7829          * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
7830          * mandates passing basic rates along with HT/VHT rates, FW
7831          * doesn't allow switching from VHT to Legacy. Hence instead of
7832          * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
7833          * we could set this VHT rate as peer fixed rate param, which
7834          * will override FIXED rate and FW rate control algorithm.
7835          * If single VHT rate is passed along with HT rates, we select
7836          * the VHT rate as fixed rate for vht peers.
7837          * - Multiple VHT Rates : When Multiple VHT rates are given,this
7838          * can be set using RATEMASK CMD which uses FW rate-ctl alg.
7839          * TODO: Setting multiple VHT MCS and replacing peer_assoc with
7840          * RATEMASK_CMDID can cover all use cases of setting rates
7841          * across multiple preambles and rates within same type.
7842          * But requires more validation of the command at this point.
7843          */
7844 
7845         num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
7846                                   mask);
7847 
7848         if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
7849             num_rates > 1) {
7850             /* TODO: Handle multiple VHT MCS values setting using
7851              * RATEMASK CMD
7852              */
7853             ath11k_warn(ar->ab,
7854                     "setting %d mcs values in bitrate mask not supported\n",
7855                 num_rates);
7856             return -EINVAL;
7857         }
7858 
7859         num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
7860                                  mask);
7861         if (num_rates == 1)
7862             he_fixed_rate = true;
7863 
7864         if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
7865             num_rates > 1) {
7866             ath11k_warn(ar->ab,
7867                     "Setting more than one HE MCS Value in bitrate mask not supported\n");
7868             return -EINVAL;
7869         }
7870 
7871         mutex_lock(&ar->conf_mutex);
7872         ieee80211_iterate_stations_atomic(ar->hw,
7873                           ath11k_mac_disable_peer_fixed_rate,
7874                           arvif);
7875 
7876         arvif->bitrate_mask = *mask;
7877         ieee80211_iterate_stations_atomic(ar->hw,
7878                           ath11k_mac_set_bitrate_mask_iter,
7879                           arvif);
7880 
7881         mutex_unlock(&ar->conf_mutex);
7882     }
7883 
7884     mutex_lock(&ar->conf_mutex);
7885 
7886     ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
7887                      he_ltf, he_fixed_rate);
7888     if (ret) {
7889         ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
7890                 arvif->vdev_id, ret);
7891     }
7892 
7893     mutex_unlock(&ar->conf_mutex);
7894 
7895     return ret;
7896 }
7897 
7898 static void
7899 ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
7900                 enum ieee80211_reconfig_type reconfig_type)
7901 {
7902     struct ath11k *ar = hw->priv;
7903     struct ath11k_base *ab = ar->ab;
7904     int recovery_count;
7905 
7906     if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
7907         return;
7908 
7909     mutex_lock(&ar->conf_mutex);
7910 
7911     if (ar->state == ATH11K_STATE_RESTARTED) {
7912         ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
7913                 ar->pdev->pdev_id);
7914         ar->state = ATH11K_STATE_ON;
7915         ieee80211_wake_queues(ar->hw);
7916 
7917         if (ar->ab->hw_params.current_cc_support &&
7918             ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
7919             struct wmi_set_current_country_params set_current_param = {};
7920 
7921             memcpy(&set_current_param.alpha2, ar->alpha2, 2);
7922             ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
7923         }
7924 
7925         if (ab->is_reset) {
7926             recovery_count = atomic_inc_return(&ab->recovery_count);
7927             ath11k_dbg(ab, ATH11K_DBG_BOOT,
7928                    "recovery count %d\n", recovery_count);
7929             /* When there are multiple radios in an SOC,
7930              * the recovery has to be done for each radio
7931              */
7932             if (recovery_count == ab->num_radios) {
7933                 atomic_dec(&ab->reset_count);
7934                 complete(&ab->reset_complete);
7935                 ab->is_reset = false;
7936                 atomic_set(&ab->fail_cont_count, 0);
7937                 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
7938             }
7939         }
7940     }
7941 
7942     mutex_unlock(&ar->conf_mutex);
7943 }
7944 
7945 static void
7946 ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
7947                   struct ieee80211_channel *channel)
7948 {
7949     int ret;
7950     enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
7951 
7952     lockdep_assert_held(&ar->conf_mutex);
7953 
7954     if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
7955         ar->rx_channel != channel)
7956         return;
7957 
7958     if (ar->scan.state != ATH11K_SCAN_IDLE) {
7959         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7960                "ignoring bss chan info req while scanning..\n");
7961         return;
7962     }
7963 
7964     reinit_completion(&ar->bss_survey_done);
7965 
7966     ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
7967     if (ret) {
7968         ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
7969         return;
7970     }
7971 
7972     ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
7973     if (ret == 0)
7974         ath11k_warn(ar->ab, "bss channel survey timed out\n");
7975 }
7976 
7977 static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
7978                     struct survey_info *survey)
7979 {
7980     struct ath11k *ar = hw->priv;
7981     struct ieee80211_supported_band *sband;
7982     struct survey_info *ar_survey;
7983     int ret = 0;
7984 
7985     if (idx >= ATH11K_NUM_CHANS)
7986         return -ENOENT;
7987 
7988     ar_survey = &ar->survey[idx];
7989 
7990     mutex_lock(&ar->conf_mutex);
7991 
7992     sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
7993     if (sband && idx >= sband->n_channels) {
7994         idx -= sband->n_channels;
7995         sband = NULL;
7996     }
7997 
7998     if (!sband)
7999         sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8000     if (sband && idx >= sband->n_channels) {
8001         idx -= sband->n_channels;
8002         sband = NULL;
8003     }
8004 
8005     if (!sband)
8006         sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
8007     if (!sband || idx >= sband->n_channels) {
8008         ret = -ENOENT;
8009         goto exit;
8010     }
8011 
8012     ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8013 
8014     spin_lock_bh(&ar->data_lock);
8015     memcpy(survey, ar_survey, sizeof(*survey));
8016     spin_unlock_bh(&ar->data_lock);
8017 
8018     survey->channel = &sband->channels[idx];
8019 
8020     if (ar->rx_channel == survey->channel)
8021         survey->filled |= SURVEY_INFO_IN_USE;
8022 
8023 exit:
8024     mutex_unlock(&ar->conf_mutex);
8025     return ret;
8026 }
8027 
8028 static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8029                       struct ath11k_sta *arsta,
8030                       char *pre,
8031                       bool clear)
8032 {
8033     struct ath11k *ar = arsta->arvif->ar;
8034     int i;
8035     s8 rssi;
8036 
8037     for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8038         sinfo->chains &= ~BIT(i);
8039         rssi = arsta->chain_signal[i];
8040         if (clear)
8041             arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8042 
8043         ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8044                "mac sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8045 
8046         if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8047             rssi != ATH11K_INVALID_RSSI_FULL &&
8048             rssi != ATH11K_INVALID_RSSI_EMPTY &&
8049             rssi != 0) {
8050             sinfo->chain_signal[i] = rssi;
8051             sinfo->chains |= BIT(i);
8052             sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8053         }
8054     }
8055 }
8056 
8057 static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8058                      struct ieee80211_vif *vif,
8059                      struct ieee80211_sta *sta,
8060                      struct station_info *sinfo)
8061 {
8062     struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
8063     struct ath11k *ar = arsta->arvif->ar;
8064     s8 signal;
8065     bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8066                    ar->ab->wmi_ab.svc_map);
8067 
8068     sinfo->rx_duration = arsta->rx_duration;
8069     sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8070 
8071     sinfo->tx_duration = arsta->tx_duration;
8072     sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8073 
8074     if (arsta->txrate.legacy || arsta->txrate.nss) {
8075         if (arsta->txrate.legacy) {
8076             sinfo->txrate.legacy = arsta->txrate.legacy;
8077         } else {
8078             sinfo->txrate.mcs = arsta->txrate.mcs;
8079             sinfo->txrate.nss = arsta->txrate.nss;
8080             sinfo->txrate.bw = arsta->txrate.bw;
8081             sinfo->txrate.he_gi = arsta->txrate.he_gi;
8082             sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8083             sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8084         }
8085         sinfo->txrate.flags = arsta->txrate.flags;
8086         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8087     }
8088 
8089     ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8090 
8091     if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8092         arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8093         ar->ab->hw_params.supports_rssi_stats &&
8094         !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8095                      WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8096         ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8097     }
8098 
8099     signal = arsta->rssi_comb;
8100     if (!signal &&
8101         arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8102         ar->ab->hw_params.supports_rssi_stats &&
8103         !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8104                     WMI_REQUEST_VDEV_STAT)))
8105         signal = arsta->rssi_beacon;
8106 
8107     ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8108            "mac sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8109            db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8110 
8111     if (signal) {
8112         sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8113         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8114     }
8115 
8116     sinfo->signal_avg = ewma_avg_rssi_read(&arsta->avg_rssi) +
8117         ATH11K_DEFAULT_NOISE_FLOOR;
8118     sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
8119 }
8120 
8121 #if IS_ENABLED(CONFIG_IPV6)
8122 static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8123                        struct ath11k_arp_ns_offload *offload)
8124 {
8125     int i;
8126 
8127     for (i = 0; i < offload->ipv6_count; i++) {
8128         offload->self_ipv6_addr[i][0] = 0xff;
8129         offload->self_ipv6_addr[i][1] = 0x02;
8130         offload->self_ipv6_addr[i][11] = 0x01;
8131         offload->self_ipv6_addr[i][12] = 0xff;
8132         offload->self_ipv6_addr[i][13] =
8133                     offload->ipv6_addr[i][13];
8134         offload->self_ipv6_addr[i][14] =
8135                     offload->ipv6_addr[i][14];
8136         offload->self_ipv6_addr[i][15] =
8137                     offload->ipv6_addr[i][15];
8138         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8139                offload->self_ipv6_addr[i]);
8140     }
8141 }
8142 
8143 static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8144                        struct ieee80211_vif *vif,
8145                        struct inet6_dev *idev)
8146 {
8147     struct ath11k *ar = hw->priv;
8148     struct ath11k_arp_ns_offload *offload;
8149     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8150     struct inet6_ifaddr *ifa6;
8151     struct ifacaddr6 *ifaca6;
8152     struct list_head *p;
8153     u32 count, scope;
8154 
8155     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac op ipv6 changed\n");
8156 
8157     offload = &arvif->arp_ns_offload;
8158     count = 0;
8159 
8160     read_lock_bh(&idev->lock);
8161 
8162     memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8163     memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8164     memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8165 
8166     /* get unicast address */
8167     list_for_each(p, &idev->addr_list) {
8168         if (count >= ATH11K_IPV6_MAX_COUNT)
8169             goto generate;
8170 
8171         ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8172         if (ifa6->flags & IFA_F_DADFAILED)
8173             continue;
8174         scope = ipv6_addr_src_scope(&ifa6->addr);
8175         if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8176             scope == IPV6_ADDR_SCOPE_GLOBAL) {
8177             memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8178                    sizeof(ifa6->addr.s6_addr));
8179             offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8180             ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 uc %pI6 scope %d\n",
8181                    count, offload->ipv6_addr[count],
8182                    scope);
8183             count++;
8184         } else {
8185             ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8186         }
8187     }
8188 
8189     /* get anycast address */
8190     for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8191         if (count >= ATH11K_IPV6_MAX_COUNT)
8192             goto generate;
8193 
8194         scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8195         if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8196             scope == IPV6_ADDR_SCOPE_GLOBAL) {
8197             memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8198                    sizeof(ifaca6->aca_addr));
8199             offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8200             ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 ac %pI6 scope %d\n",
8201                    count, offload->ipv6_addr[count],
8202                    scope);
8203             count++;
8204         } else {
8205             ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8206         }
8207     }
8208 
8209 generate:
8210     offload->ipv6_count = count;
8211     read_unlock_bh(&idev->lock);
8212 
8213     /* generate ns multicast address */
8214     ath11k_generate_ns_mc_addr(ar, offload);
8215 }
8216 #endif
8217 
8218 static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8219                      struct ieee80211_vif *vif,
8220                      struct cfg80211_gtk_rekey_data *data)
8221 {
8222     struct ath11k *ar = hw->priv;
8223     struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8224     struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8225 
8226     ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac set rekey data vdev %d\n",
8227            arvif->vdev_id);
8228 
8229     mutex_lock(&ar->conf_mutex);
8230 
8231     memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8232     memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8233 
8234     /* The supplicant works on big-endian, the firmware expects it on
8235      * little endian.
8236      */
8237     rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8238 
8239     arvif->rekey_data.enable_offload = true;
8240 
8241     ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8242             rekey_data->kck, NL80211_KCK_LEN);
8243     ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8244             rekey_data->kck, NL80211_KEK_LEN);
8245     ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8246             &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8247 
8248     mutex_unlock(&ar->conf_mutex);
8249 }
8250 
8251 static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8252                         const struct cfg80211_sar_specs *sar)
8253 {
8254     struct ath11k *ar = hw->priv;
8255     const struct cfg80211_sar_sub_specs *sspec;
8256     int ret, index;
8257     u8 *sar_tbl;
8258     u32 i;
8259 
8260     if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8261         sar->num_sub_specs == 0)
8262         return -EINVAL;
8263 
8264     mutex_lock(&ar->conf_mutex);
8265 
8266     if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8267         !ar->ab->hw_params.bios_sar_capa) {
8268         ret = -EOPNOTSUPP;
8269         goto exit;
8270     }
8271 
8272     ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8273     if (ret) {
8274         ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8275         goto exit;
8276     }
8277 
8278     sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8279     if (!sar_tbl) {
8280         ret = -ENOMEM;
8281         goto exit;
8282     }
8283 
8284     sspec = sar->sub_specs;
8285     for (i = 0; i < sar->num_sub_specs; i++) {
8286         if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8287             ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8288                     sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8289             continue;
8290         }
8291 
8292         /* chain0 and chain1 share same power setting */
8293         sar_tbl[sspec->freq_range_index] = sspec->power;
8294         index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8295         sar_tbl[index] = sspec->power;
8296         ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8297                sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8298         sspec++;
8299     }
8300 
8301     ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8302     if (ret)
8303         ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8304 
8305     kfree(sar_tbl);
8306 exit:
8307     mutex_unlock(&ar->conf_mutex);
8308 
8309     return ret;
8310 }
8311 
8312 static int ath11k_mac_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
8313                           struct ieee80211_vif *vif)
8314 {
8315     struct ath11k *ar = hw->priv;
8316 
8317     mutex_lock(&ar->conf_mutex);
8318 
8319     spin_lock_bh(&ar->data_lock);
8320     ar->scan.roc_notify = false;
8321     spin_unlock_bh(&ar->data_lock);
8322 
8323     ath11k_scan_abort(ar);
8324 
8325     mutex_unlock(&ar->conf_mutex);
8326 
8327     cancel_delayed_work_sync(&ar->scan.timeout);
8328 
8329     return 0;
8330 }
8331 
8332 static int ath11k_mac_op_remain_on_channel(struct ieee80211_hw *hw,
8333                        struct ieee80211_vif *vif,
8334                        struct ieee80211_channel *chan,
8335                        int duration,
8336                        enum ieee80211_roc_type type)
8337 {
8338     struct ath11k *ar = hw->priv;
8339     struct ath11k_vif *arvif = (void *)vif->drv_priv;
8340     struct scan_req_params arg;
8341     int ret;
8342     u32 scan_time_msec;
8343 
8344     mutex_lock(&ar->conf_mutex);
8345 
8346     spin_lock_bh(&ar->data_lock);
8347     switch (ar->scan.state) {
8348     case ATH11K_SCAN_IDLE:
8349         reinit_completion(&ar->scan.started);
8350         reinit_completion(&ar->scan.completed);
8351         reinit_completion(&ar->scan.on_channel);
8352         ar->scan.state = ATH11K_SCAN_STARTING;
8353         ar->scan.is_roc = true;
8354         ar->scan.vdev_id = arvif->vdev_id;
8355         ar->scan.roc_freq = chan->center_freq;
8356         ar->scan.roc_notify = true;
8357         ret = 0;
8358         break;
8359     case ATH11K_SCAN_STARTING:
8360     case ATH11K_SCAN_RUNNING:
8361     case ATH11K_SCAN_ABORTING:
8362         ret = -EBUSY;
8363         break;
8364     }
8365     spin_unlock_bh(&ar->data_lock);
8366 
8367     if (ret)
8368         goto exit;
8369 
8370     scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
8371 
8372     memset(&arg, 0, sizeof(arg));
8373     ath11k_wmi_start_scan_init(ar, &arg);
8374     arg.num_chan = 1;
8375     arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
8376                 GFP_KERNEL);
8377     if (!arg.chan_list) {
8378         ret = -ENOMEM;
8379         goto exit;
8380     }
8381 
8382     arg.vdev_id = arvif->vdev_id;
8383     arg.scan_id = ATH11K_SCAN_ID;
8384     arg.chan_list[0] = chan->center_freq;
8385     arg.dwell_time_active = scan_time_msec;
8386     arg.dwell_time_passive = scan_time_msec;
8387     arg.max_scan_time = scan_time_msec;
8388     arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
8389     arg.scan_flags |= WMI_SCAN_FILTER_PROBE_REQ;
8390     arg.burst_duration = duration;
8391 
8392     ret = ath11k_start_scan(ar, &arg);
8393     if (ret) {
8394         ath11k_warn(ar->ab, "failed to start roc scan: %d\n", ret);
8395 
8396         spin_lock_bh(&ar->data_lock);
8397         ar->scan.state = ATH11K_SCAN_IDLE;
8398         spin_unlock_bh(&ar->data_lock);
8399         goto free_chan_list;
8400     }
8401 
8402     ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
8403     if (ret == 0) {
8404         ath11k_warn(ar->ab, "failed to switch to channel for roc scan\n");
8405         ret = ath11k_scan_stop(ar);
8406         if (ret)
8407             ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
8408         ret = -ETIMEDOUT;
8409         goto free_chan_list;
8410     }
8411 
8412     ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
8413                      msecs_to_jiffies(duration));
8414 
8415     ret = 0;
8416 
8417 free_chan_list:
8418     kfree(arg.chan_list);
8419 exit:
8420     mutex_unlock(&ar->conf_mutex);
8421     return ret;
8422 }
8423 
8424 static const struct ieee80211_ops ath11k_ops = {
8425     .tx             = ath11k_mac_op_tx,
8426     .start                          = ath11k_mac_op_start,
8427     .stop                           = ath11k_mac_op_stop,
8428     .reconfig_complete              = ath11k_mac_op_reconfig_complete,
8429     .add_interface                  = ath11k_mac_op_add_interface,
8430     .remove_interface       = ath11k_mac_op_remove_interface,
8431     .update_vif_offload     = ath11k_mac_op_update_vif_offload,
8432     .config                         = ath11k_mac_op_config,
8433     .bss_info_changed               = ath11k_mac_op_bss_info_changed,
8434     .configure_filter       = ath11k_mac_op_configure_filter,
8435     .hw_scan                        = ath11k_mac_op_hw_scan,
8436     .cancel_hw_scan                 = ath11k_mac_op_cancel_hw_scan,
8437     .set_key                        = ath11k_mac_op_set_key,
8438     .set_rekey_data                 = ath11k_mac_op_set_rekey_data,
8439     .sta_state                      = ath11k_mac_op_sta_state,
8440     .sta_set_4addr                  = ath11k_mac_op_sta_set_4addr,
8441     .sta_set_txpwr          = ath11k_mac_op_sta_set_txpwr,
8442     .sta_rc_update          = ath11k_mac_op_sta_rc_update,
8443     .conf_tx                        = ath11k_mac_op_conf_tx,
8444     .set_antenna            = ath11k_mac_op_set_antenna,
8445     .get_antenna            = ath11k_mac_op_get_antenna,
8446     .ampdu_action           = ath11k_mac_op_ampdu_action,
8447     .add_chanctx            = ath11k_mac_op_add_chanctx,
8448     .remove_chanctx         = ath11k_mac_op_remove_chanctx,
8449     .change_chanctx         = ath11k_mac_op_change_chanctx,
8450     .assign_vif_chanctx     = ath11k_mac_op_assign_vif_chanctx,
8451     .unassign_vif_chanctx       = ath11k_mac_op_unassign_vif_chanctx,
8452     .switch_vif_chanctx     = ath11k_mac_op_switch_vif_chanctx,
8453     .set_rts_threshold      = ath11k_mac_op_set_rts_threshold,
8454     .set_frag_threshold     = ath11k_mac_op_set_frag_threshold,
8455     .set_bitrate_mask       = ath11k_mac_op_set_bitrate_mask,
8456     .get_survey         = ath11k_mac_op_get_survey,
8457     .flush              = ath11k_mac_op_flush,
8458     .sta_statistics         = ath11k_mac_op_sta_statistics,
8459     CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
8460 
8461 #ifdef CONFIG_PM
8462     .suspend            = ath11k_wow_op_suspend,
8463     .resume             = ath11k_wow_op_resume,
8464     .set_wakeup         = ath11k_wow_op_set_wakeup,
8465 #endif
8466 
8467 #ifdef CONFIG_ATH11K_DEBUGFS
8468     .sta_add_debugfs        = ath11k_debugfs_sta_op_add,
8469 #endif
8470 
8471 #if IS_ENABLED(CONFIG_IPV6)
8472     .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
8473 #endif
8474 
8475     .set_sar_specs          = ath11k_mac_op_set_bios_sar_specs,
8476     .remain_on_channel      = ath11k_mac_op_remain_on_channel,
8477     .cancel_remain_on_channel   = ath11k_mac_op_cancel_remain_on_channel,
8478 };
8479 
8480 static void ath11k_mac_update_ch_list(struct ath11k *ar,
8481                       struct ieee80211_supported_band *band,
8482                       u32 freq_low, u32 freq_high)
8483 {
8484     int i;
8485 
8486     if (!(freq_low && freq_high))
8487         return;
8488 
8489     for (i = 0; i < band->n_channels; i++) {
8490         if (band->channels[i].center_freq < freq_low ||
8491             band->channels[i].center_freq > freq_high)
8492             band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
8493     }
8494 }
8495 
8496 static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
8497 {
8498     struct ath11k_pdev *pdev = ar->pdev;
8499     struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
8500 
8501     if (band == WMI_HOST_WLAN_2G_CAP)
8502         return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
8503 
8504     if (band == WMI_HOST_WLAN_5G_CAP)
8505         return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
8506 
8507     ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
8508 
8509     return 0;
8510 }
8511 
8512 static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
8513                        u32 supported_bands)
8514 {
8515     struct ieee80211_supported_band *band;
8516     struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
8517     void *channels;
8518     u32 phy_id;
8519 
8520     BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
8521               ARRAY_SIZE(ath11k_5ghz_channels) +
8522               ARRAY_SIZE(ath11k_6ghz_channels)) !=
8523              ATH11K_NUM_CHANS);
8524 
8525     reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
8526     temp_reg_cap = reg_cap;
8527 
8528     if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
8529         channels = kmemdup(ath11k_2ghz_channels,
8530                    sizeof(ath11k_2ghz_channels),
8531                    GFP_KERNEL);
8532         if (!channels)
8533             return -ENOMEM;
8534 
8535         band = &ar->mac.sbands[NL80211_BAND_2GHZ];
8536         band->band = NL80211_BAND_2GHZ;
8537         band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
8538         band->channels = channels;
8539         band->n_bitrates = ath11k_g_rates_size;
8540         band->bitrates = ath11k_g_rates;
8541         ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
8542 
8543         if (ar->ab->hw_params.single_pdev_only) {
8544             phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
8545             temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8546         }
8547         ath11k_mac_update_ch_list(ar, band,
8548                       temp_reg_cap->low_2ghz_chan,
8549                       temp_reg_cap->high_2ghz_chan);
8550     }
8551 
8552     if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
8553         if (reg_cap->high_5ghz_chan >= ATH11K_MAX_6G_FREQ) {
8554             channels = kmemdup(ath11k_6ghz_channels,
8555                        sizeof(ath11k_6ghz_channels), GFP_KERNEL);
8556             if (!channels) {
8557                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8558                 return -ENOMEM;
8559             }
8560 
8561             ar->supports_6ghz = true;
8562             band = &ar->mac.sbands[NL80211_BAND_6GHZ];
8563             band->band = NL80211_BAND_6GHZ;
8564             band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
8565             band->channels = channels;
8566             band->n_bitrates = ath11k_a_rates_size;
8567             band->bitrates = ath11k_a_rates;
8568             ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
8569 
8570             if (ar->ab->hw_params.single_pdev_only) {
8571                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8572                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8573             }
8574 
8575             ath11k_mac_update_ch_list(ar, band,
8576                           temp_reg_cap->low_5ghz_chan,
8577                           temp_reg_cap->high_5ghz_chan);
8578         }
8579 
8580         if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
8581             channels = kmemdup(ath11k_5ghz_channels,
8582                        sizeof(ath11k_5ghz_channels),
8583                        GFP_KERNEL);
8584             if (!channels) {
8585                 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8586                 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8587                 return -ENOMEM;
8588             }
8589 
8590             band = &ar->mac.sbands[NL80211_BAND_5GHZ];
8591             band->band = NL80211_BAND_5GHZ;
8592             band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
8593             band->channels = channels;
8594             band->n_bitrates = ath11k_a_rates_size;
8595             band->bitrates = ath11k_a_rates;
8596             ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
8597 
8598             if (ar->ab->hw_params.single_pdev_only) {
8599                 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8600                 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8601             }
8602 
8603             ath11k_mac_update_ch_list(ar, band,
8604                           temp_reg_cap->low_5ghz_chan,
8605                           temp_reg_cap->high_5ghz_chan);
8606         }
8607     }
8608 
8609     return 0;
8610 }
8611 
8612 static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
8613 {
8614     struct ath11k_base *ab = ar->ab;
8615     struct ieee80211_iface_combination *combinations;
8616     struct ieee80211_iface_limit *limits;
8617     int n_limits;
8618 
8619     combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
8620     if (!combinations)
8621         return -ENOMEM;
8622 
8623     n_limits = 2;
8624 
8625     limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
8626     if (!limits) {
8627         kfree(combinations);
8628         return -ENOMEM;
8629     }
8630 
8631     limits[0].max = 1;
8632     limits[0].types |= BIT(NL80211_IFTYPE_STATION);
8633 
8634     limits[1].max = 16;
8635     limits[1].types |= BIT(NL80211_IFTYPE_AP);
8636 
8637     if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
8638         ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
8639         limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
8640 
8641     combinations[0].limits = limits;
8642     combinations[0].n_limits = n_limits;
8643     combinations[0].max_interfaces = 16;
8644     combinations[0].num_different_channels = 1;
8645     combinations[0].beacon_int_infra_match = true;
8646     combinations[0].beacon_int_min_gcd = 100;
8647     combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
8648                         BIT(NL80211_CHAN_WIDTH_20) |
8649                         BIT(NL80211_CHAN_WIDTH_40) |
8650                         BIT(NL80211_CHAN_WIDTH_80) |
8651                         BIT(NL80211_CHAN_WIDTH_80P80) |
8652                         BIT(NL80211_CHAN_WIDTH_160);
8653 
8654     ar->hw->wiphy->iface_combinations = combinations;
8655     ar->hw->wiphy->n_iface_combinations = 1;
8656 
8657     return 0;
8658 }
8659 
8660 static const u8 ath11k_if_types_ext_capa[] = {
8661     [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8662     [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8663 };
8664 
8665 static const u8 ath11k_if_types_ext_capa_sta[] = {
8666     [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8667     [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8668     [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
8669 };
8670 
8671 static const u8 ath11k_if_types_ext_capa_ap[] = {
8672     [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8673     [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8674     [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
8675 };
8676 
8677 static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
8678     {
8679         .extended_capabilities = ath11k_if_types_ext_capa,
8680         .extended_capabilities_mask = ath11k_if_types_ext_capa,
8681         .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
8682     }, {
8683         .iftype = NL80211_IFTYPE_STATION,
8684         .extended_capabilities = ath11k_if_types_ext_capa_sta,
8685         .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
8686         .extended_capabilities_len =
8687                 sizeof(ath11k_if_types_ext_capa_sta),
8688     }, {
8689         .iftype = NL80211_IFTYPE_AP,
8690         .extended_capabilities = ath11k_if_types_ext_capa_ap,
8691         .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
8692         .extended_capabilities_len =
8693                 sizeof(ath11k_if_types_ext_capa_ap),
8694     },
8695 };
8696 
8697 static void __ath11k_mac_unregister(struct ath11k *ar)
8698 {
8699     cancel_work_sync(&ar->regd_update_work);
8700 
8701     ieee80211_unregister_hw(ar->hw);
8702 
8703     idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
8704     idr_destroy(&ar->txmgmt_idr);
8705 
8706     kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8707     kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
8708     kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8709 
8710     kfree(ar->hw->wiphy->iface_combinations[0].limits);
8711     kfree(ar->hw->wiphy->iface_combinations);
8712 
8713     SET_IEEE80211_DEV(ar->hw, NULL);
8714 }
8715 
8716 void ath11k_mac_unregister(struct ath11k_base *ab)
8717 {
8718     struct ath11k *ar;
8719     struct ath11k_pdev *pdev;
8720     int i;
8721 
8722     for (i = 0; i < ab->num_radios; i++) {
8723         pdev = &ab->pdevs[i];
8724         ar = pdev->ar;
8725         if (!ar)
8726             continue;
8727 
8728         __ath11k_mac_unregister(ar);
8729     }
8730 
8731     ath11k_peer_rhash_tbl_destroy(ab);
8732 }
8733 
8734 static int __ath11k_mac_register(struct ath11k *ar)
8735 {
8736     struct ath11k_base *ab = ar->ab;
8737     struct ath11k_pdev_cap *cap = &ar->pdev->cap;
8738     static const u32 cipher_suites[] = {
8739         WLAN_CIPHER_SUITE_TKIP,
8740         WLAN_CIPHER_SUITE_CCMP,
8741         WLAN_CIPHER_SUITE_AES_CMAC,
8742         WLAN_CIPHER_SUITE_BIP_CMAC_256,
8743         WLAN_CIPHER_SUITE_BIP_GMAC_128,
8744         WLAN_CIPHER_SUITE_BIP_GMAC_256,
8745         WLAN_CIPHER_SUITE_GCMP,
8746         WLAN_CIPHER_SUITE_GCMP_256,
8747         WLAN_CIPHER_SUITE_CCMP_256,
8748     };
8749     int ret;
8750     u32 ht_cap = 0;
8751 
8752     ath11k_pdev_caps_update(ar);
8753 
8754     SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
8755 
8756     SET_IEEE80211_DEV(ar->hw, ab->dev);
8757 
8758     ret = ath11k_mac_setup_channels_rates(ar,
8759                           cap->supported_bands);
8760     if (ret)
8761         goto err;
8762 
8763     ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
8764     ath11k_mac_setup_he_cap(ar, cap);
8765 
8766     ret = ath11k_mac_setup_iface_combinations(ar);
8767     if (ret) {
8768         ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
8769         goto err_free_channels;
8770     }
8771 
8772     ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
8773     ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
8774 
8775     ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
8776 
8777     if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
8778         ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
8779 
8780     ieee80211_hw_set(ar->hw, SIGNAL_DBM);
8781     ieee80211_hw_set(ar->hw, SUPPORTS_PS);
8782     ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
8783     ieee80211_hw_set(ar->hw, MFP_CAPABLE);
8784     ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
8785     ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
8786     ieee80211_hw_set(ar->hw, AP_LINK_PS);
8787     ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
8788     ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
8789     ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
8790     ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
8791     ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
8792     ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
8793     ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
8794     ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
8795 
8796     if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
8797         ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
8798         ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
8799     }
8800 
8801     if (cap->nss_ratio_enabled)
8802         ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
8803 
8804     if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
8805         ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
8806         ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
8807         ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
8808         ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
8809         ieee80211_hw_set(ar->hw, USES_RSS);
8810     }
8811 
8812     ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
8813     ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
8814 
8815     /* TODO: Check if HT capability advertised from firmware is different
8816      * for each band for a dual band capable radio. It will be tricky to
8817      * handle it when the ht capability different for each band.
8818      */
8819     if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
8820         (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
8821         ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
8822 
8823     ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
8824     ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
8825 
8826     ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
8827 
8828     ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
8829     ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
8830     ar->hw->wiphy->max_remain_on_channel_duration = 5000;
8831 
8832     ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
8833     ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
8834                    NL80211_FEATURE_AP_SCAN;
8835 
8836     ar->max_num_stations = TARGET_NUM_STATIONS(ab);
8837     ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
8838 
8839     ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
8840 
8841     if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
8842         ar->hw->wiphy->features |=
8843             NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
8844     }
8845 
8846     if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
8847         ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
8848         ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
8849         ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
8850         ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
8851         ar->hw->wiphy->max_sched_scan_plan_interval =
8852             WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
8853         ar->hw->wiphy->max_sched_scan_plan_iterations =
8854             WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
8855         ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
8856     }
8857 
8858     ret = ath11k_wow_init(ar);
8859     if (ret) {
8860         ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
8861         goto err_free_if_combs;
8862     }
8863 
8864     ar->hw->queues = ATH11K_HW_MAX_QUEUES;
8865     ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
8866     ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
8867     ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
8868 
8869     ar->hw->vif_data_size = sizeof(struct ath11k_vif);
8870     ar->hw->sta_data_size = sizeof(struct ath11k_sta);
8871 
8872     wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
8873     wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
8874     if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD,
8875              ar->ab->wmi_ab.svc_map)) {
8876         wiphy_ext_feature_set(ar->hw->wiphy,
8877                       NL80211_EXT_FEATURE_BSS_COLOR);
8878         ieee80211_hw_set(ar->hw, DETECTS_COLOR_COLLISION);
8879     }
8880 
8881     ar->hw->wiphy->cipher_suites = cipher_suites;
8882     ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
8883 
8884     ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
8885     ar->hw->wiphy->num_iftype_ext_capab =
8886         ARRAY_SIZE(ath11k_iftypes_ext_capa);
8887 
8888     if (ar->supports_6ghz) {
8889         wiphy_ext_feature_set(ar->hw->wiphy,
8890                       NL80211_EXT_FEATURE_FILS_DISCOVERY);
8891         wiphy_ext_feature_set(ar->hw->wiphy,
8892                       NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
8893     }
8894 
8895     ath11k_reg_init(ar);
8896 
8897     if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
8898         ar->hw->netdev_features = NETIF_F_HW_CSUM;
8899         ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
8900         ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
8901     }
8902 
8903     if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
8904         ab->hw_params.bios_sar_capa)
8905         ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
8906 
8907     ret = ieee80211_register_hw(ar->hw);
8908     if (ret) {
8909         ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
8910         goto err_free_if_combs;
8911     }
8912 
8913     if (!ab->hw_params.supports_monitor)
8914         /* There's a race between calling ieee80211_register_hw()
8915          * and here where the monitor mode is enabled for a little
8916          * while. But that time is so short and in practise it make
8917          * a difference in real life.
8918          */
8919         ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
8920 
8921     /* Apply the regd received during initialization */
8922     ret = ath11k_regd_update(ar);
8923     if (ret) {
8924         ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
8925         goto err_unregister_hw;
8926     }
8927 
8928     if (ab->hw_params.current_cc_support && ab->new_alpha2[0]) {
8929         struct wmi_set_current_country_params set_current_param = {};
8930 
8931         memcpy(&set_current_param.alpha2, ab->new_alpha2, 2);
8932         memcpy(&ar->alpha2, ab->new_alpha2, 2);
8933         ret = ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
8934         if (ret)
8935             ath11k_warn(ar->ab,
8936                     "failed set cc code for mac register: %d\n", ret);
8937     }
8938 
8939     ret = ath11k_debugfs_register(ar);
8940     if (ret) {
8941         ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
8942         goto err_unregister_hw;
8943     }
8944 
8945     return 0;
8946 
8947 err_unregister_hw:
8948     ieee80211_unregister_hw(ar->hw);
8949 
8950 err_free_if_combs:
8951     kfree(ar->hw->wiphy->iface_combinations[0].limits);
8952     kfree(ar->hw->wiphy->iface_combinations);
8953 
8954 err_free_channels:
8955     kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8956     kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
8957     kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8958 
8959 err:
8960     SET_IEEE80211_DEV(ar->hw, NULL);
8961     return ret;
8962 }
8963 
8964 int ath11k_mac_register(struct ath11k_base *ab)
8965 {
8966     struct ath11k *ar;
8967     struct ath11k_pdev *pdev;
8968     int i;
8969     int ret;
8970 
8971     if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
8972         return 0;
8973 
8974     /* Initialize channel counters frequency value in hertz */
8975     ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
8976     ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
8977 
8978     ret = ath11k_peer_rhash_tbl_init(ab);
8979     if (ret)
8980         return ret;
8981 
8982     for (i = 0; i < ab->num_radios; i++) {
8983         pdev = &ab->pdevs[i];
8984         ar = pdev->ar;
8985         if (ab->pdevs_macaddr_valid) {
8986             ether_addr_copy(ar->mac_addr, pdev->mac_addr);
8987         } else {
8988             ether_addr_copy(ar->mac_addr, ab->mac_addr);
8989             ar->mac_addr[4] += i;
8990         }
8991 
8992         idr_init(&ar->txmgmt_idr);
8993         spin_lock_init(&ar->txmgmt_idr_lock);
8994 
8995         ret = __ath11k_mac_register(ar);
8996         if (ret)
8997             goto err_cleanup;
8998 
8999         init_waitqueue_head(&ar->txmgmt_empty_waitq);
9000     }
9001 
9002     return 0;
9003 
9004 err_cleanup:
9005     for (i = i - 1; i >= 0; i--) {
9006         pdev = &ab->pdevs[i];
9007         ar = pdev->ar;
9008         __ath11k_mac_unregister(ar);
9009     }
9010 
9011     ath11k_peer_rhash_tbl_destroy(ab);
9012 
9013     return ret;
9014 }
9015 
9016 int ath11k_mac_allocate(struct ath11k_base *ab)
9017 {
9018     struct ieee80211_hw *hw;
9019     struct ath11k *ar;
9020     struct ath11k_pdev *pdev;
9021     int ret;
9022     int i;
9023 
9024     if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
9025         return 0;
9026 
9027     for (i = 0; i < ab->num_radios; i++) {
9028         pdev = &ab->pdevs[i];
9029         hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
9030         if (!hw) {
9031             ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
9032             ret = -ENOMEM;
9033             goto err_free_mac;
9034         }
9035 
9036         ar = hw->priv;
9037         ar->hw = hw;
9038         ar->ab = ab;
9039         ar->pdev = pdev;
9040         ar->pdev_idx = i;
9041         ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
9042 
9043         ar->wmi = &ab->wmi_ab.wmi[i];
9044         /* FIXME wmi[0] is already initialized during attach,
9045          * Should we do this again?
9046          */
9047         ath11k_wmi_pdev_attach(ab, i);
9048 
9049         ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
9050         ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
9051         ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
9052         ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
9053 
9054         pdev->ar = ar;
9055         spin_lock_init(&ar->data_lock);
9056         INIT_LIST_HEAD(&ar->arvifs);
9057         INIT_LIST_HEAD(&ar->ppdu_stats_info);
9058         mutex_init(&ar->conf_mutex);
9059         init_completion(&ar->vdev_setup_done);
9060         init_completion(&ar->vdev_delete_done);
9061         init_completion(&ar->peer_assoc_done);
9062         init_completion(&ar->peer_delete_done);
9063         init_completion(&ar->install_key_done);
9064         init_completion(&ar->bss_survey_done);
9065         init_completion(&ar->scan.started);
9066         init_completion(&ar->scan.completed);
9067         init_completion(&ar->scan.on_channel);
9068         init_completion(&ar->thermal.wmi_sync);
9069 
9070         INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
9071         INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
9072 
9073         INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
9074         skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
9075 
9076         clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
9077 
9078         ar->monitor_vdev_id = -1;
9079         clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9080         ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
9081         init_completion(&ar->completed_11d_scan);
9082     }
9083 
9084     return 0;
9085 
9086 err_free_mac:
9087     ath11k_mac_destroy(ab);
9088 
9089     return ret;
9090 }
9091 
9092 void ath11k_mac_destroy(struct ath11k_base *ab)
9093 {
9094     struct ath11k *ar;
9095     struct ath11k_pdev *pdev;
9096     int i;
9097 
9098     for (i = 0; i < ab->num_radios; i++) {
9099         pdev = &ab->pdevs[i];
9100         ar = pdev->ar;
9101         if (!ar)
9102             continue;
9103 
9104         ieee80211_free_hw(ar->hw);
9105         pdev->ar = NULL;
9106     }
9107 }
9108 
9109 int ath11k_mac_vif_set_keepalive(struct ath11k_vif *arvif,
9110                  enum wmi_sta_keepalive_method method,
9111                  u32 interval)
9112 {
9113     struct ath11k *ar = arvif->ar;
9114     struct wmi_sta_keepalive_arg arg = {};
9115     int ret;
9116 
9117     lockdep_assert_held(&ar->conf_mutex);
9118 
9119     if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
9120         return 0;
9121 
9122     if (!test_bit(WMI_TLV_SERVICE_STA_KEEP_ALIVE, ar->ab->wmi_ab.svc_map))
9123         return 0;
9124 
9125     arg.vdev_id = arvif->vdev_id;
9126     arg.enabled = 1;
9127     arg.method = method;
9128     arg.interval = interval;
9129 
9130     ret = ath11k_wmi_sta_keepalive(ar, &arg);
9131     if (ret) {
9132         ath11k_warn(ar->ab, "failed to set keepalive on vdev %i: %d\n",
9133                 arvif->vdev_id, ret);
9134         return ret;
9135     }
9136 
9137     return 0;
9138 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!