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