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