cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

mac.c (246822B)


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