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