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