// SPDX-License-Identifier: BSD-3-Clause-Clear
/*
 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
 * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
 */

#include <net/mac80211.h>
#include <linux/etherdevice.h>
#include "mac.h"
#include "core.h"
#include "debug.h"
#include "wmi.h"
#include "hw.h"
#include "dp_tx.h"
#include "dp_rx.h"
#include "testmode.h"
#include "peer.h"
#include "debugfs_sta.h"

#define CHAN2G(_channel, _freq, _flags) { \
        .band                   = NL80211_BAND_2GHZ, \
        .hw_value               = (_channel), \
        .center_freq            = (_freq), \
        .flags                  = (_flags), \
        .max_antenna_gain       = 0, \
        .max_power              = 30, \
}

#define CHAN5G(_channel, _freq, _flags) { \
        .band                   = NL80211_BAND_5GHZ, \
        .hw_value               = (_channel), \
        .center_freq            = (_freq), \
        .flags                  = (_flags), \
        .max_antenna_gain       = 0, \
        .max_power              = 30, \
}

#define CHAN6G(_channel, _freq, _flags) { \
        .band                   = NL80211_BAND_6GHZ, \
        .hw_value               = (_channel), \
        .center_freq            = (_freq), \
        .flags                  = (_flags), \
        .max_antenna_gain       = 0, \
        .max_power              = 30, \
}

static const struct ieee80211_channel ath11k_2ghz_channels[] = {
        CHAN2G(1, 2412, 0),
        CHAN2G(2, 2417, 0),
        CHAN2G(3, 2422, 0),
        CHAN2G(4, 2427, 0),
        CHAN2G(5, 2432, 0),
        CHAN2G(6, 2437, 0),
        CHAN2G(7, 2442, 0),
        CHAN2G(8, 2447, 0),
        CHAN2G(9, 2452, 0),
        CHAN2G(10, 2457, 0),
        CHAN2G(11, 2462, 0),
        CHAN2G(12, 2467, 0),
        CHAN2G(13, 2472, 0),
        CHAN2G(14, 2484, 0),
};

static const struct ieee80211_channel ath11k_5ghz_channels[] = {
        CHAN5G(36, 5180, 0),
        CHAN5G(40, 5200, 0),
        CHAN5G(44, 5220, 0),
        CHAN5G(48, 5240, 0),
        CHAN5G(52, 5260, 0),
        CHAN5G(56, 5280, 0),
        CHAN5G(60, 5300, 0),
        CHAN5G(64, 5320, 0),
        CHAN5G(100, 5500, 0),
        CHAN5G(104, 5520, 0),
        CHAN5G(108, 5540, 0),
        CHAN5G(112, 5560, 0),
        CHAN5G(116, 5580, 0),
        CHAN5G(120, 5600, 0),
        CHAN5G(124, 5620, 0),
        CHAN5G(128, 5640, 0),
        CHAN5G(132, 5660, 0),
        CHAN5G(136, 5680, 0),
        CHAN5G(140, 5700, 0),
        CHAN5G(144, 5720, 0),
        CHAN5G(149, 5745, 0),
        CHAN5G(153, 5765, 0),
        CHAN5G(157, 5785, 0),
        CHAN5G(161, 5805, 0),
        CHAN5G(165, 5825, 0),
        CHAN5G(169, 5845, 0),
        CHAN5G(173, 5865, 0),
};

static const struct ieee80211_channel ath11k_6ghz_channels[] = {
        CHAN6G(1, 5955, 0),
        CHAN6G(5, 5975, 0),
        CHAN6G(9, 5995, 0),
        CHAN6G(13, 6015, 0),
        CHAN6G(17, 6035, 0),
        CHAN6G(21, 6055, 0),
        CHAN6G(25, 6075, 0),
        CHAN6G(29, 6095, 0),
        CHAN6G(33, 6115, 0),
        CHAN6G(37, 6135, 0),
        CHAN6G(41, 6155, 0),
        CHAN6G(45, 6175, 0),
        CHAN6G(49, 6195, 0),
        CHAN6G(53, 6215, 0),
        CHAN6G(57, 6235, 0),
        CHAN6G(61, 6255, 0),
        CHAN6G(65, 6275, 0),
        CHAN6G(69, 6295, 0),
        CHAN6G(73, 6315, 0),
        CHAN6G(77, 6335, 0),
        CHAN6G(81, 6355, 0),
        CHAN6G(85, 6375, 0),
        CHAN6G(89, 6395, 0),
        CHAN6G(93, 6415, 0),
        CHAN6G(97, 6435, 0),
        CHAN6G(101, 6455, 0),
        CHAN6G(105, 6475, 0),
        CHAN6G(109, 6495, 0),
        CHAN6G(113, 6515, 0),
        CHAN6G(117, 6535, 0),
        CHAN6G(121, 6555, 0),
        CHAN6G(125, 6575, 0),
        CHAN6G(129, 6595, 0),
        CHAN6G(133, 6615, 0),
        CHAN6G(137, 6635, 0),
        CHAN6G(141, 6655, 0),
        CHAN6G(145, 6675, 0),
        CHAN6G(149, 6695, 0),
        CHAN6G(153, 6715, 0),
        CHAN6G(157, 6735, 0),
        CHAN6G(161, 6755, 0),
        CHAN6G(165, 6775, 0),
        CHAN6G(169, 6795, 0),
        CHAN6G(173, 6815, 0),
        CHAN6G(177, 6835, 0),
        CHAN6G(181, 6855, 0),
        CHAN6G(185, 6875, 0),
        CHAN6G(189, 6895, 0),
        CHAN6G(193, 6915, 0),
        CHAN6G(197, 6935, 0),
        CHAN6G(201, 6955, 0),
        CHAN6G(205, 6975, 0),
        CHAN6G(209, 6995, 0),
        CHAN6G(213, 7015, 0),
        CHAN6G(217, 7035, 0),
        CHAN6G(221, 7055, 0),
        CHAN6G(225, 7075, 0),
        CHAN6G(229, 7095, 0),
        CHAN6G(233, 7115, 0),

        /* new addition in IEEE Std 802.11ax-2021 */
        CHAN6G(2, 5935, 0),
};

