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