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