static struct ieee80211_rate ath11k_legacy_rates[] = {
        { .bitrate = 10,
          .hw_value = ATH11K_HW_RATE_CCK_LP_1M },
        { .bitrate = 20,
          .hw_value = ATH11K_HW_RATE_CCK_LP_2M,
          .hw_value_short = ATH11K_HW_RATE_CCK_SP_2M,
          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
        { .bitrate = 55,
          .hw_value = ATH11K_HW_RATE_CCK_LP_5_5M,
          .hw_value_short = ATH11K_HW_RATE_CCK_SP_5_5M,
          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
        { .bitrate = 110,
          .hw_value = ATH11K_HW_RATE_CCK_LP_11M,
          .hw_value_short = ATH11K_HW_RATE_CCK_SP_11M,
          .flags = IEEE80211_RATE_SHORT_PREAMBLE },

        { .bitrate = 60, .hw_value = ATH11K_HW_RATE_OFDM_6M },
        { .bitrate = 90, .hw_value = ATH11K_HW_RATE_OFDM_9M },
        { .bitrate = 120, .hw_value = ATH11K_HW_RATE_OFDM_12M },
        { .bitrate = 180, .hw_value = ATH11K_HW_RATE_OFDM_18M },
        { .bitrate = 240, .hw_value = ATH11K_HW_RATE_OFDM_24M },
        { .bitrate = 360, .hw_value = ATH11K_HW_RATE_OFDM_36M },
        { .bitrate = 480, .hw_value = ATH11K_HW_RATE_OFDM_48M },
        { .bitrate = 540, .hw_value = ATH11K_HW_RATE_OFDM_54M },
};

static const int
ath11k_phymodes[NUM_NL80211_BANDS][ATH11K_CHAN_WIDTH_NUM] = {
        [NL80211_BAND_2GHZ] = {
                        [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20_2G,
                        [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20_2G,
                        [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40_2G,
                        [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80_2G,
                        [NL80211_CHAN_WIDTH_80P80] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_160] = MODE_UNKNOWN,
        },
        [NL80211_BAND_5GHZ] = {
                        [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
                        [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
                        [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
                        [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
                        [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
                        [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
        },
        [NL80211_BAND_6GHZ] = {
                        [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
                        [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11AX_HE20,
                        [NL80211_CHAN_WIDTH_20] = MODE_11AX_HE20,
                        [NL80211_CHAN_WIDTH_40] = MODE_11AX_HE40,
                        [NL80211_CHAN_WIDTH_80] = MODE_11AX_HE80,
                        [NL80211_CHAN_WIDTH_160] = MODE_11AX_HE160,
                        [NL80211_CHAN_WIDTH_80P80] = MODE_11AX_HE80_80,
        },

};

const struct htt_rx_ring_tlv_filter ath11k_mac_mon_status_filter_default = {
        .rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START |
                     HTT_RX_FILTER_TLV_FLAGS_PPDU_END |
                     HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE,
        .pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0,
        .pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1,
        .pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2,
        .pkt_filter_flags3 = HTT_RX_FP_DATA_FILTER_FLASG3 |
                             HTT_RX_FP_CTRL_FILTER_FLASG3
};

#define ATH11K_MAC_FIRST_OFDM_RATE_IDX 4
#define ath11k_g_rates ath11k_legacy_rates
#define ath11k_g_rates_size (ARRAY_SIZE(ath11k_legacy_rates))
#define ath11k_a_rates (ath11k_legacy_rates + 4)
#define ath11k_a_rates_size (ARRAY_SIZE(ath11k_legacy_rates) - 4)

#define ATH11K_MAC_SCAN_TIMEOUT_MSECS 200 /* in msecs */

static const u32 ath11k_smps_map[] = {
        [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
        [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
        [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
        [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
};

static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
                                   struct ieee80211_vif *vif);

enum nl80211_he_ru_alloc ath11k_mac_phy_he_ru_to_nl80211_he_ru_alloc(u16 ru_phy)
{
        enum nl80211_he_ru_alloc ret;

        switch (ru_phy) {
        case RU_26:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
                break;
        case RU_52:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
                break;
        case RU_106:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
                break;
        case RU_242:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
                break;
        case RU_484:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
                break;
        case RU_996:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
                break;
        default:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
                break;
        }

        return ret;
}

enum nl80211_he_ru_alloc ath11k_mac_he_ru_tones_to_nl80211_he_ru_alloc(u16 ru_tones)
{
        enum nl80211_he_ru_alloc ret;

        switch (ru_tones) {
        case 26:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
                break;
        case 52:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_52;
                break;
        case 106:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_106;
                break;
        case 242:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_242;
                break;
        case 484:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_484;
                break;
        case 996:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_996;
                break;
        case (996 * 2):
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_2x996;
                break;
        default:
                ret = NL80211_RATE_INFO_HE_RU_ALLOC_26;
                break;
        }

        return ret;
}

enum nl80211_he_gi ath11k_mac_he_gi_to_nl80211_he_gi(u8 sgi)
{
        enum nl80211_he_gi ret;

        switch (sgi) {
        case RX_MSDU_START_SGI_0_8_US:
                ret = NL80211_RATE_INFO_HE_GI_0_8;
                break;
        case RX_MSDU_START_SGI_1_6_US:
                ret = NL80211_RATE_INFO_HE_GI_1_6;
                break;
        case RX_MSDU_START_SGI_3_2_US:
                ret = NL80211_RATE_INFO_HE_GI_3_2;
                break;
        default:
                ret = NL80211_RATE_INFO_HE_GI_0_8;
                break;
        }

        return ret;
}

u8 ath11k_mac_bw_to_mac80211_bw(u8 bw)
{
        u8 ret = 0;

        switch (bw) {
        case ATH11K_BW_20:
                ret = RATE_INFO_BW_20;
                break;
        case ATH11K_BW_40:
                ret = RATE_INFO_BW_40;
                break;
        case ATH11K_BW_80:
                ret = RATE_INFO_BW_80;
                break;
        case ATH11K_BW_160:
                ret = RATE_INFO_BW_160;
                break;
        }

        return ret;
}

enum ath11k_supported_bw ath11k_mac_mac80211_bw_to_ath11k_bw(enum rate_info_bw bw)
{
        switch (bw) {
        case RATE_INFO_BW_20:
                return ATH11K_BW_20;
        case RATE_INFO_BW_40:
                return ATH11K_BW_40;
        case RATE_INFO_BW_80:
                return ATH11K_BW_80;
        case RATE_INFO_BW_160:
                return ATH11K_BW_160;
        default:
                return ATH11K_BW_20;
        }
}

int ath11k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx,
                                          u16 *rate)
{
        /* As default, it is OFDM rates */
        int i = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
        int max_rates_idx = ath11k_g_rates_size;

        if (preamble == WMI_RATE_PREAMBLE_CCK) {
                hw_rc &= ~ATH11k_HW_RATECODE_CCK_SHORT_PREAM_MASK;
                i = 0;
                max_rates_idx = ATH11K_MAC_FIRST_OFDM_RATE_IDX;
        }

        while (i < max_rates_idx) {
                if (hw_rc == ath11k_legacy_rates[i].hw_value) {
                        *rateidx = i;
                        *rate = ath11k_legacy_rates[i].bitrate;
                        return 0;
                }
                i++;
        }

        return -EINVAL;
}

static int get_num_chains(u32 mask)
{
        int num_chains = 0;

        while (mask) {
                if (mask & BIT(0))
                        num_chains++;
                mask >>= 1;
        }

        return num_chains;
}

u8 ath11k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
                             u32 bitrate)
{
        int i;

        for (i = 0; i < sband->n_bitrates; i++)
                if (sband->bitrates[i].bitrate == bitrate)
                        return i;

        return 0;
}

static u32
ath11k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
{
        int nss;

        for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
                if (ht_mcs_mask[nss])
                        return nss + 1;

        return 1;
}

static u32
ath11k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
{
        int nss;

        for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
                if (vht_mcs_mask[nss])
                        return nss + 1;

        return 1;
}

static u32
ath11k_mac_max_he_nss(const u16 he_mcs_mask[NL80211_HE_NSS_MAX])
{
        int nss;

        for (nss = NL80211_HE_NSS_MAX - 1; nss >= 0; nss--)
                if (he_mcs_mask[nss])
                        return nss + 1;

        return 1;
}

static u8 ath11k_parse_mpdudensity(u8 mpdudensity)
{
/* 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
 *   0 for no restriction
 *   1 for 1/4 us
 *   2 for 1/2 us
 *   3 for 1 us
 *   4 for 2 us
 *   5 for 4 us
 *   6 for 8 us
 *   7 for 16 us
 */
        switch (mpdudensity) {
        case 0:
                return 0;
        case 1:
        case 2:
        case 3:
        /* Our lower layer calculations limit our precision to
         * 1 microsecond
         */
                return 1;
        case 4:
                return 2;
        case 5:
                return 4;
        case 6:
                return 8;
        case 7:
                return 16;
        default:
                return 0;
        }
}

static int ath11k_mac_vif_chan(struct ieee80211_vif *vif,
                               struct cfg80211_chan_def *def)
{
        struct ieee80211_chanctx_conf *conf;

        rcu_read_lock();
        conf = rcu_dereference(vif->chanctx_conf);
        if (!conf) {
                rcu_read_unlock();
                return -ENOENT;
        }

        *def = conf->def;
        rcu_read_unlock();

        return 0;
}

static bool ath11k_mac_bitrate_is_cck(int bitrate)
{
        switch (bitrate) {
        case 10:
        case 20:
        case 55:
        case 110:
                return true;
        }

        return false;
}

u8 ath11k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
                             u8 hw_rate, bool cck)
{
        const struct ieee80211_rate *rate;
        int i;

        for (i = 0; i < sband->n_bitrates; i++) {
                rate = &sband->bitrates[i];

                if (ath11k_mac_bitrate_is_cck(rate->bitrate) != cck)
                        continue;

                if (rate->hw_value == hw_rate)
                        return i;
                else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
                         rate->hw_value_short == hw_rate)
                        return i;
        }

        return 0;
}

static u8 ath11k_mac_bitrate_to_rate(int bitrate)
{
        return DIV_ROUND_UP(bitrate, 5) |
               (ath11k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
}

static void ath11k_get_arvif_iter(void *data, u8 *mac,
                                  struct ieee80211_vif *vif)
{
        struct ath11k_vif_iter *arvif_iter = data;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;

        if (arvif->vdev_id == arvif_iter->vdev_id)
                arvif_iter->arvif = arvif;
}

struct ath11k_vif *ath11k_mac_get_arvif(struct ath11k *ar, u32 vdev_id)
{
        struct ath11k_vif_iter arvif_iter;
        u32 flags;

        memset(&arvif_iter, 0, sizeof(struct ath11k_vif_iter));
        arvif_iter.vdev_id = vdev_id;

        flags = IEEE80211_IFACE_ITER_RESUME_ALL;
        ieee80211_iterate_active_interfaces_atomic(ar->hw,
                                                   flags,
                                                   ath11k_get_arvif_iter,
                                                   &arvif_iter);
        if (!arvif_iter.arvif) {
                ath11k_warn(ar->ab, "No VIF found for vdev %d\n", vdev_id);
                return NULL;
        }

        return arvif_iter.arvif;
}

struct ath11k_vif *ath11k_mac_get_arvif_by_vdev_id(struct ath11k_base *ab,
                                                   u32 vdev_id)
{
        int i;
        struct ath11k_pdev *pdev;
        struct ath11k_vif *arvif;

        for (i = 0; i < ab->num_radios; i++) {
                pdev = rcu_dereference(ab->pdevs_active[i]);
                if (pdev && pdev->ar &&
                    (pdev->ar->allocated_vdev_map & (1LL << vdev_id))) {
                        arvif = ath11k_mac_get_arvif(pdev->ar, vdev_id);
                        if (arvif)
                                return arvif;
                }
        }

        return NULL;
}

struct ath11k *ath11k_mac_get_ar_by_vdev_id(struct ath11k_base *ab, u32 vdev_id)
{
        int i;
        struct ath11k_pdev *pdev;

        for (i = 0; i < ab->num_radios; i++) {
                pdev = rcu_dereference(ab->pdevs_active[i]);
                if (pdev && pdev->ar) {
                        if (pdev->ar->allocated_vdev_map & (1LL << vdev_id))
                                return pdev->ar;
                }
        }

        return NULL;
}

struct ath11k *ath11k_mac_get_ar_by_pdev_id(struct ath11k_base *ab, u32 pdev_id)
{
        int i;
        struct ath11k_pdev *pdev;

        if (ab->hw_params.single_pdev_only) {
                pdev = rcu_dereference(ab->pdevs_active[0]);
                return pdev ? pdev->ar : NULL;
        }

        if (WARN_ON(pdev_id > ab->num_radios))
                return NULL;

        for (i = 0; i < ab->num_radios; i++) {
                pdev = rcu_dereference(ab->pdevs_active[i]);

                if (pdev && pdev->pdev_id == pdev_id)
                        return (pdev->ar ? pdev->ar : NULL);
        }

        return NULL;
}

struct ath11k_vif *ath11k_mac_get_vif_up(struct ath11k_base *ab)
{
        struct ath11k *ar;
        struct ath11k_pdev *pdev;
        struct ath11k_vif *arvif;
        int i;

        for (i = 0; i < ab->num_radios; i++) {
                pdev = &ab->pdevs[i];
                ar = pdev->ar;
                list_for_each_entry(arvif, &ar->arvifs, list) {
                        if (arvif->is_up)
                                return arvif;
                }
        }

        return NULL;
}

static bool ath11k_mac_band_match(enum nl80211_band band1, enum WMI_HOST_WLAN_BAND band2)
{
        return (((band1 == NL80211_BAND_2GHZ) && (band2 & WMI_HOST_WLAN_2G_CAP)) ||
                (((band1 == NL80211_BAND_5GHZ) || (band1 == NL80211_BAND_6GHZ)) &&
                   (band2 & WMI_HOST_WLAN_5G_CAP)));
}

u8 ath11k_mac_get_target_pdev_id_from_vif(struct ath11k_vif *arvif)
{
        struct ath11k *ar = arvif->ar;
        struct ath11k_base *ab = ar->ab;
        struct ieee80211_vif *vif = arvif->vif;
        struct cfg80211_chan_def def;
        enum nl80211_band band;
        u8 pdev_id = ab->target_pdev_ids[0].pdev_id;
        int i;

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return pdev_id;

        band = def.chan->band;

        for (i = 0; i < ab->target_pdev_count; i++) {
                if (ath11k_mac_band_match(band, ab->target_pdev_ids[i].supported_bands))
                        return ab->target_pdev_ids[i].pdev_id;
        }

        return pdev_id;
}

u8 ath11k_mac_get_target_pdev_id(struct ath11k *ar)
{
        struct ath11k_vif *arvif;

        arvif = ath11k_mac_get_vif_up(ar->ab);

        if (arvif)
                return ath11k_mac_get_target_pdev_id_from_vif(arvif);
        else
                return ar->ab->target_pdev_ids[0].pdev_id;
}

static void ath11k_pdev_caps_update(struct ath11k *ar)
{
        struct ath11k_base *ab = ar->ab;

        ar->max_tx_power = ab->target_caps.hw_max_tx_power;

        /* FIXME Set min_tx_power to ab->target_caps.hw_min_tx_power.
         * But since the received value in svcrdy is same as hw_max_tx_power,
         * we can set ar->min_tx_power to 0 currently until
         * this is fixed in firmware
         */
        ar->min_tx_power = 0;

        ar->txpower_limit_2g = ar->max_tx_power;
        ar->txpower_limit_5g = ar->max_tx_power;
        ar->txpower_scale = WMI_HOST_TP_SCALE_MAX;
}

static int ath11k_mac_txpower_recalc(struct ath11k *ar)
{
        struct ath11k_pdev *pdev = ar->pdev;
        struct ath11k_vif *arvif;
        int ret, txpower = -1;
        u32 param;

        lockdep_assert_held(&ar->conf_mutex);

        list_for_each_entry(arvif, &ar->arvifs, list) {
                if (arvif->txpower <= 0)
                        continue;

                if (txpower == -1)
                        txpower = arvif->txpower;
                else
                        txpower = min(txpower, arvif->txpower);
        }

        if (txpower == -1)
                return 0;

        /* txpwr is set as 2 units per dBm in FW*/
        txpower = min_t(u32, max_t(u32, ar->min_tx_power, txpower),
                        ar->max_tx_power) * 2;

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "txpower to set in hw %d\n",
                   txpower / 2);

        if ((pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) &&
            ar->txpower_limit_2g != txpower) {
                param = WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
                ret = ath11k_wmi_pdev_set_param(ar, param,
                                                txpower, ar->pdev->pdev_id);
                if (ret)
                        goto fail;
                ar->txpower_limit_2g = txpower;
        }

        if ((pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) &&
            ar->txpower_limit_5g != txpower) {
                param = WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
                ret = ath11k_wmi_pdev_set_param(ar, param,
                                                txpower, ar->pdev->pdev_id);
                if (ret)
                        goto fail;
                ar->txpower_limit_5g = txpower;
        }

        return 0;

fail:
        ath11k_warn(ar->ab, "failed to recalc txpower limit %d using pdev param %d: %d\n",
                    txpower / 2, param, ret);
        return ret;
}

static int ath11k_recalc_rtscts_prot(struct ath11k_vif *arvif)
{
        struct ath11k *ar = arvif->ar;
        u32 vdev_param, rts_cts = 0;
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        vdev_param = WMI_VDEV_PARAM_ENABLE_RTSCTS;

        /* Enable RTS/CTS protection for sw retries (when legacy stations
         * are in BSS) or by default only for second rate series.
         * TODO: Check if we need to enable CTS 2 Self in any case
         */
        rts_cts = WMI_USE_RTS_CTS;

        if (arvif->num_legacy_stations > 0)
                rts_cts |= WMI_RTSCTS_ACROSS_SW_RETRIES << 4;
        else
                rts_cts |= WMI_RTSCTS_FOR_SECOND_RATESERIES << 4;

        /* Need not send duplicate param value to firmware */
        if (arvif->rtscts_prot_mode == rts_cts)
                return 0;

        arvif->rtscts_prot_mode = rts_cts;

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n",
                   arvif->vdev_id, rts_cts);

        ret =  ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
                                             vdev_param, rts_cts);
        if (ret)
                ath11k_warn(ar->ab, "failed to recalculate rts/cts prot for vdev %d: %d\n",
                            arvif->vdev_id, ret);

        return ret;
}

static int ath11k_mac_set_kickout(struct ath11k_vif *arvif)
{
        struct ath11k *ar = arvif->ar;
        u32 param;
        int ret;

        ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_STA_KICKOUT_TH,
                                        ATH11K_KICKOUT_THRESHOLD,
                                        ar->pdev->pdev_id);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set kickout threshold on vdev %i: %d\n",
                            arvif->vdev_id, ret);
                return ret;
        }

        param = WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS;
        ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
                                            ATH11K_KEEPALIVE_MIN_IDLE);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set keepalive minimum idle time on vdev %i: %d\n",
                            arvif->vdev_id, ret);
                return ret;
        }

        param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS;
        ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
                                            ATH11K_KEEPALIVE_MAX_IDLE);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set keepalive maximum idle time on vdev %i: %d\n",
                            arvif->vdev_id, ret);
                return ret;
        }

        param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS;
        ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
                                            ATH11K_KEEPALIVE_MAX_UNRESPONSIVE);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
                            arvif->vdev_id, ret);
                return ret;
        }

        return 0;
}

