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