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