void ath11k_mac_peer_cleanup_all(struct ath11k *ar)
{
        struct ath11k_peer *peer, *tmp;
        struct ath11k_base *ab = ar->ab;

        lockdep_assert_held(&ar->conf_mutex);

        spin_lock_bh(&ab->base_lock);
        list_for_each_entry_safe(peer, tmp, &ab->peers, list) {
                ath11k_peer_rx_tid_cleanup(ar, peer);
                list_del(&peer->list);
                kfree(peer);
        }
        spin_unlock_bh(&ab->base_lock);

        ar->num_peers = 0;
        ar->num_stations = 0;
}

static inline int ath11k_mac_vdev_setup_sync(struct ath11k *ar)
{
        lockdep_assert_held(&ar->conf_mutex);

        if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
                return -ESHUTDOWN;

        if (!wait_for_completion_timeout(&ar->vdev_setup_done,
                                         ATH11K_VDEV_SETUP_TIMEOUT_HZ))
                return -ETIMEDOUT;

        return ar->last_wmi_vdev_start_status ? -EINVAL : 0;
}

static void
ath11k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
                                struct ieee80211_chanctx_conf *conf,
                                void *data)
{
        struct cfg80211_chan_def **def = data;

        *def = &conf->def;
}

static int ath11k_mac_monitor_vdev_start(struct ath11k *ar, int vdev_id,
                                         struct cfg80211_chan_def *chandef)
{
        struct ieee80211_channel *channel;
        struct wmi_vdev_start_req_arg arg = {};
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        channel = chandef->chan;

        arg.vdev_id = vdev_id;
        arg.channel.freq = channel->center_freq;
        arg.channel.band_center_freq1 = chandef->center_freq1;
        arg.channel.band_center_freq2 = chandef->center_freq2;

        arg.channel.mode = ath11k_phymodes[chandef->chan->band][chandef->width];
        arg.channel.chan_radar = !!(channel->flags & IEEE80211_CHAN_RADAR);

        arg.channel.min_power = 0;
        arg.channel.max_power = channel->max_power;
        arg.channel.max_reg_power = channel->max_reg_power;
        arg.channel.max_antenna_gain = channel->max_antenna_gain;

        arg.pref_tx_streams = ar->num_tx_chains;
        arg.pref_rx_streams = ar->num_rx_chains;

        arg.channel.passive = !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);

        reinit_completion(&ar->vdev_setup_done);
        reinit_completion(&ar->vdev_delete_done);

        ret = ath11k_wmi_vdev_start(ar, &arg, false);
        if (ret) {
                ath11k_warn(ar->ab, "failed to request monitor vdev %i start: %d\n",
                            vdev_id, ret);
                return ret;
        }

        ret = ath11k_mac_vdev_setup_sync(ar);
        if (ret) {
                ath11k_warn(ar->ab, "failed to synchronize setup for monitor vdev %i start: %d\n",
                            vdev_id, ret);
                return ret;
        }

        ret = ath11k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
        if (ret) {
                ath11k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n",
                            vdev_id, ret);
                goto vdev_stop;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %i started\n",
                   vdev_id);

        return 0;

vdev_stop:
        reinit_completion(&ar->vdev_setup_done);

        ret = ath11k_wmi_vdev_stop(ar, vdev_id);
        if (ret) {
                ath11k_warn(ar->ab, "failed to stop monitor vdev %i after start failure: %d\n",
                            vdev_id, ret);
                return ret;
        }

        ret = ath11k_mac_vdev_setup_sync(ar);
        if (ret) {
                ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i stop: %d\n",
                            vdev_id, ret);
                return ret;
        }

        return -EIO;
}

static int ath11k_mac_monitor_vdev_stop(struct ath11k *ar)
{
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        reinit_completion(&ar->vdev_setup_done);

        ret = ath11k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
        if (ret) {
                ath11k_warn(ar->ab, "failed to request monitor vdev %i stop: %d\n",
                            ar->monitor_vdev_id, ret);
                return ret;
        }

        ret = ath11k_mac_vdev_setup_sync(ar);

        if (ret) {
                ath11k_warn(ar->ab, "failed to synchronize monitor vdev %i stop: %d\n",
                            ar->monitor_vdev_id, ret);
                return ret;
        }

        ret = ath11k_wmi_vdev_down(ar, ar->monitor_vdev_id);
        if (ret) {
                ath11k_warn(ar->ab, "failed to put down monitor vdev %i: %d\n",
                            ar->monitor_vdev_id, ret);
                return ret;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %i stopped\n",
                   ar->monitor_vdev_id);

        return 0;
}

static int ath11k_mac_monitor_vdev_create(struct ath11k *ar)
{
        struct ath11k_pdev *pdev = ar->pdev;
        struct vdev_create_params param = {};
        int bit, ret;
        u8 tmp_addr[6] = {0};
        u16 nss;

        lockdep_assert_held(&ar->conf_mutex);

        if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
                return 0;

        if (ar->ab->free_vdev_map == 0) {
                ath11k_warn(ar->ab, "failed to find free vdev id for monitor vdev\n");
                return -ENOMEM;
        }

        bit = __ffs64(ar->ab->free_vdev_map);

        ar->monitor_vdev_id = bit;

        param.if_id = ar->monitor_vdev_id;
        param.type = WMI_VDEV_TYPE_MONITOR;
        param.subtype = WMI_VDEV_SUBTYPE_NONE;
        param.pdev_id = pdev->pdev_id;

        if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
                param.chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
                param.chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
        }
        if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
                param.chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
                param.chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
        }

        ret = ath11k_wmi_vdev_create(ar, tmp_addr, &param);
        if (ret) {
                ath11k_warn(ar->ab, "failed to request monitor vdev %i creation: %d\n",
                            ar->monitor_vdev_id, ret);
                ar->monitor_vdev_id = -1;
                return ret;
        }

        nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
        ret = ath11k_wmi_vdev_set_param_cmd(ar, ar->monitor_vdev_id,
                                            WMI_VDEV_PARAM_NSS, nss);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
                            ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret);
                goto err_vdev_del;
        }

        ret = ath11k_mac_txpower_recalc(ar);
        if (ret) {
                ath11k_warn(ar->ab, "failed to recalc txpower for monitor vdev %d: %d\n",
                            ar->monitor_vdev_id, ret);
                goto err_vdev_del;
        }

        ar->allocated_vdev_map |= 1LL << ar->monitor_vdev_id;
        ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
        ar->num_created_vdevs++;
        set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %d created\n",
                   ar->monitor_vdev_id);

        return 0;

