projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath11k: fix missing unlock on error in ath11k_wow_op_resume()
[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();
508 conf = rcu_dereference(vif->chanctx_conf);
509 if (!conf) {
510 rcu_read_unlock();
511 return -ENOENT;
512 }
513
514 *def = conf->def;
515 rcu_read_unlock();
516
517 return 0;
518}
519
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
1401 if (!vif->color_change_active && !arvif->bcca_zero_sent)
1402 return;
1403
1404 if (vif->color_change_active && ieee80211_beacon_cntdwn_is_complete(vif)) {
1405 arvif->bcca_zero_sent = true;
1406 ieee80211_color_change_finish(vif);
1407 return;
1408 }
1409
1410 arvif->bcca_zero_sent = false;
1411
1412 if (vif->color_change_active)
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)
1542 aid = vif->bss_conf.aid;
1543 else
1544 aid = sta->aid;
1545
1546 ether_addr_copy(arg->peer_mac, sta->addr);
1547 arg->vdev_id = arvif->vdev_id;
1548 arg->peer_associd = aid;
1549 arg->auth_flag = true;
1550 /* TODO: STA WAR in ath10k for listen interval required? */
1551 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1552 arg->peer_nss = 1;
1553 arg->peer_caps = vif->bss_conf.assoc_capability;
1554}
1555
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];
1639 ratemask = sta->supp_rates[band];
1640 ratemask &= arvif->bitrate_mask.control[band].legacy;
1641 rates = sband->bitrates;
1642
1643 rateset->num_rates = 0;
1644
1645 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1646 if (!(ratemask & 1))
1647 continue;
1648
1649 rate = ath11k_mac_bitrate_to_rate(rates->bitrate);
1650 rateset->rates[rateset->num_rates] = rate;
1651 rateset->num_rates++;
1652 }
1653}
1654
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{
1684 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1685 struct ath11k_vif *arvif = (void *)vif->drv_priv;
1686 struct cfg80211_chan_def def;
1687 enum nl80211_band band;
1688 const u8 *ht_mcs_mask;
1689 int i, n;
1690 u8 max_nss;
1691 u32 stbc;
1692
1693 lockdep_assert_held(&ar->conf_mutex);
1694
1695 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
1696 return;
1697
1698 if (!ht_cap->ht_supported)
1699 return;
1700
1701 band = def.chan->band;
1702 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
1703
1704 if (ath11k_peer_assoc_h_ht_masked(ht_mcs_mask))
1705 return;
1706
1707 arg->ht_flag = true;
1708
1709 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1710 ht_cap->ampdu_factor)) - 1;
1711
1712 arg->peer_mpdu_density =
1713 ath11k_parse_mpdudensity(ht_cap->ampdu_density);
1714
1715 arg->peer_ht_caps = ht_cap->cap;
1716 arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG;
1717
1718 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1719 arg->ldpc_flag = true;
1720
1721 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
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;
1779 arg->peer_nss = min(sta->rx_nss, max_nss);
1780 }
1781
1782 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1783 arg->peer_mac,
1784 arg->peer_ht_rates.num_rates,
1785 arg->peer_nss);
1786}
1787
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{
1881 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
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
1927 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1928 arg->bw_80 = true;
1929
1930 if (sta->bandwidth == IEEE80211_STA_RX_BW_160)
1931 arg->bw_160 = true;
1932
61fe43e7
MH		 1933 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
1934
1935 if (vht_nss > sta->rx_nss) {
1936 user_rate_valid = false;
1937 for (nss_idx = sta->rx_nss - 1; nss_idx >= 0; nss_idx--) {
1938 if (vht_mcs_mask[nss_idx]) {
1939 user_rate_valid = true;
1940 break;
1941 }
1942 }
1943 }
1944
1945 if (!user_rate_valid) {
1946 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting vht range mcs value to peer supported nss %d for peer %pM\n",
1947 sta->rx_nss, sta->addr);
1948 vht_mcs_mask[sta->rx_nss - 1] = vht_mcs_mask[vht_nss - 1];
1949 }
1950
d5c65159
KV		 1951 /* Calculate peer NSS capability from VHT capabilities if STA
1952 * supports VHT.
1953 */
1954 for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) {
1955 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
1956 (2 * i) & 3;
1957
1958 if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED &&
1959 vht_mcs_mask[i])
1960 max_nss = i + 1;
1961 }
1962 arg->peer_nss = min(sta->rx_nss, max_nss);
1963 arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1964 arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1965 arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1966 arg->tx_mcs_set = ath11k_peer_assoc_h_vht_limit(
1967 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
1968
1969 /* In IPQ8074 platform, VHT mcs rate 10 and 11 is enabled by default.
1970 * VHT mcs rate 10 and 11 is not suppoerted in 11ac standard.
1971 * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode.
1972 */
1973 arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK;
1974 arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11;
1975
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;
9f056ed8 2081 const struct ieee80211_sta_he_cap *he_cap = &sta->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
2138 arg->peer_nss = min(sta->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) {
2170 if (sta->vht_cap.vht_supported)
2171 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
2172 ampdu_factor)) - 1;
2173 else if (sta->ht_cap.ht_supported)
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
2216 if (he_nss > sta->rx_nss) {
2217 user_rate_valid = false;
2218 for (nss_idx = sta->rx_nss - 1; nss_idx >= 0; nss_idx--) {
2219 if (he_mcs_mask[nss_idx]) {
2220 user_rate_valid = true;
2221 break;
2222 }
2223 }
2224 }
2225
2226 if (!user_rate_valid) {
2227 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac setting he range mcs value to peer supported nss %d for peer %pM\n",
2228 sta->rx_nss, sta->addr);
2229 he_mcs_mask[sta->rx_nss - 1] = he_mcs_mask[he_nss - 1];
2230 }
2231
9f056ed8
JC		 2232 switch (sta->bandwidth) {
2233 case IEEE80211_STA_RX_BW_160:
2234 if (he_cap->he_cap_elem.phy_cap_info[0] &
2235 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2236 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
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 */
2275 for (i = 0, max_nss = 0, he_mcs = 0; i < NL80211_HE_NSS_MAX; i++) {
2276 he_mcs = he_tx_mcs >> (2 * i) & 3;
2277
2278 /* In case of fixed rates, MCS Range in he_tx_mcs might have
2279 * unsupported range, with he_mcs_mask set, so check either of them
2280 * to find nss.
2281 */
2282 if (he_mcs != IEEE80211_HE_MCS_NOT_SUPPORTED ||
2283 he_mcs_mask[i])
2284 max_nss = i + 1;
2285 }
2286 arg->peer_nss = min(sta->rx_nss, max_nss);
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{
2319 const struct ieee80211_sta_he_cap *he_cap = &sta->he_cap;
2320 struct cfg80211_chan_def def;
2321 enum nl80211_band band;
2322 u8 ampdu_factor;
2323
2324 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
2325 return;
2326
2327 band = def.chan->band;
2328
2329 if (!arg->he_flag || band != NL80211_BAND_6GHZ || !sta->he_6ghz_capa.capa)
2330 return;
2331
1cb74719
WG		 2332 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2333 arg->bw_40 = true;
2334
c3a7d7eb
PKC		 2335 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2336 arg->bw_80 = true;
2337
2338 if (sta->bandwidth == IEEE80211_STA_RX_BW_160)
2339 arg->bw_160 = true;
2340
2341 arg->peer_he_caps_6ghz = le16_to_cpu(sta->he_6ghz_capa.capa);
2342 arg->peer_mpdu_density =
2343 ath11k_parse_mpdudensity(FIELD_GET(IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START,
2344 arg->peer_he_caps_6ghz));
2345
2346 /* From IEEE Std 802.11ax-2021 - Section 10.12.2: An HE STA shall be capable of
2347 * receiving A-MPDU where the A-MPDU pre-EOF padding length is up to the value
2348 * indicated by the Maximum A-MPDU Length Exponent Extension field in the HE
2349 * Capabilities element and the Maximum A-MPDU Length Exponent field in HE 6 GHz
2350 * Band Capabilities element in the 6 GHz band.
2351 *
2352 * Here, we are extracting the Max A-MPDU Exponent Extension from HE caps and
2353 * factor is the Maximum A-MPDU Length Exponent from HE 6 GHZ Band capability.
2354 */
2355 ampdu_factor = FIELD_GET(IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK,
2356 he_cap->he_cap_elem.mac_cap_info[3]) +
2357 FIELD_GET(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP,
2358 arg->peer_he_caps_6ghz);
2359
2360 arg->peer_max_mpdu = (1u << (IEEE80211_HE_6GHZ_MAX_AMPDU_FACTOR +
2361 ampdu_factor)) - 1;
2362}
2363
d5c65159
KV		 2364static void ath11k_peer_assoc_h_smps(struct ieee80211_sta *sta,
2365 struct peer_assoc_params *arg)
2366{
2367 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2368 int smps;
2369
6f4d7030 2370 if (!ht_cap->ht_supported && !sta->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 {
16bdce2a
KV		 2377 smps = le16_get_bits(sta->he_6ghz_capa.capa,
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{
2501 return sta->supp_rates[NL80211_BAND_2GHZ] >>
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{
2508 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) {
2509 switch (sta->vht_cap.cap &
2510 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2511 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2512 return MODE_11AC_VHT160;
2513 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2514 return MODE_11AC_VHT80_80;
2515 default:
2516 /* not sure if this is a valid case? */
2517 return MODE_11AC_VHT160;
2518 }
2519 }
2520
2521 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2522 return MODE_11AC_VHT80;
2523
2524 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2525 return MODE_11AC_VHT40;
2526
2527 if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
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{
2536 if (sta->bandwidth == IEEE80211_STA_RX_BW_160) {
2537 if (sta->he_cap.he_cap_elem.phy_cap_info[0] &
2538 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
2539 return MODE_11AX_HE160;
2540 else if (sta->he_cap.he_cap_elem.phy_cap_info[0] &
2541 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
2542 return MODE_11AX_HE80_80;
2543 /* not sure if this is a valid case? */
2544 return MODE_11AX_HE160;
2545 }
2546
2547 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2548 return MODE_11AX_HE80;
2549
2550 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2551 return MODE_11AX_HE40;
2552
2553 if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
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:
61fe43e7
MH		 2582 if (sta->he_cap.has_he &&
2583 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
9f056ed8
JC		 2584 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2585 phymode = MODE_11AX_HE80_2G;
2586 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2587 phymode = MODE_11AX_HE40_2G;
2588 else
2589 phymode = MODE_11AX_HE20_2G;
2590 } else if (sta->vht_cap.vht_supported &&
d5c65159
KV		 2591 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2592 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2593 phymode = MODE_11AC_VHT40;
2594 else
2595 phymode = MODE_11AC_VHT20;
2596 } else if (sta->ht_cap.ht_supported &&
2597 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2598 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2599 phymode = MODE_11NG_HT40;
2600 else
2601 phymode = MODE_11NG_HT20;
2602 } else if (ath11k_mac_sta_has_ofdm_only(sta)) {
2603 phymode = MODE_11G;
2604 } else {
2605 phymode = MODE_11B;
2606 }
d5c65159
KV		 2607 break;
2608 case NL80211_BAND_5GHZ:
22eeadcd 2609 case NL80211_BAND_6GHZ:
9f056ed8 2610 /* Check HE first */
61fe43e7
MH		 2611 if (sta->he_cap.has_he &&
2612 !ath11k_peer_assoc_h_he_masked(he_mcs_mask)) {
9f056ed8
JC		 2613 phymode = ath11k_mac_get_phymode_he(ar, sta);
2614 } else if (sta->vht_cap.vht_supported &&
d5c65159
KV		 2615 !ath11k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2616 phymode = ath11k_mac_get_phymode_vht(ar, sta);
2617 } else if (sta->ht_cap.ht_supported &&
2618 !ath11k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2619 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40)
2620 phymode = MODE_11NA_HT40;
2621 else
2622 phymode = MODE_11NA_HT20;
2623 } else {
2624 phymode = MODE_11A;
2625 }
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,
6f4d7030
PKC		 2742 &ap_sta->ht_cap,
2743 le16_to_cpu(ap_sta->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
2752 arvif->aid = bss_conf->aid;
2753 ether_addr_copy(arvif->bssid, bss_conf->bssid);
2754
2755 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2756 if (ret) {
2757 ath11k_warn(ar->ab, "failed to set vdev %d up: %d\n",
2758 arvif->vdev_id, ret);
2759 return;
2760 }
2761
2762 arvif->is_up = true;
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",
2767 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
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;
d5c65159
KV		 3153 }
3154
3155 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
3156 arvif->dtim_period = info->dtim_period;
3157
3158 param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
3159 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3160 param_id,
3161 arvif->dtim_period);
3162
3163 if (ret)
3164 ath11k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
3165 arvif->vdev_id, ret);
3166 else
3167 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3168 "DTIM period: %d set for VDEV: %d\n",
3169 arvif->dtim_period, arvif->vdev_id);
3170 }
3171
3172 if (changed & BSS_CHANGED_SSID &&
3173 vif->type == NL80211_IFTYPE_AP) {
3174 arvif->u.ap.ssid_len = info->ssid_len;
3175 if (info->ssid_len)
3176 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3177 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3178 }
3179
3180 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3181 ether_addr_copy(arvif->bssid, info->bssid);
3182
bd888150 3183 if (changed & BSS_CHANGED_BEACON_ENABLED) {
d5c65159
KV		 3184 ath11k_control_beaconing(arvif, info);
3185
bd888150
PKC		 3186 if (arvif->is_up && vif->bss_conf.he_support &&
3187 vif->bss_conf.he_oper.params) {
743b9065
PKC		 3188 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3189 WMI_VDEV_PARAM_BA_MODE,
3190 WMI_BA_MODE_BUFFER_SIZE_256);
3191 if (ret)
3192 ath11k_warn(ar->ab,
3193 "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
3194 arvif->vdev_id);
3195
bd888150
PKC		 3196 param_id = WMI_VDEV_PARAM_HEOPS_0_31;
3197 param_value = vif->bss_conf.he_oper.params;
3198 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3199 param_id, param_value);
3200 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3201 "he oper param: %x set for VDEV: %d\n",
3202 param_value, arvif->vdev_id);
3203
3204 if (ret)
3205 ath11k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
3206 param_value, arvif->vdev_id, ret);
3207 }
3208 }
3209
d5c65159
KV		 3210 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3211 u32 cts_prot;
3212
3213 cts_prot = !!(info->use_cts_prot);
3214 param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
3215
3216 if (arvif->is_started) {
3217 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3218 param_id, cts_prot);
3219 if (ret)
3220 ath11k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
3221 arvif->vdev_id);
3222 else
3223 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
3224 cts_prot, arvif->vdev_id);
3225 } else {
3226 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
3227 }
3228 }
3229
3230 if (changed & BSS_CHANGED_ERP_SLOT) {
3231 u32 slottime;
3232
3233 if (info->use_short_slot)
3234 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3235
3236 else
3237 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3238
3239 param_id = WMI_VDEV_PARAM_SLOT_TIME;
3240 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3241 param_id, slottime);
3242 if (ret)
3243 ath11k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
3244 arvif->vdev_id);
3245 else
3246 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3247 "Set slottime: %d for VDEV: %d\n",
3248 slottime, arvif->vdev_id);
3249 }
3250
3251 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3252 u32 preamble;
3253
3254 if (info->use_short_preamble)
3255 preamble = WMI_VDEV_PREAMBLE_SHORT;
3256 else
3257 preamble = WMI_VDEV_PREAMBLE_LONG;
3258
3259 param_id = WMI_VDEV_PARAM_PREAMBLE;
3260 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3261 param_id, preamble);
3262 if (ret)
3263 ath11k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
3264 arvif->vdev_id);
3265 else
3266 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3267 "Set preamble: %d for VDEV: %d\n",
3268 preamble, arvif->vdev_id);
3269 }
3270
3271 if (changed & BSS_CHANGED_ASSOC) {
3272 if (info->assoc)
3273 ath11k_bss_assoc(hw, vif, info);
3274 else
3275 ath11k_bss_disassoc(hw, vif);
3276 }
3277
3278 if (changed & BSS_CHANGED_TXPOWER) {
3279 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3280 arvif->vdev_id, info->txpower);
3281
3282 arvif->txpower = info->txpower;
3283 ath11k_mac_txpower_recalc(ar);
3284 }
3285
b2beffa7
CH		 3286 if (changed & BSS_CHANGED_PS &&
3287 ar->ab->hw_params.supports_sta_ps) {
3288 arvif->ps = vif->bss_conf.ps;
3289
3290 ret = ath11k_mac_config_ps(ar);
3291 if (ret)
3292 ath11k_warn(ar->ab, "failed to setup ps on vdev %i: %d\n",
3293 arvif->vdev_id, ret);
3294 }
3295
d5c65159
KV		 3296 if (changed & BSS_CHANGED_MCAST_RATE &&
3297 !ath11k_mac_vif_chan(arvif->vif, &def)) {
3298 band = def.chan->band;
3299 mcast_rate = vif->bss_conf.mcast_rate[band];
3300
3301 if (mcast_rate > 0)
3302 rateidx = mcast_rate - 1;
3303 else
3304 rateidx = ffs(vif->bss_conf.basic_rates) - 1;
3305
3306 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
3307 rateidx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
3308
3309 bitrate = ath11k_legacy_rates[rateidx].bitrate;
3310 hw_value = ath11k_legacy_rates[rateidx].hw_value;
3311
3312 if (ath11k_mac_bitrate_is_cck(bitrate))
3313 preamble = WMI_RATE_PREAMBLE_CCK;
3314 else
3315 preamble = WMI_RATE_PREAMBLE_OFDM;
3316
3317 rate = ATH11K_HW_RATE_CODE(hw_value, 0, preamble);
3318
3319 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3320 "mac vdev %d mcast_rate %x\n",
3321 arvif->vdev_id, rate);
3322
3323 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
3324 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3325 vdev_param, rate);
3326 if (ret)
3327 ath11k_warn(ar->ab,
3328 "failed to set mcast rate on vdev %i: %d\n",
3329 arvif->vdev_id, ret);
3330
3331 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
3332 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3333 vdev_param, rate);
3334 if (ret)
3335 ath11k_warn(ar->ab,
3336 "failed to set bcast rate on vdev %i: %d\n",
3337 arvif->vdev_id, ret);
3338 }
3339
3340 if (changed & BSS_CHANGED_BASIC_RATES &&
3341 !ath11k_mac_vif_chan(arvif->vif, &def))
3342 ath11k_recalculate_mgmt_rate(ar, vif, &def);
3343
6d293d44
JC		 3344 if (changed & BSS_CHANGED_TWT) {
3345 if (info->twt_requester || info->twt_responder)
485add35 3346 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id);
6d293d44 3347 else
485add35 3348 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
6d293d44
JC		 3349 }
3350
3f8be640 3351 if (changed & BSS_CHANGED_HE_OBSS_PD)
b56b08ae 3352 ath11k_mac_config_obss_pd(ar, &info->he_obss_pd);
3f8be640 3353
beb2f772
JC		 3354 if (changed & BSS_CHANGED_HE_BSS_COLOR) {
3355 if (vif->type == NL80211_IFTYPE_AP) {
3356 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3357 ar, arvif->vdev_id, info->he_bss_color.color,
3358 ATH11K_BSS_COLOR_COLLISION_DETECTION_AP_PERIOD_MS,
75e6b594 3359 info->he_bss_color.enabled);
beb2f772
JC		 3360 if (ret)
3361 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3362 arvif->vdev_id, ret);
886433a9
JC		 3363
3364 param_id = WMI_VDEV_PARAM_BSS_COLOR;
3365 if (info->he_bss_color.enabled)
3366 param_value = info->he_bss_color.color <<
3367 IEEE80211_HE_OPERATION_BSS_COLOR_OFFSET;
3368 else
3369 param_value = IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED;
3370
3371 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
3372 param_id,
3373 param_value);
3374 if (ret)
3375 ath11k_warn(ar->ab,
3376 "failed to set bss color param on vdev %i: %d\n",
3377 arvif->vdev_id, ret);
3378
3379 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
3380 "bss color param 0x%x set on vdev %i\n",
3381 param_value, arvif->vdev_id);
beb2f772
JC		 3382 } else if (vif->type == NL80211_IFTYPE_STATION) {
3383 ret = ath11k_wmi_send_bss_color_change_enable_cmd(ar,
3384 arvif->vdev_id,
3385 1);
3386 if (ret)
3387 ath11k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
3388 arvif->vdev_id, ret);
3389 ret = ath11k_wmi_send_obss_color_collision_cfg_cmd(
3390 ar, arvif->vdev_id, 0,
3391 ATH11K_BSS_COLOR_COLLISION_DETECTION_STA_PERIOD_MS, 1);
3392 if (ret)
3393 ath11k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
3394 arvif->vdev_id, ret);
3395 }
3396 }
3397
047679e3
AD		 3398 if (changed & BSS_CHANGED_FILS_DISCOVERY ||
3399 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
3400 ath11k_mac_fils_discovery(arvif, info);
3401
c3c36bfe
CH		 3402 if (changed & BSS_CHANGED_ARP_FILTER) {
3403 ipv4_cnt = min(info->arp_addr_cnt, ATH11K_IPV4_MAX_COUNT);
3404 memcpy(arvif->arp_ns_offload.ipv4_addr, info->arp_addr_list,
3405 ipv4_cnt * sizeof(u32));
3406 memcpy(arvif->arp_ns_offload.mac_addr, vif->addr, ETH_ALEN);
3407 arvif->arp_ns_offload.ipv4_count = ipv4_cnt;
3408
3409 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac arp_addr_cnt %d vif->addr %pM, offload_addr %pI4\n",
3410 info->arp_addr_cnt,
3411 vif->addr, arvif->arp_ns_offload.ipv4_addr);
3412 }
3413
d5c65159
KV		 3414 mutex_unlock(&ar->conf_mutex);
3415}
3416
3417void __ath11k_mac_scan_finish(struct ath11k *ar)
3418{
3419 lockdep_assert_held(&ar->data_lock);
3420
3421 switch (ar->scan.state) {
3422 case ATH11K_SCAN_IDLE:
3423 break;
3424 case ATH11K_SCAN_RUNNING:
3425 case ATH11K_SCAN_ABORTING:
62db14ea
WG		 3426 if (ar->scan.is_roc && ar->scan.roc_notify)
3427 ieee80211_remain_on_channel_expired(ar->hw);
3428 fallthrough;
3429 case ATH11K_SCAN_STARTING:
d5c65159
KV		 3430 if (!ar->scan.is_roc) {
3431 struct cfg80211_scan_info info = {
62db14ea
WG		 3432 .aborted = ((ar->scan.state ==
3433 ATH11K_SCAN_ABORTING) ||
3434 (ar->scan.state ==
3435 ATH11K_SCAN_STARTING)),
d5c65159
KV		 3436 };
3437
3438 ieee80211_scan_completed(ar->hw, &info);
d5c65159 3439 }
62db14ea 3440
d5c65159
KV		 3441 ar->scan.state = ATH11K_SCAN_IDLE;
3442 ar->scan_channel = NULL;
3443 ar->scan.roc_freq = 0;
3444 cancel_delayed_work(&ar->scan.timeout);
3445 complete(&ar->scan.completed);
3446 break;
3447 }
3448}
3449
3450void ath11k_mac_scan_finish(struct ath11k *ar)
3451{
3452 spin_lock_bh(&ar->data_lock);
3453 __ath11k_mac_scan_finish(ar);
3454 spin_unlock_bh(&ar->data_lock);
3455}
3456
3457static int ath11k_scan_stop(struct ath11k *ar)
3458{
3459 struct scan_cancel_param arg = {
3460 .req_type = WLAN_SCAN_CANCEL_SINGLE,
3461 .scan_id = ATH11K_SCAN_ID,
3462 };
3463 int ret;
3464
3465 lockdep_assert_held(&ar->conf_mutex);
3466
3467 /* TODO: Fill other STOP Params */
3468 arg.pdev_id = ar->pdev->pdev_id;
3469
3470 ret = ath11k_wmi_send_scan_stop_cmd(ar, &arg);
3471 if (ret) {
3472 ath11k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
3473 goto out;
3474 }
3475
3476 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
3477 if (ret == 0) {
3478 ath11k_warn(ar->ab,
3479 "failed to receive scan abort comple: timed out\n");
3480 ret = -ETIMEDOUT;
3481 } else if (ret > 0) {
3482 ret = 0;
3483 }
3484
3485out:
3486 /* Scan state should be updated upon scan completion but in case
3487 * firmware fails to deliver the event (for whatever reason) it is
3488 * desired to clean up scan state anyway. Firmware may have just
3489 * dropped the scan completion event delivery due to transport pipe
3490 * being overflown with data and/or it can recover on its own before
3491 * next scan request is submitted.
3492 */
3493 spin_lock_bh(&ar->data_lock);
3494 if (ar->scan.state != ATH11K_SCAN_IDLE)
3495 __ath11k_mac_scan_finish(ar);
3496 spin_unlock_bh(&ar->data_lock);
3497
3498 return ret;
3499}
3500
3501static void ath11k_scan_abort(struct ath11k *ar)
3502{
3503 int ret;
3504
3505 lockdep_assert_held(&ar->conf_mutex);
3506
3507 spin_lock_bh(&ar->data_lock);
3508
3509 switch (ar->scan.state) {
3510 case ATH11K_SCAN_IDLE:
3511 /* This can happen if timeout worker kicked in and called
3512 * abortion while scan completion was being processed.
3513 */
3514 break;
3515 case ATH11K_SCAN_STARTING:
3516 case ATH11K_SCAN_ABORTING:
3517 ath11k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
3518 ar->scan.state);
3519 break;
3520 case ATH11K_SCAN_RUNNING:
3521 ar->scan.state = ATH11K_SCAN_ABORTING;
3522 spin_unlock_bh(&ar->data_lock);
3523
3524 ret = ath11k_scan_stop(ar);
3525 if (ret)
3526 ath11k_warn(ar->ab, "failed to abort scan: %d\n", ret);
3527
3528 spin_lock_bh(&ar->data_lock);
3529 break;
3530 }
3531
3532 spin_unlock_bh(&ar->data_lock);
3533}
3534
3535static void ath11k_scan_timeout_work(struct work_struct *work)
3536{
3537 struct ath11k *ar = container_of(work, struct ath11k,
3538 scan.timeout.work);
3539
3540 mutex_lock(&ar->conf_mutex);
3541 ath11k_scan_abort(ar);
3542 mutex_unlock(&ar->conf_mutex);
3543}
3544
3545static int ath11k_start_scan(struct ath11k *ar,
3546 struct scan_req_params *arg)
3547{
3548 int ret;
9dcf6808 3549 unsigned long timeout = 1 * HZ;
d5c65159
KV		 3550
3551 lockdep_assert_held(&ar->conf_mutex);
3552
9d11b7bf
KP		 3553 if (ath11k_spectral_get_mode(ar) == ATH11K_SPECTRAL_BACKGROUND)
3554 ath11k_spectral_reset_buffer(ar);
3555
d5c65159
KV		 3556 ret = ath11k_wmi_send_scan_start_cmd(ar, arg);
3557 if (ret)
3558 return ret;
3559
9dcf6808
WG		 3560 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map)) {
3561 timeout = 5 * HZ;
3562
3563 if (ar->supports_6ghz)
3564 timeout += 5 * HZ;
3565 }
3566
3567 ret = wait_for_completion_timeout(&ar->scan.started, timeout);
d5c65159
KV		 3568 if (ret == 0) {
3569 ret = ath11k_scan_stop(ar);
3570 if (ret)
3571 ath11k_warn(ar->ab, "failed to stop scan: %d\n", ret);
3572
3573 return -ETIMEDOUT;
3574 }
3575
3576 /* If we failed to start the scan, return error code at
3577 * this point. This is probably due to some issue in the
3578 * firmware, but no need to wedge the driver due to that...
3579 */
3580 spin_lock_bh(&ar->data_lock);
3581 if (ar->scan.state == ATH11K_SCAN_IDLE) {
3582 spin_unlock_bh(&ar->data_lock);
3583 return -EINVAL;
3584 }
3585 spin_unlock_bh(&ar->data_lock);
3586
3587 return 0;
3588}
3589
3590static int ath11k_mac_op_hw_scan(struct ieee80211_hw *hw,
3591 struct ieee80211_vif *vif,
3592 struct ieee80211_scan_request *hw_req)
3593{
3594 struct ath11k *ar = hw->priv;
3595 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3596 struct cfg80211_scan_request *req = &hw_req->req;
3597 struct scan_req_params arg;
3598 int ret = 0;
3599 int i;
3600
3601 mutex_lock(&ar->conf_mutex);
3602
3603 spin_lock_bh(&ar->data_lock);
3604 switch (ar->scan.state) {
3605 case ATH11K_SCAN_IDLE:
3606 reinit_completion(&ar->scan.started);
3607 reinit_completion(&ar->scan.completed);
3608 ar->scan.state = ATH11K_SCAN_STARTING;
3609 ar->scan.is_roc = false;
3610 ar->scan.vdev_id = arvif->vdev_id;
3611 ret = 0;
3612 break;
3613 case ATH11K_SCAN_STARTING:
3614 case ATH11K_SCAN_RUNNING:
3615 case ATH11K_SCAN_ABORTING:
3616 ret = -EBUSY;
3617 break;
3618 }
3619 spin_unlock_bh(&ar->data_lock);
3620
3621 if (ret)
3622 goto exit;
3623
3624 memset(&arg, 0, sizeof(arg));
3625 ath11k_wmi_start_scan_init(ar, &arg);
3626 arg.vdev_id = arvif->vdev_id;
3627 arg.scan_id = ATH11K_SCAN_ID;
3628
3629 if (req->ie_len) {
eccd2513
ZQ		 3630 arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
3631 if (!arg.extraie.ptr) {
3632 ret = -ENOMEM;
3633 goto exit;
3634 }
d5c65159 3635 arg.extraie.len = req->ie_len;
d5c65159
KV		 3636 }
3637
3638 if (req->n_ssids) {
3639 arg.num_ssids = req->n_ssids;
3640 for (i = 0; i < arg.num_ssids; i++) {
3641 arg.ssid[i].length = req->ssids[i].ssid_len;
3642 memcpy(&arg.ssid[i].ssid, req->ssids[i].ssid,
3643 req->ssids[i].ssid_len);
3644 }
3645 } else {
3646 arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
3647 }
3648
3649 if (req->n_channels) {
3650 arg.num_chan = req->n_channels;
cea7f78d
WG		 3651 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
3652 GFP_KERNEL);
3653
3654 if (!arg.chan_list) {
3655 ret = -ENOMEM;
3656 goto exit;
3657 }
3658
d5c65159
KV		 3659 for (i = 0; i < arg.num_chan; i++)
3660 arg.chan_list[i] = req->channels[i]->center_freq;
3661 }
3662
9cbd7fc9
CH		 3663 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
3664 arg.scan_f_add_spoofed_mac_in_probe = 1;
3665 ether_addr_copy(arg.mac_addr.addr, req->mac_addr);
3666 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask);
3667 }
3668
d5c65159
KV		 3669 ret = ath11k_start_scan(ar, &arg);
3670 if (ret) {
3671 ath11k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
3672 spin_lock_bh(&ar->data_lock);
3673 ar->scan.state = ATH11K_SCAN_IDLE;
3674 spin_unlock_bh(&ar->data_lock);
3675 }
3676
3677 /* Add a 200ms margin to account for event/command processing */
3678 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
3679 msecs_to_jiffies(arg.max_scan_time +
3680 ATH11K_MAC_SCAN_TIMEOUT_MSECS));
3681
3682exit:
cea7f78d
WG		 3683 kfree(arg.chan_list);
3684
d5c65159
KV		 3685 if (req->ie_len)
3686 kfree(arg.extraie.ptr);
3687
3688 mutex_unlock(&ar->conf_mutex);
1f682dc9
WG		 3689
3690 if (ar->state_11d == ATH11K_11D_PREPARING)
3691 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
3692
d5c65159
KV		 3693 return ret;
3694}
3695
3696static void ath11k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
3697 struct ieee80211_vif *vif)
3698{
3699 struct ath11k *ar = hw->priv;
3700
3701 mutex_lock(&ar->conf_mutex);
3702 ath11k_scan_abort(ar);
3703 mutex_unlock(&ar->conf_mutex);
3704
3705 cancel_delayed_work_sync(&ar->scan.timeout);
3706}
3707
3708static int ath11k_install_key(struct ath11k_vif *arvif,
3709 struct ieee80211_key_conf *key,
3710 enum set_key_cmd cmd,
3711 const u8 *macaddr, u32 flags)
3712{
3713 int ret;
3714 struct ath11k *ar = arvif->ar;
3715 struct wmi_vdev_install_key_arg arg = {
3716 .vdev_id = arvif->vdev_id,
3717 .key_idx = key->keyidx,
3718 .key_len = key->keylen,
3719 .key_data = key->key,
3720 .key_flags = flags,
3721 .macaddr = macaddr,
3722 };
3723
3724 lockdep_assert_held(&arvif->ar->conf_mutex);
3725
3726 reinit_completion(&ar->install_key_done);
3727
aa2092a9
VN		 3728 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3729 return 0;
3730
d5c65159 3731 if (cmd == DISABLE_KEY) {
436a4e88 3732 arg.key_cipher = WMI_CIPHER_NONE;
d5c65159
KV		 3733 arg.key_data = NULL;
3734 goto install;
3735 }
3736
3737 switch (key->cipher) {
3738 case WLAN_CIPHER_SUITE_CCMP:
3739 arg.key_cipher = WMI_CIPHER_AES_CCM;
3740 /* TODO: Re-check if flag is valid */
3741 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
3742 break;
3743 case WLAN_CIPHER_SUITE_TKIP:
3744 arg.key_cipher = WMI_CIPHER_TKIP;
3745 arg.key_txmic_len = 8;
3746 arg.key_rxmic_len = 8;
3747 break;
3748 case WLAN_CIPHER_SUITE_CCMP_256:
3749 arg.key_cipher = WMI_CIPHER_AES_CCM;
3750 break;
3751 case WLAN_CIPHER_SUITE_GCMP:
3752 case WLAN_CIPHER_SUITE_GCMP_256:
3753 arg.key_cipher = WMI_CIPHER_AES_GCM;
3754 break;
3755 default:
3756 ath11k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
3757 return -EOPNOTSUPP;
3758 }
3759
aa2092a9
VN		 3760 if (test_bit(ATH11K_FLAG_RAW_MODE, &ar->ab->dev_flags))
3761 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
3762 IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
3763
d5c65159
KV		 3764install:
3765 ret = ath11k_wmi_vdev_install_key(arvif->ar, &arg);
aa2092a9 3766
d5c65159
KV		 3767 if (ret)
3768 return ret;
3769
3770 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
3771 return -ETIMEDOUT;
3772
3773 return ar->install_key_status ? -EINVAL : 0;
3774}
3775
3776static int ath11k_clear_peer_keys(struct ath11k_vif *arvif,
3777 const u8 *addr)
3778{
3779 struct ath11k *ar = arvif->ar;
3780 struct ath11k_base *ab = ar->ab;
3781 struct ath11k_peer *peer;
3782 int first_errno = 0;
3783 int ret;
3784 int i;
3785 u32 flags = 0;
3786
3787 lockdep_assert_held(&ar->conf_mutex);
3788
3789 spin_lock_bh(&ab->base_lock);
3790 peer = ath11k_peer_find(ab, arvif->vdev_id, addr);
3791 spin_unlock_bh(&ab->base_lock);
3792
3793 if (!peer)
3794 return -ENOENT;
3795
3796 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
3797 if (!peer->keys[i])
3798 continue;
3799
3800 /* key flags are not required to delete the key */
3801 ret = ath11k_install_key(arvif, peer->keys[i],
3802 DISABLE_KEY, addr, flags);
3803 if (ret < 0 && first_errno == 0)
3804 first_errno = ret;
3805
3806 if (ret < 0)
3807 ath11k_warn(ab, "failed to remove peer key %d: %d\n",
3808 i, ret);
3809
3810 spin_lock_bh(&ab->base_lock);
3811 peer->keys[i] = NULL;
3812 spin_unlock_bh(&ab->base_lock);
3813 }
3814
3815 return first_errno;
3816}
3817
3818static int ath11k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3819 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3820 struct ieee80211_key_conf *key)
3821{
3822 struct ath11k *ar = hw->priv;
3823 struct ath11k_base *ab = ar->ab;
3824 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
3825 struct ath11k_peer *peer;
1441b2f2 3826 struct ath11k_sta *arsta;
d5c65159
KV		 3827 const u8 *peer_addr;
3828 int ret = 0;
3829 u32 flags = 0;
3830
3831 /* BIP needs to be done in software */
3832 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
3833 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
3834 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
3835 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
3836 return 1;
3837
aa2092a9
VN		 3838 if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3839 return 1;
3840
d5c65159
KV		 3841 if (key->keyidx > WMI_MAX_KEY_INDEX)
3842 return -ENOSPC;
3843
3844 mutex_lock(&ar->conf_mutex);
3845
3846 if (sta)
3847 peer_addr = sta->addr;
3848 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3849 peer_addr = vif->bss_conf.bssid;
3850 else
3851 peer_addr = vif->addr;
3852
3853 key->hw_key_idx = key->keyidx;
3854
3855 /* the peer should not disappear in mid-way (unless FW goes awry) since
3856 * we already hold conf_mutex. we just make sure its there now.
3857 */
3858 spin_lock_bh(&ab->base_lock);
3859 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
c3944a56
S		 3860
3861 /* flush the fragments cache during key (re)install to
3862 * ensure all frags in the new frag list belong to the same key.
3863 */
ba53ee7f 3864 if (peer && sta && cmd == SET_KEY)
c3944a56 3865 ath11k_peer_frags_flush(ar, peer);
d5c65159
KV		 3866 spin_unlock_bh(&ab->base_lock);
3867
3868 if (!peer) {
3869 if (cmd == SET_KEY) {
3870 ath11k_warn(ab, "cannot install key for non-existent peer %pM\n",
3871 peer_addr);
3872 ret = -EOPNOTSUPP;
3873 goto exit;
3874 } else {
3875 /* if the peer doesn't exist there is no key to disable
3876 * anymore
3877 */
3878 goto exit;
3879 }
3880 }
3881
3882 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3883 flags |= WMI_KEY_PAIRWISE;
3884 else
3885 flags |= WMI_KEY_GROUP;
3886
3887 ret = ath11k_install_key(arvif, key, cmd, peer_addr, flags);
3888 if (ret) {
3889 ath11k_warn(ab, "ath11k_install_key failed (%d)\n", ret);
3890 goto exit;
3891 }
3892
1441b2f2
MP		 3893 ret = ath11k_dp_peer_rx_pn_replay_config(arvif, peer_addr, cmd, key);
3894 if (ret) {
3895 ath11k_warn(ab, "failed to offload PN replay detection %d\n", ret);
3896 goto exit;
3897 }
3898
d5c65159
KV		 3899 spin_lock_bh(&ab->base_lock);
3900 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
243874c6 3901 if (peer && cmd == SET_KEY) {
d5c65159 3902 peer->keys[key->keyidx] = key;
acc79d98 3903 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
243874c6 3904 peer->ucast_keyidx = key->keyidx;
acc79d98
S		 3905 peer->sec_type = ath11k_dp_tx_get_encrypt_type(key->cipher);
3906 } else {
243874c6 3907 peer->mcast_keyidx = key->keyidx;
acc79d98
S		 3908 peer->sec_type_grp = ath11k_dp_tx_get_encrypt_type(key->cipher);
3909 }
243874c6 3910 } else if (peer && cmd == DISABLE_KEY) {
d5c65159 3911 peer->keys[key->keyidx] = NULL;
243874c6
MP		 3912 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3913 peer->ucast_keyidx = 0;
3914 else
3915 peer->mcast_keyidx = 0;
3916 } else if (!peer)
d5c65159
KV		 3917 /* impossible unless FW goes crazy */
3918 ath11k_warn(ab, "peer %pM disappeared!\n", peer_addr);
1441b2f2
MP		 3919
3920 if (sta) {
3921 arsta = (struct ath11k_sta *)sta->drv_priv;
3922
3923 switch (key->cipher) {
3924 case WLAN_CIPHER_SUITE_TKIP:
3925 case WLAN_CIPHER_SUITE_CCMP:
3926 case WLAN_CIPHER_SUITE_CCMP_256:
3927 case WLAN_CIPHER_SUITE_GCMP:
3928 case WLAN_CIPHER_SUITE_GCMP_256:
3929 if (cmd == SET_KEY)
3930 arsta->pn_type = HAL_PN_TYPE_WPA;
3931 else
3932 arsta->pn_type = HAL_PN_TYPE_NONE;
3933 break;
3934 default:
3935 arsta->pn_type = HAL_PN_TYPE_NONE;
3936 break;
3937 }
3938 }
acc79d98 3939
d5c65159
KV		 3940 spin_unlock_bh(&ab->base_lock);
3941
3942exit:
3943 mutex_unlock(&ar->conf_mutex);
3944 return ret;
3945}
3946
3947static int
3948ath11k_mac_bitrate_mask_num_vht_rates(struct ath11k *ar,
3949 enum nl80211_band band,
3950 const struct cfg80211_bitrate_mask *mask)
3951{
3952 int num_rates = 0;
3953 int i;
3954
3955 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
3956 num_rates += hweight16(mask->control[band].vht_mcs[i]);
3957
3958 return num_rates;
3959}
3960
61fe43e7
MH		 3961static int
3962ath11k_mac_bitrate_mask_num_he_rates(struct ath11k *ar,
3963 enum nl80211_band band,
3964 const struct cfg80211_bitrate_mask *mask)
3965{
3966 int num_rates = 0;
3967 int i;
3968
3969 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++)
3970 num_rates += hweight16(mask->control[band].he_mcs[i]);
3971
3972 return num_rates;
3973}
3974
d5c65159
KV		 3975static int
3976ath11k_mac_set_peer_vht_fixed_rate(struct ath11k_vif *arvif,
3977 struct ieee80211_sta *sta,
3978 const struct cfg80211_bitrate_mask *mask,
3979 enum nl80211_band band)
3980{
3981 struct ath11k *ar = arvif->ar;
3982 u8 vht_rate, nss;
3983 u32 rate_code;
3984 int ret, i;
3985
3986 lockdep_assert_held(&ar->conf_mutex);
3987
3988 nss = 0;
3989
3990 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
3991 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
3992 nss = i + 1;
3993 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
3994 }
3995 }
3996
3997 if (!nss) {
3998 ath11k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
3999 sta->addr);
4000 return -EINVAL;
4001 }
4002
61fe43e7
MH		 4003 /* Avoid updating invalid nss as fixed rate*/
4004 if (nss > sta->rx_nss)
4005 return -EINVAL;
4006
d5c65159
KV		 4007 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4008 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
4009 sta->addr);
4010
4011 rate_code = ATH11K_HW_RATE_CODE(vht_rate, nss - 1,
4012 WMI_RATE_PREAMBLE_VHT);
4013 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4014 arvif->vdev_id,
4015 WMI_PEER_PARAM_FIXED_RATE,
4016 rate_code);
4017 if (ret)
4018 ath11k_warn(ar->ab,
4019 "failed to update STA %pM Fixed Rate %d: %d\n",
4020 sta->addr, rate_code, ret);
4021
4022 return ret;
4023}
4024
61fe43e7
MH		 4025static int
4026ath11k_mac_set_peer_he_fixed_rate(struct ath11k_vif *arvif,
4027 struct ieee80211_sta *sta,
4028 const struct cfg80211_bitrate_mask *mask,
4029 enum nl80211_band band)
4030{
4031 struct ath11k *ar = arvif->ar;
4032 u8 he_rate, nss;
4033 u32 rate_code;
4034 int ret, i;
4035
4036 lockdep_assert_held(&ar->conf_mutex);
4037
4038 nss = 0;
4039
4040 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
4041 if (hweight16(mask->control[band].he_mcs[i]) == 1) {
4042 nss = i + 1;
4043 he_rate = ffs(mask->control[band].he_mcs[i]) - 1;
4044 }
4045 }
4046
4047 if (!nss) {
4048 ath11k_warn(ar->ab, "No single he fixed rate found to set for %pM",
4049 sta->addr);
4050 return -EINVAL;
4051 }
4052
4053 /* Avoid updating invalid nss as fixed rate */
4054 if (nss > sta->rx_nss)
4055 return -EINVAL;
4056
4057 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4058 "mac setting fixed he rate for peer %pM, device will not switch to any other selected rates",
4059 sta->addr);
4060
4061 rate_code = ATH11K_HW_RATE_CODE(he_rate, nss - 1,
4062 WMI_RATE_PREAMBLE_HE);
4063
4064 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4065 arvif->vdev_id,
4066 WMI_PEER_PARAM_FIXED_RATE,
4067 rate_code);
4068 if (ret)
4069 ath11k_warn(ar->ab,
4070 "failed to update sta %pM fixed rate %d: %d\n",
4071 sta->addr, rate_code, ret);
4072
4073 return ret;
4074}
4075
d5c65159
KV		 4076static int ath11k_station_assoc(struct ath11k *ar,
4077 struct ieee80211_vif *vif,
4078 struct ieee80211_sta *sta,
4079 bool reassoc)
4080{
4081 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4082 struct peer_assoc_params peer_arg;
4083 int ret = 0;
4084 struct cfg80211_chan_def def;
4085 enum nl80211_band band;
4086 struct cfg80211_bitrate_mask *mask;
61fe43e7 4087 u8 num_vht_rates, num_he_rates;
d5c65159
KV		 4088
4089 lockdep_assert_held(&ar->conf_mutex);
4090
4091 if (WARN_ON(ath11k_mac_vif_chan(vif, &def)))
4092 return -EPERM;
4093
4094 band = def.chan->band;
4095 mask = &arvif->bitrate_mask;
4096
4097 ath11k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
4098
c802b6d7 4099 peer_arg.is_assoc = true;
d5c65159
KV		 4100 ret = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4101 if (ret) {
4102 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4103 sta->addr, arvif->vdev_id, ret);
4104 return ret;
4105 }
4106
4107 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4108 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4109 sta->addr, arvif->vdev_id);
4110 return -ETIMEDOUT;
4111 }
4112
4113 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
61fe43e7 4114 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask);
d5c65159 4115
61fe43e7
MH		 4116 /* If single VHT/HE rate is configured (by set_bitrate_mask()),
4117 * peer_assoc will disable VHT/HE. This is now enabled by a peer specific
d5c65159
KV		 4118 * fixed param.
4119 * Note that all other rates and NSS will be disabled for this peer.
4120 */
4121 if (sta->vht_cap.vht_supported && num_vht_rates == 1) {
4122 ret = ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4123 band);
4124 if (ret)
4125 return ret;
61fe43e7
MH		 4126 } else if (sta->he_cap.has_he && num_he_rates == 1) {
4127 ret = ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4128 band);
4129 if (ret)
4130 return ret;
d5c65159
KV		 4131 }
4132
4133 /* Re-assoc is run only to update supported rates for given station. It
4134 * doesn't make much sense to reconfigure the peer completely.
4135 */
4136 if (reassoc)
4137 return 0;
4138
4139 ret = ath11k_setup_peer_smps(ar, arvif, sta->addr,
6f4d7030 4140 &sta->ht_cap, le16_to_cpu(sta->he_6ghz_capa.capa));
d5c65159
KV		 4141 if (ret) {
4142 ath11k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
4143 arvif->vdev_id, ret);
4144 return ret;
4145 }
4146
4147 if (!sta->wme) {
4148 arvif->num_legacy_stations++;
4149 ret = ath11k_recalc_rtscts_prot(arvif);
4150 if (ret)
4151 return ret;
4152 }
4153
4154 if (sta->wme && sta->uapsd_queues) {
4155 ret = ath11k_peer_assoc_qos_ap(ar, arvif, sta);
4156 if (ret) {
4157 ath11k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
4158 sta->addr, arvif->vdev_id, ret);
4159 return ret;
4160 }
4161 }
4162
4163 return 0;
4164}
4165
4166static int ath11k_station_disassoc(struct ath11k *ar,
4167 struct ieee80211_vif *vif,
4168 struct ieee80211_sta *sta)
4169{
4170 struct ath11k_vif *arvif = (void *)vif->drv_priv;
4171 int ret = 0;
4172
4173 lockdep_assert_held(&ar->conf_mutex);
4174
4175 if (!sta->wme) {
4176 arvif->num_legacy_stations--;
4177 ret = ath11k_recalc_rtscts_prot(arvif);
4178 if (ret)
4179 return ret;
4180 }
4181
4182 ret = ath11k_clear_peer_keys(arvif, sta->addr);
4183 if (ret) {
4184 ath11k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
4185 arvif->vdev_id, ret);
4186 return ret;
4187 }
4188 return 0;
4189}
4190
4191static void ath11k_sta_rc_update_wk(struct work_struct *wk)
4192{
4193 struct ath11k *ar;
4194 struct ath11k_vif *arvif;
4195 struct ath11k_sta *arsta;
4196 struct ieee80211_sta *sta;
4197 struct cfg80211_chan_def def;
4198 enum nl80211_band band;
4199 const u8 *ht_mcs_mask;
4200 const u16 *vht_mcs_mask;
61fe43e7 4201 const u16 *he_mcs_mask;
d5c65159 4202 u32 changed, bw, nss, smps;
61fe43e7 4203 int err, num_vht_rates, num_he_rates;
d5c65159
KV		 4204 const struct cfg80211_bitrate_mask *mask;
4205 struct peer_assoc_params peer_arg;
4206
4207 arsta = container_of(wk, struct ath11k_sta, update_wk);
4208 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4209 arvif = arsta->arvif;
4210 ar = arvif->ar;
4211
4212 if (WARN_ON(ath11k_mac_vif_chan(arvif->vif, &def)))
4213 return;
4214
4215 band = def.chan->band;
4216 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4217 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
61fe43e7 4218 he_mcs_mask = arvif->bitrate_mask.control[band].he_mcs;
d5c65159
KV		 4219
4220 spin_lock_bh(&ar->data_lock);
4221
4222 changed = arsta->changed;
4223 arsta->changed = 0;
4224
4225 bw = arsta->bw;
4226 nss = arsta->nss;
4227 smps = arsta->smps;
4228
4229 spin_unlock_bh(&ar->data_lock);
4230
4231 mutex_lock(&ar->conf_mutex);
4232
4233 nss = max_t(u32, 1, nss);
61fe43e7
MH		 4234 nss = min(nss, max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
4235 ath11k_mac_max_vht_nss(vht_mcs_mask)),
4236 ath11k_mac_max_he_nss(he_mcs_mask)));
d5c65159
KV		 4237
4238 if (changed & IEEE80211_RC_BW_CHANGED) {
f187fe8e
VN		 4239 /* Send peer assoc command before set peer bandwidth param to
4240 * avoid the mismatch between the peer phymode and the peer
4241 * bandwidth.
4242 */
4243 ath11k_peer_assoc_prepare(ar, arvif->vif, sta, &peer_arg, true);
4244
4245 peer_arg.is_assoc = false;
4246 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4247 if (err) {
4248 ath11k_warn(ar->ab, "failed to send peer assoc for STA %pM vdev %i: %d\n",
4249 sta->addr, arvif->vdev_id, err);
4250 } else if (wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
4251 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4252 WMI_PEER_CHWIDTH, bw);
4253 if (err)
4254 ath11k_warn(ar->ab, "failed to update STA %pM peer bw %d: %d\n",
4255 sta->addr, bw, err);
4256 } else {
4257 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4258 sta->addr, arvif->vdev_id);
4259 }
d5c65159
KV		 4260 }
4261
4262 if (changed & IEEE80211_RC_NSS_CHANGED) {
4263 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM nss %d\n",
4264 sta->addr, nss);
4265
4266 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4267 WMI_PEER_NSS, nss);
4268 if (err)
4269 ath11k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
4270 sta->addr, nss, err);
4271 }
4272
4273 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4274 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac update sta %pM smps %d\n",
4275 sta->addr, smps);
4276
4277 err = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4278 WMI_PEER_MIMO_PS_STATE, smps);
4279 if (err)
4280 ath11k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
4281 sta->addr, smps, err);
4282 }
4283
4284 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
4285 mask = &arvif->bitrate_mask;
4286 num_vht_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
4287 mask);
61fe43e7
MH		 4288 num_he_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
4289 mask);
d5c65159
KV		 4290
4291 /* Peer_assoc_prepare will reject vht rates in
4292 * bitrate_mask if its not available in range format and
4293 * sets vht tx_rateset as unsupported. So multiple VHT MCS
4294 * setting(eg. MCS 4,5,6) per peer is not supported here.
4295 * But, Single rate in VHT mask can be set as per-peer
4296 * fixed rate. But even if any HT rates are configured in
4297 * the bitrate mask, device will not switch to those rates
4298 * when per-peer Fixed rate is set.
4299 * TODO: Check RATEMASK_CMDID to support auto rates selection
4300 * across HT/VHT and for multiple VHT MCS support.
4301 */
4302 if (sta->vht_cap.vht_supported && num_vht_rates == 1) {
4303 ath11k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
4304 band);
61fe43e7
MH		 4305 } else if (sta->he_cap.has_he && num_he_rates == 1) {
4306 ath11k_mac_set_peer_he_fixed_rate(arvif, sta, mask,
4307 band);
d5c65159 4308 } else {
61fe43e7 4309 /* If the peer is non-VHT/HE or no fixed VHT/HE rate
d5c65159 4310 * is provided in the new bitrate mask we set the
61fe43e7
MH		 4311 * other rates using peer_assoc command. Also clear
4312 * the peer fixed rate settings as it has higher proprity
4313 * than peer assoc
d5c65159 4314 */
61fe43e7
MH		 4315 err = ath11k_wmi_set_peer_param(ar, sta->addr,
4316 arvif->vdev_id,
4317 WMI_PEER_PARAM_FIXED_RATE,
4318 WMI_FIXED_RATE_NONE);
4319 if (err)
4320 ath11k_warn(ar->ab,
4321 "failed to disable peer fixed rate for sta %pM: %d\n",
4322 sta->addr, err);
4323
d5c65159
KV		 4324 ath11k_peer_assoc_prepare(ar, arvif->vif, sta,
4325 &peer_arg, true);
4326
c802b6d7 4327 peer_arg.is_assoc = false;
d5c65159
KV		 4328 err = ath11k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
4329 if (err)
4330 ath11k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
4331 sta->addr, arvif->vdev_id, err);
4332
4333 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
4334 ath11k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
4335 sta->addr, arvif->vdev_id);
4336 }
4337 }
4338
4339 mutex_unlock(&ar->conf_mutex);
4340}
4341
34c67dc3
SM		 4342static void ath11k_sta_set_4addr_wk(struct work_struct *wk)
4343{
4344 struct ath11k *ar;
4345 struct ath11k_vif *arvif;
4346 struct ath11k_sta *arsta;
4347 struct ieee80211_sta *sta;
4348 int ret = 0;
4349
4350 arsta = container_of(wk, struct ath11k_sta, set_4addr_wk);
4351 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4352 arvif = arsta->arvif;
4353 ar = arvif->ar;
4354
4355 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4356 "setting USE_4ADDR for peer %pM\n", sta->addr);
4357
4358 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4359 arvif->vdev_id,
4360 WMI_PEER_USE_4ADDR, 1);
4361
4362 if (ret)
4363 ath11k_warn(ar->ab, "failed to set peer %pM 4addr capability: %d\n",
4364 sta->addr, ret);
4365}
4366
d5c65159
KV		 4367static int ath11k_mac_inc_num_stations(struct ath11k_vif *arvif,
4368 struct ieee80211_sta *sta)
4369{
4370 struct ath11k *ar = arvif->ar;
4371
4372 lockdep_assert_held(&ar->conf_mutex);
4373
4374 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4375 return 0;
4376
4377 if (ar->num_stations >= ar->max_num_stations)
4378 return -ENOBUFS;
4379
4380 ar->num_stations++;
4381
4382 return 0;
4383}
4384
4385static void ath11k_mac_dec_num_stations(struct ath11k_vif *arvif,
4386 struct ieee80211_sta *sta)
4387{
4388 struct ath11k *ar = arvif->ar;
4389
4390 lockdep_assert_held(&ar->conf_mutex);
4391
4392 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4393 return;
4394
4395 ar->num_stations--;
4396}
4397
5e971287
KP		 4398static int ath11k_mac_station_add(struct ath11k *ar,
4399 struct ieee80211_vif *vif,
4400 struct ieee80211_sta *sta)
4401{
4402 struct ath11k_base *ab = ar->ab;
4403 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4404 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4405 struct peer_create_params peer_param;
4406 int ret;
4407
4408 lockdep_assert_held(&ar->conf_mutex);
4409
4410 ret = ath11k_mac_inc_num_stations(arvif, sta);
4411 if (ret) {
4412 ath11k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
4413 ar->max_num_stations);
4414 goto exit;
4415 }
4416
4417 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
4418 if (!arsta->rx_stats) {
4419 ret = -ENOMEM;
4420 goto dec_num_station;
4421 }
4422
4423 peer_param.vdev_id = arvif->vdev_id;
4424 peer_param.peer_addr = sta->addr;
4425 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
4426
4427 ret = ath11k_peer_create(ar, arvif, sta, &peer_param);
4428 if (ret) {
4429 ath11k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
4430 sta->addr, arvif->vdev_id);
4431 goto free_rx_stats;
4432 }
4433
4434 ath11k_dbg(ab, ATH11K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
4435 sta->addr, arvif->vdev_id);
4436
cb4e57db 4437 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar)) {
5e971287
KP		 4438 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats), GFP_KERNEL);
4439 if (!arsta->tx_stats) {
4440 ret = -ENOMEM;
4441 goto free_peer;
4442 }
4443 }
4444
4445 if (ieee80211_vif_is_mesh(vif)) {
34c67dc3
SM		 4446 ath11k_dbg(ab, ATH11K_DBG_MAC,
4447 "setting USE_4ADDR for mesh STA %pM\n", sta->addr);
5e971287
KP		 4448 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4449 arvif->vdev_id,
4450 WMI_PEER_USE_4ADDR, 1);
4451 if (ret) {
34c67dc3 4452 ath11k_warn(ab, "failed to set mesh STA %pM 4addr capability: %d\n",
5e971287
KP		 4453 sta->addr, ret);
4454 goto free_tx_stats;
4455 }
4456 }
4457
4458 ret = ath11k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
4459 if (ret) {
4460 ath11k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
4461 sta->addr, arvif->vdev_id, ret);
4462 goto free_tx_stats;
4463 }
4464
b0919924 4465 if (ab->hw_params.vdev_start_delay &&
aa44b2f3 4466 !arvif->is_started &&
b0919924 4467 arvif->vdev_type != WMI_VDEV_TYPE_AP) {
e7495035
CH		 4468 ret = ath11k_start_vdev_delay(ar->hw, vif);
4469 if (ret) {
4470 ath11k_warn(ab, "failed to delay vdev start: %d\n", ret);
4471 goto free_tx_stats;
4472 }
4473 }
4474
5e971287
KP		 4475 return 0;
4476
4477free_tx_stats:
4478 kfree(arsta->tx_stats);
4479 arsta->tx_stats = NULL;
4480free_peer:
4481 ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4482free_rx_stats:
4483 kfree(arsta->rx_stats);
4484 arsta->rx_stats = NULL;
4485dec_num_station:
4486 ath11k_mac_dec_num_stations(arvif, sta);
4487exit:
4488 return ret;
4489}
4490
d5c65159
KV		 4491static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
4492 struct ieee80211_vif *vif,
4493 struct ieee80211_sta *sta,
4494 enum ieee80211_sta_state old_state,
4495 enum ieee80211_sta_state new_state)
4496{
4497 struct ath11k *ar = hw->priv;
4498 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4499 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
58595c98 4500 struct ath11k_peer *peer;
d5c65159
KV		 4501 int ret = 0;
4502
4503 /* cancel must be done outside the mutex to avoid deadlock */
4504 if ((old_state == IEEE80211_STA_NONE &&
34c67dc3 4505 new_state == IEEE80211_STA_NOTEXIST)) {
d5c65159 4506 cancel_work_sync(&arsta->update_wk);
34c67dc3
SM		 4507 cancel_work_sync(&arsta->set_4addr_wk);
4508 }
d5c65159
KV		 4509
4510 mutex_lock(&ar->conf_mutex);
4511
4512 if (old_state == IEEE80211_STA_NOTEXIST &&
4513 new_state == IEEE80211_STA_NONE) {
4514 memset(arsta, 0, sizeof(*arsta));
4515 arsta->arvif = arvif;
4516 INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
34c67dc3 4517 INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
d5c65159 4518
5e971287
KP		 4519 ret = ath11k_mac_station_add(ar, vif, sta);
4520 if (ret)
4521 ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
d5c65159 4522 sta->addr, arvif->vdev_id);
d5c65159
KV		 4523 } else if ((old_state == IEEE80211_STA_NONE &&
4524 new_state == IEEE80211_STA_NOTEXIST)) {
212ad7cb
WG		 4525 bool skip_peer_delete = ar->ab->hw_params.vdev_start_delay &&
4526 vif->type == NL80211_IFTYPE_STATION;
d5c65159 4527
212ad7cb 4528 ath11k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
b4a0f541 4529
212ad7cb
WG		 4530 if (!skip_peer_delete) {
4531 ret = ath11k_peer_delete(ar, arvif->vdev_id, sta->addr);
4532 if (ret)
4533 ath11k_warn(ar->ab,
4534 "Failed to delete peer: %pM for VDEV: %d\n",
4535 sta->addr, arvif->vdev_id);
4536 else
4537 ath11k_dbg(ar->ab,
4538 ATH11K_DBG_MAC,
4539 "Removed peer: %pM for VDEV: %d\n",
4540 sta->addr, arvif->vdev_id);
4541 }
d5c65159
KV		 4542
4543 ath11k_mac_dec_num_stations(arvif, sta);
7b0c70d9 4544 mutex_lock(&ar->ab->tbl_mtx_lock);
58595c98
VP		 4545 spin_lock_bh(&ar->ab->base_lock);
4546 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
212ad7cb
WG		 4547 if (skip_peer_delete && peer) {
4548 peer->sta = NULL;
4549 } else if (peer && peer->sta == sta) {
58595c98
VP		 4550 ath11k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
4551 vif->addr, arvif->vdev_id);
7b0c70d9 4552 ath11k_peer_rhash_delete(ar->ab, peer);
58595c98
VP		 4553 peer->sta = NULL;
4554 list_del(&peer->list);
4555 kfree(peer);
4556 ar->num_peers--;
4557 }
4558 spin_unlock_bh(&ar->ab->base_lock);
7b0c70d9 4559 mutex_unlock(&ar->ab->tbl_mtx_lock);
d5c65159
KV		 4560
4561 kfree(arsta->tx_stats);
4562 arsta->tx_stats = NULL;
4563
4564 kfree(arsta->rx_stats);
4565 arsta->rx_stats = NULL;
4566 } else if (old_state == IEEE80211_STA_AUTH &&
4567 new_state == IEEE80211_STA_ASSOC &&
4568 (vif->type == NL80211_IFTYPE_AP ||
4569 vif->type == NL80211_IFTYPE_MESH_POINT ||
4570 vif->type == NL80211_IFTYPE_ADHOC)) {
4571 ret = ath11k_station_assoc(ar, vif, sta, false);
4572 if (ret)
4573 ath11k_warn(ar->ab, "Failed to associate station: %pM\n",
4574 sta->addr);
85f36923
KP		 4575 } else if (old_state == IEEE80211_STA_ASSOC &&
4576 new_state == IEEE80211_STA_AUTHORIZED) {
4577 spin_lock_bh(&ar->ab->base_lock);
4578
4579 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4580 if (peer)
4581 peer->is_authorized = true;
4582
4583 spin_unlock_bh(&ar->ab->base_lock);
4584
4585 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
4586 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
4587 arvif->vdev_id,
4588 WMI_PEER_AUTHORIZE,
4589 1);
4590 if (ret)
4591 ath11k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
4592 sta->addr, arvif->vdev_id, ret);
4593 }
4594 } else if (old_state == IEEE80211_STA_AUTHORIZED &&
4595 new_state == IEEE80211_STA_ASSOC) {
4596 spin_lock_bh(&ar->ab->base_lock);
4597
4598 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4599 if (peer)
4600 peer->is_authorized = false;
4601
4602 spin_unlock_bh(&ar->ab->base_lock);
d5c65159
KV		 4603 } else if (old_state == IEEE80211_STA_ASSOC &&
4604 new_state == IEEE80211_STA_AUTH &&
4605 (vif->type == NL80211_IFTYPE_AP ||
4606 vif->type == NL80211_IFTYPE_MESH_POINT ||
4607 vif->type == NL80211_IFTYPE_ADHOC)) {
4608 ret = ath11k_station_disassoc(ar, vif, sta);
4609 if (ret)
4610 ath11k_warn(ar->ab, "Failed to disassociate station: %pM\n",
4611 sta->addr);
d5c65159
KV		 4612 }
4613
d5c65159
KV		 4614 mutex_unlock(&ar->conf_mutex);
4615 return ret;
4616}
4617
64f1d7e9
MK		 4618static int ath11k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
4619 struct ieee80211_vif *vif,
4620 struct ieee80211_sta *sta)
4621{
4622 struct ath11k *ar = hw->priv;
4623 struct ath11k_vif *arvif = (void *)vif->drv_priv;
4624 int ret = 0;
4625 s16 txpwr;
4626
4627 if (sta->txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
4628 txpwr = 0;
4629 } else {
4630 txpwr = sta->txpwr.power;
4631 if (!txpwr)
4632 return -EINVAL;
4633 }
4634
4635 if (txpwr > ATH11K_TX_POWER_MAX_VAL || txpwr < ATH11K_TX_POWER_MIN_VAL)
4636 return -EINVAL;
4637
4638 mutex_lock(&ar->conf_mutex);
4639
4640 ret = ath11k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
4641 WMI_PEER_USE_FIXED_PWR, txpwr);
4642 if (ret) {
4643 ath11k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
4644 ret);
4645 goto out;
4646 }
4647
4648out:
4649 mutex_unlock(&ar->conf_mutex);
4650 return ret;
4651}
4652
34c67dc3
SM		 4653static void ath11k_mac_op_sta_set_4addr(struct ieee80211_hw *hw,
4654 struct ieee80211_vif *vif,
4655 struct ieee80211_sta *sta, bool enabled)
4656{
4657 struct ath11k *ar = hw->priv;
4658 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4659
4660 if (enabled && !arsta->use_4addr_set) {
4661 ieee80211_queue_work(ar->hw, &arsta->set_4addr_wk);
4662 arsta->use_4addr_set = true;
4663 }
4664}
4665
d5c65159
KV		 4666static void ath11k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
4667 struct ieee80211_vif *vif,
4668 struct ieee80211_sta *sta,
4669 u32 changed)
4670{
4671 struct ath11k *ar = hw->priv;
4672 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
4673 struct ath11k_vif *arvif = (void *)vif->drv_priv;
4674 struct ath11k_peer *peer;
4675 u32 bw, smps;
4676
4677 spin_lock_bh(&ar->ab->base_lock);
4678
4679 peer = ath11k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
4680 if (!peer) {
4681 spin_unlock_bh(&ar->ab->base_lock);
4682 ath11k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
4683 sta->addr, arvif->vdev_id);
4684 return;
4685 }
4686
4687 spin_unlock_bh(&ar->ab->base_lock);
4688
4689 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
4690 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4691 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4692 sta->smps_mode);
4693
4694 spin_lock_bh(&ar->data_lock);
4695
4696 if (changed & IEEE80211_RC_BW_CHANGED) {
4697 bw = WMI_PEER_CHWIDTH_20MHZ;
4698
4699 switch (sta->bandwidth) {
4700 case IEEE80211_STA_RX_BW_20:
4701 bw = WMI_PEER_CHWIDTH_20MHZ;
4702 break;
4703 case IEEE80211_STA_RX_BW_40:
4704 bw = WMI_PEER_CHWIDTH_40MHZ;
4705 break;
4706 case IEEE80211_STA_RX_BW_80:
4707 bw = WMI_PEER_CHWIDTH_80MHZ;
4708 break;
4709 case IEEE80211_STA_RX_BW_160:
4710 bw = WMI_PEER_CHWIDTH_160MHZ;
4711 break;
4712 default:
4713 ath11k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n",
4714 sta->bandwidth, sta->addr);
4715 bw = WMI_PEER_CHWIDTH_20MHZ;
4716 break;
4717 }
4718
4719 arsta->bw = bw;
4720 }
4721
4722 if (changed & IEEE80211_RC_NSS_CHANGED)
4723 arsta->nss = sta->rx_nss;
4724
4725 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4726 smps = WMI_PEER_SMPS_PS_NONE;
4727
4728 switch (sta->smps_mode) {
4729 case IEEE80211_SMPS_AUTOMATIC:
4730 case IEEE80211_SMPS_OFF:
4731 smps = WMI_PEER_SMPS_PS_NONE;
4732 break;
4733 case IEEE80211_SMPS_STATIC:
4734 smps = WMI_PEER_SMPS_STATIC;
4735 break;
4736 case IEEE80211_SMPS_DYNAMIC:
4737 smps = WMI_PEER_SMPS_DYNAMIC;
4738 break;
4739 default:
4740 ath11k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
4741 sta->smps_mode, sta->addr);
4742 smps = WMI_PEER_SMPS_PS_NONE;
4743 break;
4744 }
4745
4746 arsta->smps = smps;
4747 }
4748
4749 arsta->changed |= changed;
4750
4751 spin_unlock_bh(&ar->data_lock);
4752
4753 ieee80211_queue_work(hw, &arsta->update_wk);
4754}
4755
4756static int ath11k_conf_tx_uapsd(struct ath11k *ar, struct ieee80211_vif *vif,
4757 u16 ac, bool enable)
4758{
4759 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
4760 u32 value = 0;
4761 int ret = 0;
4762
4763 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
4764 return 0;
4765
4766 switch (ac) {
4767 case IEEE80211_AC_VO:
4768 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
4769 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
4770 break;
4771 case IEEE80211_AC_VI:
4772 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
4773 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
4774 break;
4775 case IEEE80211_AC_BE:
4776 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
4777 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
4778 break;
4779 case IEEE80211_AC_BK:
4780 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
4781 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
4782 break;
4783 }
4784
4785 if (enable)
4786 arvif->u.sta.uapsd |= value;
4787 else
4788 arvif->u.sta.uapsd &= ~value;
4789
4790 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4791 WMI_STA_PS_PARAM_UAPSD,
4792 arvif->u.sta.uapsd);
4793 if (ret) {
4794 ath11k_warn(ar->ab, "could not set uapsd params %d\n", ret);
4795 goto exit;
4796 }
4797
4798 if (arvif->u.sta.uapsd)
4799 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
4800 else
4801 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4802
4803 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4804 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
4805 value);
4806 if (ret)
4807 ath11k_warn(ar->ab, "could not set rx wake param %d\n", ret);
4808
4809exit:
4810 return ret;
4811}
4812
4813static int ath11k_mac_op_conf_tx(struct ieee80211_hw *hw,
4814 struct ieee80211_vif *vif, u16 ac,
4815 const struct ieee80211_tx_queue_params *params)
4816{
4817 struct ath11k *ar = hw->priv;
4818 struct ath11k_vif *arvif = (void *)vif->drv_priv;
4819 struct wmi_wmm_params_arg *p = NULL;
4820 int ret;
4821
4822 mutex_lock(&ar->conf_mutex);
4823
4824 switch (ac) {
4825 case IEEE80211_AC_VO:
4826 p = &arvif->wmm_params.ac_vo;
4827 break;
4828 case IEEE80211_AC_VI:
4829 p = &arvif->wmm_params.ac_vi;
4830 break;
4831 case IEEE80211_AC_BE:
4832 p = &arvif->wmm_params.ac_be;
4833 break;
4834 case IEEE80211_AC_BK:
4835 p = &arvif->wmm_params.ac_bk;
4836 break;
4837 }
4838
4839 if (WARN_ON(!p)) {
4840 ret = -EINVAL;
4841 goto exit;
4842 }
4843
4844 p->cwmin = params->cw_min;
4845 p->cwmax = params->cw_max;
4846 p->aifs = params->aifs;
f425078b 4847 p->txop = params->txop;
d5c65159
KV		 4848
4849 ret = ath11k_wmi_send_wmm_update_cmd_tlv(ar, arvif->vdev_id,
4850 &arvif->wmm_params);
4851 if (ret) {
4852 ath11k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
4853 goto exit;
4854 }
4855
4856 ret = ath11k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
4857
4858 if (ret)
4859 ath11k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
4860
4861exit:
4862 mutex_unlock(&ar->conf_mutex);
4863 return ret;
4864}
4865
4866static struct ieee80211_sta_ht_cap
4867ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
4868{
4869 int i;
4870 struct ieee80211_sta_ht_cap ht_cap = {0};
4871 u32 ar_vht_cap = ar->pdev->cap.vht_cap;
4872
4873 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
4874 return ht_cap;
4875
4876 ht_cap.ht_supported = 1;
4877 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
c000e56e 4878 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
d5c65159
KV		 4879 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4880 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4881 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4882
4883 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
4884 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4885
4886 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
4887 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4888
4889 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
4890 u32 smps;
4891
4892 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4893 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4894
4895 ht_cap.cap |= smps;
4896 }
4897
4898 if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
4899 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4900
4901 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
4902 u32 stbc;
4903
4904 stbc = ar_ht_cap;
4905 stbc &= WMI_HT_CAP_RX_STBC;
4906 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4907 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4908 stbc &= IEEE80211_HT_CAP_RX_STBC;
4909
4910 ht_cap.cap |= stbc;
4911 }
4912
4913 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
4914 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4915
4916 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
4917 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4918
4919 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4920 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4921
4922 for (i = 0; i < ar->num_rx_chains; i++) {
4923 if (rate_cap_rx_chainmask & BIT(i))
4924 ht_cap.mcs.rx_mask[i] = 0xFF;
4925 }
4926
4927 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4928
4929 return ht_cap;
4930}
4931
4932static int ath11k_mac_set_txbf_conf(struct ath11k_vif *arvif)
4933{
4934 u32 value = 0;
4935 struct ath11k *ar = arvif->ar;
4936 int nsts;
4937 int sound_dim;
4938 u32 vht_cap = ar->pdev->cap.vht_cap;
4939 u32 vdev_param = WMI_VDEV_PARAM_TXBF;
4940
4941 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
4942 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4943 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4944 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4945 }
4946
4947 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
4948 sound_dim = vht_cap &
4949 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4950 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4951 if (sound_dim > (ar->num_tx_chains - 1))
4952 sound_dim = ar->num_tx_chains - 1;
4953 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4954 }
4955
4956 if (!value)
4957 return 0;
4958
4959 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
4960 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4961
4962 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
4963 arvif->vdev_type == WMI_VDEV_TYPE_AP)
4964 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
4965 }
4966
4967 /* TODO: SUBFEE not validated in HK, disable here until validated? */
4968
4969 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
4970 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4971
4972 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
4973 arvif->vdev_type == WMI_VDEV_TYPE_STA)
4974 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
4975 }
4976
4977 return ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
4978 vdev_param, value);
4979}
4980
4981static void ath11k_set_vht_txbf_cap(struct ath11k *ar, u32 *vht_cap)
4982{
4983 bool subfer, subfee;
4984 int sound_dim = 0;
4985
4986 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
4987 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
4988
4989 if (ar->num_tx_chains < 2) {
4990 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
4991 subfer = false;
4992 }
4993
4994 /* If SU Beaformer is not set, then disable MU Beamformer Capability */
4995 if (!subfer)
4996 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
4997
4998 /* If SU Beaformee is not set, then disable MU Beamformee Capability */
4999 if (!subfee)
5000 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
5001
5002 sound_dim = (*vht_cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
5003 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5004 *vht_cap &= ~IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5005
5006 /* TODO: Need to check invalid STS and Sound_dim values set by FW? */
5007
5008 /* Enable Sounding Dimension Field only if SU BF is enabled */
5009 if (subfer) {
5010 if (sound_dim > (ar->num_tx_chains - 1))
5011 sound_dim = ar->num_tx_chains - 1;
5012
5013 sound_dim <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
5014 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
5015 *vht_cap |= sound_dim;
5016 }
5017
5018 /* Use the STS advertised by FW unless SU Beamformee is not supported*/
5019 if (!subfee)
5020 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
5021}
5022
5023static struct ieee80211_sta_vht_cap
5024ath11k_create_vht_cap(struct ath11k *ar, u32 rate_cap_tx_chainmask,
5025 u32 rate_cap_rx_chainmask)
5026{
5027 struct ieee80211_sta_vht_cap vht_cap = {0};
5028 u16 txmcs_map, rxmcs_map;
5029 int i;
5030
5031 vht_cap.vht_supported = 1;
5032 vht_cap.cap = ar->pdev->cap.vht_cap;
5033
78406044
WG		 5034 if (ar->pdev->cap.nss_ratio_enabled)
5035 vht_cap.vht_mcs.tx_highest |=
5036 cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
5037
d5c65159
KV		 5038 ath11k_set_vht_txbf_cap(ar, &vht_cap.cap);
5039
d5c65159
KV		 5040 rxmcs_map = 0;
5041 txmcs_map = 0;
5042 for (i = 0; i < 8; i++) {
5043 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
5044 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5045 else
5046 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5047
5048 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
5049 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
5050 else
5051 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
5052 }
5053
5054 if (rate_cap_tx_chainmask <= 1)
5055 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
5056
5057 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
5058 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
5059
5060 return vht_cap;
5061}
5062
5063static void ath11k_mac_setup_ht_vht_cap(struct ath11k *ar,
5064 struct ath11k_pdev_cap *cap,
5065 u32 *ht_cap_info)
5066{
5067 struct ieee80211_supported_band *band;
5068 u32 rate_cap_tx_chainmask;
5069 u32 rate_cap_rx_chainmask;
5070 u32 ht_cap;
5071
5072 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
5073 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
5074
5075 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5076 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5077 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
5078 if (ht_cap_info)
5079 *ht_cap_info = ht_cap;
5080 band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
5081 rate_cap_rx_chainmask);
5082 }
5083
54f40f55
WG		 5084 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5085 (ar->ab->hw_params.single_pdev_only ||
5086 !ar->supports_6ghz)) {
d5c65159
KV		 5087 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5088 ht_cap = cap->band[NL80211_BAND_5GHZ].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 band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
5094 rate_cap_rx_chainmask);
5095 }
5096}
5097
5098static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)
5099{
5100 /* TODO: Check the request chainmask against the supported
5101 * chainmask table which is advertised in extented_service_ready event
5102 */
5103
5104 return 0;
5105}
5106
9f056ed8
JC		 5107static void ath11k_gen_ppe_thresh(struct ath11k_ppe_threshold *fw_ppet,
5108 u8 *he_ppet)
5109{
5110 int nss, ru;
5111 u8 bit = 7;
5112
5113 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
5114 he_ppet[0] |= (fw_ppet->ru_bit_mask <<
5115 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
5116 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
5117 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
5118 for (ru = 0; ru < 4; ru++) {
5119 u8 val;
5120 int i;
5121
5122 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
5123 continue;
5124 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
5125 0x3f;
5126 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
5127 for (i = 5; i >= 0; i--) {
5128 he_ppet[bit / 8] |=
5129 ((val >> i) & 0x1) << ((bit % 8));
5130 bit++;
5131 }
5132 }
5133 }
5134}
5135
13591a1c
SE		 5136static void
5137ath11k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
5138{
5139 u8 m;
5140
5141 m = IEEE80211_HE_MAC_CAP0_TWT_RES |
5142 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5143 he_cap_elem->mac_cap_info[0] &= ~m;
5144
5145 m = IEEE80211_HE_MAC_CAP2_TRS |
5146 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5147 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5148 he_cap_elem->mac_cap_info[2] &= ~m;
5149
5150 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
5151 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
5152 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
5153 he_cap_elem->mac_cap_info[3] &= ~m;
5154
5155 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
5156 IEEE80211_HE_MAC_CAP4_BQR;
5157 he_cap_elem->mac_cap_info[4] &= ~m;
5158
76cf4221 5159 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
13591a1c
SE		 5160 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
5161 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
5162 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
5163 he_cap_elem->mac_cap_info[5] &= ~m;
5164
5165 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
5166 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
5167 he_cap_elem->phy_cap_info[2] &= ~m;
5168
76cf4221 5169 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
13591a1c
SE		 5170 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
5171 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
5172 he_cap_elem->phy_cap_info[3] &= ~m;
5173
5174 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
5175 he_cap_elem->phy_cap_info[4] &= ~m;
5176
5177 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
5178 he_cap_elem->phy_cap_info[5] &= ~m;
5179
5180 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
76cf4221 5181 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
13591a1c
SE		 5182 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
5183 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
5184 he_cap_elem->phy_cap_info[6] &= ~m;
5185
76cf4221
JB		 5186 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
5187 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
13591a1c
SE		 5188 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
5189 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
5190 he_cap_elem->phy_cap_info[7] &= ~m;
5191
5192 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
5193 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
5194 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
5195 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
5196 he_cap_elem->phy_cap_info[8] &= ~m;
5197
5198 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
5199 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
5200 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
5201 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
5202 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
5203 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
5204 he_cap_elem->phy_cap_info[9] &= ~m;
5205}
5206
f28b7b78
RM		 5207static __le16 ath11k_mac_setup_he_6ghz_cap(struct ath11k_pdev_cap *pcap,
5208 struct ath11k_band_cap *bcap)
5209{
5210 u8 val;
5211
5212 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
5213 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5214 bcap->he_6ghz_capa |=
5215 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5216 WLAN_HT_CAP_SM_PS_DYNAMIC);
5217 else
5218 bcap->he_6ghz_capa |=
5219 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_SM_PS,
5220 WLAN_HT_CAP_SM_PS_DISABLED);
5221 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
5222 pcap->vht_cap);
5223 bcap->he_6ghz_capa |=
5224 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP, val);
5225 val = FIELD_GET(IEEE80211_VHT_CAP_MAX_MPDU_MASK, pcap->vht_cap);
5226 bcap->he_6ghz_capa |=
5227 FIELD_PREP(IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN, val);
5228 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
5229 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
5230 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
5231 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
5232
5233 return cpu_to_le16(bcap->he_6ghz_capa);
5234}
5235
9f056ed8
JC		 5236static int ath11k_mac_copy_he_cap(struct ath11k *ar,
5237 struct ath11k_pdev_cap *cap,
5238 struct ieee80211_sband_iftype_data *data,
5239 int band)
5240{
5241 int i, idx = 0;
5242
5243 for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
5244 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
5245 struct ath11k_band_cap *band_cap = &cap->band[band];
5246 struct ieee80211_he_cap_elem *he_cap_elem =
5247 &he_cap->he_cap_elem;
5248
5249 switch (i) {
5250 case NL80211_IFTYPE_STATION:
5251 case NL80211_IFTYPE_AP:
13591a1c 5252 case NL80211_IFTYPE_MESH_POINT:
9f056ed8
JC		 5253 break;
5254
5255 default:
5256 continue;
5257 }
5258
5259 data[idx].types_mask = BIT(i);
5260 he_cap->has_he = true;
5261 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
5262 sizeof(he_cap_elem->mac_cap_info));
5263 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
5264 sizeof(he_cap_elem->phy_cap_info));
5265
9529cba9 5266 he_cap_elem->mac_cap_info[1] &=
9f056ed8 5267 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
9f056ed8
JC		 5268
5269 he_cap_elem->phy_cap_info[5] &=
5270 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
9f056ed8
JC		 5271 he_cap_elem->phy_cap_info[5] |= ar->num_tx_chains - 1;
5272
5273 switch (i) {
5274 case NL80211_IFTYPE_AP:
37b76986
MS		 5275 he_cap_elem->phy_cap_info[3] &=
5276 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
9f056ed8
JC		 5277 he_cap_elem->phy_cap_info[9] |=
5278 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
5279 break;
5280 case NL80211_IFTYPE_STATION:
5281 he_cap_elem->mac_cap_info[0] &=
5282 ~IEEE80211_HE_MAC_CAP0_TWT_RES;
5283 he_cap_elem->mac_cap_info[0] |=
5284 IEEE80211_HE_MAC_CAP0_TWT_REQ;
5285 he_cap_elem->phy_cap_info[9] |=
5286 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
5287 break;
13591a1c
SE		 5288 case NL80211_IFTYPE_MESH_POINT:
5289 ath11k_mac_filter_he_cap_mesh(he_cap_elem);
5290 break;
9f056ed8
JC		 5291 }
5292
5293 he_cap->he_mcs_nss_supp.rx_mcs_80 =
5294 cpu_to_le16(band_cap->he_mcs & 0xffff);
5295 he_cap->he_mcs_nss_supp.tx_mcs_80 =
5296 cpu_to_le16(band_cap->he_mcs & 0xffff);
5297 he_cap->he_mcs_nss_supp.rx_mcs_160 =
5298 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5299 he_cap->he_mcs_nss_supp.tx_mcs_160 =
5300 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5301 he_cap->he_mcs_nss_supp.rx_mcs_80p80 =
5302 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5303 he_cap->he_mcs_nss_supp.tx_mcs_80p80 =
5304 cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
5305
5306 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
5307 if (he_cap_elem->phy_cap_info[6] &
5308 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
5309 ath11k_gen_ppe_thresh(&band_cap->he_ppet,
5310 he_cap->ppe_thres);
f28b7b78
RM		 5311
5312 if (band == NL80211_BAND_6GHZ) {
5313 data[idx].he_6ghz_capa.capa =
5314 ath11k_mac_setup_he_6ghz_cap(cap, band_cap);
5315 }
9f056ed8
JC		 5316 idx++;
5317 }
5318
5319 return idx;
5320}
5321
5322static void ath11k_mac_setup_he_cap(struct ath11k *ar,
5323 struct ath11k_pdev_cap *cap)
5324{
3b451683
CIK		 5325 struct ieee80211_supported_band *band;
5326 int count;
9f056ed8
JC		 5327
5328 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
5329 count = ath11k_mac_copy_he_cap(ar, cap,
5330 ar->mac.iftype[NL80211_BAND_2GHZ],
5331 NL80211_BAND_2GHZ);
5332 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
5333 band->iftype_data = ar->mac.iftype[NL80211_BAND_2GHZ];
3b451683 5334 band->n_iftype_data = count;
9f056ed8
JC		 5335 }
5336
5337 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
5338 count = ath11k_mac_copy_he_cap(ar, cap,
5339 ar->mac.iftype[NL80211_BAND_5GHZ],
5340 NL80211_BAND_5GHZ);
5341 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5342 band->iftype_data = ar->mac.iftype[NL80211_BAND_5GHZ];
3b451683 5343 band->n_iftype_data = count;
9f056ed8 5344 }
22eeadcd
PKC		 5345
5346 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
5347 ar->supports_6ghz) {
5348 count = ath11k_mac_copy_he_cap(ar, cap,
5349 ar->mac.iftype[NL80211_BAND_6GHZ],
5350 NL80211_BAND_6GHZ);
5351 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
5352 band->iftype_data = ar->mac.iftype[NL80211_BAND_6GHZ];
5353 band->n_iftype_data = count;
5354 }
9f056ed8
JC		 5355}
5356
d5c65159
KV		 5357static int __ath11k_set_antenna(struct ath11k *ar, u32 tx_ant, u32 rx_ant)
5358{
5359 int ret;
5360
5361 lockdep_assert_held(&ar->conf_mutex);
5362
5363 if (ath11k_check_chain_mask(ar, tx_ant, true))
5364 return -EINVAL;
5365
5366 if (ath11k_check_chain_mask(ar, rx_ant, false))
5367 return -EINVAL;
5368
5369 ar->cfg_tx_chainmask = tx_ant;
5370 ar->cfg_rx_chainmask = rx_ant;
5371
5372 if (ar->state != ATH11K_STATE_ON &&
5373 ar->state != ATH11K_STATE_RESTARTED)
5374 return 0;
5375
5376 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
5377 tx_ant, ar->pdev->pdev_id);
5378 if (ret) {
5379 ath11k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
5380 ret, tx_ant);
5381 return ret;
5382 }
5383
a3c5195a
S		 5384 ar->num_tx_chains = get_num_chains(tx_ant);
5385
d5c65159
KV		 5386 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
5387 rx_ant, ar->pdev->pdev_id);
5388 if (ret) {
5389 ath11k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
5390 ret, rx_ant);
5391 return ret;
5392 }
5393
a3c5195a
S		 5394 ar->num_rx_chains = get_num_chains(rx_ant);
5395
9f056ed8 5396 /* Reload HT/VHT/HE capability */
d5c65159 5397 ath11k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
9f056ed8 5398 ath11k_mac_setup_he_cap(ar, &ar->pdev->cap);
d5c65159
KV		 5399
5400 return 0;
5401}
5402
dddaa64d
WG		 5403static void ath11k_mgmt_over_wmi_tx_drop(struct ath11k *ar, struct sk_buff *skb)
5404{
5405 int num_mgmt;
5406
5407 ieee80211_free_txskb(ar->hw, skb);
5408
5409 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5410
5411 if (num_mgmt < 0)
5412 WARN_ON_ONCE(1);
5413
5414 if (!num_mgmt)
5415 wake_up(&ar->txmgmt_empty_waitq);
5416}
5417
a93789ae 5418static void ath11k_mac_tx_mgmt_free(struct ath11k *ar, int buf_id)
d5c65159 5419{
a93789ae 5420 struct sk_buff *msdu;
52b776fa 5421 struct ieee80211_tx_info *info;
d5c65159
KV		 5422
5423 spin_lock_bh(&ar->txmgmt_idr_lock);
a93789ae 5424 msdu = idr_remove(&ar->txmgmt_idr, buf_id);
d5c65159 5425 spin_unlock_bh(&ar->txmgmt_idr_lock);
a93789ae
S		 5426
5427 if (!msdu)
5428 return;
5429
5430 dma_unmap_single(ar->ab->dev, ATH11K_SKB_CB(msdu)->paddr, msdu->len,
d5c65159
KV		 5431 DMA_TO_DEVICE);
5432
5433 info = IEEE80211_SKB_CB(msdu);
5434 memset(&info->status, 0, sizeof(info->status));
5435
dddaa64d 5436 ath11k_mgmt_over_wmi_tx_drop(ar, msdu);
a93789ae
S		 5437}
5438
5439int ath11k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
5440{
5441 struct ath11k *ar = ctx;
5442
5443 ath11k_mac_tx_mgmt_free(ar, buf_id);
d5c65159
KV		 5444
5445 return 0;
5446}
5447
5448static int ath11k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
5449{
5450 struct ieee80211_vif *vif = ctx;
5451 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
d5c65159 5452 struct ath11k *ar = skb_cb->ar;
d5c65159 5453
a93789ae
S		 5454 if (skb_cb->vif == vif)
5455 ath11k_mac_tx_mgmt_free(ar, buf_id);
d5c65159
KV		 5456
5457 return 0;
5458}
5459
5460static int ath11k_mac_mgmt_tx_wmi(struct ath11k *ar, struct ath11k_vif *arvif,
5461 struct sk_buff *skb)
5462{
5463 struct ath11k_base *ab = ar->ab;
5464 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
e7f33e0c 5465 struct ieee80211_tx_info *info;
d5c65159
KV		 5466 dma_addr_t paddr;
5467 int buf_id;
5468 int ret;
5469
a93789ae
S		 5470 ATH11K_SKB_CB(skb)->ar = ar;
5471
d5c65159
KV		 5472 spin_lock_bh(&ar->txmgmt_idr_lock);
5473 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
5474 ATH11K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
5475 spin_unlock_bh(&ar->txmgmt_idr_lock);
dddaa64d
WG		 5476
5477 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5478 "mac tx mgmt frame, buf id %d\n", buf_id);
5479
d5c65159
KV		 5480 if (buf_id < 0)
5481 return -ENOSPC;
5482
e7f33e0c 5483 info = IEEE80211_SKB_CB(skb);
cc20ff2c 5484 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
e7f33e0c
JC		 5485 if ((ieee80211_is_action(hdr->frame_control) ||
5486 ieee80211_is_deauth(hdr->frame_control) ||
5487 ieee80211_is_disassoc(hdr->frame_control)) &&
5488 ieee80211_has_protected(hdr->frame_control)) {
5489 skb_put(skb, IEEE80211_CCMP_MIC_LEN);
5490 }
d5c65159
KV		 5491 }
5492
5493 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
5494 if (dma_mapping_error(ab->dev, paddr)) {
5495 ath11k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
5496 ret = -EIO;
5497 goto err_free_idr;
5498 }
5499
5500 ATH11K_SKB_CB(skb)->paddr = paddr;
5501
5502 ret = ath11k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
5503 if (ret) {
5504 ath11k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
5505 goto err_unmap_buf;
5506 }
5507
5508 return 0;
5509
5510err_unmap_buf:
5511 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr,
5512 skb->len, DMA_TO_DEVICE);
5513err_free_idr:
5514 spin_lock_bh(&ar->txmgmt_idr_lock);
5515 idr_remove(&ar->txmgmt_idr, buf_id);
5516 spin_unlock_bh(&ar->txmgmt_idr_lock);
5517
5518 return ret;
5519}
5520
5521static void ath11k_mgmt_over_wmi_tx_purge(struct ath11k *ar)
5522{
5523 struct sk_buff *skb;
5524
5525 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
dddaa64d 5526 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
d5c65159
KV		 5527}
5528
5529static void ath11k_mgmt_over_wmi_tx_work(struct work_struct *work)
5530{
5531 struct ath11k *ar = container_of(work, struct ath11k, wmi_mgmt_tx_work);
f4d291b4 5532 struct ath11k_skb_cb *skb_cb;
d5c65159
KV		 5533 struct ath11k_vif *arvif;
5534 struct sk_buff *skb;
5535 int ret;
5536
5537 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
f4d291b4
SE		 5538 skb_cb = ATH11K_SKB_CB(skb);
5539 if (!skb_cb->vif) {
5540 ath11k_warn(ar->ab, "no vif found for mgmt frame\n");
dddaa64d 5541 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
66307ca0
SM		 5542 continue;
5543 }
5544
f4d291b4 5545 arvif = ath11k_vif_to_arvif(skb_cb->vif);
66307ca0
SM		 5546 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id) &&
5547 arvif->is_started) {
5548 ret = ath11k_mac_mgmt_tx_wmi(ar, arvif, skb);
5549 if (ret) {
5550 ath11k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
5551 arvif->vdev_id, ret);
dddaa64d
WG		 5552 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
5553 } else {
5554 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
5555 "mac tx mgmt frame, vdev_id %d\n",
5556 arvif->vdev_id);
66307ca0 5557 }
d5c65159 5558 } else {
66307ca0 5559 ath11k_warn(ar->ab,
f4d291b4
SE		 5560 "dropping mgmt frame for vdev %d, is_started %d\n",
5561 arvif->vdev_id,
66307ca0 5562 arvif->is_started);
dddaa64d 5563 ath11k_mgmt_over_wmi_tx_drop(ar, skb);
d5c65159
KV		 5564 }
5565 }
5566}
5567
5568static int ath11k_mac_mgmt_tx(struct ath11k *ar, struct sk_buff *skb,
5569 bool is_prb_rsp)
5570{
5571 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
5572
5573 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
5574 return -ESHUTDOWN;
5575
5576 /* Drop probe response packets when the pending management tx
5577 * count has reached a certain threshold, so as to prioritize
5578 * other mgmt packets like auth and assoc to be sent on time
5579 * for establishing successful connections.
5580 */
5581 if (is_prb_rsp &&
5582 atomic_read(&ar->num_pending_mgmt_tx) > ATH11K_PRB_RSP_DROP_THRESHOLD) {
5583 ath11k_warn(ar->ab,
5584 "dropping probe response as pending queue is almost full\n");
5585 return -ENOSPC;
5586 }
5587
3808a180 5588 if (skb_queue_len_lockless(q) >= ATH11K_TX_MGMT_NUM_PENDING_MAX) {
d5c65159
KV		 5589 ath11k_warn(ar->ab, "mgmt tx queue is full\n");
5590 return -ENOSPC;
5591 }
5592
5593 skb_queue_tail(q, skb);
dddaa64d 5594 atomic_inc(&ar->num_pending_mgmt_tx);
261b0751 5595 queue_work(ar->ab->workqueue, &ar->wmi_mgmt_tx_work);
d5c65159
KV		 5596
5597 return 0;
5598}
5599
ec038c61
WG		 5600int ath11k_mac_rfkill_config(struct ath11k *ar)
5601{
5602 struct ath11k_base *ab = ar->ab;
5603 u32 param;
5604 int ret;
5605
5606 if (ab->hw_params.rfkill_pin == 0)
5607 return -EOPNOTSUPP;
5608
5609 ath11k_dbg(ab, ATH11K_DBG_MAC,
5610 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d",
5611 ab->hw_params.rfkill_pin, ab->hw_params.rfkill_cfg,
5612 ab->hw_params.rfkill_on_level);
5613
5614 param = FIELD_PREP(WMI_RFKILL_CFG_RADIO_LEVEL,
5615 ab->hw_params.rfkill_on_level) |
5616 FIELD_PREP(WMI_RFKILL_CFG_GPIO_PIN_NUM,
5617 ab->hw_params.rfkill_pin) |
5618 FIELD_PREP(WMI_RFKILL_CFG_PIN_AS_GPIO,
5619 ab->hw_params.rfkill_cfg);
5620
5621 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_HW_RFKILL_CONFIG,
5622 param, ar->pdev->pdev_id);
5623 if (ret) {
5624 ath11k_warn(ab,
5625 "failed to set rfkill config 0x%x: %d\n",
5626 param, ret);
5627 return ret;
5628 }
5629
5630 return 0;
5631}
5632
5633int ath11k_mac_rfkill_enable_radio(struct ath11k *ar, bool enable)
5634{
5635 enum wmi_rfkill_enable_radio param;
5636 int ret;
5637
5638 if (enable)
5639 param = WMI_RFKILL_ENABLE_RADIO_ON;
5640 else
5641 param = WMI_RFKILL_ENABLE_RADIO_OFF;
5642
5643 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac %d rfkill enable %d",
5644 ar->pdev_idx, param);
5645
5646 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RFKILL_ENABLE,
5647 param, ar->pdev->pdev_id);
5648 if (ret) {
5649 ath11k_warn(ar->ab, "failed to set rfkill enable param %d: %d\n",
5650 param, ret);
5651 return ret;
5652 }
5653
5654 return 0;
5655}
5656
d5c65159
KV		 5657static void ath11k_mac_op_tx(struct ieee80211_hw *hw,
5658 struct ieee80211_tx_control *control,
5659 struct sk_buff *skb)
5660{
e7f33e0c 5661 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
d5c65159
KV		 5662 struct ath11k *ar = hw->priv;
5663 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
5664 struct ieee80211_vif *vif = info->control.vif;
5665 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
5666 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
f4d291b4 5667 struct ieee80211_key_conf *key = info->control.hw_key;
e20cfa3b 5668 struct ath11k_sta *arsta = NULL;
f4d291b4 5669 u32 info_flags = info->flags;
d5c65159
KV		 5670 bool is_prb_rsp;
5671 int ret;
5672
5da7acfe 5673 memset(skb_cb, 0, sizeof(*skb_cb));
f4d291b4
SE		 5674 skb_cb->vif = vif;
5675
5676 if (key) {
5677 skb_cb->cipher = key->cipher;
5678 skb_cb->flags |= ATH11K_SKB_CIPHER_SET;
5679 }
5680
5681 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
e7f33e0c
JC		 5682 skb_cb->flags |= ATH11K_SKB_HW_80211_ENCAP;
5683 } else if (ieee80211_is_mgmt(hdr->frame_control)) {
d5c65159
KV		 5684 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
5685 ret = ath11k_mac_mgmt_tx(ar, skb, is_prb_rsp);
5686 if (ret) {
5687 ath11k_warn(ar->ab, "failed to queue management frame %d\n",
5688 ret);
5689 ieee80211_free_txskb(ar->hw, skb);
5690 }
5691 return;
5692 }
5693
e20cfa3b
KP		 5694 if (control->sta)
5695 arsta = (struct ath11k_sta *)control->sta->drv_priv;
5696
5697 ret = ath11k_dp_tx(ar, arvif, arsta, skb);
bcef57ea 5698 if (unlikely(ret)) {
d5c65159
KV		 5699 ath11k_warn(ar->ab, "failed to transmit frame %d\n", ret);
5700 ieee80211_free_txskb(ar->hw, skb);
5701 }
5702}
5703
5704void ath11k_mac_drain_tx(struct ath11k *ar)
5705{
5706 /* make sure rcu-protected mac80211 tx path itself is drained */
5707 synchronize_net();
5708
5709 cancel_work_sync(&ar->wmi_mgmt_tx_work);
5710 ath11k_mgmt_over_wmi_tx_purge(ar);
5711}
5712
5713static int ath11k_mac_config_mon_status_default(struct ath11k *ar, bool enable)
5714{
5715 struct htt_rx_ring_tlv_filter tlv_filter = {0};
4152e420
CH		 5716 struct ath11k_base *ab = ar->ab;
5717 int i, ret = 0;
d5c65159
KV		 5718 u32 ring_id;
5719
ec48d28b 5720 if (enable) {
d5c65159 5721 tlv_filter = ath11k_mac_mon_status_filter_default;
11af6de4
MK		 5722 if (ath11k_debugfs_rx_filter(ar))
5723 tlv_filter.rx_filter = ath11k_debugfs_rx_filter(ar);
ec48d28b 5724 }
d5c65159 5725
4152e420
CH		 5726 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
5727 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
5728 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
5729 ar->dp.mac_id + i,
5730 HAL_RXDMA_MONITOR_STATUS,
5731 DP_RX_BUFFER_SIZE,
5732 &tlv_filter);
5733 }
d5c65159 5734
840c36fa
CH		 5735 if (enable && !ar->ab->hw_params.rxdma1_enable)
5736 mod_timer(&ar->ab->mon_reap_timer, jiffies +
5737 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
5738
4152e420 5739 return ret;
d5c65159
KV		 5740}
5741
38194f3a
WG		 5742static void ath11k_mac_wait_reconfigure(struct ath11k_base *ab)
5743{
5744 int recovery_start_count;
5745
5746 if (!ab->is_reset)
5747 return;
5748
5749 recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
5750 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
5751
5752 if (recovery_start_count == ab->num_radios) {
5753 complete(&ab->recovery_start);
5754 ath11k_dbg(ab, ATH11K_DBG_MAC, "recovery started success\n");
5755 }
5756
5757 ath11k_dbg(ab, ATH11K_DBG_MAC, "waiting reconfigure...\n");
5758
5759 wait_for_completion_timeout(&ab->reconfigure_complete,
5760 ATH11K_RECONFIGURE_TIMEOUT_HZ);
5761}
5762
d5c65159
KV		 5763static int ath11k_mac_op_start(struct ieee80211_hw *hw)
5764{
5765 struct ath11k *ar = hw->priv;
5766 struct ath11k_base *ab = ar->ab;
5767 struct ath11k_pdev *pdev = ar->pdev;
5768 int ret;
5769
5770 ath11k_mac_drain_tx(ar);
5771 mutex_lock(&ar->conf_mutex);
5772
5773 switch (ar->state) {
5774 case ATH11K_STATE_OFF:
5775 ar->state = ATH11K_STATE_ON;
5776 break;
5777 case ATH11K_STATE_RESTARTING:
5778 ar->state = ATH11K_STATE_RESTARTED;
38194f3a 5779 ath11k_mac_wait_reconfigure(ab);
d5c65159
KV		 5780 break;
5781 case ATH11K_STATE_RESTARTED:
5782 case ATH11K_STATE_WEDGED:
5783 case ATH11K_STATE_ON:
5784 WARN_ON(1);
5785 ret = -EINVAL;
5786 goto err;
5787 }
5788
5789 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
5790 1, pdev->pdev_id);
5791
5792 if (ret) {
5793 ath11k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
5794 goto err;
5795 }
5796
5797 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
5798 pdev->pdev_id);
5799 if (ret) {
5800 ath11k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
5801 goto err;
5802 }
5803
9cbd7fc9
CH		 5804 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
5805 ret = ath11k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
5806 if (ret) {
5807 ath11k_err(ab, "failed to set prob req oui: %i\n", ret);
5808 goto err;
5809 }
5810 }
5811
d5c65159
KV		 5812 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
5813 0, pdev->pdev_id);
5814 if (ret) {
5815 ath11k_err(ab, "failed to set ac override for ARP: %d\n",
5816 ret);
5817 goto err;
5818 }
5819
5820 ret = ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
5821 if (ret) {
5822 ath11k_err(ab, "failed to offload radar detection: %d\n",
5823 ret);
5824 goto err;
5825 }
5826
5827 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
5828 HTT_PPDU_STATS_TAG_DEFAULT);
5829 if (ret) {
5830 ath11k_err(ab, "failed to req ppdu stats: %d\n", ret);
5831 goto err;
5832 }
5833
5834 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
5835 1, pdev->pdev_id);
5836
5837 if (ret) {
5838 ath11k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
5839 goto err;
5840 }
5841
5842 __ath11k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5843
5844 /* TODO: Do we need to enable ANI? */
5845
1f682dc9 5846 ath11k_reg_update_chan_list(ar, false);
d5c65159
KV		 5847
5848 ar->num_started_vdevs = 0;
5849 ar->num_created_vdevs = 0;
5850 ar->num_peers = 0;
79c080db 5851 ar->allocated_vdev_map = 0;
d5c65159
KV		 5852
5853 /* Configure monitor status ring with default rx_filter to get rx status
5854 * such as rssi, rx_duration.
5855 */
5856 ret = ath11k_mac_config_mon_status_default(ar, true);
5857 if (ret) {
5858 ath11k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
5859 ret);
5860 goto err;
5861 }
5862
26c79927
S		 5863 /* Configure the hash seed for hash based reo dest ring selection */
5864 ath11k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
5865
c83c500b
CH		 5866 /* allow device to enter IMPS */
5867 if (ab->hw_params.idle_ps) {
5868 ret = ath11k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
5869 1, pdev->pdev_id);
5870 if (ret) {
5871 ath11k_err(ab, "failed to enable idle ps: %d\n", ret);
5872 goto err;
5873 }
5874 }
c202e2eb
DC		 5875
5876 mutex_unlock(&ar->conf_mutex);
5877
5878 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
5879 &ab->pdevs[ar->pdev_idx]);
5880
d5c65159
KV		 5881 return 0;
5882
5883err:
5884 ar->state = ATH11K_STATE_OFF;
5885 mutex_unlock(&ar->conf_mutex);
5886
5887 return ret;
5888}
5889
5890static void ath11k_mac_op_stop(struct ieee80211_hw *hw)
5891{
5892 struct ath11k *ar = hw->priv;
5893 struct htt_ppdu_stats_info *ppdu_stats, *tmp;
5894 int ret;
5895
5896 ath11k_mac_drain_tx(ar);
5897
5898 mutex_lock(&ar->conf_mutex);
5899 ret = ath11k_mac_config_mon_status_default(ar, false);
5900 if (ret)
5901 ath11k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
5902 ret);
5903
5904 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
5905 ar->state = ATH11K_STATE_OFF;
5906 mutex_unlock(&ar->conf_mutex);
5907
5908 cancel_delayed_work_sync(&ar->scan.timeout);
5909 cancel_work_sync(&ar->regd_update_work);
9dcf6808 5910 cancel_work_sync(&ar->ab->update_11d_work);
ec038c61 5911 cancel_work_sync(&ar->ab->rfkill_work);
d5c65159 5912
1f682dc9
WG		 5913 if (ar->state_11d == ATH11K_11D_PREPARING) {
5914 ar->state_11d = ATH11K_11D_IDLE;
5915 complete(&ar->completed_11d_scan);
5916 }
5917
d5c65159
KV		 5918 spin_lock_bh(&ar->data_lock);
5919 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
5920 list_del(&ppdu_stats->list);
5921 kfree(ppdu_stats);
5922 }
5923 spin_unlock_bh(&ar->data_lock);
5924
5925 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
5926
5927 synchronize_rcu();
5928
5929 atomic_set(&ar->num_pending_mgmt_tx, 0);
5930}
5931
5932static void
5933ath11k_mac_setup_vdev_create_params(struct ath11k_vif *arvif,
5934 struct vdev_create_params *params)
5935{
5936 struct ath11k *ar = arvif->ar;
5937 struct ath11k_pdev *pdev = ar->pdev;
5938
5939 params->if_id = arvif->vdev_id;
5940 params->type = arvif->vdev_type;
5941 params->subtype = arvif->vdev_subtype;
5942 params->pdev_id = pdev->pdev_id;
5943
5944 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
5945 params->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
5946 params->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
5947 }
5948 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
5949 params->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
5950 params->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
5951 }
22eeadcd
PKC		 5952 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
5953 ar->supports_6ghz) {
5954 params->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
5955 params->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
5956 }
d5c65159
KV		 5957}
5958
5959static u32
5960ath11k_mac_prepare_he_mode(struct ath11k_pdev *pdev, u32 viftype)
5961{
5962 struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
5963 struct ath11k_band_cap *cap_band = NULL;
5964 u32 *hecap_phy_ptr = NULL;
5965 u32 hemode = 0;
5966
5967 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP)
5968 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
5969 else
5970 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
5971
5972 hecap_phy_ptr = &cap_band->he_cap_phy_info[0];
5973
5974 hemode = FIELD_PREP(HE_MODE_SU_TX_BFEE, HE_SU_BFEE_ENABLE) |
fcaf49d0
JC		 5975 FIELD_PREP(HE_MODE_SU_TX_BFER, HECAP_PHY_SUBFMR_GET(hecap_phy_ptr)) |
5976 FIELD_PREP(HE_MODE_UL_MUMIMO, HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr));
d5c65159
KV		 5977
5978 /* TODO WDS and other modes */
5979 if (viftype == NL80211_IFTYPE_AP) {
5980 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFER,
fcaf49d0
JC		 5981 HECAP_PHY_MUBFMR_GET(hecap_phy_ptr)) |
5982 FIELD_PREP(HE_MODE_DL_OFDMA, HE_DL_MUOFDMA_ENABLE) |
5983 FIELD_PREP(HE_MODE_UL_OFDMA, HE_UL_MUOFDMA_ENABLE);
d5c65159
KV		 5984 } else {
5985 hemode |= FIELD_PREP(HE_MODE_MU_TX_BFEE, HE_MU_BFEE_ENABLE);
5986 }
5987
5988 return hemode;
5989}
5990
5991static int ath11k_set_he_mu_sounding_mode(struct ath11k *ar,
5992 struct ath11k_vif *arvif)
5993{
5994 u32 param_id, param_value;
5995 struct ath11k_base *ab = ar->ab;
5996 int ret = 0;
5997
5998 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE;
5999 param_value = ath11k_mac_prepare_he_mode(ar->pdev, arvif->vif->type);
6000 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6001 param_id, param_value);
6002 if (ret) {
6003 ath11k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n",
6004 arvif->vdev_id, ret, param_value);
6005 return ret;
6006 }
6007 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
6008 param_value =
6009 FIELD_PREP(HE_VHT_SOUNDING_MODE, HE_VHT_SOUNDING_MODE_ENABLE) |
6010 FIELD_PREP(HE_TRIG_NONTRIG_SOUNDING_MODE,
6011 HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE);
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\n",
6016 arvif->vdev_id, ret);
6017 return ret;
6018 }
6019 return ret;
6020}
6021
6aea26ce 6022static void ath11k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
cd19836a 6023 struct ieee80211_vif *vif)
6aea26ce
FF		 6024{
6025 struct ath11k *ar = hw->priv;
6026 struct ath11k_base *ab = ar->ab;
6027 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6028 u32 param_id, param_value;
6029 int ret;
6030
6031 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
6032 if (ath11k_frame_mode != ATH11K_HW_TXRX_ETHERNET ||
6033 (vif->type != NL80211_IFTYPE_STATION &&
6034 vif->type != NL80211_IFTYPE_AP))
2167fa60
S		 6035 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
6036 IEEE80211_OFFLOAD_DECAP_ENABLED);
6aea26ce
FF		 6037
6038 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
6039 param_value = ATH11K_HW_TXRX_ETHERNET;
6040 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6041 param_value = ATH11K_HW_TXRX_RAW;
6042 else
6043 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6044
6045 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6046 param_id, param_value);
6047 if (ret) {
6048 ath11k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
6049 arvif->vdev_id, ret);
6050 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
6051 }
2167fa60
S		 6052
6053 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
6054 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
6055 param_value = ATH11K_HW_TXRX_ETHERNET;
6056 else if (test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags))
6057 param_value = ATH11K_HW_TXRX_RAW;
6058 else
6059 param_value = ATH11K_HW_TXRX_NATIVE_WIFI;
6060
6061 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6062 param_id, param_value);
6063 if (ret) {
6064 ath11k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
6065 arvif->vdev_id, ret);
6066 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
6067 }
6aea26ce
FF		 6068}
6069
9dcf6808
WG		 6070static bool ath11k_mac_vif_ap_active_any(struct ath11k_base *ab)
6071{
6072 struct ath11k *ar;
6073 struct ath11k_pdev *pdev;
6074 struct ath11k_vif *arvif;
6075 int i;
6076
6077 for (i = 0; i < ab->num_radios; i++) {
6078 pdev = &ab->pdevs[i];
6079 ar = pdev->ar;
6080 list_for_each_entry(arvif, &ar->arvifs, list) {
6081 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_AP)
6082 return true;
6083 }
6084 }
6085 return false;
6086}
6087
1f682dc9 6088void ath11k_mac_11d_scan_start(struct ath11k *ar, u32 vdev_id)
9dcf6808
WG		 6089{
6090 struct wmi_11d_scan_start_params param;
6091 int ret;
6092
6093 mutex_lock(&ar->ab->vdev_id_11d_lock);
6094
6095 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac vdev id for 11d scan %d\n",
6096 ar->vdev_id_11d_scan);
6097
6098 if (ar->regdom_set_by_user)
6099 goto fin;
6100
6101 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID)
6102 goto fin;
6103
6104 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6105 goto fin;
6106
6107 if (ath11k_mac_vif_ap_active_any(ar->ab))
6108 goto fin;
6109
6110 param.vdev_id = vdev_id;
6111 param.start_interval_msec = 0;
6112 param.scan_period_msec = ATH11K_SCAN_11D_INTERVAL;
6113
6114 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac start 11d scan\n");
6115
9dcf6808
WG		 6116 ret = ath11k_wmi_send_11d_scan_start_cmd(ar, &param);
6117 if (ret) {
6118 ath11k_warn(ar->ab, "failed to start 11d scan vdev %d ret: %d\n",
6119 vdev_id, ret);
6120 } else {
6121 ar->vdev_id_11d_scan = vdev_id;
1f682dc9
WG		 6122 if (ar->state_11d == ATH11K_11D_PREPARING)
6123 ar->state_11d = ATH11K_11D_RUNNING;
9dcf6808
WG		 6124 }
6125
6126fin:
1f682dc9
WG		 6127 if (ar->state_11d == ATH11K_11D_PREPARING) {
6128 ar->state_11d = ATH11K_11D_IDLE;
6129 complete(&ar->completed_11d_scan);
6130 }
6131
9dcf6808
WG		 6132 mutex_unlock(&ar->ab->vdev_id_11d_lock);
6133}
6134
6135void ath11k_mac_11d_scan_stop(struct ath11k *ar)
6136{
6137 int ret;
6138 u32 vdev_id;
6139
6140 if (!test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ar->ab->wmi_ab.svc_map))
6141 return;
6142
6143 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d scan\n");
6144
6145 mutex_lock(&ar->ab->vdev_id_11d_lock);
6146
6147 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac stop 11d vdev id %d\n",
6148 ar->vdev_id_11d_scan);
6149
6150 if (ar->vdev_id_11d_scan != ATH11K_11D_INVALID_VDEV_ID) {
6151 vdev_id = ar->vdev_id_11d_scan;
6152
6153 ret = ath11k_wmi_send_11d_scan_stop_cmd(ar, vdev_id);
1f682dc9 6154 if (ret) {
9dcf6808
WG		 6155 ath11k_warn(ar->ab,
6156 "failed to stopt 11d scan vdev %d ret: %d\n",
6157 vdev_id, ret);
1f682dc9 6158 } else {
9dcf6808 6159 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
1f682dc9
WG		 6160 ar->state_11d = ATH11K_11D_IDLE;
6161 complete(&ar->completed_11d_scan);
6162 }
9dcf6808
WG		 6163 }
6164 mutex_unlock(&ar->ab->vdev_id_11d_lock);
6165}
6166
6167void ath11k_mac_11d_scan_stop_all(struct ath11k_base *ab)
6168{
6169 struct ath11k *ar;
6170 struct ath11k_pdev *pdev;
6171 int i;
6172
6173 ath11k_dbg(ab, ATH11K_DBG_MAC, "mac stop soc 11d scan\n");
6174
6175 for (i = 0; i < ab->num_radios; i++) {
6176 pdev = &ab->pdevs[i];
6177 ar = pdev->ar;
6178
6179 ath11k_mac_11d_scan_stop(ar);
6180 }
6181}
6182
d5c65159
KV		 6183static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
6184 struct ieee80211_vif *vif)
6185{
6186 struct ath11k *ar = hw->priv;
6187 struct ath11k_base *ab = ar->ab;
6188 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6189 struct vdev_create_params vdev_param = {0};
6190 struct peer_create_params peer_param;
6191 u32 param_id, param_value;
6192 u16 nss;
6193 int i;
4ea03443 6194 int ret, fbret;
d5c65159
KV		 6195 int bit;
6196
6197 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
6198
6199 mutex_lock(&ar->conf_mutex);
6200
6201 if (vif->type == NL80211_IFTYPE_AP &&
6202 ar->num_peers > (ar->max_num_peers - 1)) {
6203 ath11k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
6204 ret = -ENOBUFS;
6205 goto err;
6206 }
6207
523aafd0 6208 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS(ab) - 1)) {
689a5e6f 6209 ath11k_warn(ab, "failed to create vdev %u, reached max vdev limit %d\n",
523aafd0 6210 ar->num_created_vdevs, TARGET_NUM_VDEVS(ab));
d5c65159
KV		 6211 ret = -EBUSY;
6212 goto err;
6213 }
6214
6215 memset(arvif, 0, sizeof(*arvif));
6216
6217 arvif->ar = ar;
6218 arvif->vif = vif;
6219
6220 INIT_LIST_HEAD(&arvif->list);
26f69792
LS		 6221 INIT_DELAYED_WORK(&arvif->connection_loss_work,
6222 ath11k_mac_vif_sta_connection_loss_work);
d5c65159
KV		 6223
6224 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
6225 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
61fe43e7 6226 arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
d5c65159
KV		 6227 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
6228 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
6229 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
6230 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
61fe43e7
MH		 6231 memset(arvif->bitrate_mask.control[i].he_mcs, 0xff,
6232 sizeof(arvif->bitrate_mask.control[i].he_mcs));
d5c65159
KV		 6233 }
6234
6235 bit = __ffs64(ab->free_vdev_map);
6236
6237 arvif->vdev_id = bit;
6238 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
6239
6240 switch (vif->type) {
6241 case NL80211_IFTYPE_UNSPECIFIED:
6242 case NL80211_IFTYPE_STATION:
6243 arvif->vdev_type = WMI_VDEV_TYPE_STA;
6244 break;
6245 case NL80211_IFTYPE_MESH_POINT:
6246 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
0b294aeb 6247 fallthrough;
d5c65159
KV		 6248 case NL80211_IFTYPE_AP:
6249 arvif->vdev_type = WMI_VDEV_TYPE_AP;
6250 break;
6251 case NL80211_IFTYPE_MONITOR:
6252 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
689a5e6f 6253 ar->monitor_vdev_id = bit;
d5c65159
KV		 6254 break;
6255 default:
6256 WARN_ON(1);
6257 break;
6258 }
6259
6260 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n",
6261 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
6262 ab->free_vdev_map);
6263
6264 vif->cab_queue = arvif->vdev_id % (ATH11K_HW_MAX_QUEUES - 1);
6265 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
6266 vif->hw_queue[i] = i % (ATH11K_HW_MAX_QUEUES - 1);
6267
6268 ath11k_mac_setup_vdev_create_params(arvif, &vdev_param);
6269
6270 ret = ath11k_wmi_vdev_create(ar, vif->addr, &vdev_param);
6271 if (ret) {
6272 ath11k_warn(ab, "failed to create WMI vdev %d: %d\n",
6273 arvif->vdev_id, ret);
6274 goto err;
6275 }
6276
6277 ar->num_created_vdevs++;
657680cc
SM		 6278 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
6279 vif->addr, arvif->vdev_id);
79c080db 6280 ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
d5c65159 6281 ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
79c080db 6282
d5c65159
KV		 6283 spin_lock_bh(&ar->data_lock);
6284 list_add(&arvif->list, &ar->arvifs);
6285 spin_unlock_bh(&ar->data_lock);
6286
6aea26ce 6287 ath11k_mac_op_update_vif_offload(hw, vif);
d5c65159
KV		 6288
6289 nss = get_num_chains(ar->cfg_tx_chainmask) ? : 1;
6290 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6291 WMI_VDEV_PARAM_NSS, nss);
6292 if (ret) {
6293 ath11k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
6294 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
6295 goto err_vdev_del;
6296 }
6297
6298 switch (arvif->vdev_type) {
6299 case WMI_VDEV_TYPE_AP:
6300 peer_param.vdev_id = arvif->vdev_id;
6301 peer_param.peer_addr = vif->addr;
6302 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
6303 ret = ath11k_peer_create(ar, arvif, NULL, &peer_param);
6304 if (ret) {
6305 ath11k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
6306 arvif->vdev_id, ret);
6307 goto err_vdev_del;
6308 }
6309
6310 ret = ath11k_mac_set_kickout(arvif);
6311 if (ret) {
6312 ath11k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
6313 arvif->vdev_id, ret);
6314 goto err_peer_del;
6315 }
9dcf6808
WG		 6316
6317 ath11k_mac_11d_scan_stop_all(ar->ab);
d5c65159
KV		 6318 break;
6319 case WMI_VDEV_TYPE_STA:
6320 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
6321 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
6322 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6323 param_id, param_value);
6324 if (ret) {
6325 ath11k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
6326 arvif->vdev_id, ret);
6327 goto err_peer_del;
6328 }
6329
6330 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
6331 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
6332 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6333 param_id, param_value);
6334 if (ret) {
6335 ath11k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
6336 arvif->vdev_id, ret);
6337 goto err_peer_del;
6338 }
6339
6340 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
6341 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
6342 ret = ath11k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
6343 param_id, param_value);
6344 if (ret) {
6345 ath11k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
6346 arvif->vdev_id, ret);
6347 goto err_peer_del;
6348 }
6bfebd4b 6349
af3d8964
KV		 6350 ret = ath11k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id,
6351 WMI_STA_PS_MODE_DISABLED);
6bfebd4b
JC		 6352 if (ret) {
6353 ath11k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
6354 arvif->vdev_id, ret);
6355 goto err_peer_del;
6356 }
9dcf6808 6357
1f682dc9
WG		 6358 if (test_bit(WMI_TLV_SERVICE_11D_OFFLOAD, ab->wmi_ab.svc_map)) {
6359 reinit_completion(&ar->completed_11d_scan);
6360 ar->state_11d = ATH11K_11D_PREPARING;
6361 }
d5c65159 6362 break;
689a5e6f
SM		 6363 case WMI_VDEV_TYPE_MONITOR:
6364 set_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6365 break;
d5c65159
KV		 6366 default:
6367 break;
6368 }
6369
6370 arvif->txpower = vif->bss_conf.txpower;
6371 ret = ath11k_mac_txpower_recalc(ar);
6372 if (ret)
6373 goto err_peer_del;
6374
6375 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6376 param_value = ar->hw->wiphy->rts_threshold;
6377 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6378 param_id, param_value);
6379 if (ret) {
6380 ath11k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
6381 arvif->vdev_id, ret);
6382 }
6383
d5c65159
KV		 6384 ath11k_dp_vdev_tx_attach(ar, arvif);
6385
689a5e6f
SM		 6386 if (vif->type != NL80211_IFTYPE_MONITOR &&
6387 test_bit(ATH11K_FLAG_MONITOR_CONF_ENABLED, &ar->monitor_flags)) {
6388 ret = ath11k_mac_monitor_vdev_create(ar);
6389 if (ret) {
6390 ath11k_warn(ar->ab, "failed to create monitor vdev during add interface: %d",
6391 ret);
6392 goto err_peer_del;
6393 }
6394 }
6395
fe98a613
JC		 6396 ret = ath11k_debugfs_add_interface(arvif);
6397 if (ret)
6398 goto err_peer_del;
6399
d5c65159
KV		 6400 mutex_unlock(&ar->conf_mutex);
6401
6402 return 0;
6403
6404err_peer_del:
6405 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
997dc60f 6406 fbret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
4ea03443 6407 if (fbret) {
997dc60f
KP		 6408 ath11k_warn(ar->ab, "fallback fail to delete peer addr %pM vdev_id %d ret %d\n",
6409 vif->addr, arvif->vdev_id, fbret);
59ec8e2f 6410 goto err;
690ace20 6411 }
d5c65159
KV		 6412 }
6413
6414err_vdev_del:
6415 ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
6416 ar->num_created_vdevs--;
79c080db 6417 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
d5c65159
KV		 6418 ab->free_vdev_map |= 1LL << arvif->vdev_id;
6419 spin_lock_bh(&ar->data_lock);
6420 list_del(&arvif->list);
6421 spin_unlock_bh(&ar->data_lock);
6422
6423err:
fe98a613 6424 ath11k_debugfs_remove_interface(arvif);
d5c65159
KV		 6425 mutex_unlock(&ar->conf_mutex);
6426
6427 return ret;
6428}
6429
6430static int ath11k_mac_vif_unref(int buf_id, void *skb, void *ctx)
6431{
6432 struct ieee80211_vif *vif = (struct ieee80211_vif *)ctx;
6433 struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB((struct sk_buff *)skb);
6434
6435 if (skb_cb->vif == vif)
6436 skb_cb->vif = NULL;
6437
6438 return 0;
6439}
6440
6441static void ath11k_mac_op_remove_interface(struct ieee80211_hw *hw,
6442 struct ieee80211_vif *vif)
6443{
6444 struct ath11k *ar = hw->priv;
6445 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
6446 struct ath11k_base *ab = ar->ab;
3cbbdfbe 6447 unsigned long time_left;
d5c65159
KV		 6448 int ret;
6449 int i;
6450
26f69792
LS		 6451 cancel_delayed_work_sync(&arvif->connection_loss_work);
6452
d5c65159
KV		 6453 mutex_lock(&ar->conf_mutex);
6454
6455 ath11k_dbg(ab, ATH11K_DBG_MAC, "mac remove interface (vdev %d)\n",
6456 arvif->vdev_id);
6457
9dcf6808
WG		 6458 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
6459 ath11k_mac_11d_scan_stop(ar);
6460
d5c65159
KV		 6461 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6462 ret = ath11k_peer_delete(ar, arvif->vdev_id, vif->addr);
6463 if (ret)
6464 ath11k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
6465 arvif->vdev_id, ret);
6466 }
6467
3cbbdfbe
RS		 6468 reinit_completion(&ar->vdev_delete_done);
6469
d5c65159 6470 ret = ath11k_wmi_vdev_delete(ar, arvif->vdev_id);
3cbbdfbe 6471 if (ret) {
d5c65159
KV		 6472 ath11k_warn(ab, "failed to delete WMI vdev %d: %d\n",
6473 arvif->vdev_id, ret);
3cbbdfbe
RS		 6474 goto err_vdev_del;
6475 }
6476
6477 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
6478 ATH11K_VDEV_DELETE_TIMEOUT_HZ);
6479 if (time_left == 0) {
6480 ath11k_warn(ab, "Timeout in receiving vdev delete response\n");
6481 goto err_vdev_del;
6482 }
d5c65159 6483
3cbbdfbe
RS		 6484 ab->free_vdev_map |= 1LL << (arvif->vdev_id);
6485 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
d5c65159 6486 ar->num_created_vdevs--;
3cbbdfbe 6487
657680cc
SM		 6488 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
6489 vif->addr, arvif->vdev_id);
3cbbdfbe 6490
689a5e6f
SM		 6491 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6492 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
6493 ar->monitor_vdev_id = -1;
6494 } else if (test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags) &&
6495 !test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
6496 ret = ath11k_mac_monitor_vdev_delete(ar);
6497 if (ret)
6498 /* continue even if there's an error */
6499 ath11k_warn(ar->ab, "failed to delete vdev monitor during remove interface: %d",
6500 ret);
6501 }
6502
3cbbdfbe
RS		 6503err_vdev_del:
6504 spin_lock_bh(&ar->data_lock);
6505 list_del(&arvif->list);
6506 spin_unlock_bh(&ar->data_lock);
d5c65159
KV		 6507
6508 ath11k_peer_cleanup(ar, arvif->vdev_id);
6509
6510 idr_for_each(&ar->txmgmt_idr,
6511 ath11k_mac_vif_txmgmt_idr_remove, vif);
6512
31582373 6513 for (i = 0; i < ab->hw_params.max_tx_ring; i++) {
d5c65159
KV		 6514 spin_lock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6515 idr_for_each(&ab->dp.tx_ring[i].txbuf_idr,
6516 ath11k_mac_vif_unref, vif);
6517 spin_unlock_bh(&ab->dp.tx_ring[i].tx_idr_lock);
6518 }
6519
6520 /* Recalc txpower for remaining vdev */
6521 ath11k_mac_txpower_recalc(ar);
d5c65159 6522
fe98a613
JC		 6523 ath11k_debugfs_remove_interface(arvif);
6524
d5c65159
KV		 6525 /* TODO: recal traffic pause state based on the available vdevs */
6526
6527 mutex_unlock(&ar->conf_mutex);
6528}
6529
6530/* FIXME: Has to be verified. */
6531#define SUPPORTED_FILTERS \
6532 (FIF_ALLMULTI | \
6533 FIF_CONTROL | \
6534 FIF_PSPOLL | \
6535 FIF_OTHER_BSS | \
6536 FIF_BCN_PRBRESP_PROMISC | \
6537 FIF_PROBE_REQ | \
6538 FIF_FCSFAIL)
6539
6540static void ath11k_mac_op_configure_filter(struct ieee80211_hw *hw,
6541 unsigned int changed_flags,
6542 unsigned int *total_flags,
6543 u64 multicast)
6544{
6545 struct ath11k *ar = hw->priv;
d5c65159
KV		 6546
6547 mutex_lock(&ar->conf_mutex);
6548
d5c65159
KV		 6549 *total_flags &= SUPPORTED_FILTERS;
6550 ar->filter_flags = *total_flags;
6551
d5c65159
KV		 6552 mutex_unlock(&ar->conf_mutex);
6553}
6554
6555static int ath11k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
6556{
6557 struct ath11k *ar = hw->priv;
6558
6559 mutex_lock(&ar->conf_mutex);
6560
6561 *tx_ant = ar->cfg_tx_chainmask;
6562 *rx_ant = ar->cfg_rx_chainmask;
6563
6564 mutex_unlock(&ar->conf_mutex);
6565
6566 return 0;
6567}
6568
6569static int ath11k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
6570{
6571 struct ath11k *ar = hw->priv;
6572 int ret;
6573
6574 mutex_lock(&ar->conf_mutex);
6575 ret = __ath11k_set_antenna(ar, tx_ant, rx_ant);
6576 mutex_unlock(&ar->conf_mutex);
6577
6578 return ret;
6579}
6580
6581static int ath11k_mac_op_ampdu_action(struct ieee80211_hw *hw,
6582 struct ieee80211_vif *vif,
6583 struct ieee80211_ampdu_params *params)
6584{
6585 struct ath11k *ar = hw->priv;
6586 int ret = -EINVAL;
6587
6588 mutex_lock(&ar->conf_mutex);
6589
6590 switch (params->action) {
6591 case IEEE80211_AMPDU_RX_START:
6592 ret = ath11k_dp_rx_ampdu_start(ar, params);
6593 break;
6594 case IEEE80211_AMPDU_RX_STOP:
6595 ret = ath11k_dp_rx_ampdu_stop(ar, params);
6596 break;
6597 case IEEE80211_AMPDU_TX_START:
6598 case IEEE80211_AMPDU_TX_STOP_CONT:
6599 case IEEE80211_AMPDU_TX_STOP_FLUSH:
6600 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6601 case IEEE80211_AMPDU_TX_OPERATIONAL:
6602 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
6603 * Tx aggregation requests.
6604 */
6605 ret = -EOPNOTSUPP;
6606 break;
6607 }
6608
6609 mutex_unlock(&ar->conf_mutex);
6610
6611 return ret;
6612}
6613
6614static int ath11k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6615 struct ieee80211_chanctx_conf *ctx)
6616{
6617 struct ath11k *ar = hw->priv;
6618 struct ath11k_base *ab = ar->ab;
6619
6620 ath11k_dbg(ab, ATH11K_DBG_MAC,
bb2d2dfd 6621 "mac chanctx add freq %u width %d ptr %pK\n",
d5c65159
KV		 6622 ctx->def.chan->center_freq, ctx->def.width, ctx);
6623
6624 mutex_lock(&ar->conf_mutex);
6625
6626 spin_lock_bh(&ar->data_lock);
6627 /* TODO: In case of multiple channel context, populate rx_channel from
6628 * Rx PPDU desc information.
6629 */
6630 ar->rx_channel = ctx->def.chan;
6631 spin_unlock_bh(&ar->data_lock);
6632
6633 mutex_unlock(&ar->conf_mutex);
6634
6635 return 0;
6636}
6637
6638static void ath11k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6639 struct ieee80211_chanctx_conf *ctx)
6640{
6641 struct ath11k *ar = hw->priv;
6642 struct ath11k_base *ab = ar->ab;
6643
6644 ath11k_dbg(ab, ATH11K_DBG_MAC,
bb2d2dfd 6645 "mac chanctx remove freq %u width %d ptr %pK\n",
d5c65159
KV		 6646 ctx->def.chan->center_freq, ctx->def.width, ctx);
6647
6648 mutex_lock(&ar->conf_mutex);
6649
6650 spin_lock_bh(&ar->data_lock);
6651 /* TODO: In case of there is one more channel context left, populate
6652 * rx_channel with the channel of that remaining channel context.
6653 */
6654 ar->rx_channel = NULL;
6655 spin_unlock_bh(&ar->data_lock);
6656
6657 mutex_unlock(&ar->conf_mutex);
6658}
6659
d5c65159
KV		 6660static int
6661ath11k_mac_vdev_start_restart(struct ath11k_vif *arvif,
4f6dd923 6662 struct ieee80211_chanctx_conf *ctx,
d5c65159
KV		 6663 bool restart)
6664{
6665 struct ath11k *ar = arvif->ar;
6666 struct ath11k_base *ab = ar->ab;
6667 struct wmi_vdev_start_req_arg arg = {};
4f6dd923 6668 const struct cfg80211_chan_def *chandef = &ctx->def;
d5c65159
KV		 6669 int he_support = arvif->vif->bss_conf.he_support;
6670 int ret = 0;
6671
6672 lockdep_assert_held(&ar->conf_mutex);
6673
6674 reinit_completion(&ar->vdev_setup_done);
6675
6676 arg.vdev_id = arvif->vdev_id;
6677 arg.dtim_period = arvif->dtim_period;
6678 arg.bcn_intval = arvif->beacon_interval;
6679
6680 arg.channel.freq = chandef->chan->center_freq;
6681 arg.channel.band_center_freq1 = chandef->center_freq1;
6682 arg.channel.band_center_freq2 = chandef->center_freq2;
6683 arg.channel.mode =
6684 ath11k_phymodes[chandef->chan->band][chandef->width];
6685
6686 arg.channel.min_power = 0;
9212c1b9
P		 6687 arg.channel.max_power = chandef->chan->max_power;
6688 arg.channel.max_reg_power = chandef->chan->max_reg_power;
6689 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
d5c65159
KV		 6690
6691 arg.pref_tx_streams = ar->num_tx_chains;
6692 arg.pref_rx_streams = ar->num_rx_chains;
6693
6694 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6695 arg.ssid = arvif->u.ap.ssid;
6696 arg.ssid_len = arvif->u.ap.ssid_len;
6697 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
6698
6699 /* For now allow DFS for AP mode */
6700 arg.channel.chan_radar =
6701 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
6702
4f6dd923 6703 arg.channel.freq2_radar = ctx->radar_enabled;
788f805e 6704
d5c65159
KV		 6705 arg.channel.passive = arg.channel.chan_radar;
6706
6707 spin_lock_bh(&ab->base_lock);
6708 arg.regdomain = ar->ab->dfs_region;
6709 spin_unlock_bh(&ab->base_lock);
6710
d5c65159
KV		 6711 if (he_support) {
6712 ret = ath11k_set_he_mu_sounding_mode(ar, arvif);
6713 if (ret) {
6714 ath11k_warn(ar->ab, "failed to set he mode vdev %i\n",
6715 arg.vdev_id);
6716 return ret;
6717 }
6718 }
6719 }
6720
6721 arg.channel.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
6722
6723 ath11k_dbg(ab, ATH11K_DBG_MAC,
6724 "mac vdev %d start center_freq %d phymode %s\n",
6725 arg.vdev_id, arg.channel.freq,
6726 ath11k_wmi_phymode_str(arg.channel.mode));
6727
6728 ret = ath11k_wmi_vdev_start(ar, &arg, restart);
6729 if (ret) {
6730 ath11k_warn(ar->ab, "failed to %s WMI vdev %i\n",
6731 restart ? "restart" : "start", arg.vdev_id);
6732 return ret;
6733 }
6734
6735 ret = ath11k_mac_vdev_setup_sync(ar);
6736 if (ret) {
6737 ath11k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
6738 arg.vdev_id, restart ? "restart" : "start", ret);
6739 return ret;
6740 }
6741
689a5e6f
SM		 6742 if (!restart)
6743 ar->num_started_vdevs++;
6744
657680cc
SM		 6745 ath11k_dbg(ab, ATH11K_DBG_MAC, "vdev %pM started, vdev_id %d\n",
6746 arvif->vif->addr, arvif->vdev_id);
d5c65159
KV		 6747
6748 /* Enable CAC Flag in the driver by checking the channel DFS cac time,
6749 * i.e dfs_cac_ms value which will be valid only for radar channels
6750 * and state as NL80211_DFS_USABLE which indicates CAC needs to be
6751 * done before channel usage. This flags is used to drop rx packets.
6752 * during CAC.
6753 */
6754 /* TODO Set the flag for other interface types as required */
6755 if (arvif->vdev_type == WMI_VDEV_TYPE_AP &&
6756 chandef->chan->dfs_cac_ms &&
6757 chandef->chan->dfs_state == NL80211_DFS_USABLE) {
6758 set_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6759 ath11k_dbg(ab, ATH11K_DBG_MAC,
6760 "CAC Started in chan_freq %d for vdev %d\n",
6761 arg.channel.freq, arg.vdev_id);
6762 }
6763
5815719d
BP		 6764 ret = ath11k_mac_set_txbf_conf(arvif);
6765 if (ret)
6766 ath11k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
6767 arvif->vdev_id, ret);
6768
d5c65159
KV		 6769 return 0;
6770}
6771
6772static int ath11k_mac_vdev_stop(struct ath11k_vif *arvif)
6773{
6774 struct ath11k *ar = arvif->ar;
6775 int ret;
6776
6777 lockdep_assert_held(&ar->conf_mutex);
6778
6779 reinit_completion(&ar->vdev_setup_done);
6780
d5c65159
KV		 6781 ret = ath11k_wmi_vdev_stop(ar, arvif->vdev_id);
6782 if (ret) {
6783 ath11k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
6784 arvif->vdev_id, ret);
6785 goto err;
6786 }
6787
6788 ret = ath11k_mac_vdev_setup_sync(ar);
6789 if (ret) {
6790 ath11k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
6791 arvif->vdev_id, ret);
6792 goto err;
6793 }
6794
6795 WARN_ON(ar->num_started_vdevs == 0);
6796
6797 ar->num_started_vdevs--;
657680cc
SM		 6798 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
6799 arvif->vif->addr, arvif->vdev_id);
d5c65159
KV		 6800
6801 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
6802 clear_bit(ATH11K_CAC_RUNNING, &ar->dev_flags);
6803 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "CAC Stopped for vdev %d\n",
6804 arvif->vdev_id);
6805 }
6806
6807 return 0;
6808err:
d5c65159
KV		 6809 return ret;
6810}
6811
6812static int ath11k_mac_vdev_start(struct ath11k_vif *arvif,
4f6dd923 6813 struct ieee80211_chanctx_conf *ctx)
d5c65159 6814{
4f6dd923 6815 return ath11k_mac_vdev_start_restart(arvif, ctx, false);
d5c65159
KV		 6816}
6817
6818static int ath11k_mac_vdev_restart(struct ath11k_vif *arvif,
4f6dd923 6819 struct ieee80211_chanctx_conf *ctx)
d5c65159 6820{
4f6dd923 6821 return ath11k_mac_vdev_start_restart(arvif, ctx, true);
d5c65159
KV		 6822}
6823
6824struct ath11k_mac_change_chanctx_arg {
6825 struct ieee80211_chanctx_conf *ctx;
6826 struct ieee80211_vif_chanctx_switch *vifs;
6827 int n_vifs;
6828 int next_vif;
6829};
6830
6831static void
6832ath11k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6833 struct ieee80211_vif *vif)
6834{
6835 struct ath11k_mac_change_chanctx_arg *arg = data;
6836
6837 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6838 return;
6839
6840 arg->n_vifs++;
6841}
6842
6843static void
6844ath11k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6845 struct ieee80211_vif *vif)
6846{
6847 struct ath11k_mac_change_chanctx_arg *arg = data;
6848 struct ieee80211_chanctx_conf *ctx;
6849
6850 ctx = rcu_access_pointer(vif->chanctx_conf);
6851 if (ctx != arg->ctx)
6852 return;
6853
6854 if (WARN_ON(arg->next_vif == arg->n_vifs))
6855 return;
6856
6857 arg->vifs[arg->next_vif].vif = vif;
6858 arg->vifs[arg->next_vif].old_ctx = ctx;
6859 arg->vifs[arg->next_vif].new_ctx = ctx;
6860 arg->next_vif++;
6861}
6862
6863static void
6864ath11k_mac_update_vif_chan(struct ath11k *ar,
6865 struct ieee80211_vif_chanctx_switch *vifs,
6866 int n_vifs)
6867{
6868 struct ath11k_base *ab = ar->ab;
6869 struct ath11k_vif *arvif;
6870 int ret;
6871 int i;
689a5e6f 6872 bool monitor_vif = false;
d5c65159
KV		 6873
6874 lockdep_assert_held(&ar->conf_mutex);
6875
a4146249 6876 /* Associated channel resources of all relevant vdevs
d5c65159
KV		 6877 * should be available for the channel switch now.
6878 */
6879
6880 /* TODO: Update ar->rx_channel */
6881
6882 for (i = 0; i < n_vifs; i++) {
6883 arvif = (void *)vifs[i].vif->drv_priv;
6884
6885 if (WARN_ON(!arvif->is_started))
6886 continue;
6887
5ed98fb7
VN		 6888 /* change_chanctx can be called even before vdev_up from
6889 * ieee80211_start_ap->ieee80211_vif_use_channel->
6890 * ieee80211_recalc_radar_chanctx.
6891 *
6892 * Firmware expect vdev_restart only if vdev is up.
6893 * If vdev is down then it expect vdev_stop->vdev_start.
6894 */
6895 if (arvif->is_up) {
4f6dd923 6896 ret = ath11k_mac_vdev_restart(arvif, vifs[i].new_ctx);
5ed98fb7
VN		 6897 if (ret) {
6898 ath11k_warn(ab, "failed to restart vdev %d: %d\n",
6899 arvif->vdev_id, ret);
6900 continue;
6901 }
6902 } else {
6903 ret = ath11k_mac_vdev_stop(arvif);
6904 if (ret) {
6905 ath11k_warn(ab, "failed to stop vdev %d: %d\n",
6906 arvif->vdev_id, ret);
6907 continue;
6908 }
6909
4f6dd923 6910 ret = ath11k_mac_vdev_start(arvif, vifs[i].new_ctx);
5ed98fb7
VN		 6911 if (ret)
6912 ath11k_warn(ab, "failed to start vdev %d: %d\n",
6913 arvif->vdev_id, ret);
d5c65159 6914
d5c65159
KV		 6915 continue;
6916 }
6917
979ebc54
SM		 6918 ret = ath11k_mac_setup_bcn_tmpl(arvif);
6919 if (ret)
6920 ath11k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
6921 ret);
6922
d5c65159
KV		 6923 ret = ath11k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6924 arvif->bssid);
6925 if (ret) {
6926 ath11k_warn(ab, "failed to bring vdev up %d: %d\n",
6927 arvif->vdev_id, ret);
6928 continue;
6929 }
6930 }
689a5e6f
SM		 6931
6932 /* Restart the internal monitor vdev on new channel */
6933 if (!monitor_vif &&
6934 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
6935 ret = ath11k_mac_monitor_stop(ar);
6936 if (ret) {
6937 ath11k_warn(ar->ab, "failed to stop monitor during vif channel update: %d",
6938 ret);
6939 return;
6940 }
6941
6942 ret = ath11k_mac_monitor_start(ar);
6943 if (ret) {
6944 ath11k_warn(ar->ab, "failed to start monitor during vif channel update: %d",
6945 ret);
6946 return;
6947 }
6948 }
d5c65159
KV		 6949}
6950
6951static void
6952ath11k_mac_update_active_vif_chan(struct ath11k *ar,
6953 struct ieee80211_chanctx_conf *ctx)
6954{
6955 struct ath11k_mac_change_chanctx_arg arg = { .ctx = ctx };
6956
6957 lockdep_assert_held(&ar->conf_mutex);
6958
6959 ieee80211_iterate_active_interfaces_atomic(ar->hw,
6960 IEEE80211_IFACE_ITER_NORMAL,
6961 ath11k_mac_change_chanctx_cnt_iter,
6962 &arg);
6963 if (arg.n_vifs == 0)
6964 return;
6965
6966 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
6967 if (!arg.vifs)
6968 return;
6969
6970 ieee80211_iterate_active_interfaces_atomic(ar->hw,
6971 IEEE80211_IFACE_ITER_NORMAL,
6972 ath11k_mac_change_chanctx_fill_iter,
6973 &arg);
6974
6975 ath11k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6976
6977 kfree(arg.vifs);
6978}
6979
6980static void ath11k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6981 struct ieee80211_chanctx_conf *ctx,
6982 u32 changed)
6983{
6984 struct ath11k *ar = hw->priv;
6985 struct ath11k_base *ab = ar->ab;
6986
6987 mutex_lock(&ar->conf_mutex);
6988
6989 ath11k_dbg(ab, ATH11K_DBG_MAC,
bb2d2dfd 6990 "mac chanctx change freq %u width %d ptr %pK changed %x\n",
d5c65159
KV		 6991 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6992
6993 /* This shouldn't really happen because channel switching should use
6994 * switch_vif_chanctx().
6995 */
6996 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6997 goto unlock;
6998
4f6dd923
VN		 6999 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH ||
7000 changed & IEEE80211_CHANCTX_CHANGE_RADAR)
d5c65159
KV		 7001 ath11k_mac_update_active_vif_chan(ar, ctx);
7002
7003 /* TODO: Recalc radar detection */
7004
7005unlock:
7006 mutex_unlock(&ar->conf_mutex);
7007}
7008
e7495035
CH		 7009static int ath11k_start_vdev_delay(struct ieee80211_hw *hw,
7010 struct ieee80211_vif *vif)
7011{
7012 struct ath11k *ar = hw->priv;
7013 struct ath11k_base *ab = ar->ab;
7014 struct ath11k_vif *arvif = (void *)vif->drv_priv;
7015 int ret;
7016
7017 if (WARN_ON(arvif->is_started))
7018 return -EBUSY;
7019
4f6dd923 7020 ret = ath11k_mac_vdev_start(arvif, &arvif->chanctx);
e7495035
CH		 7021 if (ret) {
7022 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7023 arvif->vdev_id, vif->addr,
7024 arvif->chanctx.def.chan->center_freq, ret);
7025 return ret;
7026 }
7027
dc7ff756
BQ		 7028 /* Reconfigure hardware rate code since it is cleared by firmware.
7029 */
7030 if (ar->hw_rate_code > 0) {
7031 u32 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
7032
7033 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
7034 ar->hw_rate_code);
7035 if (ret) {
7036 ath11k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
7037 return ret;
7038 }
7039 }
7040
e7495035 7041 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
689a5e6f 7042 ret = ath11k_wmi_vdev_up(ar, arvif->vdev_id, 0, ar->mac_addr);
e7495035
CH		 7043 if (ret) {
7044 ath11k_warn(ab, "failed put monitor up: %d\n", ret);
7045 return ret;
7046 }
7047 }
7048
7049 arvif->is_started = true;
7050
7051 /* TODO: Setup ps and cts/rts protection */
7052 return 0;
7053}
7054
d5c65159
KV		 7055static int
7056ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
7057 struct ieee80211_vif *vif,
7058 struct ieee80211_chanctx_conf *ctx)
7059{
7060 struct ath11k *ar = hw->priv;
7061 struct ath11k_base *ab = ar->ab;
7062 struct ath11k_vif *arvif = (void *)vif->drv_priv;
7063 int ret;
701e48a4 7064 struct peer_create_params param;
d5c65159
KV		 7065
7066 mutex_lock(&ar->conf_mutex);
7067
7068 ath11k_dbg(ab, ATH11K_DBG_MAC,
7069 "mac chanctx assign ptr %pK vdev_id %i\n",
7070 ctx, arvif->vdev_id);
7071
e7495035 7072 /* for QCA6390 bss peer must be created before vdev_start */
b0919924 7073 if (ab->hw_params.vdev_start_delay &&
701e48a4 7074 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
aa44b2f3
CH		 7075 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7076 !ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
e7495035 7077 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
c134d1f8
AD		 7078 ret = 0;
7079 goto out;
e7495035
CH		 7080 }
7081
d5c65159 7082 if (WARN_ON(arvif->is_started)) {
c134d1f8
AD		 7083 ret = -EBUSY;
7084 goto out;
d5c65159
KV		 7085 }
7086
aa44b2f3 7087 if (ab->hw_params.vdev_start_delay &&
77d7e871
KV		 7088 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
7089 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
701e48a4
CH		 7090 param.vdev_id = arvif->vdev_id;
7091 param.peer_type = WMI_PEER_TYPE_DEFAULT;
7092 param.peer_addr = ar->mac_addr;
c134d1f8 7093
701e48a4 7094 ret = ath11k_peer_create(ar, arvif, NULL, &param);
c134d1f8
AD		 7095 if (ret) {
7096 ath11k_warn(ab, "failed to create peer after vdev start delay: %d",
7097 ret);
7098 goto out;
7099 }
701e48a4
CH		 7100 }
7101
689a5e6f
SM		 7102 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7103 ret = ath11k_mac_monitor_start(ar);
7104 if (ret) {
7105 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7106 ret);
7107 goto out;
7108 }
7109
7110 arvif->is_started = true;
7111 goto out;
7112 }
7113
4f6dd923 7114 ret = ath11k_mac_vdev_start(arvif, ctx);
d5c65159
KV		 7115 if (ret) {
7116 ath11k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
7117 arvif->vdev_id, vif->addr,
7118 ctx->def.chan->center_freq, ret);
c134d1f8 7119 goto out;
d5c65159 7120 }
d5c65159
KV		 7121
7122 arvif->is_started = true;
7123
689a5e6f
SM		 7124 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7125 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7126 ret = ath11k_mac_monitor_start(ar);
7127 if (ret) {
7128 ath11k_warn(ar->ab, "failed to start monitor during vif channel context assignment: %d",
7129 ret);
7130 goto out;
7131 }
7132 }
7133
d5c65159
KV		 7134 /* TODO: Setup ps and cts/rts protection */
7135
c134d1f8 7136 ret = 0;
d5c65159 7137
c134d1f8 7138out:
d5c65159
KV		 7139 mutex_unlock(&ar->conf_mutex);
7140
7141 return ret;
7142}
7143
7144static void
7145ath11k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
7146 struct ieee80211_vif *vif,
7147 struct ieee80211_chanctx_conf *ctx)
7148{
7149 struct ath11k *ar = hw->priv;
7150 struct ath11k_base *ab = ar->ab;
7151 struct ath11k_vif *arvif = (void *)vif->drv_priv;
2db80f93 7152 struct ath11k_peer *peer;
d5c65159
KV		 7153 int ret;
7154
7155 mutex_lock(&ar->conf_mutex);
7156
7157 ath11k_dbg(ab, ATH11K_DBG_MAC,
7158 "mac chanctx unassign ptr %pK vdev_id %i\n",
7159 ctx, arvif->vdev_id);
7160
7161 WARN_ON(!arvif->is_started);
7162
701e48a4 7163 if (ab->hw_params.vdev_start_delay &&
2db80f93
ND		 7164 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7165 spin_lock_bh(&ab->base_lock);
7166 peer = ath11k_peer_find_by_addr(ab, ar->mac_addr);
7167 spin_unlock_bh(&ab->base_lock);
7168 if (peer)
7169 ath11k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
7170 }
701e48a4 7171
689a5e6f
SM		 7172 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
7173 ret = ath11k_mac_monitor_stop(ar);
7174 if (ret) {
7175 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7176 ret);
7177 mutex_unlock(&ar->conf_mutex);
7178 return;
7179 }
7180
7181 arvif->is_started = false;
7182 mutex_unlock(&ar->conf_mutex);
7183 return;
7184 }
7185
d5c65159
KV		 7186 ret = ath11k_mac_vdev_stop(arvif);
7187 if (ret)
7188 ath11k_warn(ab, "failed to stop vdev %i: %d\n",
7189 arvif->vdev_id, ret);
7190
7191 arvif->is_started = false;
7192
b4a0f541
WG		 7193 if (ab->hw_params.vdev_start_delay &&
7194 arvif->vdev_type == WMI_VDEV_TYPE_STA) {
7195 ret = ath11k_peer_delete(ar, arvif->vdev_id, arvif->bssid);
7196 if (ret)
7197 ath11k_warn(ar->ab,
7198 "failed to delete peer %pM for vdev %d: %d\n",
7199 arvif->bssid, arvif->vdev_id, ret);
7200 else
7201 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7202 "mac removed peer %pM vdev %d after vdev stop\n",
7203 arvif->bssid, arvif->vdev_id);
7204 }
7205
701e48a4
CH		 7206 if (ab->hw_params.vdev_start_delay &&
7207 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
7208 ath11k_wmi_vdev_down(ar, arvif->vdev_id);
7209
689a5e6f
SM		 7210 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
7211 ar->num_started_vdevs == 1 &&
7212 test_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags)) {
7213 ret = ath11k_mac_monitor_stop(ar);
7214 if (ret)
7215 /* continue even if there's an error */
7216 ath11k_warn(ar->ab, "failed to stop monitor during vif channel context unassignment: %d",
7217 ret);
7218 }
7219
9dcf6808 7220 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
1f682dc9 7221 ath11k_mac_11d_scan_start(ar, arvif->vdev_id);
9dcf6808 7222
d5c65159
KV		 7223 mutex_unlock(&ar->conf_mutex);
7224}
7225
7226static int
7227ath11k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
7228 struct ieee80211_vif_chanctx_switch *vifs,
7229 int n_vifs,
7230 enum ieee80211_chanctx_switch_mode mode)
7231{
7232 struct ath11k *ar = hw->priv;
7233
7234 mutex_lock(&ar->conf_mutex);
7235
7236 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7237 "mac chanctx switch n_vifs %d mode %d\n",
7238 n_vifs, mode);
7239 ath11k_mac_update_vif_chan(ar, vifs, n_vifs);
7240
7241 mutex_unlock(&ar->conf_mutex);
7242
7243 return 0;
7244}
7245
7246static int
7247ath11k_set_vdev_param_to_all_vifs(struct ath11k *ar, int param, u32 value)
7248{
7249 struct ath11k_vif *arvif;
7250 int ret = 0;
7251
7252 mutex_lock(&ar->conf_mutex);
7253 list_for_each_entry(arvif, &ar->arvifs, list) {
7254 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
7255 param, arvif->vdev_id, value);
7256
7257 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7258 param, value);
7259 if (ret) {
7260 ath11k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
7261 param, arvif->vdev_id, ret);
7262 break;
7263 }
7264 }
7265 mutex_unlock(&ar->conf_mutex);
7266 return ret;
7267}
7268
7269/* mac80211 stores device specific RTS/Fragmentation threshold value,
7270 * this is set interface specific to firmware from ath11k driver
7271 */
7272static int ath11k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7273{
7274 struct ath11k *ar = hw->priv;
7275 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
7276
7277 return ath11k_set_vdev_param_to_all_vifs(ar, param_id, value);
7278}
7279
7280static int ath11k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7281{
7282 /* Even though there's a WMI vdev param for fragmentation threshold no
7283 * known firmware actually implements it. Moreover it is not possible to
7284 * rely frame fragmentation to mac80211 because firmware clears the
7285 * "more fragments" bit in frame control making it impossible for remote
7286 * devices to reassemble frames.
7287 *
7288 * Hence implement a dummy callback just to say fragmentation isn't
7289 * supported. This effectively prevents mac80211 from doing frame
7290 * fragmentation in software.
7291 */
7292 return -EOPNOTSUPP;
7293}
7294
ba9177fc 7295static int ath11k_mac_flush_tx_complete(struct ath11k *ar)
d5c65159 7296{
d5c65159 7297 long time_left;
ba9177fc 7298 int ret = 0;
d5c65159
KV		 7299
7300 time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
7301 (atomic_read(&ar->dp.num_tx_pending) == 0),
7302 ATH11K_FLUSH_TIMEOUT);
ba9177fc
CH		 7303 if (time_left == 0) {
7304 ath11k_warn(ar->ab, "failed to flush transmit queue, data pkts pending %d\n",
7305 atomic_read(&ar->dp.num_tx_pending));
7306 ret = -ETIMEDOUT;
7307 }
dddaa64d
WG		 7308
7309 time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
7310 (atomic_read(&ar->num_pending_mgmt_tx) == 0),
7311 ATH11K_FLUSH_TIMEOUT);
ba9177fc
CH		 7312 if (time_left == 0) {
7313 ath11k_warn(ar->ab, "failed to flush mgmt transmit queue, mgmt pkts pending %d\n",
7314 atomic_read(&ar->num_pending_mgmt_tx));
7315 ret = -ETIMEDOUT;
7316 }
dddaa64d 7317
ba9177fc
CH		 7318 return ret;
7319}
7320
7321int ath11k_mac_wait_tx_complete(struct ath11k *ar)
7322{
7323 ath11k_mac_drain_tx(ar);
7324 return ath11k_mac_flush_tx_complete(ar);
7325}
7326
7327static void ath11k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7328 u32 queues, bool drop)
7329{
7330 struct ath11k *ar = hw->priv;
7331
7332 if (drop)
7333 return;
7334
7335 ath11k_mac_flush_tx_complete(ar);
d5c65159
KV		 7336}
7337
7338static int
7339ath11k_mac_bitrate_mask_num_ht_rates(struct ath11k *ar,
7340 enum nl80211_band band,
7341 const struct cfg80211_bitrate_mask *mask)
7342{
7343 int num_rates = 0;
7344 int i;
7345
7346 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
7347 num_rates += hweight16(mask->control[band].ht_mcs[i]);
7348
7349 return num_rates;
7350}
7351
7352static bool
7353ath11k_mac_has_single_legacy_rate(struct ath11k *ar,
7354 enum nl80211_band band,
7355 const struct cfg80211_bitrate_mask *mask)
7356{
7357 int num_rates = 0;
7358
7359 num_rates = hweight32(mask->control[band].legacy);
7360
7361 if (ath11k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
7362 return false;
7363
7364 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
7365 return false;
7366
61fe43e7
MH		 7367 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask))
7368 return false;
7369
d5c65159
KV		 7370 return num_rates == 1;
7371}
7372
61fe43e7
MH		 7373static __le16
7374ath11k_mac_get_tx_mcs_map(const struct ieee80211_sta_he_cap *he_cap)
7375{
7376 if (he_cap->he_cap_elem.phy_cap_info[0] &
7377 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
7378 return he_cap->he_mcs_nss_supp.tx_mcs_80p80;
7379
7380 if (he_cap->he_cap_elem.phy_cap_info[0] &
7381 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
7382 return he_cap->he_mcs_nss_supp.tx_mcs_160;
7383
7384 return he_cap->he_mcs_nss_supp.tx_mcs_80;
7385}
7386
d5c65159
KV		 7387static bool
7388ath11k_mac_bitrate_mask_get_single_nss(struct ath11k *ar,
7389 enum nl80211_band band,
7390 const struct cfg80211_bitrate_mask *mask,
7391 int *nss)
7392{
7393 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
7394 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
61fe43e7 7395 u16 he_mcs_map = 0;
d5c65159
KV		 7396 u8 ht_nss_mask = 0;
7397 u8 vht_nss_mask = 0;
61fe43e7 7398 u8 he_nss_mask = 0;
d5c65159
KV		 7399 int i;
7400
7401 /* No need to consider legacy here. Basic rates are always present
7402 * in bitrate mask
7403 */
7404
7405 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
7406 if (mask->control[band].ht_mcs[i] == 0)
7407 continue;
7408 else if (mask->control[band].ht_mcs[i] ==
7409 sband->ht_cap.mcs.rx_mask[i])
7410 ht_nss_mask |= BIT(i);
7411 else
7412 return false;
7413 }
7414
7415 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
7416 if (mask->control[band].vht_mcs[i] == 0)
7417 continue;
7418 else if (mask->control[band].vht_mcs[i] ==
7419 ath11k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
7420 vht_nss_mask |= BIT(i);
7421 else
7422 return false;
7423 }
7424
61fe43e7
MH		 7425 he_mcs_map = le16_to_cpu(ath11k_mac_get_tx_mcs_map(&sband->iftype_data->he_cap));
7426
7427 for (i = 0; i < ARRAY_SIZE(mask->control[band].he_mcs); i++) {
7428 if (mask->control[band].he_mcs[i] == 0)
7429 continue;
7430
7431 if (mask->control[band].he_mcs[i] ==
7432 ath11k_mac_get_max_he_mcs_map(he_mcs_map, i))
7433 he_nss_mask |= BIT(i);
7434 else
7435 return false;
7436 }
7437
7438 if (ht_nss_mask != vht_nss_mask || ht_nss_mask != he_nss_mask)
d5c65159
KV		 7439 return false;
7440
7441 if (ht_nss_mask == 0)
7442 return false;
7443
7444 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
7445 return false;
7446
7447 *nss = fls(ht_nss_mask);
7448
7449 return true;
7450}
7451
7452static int
7453ath11k_mac_get_single_legacy_rate(struct ath11k *ar,
7454 enum nl80211_band band,
7455 const struct cfg80211_bitrate_mask *mask,
7456 u32 *rate, u8 *nss)
7457{
7458 int rate_idx;
7459 u16 bitrate;
7460 u8 preamble;
7461 u8 hw_rate;
7462
7463 if (hweight32(mask->control[band].legacy) != 1)
7464 return -EINVAL;
7465
7466 rate_idx = ffs(mask->control[band].legacy) - 1;
7467
22eeadcd 7468 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
d5c65159
KV		 7469 rate_idx += ATH11K_MAC_FIRST_OFDM_RATE_IDX;
7470
7471 hw_rate = ath11k_legacy_rates[rate_idx].hw_value;
7472 bitrate = ath11k_legacy_rates[rate_idx].bitrate;
7473
7474 if (ath11k_mac_bitrate_is_cck(bitrate))
7475 preamble = WMI_RATE_PREAMBLE_CCK;
7476 else
7477 preamble = WMI_RATE_PREAMBLE_OFDM;
7478
7479 *nss = 1;
7480 *rate = ATH11K_HW_RATE_CODE(hw_rate, 0, preamble);
7481
7482 return 0;
7483}
7484
61fe43e7
MH		 7485static int
7486ath11k_mac_set_fixed_rate_gi_ltf(struct ath11k_vif *arvif, u8 he_gi, u8 he_ltf)
d5c65159
KV		 7487{
7488 struct ath11k *ar = arvif->ar;
d5c65159
KV		 7489 int ret;
7490
61fe43e7
MH		 7491 /* 0.8 = 0, 1.6 = 2 and 3.2 = 3. */
7492 if (he_gi && he_gi != 0xFF)
7493 he_gi += 1;
d5c65159 7494
61fe43e7
MH		 7495 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7496 WMI_VDEV_PARAM_SGI, he_gi);
7497 if (ret) {
7498 ath11k_warn(ar->ab, "failed to set he gi %d: %d\n",
7499 he_gi, ret);
7500 return ret;
7501 }
7502 /* start from 1 */
7503 if (he_ltf != 0xFF)
7504 he_ltf += 1;
d5c65159 7505
d5c65159 7506 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
61fe43e7 7507 WMI_VDEV_PARAM_HE_LTF, he_ltf);
d5c65159 7508 if (ret) {
61fe43e7
MH		 7509 ath11k_warn(ar->ab, "failed to set he ltf %d: %d\n",
7510 he_ltf, ret);
d5c65159
KV		 7511 return ret;
7512 }
7513
61fe43e7
MH		 7514 return 0;
7515}
7516
7517static int
7518ath11k_mac_set_auto_rate_gi_ltf(struct ath11k_vif *arvif, u16 he_gi, u8 he_ltf)
7519{
7520 struct ath11k *ar = arvif->ar;
7521 int ret;
7522 u32 he_ar_gi_ltf;
7523
7524 if (he_gi != 0xFF) {
7525 switch (he_gi) {
7526 case NL80211_RATE_INFO_HE_GI_0_8:
7527 he_gi = WMI_AUTORATE_800NS_GI;
7528 break;
7529 case NL80211_RATE_INFO_HE_GI_1_6:
7530 he_gi = WMI_AUTORATE_1600NS_GI;
7531 break;
7532 case NL80211_RATE_INFO_HE_GI_3_2:
7533 he_gi = WMI_AUTORATE_3200NS_GI;
7534 break;
7535 default:
7536 ath11k_warn(ar->ab, "invalid he gi: %d\n", he_gi);
7537 return -EINVAL;
7538 }
7539 }
7540
7541 if (he_ltf != 0xFF) {
7542 switch (he_ltf) {
7543 case NL80211_RATE_INFO_HE_1XLTF:
7544 he_ltf = WMI_HE_AUTORATE_LTF_1X;
7545 break;
7546 case NL80211_RATE_INFO_HE_2XLTF:
7547 he_ltf = WMI_HE_AUTORATE_LTF_2X;
7548 break;
7549 case NL80211_RATE_INFO_HE_4XLTF:
7550 he_ltf = WMI_HE_AUTORATE_LTF_4X;
7551 break;
7552 default:
7553 ath11k_warn(ar->ab, "invalid he ltf: %d\n", he_ltf);
7554 return -EINVAL;
7555 }
7556 }
7557
7558 he_ar_gi_ltf = he_gi | he_ltf;
d5c65159 7559 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
61fe43e7
MH		 7560 WMI_VDEV_PARAM_AUTORATE_MISC_CFG,
7561 he_ar_gi_ltf);
d5c65159 7562 if (ret) {
61fe43e7
MH		 7563 ath11k_warn(ar->ab,
7564 "failed to set he autorate gi %u ltf %u: %d\n",
7565 he_gi, he_ltf, ret);
d5c65159
KV		 7566 return ret;
7567 }
7568
61fe43e7
MH		 7569 return 0;
7570}
7571
7572static int ath11k_mac_set_rate_params(struct ath11k_vif *arvif,
7573 u32 rate, u8 nss, u8 sgi, u8 ldpc,
7574 u8 he_gi, u8 he_ltf, bool he_fixed_rate)
7575{
7576 struct ath11k *ar = arvif->ar;
7577 u32 vdev_param;
7578 int ret;
7579
7580 lockdep_assert_held(&ar->conf_mutex);
7581
7582 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7583 "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",
7584 arvif->vdev_id, rate, nss, sgi, ldpc, he_gi,
7585 he_ltf, he_fixed_rate);
7586
7587 if (!arvif->vif->bss_conf.he_support) {
7588 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
7589 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7590 vdev_param, rate);
7591 if (ret) {
7592 ath11k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
7593 rate, ret);
7594 return ret;
7595 }
7596 }
7597
7598 vdev_param = WMI_VDEV_PARAM_NSS;
d5c65159 7599 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
61fe43e7 7600 vdev_param, nss);
d5c65159 7601 if (ret) {
61fe43e7
MH		 7602 ath11k_warn(ar->ab, "failed to set nss param %d: %d\n",
7603 nss, ret);
d5c65159
KV		 7604 return ret;
7605 }
7606
7607 vdev_param = WMI_VDEV_PARAM_LDPC;
7608 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7609 vdev_param, ldpc);
7610 if (ret) {
7611 ath11k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
7612 ldpc, ret);
7613 return ret;
7614 }
7615
61fe43e7
MH		 7616 if (arvif->vif->bss_conf.he_support) {
7617 if (he_fixed_rate) {
7618 ret = ath11k_mac_set_fixed_rate_gi_ltf(arvif, he_gi,
7619 he_ltf);
7620 if (ret) {
7621 ath11k_warn(ar->ab, "failed to set fixed rate gi ltf: %d\n",
7622 ret);
7623 return ret;
7624 }
7625 } else {
7626 ret = ath11k_mac_set_auto_rate_gi_ltf(arvif, he_gi,
7627 he_ltf);
7628 if (ret) {
7629 ath11k_warn(ar->ab, "failed to set auto rate gi ltf: %d\n",
7630 ret);
7631 return ret;
7632 }
7633 }
7634 } else {
7635 vdev_param = WMI_VDEV_PARAM_SGI;
7636 ret = ath11k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
7637 vdev_param, sgi);
7638 if (ret) {
7639 ath11k_warn(ar->ab, "failed to set sgi param %d: %d\n",
7640 sgi, ret);
7641 return ret;
7642 }
7643 }
7644
d5c65159
KV		 7645 return 0;
7646}
7647
7648static bool
7649ath11k_mac_vht_mcs_range_present(struct ath11k *ar,
7650 enum nl80211_band band,
7651 const struct cfg80211_bitrate_mask *mask)
7652{
7653 int i;
7654 u16 vht_mcs;
7655
7656 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
7657 vht_mcs = mask->control[band].vht_mcs[i];
7658
7659 switch (vht_mcs) {
7660 case 0:
7661 case BIT(8) - 1:
7662 case BIT(9) - 1:
7663 case BIT(10) - 1:
7664 break;
7665 default:
7666 return false;
7667 }
7668 }
7669
7670 return true;
7671}
7672
61fe43e7
MH		 7673static bool
7674ath11k_mac_he_mcs_range_present(struct ath11k *ar,
7675 enum nl80211_band band,
7676 const struct cfg80211_bitrate_mask *mask)
7677{
7678 int i;
7679 u16 he_mcs;
7680
7681 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
7682 he_mcs = mask->control[band].he_mcs[i];
7683
7684 switch (he_mcs) {
7685 case 0:
7686 case BIT(8) - 1:
7687 case BIT(10) - 1:
7688 case BIT(12) - 1:
7689 break;
7690 default:
7691 return false;
7692 }
7693 }
7694
7695 return true;
7696}
7697
d5c65159
KV		 7698static void ath11k_mac_set_bitrate_mask_iter(void *data,
7699 struct ieee80211_sta *sta)
7700{
7701 struct ath11k_vif *arvif = data;
7702 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
7703 struct ath11k *ar = arvif->ar;
7704
7705 spin_lock_bh(&ar->data_lock);
7706 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
7707 spin_unlock_bh(&ar->data_lock);
7708
7709 ieee80211_queue_work(ar->hw, &arsta->update_wk);
7710}
7711
7712static void ath11k_mac_disable_peer_fixed_rate(void *data,
7713 struct ieee80211_sta *sta)
7714{
7715 struct ath11k_vif *arvif = data;
7716 struct ath11k *ar = arvif->ar;
7717 int ret;
7718
7719 ret = ath11k_wmi_set_peer_param(ar, sta->addr,
7720 arvif->vdev_id,
7721 WMI_PEER_PARAM_FIXED_RATE,
7722 WMI_FIXED_RATE_NONE);
7723 if (ret)
7724 ath11k_warn(ar->ab,
7725 "failed to disable peer fixed rate for STA %pM ret %d\n",
7726 sta->addr, ret);
7727}
7728
61fe43e7
MH		 7729static bool
7730ath11k_mac_validate_vht_he_fixed_rate_settings(struct ath11k *ar, enum nl80211_band band,
7731 const struct cfg80211_bitrate_mask *mask)
7732{
7733 bool he_fixed_rate = false, vht_fixed_rate = false;
7734 struct ath11k_peer *peer, *tmp;
7735 const u16 *vht_mcs_mask, *he_mcs_mask;
7736 u8 vht_nss, he_nss;
7737 bool ret = true;
7738
7739 vht_mcs_mask = mask->control[band].vht_mcs;
7740 he_mcs_mask = mask->control[band].he_mcs;
7741
7742 if (ath11k_mac_bitrate_mask_num_vht_rates(ar, band, mask) == 1)
7743 vht_fixed_rate = true;
7744
7745 if (ath11k_mac_bitrate_mask_num_he_rates(ar, band, mask) == 1)
7746 he_fixed_rate = true;
7747
7748 if (!vht_fixed_rate && !he_fixed_rate)
7749 return true;
7750
7751 vht_nss = ath11k_mac_max_vht_nss(vht_mcs_mask);
7752 he_nss = ath11k_mac_max_he_nss(he_mcs_mask);
7753
7754 rcu_read_lock();
7755 spin_lock_bh(&ar->ab->base_lock);
7756 list_for_each_entry_safe(peer, tmp, &ar->ab->peers, list) {
7757 if (peer->sta) {
7758 if (vht_fixed_rate && (!peer->sta->vht_cap.vht_supported ||
7759 peer->sta->rx_nss < vht_nss)) {
7760 ret = false;
7761 goto out;
7762 }
7763 if (he_fixed_rate && (!peer->sta->he_cap.has_he ||
7764 peer->sta->rx_nss < he_nss)) {
7765 ret = false;
7766 goto out;
7767 }
7768 }
7769 }
7770
7771out:
7772 spin_unlock_bh(&ar->ab->base_lock);
7773 rcu_read_unlock();
7774 return ret;
7775}
7776
d5c65159
KV		 7777static int
7778ath11k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
7779 struct ieee80211_vif *vif,
7780 const struct cfg80211_bitrate_mask *mask)
7781{
7782 struct ath11k_vif *arvif = (void *)vif->drv_priv;
7783 struct cfg80211_chan_def def;
7784 struct ath11k *ar = arvif->ar;
7785 enum nl80211_band band;
7786 const u8 *ht_mcs_mask;
7787 const u16 *vht_mcs_mask;
61fe43e7
MH		 7788 const u16 *he_mcs_mask;
7789 u8 he_ltf = 0;
7790 u8 he_gi = 0;
d5c65159
KV		 7791 u32 rate;
7792 u8 nss;
7793 u8 sgi;
7794 u8 ldpc;
7795 int single_nss;
7796 int ret;
7797 int num_rates;
61fe43e7 7798 bool he_fixed_rate = false;
d5c65159
KV		 7799
7800 if (ath11k_mac_vif_chan(vif, &def))
7801 return -EPERM;
7802
7803 band = def.chan->band;
7804 ht_mcs_mask = mask->control[band].ht_mcs;
7805 vht_mcs_mask = mask->control[band].vht_mcs;
61fe43e7 7806 he_mcs_mask = mask->control[band].he_mcs;
d5c65159
KV		 7807 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
7808
7809 sgi = mask->control[band].gi;
7810 if (sgi == NL80211_TXRATE_FORCE_LGI)
7811 return -EINVAL;
7812
61fe43e7
MH		 7813 he_gi = mask->control[band].he_gi;
7814 he_ltf = mask->control[band].he_ltf;
7815
d5c65159
KV		 7816 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
7817 * requires passing atleast one of used basic rates along with them.
7818 * Fixed rate setting across different preambles(legacy, HT, VHT) is
7819 * not supported by the FW. Hence use of FIXED_RATE vdev param is not
7820 * suitable for setting single HT/VHT rates.
7821 * But, there could be a single basic rate passed from userspace which
7822 * can be done through the FIXED_RATE param.
7823 */
7824 if (ath11k_mac_has_single_legacy_rate(ar, band, mask)) {
7825 ret = ath11k_mac_get_single_legacy_rate(ar, band, mask, &rate,
7826 &nss);
7827 if (ret) {
7828 ath11k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
7829 arvif->vdev_id, ret);
7830 return ret;
7831 }
7832 ieee80211_iterate_stations_atomic(ar->hw,
7833 ath11k_mac_disable_peer_fixed_rate,
7834 arvif);
7835 } else if (ath11k_mac_bitrate_mask_get_single_nss(ar, band, mask,
7836 &single_nss)) {
7837 rate = WMI_FIXED_RATE_NONE;
7838 nss = single_nss;
61fe43e7
MH		 7839 mutex_lock(&ar->conf_mutex);
7840 arvif->bitrate_mask = *mask;
7841 ieee80211_iterate_stations_atomic(ar->hw,
7842 ath11k_mac_set_bitrate_mask_iter,
7843 arvif);
7844 mutex_unlock(&ar->conf_mutex);
d5c65159
KV		 7845 } else {
7846 rate = WMI_FIXED_RATE_NONE;
61fe43e7
MH		 7847
7848 if (!ath11k_mac_validate_vht_he_fixed_rate_settings(ar, band, mask))
7849 ath11k_warn(ar->ab,
567ec33a 7850 "could not update fixed rate settings to all peers due to mcs/nss incompatibility\n");
d5c65159 7851 nss = min_t(u32, ar->num_tx_chains,
61fe43e7
MH		 7852 max(max(ath11k_mac_max_ht_nss(ht_mcs_mask),
7853 ath11k_mac_max_vht_nss(vht_mcs_mask)),
7854 ath11k_mac_max_he_nss(he_mcs_mask)));
d5c65159
KV		 7855
7856 /* If multiple rates across different preambles are given
7857 * we can reconfigure this info with all peers using PEER_ASSOC
7858 * command with the below exception cases.
7859 * - Single VHT Rate : peer_assoc command accommodates only MCS
7860 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
7861 * mandates passing basic rates along with HT/VHT rates, FW
7862 * doesn't allow switching from VHT to Legacy. Hence instead of
7863 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
7864 * we could set this VHT rate as peer fixed rate param, which
7865 * will override FIXED rate and FW rate control algorithm.
7866 * If single VHT rate is passed along with HT rates, we select
7867 * the VHT rate as fixed rate for vht peers.
7868 * - Multiple VHT Rates : When Multiple VHT rates are given,this
7869 * can be set using RATEMASK CMD which uses FW rate-ctl alg.
7870 * TODO: Setting multiple VHT MCS and replacing peer_assoc with
7871 * RATEMASK_CMDID can cover all use cases of setting rates
7872 * across multiple preambles and rates within same type.
7873 * But requires more validation of the command at this point.
7874 */
7875
7876 num_rates = ath11k_mac_bitrate_mask_num_vht_rates(ar, band,
7877 mask);
7878
7879 if (!ath11k_mac_vht_mcs_range_present(ar, band, mask) &&
7880 num_rates > 1) {
7881 /* TODO: Handle multiple VHT MCS values setting using
7882 * RATEMASK CMD
7883 */
7884 ath11k_warn(ar->ab,
61fe43e7
MH		 7885 "setting %d mcs values in bitrate mask not supported\n",
7886 num_rates);
d5c65159
KV		 7887 return -EINVAL;
7888 }
7889
61fe43e7
MH		 7890 num_rates = ath11k_mac_bitrate_mask_num_he_rates(ar, band,
7891 mask);
7892 if (num_rates == 1)
7893 he_fixed_rate = true;
7894
7895 if (!ath11k_mac_he_mcs_range_present(ar, band, mask) &&
7896 num_rates > 1) {
7897 ath11k_warn(ar->ab,
7898 "Setting more than one HE MCS Value in bitrate mask not supported\n");
7899 return -EINVAL;
7900 }
7901
7902 mutex_lock(&ar->conf_mutex);
d5c65159
KV		 7903 ieee80211_iterate_stations_atomic(ar->hw,
7904 ath11k_mac_disable_peer_fixed_rate,
7905 arvif);
7906
d5c65159
KV		 7907 arvif->bitrate_mask = *mask;
7908 ieee80211_iterate_stations_atomic(ar->hw,
7909 ath11k_mac_set_bitrate_mask_iter,
7910 arvif);
7911
7912 mutex_unlock(&ar->conf_mutex);
7913 }
7914
7915 mutex_lock(&ar->conf_mutex);
7916
61fe43e7
MH		 7917 ret = ath11k_mac_set_rate_params(arvif, rate, nss, sgi, ldpc, he_gi,
7918 he_ltf, he_fixed_rate);
d5c65159 7919 if (ret) {
61fe43e7 7920 ath11k_warn(ar->ab, "failed to set rate params on vdev %i: %d\n",
d5c65159
KV		 7921 arvif->vdev_id, ret);
7922 }
7923
7924 mutex_unlock(&ar->conf_mutex);
7925
7926 return ret;
7927}
7928
7929static void
7930ath11k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
7931 enum ieee80211_reconfig_type reconfig_type)
7932{
7933 struct ath11k *ar = hw->priv;
13da397f
WG		 7934 struct ath11k_base *ab = ar->ab;
7935 int recovery_count;
d5c65159
KV		 7936
7937 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
7938 return;
7939
7940 mutex_lock(&ar->conf_mutex);
7941
7942 if (ar->state == ATH11K_STATE_RESTARTED) {
7943 ath11k_warn(ar->ab, "pdev %d successfully recovered\n",
7944 ar->pdev->pdev_id);
7945 ar->state = ATH11K_STATE_ON;
7946 ieee80211_wake_queues(ar->hw);
13da397f 7947
b2beae32
WG		 7948 if (ar->ab->hw_params.current_cc_support &&
7949 ar->alpha2[0] != 0 && ar->alpha2[1] != 0) {
7950 struct wmi_set_current_country_params set_current_param = {};
7951
7952 memcpy(&set_current_param.alpha2, ar->alpha2, 2);
7953 ath11k_wmi_send_set_current_country_cmd(ar, &set_current_param);
7954 }
7955
13da397f
WG		 7956 if (ab->is_reset) {
7957 recovery_count = atomic_inc_return(&ab->recovery_count);
7958 ath11k_dbg(ab, ATH11K_DBG_BOOT,
7959 "recovery count %d\n", recovery_count);
7960 /* When there are multiple radios in an SOC,
7961 * the recovery has to be done for each radio
7962 */
7963 if (recovery_count == ab->num_radios) {
7964 atomic_dec(&ab->reset_count);
7965 complete(&ab->reset_complete);
7966 ab->is_reset = false;
7967 atomic_set(&ab->fail_cont_count, 0);
7968 ath11k_dbg(ab, ATH11K_DBG_BOOT, "reset success\n");
7969 }
7970 }
d5c65159
KV		 7971 }
7972
7973 mutex_unlock(&ar->conf_mutex);
7974}
7975
7976static void
7977ath11k_mac_update_bss_chan_survey(struct ath11k *ar,
7978 struct ieee80211_channel *channel)
7979{
7980 int ret;
7981 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
7982
7983 lockdep_assert_held(&ar->conf_mutex);
7984
6bc9d6f7 7985 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
d5c65159
KV		 7986 ar->rx_channel != channel)
7987 return;
7988
7989 if (ar->scan.state != ATH11K_SCAN_IDLE) {
7990 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
7991 "ignoring bss chan info req while scanning..\n");
7992 return;
7993 }
7994
7995 reinit_completion(&ar->bss_survey_done);
7996
7997 ret = ath11k_wmi_pdev_bss_chan_info_request(ar, type);
7998 if (ret) {
7999 ath11k_warn(ar->ab, "failed to send pdev bss chan info request\n");
8000 return;
8001 }
8002
8003 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8004 if (ret == 0)
8005 ath11k_warn(ar->ab, "bss channel survey timed out\n");
8006}
8007
8008static int ath11k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
8009 struct survey_info *survey)
8010{
8011 struct ath11k *ar = hw->priv;
8012 struct ieee80211_supported_band *sband;
8013 struct survey_info *ar_survey;
8014 int ret = 0;
8015
8016 if (idx >= ATH11K_NUM_CHANS)
8017 return -ENOENT;
8018
8019 ar_survey = &ar->survey[idx];
8020
8021 mutex_lock(&ar->conf_mutex);
8022
8023 sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8024 if (sband && idx >= sband->n_channels) {
8025 idx -= sband->n_channels;
8026 sband = NULL;
8027 }
8028
8029 if (!sband)
8030 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
b6b142f6
PKC		 8031 if (sband && idx >= sband->n_channels) {
8032 idx -= sband->n_channels;
8033 sband = NULL;
8034 }
d5c65159 8035
b6b142f6
PKC		 8036 if (!sband)
8037 sband = hw->wiphy->bands[NL80211_BAND_6GHZ];
d5c65159
KV		 8038 if (!sband || idx >= sband->n_channels) {
8039 ret = -ENOENT;
8040 goto exit;
8041 }
8042
8043 ath11k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8044
8045 spin_lock_bh(&ar->data_lock);
8046 memcpy(survey, ar_survey, sizeof(*survey));
8047 spin_unlock_bh(&ar->data_lock);
8048
8049 survey->channel = &sband->channels[idx];
8050
8051 if (ar->rx_channel == survey->channel)
8052 survey->filled |= SURVEY_INFO_IN_USE;
8053
8054exit:
8055 mutex_unlock(&ar->conf_mutex);
8056 return ret;
8057}
8058
b488c766
WG		 8059static void ath11k_mac_put_chain_rssi(struct station_info *sinfo,
8060 struct ath11k_sta *arsta,
8061 char *pre,
8062 bool clear)
8063{
8064 struct ath11k *ar = arsta->arvif->ar;
8065 int i;
8066 s8 rssi;
8067
8068 for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
8069 sinfo->chains &= ~BIT(i);
8070 rssi = arsta->chain_signal[i];
8071 if (clear)
8072 arsta->chain_signal[i] = ATH11K_INVALID_RSSI_FULL;
8073
8074 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8075 "mac sta statistics %s rssi[%d] %d\n", pre, i, rssi);
8076
8077 if (rssi != ATH11K_DEFAULT_NOISE_FLOOR &&
8078 rssi != ATH11K_INVALID_RSSI_FULL &&
8079 rssi != ATH11K_INVALID_RSSI_EMPTY &&
8080 rssi != 0) {
8081 sinfo->chain_signal[i] = rssi;
8082 sinfo->chains |= BIT(i);
8083 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
8084 }
8085 }
8086}
8087
d5c65159
KV		 8088static void ath11k_mac_op_sta_statistics(struct ieee80211_hw *hw,
8089 struct ieee80211_vif *vif,
8090 struct ieee80211_sta *sta,
8091 struct station_info *sinfo)
8092{
8093 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
b488c766 8094 struct ath11k *ar = arsta->arvif->ar;
c3b39553
WG		 8095 s8 signal;
8096 bool db2dbm = test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT,
8097 ar->ab->wmi_ab.svc_map);
d5c65159
KV		 8098
8099 sinfo->rx_duration = arsta->rx_duration;
8100 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
8101
a9e945ea
VN		 8102 sinfo->tx_duration = arsta->tx_duration;
8103 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
8104
1d795645
WG		 8105 if (arsta->txrate.legacy || arsta->txrate.nss) {
8106 if (arsta->txrate.legacy) {
8107 sinfo->txrate.legacy = arsta->txrate.legacy;
8108 } else {
8109 sinfo->txrate.mcs = arsta->txrate.mcs;
8110 sinfo->txrate.nss = arsta->txrate.nss;
8111 sinfo->txrate.bw = arsta->txrate.bw;
8112 sinfo->txrate.he_gi = arsta->txrate.he_gi;
8113 sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
8114 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
8115 }
8116 sinfo->txrate.flags = arsta->txrate.flags;
8117 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
8118 }
d5c65159 8119
b488c766
WG		 8120 ath11k_mac_put_chain_rssi(sinfo, arsta, "ppdu", false);
8121
8122 if (!(sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) &&
8123 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8124 ar->ab->hw_params.supports_rssi_stats &&
8125 !ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8126 WMI_REQUEST_RSSI_PER_CHAIN_STAT)) {
8127 ath11k_mac_put_chain_rssi(sinfo, arsta, "fw stats", true);
8128 }
8129
c3b39553
WG		 8130 signal = arsta->rssi_comb;
8131 if (!signal &&
8132 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA &&
8133 ar->ab->hw_params.supports_rssi_stats &&
8134 !(ath11k_debugfs_get_fw_stats(ar, ar->pdev->pdev_id, 0,
8135 WMI_REQUEST_VDEV_STAT)))
8136 signal = arsta->rssi_beacon;
8137
8138 ath11k_dbg(ar->ab, ATH11K_DBG_MAC,
8139 "mac sta statistics db2dbm %u rssi comb %d rssi beacon %d\n",
8140 db2dbm, arsta->rssi_comb, arsta->rssi_beacon);
8141
8142 if (signal) {
8143 sinfo->signal = db2dbm ? signal : signal + ATH11K_DEFAULT_NOISE_FLOOR;
8144 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
8145 }
d5c65159
KV		 8146}
8147
c3c36bfe
CH		 8148static void ath11k_generate_ns_mc_addr(struct ath11k *ar,
8149 struct ath11k_arp_ns_offload *offload)
8150{
8151 int i;
8152
8153 for (i = 0; i < offload->ipv6_count; i++) {
8154 offload->self_ipv6_addr[i][0] = 0xff;
8155 offload->self_ipv6_addr[i][1] = 0x02;
8156 offload->self_ipv6_addr[i][11] = 0x01;
8157 offload->self_ipv6_addr[i][12] = 0xff;
8158 offload->self_ipv6_addr[i][13] =
8159 offload->ipv6_addr[i][13];
8160 offload->self_ipv6_addr[i][14] =
8161 offload->ipv6_addr[i][14];
8162 offload->self_ipv6_addr[i][15] =
8163 offload->ipv6_addr[i][15];
8164 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "NS solicited addr %pI6\n",
8165 offload->self_ipv6_addr[i]);
8166 }
8167}
8168
8169static void ath11k_mac_op_ipv6_changed(struct ieee80211_hw *hw,
8170 struct ieee80211_vif *vif,
8171 struct inet6_dev *idev)
8172{
8173 struct ath11k *ar = hw->priv;
8174 struct ath11k_arp_ns_offload *offload;
8175 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8176 struct inet6_ifaddr *ifa6;
8177 struct ifacaddr6 *ifaca6;
8178 struct list_head *p;
8179 u32 count, scope;
8180
8181 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac op ipv6 changed\n");
8182
8183 offload = &arvif->arp_ns_offload;
8184 count = 0;
8185
8186 read_lock_bh(&idev->lock);
8187
8188 memset(offload->ipv6_addr, 0, sizeof(offload->ipv6_addr));
8189 memset(offload->self_ipv6_addr, 0, sizeof(offload->self_ipv6_addr));
8190 memcpy(offload->mac_addr, vif->addr, ETH_ALEN);
8191
8192 /* get unicast address */
8193 list_for_each(p, &idev->addr_list) {
8194 if (count >= ATH11K_IPV6_MAX_COUNT)
8195 goto generate;
8196
8197 ifa6 = list_entry(p, struct inet6_ifaddr, if_list);
8198 if (ifa6->flags & IFA_F_DADFAILED)
8199 continue;
8200 scope = ipv6_addr_src_scope(&ifa6->addr);
8201 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8202 scope == IPV6_ADDR_SCOPE_GLOBAL) {
8203 memcpy(offload->ipv6_addr[count], &ifa6->addr.s6_addr,
8204 sizeof(ifa6->addr.s6_addr));
8205 offload->ipv6_type[count] = ATH11K_IPV6_UC_TYPE;
8206 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 uc %pI6 scope %d\n",
8207 count, offload->ipv6_addr[count],
8208 scope);
8209 count++;
8210 } else {
8211 ath11k_warn(ar->ab, "Unsupported ipv6 scope: %d\n", scope);
8212 }
8213 }
8214
8215 /* get anycast address */
8216 for (ifaca6 = idev->ac_list; ifaca6; ifaca6 = ifaca6->aca_next) {
8217 if (count >= ATH11K_IPV6_MAX_COUNT)
8218 goto generate;
8219
8220 scope = ipv6_addr_src_scope(&ifaca6->aca_addr);
8221 if (scope == IPV6_ADDR_SCOPE_LINKLOCAL ||
8222 scope == IPV6_ADDR_SCOPE_GLOBAL) {
8223 memcpy(offload->ipv6_addr[count], &ifaca6->aca_addr,
8224 sizeof(ifaca6->aca_addr));
8225 offload->ipv6_type[count] = ATH11K_IPV6_AC_TYPE;
8226 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac count %d ipv6 ac %pI6 scope %d\n",
8227 count, offload->ipv6_addr[count],
8228 scope);
8229 count++;
8230 } else {
8231 ath11k_warn(ar->ab, "Unsupported ipv scope: %d\n", scope);
8232 }
8233 }
8234
8235generate:
8236 offload->ipv6_count = count;
8237 read_unlock_bh(&idev->lock);
8238
8239 /* generate ns multicast address */
8240 ath11k_generate_ns_mc_addr(ar, offload);
8241}
8242
a16d9b50
CH		 8243static void ath11k_mac_op_set_rekey_data(struct ieee80211_hw *hw,
8244 struct ieee80211_vif *vif,
8245 struct cfg80211_gtk_rekey_data *data)
8246{
8247 struct ath11k *ar = hw->priv;
8248 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
8249 struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
8250
8251 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "mac set rekey data vdev %d\n",
8252 arvif->vdev_id);
8253
8254 mutex_lock(&ar->conf_mutex);
8255
8256 memcpy(rekey_data->kck, data->kck, NL80211_KCK_LEN);
8257 memcpy(rekey_data->kek, data->kek, NL80211_KEK_LEN);
8258
8259 /* The supplicant works on big-endian, the firmware expects it on
8260 * little endian.
8261 */
8262 rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
8263
8264 arvif->rekey_data.enable_offload = true;
8265
8266 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kck", NULL,
8267 rekey_data->kck, NL80211_KCK_LEN);
8268 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "kek", NULL,
8269 rekey_data->kck, NL80211_KEK_LEN);
8270 ath11k_dbg_dump(ar->ab, ATH11K_DBG_MAC, "replay ctr", NULL,
8271 &rekey_data->replay_ctr, sizeof(rekey_data->replay_ctr));
8272
8273 mutex_unlock(&ar->conf_mutex);
8274}
8275
652f69ed
BQ		 8276static int ath11k_mac_op_set_bios_sar_specs(struct ieee80211_hw *hw,
8277 const struct cfg80211_sar_specs *sar)
8278{
8279 struct ath11k *ar = hw->priv;
8280 const struct cfg80211_sar_sub_specs *sspec = sar->sub_specs;
8281 int ret, index;
8282 u8 *sar_tbl;
8283 u32 i;
8284
8285 mutex_lock(&ar->conf_mutex);
8286
8287 if (!test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) ||
8288 !ar->ab->hw_params.bios_sar_capa) {
8289 ret = -EOPNOTSUPP;
8290 goto exit;
8291 }
8292
8293 if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
8294 sar->num_sub_specs == 0) {
8295 ret = -EINVAL;
8296 goto exit;
8297 }
8298
8299 ret = ath11k_wmi_pdev_set_bios_geo_table_param(ar);
8300 if (ret) {
8301 ath11k_warn(ar->ab, "failed to set geo table: %d\n", ret);
8302 goto exit;
8303 }
8304
8305 sar_tbl = kzalloc(BIOS_SAR_TABLE_LEN, GFP_KERNEL);
8306 if (!sar_tbl) {
8307 ret = -ENOMEM;
8308 goto exit;
8309 }
8310
8311 for (i = 0; i < sar->num_sub_specs; i++) {
8312 if (sspec->freq_range_index >= (BIOS_SAR_TABLE_LEN >> 1)) {
8313 ath11k_warn(ar->ab, "Ignore bad frequency index %u, max allowed %u\n",
8314 sspec->freq_range_index, BIOS_SAR_TABLE_LEN >> 1);
8315 continue;
8316 }
8317
8318 /* chain0 and chain1 share same power setting */
8319 sar_tbl[sspec->freq_range_index] = sspec->power;
8320 index = sspec->freq_range_index + (BIOS_SAR_TABLE_LEN >> 1);
8321 sar_tbl[index] = sspec->power;
8322 ath11k_dbg(ar->ab, ATH11K_DBG_MAC, "sar tbl[%d] = %d\n",
8323 sspec->freq_range_index, sar_tbl[sspec->freq_range_index]);
8324 sspec++;
8325 }
8326
8327 ret = ath11k_wmi_pdev_set_bios_sar_table_param(ar, sar_tbl);
8328 if (ret)
8329 ath11k_warn(ar->ab, "failed to set sar power: %d", ret);
8330
8331 kfree(sar_tbl);
8332exit:
8333 mutex_unlock(&ar->conf_mutex);
8334
8335 return ret;
8336}
8337
d5c65159
KV		 8338static const struct ieee80211_ops ath11k_ops = {
8339 .tx = ath11k_mac_op_tx,
8340 .start = ath11k_mac_op_start,
8341 .stop = ath11k_mac_op_stop,
8342 .reconfig_complete = ath11k_mac_op_reconfig_complete,
8343 .add_interface = ath11k_mac_op_add_interface,
8344 .remove_interface = ath11k_mac_op_remove_interface,
6aea26ce 8345 .update_vif_offload = ath11k_mac_op_update_vif_offload,
d5c65159
KV		 8346 .config = ath11k_mac_op_config,
8347 .bss_info_changed = ath11k_mac_op_bss_info_changed,
8348 .configure_filter = ath11k_mac_op_configure_filter,
8349 .hw_scan = ath11k_mac_op_hw_scan,
8350 .cancel_hw_scan = ath11k_mac_op_cancel_hw_scan,
8351 .set_key = ath11k_mac_op_set_key,
a16d9b50 8352 .set_rekey_data = ath11k_mac_op_set_rekey_data,
d5c65159 8353 .sta_state = ath11k_mac_op_sta_state,
34c67dc3 8354 .sta_set_4addr = ath11k_mac_op_sta_set_4addr,
64f1d7e9 8355 .sta_set_txpwr = ath11k_mac_op_sta_set_txpwr,
d5c65159
KV		 8356 .sta_rc_update = ath11k_mac_op_sta_rc_update,
8357 .conf_tx = ath11k_mac_op_conf_tx,
8358 .set_antenna = ath11k_mac_op_set_antenna,
8359 .get_antenna = ath11k_mac_op_get_antenna,
8360 .ampdu_action = ath11k_mac_op_ampdu_action,
8361 .add_chanctx = ath11k_mac_op_add_chanctx,
8362 .remove_chanctx = ath11k_mac_op_remove_chanctx,
8363 .change_chanctx = ath11k_mac_op_change_chanctx,
8364 .assign_vif_chanctx = ath11k_mac_op_assign_vif_chanctx,
8365 .unassign_vif_chanctx = ath11k_mac_op_unassign_vif_chanctx,
8366 .switch_vif_chanctx = ath11k_mac_op_switch_vif_chanctx,
8367 .set_rts_threshold = ath11k_mac_op_set_rts_threshold,
8368 .set_frag_threshold = ath11k_mac_op_set_frag_threshold,
8369 .set_bitrate_mask = ath11k_mac_op_set_bitrate_mask,
8370 .get_survey = ath11k_mac_op_get_survey,
8371 .flush = ath11k_mac_op_flush,
8372 .sta_statistics = ath11k_mac_op_sta_statistics,
8373 CFG80211_TESTMODE_CMD(ath11k_tm_cmd)
ba9177fc
CH		 8374
8375#ifdef CONFIG_PM
8376 .suspend = ath11k_wow_op_suspend,
8377 .resume = ath11k_wow_op_resume,
8378 .set_wakeup = ath11k_wow_op_set_wakeup,
8379#endif
8380
a45ceea5 8381#ifdef CONFIG_ATH11K_DEBUGFS
568f0603 8382 .sta_add_debugfs = ath11k_debugfs_sta_op_add,
d5c65159 8383#endif
c3c36bfe
CH		 8384
8385#if IS_ENABLED(CONFIG_IPV6)
8386 .ipv6_addr_change = ath11k_mac_op_ipv6_changed,
8387#endif
8388
652f69ed 8389 .set_sar_specs = ath11k_mac_op_set_bios_sar_specs,
d5c65159
KV		 8390};
8391
d5c65159
KV		 8392static void ath11k_mac_update_ch_list(struct ath11k *ar,
8393 struct ieee80211_supported_band *band,
8394 u32 freq_low, u32 freq_high)
8395{
8396 int i;
8397
8398 if (!(freq_low && freq_high))
8399 return;
8400
8401 for (i = 0; i < band->n_channels; i++) {
8402 if (band->channels[i].center_freq < freq_low ||
8403 band->channels[i].center_freq > freq_high)
8404 band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
8405 }
8406}
8407
5f859bc0
CH		 8408static u32 ath11k_get_phy_id(struct ath11k *ar, u32 band)
8409{
8410 struct ath11k_pdev *pdev = ar->pdev;
8411 struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
8412
8413 if (band == WMI_HOST_WLAN_2G_CAP)
8414 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
8415
8416 if (band == WMI_HOST_WLAN_5G_CAP)
8417 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
8418
8419 ath11k_warn(ar->ab, "unsupported phy cap:%d\n", band);
8420
8421 return 0;
8422}
8423
d5c65159
KV		 8424static int ath11k_mac_setup_channels_rates(struct ath11k *ar,
8425 u32 supported_bands)
8426{
8427 struct ieee80211_supported_band *band;
74bba5e5 8428 struct ath11k_hal_reg_capabilities_ext *reg_cap, *temp_reg_cap;
d5c65159 8429 void *channels;
5f859bc0 8430 u32 phy_id;
d5c65159
KV		 8431
8432 BUILD_BUG_ON((ARRAY_SIZE(ath11k_2ghz_channels) +
22eeadcd
PKC		 8433 ARRAY_SIZE(ath11k_5ghz_channels) +
8434 ARRAY_SIZE(ath11k_6ghz_channels)) !=
d5c65159
KV		 8435 ATH11K_NUM_CHANS);
8436
8437 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
74bba5e5 8438 temp_reg_cap = reg_cap;
d5c65159
KV		 8439
8440 if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
8441 channels = kmemdup(ath11k_2ghz_channels,
8442 sizeof(ath11k_2ghz_channels),
8443 GFP_KERNEL);
8444 if (!channels)
8445 return -ENOMEM;
8446
8447 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
22eeadcd 8448 band->band = NL80211_BAND_2GHZ;
d5c65159
KV		 8449 band->n_channels = ARRAY_SIZE(ath11k_2ghz_channels);
8450 band->channels = channels;
8451 band->n_bitrates = ath11k_g_rates_size;
8452 band->bitrates = ath11k_g_rates;
8453 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
5f859bc0
CH		 8454
8455 if (ar->ab->hw_params.single_pdev_only) {
8456 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
74bba5e5 8457 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
5f859bc0 8458 }
d5c65159 8459 ath11k_mac_update_ch_list(ar, band,
74bba5e5
WG		 8460 temp_reg_cap->low_2ghz_chan,
8461 temp_reg_cap->high_2ghz_chan);
d5c65159
KV		 8462 }
8463
8464 if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
22eeadcd
PKC		 8465 if (reg_cap->high_5ghz_chan >= ATH11K_MAX_6G_FREQ) {
8466 channels = kmemdup(ath11k_6ghz_channels,
8467 sizeof(ath11k_6ghz_channels), GFP_KERNEL);
8468 if (!channels) {
8469 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8470 return -ENOMEM;
8471 }
8472
8473 ar->supports_6ghz = true;
8474 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
8475 band->band = NL80211_BAND_6GHZ;
8476 band->n_channels = ARRAY_SIZE(ath11k_6ghz_channels);
8477 band->channels = channels;
8478 band->n_bitrates = ath11k_a_rates_size;
8479 band->bitrates = ath11k_a_rates;
8480 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
74bba5e5
WG		 8481
8482 if (ar->ab->hw_params.single_pdev_only) {
8483 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
8484 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
8485 }
8486
22eeadcd 8487 ath11k_mac_update_ch_list(ar, band,
74bba5e5
WG		 8488 temp_reg_cap->low_5ghz_chan,
8489 temp_reg_cap->high_5ghz_chan);
d5c65159
KV		 8490 }
8491
22eeadcd
PKC		 8492 if (reg_cap->low_5ghz_chan < ATH11K_MIN_6G_FREQ) {
8493 channels = kmemdup(ath11k_5ghz_channels,
8494 sizeof(ath11k_5ghz_channels),
8495 GFP_KERNEL);
8496 if (!channels) {
8497 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8498 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
8499 return -ENOMEM;
8500 }
8501
8502 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
8503 band->band = NL80211_BAND_5GHZ;
8504 band->n_channels = ARRAY_SIZE(ath11k_5ghz_channels);
8505 band->channels = channels;
8506 band->n_bitrates = ath11k_a_rates_size;
8507 band->bitrates = ath11k_a_rates;
8508 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
5f859bc0
CH		 8509
8510 if (ar->ab->hw_params.single_pdev_only) {
8511 phy_id = ath11k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
74bba5e5 8512 temp_reg_cap = &ar->ab->hal_reg_cap[phy_id];
5f859bc0
CH		 8513 }
8514
22eeadcd 8515 ath11k_mac_update_ch_list(ar, band,
74bba5e5
WG		 8516 temp_reg_cap->low_5ghz_chan,
8517 temp_reg_cap->high_5ghz_chan);
22eeadcd 8518 }
d5c65159
KV		 8519 }
8520
8521 return 0;
8522}
8523
2626c269
KV		 8524static int ath11k_mac_setup_iface_combinations(struct ath11k *ar)
8525{
8526 struct ath11k_base *ab = ar->ab;
8527 struct ieee80211_iface_combination *combinations;
8528 struct ieee80211_iface_limit *limits;
8529 int n_limits;
8530
8531 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
8532 if (!combinations)
8533 return -ENOMEM;
8534
8535 n_limits = 2;
8536
8537 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
8431350e
AD		 8538 if (!limits) {
8539 kfree(combinations);
2626c269 8540 return -ENOMEM;
8431350e 8541 }
2626c269
KV		 8542
8543 limits[0].max = 1;
8544 limits[0].types |= BIT(NL80211_IFTYPE_STATION);
8545
8546 limits[1].max = 16;
8547 limits[1].types |= BIT(NL80211_IFTYPE_AP);
8548
8549 if (IS_ENABLED(CONFIG_MAC80211_MESH) &&
8550 ab->hw_params.interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
8551 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
8552
8553 combinations[0].limits = limits;
8554 combinations[0].n_limits = n_limits;
8555 combinations[0].max_interfaces = 16;
8556 combinations[0].num_different_channels = 1;
8557 combinations[0].beacon_int_infra_match = true;
8558 combinations[0].beacon_int_min_gcd = 100;
8559 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
8560 BIT(NL80211_CHAN_WIDTH_20) |
8561 BIT(NL80211_CHAN_WIDTH_40) |
f552d6fd
P		 8562 BIT(NL80211_CHAN_WIDTH_80) |
8563 BIT(NL80211_CHAN_WIDTH_80P80) |
8564 BIT(NL80211_CHAN_WIDTH_160);
2626c269
KV		 8565
8566 ar->hw->wiphy->iface_combinations = combinations;
8567 ar->hw->wiphy->n_iface_combinations = 1;
8568
8569 return 0;
8570}
8571
d5c65159
KV		 8572static const u8 ath11k_if_types_ext_capa[] = {
8573 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8574 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8575};
8576
8577static const u8 ath11k_if_types_ext_capa_sta[] = {
8578 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8579 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8580 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
8581};
8582
8583static const u8 ath11k_if_types_ext_capa_ap[] = {
8584 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
8585 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
8586 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
8587};
8588
8589static const struct wiphy_iftype_ext_capab ath11k_iftypes_ext_capa[] = {
8590 {
8591 .extended_capabilities = ath11k_if_types_ext_capa,
8592 .extended_capabilities_mask = ath11k_if_types_ext_capa,
8593 .extended_capabilities_len = sizeof(ath11k_if_types_ext_capa),
8594 }, {
8595 .iftype = NL80211_IFTYPE_STATION,
8596 .extended_capabilities = ath11k_if_types_ext_capa_sta,
8597 .extended_capabilities_mask = ath11k_if_types_ext_capa_sta,
8598 .extended_capabilities_len =
8599 sizeof(ath11k_if_types_ext_capa_sta),
8600 }, {
8601 .iftype = NL80211_IFTYPE_AP,
8602 .extended_capabilities = ath11k_if_types_ext_capa_ap,
8603 .extended_capabilities_mask = ath11k_if_types_ext_capa_ap,
8604 .extended_capabilities_len =
8605 sizeof(ath11k_if_types_ext_capa_ap),
8606 },
8607};
8608
0366f426
VT		 8609static void __ath11k_mac_unregister(struct ath11k *ar)
8610{
8611 cancel_work_sync(&ar->regd_update_work);
8612
8613 ieee80211_unregister_hw(ar->hw);
8614
8615 idr_for_each(&ar->txmgmt_idr, ath11k_mac_tx_mgmt_pending_free, ar);
8616 idr_destroy(&ar->txmgmt_idr);
8617
8618 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8619 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
22eeadcd 8620 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
0366f426 8621
2626c269
KV		 8622 kfree(ar->hw->wiphy->iface_combinations[0].limits);
8623 kfree(ar->hw->wiphy->iface_combinations);
8624
0366f426
VT		 8625 SET_IEEE80211_DEV(ar->hw, NULL);
8626}
8627
8628void ath11k_mac_unregister(struct ath11k_base *ab)
8629{
8630 struct ath11k *ar;
8631 struct ath11k_pdev *pdev;
8632 int i;
8633
8634 for (i = 0; i < ab->num_radios; i++) {
8635 pdev = &ab->pdevs[i];
8636 ar = pdev->ar;
8637 if (!ar)
8638 continue;
8639
8640 __ath11k_mac_unregister(ar);
8641 }
7b0c70d9
KP		 8642
8643 ath11k_peer_rhash_tbl_destroy(ab);
0366f426
VT		 8644}
8645
8646static int __ath11k_mac_register(struct ath11k *ar)
d5c65159
KV		 8647{
8648 struct ath11k_base *ab = ar->ab;
8649 struct ath11k_pdev_cap *cap = &ar->pdev->cap;
8650 static const u32 cipher_suites[] = {
8651 WLAN_CIPHER_SUITE_TKIP,
8652 WLAN_CIPHER_SUITE_CCMP,
8653 WLAN_CIPHER_SUITE_AES_CMAC,
8654 WLAN_CIPHER_SUITE_BIP_CMAC_256,
8655 WLAN_CIPHER_SUITE_BIP_GMAC_128,
8656 WLAN_CIPHER_SUITE_BIP_GMAC_256,
8657 WLAN_CIPHER_SUITE_GCMP,
8658 WLAN_CIPHER_SUITE_GCMP_256,
8659 WLAN_CIPHER_SUITE_CCMP_256,
8660 };
8661 int ret;
8662 u32 ht_cap = 0;
8663
8664 ath11k_pdev_caps_update(ar);
8665
8666 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
8667
8668 SET_IEEE80211_DEV(ar->hw, ab->dev);
8669
8670 ret = ath11k_mac_setup_channels_rates(ar,
8671 cap->supported_bands);
8672 if (ret)
7e8453e3 8673 goto err;
d5c65159
KV		 8674
8675 ath11k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
9f056ed8 8676 ath11k_mac_setup_he_cap(ar, cap);
d5c65159 8677
2626c269
KV		 8678 ret = ath11k_mac_setup_iface_combinations(ar);
8679 if (ret) {
8680 ath11k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
8681 goto err_free_channels;
8682 }
8683
d5c65159
KV		 8684 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
8685 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
8686
2626c269 8687 ar->hw->wiphy->interface_modes = ab->hw_params.interface_modes;
d5c65159 8688
9f6da09a
WG		 8689 if (ab->hw_params.single_pdev_only && ar->supports_6ghz)
8690 ieee80211_hw_set(ar->hw, SINGLE_SCAN_ON_ALL_BANDS);
8691
d5c65159
KV		 8692 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
8693 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
8694 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
8695 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
8696 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
8697 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
8698 ieee80211_hw_set(ar->hw, AP_LINK_PS);
8699 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
d5c65159
KV		 8700 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
8701 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
8702 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
8703 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
8704 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
8705 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
8706 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
2167fa60
S		 8707
8708 if (ath11k_frame_mode == ATH11K_HW_TXRX_ETHERNET) {
8709 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
8710 ieee80211_hw_set(ar->hw, SUPPORTS_RX_DECAP_OFFLOAD);
8711 }
f552d6fd
P		 8712
8713 if (cap->nss_ratio_enabled)
8714 ieee80211_hw_set(ar->hw, SUPPORTS_VHT_EXT_NSS_BW);
8715
c3a7d7eb 8716 if ((ht_cap & WMI_HT_CAP_ENABLED) || ar->supports_6ghz) {
d5c65159
KV		 8717 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
8718 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
8719 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
8720 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
26c79927 8721 ieee80211_hw_set(ar->hw, USES_RSS);
d5c65159
KV		 8722 }
8723
8724 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
8725 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
8726
8727 /* TODO: Check if HT capability advertised from firmware is different
8728 * for each band for a dual band capable radio. It will be tricky to
8729 * handle it when the ht capability different for each band.
8730 */
82c434c1
WG		 8731 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS ||
8732 (ar->supports_6ghz && ab->hw_params.supports_dynamic_smps_6ghz))
d5c65159
KV		 8733 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
8734
8735 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
8736 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
8737
8738 ar->hw->max_listen_interval = ATH11K_MAX_HW_LISTEN_INTERVAL;
8739
8740 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
8741 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
8742 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
8743
8744 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
8745 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
8746 NL80211_FEATURE_AP_SCAN;
8747
523aafd0
KV		 8748 ar->max_num_stations = TARGET_NUM_STATIONS(ab);
8749 ar->max_num_peers = TARGET_NUM_PEERS_PDEV(ab);
d5c65159
KV		 8750
8751 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
8752
9cbd7fc9
CH		 8753 if (test_bit(WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi->wmi_ab->svc_map)) {
8754 ar->hw->wiphy->features |=
8755 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
8756 }
8757
fec4b898
CH		 8758 if (test_bit(WMI_TLV_SERVICE_NLO, ar->wmi->wmi_ab->svc_map)) {
8759 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
8760 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
8761 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
8762 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
8763 ar->hw->wiphy->max_sched_scan_plan_interval =
8764 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
8765 ar->hw->wiphy->max_sched_scan_plan_iterations =
8766 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
8767 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
8768 }
8769
ba9177fc
CH		 8770 ret = ath11k_wow_init(ar);
8771 if (ret) {
8772 ath11k_warn(ar->ab, "failed to init wow: %d\n", ret);
8773 goto err_free_if_combs;
8774 }
8775
d5c65159 8776 ar->hw->queues = ATH11K_HW_MAX_QUEUES;
107560d8 8777 ar->hw->wiphy->tx_queue_len = ATH11K_QUEUE_LEN;
d5c65159 8778 ar->hw->offchannel_tx_hw_queue = ATH11K_HW_MAX_QUEUES - 1;
2a2c86f1 8779 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
d5c65159
KV		 8780
8781 ar->hw->vif_data_size = sizeof(struct ath11k_vif);
8782 ar->hw->sta_data_size = sizeof(struct ath11k_sta);
8783
d5c65159 8784 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
64f1d7e9 8785 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
886433a9
JC		 8786 if (test_bit(WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD, ar->ab->wmi_ab.svc_map))
8787 wiphy_ext_feature_set(ar->hw->wiphy,
8788 NL80211_EXT_FEATURE_BSS_COLOR);
d5c65159
KV		 8789
8790 ar->hw->wiphy->cipher_suites = cipher_suites;
8791 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
8792
8793 ar->hw->wiphy->iftype_ext_capab = ath11k_iftypes_ext_capa;
8794 ar->hw->wiphy->num_iftype_ext_capab =
8795 ARRAY_SIZE(ath11k_iftypes_ext_capa);
8796
047679e3
AD		 8797 if (ar->supports_6ghz) {
8798 wiphy_ext_feature_set(ar->hw->wiphy,
8799 NL80211_EXT_FEATURE_FILS_DISCOVERY);
8800 wiphy_ext_feature_set(ar->hw->wiphy,
8801 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
8802 }
8803
d5c65159
KV		 8804 ath11k_reg_init(ar);
8805
aa2092a9
VN		 8806 if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
8807 ar->hw->netdev_features = NETIF_F_HW_CSUM;
8808 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
8809 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
8810 }
d5c65159 8811
652f69ed
BQ		 8812 if (test_bit(WMI_TLV_SERVICE_BIOS_SAR_SUPPORT, ar->ab->wmi_ab.svc_map) &&
8813 ab->hw_params.bios_sar_capa)
8814 ar->hw->wiphy->sar_capa = ab->hw_params.bios_sar_capa;
8815
d5c65159
KV		 8816 ret = ieee80211_register_hw(ar->hw);
8817 if (ret) {
8818 ath11k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
2626c269 8819 goto err_free_if_combs;
d5c65159
KV		 8820 }
8821
3f6e6c32
KV		 8822 if (!ab->hw_params.supports_monitor)
8823 /* There's a race between calling ieee80211_register_hw()
8824 * and here where the monitor mode is enabled for a little
8825 * while. But that time is so short and in practise it make
8826 * a difference in real life.
8827 */
8828 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
8829
d5c65159 8830 /* Apply the regd received during initialization */
1db2b0d0 8831 ret = ath11k_regd_update(ar);
d5c65159
KV		 8832 if (ret) {
8833 ath11k_err(ar->ab, "ath11k regd update failed: %d\n", ret);
0d969683 8834 goto err_unregister_hw;
d5c65159
KV		 8835 }
8836
cb4e57db 8837 ret = ath11k_debugfs_register(ar);
d5c65159
KV		 8838 if (ret) {
8839 ath11k_err(ar->ab, "debugfs registration failed: %d\n", ret);
0d969683 8840 goto err_unregister_hw;
d5c65159
KV		 8841 }
8842
8843 return 0;
8844
0d969683
WG		 8845err_unregister_hw:
8846 ieee80211_unregister_hw(ar->hw);
8847
2626c269
KV		 8848err_free_if_combs:
8849 kfree(ar->hw->wiphy->iface_combinations[0].limits);
8850 kfree(ar->hw->wiphy->iface_combinations);
8851
8852err_free_channels:
d5c65159
KV		 8853 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
8854 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
7e8453e3 8855 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
d5c65159 8856
7e8453e3 8857err:
d5c65159
KV		 8858 SET_IEEE80211_DEV(ar->hw, NULL);
8859 return ret;
8860}
8861
0366f426 8862int ath11k_mac_register(struct ath11k_base *ab)
d5c65159
KV		 8863{
8864 struct ath11k *ar;
8865 struct ath11k_pdev *pdev;
8866 int i;
0366f426 8867 int ret;
d5c65159 8868
6fc3b94e
MK		 8869 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
8870 return 0;
8871
3c79cb4d
SM		 8872 /* Initialize channel counters frequency value in hertz */
8873 ab->cc_freq_hz = IPQ8074_CC_FREQ_HERTZ;
523aafd0 8874 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS(ab))) - 1;
3c79cb4d 8875
7b0c70d9
KP		 8876 ret = ath11k_peer_rhash_tbl_init(ab);
8877 if (ret)
8878 return ret;
8879
d5c65159
KV		 8880 for (i = 0; i < ab->num_radios; i++) {
8881 pdev = &ab->pdevs[i];
8882 ar = pdev->ar;
0366f426
VT		 8883 if (ab->pdevs_macaddr_valid) {
8884 ether_addr_copy(ar->mac_addr, pdev->mac_addr);
8885 } else {
8886 ether_addr_copy(ar->mac_addr, ab->mac_addr);
8887 ar->mac_addr[4] += i;
8888 }
d5c65159 8889
3c79cb4d
SM		 8890 idr_init(&ar->txmgmt_idr);
8891 spin_lock_init(&ar->txmgmt_idr_lock);
8892
0366f426
VT		 8893 ret = __ath11k_mac_register(ar);
8894 if (ret)
8895 goto err_cleanup;
dddaa64d
WG		 8896
8897 init_waitqueue_head(&ar->txmgmt_empty_waitq);
0366f426 8898 }
d5c65159 8899
0366f426 8900 return 0;
d5c65159 8901
0366f426
VT		 8902err_cleanup:
8903 for (i = i - 1; i >= 0; i--) {
8904 pdev = &ab->pdevs[i];
8905 ar = pdev->ar;
8906 __ath11k_mac_unregister(ar);
d5c65159 8907 }
0366f426 8908
7b0c70d9
KP		 8909 ath11k_peer_rhash_tbl_destroy(ab);
8910
0366f426 8911 return ret;
d5c65159
KV		 8912}
8913
0366f426 8914int ath11k_mac_allocate(struct ath11k_base *ab)
d5c65159
KV		 8915{
8916 struct ieee80211_hw *hw;
8917 struct ath11k *ar;
8918 struct ath11k_pdev *pdev;
8919 int ret;
8920 int i;
8921
8922 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
8923 return 0;
8924
8925 for (i = 0; i < ab->num_radios; i++) {
8926 pdev = &ab->pdevs[i];
8927 hw = ieee80211_alloc_hw(sizeof(struct ath11k), &ath11k_ops);
8928 if (!hw) {
8929 ath11k_warn(ab, "failed to allocate mac80211 hw device\n");
8930 ret = -ENOMEM;
0366f426 8931 goto err_free_mac;
d5c65159
KV		 8932 }
8933
8934 ar = hw->priv;
8935 ar->hw = hw;
8936 ar->ab = ab;
8937 ar->pdev = pdev;
8938 ar->pdev_idx = i;
d547ca4c 8939 ar->lmac_id = ath11k_hw_get_mac_from_pdev_id(&ab->hw_params, i);
d5c65159 8940
6bc9d6f7 8941 ar->wmi = &ab->wmi_ab.wmi[i];
d5c65159
KV		 8942 /* FIXME wmi[0] is already initialized during attach,
8943 * Should we do this again?
8944 */
8945 ath11k_wmi_pdev_attach(ab, i);
8946
8947 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
8948 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
8949 ar->num_tx_chains = get_num_chains(pdev->cap.tx_chain_mask);
8950 ar->num_rx_chains = get_num_chains(pdev->cap.rx_chain_mask);
8951
d5c65159
KV		 8952 pdev->ar = ar;
8953 spin_lock_init(&ar->data_lock);
8954 INIT_LIST_HEAD(&ar->arvifs);
8955 INIT_LIST_HEAD(&ar->ppdu_stats_info);
8956 mutex_init(&ar->conf_mutex);
8957 init_completion(&ar->vdev_setup_done);
3cbbdfbe 8958 init_completion(&ar->vdev_delete_done);
d5c65159 8959 init_completion(&ar->peer_assoc_done);
690ace20 8960 init_completion(&ar->peer_delete_done);
d5c65159
KV		 8961 init_completion(&ar->install_key_done);
8962 init_completion(&ar->bss_survey_done);
8963 init_completion(&ar->scan.started);
8964 init_completion(&ar->scan.completed);
a41d1034
PKC		 8965 init_completion(&ar->thermal.wmi_sync);
8966
d5c65159
KV		 8967 INIT_DELAYED_WORK(&ar->scan.timeout, ath11k_scan_timeout_work);
8968 INIT_WORK(&ar->regd_update_work, ath11k_regd_update_work);
8969
8970 INIT_WORK(&ar->wmi_mgmt_tx_work, ath11k_mgmt_over_wmi_tx_work);
8971 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
64e06b78 8972
64e06b78
SM		 8973 clear_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags);
8974
8975 ar->monitor_vdev_id = -1;
8976 clear_bit(ATH11K_FLAG_MONITOR_VDEV_CREATED, &ar->monitor_flags);
9dcf6808 8977 ar->vdev_id_11d_scan = ATH11K_11D_INVALID_VDEV_ID;
1f682dc9 8978 init_completion(&ar->completed_11d_scan);
d5c65159
KV		 8979 }
8980
d5c65159
KV		 8981 return 0;
8982
0366f426 8983err_free_mac:
d5c65159
KV		 8984 ath11k_mac_destroy(ab);
8985
8986 return ret;
8987}
8988
8989void ath11k_mac_destroy(struct ath11k_base *ab)
8990{
8991 struct ath11k *ar;
8992 struct ath11k_pdev *pdev;
8993 int i;
8994
8995 for (i = 0; i < ab->num_radios; i++) {
8996 pdev = &ab->pdevs[i];
8997 ar = pdev->ar;
8998 if (!ar)
8999 continue;
9000
9001 ieee80211_free_hw(ar->hw);
9002 pdev->ar = NULL;
9003 }
9004}
Linux 6.x block layer and io_uring tree(s)