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