err_vdev_del:
        ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
        ar->monitor_vdev_id = -1;
        return ret;
}

static int ath11k_mac_monitor_vdev_delete(struct ath11k *ar)
{
        int ret;
        unsigned long time_left;

        lockdep_assert_held(&ar->conf_mutex);

        if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags))
                return 0;

        reinit_completion(&ar->vdev_delete_done);

        ret = ath11k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
        if (ret) {
                ath11k_warn(ar->ab, "failed to request wmi monitor vdev %i removal: %d\n",
                            ar->monitor_vdev_id, ret);
                return ret;
        }

        time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
                                                ATH11K_VDEV_DELETE_TIMEOUT_HZ);
        if (time_left == 0) {
                ath11k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
        } else {
                ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor vdev %d deleted\n",
                           ar->monitor_vdev_id);

                ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id);
                ar->ab->free_vdev_map |= 1LL << (ar->monitor_vdev_id);
                ar->num_created_vdevs--;
                ar->monitor_vdev_id = -1;
                clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
        }

        return ret;
}

static int ath11k_mac_monitor_start(struct ath11k *ar)
{
        struct cfg80211_chan_def *chandef = NULL;
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
                return 0;

        ieee80211_iter_chan_contexts_atomic(ar->hw,
                                            ath11k_mac_get_any_chandef_iter,
                                            &chandef);
        if (!chandef)
                return 0;

        ret = ath11k_mac_monitor_vdev_start(ar, ar->monitor_vdev_id, chandef);
        if (ret) {
                ath11k_warn(ar->ab, "failed to start monitor vdev: %d\n", ret);
                ath11k_mac_monitor_vdev_delete(ar);
                return ret;
        }

        set_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);

        ar->num_started_vdevs++;
        ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, false);
        if (ret) {
                ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during start: %d",
                            ret);
                return ret;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor started\n");

        return 0;
}

static int ath11k_mac_monitor_stop(struct ath11k *ar)
{
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        if (!test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags))
                return 0;

        ret = ath11k_mac_monitor_vdev_stop(ar);
        if (ret) {
                ath11k_warn(ar->ab, "failed to stop monitor vdev: %d\n", ret);
                return ret;
        }

        clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
        ar->num_started_vdevs--;

        ret = ath11k_dp_tx_htt_monitor_mode_ring_config(ar, true);
        if (ret) {
                ath11k_warn(ar->ab, "failed to configure htt monitor mode ring during stop: %d",
                            ret);
                return ret;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac monitor stopped ret %d\n", ret);

        return 0;
}

static int ath11k_mac_vif_setup_ps(struct ath11k_vif *arvif)
{
        struct ath11k *ar = arvif->ar;
        struct ieee80211_vif *vif = arvif->vif;
        struct ieee80211_conf *conf = &ar->hw->conf;
        enum wmi_sta_powersave_param param;
        enum wmi_sta_ps_mode psmode;
        int ret;
        int timeout;
        bool enable_ps;

        lockdep_assert_held(&arvif->ar->conf_mutex);

        if (arvif->vif->type != NL80211_IFTYPE_STATION)
                return 0;

        enable_ps = arvif->ps;

        if (!arvif->is_started) {
                /* mac80211 can update vif powersave state while disconnected.
                 * Firmware doesn't behave nicely and consumes more power than
                 * necessary if PS is disabled on a non-started vdev. Hence
                 * force-enable PS for non-running vdevs.
                 */
                psmode = WMI_STA_PS_MODE_ENABLED;
        } else if (enable_ps) {
                psmode = WMI_STA_PS_MODE_ENABLED;
                param = WMI_STA_PS_PARAM_INACTIVITY_TIME;

                timeout = conf->dynamic_ps_timeout;
                if (timeout == 0) {
                        /* firmware doesn't like 0 */
                        timeout = ieee80211_tu_to_usec(vif->bss_conf.beacon_int) / 1000;
                }

                ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
                                                  timeout);
                if (ret) {
                        ath11k_warn(ar->ab, "failed to set inactivity time for vdev %d: %i\n",
                                    arvif->vdev_id, ret);
                        return ret;
                }
        } else {
                psmode = WMI_STA_PS_MODE_DISABLED;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d psmode %s\n",
                   arvif->vdev_id, psmode ? "enable" : "disable");

        ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, psmode);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set sta power save mode %d for vdev %d: %d\n",
                            psmode, arvif->vdev_id, ret);
                return ret;
        }

        return 0;
}

static int ath11k_mac_config_ps(struct ath11k *ar)
{
        struct ath11k_vif *arvif;
        int ret = 0;

        lockdep_assert_held(&ar->conf_mutex);

        list_for_each_entry(arvif, &ar->arvifs, list) {
                ret = ath11k_mac_vif_setup_ps(arvif);
                if (ret) {
                        ath11k_warn(ar->ab, "failed to setup powersave: %d\n", ret);
                        break;
                }
        }

        return ret;
}

static int ath11k_mac_op_config(struct ieee80211_hw *hw, u32 changed)
{
        struct ath11k *ar = hw->priv;
        struct ieee80211_conf *conf = &hw->conf;
        int ret = 0;

        mutex_lock(&ar->conf_mutex);

        if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
                if (conf->flags & IEEE80211_CONF_MONITOR) {
                        set_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);

                        if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
                                     &ar->monitor_flags))
                                goto out;

                        ret = ath11k_mac_monitor_vdev_create(ar);
                        if (ret) {
                                ath11k_warn(ar->ab, "failed to create monitor vdev: %d",
                                            ret);
                                goto out;
                        }

                        ret = ath11k_mac_monitor_start(ar);
                        if (ret) {
                                ath11k_warn(ar->ab, "failed to start monitor: %d",
                                            ret);
                                goto err_mon_del;
                        }
                } else {
                        clear_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags);

                        if (!test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED,
                                      &ar->monitor_flags))
                                goto out;

                        ret = ath11k_mac_monitor_stop(ar);
                        if (ret) {
                                ath11k_warn(ar->ab, "failed to stop monitor: %d",
                                            ret);
                                goto out;
                        }

                        ret = ath11k_mac_monitor_vdev_delete(ar);
                        if (ret) {
                                ath11k_warn(ar->ab, "failed to delete monitor vdev: %d",
                                            ret);
                                goto out;
                        }
                }
        }

out:
        mutex_unlock(&ar->conf_mutex);
        return ret;

err_mon_del:
        ath11k_mac_monitor_vdev_delete(ar);
        mutex_unlock(&ar->conf_mutex);
        return ret;
}

static int ath11k_mac_setup_bcn_tmpl(struct ath11k_vif *arvif)
{
        struct ath11k *ar = arvif->ar;
        struct ath11k_base *ab = ar->ab;
        struct ieee80211_hw *hw = ar->hw;
        struct ieee80211_vif *vif = arvif->vif;
        struct ieee80211_mutable_offsets offs = {};
        struct sk_buff *bcn;
        struct ieee80211_mgmt *mgmt;
        u8 *ies;
        int ret;

        if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
                return 0;

        bcn = ieee80211_beacon_get_template(hw, vif, &offs);
        if (!bcn) {
                ath11k_warn(ab, "failed to get beacon template from mac80211\n");
                return -EPERM;
        }

        ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
        ies += sizeof(mgmt->u.beacon);

        if (cfg80211_find_ie(WLAN_EID_RSN, ies, (skb_tail_pointer(bcn) - ies)))
                arvif->rsnie_present = true;
        else
                arvif->rsnie_present = false;

        if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
                                    WLAN_OUI_TYPE_MICROSOFT_WPA,
                                    ies, (skb_tail_pointer(bcn) - ies)))
                arvif->wpaie_present = true;
        else
                arvif->wpaie_present = false;

        ret = ath11k_wmi_bcn_tmpl(ar, arvif->vdev_id, &offs, bcn);

        kfree_skb(bcn);

        if (ret)
                ath11k_warn(ab, "failed to submit beacon template command: %d\n",
                            ret);

        return ret;
}

void ath11k_mac_bcn_tx_event(struct ath11k_vif *arvif)
{
        struct ieee80211_vif *vif = arvif->vif;

        if (!vif->color_change_active && !arvif->bcca_zero_sent)
                return;

        if (vif->color_change_active && ieee80211_beacon_cntdwn_is_complete(vif)) {
                arvif->bcca_zero_sent = true;
                ieee80211_color_change_finish(vif);
                return;
        }

        arvif->bcca_zero_sent = false;

        if (vif->color_change_active)
                ieee80211_beacon_update_cntdwn(vif);
        ath11k_mac_setup_bcn_tmpl(arvif);
}

static void ath11k_control_beaconing(struct ath11k_vif *arvif,
                                     struct ieee80211_bss_conf *info)
{
        struct ath11k *ar = arvif->ar;
        int ret = 0;

        lockdep_assert_held(&arvif->ar->conf_mutex);

        if (!info->enable_beacon) {
                ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
                if (ret)
                        ath11k_warn(ar->ab, "failed to down vdev_id %i: %d\n",
                                    arvif->vdev_id, ret);

                arvif->is_up = false;
                return;
        }

        /* Install the beacon template to the FW */
        ret = ath11k_mac_setup_bcn_tmpl(arvif);
        if (ret) {
                ath11k_warn(ar->ab, "failed to update bcn tmpl during vdev up: %d\n",
                            ret);
                return;
        }

        arvif->tx_seq_no = 0x1000;

        arvif->aid = 0;

        ether_addr_copy(arvif->bssid, info->bssid);

        ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
                                 arvif->bssid);
        if (ret) {
                ath11k_warn(ar->ab, "failed to bring up vdev %d: %i\n",
                            arvif->vdev_id, ret);
                return;
        }

        arvif->is_up = true;

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
}

static void ath11k_mac_handle_beacon_iter(void *data, u8 *mac,
                                          struct ieee80211_vif *vif)
{
        struct sk_buff *skb = data;
        struct ieee80211_mgmt *mgmt = (void *)skb->data;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;

        if (vif->type != NL80211_IFTYPE_STATION)
                return;

        if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
                return;

