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