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