        cancel_delayed_work(&arvif->connection_loss_work);
}

void ath11k_mac_handle_beacon(struct ath11k *ar, struct sk_buff *skb)
{
        ieee80211_iterate_active_interfaces_atomic(ar->hw,
                                                   IEEE80211_IFACE_ITER_NORMAL,
                                                   ath11k_mac_handle_beacon_iter,
                                                   skb);
}

static void ath11k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
                                               struct ieee80211_vif *vif)
{
        u32 *vdev_id = data;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct ath11k *ar = arvif->ar;
        struct ieee80211_hw *hw = ar->hw;

        if (arvif->vdev_id != *vdev_id)
                return;

        if (!arvif->is_up)
                return;

        ieee80211_beacon_loss(vif);

        /* Firmware doesn't report beacon loss events repeatedly. If AP probe
         * (done by mac80211) succeeds but beacons do not resume then it
         * doesn't make sense to continue operation. Queue connection loss work
         * which can be cancelled when beacon is received.
         */
        ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
                                     ATH11K_CONNECTION_LOSS_HZ);
}

void ath11k_mac_handle_beacon_miss(struct ath11k *ar, u32 vdev_id)
{
        ieee80211_iterate_active_interfaces_atomic(ar->hw,
                                                   IEEE80211_IFACE_ITER_NORMAL,
                                                   ath11k_mac_handle_beacon_miss_iter,
                                                   &vdev_id);
}

static void ath11k_mac_vif_sta_connection_loss_work(struct work_struct *work)
{
        struct ath11k_vif *arvif = container_of(work, struct ath11k_vif,
                                                connection_loss_work.work);
        struct ieee80211_vif *vif = arvif->vif;

        if (!arvif->is_up)
                return;

        ieee80211_connection_loss(vif);
}

static void ath11k_peer_assoc_h_basic(struct ath11k *ar,
                                      struct ieee80211_vif *vif,
                                      struct ieee80211_sta *sta,
                                      struct peer_assoc_params *arg)
{
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        u32 aid;

        lockdep_assert_held(&ar->conf_mutex);

        if (vif->type == NL80211_IFTYPE_STATION)
                aid = vif->bss_conf.aid;
        else
                aid = sta->aid;

        ether_addr_copy(arg->peer_mac, sta->addr);
        arg->vdev_id = arvif->vdev_id;
        arg->peer_associd = aid;
        arg->auth_flag = true;
        /* TODO: STA WAR in ath10k for listen interval required? */
        arg->peer_listen_intval = ar->hw->conf.listen_interval;
        arg->peer_nss = 1;
        arg->peer_caps = vif->bss_conf.assoc_capability;
}

static void ath11k_peer_assoc_h_crypto(struct ath11k *ar,
                                       struct ieee80211_vif *vif,
                                       struct ieee80211_sta *sta,
                                       struct peer_assoc_params *arg)
{
        struct ieee80211_bss_conf *info = &vif->bss_conf;
        struct cfg80211_chan_def def;
        struct cfg80211_bss *bss;
        struct ath11k_vif *arvif = (struct ath11k_vif *)vif->drv_priv;
        const u8 *rsnie = NULL;
        const u8 *wpaie = NULL;

        lockdep_assert_held(&ar->conf_mutex);

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
                               IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);

        if (arvif->rsnie_present || arvif->wpaie_present) {
                arg->need_ptk_4_way = true;
                if (arvif->wpaie_present)
                        arg->need_gtk_2_way = true;
        } else if (bss) {
                const struct cfg80211_bss_ies *ies;

                rcu_read_lock();
                rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);

                ies = rcu_dereference(bss->ies);

                wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
                                                WLAN_OUI_TYPE_MICROSOFT_WPA,
                                                ies->data,
                                                ies->len);
                rcu_read_unlock();
                cfg80211_put_bss(ar->hw->wiphy, bss);
        }

        /* FIXME: base on RSN IE/WPA IE is a correct idea? */
        if (rsnie || wpaie) {
                ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
                           "%s: rsn ie found\n", __func__);
                arg->need_ptk_4_way = true;
        }

        if (wpaie) {
                ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
                           "%s: wpa ie found\n", __func__);
                arg->need_gtk_2_way = true;
        }

        if (sta->mfp) {
                /* TODO: Need to check if FW supports PMF? */
                arg->is_pmf_enabled = true;
        }

        /* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */
}

static void ath11k_peer_assoc_h_rates(struct ath11k *ar,
                                      struct ieee80211_vif *vif,
                                      struct ieee80211_sta *sta,
                                      struct peer_assoc_params *arg)
{
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
        struct cfg80211_chan_def def;
        const struct ieee80211_supported_band *sband;
        const struct ieee80211_rate *rates;
        enum nl80211_band band;
        u32 ratemask;
        u8 rate;
        int i;

        lockdep_assert_held(&ar->conf_mutex);

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        band = def.chan->band;
        sband = ar->hw->wiphy->bands[band];
        ratemask = sta->supp_rates[band];
        ratemask &= arvif->bitrate_mask.control[band].legacy;
        rates = sband->bitrates;

        rateset->num_rates = 0;

        for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
                if (!(ratemask & 1))
                        continue;

                rate = ath11k_mac_bitrate_to_rate(rates->bitrate);
                rateset->rates[rateset->num_rates] = rate;
                rateset->num_rates++;
        }
}

static bool
ath11k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
{
        int nss;

        for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
                if (ht_mcs_mask[nss])
                        return false;

        return true;
}

static bool
ath11k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[])
{
        int nss;

        for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
                if (vht_mcs_mask[nss])
                        return false;

        return true;
}

static void ath11k_peer_assoc_h_ht(struct ath11k *ar,
                                   struct ieee80211_vif *vif,
                                   struct ieee80211_sta *sta,
                                   struct peer_assoc_params *arg)
{
        const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct cfg80211_chan_def def;
        enum nl80211_band band;
        const u8 *ht_mcs_mask;
        int i, n;
        u8 max_nss;
        u32 stbc;

        lockdep_assert_held(&ar->conf_mutex);

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        if (!ht_cap->ht_supported)
                return;

        band = def.chan->band;
        ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;

        if (ath11k_peer_assoc_h_ht_masked(ht_mcs_mask))
                return;

        arg->ht_flag = true;

        arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
                                    ht_cap->ampdu_factor)) - 1;

        arg->peer_mpdu_density =
                ath11k_parse_mpdudensity(ht_cap->ampdu_density);

        arg->peer_ht_caps = ht_cap->cap;
        arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG;

        if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
                arg->ldpc_flag = true;

        if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
                arg->bw_40 = true;
                arg->peer_rate_caps |= WMI_HOST_RC_CW40_FLAG;
        }

        /* As firmware handles this two flags (IEEE80211_HT_CAP_SGI_20
         * and IEEE80211_HT_CAP_SGI_40) for enabling SGI, we reset
         * both flags if guard interval is Default GI
         */
        if (arvif->bitrate_mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI)
                arg->peer_ht_caps &= ~(IEEE80211_HT_CAP_SGI_20 |
                                IEEE80211_HT_CAP_SGI_40);

        if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
                if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 |
                    IEEE80211_HT_CAP_SGI_40))
                        arg->peer_rate_caps |= WMI_HOST_RC_SGI_FLAG;
        }

        if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
                arg->peer_rate_caps |= WMI_HOST_RC_TX_STBC_FLAG;
                arg->stbc_flag = true;
        }

        if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
                stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
                stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
                stbc = stbc << WMI_HOST_RC_RX_STBC_FLAG_S;
                arg->peer_rate_caps |= stbc;
                arg->stbc_flag = true;
        }

        if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
                arg->peer_rate_caps |= WMI_HOST_RC_TS_FLAG;
        else if (ht_cap->mcs.rx_mask[1])
                arg->peer_rate_caps |= WMI_HOST_RC_DS_FLAG;

        for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
                if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
                    (ht_mcs_mask[i / 8] & BIT(i % 8))) {
                        max_nss = (i / 8) + 1;
                        arg->peer_ht_rates.rates[n++] = i;
                }

        /* This is a workaround for HT-enabled STAs which break the spec
         * and have no HT capabilities RX mask (no HT RX MCS map).
         *
         * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
         * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
         *
         * Firmware asserts if such situation occurs.
         */
        if (n == 0) {
                arg->peer_ht_rates.num_rates = 8;
                for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
                        arg->peer_ht_rates.rates[i] = i;
        } else {
                arg->peer_ht_rates.num_rates = n;
                arg->peer_nss = min(sta->rx_nss, max_nss);
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
                   arg->peer_mac,
                   arg->peer_ht_rates.num_rates,
                   arg->peer_nss);
}

static int ath11k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
{
        switch ((mcs_map >> (2 * nss)) & 0x3) {
        case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
        case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
        case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
        }
        return 0;
}

static u16
ath11k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
                              const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
{
        int idx_limit;
        int nss;
        u16 mcs_map;
        u16 mcs;

        for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
                mcs_map = ath11k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
                          vht_mcs_limit[nss];

                if (mcs_map)
                        idx_limit = fls(mcs_map) - 1;
                else
                        idx_limit = -1;

                switch (idx_limit) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                        mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
                        break;
                case 8:
                        mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
                        break;
                case 9:
                        mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
                        break;
                default:
                        WARN_ON(1);
                        fallthrough;
                case -1:
                        mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
                        break;
                }

                tx_mcs_set &= ~(0x3 << (nss * 2));
                tx_mcs_set |= mcs << (nss * 2);
        }

        return tx_mcs_set;
}

static u8 ath11k_get_nss_160mhz(struct ath11k *ar,
                                u8 max_nss)
{
        u8 nss_ratio_info = ar->pdev->cap.nss_ratio_info;
        u8 max_sup_nss = 0;

        switch (nss_ratio_info) {
        case WMI_NSS_RATIO_1BY2_NSS:
                max_sup_nss = max_nss >> 1;
                break;
        case WMI_NSS_RATIO_3BY4_NSS:
                ath11k_warn(ar->ab, "WMI_NSS_RATIO_3BY4_NSS not supported\n");
                break;
        case WMI_NSS_RATIO_1_NSS:
                max_sup_nss = max_nss;
                break;
        case WMI_NSS_RATIO_2_NSS:
                ath11k_warn(ar->ab, "WMI_NSS_RATIO_2_NSS not supported\n");
                break;
        default:
                ath11k_warn(ar->ab, "invalid nss ratio received from firmware: %d\n",
                            nss_ratio_info);
                break;
        }

        return max_sup_nss;
}

