1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
4 * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
5 */
6
7 #include <net/mac80211.h>
8 #include <linux/etherdevice.h>
9 #include "mac.h"
10 #include "core.h"
11 #include "debug.h"
12 #include "wmi.h"
13 #include "hw.h"
14 #include "dp_tx.h"
15 #include "dp_rx.h"
16 #include "peer.h"
17
18 #define CHAN2G(_channel, _freq, _flags) { \
19 .band = NL80211_BAND_2GHZ, \
20 .hw_value = (_channel), \
21 .center_freq = (_freq), \
22 .flags = (_flags), \
23 .max_antenna_gain = 0, \
24 .max_power = 30, \
25 }
26
27 #define CHAN5G(_channel, _freq, _flags) { \
28 .band = NL80211_BAND_5GHZ, \
29 .hw_value = (_channel), \
30 .center_freq = (_freq), \
31 .flags = (_flags), \
32 .max_antenna_gain = 0, \
33 .max_power = 30, \
34 }
35
36 #define CHAN6G(_channel, _freq, _flags) { \
37 .band = NL80211_BAND_6GHZ, \
38 .hw_value = (_channel), \
39 .center_freq = (_freq), \
40 .flags = (_flags), \
41 .max_antenna_gain = 0, \
42 .max_power = 30, \
43 }
44
45 static const struct ieee80211_channel ath12k_2ghz_channels[] = {
46 CHAN2G(1, 2412, 0),
47 CHAN2G(2, 2417, 0),
48 CHAN2G(3, 2422, 0),
49 CHAN2G(4, 2427, 0),
50 CHAN2G(5, 2432, 0),
51 CHAN2G(6, 2437, 0),
52 CHAN2G(7, 2442, 0),
53 CHAN2G(8, 2447, 0),
54 CHAN2G(9, 2452, 0),
55 CHAN2G(10, 2457, 0),
56 CHAN2G(11, 2462, 0),
57 CHAN2G(12, 2467, 0),
58 CHAN2G(13, 2472, 0),
59 CHAN2G(14, 2484, 0),
60 };
61
62 static const struct ieee80211_channel ath12k_5ghz_channels[] = {
63 CHAN5G(36, 5180, 0),
64 CHAN5G(40, 5200, 0),
65 CHAN5G(44, 5220, 0),
66 CHAN5G(48, 5240, 0),
67 CHAN5G(52, 5260, 0),
68 CHAN5G(56, 5280, 0),
69 CHAN5G(60, 5300, 0),
70 CHAN5G(64, 5320, 0),
71 CHAN5G(100, 5500, 0),
72 CHAN5G(104, 5520, 0),
73 CHAN5G(108, 5540, 0),
74 CHAN5G(112, 5560, 0),
75 CHAN5G(116, 5580, 0),
76 CHAN5G(120, 5600, 0),
77 CHAN5G(124, 5620, 0),
78 CHAN5G(128, 5640, 0),
79 CHAN5G(132, 5660, 0),
80 CHAN5G(136, 5680, 0),
81 CHAN5G(140, 5700, 0),
82 CHAN5G(144, 5720, 0),
83 CHAN5G(149, 5745, 0),
84 CHAN5G(153, 5765, 0),
85 CHAN5G(157, 5785, 0),
86 CHAN5G(161, 5805, 0),
87 CHAN5G(165, 5825, 0),
88 CHAN5G(169, 5845, 0),
89 CHAN5G(173, 5865, 0),
90 };
91
92 static const struct ieee80211_channel ath12k_6ghz_channels[] = {
93 CHAN6G(1, 5955, 0),
94 CHAN6G(5, 5975, 0),
95 CHAN6G(9, 5995, 0),
96 CHAN6G(13, 6015, 0),
97 CHAN6G(17, 6035, 0),
98 CHAN6G(21, 6055, 0),
99 CHAN6G(25, 6075, 0),
100 CHAN6G(29, 6095, 0),
101 CHAN6G(33, 6115, 0),
102 CHAN6G(37, 6135, 0),
103 CHAN6G(41, 6155, 0),
104 CHAN6G(45, 6175, 0),
105 CHAN6G(49, 6195, 0),
106 CHAN6G(53, 6215, 0),
107 CHAN6G(57, 6235, 0),
108 CHAN6G(61, 6255, 0),
109 CHAN6G(65, 6275, 0),
110 CHAN6G(69, 6295, 0),
111 CHAN6G(73, 6315, 0),
112 CHAN6G(77, 6335, 0),
113 CHAN6G(81, 6355, 0),
114 CHAN6G(85, 6375, 0),
115 CHAN6G(89, 6395, 0),
116 CHAN6G(93, 6415, 0),
117 CHAN6G(97, 6435, 0),
118 CHAN6G(101, 6455, 0),
119 CHAN6G(105, 6475, 0),
120 CHAN6G(109, 6495, 0),
121 CHAN6G(113, 6515, 0),
122 CHAN6G(117, 6535, 0),
123 CHAN6G(121, 6555, 0),
124 CHAN6G(125, 6575, 0),
125 CHAN6G(129, 6595, 0),
126 CHAN6G(133, 6615, 0),
127 CHAN6G(137, 6635, 0),
128 CHAN6G(141, 6655, 0),
129 CHAN6G(145, 6675, 0),
130 CHAN6G(149, 6695, 0),
131 CHAN6G(153, 6715, 0),
132 CHAN6G(157, 6735, 0),
133 CHAN6G(161, 6755, 0),
134 CHAN6G(165, 6775, 0),
135 CHAN6G(169, 6795, 0),
136 CHAN6G(173, 6815, 0),
137 CHAN6G(177, 6835, 0),
138 CHAN6G(181, 6855, 0),
139 CHAN6G(185, 6875, 0),
140 CHAN6G(189, 6895, 0),
141 CHAN6G(193, 6915, 0),
142 CHAN6G(197, 6935, 0),
143 CHAN6G(201, 6955, 0),
144 CHAN6G(205, 6975, 0),
145 CHAN6G(209, 6995, 0),
146 CHAN6G(213, 7015, 0),
147 CHAN6G(217, 7035, 0),
148 CHAN6G(221, 7055, 0),
149 CHAN6G(225, 7075, 0),
150 CHAN6G(229, 7095, 0),
151 CHAN6G(233, 7115, 0),
152 };
153
154 static struct ieee80211_rate ath12k_legacy_rates[] = {
155 { .bitrate = 10,
156 .hw_value = ATH12K_HW_RATE_CCK_LP_1M },
157 { .bitrate = 20,
158 .hw_value = ATH12K_HW_RATE_CCK_LP_2M,
159 .hw_value_short = ATH12K_HW_RATE_CCK_SP_2M,
160 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
161 { .bitrate = 55,
162 .hw_value = ATH12K_HW_RATE_CCK_LP_5_5M,
163 .hw_value_short = ATH12K_HW_RATE_CCK_SP_5_5M,
164 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
165 { .bitrate = 110,
166 .hw_value = ATH12K_HW_RATE_CCK_LP_11M,
167 .hw_value_short = ATH12K_HW_RATE_CCK_SP_11M,
168 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
169
170 { .bitrate = 60, .hw_value = ATH12K_HW_RATE_OFDM_6M },
171 { .bitrate = 90, .hw_value = ATH12K_HW_RATE_OFDM_9M },
172 { .bitrate = 120, .hw_value = ATH12K_HW_RATE_OFDM_12M },
173 { .bitrate = 180, .hw_value = ATH12K_HW_RATE_OFDM_18M },
174 { .bitrate = 240, .hw_value = ATH12K_HW_RATE_OFDM_24M },
175 { .bitrate = 360, .hw_value = ATH12K_HW_RATE_OFDM_36M },
176 { .bitrate = 480, .hw_value = ATH12K_HW_RATE_OFDM_48M },
177 { .bitrate = 540, .hw_value = ATH12K_HW_RATE_OFDM_54M },
178 };
179
180 static const int
181 ath12k_phymodes[NUM_NL80211_BANDS][ATH12K_CHAN_WIDTH_NUM] = {
182 [NL80211_BAND_2GHZ] = {
183 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
184 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
185 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11BE_EHT20_2G,
186 [NL80211_CHAN_WIDTH_20] = MODE_11BE_EHT20_2G,
187 [NL80211_CHAN_WIDTH_40] = MODE_11BE_EHT40_2G,
188 [NL80211_CHAN_WIDTH_80] = MODE_UNKNOWN,
189 [NL80211_CHAN_WIDTH_80P80] = MODE_UNKNOWN,
190 [NL80211_CHAN_WIDTH_160] = MODE_UNKNOWN,
191 [NL80211_CHAN_WIDTH_320] = MODE_UNKNOWN,
192 },
193 [NL80211_BAND_5GHZ] = {
194 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
195 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
196 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11BE_EHT20,
197 [NL80211_CHAN_WIDTH_20] = MODE_11BE_EHT20,
198 [NL80211_CHAN_WIDTH_40] = MODE_11BE_EHT40,
199 [NL80211_CHAN_WIDTH_80] = MODE_11BE_EHT80,
200 [NL80211_CHAN_WIDTH_160] = MODE_11BE_EHT160,
201 [NL80211_CHAN_WIDTH_80P80] = MODE_11BE_EHT80_80,
202 [NL80211_CHAN_WIDTH_320] = MODE_11BE_EHT320,
203 },
204 [NL80211_BAND_6GHZ] = {
205 [NL80211_CHAN_WIDTH_5] = MODE_UNKNOWN,
206 [NL80211_CHAN_WIDTH_10] = MODE_UNKNOWN,
207 [NL80211_CHAN_WIDTH_20_NOHT] = MODE_11BE_EHT20,
208 [NL80211_CHAN_WIDTH_20] = MODE_11BE_EHT20,
209 [NL80211_CHAN_WIDTH_40] = MODE_11BE_EHT40,
210 [NL80211_CHAN_WIDTH_80] = MODE_11BE_EHT80,
211 [NL80211_CHAN_WIDTH_160] = MODE_11BE_EHT160,
212 [NL80211_CHAN_WIDTH_80P80] = MODE_11BE_EHT80_80,
213 [NL80211_CHAN_WIDTH_320] = MODE_11BE_EHT320,
214 },
215
216 };
217
218 const struct htt_rx_ring_tlv_filter ath12k_mac_mon_status_filter_default = {
219 .rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START |
220 HTT_RX_FILTER_TLV_FLAGS_PPDU_END |
221 HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE,
222 .pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0,
223 .pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1,
224 .pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2,
225 .pkt_filter_flags3 = HTT_RX_FP_DATA_FILTER_FLASG3 |
226 HTT_RX_FP_CTRL_FILTER_FLASG3
227 };
228
229 #define ATH12K_MAC_FIRST_OFDM_RATE_IDX 4
230 #define ath12k_g_rates ath12k_legacy_rates
231 #define ath12k_g_rates_size (ARRAY_SIZE(ath12k_legacy_rates))
232 #define ath12k_a_rates (ath12k_legacy_rates + 4)
233 #define ath12k_a_rates_size (ARRAY_SIZE(ath12k_legacy_rates) - 4)
234
235 #define ATH12K_MAC_SCAN_TIMEOUT_MSECS 200 /* in msecs */
236
237 static const u32 ath12k_smps_map[] = {
238 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
239 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
240 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
241 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
242 };
243
244 static int ath12k_start_vdev_delay(struct ieee80211_hw *hw,
245 struct ieee80211_vif *vif);
246
ath12k_mac_phymode_str(enum wmi_phy_mode mode)247 static const char *ath12k_mac_phymode_str(enum wmi_phy_mode mode)
248 {
249 switch (mode) {
250 case MODE_11A:
251 return "11a";
252 case MODE_11G:
253 return "11g";
254 case MODE_11B:
255 return "11b";
256 case MODE_11GONLY:
257 return "11gonly";
258 case MODE_11NA_HT20:
259 return "11na-ht20";
260 case MODE_11NG_HT20:
261 return "11ng-ht20";
262 case MODE_11NA_HT40:
263 return "11na-ht40";
264 case MODE_11NG_HT40:
265 return "11ng-ht40";
266 case MODE_11AC_VHT20:
267 return "11ac-vht20";
268 case MODE_11AC_VHT40:
269 return "11ac-vht40";
270 case MODE_11AC_VHT80:
271 return "11ac-vht80";
272 case MODE_11AC_VHT160:
273 return "11ac-vht160";
274 case MODE_11AC_VHT80_80:
275 return "11ac-vht80+80";
276 case MODE_11AC_VHT20_2G:
277 return "11ac-vht20-2g";
278 case MODE_11AC_VHT40_2G:
279 return "11ac-vht40-2g";
280 case MODE_11AC_VHT80_2G:
281 return "11ac-vht80-2g";
282 case MODE_11AX_HE20:
283 return "11ax-he20";
284 case MODE_11AX_HE40:
285 return "11ax-he40";
286 case MODE_11AX_HE80:
287 return "11ax-he80";
288 case MODE_11AX_HE80_80:
289 return "11ax-he80+80";
290 case MODE_11AX_HE160:
291 return "11ax-he160";
292 case MODE_11AX_HE20_2G:
293 return "11ax-he20-2g";
294 case MODE_11AX_HE40_2G:
295 return "11ax-he40-2g";
296 case MODE_11AX_HE80_2G:
297 return "11ax-he80-2g";
298 case MODE_11BE_EHT20:
299 return "11be-eht20";
300 case MODE_11BE_EHT40:
301 return "11be-eht40";
302 case MODE_11BE_EHT80:
303 return "11be-eht80";
304 case MODE_11BE_EHT80_80:
305 return "11be-eht80+80";
306 case MODE_11BE_EHT160:
307 return "11be-eht160";
308 case MODE_11BE_EHT160_160:
309 return "11be-eht160+160";
310 case MODE_11BE_EHT320:
311 return "11be-eht320";
312 case MODE_11BE_EHT20_2G:
313 return "11be-eht20-2g";
314 case MODE_11BE_EHT40_2G:
315 return "11be-eht40-2g";
316 case MODE_UNKNOWN:
317 /* skip */
318 break;
319
320 /* no default handler to allow compiler to check that the
321 * enum is fully handled
322 */
323 }
324
325 return "<unknown>";
326 }
327
328 enum rate_info_bw
ath12k_mac_bw_to_mac80211_bw(enum ath12k_supported_bw bw)329 ath12k_mac_bw_to_mac80211_bw(enum ath12k_supported_bw bw)
330 {
331 u8 ret = RATE_INFO_BW_20;
332
333 switch (bw) {
334 case ATH12K_BW_20:
335 ret = RATE_INFO_BW_20;
336 break;
337 case ATH12K_BW_40:
338 ret = RATE_INFO_BW_40;
339 break;
340 case ATH12K_BW_80:
341 ret = RATE_INFO_BW_80;
342 break;
343 case ATH12K_BW_160:
344 ret = RATE_INFO_BW_160;
345 break;
346 }
347
348 return ret;
349 }
350
ath12k_mac_mac80211_bw_to_ath12k_bw(enum rate_info_bw bw)351 enum ath12k_supported_bw ath12k_mac_mac80211_bw_to_ath12k_bw(enum rate_info_bw bw)
352 {
353 switch (bw) {
354 case RATE_INFO_BW_20:
355 return ATH12K_BW_20;
356 case RATE_INFO_BW_40:
357 return ATH12K_BW_40;
358 case RATE_INFO_BW_80:
359 return ATH12K_BW_80;
360 case RATE_INFO_BW_160:
361 return ATH12K_BW_160;
362 default:
363 return ATH12K_BW_20;
364 }
365 }
366
ath12k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc,u8 preamble,u8 * rateidx,u16 * rate)367 int ath12k_mac_hw_ratecode_to_legacy_rate(u8 hw_rc, u8 preamble, u8 *rateidx,
368 u16 *rate)
369 {
370 /* As default, it is OFDM rates */
371 int i = ATH12K_MAC_FIRST_OFDM_RATE_IDX;
372 int max_rates_idx = ath12k_g_rates_size;
373
374 if (preamble == WMI_RATE_PREAMBLE_CCK) {
375 hw_rc &= ~ATH12K_HW_RATECODE_CCK_SHORT_PREAM_MASK;
376 i = 0;
377 max_rates_idx = ATH12K_MAC_FIRST_OFDM_RATE_IDX;
378 }
379
380 while (i < max_rates_idx) {
381 if (hw_rc == ath12k_legacy_rates[i].hw_value) {
382 *rateidx = i;
383 *rate = ath12k_legacy_rates[i].bitrate;
384 return 0;
385 }
386 i++;
387 }
388
389 return -EINVAL;
390 }
391
ath12k_mac_bitrate_to_idx(const struct ieee80211_supported_band * sband,u32 bitrate)392 u8 ath12k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
393 u32 bitrate)
394 {
395 int i;
396
397 for (i = 0; i < sband->n_bitrates; i++)
398 if (sband->bitrates[i].bitrate == bitrate)
399 return i;
400
401 return 0;
402 }
403
404 static u32
ath12k_mac_max_ht_nss(const u8 * ht_mcs_mask)405 ath12k_mac_max_ht_nss(const u8 *ht_mcs_mask)
406 {
407 int nss;
408
409 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
410 if (ht_mcs_mask[nss])
411 return nss + 1;
412
413 return 1;
414 }
415
416 static u32
ath12k_mac_max_vht_nss(const u16 * vht_mcs_mask)417 ath12k_mac_max_vht_nss(const u16 *vht_mcs_mask)
418 {
419 int nss;
420
421 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
422 if (vht_mcs_mask[nss])
423 return nss + 1;
424
425 return 1;
426 }
427
ath12k_parse_mpdudensity(u8 mpdudensity)428 static u8 ath12k_parse_mpdudensity(u8 mpdudensity)
429 {
430 /* From IEEE Std 802.11-2020 defined values for "Minimum MPDU Start Spacing":
431 * 0 for no restriction
432 * 1 for 1/4 us
433 * 2 for 1/2 us
434 * 3 for 1 us
435 * 4 for 2 us
436 * 5 for 4 us
437 * 6 for 8 us
438 * 7 for 16 us
439 */
440 switch (mpdudensity) {
441 case 0:
442 return 0;
443 case 1:
444 case 2:
445 case 3:
446 /* Our lower layer calculations limit our precision to
447 * 1 microsecond
448 */
449 return 1;
450 case 4:
451 return 2;
452 case 5:
453 return 4;
454 case 6:
455 return 8;
456 case 7:
457 return 16;
458 default:
459 return 0;
460 }
461 }
462
ath12k_mac_vif_chan(struct ieee80211_vif * vif,struct cfg80211_chan_def * def)463 static int ath12k_mac_vif_chan(struct ieee80211_vif *vif,
464 struct cfg80211_chan_def *def)
465 {
466 struct ieee80211_chanctx_conf *conf;
467
468 rcu_read_lock();
469 conf = rcu_dereference(vif->bss_conf.chanctx_conf);
470 if (!conf) {
471 rcu_read_unlock();
472 return -ENOENT;
473 }
474
475 *def = conf->def;
476 rcu_read_unlock();
477
478 return 0;
479 }
480
ath12k_mac_bitrate_is_cck(int bitrate)481 static bool ath12k_mac_bitrate_is_cck(int bitrate)
482 {
483 switch (bitrate) {
484 case 10:
485 case 20:
486 case 55:
487 case 110:
488 return true;
489 }
490
491 return false;
492 }
493
ath12k_mac_hw_rate_to_idx(const struct ieee80211_supported_band * sband,u8 hw_rate,bool cck)494 u8 ath12k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
495 u8 hw_rate, bool cck)
496 {
497 const struct ieee80211_rate *rate;
498 int i;
499
500 for (i = 0; i < sband->n_bitrates; i++) {
501 rate = &sband->bitrates[i];
502
503 if (ath12k_mac_bitrate_is_cck(rate->bitrate) != cck)
504 continue;
505
506 if (rate->hw_value == hw_rate)
507 return i;
508 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
509 rate->hw_value_short == hw_rate)
510 return i;
511 }
512
513 return 0;
514 }
515
ath12k_mac_bitrate_to_rate(int bitrate)516 static u8 ath12k_mac_bitrate_to_rate(int bitrate)
517 {
518 return DIV_ROUND_UP(bitrate, 5) |
519 (ath12k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
520 }
521
ath12k_get_arvif_iter(void * data,u8 * mac,struct ieee80211_vif * vif)522 static void ath12k_get_arvif_iter(void *data, u8 *mac,
523 struct ieee80211_vif *vif)
524 {
525 struct ath12k_vif_iter *arvif_iter = data;
526 struct ath12k_vif *arvif = (void *)vif->drv_priv;
527
528 if (arvif->vdev_id == arvif_iter->vdev_id)
529 arvif_iter->arvif = arvif;
530 }
531
ath12k_mac_get_arvif(struct ath12k * ar,u32 vdev_id)532 struct ath12k_vif *ath12k_mac_get_arvif(struct ath12k *ar, u32 vdev_id)
533 {
534 struct ath12k_vif_iter arvif_iter = {};
535 u32 flags;
536
537 arvif_iter.vdev_id = vdev_id;
538
539 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
540 ieee80211_iterate_active_interfaces_atomic(ar->hw,
541 flags,
542 ath12k_get_arvif_iter,
543 &arvif_iter);
544 if (!arvif_iter.arvif) {
545 ath12k_warn(ar->ab, "No VIF found for vdev %d\n", vdev_id);
546 return NULL;
547 }
548
549 return arvif_iter.arvif;
550 }
551
ath12k_mac_get_arvif_by_vdev_id(struct ath12k_base * ab,u32 vdev_id)552 struct ath12k_vif *ath12k_mac_get_arvif_by_vdev_id(struct ath12k_base *ab,
553 u32 vdev_id)
554 {
555 int i;
556 struct ath12k_pdev *pdev;
557 struct ath12k_vif *arvif;
558
559 for (i = 0; i < ab->num_radios; i++) {
560 pdev = rcu_dereference(ab->pdevs_active[i]);
561 if (pdev && pdev->ar) {
562 arvif = ath12k_mac_get_arvif(pdev->ar, vdev_id);
563 if (arvif)
564 return arvif;
565 }
566 }
567
568 return NULL;
569 }
570
ath12k_mac_get_ar_by_vdev_id(struct ath12k_base * ab,u32 vdev_id)571 struct ath12k *ath12k_mac_get_ar_by_vdev_id(struct ath12k_base *ab, u32 vdev_id)
572 {
573 int i;
574 struct ath12k_pdev *pdev;
575
576 for (i = 0; i < ab->num_radios; i++) {
577 pdev = rcu_dereference(ab->pdevs_active[i]);
578 if (pdev && pdev->ar) {
579 if (pdev->ar->allocated_vdev_map & (1LL << vdev_id))
580 return pdev->ar;
581 }
582 }
583
584 return NULL;
585 }
586
ath12k_mac_get_ar_by_pdev_id(struct ath12k_base * ab,u32 pdev_id)587 struct ath12k *ath12k_mac_get_ar_by_pdev_id(struct ath12k_base *ab, u32 pdev_id)
588 {
589 int i;
590 struct ath12k_pdev *pdev;
591
592 if (ab->hw_params->single_pdev_only) {
593 pdev = rcu_dereference(ab->pdevs_active[0]);
594 return pdev ? pdev->ar : NULL;
595 }
596
597 if (WARN_ON(pdev_id > ab->num_radios))
598 return NULL;
599
600 for (i = 0; i < ab->num_radios; i++) {
601 pdev = rcu_dereference(ab->pdevs_active[i]);
602
603 if (pdev && pdev->pdev_id == pdev_id)
604 return (pdev->ar ? pdev->ar : NULL);
605 }
606
607 return NULL;
608 }
609
ath12k_pdev_caps_update(struct ath12k * ar)610 static void ath12k_pdev_caps_update(struct ath12k *ar)
611 {
612 struct ath12k_base *ab = ar->ab;
613
614 ar->max_tx_power = ab->target_caps.hw_max_tx_power;
615
616 /* FIXME: Set min_tx_power to ab->target_caps.hw_min_tx_power.
617 * But since the received value in svcrdy is same as hw_max_tx_power,
618 * we can set ar->min_tx_power to 0 currently until
619 * this is fixed in firmware
620 */
621 ar->min_tx_power = 0;
622
623 ar->txpower_limit_2g = ar->max_tx_power;
624 ar->txpower_limit_5g = ar->max_tx_power;
625 ar->txpower_scale = WMI_HOST_TP_SCALE_MAX;
626 }
627
ath12k_mac_txpower_recalc(struct ath12k * ar)628 static int ath12k_mac_txpower_recalc(struct ath12k *ar)
629 {
630 struct ath12k_pdev *pdev = ar->pdev;
631 struct ath12k_vif *arvif;
632 int ret, txpower = -1;
633 u32 param;
634
635 lockdep_assert_held(&ar->conf_mutex);
636
637 list_for_each_entry(arvif, &ar->arvifs, list) {
638 if (arvif->txpower <= 0)
639 continue;
640
641 if (txpower == -1)
642 txpower = arvif->txpower;
643 else
644 txpower = min(txpower, arvif->txpower);
645 }
646
647 if (txpower == -1)
648 return 0;
649
650 /* txpwr is set as 2 units per dBm in FW*/
651 txpower = min_t(u32, max_t(u32, ar->min_tx_power, txpower),
652 ar->max_tx_power) * 2;
653
654 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "txpower to set in hw %d\n",
655 txpower / 2);
656
657 if ((pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) &&
658 ar->txpower_limit_2g != txpower) {
659 param = WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
660 ret = ath12k_wmi_pdev_set_param(ar, param,
661 txpower, ar->pdev->pdev_id);
662 if (ret)
663 goto fail;
664 ar->txpower_limit_2g = txpower;
665 }
666
667 if ((pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) &&
668 ar->txpower_limit_5g != txpower) {
669 param = WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
670 ret = ath12k_wmi_pdev_set_param(ar, param,
671 txpower, ar->pdev->pdev_id);
672 if (ret)
673 goto fail;
674 ar->txpower_limit_5g = txpower;
675 }
676
677 return 0;
678
679 fail:
680 ath12k_warn(ar->ab, "failed to recalc txpower limit %d using pdev param %d: %d\n",
681 txpower / 2, param, ret);
682 return ret;
683 }
684
ath12k_recalc_rtscts_prot(struct ath12k_vif * arvif)685 static int ath12k_recalc_rtscts_prot(struct ath12k_vif *arvif)
686 {
687 struct ath12k *ar = arvif->ar;
688 u32 vdev_param, rts_cts;
689 int ret;
690
691 lockdep_assert_held(&ar->conf_mutex);
692
693 vdev_param = WMI_VDEV_PARAM_ENABLE_RTSCTS;
694
695 /* Enable RTS/CTS protection for sw retries (when legacy stations
696 * are in BSS) or by default only for second rate series.
697 * TODO: Check if we need to enable CTS 2 Self in any case
698 */
699 rts_cts = WMI_USE_RTS_CTS;
700
701 if (arvif->num_legacy_stations > 0)
702 rts_cts |= WMI_RTSCTS_ACROSS_SW_RETRIES << 4;
703 else
704 rts_cts |= WMI_RTSCTS_FOR_SECOND_RATESERIES << 4;
705
706 /* Need not send duplicate param value to firmware */
707 if (arvif->rtscts_prot_mode == rts_cts)
708 return 0;
709
710 arvif->rtscts_prot_mode = rts_cts;
711
712 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n",
713 arvif->vdev_id, rts_cts);
714
715 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
716 vdev_param, rts_cts);
717 if (ret)
718 ath12k_warn(ar->ab, "failed to recalculate rts/cts prot for vdev %d: %d\n",
719 arvif->vdev_id, ret);
720
721 return ret;
722 }
723
ath12k_mac_set_kickout(struct ath12k_vif * arvif)724 static int ath12k_mac_set_kickout(struct ath12k_vif *arvif)
725 {
726 struct ath12k *ar = arvif->ar;
727 u32 param;
728 int ret;
729
730 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_STA_KICKOUT_TH,
731 ATH12K_KICKOUT_THRESHOLD,
732 ar->pdev->pdev_id);
733 if (ret) {
734 ath12k_warn(ar->ab, "failed to set kickout threshold on vdev %i: %d\n",
735 arvif->vdev_id, ret);
736 return ret;
737 }
738
739 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS;
740 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
741 ATH12K_KEEPALIVE_MIN_IDLE);
742 if (ret) {
743 ath12k_warn(ar->ab, "failed to set keepalive minimum idle time on vdev %i: %d\n",
744 arvif->vdev_id, ret);
745 return ret;
746 }
747
748 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS;
749 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
750 ATH12K_KEEPALIVE_MAX_IDLE);
751 if (ret) {
752 ath12k_warn(ar->ab, "failed to set keepalive maximum idle time on vdev %i: %d\n",
753 arvif->vdev_id, ret);
754 return ret;
755 }
756
757 param = WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS;
758 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, param,
759 ATH12K_KEEPALIVE_MAX_UNRESPONSIVE);
760 if (ret) {
761 ath12k_warn(ar->ab, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
762 arvif->vdev_id, ret);
763 return ret;
764 }
765
766 return 0;
767 }
768
ath12k_mac_peer_cleanup_all(struct ath12k * ar)769 void ath12k_mac_peer_cleanup_all(struct ath12k *ar)
770 {
771 struct ath12k_peer *peer, *tmp;
772 struct ath12k_base *ab = ar->ab;
773
774 lockdep_assert_held(&ar->conf_mutex);
775
776 spin_lock_bh(&ab->base_lock);
777 list_for_each_entry_safe(peer, tmp, &ab->peers, list) {
778 ath12k_dp_rx_peer_tid_cleanup(ar, peer);
779 list_del(&peer->list);
780 kfree(peer);
781 }
782 spin_unlock_bh(&ab->base_lock);
783
784 ar->num_peers = 0;
785 ar->num_stations = 0;
786 }
787
ath12k_mac_vdev_setup_sync(struct ath12k * ar)788 static int ath12k_mac_vdev_setup_sync(struct ath12k *ar)
789 {
790 lockdep_assert_held(&ar->conf_mutex);
791
792 if (test_bit(ATH12K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
793 return -ESHUTDOWN;
794
795 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "vdev setup timeout %d\n",
796 ATH12K_VDEV_SETUP_TIMEOUT_HZ);
797
798 if (!wait_for_completion_timeout(&ar->vdev_setup_done,
799 ATH12K_VDEV_SETUP_TIMEOUT_HZ))
800 return -ETIMEDOUT;
801
802 return ar->last_wmi_vdev_start_status ? -EINVAL : 0;
803 }
804
ath12k_monitor_vdev_up(struct ath12k * ar,int vdev_id)805 static int ath12k_monitor_vdev_up(struct ath12k *ar, int vdev_id)
806 {
807 int ret;
808
809 ret = ath12k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
810 if (ret) {
811 ath12k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n",
812 vdev_id, ret);
813 return ret;
814 }
815
816 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor vdev %i started\n",
817 vdev_id);
818 return 0;
819 }
820
ath12k_mac_monitor_vdev_start(struct ath12k * ar,int vdev_id,struct cfg80211_chan_def * chandef)821 static int ath12k_mac_monitor_vdev_start(struct ath12k *ar, int vdev_id,
822 struct cfg80211_chan_def *chandef)
823 {
824 struct ieee80211_channel *channel;
825 struct wmi_vdev_start_req_arg arg = {};
826 int ret;
827
828 lockdep_assert_held(&ar->conf_mutex);
829
830 channel = chandef->chan;
831 arg.vdev_id = vdev_id;
832 arg.freq = channel->center_freq;
833 arg.band_center_freq1 = chandef->center_freq1;
834 arg.band_center_freq2 = chandef->center_freq2;
835 arg.mode = ath12k_phymodes[chandef->chan->band][chandef->width];
836 arg.chan_radar = !!(channel->flags & IEEE80211_CHAN_RADAR);
837
838 arg.min_power = 0;
839 arg.max_power = channel->max_power;
840 arg.max_reg_power = channel->max_reg_power;
841 arg.max_antenna_gain = channel->max_antenna_gain;
842
843 arg.pref_tx_streams = ar->num_tx_chains;
844 arg.pref_rx_streams = ar->num_rx_chains;
845 arg.punct_bitmap = 0xFFFFFFFF;
846
847 arg.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
848
849 reinit_completion(&ar->vdev_setup_done);
850 reinit_completion(&ar->vdev_delete_done);
851
852 ret = ath12k_wmi_vdev_start(ar, &arg, false);
853 if (ret) {
854 ath12k_warn(ar->ab, "failed to request monitor vdev %i start: %d\n",
855 vdev_id, ret);
856 return ret;
857 }
858
859 ret = ath12k_mac_vdev_setup_sync(ar);
860 if (ret) {
861 ath12k_warn(ar->ab, "failed to synchronize setup for monitor vdev %i start: %d\n",
862 vdev_id, ret);
863 return ret;
864 }
865
866 ret = ath12k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
867 if (ret) {
868 ath12k_warn(ar->ab, "failed to put up monitor vdev %i: %d\n",
869 vdev_id, ret);
870 goto vdev_stop;
871 }
872
873 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor vdev %i started\n",
874 vdev_id);
875 return 0;
876
877 vdev_stop:
878 ret = ath12k_wmi_vdev_stop(ar, vdev_id);
879 if (ret)
880 ath12k_warn(ar->ab, "failed to stop monitor vdev %i after start failure: %d\n",
881 vdev_id, ret);
882 return ret;
883 }
884
ath12k_mac_monitor_vdev_stop(struct ath12k * ar)885 static int ath12k_mac_monitor_vdev_stop(struct ath12k *ar)
886 {
887 int ret;
888
889 lockdep_assert_held(&ar->conf_mutex);
890
891 reinit_completion(&ar->vdev_setup_done);
892
893 ret = ath12k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
894 if (ret)
895 ath12k_warn(ar->ab, "failed to request monitor vdev %i stop: %d\n",
896 ar->monitor_vdev_id, ret);
897
898 ret = ath12k_mac_vdev_setup_sync(ar);
899 if (ret)
900 ath12k_warn(ar->ab, "failed to synchronize monitor vdev %i stop: %d\n",
901 ar->monitor_vdev_id, ret);
902
903 ret = ath12k_wmi_vdev_down(ar, ar->monitor_vdev_id);
904 if (ret)
905 ath12k_warn(ar->ab, "failed to put down monitor vdev %i: %d\n",
906 ar->monitor_vdev_id, ret);
907
908 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor vdev %i stopped\n",
909 ar->monitor_vdev_id);
910 return ret;
911 }
912
ath12k_mac_monitor_vdev_create(struct ath12k * ar)913 static int ath12k_mac_monitor_vdev_create(struct ath12k *ar)
914 {
915 struct ath12k_pdev *pdev = ar->pdev;
916 struct ath12k_wmi_vdev_create_arg arg = {};
917 int bit, ret;
918 u8 tmp_addr[6];
919 u16 nss;
920
921 lockdep_assert_held(&ar->conf_mutex);
922
923 if (ar->monitor_vdev_created)
924 return 0;
925
926 if (ar->ab->free_vdev_map == 0) {
927 ath12k_warn(ar->ab, "failed to find free vdev id for monitor vdev\n");
928 return -ENOMEM;
929 }
930
931 bit = __ffs64(ar->ab->free_vdev_map);
932
933 ar->monitor_vdev_id = bit;
934
935 arg.if_id = ar->monitor_vdev_id;
936 arg.type = WMI_VDEV_TYPE_MONITOR;
937 arg.subtype = WMI_VDEV_SUBTYPE_NONE;
938 arg.pdev_id = pdev->pdev_id;
939 arg.if_stats_id = ATH12K_INVAL_VDEV_STATS_ID;
940
941 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
942 arg.chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
943 arg.chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
944 }
945
946 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
947 arg.chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
948 arg.chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
949 }
950
951 ret = ath12k_wmi_vdev_create(ar, tmp_addr, &arg);
952 if (ret) {
953 ath12k_warn(ar->ab, "failed to request monitor vdev %i creation: %d\n",
954 ar->monitor_vdev_id, ret);
955 ar->monitor_vdev_id = -1;
956 return ret;
957 }
958
959 nss = hweight32(ar->cfg_tx_chainmask) ? : 1;
960 ret = ath12k_wmi_vdev_set_param_cmd(ar, ar->monitor_vdev_id,
961 WMI_VDEV_PARAM_NSS, nss);
962 if (ret) {
963 ath12k_warn(ar->ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
964 ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret);
965 return ret;
966 }
967
968 ret = ath12k_mac_txpower_recalc(ar);
969 if (ret)
970 return ret;
971
972 ar->allocated_vdev_map |= 1LL << ar->monitor_vdev_id;
973 ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
974 ar->num_created_vdevs++;
975 ar->monitor_vdev_created = true;
976 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor vdev %d created\n",
977 ar->monitor_vdev_id);
978
979 return 0;
980 }
981
ath12k_mac_monitor_vdev_delete(struct ath12k * ar)982 static int ath12k_mac_monitor_vdev_delete(struct ath12k *ar)
983 {
984 int ret;
985 unsigned long time_left;
986
987 lockdep_assert_held(&ar->conf_mutex);
988
989 if (!ar->monitor_vdev_created)
990 return 0;
991
992 reinit_completion(&ar->vdev_delete_done);
993
994 ret = ath12k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
995 if (ret) {
996 ath12k_warn(ar->ab, "failed to request wmi monitor vdev %i removal: %d\n",
997 ar->monitor_vdev_id, ret);
998 return ret;
999 }
1000
1001 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
1002 ATH12K_VDEV_DELETE_TIMEOUT_HZ);
1003 if (time_left == 0) {
1004 ath12k_warn(ar->ab, "Timeout in receiving vdev delete response\n");
1005 } else {
1006 ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1007 ar->ab->free_vdev_map |= 1LL << (ar->monitor_vdev_id);
1008 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor vdev %d deleted\n",
1009 ar->monitor_vdev_id);
1010 ar->num_created_vdevs--;
1011 ar->monitor_vdev_id = -1;
1012 ar->monitor_vdev_created = false;
1013 }
1014
1015 return ret;
1016 }
1017
1018 static void
ath12k_mac_get_any_chandef_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)1019 ath12k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
1020 struct ieee80211_chanctx_conf *conf,
1021 void *data)
1022 {
1023 struct cfg80211_chan_def **def = data;
1024
1025 *def = &conf->def;
1026 }
1027
ath12k_mac_monitor_start(struct ath12k * ar)1028 static int ath12k_mac_monitor_start(struct ath12k *ar)
1029 {
1030 struct cfg80211_chan_def *chandef = NULL;
1031 int ret;
1032
1033 lockdep_assert_held(&ar->conf_mutex);
1034
1035 if (ar->monitor_started)
1036 return 0;
1037
1038 ieee80211_iter_chan_contexts_atomic(ar->hw,
1039 ath12k_mac_get_any_chandef_iter,
1040 &chandef);
1041 if (!chandef)
1042 return 0;
1043
1044 ret = ath12k_mac_monitor_vdev_start(ar, ar->monitor_vdev_id, chandef);
1045 if (ret) {
1046 ath12k_warn(ar->ab, "failed to start monitor vdev: %d\n", ret);
1047 ath12k_mac_monitor_vdev_delete(ar);
1048 return ret;
1049 }
1050
1051 ar->monitor_started = true;
1052 ar->num_started_vdevs++;
1053 ret = ath12k_dp_tx_htt_monitor_mode_ring_config(ar, false);
1054 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor started ret %d\n", ret);
1055
1056 return ret;
1057 }
1058
ath12k_mac_monitor_stop(struct ath12k * ar)1059 static int ath12k_mac_monitor_stop(struct ath12k *ar)
1060 {
1061 int ret;
1062
1063 lockdep_assert_held(&ar->conf_mutex);
1064
1065 if (!ar->monitor_started)
1066 return 0;
1067
1068 ret = ath12k_mac_monitor_vdev_stop(ar);
1069 if (ret) {
1070 ath12k_warn(ar->ab, "failed to stop monitor vdev: %d\n", ret);
1071 return ret;
1072 }
1073
1074 ar->monitor_started = false;
1075 ar->num_started_vdevs--;
1076 ret = ath12k_dp_tx_htt_monitor_mode_ring_config(ar, true);
1077 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac monitor stopped ret %d\n", ret);
1078 return ret;
1079 }
1080
ath12k_mac_op_config(struct ieee80211_hw * hw,u32 changed)1081 static int ath12k_mac_op_config(struct ieee80211_hw *hw, u32 changed)
1082 {
1083 struct ath12k *ar = hw->priv;
1084 struct ieee80211_conf *conf = &hw->conf;
1085 int ret = 0;
1086
1087 mutex_lock(&ar->conf_mutex);
1088
1089 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1090 ar->monitor_conf_enabled = conf->flags & IEEE80211_CONF_MONITOR;
1091 if (ar->monitor_conf_enabled) {
1092 if (ar->monitor_vdev_created)
1093 goto exit;
1094 ret = ath12k_mac_monitor_vdev_create(ar);
1095 if (ret)
1096 goto exit;
1097 ret = ath12k_mac_monitor_start(ar);
1098 if (ret)
1099 goto err_mon_del;
1100 } else {
1101 if (!ar->monitor_vdev_created)
1102 goto exit;
1103 ret = ath12k_mac_monitor_stop(ar);
1104 if (ret)
1105 goto exit;
1106 ath12k_mac_monitor_vdev_delete(ar);
1107 }
1108 }
1109
1110 exit:
1111 mutex_unlock(&ar->conf_mutex);
1112 return ret;
1113
1114 err_mon_del:
1115 ath12k_mac_monitor_vdev_delete(ar);
1116 mutex_unlock(&ar->conf_mutex);
1117 return ret;
1118 }
1119
ath12k_mac_setup_bcn_tmpl(struct ath12k_vif * arvif)1120 static int ath12k_mac_setup_bcn_tmpl(struct ath12k_vif *arvif)
1121 {
1122 struct ath12k *ar = arvif->ar;
1123 struct ath12k_base *ab = ar->ab;
1124 struct ieee80211_hw *hw = ar->hw;
1125 struct ieee80211_vif *vif = arvif->vif;
1126 struct ieee80211_mutable_offsets offs = {};
1127 struct sk_buff *bcn;
1128 struct ieee80211_mgmt *mgmt;
1129 u8 *ies;
1130 int ret;
1131
1132 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1133 return 0;
1134
1135 bcn = ieee80211_beacon_get_template(hw, vif, &offs, 0);
1136 if (!bcn) {
1137 ath12k_warn(ab, "failed to get beacon template from mac80211\n");
1138 return -EPERM;
1139 }
1140
1141 ies = bcn->data + ieee80211_get_hdrlen_from_skb(bcn);
1142 ies += sizeof(mgmt->u.beacon);
1143
1144 if (cfg80211_find_ie(WLAN_EID_RSN, ies, (skb_tail_pointer(bcn) - ies)))
1145 arvif->rsnie_present = true;
1146
1147 if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1148 WLAN_OUI_TYPE_MICROSOFT_WPA,
1149 ies, (skb_tail_pointer(bcn) - ies)))
1150 arvif->wpaie_present = true;
1151
1152 ret = ath12k_wmi_bcn_tmpl(ar, arvif->vdev_id, &offs, bcn);
1153
1154 kfree_skb(bcn);
1155
1156 if (ret)
1157 ath12k_warn(ab, "failed to submit beacon template command: %d\n",
1158 ret);
1159
1160 return ret;
1161 }
1162
ath12k_control_beaconing(struct ath12k_vif * arvif,struct ieee80211_bss_conf * info)1163 static void ath12k_control_beaconing(struct ath12k_vif *arvif,
1164 struct ieee80211_bss_conf *info)
1165 {
1166 struct ath12k *ar = arvif->ar;
1167 int ret;
1168
1169 lockdep_assert_held(&arvif->ar->conf_mutex);
1170
1171 if (!info->enable_beacon) {
1172 ret = ath12k_wmi_vdev_down(ar, arvif->vdev_id);
1173 if (ret)
1174 ath12k_warn(ar->ab, "failed to down vdev_id %i: %d\n",
1175 arvif->vdev_id, ret);
1176
1177 arvif->is_up = false;
1178 return;
1179 }
1180
1181 /* Install the beacon template to the FW */
1182 ret = ath12k_mac_setup_bcn_tmpl(arvif);
1183 if (ret) {
1184 ath12k_warn(ar->ab, "failed to update bcn tmpl during vdev up: %d\n",
1185 ret);
1186 return;
1187 }
1188
1189 arvif->aid = 0;
1190
1191 ether_addr_copy(arvif->bssid, info->bssid);
1192
1193 ret = ath12k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1194 arvif->bssid);
1195 if (ret) {
1196 ath12k_warn(ar->ab, "failed to bring up vdev %d: %i\n",
1197 arvif->vdev_id, ret);
1198 return;
1199 }
1200
1201 arvif->is_up = true;
1202
1203 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1204 }
1205
ath12k_peer_assoc_h_basic(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1206 static void ath12k_peer_assoc_h_basic(struct ath12k *ar,
1207 struct ieee80211_vif *vif,
1208 struct ieee80211_sta *sta,
1209 struct ath12k_wmi_peer_assoc_arg *arg)
1210 {
1211 struct ath12k_vif *arvif = (void *)vif->drv_priv;
1212 u32 aid;
1213
1214 lockdep_assert_held(&ar->conf_mutex);
1215
1216 if (vif->type == NL80211_IFTYPE_STATION)
1217 aid = vif->cfg.aid;
1218 else
1219 aid = sta->aid;
1220
1221 ether_addr_copy(arg->peer_mac, sta->addr);
1222 arg->vdev_id = arvif->vdev_id;
1223 arg->peer_associd = aid;
1224 arg->auth_flag = true;
1225 /* TODO: STA WAR in ath10k for listen interval required? */
1226 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1227 arg->peer_nss = 1;
1228 arg->peer_caps = vif->bss_conf.assoc_capability;
1229 }
1230
ath12k_peer_assoc_h_crypto(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1231 static void ath12k_peer_assoc_h_crypto(struct ath12k *ar,
1232 struct ieee80211_vif *vif,
1233 struct ieee80211_sta *sta,
1234 struct ath12k_wmi_peer_assoc_arg *arg)
1235 {
1236 struct ieee80211_bss_conf *info = &vif->bss_conf;
1237 struct cfg80211_chan_def def;
1238 struct cfg80211_bss *bss;
1239 struct ath12k_vif *arvif = (struct ath12k_vif *)vif->drv_priv;
1240 const u8 *rsnie = NULL;
1241 const u8 *wpaie = NULL;
1242
1243 lockdep_assert_held(&ar->conf_mutex);
1244
1245 if (WARN_ON(ath12k_mac_vif_chan(vif, &def)))
1246 return;
1247
1248 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1249 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1250
1251 if (arvif->rsnie_present || arvif->wpaie_present) {
1252 arg->need_ptk_4_way = true;
1253 if (arvif->wpaie_present)
1254 arg->need_gtk_2_way = true;
1255 } else if (bss) {
1256 const struct cfg80211_bss_ies *ies;
1257
1258 rcu_read_lock();
1259 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1260
1261 ies = rcu_dereference(bss->ies);
1262
1263 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1264 WLAN_OUI_TYPE_MICROSOFT_WPA,
1265 ies->data,
1266 ies->len);
1267 rcu_read_unlock();
1268 cfg80211_put_bss(ar->hw->wiphy, bss);
1269 }
1270
1271 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1272 if (rsnie || wpaie) {
1273 ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
1274 "%s: rsn ie found\n", __func__);
1275 arg->need_ptk_4_way = true;
1276 }
1277
1278 if (wpaie) {
1279 ath12k_dbg(ar->ab, ATH12K_DBG_WMI,
1280 "%s: wpa ie found\n", __func__);
1281 arg->need_gtk_2_way = true;
1282 }
1283
1284 if (sta->mfp) {
1285 /* TODO: Need to check if FW supports PMF? */
1286 arg->is_pmf_enabled = true;
1287 }
1288
1289 /* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */
1290 }
1291
ath12k_peer_assoc_h_rates(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1292 static void ath12k_peer_assoc_h_rates(struct ath12k *ar,
1293 struct ieee80211_vif *vif,
1294 struct ieee80211_sta *sta,
1295 struct ath12k_wmi_peer_assoc_arg *arg)
1296 {
1297 struct ath12k_vif *arvif = (void *)vif->drv_priv;
1298 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1299 struct cfg80211_chan_def def;
1300 const struct ieee80211_supported_band *sband;
1301 const struct ieee80211_rate *rates;
1302 enum nl80211_band band;
1303 u32 ratemask;
1304 u8 rate;
1305 int i;
1306
1307 lockdep_assert_held(&ar->conf_mutex);
1308
1309 if (WARN_ON(ath12k_mac_vif_chan(vif, &def)))
1310 return;
1311
1312 band = def.chan->band;
1313 sband = ar->hw->wiphy->bands[band];
1314 ratemask = sta->deflink.supp_rates[band];
1315 ratemask &= arvif->bitrate_mask.control[band].legacy;
1316 rates = sband->bitrates;
1317
1318 rateset->num_rates = 0;
1319
1320 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1321 if (!(ratemask & 1))
1322 continue;
1323
1324 rate = ath12k_mac_bitrate_to_rate(rates->bitrate);
1325 rateset->rates[rateset->num_rates] = rate;
1326 rateset->num_rates++;
1327 }
1328 }
1329
1330 static bool
ath12k_peer_assoc_h_ht_masked(const u8 * ht_mcs_mask)1331 ath12k_peer_assoc_h_ht_masked(const u8 *ht_mcs_mask)
1332 {
1333 int nss;
1334
1335 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
1336 if (ht_mcs_mask[nss])
1337 return false;
1338
1339 return true;
1340 }
1341
1342 static bool
ath12k_peer_assoc_h_vht_masked(const u16 * vht_mcs_mask)1343 ath12k_peer_assoc_h_vht_masked(const u16 *vht_mcs_mask)
1344 {
1345 int nss;
1346
1347 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
1348 if (vht_mcs_mask[nss])
1349 return false;
1350
1351 return true;
1352 }
1353
ath12k_peer_assoc_h_ht(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1354 static void ath12k_peer_assoc_h_ht(struct ath12k *ar,
1355 struct ieee80211_vif *vif,
1356 struct ieee80211_sta *sta,
1357 struct ath12k_wmi_peer_assoc_arg *arg)
1358 {
1359 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
1360 struct ath12k_vif *arvif = (void *)vif->drv_priv;
1361 struct cfg80211_chan_def def;
1362 enum nl80211_band band;
1363 const u8 *ht_mcs_mask;
1364 int i, n;
1365 u8 max_nss;
1366 u32 stbc;
1367
1368 lockdep_assert_held(&ar->conf_mutex);
1369
1370 if (WARN_ON(ath12k_mac_vif_chan(vif, &def)))
1371 return;
1372
1373 if (!ht_cap->ht_supported)
1374 return;
1375
1376 band = def.chan->band;
1377 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
1378
1379 if (ath12k_peer_assoc_h_ht_masked(ht_mcs_mask))
1380 return;
1381
1382 arg->ht_flag = true;
1383
1384 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1385 ht_cap->ampdu_factor)) - 1;
1386
1387 arg->peer_mpdu_density =
1388 ath12k_parse_mpdudensity(ht_cap->ampdu_density);
1389
1390 arg->peer_ht_caps = ht_cap->cap;
1391 arg->peer_rate_caps |= WMI_HOST_RC_HT_FLAG;
1392
1393 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1394 arg->ldpc_flag = true;
1395
1396 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {
1397 arg->bw_40 = true;
1398 arg->peer_rate_caps |= WMI_HOST_RC_CW40_FLAG;
1399 }
1400
1401 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
1402 if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 |
1403 IEEE80211_HT_CAP_SGI_40))
1404 arg->peer_rate_caps |= WMI_HOST_RC_SGI_FLAG;
1405 }
1406
1407 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1408 arg->peer_rate_caps |= WMI_HOST_RC_TX_STBC_FLAG;
1409 arg->stbc_flag = true;
1410 }
1411
1412 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1413 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1414 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1415 stbc = stbc << WMI_HOST_RC_RX_STBC_FLAG_S;
1416 arg->peer_rate_caps |= stbc;
1417 arg->stbc_flag = true;
1418 }
1419
1420 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1421 arg->peer_rate_caps |= WMI_HOST_RC_TS_FLAG;
1422 else if (ht_cap->mcs.rx_mask[1])
1423 arg->peer_rate_caps |= WMI_HOST_RC_DS_FLAG;
1424
1425 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
1426 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
1427 (ht_mcs_mask[i / 8] & BIT(i % 8))) {
1428 max_nss = (i / 8) + 1;
1429 arg->peer_ht_rates.rates[n++] = i;
1430 }
1431
1432 /* This is a workaround for HT-enabled STAs which break the spec
1433 * and have no HT capabilities RX mask (no HT RX MCS map).
1434 *
1435 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1436 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1437 *
1438 * Firmware asserts if such situation occurs.
1439 */
1440 if (n == 0) {
1441 arg->peer_ht_rates.num_rates = 8;
1442 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1443 arg->peer_ht_rates.rates[i] = i;
1444 } else {
1445 arg->peer_ht_rates.num_rates = n;
1446 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1447 }
1448
1449 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1450 arg->peer_mac,
1451 arg->peer_ht_rates.num_rates,
1452 arg->peer_nss);
1453 }
1454
ath12k_mac_get_max_vht_mcs_map(u16 mcs_map,int nss)1455 static int ath12k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
1456 {
1457 switch ((mcs_map >> (2 * nss)) & 0x3) {
1458 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
1459 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
1460 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
1461 }
1462 return 0;
1463 }
1464
1465 static u16
ath12k_peer_assoc_h_vht_limit(u16 tx_mcs_set,const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])1466 ath12k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
1467 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
1468 {
1469 int idx_limit;
1470 int nss;
1471 u16 mcs_map;
1472 u16 mcs;
1473
1474 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
1475 mcs_map = ath12k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
1476 vht_mcs_limit[nss];
1477
1478 if (mcs_map)
1479 idx_limit = fls(mcs_map) - 1;
1480 else
1481 idx_limit = -1;
1482
1483 switch (idx_limit) {
1484 case 0:
1485 case 1:
1486 case 2:
1487 case 3:
1488 case 4:
1489 case 5:
1490 case 6:
1491 case 7:
1492 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
1493 break;
1494 case 8:
1495 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
1496 break;
1497 case 9:
1498 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
1499 break;
1500 default:
1501 WARN_ON(1);
1502 fallthrough;
1503 case -1:
1504 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
1505 break;
1506 }
1507
1508 tx_mcs_set &= ~(0x3 << (nss * 2));
1509 tx_mcs_set |= mcs << (nss * 2);
1510 }
1511
1512 return tx_mcs_set;
1513 }
1514
ath12k_peer_assoc_h_vht(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1515 static void ath12k_peer_assoc_h_vht(struct ath12k *ar,
1516 struct ieee80211_vif *vif,
1517 struct ieee80211_sta *sta,
1518 struct ath12k_wmi_peer_assoc_arg *arg)
1519 {
1520 const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
1521 struct ath12k_vif *arvif = (void *)vif->drv_priv;
1522 struct cfg80211_chan_def def;
1523 enum nl80211_band band;
1524 const u16 *vht_mcs_mask;
1525 u16 tx_mcs_map;
1526 u8 ampdu_factor;
1527 u8 max_nss, vht_mcs;
1528 int i;
1529
1530 if (WARN_ON(ath12k_mac_vif_chan(vif, &def)))
1531 return;
1532
1533 if (!vht_cap->vht_supported)
1534 return;
1535
1536 band = def.chan->band;
1537 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
1538
1539 if (ath12k_peer_assoc_h_vht_masked(vht_mcs_mask))
1540 return;
1541
1542 arg->vht_flag = true;
1543
1544 /* TODO: similar flags required? */
1545 arg->vht_capable = true;
1546
1547 if (def.chan->band == NL80211_BAND_2GHZ)
1548 arg->vht_ng_flag = true;
1549
1550 arg->peer_vht_caps = vht_cap->cap;
1551
1552 ampdu_factor = (vht_cap->cap &
1553 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1554 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1555
1556 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1557 * zero in VHT IE. Using it would result in degraded throughput.
1558 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1559 * it if VHT max_mpdu is smaller.
1560 */
1561 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1562 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1563 ampdu_factor)) - 1);
1564
1565 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
1566 arg->bw_80 = true;
1567
1568 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
1569 arg->bw_160 = true;
1570
1571 /* Calculate peer NSS capability from VHT capabilities if STA
1572 * supports VHT.
1573 */
1574 for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) {
1575 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
1576 (2 * i) & 3;
1577
1578 if (vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED &&
1579 vht_mcs_mask[i])
1580 max_nss = i + 1;
1581 }
1582 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1583 arg->rx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1584 arg->rx_mcs_set = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1585 arg->tx_max_rate = __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1586
1587 tx_mcs_map = __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1588 arg->tx_mcs_set = ath12k_peer_assoc_h_vht_limit(tx_mcs_map, vht_mcs_mask);
1589
1590 /* In QCN9274 platform, VHT MCS rate 10 and 11 is enabled by default.
1591 * VHT MCS rate 10 and 11 is not supported in 11ac standard.
1592 * so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode.
1593 */
1594 arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK;
1595 arg->tx_mcs_set |= IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11;
1596
1597 if ((arg->tx_mcs_set & IEEE80211_VHT_MCS_NOT_SUPPORTED) ==
1598 IEEE80211_VHT_MCS_NOT_SUPPORTED)
1599 arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
1600
1601 /* TODO: Check */
1602 arg->tx_max_mcs_nss = 0xFF;
1603
1604 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1605 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1606
1607 /* TODO: rxnss_override */
1608 }
1609
ath12k_peer_assoc_h_he(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1610 static void ath12k_peer_assoc_h_he(struct ath12k *ar,
1611 struct ieee80211_vif *vif,
1612 struct ieee80211_sta *sta,
1613 struct ath12k_wmi_peer_assoc_arg *arg)
1614 {
1615 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
1616 int i;
1617 u8 ampdu_factor, rx_mcs_80, rx_mcs_160, max_nss;
1618 u16 mcs_160_map, mcs_80_map;
1619 bool support_160;
1620 u16 v;
1621
1622 if (!he_cap->has_he)
1623 return;
1624
1625 arg->he_flag = true;
1626
1627 support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0] &
1628 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G);
1629
1630 /* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */
1631 mcs_160_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
1632 mcs_80_map = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
1633
1634 if (support_160) {
1635 for (i = 7; i >= 0; i--) {
1636 u8 mcs_160 = (mcs_160_map >> (2 * i)) & 3;
1637
1638 if (mcs_160 != IEEE80211_HE_MCS_NOT_SUPPORTED) {
1639 rx_mcs_160 = i + 1;
1640 break;
1641 }
1642 }
1643 }
1644
1645 for (i = 7; i >= 0; i--) {
1646 u8 mcs_80 = (mcs_80_map >> (2 * i)) & 3;
1647
1648 if (mcs_80 != IEEE80211_HE_MCS_NOT_SUPPORTED) {
1649 rx_mcs_80 = i + 1;
1650 break;
1651 }
1652 }
1653
1654 if (support_160)
1655 max_nss = min(rx_mcs_80, rx_mcs_160);
1656 else
1657 max_nss = rx_mcs_80;
1658
1659 arg->peer_nss = min(sta->deflink.rx_nss, max_nss);
1660
1661 memcpy(&arg->peer_he_cap_macinfo, he_cap->he_cap_elem.mac_cap_info,
1662 sizeof(he_cap->he_cap_elem.mac_cap_info));
1663 memcpy(&arg->peer_he_cap_phyinfo, he_cap->he_cap_elem.phy_cap_info,
1664 sizeof(he_cap->he_cap_elem.phy_cap_info));
1665 arg->peer_he_ops = vif->bss_conf.he_oper.params;
1666
1667 /* the top most byte is used to indicate BSS color info */
1668 arg->peer_he_ops &= 0xffffff;
1669
1670 /* As per section 26.6.1 IEEE Std 802.11ax‐2022, if the Max AMPDU
1671 * Exponent Extension in HE cap is zero, use the arg->peer_max_mpdu
1672 * as calculated while parsing VHT caps(if VHT caps is present)
1673 * or HT caps (if VHT caps is not present).
1674 *
1675 * For non-zero value of Max AMPDU Exponent Extension in HE MAC caps,
1676 * if a HE STA sends VHT cap and HE cap IE in assoc request then, use
1677 * MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length.
1678 * If a HE STA that does not send VHT cap, but HE and HT cap in assoc
1679 * request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu
1680 * length.
1681 */
1682 ampdu_factor = (he_cap->he_cap_elem.mac_cap_info[3] &
1683 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK) >>
1684 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK;
1685
1686 if (ampdu_factor) {
1687 if (sta->deflink.vht_cap.vht_supported)
1688 arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR +
1689 ampdu_factor)) - 1;
1690 else if (sta->deflink.ht_cap.ht_supported)
1691 arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR +
1692 ampdu_factor)) - 1;
1693 }
1694
1695 if (he_cap->he_cap_elem.phy_cap_info[6] &
1696 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
1697 int bit = 7;
1698 int nss, ru;
1699
1700 arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0] &
1701 IEEE80211_PPE_THRES_NSS_MASK;
1702 arg->peer_ppet.ru_bit_mask =
1703 (he_cap->ppe_thres[0] &
1704 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
1705 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
1706
1707 for (nss = 0; nss <= arg->peer_ppet.numss_m1; nss++) {
1708 for (ru = 0; ru < 4; ru++) {
1709 u32 val = 0;
1710 int i;
1711
1712 if ((arg->peer_ppet.ru_bit_mask & BIT(ru)) == 0)
1713 continue;
1714 for (i = 0; i < 6; i++) {
1715 val >>= 1;
1716 val |= ((he_cap->ppe_thres[bit / 8] >>
1717 (bit % 8)) & 0x1) << 5;
1718 bit++;
1719 }
1720 arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |=
1721 val << (ru * 6);
1722 }
1723 }
1724 }
1725
1726 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_RES)
1727 arg->twt_responder = true;
1728 if (he_cap->he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_TWT_REQ)
1729 arg->twt_requester = true;
1730
1731 switch (sta->deflink.bandwidth) {
1732 case IEEE80211_STA_RX_BW_160:
1733 if (he_cap->he_cap_elem.phy_cap_info[0] &
1734 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
1735 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80p80);
1736 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
1737
1738 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80p80);
1739 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80] = v;
1740
1741 arg->peer_he_mcs_count++;
1742 }
1743 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_160);
1744 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
1745
1746 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_160);
1747 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160] = v;
1748
1749 arg->peer_he_mcs_count++;
1750 fallthrough;
1751
1752 default:
1753 v = le16_to_cpu(he_cap->he_mcs_nss_supp.rx_mcs_80);
1754 arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
1755
1756 v = le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
1757 arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80] = v;
1758
1759 arg->peer_he_mcs_count++;
1760 break;
1761 }
1762 }
1763
ath12k_peer_assoc_h_smps(struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1764 static void ath12k_peer_assoc_h_smps(struct ieee80211_sta *sta,
1765 struct ath12k_wmi_peer_assoc_arg *arg)
1766 {
1767 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
1768 int smps;
1769
1770 if (!ht_cap->ht_supported)
1771 return;
1772
1773 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1774 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1775
1776 switch (smps) {
1777 case WLAN_HT_CAP_SM_PS_STATIC:
1778 arg->static_mimops_flag = true;
1779 break;
1780 case WLAN_HT_CAP_SM_PS_DYNAMIC:
1781 arg->dynamic_mimops_flag = true;
1782 break;
1783 case WLAN_HT_CAP_SM_PS_DISABLED:
1784 arg->spatial_mux_flag = true;
1785 break;
1786 default:
1787 break;
1788 }
1789 }
1790
ath12k_peer_assoc_h_qos(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1791 static void ath12k_peer_assoc_h_qos(struct ath12k *ar,
1792 struct ieee80211_vif *vif,
1793 struct ieee80211_sta *sta,
1794 struct ath12k_wmi_peer_assoc_arg *arg)
1795 {
1796 struct ath12k_vif *arvif = (void *)vif->drv_priv;
1797
1798 switch (arvif->vdev_type) {
1799 case WMI_VDEV_TYPE_AP:
1800 if (sta->wme) {
1801 /* TODO: Check WME vs QoS */
1802 arg->is_wme_set = true;
1803 arg->qos_flag = true;
1804 }
1805
1806 if (sta->wme && sta->uapsd_queues) {
1807 /* TODO: Check WME vs QoS */
1808 arg->is_wme_set = true;
1809 arg->apsd_flag = true;
1810 arg->peer_rate_caps |= WMI_HOST_RC_UAPSD_FLAG;
1811 }
1812 break;
1813 case WMI_VDEV_TYPE_STA:
1814 if (sta->wme) {
1815 arg->is_wme_set = true;
1816 arg->qos_flag = true;
1817 }
1818 break;
1819 default:
1820 break;
1821 }
1822
1823 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac peer %pM qos %d\n",
1824 sta->addr, arg->qos_flag);
1825 }
1826
ath12k_peer_assoc_qos_ap(struct ath12k * ar,struct ath12k_vif * arvif,struct ieee80211_sta * sta)1827 static int ath12k_peer_assoc_qos_ap(struct ath12k *ar,
1828 struct ath12k_vif *arvif,
1829 struct ieee80211_sta *sta)
1830 {
1831 struct ath12k_wmi_ap_ps_arg arg;
1832 u32 max_sp;
1833 u32 uapsd;
1834 int ret;
1835
1836 lockdep_assert_held(&ar->conf_mutex);
1837
1838 arg.vdev_id = arvif->vdev_id;
1839
1840 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1841 sta->uapsd_queues, sta->max_sp);
1842
1843 uapsd = 0;
1844 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1845 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1846 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1847 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1848 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1849 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1850 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1851 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1852 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1853 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1854 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1855 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1856
1857 max_sp = 0;
1858 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1859 max_sp = sta->max_sp;
1860
1861 arg.param = WMI_AP_PS_PEER_PARAM_UAPSD;
1862 arg.value = uapsd;
1863 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg);
1864 if (ret)
1865 goto err;
1866
1867 arg.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
1868 arg.value = max_sp;
1869 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg);
1870 if (ret)
1871 goto err;
1872
1873 /* TODO: revisit during testing */
1874 arg.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE;
1875 arg.value = DISABLE_SIFS_RESPONSE_TRIGGER;
1876 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg);
1877 if (ret)
1878 goto err;
1879
1880 arg.param = WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD;
1881 arg.value = DISABLE_SIFS_RESPONSE_TRIGGER;
1882 ret = ath12k_wmi_send_set_ap_ps_param_cmd(ar, sta->addr, &arg);
1883 if (ret)
1884 goto err;
1885
1886 return 0;
1887
1888 err:
1889 ath12k_warn(ar->ab, "failed to set ap ps peer param %d for vdev %i: %d\n",
1890 arg.param, arvif->vdev_id, ret);
1891 return ret;
1892 }
1893
ath12k_mac_sta_has_ofdm_only(struct ieee80211_sta * sta)1894 static bool ath12k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
1895 {
1896 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
1897 ATH12K_MAC_FIRST_OFDM_RATE_IDX;
1898 }
1899
ath12k_mac_get_phymode_vht(struct ath12k * ar,struct ieee80211_sta * sta)1900 static enum wmi_phy_mode ath12k_mac_get_phymode_vht(struct ath12k *ar,
1901 struct ieee80211_sta *sta)
1902 {
1903 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
1904 switch (sta->deflink.vht_cap.cap &
1905 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
1906 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
1907 return MODE_11AC_VHT160;
1908 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
1909 return MODE_11AC_VHT80_80;
1910 default:
1911 /* not sure if this is a valid case? */
1912 return MODE_11AC_VHT160;
1913 }
1914 }
1915
1916 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
1917 return MODE_11AC_VHT80;
1918
1919 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
1920 return MODE_11AC_VHT40;
1921
1922 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
1923 return MODE_11AC_VHT20;
1924
1925 return MODE_UNKNOWN;
1926 }
1927
ath12k_mac_get_phymode_he(struct ath12k * ar,struct ieee80211_sta * sta)1928 static enum wmi_phy_mode ath12k_mac_get_phymode_he(struct ath12k *ar,
1929 struct ieee80211_sta *sta)
1930 {
1931 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
1932 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
1933 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
1934 return MODE_11AX_HE160;
1935 else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
1936 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
1937 return MODE_11AX_HE80_80;
1938 /* not sure if this is a valid case? */
1939 return MODE_11AX_HE160;
1940 }
1941
1942 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
1943 return MODE_11AX_HE80;
1944
1945 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
1946 return MODE_11AX_HE40;
1947
1948 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
1949 return MODE_11AX_HE20;
1950
1951 return MODE_UNKNOWN;
1952 }
1953
ath12k_mac_get_phymode_eht(struct ath12k * ar,struct ieee80211_sta * sta)1954 static enum wmi_phy_mode ath12k_mac_get_phymode_eht(struct ath12k *ar,
1955 struct ieee80211_sta *sta)
1956 {
1957 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_320)
1958 if (sta->deflink.eht_cap.eht_cap_elem.phy_cap_info[0] &
1959 IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ)
1960 return MODE_11BE_EHT320;
1961
1962 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
1963 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
1964 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
1965 return MODE_11BE_EHT160;
1966
1967 if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0] &
1968 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
1969 return MODE_11BE_EHT80_80;
1970
1971 ath12k_warn(ar->ab, "invalid EHT PHY capability info for 160 Mhz: %d\n",
1972 sta->deflink.he_cap.he_cap_elem.phy_cap_info[0]);
1973
1974 return MODE_11BE_EHT160;
1975 }
1976
1977 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
1978 return MODE_11BE_EHT80;
1979
1980 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
1981 return MODE_11BE_EHT40;
1982
1983 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
1984 return MODE_11BE_EHT20;
1985
1986 return MODE_UNKNOWN;
1987 }
1988
ath12k_peer_assoc_h_phymode(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)1989 static void ath12k_peer_assoc_h_phymode(struct ath12k *ar,
1990 struct ieee80211_vif *vif,
1991 struct ieee80211_sta *sta,
1992 struct ath12k_wmi_peer_assoc_arg *arg)
1993 {
1994 struct ath12k_vif *arvif = (void *)vif->drv_priv;
1995 struct cfg80211_chan_def def;
1996 enum nl80211_band band;
1997 const u8 *ht_mcs_mask;
1998 const u16 *vht_mcs_mask;
1999 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2000
2001 if (WARN_ON(ath12k_mac_vif_chan(vif, &def)))
2002 return;
2003
2004 band = def.chan->band;
2005 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2006 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2007
2008 switch (band) {
2009 case NL80211_BAND_2GHZ:
2010 if (sta->deflink.eht_cap.has_eht) {
2011 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2012 phymode = MODE_11BE_EHT40_2G;
2013 else
2014 phymode = MODE_11BE_EHT20_2G;
2015 } else if (sta->deflink.he_cap.has_he) {
2016 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2017 phymode = MODE_11AX_HE80_2G;
2018 else if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2019 phymode = MODE_11AX_HE40_2G;
2020 else
2021 phymode = MODE_11AX_HE20_2G;
2022 } else if (sta->deflink.vht_cap.vht_supported &&
2023 !ath12k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2024 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2025 phymode = MODE_11AC_VHT40;
2026 else
2027 phymode = MODE_11AC_VHT20;
2028 } else if (sta->deflink.ht_cap.ht_supported &&
2029 !ath12k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2030 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2031 phymode = MODE_11NG_HT40;
2032 else
2033 phymode = MODE_11NG_HT20;
2034 } else if (ath12k_mac_sta_has_ofdm_only(sta)) {
2035 phymode = MODE_11G;
2036 } else {
2037 phymode = MODE_11B;
2038 }
2039 break;
2040 case NL80211_BAND_5GHZ:
2041 case NL80211_BAND_6GHZ:
2042 /* Check EHT first */
2043 if (sta->deflink.eht_cap.has_eht) {
2044 phymode = ath12k_mac_get_phymode_eht(ar, sta);
2045 } else if (sta->deflink.he_cap.has_he) {
2046 phymode = ath12k_mac_get_phymode_he(ar, sta);
2047 } else if (sta->deflink.vht_cap.vht_supported &&
2048 !ath12k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2049 phymode = ath12k_mac_get_phymode_vht(ar, sta);
2050 } else if (sta->deflink.ht_cap.ht_supported &&
2051 !ath12k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2052 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2053 phymode = MODE_11NA_HT40;
2054 else
2055 phymode = MODE_11NA_HT20;
2056 } else {
2057 phymode = MODE_11A;
2058 }
2059 break;
2060 default:
2061 break;
2062 }
2063
2064 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac peer %pM phymode %s\n",
2065 sta->addr, ath12k_mac_phymode_str(phymode));
2066
2067 arg->peer_phymode = phymode;
2068 WARN_ON(phymode == MODE_UNKNOWN);
2069 }
2070
ath12k_mac_set_eht_mcs(u8 rx_tx_mcs7,u8 rx_tx_mcs9,u8 rx_tx_mcs11,u8 rx_tx_mcs13,u32 * rx_mcs,u32 * tx_mcs)2071 static void ath12k_mac_set_eht_mcs(u8 rx_tx_mcs7, u8 rx_tx_mcs9,
2072 u8 rx_tx_mcs11, u8 rx_tx_mcs13,
2073 u32 *rx_mcs, u32 *tx_mcs)
2074 {
2075 *rx_mcs = 0;
2076 u32p_replace_bits(rx_mcs,
2077 u8_get_bits(rx_tx_mcs7, IEEE80211_EHT_MCS_NSS_RX),
2078 WMI_EHT_MCS_NSS_0_7);
2079 u32p_replace_bits(rx_mcs,
2080 u8_get_bits(rx_tx_mcs9, IEEE80211_EHT_MCS_NSS_RX),
2081 WMI_EHT_MCS_NSS_8_9);
2082 u32p_replace_bits(rx_mcs,
2083 u8_get_bits(rx_tx_mcs11, IEEE80211_EHT_MCS_NSS_RX),
2084 WMI_EHT_MCS_NSS_10_11);
2085 u32p_replace_bits(rx_mcs,
2086 u8_get_bits(rx_tx_mcs13, IEEE80211_EHT_MCS_NSS_RX),
2087 WMI_EHT_MCS_NSS_12_13);
2088
2089 *tx_mcs = 0;
2090 u32p_replace_bits(tx_mcs,
2091 u8_get_bits(rx_tx_mcs7, IEEE80211_EHT_MCS_NSS_TX),
2092 WMI_EHT_MCS_NSS_0_7);
2093 u32p_replace_bits(tx_mcs,
2094 u8_get_bits(rx_tx_mcs9, IEEE80211_EHT_MCS_NSS_TX),
2095 WMI_EHT_MCS_NSS_8_9);
2096 u32p_replace_bits(tx_mcs,
2097 u8_get_bits(rx_tx_mcs11, IEEE80211_EHT_MCS_NSS_TX),
2098 WMI_EHT_MCS_NSS_10_11);
2099 u32p_replace_bits(tx_mcs,
2100 u8_get_bits(rx_tx_mcs13, IEEE80211_EHT_MCS_NSS_TX),
2101 WMI_EHT_MCS_NSS_12_13);
2102 }
2103
ath12k_mac_set_eht_ppe_threshold(const u8 * ppe_thres,struct ath12k_wmi_ppe_threshold_arg * ppet)2104 static void ath12k_mac_set_eht_ppe_threshold(const u8 *ppe_thres,
2105 struct ath12k_wmi_ppe_threshold_arg *ppet)
2106 {
2107 u32 bit_pos = IEEE80211_EHT_PPE_THRES_INFO_HEADER_SIZE, val;
2108 u8 nss, ru, i;
2109 u8 ppet_bit_len_per_ru = IEEE80211_EHT_PPE_THRES_INFO_PPET_SIZE * 2;
2110
2111 ppet->numss_m1 = u8_get_bits(ppe_thres[0], IEEE80211_EHT_PPE_THRES_NSS_MASK);
2112 ppet->ru_bit_mask = u16_get_bits(get_unaligned_le16(ppe_thres),
2113 IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK);
2114
2115 for (nss = 0; nss <= ppet->numss_m1; nss++) {
2116 for (ru = 0;
2117 ru < hweight16(IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK);
2118 ru++) {
2119 if ((ppet->ru_bit_mask & BIT(ru)) == 0)
2120 continue;
2121
2122 val = 0;
2123 for (i = 0; i < ppet_bit_len_per_ru; i++) {
2124 val |= (((ppe_thres[bit_pos / 8] >>
2125 (bit_pos % 8)) & 0x1) << i);
2126 bit_pos++;
2127 }
2128 ppet->ppet16_ppet8_ru3_ru0[nss] |=
2129 (val << (ru * ppet_bit_len_per_ru));
2130 }
2131 }
2132 }
2133
ath12k_peer_assoc_h_eht(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg)2134 static void ath12k_peer_assoc_h_eht(struct ath12k *ar,
2135 struct ieee80211_vif *vif,
2136 struct ieee80211_sta *sta,
2137 struct ath12k_wmi_peer_assoc_arg *arg)
2138 {
2139 const struct ieee80211_sta_eht_cap *eht_cap = &sta->deflink.eht_cap;
2140 const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap;
2141 const struct ieee80211_eht_mcs_nss_supp_20mhz_only *bw_20;
2142 const struct ieee80211_eht_mcs_nss_supp_bw *bw;
2143 struct ath12k_vif *arvif = (struct ath12k_vif *)vif->drv_priv;
2144 u32 *rx_mcs, *tx_mcs;
2145
2146 if (!sta->deflink.he_cap.has_he || !eht_cap->has_eht)
2147 return;
2148
2149 arg->eht_flag = true;
2150
2151 if ((eht_cap->eht_cap_elem.phy_cap_info[5] &
2152 IEEE80211_EHT_PHY_CAP5_PPE_THRESHOLD_PRESENT) &&
2153 eht_cap->eht_ppe_thres[0] != 0)
2154 ath12k_mac_set_eht_ppe_threshold(eht_cap->eht_ppe_thres,
2155 &arg->peer_eht_ppet);
2156
2157 memcpy(arg->peer_eht_cap_mac, eht_cap->eht_cap_elem.mac_cap_info,
2158 sizeof(eht_cap->eht_cap_elem.mac_cap_info));
2159 memcpy(arg->peer_eht_cap_phy, eht_cap->eht_cap_elem.phy_cap_info,
2160 sizeof(eht_cap->eht_cap_elem.phy_cap_info));
2161
2162 rx_mcs = arg->peer_eht_rx_mcs_set;
2163 tx_mcs = arg->peer_eht_tx_mcs_set;
2164
2165 switch (sta->deflink.bandwidth) {
2166 case IEEE80211_STA_RX_BW_320:
2167 bw = &eht_cap->eht_mcs_nss_supp.bw._320;
2168 ath12k_mac_set_eht_mcs(bw->rx_tx_mcs9_max_nss,
2169 bw->rx_tx_mcs9_max_nss,
2170 bw->rx_tx_mcs11_max_nss,
2171 bw->rx_tx_mcs13_max_nss,
2172 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_320],
2173 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_320]);
2174 arg->peer_eht_mcs_count++;
2175 fallthrough;
2176 case IEEE80211_STA_RX_BW_160:
2177 bw = &eht_cap->eht_mcs_nss_supp.bw._160;
2178 ath12k_mac_set_eht_mcs(bw->rx_tx_mcs9_max_nss,
2179 bw->rx_tx_mcs9_max_nss,
2180 bw->rx_tx_mcs11_max_nss,
2181 bw->rx_tx_mcs13_max_nss,
2182 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_160],
2183 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_160]);
2184 arg->peer_eht_mcs_count++;
2185 fallthrough;
2186 default:
2187 if ((he_cap->he_cap_elem.phy_cap_info[0] &
2188 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G |
2189 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
2190 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
2191 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0) {
2192 bw_20 = &eht_cap->eht_mcs_nss_supp.only_20mhz;
2193
2194 ath12k_mac_set_eht_mcs(bw_20->rx_tx_mcs7_max_nss,
2195 bw_20->rx_tx_mcs9_max_nss,
2196 bw_20->rx_tx_mcs11_max_nss,
2197 bw_20->rx_tx_mcs13_max_nss,
2198 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80],
2199 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80]);
2200 } else {
2201 bw = &eht_cap->eht_mcs_nss_supp.bw._80;
2202 ath12k_mac_set_eht_mcs(bw->rx_tx_mcs9_max_nss,
2203 bw->rx_tx_mcs9_max_nss,
2204 bw->rx_tx_mcs11_max_nss,
2205 bw->rx_tx_mcs13_max_nss,
2206 &rx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80],
2207 &tx_mcs[WMI_EHTCAP_TXRX_MCS_NSS_IDX_80]);
2208 }
2209
2210 arg->peer_eht_mcs_count++;
2211 break;
2212 }
2213
2214 arg->punct_bitmap = ~arvif->punct_bitmap;
2215 }
2216
ath12k_peer_assoc_prepare(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_assoc_arg * arg,bool reassoc)2217 static void ath12k_peer_assoc_prepare(struct ath12k *ar,
2218 struct ieee80211_vif *vif,
2219 struct ieee80211_sta *sta,
2220 struct ath12k_wmi_peer_assoc_arg *arg,
2221 bool reassoc)
2222 {
2223 lockdep_assert_held(&ar->conf_mutex);
2224
2225 memset(arg, 0, sizeof(*arg));
2226
2227 reinit_completion(&ar->peer_assoc_done);
2228
2229 arg->peer_new_assoc = !reassoc;
2230 ath12k_peer_assoc_h_basic(ar, vif, sta, arg);
2231 ath12k_peer_assoc_h_crypto(ar, vif, sta, arg);
2232 ath12k_peer_assoc_h_rates(ar, vif, sta, arg);
2233 ath12k_peer_assoc_h_ht(ar, vif, sta, arg);
2234 ath12k_peer_assoc_h_vht(ar, vif, sta, arg);
2235 ath12k_peer_assoc_h_he(ar, vif, sta, arg);
2236 ath12k_peer_assoc_h_eht(ar, vif, sta, arg);
2237 ath12k_peer_assoc_h_qos(ar, vif, sta, arg);
2238 ath12k_peer_assoc_h_phymode(ar, vif, sta, arg);
2239 ath12k_peer_assoc_h_smps(sta, arg);
2240
2241 /* TODO: amsdu_disable req? */
2242 }
2243
ath12k_setup_peer_smps(struct ath12k * ar,struct ath12k_vif * arvif,const u8 * addr,const struct ieee80211_sta_ht_cap * ht_cap)2244 static int ath12k_setup_peer_smps(struct ath12k *ar, struct ath12k_vif *arvif,
2245 const u8 *addr,
2246 const struct ieee80211_sta_ht_cap *ht_cap)
2247 {
2248 int smps;
2249
2250 if (!ht_cap->ht_supported)
2251 return 0;
2252
2253 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2254 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2255
2256 if (smps >= ARRAY_SIZE(ath12k_smps_map))
2257 return -EINVAL;
2258
2259 return ath12k_wmi_set_peer_param(ar, addr, arvif->vdev_id,
2260 WMI_PEER_MIMO_PS_STATE,
2261 ath12k_smps_map[smps]);
2262 }
2263
ath12k_bss_assoc(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * bss_conf)2264 static void ath12k_bss_assoc(struct ieee80211_hw *hw,
2265 struct ieee80211_vif *vif,
2266 struct ieee80211_bss_conf *bss_conf)
2267 {
2268 struct ath12k *ar = hw->priv;
2269 struct ath12k_vif *arvif = (void *)vif->drv_priv;
2270 struct ath12k_wmi_peer_assoc_arg peer_arg;
2271 struct ieee80211_sta *ap_sta;
2272 struct ath12k_peer *peer;
2273 bool is_auth = false;
2274 int ret;
2275
2276 lockdep_assert_held(&ar->conf_mutex);
2277
2278 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2279 arvif->vdev_id, arvif->bssid, arvif->aid);
2280
2281 rcu_read_lock();
2282
2283 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2284 if (!ap_sta) {
2285 ath12k_warn(ar->ab, "failed to find station entry for bss %pM vdev %i\n",
2286 bss_conf->bssid, arvif->vdev_id);
2287 rcu_read_unlock();
2288 return;
2289 }
2290
2291 ath12k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg, false);
2292
2293 rcu_read_unlock();
2294
2295 ret = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
2296 if (ret) {
2297 ath12k_warn(ar->ab, "failed to run peer assoc for %pM vdev %i: %d\n",
2298 bss_conf->bssid, arvif->vdev_id, ret);
2299 return;
2300 }
2301
2302 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
2303 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
2304 bss_conf->bssid, arvif->vdev_id);
2305 return;
2306 }
2307
2308 ret = ath12k_setup_peer_smps(ar, arvif, bss_conf->bssid,
2309 &ap_sta->deflink.ht_cap);
2310 if (ret) {
2311 ath12k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
2312 arvif->vdev_id, ret);
2313 return;
2314 }
2315
2316 WARN_ON(arvif->is_up);
2317
2318 arvif->aid = vif->cfg.aid;
2319 ether_addr_copy(arvif->bssid, bss_conf->bssid);
2320
2321 ret = ath12k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2322 if (ret) {
2323 ath12k_warn(ar->ab, "failed to set vdev %d up: %d\n",
2324 arvif->vdev_id, ret);
2325 return;
2326 }
2327
2328 arvif->is_up = true;
2329
2330 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2331 "mac vdev %d up (associated) bssid %pM aid %d\n",
2332 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
2333
2334 spin_lock_bh(&ar->ab->base_lock);
2335
2336 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, arvif->bssid);
2337 if (peer && peer->is_authorized)
2338 is_auth = true;
2339
2340 spin_unlock_bh(&ar->ab->base_lock);
2341
2342 /* Authorize BSS Peer */
2343 if (is_auth) {
2344 ret = ath12k_wmi_set_peer_param(ar, arvif->bssid,
2345 arvif->vdev_id,
2346 WMI_PEER_AUTHORIZE,
2347 1);
2348 if (ret)
2349 ath12k_warn(ar->ab, "Unable to authorize BSS peer: %d\n", ret);
2350 }
2351
2352 ret = ath12k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
2353 &bss_conf->he_obss_pd);
2354 if (ret)
2355 ath12k_warn(ar->ab, "failed to set vdev %i OBSS PD parameters: %d\n",
2356 arvif->vdev_id, ret);
2357 }
2358
ath12k_bss_disassoc(struct ieee80211_hw * hw,struct ieee80211_vif * vif)2359 static void ath12k_bss_disassoc(struct ieee80211_hw *hw,
2360 struct ieee80211_vif *vif)
2361 {
2362 struct ath12k *ar = hw->priv;
2363 struct ath12k_vif *arvif = (void *)vif->drv_priv;
2364 int ret;
2365
2366 lockdep_assert_held(&ar->conf_mutex);
2367
2368 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2369 arvif->vdev_id, arvif->bssid);
2370
2371 ret = ath12k_wmi_vdev_down(ar, arvif->vdev_id);
2372 if (ret)
2373 ath12k_warn(ar->ab, "failed to down vdev %i: %d\n",
2374 arvif->vdev_id, ret);
2375
2376 arvif->is_up = false;
2377
2378 /* TODO: cancel connection_loss_work */
2379 }
2380
ath12k_mac_get_rate_hw_value(int bitrate)2381 static u32 ath12k_mac_get_rate_hw_value(int bitrate)
2382 {
2383 u32 preamble;
2384 u16 hw_value;
2385 int rate;
2386 size_t i;
2387
2388 if (ath12k_mac_bitrate_is_cck(bitrate))
2389 preamble = WMI_RATE_PREAMBLE_CCK;
2390 else
2391 preamble = WMI_RATE_PREAMBLE_OFDM;
2392
2393 for (i = 0; i < ARRAY_SIZE(ath12k_legacy_rates); i++) {
2394 if (ath12k_legacy_rates[i].bitrate != bitrate)
2395 continue;
2396
2397 hw_value = ath12k_legacy_rates[i].hw_value;
2398 rate = ATH12K_HW_RATE_CODE(hw_value, 0, preamble);
2399
2400 return rate;
2401 }
2402
2403 return -EINVAL;
2404 }
2405
ath12k_recalculate_mgmt_rate(struct ath12k * ar,struct ieee80211_vif * vif,struct cfg80211_chan_def * def)2406 static void ath12k_recalculate_mgmt_rate(struct ath12k *ar,
2407 struct ieee80211_vif *vif,
2408 struct cfg80211_chan_def *def)
2409 {
2410 struct ath12k_vif *arvif = (void *)vif->drv_priv;
2411 const struct ieee80211_supported_band *sband;
2412 u8 basic_rate_idx;
2413 int hw_rate_code;
2414 u32 vdev_param;
2415 u16 bitrate;
2416 int ret;
2417
2418 lockdep_assert_held(&ar->conf_mutex);
2419
2420 sband = ar->hw->wiphy->bands[def->chan->band];
2421 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
2422 bitrate = sband->bitrates[basic_rate_idx].bitrate;
2423
2424 hw_rate_code = ath12k_mac_get_rate_hw_value(bitrate);
2425 if (hw_rate_code < 0) {
2426 ath12k_warn(ar->ab, "bitrate not supported %d\n", bitrate);
2427 return;
2428 }
2429
2430 vdev_param = WMI_VDEV_PARAM_MGMT_RATE;
2431 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
2432 hw_rate_code);
2433 if (ret)
2434 ath12k_warn(ar->ab, "failed to set mgmt tx rate %d\n", ret);
2435
2436 vdev_param = WMI_VDEV_PARAM_BEACON_RATE;
2437 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id, vdev_param,
2438 hw_rate_code);
2439 if (ret)
2440 ath12k_warn(ar->ab, "failed to set beacon tx rate %d\n", ret);
2441 }
2442
ath12k_mac_fils_discovery(struct ath12k_vif * arvif,struct ieee80211_bss_conf * info)2443 static int ath12k_mac_fils_discovery(struct ath12k_vif *arvif,
2444 struct ieee80211_bss_conf *info)
2445 {
2446 struct ath12k *ar = arvif->ar;
2447 struct sk_buff *tmpl;
2448 int ret;
2449 u32 interval;
2450 bool unsol_bcast_probe_resp_enabled = false;
2451
2452 if (info->fils_discovery.max_interval) {
2453 interval = info->fils_discovery.max_interval;
2454
2455 tmpl = ieee80211_get_fils_discovery_tmpl(ar->hw, arvif->vif);
2456 if (tmpl)
2457 ret = ath12k_wmi_fils_discovery_tmpl(ar, arvif->vdev_id,
2458 tmpl);
2459 } else if (info->unsol_bcast_probe_resp_interval) {
2460 unsol_bcast_probe_resp_enabled = 1;
2461 interval = info->unsol_bcast_probe_resp_interval;
2462
2463 tmpl = ieee80211_get_unsol_bcast_probe_resp_tmpl(ar->hw,
2464 arvif->vif);
2465 if (tmpl)
2466 ret = ath12k_wmi_probe_resp_tmpl(ar, arvif->vdev_id,
2467 tmpl);
2468 } else { /* Disable */
2469 return ath12k_wmi_fils_discovery(ar, arvif->vdev_id, 0, false);
2470 }
2471
2472 if (!tmpl) {
2473 ath12k_warn(ar->ab,
2474 "mac vdev %i failed to retrieve %s template\n",
2475 arvif->vdev_id, (unsol_bcast_probe_resp_enabled ?
2476 "unsolicited broadcast probe response" :
2477 "FILS discovery"));
2478 return -EPERM;
2479 }
2480 kfree_skb(tmpl);
2481
2482 if (!ret)
2483 ret = ath12k_wmi_fils_discovery(ar, arvif->vdev_id, interval,
2484 unsol_bcast_probe_resp_enabled);
2485
2486 return ret;
2487 }
2488
ath12k_mac_op_bss_info_changed(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * info,u64 changed)2489 static void ath12k_mac_op_bss_info_changed(struct ieee80211_hw *hw,
2490 struct ieee80211_vif *vif,
2491 struct ieee80211_bss_conf *info,
2492 u64 changed)
2493 {
2494 struct ath12k *ar = hw->priv;
2495 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
2496 struct cfg80211_chan_def def;
2497 u32 param_id, param_value;
2498 enum nl80211_band band;
2499 u32 vdev_param;
2500 int mcast_rate;
2501 u32 preamble;
2502 u16 hw_value;
2503 u16 bitrate;
2504 int ret;
2505 u8 rateidx;
2506 u32 rate;
2507
2508 mutex_lock(&ar->conf_mutex);
2509
2510 if (changed & BSS_CHANGED_BEACON_INT) {
2511 arvif->beacon_interval = info->beacon_int;
2512
2513 param_id = WMI_VDEV_PARAM_BEACON_INTERVAL;
2514 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2515 param_id,
2516 arvif->beacon_interval);
2517 if (ret)
2518 ath12k_warn(ar->ab, "Failed to set beacon interval for VDEV: %d\n",
2519 arvif->vdev_id);
2520 else
2521 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2522 "Beacon interval: %d set for VDEV: %d\n",
2523 arvif->beacon_interval, arvif->vdev_id);
2524 }
2525
2526 if (changed & BSS_CHANGED_BEACON) {
2527 param_id = WMI_PDEV_PARAM_BEACON_TX_MODE;
2528 param_value = WMI_BEACON_STAGGERED_MODE;
2529 ret = ath12k_wmi_pdev_set_param(ar, param_id,
2530 param_value, ar->pdev->pdev_id);
2531 if (ret)
2532 ath12k_warn(ar->ab, "Failed to set beacon mode for VDEV: %d\n",
2533 arvif->vdev_id);
2534 else
2535 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2536 "Set staggered beacon mode for VDEV: %d\n",
2537 arvif->vdev_id);
2538
2539 ret = ath12k_mac_setup_bcn_tmpl(arvif);
2540 if (ret)
2541 ath12k_warn(ar->ab, "failed to update bcn template: %d\n",
2542 ret);
2543 }
2544
2545 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
2546 arvif->dtim_period = info->dtim_period;
2547
2548 param_id = WMI_VDEV_PARAM_DTIM_PERIOD;
2549 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2550 param_id,
2551 arvif->dtim_period);
2552
2553 if (ret)
2554 ath12k_warn(ar->ab, "Failed to set dtim period for VDEV %d: %i\n",
2555 arvif->vdev_id, ret);
2556 else
2557 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2558 "DTIM period: %d set for VDEV: %d\n",
2559 arvif->dtim_period, arvif->vdev_id);
2560 }
2561
2562 if (changed & BSS_CHANGED_SSID &&
2563 vif->type == NL80211_IFTYPE_AP) {
2564 arvif->u.ap.ssid_len = vif->cfg.ssid_len;
2565 if (vif->cfg.ssid_len)
2566 memcpy(arvif->u.ap.ssid, vif->cfg.ssid, vif->cfg.ssid_len);
2567 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2568 }
2569
2570 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
2571 ether_addr_copy(arvif->bssid, info->bssid);
2572
2573 if (changed & BSS_CHANGED_BEACON_ENABLED) {
2574 ath12k_control_beaconing(arvif, info);
2575
2576 if (arvif->is_up && vif->bss_conf.he_support &&
2577 vif->bss_conf.he_oper.params) {
2578 /* TODO: Extend to support 1024 BA Bitmap size */
2579 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2580 WMI_VDEV_PARAM_BA_MODE,
2581 WMI_BA_MODE_BUFFER_SIZE_256);
2582 if (ret)
2583 ath12k_warn(ar->ab,
2584 "failed to set BA BUFFER SIZE 256 for vdev: %d\n",
2585 arvif->vdev_id);
2586
2587 param_id = WMI_VDEV_PARAM_HEOPS_0_31;
2588 param_value = vif->bss_conf.he_oper.params;
2589 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2590 param_id, param_value);
2591 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2592 "he oper param: %x set for VDEV: %d\n",
2593 param_value, arvif->vdev_id);
2594
2595 if (ret)
2596 ath12k_warn(ar->ab, "Failed to set he oper params %x for VDEV %d: %i\n",
2597 param_value, arvif->vdev_id, ret);
2598 }
2599 }
2600
2601 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2602 u32 cts_prot;
2603
2604 cts_prot = !!(info->use_cts_prot);
2605 param_id = WMI_VDEV_PARAM_PROTECTION_MODE;
2606
2607 if (arvif->is_started) {
2608 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2609 param_id, cts_prot);
2610 if (ret)
2611 ath12k_warn(ar->ab, "Failed to set CTS prot for VDEV: %d\n",
2612 arvif->vdev_id);
2613 else
2614 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "Set CTS prot: %d for VDEV: %d\n",
2615 cts_prot, arvif->vdev_id);
2616 } else {
2617 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "defer protection mode setup, vdev is not ready yet\n");
2618 }
2619 }
2620
2621 if (changed & BSS_CHANGED_ERP_SLOT) {
2622 u32 slottime;
2623
2624 if (info->use_short_slot)
2625 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2626
2627 else
2628 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2629
2630 param_id = WMI_VDEV_PARAM_SLOT_TIME;
2631 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2632 param_id, slottime);
2633 if (ret)
2634 ath12k_warn(ar->ab, "Failed to set erp slot for VDEV: %d\n",
2635 arvif->vdev_id);
2636 else
2637 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2638 "Set slottime: %d for VDEV: %d\n",
2639 slottime, arvif->vdev_id);
2640 }
2641
2642 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2643 u32 preamble;
2644
2645 if (info->use_short_preamble)
2646 preamble = WMI_VDEV_PREAMBLE_SHORT;
2647 else
2648 preamble = WMI_VDEV_PREAMBLE_LONG;
2649
2650 param_id = WMI_VDEV_PARAM_PREAMBLE;
2651 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2652 param_id, preamble);
2653 if (ret)
2654 ath12k_warn(ar->ab, "Failed to set preamble for VDEV: %d\n",
2655 arvif->vdev_id);
2656 else
2657 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2658 "Set preamble: %d for VDEV: %d\n",
2659 preamble, arvif->vdev_id);
2660 }
2661
2662 if (changed & BSS_CHANGED_ASSOC) {
2663 if (vif->cfg.assoc)
2664 ath12k_bss_assoc(hw, vif, info);
2665 else
2666 ath12k_bss_disassoc(hw, vif);
2667 }
2668
2669 if (changed & BSS_CHANGED_TXPOWER) {
2670 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac vdev_id %i txpower %d\n",
2671 arvif->vdev_id, info->txpower);
2672
2673 arvif->txpower = info->txpower;
2674 ath12k_mac_txpower_recalc(ar);
2675 }
2676
2677 if (changed & BSS_CHANGED_MCAST_RATE &&
2678 !ath12k_mac_vif_chan(arvif->vif, &def)) {
2679 band = def.chan->band;
2680 mcast_rate = vif->bss_conf.mcast_rate[band];
2681
2682 if (mcast_rate > 0)
2683 rateidx = mcast_rate - 1;
2684 else
2685 rateidx = ffs(vif->bss_conf.basic_rates) - 1;
2686
2687 if (ar->pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP)
2688 rateidx += ATH12K_MAC_FIRST_OFDM_RATE_IDX;
2689
2690 bitrate = ath12k_legacy_rates[rateidx].bitrate;
2691 hw_value = ath12k_legacy_rates[rateidx].hw_value;
2692
2693 if (ath12k_mac_bitrate_is_cck(bitrate))
2694 preamble = WMI_RATE_PREAMBLE_CCK;
2695 else
2696 preamble = WMI_RATE_PREAMBLE_OFDM;
2697
2698 rate = ATH12K_HW_RATE_CODE(hw_value, 0, preamble);
2699
2700 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
2701 "mac vdev %d mcast_rate %x\n",
2702 arvif->vdev_id, rate);
2703
2704 vdev_param = WMI_VDEV_PARAM_MCAST_DATA_RATE;
2705 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2706 vdev_param, rate);
2707 if (ret)
2708 ath12k_warn(ar->ab,
2709 "failed to set mcast rate on vdev %i: %d\n",
2710 arvif->vdev_id, ret);
2711
2712 vdev_param = WMI_VDEV_PARAM_BCAST_DATA_RATE;
2713 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
2714 vdev_param, rate);
2715 if (ret)
2716 ath12k_warn(ar->ab,
2717 "failed to set bcast rate on vdev %i: %d\n",
2718 arvif->vdev_id, ret);
2719 }
2720
2721 if (changed & BSS_CHANGED_BASIC_RATES &&
2722 !ath12k_mac_vif_chan(arvif->vif, &def))
2723 ath12k_recalculate_mgmt_rate(ar, vif, &def);
2724
2725 if (changed & BSS_CHANGED_TWT) {
2726 if (info->twt_requester || info->twt_responder)
2727 ath12k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id);
2728 else
2729 ath12k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
2730 }
2731
2732 if (changed & BSS_CHANGED_HE_OBSS_PD)
2733 ath12k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id,
2734 &info->he_obss_pd);
2735
2736 if (changed & BSS_CHANGED_HE_BSS_COLOR) {
2737 if (vif->type == NL80211_IFTYPE_AP) {
2738 ret = ath12k_wmi_obss_color_cfg_cmd(ar,
2739 arvif->vdev_id,
2740 info->he_bss_color.color,
2741 ATH12K_BSS_COLOR_AP_PERIODS,
2742 info->he_bss_color.enabled);
2743 if (ret)
2744 ath12k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
2745 arvif->vdev_id, ret);
2746 } else if (vif->type == NL80211_IFTYPE_STATION) {
2747 ret = ath12k_wmi_send_bss_color_change_enable_cmd(ar,
2748 arvif->vdev_id,
2749 1);
2750 if (ret)
2751 ath12k_warn(ar->ab, "failed to enable bss color change on vdev %i: %d\n",
2752 arvif->vdev_id, ret);
2753 ret = ath12k_wmi_obss_color_cfg_cmd(ar,
2754 arvif->vdev_id,
2755 0,
2756 ATH12K_BSS_COLOR_STA_PERIODS,
2757 1);
2758 if (ret)
2759 ath12k_warn(ar->ab, "failed to set bss color collision on vdev %i: %d\n",
2760 arvif->vdev_id, ret);
2761 }
2762 }
2763
2764 if (changed & BSS_CHANGED_FILS_DISCOVERY ||
2765 changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP)
2766 ath12k_mac_fils_discovery(arvif, info);
2767
2768 if (changed & BSS_CHANGED_EHT_PUNCTURING)
2769 arvif->punct_bitmap = info->eht_puncturing;
2770
2771 mutex_unlock(&ar->conf_mutex);
2772 }
2773
__ath12k_mac_scan_finish(struct ath12k * ar)2774 void __ath12k_mac_scan_finish(struct ath12k *ar)
2775 {
2776 lockdep_assert_held(&ar->data_lock);
2777
2778 switch (ar->scan.state) {
2779 case ATH12K_SCAN_IDLE:
2780 break;
2781 case ATH12K_SCAN_RUNNING:
2782 case ATH12K_SCAN_ABORTING:
2783 if (!ar->scan.is_roc) {
2784 struct cfg80211_scan_info info = {
2785 .aborted = (ar->scan.state ==
2786 ATH12K_SCAN_ABORTING),
2787 };
2788
2789 ieee80211_scan_completed(ar->hw, &info);
2790 } else if (ar->scan.roc_notify) {
2791 ieee80211_remain_on_channel_expired(ar->hw);
2792 }
2793 fallthrough;
2794 case ATH12K_SCAN_STARTING:
2795 ar->scan.state = ATH12K_SCAN_IDLE;
2796 ar->scan_channel = NULL;
2797 ar->scan.roc_freq = 0;
2798 cancel_delayed_work(&ar->scan.timeout);
2799 complete(&ar->scan.completed);
2800 break;
2801 }
2802 }
2803
ath12k_mac_scan_finish(struct ath12k * ar)2804 void ath12k_mac_scan_finish(struct ath12k *ar)
2805 {
2806 spin_lock_bh(&ar->data_lock);
2807 __ath12k_mac_scan_finish(ar);
2808 spin_unlock_bh(&ar->data_lock);
2809 }
2810
ath12k_scan_stop(struct ath12k * ar)2811 static int ath12k_scan_stop(struct ath12k *ar)
2812 {
2813 struct ath12k_wmi_scan_cancel_arg arg = {
2814 .req_type = WLAN_SCAN_CANCEL_SINGLE,
2815 .scan_id = ATH12K_SCAN_ID,
2816 };
2817 int ret;
2818
2819 lockdep_assert_held(&ar->conf_mutex);
2820
2821 /* TODO: Fill other STOP Params */
2822 arg.pdev_id = ar->pdev->pdev_id;
2823
2824 ret = ath12k_wmi_send_scan_stop_cmd(ar, &arg);
2825 if (ret) {
2826 ath12k_warn(ar->ab, "failed to stop wmi scan: %d\n", ret);
2827 goto out;
2828 }
2829
2830 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
2831 if (ret == 0) {
2832 ath12k_warn(ar->ab,
2833 "failed to receive scan abort comple: timed out\n");
2834 ret = -ETIMEDOUT;
2835 } else if (ret > 0) {
2836 ret = 0;
2837 }
2838
2839 out:
2840 /* Scan state should be updated upon scan completion but in case
2841 * firmware fails to deliver the event (for whatever reason) it is
2842 * desired to clean up scan state anyway. Firmware may have just
2843 * dropped the scan completion event delivery due to transport pipe
2844 * being overflown with data and/or it can recover on its own before
2845 * next scan request is submitted.
2846 */
2847 spin_lock_bh(&ar->data_lock);
2848 if (ar->scan.state != ATH12K_SCAN_IDLE)
2849 __ath12k_mac_scan_finish(ar);
2850 spin_unlock_bh(&ar->data_lock);
2851
2852 return ret;
2853 }
2854
ath12k_scan_abort(struct ath12k * ar)2855 static void ath12k_scan_abort(struct ath12k *ar)
2856 {
2857 int ret;
2858
2859 lockdep_assert_held(&ar->conf_mutex);
2860
2861 spin_lock_bh(&ar->data_lock);
2862
2863 switch (ar->scan.state) {
2864 case ATH12K_SCAN_IDLE:
2865 /* This can happen if timeout worker kicked in and called
2866 * abortion while scan completion was being processed.
2867 */
2868 break;
2869 case ATH12K_SCAN_STARTING:
2870 case ATH12K_SCAN_ABORTING:
2871 ath12k_warn(ar->ab, "refusing scan abortion due to invalid scan state: %d\n",
2872 ar->scan.state);
2873 break;
2874 case ATH12K_SCAN_RUNNING:
2875 ar->scan.state = ATH12K_SCAN_ABORTING;
2876 spin_unlock_bh(&ar->data_lock);
2877
2878 ret = ath12k_scan_stop(ar);
2879 if (ret)
2880 ath12k_warn(ar->ab, "failed to abort scan: %d\n", ret);
2881
2882 spin_lock_bh(&ar->data_lock);
2883 break;
2884 }
2885
2886 spin_unlock_bh(&ar->data_lock);
2887 }
2888
ath12k_scan_timeout_work(struct work_struct * work)2889 static void ath12k_scan_timeout_work(struct work_struct *work)
2890 {
2891 struct ath12k *ar = container_of(work, struct ath12k,
2892 scan.timeout.work);
2893
2894 mutex_lock(&ar->conf_mutex);
2895 ath12k_scan_abort(ar);
2896 mutex_unlock(&ar->conf_mutex);
2897 }
2898
ath12k_start_scan(struct ath12k * ar,struct ath12k_wmi_scan_req_arg * arg)2899 static int ath12k_start_scan(struct ath12k *ar,
2900 struct ath12k_wmi_scan_req_arg *arg)
2901 {
2902 int ret;
2903
2904 lockdep_assert_held(&ar->conf_mutex);
2905
2906 ret = ath12k_wmi_send_scan_start_cmd(ar, arg);
2907 if (ret)
2908 return ret;
2909
2910 ret = wait_for_completion_timeout(&ar->scan.started, 1 * HZ);
2911 if (ret == 0) {
2912 ret = ath12k_scan_stop(ar);
2913 if (ret)
2914 ath12k_warn(ar->ab, "failed to stop scan: %d\n", ret);
2915
2916 return -ETIMEDOUT;
2917 }
2918
2919 /* If we failed to start the scan, return error code at
2920 * this point. This is probably due to some issue in the
2921 * firmware, but no need to wedge the driver due to that...
2922 */
2923 spin_lock_bh(&ar->data_lock);
2924 if (ar->scan.state == ATH12K_SCAN_IDLE) {
2925 spin_unlock_bh(&ar->data_lock);
2926 return -EINVAL;
2927 }
2928 spin_unlock_bh(&ar->data_lock);
2929
2930 return 0;
2931 }
2932
ath12k_mac_op_hw_scan(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_scan_request * hw_req)2933 static int ath12k_mac_op_hw_scan(struct ieee80211_hw *hw,
2934 struct ieee80211_vif *vif,
2935 struct ieee80211_scan_request *hw_req)
2936 {
2937 struct ath12k *ar = hw->priv;
2938 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
2939 struct cfg80211_scan_request *req = &hw_req->req;
2940 struct ath12k_wmi_scan_req_arg arg = {};
2941 int ret;
2942 int i;
2943
2944 mutex_lock(&ar->conf_mutex);
2945
2946 spin_lock_bh(&ar->data_lock);
2947 switch (ar->scan.state) {
2948 case ATH12K_SCAN_IDLE:
2949 reinit_completion(&ar->scan.started);
2950 reinit_completion(&ar->scan.completed);
2951 ar->scan.state = ATH12K_SCAN_STARTING;
2952 ar->scan.is_roc = false;
2953 ar->scan.vdev_id = arvif->vdev_id;
2954 ret = 0;
2955 break;
2956 case ATH12K_SCAN_STARTING:
2957 case ATH12K_SCAN_RUNNING:
2958 case ATH12K_SCAN_ABORTING:
2959 ret = -EBUSY;
2960 break;
2961 }
2962 spin_unlock_bh(&ar->data_lock);
2963
2964 if (ret)
2965 goto exit;
2966
2967 ath12k_wmi_start_scan_init(ar, &arg);
2968 arg.vdev_id = arvif->vdev_id;
2969 arg.scan_id = ATH12K_SCAN_ID;
2970
2971 if (req->ie_len) {
2972 arg.extraie.ptr = kmemdup(req->ie, req->ie_len, GFP_KERNEL);
2973 if (!arg.extraie.ptr) {
2974 ret = -ENOMEM;
2975 goto exit;
2976 }
2977 arg.extraie.len = req->ie_len;
2978 }
2979
2980 if (req->n_ssids) {
2981 arg.num_ssids = req->n_ssids;
2982 for (i = 0; i < arg.num_ssids; i++)
2983 arg.ssid[i] = req->ssids[i];
2984 } else {
2985 arg.scan_flags |= WMI_SCAN_FLAG_PASSIVE;
2986 }
2987
2988 if (req->n_channels) {
2989 arg.num_chan = req->n_channels;
2990 arg.chan_list = kcalloc(arg.num_chan, sizeof(*arg.chan_list),
2991 GFP_KERNEL);
2992
2993 if (!arg.chan_list) {
2994 ret = -ENOMEM;
2995 goto exit;
2996 }
2997
2998 for (i = 0; i < arg.num_chan; i++)
2999 arg.chan_list[i] = req->channels[i]->center_freq;
3000 }
3001
3002 ret = ath12k_start_scan(ar, &arg);
3003 if (ret) {
3004 ath12k_warn(ar->ab, "failed to start hw scan: %d\n", ret);
3005 spin_lock_bh(&ar->data_lock);
3006 ar->scan.state = ATH12K_SCAN_IDLE;
3007 spin_unlock_bh(&ar->data_lock);
3008 }
3009
3010 /* Add a margin to account for event/command processing */
3011 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
3012 msecs_to_jiffies(arg.max_scan_time +
3013 ATH12K_MAC_SCAN_TIMEOUT_MSECS));
3014
3015 exit:
3016 kfree(arg.chan_list);
3017
3018 if (req->ie_len)
3019 kfree(arg.extraie.ptr);
3020
3021 mutex_unlock(&ar->conf_mutex);
3022 return ret;
3023 }
3024
ath12k_mac_op_cancel_hw_scan(struct ieee80211_hw * hw,struct ieee80211_vif * vif)3025 static void ath12k_mac_op_cancel_hw_scan(struct ieee80211_hw *hw,
3026 struct ieee80211_vif *vif)
3027 {
3028 struct ath12k *ar = hw->priv;
3029
3030 mutex_lock(&ar->conf_mutex);
3031 ath12k_scan_abort(ar);
3032 mutex_unlock(&ar->conf_mutex);
3033
3034 cancel_delayed_work_sync(&ar->scan.timeout);
3035 }
3036
ath12k_install_key(struct ath12k_vif * arvif,struct ieee80211_key_conf * key,enum set_key_cmd cmd,const u8 * macaddr,u32 flags)3037 static int ath12k_install_key(struct ath12k_vif *arvif,
3038 struct ieee80211_key_conf *key,
3039 enum set_key_cmd cmd,
3040 const u8 *macaddr, u32 flags)
3041 {
3042 int ret;
3043 struct ath12k *ar = arvif->ar;
3044 struct wmi_vdev_install_key_arg arg = {
3045 .vdev_id = arvif->vdev_id,
3046 .key_idx = key->keyidx,
3047 .key_len = key->keylen,
3048 .key_data = key->key,
3049 .key_flags = flags,
3050 .macaddr = macaddr,
3051 };
3052
3053 lockdep_assert_held(&arvif->ar->conf_mutex);
3054
3055 reinit_completion(&ar->install_key_done);
3056
3057 if (test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3058 return 0;
3059
3060 if (cmd == DISABLE_KEY) {
3061 /* TODO: Check if FW expects value other than NONE for del */
3062 /* arg.key_cipher = WMI_CIPHER_NONE; */
3063 arg.key_len = 0;
3064 arg.key_data = NULL;
3065 goto install;
3066 }
3067
3068 switch (key->cipher) {
3069 case WLAN_CIPHER_SUITE_CCMP:
3070 arg.key_cipher = WMI_CIPHER_AES_CCM;
3071 /* TODO: Re-check if flag is valid */
3072 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
3073 break;
3074 case WLAN_CIPHER_SUITE_TKIP:
3075 arg.key_cipher = WMI_CIPHER_TKIP;
3076 arg.key_txmic_len = 8;
3077 arg.key_rxmic_len = 8;
3078 break;
3079 case WLAN_CIPHER_SUITE_CCMP_256:
3080 arg.key_cipher = WMI_CIPHER_AES_CCM;
3081 break;
3082 case WLAN_CIPHER_SUITE_GCMP:
3083 case WLAN_CIPHER_SUITE_GCMP_256:
3084 arg.key_cipher = WMI_CIPHER_AES_GCM;
3085 break;
3086 default:
3087 ath12k_warn(ar->ab, "cipher %d is not supported\n", key->cipher);
3088 return -EOPNOTSUPP;
3089 }
3090
3091 if (test_bit(ATH12K_FLAG_RAW_MODE, &ar->ab->dev_flags))
3092 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV |
3093 IEEE80211_KEY_FLAG_RESERVE_TAILROOM;
3094
3095 install:
3096 ret = ath12k_wmi_vdev_install_key(arvif->ar, &arg);
3097
3098 if (ret)
3099 return ret;
3100
3101 if (!wait_for_completion_timeout(&ar->install_key_done, 1 * HZ))
3102 return -ETIMEDOUT;
3103
3104 if (ether_addr_equal(macaddr, arvif->vif->addr))
3105 arvif->key_cipher = key->cipher;
3106
3107 return ar->install_key_status ? -EINVAL : 0;
3108 }
3109
ath12k_clear_peer_keys(struct ath12k_vif * arvif,const u8 * addr)3110 static int ath12k_clear_peer_keys(struct ath12k_vif *arvif,
3111 const u8 *addr)
3112 {
3113 struct ath12k *ar = arvif->ar;
3114 struct ath12k_base *ab = ar->ab;
3115 struct ath12k_peer *peer;
3116 int first_errno = 0;
3117 int ret;
3118 int i;
3119 u32 flags = 0;
3120
3121 lockdep_assert_held(&ar->conf_mutex);
3122
3123 spin_lock_bh(&ab->base_lock);
3124 peer = ath12k_peer_find(ab, arvif->vdev_id, addr);
3125 spin_unlock_bh(&ab->base_lock);
3126
3127 if (!peer)
3128 return -ENOENT;
3129
3130 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
3131 if (!peer->keys[i])
3132 continue;
3133
3134 /* key flags are not required to delete the key */
3135 ret = ath12k_install_key(arvif, peer->keys[i],
3136 DISABLE_KEY, addr, flags);
3137 if (ret < 0 && first_errno == 0)
3138 first_errno = ret;
3139
3140 if (ret < 0)
3141 ath12k_warn(ab, "failed to remove peer key %d: %d\n",
3142 i, ret);
3143
3144 spin_lock_bh(&ab->base_lock);
3145 peer->keys[i] = NULL;
3146 spin_unlock_bh(&ab->base_lock);
3147 }
3148
3149 return first_errno;
3150 }
3151
ath12k_mac_op_set_key(struct ieee80211_hw * hw,enum set_key_cmd cmd,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key)3152 static int ath12k_mac_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3153 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3154 struct ieee80211_key_conf *key)
3155 {
3156 struct ath12k *ar = hw->priv;
3157 struct ath12k_base *ab = ar->ab;
3158 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
3159 struct ath12k_peer *peer;
3160 struct ath12k_sta *arsta;
3161 const u8 *peer_addr;
3162 int ret = 0;
3163 u32 flags = 0;
3164
3165 /* BIP needs to be done in software */
3166 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
3167 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
3168 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
3169 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
3170 return 1;
3171
3172 if (test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
3173 return 1;
3174
3175 if (key->keyidx > WMI_MAX_KEY_INDEX)
3176 return -ENOSPC;
3177
3178 mutex_lock(&ar->conf_mutex);
3179
3180 if (sta)
3181 peer_addr = sta->addr;
3182 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3183 peer_addr = vif->bss_conf.bssid;
3184 else
3185 peer_addr = vif->addr;
3186
3187 key->hw_key_idx = key->keyidx;
3188
3189 /* the peer should not disappear in mid-way (unless FW goes awry) since
3190 * we already hold conf_mutex. we just make sure its there now.
3191 */
3192 spin_lock_bh(&ab->base_lock);
3193 peer = ath12k_peer_find(ab, arvif->vdev_id, peer_addr);
3194 spin_unlock_bh(&ab->base_lock);
3195
3196 if (!peer) {
3197 if (cmd == SET_KEY) {
3198 ath12k_warn(ab, "cannot install key for non-existent peer %pM\n",
3199 peer_addr);
3200 ret = -EOPNOTSUPP;
3201 goto exit;
3202 } else {
3203 /* if the peer doesn't exist there is no key to disable
3204 * anymore
3205 */
3206 goto exit;
3207 }
3208 }
3209
3210 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3211 flags |= WMI_KEY_PAIRWISE;
3212 else
3213 flags |= WMI_KEY_GROUP;
3214
3215 ret = ath12k_install_key(arvif, key, cmd, peer_addr, flags);
3216 if (ret) {
3217 ath12k_warn(ab, "ath12k_install_key failed (%d)\n", ret);
3218 goto exit;
3219 }
3220
3221 ret = ath12k_dp_rx_peer_pn_replay_config(arvif, peer_addr, cmd, key);
3222 if (ret) {
3223 ath12k_warn(ab, "failed to offload PN replay detection %d\n", ret);
3224 goto exit;
3225 }
3226
3227 spin_lock_bh(&ab->base_lock);
3228 peer = ath12k_peer_find(ab, arvif->vdev_id, peer_addr);
3229 if (peer && cmd == SET_KEY) {
3230 peer->keys[key->keyidx] = key;
3231 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
3232 peer->ucast_keyidx = key->keyidx;
3233 peer->sec_type = ath12k_dp_tx_get_encrypt_type(key->cipher);
3234 } else {
3235 peer->mcast_keyidx = key->keyidx;
3236 peer->sec_type_grp = ath12k_dp_tx_get_encrypt_type(key->cipher);
3237 }
3238 } else if (peer && cmd == DISABLE_KEY) {
3239 peer->keys[key->keyidx] = NULL;
3240 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3241 peer->ucast_keyidx = 0;
3242 else
3243 peer->mcast_keyidx = 0;
3244 } else if (!peer)
3245 /* impossible unless FW goes crazy */
3246 ath12k_warn(ab, "peer %pM disappeared!\n", peer_addr);
3247
3248 if (sta) {
3249 arsta = (struct ath12k_sta *)sta->drv_priv;
3250
3251 switch (key->cipher) {
3252 case WLAN_CIPHER_SUITE_TKIP:
3253 case WLAN_CIPHER_SUITE_CCMP:
3254 case WLAN_CIPHER_SUITE_CCMP_256:
3255 case WLAN_CIPHER_SUITE_GCMP:
3256 case WLAN_CIPHER_SUITE_GCMP_256:
3257 if (cmd == SET_KEY)
3258 arsta->pn_type = HAL_PN_TYPE_WPA;
3259 else
3260 arsta->pn_type = HAL_PN_TYPE_NONE;
3261 break;
3262 default:
3263 arsta->pn_type = HAL_PN_TYPE_NONE;
3264 break;
3265 }
3266 }
3267
3268 spin_unlock_bh(&ab->base_lock);
3269
3270 exit:
3271 mutex_unlock(&ar->conf_mutex);
3272 return ret;
3273 }
3274
3275 static int
ath12k_mac_bitrate_mask_num_vht_rates(struct ath12k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask)3276 ath12k_mac_bitrate_mask_num_vht_rates(struct ath12k *ar,
3277 enum nl80211_band band,
3278 const struct cfg80211_bitrate_mask *mask)
3279 {
3280 int num_rates = 0;
3281 int i;
3282
3283 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
3284 num_rates += hweight16(mask->control[band].vht_mcs[i]);
3285
3286 return num_rates;
3287 }
3288
3289 static int
ath12k_mac_set_peer_vht_fixed_rate(struct ath12k_vif * arvif,struct ieee80211_sta * sta,const struct cfg80211_bitrate_mask * mask,enum nl80211_band band)3290 ath12k_mac_set_peer_vht_fixed_rate(struct ath12k_vif *arvif,
3291 struct ieee80211_sta *sta,
3292 const struct cfg80211_bitrate_mask *mask,
3293 enum nl80211_band band)
3294 {
3295 struct ath12k *ar = arvif->ar;
3296 u8 vht_rate, nss;
3297 u32 rate_code;
3298 int ret, i;
3299
3300 lockdep_assert_held(&ar->conf_mutex);
3301
3302 nss = 0;
3303
3304 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
3305 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
3306 nss = i + 1;
3307 vht_rate = ffs(mask->control[band].vht_mcs[i]) - 1;
3308 }
3309 }
3310
3311 if (!nss) {
3312 ath12k_warn(ar->ab, "No single VHT Fixed rate found to set for %pM",
3313 sta->addr);
3314 return -EINVAL;
3315 }
3316
3317 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
3318 "Setting Fixed VHT Rate for peer %pM. Device will not switch to any other selected rates",
3319 sta->addr);
3320
3321 rate_code = ATH12K_HW_RATE_CODE(vht_rate, nss - 1,
3322 WMI_RATE_PREAMBLE_VHT);
3323 ret = ath12k_wmi_set_peer_param(ar, sta->addr,
3324 arvif->vdev_id,
3325 WMI_PEER_PARAM_FIXED_RATE,
3326 rate_code);
3327 if (ret)
3328 ath12k_warn(ar->ab,
3329 "failed to update STA %pM Fixed Rate %d: %d\n",
3330 sta->addr, rate_code, ret);
3331
3332 return ret;
3333 }
3334
ath12k_station_assoc(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,bool reassoc)3335 static int ath12k_station_assoc(struct ath12k *ar,
3336 struct ieee80211_vif *vif,
3337 struct ieee80211_sta *sta,
3338 bool reassoc)
3339 {
3340 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
3341 struct ath12k_wmi_peer_assoc_arg peer_arg;
3342 int ret;
3343 struct cfg80211_chan_def def;
3344 enum nl80211_band band;
3345 struct cfg80211_bitrate_mask *mask;
3346 u8 num_vht_rates;
3347
3348 lockdep_assert_held(&ar->conf_mutex);
3349
3350 if (WARN_ON(ath12k_mac_vif_chan(vif, &def)))
3351 return -EPERM;
3352
3353 band = def.chan->band;
3354 mask = &arvif->bitrate_mask;
3355
3356 ath12k_peer_assoc_prepare(ar, vif, sta, &peer_arg, reassoc);
3357
3358 ret = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
3359 if (ret) {
3360 ath12k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
3361 sta->addr, arvif->vdev_id, ret);
3362 return ret;
3363 }
3364
3365 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ)) {
3366 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
3367 sta->addr, arvif->vdev_id);
3368 return -ETIMEDOUT;
3369 }
3370
3371 num_vht_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask);
3372
3373 /* If single VHT rate is configured (by set_bitrate_mask()),
3374 * peer_assoc will disable VHT. This is now enabled by a peer specific
3375 * fixed param.
3376 * Note that all other rates and NSS will be disabled for this peer.
3377 */
3378 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
3379 ret = ath12k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
3380 band);
3381 if (ret)
3382 return ret;
3383 }
3384
3385 /* Re-assoc is run only to update supported rates for given station. It
3386 * doesn't make much sense to reconfigure the peer completely.
3387 */
3388 if (reassoc)
3389 return 0;
3390
3391 ret = ath12k_setup_peer_smps(ar, arvif, sta->addr,
3392 &sta->deflink.ht_cap);
3393 if (ret) {
3394 ath12k_warn(ar->ab, "failed to setup peer SMPS for vdev %d: %d\n",
3395 arvif->vdev_id, ret);
3396 return ret;
3397 }
3398
3399 if (!sta->wme) {
3400 arvif->num_legacy_stations++;
3401 ret = ath12k_recalc_rtscts_prot(arvif);
3402 if (ret)
3403 return ret;
3404 }
3405
3406 if (sta->wme && sta->uapsd_queues) {
3407 ret = ath12k_peer_assoc_qos_ap(ar, arvif, sta);
3408 if (ret) {
3409 ath12k_warn(ar->ab, "failed to set qos params for STA %pM for vdev %i: %d\n",
3410 sta->addr, arvif->vdev_id, ret);
3411 return ret;
3412 }
3413 }
3414
3415 return 0;
3416 }
3417
ath12k_station_disassoc(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta)3418 static int ath12k_station_disassoc(struct ath12k *ar,
3419 struct ieee80211_vif *vif,
3420 struct ieee80211_sta *sta)
3421 {
3422 struct ath12k_vif *arvif = (void *)vif->drv_priv;
3423 int ret;
3424
3425 lockdep_assert_held(&ar->conf_mutex);
3426
3427 if (!sta->wme) {
3428 arvif->num_legacy_stations--;
3429 ret = ath12k_recalc_rtscts_prot(arvif);
3430 if (ret)
3431 return ret;
3432 }
3433
3434 ret = ath12k_clear_peer_keys(arvif, sta->addr);
3435 if (ret) {
3436 ath12k_warn(ar->ab, "failed to clear all peer keys for vdev %i: %d\n",
3437 arvif->vdev_id, ret);
3438 return ret;
3439 }
3440 return 0;
3441 }
3442
ath12k_sta_rc_update_wk(struct work_struct * wk)3443 static void ath12k_sta_rc_update_wk(struct work_struct *wk)
3444 {
3445 struct ath12k *ar;
3446 struct ath12k_vif *arvif;
3447 struct ath12k_sta *arsta;
3448 struct ieee80211_sta *sta;
3449 struct cfg80211_chan_def def;
3450 enum nl80211_band band;
3451 const u8 *ht_mcs_mask;
3452 const u16 *vht_mcs_mask;
3453 u32 changed, bw, nss, smps, bw_prev;
3454 int err, num_vht_rates;
3455 const struct cfg80211_bitrate_mask *mask;
3456 struct ath12k_wmi_peer_assoc_arg peer_arg;
3457 enum wmi_phy_mode peer_phymode;
3458
3459 arsta = container_of(wk, struct ath12k_sta, update_wk);
3460 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3461 arvif = arsta->arvif;
3462 ar = arvif->ar;
3463
3464 if (WARN_ON(ath12k_mac_vif_chan(arvif->vif, &def)))
3465 return;
3466
3467 band = def.chan->band;
3468 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
3469 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
3470
3471 spin_lock_bh(&ar->data_lock);
3472
3473 changed = arsta->changed;
3474 arsta->changed = 0;
3475
3476 bw = arsta->bw;
3477 bw_prev = arsta->bw_prev;
3478 nss = arsta->nss;
3479 smps = arsta->smps;
3480
3481 spin_unlock_bh(&ar->data_lock);
3482
3483 mutex_lock(&ar->conf_mutex);
3484
3485 nss = max_t(u32, 1, nss);
3486 nss = min(nss, max(ath12k_mac_max_ht_nss(ht_mcs_mask),
3487 ath12k_mac_max_vht_nss(vht_mcs_mask)));
3488
3489 if (changed & IEEE80211_RC_BW_CHANGED) {
3490 ath12k_peer_assoc_h_phymode(ar, arvif->vif, sta, &peer_arg);
3491 peer_phymode = peer_arg.peer_phymode;
3492
3493 if (bw > bw_prev) {
3494 /* Phymode shows maximum supported channel width, if we
3495 * upgrade bandwidth then due to sanity check of firmware,
3496 * we have to send WMI_PEER_PHYMODE followed by
3497 * WMI_PEER_CHWIDTH
3498 */
3499 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac bandwidth upgrade for sta %pM new %d old %d\n",
3500 sta->addr, bw, bw_prev);
3501 err = ath12k_wmi_set_peer_param(ar, sta->addr,
3502 arvif->vdev_id, WMI_PEER_PHYMODE,
3503 peer_phymode);
3504 if (err) {
3505 ath12k_warn(ar->ab, "failed to update STA %pM to peer phymode %d: %d\n",
3506 sta->addr, peer_phymode, err);
3507 goto err_rc_bw_changed;
3508 }
3509 err = ath12k_wmi_set_peer_param(ar, sta->addr,
3510 arvif->vdev_id, WMI_PEER_CHWIDTH,
3511 bw);
3512 if (err)
3513 ath12k_warn(ar->ab, "failed to update STA %pM to peer bandwidth %d: %d\n",
3514 sta->addr, bw, err);
3515 } else {
3516 /* When we downgrade bandwidth this will conflict with phymode
3517 * and cause to trigger firmware crash. In this case we send
3518 * WMI_PEER_CHWIDTH followed by WMI_PEER_PHYMODE
3519 */
3520 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac bandwidth downgrade for sta %pM new %d old %d\n",
3521 sta->addr, bw, bw_prev);
3522 err = ath12k_wmi_set_peer_param(ar, sta->addr,
3523 arvif->vdev_id, WMI_PEER_CHWIDTH,
3524 bw);
3525 if (err) {
3526 ath12k_warn(ar->ab, "failed to update STA %pM peer to bandwidth %d: %d\n",
3527 sta->addr, bw, err);
3528 goto err_rc_bw_changed;
3529 }
3530 err = ath12k_wmi_set_peer_param(ar, sta->addr,
3531 arvif->vdev_id, WMI_PEER_PHYMODE,
3532 peer_phymode);
3533 if (err)
3534 ath12k_warn(ar->ab, "failed to update STA %pM to peer phymode %d: %d\n",
3535 sta->addr, peer_phymode, err);
3536 }
3537 }
3538
3539 if (changed & IEEE80211_RC_NSS_CHANGED) {
3540 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac update sta %pM nss %d\n",
3541 sta->addr, nss);
3542
3543 err = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
3544 WMI_PEER_NSS, nss);
3545 if (err)
3546 ath12k_warn(ar->ab, "failed to update STA %pM nss %d: %d\n",
3547 sta->addr, nss, err);
3548 }
3549
3550 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3551 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac update sta %pM smps %d\n",
3552 sta->addr, smps);
3553
3554 err = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
3555 WMI_PEER_MIMO_PS_STATE, smps);
3556 if (err)
3557 ath12k_warn(ar->ab, "failed to update STA %pM smps %d: %d\n",
3558 sta->addr, smps, err);
3559 }
3560
3561 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3562 mask = &arvif->bitrate_mask;
3563 num_vht_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band,
3564 mask);
3565
3566 /* Peer_assoc_prepare will reject vht rates in
3567 * bitrate_mask if its not available in range format and
3568 * sets vht tx_rateset as unsupported. So multiple VHT MCS
3569 * setting(eg. MCS 4,5,6) per peer is not supported here.
3570 * But, Single rate in VHT mask can be set as per-peer
3571 * fixed rate. But even if any HT rates are configured in
3572 * the bitrate mask, device will not switch to those rates
3573 * when per-peer Fixed rate is set.
3574 * TODO: Check RATEMASK_CMDID to support auto rates selection
3575 * across HT/VHT and for multiple VHT MCS support.
3576 */
3577 if (sta->deflink.vht_cap.vht_supported && num_vht_rates == 1) {
3578 ath12k_mac_set_peer_vht_fixed_rate(arvif, sta, mask,
3579 band);
3580 } else {
3581 /* If the peer is non-VHT or no fixed VHT rate
3582 * is provided in the new bitrate mask we set the
3583 * other rates using peer_assoc command.
3584 */
3585 ath12k_peer_assoc_prepare(ar, arvif->vif, sta,
3586 &peer_arg, true);
3587
3588 err = ath12k_wmi_send_peer_assoc_cmd(ar, &peer_arg);
3589 if (err)
3590 ath12k_warn(ar->ab, "failed to run peer assoc for STA %pM vdev %i: %d\n",
3591 sta->addr, arvif->vdev_id, err);
3592
3593 if (!wait_for_completion_timeout(&ar->peer_assoc_done, 1 * HZ))
3594 ath12k_warn(ar->ab, "failed to get peer assoc conf event for %pM vdev %i\n",
3595 sta->addr, arvif->vdev_id);
3596 }
3597 }
3598 err_rc_bw_changed:
3599 mutex_unlock(&ar->conf_mutex);
3600 }
3601
ath12k_mac_inc_num_stations(struct ath12k_vif * arvif,struct ieee80211_sta * sta)3602 static int ath12k_mac_inc_num_stations(struct ath12k_vif *arvif,
3603 struct ieee80211_sta *sta)
3604 {
3605 struct ath12k *ar = arvif->ar;
3606
3607 lockdep_assert_held(&ar->conf_mutex);
3608
3609 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
3610 return 0;
3611
3612 if (ar->num_stations >= ar->max_num_stations)
3613 return -ENOBUFS;
3614
3615 ar->num_stations++;
3616
3617 return 0;
3618 }
3619
ath12k_mac_dec_num_stations(struct ath12k_vif * arvif,struct ieee80211_sta * sta)3620 static void ath12k_mac_dec_num_stations(struct ath12k_vif *arvif,
3621 struct ieee80211_sta *sta)
3622 {
3623 struct ath12k *ar = arvif->ar;
3624
3625 lockdep_assert_held(&ar->conf_mutex);
3626
3627 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
3628 return;
3629
3630 ar->num_stations--;
3631 }
3632
ath12k_mac_station_add(struct ath12k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta)3633 static int ath12k_mac_station_add(struct ath12k *ar,
3634 struct ieee80211_vif *vif,
3635 struct ieee80211_sta *sta)
3636 {
3637 struct ath12k_base *ab = ar->ab;
3638 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
3639 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv;
3640 struct ath12k_wmi_peer_create_arg peer_param;
3641 int ret;
3642
3643 lockdep_assert_held(&ar->conf_mutex);
3644
3645 ret = ath12k_mac_inc_num_stations(arvif, sta);
3646 if (ret) {
3647 ath12k_warn(ab, "refusing to associate station: too many connected already (%d)\n",
3648 ar->max_num_stations);
3649 goto exit;
3650 }
3651
3652 arsta->rx_stats = kzalloc(sizeof(*arsta->rx_stats), GFP_KERNEL);
3653 if (!arsta->rx_stats) {
3654 ret = -ENOMEM;
3655 goto dec_num_station;
3656 }
3657
3658 peer_param.vdev_id = arvif->vdev_id;
3659 peer_param.peer_addr = sta->addr;
3660 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
3661
3662 ret = ath12k_peer_create(ar, arvif, sta, &peer_param);
3663 if (ret) {
3664 ath12k_warn(ab, "Failed to add peer: %pM for VDEV: %d\n",
3665 sta->addr, arvif->vdev_id);
3666 goto free_peer;
3667 }
3668
3669 ath12k_dbg(ab, ATH12K_DBG_MAC, "Added peer: %pM for VDEV: %d\n",
3670 sta->addr, arvif->vdev_id);
3671
3672 if (ieee80211_vif_is_mesh(vif)) {
3673 ret = ath12k_wmi_set_peer_param(ar, sta->addr,
3674 arvif->vdev_id,
3675 WMI_PEER_USE_4ADDR, 1);
3676 if (ret) {
3677 ath12k_warn(ab, "failed to STA %pM 4addr capability: %d\n",
3678 sta->addr, ret);
3679 goto free_peer;
3680 }
3681 }
3682
3683 ret = ath12k_dp_peer_setup(ar, arvif->vdev_id, sta->addr);
3684 if (ret) {
3685 ath12k_warn(ab, "failed to setup dp for peer %pM on vdev %i (%d)\n",
3686 sta->addr, arvif->vdev_id, ret);
3687 goto free_peer;
3688 }
3689
3690 if (ab->hw_params->vdev_start_delay &&
3691 !arvif->is_started &&
3692 arvif->vdev_type != WMI_VDEV_TYPE_AP) {
3693 ret = ath12k_start_vdev_delay(ar->hw, vif);
3694 if (ret) {
3695 ath12k_warn(ab, "failed to delay vdev start: %d\n", ret);
3696 goto free_peer;
3697 }
3698 }
3699
3700 return 0;
3701
3702 free_peer:
3703 ath12k_peer_delete(ar, arvif->vdev_id, sta->addr);
3704 dec_num_station:
3705 ath12k_mac_dec_num_stations(arvif, sta);
3706 exit:
3707 return ret;
3708 }
3709
ath12k_mac_ieee80211_sta_bw_to_wmi(struct ath12k * ar,struct ieee80211_sta * sta)3710 static u32 ath12k_mac_ieee80211_sta_bw_to_wmi(struct ath12k *ar,
3711 struct ieee80211_sta *sta)
3712 {
3713 u32 bw = WMI_PEER_CHWIDTH_20MHZ;
3714
3715 switch (sta->deflink.bandwidth) {
3716 case IEEE80211_STA_RX_BW_20:
3717 bw = WMI_PEER_CHWIDTH_20MHZ;
3718 break;
3719 case IEEE80211_STA_RX_BW_40:
3720 bw = WMI_PEER_CHWIDTH_40MHZ;
3721 break;
3722 case IEEE80211_STA_RX_BW_80:
3723 bw = WMI_PEER_CHWIDTH_80MHZ;
3724 break;
3725 case IEEE80211_STA_RX_BW_160:
3726 bw = WMI_PEER_CHWIDTH_160MHZ;
3727 break;
3728 default:
3729 ath12k_warn(ar->ab, "Invalid bandwidth %d in rc update for %pM\n",
3730 sta->deflink.bandwidth, sta->addr);
3731 bw = WMI_PEER_CHWIDTH_20MHZ;
3732 break;
3733 }
3734
3735 return bw;
3736 }
3737
ath12k_mac_op_sta_state(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,enum ieee80211_sta_state old_state,enum ieee80211_sta_state new_state)3738 static int ath12k_mac_op_sta_state(struct ieee80211_hw *hw,
3739 struct ieee80211_vif *vif,
3740 struct ieee80211_sta *sta,
3741 enum ieee80211_sta_state old_state,
3742 enum ieee80211_sta_state new_state)
3743 {
3744 struct ath12k *ar = hw->priv;
3745 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
3746 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv;
3747 struct ath12k_peer *peer;
3748 int ret = 0;
3749
3750 /* cancel must be done outside the mutex to avoid deadlock */
3751 if ((old_state == IEEE80211_STA_NONE &&
3752 new_state == IEEE80211_STA_NOTEXIST))
3753 cancel_work_sync(&arsta->update_wk);
3754
3755 mutex_lock(&ar->conf_mutex);
3756
3757 if (old_state == IEEE80211_STA_NOTEXIST &&
3758 new_state == IEEE80211_STA_NONE) {
3759 memset(arsta, 0, sizeof(*arsta));
3760 arsta->arvif = arvif;
3761 INIT_WORK(&arsta->update_wk, ath12k_sta_rc_update_wk);
3762
3763 ret = ath12k_mac_station_add(ar, vif, sta);
3764 if (ret)
3765 ath12k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
3766 sta->addr, arvif->vdev_id);
3767 } else if ((old_state == IEEE80211_STA_NONE &&
3768 new_state == IEEE80211_STA_NOTEXIST)) {
3769 ath12k_dp_peer_cleanup(ar, arvif->vdev_id, sta->addr);
3770
3771 ret = ath12k_peer_delete(ar, arvif->vdev_id, sta->addr);
3772 if (ret)
3773 ath12k_warn(ar->ab, "Failed to delete peer: %pM for VDEV: %d\n",
3774 sta->addr, arvif->vdev_id);
3775 else
3776 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "Removed peer: %pM for VDEV: %d\n",
3777 sta->addr, arvif->vdev_id);
3778
3779 ath12k_mac_dec_num_stations(arvif, sta);
3780 spin_lock_bh(&ar->ab->base_lock);
3781 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
3782 if (peer && peer->sta == sta) {
3783 ath12k_warn(ar->ab, "Found peer entry %pM n vdev %i after it was supposedly removed\n",
3784 vif->addr, arvif->vdev_id);
3785 peer->sta = NULL;
3786 list_del(&peer->list);
3787 kfree(peer);
3788 ar->num_peers--;
3789 }
3790 spin_unlock_bh(&ar->ab->base_lock);
3791
3792 kfree(arsta->rx_stats);
3793 arsta->rx_stats = NULL;
3794 } else if (old_state == IEEE80211_STA_AUTH &&
3795 new_state == IEEE80211_STA_ASSOC &&
3796 (vif->type == NL80211_IFTYPE_AP ||
3797 vif->type == NL80211_IFTYPE_MESH_POINT ||
3798 vif->type == NL80211_IFTYPE_ADHOC)) {
3799 ret = ath12k_station_assoc(ar, vif, sta, false);
3800 if (ret)
3801 ath12k_warn(ar->ab, "Failed to associate station: %pM\n",
3802 sta->addr);
3803
3804 spin_lock_bh(&ar->data_lock);
3805
3806 arsta->bw = ath12k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
3807 arsta->bw_prev = sta->deflink.bandwidth;
3808
3809 spin_unlock_bh(&ar->data_lock);
3810 } else if (old_state == IEEE80211_STA_ASSOC &&
3811 new_state == IEEE80211_STA_AUTHORIZED) {
3812 spin_lock_bh(&ar->ab->base_lock);
3813
3814 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
3815 if (peer)
3816 peer->is_authorized = true;
3817
3818 spin_unlock_bh(&ar->ab->base_lock);
3819
3820 if (vif->type == NL80211_IFTYPE_STATION && arvif->is_up) {
3821 ret = ath12k_wmi_set_peer_param(ar, sta->addr,
3822 arvif->vdev_id,
3823 WMI_PEER_AUTHORIZE,
3824 1);
3825 if (ret)
3826 ath12k_warn(ar->ab, "Unable to authorize peer %pM vdev %d: %d\n",
3827 sta->addr, arvif->vdev_id, ret);
3828 }
3829 } else if (old_state == IEEE80211_STA_AUTHORIZED &&
3830 new_state == IEEE80211_STA_ASSOC) {
3831 spin_lock_bh(&ar->ab->base_lock);
3832
3833 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
3834 if (peer)
3835 peer->is_authorized = false;
3836
3837 spin_unlock_bh(&ar->ab->base_lock);
3838 } else if (old_state == IEEE80211_STA_ASSOC &&
3839 new_state == IEEE80211_STA_AUTH &&
3840 (vif->type == NL80211_IFTYPE_AP ||
3841 vif->type == NL80211_IFTYPE_MESH_POINT ||
3842 vif->type == NL80211_IFTYPE_ADHOC)) {
3843 ret = ath12k_station_disassoc(ar, vif, sta);
3844 if (ret)
3845 ath12k_warn(ar->ab, "Failed to disassociate station: %pM\n",
3846 sta->addr);
3847 }
3848
3849 mutex_unlock(&ar->conf_mutex);
3850 return ret;
3851 }
3852
ath12k_mac_op_sta_set_txpwr(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)3853 static int ath12k_mac_op_sta_set_txpwr(struct ieee80211_hw *hw,
3854 struct ieee80211_vif *vif,
3855 struct ieee80211_sta *sta)
3856 {
3857 struct ath12k *ar = hw->priv;
3858 struct ath12k_vif *arvif = (void *)vif->drv_priv;
3859 int ret;
3860 s16 txpwr;
3861
3862 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
3863 txpwr = 0;
3864 } else {
3865 txpwr = sta->deflink.txpwr.power;
3866 if (!txpwr)
3867 return -EINVAL;
3868 }
3869
3870 if (txpwr > ATH12K_TX_POWER_MAX_VAL || txpwr < ATH12K_TX_POWER_MIN_VAL)
3871 return -EINVAL;
3872
3873 mutex_lock(&ar->conf_mutex);
3874
3875 ret = ath12k_wmi_set_peer_param(ar, sta->addr, arvif->vdev_id,
3876 WMI_PEER_USE_FIXED_PWR, txpwr);
3877 if (ret) {
3878 ath12k_warn(ar->ab, "failed to set tx power for station ret: %d\n",
3879 ret);
3880 goto out;
3881 }
3882
3883 out:
3884 mutex_unlock(&ar->conf_mutex);
3885 return ret;
3886 }
3887
ath12k_mac_op_sta_rc_update(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 changed)3888 static void ath12k_mac_op_sta_rc_update(struct ieee80211_hw *hw,
3889 struct ieee80211_vif *vif,
3890 struct ieee80211_sta *sta,
3891 u32 changed)
3892 {
3893 struct ath12k *ar = hw->priv;
3894 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv;
3895 struct ath12k_vif *arvif = (void *)vif->drv_priv;
3896 struct ath12k_peer *peer;
3897 u32 bw, smps;
3898
3899 spin_lock_bh(&ar->ab->base_lock);
3900
3901 peer = ath12k_peer_find(ar->ab, arvif->vdev_id, sta->addr);
3902 if (!peer) {
3903 spin_unlock_bh(&ar->ab->base_lock);
3904 ath12k_warn(ar->ab, "mac sta rc update failed to find peer %pM on vdev %i\n",
3905 sta->addr, arvif->vdev_id);
3906 return;
3907 }
3908
3909 spin_unlock_bh(&ar->ab->base_lock);
3910
3911 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
3912 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
3913 sta->addr, changed, sta->deflink.bandwidth, sta->deflink.rx_nss,
3914 sta->deflink.smps_mode);
3915
3916 spin_lock_bh(&ar->data_lock);
3917
3918 if (changed & IEEE80211_RC_BW_CHANGED) {
3919 bw = ath12k_mac_ieee80211_sta_bw_to_wmi(ar, sta);
3920 arsta->bw_prev = arsta->bw;
3921 arsta->bw = bw;
3922 }
3923
3924 if (changed & IEEE80211_RC_NSS_CHANGED)
3925 arsta->nss = sta->deflink.rx_nss;
3926
3927 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3928 smps = WMI_PEER_SMPS_PS_NONE;
3929
3930 switch (sta->deflink.smps_mode) {
3931 case IEEE80211_SMPS_AUTOMATIC:
3932 case IEEE80211_SMPS_OFF:
3933 smps = WMI_PEER_SMPS_PS_NONE;
3934 break;
3935 case IEEE80211_SMPS_STATIC:
3936 smps = WMI_PEER_SMPS_STATIC;
3937 break;
3938 case IEEE80211_SMPS_DYNAMIC:
3939 smps = WMI_PEER_SMPS_DYNAMIC;
3940 break;
3941 default:
3942 ath12k_warn(ar->ab, "Invalid smps %d in sta rc update for %pM\n",
3943 sta->deflink.smps_mode, sta->addr);
3944 smps = WMI_PEER_SMPS_PS_NONE;
3945 break;
3946 }
3947
3948 arsta->smps = smps;
3949 }
3950
3951 arsta->changed |= changed;
3952
3953 spin_unlock_bh(&ar->data_lock);
3954
3955 ieee80211_queue_work(hw, &arsta->update_wk);
3956 }
3957
ath12k_conf_tx_uapsd(struct ath12k * ar,struct ieee80211_vif * vif,u16 ac,bool enable)3958 static int ath12k_conf_tx_uapsd(struct ath12k *ar, struct ieee80211_vif *vif,
3959 u16 ac, bool enable)
3960 {
3961 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
3962 u32 value;
3963 int ret;
3964
3965 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3966 return 0;
3967
3968 switch (ac) {
3969 case IEEE80211_AC_VO:
3970 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3971 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3972 break;
3973 case IEEE80211_AC_VI:
3974 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3975 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3976 break;
3977 case IEEE80211_AC_BE:
3978 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3979 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3980 break;
3981 case IEEE80211_AC_BK:
3982 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3983 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3984 break;
3985 }
3986
3987 if (enable)
3988 arvif->u.sta.uapsd |= value;
3989 else
3990 arvif->u.sta.uapsd &= ~value;
3991
3992 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3993 WMI_STA_PS_PARAM_UAPSD,
3994 arvif->u.sta.uapsd);
3995 if (ret) {
3996 ath12k_warn(ar->ab, "could not set uapsd params %d\n", ret);
3997 goto exit;
3998 }
3999
4000 if (arvif->u.sta.uapsd)
4001 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
4002 else
4003 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4004
4005 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4006 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
4007 value);
4008 if (ret)
4009 ath12k_warn(ar->ab, "could not set rx wake param %d\n", ret);
4010
4011 exit:
4012 return ret;
4013 }
4014
ath12k_mac_op_conf_tx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,unsigned int link_id,u16 ac,const struct ieee80211_tx_queue_params * params)4015 static int ath12k_mac_op_conf_tx(struct ieee80211_hw *hw,
4016 struct ieee80211_vif *vif,
4017 unsigned int link_id, u16 ac,
4018 const struct ieee80211_tx_queue_params *params)
4019 {
4020 struct ath12k *ar = hw->priv;
4021 struct ath12k_vif *arvif = (void *)vif->drv_priv;
4022 struct wmi_wmm_params_arg *p = NULL;
4023 int ret;
4024
4025 mutex_lock(&ar->conf_mutex);
4026
4027 switch (ac) {
4028 case IEEE80211_AC_VO:
4029 p = &arvif->wmm_params.ac_vo;
4030 break;
4031 case IEEE80211_AC_VI:
4032 p = &arvif->wmm_params.ac_vi;
4033 break;
4034 case IEEE80211_AC_BE:
4035 p = &arvif->wmm_params.ac_be;
4036 break;
4037 case IEEE80211_AC_BK:
4038 p = &arvif->wmm_params.ac_bk;
4039 break;
4040 }
4041
4042 if (WARN_ON(!p)) {
4043 ret = -EINVAL;
4044 goto exit;
4045 }
4046
4047 p->cwmin = params->cw_min;
4048 p->cwmax = params->cw_max;
4049 p->aifs = params->aifs;
4050 p->txop = params->txop;
4051
4052 ret = ath12k_wmi_send_wmm_update_cmd(ar, arvif->vdev_id,
4053 &arvif->wmm_params);
4054 if (ret) {
4055 ath12k_warn(ar->ab, "failed to set wmm params: %d\n", ret);
4056 goto exit;
4057 }
4058
4059 ret = ath12k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
4060
4061 if (ret)
4062 ath12k_warn(ar->ab, "failed to set sta uapsd: %d\n", ret);
4063
4064 exit:
4065 mutex_unlock(&ar->conf_mutex);
4066 return ret;
4067 }
4068
4069 static struct ieee80211_sta_ht_cap
ath12k_create_ht_cap(struct ath12k * ar,u32 ar_ht_cap,u32 rate_cap_rx_chainmask)4070 ath12k_create_ht_cap(struct ath12k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
4071 {
4072 int i;
4073 struct ieee80211_sta_ht_cap ht_cap = {0};
4074 u32 ar_vht_cap = ar->pdev->cap.vht_cap;
4075
4076 if (!(ar_ht_cap & WMI_HT_CAP_ENABLED))
4077 return ht_cap;
4078
4079 ht_cap.ht_supported = 1;
4080 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4081 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
4082 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4083 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4084 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4085
4086 if (ar_ht_cap & WMI_HT_CAP_HT20_SGI)
4087 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4088
4089 if (ar_ht_cap & WMI_HT_CAP_HT40_SGI)
4090 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4091
4092 if (ar_ht_cap & WMI_HT_CAP_DYNAMIC_SMPS) {
4093 u32 smps;
4094
4095 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4096 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4097
4098 ht_cap.cap |= smps;
4099 }
4100
4101 if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
4102 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4103
4104 if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
4105 u32 stbc;
4106
4107 stbc = ar_ht_cap;
4108 stbc &= WMI_HT_CAP_RX_STBC;
4109 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4110 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4111 stbc &= IEEE80211_HT_CAP_RX_STBC;
4112
4113 ht_cap.cap |= stbc;
4114 }
4115
4116 if (ar_ht_cap & WMI_HT_CAP_RX_LDPC)
4117 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4118
4119 if (ar_ht_cap & WMI_HT_CAP_L_SIG_TXOP_PROT)
4120 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4121
4122 if (ar_vht_cap & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4123 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4124
4125 for (i = 0; i < ar->num_rx_chains; i++) {
4126 if (rate_cap_rx_chainmask & BIT(i))
4127 ht_cap.mcs.rx_mask[i] = 0xFF;
4128 }
4129
4130 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4131
4132 return ht_cap;
4133 }
4134
ath12k_mac_set_txbf_conf(struct ath12k_vif * arvif)4135 static int ath12k_mac_set_txbf_conf(struct ath12k_vif *arvif)
4136 {
4137 u32 value = 0;
4138 struct ath12k *ar = arvif->ar;
4139 int nsts;
4140 int sound_dim;
4141 u32 vht_cap = ar->pdev->cap.vht_cap;
4142 u32 vdev_param = WMI_VDEV_PARAM_TXBF;
4143
4144 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)) {
4145 nsts = vht_cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4146 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4147 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4148 }
4149
4150 if (vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)) {
4151 sound_dim = vht_cap &
4152 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4153 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4154 if (sound_dim > (ar->num_tx_chains - 1))
4155 sound_dim = ar->num_tx_chains - 1;
4156 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4157 }
4158
4159 if (!value)
4160 return 0;
4161
4162 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) {
4163 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4164
4165 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE) &&
4166 arvif->vdev_type == WMI_VDEV_TYPE_AP)
4167 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
4168 }
4169
4170 if (vht_cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
4171 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4172
4173 if ((vht_cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE) &&
4174 arvif->vdev_type == WMI_VDEV_TYPE_STA)
4175 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
4176 }
4177
4178 return ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
4179 vdev_param, value);
4180 }
4181
ath12k_set_vht_txbf_cap(struct ath12k * ar,u32 * vht_cap)4182 static void ath12k_set_vht_txbf_cap(struct ath12k *ar, u32 *vht_cap)
4183 {
4184 bool subfer, subfee;
4185 int sound_dim = 0;
4186
4187 subfer = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE));
4188 subfee = !!(*vht_cap & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
4189
4190 if (ar->num_tx_chains < 2) {
4191 *vht_cap &= ~(IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
4192 subfer = false;
4193 }
4194
4195 /* If SU Beaformer is not set, then disable MU Beamformer Capability */
4196 if (!subfer)
4197 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
4198
4199 /* If SU Beaformee is not set, then disable MU Beamformee Capability */
4200 if (!subfee)
4201 *vht_cap &= ~(IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
4202
4203 sound_dim = u32_get_bits(*vht_cap,
4204 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
4205 *vht_cap = u32_replace_bits(*vht_cap, 0,
4206 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
4207
4208 /* TODO: Need to check invalid STS and Sound_dim values set by FW? */
4209
4210 /* Enable Sounding Dimension Field only if SU BF is enabled */
4211 if (subfer) {
4212 if (sound_dim > (ar->num_tx_chains - 1))
4213 sound_dim = ar->num_tx_chains - 1;
4214
4215 *vht_cap = u32_replace_bits(*vht_cap, sound_dim,
4216 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
4217 }
4218
4219 /* Use the STS advertised by FW unless SU Beamformee is not supported*/
4220 if (!subfee)
4221 *vht_cap &= ~(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
4222 }
4223
4224 static struct ieee80211_sta_vht_cap
ath12k_create_vht_cap(struct ath12k * ar,u32 rate_cap_tx_chainmask,u32 rate_cap_rx_chainmask)4225 ath12k_create_vht_cap(struct ath12k *ar, u32 rate_cap_tx_chainmask,
4226 u32 rate_cap_rx_chainmask)
4227 {
4228 struct ieee80211_sta_vht_cap vht_cap = {0};
4229 u16 txmcs_map, rxmcs_map;
4230 int i;
4231
4232 vht_cap.vht_supported = 1;
4233 vht_cap.cap = ar->pdev->cap.vht_cap;
4234
4235 ath12k_set_vht_txbf_cap(ar, &vht_cap.cap);
4236
4237 /* TODO: Enable back VHT160 mode once association issues are fixed */
4238 /* Disabling VHT160 and VHT80+80 modes */
4239 vht_cap.cap &= ~IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
4240 vht_cap.cap &= ~IEEE80211_VHT_CAP_SHORT_GI_160;
4241
4242 rxmcs_map = 0;
4243 txmcs_map = 0;
4244 for (i = 0; i < 8; i++) {
4245 if (i < ar->num_tx_chains && rate_cap_tx_chainmask & BIT(i))
4246 txmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
4247 else
4248 txmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
4249
4250 if (i < ar->num_rx_chains && rate_cap_rx_chainmask & BIT(i))
4251 rxmcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
4252 else
4253 rxmcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
4254 }
4255
4256 if (rate_cap_tx_chainmask <= 1)
4257 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
4258
4259 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_map);
4260 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_map);
4261
4262 return vht_cap;
4263 }
4264
ath12k_mac_setup_ht_vht_cap(struct ath12k * ar,struct ath12k_pdev_cap * cap,u32 * ht_cap_info)4265 static void ath12k_mac_setup_ht_vht_cap(struct ath12k *ar,
4266 struct ath12k_pdev_cap *cap,
4267 u32 *ht_cap_info)
4268 {
4269 struct ieee80211_supported_band *band;
4270 u32 rate_cap_tx_chainmask;
4271 u32 rate_cap_rx_chainmask;
4272 u32 ht_cap;
4273
4274 rate_cap_tx_chainmask = ar->cfg_tx_chainmask >> cap->tx_chain_mask_shift;
4275 rate_cap_rx_chainmask = ar->cfg_rx_chainmask >> cap->rx_chain_mask_shift;
4276
4277 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
4278 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
4279 ht_cap = cap->band[NL80211_BAND_2GHZ].ht_cap_info;
4280 if (ht_cap_info)
4281 *ht_cap_info = ht_cap;
4282 band->ht_cap = ath12k_create_ht_cap(ar, ht_cap,
4283 rate_cap_rx_chainmask);
4284 }
4285
4286 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
4287 (ar->ab->hw_params->single_pdev_only ||
4288 !ar->supports_6ghz)) {
4289 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
4290 ht_cap = cap->band[NL80211_BAND_5GHZ].ht_cap_info;
4291 if (ht_cap_info)
4292 *ht_cap_info = ht_cap;
4293 band->ht_cap = ath12k_create_ht_cap(ar, ht_cap,
4294 rate_cap_rx_chainmask);
4295 band->vht_cap = ath12k_create_vht_cap(ar, rate_cap_tx_chainmask,
4296 rate_cap_rx_chainmask);
4297 }
4298 }
4299
ath12k_check_chain_mask(struct ath12k * ar,u32 ant,bool is_tx_ant)4300 static int ath12k_check_chain_mask(struct ath12k *ar, u32 ant, bool is_tx_ant)
4301 {
4302 /* TODO: Check the request chainmask against the supported
4303 * chainmask table which is advertised in extented_service_ready event
4304 */
4305
4306 return 0;
4307 }
4308
ath12k_gen_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg * fw_ppet,u8 * he_ppet)4309 static void ath12k_gen_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg *fw_ppet,
4310 u8 *he_ppet)
4311 {
4312 int nss, ru;
4313 u8 bit = 7;
4314
4315 he_ppet[0] = fw_ppet->numss_m1 & IEEE80211_PPE_THRES_NSS_MASK;
4316 he_ppet[0] |= (fw_ppet->ru_bit_mask <<
4317 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS) &
4318 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK;
4319 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
4320 for (ru = 0; ru < 4; ru++) {
4321 u8 val;
4322 int i;
4323
4324 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
4325 continue;
4326 val = (fw_ppet->ppet16_ppet8_ru3_ru0[nss] >> (ru * 6)) &
4327 0x3f;
4328 val = ((val >> 3) & 0x7) | ((val & 0x7) << 3);
4329 for (i = 5; i >= 0; i--) {
4330 he_ppet[bit / 8] |=
4331 ((val >> i) & 0x1) << ((bit % 8));
4332 bit++;
4333 }
4334 }
4335 }
4336 }
4337
4338 static void
ath12k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem * he_cap_elem)4339 ath12k_mac_filter_he_cap_mesh(struct ieee80211_he_cap_elem *he_cap_elem)
4340 {
4341 u8 m;
4342
4343 m = IEEE80211_HE_MAC_CAP0_TWT_RES |
4344 IEEE80211_HE_MAC_CAP0_TWT_REQ;
4345 he_cap_elem->mac_cap_info[0] &= ~m;
4346
4347 m = IEEE80211_HE_MAC_CAP2_TRS |
4348 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
4349 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
4350 he_cap_elem->mac_cap_info[2] &= ~m;
4351
4352 m = IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED |
4353 IEEE80211_HE_MAC_CAP2_BCAST_TWT |
4354 IEEE80211_HE_MAC_CAP2_MU_CASCADING;
4355 he_cap_elem->mac_cap_info[3] &= ~m;
4356
4357 m = IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG |
4358 IEEE80211_HE_MAC_CAP4_BQR;
4359 he_cap_elem->mac_cap_info[4] &= ~m;
4360
4361 m = IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECTIVE_TRANSMISSION |
4362 IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU |
4363 IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING |
4364 IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX;
4365 he_cap_elem->mac_cap_info[5] &= ~m;
4366
4367 m = IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
4368 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
4369 he_cap_elem->phy_cap_info[2] &= ~m;
4370
4371 m = IEEE80211_HE_PHY_CAP3_RX_PARTIAL_BW_SU_IN_20MHZ_MU |
4372 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK |
4373 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK;
4374 he_cap_elem->phy_cap_info[3] &= ~m;
4375
4376 m = IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER;
4377 he_cap_elem->phy_cap_info[4] &= ~m;
4378
4379 m = IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
4380 he_cap_elem->phy_cap_info[5] &= ~m;
4381
4382 m = IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
4383 IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB |
4384 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
4385 IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO;
4386 he_cap_elem->phy_cap_info[6] &= ~m;
4387
4388 m = IEEE80211_HE_PHY_CAP7_PSR_BASED_SR |
4389 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
4390 IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
4391 IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ;
4392 he_cap_elem->phy_cap_info[7] &= ~m;
4393
4394 m = IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI |
4395 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
4396 IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
4397 IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
4398 he_cap_elem->phy_cap_info[8] &= ~m;
4399
4400 m = IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
4401 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
4402 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
4403 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
4404 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
4405 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
4406 he_cap_elem->phy_cap_info[9] &= ~m;
4407 }
4408
ath12k_mac_setup_he_6ghz_cap(struct ath12k_pdev_cap * pcap,struct ath12k_band_cap * bcap)4409 static __le16 ath12k_mac_setup_he_6ghz_cap(struct ath12k_pdev_cap *pcap,
4410 struct ath12k_band_cap *bcap)
4411 {
4412 u8 val;
4413
4414 bcap->he_6ghz_capa = IEEE80211_HT_MPDU_DENSITY_NONE;
4415 if (bcap->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4416 bcap->he_6ghz_capa |=
4417 u32_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC,
4418 IEEE80211_HE_6GHZ_CAP_SM_PS);
4419 else
4420 bcap->he_6ghz_capa |=
4421 u32_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED,
4422 IEEE80211_HE_6GHZ_CAP_SM_PS);
4423 val = u32_get_bits(pcap->vht_cap,
4424 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK);
4425 bcap->he_6ghz_capa |=
4426 u32_encode_bits(val, IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP);
4427 val = u32_get_bits(pcap->vht_cap,
4428 IEEE80211_VHT_CAP_MAX_MPDU_MASK);
4429 bcap->he_6ghz_capa |=
4430 u32_encode_bits(val, IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN);
4431 if (pcap->vht_cap & IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN)
4432 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS;
4433 if (pcap->vht_cap & IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN)
4434 bcap->he_6ghz_capa |= IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS;
4435
4436 return cpu_to_le16(bcap->he_6ghz_capa);
4437 }
4438
ath12k_mac_copy_he_cap(struct ath12k_band_cap * band_cap,int iftype,u8 num_tx_chains,struct ieee80211_sta_he_cap * he_cap)4439 static void ath12k_mac_copy_he_cap(struct ath12k_band_cap *band_cap,
4440 int iftype, u8 num_tx_chains,
4441 struct ieee80211_sta_he_cap *he_cap)
4442 {
4443 struct ieee80211_he_cap_elem *he_cap_elem = &he_cap->he_cap_elem;
4444 struct ieee80211_he_mcs_nss_supp *mcs_nss = &he_cap->he_mcs_nss_supp;
4445
4446 he_cap->has_he = true;
4447 memcpy(he_cap_elem->mac_cap_info, band_cap->he_cap_info,
4448 sizeof(he_cap_elem->mac_cap_info));
4449 memcpy(he_cap_elem->phy_cap_info, band_cap->he_cap_phy_info,
4450 sizeof(he_cap_elem->phy_cap_info));
4451
4452 he_cap_elem->mac_cap_info[1] &=
4453 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK;
4454
4455 he_cap_elem->phy_cap_info[5] &=
4456 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK;
4457 he_cap_elem->phy_cap_info[5] &=
4458 ~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK;
4459 he_cap_elem->phy_cap_info[5] |= num_tx_chains - 1;
4460
4461 switch (iftype) {
4462 case NL80211_IFTYPE_AP:
4463 he_cap_elem->phy_cap_info[3] &=
4464 ~IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK;
4465 he_cap_elem->phy_cap_info[9] |=
4466 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
4467 break;
4468 case NL80211_IFTYPE_STATION:
4469 he_cap_elem->mac_cap_info[0] &= ~IEEE80211_HE_MAC_CAP0_TWT_RES;
4470 he_cap_elem->mac_cap_info[0] |= IEEE80211_HE_MAC_CAP0_TWT_REQ;
4471 he_cap_elem->phy_cap_info[9] |=
4472 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU;
4473 break;
4474 case NL80211_IFTYPE_MESH_POINT:
4475 ath12k_mac_filter_he_cap_mesh(he_cap_elem);
4476 break;
4477 }
4478
4479 mcs_nss->rx_mcs_80 = cpu_to_le16(band_cap->he_mcs & 0xffff);
4480 mcs_nss->tx_mcs_80 = cpu_to_le16(band_cap->he_mcs & 0xffff);
4481 mcs_nss->rx_mcs_160 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
4482 mcs_nss->tx_mcs_160 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
4483 mcs_nss->rx_mcs_80p80 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
4484 mcs_nss->tx_mcs_80p80 = cpu_to_le16((band_cap->he_mcs >> 16) & 0xffff);
4485
4486 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
4487 if (he_cap_elem->phy_cap_info[6] &
4488 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT)
4489 ath12k_gen_ppe_thresh(&band_cap->he_ppet, he_cap->ppe_thres);
4490 }
4491
4492 static void
ath12k_mac_copy_eht_mcs_nss(struct ath12k_band_cap * band_cap,struct ieee80211_eht_mcs_nss_supp * mcs_nss,const struct ieee80211_he_cap_elem * he_cap,const struct ieee80211_eht_cap_elem_fixed * eht_cap)4493 ath12k_mac_copy_eht_mcs_nss(struct ath12k_band_cap *band_cap,
4494 struct ieee80211_eht_mcs_nss_supp *mcs_nss,
4495 const struct ieee80211_he_cap_elem *he_cap,
4496 const struct ieee80211_eht_cap_elem_fixed *eht_cap)
4497 {
4498 if ((he_cap->phy_cap_info[0] &
4499 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G |
4500 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
4501 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
4502 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0)
4503 memcpy(&mcs_nss->only_20mhz, &band_cap->eht_mcs_20_only,
4504 sizeof(struct ieee80211_eht_mcs_nss_supp_20mhz_only));
4505
4506 if (he_cap->phy_cap_info[0] &
4507 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G |
4508 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G))
4509 memcpy(&mcs_nss->bw._80, &band_cap->eht_mcs_80,
4510 sizeof(struct ieee80211_eht_mcs_nss_supp_bw));
4511
4512 if (he_cap->phy_cap_info[0] &
4513 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
4514 memcpy(&mcs_nss->bw._160, &band_cap->eht_mcs_160,
4515 sizeof(struct ieee80211_eht_mcs_nss_supp_bw));
4516
4517 if (eht_cap->phy_cap_info[0] & IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ)
4518 memcpy(&mcs_nss->bw._320, &band_cap->eht_mcs_320,
4519 sizeof(struct ieee80211_eht_mcs_nss_supp_bw));
4520 }
4521
ath12k_mac_copy_eht_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg * fw_ppet,struct ieee80211_sta_eht_cap * cap)4522 static void ath12k_mac_copy_eht_ppe_thresh(struct ath12k_wmi_ppe_threshold_arg *fw_ppet,
4523 struct ieee80211_sta_eht_cap *cap)
4524 {
4525 u16 bit = IEEE80211_EHT_PPE_THRES_INFO_HEADER_SIZE;
4526 u8 i, nss, ru, ppet_bit_len_per_ru = IEEE80211_EHT_PPE_THRES_INFO_PPET_SIZE * 2;
4527
4528 u8p_replace_bits(&cap->eht_ppe_thres[0], fw_ppet->numss_m1,
4529 IEEE80211_EHT_PPE_THRES_NSS_MASK);
4530
4531 u16p_replace_bits((u16 *)&cap->eht_ppe_thres[0], fw_ppet->ru_bit_mask,
4532 IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK);
4533
4534 for (nss = 0; nss <= fw_ppet->numss_m1; nss++) {
4535 for (ru = 0;
4536 ru < hweight16(IEEE80211_EHT_PPE_THRES_RU_INDEX_BITMASK_MASK);
4537 ru++) {
4538 u32 val = 0;
4539
4540 if ((fw_ppet->ru_bit_mask & BIT(ru)) == 0)
4541 continue;
4542
4543 u32p_replace_bits(&val, fw_ppet->ppet16_ppet8_ru3_ru0[nss] >>
4544 (ru * ppet_bit_len_per_ru),
4545 GENMASK(ppet_bit_len_per_ru - 1, 0));
4546
4547 for (i = 0; i < ppet_bit_len_per_ru; i++) {
4548 cap->eht_ppe_thres[bit / 8] |=
4549 (((val >> i) & 0x1) << ((bit % 8)));
4550 bit++;
4551 }
4552 }
4553 }
4554 }
4555
ath12k_mac_copy_eht_cap(struct ath12k_band_cap * band_cap,struct ieee80211_he_cap_elem * he_cap_elem,int iftype,struct ieee80211_sta_eht_cap * eht_cap)4556 static void ath12k_mac_copy_eht_cap(struct ath12k_band_cap *band_cap,
4557 struct ieee80211_he_cap_elem *he_cap_elem,
4558 int iftype,
4559 struct ieee80211_sta_eht_cap *eht_cap)
4560 {
4561 struct ieee80211_eht_cap_elem_fixed *eht_cap_elem = &eht_cap->eht_cap_elem;
4562
4563 memset(eht_cap, 0, sizeof(struct ieee80211_sta_eht_cap));
4564 eht_cap->has_eht = true;
4565 memcpy(eht_cap_elem->mac_cap_info, band_cap->eht_cap_mac_info,
4566 sizeof(eht_cap_elem->mac_cap_info));
4567 memcpy(eht_cap_elem->phy_cap_info, band_cap->eht_cap_phy_info,
4568 sizeof(eht_cap_elem->phy_cap_info));
4569
4570 switch (iftype) {
4571 case NL80211_IFTYPE_AP:
4572 eht_cap_elem->phy_cap_info[0] &=
4573 ~IEEE80211_EHT_PHY_CAP0_242_TONE_RU_GT20MHZ;
4574 eht_cap_elem->phy_cap_info[4] &=
4575 ~IEEE80211_EHT_PHY_CAP4_PART_BW_DL_MU_MIMO;
4576 eht_cap_elem->phy_cap_info[5] &=
4577 ~IEEE80211_EHT_PHY_CAP5_TX_LESS_242_TONE_RU_SUPP;
4578 break;
4579 case NL80211_IFTYPE_STATION:
4580 eht_cap_elem->phy_cap_info[7] &=
4581 ~(IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_80MHZ |
4582 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_160MHZ |
4583 IEEE80211_EHT_PHY_CAP7_NON_OFDMA_UL_MU_MIMO_320MHZ);
4584 eht_cap_elem->phy_cap_info[7] &=
4585 ~(IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_80MHZ |
4586 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_160MHZ |
4587 IEEE80211_EHT_PHY_CAP7_MU_BEAMFORMER_320MHZ);
4588 break;
4589 default:
4590 break;
4591 }
4592
4593 ath12k_mac_copy_eht_mcs_nss(band_cap, &eht_cap->eht_mcs_nss_supp,
4594 he_cap_elem, eht_cap_elem);
4595
4596 if (eht_cap_elem->phy_cap_info[5] &
4597 IEEE80211_EHT_PHY_CAP5_PPE_THRESHOLD_PRESENT)
4598 ath12k_mac_copy_eht_ppe_thresh(&band_cap->eht_ppet, eht_cap);
4599 }
4600
ath12k_mac_copy_sband_iftype_data(struct ath12k * ar,struct ath12k_pdev_cap * cap,struct ieee80211_sband_iftype_data * data,int band)4601 static int ath12k_mac_copy_sband_iftype_data(struct ath12k *ar,
4602 struct ath12k_pdev_cap *cap,
4603 struct ieee80211_sband_iftype_data *data,
4604 int band)
4605 {
4606 struct ath12k_band_cap *band_cap = &cap->band[band];
4607 int i, idx = 0;
4608
4609 for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
4610 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
4611
4612 switch (i) {
4613 case NL80211_IFTYPE_STATION:
4614 case NL80211_IFTYPE_AP:
4615 case NL80211_IFTYPE_MESH_POINT:
4616 break;
4617
4618 default:
4619 continue;
4620 }
4621
4622 data[idx].types_mask = BIT(i);
4623
4624 ath12k_mac_copy_he_cap(band_cap, i, ar->num_tx_chains, he_cap);
4625 if (band == NL80211_BAND_6GHZ) {
4626 data[idx].he_6ghz_capa.capa =
4627 ath12k_mac_setup_he_6ghz_cap(cap, band_cap);
4628 }
4629 ath12k_mac_copy_eht_cap(band_cap, &he_cap->he_cap_elem, i,
4630 &data[idx].eht_cap);
4631 idx++;
4632 }
4633
4634 return idx;
4635 }
4636
ath12k_mac_setup_sband_iftype_data(struct ath12k * ar,struct ath12k_pdev_cap * cap)4637 static void ath12k_mac_setup_sband_iftype_data(struct ath12k *ar,
4638 struct ath12k_pdev_cap *cap)
4639 {
4640 struct ieee80211_supported_band *sband;
4641 enum nl80211_band band;
4642 int count;
4643
4644 if (cap->supported_bands & WMI_HOST_WLAN_2G_CAP) {
4645 band = NL80211_BAND_2GHZ;
4646 count = ath12k_mac_copy_sband_iftype_data(ar, cap,
4647 ar->mac.iftype[band],
4648 band);
4649 sband = &ar->mac.sbands[band];
4650 sband->iftype_data = ar->mac.iftype[band];
4651 sband->n_iftype_data = count;
4652 }
4653
4654 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP) {
4655 band = NL80211_BAND_5GHZ;
4656 count = ath12k_mac_copy_sband_iftype_data(ar, cap,
4657 ar->mac.iftype[band],
4658 band);
4659 sband = &ar->mac.sbands[band];
4660 sband->iftype_data = ar->mac.iftype[band];
4661 sband->n_iftype_data = count;
4662 }
4663
4664 if (cap->supported_bands & WMI_HOST_WLAN_5G_CAP &&
4665 ar->supports_6ghz) {
4666 band = NL80211_BAND_6GHZ;
4667 count = ath12k_mac_copy_sband_iftype_data(ar, cap,
4668 ar->mac.iftype[band],
4669 band);
4670 sband = &ar->mac.sbands[band];
4671 sband->iftype_data = ar->mac.iftype[band];
4672 sband->n_iftype_data = count;
4673 }
4674 }
4675
__ath12k_set_antenna(struct ath12k * ar,u32 tx_ant,u32 rx_ant)4676 static int __ath12k_set_antenna(struct ath12k *ar, u32 tx_ant, u32 rx_ant)
4677 {
4678 int ret;
4679
4680 lockdep_assert_held(&ar->conf_mutex);
4681
4682 if (ath12k_check_chain_mask(ar, tx_ant, true))
4683 return -EINVAL;
4684
4685 if (ath12k_check_chain_mask(ar, rx_ant, false))
4686 return -EINVAL;
4687
4688 ar->cfg_tx_chainmask = tx_ant;
4689 ar->cfg_rx_chainmask = rx_ant;
4690
4691 if (ar->state != ATH12K_STATE_ON &&
4692 ar->state != ATH12K_STATE_RESTARTED)
4693 return 0;
4694
4695 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_TX_CHAIN_MASK,
4696 tx_ant, ar->pdev->pdev_id);
4697 if (ret) {
4698 ath12k_warn(ar->ab, "failed to set tx-chainmask: %d, req 0x%x\n",
4699 ret, tx_ant);
4700 return ret;
4701 }
4702
4703 ar->num_tx_chains = hweight32(tx_ant);
4704
4705 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_RX_CHAIN_MASK,
4706 rx_ant, ar->pdev->pdev_id);
4707 if (ret) {
4708 ath12k_warn(ar->ab, "failed to set rx-chainmask: %d, req 0x%x\n",
4709 ret, rx_ant);
4710 return ret;
4711 }
4712
4713 ar->num_rx_chains = hweight32(rx_ant);
4714
4715 /* Reload HT/VHT/HE capability */
4716 ath12k_mac_setup_ht_vht_cap(ar, &ar->pdev->cap, NULL);
4717 ath12k_mac_setup_sband_iftype_data(ar, &ar->pdev->cap);
4718
4719 return 0;
4720 }
4721
ath12k_mgmt_over_wmi_tx_drop(struct ath12k * ar,struct sk_buff * skb)4722 static void ath12k_mgmt_over_wmi_tx_drop(struct ath12k *ar, struct sk_buff *skb)
4723 {
4724 int num_mgmt;
4725
4726 ieee80211_free_txskb(ar->hw, skb);
4727
4728 num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
4729
4730 if (num_mgmt < 0)
4731 WARN_ON_ONCE(1);
4732
4733 if (!num_mgmt)
4734 wake_up(&ar->txmgmt_empty_waitq);
4735 }
4736
ath12k_mac_tx_mgmt_pending_free(int buf_id,void * skb,void * ctx)4737 int ath12k_mac_tx_mgmt_pending_free(int buf_id, void *skb, void *ctx)
4738 {
4739 struct sk_buff *msdu = skb;
4740 struct ieee80211_tx_info *info;
4741 struct ath12k *ar = ctx;
4742 struct ath12k_base *ab = ar->ab;
4743
4744 spin_lock_bh(&ar->txmgmt_idr_lock);
4745 idr_remove(&ar->txmgmt_idr, buf_id);
4746 spin_unlock_bh(&ar->txmgmt_idr_lock);
4747 dma_unmap_single(ab->dev, ATH12K_SKB_CB(msdu)->paddr, msdu->len,
4748 DMA_TO_DEVICE);
4749
4750 info = IEEE80211_SKB_CB(msdu);
4751 memset(&info->status, 0, sizeof(info->status));
4752
4753 ath12k_mgmt_over_wmi_tx_drop(ar, skb);
4754
4755 return 0;
4756 }
4757
ath12k_mac_vif_txmgmt_idr_remove(int buf_id,void * skb,void * ctx)4758 static int ath12k_mac_vif_txmgmt_idr_remove(int buf_id, void *skb, void *ctx)
4759 {
4760 struct ieee80211_vif *vif = ctx;
4761 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb);
4762 struct sk_buff *msdu = skb;
4763 struct ath12k *ar = skb_cb->ar;
4764 struct ath12k_base *ab = ar->ab;
4765
4766 if (skb_cb->vif == vif) {
4767 spin_lock_bh(&ar->txmgmt_idr_lock);
4768 idr_remove(&ar->txmgmt_idr, buf_id);
4769 spin_unlock_bh(&ar->txmgmt_idr_lock);
4770 dma_unmap_single(ab->dev, skb_cb->paddr, msdu->len,
4771 DMA_TO_DEVICE);
4772 }
4773
4774 return 0;
4775 }
4776
ath12k_mac_mgmt_tx_wmi(struct ath12k * ar,struct ath12k_vif * arvif,struct sk_buff * skb)4777 static int ath12k_mac_mgmt_tx_wmi(struct ath12k *ar, struct ath12k_vif *arvif,
4778 struct sk_buff *skb)
4779 {
4780 struct ath12k_base *ab = ar->ab;
4781 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
4782 struct ieee80211_tx_info *info;
4783 dma_addr_t paddr;
4784 int buf_id;
4785 int ret;
4786
4787 ATH12K_SKB_CB(skb)->ar = ar;
4788 spin_lock_bh(&ar->txmgmt_idr_lock);
4789 buf_id = idr_alloc(&ar->txmgmt_idr, skb, 0,
4790 ATH12K_TX_MGMT_NUM_PENDING_MAX, GFP_ATOMIC);
4791 spin_unlock_bh(&ar->txmgmt_idr_lock);
4792 if (buf_id < 0)
4793 return -ENOSPC;
4794
4795 info = IEEE80211_SKB_CB(skb);
4796 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
4797 if ((ieee80211_is_action(hdr->frame_control) ||
4798 ieee80211_is_deauth(hdr->frame_control) ||
4799 ieee80211_is_disassoc(hdr->frame_control)) &&
4800 ieee80211_has_protected(hdr->frame_control)) {
4801 skb_put(skb, IEEE80211_CCMP_MIC_LEN);
4802 }
4803 }
4804
4805 paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);
4806 if (dma_mapping_error(ab->dev, paddr)) {
4807 ath12k_warn(ab, "failed to DMA map mgmt Tx buffer\n");
4808 ret = -EIO;
4809 goto err_free_idr;
4810 }
4811
4812 ATH12K_SKB_CB(skb)->paddr = paddr;
4813
4814 ret = ath12k_wmi_mgmt_send(ar, arvif->vdev_id, buf_id, skb);
4815 if (ret) {
4816 ath12k_warn(ar->ab, "failed to send mgmt frame: %d\n", ret);
4817 goto err_unmap_buf;
4818 }
4819
4820 return 0;
4821
4822 err_unmap_buf:
4823 dma_unmap_single(ab->dev, ATH12K_SKB_CB(skb)->paddr,
4824 skb->len, DMA_TO_DEVICE);
4825 err_free_idr:
4826 spin_lock_bh(&ar->txmgmt_idr_lock);
4827 idr_remove(&ar->txmgmt_idr, buf_id);
4828 spin_unlock_bh(&ar->txmgmt_idr_lock);
4829
4830 return ret;
4831 }
4832
ath12k_mgmt_over_wmi_tx_purge(struct ath12k * ar)4833 static void ath12k_mgmt_over_wmi_tx_purge(struct ath12k *ar)
4834 {
4835 struct sk_buff *skb;
4836
4837 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL)
4838 ath12k_mgmt_over_wmi_tx_drop(ar, skb);
4839 }
4840
ath12k_mgmt_over_wmi_tx_work(struct work_struct * work)4841 static void ath12k_mgmt_over_wmi_tx_work(struct work_struct *work)
4842 {
4843 struct ath12k *ar = container_of(work, struct ath12k, wmi_mgmt_tx_work);
4844 struct ath12k_skb_cb *skb_cb;
4845 struct ath12k_vif *arvif;
4846 struct sk_buff *skb;
4847 int ret;
4848
4849 while ((skb = skb_dequeue(&ar->wmi_mgmt_tx_queue)) != NULL) {
4850 skb_cb = ATH12K_SKB_CB(skb);
4851 if (!skb_cb->vif) {
4852 ath12k_warn(ar->ab, "no vif found for mgmt frame\n");
4853 ath12k_mgmt_over_wmi_tx_drop(ar, skb);
4854 continue;
4855 }
4856
4857 arvif = ath12k_vif_to_arvif(skb_cb->vif);
4858 if (ar->allocated_vdev_map & (1LL << arvif->vdev_id) &&
4859 arvif->is_started) {
4860 ret = ath12k_mac_mgmt_tx_wmi(ar, arvif, skb);
4861 if (ret) {
4862 ath12k_warn(ar->ab, "failed to tx mgmt frame, vdev_id %d :%d\n",
4863 arvif->vdev_id, ret);
4864 ath12k_mgmt_over_wmi_tx_drop(ar, skb);
4865 }
4866 } else {
4867 ath12k_warn(ar->ab,
4868 "dropping mgmt frame for vdev %d, is_started %d\n",
4869 arvif->vdev_id,
4870 arvif->is_started);
4871 ath12k_mgmt_over_wmi_tx_drop(ar, skb);
4872 }
4873 }
4874 }
4875
ath12k_mac_mgmt_tx(struct ath12k * ar,struct sk_buff * skb,bool is_prb_rsp)4876 static int ath12k_mac_mgmt_tx(struct ath12k *ar, struct sk_buff *skb,
4877 bool is_prb_rsp)
4878 {
4879 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
4880
4881 if (test_bit(ATH12K_FLAG_CRASH_FLUSH, &ar->ab->dev_flags))
4882 return -ESHUTDOWN;
4883
4884 /* Drop probe response packets when the pending management tx
4885 * count has reached a certain threshold, so as to prioritize
4886 * other mgmt packets like auth and assoc to be sent on time
4887 * for establishing successful connections.
4888 */
4889 if (is_prb_rsp &&
4890 atomic_read(&ar->num_pending_mgmt_tx) > ATH12K_PRB_RSP_DROP_THRESHOLD) {
4891 ath12k_warn(ar->ab,
4892 "dropping probe response as pending queue is almost full\n");
4893 return -ENOSPC;
4894 }
4895
4896 if (skb_queue_len_lockless(q) >= ATH12K_TX_MGMT_NUM_PENDING_MAX) {
4897 ath12k_warn(ar->ab, "mgmt tx queue is full\n");
4898 return -ENOSPC;
4899 }
4900
4901 skb_queue_tail(q, skb);
4902 atomic_inc(&ar->num_pending_mgmt_tx);
4903 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
4904
4905 return 0;
4906 }
4907
ath12k_mac_op_tx(struct ieee80211_hw * hw,struct ieee80211_tx_control * control,struct sk_buff * skb)4908 static void ath12k_mac_op_tx(struct ieee80211_hw *hw,
4909 struct ieee80211_tx_control *control,
4910 struct sk_buff *skb)
4911 {
4912 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb);
4913 struct ath12k *ar = hw->priv;
4914 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
4915 struct ieee80211_vif *vif = info->control.vif;
4916 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
4917 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
4918 struct ieee80211_key_conf *key = info->control.hw_key;
4919 u32 info_flags = info->flags;
4920 bool is_prb_rsp;
4921 int ret;
4922
4923 memset(skb_cb, 0, sizeof(*skb_cb));
4924 skb_cb->vif = vif;
4925
4926 if (key) {
4927 skb_cb->cipher = key->cipher;
4928 skb_cb->flags |= ATH12K_SKB_CIPHER_SET;
4929 }
4930
4931 if (info_flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
4932 skb_cb->flags |= ATH12K_SKB_HW_80211_ENCAP;
4933 } else if (ieee80211_is_mgmt(hdr->frame_control)) {
4934 is_prb_rsp = ieee80211_is_probe_resp(hdr->frame_control);
4935 ret = ath12k_mac_mgmt_tx(ar, skb, is_prb_rsp);
4936 if (ret) {
4937 ath12k_warn(ar->ab, "failed to queue management frame %d\n",
4938 ret);
4939 ieee80211_free_txskb(ar->hw, skb);
4940 }
4941 return;
4942 }
4943
4944 ret = ath12k_dp_tx(ar, arvif, skb);
4945 if (ret) {
4946 ath12k_warn(ar->ab, "failed to transmit frame %d\n", ret);
4947 ieee80211_free_txskb(ar->hw, skb);
4948 }
4949 }
4950
ath12k_mac_drain_tx(struct ath12k * ar)4951 void ath12k_mac_drain_tx(struct ath12k *ar)
4952 {
4953 /* make sure rcu-protected mac80211 tx path itself is drained */
4954 synchronize_net();
4955
4956 cancel_work_sync(&ar->wmi_mgmt_tx_work);
4957 ath12k_mgmt_over_wmi_tx_purge(ar);
4958 }
4959
ath12k_mac_config_mon_status_default(struct ath12k * ar,bool enable)4960 static int ath12k_mac_config_mon_status_default(struct ath12k *ar, bool enable)
4961 {
4962 return -ENOTSUPP;
4963 /* TODO: Need to support new monitor mode */
4964 }
4965
ath12k_mac_wait_reconfigure(struct ath12k_base * ab)4966 static void ath12k_mac_wait_reconfigure(struct ath12k_base *ab)
4967 {
4968 int recovery_start_count;
4969
4970 if (!ab->is_reset)
4971 return;
4972
4973 recovery_start_count = atomic_inc_return(&ab->recovery_start_count);
4974
4975 ath12k_dbg(ab, ATH12K_DBG_MAC, "recovery start count %d\n", recovery_start_count);
4976
4977 if (recovery_start_count == ab->num_radios) {
4978 complete(&ab->recovery_start);
4979 ath12k_dbg(ab, ATH12K_DBG_MAC, "recovery started success\n");
4980 }
4981
4982 ath12k_dbg(ab, ATH12K_DBG_MAC, "waiting reconfigure...\n");
4983
4984 wait_for_completion_timeout(&ab->reconfigure_complete,
4985 ATH12K_RECONFIGURE_TIMEOUT_HZ);
4986 }
4987
ath12k_mac_op_start(struct ieee80211_hw * hw)4988 static int ath12k_mac_op_start(struct ieee80211_hw *hw)
4989 {
4990 struct ath12k *ar = hw->priv;
4991 struct ath12k_base *ab = ar->ab;
4992 struct ath12k_pdev *pdev = ar->pdev;
4993 int ret;
4994
4995 ath12k_mac_drain_tx(ar);
4996 mutex_lock(&ar->conf_mutex);
4997
4998 switch (ar->state) {
4999 case ATH12K_STATE_OFF:
5000 ar->state = ATH12K_STATE_ON;
5001 break;
5002 case ATH12K_STATE_RESTARTING:
5003 ar->state = ATH12K_STATE_RESTARTED;
5004 ath12k_mac_wait_reconfigure(ab);
5005 break;
5006 case ATH12K_STATE_RESTARTED:
5007 case ATH12K_STATE_WEDGED:
5008 case ATH12K_STATE_ON:
5009 WARN_ON(1);
5010 ret = -EINVAL;
5011 goto err;
5012 }
5013
5014 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS,
5015 1, pdev->pdev_id);
5016
5017 if (ret) {
5018 ath12k_err(ar->ab, "failed to enable PMF QOS: (%d\n", ret);
5019 goto err;
5020 }
5021
5022 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 1,
5023 pdev->pdev_id);
5024 if (ret) {
5025 ath12k_err(ar->ab, "failed to enable dynamic bw: %d\n", ret);
5026 goto err;
5027 }
5028
5029 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
5030 0, pdev->pdev_id);
5031 if (ret) {
5032 ath12k_err(ab, "failed to set ac override for ARP: %d\n",
5033 ret);
5034 goto err;
5035 }
5036
5037 ret = ath12k_wmi_send_dfs_phyerr_offload_enable_cmd(ar, pdev->pdev_id);
5038 if (ret) {
5039 ath12k_err(ab, "failed to offload radar detection: %d\n",
5040 ret);
5041 goto err;
5042 }
5043
5044 ret = ath12k_dp_tx_htt_h2t_ppdu_stats_req(ar,
5045 HTT_PPDU_STATS_TAG_DEFAULT);
5046 if (ret) {
5047 ath12k_err(ab, "failed to req ppdu stats: %d\n", ret);
5048 goto err;
5049 }
5050
5051 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_MESH_MCAST_ENABLE,
5052 1, pdev->pdev_id);
5053
5054 if (ret) {
5055 ath12k_err(ar->ab, "failed to enable MESH MCAST ENABLE: (%d\n", ret);
5056 goto err;
5057 }
5058
5059 __ath12k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5060
5061 /* TODO: Do we need to enable ANI? */
5062
5063 ath12k_reg_update_chan_list(ar);
5064
5065 ar->num_started_vdevs = 0;
5066 ar->num_created_vdevs = 0;
5067 ar->num_peers = 0;
5068 ar->allocated_vdev_map = 0;
5069
5070 /* Configure monitor status ring with default rx_filter to get rx status
5071 * such as rssi, rx_duration.
5072 */
5073 ret = ath12k_mac_config_mon_status_default(ar, true);
5074 if (ret && (ret != -ENOTSUPP)) {
5075 ath12k_err(ab, "failed to configure monitor status ring with default rx_filter: (%d)\n",
5076 ret);
5077 goto err;
5078 }
5079
5080 if (ret == -ENOTSUPP)
5081 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
5082 "monitor status config is not yet supported");
5083
5084 /* Configure the hash seed for hash based reo dest ring selection */
5085 ath12k_wmi_pdev_lro_cfg(ar, ar->pdev->pdev_id);
5086
5087 /* allow device to enter IMPS */
5088 if (ab->hw_params->idle_ps) {
5089 ret = ath12k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_IDLE_PS_CONFIG,
5090 1, pdev->pdev_id);
5091 if (ret) {
5092 ath12k_err(ab, "failed to enable idle ps: %d\n", ret);
5093 goto err;
5094 }
5095 }
5096
5097 mutex_unlock(&ar->conf_mutex);
5098
5099 rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx],
5100 &ab->pdevs[ar->pdev_idx]);
5101
5102 return 0;
5103
5104 err:
5105 ar->state = ATH12K_STATE_OFF;
5106 mutex_unlock(&ar->conf_mutex);
5107
5108 return ret;
5109 }
5110
ath12k_mac_op_stop(struct ieee80211_hw * hw)5111 static void ath12k_mac_op_stop(struct ieee80211_hw *hw)
5112 {
5113 struct ath12k *ar = hw->priv;
5114 struct htt_ppdu_stats_info *ppdu_stats, *tmp;
5115 int ret;
5116
5117 ath12k_mac_drain_tx(ar);
5118
5119 mutex_lock(&ar->conf_mutex);
5120 ret = ath12k_mac_config_mon_status_default(ar, false);
5121 if (ret && (ret != -ENOTSUPP))
5122 ath12k_err(ar->ab, "failed to clear rx_filter for monitor status ring: (%d)\n",
5123 ret);
5124
5125 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags);
5126 ar->state = ATH12K_STATE_OFF;
5127 mutex_unlock(&ar->conf_mutex);
5128
5129 cancel_delayed_work_sync(&ar->scan.timeout);
5130 cancel_work_sync(&ar->regd_update_work);
5131
5132 spin_lock_bh(&ar->data_lock);
5133 list_for_each_entry_safe(ppdu_stats, tmp, &ar->ppdu_stats_info, list) {
5134 list_del(&ppdu_stats->list);
5135 kfree(ppdu_stats);
5136 }
5137 spin_unlock_bh(&ar->data_lock);
5138
5139 rcu_assign_pointer(ar->ab->pdevs_active[ar->pdev_idx], NULL);
5140
5141 synchronize_rcu();
5142
5143 atomic_set(&ar->num_pending_mgmt_tx, 0);
5144 }
5145
5146 static u8
ath12k_mac_get_vdev_stats_id(struct ath12k_vif * arvif)5147 ath12k_mac_get_vdev_stats_id(struct ath12k_vif *arvif)
5148 {
5149 struct ath12k_base *ab = arvif->ar->ab;
5150 u8 vdev_stats_id = 0;
5151
5152 do {
5153 if (ab->free_vdev_stats_id_map & (1LL << vdev_stats_id)) {
5154 vdev_stats_id++;
5155 if (vdev_stats_id <= ATH12K_INVAL_VDEV_STATS_ID) {
5156 vdev_stats_id = ATH12K_INVAL_VDEV_STATS_ID;
5157 break;
5158 }
5159 } else {
5160 ab->free_vdev_stats_id_map |= (1LL << vdev_stats_id);
5161 break;
5162 }
5163 } while (vdev_stats_id);
5164
5165 arvif->vdev_stats_id = vdev_stats_id;
5166 return vdev_stats_id;
5167 }
5168
ath12k_mac_setup_vdev_create_arg(struct ath12k_vif * arvif,struct ath12k_wmi_vdev_create_arg * arg)5169 static void ath12k_mac_setup_vdev_create_arg(struct ath12k_vif *arvif,
5170 struct ath12k_wmi_vdev_create_arg *arg)
5171 {
5172 struct ath12k *ar = arvif->ar;
5173 struct ath12k_pdev *pdev = ar->pdev;
5174
5175 arg->if_id = arvif->vdev_id;
5176 arg->type = arvif->vdev_type;
5177 arg->subtype = arvif->vdev_subtype;
5178 arg->pdev_id = pdev->pdev_id;
5179
5180 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP) {
5181 arg->chains[NL80211_BAND_2GHZ].tx = ar->num_tx_chains;
5182 arg->chains[NL80211_BAND_2GHZ].rx = ar->num_rx_chains;
5183 }
5184 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP) {
5185 arg->chains[NL80211_BAND_5GHZ].tx = ar->num_tx_chains;
5186 arg->chains[NL80211_BAND_5GHZ].rx = ar->num_rx_chains;
5187 }
5188 if (pdev->cap.supported_bands & WMI_HOST_WLAN_5G_CAP &&
5189 ar->supports_6ghz) {
5190 arg->chains[NL80211_BAND_6GHZ].tx = ar->num_tx_chains;
5191 arg->chains[NL80211_BAND_6GHZ].rx = ar->num_rx_chains;
5192 }
5193
5194 arg->if_stats_id = ath12k_mac_get_vdev_stats_id(arvif);
5195 }
5196
5197 static u32
ath12k_mac_prepare_he_mode(struct ath12k_pdev * pdev,u32 viftype)5198 ath12k_mac_prepare_he_mode(struct ath12k_pdev *pdev, u32 viftype)
5199 {
5200 struct ath12k_pdev_cap *pdev_cap = &pdev->cap;
5201 struct ath12k_band_cap *cap_band = NULL;
5202 u32 *hecap_phy_ptr = NULL;
5203 u32 hemode;
5204
5205 if (pdev->cap.supported_bands & WMI_HOST_WLAN_2G_CAP)
5206 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
5207 else
5208 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
5209
5210 hecap_phy_ptr = &cap_band->he_cap_phy_info[0];
5211
5212 hemode = u32_encode_bits(HE_SU_BFEE_ENABLE, HE_MODE_SU_TX_BFEE) |
5213 u32_encode_bits(HECAP_PHY_SUBFMR_GET(hecap_phy_ptr),
5214 HE_MODE_SU_TX_BFER) |
5215 u32_encode_bits(HECAP_PHY_ULMUMIMO_GET(hecap_phy_ptr),
5216 HE_MODE_UL_MUMIMO);
5217
5218 /* TODO: WDS and other modes */
5219 if (viftype == NL80211_IFTYPE_AP) {
5220 hemode |= u32_encode_bits(HECAP_PHY_MUBFMR_GET(hecap_phy_ptr),
5221 HE_MODE_MU_TX_BFER) |
5222 u32_encode_bits(HE_DL_MUOFDMA_ENABLE, HE_MODE_DL_OFDMA) |
5223 u32_encode_bits(HE_UL_MUOFDMA_ENABLE, HE_MODE_UL_OFDMA);
5224 } else {
5225 hemode |= u32_encode_bits(HE_MU_BFEE_ENABLE, HE_MODE_MU_TX_BFEE);
5226 }
5227
5228 return hemode;
5229 }
5230
ath12k_set_he_mu_sounding_mode(struct ath12k * ar,struct ath12k_vif * arvif)5231 static int ath12k_set_he_mu_sounding_mode(struct ath12k *ar,
5232 struct ath12k_vif *arvif)
5233 {
5234 u32 param_id, param_value;
5235 struct ath12k_base *ab = ar->ab;
5236 int ret;
5237
5238 param_id = WMI_VDEV_PARAM_SET_HEMU_MODE;
5239 param_value = ath12k_mac_prepare_he_mode(ar->pdev, arvif->vif->type);
5240 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5241 param_id, param_value);
5242 if (ret) {
5243 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d param_value %x\n",
5244 arvif->vdev_id, ret, param_value);
5245 return ret;
5246 }
5247 param_id = WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE;
5248 param_value =
5249 u32_encode_bits(HE_VHT_SOUNDING_MODE_ENABLE, HE_VHT_SOUNDING_MODE) |
5250 u32_encode_bits(HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE,
5251 HE_TRIG_NONTRIG_SOUNDING_MODE);
5252 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5253 param_id, param_value);
5254 if (ret) {
5255 ath12k_warn(ab, "failed to set vdev %d HE MU mode: %d\n",
5256 arvif->vdev_id, ret);
5257 return ret;
5258 }
5259 return ret;
5260 }
5261
ath12k_mac_op_update_vif_offload(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5262 static void ath12k_mac_op_update_vif_offload(struct ieee80211_hw *hw,
5263 struct ieee80211_vif *vif)
5264 {
5265 struct ath12k *ar = hw->priv;
5266 struct ath12k_base *ab = ar->ab;
5267 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
5268 u32 param_id, param_value;
5269 int ret;
5270
5271 param_id = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
5272 if (vif->type != NL80211_IFTYPE_STATION &&
5273 vif->type != NL80211_IFTYPE_AP)
5274 vif->offload_flags &= ~(IEEE80211_OFFLOAD_ENCAP_ENABLED |
5275 IEEE80211_OFFLOAD_DECAP_ENABLED);
5276
5277 if (vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED)
5278 arvif->tx_encap_type = ATH12K_HW_TXRX_ETHERNET;
5279 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags))
5280 arvif->tx_encap_type = ATH12K_HW_TXRX_RAW;
5281 else
5282 arvif->tx_encap_type = ATH12K_HW_TXRX_NATIVE_WIFI;
5283
5284 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5285 param_id, arvif->tx_encap_type);
5286 if (ret) {
5287 ath12k_warn(ab, "failed to set vdev %d tx encap mode: %d\n",
5288 arvif->vdev_id, ret);
5289 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
5290 }
5291
5292 param_id = WMI_VDEV_PARAM_RX_DECAP_TYPE;
5293 if (vif->offload_flags & IEEE80211_OFFLOAD_DECAP_ENABLED)
5294 param_value = ATH12K_HW_TXRX_ETHERNET;
5295 else if (test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags))
5296 param_value = ATH12K_HW_TXRX_RAW;
5297 else
5298 param_value = ATH12K_HW_TXRX_NATIVE_WIFI;
5299
5300 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5301 param_id, param_value);
5302 if (ret) {
5303 ath12k_warn(ab, "failed to set vdev %d rx decap mode: %d\n",
5304 arvif->vdev_id, ret);
5305 vif->offload_flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
5306 }
5307 }
5308
ath12k_mac_op_add_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5309 static int ath12k_mac_op_add_interface(struct ieee80211_hw *hw,
5310 struct ieee80211_vif *vif)
5311 {
5312 struct ath12k *ar = hw->priv;
5313 struct ath12k_base *ab = ar->ab;
5314 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
5315 struct ath12k_wmi_vdev_create_arg vdev_arg = {0};
5316 struct ath12k_wmi_peer_create_arg peer_param;
5317 u32 param_id, param_value;
5318 u16 nss;
5319 int i;
5320 int ret;
5321 int bit;
5322
5323 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
5324
5325 mutex_lock(&ar->conf_mutex);
5326
5327 if (vif->type == NL80211_IFTYPE_AP &&
5328 ar->num_peers > (ar->max_num_peers - 1)) {
5329 ath12k_warn(ab, "failed to create vdev due to insufficient peer entry resource in firmware\n");
5330 ret = -ENOBUFS;
5331 goto err;
5332 }
5333
5334 if (ar->num_created_vdevs > (TARGET_NUM_VDEVS - 1)) {
5335 ath12k_warn(ab, "failed to create vdev, reached max vdev limit %d\n",
5336 TARGET_NUM_VDEVS);
5337 ret = -EBUSY;
5338 goto err;
5339 }
5340
5341 memset(arvif, 0, sizeof(*arvif));
5342
5343 arvif->ar = ar;
5344 arvif->vif = vif;
5345
5346 INIT_LIST_HEAD(&arvif->list);
5347
5348 /* Should we initialize any worker to handle connection loss indication
5349 * from firmware in sta mode?
5350 */
5351
5352 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
5353 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
5354 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
5355 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
5356 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
5357 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
5358 }
5359
5360 bit = __ffs64(ab->free_vdev_map);
5361
5362 arvif->vdev_id = bit;
5363 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
5364
5365 switch (vif->type) {
5366 case NL80211_IFTYPE_UNSPECIFIED:
5367 case NL80211_IFTYPE_STATION:
5368 arvif->vdev_type = WMI_VDEV_TYPE_STA;
5369 break;
5370 case NL80211_IFTYPE_MESH_POINT:
5371 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH_11S;
5372 fallthrough;
5373 case NL80211_IFTYPE_AP:
5374 arvif->vdev_type = WMI_VDEV_TYPE_AP;
5375 break;
5376 case NL80211_IFTYPE_MONITOR:
5377 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
5378 ar->monitor_vdev_id = bit;
5379 break;
5380 default:
5381 WARN_ON(1);
5382 break;
5383 }
5384
5385 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac add interface id %d type %d subtype %d map %llx\n",
5386 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
5387 ab->free_vdev_map);
5388
5389 vif->cab_queue = arvif->vdev_id % (ATH12K_HW_MAX_QUEUES - 1);
5390 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
5391 vif->hw_queue[i] = i % (ATH12K_HW_MAX_QUEUES - 1);
5392
5393 ath12k_mac_setup_vdev_create_arg(arvif, &vdev_arg);
5394
5395 ret = ath12k_wmi_vdev_create(ar, vif->addr, &vdev_arg);
5396 if (ret) {
5397 ath12k_warn(ab, "failed to create WMI vdev %d: %d\n",
5398 arvif->vdev_id, ret);
5399 goto err;
5400 }
5401
5402 ar->num_created_vdevs++;
5403 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM created, vdev_id %d\n",
5404 vif->addr, arvif->vdev_id);
5405 ar->allocated_vdev_map |= 1LL << arvif->vdev_id;
5406 ab->free_vdev_map &= ~(1LL << arvif->vdev_id);
5407
5408 spin_lock_bh(&ar->data_lock);
5409 list_add(&arvif->list, &ar->arvifs);
5410 spin_unlock_bh(&ar->data_lock);
5411
5412 ath12k_mac_op_update_vif_offload(hw, vif);
5413
5414 nss = hweight32(ar->cfg_tx_chainmask) ? : 1;
5415 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5416 WMI_VDEV_PARAM_NSS, nss);
5417 if (ret) {
5418 ath12k_warn(ab, "failed to set vdev %d chainmask 0x%x, nss %d :%d\n",
5419 arvif->vdev_id, ar->cfg_tx_chainmask, nss, ret);
5420 goto err_vdev_del;
5421 }
5422
5423 switch (arvif->vdev_type) {
5424 case WMI_VDEV_TYPE_AP:
5425 peer_param.vdev_id = arvif->vdev_id;
5426 peer_param.peer_addr = vif->addr;
5427 peer_param.peer_type = WMI_PEER_TYPE_DEFAULT;
5428 ret = ath12k_peer_create(ar, arvif, NULL, &peer_param);
5429 if (ret) {
5430 ath12k_warn(ab, "failed to vdev %d create peer for AP: %d\n",
5431 arvif->vdev_id, ret);
5432 goto err_vdev_del;
5433 }
5434
5435 ret = ath12k_mac_set_kickout(arvif);
5436 if (ret) {
5437 ath12k_warn(ar->ab, "failed to set vdev %i kickout parameters: %d\n",
5438 arvif->vdev_id, ret);
5439 goto err_peer_del;
5440 }
5441 break;
5442 case WMI_VDEV_TYPE_STA:
5443 param_id = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
5444 param_value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5445 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5446 param_id, param_value);
5447 if (ret) {
5448 ath12k_warn(ar->ab, "failed to set vdev %d RX wake policy: %d\n",
5449 arvif->vdev_id, ret);
5450 goto err_peer_del;
5451 }
5452
5453 param_id = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
5454 param_value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
5455 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5456 param_id, param_value);
5457 if (ret) {
5458 ath12k_warn(ar->ab, "failed to set vdev %d TX wake threshold: %d\n",
5459 arvif->vdev_id, ret);
5460 goto err_peer_del;
5461 }
5462
5463 param_id = WMI_STA_PS_PARAM_PSPOLL_COUNT;
5464 param_value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
5465 ret = ath12k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5466 param_id, param_value);
5467 if (ret) {
5468 ath12k_warn(ar->ab, "failed to set vdev %d pspoll count: %d\n",
5469 arvif->vdev_id, ret);
5470 goto err_peer_del;
5471 }
5472
5473 ret = ath12k_wmi_pdev_set_ps_mode(ar, arvif->vdev_id, false);
5474 if (ret) {
5475 ath12k_warn(ar->ab, "failed to disable vdev %d ps mode: %d\n",
5476 arvif->vdev_id, ret);
5477 goto err_peer_del;
5478 }
5479 break;
5480 default:
5481 break;
5482 }
5483
5484 arvif->txpower = vif->bss_conf.txpower;
5485 ret = ath12k_mac_txpower_recalc(ar);
5486 if (ret)
5487 goto err_peer_del;
5488
5489 param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
5490 param_value = ar->hw->wiphy->rts_threshold;
5491 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
5492 param_id, param_value);
5493 if (ret) {
5494 ath12k_warn(ar->ab, "failed to set rts threshold for vdev %d: %d\n",
5495 arvif->vdev_id, ret);
5496 }
5497
5498 ath12k_dp_vdev_tx_attach(ar, arvif);
5499
5500 if (vif->type != NL80211_IFTYPE_MONITOR && ar->monitor_conf_enabled)
5501 ath12k_mac_monitor_vdev_create(ar);
5502
5503 mutex_unlock(&ar->conf_mutex);
5504
5505 return ret;
5506
5507 err_peer_del:
5508 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
5509 reinit_completion(&ar->peer_delete_done);
5510
5511 ret = ath12k_wmi_send_peer_delete_cmd(ar, vif->addr,
5512 arvif->vdev_id);
5513 if (ret) {
5514 ath12k_warn(ar->ab, "failed to delete peer vdev_id %d addr %pM\n",
5515 arvif->vdev_id, vif->addr);
5516 goto err;
5517 }
5518
5519 ret = ath12k_wait_for_peer_delete_done(ar, arvif->vdev_id,
5520 vif->addr);
5521 if (ret)
5522 goto err;
5523
5524 ar->num_peers--;
5525 }
5526
5527 err_vdev_del:
5528 ath12k_wmi_vdev_delete(ar, arvif->vdev_id);
5529 ar->num_created_vdevs--;
5530 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
5531 ab->free_vdev_map |= 1LL << arvif->vdev_id;
5532 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id);
5533 spin_lock_bh(&ar->data_lock);
5534 list_del(&arvif->list);
5535 spin_unlock_bh(&ar->data_lock);
5536
5537 err:
5538 mutex_unlock(&ar->conf_mutex);
5539
5540 return ret;
5541 }
5542
ath12k_mac_vif_unref(struct ath12k_dp * dp,struct ieee80211_vif * vif)5543 static void ath12k_mac_vif_unref(struct ath12k_dp *dp, struct ieee80211_vif *vif)
5544 {
5545 struct ath12k_tx_desc_info *tx_desc_info;
5546 struct ath12k_skb_cb *skb_cb;
5547 struct sk_buff *skb;
5548 int i;
5549
5550 for (i = 0; i < ATH12K_HW_MAX_QUEUES; i++) {
5551 spin_lock_bh(&dp->tx_desc_lock[i]);
5552
5553 list_for_each_entry(tx_desc_info, &dp->tx_desc_used_list[i],
5554 list) {
5555 skb = tx_desc_info->skb;
5556 if (!skb)
5557 continue;
5558
5559 skb_cb = ATH12K_SKB_CB(skb);
5560 if (skb_cb->vif == vif)
5561 skb_cb->vif = NULL;
5562 }
5563
5564 spin_unlock_bh(&dp->tx_desc_lock[i]);
5565 }
5566 }
5567
ath12k_mac_op_remove_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5568 static void ath12k_mac_op_remove_interface(struct ieee80211_hw *hw,
5569 struct ieee80211_vif *vif)
5570 {
5571 struct ath12k *ar = hw->priv;
5572 struct ath12k_vif *arvif = ath12k_vif_to_arvif(vif);
5573 struct ath12k_base *ab = ar->ab;
5574 unsigned long time_left;
5575 int ret;
5576
5577 mutex_lock(&ar->conf_mutex);
5578
5579 ath12k_dbg(ab, ATH12K_DBG_MAC, "mac remove interface (vdev %d)\n",
5580 arvif->vdev_id);
5581
5582 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
5583 ret = ath12k_peer_delete(ar, arvif->vdev_id, vif->addr);
5584 if (ret)
5585 ath12k_warn(ab, "failed to submit AP self-peer removal on vdev %d: %d\n",
5586 arvif->vdev_id, ret);
5587 }
5588
5589 reinit_completion(&ar->vdev_delete_done);
5590
5591 ret = ath12k_wmi_vdev_delete(ar, arvif->vdev_id);
5592 if (ret) {
5593 ath12k_warn(ab, "failed to delete WMI vdev %d: %d\n",
5594 arvif->vdev_id, ret);
5595 goto err_vdev_del;
5596 }
5597
5598 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
5599 ATH12K_VDEV_DELETE_TIMEOUT_HZ);
5600 if (time_left == 0) {
5601 ath12k_warn(ab, "Timeout in receiving vdev delete response\n");
5602 goto err_vdev_del;
5603 }
5604
5605 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
5606 ar->monitor_vdev_id = -1;
5607 ar->monitor_vdev_created = false;
5608 } else if (ar->monitor_vdev_created && !ar->monitor_started) {
5609 ret = ath12k_mac_monitor_vdev_delete(ar);
5610 }
5611
5612 ab->free_vdev_map |= 1LL << (arvif->vdev_id);
5613 ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id);
5614 ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id);
5615 ar->num_created_vdevs--;
5616
5617 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM deleted, vdev_id %d\n",
5618 vif->addr, arvif->vdev_id);
5619
5620 err_vdev_del:
5621 spin_lock_bh(&ar->data_lock);
5622 list_del(&arvif->list);
5623 spin_unlock_bh(&ar->data_lock);
5624
5625 ath12k_peer_cleanup(ar, arvif->vdev_id);
5626
5627 idr_for_each(&ar->txmgmt_idr,
5628 ath12k_mac_vif_txmgmt_idr_remove, vif);
5629
5630 ath12k_mac_vif_unref(&ab->dp, vif);
5631 ath12k_dp_tx_put_bank_profile(&ab->dp, arvif->bank_id);
5632
5633 /* Recalc txpower for remaining vdev */
5634 ath12k_mac_txpower_recalc(ar);
5635 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags);
5636
5637 /* TODO: recal traffic pause state based on the available vdevs */
5638
5639 mutex_unlock(&ar->conf_mutex);
5640 }
5641
5642 /* FIXME: Has to be verified. */
5643 #define SUPPORTED_FILTERS \
5644 (FIF_ALLMULTI | \
5645 FIF_CONTROL | \
5646 FIF_PSPOLL | \
5647 FIF_OTHER_BSS | \
5648 FIF_BCN_PRBRESP_PROMISC | \
5649 FIF_PROBE_REQ | \
5650 FIF_FCSFAIL)
5651
ath12k_mac_op_configure_filter(struct ieee80211_hw * hw,unsigned int changed_flags,unsigned int * total_flags,u64 multicast)5652 static void ath12k_mac_op_configure_filter(struct ieee80211_hw *hw,
5653 unsigned int changed_flags,
5654 unsigned int *total_flags,
5655 u64 multicast)
5656 {
5657 struct ath12k *ar = hw->priv;
5658 bool reset_flag;
5659 int ret;
5660
5661 mutex_lock(&ar->conf_mutex);
5662
5663 changed_flags &= SUPPORTED_FILTERS;
5664 *total_flags &= SUPPORTED_FILTERS;
5665 ar->filter_flags = *total_flags;
5666
5667 /* For monitor mode */
5668 reset_flag = !(ar->filter_flags & FIF_BCN_PRBRESP_PROMISC);
5669
5670 ret = ath12k_dp_tx_htt_monitor_mode_ring_config(ar, reset_flag);
5671 if (!ret) {
5672 if (!reset_flag)
5673 set_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags);
5674 else
5675 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags);
5676 } else {
5677 ath12k_warn(ar->ab,
5678 "fail to set monitor filter: %d\n", ret);
5679 }
5680 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
5681 "changed_flags:0x%x, total_flags:0x%x, reset_flag:%d\n",
5682 changed_flags, *total_flags, reset_flag);
5683
5684 mutex_unlock(&ar->conf_mutex);
5685 }
5686
ath12k_mac_op_get_antenna(struct ieee80211_hw * hw,u32 * tx_ant,u32 * rx_ant)5687 static int ath12k_mac_op_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
5688 {
5689 struct ath12k *ar = hw->priv;
5690
5691 mutex_lock(&ar->conf_mutex);
5692
5693 *tx_ant = ar->cfg_tx_chainmask;
5694 *rx_ant = ar->cfg_rx_chainmask;
5695
5696 mutex_unlock(&ar->conf_mutex);
5697
5698 return 0;
5699 }
5700
ath12k_mac_op_set_antenna(struct ieee80211_hw * hw,u32 tx_ant,u32 rx_ant)5701 static int ath12k_mac_op_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
5702 {
5703 struct ath12k *ar = hw->priv;
5704 int ret;
5705
5706 mutex_lock(&ar->conf_mutex);
5707 ret = __ath12k_set_antenna(ar, tx_ant, rx_ant);
5708 mutex_unlock(&ar->conf_mutex);
5709
5710 return ret;
5711 }
5712
ath12k_mac_op_ampdu_action(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_ampdu_params * params)5713 static int ath12k_mac_op_ampdu_action(struct ieee80211_hw *hw,
5714 struct ieee80211_vif *vif,
5715 struct ieee80211_ampdu_params *params)
5716 {
5717 struct ath12k *ar = hw->priv;
5718 int ret = -EINVAL;
5719
5720 mutex_lock(&ar->conf_mutex);
5721
5722 switch (params->action) {
5723 case IEEE80211_AMPDU_RX_START:
5724 ret = ath12k_dp_rx_ampdu_start(ar, params);
5725 break;
5726 case IEEE80211_AMPDU_RX_STOP:
5727 ret = ath12k_dp_rx_ampdu_stop(ar, params);
5728 break;
5729 case IEEE80211_AMPDU_TX_START:
5730 case IEEE80211_AMPDU_TX_STOP_CONT:
5731 case IEEE80211_AMPDU_TX_STOP_FLUSH:
5732 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
5733 case IEEE80211_AMPDU_TX_OPERATIONAL:
5734 /* Tx A-MPDU aggregation offloaded to hw/fw so deny mac80211
5735 * Tx aggregation requests.
5736 */
5737 ret = -EOPNOTSUPP;
5738 break;
5739 }
5740
5741 mutex_unlock(&ar->conf_mutex);
5742
5743 return ret;
5744 }
5745
ath12k_mac_op_add_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx)5746 static int ath12k_mac_op_add_chanctx(struct ieee80211_hw *hw,
5747 struct ieee80211_chanctx_conf *ctx)
5748 {
5749 struct ath12k *ar = hw->priv;
5750 struct ath12k_base *ab = ar->ab;
5751
5752 ath12k_dbg(ab, ATH12K_DBG_MAC,
5753 "mac chanctx add freq %u width %d ptr %pK\n",
5754 ctx->def.chan->center_freq, ctx->def.width, ctx);
5755
5756 mutex_lock(&ar->conf_mutex);
5757
5758 spin_lock_bh(&ar->data_lock);
5759 /* TODO: In case of multiple channel context, populate rx_channel from
5760 * Rx PPDU desc information.
5761 */
5762 ar->rx_channel = ctx->def.chan;
5763 spin_unlock_bh(&ar->data_lock);
5764
5765 mutex_unlock(&ar->conf_mutex);
5766
5767 return 0;
5768 }
5769
ath12k_mac_op_remove_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx)5770 static void ath12k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
5771 struct ieee80211_chanctx_conf *ctx)
5772 {
5773 struct ath12k *ar = hw->priv;
5774 struct ath12k_base *ab = ar->ab;
5775
5776 ath12k_dbg(ab, ATH12K_DBG_MAC,
5777 "mac chanctx remove freq %u width %d ptr %pK\n",
5778 ctx->def.chan->center_freq, ctx->def.width, ctx);
5779
5780 mutex_lock(&ar->conf_mutex);
5781
5782 spin_lock_bh(&ar->data_lock);
5783 /* TODO: In case of there is one more channel context left, populate
5784 * rx_channel with the channel of that remaining channel context.
5785 */
5786 ar->rx_channel = NULL;
5787 spin_unlock_bh(&ar->data_lock);
5788
5789 mutex_unlock(&ar->conf_mutex);
5790 }
5791
5792 static int
ath12k_mac_vdev_start_restart(struct ath12k_vif * arvif,const struct cfg80211_chan_def * chandef,bool restart)5793 ath12k_mac_vdev_start_restart(struct ath12k_vif *arvif,
5794 const struct cfg80211_chan_def *chandef,
5795 bool restart)
5796 {
5797 struct ath12k *ar = arvif->ar;
5798 struct ath12k_base *ab = ar->ab;
5799 struct wmi_vdev_start_req_arg arg = {};
5800 int he_support = arvif->vif->bss_conf.he_support;
5801 int ret;
5802
5803 lockdep_assert_held(&ar->conf_mutex);
5804
5805 reinit_completion(&ar->vdev_setup_done);
5806
5807 arg.vdev_id = arvif->vdev_id;
5808 arg.dtim_period = arvif->dtim_period;
5809 arg.bcn_intval = arvif->beacon_interval;
5810 arg.punct_bitmap = ~arvif->punct_bitmap;
5811
5812 arg.freq = chandef->chan->center_freq;
5813 arg.band_center_freq1 = chandef->center_freq1;
5814 arg.band_center_freq2 = chandef->center_freq2;
5815 arg.mode = ath12k_phymodes[chandef->chan->band][chandef->width];
5816
5817 arg.min_power = 0;
5818 arg.max_power = chandef->chan->max_power * 2;
5819 arg.max_reg_power = chandef->chan->max_reg_power * 2;
5820 arg.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
5821
5822 arg.pref_tx_streams = ar->num_tx_chains;
5823 arg.pref_rx_streams = ar->num_rx_chains;
5824
5825 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
5826 arg.ssid = arvif->u.ap.ssid;
5827 arg.ssid_len = arvif->u.ap.ssid_len;
5828 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
5829
5830 /* For now allow DFS for AP mode */
5831 arg.chan_radar = !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
5832
5833 arg.passive = arg.chan_radar;
5834
5835 spin_lock_bh(&ab->base_lock);
5836 arg.regdomain = ar->ab->dfs_region;
5837 spin_unlock_bh(&ab->base_lock);
5838
5839 /* TODO: Notify if secondary 80Mhz also needs radar detection */
5840 if (he_support) {
5841 ret = ath12k_set_he_mu_sounding_mode(ar, arvif);
5842 if (ret) {
5843 ath12k_warn(ar->ab, "failed to set he mode vdev %i\n",
5844 arg.vdev_id);
5845 return ret;
5846 }
5847 }
5848 }
5849
5850 arg.passive |= !!(chandef->chan->flags & IEEE80211_CHAN_NO_IR);
5851
5852 ath12k_dbg(ab, ATH12K_DBG_MAC,
5853 "mac vdev %d start center_freq %d phymode %s punct_bitmap 0x%x\n",
5854 arg.vdev_id, arg.freq,
5855 ath12k_mac_phymode_str(arg.mode), arg.punct_bitmap);
5856
5857 ret = ath12k_wmi_vdev_start(ar, &arg, restart);
5858 if (ret) {
5859 ath12k_warn(ar->ab, "failed to %s WMI vdev %i\n",
5860 restart ? "restart" : "start", arg.vdev_id);
5861 return ret;
5862 }
5863
5864 ret = ath12k_mac_vdev_setup_sync(ar);
5865 if (ret) {
5866 ath12k_warn(ab, "failed to synchronize setup for vdev %i %s: %d\n",
5867 arg.vdev_id, restart ? "restart" : "start", ret);
5868 return ret;
5869 }
5870
5871 ar->num_started_vdevs++;
5872 ath12k_dbg(ab, ATH12K_DBG_MAC, "vdev %pM started, vdev_id %d\n",
5873 arvif->vif->addr, arvif->vdev_id);
5874
5875 /* Enable CAC Flag in the driver by checking the channel DFS cac time,
5876 * i.e dfs_cac_ms value which will be valid only for radar channels
5877 * and state as NL80211_DFS_USABLE which indicates CAC needs to be
5878 * done before channel usage. This flags is used to drop rx packets.
5879 * during CAC.
5880 */
5881 /* TODO: Set the flag for other interface types as required */
5882 if (arvif->vdev_type == WMI_VDEV_TYPE_AP &&
5883 chandef->chan->dfs_cac_ms &&
5884 chandef->chan->dfs_state == NL80211_DFS_USABLE) {
5885 set_bit(ATH12K_CAC_RUNNING, &ar->dev_flags);
5886 ath12k_dbg(ab, ATH12K_DBG_MAC,
5887 "CAC Started in chan_freq %d for vdev %d\n",
5888 arg.freq, arg.vdev_id);
5889 }
5890
5891 ret = ath12k_mac_set_txbf_conf(arvif);
5892 if (ret)
5893 ath12k_warn(ab, "failed to set txbf conf for vdev %d: %d\n",
5894 arvif->vdev_id, ret);
5895
5896 return 0;
5897 }
5898
ath12k_mac_vdev_stop(struct ath12k_vif * arvif)5899 static int ath12k_mac_vdev_stop(struct ath12k_vif *arvif)
5900 {
5901 struct ath12k *ar = arvif->ar;
5902 int ret;
5903
5904 lockdep_assert_held(&ar->conf_mutex);
5905
5906 reinit_completion(&ar->vdev_setup_done);
5907
5908 ret = ath12k_wmi_vdev_stop(ar, arvif->vdev_id);
5909 if (ret) {
5910 ath12k_warn(ar->ab, "failed to stop WMI vdev %i: %d\n",
5911 arvif->vdev_id, ret);
5912 goto err;
5913 }
5914
5915 ret = ath12k_mac_vdev_setup_sync(ar);
5916 if (ret) {
5917 ath12k_warn(ar->ab, "failed to synchronize setup for vdev %i: %d\n",
5918 arvif->vdev_id, ret);
5919 goto err;
5920 }
5921
5922 WARN_ON(ar->num_started_vdevs == 0);
5923
5924 ar->num_started_vdevs--;
5925 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "vdev %pM stopped, vdev_id %d\n",
5926 arvif->vif->addr, arvif->vdev_id);
5927
5928 if (test_bit(ATH12K_CAC_RUNNING, &ar->dev_flags)) {
5929 clear_bit(ATH12K_CAC_RUNNING, &ar->dev_flags);
5930 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "CAC Stopped for vdev %d\n",
5931 arvif->vdev_id);
5932 }
5933
5934 return 0;
5935 err:
5936 return ret;
5937 }
5938
ath12k_mac_vdev_start(struct ath12k_vif * arvif,const struct cfg80211_chan_def * chandef)5939 static int ath12k_mac_vdev_start(struct ath12k_vif *arvif,
5940 const struct cfg80211_chan_def *chandef)
5941 {
5942 return ath12k_mac_vdev_start_restart(arvif, chandef, false);
5943 }
5944
ath12k_mac_vdev_restart(struct ath12k_vif * arvif,const struct cfg80211_chan_def * chandef)5945 static int ath12k_mac_vdev_restart(struct ath12k_vif *arvif,
5946 const struct cfg80211_chan_def *chandef)
5947 {
5948 return ath12k_mac_vdev_start_restart(arvif, chandef, true);
5949 }
5950
5951 struct ath12k_mac_change_chanctx_arg {
5952 struct ieee80211_chanctx_conf *ctx;
5953 struct ieee80211_vif_chanctx_switch *vifs;
5954 int n_vifs;
5955 int next_vif;
5956 };
5957
5958 static void
ath12k_mac_change_chanctx_cnt_iter(void * data,u8 * mac,struct ieee80211_vif * vif)5959 ath12k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
5960 struct ieee80211_vif *vif)
5961 {
5962 struct ath12k_mac_change_chanctx_arg *arg = data;
5963
5964 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
5965 return;
5966
5967 arg->n_vifs++;
5968 }
5969
5970 static void
ath12k_mac_change_chanctx_fill_iter(void * data,u8 * mac,struct ieee80211_vif * vif)5971 ath12k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
5972 struct ieee80211_vif *vif)
5973 {
5974 struct ath12k_mac_change_chanctx_arg *arg = data;
5975 struct ieee80211_chanctx_conf *ctx;
5976
5977 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
5978 if (ctx != arg->ctx)
5979 return;
5980
5981 if (WARN_ON(arg->next_vif == arg->n_vifs))
5982 return;
5983
5984 arg->vifs[arg->next_vif].vif = vif;
5985 arg->vifs[arg->next_vif].old_ctx = ctx;
5986 arg->vifs[arg->next_vif].new_ctx = ctx;
5987 arg->next_vif++;
5988 }
5989
5990 static void
ath12k_mac_update_vif_chan(struct ath12k * ar,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs)5991 ath12k_mac_update_vif_chan(struct ath12k *ar,
5992 struct ieee80211_vif_chanctx_switch *vifs,
5993 int n_vifs)
5994 {
5995 struct ath12k_base *ab = ar->ab;
5996 struct ath12k_vif *arvif;
5997 int ret;
5998 int i;
5999 bool monitor_vif = false;
6000
6001 lockdep_assert_held(&ar->conf_mutex);
6002
6003 for (i = 0; i < n_vifs; i++) {
6004 arvif = (void *)vifs[i].vif->drv_priv;
6005
6006 if (vifs[i].vif->type == NL80211_IFTYPE_MONITOR)
6007 monitor_vif = true;
6008
6009 ath12k_dbg(ab, ATH12K_DBG_MAC,
6010 "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n",
6011 arvif->vdev_id,
6012 vifs[i].old_ctx->def.chan->center_freq,
6013 vifs[i].new_ctx->def.chan->center_freq,
6014 vifs[i].old_ctx->def.width,
6015 vifs[i].new_ctx->def.width);
6016
6017 if (WARN_ON(!arvif->is_started))
6018 continue;
6019
6020 if (WARN_ON(!arvif->is_up))
6021 continue;
6022
6023 ret = ath12k_wmi_vdev_down(ar, arvif->vdev_id);
6024 if (ret) {
6025 ath12k_warn(ab, "failed to down vdev %d: %d\n",
6026 arvif->vdev_id, ret);
6027 continue;
6028 }
6029 }
6030
6031 /* All relevant vdevs are downed and associated channel resources
6032 * should be available for the channel switch now.
6033 */
6034
6035 /* TODO: Update ar->rx_channel */
6036
6037 for (i = 0; i < n_vifs; i++) {
6038 arvif = (void *)vifs[i].vif->drv_priv;
6039
6040 if (WARN_ON(!arvif->is_started))
6041 continue;
6042
6043 if (WARN_ON(!arvif->is_up))
6044 continue;
6045
6046 ret = ath12k_mac_vdev_restart(arvif, &vifs[i].new_ctx->def);
6047 if (ret) {
6048 ath12k_warn(ab, "failed to restart vdev %d: %d\n",
6049 arvif->vdev_id, ret);
6050 continue;
6051 }
6052
6053 ret = ath12k_mac_setup_bcn_tmpl(arvif);
6054 if (ret)
6055 ath12k_warn(ab, "failed to update bcn tmpl during csa: %d\n",
6056 ret);
6057
6058 ret = ath12k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6059 arvif->bssid);
6060 if (ret) {
6061 ath12k_warn(ab, "failed to bring vdev up %d: %d\n",
6062 arvif->vdev_id, ret);
6063 continue;
6064 }
6065 }
6066
6067 /* Restart the internal monitor vdev on new channel */
6068 if (!monitor_vif && ar->monitor_vdev_created) {
6069 if (!ath12k_mac_monitor_stop(ar))
6070 ath12k_mac_monitor_start(ar);
6071 }
6072 }
6073
6074 static void
ath12k_mac_update_active_vif_chan(struct ath12k * ar,struct ieee80211_chanctx_conf * ctx)6075 ath12k_mac_update_active_vif_chan(struct ath12k *ar,
6076 struct ieee80211_chanctx_conf *ctx)
6077 {
6078 struct ath12k_mac_change_chanctx_arg arg = { .ctx = ctx };
6079
6080 lockdep_assert_held(&ar->conf_mutex);
6081
6082 ieee80211_iterate_active_interfaces_atomic(ar->hw,
6083 IEEE80211_IFACE_ITER_NORMAL,
6084 ath12k_mac_change_chanctx_cnt_iter,
6085 &arg);
6086 if (arg.n_vifs == 0)
6087 return;
6088
6089 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]), GFP_KERNEL);
6090 if (!arg.vifs)
6091 return;
6092
6093 ieee80211_iterate_active_interfaces_atomic(ar->hw,
6094 IEEE80211_IFACE_ITER_NORMAL,
6095 ath12k_mac_change_chanctx_fill_iter,
6096 &arg);
6097
6098 ath12k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6099
6100 kfree(arg.vifs);
6101 }
6102
ath12k_mac_op_change_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx,u32 changed)6103 static void ath12k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6104 struct ieee80211_chanctx_conf *ctx,
6105 u32 changed)
6106 {
6107 struct ath12k *ar = hw->priv;
6108 struct ath12k_base *ab = ar->ab;
6109
6110 mutex_lock(&ar->conf_mutex);
6111
6112 ath12k_dbg(ab, ATH12K_DBG_MAC,
6113 "mac chanctx change freq %u width %d ptr %pK changed %x\n",
6114 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6115
6116 /* This shouldn't really happen because channel switching should use
6117 * switch_vif_chanctx().
6118 */
6119 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6120 goto unlock;
6121
6122 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH)
6123 ath12k_mac_update_active_vif_chan(ar, ctx);
6124
6125 /* TODO: Recalc radar detection */
6126
6127 unlock:
6128 mutex_unlock(&ar->conf_mutex);
6129 }
6130
ath12k_start_vdev_delay(struct ieee80211_hw * hw,struct ieee80211_vif * vif)6131 static int ath12k_start_vdev_delay(struct ieee80211_hw *hw,
6132 struct ieee80211_vif *vif)
6133 {
6134 struct ath12k *ar = hw->priv;
6135 struct ath12k_base *ab = ar->ab;
6136 struct ath12k_vif *arvif = (void *)vif->drv_priv;
6137 int ret;
6138
6139 if (WARN_ON(arvif->is_started))
6140 return -EBUSY;
6141
6142 ret = ath12k_mac_vdev_start(arvif, &arvif->chanctx.def);
6143 if (ret) {
6144 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
6145 arvif->vdev_id, vif->addr,
6146 arvif->chanctx.def.chan->center_freq, ret);
6147 return ret;
6148 }
6149
6150 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6151 ret = ath12k_monitor_vdev_up(ar, arvif->vdev_id);
6152 if (ret) {
6153 ath12k_warn(ab, "failed put monitor up: %d\n", ret);
6154 return ret;
6155 }
6156 }
6157
6158 arvif->is_started = true;
6159
6160 /* TODO: Setup ps and cts/rts protection */
6161 return 0;
6162 }
6163
6164 static int
ath12k_mac_op_assign_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * link_conf,struct ieee80211_chanctx_conf * ctx)6165 ath12k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6166 struct ieee80211_vif *vif,
6167 struct ieee80211_bss_conf *link_conf,
6168 struct ieee80211_chanctx_conf *ctx)
6169 {
6170 struct ath12k *ar = hw->priv;
6171 struct ath12k_base *ab = ar->ab;
6172 struct ath12k_vif *arvif = (void *)vif->drv_priv;
6173 int ret;
6174 struct ath12k_wmi_peer_create_arg param;
6175
6176 mutex_lock(&ar->conf_mutex);
6177
6178 ath12k_dbg(ab, ATH12K_DBG_MAC,
6179 "mac chanctx assign ptr %pK vdev_id %i\n",
6180 ctx, arvif->vdev_id);
6181
6182 arvif->punct_bitmap = link_conf->eht_puncturing;
6183
6184 /* for some targets bss peer must be created before vdev_start */
6185 if (ab->hw_params->vdev_start_delay &&
6186 arvif->vdev_type != WMI_VDEV_TYPE_AP &&
6187 arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
6188 !ath12k_peer_exist_by_vdev_id(ab, arvif->vdev_id)) {
6189 memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
6190 ret = 0;
6191 goto out;
6192 }
6193
6194 if (WARN_ON(arvif->is_started)) {
6195 ret = -EBUSY;
6196 goto out;
6197 }
6198
6199 if (ab->hw_params->vdev_start_delay &&
6200 (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
6201 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)) {
6202 param.vdev_id = arvif->vdev_id;
6203 param.peer_type = WMI_PEER_TYPE_DEFAULT;
6204 param.peer_addr = ar->mac_addr;
6205
6206 ret = ath12k_peer_create(ar, arvif, NULL, ¶m);
6207 if (ret) {
6208 ath12k_warn(ab, "failed to create peer after vdev start delay: %d",
6209 ret);
6210 goto out;
6211 }
6212 }
6213
6214 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6215 ret = ath12k_mac_monitor_start(ar);
6216 if (ret)
6217 goto out;
6218 arvif->is_started = true;
6219 goto out;
6220 }
6221
6222 ret = ath12k_mac_vdev_start(arvif, &ctx->def);
6223 if (ret) {
6224 ath12k_warn(ab, "failed to start vdev %i addr %pM on freq %d: %d\n",
6225 arvif->vdev_id, vif->addr,
6226 ctx->def.chan->center_freq, ret);
6227 goto out;
6228 }
6229
6230 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR && ar->monitor_vdev_created)
6231 ath12k_mac_monitor_start(ar);
6232
6233 arvif->is_started = true;
6234
6235 /* TODO: Setup ps and cts/rts protection */
6236
6237 out:
6238 mutex_unlock(&ar->conf_mutex);
6239
6240 return ret;
6241 }
6242
6243 static void
ath12k_mac_op_unassign_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * link_conf,struct ieee80211_chanctx_conf * ctx)6244 ath12k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6245 struct ieee80211_vif *vif,
6246 struct ieee80211_bss_conf *link_conf,
6247 struct ieee80211_chanctx_conf *ctx)
6248 {
6249 struct ath12k *ar = hw->priv;
6250 struct ath12k_base *ab = ar->ab;
6251 struct ath12k_vif *arvif = (void *)vif->drv_priv;
6252 int ret;
6253
6254 mutex_lock(&ar->conf_mutex);
6255
6256 ath12k_dbg(ab, ATH12K_DBG_MAC,
6257 "mac chanctx unassign ptr %pK vdev_id %i\n",
6258 ctx, arvif->vdev_id);
6259
6260 WARN_ON(!arvif->is_started);
6261
6262 if (ab->hw_params->vdev_start_delay &&
6263 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR &&
6264 ath12k_peer_find_by_addr(ab, ar->mac_addr))
6265 ath12k_peer_delete(ar, arvif->vdev_id, ar->mac_addr);
6266
6267 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) {
6268 ret = ath12k_mac_monitor_stop(ar);
6269 if (ret) {
6270 mutex_unlock(&ar->conf_mutex);
6271 return;
6272 }
6273
6274 arvif->is_started = false;
6275 }
6276
6277 ret = ath12k_mac_vdev_stop(arvif);
6278 if (ret)
6279 ath12k_warn(ab, "failed to stop vdev %i: %d\n",
6280 arvif->vdev_id, ret);
6281
6282 arvif->is_started = false;
6283
6284 if (ab->hw_params->vdev_start_delay &&
6285 arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
6286 ath12k_wmi_vdev_down(ar, arvif->vdev_id);
6287
6288 if (arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
6289 ar->num_started_vdevs == 1 && ar->monitor_vdev_created)
6290 ath12k_mac_monitor_stop(ar);
6291
6292 mutex_unlock(&ar->conf_mutex);
6293 }
6294
6295 static int
ath12k_mac_op_switch_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs,enum ieee80211_chanctx_switch_mode mode)6296 ath12k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6297 struct ieee80211_vif_chanctx_switch *vifs,
6298 int n_vifs,
6299 enum ieee80211_chanctx_switch_mode mode)
6300 {
6301 struct ath12k *ar = hw->priv;
6302
6303 mutex_lock(&ar->conf_mutex);
6304
6305 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
6306 "mac chanctx switch n_vifs %d mode %d\n",
6307 n_vifs, mode);
6308 ath12k_mac_update_vif_chan(ar, vifs, n_vifs);
6309
6310 mutex_unlock(&ar->conf_mutex);
6311
6312 return 0;
6313 }
6314
6315 static int
ath12k_set_vdev_param_to_all_vifs(struct ath12k * ar,int param,u32 value)6316 ath12k_set_vdev_param_to_all_vifs(struct ath12k *ar, int param, u32 value)
6317 {
6318 struct ath12k_vif *arvif;
6319 int ret = 0;
6320
6321 mutex_lock(&ar->conf_mutex);
6322 list_for_each_entry(arvif, &ar->arvifs, list) {
6323 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "setting mac vdev %d param %d value %d\n",
6324 param, arvif->vdev_id, value);
6325
6326 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6327 param, value);
6328 if (ret) {
6329 ath12k_warn(ar->ab, "failed to set param %d for vdev %d: %d\n",
6330 param, arvif->vdev_id, ret);
6331 break;
6332 }
6333 }
6334 mutex_unlock(&ar->conf_mutex);
6335 return ret;
6336 }
6337
6338 /* mac80211 stores device specific RTS/Fragmentation threshold value,
6339 * this is set interface specific to firmware from ath12k driver
6340 */
ath12k_mac_op_set_rts_threshold(struct ieee80211_hw * hw,u32 value)6341 static int ath12k_mac_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
6342 {
6343 struct ath12k *ar = hw->priv;
6344 int param_id = WMI_VDEV_PARAM_RTS_THRESHOLD;
6345
6346 return ath12k_set_vdev_param_to_all_vifs(ar, param_id, value);
6347 }
6348
ath12k_mac_op_set_frag_threshold(struct ieee80211_hw * hw,u32 value)6349 static int ath12k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
6350 {
6351 /* Even though there's a WMI vdev param for fragmentation threshold no
6352 * known firmware actually implements it. Moreover it is not possible to
6353 * rely frame fragmentation to mac80211 because firmware clears the
6354 * "more fragments" bit in frame control making it impossible for remote
6355 * devices to reassemble frames.
6356 *
6357 * Hence implement a dummy callback just to say fragmentation isn't
6358 * supported. This effectively prevents mac80211 from doing frame
6359 * fragmentation in software.
6360 */
6361 return -EOPNOTSUPP;
6362 }
6363
ath12k_mac_op_flush(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u32 queues,bool drop)6364 static void ath12k_mac_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
6365 u32 queues, bool drop)
6366 {
6367 struct ath12k *ar = hw->priv;
6368 long time_left;
6369
6370 if (drop)
6371 return;
6372
6373 time_left = wait_event_timeout(ar->dp.tx_empty_waitq,
6374 (atomic_read(&ar->dp.num_tx_pending) == 0),
6375 ATH12K_FLUSH_TIMEOUT);
6376 if (time_left == 0)
6377 ath12k_warn(ar->ab, "failed to flush transmit queue %ld\n", time_left);
6378
6379 time_left = wait_event_timeout(ar->txmgmt_empty_waitq,
6380 (atomic_read(&ar->num_pending_mgmt_tx) == 0),
6381 ATH12K_FLUSH_TIMEOUT);
6382 if (time_left == 0)
6383 ath12k_warn(ar->ab, "failed to flush mgmt transmit queue %ld\n",
6384 time_left);
6385 }
6386
6387 static int
ath12k_mac_bitrate_mask_num_ht_rates(struct ath12k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask)6388 ath12k_mac_bitrate_mask_num_ht_rates(struct ath12k *ar,
6389 enum nl80211_band band,
6390 const struct cfg80211_bitrate_mask *mask)
6391 {
6392 int num_rates = 0;
6393 int i;
6394
6395 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6396 num_rates += hweight16(mask->control[band].ht_mcs[i]);
6397
6398 return num_rates;
6399 }
6400
6401 static bool
ath12k_mac_has_single_legacy_rate(struct ath12k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask)6402 ath12k_mac_has_single_legacy_rate(struct ath12k *ar,
6403 enum nl80211_band band,
6404 const struct cfg80211_bitrate_mask *mask)
6405 {
6406 int num_rates = 0;
6407
6408 num_rates = hweight32(mask->control[band].legacy);
6409
6410 if (ath12k_mac_bitrate_mask_num_ht_rates(ar, band, mask))
6411 return false;
6412
6413 if (ath12k_mac_bitrate_mask_num_vht_rates(ar, band, mask))
6414 return false;
6415
6416 return num_rates == 1;
6417 }
6418
6419 static bool
ath12k_mac_bitrate_mask_get_single_nss(struct ath12k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,int * nss)6420 ath12k_mac_bitrate_mask_get_single_nss(struct ath12k *ar,
6421 enum nl80211_band band,
6422 const struct cfg80211_bitrate_mask *mask,
6423 int *nss)
6424 {
6425 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6426 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6427 u8 ht_nss_mask = 0;
6428 u8 vht_nss_mask = 0;
6429 int i;
6430
6431 /* No need to consider legacy here. Basic rates are always present
6432 * in bitrate mask
6433 */
6434
6435 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6436 if (mask->control[band].ht_mcs[i] == 0)
6437 continue;
6438 else if (mask->control[band].ht_mcs[i] ==
6439 sband->ht_cap.mcs.rx_mask[i])
6440 ht_nss_mask |= BIT(i);
6441 else
6442 return false;
6443 }
6444
6445 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6446 if (mask->control[band].vht_mcs[i] == 0)
6447 continue;
6448 else if (mask->control[band].vht_mcs[i] ==
6449 ath12k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6450 vht_nss_mask |= BIT(i);
6451 else
6452 return false;
6453 }
6454
6455 if (ht_nss_mask != vht_nss_mask)
6456 return false;
6457
6458 if (ht_nss_mask == 0)
6459 return false;
6460
6461 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6462 return false;
6463
6464 *nss = fls(ht_nss_mask);
6465
6466 return true;
6467 }
6468
6469 static int
ath12k_mac_get_single_legacy_rate(struct ath12k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,u32 * rate,u8 * nss)6470 ath12k_mac_get_single_legacy_rate(struct ath12k *ar,
6471 enum nl80211_band band,
6472 const struct cfg80211_bitrate_mask *mask,
6473 u32 *rate, u8 *nss)
6474 {
6475 int rate_idx;
6476 u16 bitrate;
6477 u8 preamble;
6478 u8 hw_rate;
6479
6480 if (hweight32(mask->control[band].legacy) != 1)
6481 return -EINVAL;
6482
6483 rate_idx = ffs(mask->control[band].legacy) - 1;
6484
6485 if (band == NL80211_BAND_5GHZ || band == NL80211_BAND_6GHZ)
6486 rate_idx += ATH12K_MAC_FIRST_OFDM_RATE_IDX;
6487
6488 hw_rate = ath12k_legacy_rates[rate_idx].hw_value;
6489 bitrate = ath12k_legacy_rates[rate_idx].bitrate;
6490
6491 if (ath12k_mac_bitrate_is_cck(bitrate))
6492 preamble = WMI_RATE_PREAMBLE_CCK;
6493 else
6494 preamble = WMI_RATE_PREAMBLE_OFDM;
6495
6496 *nss = 1;
6497 *rate = ATH12K_HW_RATE_CODE(hw_rate, 0, preamble);
6498
6499 return 0;
6500 }
6501
ath12k_mac_set_fixed_rate_params(struct ath12k_vif * arvif,u32 rate,u8 nss,u8 sgi,u8 ldpc)6502 static int ath12k_mac_set_fixed_rate_params(struct ath12k_vif *arvif,
6503 u32 rate, u8 nss, u8 sgi, u8 ldpc)
6504 {
6505 struct ath12k *ar = arvif->ar;
6506 u32 vdev_param;
6507 int ret;
6508
6509 lockdep_assert_held(&ar->conf_mutex);
6510
6511 ath12k_dbg(ar->ab, ATH12K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n",
6512 arvif->vdev_id, rate, nss, sgi);
6513
6514 vdev_param = WMI_VDEV_PARAM_FIXED_RATE;
6515 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6516 vdev_param, rate);
6517 if (ret) {
6518 ath12k_warn(ar->ab, "failed to set fixed rate param 0x%02x: %d\n",
6519 rate, ret);
6520 return ret;
6521 }
6522
6523 vdev_param = WMI_VDEV_PARAM_NSS;
6524 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6525 vdev_param, nss);
6526 if (ret) {
6527 ath12k_warn(ar->ab, "failed to set nss param %d: %d\n",
6528 nss, ret);
6529 return ret;
6530 }
6531
6532 vdev_param = WMI_VDEV_PARAM_SGI;
6533 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6534 vdev_param, sgi);
6535 if (ret) {
6536 ath12k_warn(ar->ab, "failed to set sgi param %d: %d\n",
6537 sgi, ret);
6538 return ret;
6539 }
6540
6541 vdev_param = WMI_VDEV_PARAM_LDPC;
6542 ret = ath12k_wmi_vdev_set_param_cmd(ar, arvif->vdev_id,
6543 vdev_param, ldpc);
6544 if (ret) {
6545 ath12k_warn(ar->ab, "failed to set ldpc param %d: %d\n",
6546 ldpc, ret);
6547 return ret;
6548 }
6549
6550 return 0;
6551 }
6552
6553 static bool
ath12k_mac_vht_mcs_range_present(struct ath12k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask)6554 ath12k_mac_vht_mcs_range_present(struct ath12k *ar,
6555 enum nl80211_band band,
6556 const struct cfg80211_bitrate_mask *mask)
6557 {
6558 int i;
6559 u16 vht_mcs;
6560
6561 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6562 vht_mcs = mask->control[band].vht_mcs[i];
6563
6564 switch (vht_mcs) {
6565 case 0:
6566 case BIT(8) - 1:
6567 case BIT(9) - 1:
6568 case BIT(10) - 1:
6569 break;
6570 default:
6571 return false;
6572 }
6573 }
6574
6575 return true;
6576 }
6577
ath12k_mac_set_bitrate_mask_iter(void * data,struct ieee80211_sta * sta)6578 static void ath12k_mac_set_bitrate_mask_iter(void *data,
6579 struct ieee80211_sta *sta)
6580 {
6581 struct ath12k_vif *arvif = data;
6582 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv;
6583 struct ath12k *ar = arvif->ar;
6584
6585 spin_lock_bh(&ar->data_lock);
6586 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6587 spin_unlock_bh(&ar->data_lock);
6588
6589 ieee80211_queue_work(ar->hw, &arsta->update_wk);
6590 }
6591
ath12k_mac_disable_peer_fixed_rate(void * data,struct ieee80211_sta * sta)6592 static void ath12k_mac_disable_peer_fixed_rate(void *data,
6593 struct ieee80211_sta *sta)
6594 {
6595 struct ath12k_vif *arvif = data;
6596 struct ath12k *ar = arvif->ar;
6597 int ret;
6598
6599 ret = ath12k_wmi_set_peer_param(ar, sta->addr,
6600 arvif->vdev_id,
6601 WMI_PEER_PARAM_FIXED_RATE,
6602 WMI_FIXED_RATE_NONE);
6603 if (ret)
6604 ath12k_warn(ar->ab,
6605 "failed to disable peer fixed rate for STA %pM ret %d\n",
6606 sta->addr, ret);
6607 }
6608
6609 static int
ath12k_mac_op_set_bitrate_mask(struct ieee80211_hw * hw,struct ieee80211_vif * vif,const struct cfg80211_bitrate_mask * mask)6610 ath12k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6611 struct ieee80211_vif *vif,
6612 const struct cfg80211_bitrate_mask *mask)
6613 {
6614 struct ath12k_vif *arvif = (void *)vif->drv_priv;
6615 struct cfg80211_chan_def def;
6616 struct ath12k *ar = arvif->ar;
6617 enum nl80211_band band;
6618 const u8 *ht_mcs_mask;
6619 const u16 *vht_mcs_mask;
6620 u32 rate;
6621 u8 nss;
6622 u8 sgi;
6623 u8 ldpc;
6624 int single_nss;
6625 int ret;
6626 int num_rates;
6627
6628 if (ath12k_mac_vif_chan(vif, &def))
6629 return -EPERM;
6630
6631 band = def.chan->band;
6632 ht_mcs_mask = mask->control[band].ht_mcs;
6633 vht_mcs_mask = mask->control[band].vht_mcs;
6634 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6635
6636 sgi = mask->control[band].gi;
6637 if (sgi == NL80211_TXRATE_FORCE_LGI)
6638 return -EINVAL;
6639
6640 /* mac80211 doesn't support sending a fixed HT/VHT MCS alone, rather it
6641 * requires passing at least one of used basic rates along with them.
6642 * Fixed rate setting across different preambles(legacy, HT, VHT) is
6643 * not supported by the FW. Hence use of FIXED_RATE vdev param is not
6644 * suitable for setting single HT/VHT rates.
6645 * But, there could be a single basic rate passed from userspace which
6646 * can be done through the FIXED_RATE param.
6647 */
6648 if (ath12k_mac_has_single_legacy_rate(ar, band, mask)) {
6649 ret = ath12k_mac_get_single_legacy_rate(ar, band, mask, &rate,
6650 &nss);
6651 if (ret) {
6652 ath12k_warn(ar->ab, "failed to get single legacy rate for vdev %i: %d\n",
6653 arvif->vdev_id, ret);
6654 return ret;
6655 }
6656 ieee80211_iterate_stations_atomic(ar->hw,
6657 ath12k_mac_disable_peer_fixed_rate,
6658 arvif);
6659 } else if (ath12k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6660 &single_nss)) {
6661 rate = WMI_FIXED_RATE_NONE;
6662 nss = single_nss;
6663 } else {
6664 rate = WMI_FIXED_RATE_NONE;
6665 nss = min_t(u32, ar->num_tx_chains,
6666 max(ath12k_mac_max_ht_nss(ht_mcs_mask),
6667 ath12k_mac_max_vht_nss(vht_mcs_mask)));
6668
6669 /* If multiple rates across different preambles are given
6670 * we can reconfigure this info with all peers using PEER_ASSOC
6671 * command with the below exception cases.
6672 * - Single VHT Rate : peer_assoc command accommodates only MCS
6673 * range values i.e 0-7, 0-8, 0-9 for VHT. Though mac80211
6674 * mandates passing basic rates along with HT/VHT rates, FW
6675 * doesn't allow switching from VHT to Legacy. Hence instead of
6676 * setting legacy and VHT rates using RATEMASK_CMD vdev cmd,
6677 * we could set this VHT rate as peer fixed rate param, which
6678 * will override FIXED rate and FW rate control algorithm.
6679 * If single VHT rate is passed along with HT rates, we select
6680 * the VHT rate as fixed rate for vht peers.
6681 * - Multiple VHT Rates : When Multiple VHT rates are given,this
6682 * can be set using RATEMASK CMD which uses FW rate-ctl alg.
6683 * TODO: Setting multiple VHT MCS and replacing peer_assoc with
6684 * RATEMASK_CMDID can cover all use cases of setting rates
6685 * across multiple preambles and rates within same type.
6686 * But requires more validation of the command at this point.
6687 */
6688
6689 num_rates = ath12k_mac_bitrate_mask_num_vht_rates(ar, band,
6690 mask);
6691
6692 if (!ath12k_mac_vht_mcs_range_present(ar, band, mask) &&
6693 num_rates > 1) {
6694 /* TODO: Handle multiple VHT MCS values setting using
6695 * RATEMASK CMD
6696 */
6697 ath12k_warn(ar->ab,
6698 "Setting more than one MCS Value in bitrate mask not supported\n");
6699 return -EINVAL;
6700 }
6701
6702 ieee80211_iterate_stations_atomic(ar->hw,
6703 ath12k_mac_disable_peer_fixed_rate,
6704 arvif);
6705
6706 mutex_lock(&ar->conf_mutex);
6707
6708 arvif->bitrate_mask = *mask;
6709 ieee80211_iterate_stations_atomic(ar->hw,
6710 ath12k_mac_set_bitrate_mask_iter,
6711 arvif);
6712
6713 mutex_unlock(&ar->conf_mutex);
6714 }
6715
6716 mutex_lock(&ar->conf_mutex);
6717
6718 ret = ath12k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6719 if (ret) {
6720 ath12k_warn(ar->ab, "failed to set fixed rate params on vdev %i: %d\n",
6721 arvif->vdev_id, ret);
6722 }
6723
6724 mutex_unlock(&ar->conf_mutex);
6725
6726 return ret;
6727 }
6728
6729 static void
ath12k_mac_op_reconfig_complete(struct ieee80211_hw * hw,enum ieee80211_reconfig_type reconfig_type)6730 ath12k_mac_op_reconfig_complete(struct ieee80211_hw *hw,
6731 enum ieee80211_reconfig_type reconfig_type)
6732 {
6733 struct ath12k *ar = hw->priv;
6734 struct ath12k_base *ab = ar->ab;
6735 struct ath12k_vif *arvif;
6736 int recovery_count;
6737
6738 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
6739 return;
6740
6741 mutex_lock(&ar->conf_mutex);
6742
6743 if (ar->state == ATH12K_STATE_RESTARTED) {
6744 ath12k_warn(ar->ab, "pdev %d successfully recovered\n",
6745 ar->pdev->pdev_id);
6746 ar->state = ATH12K_STATE_ON;
6747 ieee80211_wake_queues(ar->hw);
6748
6749 if (ab->is_reset) {
6750 recovery_count = atomic_inc_return(&ab->recovery_count);
6751 ath12k_dbg(ab, ATH12K_DBG_BOOT, "recovery count %d\n",
6752 recovery_count);
6753 /* When there are multiple radios in an SOC,
6754 * the recovery has to be done for each radio
6755 */
6756 if (recovery_count == ab->num_radios) {
6757 atomic_dec(&ab->reset_count);
6758 complete(&ab->reset_complete);
6759 ab->is_reset = false;
6760 atomic_set(&ab->fail_cont_count, 0);
6761 ath12k_dbg(ab, ATH12K_DBG_BOOT, "reset success\n");
6762 }
6763 }
6764
6765 list_for_each_entry(arvif, &ar->arvifs, list) {
6766 ath12k_dbg(ab, ATH12K_DBG_BOOT,
6767 "reconfig cipher %d up %d vdev type %d\n",
6768 arvif->key_cipher,
6769 arvif->is_up,
6770 arvif->vdev_type);
6771 /* After trigger disconnect, then upper layer will
6772 * trigger connect again, then the PN number of
6773 * upper layer will be reset to keep up with AP
6774 * side, hence PN number mis-match will not happened.
6775 */
6776 if (arvif->is_up &&
6777 arvif->vdev_type == WMI_VDEV_TYPE_STA &&
6778 arvif->vdev_subtype == WMI_VDEV_SUBTYPE_NONE) {
6779 ieee80211_hw_restart_disconnect(arvif->vif);
6780 ath12k_dbg(ab, ATH12K_DBG_BOOT,
6781 "restart disconnect\n");
6782 }
6783 }
6784 }
6785
6786 mutex_unlock(&ar->conf_mutex);
6787 }
6788
6789 static void
ath12k_mac_update_bss_chan_survey(struct ath12k * ar,struct ieee80211_channel * channel)6790 ath12k_mac_update_bss_chan_survey(struct ath12k *ar,
6791 struct ieee80211_channel *channel)
6792 {
6793 int ret;
6794 enum wmi_bss_chan_info_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
6795
6796 lockdep_assert_held(&ar->conf_mutex);
6797
6798 if (!test_bit(WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64, ar->ab->wmi_ab.svc_map) ||
6799 ar->rx_channel != channel)
6800 return;
6801
6802 if (ar->scan.state != ATH12K_SCAN_IDLE) {
6803 ath12k_dbg(ar->ab, ATH12K_DBG_MAC,
6804 "ignoring bss chan info req while scanning..\n");
6805 return;
6806 }
6807
6808 reinit_completion(&ar->bss_survey_done);
6809
6810 ret = ath12k_wmi_pdev_bss_chan_info_request(ar, type);
6811 if (ret) {
6812 ath12k_warn(ar->ab, "failed to send pdev bss chan info request\n");
6813 return;
6814 }
6815
6816 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
6817 if (ret == 0)
6818 ath12k_warn(ar->ab, "bss channel survey timed out\n");
6819 }
6820
ath12k_mac_op_get_survey(struct ieee80211_hw * hw,int idx,struct survey_info * survey)6821 static int ath12k_mac_op_get_survey(struct ieee80211_hw *hw, int idx,
6822 struct survey_info *survey)
6823 {
6824 struct ath12k *ar = hw->priv;
6825 struct ieee80211_supported_band *sband;
6826 struct survey_info *ar_survey;
6827 int ret = 0;
6828
6829 if (idx >= ATH12K_NUM_CHANS)
6830 return -ENOENT;
6831
6832 ar_survey = &ar->survey[idx];
6833
6834 mutex_lock(&ar->conf_mutex);
6835
6836 sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
6837 if (sband && idx >= sband->n_channels) {
6838 idx -= sband->n_channels;
6839 sband = NULL;
6840 }
6841
6842 if (!sband)
6843 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
6844
6845 if (!sband || idx >= sband->n_channels) {
6846 ret = -ENOENT;
6847 goto exit;
6848 }
6849
6850 ath12k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
6851
6852 spin_lock_bh(&ar->data_lock);
6853 memcpy(survey, ar_survey, sizeof(*survey));
6854 spin_unlock_bh(&ar->data_lock);
6855
6856 survey->channel = &sband->channels[idx];
6857
6858 if (ar->rx_channel == survey->channel)
6859 survey->filled |= SURVEY_INFO_IN_USE;
6860
6861 exit:
6862 mutex_unlock(&ar->conf_mutex);
6863 return ret;
6864 }
6865
ath12k_mac_op_sta_statistics(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct station_info * sinfo)6866 static void ath12k_mac_op_sta_statistics(struct ieee80211_hw *hw,
6867 struct ieee80211_vif *vif,
6868 struct ieee80211_sta *sta,
6869 struct station_info *sinfo)
6870 {
6871 struct ath12k_sta *arsta = (struct ath12k_sta *)sta->drv_priv;
6872
6873 sinfo->rx_duration = arsta->rx_duration;
6874 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
6875
6876 sinfo->tx_duration = arsta->tx_duration;
6877 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_DURATION);
6878
6879 if (!arsta->txrate.legacy && !arsta->txrate.nss)
6880 return;
6881
6882 if (arsta->txrate.legacy) {
6883 sinfo->txrate.legacy = arsta->txrate.legacy;
6884 } else {
6885 sinfo->txrate.mcs = arsta->txrate.mcs;
6886 sinfo->txrate.nss = arsta->txrate.nss;
6887 sinfo->txrate.bw = arsta->txrate.bw;
6888 sinfo->txrate.he_gi = arsta->txrate.he_gi;
6889 sinfo->txrate.he_dcm = arsta->txrate.he_dcm;
6890 sinfo->txrate.he_ru_alloc = arsta->txrate.he_ru_alloc;
6891 }
6892 sinfo->txrate.flags = arsta->txrate.flags;
6893 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
6894
6895 /* TODO: Use real NF instead of default one. */
6896 sinfo->signal = arsta->rssi_comb + ATH12K_DEFAULT_NOISE_FLOOR;
6897 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
6898 }
6899
6900 static const struct ieee80211_ops ath12k_ops = {
6901 .tx = ath12k_mac_op_tx,
6902 .wake_tx_queue = ieee80211_handle_wake_tx_queue,
6903 .start = ath12k_mac_op_start,
6904 .stop = ath12k_mac_op_stop,
6905 .reconfig_complete = ath12k_mac_op_reconfig_complete,
6906 .add_interface = ath12k_mac_op_add_interface,
6907 .remove_interface = ath12k_mac_op_remove_interface,
6908 .update_vif_offload = ath12k_mac_op_update_vif_offload,
6909 .config = ath12k_mac_op_config,
6910 .bss_info_changed = ath12k_mac_op_bss_info_changed,
6911 .configure_filter = ath12k_mac_op_configure_filter,
6912 .hw_scan = ath12k_mac_op_hw_scan,
6913 .cancel_hw_scan = ath12k_mac_op_cancel_hw_scan,
6914 .set_key = ath12k_mac_op_set_key,
6915 .sta_state = ath12k_mac_op_sta_state,
6916 .sta_set_txpwr = ath12k_mac_op_sta_set_txpwr,
6917 .sta_rc_update = ath12k_mac_op_sta_rc_update,
6918 .conf_tx = ath12k_mac_op_conf_tx,
6919 .set_antenna = ath12k_mac_op_set_antenna,
6920 .get_antenna = ath12k_mac_op_get_antenna,
6921 .ampdu_action = ath12k_mac_op_ampdu_action,
6922 .add_chanctx = ath12k_mac_op_add_chanctx,
6923 .remove_chanctx = ath12k_mac_op_remove_chanctx,
6924 .change_chanctx = ath12k_mac_op_change_chanctx,
6925 .assign_vif_chanctx = ath12k_mac_op_assign_vif_chanctx,
6926 .unassign_vif_chanctx = ath12k_mac_op_unassign_vif_chanctx,
6927 .switch_vif_chanctx = ath12k_mac_op_switch_vif_chanctx,
6928 .set_rts_threshold = ath12k_mac_op_set_rts_threshold,
6929 .set_frag_threshold = ath12k_mac_op_set_frag_threshold,
6930 .set_bitrate_mask = ath12k_mac_op_set_bitrate_mask,
6931 .get_survey = ath12k_mac_op_get_survey,
6932 .flush = ath12k_mac_op_flush,
6933 .sta_statistics = ath12k_mac_op_sta_statistics,
6934 };
6935
ath12k_mac_update_ch_list(struct ath12k * ar,struct ieee80211_supported_band * band,u32 freq_low,u32 freq_high)6936 static void ath12k_mac_update_ch_list(struct ath12k *ar,
6937 struct ieee80211_supported_band *band,
6938 u32 freq_low, u32 freq_high)
6939 {
6940 int i;
6941
6942 if (!(freq_low && freq_high))
6943 return;
6944
6945 for (i = 0; i < band->n_channels; i++) {
6946 if (band->channels[i].center_freq < freq_low ||
6947 band->channels[i].center_freq > freq_high)
6948 band->channels[i].flags |= IEEE80211_CHAN_DISABLED;
6949 }
6950 }
6951
ath12k_get_phy_id(struct ath12k * ar,u32 band)6952 static u32 ath12k_get_phy_id(struct ath12k *ar, u32 band)
6953 {
6954 struct ath12k_pdev *pdev = ar->pdev;
6955 struct ath12k_pdev_cap *pdev_cap = &pdev->cap;
6956
6957 if (band == WMI_HOST_WLAN_2G_CAP)
6958 return pdev_cap->band[NL80211_BAND_2GHZ].phy_id;
6959
6960 if (band == WMI_HOST_WLAN_5G_CAP)
6961 return pdev_cap->band[NL80211_BAND_5GHZ].phy_id;
6962
6963 ath12k_warn(ar->ab, "unsupported phy cap:%d\n", band);
6964
6965 return 0;
6966 }
6967
ath12k_mac_setup_channels_rates(struct ath12k * ar,u32 supported_bands)6968 static int ath12k_mac_setup_channels_rates(struct ath12k *ar,
6969 u32 supported_bands)
6970 {
6971 struct ieee80211_supported_band *band;
6972 struct ath12k_wmi_hal_reg_capabilities_ext_arg *reg_cap;
6973 void *channels;
6974 u32 phy_id;
6975
6976 BUILD_BUG_ON((ARRAY_SIZE(ath12k_2ghz_channels) +
6977 ARRAY_SIZE(ath12k_5ghz_channels) +
6978 ARRAY_SIZE(ath12k_6ghz_channels)) !=
6979 ATH12K_NUM_CHANS);
6980
6981 reg_cap = &ar->ab->hal_reg_cap[ar->pdev_idx];
6982
6983 if (supported_bands & WMI_HOST_WLAN_2G_CAP) {
6984 channels = kmemdup(ath12k_2ghz_channels,
6985 sizeof(ath12k_2ghz_channels),
6986 GFP_KERNEL);
6987 if (!channels)
6988 return -ENOMEM;
6989
6990 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
6991 band->band = NL80211_BAND_2GHZ;
6992 band->n_channels = ARRAY_SIZE(ath12k_2ghz_channels);
6993 band->channels = channels;
6994 band->n_bitrates = ath12k_g_rates_size;
6995 band->bitrates = ath12k_g_rates;
6996 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
6997
6998 if (ar->ab->hw_params->single_pdev_only) {
6999 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_2G_CAP);
7000 reg_cap = &ar->ab->hal_reg_cap[phy_id];
7001 }
7002 ath12k_mac_update_ch_list(ar, band,
7003 reg_cap->low_2ghz_chan,
7004 reg_cap->high_2ghz_chan);
7005 }
7006
7007 if (supported_bands & WMI_HOST_WLAN_5G_CAP) {
7008 if (reg_cap->high_5ghz_chan >= ATH12K_MAX_6G_FREQ) {
7009 channels = kmemdup(ath12k_6ghz_channels,
7010 sizeof(ath12k_6ghz_channels), GFP_KERNEL);
7011 if (!channels) {
7012 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
7013 return -ENOMEM;
7014 }
7015
7016 ar->supports_6ghz = true;
7017 band = &ar->mac.sbands[NL80211_BAND_6GHZ];
7018 band->band = NL80211_BAND_6GHZ;
7019 band->n_channels = ARRAY_SIZE(ath12k_6ghz_channels);
7020 band->channels = channels;
7021 band->n_bitrates = ath12k_a_rates_size;
7022 band->bitrates = ath12k_a_rates;
7023 ar->hw->wiphy->bands[NL80211_BAND_6GHZ] = band;
7024 ath12k_mac_update_ch_list(ar, band,
7025 reg_cap->low_5ghz_chan,
7026 reg_cap->high_5ghz_chan);
7027 }
7028
7029 if (reg_cap->low_5ghz_chan < ATH12K_MIN_6G_FREQ) {
7030 channels = kmemdup(ath12k_5ghz_channels,
7031 sizeof(ath12k_5ghz_channels),
7032 GFP_KERNEL);
7033 if (!channels) {
7034 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
7035 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
7036 return -ENOMEM;
7037 }
7038
7039 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
7040 band->band = NL80211_BAND_5GHZ;
7041 band->n_channels = ARRAY_SIZE(ath12k_5ghz_channels);
7042 band->channels = channels;
7043 band->n_bitrates = ath12k_a_rates_size;
7044 band->bitrates = ath12k_a_rates;
7045 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
7046
7047 if (ar->ab->hw_params->single_pdev_only) {
7048 phy_id = ath12k_get_phy_id(ar, WMI_HOST_WLAN_5G_CAP);
7049 reg_cap = &ar->ab->hal_reg_cap[phy_id];
7050 }
7051
7052 ath12k_mac_update_ch_list(ar, band,
7053 reg_cap->low_5ghz_chan,
7054 reg_cap->high_5ghz_chan);
7055 }
7056 }
7057
7058 return 0;
7059 }
7060
ath12k_mac_setup_iface_combinations(struct ath12k * ar)7061 static int ath12k_mac_setup_iface_combinations(struct ath12k *ar)
7062 {
7063 struct ath12k_base *ab = ar->ab;
7064 struct ieee80211_iface_combination *combinations;
7065 struct ieee80211_iface_limit *limits;
7066 int n_limits, max_interfaces;
7067 bool ap, mesh;
7068
7069 ap = ab->hw_params->interface_modes & BIT(NL80211_IFTYPE_AP);
7070
7071 mesh = IS_ENABLED(CONFIG_MAC80211_MESH) &&
7072 ab->hw_params->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT);
7073
7074 combinations = kzalloc(sizeof(*combinations), GFP_KERNEL);
7075 if (!combinations)
7076 return -ENOMEM;
7077
7078 if (ap || mesh) {
7079 n_limits = 2;
7080 max_interfaces = 16;
7081 } else {
7082 n_limits = 1;
7083 max_interfaces = 1;
7084 }
7085
7086 limits = kcalloc(n_limits, sizeof(*limits), GFP_KERNEL);
7087 if (!limits) {
7088 kfree(combinations);
7089 return -ENOMEM;
7090 }
7091
7092 limits[0].max = 1;
7093 limits[0].types |= BIT(NL80211_IFTYPE_STATION);
7094
7095 if (ap) {
7096 limits[1].max = max_interfaces;
7097 limits[1].types |= BIT(NL80211_IFTYPE_AP);
7098 }
7099
7100 if (mesh)
7101 limits[1].types |= BIT(NL80211_IFTYPE_MESH_POINT);
7102
7103 combinations[0].limits = limits;
7104 combinations[0].n_limits = n_limits;
7105 combinations[0].max_interfaces = max_interfaces;
7106 combinations[0].num_different_channels = 1;
7107 combinations[0].beacon_int_infra_match = true;
7108 combinations[0].beacon_int_min_gcd = 100;
7109 combinations[0].radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7110 BIT(NL80211_CHAN_WIDTH_20) |
7111 BIT(NL80211_CHAN_WIDTH_40) |
7112 BIT(NL80211_CHAN_WIDTH_80);
7113
7114 ar->hw->wiphy->iface_combinations = combinations;
7115 ar->hw->wiphy->n_iface_combinations = 1;
7116
7117 return 0;
7118 }
7119
7120 static const u8 ath12k_if_types_ext_capa[] = {
7121 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
7122 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
7123 };
7124
7125 static const u8 ath12k_if_types_ext_capa_sta[] = {
7126 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
7127 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
7128 [9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
7129 };
7130
7131 static const u8 ath12k_if_types_ext_capa_ap[] = {
7132 [0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
7133 [7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
7134 [9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
7135 };
7136
7137 static const struct wiphy_iftype_ext_capab ath12k_iftypes_ext_capa[] = {
7138 {
7139 .extended_capabilities = ath12k_if_types_ext_capa,
7140 .extended_capabilities_mask = ath12k_if_types_ext_capa,
7141 .extended_capabilities_len = sizeof(ath12k_if_types_ext_capa),
7142 }, {
7143 .iftype = NL80211_IFTYPE_STATION,
7144 .extended_capabilities = ath12k_if_types_ext_capa_sta,
7145 .extended_capabilities_mask = ath12k_if_types_ext_capa_sta,
7146 .extended_capabilities_len =
7147 sizeof(ath12k_if_types_ext_capa_sta),
7148 }, {
7149 .iftype = NL80211_IFTYPE_AP,
7150 .extended_capabilities = ath12k_if_types_ext_capa_ap,
7151 .extended_capabilities_mask = ath12k_if_types_ext_capa_ap,
7152 .extended_capabilities_len =
7153 sizeof(ath12k_if_types_ext_capa_ap),
7154 },
7155 };
7156
__ath12k_mac_unregister(struct ath12k * ar)7157 static void __ath12k_mac_unregister(struct ath12k *ar)
7158 {
7159 cancel_work_sync(&ar->regd_update_work);
7160
7161 ieee80211_unregister_hw(ar->hw);
7162
7163 idr_for_each(&ar->txmgmt_idr, ath12k_mac_tx_mgmt_pending_free, ar);
7164 idr_destroy(&ar->txmgmt_idr);
7165
7166 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
7167 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
7168 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
7169
7170 kfree(ar->hw->wiphy->iface_combinations[0].limits);
7171 kfree(ar->hw->wiphy->iface_combinations);
7172
7173 SET_IEEE80211_DEV(ar->hw, NULL);
7174 }
7175
ath12k_mac_unregister(struct ath12k_base * ab)7176 void ath12k_mac_unregister(struct ath12k_base *ab)
7177 {
7178 struct ath12k *ar;
7179 struct ath12k_pdev *pdev;
7180 int i;
7181
7182 for (i = 0; i < ab->num_radios; i++) {
7183 pdev = &ab->pdevs[i];
7184 ar = pdev->ar;
7185 if (!ar)
7186 continue;
7187
7188 __ath12k_mac_unregister(ar);
7189 }
7190 }
7191
__ath12k_mac_register(struct ath12k * ar)7192 static int __ath12k_mac_register(struct ath12k *ar)
7193 {
7194 struct ath12k_base *ab = ar->ab;
7195 struct ath12k_pdev_cap *cap = &ar->pdev->cap;
7196 static const u32 cipher_suites[] = {
7197 WLAN_CIPHER_SUITE_TKIP,
7198 WLAN_CIPHER_SUITE_CCMP,
7199 WLAN_CIPHER_SUITE_AES_CMAC,
7200 WLAN_CIPHER_SUITE_BIP_CMAC_256,
7201 WLAN_CIPHER_SUITE_BIP_GMAC_128,
7202 WLAN_CIPHER_SUITE_BIP_GMAC_256,
7203 WLAN_CIPHER_SUITE_GCMP,
7204 WLAN_CIPHER_SUITE_GCMP_256,
7205 WLAN_CIPHER_SUITE_CCMP_256,
7206 };
7207 int ret;
7208 u32 ht_cap = 0;
7209
7210 ath12k_pdev_caps_update(ar);
7211
7212 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7213
7214 SET_IEEE80211_DEV(ar->hw, ab->dev);
7215
7216 ret = ath12k_mac_setup_channels_rates(ar,
7217 cap->supported_bands);
7218 if (ret)
7219 goto err;
7220
7221 ath12k_mac_setup_ht_vht_cap(ar, cap, &ht_cap);
7222 ath12k_mac_setup_sband_iftype_data(ar, cap);
7223
7224 ret = ath12k_mac_setup_iface_combinations(ar);
7225 if (ret) {
7226 ath12k_err(ar->ab, "failed to setup interface combinations: %d\n", ret);
7227 goto err_free_channels;
7228 }
7229
7230 ar->hw->wiphy->available_antennas_rx = cap->rx_chain_mask;
7231 ar->hw->wiphy->available_antennas_tx = cap->tx_chain_mask;
7232
7233 ar->hw->wiphy->interface_modes = ab->hw_params->interface_modes;
7234
7235 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7236 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7237 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7238 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7239 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7240 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7241 ieee80211_hw_set(ar->hw, AP_LINK_PS);
7242 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7243 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7244 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7245 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7246 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7247 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
7248 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
7249
7250 if (ht_cap & WMI_HT_CAP_ENABLED) {
7251 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7252 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7253 ieee80211_hw_set(ar->hw, SUPPORTS_REORDERING_BUFFER);
7254 ieee80211_hw_set(ar->hw, SUPPORTS_AMSDU_IN_AMPDU);
7255 ieee80211_hw_set(ar->hw, USES_RSS);
7256 }
7257
7258 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7259 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7260
7261 /* TODO: Check if HT capability advertised from firmware is different
7262 * for each band for a dual band capable radio. It will be tricky to
7263 * handle it when the ht capability different for each band.
7264 */
7265 if (ht_cap & WMI_HT_CAP_DYNAMIC_SMPS)
7266 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7267
7268 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7269 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7270
7271 ar->hw->max_listen_interval = ATH12K_MAX_HW_LISTEN_INTERVAL;
7272
7273 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7274 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7275 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7276
7277 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7278 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
7279 NL80211_FEATURE_AP_SCAN;
7280
7281 ar->max_num_stations = TARGET_NUM_STATIONS;
7282 ar->max_num_peers = TARGET_NUM_PEERS_PDEV;
7283
7284 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7285
7286 ar->hw->queues = ATH12K_HW_MAX_QUEUES;
7287 ar->hw->wiphy->tx_queue_len = ATH12K_QUEUE_LEN;
7288 ar->hw->offchannel_tx_hw_queue = ATH12K_HW_MAX_QUEUES - 1;
7289 ar->hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
7290
7291 ar->hw->vif_data_size = sizeof(struct ath12k_vif);
7292 ar->hw->sta_data_size = sizeof(struct ath12k_sta);
7293
7294 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
7295 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
7296
7297 ar->hw->wiphy->cipher_suites = cipher_suites;
7298 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7299
7300 ar->hw->wiphy->iftype_ext_capab = ath12k_iftypes_ext_capa;
7301 ar->hw->wiphy->num_iftype_ext_capab =
7302 ARRAY_SIZE(ath12k_iftypes_ext_capa);
7303
7304 if (ar->supports_6ghz) {
7305 wiphy_ext_feature_set(ar->hw->wiphy,
7306 NL80211_EXT_FEATURE_FILS_DISCOVERY);
7307 wiphy_ext_feature_set(ar->hw->wiphy,
7308 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP);
7309 }
7310
7311 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_PUNCT);
7312
7313 ath12k_reg_init(ar);
7314
7315 if (!test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) {
7316 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7317 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7318 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7319 }
7320
7321 ret = ieee80211_register_hw(ar->hw);
7322 if (ret) {
7323 ath12k_err(ar->ab, "ieee80211 registration failed: %d\n", ret);
7324 goto err_free_if_combs;
7325 }
7326
7327 if (!ab->hw_params->supports_monitor)
7328 /* There's a race between calling ieee80211_register_hw()
7329 * and here where the monitor mode is enabled for a little
7330 * while. But that time is so short and in practise it make
7331 * a difference in real life.
7332 */
7333 ar->hw->wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MONITOR);
7334
7335 /* Apply the regd received during initialization */
7336 ret = ath12k_regd_update(ar, true);
7337 if (ret) {
7338 ath12k_err(ar->ab, "ath12k regd update failed: %d\n", ret);
7339 goto err_unregister_hw;
7340 }
7341
7342 return 0;
7343
7344 err_unregister_hw:
7345 ieee80211_unregister_hw(ar->hw);
7346
7347 err_free_if_combs:
7348 kfree(ar->hw->wiphy->iface_combinations[0].limits);
7349 kfree(ar->hw->wiphy->iface_combinations);
7350
7351 err_free_channels:
7352 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
7353 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
7354 kfree(ar->mac.sbands[NL80211_BAND_6GHZ].channels);
7355
7356 err:
7357 SET_IEEE80211_DEV(ar->hw, NULL);
7358 return ret;
7359 }
7360
ath12k_mac_register(struct ath12k_base * ab)7361 int ath12k_mac_register(struct ath12k_base *ab)
7362 {
7363 struct ath12k *ar;
7364 struct ath12k_pdev *pdev;
7365 int i;
7366 int ret;
7367
7368 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags))
7369 return 0;
7370
7371 for (i = 0; i < ab->num_radios; i++) {
7372 pdev = &ab->pdevs[i];
7373 ar = pdev->ar;
7374 if (ab->pdevs_macaddr_valid) {
7375 ether_addr_copy(ar->mac_addr, pdev->mac_addr);
7376 } else {
7377 ether_addr_copy(ar->mac_addr, ab->mac_addr);
7378 ar->mac_addr[4] += i;
7379 }
7380
7381 ret = __ath12k_mac_register(ar);
7382 if (ret)
7383 goto err_cleanup;
7384
7385 init_waitqueue_head(&ar->txmgmt_empty_waitq);
7386 idr_init(&ar->txmgmt_idr);
7387 spin_lock_init(&ar->txmgmt_idr_lock);
7388 }
7389
7390 /* Initialize channel counters frequency value in hertz */
7391 ab->cc_freq_hz = 320000;
7392 ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
7393
7394 return 0;
7395
7396 err_cleanup:
7397 for (i = i - 1; i >= 0; i--) {
7398 pdev = &ab->pdevs[i];
7399 ar = pdev->ar;
7400 __ath12k_mac_unregister(ar);
7401 }
7402
7403 return ret;
7404 }
7405
ath12k_mac_allocate(struct ath12k_base * ab)7406 int ath12k_mac_allocate(struct ath12k_base *ab)
7407 {
7408 struct ieee80211_hw *hw;
7409 struct ath12k *ar;
7410 struct ath12k_pdev *pdev;
7411 int ret;
7412 int i;
7413
7414 if (test_bit(ATH12K_FLAG_REGISTERED, &ab->dev_flags))
7415 return 0;
7416
7417 for (i = 0; i < ab->num_radios; i++) {
7418 pdev = &ab->pdevs[i];
7419 hw = ieee80211_alloc_hw(sizeof(struct ath12k), &ath12k_ops);
7420 if (!hw) {
7421 ath12k_warn(ab, "failed to allocate mac80211 hw device\n");
7422 ret = -ENOMEM;
7423 goto err_free_mac;
7424 }
7425
7426 ar = hw->priv;
7427 ar->hw = hw;
7428 ar->ab = ab;
7429 ar->pdev = pdev;
7430 ar->pdev_idx = i;
7431 ar->lmac_id = ath12k_hw_get_mac_from_pdev_id(ab->hw_params, i);
7432
7433 ar->wmi = &ab->wmi_ab.wmi[i];
7434 /* FIXME: wmi[0] is already initialized during attach,
7435 * Should we do this again?
7436 */
7437 ath12k_wmi_pdev_attach(ab, i);
7438
7439 ar->cfg_tx_chainmask = pdev->cap.tx_chain_mask;
7440 ar->cfg_rx_chainmask = pdev->cap.rx_chain_mask;
7441 ar->num_tx_chains = hweight32(pdev->cap.tx_chain_mask);
7442 ar->num_rx_chains = hweight32(pdev->cap.rx_chain_mask);
7443
7444 pdev->ar = ar;
7445 spin_lock_init(&ar->data_lock);
7446 INIT_LIST_HEAD(&ar->arvifs);
7447 INIT_LIST_HEAD(&ar->ppdu_stats_info);
7448 mutex_init(&ar->conf_mutex);
7449 init_completion(&ar->vdev_setup_done);
7450 init_completion(&ar->vdev_delete_done);
7451 init_completion(&ar->peer_assoc_done);
7452 init_completion(&ar->peer_delete_done);
7453 init_completion(&ar->install_key_done);
7454 init_completion(&ar->bss_survey_done);
7455 init_completion(&ar->scan.started);
7456 init_completion(&ar->scan.completed);
7457
7458 INIT_DELAYED_WORK(&ar->scan.timeout, ath12k_scan_timeout_work);
7459 INIT_WORK(&ar->regd_update_work, ath12k_regd_update_work);
7460
7461 INIT_WORK(&ar->wmi_mgmt_tx_work, ath12k_mgmt_over_wmi_tx_work);
7462 skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
7463 clear_bit(ATH12K_FLAG_MONITOR_ENABLED, &ar->monitor_flags);
7464 }
7465
7466 return 0;
7467
7468 err_free_mac:
7469 ath12k_mac_destroy(ab);
7470
7471 return ret;
7472 }
7473
ath12k_mac_destroy(struct ath12k_base * ab)7474 void ath12k_mac_destroy(struct ath12k_base *ab)
7475 {
7476 struct ath12k *ar;
7477 struct ath12k_pdev *pdev;
7478 int i;
7479
7480 for (i = 0; i < ab->num_radios; i++) {
7481 pdev = &ab->pdevs[i];
7482 ar = pdev->ar;
7483 if (!ar)
7484 continue;
7485
7486 ieee80211_free_hw(ar->hw);
7487 pdev->ar = NULL;
7488 }
7489 }
7490