static void ath11k_peer_assoc_h_vht(struct ath11k *ar,
                                    struct ieee80211_vif *vif,
                                    struct ieee80211_sta *sta,
                                    struct peer_assoc_params *arg)
{
        const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct cfg80211_chan_def def;
        enum nl80211_band band;
        u16 *vht_mcs_mask;
        u8 ampdu_factor;
        u8 max_nss, vht_mcs;
        int i, vht_nss, nss_idx;
        bool user_rate_valid = true;
        u32 rx_nss, tx_nss, nss_160;

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        if (!vht_cap->vht_supported)
                return;

        band = def.chan->band;
        vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;

        if (ath11k_peer_assoc_h_vht_masked(vht_mcs_mask))
                return;

        arg->vht_flag = true;

        /* TODO: similar flags required? */
        arg->vht_capable = true;

        if (def.chan->band == NL80211_BAND_2GHZ)
                arg->vht_ng_flag = true;

        arg->peer_vht_caps = vht_cap->cap;

        ampdu_factor = (vht_cap->cap &
                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
                       IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;

        /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
         * zero in VHT IE. Using it would result in degraded throughput.
         * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
         * it if VHT max_mpdu is smaller.
         */
        arg->peer_max_mpdu = max(arg->peer_max_mpdu,
                                 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
                                        ampdu_factor)) - 1);

        if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
                arg->bw_80 = true;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_160)
                arg->bw_160 = true;

        vht_nss =  ath11k_mac_max_vht_nss(vht_mcs_mask);

        if (vht_nss > sta->rx_nss) {
                user_rate_valid = false;
                for (nss_idx = sta->rx_nss - 1; nss_idx >= 0; nss_idx--) {
                        if (vht_mcs_mask[nss_idx]) {
                                user_rate_valid = true;
                                break;
                        }
                }
        }

        if (!user_rate_valid) {
                ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting vht range mcs value to peer supported nss %d for peer %pM\n",
                           sta->rx_nss, sta->addr);
                vht_mcs_mask[sta->rx_nss - 1] = vht_mcs_mask[vht_nss - 1];
        }

        /* Calculate peer NSS capability from VHT capabilities if STA
         * supports VHT.
         */
        for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) {
                vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
                          (2 * i) & 3;

                if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED &&
                    vht_mcs_mask[i])
                        max_nss = i + 1;
        }
        arg->peer_nss = min(sta->rx_nss, max_nss);
        arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
        arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
        arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
        arg->tx_mcs_set = ath11k_peer_assoc_h_vht_limit(
                __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);

        /* In IPQ8074 platform, VHT mcs rate 10 and 11 is enabled by default.
         * VHT mcs rate 10 and 11 is not suppoerted in 11ac standard.
         * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode.
         */
        arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK;
        arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11;

        if ((arg->tx_mcs_set & IEEE80211_VHT_MCS_NOT_SUPPORTED) ==
                        IEEE80211_VHT_MCS_NOT_SUPPORTED)
                arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;

        /* TODO:  Check */
        arg->tx_max_mcs_nss = 0xFF;

        if (arg->peer_phymode == MODE_11AC_VHT160 ||
            arg->peer_phymode == MODE_11AC_VHT80_80) {
                tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
                rx_nss = min(arg->peer_nss, tx_nss);
                arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;

                if (!rx_nss) {
                        ath11k_warn(ar->ab, "invalid max_nss\n");
                        return;
                }

                if (arg->peer_phymode == MODE_11AC_VHT160)
                        nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
                else
                        nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);

                arg->peer_bw_rxnss_override |= nss_160;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
                   "mac vht peer %pM max_mpdu %d flags 0x%x nss_override 0x%x\n",
                   sta->addr, arg->peer_max_mpdu, arg->peer_flags,
                   arg->peer_bw_rxnss_override);
}

static int ath11k_mac_get_max_he_mcs_map(u16 mcs_map, int nss)
{
        switch ((mcs_map >> (2 * nss)) & 0x3) {

        case IEEE80211_HE_MCS_SUPPORT_0_7: return BIT(8) - 1;
        case IEEE80211_HE_MCS_SUPPORT_0_9: return BIT(10) - 1;
        case IEEE80211_HE_MCS_SUPPORT_0_11: return BIT(12) - 1;
        }
        return 0;
}

static u16 ath11k_peer_assoc_h_he_limit(u16 tx_mcs_set,
                                        const u16 he_mcs_limit[NL80211_HE_NSS_MAX])
{
        int idx_limit;
        int nss;
        u16 mcs_map;
        u16 mcs;

        for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) {
                mcs_map = ath11k_mac_get_max_he_mcs_map(tx_mcs_set, nss) &
                        he_mcs_limit[nss];

                if (mcs_map)
                        idx_limit = fls(mcs_map) - 1;
                else
                        idx_limit = -1;

                switch (idx_limit) {
                case 0 ... 7:
                        mcs = IEEE80211_HE_MCS_SUPPORT_0_7;
                        break;
                case 8:
                case 9:
                        mcs = IEEE80211_HE_MCS_SUPPORT_0_9;
                        break;
                case 10:
                case 11:
                        mcs = IEEE80211_HE_MCS_SUPPORT_0_11;
                        break;
                default:
                        WARN_ON(1);
                        fallthrough;
                case -1:
                        mcs = IEEE80211_HE_MCS_NOT_SUPPORTED;
                        break;
                }

                tx_mcs_set &= ~(0x3 << (nss * 2));
                tx_mcs_set |= mcs << (nss * 2);
        }

        return tx_mcs_set;
}

static bool
ath11k_peer_assoc_h_he_masked(const u16 he_mcs_mask[NL80211_HE_NSS_MAX])
{
        int nss;

        for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++)
                if (he_mcs_mask[nss])
                        return false;

        return true;
}

static void ath11k_peer_assoc_h_he(struct ath11k *ar,
                                   struct ieee80211_vif *vif,
                                   struct ieee80211_sta *sta,
                                   struct peer_assoc_params *arg)
{
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct cfg80211_chan_def def;
        const struct ieee80211_sta_he_cap *he_cap = &sta->he_cap;
        enum nl80211_band band;
        u16 *he_mcs_mask;
        u8 max_nss, he_mcs;
        u16 he_tx_mcs = 0, v = 0;
        int i, he_nss, nss_idx;
        bool user_rate_valid = true;
        u32 rx_nss, tx_nss, nss_160;
        u8 ampdu_factor, rx_mcs_80, rx_mcs_160;
        u16 mcs_160_map, mcs_80_map;
        bool support_160;

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        if (!he_cap->has_he)
                return;

        band = def.chan->band;
        he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;

        if (ath11k_peer_assoc_h_he_masked(he_mcs_mask))
                return;

        arg->he_flag = true;
        support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] &
                  IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G);

        /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */
        mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
        mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);

        if (support_160) {
                for (i = 7; i >= 0; i--) {
                        u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;

                        if (mcs_160 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
                                rx_mcs_160 = i + 1;
                                break;
                        }
                }
        }

        for (i = 7; i >= 0; i--) {
                u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;

                if (mcs_80 != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
                        rx_mcs_80 = i + 1;
                        break;
                }
        }

        if (support_160)
                max_nss = min(rx_mcs_80, rx_mcs_160);
        else
                max_nss = rx_mcs_80;

        arg->peer_nss = min(sta->rx_nss, max_nss);

        memcpy_and_pad(&arg->peer_he_cap_macinfo,
                       sizeof(arg->peer_he_cap_macinfo),
                       he_cap->he_cap_elem.mac_cap_info,
                       sizeof(he_cap->he_cap_elem.mac_cap_info),
                       0);
        memcpy_and_pad(&arg->peer_he_cap_phyinfo,
                       sizeof(arg->peer_he_cap_phyinfo),
                       he_cap->he_cap_elem.phy_cap_info,
                       sizeof(he_cap->he_cap_elem.phy_cap_info),
                       0);
        arg->peer_he_ops = vif->bss_conf.he_oper.params;

        /* the top most byte is used to indicate BSS color info */
        arg->peer_he_ops &= 0xffffff;

        /* As per section 26.6.1 11ax Draft5.0, if the Max AMPDU Exponent Extension
         * in HE cap is zero, use the arg->peer_max_mpdu as calculated while parsing
         * VHT caps(if VHT caps is present) or HT caps (if VHT caps is not present).
         *
         * For non-zero value of Max AMPDU Extponent Extension in HE MAC caps,
         * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
         * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
         * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
         * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
         * length.
         */
        ampdu_factor = u8_get_bits(he_cap->he_cap_elem.mac_cap_info[3],
                                   IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK);

        if (ampdu_factor) {
                if (sta->vht_cap.vht_supported)
                        arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
                                                    ampdu_factor)) - 1;
                else if (sta->ht_cap.ht_supported)
                        arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
                                                    ampdu_factor)) - 1;
        }

        if (he_cap->he_cap_elem.phy_cap_info[6] &
            IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
                int bit = 7;
                int nss, ru;

                arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
                                          IEEE80211_PPE_THRES_NSS_MASK;
                arg->peer_ppet.ru_bit_mask =
                        (he_cap->ppe_thres[0] &
                         IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
                        IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;

                for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
                        for (ru = 0; ru < 4; ru++) {
                                u32 val = 0;
                                int i;

                                if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
                                        continue;
                                for (i = 0; i < 6; i++) {
                                        val >>= 1;
                                        val |= ((he_cap->ppe_thres[bit / 8] >>
                                                 (bit % 8)) & 0x1) << 5;
                                        bit++;
                                }
                                arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
                                                                val << (ru * 6);
                        }
                }
        }

        if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
                arg->twt_responder = true;
        if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
                arg->twt_requester = true;

        he_nss =  ath11k_mac_max_he_nss(he_mcs_mask);

        if (he_nss > sta->rx_nss) {
                user_rate_valid = false;
                for (nss_idx = sta->rx_nss - 1; nss_idx >= 0; nss_idx--) {
                        if (he_mcs_mask[nss_idx]) {
                                user_rate_valid = true;
                                break;
                        }
                }
        }

        if (!user_rate_valid) {
                ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting he range mcs value to peer supported nss %d for peer %pM\n",
                           sta->rx_nss, sta->addr);
                he_mcs_mask[sta->rx_nss - 1] = he_mcs_mask[he_nss - 1];
        }

        switch (sta->bandwidth) {
        case IEEE80211_STA_RX_BW_160:
                if (he_cap->he_cap_elem.phy_cap_info[0] &
                    IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
                        v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
                        v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
                        arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;

                        v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
                        arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;

                        arg->peer_he_mcs_count++;
                        he_tx_mcs = v;
                }
                v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
                arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;

                v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
                v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
                arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;

                arg->peer_he_mcs_count++;
                if (!he_tx_mcs)
                        he_tx_mcs = v;
                fallthrough;

        default:
                v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
                arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;

                v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
                v = ath11k_peer_assoc_h_he_limit(v, he_mcs_mask);
                arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;

                arg->peer_he_mcs_count++;
                if (!he_tx_mcs)
                        he_tx_mcs = v;
                break;
        }

        /* Calculate peer NSS capability from HE capabilities if STA
         * supports HE.
         */
        for (i = 0, max_nss = 0, he_mcs = 0; i < NL80211_HE_NSS_MAX; i++) {
                he_mcs = he_tx_mcs >> (2 * i) & 3;

                /* In case of fixed rates, MCS Range in he_tx_mcs might have
                 * unsupported range, with he_mcs_mask set, so check either of them
                 * to find nss.
                 */
                if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
                    he_mcs_mask[i])
                        max_nss = i + 1;
        }
        arg->peer_nss = min(sta->rx_nss, max_nss);

        if (arg->peer_phymode == MODE_11AX_HE160 ||
            arg->peer_phymode == MODE_11AX_HE80_80) {
                tx_nss = ath11k_get_nss_160mhz(ar, max_nss);
                rx_nss = min(arg->peer_nss, tx_nss);
                arg->peer_bw_rxnss_override = ATH11K_BW_NSS_MAP_ENABLE;

                if (!rx_nss) {
                        ath11k_warn(ar->ab, "invalid max_nss\n");
                        return;
                }

                if (arg->peer_phymode == MODE_11AX_HE160)
                        nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_160MHZ, rx_nss - 1);
                else
                        nss_160 = FIELD_PREP(ATH11K_PEER_RX_NSS_80_80MHZ, rx_nss - 1);

                arg->peer_bw_rxnss_override |= nss_160;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
                   "mac he peer %pM nss %d mcs cnt %d nss_override 0x%x\n",
                   sta->addr, arg->peer_nss,
                   arg->peer_he_mcs_count,
                   arg->peer_bw_rxnss_override);
}

static void ath11k_peer_assoc_h_he_6ghz(struct ath11k *ar,
                                        struct ieee80211_vif *vif,
                                        struct ieee80211_sta *sta,
                                        struct peer_assoc_params *arg)
{
        const struct ieee80211_sta_he_cap *he_cap = &sta->he_cap;
        struct cfg80211_chan_def def;
        enum nl80211_band band;
        u8  ampdu_factor;

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        band = def.chan->band;

        if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->he_6ghz_capa.capa)
                return;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
                arg->bw_80 = true;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_160)
                arg->bw_160 = true;

        arg->peer_he_caps_6ghz = le16_to_cpu(sta->he_6ghz_capa.capa);
        arg->peer_mpdu_density =
                ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
                                                   arg->peer_he_caps_6ghz));

        /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
         * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
         * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
         * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
         * Band Capabilities element in the 6 GHz band.
         *
         * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
         * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
         */
        ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
                                 he_cap->he_cap_elem.mac_cap_info[3]) +
                        FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
                                  arg->peer_he_caps_6ghz);

        arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
                                     ampdu_factor)) - 1;
}

static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
                                     struct peer_assoc_params *arg)
{
        const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
        int smps;

        if (!ht_cap->ht_supported && !sta->he_6ghz_capa.capa)
                return;

        if (ht_cap->ht_supported) {
                smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
                smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
        } else {
                smps = le16_get_bits(sta->he_6ghz_capa.capa,
                                     IEEE80211_HE_6GHZ_CAP_SM_PS);
        }

        switch (smps) {
        case WLAN_HT_CAP_SM_PS_STATIC:
                arg->static_mimops_flag = true;
                break;
        case WLAN_HT_CAP_SM_PS_DYNAMIC:
                arg->dynamic_mimops_flag = true;
                break;
        case WLAN_HT_CAP_SM_PS_DISABLED:
                arg->spatial_mux_flag = true;
                break;
        default:
                break;
        }
}

static void ath11k_peer_assoc_h_qos(struct ath11k *ar,
                                    struct ieee80211_vif *vif,
                                    struct ieee80211_sta *sta,
                                    struct peer_assoc_params *arg)
{
        struct ath11k_vif *arvif = (void *)vif->drv_priv;

        switch (arvif->vdev_type) {
        case WMI_VDEV_TYPE_AP:
                if (sta->wme) {
                        /* TODO: Check WME vs QoS */
                        arg->is_wme_set = true;
                        arg->qos_flag = true;
                }

                if (sta->wme && sta->uapsd_queues) {
                        /* TODO: Check WME vs QoS */
                        arg->is_wme_set = true;
                        arg->apsd_flag = true;
                        arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
                }
                break;
        case WMI_VDEV_TYPE_STA:
                if (sta->wme) {
                        arg->is_wme_set = true;
                        arg->qos_flag = true;
                }
                break;
        default:
                break;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM qos %d\n",
                   sta->addr, arg->qos_flag);
}

static int ath11k_peer_assoc_qos_ap(struct ath11k *ar,
                                    struct ath11k_vif *arvif,
                                    struct ieee80211_sta *sta)
{
        struct ap_ps_params params;
        u32 max_sp;
        u32 uapsd;
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        params.vdev_id = arvif->vdev_id;

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
                   sta->uapsd_queues, sta->max_sp);

        uapsd = 0;
        if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
                uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
                         WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
        if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
                uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
                         WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
        if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
                uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
                         WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
        if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
                uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
                         WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;

        max_sp = 0;
        if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
                max_sp = sta->max_sp;

        params.param = WMI_AP_PS_PEER_PARAM_UAPSD;
        params.value = uapsd;
        ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
        if (ret)
                goto err;

        params.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
        params.value = max_sp;
        ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
        if (ret)
                goto err;

        /* TODO revisit during testing */
        params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
        params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
        ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
        if (ret)
                goto err;

        params.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
        params.value = DISABLE_SIFS_RESPONSE_TRIGGER;
        ret = ath11k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &params);
        if (ret)
                goto err;

        return 0;

err:
        ath11k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
                    params.param, arvif->vdev_id, ret);
        return ret;
}

static bool ath11k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
{
        return sta->supp_rates[NL80211_BAND_2GHZ] >>
               ATH11K_MAC_FIRST_OFDM_RATE_IDX;
}

static enum wmi_phy_mode ath11k_mac_get_phymode_vht(struct ath11k *ar,
                                                    struct ieee80211_sta *sta)
{
        if (sta->bandwidth == IEEE80211_STA_RX_BW_160) {
                switch (sta->vht_cap.cap &
                        IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
                case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
                        return MODE_11AC_VHT160;
                case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
                        return MODE_11AC_VHT80_80;
                default:
                        /* not sure if this is a valid case? */
                        return MODE_11AC_VHT160;
                }
        }

        if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
                return MODE_11AC_VHT80;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
                return MODE_11AC_VHT40;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
                return MODE_11AC_VHT20;

        return MODE_UNKNOWN;
}

static enum wmi_phy_mode ath11k_mac_get_phymode_he(struct ath11k *ar,
                                                   struct ieee80211_sta *sta)
{
        if (sta->bandwidth == IEEE80211_STA_RX_BW_160) {
                if (sta->he_cap.he_cap_elem.phy_cap_info[0] &
                     IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
                        return MODE_11AX_HE160;
                else if (sta->he_cap.he_cap_elem.phy_cap_info[0] &
                     IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
                        return MODE_11AX_HE80_80;
                /* not sure if this is a valid case? */
                return MODE_11AX_HE160;
        }

        if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
                return MODE_11AX_HE80;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
                return MODE_11AX_HE40;

        if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
                return MODE_11AX_HE20;

        return MODE_UNKNOWN;
}

static void ath11k_peer_assoc_h_phymode(struct ath11k *ar,
                                        struct ieee80211_vif *vif,
                                        struct ieee80211_sta *sta,
                                        struct peer_assoc_params *arg)
{
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct cfg80211_chan_def def;
        enum nl80211_band band;
        const u8 *ht_mcs_mask;
        const u16 *vht_mcs_mask;
        const u16 *he_mcs_mask;
        enum wmi_phy_mode phymode = MODE_UNKNOWN;

        if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
                return;

        band = def.chan->band;
        ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
        vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
        he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;

        switch (band) {
        case NL80211_BAND_2GHZ:
                if (sta->he_cap.has_he &&
                    !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
                        if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
                                phymode = MODE_11AX_HE80_2G;
                        else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
                                phymode = MODE_11AX_HE40_2G;
                        else
                                phymode = MODE_11AX_HE20_2G;
                } else if (sta->vht_cap.vht_supported &&
                    !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
                        if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
                                phymode = MODE_11AC_VHT40;
                        else
                                phymode = MODE_11AC_VHT20;
                } else if (sta->ht_cap.ht_supported &&
                           !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
                        if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
                                phymode = MODE_11NG_HT40;
                        else
                                phymode = MODE_11NG_HT20;
                } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
                        phymode = MODE_11G;
                } else {
                        phymode = MODE_11B;
                }
                break;
        case NL80211_BAND_5GHZ:
        case NL80211_BAND_6GHZ:
                /* Check HE first */
                if (sta->he_cap.has_he &&
                    !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
                        phymode = ath11k_mac_get_phymode_he(ar, sta);
                } else if (sta->vht_cap.vht_supported &&
                    !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
                        phymode = ath11k_mac_get_phymode_vht(ar, sta);
                } else if (sta->ht_cap.ht_supported &&
                           !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
                        if (sta->bandwidth >= IEEE80211_STA_RX_BW_40)
                                phymode = MODE_11NA_HT40;
                        else
                                phymode = MODE_11NA_HT20;
                } else {
                        phymode = MODE_11A;
                }
                break;
        default:
                break;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac peer %pM phymode %s\n",
                   sta->addr, ath11k_wmi_phymode_str(phymode));

        arg->peer_phymode = phymode;
        WARN_ON(phymode == MODE_UNKNOWN);
}

static void ath11k_peer_assoc_prepare(struct ath11k *ar,
                                      struct ieee80211_vif *vif,
                                      struct ieee80211_sta *sta,
                                      struct peer_assoc_params *arg,
                                      bool reassoc)
{
        struct ath11k_sta *arsta;

        lockdep_assert_held(&ar->conf_mutex);

        arsta = (struct ath11k_sta *)sta->drv_priv;

        memset(arg, 0, sizeof(*arg));

        reinit_completion(&ar->peer_assoc_done);

        arg->peer_new_assoc = !reassoc;
        ath11k_peer_assoc_h_basic(ar, vif, sta, arg);
        ath11k_peer_assoc_h_crypto(ar, vif, sta, arg);
        ath11k_peer_assoc_h_rates(ar, vif, sta, arg);
        ath11k_peer_assoc_h_phymode(ar, vif, sta, arg);
        ath11k_peer_assoc_h_ht(ar, vif, sta, arg);
        ath11k_peer_assoc_h_vht(ar, vif, sta, arg);
        ath11k_peer_assoc_h_he(ar, vif, sta, arg);
        ath11k_peer_assoc_h_he_6ghz(ar, vif, sta, arg);
        ath11k_peer_assoc_h_qos(ar, vif, sta, arg);
        ath11k_peer_assoc_h_smps(sta, arg);

        arsta->peer_nss = arg->peer_nss;

        /* TODO: amsdu_disable req? */
}

static int ath11k_setup_peer_smps(struct ath11k *ar, struct ath11k_vif *arvif,
                                  const u8 *addr,
                                  const struct ieee80211_sta_ht_cap *ht_cap,
                                  u16 he_6ghz_capa)
{
        int smps;

        if (!ht_cap->ht_supported && !he_6ghz_capa)
                return 0;

        if (ht_cap->ht_supported) {
                smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
                smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
        } else {
                smps = FIELD_GET(IEEE80211_HE_6GHZ_CAP_SM_PS, he_6ghz_capa);
        }

        if (smps >= ARRAY_SIZE(ath11k_smps_map))
                return -EINVAL;

        return ath11k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
                                         WMI_PEER_MIMO_PS_STATE,
                                         ath11k_smps_map[smps]);
}

static void ath11k_bss_assoc(struct ieee80211_hw *hw,
                             struct ieee80211_vif *vif,
                             struct ieee80211_bss_conf *bss_conf)
{
        struct ath11k *ar = hw->priv;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        struct peer_assoc_params peer_arg;
        struct ieee80211_sta *ap_sta;
        struct ath11k_peer *peer;
        bool is_auth = false;
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
                   arvif->vdev_id, arvif->bssid, arvif->aid);

        rcu_read_lock();

        ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
        if (!ap_sta) {
                ath11k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
                            bss_conf->bssid, arvif->vdev_id);
                rcu_read_unlock();
                return;
        }

        ath11k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);

        rcu_read_unlock();

        peer_arg.is_assoc = true;
        ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
        if (ret) {
                ath11k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
                            bss_conf->bssid, arvif->vdev_id, ret);
                return;
        }

        if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
                ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
                            bss_conf->bssid, arvif->vdev_id);
                return;
        }

        ret = ath11k_setup_peer_smps(ar, arvif, bss_conf->bssid,
                                     &ap_sta->ht_cap,
                                     le16_to_cpu(ap_sta->he_6ghz_capa.capa));
        if (ret) {
                ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
                            arvif->vdev_id, ret);
                return;
        }

        WARN_ON(arvif->is_up);

        arvif->aid = bss_conf->aid;
        ether_addr_copy(arvif->bssid, bss_conf->bssid);

        ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
                            arvif->vdev_id, ret);
                return;
        }

        arvif->is_up = true;

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
                   "mac vdev %d up (associated) bssid %pM aid %d\n",
                   arvif->vdev_id, bss_conf->bssid, bss_conf->aid);

        spin_lock_bh(&ar->ab->base_lock);

        peer = ath11k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
        if (peer && peer->is_authorized)
                is_auth = true;

        spin_unlock_bh(&ar->ab->base_lock);

        if (is_auth) {
                ret = ath11k_wmi_set_peer_param(ar, arvif->bssid,
                                                arvif->vdev_id,
                                                WMI_PEER_AUTHORIZE,
                                                1);
                if (ret)
                        ath11k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
        }

        ret = ath11k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
                                           &bss_conf->he_obss_pd);
        if (ret)
                ath11k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
                            arvif->vdev_id, ret);

        ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
                                            WMI_VDEV_PARAM_DTIM_POLICY,
                                            WMI_DTIM_POLICY_STICK);
        if (ret)
                ath11k_warn(ar->ab, "failed to set vdev %d dtim policy: %d\n",
                            arvif->vdev_id, ret);

        ath11k_mac_11d_scan_stop_all(ar->ab);
}

static void ath11k_bss_disassoc(struct ieee80211_hw *hw,
                                struct ieee80211_vif *vif)
{
        struct ath11k *ar = hw->priv;
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
                   arvif->vdev_id, arvif->bssid);

        ret = ath11k_wmi_vdev_down(ar, arvif->vdev_id);
        if (ret)
                ath11k_warn(ar->ab, "failed to down vdev %i: %d\n",
                            arvif->vdev_id, ret);

        arvif->is_up = false;

        cancel_delayed_work_sync(&arvif->connection_loss_work);
}

static u32 ath11k_mac_get_rate_hw_value(int bitrate)
{
        u32 preamble;
        u16 hw_value;
        int rate;
        size_t i;

        if (ath11k_mac_bitrate_is_cck(bitrate))
                preamble = WMI_RATE_PREAMBLE_CCK;
        else
                preamble = WMI_RATE_PREAMBLE_OFDM;

        for (i = 0; i < ARRAY_SIZE(ath11k_legacy_rates); i++) {
                if (ath11k_legacy_rates[i].bitrate != bitrate)
                        continue;

                hw_value = ath11k_legacy_rates[i].hw_value;
                rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);

                return rate;
        }

        return -EINVAL;
}

static void ath11k_recalculate_mgmt_rate(struct ath11k *ar,
                                         struct ieee80211_vif *vif,
                                         struct cfg80211_chan_def *def)
{
        struct ath11k_vif *arvif = (void *)vif->drv_priv;
        const struct ieee80211_supported_band *sband;
        u8 basic_rate_idx;
        int hw_rate_code;
        u32 vdev_param;
        u16 bitrate;
        int ret;

        lockdep_assert_held(&ar->conf_mutex);

        sband = ar->hw->wiphy->bands[def->chan->band];
        basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
        bitrate = sband->bitrates[basic_rate_idx].bitrate;

        hw_rate_code = ath11k_mac_get_rate_hw_value(bitrate);
        if (hw_rate_code < 0) {
                ath11k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
                return;
        }

        vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
        ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
                                            hw_rate_code);
        if (ret)
                ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);

        vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
        ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
                                            hw_rate_code);
        if (ret)
                ath11k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
}

static int ath11k_mac_fils_discovery(struct ath11k_vif *arvif,
                                     struct ieee80211_bss_conf *info)
{
        struct ath11k *ar = arvif->ar;
        struct sk_buff *tmpl;
        int ret;
        u32 interval;
        bool unsol_bcast_probe_resp_enabled = false;

        if (info->fils_discovery.max_interval) {
                interval = info->fils_discovery.max_interval;

                tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
                if (tmpl)
                        ret = ath11k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
                                                             tmpl);
        } else if (info->unsol_bcast_probe_resp_interval) {
                unsol_bcast_probe_resp_enabled = 1;
                interval = info->unsol_bcast_probe_resp_interval;

                tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
                                                                 arvif->vif);
                if (tmpl)
                        ret = ath11k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
                                                         tmpl);
        } else { /* Disable */
                return ath11k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
        }

        if (!tmpl) {
                ath11k_warn(ar->ab,
                            "mac vdev %i failed to retrieve %s template\n",
                            arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
                            "unsolicited broadcast probe response" :
                            "FILS discovery"));
                return -EPERM;
        }
        kfree_skb(tmpl);

        if (!ret)
                ret = ath11k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
                                                unsol_bcast_probe_resp_enabled);

        return ret;
}

static int ath11k_mac_config_obss_pd(struct ath11k *ar,
                                     struct ieee80211_he_obss_pd *he_obss_pd)
{
        u32 bitmap[2], param_id, param_val, pdev_id;
        int ret;
        s8 non_srg_th = 0, srg_th = 0;

        pdev_id = ar->pdev->pdev_id;

        /* Set and enable SRG/non-SRG OBSS PD Threshold */
        param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD;
        if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
                ret = ath11k_wmi_pdev_set_param(ar, param_id, 0, pdev_id);
                if (ret)
                        ath11k_warn(ar->ab,
                                    "failed to set obss_pd_threshold for pdev: %u\n",
                                    pdev_id);
                return ret;
        }

        ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
                   "mac obss pd sr_ctrl %x non_srg_thres %u srg_max %u\n",
                   he_obss_pd->sr_ctrl, he_obss_pd->non_srg_max_offset,
                   he_obss_pd->max_offset);

        param_val = 0;

        if (he_obss_pd->sr_ctrl &
            IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED) {
                non_srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD;
        } else {
                if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
                        non_srg_th = (ATH11K_OBSS_PD_MAX_THRESHOLD +
                                      he_obss_pd->non_srg_max_offset);
                else
                        non_srg_th = ATH11K_OBSS_PD_NON_SRG_MAX_THRESHOLD;

                param_val |= ATH11K_OBSS_PD_NON_SRG_EN;
        }

        if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) {
                srg_th = ATH11K_OBSS_PD_MAX_THRESHOLD + he_obss_pd->max_offset;
                param_val |= ATH11K_OBSS_PD_SRG_EN;
        }

        if (test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT,
                     ar->ab->wmi_ab.svc_map)) {
                param_val |= ATH11K_OBSS_PD_THRESHOLD_IN_DBM;
                param_val |= FIELD_PREP(GENMASK(15, 8), srg_th);
        } else {
                non_srg_th -= ATH11K_DEFAULT_NOISE_FLOOR;
                /* SRG not supported and threshold in dB */
                param_val &= ~(ATH11K_OBSS_PD_SRG_EN |
                               ATH11K_OBSS_PD_THRESHOLD_IN_DBM);
        }

        param_val |= (non_srg_th & GENMASK(7, 0));
        ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
        if (ret) {
                ath11k_warn(ar->ab,
                            "failed to set obss_pd_threshold for pdev: %u\n",
                            pdev_id);
                return ret;
        }

        /* Enable OBSS PD for all access category */
        param_id  = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC;
        param_val = 0xf;
        ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
        if (ret) {
                ath11k_warn(ar->ab,
                            "failed to set obss_pd_per_ac for pdev: %u\n",
                            pdev_id);
                return ret;
        }

        /* Set SR Prohibit */
        param_id  = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT;
        param_val = !!(he_obss_pd->sr_ctrl &
                       IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED);
        ret = ath11k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id);
        if (ret) {
                ath11k_warn(ar->ab, "failed to set sr_prohibit for pdev: %u\n",