1 // SPDX-License-Identifier: ISC
2 /*
3 * Copyright (c) 2005-2011 Atheros Communications Inc.
4 * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
5 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
6 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
7 */
8
9 #include "mac.h"
10
11 #include <net/cfg80211.h>
12 #include <net/mac80211.h>
13 #include <linux/etherdevice.h>
14 #include <linux/acpi.h>
15 #include <linux/of.h>
16 #include <linux/bitfield.h>
17
18 #include "hif.h"
19 #include "core.h"
20 #include "debug.h"
21 #include "wmi.h"
22 #include "htt.h"
23 #include "txrx.h"
24 #include "testmode.h"
25 #include "wmi-tlv.h"
26 #include "wmi-ops.h"
27 #include "wow.h"
28
29 /*********/
30 /* Rates */
31 /*********/
32
33 static struct ieee80211_rate ath10k_rates[] = {
34 { .bitrate = 10,
35 .hw_value = ATH10K_HW_RATE_CCK_LP_1M },
36 { .bitrate = 20,
37 .hw_value = ATH10K_HW_RATE_CCK_LP_2M,
38 .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M,
39 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
40 { .bitrate = 55,
41 .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M,
42 .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M,
43 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
44 { .bitrate = 110,
45 .hw_value = ATH10K_HW_RATE_CCK_LP_11M,
46 .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M,
47 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
48
49 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
50 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
51 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
52 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
53 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
54 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
55 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
56 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
57 };
58
59 static struct ieee80211_rate ath10k_rates_rev2[] = {
60 { .bitrate = 10,
61 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_1M },
62 { .bitrate = 20,
63 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_2M,
64 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_2M,
65 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
66 { .bitrate = 55,
67 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_5_5M,
68 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_5_5M,
69 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
70 { .bitrate = 110,
71 .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_11M,
72 .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_11M,
73 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
74
75 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
76 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
77 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
78 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
79 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
80 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
81 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
82 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
83 };
84
85 static const struct cfg80211_sar_freq_ranges ath10k_sar_freq_ranges[] = {
86 {.start_freq = 2402, .end_freq = 2494 },
87 {.start_freq = 5170, .end_freq = 5875 },
88 };
89
90 static const struct cfg80211_sar_capa ath10k_sar_capa = {
91 .type = NL80211_SAR_TYPE_POWER,
92 .num_freq_ranges = (ARRAY_SIZE(ath10k_sar_freq_ranges)),
93 .freq_ranges = &ath10k_sar_freq_ranges[0],
94 };
95
96 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4
97
98 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)
99 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \
100 ATH10K_MAC_FIRST_OFDM_RATE_IDX)
101 #define ath10k_g_rates (ath10k_rates + 0)
102 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
103
104 #define ath10k_g_rates_rev2 (ath10k_rates_rev2 + 0)
105 #define ath10k_g_rates_rev2_size (ARRAY_SIZE(ath10k_rates_rev2))
106
107 #define ath10k_wmi_legacy_rates ath10k_rates
108
ath10k_mac_bitrate_is_cck(int bitrate)109 static bool ath10k_mac_bitrate_is_cck(int bitrate)
110 {
111 switch (bitrate) {
112 case 10:
113 case 20:
114 case 55:
115 case 110:
116 return true;
117 }
118
119 return false;
120 }
121
ath10k_mac_bitrate_to_rate(int bitrate)122 static u8 ath10k_mac_bitrate_to_rate(int bitrate)
123 {
124 return DIV_ROUND_UP(bitrate, 5) |
125 (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
126 }
127
ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band * sband,u8 hw_rate,bool cck)128 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
129 u8 hw_rate, bool cck)
130 {
131 const struct ieee80211_rate *rate;
132 int i;
133
134 for (i = 0; i < sband->n_bitrates; i++) {
135 rate = &sband->bitrates[i];
136
137 if (ath10k_mac_bitrate_is_cck(rate->bitrate) != cck)
138 continue;
139
140 if (rate->hw_value == hw_rate)
141 return i;
142 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
143 rate->hw_value_short == hw_rate)
144 return i;
145 }
146
147 return 0;
148 }
149
ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band * sband,u32 bitrate)150 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
151 u32 bitrate)
152 {
153 int i;
154
155 for (i = 0; i < sband->n_bitrates; i++)
156 if (sband->bitrates[i].bitrate == bitrate)
157 return i;
158
159 return 0;
160 }
161
ath10k_mac_get_rate_hw_value(int bitrate)162 static int ath10k_mac_get_rate_hw_value(int bitrate)
163 {
164 int i;
165 u8 hw_value_prefix = 0;
166
167 if (ath10k_mac_bitrate_is_cck(bitrate))
168 hw_value_prefix = WMI_RATE_PREAMBLE_CCK << 6;
169
170 for (i = 0; i < ARRAY_SIZE(ath10k_rates); i++) {
171 if (ath10k_rates[i].bitrate == bitrate)
172 return hw_value_prefix | ath10k_rates[i].hw_value;
173 }
174
175 return -EINVAL;
176 }
177
ath10k_mac_get_max_vht_mcs_map(u16 mcs_map,int nss)178 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
179 {
180 switch ((mcs_map >> (2 * nss)) & 0x3) {
181 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
182 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
183 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
184 }
185 return 0;
186 }
187
188 static u32
ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])189 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
190 {
191 int nss;
192
193 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
194 if (ht_mcs_mask[nss])
195 return nss + 1;
196
197 return 1;
198 }
199
200 static u32
ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])201 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
202 {
203 int nss;
204
205 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
206 if (vht_mcs_mask[nss])
207 return nss + 1;
208
209 return 1;
210 }
211
ath10k_mac_ext_resource_config(struct ath10k * ar,u32 val)212 int ath10k_mac_ext_resource_config(struct ath10k *ar, u32 val)
213 {
214 enum wmi_host_platform_type platform_type;
215 int ret;
216
217 if (test_bit(WMI_SERVICE_TX_MODE_DYNAMIC, ar->wmi.svc_map))
218 platform_type = WMI_HOST_PLATFORM_LOW_PERF;
219 else
220 platform_type = WMI_HOST_PLATFORM_HIGH_PERF;
221
222 ret = ath10k_wmi_ext_resource_config(ar, platform_type, val);
223
224 if (ret && ret != -EOPNOTSUPP) {
225 ath10k_warn(ar, "failed to configure ext resource: %d\n", ret);
226 return ret;
227 }
228
229 return 0;
230 }
231
232 /**********/
233 /* Crypto */
234 /**********/
235
ath10k_send_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key,enum set_key_cmd cmd,const u8 * macaddr,u32 flags)236 static int ath10k_send_key(struct ath10k_vif *arvif,
237 struct ieee80211_key_conf *key,
238 enum set_key_cmd cmd,
239 const u8 *macaddr, u32 flags)
240 {
241 struct ath10k *ar = arvif->ar;
242 struct wmi_vdev_install_key_arg arg = {
243 .vdev_id = arvif->vdev_id,
244 .key_idx = key->keyidx,
245 .key_len = key->keylen,
246 .key_data = key->key,
247 .key_flags = flags,
248 .macaddr = macaddr,
249 };
250
251 lockdep_assert_held(&arvif->ar->conf_mutex);
252
253 switch (key->cipher) {
254 case WLAN_CIPHER_SUITE_CCMP:
255 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM];
256 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
257 break;
258 case WLAN_CIPHER_SUITE_TKIP:
259 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_TKIP];
260 arg.key_txmic_len = 8;
261 arg.key_rxmic_len = 8;
262 break;
263 case WLAN_CIPHER_SUITE_WEP40:
264 case WLAN_CIPHER_SUITE_WEP104:
265 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_WEP];
266 break;
267 case WLAN_CIPHER_SUITE_CCMP_256:
268 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM];
269 break;
270 case WLAN_CIPHER_SUITE_GCMP:
271 case WLAN_CIPHER_SUITE_GCMP_256:
272 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_GCM];
273 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
274 break;
275 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
276 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
277 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
278 case WLAN_CIPHER_SUITE_AES_CMAC:
279 WARN_ON(1);
280 return -EINVAL;
281 default:
282 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
283 return -EOPNOTSUPP;
284 }
285
286 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
287 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
288
289 if (cmd == DISABLE_KEY) {
290 arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_NONE];
291 arg.key_data = NULL;
292 }
293
294 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
295 }
296
ath10k_install_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key,enum set_key_cmd cmd,const u8 * macaddr,u32 flags)297 static int ath10k_install_key(struct ath10k_vif *arvif,
298 struct ieee80211_key_conf *key,
299 enum set_key_cmd cmd,
300 const u8 *macaddr, u32 flags)
301 {
302 struct ath10k *ar = arvif->ar;
303 int ret;
304 unsigned long time_left;
305
306 lockdep_assert_held(&ar->conf_mutex);
307
308 reinit_completion(&ar->install_key_done);
309
310 if (arvif->nohwcrypt)
311 return 1;
312
313 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
314 if (ret)
315 return ret;
316
317 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
318 if (time_left == 0)
319 return -ETIMEDOUT;
320
321 return 0;
322 }
323
ath10k_install_peer_wep_keys(struct ath10k_vif * arvif,const u8 * addr)324 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
325 const u8 *addr)
326 {
327 struct ath10k *ar = arvif->ar;
328 struct ath10k_peer *peer;
329 int ret;
330 int i;
331 u32 flags;
332
333 lockdep_assert_held(&ar->conf_mutex);
334
335 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&
336 arvif->vif->type != NL80211_IFTYPE_ADHOC &&
337 arvif->vif->type != NL80211_IFTYPE_MESH_POINT))
338 return -EINVAL;
339
340 spin_lock_bh(&ar->data_lock);
341 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
342 spin_unlock_bh(&ar->data_lock);
343
344 if (!peer)
345 return -ENOENT;
346
347 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
348 if (arvif->wep_keys[i] == NULL)
349 continue;
350
351 switch (arvif->vif->type) {
352 case NL80211_IFTYPE_AP:
353 flags = WMI_KEY_PAIRWISE;
354
355 if (arvif->def_wep_key_idx == i)
356 flags |= WMI_KEY_TX_USAGE;
357
358 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
359 SET_KEY, addr, flags);
360 if (ret < 0)
361 return ret;
362 break;
363 case NL80211_IFTYPE_ADHOC:
364 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
365 SET_KEY, addr,
366 WMI_KEY_PAIRWISE);
367 if (ret < 0)
368 return ret;
369
370 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
371 SET_KEY, addr, WMI_KEY_GROUP);
372 if (ret < 0)
373 return ret;
374 break;
375 default:
376 WARN_ON(1);
377 return -EINVAL;
378 }
379
380 spin_lock_bh(&ar->data_lock);
381 peer->keys[i] = arvif->wep_keys[i];
382 spin_unlock_bh(&ar->data_lock);
383 }
384
385 /* In some cases (notably with static WEP IBSS with multiple keys)
386 * multicast Tx becomes broken. Both pairwise and groupwise keys are
387 * installed already. Using WMI_KEY_TX_USAGE in different combinations
388 * didn't seem help. Using def_keyid vdev parameter seems to be
389 * effective so use that.
390 *
391 * FIXME: Revisit. Perhaps this can be done in a less hacky way.
392 */
393 if (arvif->vif->type != NL80211_IFTYPE_ADHOC)
394 return 0;
395
396 if (arvif->def_wep_key_idx == -1)
397 return 0;
398
399 ret = ath10k_wmi_vdev_set_param(arvif->ar,
400 arvif->vdev_id,
401 arvif->ar->wmi.vdev_param->def_keyid,
402 arvif->def_wep_key_idx);
403 if (ret) {
404 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
405 arvif->vdev_id, ret);
406 return ret;
407 }
408
409 return 0;
410 }
411
ath10k_clear_peer_keys(struct ath10k_vif * arvif,const u8 * addr)412 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
413 const u8 *addr)
414 {
415 struct ath10k *ar = arvif->ar;
416 struct ath10k_peer *peer;
417 int first_errno = 0;
418 int ret;
419 int i;
420 u32 flags = 0;
421
422 lockdep_assert_held(&ar->conf_mutex);
423
424 spin_lock_bh(&ar->data_lock);
425 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
426 spin_unlock_bh(&ar->data_lock);
427
428 if (!peer)
429 return -ENOENT;
430
431 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
432 if (peer->keys[i] == NULL)
433 continue;
434
435 /* key flags are not required to delete the key */
436 ret = ath10k_install_key(arvif, peer->keys[i],
437 DISABLE_KEY, addr, flags);
438 if (ret < 0 && first_errno == 0)
439 first_errno = ret;
440
441 if (ret < 0)
442 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
443 i, ret);
444
445 spin_lock_bh(&ar->data_lock);
446 peer->keys[i] = NULL;
447 spin_unlock_bh(&ar->data_lock);
448 }
449
450 return first_errno;
451 }
452
ath10k_mac_is_peer_wep_key_set(struct ath10k * ar,const u8 * addr,u8 keyidx)453 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
454 u8 keyidx)
455 {
456 struct ath10k_peer *peer;
457 int i;
458
459 lockdep_assert_held(&ar->data_lock);
460
461 /* We don't know which vdev this peer belongs to,
462 * since WMI doesn't give us that information.
463 *
464 * FIXME: multi-bss needs to be handled.
465 */
466 peer = ath10k_peer_find(ar, 0, addr);
467 if (!peer)
468 return false;
469
470 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
471 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
472 return true;
473 }
474
475 return false;
476 }
477
ath10k_clear_vdev_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key)478 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
479 struct ieee80211_key_conf *key)
480 {
481 struct ath10k *ar = arvif->ar;
482 struct ath10k_peer *peer;
483 u8 addr[ETH_ALEN];
484 int first_errno = 0;
485 int ret;
486 int i;
487 u32 flags = 0;
488
489 lockdep_assert_held(&ar->conf_mutex);
490
491 for (;;) {
492 /* since ath10k_install_key we can't hold data_lock all the
493 * time, so we try to remove the keys incrementally
494 */
495 spin_lock_bh(&ar->data_lock);
496 i = 0;
497 list_for_each_entry(peer, &ar->peers, list) {
498 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
499 if (peer->keys[i] == key) {
500 ether_addr_copy(addr, peer->addr);
501 peer->keys[i] = NULL;
502 break;
503 }
504 }
505
506 if (i < ARRAY_SIZE(peer->keys))
507 break;
508 }
509 spin_unlock_bh(&ar->data_lock);
510
511 if (i == ARRAY_SIZE(peer->keys))
512 break;
513 /* key flags are not required to delete the key */
514 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
515 if (ret < 0 && first_errno == 0)
516 first_errno = ret;
517
518 if (ret)
519 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
520 addr, ret);
521 }
522
523 return first_errno;
524 }
525
ath10k_mac_vif_update_wep_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key)526 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
527 struct ieee80211_key_conf *key)
528 {
529 struct ath10k *ar = arvif->ar;
530 struct ath10k_peer *peer;
531 int ret;
532
533 lockdep_assert_held(&ar->conf_mutex);
534
535 list_for_each_entry(peer, &ar->peers, list) {
536 if (ether_addr_equal(peer->addr, arvif->vif->addr))
537 continue;
538
539 if (ether_addr_equal(peer->addr, arvif->bssid))
540 continue;
541
542 if (peer->keys[key->keyidx] == key)
543 continue;
544
545 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
546 arvif->vdev_id, key->keyidx);
547
548 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
549 if (ret) {
550 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
551 arvif->vdev_id, peer->addr, ret);
552 return ret;
553 }
554 }
555
556 return 0;
557 }
558
559 /*********************/
560 /* General utilities */
561 /*********************/
562
563 static inline enum wmi_phy_mode
chan_to_phymode(const struct cfg80211_chan_def * chandef)564 chan_to_phymode(const struct cfg80211_chan_def *chandef)
565 {
566 enum wmi_phy_mode phymode = MODE_UNKNOWN;
567
568 switch (chandef->chan->band) {
569 case NL80211_BAND_2GHZ:
570 switch (chandef->width) {
571 case NL80211_CHAN_WIDTH_20_NOHT:
572 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
573 phymode = MODE_11B;
574 else
575 phymode = MODE_11G;
576 break;
577 case NL80211_CHAN_WIDTH_20:
578 phymode = MODE_11NG_HT20;
579 break;
580 case NL80211_CHAN_WIDTH_40:
581 phymode = MODE_11NG_HT40;
582 break;
583 default:
584 phymode = MODE_UNKNOWN;
585 break;
586 }
587 break;
588 case NL80211_BAND_5GHZ:
589 switch (chandef->width) {
590 case NL80211_CHAN_WIDTH_20_NOHT:
591 phymode = MODE_11A;
592 break;
593 case NL80211_CHAN_WIDTH_20:
594 phymode = MODE_11NA_HT20;
595 break;
596 case NL80211_CHAN_WIDTH_40:
597 phymode = MODE_11NA_HT40;
598 break;
599 case NL80211_CHAN_WIDTH_80:
600 phymode = MODE_11AC_VHT80;
601 break;
602 case NL80211_CHAN_WIDTH_160:
603 phymode = MODE_11AC_VHT160;
604 break;
605 case NL80211_CHAN_WIDTH_80P80:
606 phymode = MODE_11AC_VHT80_80;
607 break;
608 default:
609 phymode = MODE_UNKNOWN;
610 break;
611 }
612 break;
613 default:
614 break;
615 }
616
617 WARN_ON(phymode == MODE_UNKNOWN);
618 return phymode;
619 }
620
ath10k_parse_mpdudensity(u8 mpdudensity)621 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
622 {
623 /*
624 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
625 * 0 for no restriction
626 * 1 for 1/4 us
627 * 2 for 1/2 us
628 * 3 for 1 us
629 * 4 for 2 us
630 * 5 for 4 us
631 * 6 for 8 us
632 * 7 for 16 us
633 */
634 switch (mpdudensity) {
635 case 0:
636 return 0;
637 case 1:
638 case 2:
639 case 3:
640 /* Our lower layer calculations limit our precision to
641 * 1 microsecond
642 */
643 return 1;
644 case 4:
645 return 2;
646 case 5:
647 return 4;
648 case 6:
649 return 8;
650 case 7:
651 return 16;
652 default:
653 return 0;
654 }
655 }
656
ath10k_mac_vif_chan(struct ieee80211_vif * vif,struct cfg80211_chan_def * def)657 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
658 struct cfg80211_chan_def *def)
659 {
660 struct ieee80211_chanctx_conf *conf;
661
662 rcu_read_lock();
663 conf = rcu_dereference(vif->bss_conf.chanctx_conf);
664 if (!conf) {
665 rcu_read_unlock();
666 return -ENOENT;
667 }
668
669 *def = conf->def;
670 rcu_read_unlock();
671
672 return 0;
673 }
674
ath10k_mac_num_chanctxs_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)675 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
676 struct ieee80211_chanctx_conf *conf,
677 void *data)
678 {
679 int *num = data;
680
681 (*num)++;
682 }
683
ath10k_mac_num_chanctxs(struct ath10k * ar)684 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
685 {
686 int num = 0;
687
688 ieee80211_iter_chan_contexts_atomic(ar->hw,
689 ath10k_mac_num_chanctxs_iter,
690 &num);
691
692 return num;
693 }
694
695 static void
ath10k_mac_get_any_chandef_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)696 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
697 struct ieee80211_chanctx_conf *conf,
698 void *data)
699 {
700 struct cfg80211_chan_def **def = data;
701
702 *def = &conf->def;
703 }
704
ath10k_wait_for_peer_delete_done(struct ath10k * ar,u32 vdev_id,const u8 * addr)705 static void ath10k_wait_for_peer_delete_done(struct ath10k *ar, u32 vdev_id,
706 const u8 *addr)
707 {
708 unsigned long time_left;
709 int ret;
710
711 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {
712 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
713 if (ret) {
714 ath10k_warn(ar, "failed wait for peer deleted");
715 return;
716 }
717
718 time_left = wait_for_completion_timeout(&ar->peer_delete_done,
719 5 * HZ);
720 if (!time_left)
721 ath10k_warn(ar, "Timeout in receiving peer delete response\n");
722 }
723 }
724
ath10k_peer_create(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 vdev_id,const u8 * addr,enum wmi_peer_type peer_type)725 static int ath10k_peer_create(struct ath10k *ar,
726 struct ieee80211_vif *vif,
727 struct ieee80211_sta *sta,
728 u32 vdev_id,
729 const u8 *addr,
730 enum wmi_peer_type peer_type)
731 {
732 struct ath10k_peer *peer;
733 int ret;
734
735 lockdep_assert_held(&ar->conf_mutex);
736
737 /* Each vdev consumes a peer entry as well. */
738 if (ar->num_peers + list_count_nodes(&ar->arvifs) >= ar->max_num_peers)
739 return -ENOBUFS;
740
741 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
742 if (ret) {
743 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
744 addr, vdev_id, ret);
745 return ret;
746 }
747
748 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
749 if (ret) {
750 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
751 addr, vdev_id, ret);
752 return ret;
753 }
754
755 spin_lock_bh(&ar->data_lock);
756
757 peer = ath10k_peer_find(ar, vdev_id, addr);
758 if (!peer) {
759 spin_unlock_bh(&ar->data_lock);
760 ath10k_warn(ar, "failed to find peer %pM on vdev %i after creation\n",
761 addr, vdev_id);
762 ath10k_wait_for_peer_delete_done(ar, vdev_id, addr);
763 return -ENOENT;
764 }
765
766 peer->vif = vif;
767 peer->sta = sta;
768
769 spin_unlock_bh(&ar->data_lock);
770
771 ar->num_peers++;
772
773 return 0;
774 }
775
ath10k_mac_set_kickout(struct ath10k_vif * arvif)776 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
777 {
778 struct ath10k *ar = arvif->ar;
779 u32 param;
780 int ret;
781
782 param = ar->wmi.pdev_param->sta_kickout_th;
783 ret = ath10k_wmi_pdev_set_param(ar, param,
784 ATH10K_KICKOUT_THRESHOLD);
785 if (ret) {
786 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
787 arvif->vdev_id, ret);
788 return ret;
789 }
790
791 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
792 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
793 ATH10K_KEEPALIVE_MIN_IDLE);
794 if (ret) {
795 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
796 arvif->vdev_id, ret);
797 return ret;
798 }
799
800 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
801 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
802 ATH10K_KEEPALIVE_MAX_IDLE);
803 if (ret) {
804 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
805 arvif->vdev_id, ret);
806 return ret;
807 }
808
809 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
810 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
811 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
812 if (ret) {
813 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
814 arvif->vdev_id, ret);
815 return ret;
816 }
817
818 return 0;
819 }
820
ath10k_mac_set_rts(struct ath10k_vif * arvif,u32 value)821 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
822 {
823 struct ath10k *ar = arvif->ar;
824 u32 vdev_param;
825
826 vdev_param = ar->wmi.vdev_param->rts_threshold;
827 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
828 }
829
ath10k_peer_delete(struct ath10k * ar,u32 vdev_id,const u8 * addr)830 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
831 {
832 int ret;
833
834 lockdep_assert_held(&ar->conf_mutex);
835
836 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
837 if (ret)
838 return ret;
839
840 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
841 if (ret)
842 return ret;
843
844 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {
845 unsigned long time_left;
846
847 time_left = wait_for_completion_timeout
848 (&ar->peer_delete_done, 5 * HZ);
849
850 if (!time_left) {
851 ath10k_warn(ar, "Timeout in receiving peer delete response\n");
852 return -ETIMEDOUT;
853 }
854 }
855
856 ar->num_peers--;
857
858 return 0;
859 }
860
ath10k_peer_map_cleanup(struct ath10k * ar,struct ath10k_peer * peer)861 static void ath10k_peer_map_cleanup(struct ath10k *ar, struct ath10k_peer *peer)
862 {
863 int peer_id, i;
864
865 lockdep_assert_held(&ar->conf_mutex);
866
867 for_each_set_bit(peer_id, peer->peer_ids,
868 ATH10K_MAX_NUM_PEER_IDS) {
869 ar->peer_map[peer_id] = NULL;
870 }
871
872 /* Double check that peer is properly un-referenced from
873 * the peer_map
874 */
875 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
876 if (ar->peer_map[i] == peer) {
877 ath10k_warn(ar, "removing stale peer_map entry for %pM (ptr %pK idx %d)\n",
878 peer->addr, peer, i);
879 ar->peer_map[i] = NULL;
880 }
881 }
882
883 list_del(&peer->list);
884 kfree(peer);
885 ar->num_peers--;
886 }
887
ath10k_peer_cleanup(struct ath10k * ar,u32 vdev_id)888 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
889 {
890 struct ath10k_peer *peer, *tmp;
891
892 lockdep_assert_held(&ar->conf_mutex);
893
894 spin_lock_bh(&ar->data_lock);
895 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
896 if (peer->vdev_id != vdev_id)
897 continue;
898
899 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
900 peer->addr, vdev_id);
901
902 ath10k_peer_map_cleanup(ar, peer);
903 }
904 spin_unlock_bh(&ar->data_lock);
905 }
906
ath10k_peer_cleanup_all(struct ath10k * ar)907 static void ath10k_peer_cleanup_all(struct ath10k *ar)
908 {
909 struct ath10k_peer *peer, *tmp;
910 int i;
911
912 lockdep_assert_held(&ar->conf_mutex);
913
914 spin_lock_bh(&ar->data_lock);
915 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
916 list_del(&peer->list);
917 kfree(peer);
918 }
919
920 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++)
921 ar->peer_map[i] = NULL;
922
923 spin_unlock_bh(&ar->data_lock);
924
925 ar->num_peers = 0;
926 ar->num_stations = 0;
927 }
928
ath10k_mac_tdls_peer_update(struct ath10k * ar,u32 vdev_id,struct ieee80211_sta * sta,enum wmi_tdls_peer_state state)929 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
930 struct ieee80211_sta *sta,
931 enum wmi_tdls_peer_state state)
932 {
933 int ret;
934 struct wmi_tdls_peer_update_cmd_arg arg = {};
935 struct wmi_tdls_peer_capab_arg cap = {};
936 struct wmi_channel_arg chan_arg = {};
937
938 lockdep_assert_held(&ar->conf_mutex);
939
940 arg.vdev_id = vdev_id;
941 arg.peer_state = state;
942 ether_addr_copy(arg.addr, sta->addr);
943
944 cap.peer_max_sp = sta->max_sp;
945 cap.peer_uapsd_queues = sta->uapsd_queues;
946
947 if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
948 !sta->tdls_initiator)
949 cap.is_peer_responder = 1;
950
951 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
952 if (ret) {
953 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
954 arg.addr, vdev_id, ret);
955 return ret;
956 }
957
958 return 0;
959 }
960
961 /************************/
962 /* Interface management */
963 /************************/
964
ath10k_mac_vif_beacon_free(struct ath10k_vif * arvif)965 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
966 {
967 struct ath10k *ar = arvif->ar;
968
969 lockdep_assert_held(&ar->data_lock);
970
971 if (!arvif->beacon)
972 return;
973
974 if (!arvif->beacon_buf)
975 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
976 arvif->beacon->len, DMA_TO_DEVICE);
977
978 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
979 arvif->beacon_state != ATH10K_BEACON_SENT))
980 return;
981
982 dev_kfree_skb_any(arvif->beacon);
983
984 arvif->beacon = NULL;
985 arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
986 }
987
ath10k_mac_vif_beacon_cleanup(struct ath10k_vif * arvif)988 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
989 {
990 struct ath10k *ar = arvif->ar;
991
992 lockdep_assert_held(&ar->data_lock);
993
994 ath10k_mac_vif_beacon_free(arvif);
995
996 if (arvif->beacon_buf) {
997 if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL)
998 kfree(arvif->beacon_buf);
999 else
1000 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
1001 arvif->beacon_buf,
1002 arvif->beacon_paddr);
1003 arvif->beacon_buf = NULL;
1004 }
1005 }
1006
ath10k_vdev_setup_sync(struct ath10k * ar)1007 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
1008 {
1009 unsigned long time_left;
1010
1011 lockdep_assert_held(&ar->conf_mutex);
1012
1013 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
1014 return -ESHUTDOWN;
1015
1016 time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
1017 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
1018 if (time_left == 0)
1019 return -ETIMEDOUT;
1020
1021 return ar->last_wmi_vdev_start_status;
1022 }
1023
ath10k_monitor_vdev_start(struct ath10k * ar,int vdev_id)1024 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
1025 {
1026 struct cfg80211_chan_def *chandef = NULL;
1027 struct ieee80211_channel *channel = NULL;
1028 struct wmi_vdev_start_request_arg arg = {};
1029 int ret = 0;
1030
1031 lockdep_assert_held(&ar->conf_mutex);
1032
1033 ieee80211_iter_chan_contexts_atomic(ar->hw,
1034 ath10k_mac_get_any_chandef_iter,
1035 &chandef);
1036 if (WARN_ON_ONCE(!chandef))
1037 return -ENOENT;
1038
1039 channel = chandef->chan;
1040
1041 arg.vdev_id = vdev_id;
1042 arg.channel.freq = channel->center_freq;
1043 arg.channel.band_center_freq1 = chandef->center_freq1;
1044 arg.channel.band_center_freq2 = chandef->center_freq2;
1045
1046 /* TODO setup this dynamically, what in case we
1047 * don't have any vifs?
1048 */
1049 arg.channel.mode = chan_to_phymode(chandef);
1050 arg.channel.chan_radar =
1051 !!(channel->flags & IEEE80211_CHAN_RADAR);
1052
1053 arg.channel.min_power = 0;
1054 arg.channel.max_power = channel->max_power * 2;
1055 arg.channel.max_reg_power = channel->max_reg_power * 2;
1056 arg.channel.max_antenna_gain = channel->max_antenna_gain;
1057
1058 reinit_completion(&ar->vdev_setup_done);
1059 reinit_completion(&ar->vdev_delete_done);
1060
1061 ret = ath10k_wmi_vdev_start(ar, &arg);
1062 if (ret) {
1063 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
1064 vdev_id, ret);
1065 return ret;
1066 }
1067
1068 ret = ath10k_vdev_setup_sync(ar);
1069 if (ret) {
1070 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
1071 vdev_id, ret);
1072 return ret;
1073 }
1074
1075 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
1076 if (ret) {
1077 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
1078 vdev_id, ret);
1079 goto vdev_stop;
1080 }
1081
1082 ar->monitor_vdev_id = vdev_id;
1083
1084 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
1085 ar->monitor_vdev_id);
1086 return 0;
1087
1088 vdev_stop:
1089 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1090 if (ret)
1091 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
1092 ar->monitor_vdev_id, ret);
1093
1094 return ret;
1095 }
1096
ath10k_monitor_vdev_stop(struct ath10k * ar)1097 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
1098 {
1099 int ret = 0;
1100
1101 lockdep_assert_held(&ar->conf_mutex);
1102
1103 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
1104 if (ret)
1105 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
1106 ar->monitor_vdev_id, ret);
1107
1108 reinit_completion(&ar->vdev_setup_done);
1109 reinit_completion(&ar->vdev_delete_done);
1110
1111 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1112 if (ret)
1113 ath10k_warn(ar, "failed to request monitor vdev %i stop: %d\n",
1114 ar->monitor_vdev_id, ret);
1115
1116 ret = ath10k_vdev_setup_sync(ar);
1117 if (ret)
1118 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
1119 ar->monitor_vdev_id, ret);
1120
1121 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
1122 ar->monitor_vdev_id);
1123 return ret;
1124 }
1125
ath10k_monitor_vdev_create(struct ath10k * ar)1126 static int ath10k_monitor_vdev_create(struct ath10k *ar)
1127 {
1128 int bit, ret = 0;
1129
1130 lockdep_assert_held(&ar->conf_mutex);
1131
1132 if (ar->free_vdev_map == 0) {
1133 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
1134 return -ENOMEM;
1135 }
1136
1137 bit = __ffs64(ar->free_vdev_map);
1138
1139 ar->monitor_vdev_id = bit;
1140
1141 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
1142 WMI_VDEV_TYPE_MONITOR,
1143 0, ar->mac_addr);
1144 if (ret) {
1145 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
1146 ar->monitor_vdev_id, ret);
1147 return ret;
1148 }
1149
1150 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1151 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
1152 ar->monitor_vdev_id);
1153
1154 return 0;
1155 }
1156
ath10k_monitor_vdev_delete(struct ath10k * ar)1157 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
1158 {
1159 int ret = 0;
1160
1161 lockdep_assert_held(&ar->conf_mutex);
1162
1163 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1164 if (ret) {
1165 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
1166 ar->monitor_vdev_id, ret);
1167 return ret;
1168 }
1169
1170 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
1171
1172 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
1173 ar->monitor_vdev_id);
1174 return ret;
1175 }
1176
ath10k_monitor_start(struct ath10k * ar)1177 static int ath10k_monitor_start(struct ath10k *ar)
1178 {
1179 int ret;
1180
1181 lockdep_assert_held(&ar->conf_mutex);
1182
1183 ret = ath10k_monitor_vdev_create(ar);
1184 if (ret) {
1185 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1186 return ret;
1187 }
1188
1189 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
1190 if (ret) {
1191 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1192 ath10k_monitor_vdev_delete(ar);
1193 return ret;
1194 }
1195
1196 ar->monitor_started = true;
1197 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1198
1199 return 0;
1200 }
1201
ath10k_monitor_stop(struct ath10k * ar)1202 static int ath10k_monitor_stop(struct ath10k *ar)
1203 {
1204 int ret;
1205
1206 lockdep_assert_held(&ar->conf_mutex);
1207
1208 ret = ath10k_monitor_vdev_stop(ar);
1209 if (ret) {
1210 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1211 return ret;
1212 }
1213
1214 ret = ath10k_monitor_vdev_delete(ar);
1215 if (ret) {
1216 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1217 return ret;
1218 }
1219
1220 ar->monitor_started = false;
1221 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1222
1223 return 0;
1224 }
1225
ath10k_mac_monitor_vdev_is_needed(struct ath10k * ar)1226 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1227 {
1228 int num_ctx;
1229
1230 /* At least one chanctx is required to derive a channel to start
1231 * monitor vdev on.
1232 */
1233 num_ctx = ath10k_mac_num_chanctxs(ar);
1234 if (num_ctx == 0)
1235 return false;
1236
1237 /* If there's already an existing special monitor interface then don't
1238 * bother creating another monitor vdev.
1239 */
1240 if (ar->monitor_arvif)
1241 return false;
1242
1243 return ar->monitor ||
1244 (!test_bit(ATH10K_FW_FEATURE_ALLOWS_MESH_BCAST,
1245 ar->running_fw->fw_file.fw_features) &&
1246 (ar->filter_flags & (FIF_OTHER_BSS | FIF_MCAST_ACTION))) ||
1247 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1248 }
1249
ath10k_mac_monitor_vdev_is_allowed(struct ath10k * ar)1250 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)
1251 {
1252 int num_ctx;
1253
1254 num_ctx = ath10k_mac_num_chanctxs(ar);
1255
1256 /* FIXME: Current interface combinations and cfg80211/mac80211 code
1257 * shouldn't allow this but make sure to prevent handling the following
1258 * case anyway since multi-channel DFS hasn't been tested at all.
1259 */
1260 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)
1261 return false;
1262
1263 return true;
1264 }
1265
ath10k_monitor_recalc(struct ath10k * ar)1266 static int ath10k_monitor_recalc(struct ath10k *ar)
1267 {
1268 bool needed;
1269 bool allowed;
1270 int ret;
1271
1272 lockdep_assert_held(&ar->conf_mutex);
1273
1274 needed = ath10k_mac_monitor_vdev_is_needed(ar);
1275 allowed = ath10k_mac_monitor_vdev_is_allowed(ar);
1276
1277 ath10k_dbg(ar, ATH10K_DBG_MAC,
1278 "mac monitor recalc started? %d needed? %d allowed? %d\n",
1279 ar->monitor_started, needed, allowed);
1280
1281 if (WARN_ON(needed && !allowed)) {
1282 if (ar->monitor_started) {
1283 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");
1284
1285 ret = ath10k_monitor_stop(ar);
1286 if (ret)
1287 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n",
1288 ret);
1289 /* not serious */
1290 }
1291
1292 return -EPERM;
1293 }
1294
1295 if (needed == ar->monitor_started)
1296 return 0;
1297
1298 if (needed)
1299 return ath10k_monitor_start(ar);
1300 else
1301 return ath10k_monitor_stop(ar);
1302 }
1303
ath10k_mac_can_set_cts_prot(struct ath10k_vif * arvif)1304 static bool ath10k_mac_can_set_cts_prot(struct ath10k_vif *arvif)
1305 {
1306 struct ath10k *ar = arvif->ar;
1307
1308 lockdep_assert_held(&ar->conf_mutex);
1309
1310 if (!arvif->is_started) {
1311 ath10k_dbg(ar, ATH10K_DBG_MAC, "defer cts setup, vdev is not ready yet\n");
1312 return false;
1313 }
1314
1315 return true;
1316 }
1317
ath10k_mac_set_cts_prot(struct ath10k_vif * arvif)1318 static int ath10k_mac_set_cts_prot(struct ath10k_vif *arvif)
1319 {
1320 struct ath10k *ar = arvif->ar;
1321 u32 vdev_param;
1322
1323 lockdep_assert_held(&ar->conf_mutex);
1324
1325 vdev_param = ar->wmi.vdev_param->protection_mode;
1326
1327 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_protection %d\n",
1328 arvif->vdev_id, arvif->use_cts_prot);
1329
1330 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1331 arvif->use_cts_prot ? 1 : 0);
1332 }
1333
ath10k_recalc_rtscts_prot(struct ath10k_vif * arvif)1334 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
1335 {
1336 struct ath10k *ar = arvif->ar;
1337 u32 vdev_param, rts_cts = 0;
1338
1339 lockdep_assert_held(&ar->conf_mutex);
1340
1341 vdev_param = ar->wmi.vdev_param->enable_rtscts;
1342
1343 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
1344
1345 if (arvif->num_legacy_stations > 0)
1346 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
1347 WMI_RTSCTS_PROFILE);
1348 else
1349 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,
1350 WMI_RTSCTS_PROFILE);
1351
1352 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n",
1353 arvif->vdev_id, rts_cts);
1354
1355 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1356 rts_cts);
1357 }
1358
ath10k_start_cac(struct ath10k * ar)1359 static int ath10k_start_cac(struct ath10k *ar)
1360 {
1361 int ret;
1362
1363 lockdep_assert_held(&ar->conf_mutex);
1364
1365 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1366
1367 ret = ath10k_monitor_recalc(ar);
1368 if (ret) {
1369 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
1370 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1371 return ret;
1372 }
1373
1374 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
1375 ar->monitor_vdev_id);
1376
1377 return 0;
1378 }
1379
ath10k_stop_cac(struct ath10k * ar)1380 static int ath10k_stop_cac(struct ath10k *ar)
1381 {
1382 lockdep_assert_held(&ar->conf_mutex);
1383
1384 /* CAC is not running - do nothing */
1385 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
1386 return 0;
1387
1388 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1389 ath10k_monitor_stop(ar);
1390
1391 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
1392
1393 return 0;
1394 }
1395
ath10k_mac_has_radar_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)1396 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,
1397 struct ieee80211_chanctx_conf *conf,
1398 void *data)
1399 {
1400 bool *ret = data;
1401
1402 if (!*ret && conf->radar_enabled)
1403 *ret = true;
1404 }
1405
ath10k_mac_has_radar_enabled(struct ath10k * ar)1406 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)
1407 {
1408 bool has_radar = false;
1409
1410 ieee80211_iter_chan_contexts_atomic(ar->hw,
1411 ath10k_mac_has_radar_iter,
1412 &has_radar);
1413
1414 return has_radar;
1415 }
1416
ath10k_recalc_radar_detection(struct ath10k * ar)1417 static void ath10k_recalc_radar_detection(struct ath10k *ar)
1418 {
1419 int ret;
1420
1421 lockdep_assert_held(&ar->conf_mutex);
1422
1423 ath10k_stop_cac(ar);
1424
1425 if (!ath10k_mac_has_radar_enabled(ar))
1426 return;
1427
1428 if (ar->num_started_vdevs > 0)
1429 return;
1430
1431 ret = ath10k_start_cac(ar);
1432 if (ret) {
1433 /*
1434 * Not possible to start CAC on current channel so starting
1435 * radiation is not allowed, make this channel DFS_UNAVAILABLE
1436 * by indicating that radar was detected.
1437 */
1438 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
1439 ieee80211_radar_detected(ar->hw);
1440 }
1441 }
1442
ath10k_vdev_stop(struct ath10k_vif * arvif)1443 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
1444 {
1445 struct ath10k *ar = arvif->ar;
1446 int ret;
1447
1448 lockdep_assert_held(&ar->conf_mutex);
1449
1450 reinit_completion(&ar->vdev_setup_done);
1451 reinit_completion(&ar->vdev_delete_done);
1452
1453 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
1454 if (ret) {
1455 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
1456 arvif->vdev_id, ret);
1457 return ret;
1458 }
1459
1460 ret = ath10k_vdev_setup_sync(ar);
1461 if (ret) {
1462 ath10k_warn(ar, "failed to synchronize setup for vdev %i: %d\n",
1463 arvif->vdev_id, ret);
1464 return ret;
1465 }
1466
1467 WARN_ON(ar->num_started_vdevs == 0);
1468
1469 if (ar->num_started_vdevs != 0) {
1470 ar->num_started_vdevs--;
1471 ath10k_recalc_radar_detection(ar);
1472 }
1473
1474 return ret;
1475 }
1476
ath10k_vdev_start_restart(struct ath10k_vif * arvif,const struct cfg80211_chan_def * chandef,bool restart)1477 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,
1478 const struct cfg80211_chan_def *chandef,
1479 bool restart)
1480 {
1481 struct ath10k *ar = arvif->ar;
1482 struct wmi_vdev_start_request_arg arg = {};
1483 int ret = 0;
1484
1485 lockdep_assert_held(&ar->conf_mutex);
1486
1487 reinit_completion(&ar->vdev_setup_done);
1488 reinit_completion(&ar->vdev_delete_done);
1489
1490 arg.vdev_id = arvif->vdev_id;
1491 arg.dtim_period = arvif->dtim_period;
1492 arg.bcn_intval = arvif->beacon_interval;
1493
1494 arg.channel.freq = chandef->chan->center_freq;
1495 arg.channel.band_center_freq1 = chandef->center_freq1;
1496 arg.channel.band_center_freq2 = chandef->center_freq2;
1497 arg.channel.mode = chan_to_phymode(chandef);
1498
1499 arg.channel.min_power = 0;
1500 arg.channel.max_power = chandef->chan->max_power * 2;
1501 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
1502 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
1503
1504 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1505 arg.ssid = arvif->u.ap.ssid;
1506 arg.ssid_len = arvif->u.ap.ssid_len;
1507 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
1508
1509 /* For now allow DFS for AP mode */
1510 arg.channel.chan_radar =
1511 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
1512 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
1513 arg.ssid = arvif->vif->cfg.ssid;
1514 arg.ssid_len = arvif->vif->cfg.ssid_len;
1515 }
1516
1517 ath10k_dbg(ar, ATH10K_DBG_MAC,
1518 "mac vdev %d start center_freq %d phymode %s\n",
1519 arg.vdev_id, arg.channel.freq,
1520 ath10k_wmi_phymode_str(arg.channel.mode));
1521
1522 if (restart)
1523 ret = ath10k_wmi_vdev_restart(ar, &arg);
1524 else
1525 ret = ath10k_wmi_vdev_start(ar, &arg);
1526
1527 if (ret) {
1528 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
1529 arg.vdev_id, ret);
1530 return ret;
1531 }
1532
1533 ret = ath10k_vdev_setup_sync(ar);
1534 if (ret) {
1535 ath10k_warn(ar,
1536 "failed to synchronize setup for vdev %i restart %d: %d\n",
1537 arg.vdev_id, restart, ret);
1538 return ret;
1539 }
1540
1541 ar->num_started_vdevs++;
1542 ath10k_recalc_radar_detection(ar);
1543
1544 return ret;
1545 }
1546
ath10k_vdev_start(struct ath10k_vif * arvif,const struct cfg80211_chan_def * def)1547 static int ath10k_vdev_start(struct ath10k_vif *arvif,
1548 const struct cfg80211_chan_def *def)
1549 {
1550 return ath10k_vdev_start_restart(arvif, def, false);
1551 }
1552
ath10k_vdev_restart(struct ath10k_vif * arvif,const struct cfg80211_chan_def * def)1553 static int ath10k_vdev_restart(struct ath10k_vif *arvif,
1554 const struct cfg80211_chan_def *def)
1555 {
1556 return ath10k_vdev_start_restart(arvif, def, true);
1557 }
1558
ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif * arvif,struct sk_buff * bcn)1559 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
1560 struct sk_buff *bcn)
1561 {
1562 struct ath10k *ar = arvif->ar;
1563 struct ieee80211_mgmt *mgmt;
1564 const u8 *p2p_ie;
1565 int ret;
1566
1567 if (arvif->vif->type != NL80211_IFTYPE_AP || !arvif->vif->p2p)
1568 return 0;
1569
1570 mgmt = (void *)bcn->data;
1571 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1572 mgmt->u.beacon.variable,
1573 bcn->len - (mgmt->u.beacon.variable -
1574 bcn->data));
1575 if (!p2p_ie)
1576 return -ENOENT;
1577
1578 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1579 if (ret) {
1580 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1581 arvif->vdev_id, ret);
1582 return ret;
1583 }
1584
1585 return 0;
1586 }
1587
ath10k_mac_remove_vendor_ie(struct sk_buff * skb,unsigned int oui,u8 oui_type,size_t ie_offset)1588 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1589 u8 oui_type, size_t ie_offset)
1590 {
1591 size_t len;
1592 const u8 *next;
1593 const u8 *end;
1594 u8 *ie;
1595
1596 if (WARN_ON(skb->len < ie_offset))
1597 return -EINVAL;
1598
1599 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1600 skb->data + ie_offset,
1601 skb->len - ie_offset);
1602 if (!ie)
1603 return -ENOENT;
1604
1605 len = ie[1] + 2;
1606 end = skb->data + skb->len;
1607 next = ie + len;
1608
1609 if (WARN_ON(next > end))
1610 return -EINVAL;
1611
1612 memmove(ie, next, end - next);
1613 skb_trim(skb, skb->len - len);
1614
1615 return 0;
1616 }
1617
ath10k_mac_setup_bcn_tmpl(struct ath10k_vif * arvif)1618 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1619 {
1620 struct ath10k *ar = arvif->ar;
1621 struct ieee80211_hw *hw = ar->hw;
1622 struct ieee80211_vif *vif = arvif->vif;
1623 struct ieee80211_mutable_offsets offs = {};
1624 struct sk_buff *bcn;
1625 int ret;
1626
1627 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1628 return 0;
1629
1630 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
1631 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
1632 return 0;
1633
1634 bcn = ieee80211_beacon_get_template(hw, vif, &offs, 0);
1635 if (!bcn) {
1636 ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1637 return -EPERM;
1638 }
1639
1640 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1641 if (ret) {
1642 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1643 kfree_skb(bcn);
1644 return ret;
1645 }
1646
1647 /* P2P IE is inserted by firmware automatically (as configured above)
1648 * so remove it from the base beacon template to avoid duplicate P2P
1649 * IEs in beacon frames.
1650 */
1651 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1652 offsetof(struct ieee80211_mgmt,
1653 u.beacon.variable));
1654
1655 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1656 0, NULL, 0);
1657 kfree_skb(bcn);
1658
1659 if (ret) {
1660 ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1661 ret);
1662 return ret;
1663 }
1664
1665 return 0;
1666 }
1667
ath10k_mac_setup_prb_tmpl(struct ath10k_vif * arvif)1668 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1669 {
1670 struct ath10k *ar = arvif->ar;
1671 struct ieee80211_hw *hw = ar->hw;
1672 struct ieee80211_vif *vif = arvif->vif;
1673 struct sk_buff *prb;
1674 int ret;
1675
1676 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1677 return 0;
1678
1679 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1680 return 0;
1681
1682 /* For mesh, probe response and beacon share the same template */
1683 if (ieee80211_vif_is_mesh(vif))
1684 return 0;
1685
1686 prb = ieee80211_proberesp_get(hw, vif);
1687 if (!prb) {
1688 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1689 return -EPERM;
1690 }
1691
1692 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1693 kfree_skb(prb);
1694
1695 if (ret) {
1696 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1697 ret);
1698 return ret;
1699 }
1700
1701 return 0;
1702 }
1703
ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif * arvif)1704 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)
1705 {
1706 struct ath10k *ar = arvif->ar;
1707 struct cfg80211_chan_def def;
1708 int ret;
1709
1710 /* When originally vdev is started during assign_vif_chanctx() some
1711 * information is missing, notably SSID. Firmware revisions with beacon
1712 * offloading require the SSID to be provided during vdev (re)start to
1713 * handle hidden SSID properly.
1714 *
1715 * Vdev restart must be done after vdev has been both started and
1716 * upped. Otherwise some firmware revisions (at least 10.2) fail to
1717 * deliver vdev restart response event causing timeouts during vdev
1718 * syncing in ath10k.
1719 *
1720 * Note: The vdev down/up and template reinstallation could be skipped
1721 * since only wmi-tlv firmware are known to have beacon offload and
1722 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1723 * response delivery. It's probably more robust to keep it as is.
1724 */
1725 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1726 return 0;
1727
1728 if (WARN_ON(!arvif->is_started))
1729 return -EINVAL;
1730
1731 if (WARN_ON(!arvif->is_up))
1732 return -EINVAL;
1733
1734 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
1735 return -EINVAL;
1736
1737 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1738 if (ret) {
1739 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",
1740 arvif->vdev_id, ret);
1741 return ret;
1742 }
1743
1744 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1745 * firmware will crash upon vdev up.
1746 */
1747
1748 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1749 if (ret) {
1750 ath10k_warn(ar, "failed to update beacon template: %d\n", ret);
1751 return ret;
1752 }
1753
1754 ret = ath10k_mac_setup_prb_tmpl(arvif);
1755 if (ret) {
1756 ath10k_warn(ar, "failed to update presp template: %d\n", ret);
1757 return ret;
1758 }
1759
1760 ret = ath10k_vdev_restart(arvif, &def);
1761 if (ret) {
1762 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",
1763 arvif->vdev_id, ret);
1764 return ret;
1765 }
1766
1767 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1768 arvif->bssid);
1769 if (ret) {
1770 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",
1771 arvif->vdev_id, ret);
1772 return ret;
1773 }
1774
1775 return 0;
1776 }
1777
ath10k_control_beaconing(struct ath10k_vif * arvif,struct ieee80211_bss_conf * info)1778 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1779 struct ieee80211_bss_conf *info)
1780 {
1781 struct ath10k *ar = arvif->ar;
1782 int ret = 0;
1783
1784 lockdep_assert_held(&arvif->ar->conf_mutex);
1785
1786 if (!info->enable_beacon) {
1787 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1788 if (ret)
1789 ath10k_warn(ar, "failed to down vdev_id %i: %d\n",
1790 arvif->vdev_id, ret);
1791
1792 arvif->is_up = false;
1793
1794 spin_lock_bh(&arvif->ar->data_lock);
1795 ath10k_mac_vif_beacon_free(arvif);
1796 spin_unlock_bh(&arvif->ar->data_lock);
1797
1798 return;
1799 }
1800
1801 arvif->tx_seq_no = 0x1000;
1802
1803 arvif->aid = 0;
1804 ether_addr_copy(arvif->bssid, info->bssid);
1805
1806 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1807 arvif->bssid);
1808 if (ret) {
1809 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1810 arvif->vdev_id, ret);
1811 return;
1812 }
1813
1814 arvif->is_up = true;
1815
1816 ret = ath10k_mac_vif_fix_hidden_ssid(arvif);
1817 if (ret) {
1818 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1819 arvif->vdev_id, ret);
1820 return;
1821 }
1822
1823 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1824 }
1825
ath10k_control_ibss(struct ath10k_vif * arvif,struct ieee80211_vif * vif)1826 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1827 struct ieee80211_vif *vif)
1828 {
1829 struct ath10k *ar = arvif->ar;
1830 u32 vdev_param;
1831 int ret = 0;
1832
1833 lockdep_assert_held(&arvif->ar->conf_mutex);
1834
1835 if (!vif->cfg.ibss_joined) {
1836 if (is_zero_ether_addr(arvif->bssid))
1837 return;
1838
1839 eth_zero_addr(arvif->bssid);
1840
1841 return;
1842 }
1843
1844 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1845 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1846 ATH10K_DEFAULT_ATIM);
1847 if (ret)
1848 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1849 arvif->vdev_id, ret);
1850 }
1851
ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif * arvif)1852 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1853 {
1854 struct ath10k *ar = arvif->ar;
1855 u32 param;
1856 u32 value;
1857 int ret;
1858
1859 lockdep_assert_held(&arvif->ar->conf_mutex);
1860
1861 if (arvif->u.sta.uapsd)
1862 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1863 else
1864 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1865
1866 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1867 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1868 if (ret) {
1869 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1870 value, arvif->vdev_id, ret);
1871 return ret;
1872 }
1873
1874 return 0;
1875 }
1876
ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif * arvif)1877 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1878 {
1879 struct ath10k *ar = arvif->ar;
1880 u32 param;
1881 u32 value;
1882 int ret;
1883
1884 lockdep_assert_held(&arvif->ar->conf_mutex);
1885
1886 if (arvif->u.sta.uapsd)
1887 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1888 else
1889 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1890
1891 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1892 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1893 param, value);
1894 if (ret) {
1895 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1896 value, arvif->vdev_id, ret);
1897 return ret;
1898 }
1899
1900 return 0;
1901 }
1902
ath10k_mac_num_vifs_started(struct ath10k * ar)1903 static int ath10k_mac_num_vifs_started(struct ath10k *ar)
1904 {
1905 struct ath10k_vif *arvif;
1906 int num = 0;
1907
1908 lockdep_assert_held(&ar->conf_mutex);
1909
1910 list_for_each_entry(arvif, &ar->arvifs, list)
1911 if (arvif->is_started)
1912 num++;
1913
1914 return num;
1915 }
1916
ath10k_mac_vif_setup_ps(struct ath10k_vif * arvif)1917 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1918 {
1919 struct ath10k *ar = arvif->ar;
1920 struct ieee80211_vif *vif = arvif->vif;
1921 struct ieee80211_conf *conf = &ar->hw->conf;
1922 enum wmi_sta_powersave_param param;
1923 enum wmi_sta_ps_mode psmode;
1924 int ret;
1925 int ps_timeout;
1926 bool enable_ps;
1927
1928 lockdep_assert_held(&arvif->ar->conf_mutex);
1929
1930 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1931 return 0;
1932
1933 enable_ps = arvif->ps;
1934
1935 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&
1936 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,
1937 ar->running_fw->fw_file.fw_features)) {
1938 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",
1939 arvif->vdev_id);
1940 enable_ps = false;
1941 }
1942
1943 if (!arvif->is_started) {
1944 /* mac80211 can update vif powersave state while disconnected.
1945 * Firmware doesn't behave nicely and consumes more power than
1946 * necessary if PS is disabled on a non-started vdev. Hence
1947 * force-enable PS for non-running vdevs.
1948 */
1949 psmode = WMI_STA_PS_MODE_ENABLED;
1950 } else if (enable_ps) {
1951 psmode = WMI_STA_PS_MODE_ENABLED;
1952 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1953
1954 ps_timeout = conf->dynamic_ps_timeout;
1955 if (ps_timeout == 0) {
1956 /* Firmware doesn't like 0 */
1957 ps_timeout = ieee80211_tu_to_usec(
1958 vif->bss_conf.beacon_int) / 1000;
1959 }
1960
1961 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1962 ps_timeout);
1963 if (ret) {
1964 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1965 arvif->vdev_id, ret);
1966 return ret;
1967 }
1968 } else {
1969 psmode = WMI_STA_PS_MODE_DISABLED;
1970 }
1971
1972 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1973 arvif->vdev_id, psmode ? "enable" : "disable");
1974
1975 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1976 if (ret) {
1977 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1978 psmode, arvif->vdev_id, ret);
1979 return ret;
1980 }
1981
1982 return 0;
1983 }
1984
ath10k_mac_vif_disable_keepalive(struct ath10k_vif * arvif)1985 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1986 {
1987 struct ath10k *ar = arvif->ar;
1988 struct wmi_sta_keepalive_arg arg = {};
1989 int ret;
1990
1991 lockdep_assert_held(&arvif->ar->conf_mutex);
1992
1993 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1994 return 0;
1995
1996 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1997 return 0;
1998
1999 /* Some firmware revisions have a bug and ignore the `enabled` field.
2000 * Instead use the interval to disable the keepalive.
2001 */
2002 arg.vdev_id = arvif->vdev_id;
2003 arg.enabled = 1;
2004 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
2005 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
2006
2007 ret = ath10k_wmi_sta_keepalive(ar, &arg);
2008 if (ret) {
2009 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
2010 arvif->vdev_id, ret);
2011 return ret;
2012 }
2013
2014 return 0;
2015 }
2016
ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif * arvif)2017 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)
2018 {
2019 struct ath10k *ar = arvif->ar;
2020 struct ieee80211_vif *vif = arvif->vif;
2021 int ret;
2022
2023 lockdep_assert_held(&arvif->ar->conf_mutex);
2024
2025 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))
2026 return;
2027
2028 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
2029 return;
2030
2031 if (!vif->bss_conf.csa_active)
2032 return;
2033
2034 if (!arvif->is_up)
2035 return;
2036
2037 if (!ieee80211_beacon_cntdwn_is_complete(vif)) {
2038 ieee80211_beacon_update_cntdwn(vif);
2039
2040 ret = ath10k_mac_setup_bcn_tmpl(arvif);
2041 if (ret)
2042 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
2043 ret);
2044
2045 ret = ath10k_mac_setup_prb_tmpl(arvif);
2046 if (ret)
2047 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
2048 ret);
2049 } else {
2050 ieee80211_csa_finish(vif);
2051 }
2052 }
2053
ath10k_mac_vif_ap_csa_work(struct work_struct * work)2054 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)
2055 {
2056 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
2057 ap_csa_work);
2058 struct ath10k *ar = arvif->ar;
2059
2060 mutex_lock(&ar->conf_mutex);
2061 ath10k_mac_vif_ap_csa_count_down(arvif);
2062 mutex_unlock(&ar->conf_mutex);
2063 }
2064
ath10k_mac_handle_beacon_iter(void * data,u8 * mac,struct ieee80211_vif * vif)2065 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,
2066 struct ieee80211_vif *vif)
2067 {
2068 struct sk_buff *skb = data;
2069 struct ieee80211_mgmt *mgmt = (void *)skb->data;
2070 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2071
2072 if (vif->type != NL80211_IFTYPE_STATION)
2073 return;
2074
2075 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
2076 return;
2077
2078 cancel_delayed_work(&arvif->connection_loss_work);
2079 }
2080
ath10k_mac_handle_beacon(struct ath10k * ar,struct sk_buff * skb)2081 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)
2082 {
2083 ieee80211_iterate_active_interfaces_atomic(ar->hw,
2084 ATH10K_ITER_NORMAL_FLAGS,
2085 ath10k_mac_handle_beacon_iter,
2086 skb);
2087 }
2088
ath10k_mac_handle_beacon_miss_iter(void * data,u8 * mac,struct ieee80211_vif * vif)2089 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
2090 struct ieee80211_vif *vif)
2091 {
2092 u32 *vdev_id = data;
2093 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2094 struct ath10k *ar = arvif->ar;
2095 struct ieee80211_hw *hw = ar->hw;
2096
2097 if (arvif->vdev_id != *vdev_id)
2098 return;
2099
2100 if (!arvif->is_up)
2101 return;
2102
2103 ieee80211_beacon_loss(vif);
2104
2105 /* Firmware doesn't report beacon loss events repeatedly. If AP probe
2106 * (done by mac80211) succeeds but beacons do not resume then it
2107 * doesn't make sense to continue operation. Queue connection loss work
2108 * which can be cancelled when beacon is received.
2109 */
2110 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
2111 ATH10K_CONNECTION_LOSS_HZ);
2112 }
2113
ath10k_mac_handle_beacon_miss(struct ath10k * ar,u32 vdev_id)2114 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)
2115 {
2116 ieee80211_iterate_active_interfaces_atomic(ar->hw,
2117 ATH10K_ITER_NORMAL_FLAGS,
2118 ath10k_mac_handle_beacon_miss_iter,
2119 &vdev_id);
2120 }
2121
ath10k_mac_vif_sta_connection_loss_work(struct work_struct * work)2122 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)
2123 {
2124 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
2125 connection_loss_work.work);
2126 struct ieee80211_vif *vif = arvif->vif;
2127
2128 if (!arvif->is_up)
2129 return;
2130
2131 ieee80211_connection_loss(vif);
2132 }
2133
2134 /**********************/
2135 /* Station management */
2136 /**********************/
2137
ath10k_peer_assoc_h_listen_intval(struct ath10k * ar,struct ieee80211_vif * vif)2138 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
2139 struct ieee80211_vif *vif)
2140 {
2141 /* Some firmware revisions have unstable STA powersave when listen
2142 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
2143 * generate NullFunc frames properly even if buffered frames have been
2144 * indicated in Beacon TIM. Firmware would seldom wake up to pull
2145 * buffered frames. Often pinging the device from AP would simply fail.
2146 *
2147 * As a workaround set it to 1.
2148 */
2149 if (vif->type == NL80211_IFTYPE_STATION)
2150 return 1;
2151
2152 return ar->hw->conf.listen_interval;
2153 }
2154
ath10k_peer_assoc_h_basic(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2155 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
2156 struct ieee80211_vif *vif,
2157 struct ieee80211_sta *sta,
2158 struct wmi_peer_assoc_complete_arg *arg)
2159 {
2160 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2161 u32 aid;
2162
2163 lockdep_assert_held(&ar->conf_mutex);
2164
2165 if (vif->type == NL80211_IFTYPE_STATION)
2166 aid = vif->cfg.aid;
2167 else
2168 aid = sta->aid;
2169
2170 ether_addr_copy(arg->addr, sta->addr);
2171 arg->vdev_id = arvif->vdev_id;
2172 arg->peer_aid = aid;
2173 arg->peer_flags |= arvif->ar->wmi.peer_flags->auth;
2174 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
2175 arg->peer_num_spatial_streams = 1;
2176 arg->peer_caps = vif->bss_conf.assoc_capability;
2177 }
2178
ath10k_peer_assoc_h_crypto(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2179 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
2180 struct ieee80211_vif *vif,
2181 struct ieee80211_sta *sta,
2182 struct wmi_peer_assoc_complete_arg *arg)
2183 {
2184 struct ieee80211_bss_conf *info = &vif->bss_conf;
2185 struct cfg80211_chan_def def;
2186 struct cfg80211_bss *bss;
2187 const u8 *rsnie = NULL;
2188 const u8 *wpaie = NULL;
2189
2190 lockdep_assert_held(&ar->conf_mutex);
2191
2192 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2193 return;
2194
2195 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid,
2196 vif->cfg.ssid_len ? vif->cfg.ssid : NULL,
2197 vif->cfg.ssid_len,
2198 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
2199 if (bss) {
2200 const struct cfg80211_bss_ies *ies;
2201
2202 rcu_read_lock();
2203 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
2204
2205 ies = rcu_dereference(bss->ies);
2206
2207 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
2208 WLAN_OUI_TYPE_MICROSOFT_WPA,
2209 ies->data,
2210 ies->len);
2211 rcu_read_unlock();
2212 cfg80211_put_bss(ar->hw->wiphy, bss);
2213 }
2214
2215 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
2216 if (rsnie || wpaie) {
2217 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
2218 arg->peer_flags |= ar->wmi.peer_flags->need_ptk_4_way;
2219 }
2220
2221 if (wpaie) {
2222 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
2223 arg->peer_flags |= ar->wmi.peer_flags->need_gtk_2_way;
2224 }
2225
2226 if (sta->mfp &&
2227 test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT,
2228 ar->running_fw->fw_file.fw_features)) {
2229 arg->peer_flags |= ar->wmi.peer_flags->pmf;
2230 }
2231 }
2232
ath10k_peer_assoc_h_rates(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2233 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
2234 struct ieee80211_vif *vif,
2235 struct ieee80211_sta *sta,
2236 struct wmi_peer_assoc_complete_arg *arg)
2237 {
2238 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2239 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
2240 struct cfg80211_chan_def def;
2241 const struct ieee80211_supported_band *sband;
2242 const struct ieee80211_rate *rates;
2243 enum nl80211_band band;
2244 u32 ratemask;
2245 u8 rate;
2246 int i;
2247
2248 lockdep_assert_held(&ar->conf_mutex);
2249
2250 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2251 return;
2252
2253 band = def.chan->band;
2254 sband = ar->hw->wiphy->bands[band];
2255 ratemask = sta->deflink.supp_rates[band];
2256 ratemask &= arvif->bitrate_mask.control[band].legacy;
2257 rates = sband->bitrates;
2258
2259 rateset->num_rates = 0;
2260
2261 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
2262 if (!(ratemask & 1))
2263 continue;
2264
2265 rate = ath10k_mac_bitrate_to_rate(rates->bitrate);
2266 rateset->rates[rateset->num_rates] = rate;
2267 rateset->num_rates++;
2268 }
2269 }
2270
2271 static bool
ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])2272 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
2273 {
2274 int nss;
2275
2276 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
2277 if (ht_mcs_mask[nss])
2278 return false;
2279
2280 return true;
2281 }
2282
2283 static bool
ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])2284 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
2285 {
2286 int nss;
2287
2288 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
2289 if (vht_mcs_mask[nss])
2290 return false;
2291
2292 return true;
2293 }
2294
ath10k_peer_assoc_h_ht(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2295 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
2296 struct ieee80211_vif *vif,
2297 struct ieee80211_sta *sta,
2298 struct wmi_peer_assoc_complete_arg *arg)
2299 {
2300 const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2301 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2302 struct cfg80211_chan_def def;
2303 enum nl80211_band band;
2304 const u8 *ht_mcs_mask;
2305 const u16 *vht_mcs_mask;
2306 int i, n;
2307 u8 max_nss;
2308 u32 stbc;
2309
2310 lockdep_assert_held(&ar->conf_mutex);
2311
2312 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2313 return;
2314
2315 if (!ht_cap->ht_supported)
2316 return;
2317
2318 band = def.chan->band;
2319 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2320 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2321
2322 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&
2323 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2324 return;
2325
2326 arg->peer_flags |= ar->wmi.peer_flags->ht;
2327 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2328 ht_cap->ampdu_factor)) - 1;
2329
2330 arg->peer_mpdu_density =
2331 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
2332
2333 arg->peer_ht_caps = ht_cap->cap;
2334 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
2335
2336 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
2337 arg->peer_flags |= ar->wmi.peer_flags->ldbc;
2338
2339 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {
2340 arg->peer_flags |= ar->wmi.peer_flags->bw40;
2341 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
2342 }
2343
2344 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
2345 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
2346 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2347
2348 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
2349 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2350 }
2351
2352 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
2353 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
2354 arg->peer_flags |= ar->wmi.peer_flags->stbc;
2355 }
2356
2357 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
2358 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
2359 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
2360 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
2361 arg->peer_rate_caps |= stbc;
2362 arg->peer_flags |= ar->wmi.peer_flags->stbc;
2363 }
2364
2365 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
2366 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
2367 else if (ht_cap->mcs.rx_mask[1])
2368 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
2369
2370 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
2371 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
2372 (ht_mcs_mask[i / 8] & BIT(i % 8))) {
2373 max_nss = (i / 8) + 1;
2374 arg->peer_ht_rates.rates[n++] = i;
2375 }
2376
2377 /*
2378 * This is a workaround for HT-enabled STAs which break the spec
2379 * and have no HT capabilities RX mask (no HT RX MCS map).
2380 *
2381 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2382 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2383 *
2384 * Firmware asserts if such situation occurs.
2385 */
2386 if (n == 0) {
2387 arg->peer_ht_rates.num_rates = 8;
2388 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
2389 arg->peer_ht_rates.rates[i] = i;
2390 } else {
2391 arg->peer_ht_rates.num_rates = n;
2392 arg->peer_num_spatial_streams = min(sta->deflink.rx_nss,
2393 max_nss);
2394 }
2395
2396 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
2397 arg->addr,
2398 arg->peer_ht_rates.num_rates,
2399 arg->peer_num_spatial_streams);
2400 }
2401
ath10k_peer_assoc_qos_ap(struct ath10k * ar,struct ath10k_vif * arvif,struct ieee80211_sta * sta)2402 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
2403 struct ath10k_vif *arvif,
2404 struct ieee80211_sta *sta)
2405 {
2406 u32 uapsd = 0;
2407 u32 max_sp = 0;
2408 int ret = 0;
2409
2410 lockdep_assert_held(&ar->conf_mutex);
2411
2412 if (sta->wme && sta->uapsd_queues) {
2413 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2414 sta->uapsd_queues, sta->max_sp);
2415
2416 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2417 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2418 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2419 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2420 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2421 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2422 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2423 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2424 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2425 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2426 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2427 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2428
2429 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2430 max_sp = sta->max_sp;
2431
2432 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2433 sta->addr,
2434 WMI_AP_PS_PEER_PARAM_UAPSD,
2435 uapsd);
2436 if (ret) {
2437 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2438 arvif->vdev_id, ret);
2439 return ret;
2440 }
2441
2442 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2443 sta->addr,
2444 WMI_AP_PS_PEER_PARAM_MAX_SP,
2445 max_sp);
2446 if (ret) {
2447 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2448 arvif->vdev_id, ret);
2449 return ret;
2450 }
2451
2452 /* TODO setup this based on STA listen interval and
2453 * beacon interval. Currently we don't know
2454 * sta->listen_interval - mac80211 patch required.
2455 * Currently use 10 seconds
2456 */
2457 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
2458 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
2459 10);
2460 if (ret) {
2461 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2462 arvif->vdev_id, ret);
2463 return ret;
2464 }
2465 }
2466
2467 return 0;
2468 }
2469
2470 static u16
ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])2471 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
2472 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
2473 {
2474 int idx_limit;
2475 int nss;
2476 u16 mcs_map;
2477 u16 mcs;
2478
2479 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
2480 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
2481 vht_mcs_limit[nss];
2482
2483 if (mcs_map)
2484 idx_limit = fls(mcs_map) - 1;
2485 else
2486 idx_limit = -1;
2487
2488 switch (idx_limit) {
2489 case 0:
2490 case 1:
2491 case 2:
2492 case 3:
2493 case 4:
2494 case 5:
2495 case 6:
2496 default:
2497 /* see ath10k_mac_can_set_bitrate_mask() */
2498 WARN_ON(1);
2499 fallthrough;
2500 case -1:
2501 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2502 break;
2503 case 7:
2504 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2505 break;
2506 case 8:
2507 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2508 break;
2509 case 9:
2510 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2511 break;
2512 }
2513
2514 tx_mcs_set &= ~(0x3 << (nss * 2));
2515 tx_mcs_set |= mcs << (nss * 2);
2516 }
2517
2518 return tx_mcs_set;
2519 }
2520
get_160mhz_nss_from_maxrate(int rate)2521 static u32 get_160mhz_nss_from_maxrate(int rate)
2522 {
2523 u32 nss;
2524
2525 switch (rate) {
2526 case 780:
2527 nss = 1;
2528 break;
2529 case 1560:
2530 nss = 2;
2531 break;
2532 case 2106:
2533 nss = 3; /* not support MCS9 from spec*/
2534 break;
2535 case 3120:
2536 nss = 4;
2537 break;
2538 default:
2539 nss = 1;
2540 }
2541
2542 return nss;
2543 }
2544
ath10k_peer_assoc_h_vht(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2545 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
2546 struct ieee80211_vif *vif,
2547 struct ieee80211_sta *sta,
2548 struct wmi_peer_assoc_complete_arg *arg)
2549 {
2550 const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
2551 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2552 struct ath10k_hw_params *hw = &ar->hw_params;
2553 struct cfg80211_chan_def def;
2554 enum nl80211_band band;
2555 const u16 *vht_mcs_mask;
2556 u8 ampdu_factor;
2557 u8 max_nss, vht_mcs;
2558 int i;
2559
2560 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2561 return;
2562
2563 if (!vht_cap->vht_supported)
2564 return;
2565
2566 band = def.chan->band;
2567 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2568
2569 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2570 return;
2571
2572 arg->peer_flags |= ar->wmi.peer_flags->vht;
2573
2574 if (def.chan->band == NL80211_BAND_2GHZ)
2575 arg->peer_flags |= ar->wmi.peer_flags->vht_2g;
2576
2577 arg->peer_vht_caps = vht_cap->cap;
2578
2579 ampdu_factor = (vht_cap->cap &
2580 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2581 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2582
2583 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2584 * zero in VHT IE. Using it would result in degraded throughput.
2585 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2586 * it if VHT max_mpdu is smaller.
2587 */
2588 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2589 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2590 ampdu_factor)) - 1);
2591
2592 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2593 arg->peer_flags |= ar->wmi.peer_flags->bw80;
2594
2595 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2596 arg->peer_flags |= ar->wmi.peer_flags->bw160;
2597
2598 /* Calculate peer NSS capability from VHT capabilities if STA
2599 * supports VHT.
2600 */
2601 for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) {
2602 vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
2603 (2 * i) & 3;
2604
2605 if ((vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) &&
2606 vht_mcs_mask[i])
2607 max_nss = i + 1;
2608 }
2609 arg->peer_num_spatial_streams = min(sta->deflink.rx_nss, max_nss);
2610 arg->peer_vht_rates.rx_max_rate =
2611 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2612 arg->peer_vht_rates.rx_mcs_set =
2613 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2614 arg->peer_vht_rates.tx_max_rate =
2615 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2616 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(
2617 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2618
2619 /* Configure bandwidth-NSS mapping to FW
2620 * for the chip's tx chains setting on 160Mhz bw
2621 */
2622 if (arg->peer_phymode == MODE_11AC_VHT160 ||
2623 arg->peer_phymode == MODE_11AC_VHT80_80) {
2624 u32 rx_nss;
2625 u32 max_rate;
2626
2627 max_rate = arg->peer_vht_rates.rx_max_rate;
2628 rx_nss = get_160mhz_nss_from_maxrate(max_rate);
2629
2630 if (rx_nss == 0)
2631 rx_nss = arg->peer_num_spatial_streams;
2632 else
2633 rx_nss = min(arg->peer_num_spatial_streams, rx_nss);
2634
2635 max_rate = hw->vht160_mcs_tx_highest;
2636 rx_nss = min(rx_nss, get_160mhz_nss_from_maxrate(max_rate));
2637
2638 arg->peer_bw_rxnss_override =
2639 FIELD_PREP(WMI_PEER_NSS_MAP_ENABLE, 1) |
2640 FIELD_PREP(WMI_PEER_NSS_160MHZ_MASK, (rx_nss - 1));
2641
2642 if (arg->peer_phymode == MODE_11AC_VHT80_80) {
2643 arg->peer_bw_rxnss_override |=
2644 FIELD_PREP(WMI_PEER_NSS_80_80MHZ_MASK, (rx_nss - 1));
2645 }
2646 }
2647 ath10k_dbg(ar, ATH10K_DBG_MAC,
2648 "mac vht peer %pM max_mpdu %d flags 0x%x peer_rx_nss_override 0x%x\n",
2649 sta->addr, arg->peer_max_mpdu,
2650 arg->peer_flags, arg->peer_bw_rxnss_override);
2651 }
2652
ath10k_peer_assoc_h_qos(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2653 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
2654 struct ieee80211_vif *vif,
2655 struct ieee80211_sta *sta,
2656 struct wmi_peer_assoc_complete_arg *arg)
2657 {
2658 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2659
2660 switch (arvif->vdev_type) {
2661 case WMI_VDEV_TYPE_AP:
2662 if (sta->wme)
2663 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2664
2665 if (sta->wme && sta->uapsd_queues) {
2666 arg->peer_flags |= arvif->ar->wmi.peer_flags->apsd;
2667 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
2668 }
2669 break;
2670 case WMI_VDEV_TYPE_STA:
2671 if (sta->wme)
2672 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2673 break;
2674 case WMI_VDEV_TYPE_IBSS:
2675 if (sta->wme)
2676 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2677 break;
2678 default:
2679 break;
2680 }
2681
2682 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
2683 sta->addr, !!(arg->peer_flags &
2684 arvif->ar->wmi.peer_flags->qos));
2685 }
2686
ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta * sta)2687 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2688 {
2689 return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2690 ATH10K_MAC_FIRST_OFDM_RATE_IDX;
2691 }
2692
ath10k_mac_get_phymode_vht(struct ath10k * ar,struct ieee80211_sta * sta)2693 static enum wmi_phy_mode ath10k_mac_get_phymode_vht(struct ath10k *ar,
2694 struct ieee80211_sta *sta)
2695 {
2696 struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
2697
2698 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2699 switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2700 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2701 return MODE_11AC_VHT160;
2702 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2703 return MODE_11AC_VHT80_80;
2704 default:
2705 /* not sure if this is a valid case? */
2706 return MODE_11AC_VHT160;
2707 }
2708 }
2709
2710 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2711 return MODE_11AC_VHT80;
2712
2713 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2714 return MODE_11AC_VHT40;
2715
2716 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2717 return MODE_11AC_VHT20;
2718
2719 return MODE_UNKNOWN;
2720 }
2721
ath10k_peer_assoc_h_phymode(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2722 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
2723 struct ieee80211_vif *vif,
2724 struct ieee80211_sta *sta,
2725 struct wmi_peer_assoc_complete_arg *arg)
2726 {
2727 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2728 struct cfg80211_chan_def def;
2729 enum nl80211_band band;
2730 const u8 *ht_mcs_mask;
2731 const u16 *vht_mcs_mask;
2732 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2733
2734 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2735 return;
2736
2737 band = def.chan->band;
2738 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2739 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2740
2741 switch (band) {
2742 case NL80211_BAND_2GHZ:
2743 if (sta->deflink.vht_cap.vht_supported &&
2744 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2745 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2746 phymode = MODE_11AC_VHT40;
2747 else
2748 phymode = MODE_11AC_VHT20;
2749 } else if (sta->deflink.ht_cap.ht_supported &&
2750 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2751 if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2752 phymode = MODE_11NG_HT40;
2753 else
2754 phymode = MODE_11NG_HT20;
2755 } else if (ath10k_mac_sta_has_ofdm_only(sta)) {
2756 phymode = MODE_11G;
2757 } else {
2758 phymode = MODE_11B;
2759 }
2760
2761 break;
2762 case NL80211_BAND_5GHZ:
2763 /*
2764 * Check VHT first.
2765 */
2766 if (sta->deflink.vht_cap.vht_supported &&
2767 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2768 phymode = ath10k_mac_get_phymode_vht(ar, sta);
2769 } else if (sta->deflink.ht_cap.ht_supported &&
2770 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2771 if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2772 phymode = MODE_11NA_HT40;
2773 else
2774 phymode = MODE_11NA_HT20;
2775 } else {
2776 phymode = MODE_11A;
2777 }
2778
2779 break;
2780 default:
2781 break;
2782 }
2783
2784 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
2785 sta->addr, ath10k_wmi_phymode_str(phymode));
2786
2787 arg->peer_phymode = phymode;
2788 WARN_ON(phymode == MODE_UNKNOWN);
2789 }
2790
ath10k_peer_assoc_prepare(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2791 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
2792 struct ieee80211_vif *vif,
2793 struct ieee80211_sta *sta,
2794 struct wmi_peer_assoc_complete_arg *arg)
2795 {
2796 lockdep_assert_held(&ar->conf_mutex);
2797
2798 memset(arg, 0, sizeof(*arg));
2799
2800 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
2801 ath10k_peer_assoc_h_crypto(ar, vif, sta, arg);
2802 ath10k_peer_assoc_h_rates(ar, vif, sta, arg);
2803 ath10k_peer_assoc_h_ht(ar, vif, sta, arg);
2804 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
2805 ath10k_peer_assoc_h_vht(ar, vif, sta, arg);
2806 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
2807
2808 return 0;
2809 }
2810
2811 static const u32 ath10k_smps_map[] = {
2812 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
2813 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
2814 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
2815 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
2816 };
2817
ath10k_setup_peer_smps(struct ath10k * ar,struct ath10k_vif * arvif,const u8 * addr,const struct ieee80211_sta_ht_cap * ht_cap)2818 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
2819 const u8 *addr,
2820 const struct ieee80211_sta_ht_cap *ht_cap)
2821 {
2822 int smps;
2823
2824 if (!ht_cap->ht_supported)
2825 return 0;
2826
2827 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2828 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2829
2830 if (smps >= ARRAY_SIZE(ath10k_smps_map))
2831 return -EINVAL;
2832
2833 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
2834 ar->wmi.peer_param->smps_state,
2835 ath10k_smps_map[smps]);
2836 }
2837
ath10k_mac_vif_recalc_txbf(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta_vht_cap vht_cap)2838 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,
2839 struct ieee80211_vif *vif,
2840 struct ieee80211_sta_vht_cap vht_cap)
2841 {
2842 struct ath10k_vif *arvif = (void *)vif->drv_priv;
2843 int ret;
2844 u32 param;
2845 u32 value;
2846
2847 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC)
2848 return 0;
2849
2850 if (!(ar->vht_cap_info &
2851 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2852 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
2853 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2854 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))
2855 return 0;
2856
2857 param = ar->wmi.vdev_param->txbf;
2858 value = 0;
2859
2860 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))
2861 return 0;
2862
2863 /* The following logic is correct. If a remote STA advertises support
2864 * for being a beamformer then we should enable us being a beamformee.
2865 */
2866
2867 if (ar->vht_cap_info &
2868 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2869 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
2870 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
2871 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2872
2873 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
2874 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
2875 }
2876
2877 if (ar->vht_cap_info &
2878 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2879 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
2880 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
2881 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2882
2883 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
2884 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
2885 }
2886
2887 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)
2888 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2889
2890 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)
2891 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2892
2893 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);
2894 if (ret) {
2895 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",
2896 value, ret);
2897 return ret;
2898 }
2899
2900 return 0;
2901 }
2902
ath10k_mac_is_connected(struct ath10k * ar)2903 static bool ath10k_mac_is_connected(struct ath10k *ar)
2904 {
2905 struct ath10k_vif *arvif;
2906
2907 list_for_each_entry(arvif, &ar->arvifs, list) {
2908 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)
2909 return true;
2910 }
2911
2912 return false;
2913 }
2914
ath10k_mac_txpower_setup(struct ath10k * ar,int txpower)2915 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
2916 {
2917 int ret;
2918 u32 param;
2919 int tx_power_2g, tx_power_5g;
2920 bool connected;
2921
2922 lockdep_assert_held(&ar->conf_mutex);
2923
2924 /* ath10k internally uses unit of 0.5 dBm so multiply by 2 */
2925 tx_power_2g = txpower * 2;
2926 tx_power_5g = txpower * 2;
2927
2928 connected = ath10k_mac_is_connected(ar);
2929
2930 if (connected && ar->tx_power_2g_limit)
2931 if (tx_power_2g > ar->tx_power_2g_limit)
2932 tx_power_2g = ar->tx_power_2g_limit;
2933
2934 if (connected && ar->tx_power_5g_limit)
2935 if (tx_power_5g > ar->tx_power_5g_limit)
2936 tx_power_5g = ar->tx_power_5g_limit;
2937
2938 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower 2g: %d, 5g: %d\n",
2939 tx_power_2g, tx_power_5g);
2940
2941 param = ar->wmi.pdev_param->txpower_limit2g;
2942 ret = ath10k_wmi_pdev_set_param(ar, param, tx_power_2g);
2943 if (ret) {
2944 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2945 tx_power_2g, ret);
2946 return ret;
2947 }
2948
2949 param = ar->wmi.pdev_param->txpower_limit5g;
2950 ret = ath10k_wmi_pdev_set_param(ar, param, tx_power_5g);
2951 if (ret) {
2952 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2953 tx_power_5g, ret);
2954 return ret;
2955 }
2956
2957 return 0;
2958 }
2959
ath10k_mac_txpower_recalc(struct ath10k * ar)2960 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
2961 {
2962 struct ath10k_vif *arvif;
2963 int ret, txpower = -1;
2964
2965 lockdep_assert_held(&ar->conf_mutex);
2966
2967 list_for_each_entry(arvif, &ar->arvifs, list) {
2968 /* txpower not initialized yet? */
2969 if (arvif->txpower == INT_MIN)
2970 continue;
2971
2972 if (txpower == -1)
2973 txpower = arvif->txpower;
2974 else
2975 txpower = min(txpower, arvif->txpower);
2976 }
2977
2978 if (txpower == -1)
2979 return 0;
2980
2981 ret = ath10k_mac_txpower_setup(ar, txpower);
2982 if (ret) {
2983 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
2984 txpower, ret);
2985 return ret;
2986 }
2987
2988 return 0;
2989 }
2990
ath10k_mac_set_sar_power(struct ath10k * ar)2991 static int ath10k_mac_set_sar_power(struct ath10k *ar)
2992 {
2993 if (!ar->hw_params.dynamic_sar_support)
2994 return -EOPNOTSUPP;
2995
2996 if (!ath10k_mac_is_connected(ar))
2997 return 0;
2998
2999 /* if connected, then arvif->txpower must be valid */
3000 return ath10k_mac_txpower_recalc(ar);
3001 }
3002
ath10k_mac_set_sar_specs(struct ieee80211_hw * hw,const struct cfg80211_sar_specs * sar)3003 static int ath10k_mac_set_sar_specs(struct ieee80211_hw *hw,
3004 const struct cfg80211_sar_specs *sar)
3005 {
3006 const struct cfg80211_sar_sub_specs *sub_specs;
3007 struct ath10k *ar = hw->priv;
3008 u32 i;
3009 int ret;
3010
3011 mutex_lock(&ar->conf_mutex);
3012
3013 if (!ar->hw_params.dynamic_sar_support) {
3014 ret = -EOPNOTSUPP;
3015 goto err;
3016 }
3017
3018 if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
3019 sar->num_sub_specs == 0) {
3020 ret = -EINVAL;
3021 goto err;
3022 }
3023
3024 sub_specs = sar->sub_specs;
3025
3026 /* 0dbm is not a practical value for ath10k, so use 0
3027 * as no SAR limitation on it.
3028 */
3029 ar->tx_power_2g_limit = 0;
3030 ar->tx_power_5g_limit = 0;
3031
3032 /* note the power is in 0.25dbm unit, while ath10k uses
3033 * 0.5dbm unit.
3034 */
3035 for (i = 0; i < sar->num_sub_specs; i++) {
3036 if (sub_specs->freq_range_index == 0)
3037 ar->tx_power_2g_limit = sub_specs->power / 2;
3038 else if (sub_specs->freq_range_index == 1)
3039 ar->tx_power_5g_limit = sub_specs->power / 2;
3040
3041 sub_specs++;
3042 }
3043
3044 ret = ath10k_mac_set_sar_power(ar);
3045 if (ret) {
3046 ath10k_warn(ar, "failed to set sar power: %d", ret);
3047 goto err;
3048 }
3049
3050 err:
3051 mutex_unlock(&ar->conf_mutex);
3052 return ret;
3053 }
3054
3055 /* can be called only in mac80211 callbacks due to `key_count` usage */
ath10k_bss_assoc(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * bss_conf)3056 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
3057 struct ieee80211_vif *vif,
3058 struct ieee80211_bss_conf *bss_conf)
3059 {
3060 struct ath10k *ar = hw->priv;
3061 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3062 struct ieee80211_sta_ht_cap ht_cap;
3063 struct ieee80211_sta_vht_cap vht_cap;
3064 struct wmi_peer_assoc_complete_arg peer_arg;
3065 struct ieee80211_sta *ap_sta;
3066 int ret;
3067
3068 lockdep_assert_held(&ar->conf_mutex);
3069
3070 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
3071 arvif->vdev_id, arvif->bssid, arvif->aid);
3072
3073 rcu_read_lock();
3074
3075 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
3076 if (!ap_sta) {
3077 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
3078 bss_conf->bssid, arvif->vdev_id);
3079 rcu_read_unlock();
3080 return;
3081 }
3082
3083 /* ap_sta must be accessed only within rcu section which must be left
3084 * before calling ath10k_setup_peer_smps() which might sleep.
3085 */
3086 ht_cap = ap_sta->deflink.ht_cap;
3087 vht_cap = ap_sta->deflink.vht_cap;
3088
3089 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
3090 if (ret) {
3091 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
3092 bss_conf->bssid, arvif->vdev_id, ret);
3093 rcu_read_unlock();
3094 return;
3095 }
3096
3097 rcu_read_unlock();
3098
3099 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
3100 if (ret) {
3101 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
3102 bss_conf->bssid, arvif->vdev_id, ret);
3103 return;
3104 }
3105
3106 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
3107 if (ret) {
3108 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
3109 arvif->vdev_id, ret);
3110 return;
3111 }
3112
3113 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
3114 if (ret) {
3115 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
3116 arvif->vdev_id, bss_conf->bssid, ret);
3117 return;
3118 }
3119
3120 ath10k_dbg(ar, ATH10K_DBG_MAC,
3121 "mac vdev %d up (associated) bssid %pM aid %d\n",
3122 arvif->vdev_id, bss_conf->bssid, vif->cfg.aid);
3123
3124 WARN_ON(arvif->is_up);
3125
3126 arvif->aid = vif->cfg.aid;
3127 ether_addr_copy(arvif->bssid, bss_conf->bssid);
3128
3129 ret = ath10k_wmi_pdev_set_param(ar,
3130 ar->wmi.pdev_param->peer_stats_info_enable, 1);
3131 if (ret)
3132 ath10k_warn(ar, "failed to enable peer stats info: %d\n", ret);
3133
3134 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
3135 if (ret) {
3136 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
3137 arvif->vdev_id, ret);
3138 return;
3139 }
3140
3141 arvif->is_up = true;
3142
3143 ath10k_mac_set_sar_power(ar);
3144
3145 /* Workaround: Some firmware revisions (tested with qca6174
3146 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
3147 * poked with peer param command.
3148 */
3149 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
3150 ar->wmi.peer_param->dummy_var, 1);
3151 if (ret) {
3152 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
3153 arvif->bssid, arvif->vdev_id, ret);
3154 return;
3155 }
3156 }
3157
ath10k_bss_disassoc(struct ieee80211_hw * hw,struct ieee80211_vif * vif)3158 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
3159 struct ieee80211_vif *vif)
3160 {
3161 struct ath10k *ar = hw->priv;
3162 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3163 struct ieee80211_sta_vht_cap vht_cap = {};
3164 int ret;
3165
3166 lockdep_assert_held(&ar->conf_mutex);
3167
3168 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
3169 arvif->vdev_id, arvif->bssid);
3170
3171 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
3172 if (ret)
3173 ath10k_warn(ar, "failed to down vdev %i: %d\n",
3174 arvif->vdev_id, ret);
3175
3176 arvif->def_wep_key_idx = -1;
3177
3178 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
3179 if (ret) {
3180 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",
3181 arvif->vdev_id, ret);
3182 return;
3183 }
3184
3185 arvif->is_up = false;
3186
3187 ath10k_mac_txpower_recalc(ar);
3188
3189 cancel_delayed_work_sync(&arvif->connection_loss_work);
3190 }
3191
ath10k_new_peer_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ath10k_vif * arvif)3192 static int ath10k_new_peer_tid_config(struct ath10k *ar,
3193 struct ieee80211_sta *sta,
3194 struct ath10k_vif *arvif)
3195 {
3196 struct wmi_per_peer_per_tid_cfg_arg arg = {};
3197 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3198 bool config_apply;
3199 int ret, i;
3200
3201 for (i = 0; i < ATH10K_TID_MAX; i++) {
3202 config_apply = false;
3203 if (arvif->retry_long[i] || arvif->ampdu[i] ||
3204 arvif->rate_ctrl[i] || arvif->rtscts[i]) {
3205 config_apply = true;
3206 arg.tid = i;
3207 arg.vdev_id = arvif->vdev_id;
3208 arg.retry_count = arvif->retry_long[i];
3209 arg.aggr_control = arvif->ampdu[i];
3210 arg.rate_ctrl = arvif->rate_ctrl[i];
3211 arg.rcode_flags = arvif->rate_code[i];
3212
3213 if (arvif->rtscts[i])
3214 arg.ext_tid_cfg_bitmap =
3215 WMI_EXT_TID_RTS_CTS_CONFIG;
3216 else
3217 arg.ext_tid_cfg_bitmap = 0;
3218
3219 arg.rtscts_ctrl = arvif->rtscts[i];
3220 }
3221
3222 if (arvif->noack[i]) {
3223 arg.ack_policy = arvif->noack[i];
3224 arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE;
3225 arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;
3226 config_apply = true;
3227 }
3228
3229 /* Assign default value(-1) to newly connected station.
3230 * This is to identify station specific tid configuration not
3231 * configured for the station.
3232 */
3233 arsta->retry_long[i] = -1;
3234 arsta->noack[i] = -1;
3235 arsta->ampdu[i] = -1;
3236
3237 if (!config_apply)
3238 continue;
3239
3240 ether_addr_copy(arg.peer_macaddr.addr, sta->addr);
3241
3242 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);
3243 if (ret) {
3244 ath10k_warn(ar, "failed to set per tid retry/aggr config for sta %pM: %d\n",
3245 sta->addr, ret);
3246 return ret;
3247 }
3248
3249 memset(&arg, 0, sizeof(arg));
3250 }
3251
3252 return 0;
3253 }
3254
ath10k_station_assoc(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,bool reassoc)3255 static int ath10k_station_assoc(struct ath10k *ar,
3256 struct ieee80211_vif *vif,
3257 struct ieee80211_sta *sta,
3258 bool reassoc)
3259 {
3260 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3261 struct wmi_peer_assoc_complete_arg peer_arg;
3262 int ret = 0;
3263
3264 lockdep_assert_held(&ar->conf_mutex);
3265
3266 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
3267 if (ret) {
3268 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
3269 sta->addr, arvif->vdev_id, ret);
3270 return ret;
3271 }
3272
3273 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
3274 if (ret) {
3275 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
3276 sta->addr, arvif->vdev_id, ret);
3277 return ret;
3278 }
3279
3280 /* Re-assoc is run only to update supported rates for given station. It
3281 * doesn't make much sense to reconfigure the peer completely.
3282 */
3283 if (!reassoc) {
3284 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
3285 &sta->deflink.ht_cap);
3286 if (ret) {
3287 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
3288 arvif->vdev_id, ret);
3289 return ret;
3290 }
3291
3292 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
3293 if (ret) {
3294 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
3295 sta->addr, arvif->vdev_id, ret);
3296 return ret;
3297 }
3298
3299 if (!sta->wme) {
3300 arvif->num_legacy_stations++;
3301 ret = ath10k_recalc_rtscts_prot(arvif);
3302 if (ret) {
3303 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3304 arvif->vdev_id, ret);
3305 return ret;
3306 }
3307 }
3308
3309 /* Plumb cached keys only for static WEP */
3310 if ((arvif->def_wep_key_idx != -1) && (!sta->tdls)) {
3311 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
3312 if (ret) {
3313 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
3314 arvif->vdev_id, ret);
3315 return ret;
3316 }
3317 }
3318 }
3319
3320 if (!test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map))
3321 return ret;
3322
3323 return ath10k_new_peer_tid_config(ar, sta, arvif);
3324 }
3325
ath10k_station_disassoc(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta)3326 static int ath10k_station_disassoc(struct ath10k *ar,
3327 struct ieee80211_vif *vif,
3328 struct ieee80211_sta *sta)
3329 {
3330 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3331 int ret = 0;
3332
3333 lockdep_assert_held(&ar->conf_mutex);
3334
3335 if (!sta->wme) {
3336 arvif->num_legacy_stations--;
3337 ret = ath10k_recalc_rtscts_prot(arvif);
3338 if (ret) {
3339 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3340 arvif->vdev_id, ret);
3341 return ret;
3342 }
3343 }
3344
3345 ret = ath10k_clear_peer_keys(arvif, sta->addr);
3346 if (ret) {
3347 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
3348 arvif->vdev_id, ret);
3349 return ret;
3350 }
3351
3352 return ret;
3353 }
3354
3355 /**************/
3356 /* Regulatory */
3357 /**************/
3358
ath10k_update_channel_list(struct ath10k * ar)3359 static int ath10k_update_channel_list(struct ath10k *ar)
3360 {
3361 struct ieee80211_hw *hw = ar->hw;
3362 struct ieee80211_supported_band **bands;
3363 enum nl80211_band band;
3364 struct ieee80211_channel *channel;
3365 struct wmi_scan_chan_list_arg arg = {0};
3366 struct wmi_channel_arg *ch;
3367 bool passive;
3368 int len;
3369 int ret;
3370 int i;
3371
3372 lockdep_assert_held(&ar->conf_mutex);
3373
3374 bands = hw->wiphy->bands;
3375 for (band = 0; band < NUM_NL80211_BANDS; band++) {
3376 if (!bands[band])
3377 continue;
3378
3379 for (i = 0; i < bands[band]->n_channels; i++) {
3380 if (bands[band]->channels[i].flags &
3381 IEEE80211_CHAN_DISABLED)
3382 continue;
3383
3384 arg.n_channels++;
3385 }
3386 }
3387
3388 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
3389 arg.channels = kzalloc(len, GFP_KERNEL);
3390 if (!arg.channels)
3391 return -ENOMEM;
3392
3393 ch = arg.channels;
3394 for (band = 0; band < NUM_NL80211_BANDS; band++) {
3395 if (!bands[band])
3396 continue;
3397
3398 for (i = 0; i < bands[band]->n_channels; i++) {
3399 channel = &bands[band]->channels[i];
3400
3401 if (channel->flags & IEEE80211_CHAN_DISABLED)
3402 continue;
3403
3404 ch->allow_ht = true;
3405
3406 /* FIXME: when should we really allow VHT? */
3407 ch->allow_vht = true;
3408
3409 ch->allow_ibss =
3410 !(channel->flags & IEEE80211_CHAN_NO_IR);
3411
3412 ch->ht40plus =
3413 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
3414
3415 ch->chan_radar =
3416 !!(channel->flags & IEEE80211_CHAN_RADAR);
3417
3418 passive = channel->flags & IEEE80211_CHAN_NO_IR;
3419 ch->passive = passive;
3420
3421 /* the firmware is ignoring the "radar" flag of the
3422 * channel and is scanning actively using Probe Requests
3423 * on "Radar detection"/DFS channels which are not
3424 * marked as "available"
3425 */
3426 ch->passive |= ch->chan_radar;
3427
3428 ch->freq = channel->center_freq;
3429 ch->band_center_freq1 = channel->center_freq;
3430 ch->min_power = 0;
3431 ch->max_power = channel->max_power * 2;
3432 ch->max_reg_power = channel->max_reg_power * 2;
3433 ch->max_antenna_gain = channel->max_antenna_gain;
3434 ch->reg_class_id = 0; /* FIXME */
3435
3436 /* FIXME: why use only legacy modes, why not any
3437 * HT/VHT modes? Would that even make any
3438 * difference?
3439 */
3440 if (channel->band == NL80211_BAND_2GHZ)
3441 ch->mode = MODE_11G;
3442 else
3443 ch->mode = MODE_11A;
3444
3445 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
3446 continue;
3447
3448 ath10k_dbg(ar, ATH10K_DBG_WMI,
3449 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
3450 ch - arg.channels, arg.n_channels,
3451 ch->freq, ch->max_power, ch->max_reg_power,
3452 ch->max_antenna_gain, ch->mode);
3453
3454 ch++;
3455 }
3456 }
3457
3458 ret = ath10k_wmi_scan_chan_list(ar, &arg);
3459 kfree(arg.channels);
3460
3461 return ret;
3462 }
3463
3464 static enum wmi_dfs_region
ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)3465 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
3466 {
3467 switch (dfs_region) {
3468 case NL80211_DFS_UNSET:
3469 return WMI_UNINIT_DFS_DOMAIN;
3470 case NL80211_DFS_FCC:
3471 return WMI_FCC_DFS_DOMAIN;
3472 case NL80211_DFS_ETSI:
3473 return WMI_ETSI_DFS_DOMAIN;
3474 case NL80211_DFS_JP:
3475 return WMI_MKK4_DFS_DOMAIN;
3476 }
3477 return WMI_UNINIT_DFS_DOMAIN;
3478 }
3479
ath10k_regd_update(struct ath10k * ar)3480 static void ath10k_regd_update(struct ath10k *ar)
3481 {
3482 struct reg_dmn_pair_mapping *regpair;
3483 int ret;
3484 enum wmi_dfs_region wmi_dfs_reg;
3485 enum nl80211_dfs_regions nl_dfs_reg;
3486
3487 lockdep_assert_held(&ar->conf_mutex);
3488
3489 ret = ath10k_update_channel_list(ar);
3490 if (ret)
3491 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
3492
3493 regpair = ar->ath_common.regulatory.regpair;
3494
3495 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
3496 nl_dfs_reg = ar->dfs_detector->region;
3497 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
3498 } else {
3499 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
3500 }
3501
3502 /* Target allows setting up per-band regdomain but ath_common provides
3503 * a combined one only
3504 */
3505 ret = ath10k_wmi_pdev_set_regdomain(ar,
3506 regpair->reg_domain,
3507 regpair->reg_domain, /* 2ghz */
3508 regpair->reg_domain, /* 5ghz */
3509 regpair->reg_2ghz_ctl,
3510 regpair->reg_5ghz_ctl,
3511 wmi_dfs_reg);
3512 if (ret)
3513 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
3514 }
3515
ath10k_mac_update_channel_list(struct ath10k * ar,struct ieee80211_supported_band * band)3516 static void ath10k_mac_update_channel_list(struct ath10k *ar,
3517 struct ieee80211_supported_band *band)
3518 {
3519 int i;
3520
3521 if (ar->low_5ghz_chan && ar->high_5ghz_chan) {
3522 for (i = 0; i < band->n_channels; i++) {
3523 if (band->channels[i].center_freq < ar->low_5ghz_chan ||
3524 band->channels[i].center_freq > ar->high_5ghz_chan)
3525 band->channels[i].flags |=
3526 IEEE80211_CHAN_DISABLED;
3527 }
3528 }
3529 }
3530
ath10k_reg_notifier(struct wiphy * wiphy,struct regulatory_request * request)3531 static void ath10k_reg_notifier(struct wiphy *wiphy,
3532 struct regulatory_request *request)
3533 {
3534 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
3535 struct ath10k *ar = hw->priv;
3536 bool result;
3537
3538 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
3539
3540 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
3541 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
3542 request->dfs_region);
3543 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
3544 request->dfs_region);
3545 if (!result)
3546 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
3547 request->dfs_region);
3548 }
3549
3550 mutex_lock(&ar->conf_mutex);
3551 if (ar->state == ATH10K_STATE_ON)
3552 ath10k_regd_update(ar);
3553 mutex_unlock(&ar->conf_mutex);
3554
3555 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)
3556 ath10k_mac_update_channel_list(ar,
3557 ar->hw->wiphy->bands[NL80211_BAND_5GHZ]);
3558 }
3559
ath10k_stop_radar_confirmation(struct ath10k * ar)3560 static void ath10k_stop_radar_confirmation(struct ath10k *ar)
3561 {
3562 spin_lock_bh(&ar->data_lock);
3563 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_STOPPED;
3564 spin_unlock_bh(&ar->data_lock);
3565
3566 cancel_work_sync(&ar->radar_confirmation_work);
3567 }
3568
3569 /***************/
3570 /* TX handlers */
3571 /***************/
3572
3573 enum ath10k_mac_tx_path {
3574 ATH10K_MAC_TX_HTT,
3575 ATH10K_MAC_TX_HTT_MGMT,
3576 ATH10K_MAC_TX_WMI_MGMT,
3577 ATH10K_MAC_TX_UNKNOWN,
3578 };
3579
ath10k_mac_tx_lock(struct ath10k * ar,int reason)3580 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
3581 {
3582 lockdep_assert_held(&ar->htt.tx_lock);
3583
3584 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3585 ar->tx_paused |= BIT(reason);
3586 ieee80211_stop_queues(ar->hw);
3587 }
3588
ath10k_mac_tx_unlock_iter(void * data,u8 * mac,struct ieee80211_vif * vif)3589 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,
3590 struct ieee80211_vif *vif)
3591 {
3592 struct ath10k *ar = data;
3593 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3594
3595 if (arvif->tx_paused)
3596 return;
3597
3598 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3599 }
3600
ath10k_mac_tx_unlock(struct ath10k * ar,int reason)3601 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)
3602 {
3603 lockdep_assert_held(&ar->htt.tx_lock);
3604
3605 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3606 ar->tx_paused &= ~BIT(reason);
3607
3608 if (ar->tx_paused)
3609 return;
3610
3611 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3612 ATH10K_ITER_RESUME_FLAGS,
3613 ath10k_mac_tx_unlock_iter,
3614 ar);
3615
3616 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue);
3617 }
3618
ath10k_mac_vif_tx_lock(struct ath10k_vif * arvif,int reason)3619 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)
3620 {
3621 struct ath10k *ar = arvif->ar;
3622
3623 lockdep_assert_held(&ar->htt.tx_lock);
3624
3625 WARN_ON(reason >= BITS_PER_LONG);
3626 arvif->tx_paused |= BIT(reason);
3627 ieee80211_stop_queue(ar->hw, arvif->vdev_id);
3628 }
3629
ath10k_mac_vif_tx_unlock(struct ath10k_vif * arvif,int reason)3630 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason)
3631 {
3632 struct ath10k *ar = arvif->ar;
3633
3634 lockdep_assert_held(&ar->htt.tx_lock);
3635
3636 WARN_ON(reason >= BITS_PER_LONG);
3637 arvif->tx_paused &= ~BIT(reason);
3638
3639 if (ar->tx_paused)
3640 return;
3641
3642 if (arvif->tx_paused)
3643 return;
3644
3645 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3646 }
3647
ath10k_mac_vif_handle_tx_pause(struct ath10k_vif * arvif,enum wmi_tlv_tx_pause_id pause_id,enum wmi_tlv_tx_pause_action action)3648 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,
3649 enum wmi_tlv_tx_pause_id pause_id,
3650 enum wmi_tlv_tx_pause_action action)
3651 {
3652 struct ath10k *ar = arvif->ar;
3653
3654 lockdep_assert_held(&ar->htt.tx_lock);
3655
3656 switch (action) {
3657 case WMI_TLV_TX_PAUSE_ACTION_STOP:
3658 ath10k_mac_vif_tx_lock(arvif, pause_id);
3659 break;
3660 case WMI_TLV_TX_PAUSE_ACTION_WAKE:
3661 ath10k_mac_vif_tx_unlock(arvif, pause_id);
3662 break;
3663 default:
3664 ath10k_dbg(ar, ATH10K_DBG_BOOT,
3665 "received unknown tx pause action %d on vdev %i, ignoring\n",
3666 action, arvif->vdev_id);
3667 break;
3668 }
3669 }
3670
3671 struct ath10k_mac_tx_pause {
3672 u32 vdev_id;
3673 enum wmi_tlv_tx_pause_id pause_id;
3674 enum wmi_tlv_tx_pause_action action;
3675 };
3676
ath10k_mac_handle_tx_pause_iter(void * data,u8 * mac,struct ieee80211_vif * vif)3677 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,
3678 struct ieee80211_vif *vif)
3679 {
3680 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3681 struct ath10k_mac_tx_pause *arg = data;
3682
3683 if (arvif->vdev_id != arg->vdev_id)
3684 return;
3685
3686 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);
3687 }
3688
ath10k_mac_handle_tx_pause_vdev(struct ath10k * ar,u32 vdev_id,enum wmi_tlv_tx_pause_id pause_id,enum wmi_tlv_tx_pause_action action)3689 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id,
3690 enum wmi_tlv_tx_pause_id pause_id,
3691 enum wmi_tlv_tx_pause_action action)
3692 {
3693 struct ath10k_mac_tx_pause arg = {
3694 .vdev_id = vdev_id,
3695 .pause_id = pause_id,
3696 .action = action,
3697 };
3698
3699 spin_lock_bh(&ar->htt.tx_lock);
3700 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3701 ATH10K_ITER_RESUME_FLAGS,
3702 ath10k_mac_handle_tx_pause_iter,
3703 &arg);
3704 spin_unlock_bh(&ar->htt.tx_lock);
3705 }
3706
3707 static enum ath10k_hw_txrx_mode
ath10k_mac_tx_h_get_txmode(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct sk_buff * skb)3708 ath10k_mac_tx_h_get_txmode(struct ath10k *ar,
3709 struct ieee80211_vif *vif,
3710 struct ieee80211_sta *sta,
3711 struct sk_buff *skb)
3712 {
3713 const struct ieee80211_hdr *hdr = (void *)skb->data;
3714 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
3715 __le16 fc = hdr->frame_control;
3716
3717 if (IEEE80211_SKB_CB(skb)->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)
3718 return ATH10K_HW_TXRX_ETHERNET;
3719
3720 if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3721 return ATH10K_HW_TXRX_RAW;
3722
3723 if (ieee80211_is_mgmt(fc))
3724 return ATH10K_HW_TXRX_MGMT;
3725
3726 /* Workaround:
3727 *
3728 * NullFunc frames are mostly used to ping if a client or AP are still
3729 * reachable and responsive. This implies tx status reports must be
3730 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3731 * come to a conclusion that the other end disappeared and tear down
3732 * BSS connection or it can never disconnect from BSS/client (which is
3733 * the case).
3734 *
3735 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3736 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3737 * which seems to deliver correct tx reports for NullFunc frames. The
3738 * downside of using it is it ignores client powersave state so it can
3739 * end up disconnecting sleeping clients in AP mode. It should fix STA
3740 * mode though because AP don't sleep.
3741 */
3742 if (ar->htt.target_version_major < 3 &&
3743 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3744 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3745 ar->running_fw->fw_file.fw_features))
3746 return ATH10K_HW_TXRX_MGMT;
3747
3748 /* Workaround:
3749 *
3750 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3751 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3752 * to work with Ethernet txmode so use it.
3753 *
3754 * FIXME: Check if raw mode works with TDLS.
3755 */
3756 if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3757 return ATH10K_HW_TXRX_ETHERNET;
3758
3759 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) ||
3760 skb_cb->flags & ATH10K_SKB_F_RAW_TX)
3761 return ATH10K_HW_TXRX_RAW;
3762
3763 return ATH10K_HW_TXRX_NATIVE_WIFI;
3764 }
3765
ath10k_tx_h_use_hwcrypto(struct ieee80211_vif * vif,struct sk_buff * skb)3766 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,
3767 struct sk_buff *skb)
3768 {
3769 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3770 const struct ieee80211_hdr *hdr = (void *)skb->data;
3771 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |
3772 IEEE80211_TX_CTL_INJECTED;
3773
3774 if (!ieee80211_has_protected(hdr->frame_control))
3775 return false;
3776
3777 if ((info->flags & mask) == mask)
3778 return false;
3779
3780 if (vif)
3781 return !((struct ath10k_vif *)vif->drv_priv)->nohwcrypt;
3782
3783 return true;
3784 }
3785
3786 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3787 * Control in the header.
3788 */
ath10k_tx_h_nwifi(struct ieee80211_hw * hw,struct sk_buff * skb)3789 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3790 {
3791 struct ieee80211_hdr *hdr = (void *)skb->data;
3792 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3793 u8 *qos_ctl;
3794
3795 if (!ieee80211_is_data_qos(hdr->frame_control))
3796 return;
3797
3798 qos_ctl = ieee80211_get_qos_ctl(hdr);
3799 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3800 skb->data, (void *)qos_ctl - (void *)skb->data);
3801 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3802
3803 /* Some firmware revisions don't handle sending QoS NullFunc well.
3804 * These frames are mainly used for CQM purposes so it doesn't really
3805 * matter whether QoS NullFunc or NullFunc are sent.
3806 */
3807 hdr = (void *)skb->data;
3808 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3809 cb->flags &= ~ATH10K_SKB_F_QOS;
3810
3811 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3812 }
3813
ath10k_tx_h_8023(struct sk_buff * skb)3814 static void ath10k_tx_h_8023(struct sk_buff *skb)
3815 {
3816 struct ieee80211_hdr *hdr;
3817 struct rfc1042_hdr *rfc1042;
3818 struct ethhdr *eth;
3819 size_t hdrlen;
3820 u8 da[ETH_ALEN];
3821 u8 sa[ETH_ALEN];
3822 __be16 type;
3823
3824 hdr = (void *)skb->data;
3825 hdrlen = ieee80211_hdrlen(hdr->frame_control);
3826 rfc1042 = (void *)skb->data + hdrlen;
3827
3828 ether_addr_copy(da, ieee80211_get_DA(hdr));
3829 ether_addr_copy(sa, ieee80211_get_SA(hdr));
3830 type = rfc1042->snap_type;
3831
3832 skb_pull(skb, hdrlen + sizeof(*rfc1042));
3833 skb_push(skb, sizeof(*eth));
3834
3835 eth = (void *)skb->data;
3836 ether_addr_copy(eth->h_dest, da);
3837 ether_addr_copy(eth->h_source, sa);
3838 eth->h_proto = type;
3839 }
3840
ath10k_tx_h_add_p2p_noa_ie(struct ath10k * ar,struct ieee80211_vif * vif,struct sk_buff * skb)3841 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3842 struct ieee80211_vif *vif,
3843 struct sk_buff *skb)
3844 {
3845 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3846 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3847
3848 /* This is case only for P2P_GO */
3849 if (vif->type != NL80211_IFTYPE_AP || !vif->p2p)
3850 return;
3851
3852 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3853 spin_lock_bh(&ar->data_lock);
3854 if (arvif->u.ap.noa_data)
3855 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3856 GFP_ATOMIC))
3857 skb_put_data(skb, arvif->u.ap.noa_data,
3858 arvif->u.ap.noa_len);
3859 spin_unlock_bh(&ar->data_lock);
3860 }
3861 }
3862
ath10k_mac_tx_h_fill_cb(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_txq * txq,struct ieee80211_sta * sta,struct sk_buff * skb,u16 airtime)3863 static void ath10k_mac_tx_h_fill_cb(struct ath10k *ar,
3864 struct ieee80211_vif *vif,
3865 struct ieee80211_txq *txq,
3866 struct ieee80211_sta *sta,
3867 struct sk_buff *skb, u16 airtime)
3868 {
3869 struct ieee80211_hdr *hdr = (void *)skb->data;
3870 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3871 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3872 bool is_data = ieee80211_is_data(hdr->frame_control) ||
3873 ieee80211_is_data_qos(hdr->frame_control);
3874 struct ath10k_vif *arvif = (void *)vif->drv_priv;
3875 struct ath10k_sta *arsta;
3876 u8 tid, *qos_ctl;
3877 bool noack = false;
3878
3879 cb->flags = 0;
3880
3881 if (info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP) {
3882 cb->flags |= ATH10K_SKB_F_QOS; /* Assume data frames are QoS */
3883 goto finish_cb_fill;
3884 }
3885
3886 if (!ath10k_tx_h_use_hwcrypto(vif, skb))
3887 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3888
3889 if (ieee80211_is_mgmt(hdr->frame_control))
3890 cb->flags |= ATH10K_SKB_F_MGMT;
3891
3892 if (ieee80211_is_data_qos(hdr->frame_control)) {
3893 cb->flags |= ATH10K_SKB_F_QOS;
3894 qos_ctl = ieee80211_get_qos_ctl(hdr);
3895 tid = (*qos_ctl) & IEEE80211_QOS_CTL_TID_MASK;
3896
3897 if (arvif->noack[tid] == WMI_PEER_TID_CONFIG_NOACK)
3898 noack = true;
3899
3900 if (sta) {
3901 arsta = (struct ath10k_sta *)sta->drv_priv;
3902
3903 if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_NOACK)
3904 noack = true;
3905
3906 if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_ACK)
3907 noack = false;
3908 }
3909
3910 if (noack)
3911 cb->flags |= ATH10K_SKB_F_NOACK_TID;
3912 }
3913
3914 /* Data frames encrypted in software will be posted to firmware
3915 * with tx encap mode set to RAW. Ex: Multicast traffic generated
3916 * for a specific VLAN group will always be encrypted in software.
3917 */
3918 if (is_data && ieee80211_has_protected(hdr->frame_control) &&
3919 !info->control.hw_key) {
3920 cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3921 cb->flags |= ATH10K_SKB_F_RAW_TX;
3922 }
3923
3924 finish_cb_fill:
3925 cb->vif = vif;
3926 cb->txq = txq;
3927 cb->airtime_est = airtime;
3928 if (sta) {
3929 arsta = (struct ath10k_sta *)sta->drv_priv;
3930 spin_lock_bh(&ar->data_lock);
3931 cb->ucast_cipher = arsta->ucast_cipher;
3932 spin_unlock_bh(&ar->data_lock);
3933 }
3934 }
3935
ath10k_mac_tx_frm_has_freq(struct ath10k * ar)3936 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)
3937 {
3938 /* FIXME: Not really sure since when the behaviour changed. At some
3939 * point new firmware stopped requiring creation of peer entries for
3940 * offchannel tx (and actually creating them causes issues with wmi-htc
3941 * tx credit replenishment and reliability). Assuming it's at least 3.4
3942 * because that's when the `freq` was introduced to TX_FRM HTT command.
3943 */
3944 return (ar->htt.target_version_major >= 3 &&
3945 ar->htt.target_version_minor >= 4 &&
3946 ar->running_fw->fw_file.htt_op_version == ATH10K_FW_HTT_OP_VERSION_TLV);
3947 }
3948
ath10k_mac_tx_wmi_mgmt(struct ath10k * ar,struct sk_buff * skb)3949 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3950 {
3951 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3952
3953 if (skb_queue_len_lockless(q) >= ATH10K_MAX_NUM_MGMT_PENDING) {
3954 ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3955 return -ENOSPC;
3956 }
3957
3958 skb_queue_tail(q, skb);
3959 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3960
3961 return 0;
3962 }
3963
3964 static enum ath10k_mac_tx_path
ath10k_mac_tx_h_get_txpath(struct ath10k * ar,struct sk_buff * skb,enum ath10k_hw_txrx_mode txmode)3965 ath10k_mac_tx_h_get_txpath(struct ath10k *ar,
3966 struct sk_buff *skb,
3967 enum ath10k_hw_txrx_mode txmode)
3968 {
3969 switch (txmode) {
3970 case ATH10K_HW_TXRX_RAW:
3971 case ATH10K_HW_TXRX_NATIVE_WIFI:
3972 case ATH10K_HW_TXRX_ETHERNET:
3973 return ATH10K_MAC_TX_HTT;
3974 case ATH10K_HW_TXRX_MGMT:
3975 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3976 ar->running_fw->fw_file.fw_features) ||
3977 test_bit(WMI_SERVICE_MGMT_TX_WMI,
3978 ar->wmi.svc_map))
3979 return ATH10K_MAC_TX_WMI_MGMT;
3980 else if (ar->htt.target_version_major >= 3)
3981 return ATH10K_MAC_TX_HTT;
3982 else
3983 return ATH10K_MAC_TX_HTT_MGMT;
3984 }
3985
3986 return ATH10K_MAC_TX_UNKNOWN;
3987 }
3988
ath10k_mac_tx_submit(struct ath10k * ar,enum ath10k_hw_txrx_mode txmode,enum ath10k_mac_tx_path txpath,struct sk_buff * skb)3989 static int ath10k_mac_tx_submit(struct ath10k *ar,
3990 enum ath10k_hw_txrx_mode txmode,
3991 enum ath10k_mac_tx_path txpath,
3992 struct sk_buff *skb)
3993 {
3994 struct ath10k_htt *htt = &ar->htt;
3995 int ret = -EINVAL;
3996
3997 switch (txpath) {
3998 case ATH10K_MAC_TX_HTT:
3999 ret = ath10k_htt_tx(htt, txmode, skb);
4000 break;
4001 case ATH10K_MAC_TX_HTT_MGMT:
4002 ret = ath10k_htt_mgmt_tx(htt, skb);
4003 break;
4004 case ATH10K_MAC_TX_WMI_MGMT:
4005 ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
4006 break;
4007 case ATH10K_MAC_TX_UNKNOWN:
4008 WARN_ON_ONCE(1);
4009 ret = -EINVAL;
4010 break;
4011 }
4012
4013 if (ret) {
4014 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
4015 ret);
4016 ieee80211_free_txskb(ar->hw, skb);
4017 }
4018
4019 return ret;
4020 }
4021
4022 /* This function consumes the sk_buff regardless of return value as far as
4023 * caller is concerned so no freeing is necessary afterwards.
4024 */
ath10k_mac_tx(struct ath10k * ar,struct ieee80211_vif * vif,enum ath10k_hw_txrx_mode txmode,enum ath10k_mac_tx_path txpath,struct sk_buff * skb,bool noque_offchan)4025 static int ath10k_mac_tx(struct ath10k *ar,
4026 struct ieee80211_vif *vif,
4027 enum ath10k_hw_txrx_mode txmode,
4028 enum ath10k_mac_tx_path txpath,
4029 struct sk_buff *skb, bool noque_offchan)
4030 {
4031 struct ieee80211_hw *hw = ar->hw;
4032 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
4033 const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
4034 int ret;
4035
4036 /* We should disable CCK RATE due to P2P */
4037 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
4038 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
4039
4040 switch (txmode) {
4041 case ATH10K_HW_TXRX_MGMT:
4042 case ATH10K_HW_TXRX_NATIVE_WIFI:
4043 ath10k_tx_h_nwifi(hw, skb);
4044 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
4045 ath10k_tx_h_seq_no(vif, skb);
4046 break;
4047 case ATH10K_HW_TXRX_ETHERNET:
4048 /* Convert 802.11->802.3 header only if the frame was earlier
4049 * encapsulated to 802.11 by mac80211. Otherwise pass it as is.
4050 */
4051 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP))
4052 ath10k_tx_h_8023(skb);
4053 break;
4054 case ATH10K_HW_TXRX_RAW:
4055 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) &&
4056 !(skb_cb->flags & ATH10K_SKB_F_RAW_TX)) {
4057 WARN_ON_ONCE(1);
4058 ieee80211_free_txskb(hw, skb);
4059 return -ENOTSUPP;
4060 }
4061 }
4062
4063 if (!noque_offchan && info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
4064 if (!ath10k_mac_tx_frm_has_freq(ar)) {
4065 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac queued offchannel skb %pK len %d\n",
4066 skb, skb->len);
4067
4068 skb_queue_tail(&ar->offchan_tx_queue, skb);
4069 ieee80211_queue_work(hw, &ar->offchan_tx_work);
4070 return 0;
4071 }
4072 }
4073
4074 ret = ath10k_mac_tx_submit(ar, txmode, txpath, skb);
4075 if (ret) {
4076 ath10k_warn(ar, "failed to submit frame: %d\n", ret);
4077 return ret;
4078 }
4079
4080 return 0;
4081 }
4082
ath10k_offchan_tx_purge(struct ath10k * ar)4083 void ath10k_offchan_tx_purge(struct ath10k *ar)
4084 {
4085 struct sk_buff *skb;
4086
4087 for (;;) {
4088 skb = skb_dequeue(&ar->offchan_tx_queue);
4089 if (!skb)
4090 break;
4091
4092 ieee80211_free_txskb(ar->hw, skb);
4093 }
4094 }
4095
ath10k_offchan_tx_work(struct work_struct * work)4096 void ath10k_offchan_tx_work(struct work_struct *work)
4097 {
4098 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
4099 struct ath10k_peer *peer;
4100 struct ath10k_vif *arvif;
4101 enum ath10k_hw_txrx_mode txmode;
4102 enum ath10k_mac_tx_path txpath;
4103 struct ieee80211_hdr *hdr;
4104 struct ieee80211_vif *vif;
4105 struct ieee80211_sta *sta;
4106 struct sk_buff *skb;
4107 const u8 *peer_addr;
4108 int vdev_id;
4109 int ret;
4110 unsigned long time_left;
4111 bool tmp_peer_created = false;
4112
4113 /* FW requirement: We must create a peer before FW will send out
4114 * an offchannel frame. Otherwise the frame will be stuck and
4115 * never transmitted. We delete the peer upon tx completion.
4116 * It is unlikely that a peer for offchannel tx will already be
4117 * present. However it may be in some rare cases so account for that.
4118 * Otherwise we might remove a legitimate peer and break stuff.
4119 */
4120
4121 for (;;) {
4122 skb = skb_dequeue(&ar->offchan_tx_queue);
4123 if (!skb)
4124 break;
4125
4126 mutex_lock(&ar->conf_mutex);
4127
4128 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %pK len %d\n",
4129 skb, skb->len);
4130
4131 hdr = (struct ieee80211_hdr *)skb->data;
4132 peer_addr = ieee80211_get_DA(hdr);
4133
4134 spin_lock_bh(&ar->data_lock);
4135 vdev_id = ar->scan.vdev_id;
4136 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
4137 spin_unlock_bh(&ar->data_lock);
4138
4139 if (peer) {
4140 ath10k_warn(ar, "peer %pM on vdev %d already present\n",
4141 peer_addr, vdev_id);
4142 } else {
4143 ret = ath10k_peer_create(ar, NULL, NULL, vdev_id,
4144 peer_addr,
4145 WMI_PEER_TYPE_DEFAULT);
4146 if (ret)
4147 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
4148 peer_addr, vdev_id, ret);
4149 tmp_peer_created = (ret == 0);
4150 }
4151
4152 spin_lock_bh(&ar->data_lock);
4153 reinit_completion(&ar->offchan_tx_completed);
4154 ar->offchan_tx_skb = skb;
4155 spin_unlock_bh(&ar->data_lock);
4156
4157 /* It's safe to access vif and sta - conf_mutex guarantees that
4158 * sta_state() and remove_interface() are locked exclusively
4159 * out wrt to this offchannel worker.
4160 */
4161 arvif = ath10k_get_arvif(ar, vdev_id);
4162 if (arvif) {
4163 vif = arvif->vif;
4164 sta = ieee80211_find_sta(vif, peer_addr);
4165 } else {
4166 vif = NULL;
4167 sta = NULL;
4168 }
4169
4170 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
4171 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
4172
4173 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, true);
4174 if (ret) {
4175 ath10k_warn(ar, "failed to transmit offchannel frame: %d\n",
4176 ret);
4177 /* not serious */
4178 }
4179
4180 time_left =
4181 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
4182 if (time_left == 0)
4183 ath10k_warn(ar, "timed out waiting for offchannel skb %pK, len: %d\n",
4184 skb, skb->len);
4185
4186 if (!peer && tmp_peer_created) {
4187 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
4188 if (ret)
4189 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
4190 peer_addr, vdev_id, ret);
4191 }
4192
4193 mutex_unlock(&ar->conf_mutex);
4194 }
4195 }
4196
ath10k_mgmt_over_wmi_tx_purge(struct ath10k * ar)4197 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
4198 {
4199 struct sk_buff *skb;
4200
4201 for (;;) {
4202 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
4203 if (!skb)
4204 break;
4205
4206 ieee80211_free_txskb(ar->hw, skb);
4207 }
4208 }
4209
ath10k_mgmt_over_wmi_tx_work(struct work_struct * work)4210 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
4211 {
4212 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
4213 struct sk_buff *skb;
4214 dma_addr_t paddr;
4215 int ret;
4216
4217 for (;;) {
4218 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
4219 if (!skb)
4220 break;
4221
4222 if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF,
4223 ar->running_fw->fw_file.fw_features)) {
4224 paddr = dma_map_single(ar->dev, skb->data,
4225 skb->len, DMA_TO_DEVICE);
4226 if (dma_mapping_error(ar->dev, paddr)) {
4227 ieee80211_free_txskb(ar->hw, skb);
4228 continue;
4229 }
4230 ret = ath10k_wmi_mgmt_tx_send(ar, skb, paddr);
4231 if (ret) {
4232 ath10k_warn(ar, "failed to transmit management frame by ref via WMI: %d\n",
4233 ret);
4234 /* remove this msdu from idr tracking */
4235 ath10k_wmi_cleanup_mgmt_tx_send(ar, skb);
4236
4237 dma_unmap_single(ar->dev, paddr, skb->len,
4238 DMA_TO_DEVICE);
4239 ieee80211_free_txskb(ar->hw, skb);
4240 }
4241 } else {
4242 ret = ath10k_wmi_mgmt_tx(ar, skb);
4243 if (ret) {
4244 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
4245 ret);
4246 ieee80211_free_txskb(ar->hw, skb);
4247 }
4248 }
4249 }
4250 }
4251
ath10k_mac_txq_init(struct ieee80211_txq * txq)4252 static void ath10k_mac_txq_init(struct ieee80211_txq *txq)
4253 {
4254 struct ath10k_txq *artxq;
4255
4256 if (!txq)
4257 return;
4258
4259 artxq = (void *)txq->drv_priv;
4260 INIT_LIST_HEAD(&artxq->list);
4261 }
4262
ath10k_mac_txq_unref(struct ath10k * ar,struct ieee80211_txq * txq)4263 static void ath10k_mac_txq_unref(struct ath10k *ar, struct ieee80211_txq *txq)
4264 {
4265 struct ath10k_skb_cb *cb;
4266 struct sk_buff *msdu;
4267 int msdu_id;
4268
4269 if (!txq)
4270 return;
4271
4272 spin_lock_bh(&ar->htt.tx_lock);
4273 idr_for_each_entry(&ar->htt.pending_tx, msdu, msdu_id) {
4274 cb = ATH10K_SKB_CB(msdu);
4275 if (cb->txq == txq)
4276 cb->txq = NULL;
4277 }
4278 spin_unlock_bh(&ar->htt.tx_lock);
4279 }
4280
ath10k_mac_txq_lookup(struct ath10k * ar,u16 peer_id,u8 tid)4281 struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar,
4282 u16 peer_id,
4283 u8 tid)
4284 {
4285 struct ath10k_peer *peer;
4286
4287 lockdep_assert_held(&ar->data_lock);
4288
4289 peer = ar->peer_map[peer_id];
4290 if (!peer)
4291 return NULL;
4292
4293 if (peer->removed)
4294 return NULL;
4295
4296 if (peer->sta)
4297 return peer->sta->txq[tid];
4298 else if (peer->vif)
4299 return peer->vif->txq;
4300 else
4301 return NULL;
4302 }
4303
ath10k_mac_tx_can_push(struct ieee80211_hw * hw,struct ieee80211_txq * txq)4304 static bool ath10k_mac_tx_can_push(struct ieee80211_hw *hw,
4305 struct ieee80211_txq *txq)
4306 {
4307 struct ath10k *ar = hw->priv;
4308 struct ath10k_txq *artxq = (void *)txq->drv_priv;
4309
4310 /* No need to get locks */
4311 if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH)
4312 return true;
4313
4314 if (ar->htt.num_pending_tx < ar->htt.tx_q_state.num_push_allowed)
4315 return true;
4316
4317 if (artxq->num_fw_queued < artxq->num_push_allowed)
4318 return true;
4319
4320 return false;
4321 }
4322
4323 /* Return estimated airtime in microsecond, which is calculated using last
4324 * reported TX rate. This is just a rough estimation because host driver has no
4325 * knowledge of the actual transmit rate, retries or aggregation. If actual
4326 * airtime can be reported by firmware, then delta between estimated and actual
4327 * airtime can be adjusted from deficit.
4328 */
4329 #define IEEE80211_ATF_OVERHEAD 100 /* IFS + some slot time */
4330 #define IEEE80211_ATF_OVERHEAD_IFS 16 /* IFS only */
ath10k_mac_update_airtime(struct ath10k * ar,struct ieee80211_txq * txq,struct sk_buff * skb)4331 static u16 ath10k_mac_update_airtime(struct ath10k *ar,
4332 struct ieee80211_txq *txq,
4333 struct sk_buff *skb)
4334 {
4335 struct ath10k_sta *arsta;
4336 u32 pktlen;
4337 u16 airtime = 0;
4338
4339 if (!txq || !txq->sta)
4340 return airtime;
4341
4342 if (test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map))
4343 return airtime;
4344
4345 spin_lock_bh(&ar->data_lock);
4346 arsta = (struct ath10k_sta *)txq->sta->drv_priv;
4347
4348 pktlen = skb->len + 38; /* Assume MAC header 30, SNAP 8 for most case */
4349 if (arsta->last_tx_bitrate) {
4350 /* airtime in us, last_tx_bitrate in 100kbps */
4351 airtime = (pktlen * 8 * (1000 / 100))
4352 / arsta->last_tx_bitrate;
4353 /* overhead for media access time and IFS */
4354 airtime += IEEE80211_ATF_OVERHEAD_IFS;
4355 } else {
4356 /* This is mostly for throttle excessive BC/MC frames, and the
4357 * airtime/rate doesn't need be exact. Airtime of BC/MC frames
4358 * in 2G get some discount, which helps prevent very low rate
4359 * frames from being blocked for too long.
4360 */
4361 airtime = (pktlen * 8 * (1000 / 100)) / 60; /* 6M */
4362 airtime += IEEE80211_ATF_OVERHEAD;
4363 }
4364 spin_unlock_bh(&ar->data_lock);
4365
4366 return airtime;
4367 }
4368
ath10k_mac_tx_push_txq(struct ieee80211_hw * hw,struct ieee80211_txq * txq)4369 int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw,
4370 struct ieee80211_txq *txq)
4371 {
4372 struct ath10k *ar = hw->priv;
4373 struct ath10k_htt *htt = &ar->htt;
4374 struct ath10k_txq *artxq = (void *)txq->drv_priv;
4375 struct ieee80211_vif *vif = txq->vif;
4376 struct ieee80211_sta *sta = txq->sta;
4377 enum ath10k_hw_txrx_mode txmode;
4378 enum ath10k_mac_tx_path txpath;
4379 struct sk_buff *skb;
4380 struct ieee80211_hdr *hdr;
4381 size_t skb_len;
4382 bool is_mgmt, is_presp;
4383 int ret;
4384 u16 airtime;
4385
4386 spin_lock_bh(&ar->htt.tx_lock);
4387 ret = ath10k_htt_tx_inc_pending(htt);
4388 spin_unlock_bh(&ar->htt.tx_lock);
4389
4390 if (ret)
4391 return ret;
4392
4393 skb = ieee80211_tx_dequeue_ni(hw, txq);
4394 if (!skb) {
4395 spin_lock_bh(&ar->htt.tx_lock);
4396 ath10k_htt_tx_dec_pending(htt);
4397 spin_unlock_bh(&ar->htt.tx_lock);
4398
4399 return -ENOENT;
4400 }
4401
4402 airtime = ath10k_mac_update_airtime(ar, txq, skb);
4403 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime);
4404
4405 skb_len = skb->len;
4406 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
4407 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
4408 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);
4409
4410 if (is_mgmt) {
4411 hdr = (struct ieee80211_hdr *)skb->data;
4412 is_presp = ieee80211_is_probe_resp(hdr->frame_control);
4413
4414 spin_lock_bh(&ar->htt.tx_lock);
4415 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);
4416
4417 if (ret) {
4418 ath10k_htt_tx_dec_pending(htt);
4419 spin_unlock_bh(&ar->htt.tx_lock);
4420 return ret;
4421 }
4422 spin_unlock_bh(&ar->htt.tx_lock);
4423 }
4424
4425 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false);
4426 if (unlikely(ret)) {
4427 ath10k_warn(ar, "failed to push frame: %d\n", ret);
4428
4429 spin_lock_bh(&ar->htt.tx_lock);
4430 ath10k_htt_tx_dec_pending(htt);
4431 if (is_mgmt)
4432 ath10k_htt_tx_mgmt_dec_pending(htt);
4433 spin_unlock_bh(&ar->htt.tx_lock);
4434
4435 return ret;
4436 }
4437
4438 spin_lock_bh(&ar->htt.tx_lock);
4439 artxq->num_fw_queued++;
4440 spin_unlock_bh(&ar->htt.tx_lock);
4441
4442 return skb_len;
4443 }
4444
ath10k_mac_schedule_txq(struct ieee80211_hw * hw,u32 ac)4445 static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac)
4446 {
4447 struct ieee80211_txq *txq;
4448 int ret = 0;
4449
4450 ieee80211_txq_schedule_start(hw, ac);
4451 while ((txq = ieee80211_next_txq(hw, ac))) {
4452 while (ath10k_mac_tx_can_push(hw, txq)) {
4453 ret = ath10k_mac_tx_push_txq(hw, txq);
4454 if (ret < 0)
4455 break;
4456 }
4457 ieee80211_return_txq(hw, txq, false);
4458 ath10k_htt_tx_txq_update(hw, txq);
4459 if (ret == -EBUSY)
4460 break;
4461 }
4462 ieee80211_txq_schedule_end(hw, ac);
4463
4464 return ret;
4465 }
4466
ath10k_mac_tx_push_pending(struct ath10k * ar)4467 void ath10k_mac_tx_push_pending(struct ath10k *ar)
4468 {
4469 struct ieee80211_hw *hw = ar->hw;
4470 u32 ac;
4471
4472 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH)
4473 return;
4474
4475 if (ar->htt.num_pending_tx >= (ar->htt.max_num_pending_tx / 2))
4476 return;
4477
4478 rcu_read_lock();
4479 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
4480 if (ath10k_mac_schedule_txq(hw, ac) == -EBUSY)
4481 break;
4482 }
4483 rcu_read_unlock();
4484 }
4485 EXPORT_SYMBOL(ath10k_mac_tx_push_pending);
4486
4487 /************/
4488 /* Scanning */
4489 /************/
4490
__ath10k_scan_finish(struct ath10k * ar)4491 void __ath10k_scan_finish(struct ath10k *ar)
4492 {
4493 lockdep_assert_held(&ar->data_lock);
4494
4495 switch (ar->scan.state) {
4496 case ATH10K_SCAN_IDLE:
4497 break;
4498 case ATH10K_SCAN_RUNNING:
4499 case ATH10K_SCAN_ABORTING:
4500 if (ar->scan.is_roc && ar->scan.roc_notify)
4501 ieee80211_remain_on_channel_expired(ar->hw);
4502 fallthrough;
4503 case ATH10K_SCAN_STARTING:
4504 if (!ar->scan.is_roc) {
4505 struct cfg80211_scan_info info = {
4506 .aborted = ((ar->scan.state ==
4507 ATH10K_SCAN_ABORTING) ||
4508 (ar->scan.state ==
4509 ATH10K_SCAN_STARTING)),
4510 };
4511
4512 ieee80211_scan_completed(ar->hw, &info);
4513 }
4514
4515 ar->scan.state = ATH10K_SCAN_IDLE;
4516 ar->scan_channel = NULL;
4517 ar->scan.roc_freq = 0;
4518 ath10k_offchan_tx_purge(ar);
4519 cancel_delayed_work(&ar->scan.timeout);
4520 complete(&ar->scan.completed);
4521 break;
4522 }
4523 }
4524
ath10k_scan_finish(struct ath10k * ar)4525 void ath10k_scan_finish(struct ath10k *ar)
4526 {
4527 spin_lock_bh(&ar->data_lock);
4528 __ath10k_scan_finish(ar);
4529 spin_unlock_bh(&ar->data_lock);
4530 }
4531
ath10k_scan_stop(struct ath10k * ar)4532 static int ath10k_scan_stop(struct ath10k *ar)
4533 {
4534 struct wmi_stop_scan_arg arg = {
4535 .req_id = 1, /* FIXME */
4536 .req_type = WMI_SCAN_STOP_ONE,
4537 .u.scan_id = ATH10K_SCAN_ID,
4538 };
4539 int ret;
4540
4541 lockdep_assert_held(&ar->conf_mutex);
4542
4543 ret = ath10k_wmi_stop_scan(ar, &arg);
4544 if (ret) {
4545 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
4546 goto out;
4547 }
4548
4549 ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
4550 if (ret == 0) {
4551 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
4552 ret = -ETIMEDOUT;
4553 } else if (ret > 0) {
4554 ret = 0;
4555 }
4556
4557 out:
4558 /* Scan state should be updated upon scan completion but in case
4559 * firmware fails to deliver the event (for whatever reason) it is
4560 * desired to clean up scan state anyway. Firmware may have just
4561 * dropped the scan completion event delivery due to transport pipe
4562 * being overflown with data and/or it can recover on its own before
4563 * next scan request is submitted.
4564 */
4565 spin_lock_bh(&ar->data_lock);
4566 if (ar->scan.state != ATH10K_SCAN_IDLE)
4567 __ath10k_scan_finish(ar);
4568 spin_unlock_bh(&ar->data_lock);
4569
4570 return ret;
4571 }
4572
ath10k_scan_abort(struct ath10k * ar)4573 static void ath10k_scan_abort(struct ath10k *ar)
4574 {
4575 int ret;
4576
4577 lockdep_assert_held(&ar->conf_mutex);
4578
4579 spin_lock_bh(&ar->data_lock);
4580
4581 switch (ar->scan.state) {
4582 case ATH10K_SCAN_IDLE:
4583 /* This can happen if timeout worker kicked in and called
4584 * abortion while scan completion was being processed.
4585 */
4586 break;
4587 case ATH10K_SCAN_STARTING:
4588 case ATH10K_SCAN_ABORTING:
4589 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
4590 ath10k_scan_state_str(ar->scan.state),
4591 ar->scan.state);
4592 break;
4593 case ATH10K_SCAN_RUNNING:
4594 ar->scan.state = ATH10K_SCAN_ABORTING;
4595 spin_unlock_bh(&ar->data_lock);
4596
4597 ret = ath10k_scan_stop(ar);
4598 if (ret)
4599 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
4600
4601 spin_lock_bh(&ar->data_lock);
4602 break;
4603 }
4604
4605 spin_unlock_bh(&ar->data_lock);
4606 }
4607
ath10k_scan_timeout_work(struct work_struct * work)4608 void ath10k_scan_timeout_work(struct work_struct *work)
4609 {
4610 struct ath10k *ar = container_of(work, struct ath10k,
4611 scan.timeout.work);
4612
4613 mutex_lock(&ar->conf_mutex);
4614 ath10k_scan_abort(ar);
4615 mutex_unlock(&ar->conf_mutex);
4616 }
4617
ath10k_start_scan(struct ath10k * ar,const struct wmi_start_scan_arg * arg)4618 static int ath10k_start_scan(struct ath10k *ar,
4619 const struct wmi_start_scan_arg *arg)
4620 {
4621 int ret;
4622
4623 lockdep_assert_held(&ar->conf_mutex);
4624
4625 ret = ath10k_wmi_start_scan(ar, arg);
4626 if (ret)
4627 return ret;
4628
4629 ret = wait_for_completion_timeout(&ar->scan.started, 1 * HZ);
4630 if (ret == 0) {
4631 ret = ath10k_scan_stop(ar);
4632 if (ret)
4633 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
4634
4635 return -ETIMEDOUT;
4636 }
4637
4638 /* If we failed to start the scan, return error code at
4639 * this point. This is probably due to some issue in the
4640 * firmware, but no need to wedge the driver due to that...
4641 */
4642 spin_lock_bh(&ar->data_lock);
4643 if (ar->scan.state == ATH10K_SCAN_IDLE) {
4644 spin_unlock_bh(&ar->data_lock);
4645 return -EINVAL;
4646 }
4647 spin_unlock_bh(&ar->data_lock);
4648
4649 return 0;
4650 }
4651
4652 /**********************/
4653 /* mac80211 callbacks */
4654 /**********************/
4655
ath10k_mac_op_tx(struct ieee80211_hw * hw,struct ieee80211_tx_control * control,struct sk_buff * skb)4656 static void ath10k_mac_op_tx(struct ieee80211_hw *hw,
4657 struct ieee80211_tx_control *control,
4658 struct sk_buff *skb)
4659 {
4660 struct ath10k *ar = hw->priv;
4661 struct ath10k_htt *htt = &ar->htt;
4662 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
4663 struct ieee80211_vif *vif = info->control.vif;
4664 struct ieee80211_sta *sta = control->sta;
4665 struct ieee80211_txq *txq = NULL;
4666 enum ath10k_hw_txrx_mode txmode;
4667 enum ath10k_mac_tx_path txpath;
4668 bool is_htt;
4669 bool is_mgmt;
4670 int ret;
4671 u16 airtime;
4672
4673 airtime = ath10k_mac_update_airtime(ar, txq, skb);
4674 ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime);
4675
4676 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
4677 txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
4678 is_htt = (txpath == ATH10K_MAC_TX_HTT ||
4679 txpath == ATH10K_MAC_TX_HTT_MGMT);
4680 is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);
4681
4682 if (is_htt) {
4683 bool is_presp = false;
4684
4685 spin_lock_bh(&ar->htt.tx_lock);
4686 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)) {
4687 struct ieee80211_hdr *hdr = (void *)skb->data;
4688
4689 is_presp = ieee80211_is_probe_resp(hdr->frame_control);
4690 }
4691
4692 ret = ath10k_htt_tx_inc_pending(htt);
4693 if (ret) {
4694 ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n",
4695 ret);
4696 spin_unlock_bh(&ar->htt.tx_lock);
4697 ieee80211_free_txskb(ar->hw, skb);
4698 return;
4699 }
4700
4701 ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);
4702 if (ret) {
4703 ath10k_dbg(ar, ATH10K_DBG_MAC, "failed to increase tx mgmt pending count: %d, dropping\n",
4704 ret);
4705 ath10k_htt_tx_dec_pending(htt);
4706 spin_unlock_bh(&ar->htt.tx_lock);
4707 ieee80211_free_txskb(ar->hw, skb);
4708 return;
4709 }
4710 spin_unlock_bh(&ar->htt.tx_lock);
4711 }
4712
4713 ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false);
4714 if (ret) {
4715 ath10k_warn(ar, "failed to transmit frame: %d\n", ret);
4716 if (is_htt) {
4717 spin_lock_bh(&ar->htt.tx_lock);
4718 ath10k_htt_tx_dec_pending(htt);
4719 if (is_mgmt)
4720 ath10k_htt_tx_mgmt_dec_pending(htt);
4721 spin_unlock_bh(&ar->htt.tx_lock);
4722 }
4723 return;
4724 }
4725 }
4726
ath10k_mac_op_wake_tx_queue(struct ieee80211_hw * hw,struct ieee80211_txq * txq)4727 static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw,
4728 struct ieee80211_txq *txq)
4729 {
4730 struct ath10k *ar = hw->priv;
4731 int ret;
4732 u8 ac = txq->ac;
4733
4734 ath10k_htt_tx_txq_update(hw, txq);
4735 if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH)
4736 return;
4737
4738 spin_lock_bh(&ar->queue_lock[ac]);
4739
4740 ieee80211_txq_schedule_start(hw, ac);
4741 txq = ieee80211_next_txq(hw, ac);
4742 if (!txq)
4743 goto out;
4744
4745 while (ath10k_mac_tx_can_push(hw, txq)) {
4746 ret = ath10k_mac_tx_push_txq(hw, txq);
4747 if (ret < 0)
4748 break;
4749 }
4750 ieee80211_return_txq(hw, txq, false);
4751 ath10k_htt_tx_txq_update(hw, txq);
4752 out:
4753 ieee80211_txq_schedule_end(hw, ac);
4754 spin_unlock_bh(&ar->queue_lock[ac]);
4755 }
4756
4757 /* Must not be called with conf_mutex held as workers can use that also. */
ath10k_drain_tx(struct ath10k * ar)4758 void ath10k_drain_tx(struct ath10k *ar)
4759 {
4760 lockdep_assert_not_held(&ar->conf_mutex);
4761
4762 /* make sure rcu-protected mac80211 tx path itself is drained */
4763 synchronize_net();
4764
4765 ath10k_offchan_tx_purge(ar);
4766 ath10k_mgmt_over_wmi_tx_purge(ar);
4767
4768 cancel_work_sync(&ar->offchan_tx_work);
4769 cancel_work_sync(&ar->wmi_mgmt_tx_work);
4770 }
4771
ath10k_halt(struct ath10k * ar)4772 void ath10k_halt(struct ath10k *ar)
4773 {
4774 struct ath10k_vif *arvif;
4775
4776 lockdep_assert_held(&ar->conf_mutex);
4777
4778 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
4779 ar->filter_flags = 0;
4780 ar->monitor = false;
4781 ar->monitor_arvif = NULL;
4782
4783 if (ar->monitor_started)
4784 ath10k_monitor_stop(ar);
4785
4786 ar->monitor_started = false;
4787 ar->tx_paused = 0;
4788
4789 ath10k_scan_finish(ar);
4790 ath10k_peer_cleanup_all(ar);
4791 ath10k_stop_radar_confirmation(ar);
4792 ath10k_core_stop(ar);
4793 ath10k_hif_power_down(ar);
4794
4795 spin_lock_bh(&ar->data_lock);
4796 list_for_each_entry(arvif, &ar->arvifs, list)
4797 ath10k_mac_vif_beacon_cleanup(arvif);
4798 spin_unlock_bh(&ar->data_lock);
4799 }
4800
ath10k_get_antenna(struct ieee80211_hw * hw,u32 * tx_ant,u32 * rx_ant)4801 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
4802 {
4803 struct ath10k *ar = hw->priv;
4804
4805 mutex_lock(&ar->conf_mutex);
4806
4807 *tx_ant = ar->cfg_tx_chainmask;
4808 *rx_ant = ar->cfg_rx_chainmask;
4809
4810 mutex_unlock(&ar->conf_mutex);
4811
4812 return 0;
4813 }
4814
ath10k_check_chain_mask(struct ath10k * ar,u32 cm,const char * dbg)4815 static bool ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
4816 {
4817 /* It is not clear that allowing gaps in chainmask
4818 * is helpful. Probably it will not do what user
4819 * is hoping for, so warn in that case.
4820 */
4821 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
4822 return true;
4823
4824 ath10k_warn(ar, "mac %s antenna chainmask is invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
4825 dbg, cm);
4826 return false;
4827 }
4828
ath10k_mac_get_vht_cap_bf_sts(struct ath10k * ar)4829 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
4830 {
4831 int nsts = ar->vht_cap_info;
4832
4833 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4834 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4835
4836 /* If firmware does not deliver to host number of space-time
4837 * streams supported, assume it support up to 4 BF STS and return
4838 * the value for VHT CAP: nsts-1)
4839 */
4840 if (nsts == 0)
4841 return 3;
4842
4843 return nsts;
4844 }
4845
ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k * ar)4846 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
4847 {
4848 int sound_dim = ar->vht_cap_info;
4849
4850 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4851 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4852
4853 /* If the sounding dimension is not advertised by the firmware,
4854 * let's use a default value of 1
4855 */
4856 if (sound_dim == 0)
4857 return 1;
4858
4859 return sound_dim;
4860 }
4861
ath10k_create_vht_cap(struct ath10k * ar)4862 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4863 {
4864 struct ieee80211_sta_vht_cap vht_cap = {0};
4865 struct ath10k_hw_params *hw = &ar->hw_params;
4866 u16 mcs_map;
4867 u32 val;
4868 int i;
4869
4870 vht_cap.vht_supported = 1;
4871 vht_cap.cap = ar->vht_cap_info;
4872
4873 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4874 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
4875 val = ath10k_mac_get_vht_cap_bf_sts(ar);
4876 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4877 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4878
4879 vht_cap.cap |= val;
4880 }
4881
4882 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4883 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
4884 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4885 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4886 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4887
4888 vht_cap.cap |= val;
4889 }
4890
4891 mcs_map = 0;
4892 for (i = 0; i < 8; i++) {
4893 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))
4894 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
4895 else
4896 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
4897 }
4898
4899 if (ar->cfg_tx_chainmask <= 1)
4900 vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
4901
4902 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4903 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4904
4905 /* If we are supporting 160Mhz or 80+80, then the NIC may be able to do
4906 * a restricted NSS for 160 or 80+80 vs what it can do for 80Mhz. Give
4907 * user-space a clue if that is the case.
4908 */
4909 if ((vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) &&
4910 (hw->vht160_mcs_rx_highest != 0 ||
4911 hw->vht160_mcs_tx_highest != 0)) {
4912 vht_cap.vht_mcs.rx_highest = cpu_to_le16(hw->vht160_mcs_rx_highest);
4913 vht_cap.vht_mcs.tx_highest = cpu_to_le16(hw->vht160_mcs_tx_highest);
4914 }
4915
4916 return vht_cap;
4917 }
4918
ath10k_get_ht_cap(struct ath10k * ar)4919 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4920 {
4921 int i;
4922 struct ieee80211_sta_ht_cap ht_cap = {0};
4923
4924 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4925 return ht_cap;
4926
4927 ht_cap.ht_supported = 1;
4928 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4929 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4930 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4931 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4932 ht_cap.cap |=
4933 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT;
4934
4935 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4936 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4937
4938 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4939 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4940
4941 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4942 u32 smps;
4943
4944 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4945 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4946
4947 ht_cap.cap |= smps;
4948 }
4949
4950 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC && (ar->cfg_tx_chainmask > 1))
4951 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4952
4953 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4954 u32 stbc;
4955
4956 stbc = ar->ht_cap_info;
4957 stbc &= WMI_HT_CAP_RX_STBC;
4958 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4959 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4960 stbc &= IEEE80211_HT_CAP_RX_STBC;
4961
4962 ht_cap.cap |= stbc;
4963 }
4964
4965 if (ar->ht_cap_info & WMI_HT_CAP_LDPC || (ar->ht_cap_info &
4966 WMI_HT_CAP_RX_LDPC && (ar->ht_cap_info & WMI_HT_CAP_TX_LDPC)))
4967 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4968
4969 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4970 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4971
4972 /* max AMSDU is implicitly taken from vht_cap_info */
4973 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4974 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4975
4976 for (i = 0; i < ar->num_rf_chains; i++) {
4977 if (ar->cfg_rx_chainmask & BIT(i))
4978 ht_cap.mcs.rx_mask[i] = 0xFF;
4979 }
4980
4981 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4982
4983 return ht_cap;
4984 }
4985
ath10k_mac_setup_ht_vht_cap(struct ath10k * ar)4986 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
4987 {
4988 struct ieee80211_supported_band *band;
4989 struct ieee80211_sta_vht_cap vht_cap;
4990 struct ieee80211_sta_ht_cap ht_cap;
4991
4992 ht_cap = ath10k_get_ht_cap(ar);
4993 vht_cap = ath10k_create_vht_cap(ar);
4994
4995 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4996 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
4997 band->ht_cap = ht_cap;
4998 }
4999 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
5000 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
5001 band->ht_cap = ht_cap;
5002 band->vht_cap = vht_cap;
5003 }
5004 }
5005
__ath10k_set_antenna(struct ath10k * ar,u32 tx_ant,u32 rx_ant)5006 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
5007 {
5008 int ret;
5009 bool is_valid_tx_chain_mask, is_valid_rx_chain_mask;
5010
5011 lockdep_assert_held(&ar->conf_mutex);
5012
5013 is_valid_tx_chain_mask = ath10k_check_chain_mask(ar, tx_ant, "tx");
5014 is_valid_rx_chain_mask = ath10k_check_chain_mask(ar, rx_ant, "rx");
5015
5016 if (!is_valid_tx_chain_mask || !is_valid_rx_chain_mask)
5017 return -EINVAL;
5018
5019 ar->cfg_tx_chainmask = tx_ant;
5020 ar->cfg_rx_chainmask = rx_ant;
5021
5022 if ((ar->state != ATH10K_STATE_ON) &&
5023 (ar->state != ATH10K_STATE_RESTARTED))
5024 return 0;
5025
5026 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
5027 tx_ant);
5028 if (ret) {
5029 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
5030 ret, tx_ant);
5031 return ret;
5032 }
5033
5034 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
5035 rx_ant);
5036 if (ret) {
5037 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
5038 ret, rx_ant);
5039 return ret;
5040 }
5041
5042 /* Reload HT/VHT capability */
5043 ath10k_mac_setup_ht_vht_cap(ar);
5044
5045 return 0;
5046 }
5047
ath10k_set_antenna(struct ieee80211_hw * hw,u32 tx_ant,u32 rx_ant)5048 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
5049 {
5050 struct ath10k *ar = hw->priv;
5051 int ret;
5052
5053 mutex_lock(&ar->conf_mutex);
5054 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
5055 mutex_unlock(&ar->conf_mutex);
5056 return ret;
5057 }
5058
__ath10k_fetch_bb_timing_dt(struct ath10k * ar,struct wmi_bb_timing_cfg_arg * bb_timing)5059 static int __ath10k_fetch_bb_timing_dt(struct ath10k *ar,
5060 struct wmi_bb_timing_cfg_arg *bb_timing)
5061 {
5062 struct device_node *node;
5063 const char *fem_name;
5064 int ret;
5065
5066 node = ar->dev->of_node;
5067 if (!node)
5068 return -ENOENT;
5069
5070 ret = of_property_read_string_index(node, "ext-fem-name", 0, &fem_name);
5071 if (ret)
5072 return -ENOENT;
5073
5074 /*
5075 * If external Front End module used in hardware, then default base band timing
5076 * parameter cannot be used since they were fine tuned for reference hardware,
5077 * so choosing different value suitable for that external FEM.
5078 */
5079 if (!strcmp("microsemi-lx5586", fem_name)) {
5080 bb_timing->bb_tx_timing = 0x00;
5081 bb_timing->bb_xpa_timing = 0x0101;
5082 } else {
5083 return -ENOENT;
5084 }
5085
5086 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot bb_tx_timing 0x%x bb_xpa_timing 0x%x\n",
5087 bb_timing->bb_tx_timing, bb_timing->bb_xpa_timing);
5088 return 0;
5089 }
5090
ath10k_mac_rfkill_config(struct ath10k * ar)5091 static int ath10k_mac_rfkill_config(struct ath10k *ar)
5092 {
5093 u32 param;
5094 int ret;
5095
5096 if (ar->hw_values->rfkill_pin == 0) {
5097 ath10k_warn(ar, "ath10k does not support hardware rfkill with this device\n");
5098 return -EOPNOTSUPP;
5099 }
5100
5101 ath10k_dbg(ar, ATH10K_DBG_MAC,
5102 "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d",
5103 ar->hw_values->rfkill_pin, ar->hw_values->rfkill_cfg,
5104 ar->hw_values->rfkill_on_level);
5105
5106 param = FIELD_PREP(WMI_TLV_RFKILL_CFG_RADIO_LEVEL,
5107 ar->hw_values->rfkill_on_level) |
5108 FIELD_PREP(WMI_TLV_RFKILL_CFG_GPIO_PIN_NUM,
5109 ar->hw_values->rfkill_pin) |
5110 FIELD_PREP(WMI_TLV_RFKILL_CFG_PIN_AS_GPIO,
5111 ar->hw_values->rfkill_cfg);
5112
5113 ret = ath10k_wmi_pdev_set_param(ar,
5114 ar->wmi.pdev_param->rfkill_config,
5115 param);
5116 if (ret) {
5117 ath10k_warn(ar,
5118 "failed to set rfkill config 0x%x: %d\n",
5119 param, ret);
5120 return ret;
5121 }
5122 return 0;
5123 }
5124
ath10k_mac_rfkill_enable_radio(struct ath10k * ar,bool enable)5125 int ath10k_mac_rfkill_enable_radio(struct ath10k *ar, bool enable)
5126 {
5127 enum wmi_tlv_rfkill_enable_radio param;
5128 int ret;
5129
5130 if (enable)
5131 param = WMI_TLV_RFKILL_ENABLE_RADIO_ON;
5132 else
5133 param = WMI_TLV_RFKILL_ENABLE_RADIO_OFF;
5134
5135 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac rfkill enable %d", param);
5136
5137 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rfkill_enable,
5138 param);
5139 if (ret) {
5140 ath10k_warn(ar, "failed to set rfkill enable param %d: %d\n",
5141 param, ret);
5142 return ret;
5143 }
5144
5145 return 0;
5146 }
5147
ath10k_start(struct ieee80211_hw * hw)5148 static int ath10k_start(struct ieee80211_hw *hw)
5149 {
5150 struct ath10k *ar = hw->priv;
5151 u32 param;
5152 int ret = 0;
5153 struct wmi_bb_timing_cfg_arg bb_timing = {0};
5154
5155 /*
5156 * This makes sense only when restarting hw. It is harmless to call
5157 * unconditionally. This is necessary to make sure no HTT/WMI tx
5158 * commands will be submitted while restarting.
5159 */
5160 ath10k_drain_tx(ar);
5161
5162 mutex_lock(&ar->conf_mutex);
5163
5164 switch (ar->state) {
5165 case ATH10K_STATE_OFF:
5166 ar->state = ATH10K_STATE_ON;
5167 break;
5168 case ATH10K_STATE_RESTARTING:
5169 ar->state = ATH10K_STATE_RESTARTED;
5170 break;
5171 case ATH10K_STATE_ON:
5172 case ATH10K_STATE_RESTARTED:
5173 case ATH10K_STATE_WEDGED:
5174 WARN_ON(1);
5175 ret = -EINVAL;
5176 goto err;
5177 case ATH10K_STATE_UTF:
5178 ret = -EBUSY;
5179 goto err;
5180 }
5181
5182 spin_lock_bh(&ar->data_lock);
5183
5184 if (ar->hw_rfkill_on) {
5185 ar->hw_rfkill_on = false;
5186 spin_unlock_bh(&ar->data_lock);
5187 goto err;
5188 }
5189
5190 spin_unlock_bh(&ar->data_lock);
5191
5192 ret = ath10k_hif_power_up(ar, ATH10K_FIRMWARE_MODE_NORMAL);
5193 if (ret) {
5194 ath10k_err(ar, "Could not init hif: %d\n", ret);
5195 goto err_off;
5196 }
5197
5198 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL,
5199 &ar->normal_mode_fw);
5200 if (ret) {
5201 ath10k_err(ar, "Could not init core: %d\n", ret);
5202 goto err_power_down;
5203 }
5204
5205 if (ar->sys_cap_info & WMI_TLV_SYS_CAP_INFO_RFKILL) {
5206 ret = ath10k_mac_rfkill_config(ar);
5207 if (ret && ret != -EOPNOTSUPP) {
5208 ath10k_warn(ar, "failed to configure rfkill: %d", ret);
5209 goto err_core_stop;
5210 }
5211 }
5212
5213 param = ar->wmi.pdev_param->pmf_qos;
5214 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5215 if (ret) {
5216 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
5217 goto err_core_stop;
5218 }
5219
5220 param = ar->wmi.pdev_param->dynamic_bw;
5221 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5222 if (ret) {
5223 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
5224 goto err_core_stop;
5225 }
5226
5227 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) {
5228 ret = ath10k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
5229 if (ret) {
5230 ath10k_err(ar, "failed to set prob req oui: %i\n", ret);
5231 goto err_core_stop;
5232 }
5233 }
5234
5235 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
5236 ret = ath10k_wmi_adaptive_qcs(ar, true);
5237 if (ret) {
5238 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
5239 ret);
5240 goto err_core_stop;
5241 }
5242 }
5243
5244 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
5245 param = ar->wmi.pdev_param->burst_enable;
5246 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
5247 if (ret) {
5248 ath10k_warn(ar, "failed to disable burst: %d\n", ret);
5249 goto err_core_stop;
5250 }
5251 }
5252
5253 param = ar->wmi.pdev_param->idle_ps_config;
5254 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5255 if (ret && ret != -EOPNOTSUPP) {
5256 ath10k_warn(ar, "failed to enable idle_ps_config: %d\n", ret);
5257 goto err_core_stop;
5258 }
5259
5260 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5261
5262 /*
5263 * By default FW set ARP frames ac to voice (6). In that case ARP
5264 * exchange is not working properly for UAPSD enabled AP. ARP requests
5265 * which arrives with access category 0 are processed by network stack
5266 * and send back with access category 0, but FW changes access category
5267 * to 6. Set ARP frames access category to best effort (0) solves
5268 * this problem.
5269 */
5270
5271 param = ar->wmi.pdev_param->arp_ac_override;
5272 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
5273 if (ret) {
5274 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
5275 ret);
5276 goto err_core_stop;
5277 }
5278
5279 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
5280 ar->running_fw->fw_file.fw_features)) {
5281 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
5282 WMI_CCA_DETECT_LEVEL_AUTO,
5283 WMI_CCA_DETECT_MARGIN_AUTO);
5284 if (ret) {
5285 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
5286 ret);
5287 goto err_core_stop;
5288 }
5289 }
5290
5291 param = ar->wmi.pdev_param->ani_enable;
5292 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5293 if (ret) {
5294 ath10k_warn(ar, "failed to enable ani by default: %d\n",
5295 ret);
5296 goto err_core_stop;
5297 }
5298
5299 ar->ani_enabled = true;
5300
5301 if (ath10k_peer_stats_enabled(ar)) {
5302 param = ar->wmi.pdev_param->peer_stats_update_period;
5303 ret = ath10k_wmi_pdev_set_param(ar, param,
5304 PEER_DEFAULT_STATS_UPDATE_PERIOD);
5305 if (ret) {
5306 ath10k_warn(ar,
5307 "failed to set peer stats period : %d\n",
5308 ret);
5309 goto err_core_stop;
5310 }
5311 }
5312
5313 param = ar->wmi.pdev_param->enable_btcoex;
5314 if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map) &&
5315 test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
5316 ar->running_fw->fw_file.fw_features) &&
5317 ar->coex_support) {
5318 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
5319 if (ret) {
5320 ath10k_warn(ar,
5321 "failed to set btcoex param: %d\n", ret);
5322 goto err_core_stop;
5323 }
5324 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
5325 }
5326
5327 if (test_bit(WMI_SERVICE_BB_TIMING_CONFIG_SUPPORT, ar->wmi.svc_map)) {
5328 ret = __ath10k_fetch_bb_timing_dt(ar, &bb_timing);
5329 if (!ret) {
5330 ret = ath10k_wmi_pdev_bb_timing(ar, &bb_timing);
5331 if (ret) {
5332 ath10k_warn(ar,
5333 "failed to set bb timings: %d\n",
5334 ret);
5335 goto err_core_stop;
5336 }
5337 }
5338 }
5339
5340 ar->num_started_vdevs = 0;
5341 ath10k_regd_update(ar);
5342
5343 ath10k_spectral_start(ar);
5344 ath10k_thermal_set_throttling(ar);
5345
5346 ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_IDLE;
5347
5348 mutex_unlock(&ar->conf_mutex);
5349 return 0;
5350
5351 err_core_stop:
5352 ath10k_core_stop(ar);
5353
5354 err_power_down:
5355 ath10k_hif_power_down(ar);
5356
5357 err_off:
5358 ar->state = ATH10K_STATE_OFF;
5359
5360 err:
5361 mutex_unlock(&ar->conf_mutex);
5362 return ret;
5363 }
5364
ath10k_stop(struct ieee80211_hw * hw)5365 static void ath10k_stop(struct ieee80211_hw *hw)
5366 {
5367 struct ath10k *ar = hw->priv;
5368 u32 opt;
5369
5370 ath10k_drain_tx(ar);
5371
5372 mutex_lock(&ar->conf_mutex);
5373 if (ar->state != ATH10K_STATE_OFF) {
5374 if (!ar->hw_rfkill_on) {
5375 /* If the current driver state is RESTARTING but not yet
5376 * fully RESTARTED because of incoming suspend event,
5377 * then ath10k_halt() is already called via
5378 * ath10k_core_restart() and should not be called here.
5379 */
5380 if (ar->state != ATH10K_STATE_RESTARTING) {
5381 ath10k_halt(ar);
5382 } else {
5383 /* Suspending here, because when in RESTARTING
5384 * state, ath10k_core_stop() skips
5385 * ath10k_wait_for_suspend().
5386 */
5387 opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;
5388 ath10k_wait_for_suspend(ar, opt);
5389 }
5390 }
5391 ar->state = ATH10K_STATE_OFF;
5392 }
5393 mutex_unlock(&ar->conf_mutex);
5394
5395 cancel_work_sync(&ar->set_coverage_class_work);
5396 cancel_delayed_work_sync(&ar->scan.timeout);
5397 cancel_work_sync(&ar->restart_work);
5398 }
5399
ath10k_config_ps(struct ath10k * ar)5400 static int ath10k_config_ps(struct ath10k *ar)
5401 {
5402 struct ath10k_vif *arvif;
5403 int ret = 0;
5404
5405 lockdep_assert_held(&ar->conf_mutex);
5406
5407 list_for_each_entry(arvif, &ar->arvifs, list) {
5408 ret = ath10k_mac_vif_setup_ps(arvif);
5409 if (ret) {
5410 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
5411 break;
5412 }
5413 }
5414
5415 return ret;
5416 }
5417
ath10k_config(struct ieee80211_hw * hw,u32 changed)5418 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
5419 {
5420 struct ath10k *ar = hw->priv;
5421 struct ieee80211_conf *conf = &hw->conf;
5422 int ret = 0;
5423
5424 mutex_lock(&ar->conf_mutex);
5425
5426 if (changed & IEEE80211_CONF_CHANGE_PS)
5427 ath10k_config_ps(ar);
5428
5429 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
5430 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
5431 ret = ath10k_monitor_recalc(ar);
5432 if (ret)
5433 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5434 }
5435
5436 mutex_unlock(&ar->conf_mutex);
5437 return ret;
5438 }
5439
get_nss_from_chainmask(u16 chain_mask)5440 static u32 get_nss_from_chainmask(u16 chain_mask)
5441 {
5442 if ((chain_mask & 0xf) == 0xf)
5443 return 4;
5444 else if ((chain_mask & 0x7) == 0x7)
5445 return 3;
5446 else if ((chain_mask & 0x3) == 0x3)
5447 return 2;
5448 return 1;
5449 }
5450
ath10k_mac_set_txbf_conf(struct ath10k_vif * arvif)5451 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
5452 {
5453 u32 value = 0;
5454 struct ath10k *ar = arvif->ar;
5455 int nsts;
5456 int sound_dim;
5457
5458 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
5459 return 0;
5460
5461 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
5462 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
5463 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
5464 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
5465
5466 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
5467 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
5468 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
5469 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
5470
5471 if (!value)
5472 return 0;
5473
5474 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
5475 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
5476
5477 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
5478 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
5479 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
5480
5481 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
5482 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
5483
5484 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
5485 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
5486 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
5487
5488 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
5489 ar->wmi.vdev_param->txbf, value);
5490 }
5491
ath10k_update_vif_offload(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5492 static void ath10k_update_vif_offload(struct ieee80211_hw *hw,
5493 struct ieee80211_vif *vif)
5494 {
5495 struct ath10k_vif *arvif = (void *)vif->drv_priv;
5496 struct ath10k *ar = hw->priv;
5497 u32 vdev_param;
5498 int ret;
5499
5500 if (ath10k_frame_mode != ATH10K_HW_TXRX_ETHERNET ||
5501 ar->wmi.vdev_param->tx_encap_type == WMI_VDEV_PARAM_UNSUPPORTED ||
5502 (vif->type != NL80211_IFTYPE_STATION &&
5503 vif->type != NL80211_IFTYPE_AP))
5504 vif->offload_flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
5505
5506 vdev_param = ar->wmi.vdev_param->tx_encap_type;
5507 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5508 ATH10K_HW_TXRX_NATIVE_WIFI);
5509 /* 10.X firmware does not support this VDEV parameter. Do not warn */
5510 if (ret && ret != -EOPNOTSUPP) {
5511 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
5512 arvif->vdev_id, ret);
5513 }
5514 }
5515
5516 /*
5517 * TODO:
5518 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
5519 * because we will send mgmt frames without CCK. This requirement
5520 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
5521 * in the TX packet.
5522 */
ath10k_add_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5523 static int ath10k_add_interface(struct ieee80211_hw *hw,
5524 struct ieee80211_vif *vif)
5525 {
5526 struct ath10k *ar = hw->priv;
5527 struct ath10k_vif *arvif = (void *)vif->drv_priv;
5528 struct ath10k_peer *peer;
5529 enum wmi_sta_powersave_param param;
5530 int ret = 0;
5531 u32 value;
5532 int bit;
5533 int i;
5534 u32 vdev_param;
5535
5536 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
5537
5538 mutex_lock(&ar->conf_mutex);
5539
5540 memset(arvif, 0, sizeof(*arvif));
5541 ath10k_mac_txq_init(vif->txq);
5542
5543 arvif->ar = ar;
5544 arvif->vif = vif;
5545
5546 INIT_LIST_HEAD(&arvif->list);
5547 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
5548 INIT_DELAYED_WORK(&arvif->connection_loss_work,
5549 ath10k_mac_vif_sta_connection_loss_work);
5550
5551 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
5552 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
5553 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
5554 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
5555 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
5556 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
5557 }
5558
5559 if (ar->num_peers >= ar->max_num_peers) {
5560 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
5561 ret = -ENOBUFS;
5562 goto err;
5563 }
5564
5565 if (ar->free_vdev_map == 0) {
5566 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
5567 ret = -EBUSY;
5568 goto err;
5569 }
5570 bit = __ffs64(ar->free_vdev_map);
5571
5572 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
5573 bit, ar->free_vdev_map);
5574
5575 arvif->vdev_id = bit;
5576 arvif->vdev_subtype =
5577 ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE);
5578
5579 switch (vif->type) {
5580 case NL80211_IFTYPE_P2P_DEVICE:
5581 arvif->vdev_type = WMI_VDEV_TYPE_STA;
5582 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5583 (ar, WMI_VDEV_SUBTYPE_P2P_DEVICE);
5584 break;
5585 case NL80211_IFTYPE_UNSPECIFIED:
5586 case NL80211_IFTYPE_STATION:
5587 arvif->vdev_type = WMI_VDEV_TYPE_STA;
5588 if (vif->p2p)
5589 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5590 (ar, WMI_VDEV_SUBTYPE_P2P_CLIENT);
5591 break;
5592 case NL80211_IFTYPE_ADHOC:
5593 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
5594 break;
5595 case NL80211_IFTYPE_MESH_POINT:
5596 if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) {
5597 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5598 (ar, WMI_VDEV_SUBTYPE_MESH_11S);
5599 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
5600 ret = -EINVAL;
5601 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
5602 goto err;
5603 }
5604 arvif->vdev_type = WMI_VDEV_TYPE_AP;
5605 break;
5606 case NL80211_IFTYPE_AP:
5607 arvif->vdev_type = WMI_VDEV_TYPE_AP;
5608
5609 if (vif->p2p)
5610 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5611 (ar, WMI_VDEV_SUBTYPE_P2P_GO);
5612 break;
5613 case NL80211_IFTYPE_MONITOR:
5614 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
5615 break;
5616 default:
5617 WARN_ON(1);
5618 break;
5619 }
5620
5621 /* Using vdev_id as queue number will make it very easy to do per-vif
5622 * tx queue locking. This shouldn't wrap due to interface combinations
5623 * but do a modulo for correctness sake and prevent using offchannel tx
5624 * queues for regular vif tx.
5625 */
5626 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
5627 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
5628 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
5629
5630 /* Some firmware revisions don't wait for beacon tx completion before
5631 * sending another SWBA event. This could lead to hardware using old
5632 * (freed) beacon data in some cases, e.g. tx credit starvation
5633 * combined with missed TBTT. This is very rare.
5634 *
5635 * On non-IOMMU-enabled hosts this could be a possible security issue
5636 * because hw could beacon some random data on the air. On
5637 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
5638 * device would crash.
5639 *
5640 * Since there are no beacon tx completions (implicit nor explicit)
5641 * propagated to host the only workaround for this is to allocate a
5642 * DMA-coherent buffer for a lifetime of a vif and use it for all
5643 * beacon tx commands. Worst case for this approach is some beacons may
5644 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
5645 */
5646 if (vif->type == NL80211_IFTYPE_ADHOC ||
5647 vif->type == NL80211_IFTYPE_MESH_POINT ||
5648 vif->type == NL80211_IFTYPE_AP) {
5649 if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL) {
5650 arvif->beacon_buf = kmalloc(IEEE80211_MAX_FRAME_LEN,
5651 GFP_KERNEL);
5652
5653 /* Using a kernel pointer in place of a dma_addr_t
5654 * token can lead to undefined behavior if that
5655 * makes it into cache management functions. Use a
5656 * known-invalid address token instead, which
5657 * avoids the warning and makes it easier to catch
5658 * bugs if it does end up getting used.
5659 */
5660 arvif->beacon_paddr = DMA_MAPPING_ERROR;
5661 } else {
5662 arvif->beacon_buf =
5663 dma_alloc_coherent(ar->dev,
5664 IEEE80211_MAX_FRAME_LEN,
5665 &arvif->beacon_paddr,
5666 GFP_ATOMIC);
5667 }
5668 if (!arvif->beacon_buf) {
5669 ret = -ENOMEM;
5670 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
5671 ret);
5672 goto err;
5673 }
5674 }
5675 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
5676 arvif->nohwcrypt = true;
5677
5678 if (arvif->nohwcrypt &&
5679 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
5680 ret = -EINVAL;
5681 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
5682 goto err;
5683 }
5684
5685 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
5686 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
5687 arvif->beacon_buf ? "single-buf" : "per-skb");
5688
5689 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
5690 arvif->vdev_subtype, vif->addr);
5691 if (ret) {
5692 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
5693 arvif->vdev_id, ret);
5694 goto err;
5695 }
5696
5697 if (test_bit(WMI_SERVICE_VDEV_DISABLE_4_ADDR_SRC_LRN_SUPPORT,
5698 ar->wmi.svc_map)) {
5699 vdev_param = ar->wmi.vdev_param->disable_4addr_src_lrn;
5700 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5701 WMI_VDEV_DISABLE_4_ADDR_SRC_LRN);
5702 if (ret && ret != -EOPNOTSUPP) {
5703 ath10k_warn(ar, "failed to disable 4addr src lrn vdev %i: %d\n",
5704 arvif->vdev_id, ret);
5705 }
5706 }
5707
5708 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
5709 spin_lock_bh(&ar->data_lock);
5710 list_add(&arvif->list, &ar->arvifs);
5711 spin_unlock_bh(&ar->data_lock);
5712
5713 /* It makes no sense to have firmware do keepalives. mac80211 already
5714 * takes care of this with idle connection polling.
5715 */
5716 ret = ath10k_mac_vif_disable_keepalive(arvif);
5717 if (ret) {
5718 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
5719 arvif->vdev_id, ret);
5720 goto err_vdev_delete;
5721 }
5722
5723 arvif->def_wep_key_idx = -1;
5724
5725 ath10k_update_vif_offload(hw, vif);
5726
5727 /* Configuring number of spatial stream for monitor interface is causing
5728 * target assert in qca9888 and qca6174.
5729 */
5730 if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) {
5731 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
5732
5733 vdev_param = ar->wmi.vdev_param->nss;
5734 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5735 nss);
5736 if (ret) {
5737 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
5738 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
5739 ret);
5740 goto err_vdev_delete;
5741 }
5742 }
5743
5744 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5745 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5746 ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id,
5747 vif->addr, WMI_PEER_TYPE_DEFAULT);
5748 if (ret) {
5749 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
5750 arvif->vdev_id, ret);
5751 goto err_vdev_delete;
5752 }
5753
5754 spin_lock_bh(&ar->data_lock);
5755
5756 peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr);
5757 if (!peer) {
5758 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
5759 vif->addr, arvif->vdev_id);
5760 spin_unlock_bh(&ar->data_lock);
5761 ret = -ENOENT;
5762 goto err_peer_delete;
5763 }
5764
5765 arvif->peer_id = find_first_bit(peer->peer_ids,
5766 ATH10K_MAX_NUM_PEER_IDS);
5767
5768 spin_unlock_bh(&ar->data_lock);
5769 } else {
5770 arvif->peer_id = HTT_INVALID_PEERID;
5771 }
5772
5773 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
5774 ret = ath10k_mac_set_kickout(arvif);
5775 if (ret) {
5776 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
5777 arvif->vdev_id, ret);
5778 goto err_peer_delete;
5779 }
5780 }
5781
5782 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
5783 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
5784 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5785 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5786 param, value);
5787 if (ret) {
5788 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
5789 arvif->vdev_id, ret);
5790 goto err_peer_delete;
5791 }
5792
5793 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5794 if (ret) {
5795 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5796 arvif->vdev_id, ret);
5797 goto err_peer_delete;
5798 }
5799
5800 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5801 if (ret) {
5802 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5803 arvif->vdev_id, ret);
5804 goto err_peer_delete;
5805 }
5806 }
5807
5808 ret = ath10k_mac_set_txbf_conf(arvif);
5809 if (ret) {
5810 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
5811 arvif->vdev_id, ret);
5812 goto err_peer_delete;
5813 }
5814
5815 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
5816 if (ret) {
5817 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5818 arvif->vdev_id, ret);
5819 goto err_peer_delete;
5820 }
5821
5822 arvif->txpower = vif->bss_conf.txpower;
5823 ret = ath10k_mac_txpower_recalc(ar);
5824 if (ret) {
5825 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
5826 goto err_peer_delete;
5827 }
5828
5829 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) {
5830 vdev_param = ar->wmi.vdev_param->rtt_responder_role;
5831 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5832 arvif->ftm_responder);
5833
5834 /* It is harmless to not set FTM role. Do not warn */
5835 if (ret && ret != -EOPNOTSUPP)
5836 ath10k_warn(ar, "failed to set vdev %i FTM Responder: %d\n",
5837 arvif->vdev_id, ret);
5838 }
5839
5840 if (vif->type == NL80211_IFTYPE_MONITOR) {
5841 ar->monitor_arvif = arvif;
5842 ret = ath10k_monitor_recalc(ar);
5843 if (ret) {
5844 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5845 goto err_peer_delete;
5846 }
5847 }
5848
5849 spin_lock_bh(&ar->htt.tx_lock);
5850 if (!ar->tx_paused)
5851 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
5852 spin_unlock_bh(&ar->htt.tx_lock);
5853
5854 mutex_unlock(&ar->conf_mutex);
5855 return 0;
5856
5857 err_peer_delete:
5858 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5859 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5860 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
5861 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id,
5862 vif->addr);
5863 }
5864
5865 err_vdev_delete:
5866 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
5867 ar->free_vdev_map |= 1LL << arvif->vdev_id;
5868 spin_lock_bh(&ar->data_lock);
5869 list_del(&arvif->list);
5870 spin_unlock_bh(&ar->data_lock);
5871
5872 err:
5873 if (arvif->beacon_buf) {
5874 if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL)
5875 kfree(arvif->beacon_buf);
5876 else
5877 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
5878 arvif->beacon_buf,
5879 arvif->beacon_paddr);
5880 arvif->beacon_buf = NULL;
5881 }
5882
5883 mutex_unlock(&ar->conf_mutex);
5884
5885 return ret;
5886 }
5887
ath10k_mac_vif_tx_unlock_all(struct ath10k_vif * arvif)5888 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
5889 {
5890 int i;
5891
5892 for (i = 0; i < BITS_PER_LONG; i++)
5893 ath10k_mac_vif_tx_unlock(arvif, i);
5894 }
5895
ath10k_remove_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5896 static void ath10k_remove_interface(struct ieee80211_hw *hw,
5897 struct ieee80211_vif *vif)
5898 {
5899 struct ath10k *ar = hw->priv;
5900 struct ath10k_vif *arvif = (void *)vif->drv_priv;
5901 struct ath10k_peer *peer;
5902 unsigned long time_left;
5903 int ret;
5904 int i;
5905
5906 cancel_work_sync(&arvif->ap_csa_work);
5907 cancel_delayed_work_sync(&arvif->connection_loss_work);
5908
5909 mutex_lock(&ar->conf_mutex);
5910
5911 ret = ath10k_spectral_vif_stop(arvif);
5912 if (ret)
5913 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
5914 arvif->vdev_id, ret);
5915
5916 ar->free_vdev_map |= 1LL << arvif->vdev_id;
5917 spin_lock_bh(&ar->data_lock);
5918 list_del(&arvif->list);
5919 spin_unlock_bh(&ar->data_lock);
5920
5921 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5922 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5923 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
5924 vif->addr);
5925 if (ret)
5926 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
5927 arvif->vdev_id, ret);
5928
5929 ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id,
5930 vif->addr);
5931 kfree(arvif->u.ap.noa_data);
5932 }
5933
5934 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
5935 arvif->vdev_id);
5936
5937 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
5938 if (ret)
5939 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
5940 arvif->vdev_id, ret);
5941
5942 if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {
5943 time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
5944 ATH10K_VDEV_DELETE_TIMEOUT_HZ);
5945 if (time_left == 0) {
5946 ath10k_warn(ar, "Timeout in receiving vdev delete response\n");
5947 goto out;
5948 }
5949 }
5950
5951 /* Some firmware revisions don't notify host about self-peer removal
5952 * until after associated vdev is deleted.
5953 */
5954 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5955 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5956 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
5957 vif->addr);
5958 if (ret)
5959 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
5960 arvif->vdev_id, ret);
5961
5962 spin_lock_bh(&ar->data_lock);
5963 ar->num_peers--;
5964 spin_unlock_bh(&ar->data_lock);
5965 }
5966
5967 spin_lock_bh(&ar->data_lock);
5968 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
5969 peer = ar->peer_map[i];
5970 if (!peer)
5971 continue;
5972
5973 if (peer->vif == vif) {
5974 ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n",
5975 vif->addr, arvif->vdev_id);
5976 peer->vif = NULL;
5977 }
5978 }
5979
5980 /* Clean this up late, less opportunity for firmware to access
5981 * DMA memory we have deleted.
5982 */
5983 ath10k_mac_vif_beacon_cleanup(arvif);
5984 spin_unlock_bh(&ar->data_lock);
5985
5986 ath10k_peer_cleanup(ar, arvif->vdev_id);
5987 ath10k_mac_txq_unref(ar, vif->txq);
5988
5989 if (vif->type == NL80211_IFTYPE_MONITOR) {
5990 ar->monitor_arvif = NULL;
5991 ret = ath10k_monitor_recalc(ar);
5992 if (ret)
5993 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5994 }
5995
5996 ret = ath10k_mac_txpower_recalc(ar);
5997 if (ret)
5998 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
5999
6000 spin_lock_bh(&ar->htt.tx_lock);
6001 ath10k_mac_vif_tx_unlock_all(arvif);
6002 spin_unlock_bh(&ar->htt.tx_lock);
6003
6004 ath10k_mac_txq_unref(ar, vif->txq);
6005
6006 out:
6007 mutex_unlock(&ar->conf_mutex);
6008 }
6009
6010 /*
6011 * FIXME: Has to be verified.
6012 */
6013 #define SUPPORTED_FILTERS \
6014 (FIF_ALLMULTI | \
6015 FIF_CONTROL | \
6016 FIF_PSPOLL | \
6017 FIF_OTHER_BSS | \
6018 FIF_BCN_PRBRESP_PROMISC | \
6019 FIF_PROBE_REQ | \
6020 FIF_FCSFAIL)
6021
ath10k_configure_filter(struct ieee80211_hw * hw,unsigned int changed_flags,unsigned int * total_flags,u64 multicast)6022 static void ath10k_configure_filter(struct ieee80211_hw *hw,
6023 unsigned int changed_flags,
6024 unsigned int *total_flags,
6025 u64 multicast)
6026 {
6027 struct ath10k *ar = hw->priv;
6028 int ret;
6029 unsigned int supported = SUPPORTED_FILTERS;
6030
6031 mutex_lock(&ar->conf_mutex);
6032
6033 if (ar->hw_params.mcast_frame_registration)
6034 supported |= FIF_MCAST_ACTION;
6035
6036 *total_flags &= supported;
6037
6038 ar->filter_flags = *total_flags;
6039
6040 ret = ath10k_monitor_recalc(ar);
6041 if (ret)
6042 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
6043
6044 mutex_unlock(&ar->conf_mutex);
6045 }
6046
ath10k_recalculate_mgmt_rate(struct ath10k * ar,struct ieee80211_vif * vif,struct cfg80211_chan_def * def)6047 static void ath10k_recalculate_mgmt_rate(struct ath10k *ar,
6048 struct ieee80211_vif *vif,
6049 struct cfg80211_chan_def *def)
6050 {
6051 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6052 const struct ieee80211_supported_band *sband;
6053 u8 basic_rate_idx;
6054 int hw_rate_code;
6055 u32 vdev_param;
6056 u16 bitrate;
6057 int ret;
6058
6059 lockdep_assert_held(&ar->conf_mutex);
6060
6061 sband = ar->hw->wiphy->bands[def->chan->band];
6062 basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
6063 bitrate = sband->bitrates[basic_rate_idx].bitrate;
6064
6065 hw_rate_code = ath10k_mac_get_rate_hw_value(bitrate);
6066 if (hw_rate_code < 0) {
6067 ath10k_warn(ar, "bitrate not supported %d\n", bitrate);
6068 return;
6069 }
6070
6071 vdev_param = ar->wmi.vdev_param->mgmt_rate;
6072 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6073 hw_rate_code);
6074 if (ret)
6075 ath10k_warn(ar, "failed to set mgmt tx rate %d\n", ret);
6076 }
6077
ath10k_bss_info_changed(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * info,u64 changed)6078 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
6079 struct ieee80211_vif *vif,
6080 struct ieee80211_bss_conf *info,
6081 u64 changed)
6082 {
6083 struct ath10k *ar = hw->priv;
6084 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6085 struct cfg80211_chan_def def;
6086 u32 vdev_param, pdev_param, slottime, preamble;
6087 u16 bitrate, hw_value;
6088 u8 rate, rateidx;
6089 int ret = 0, mcast_rate;
6090 enum nl80211_band band;
6091
6092 mutex_lock(&ar->conf_mutex);
6093
6094 if (changed & BSS_CHANGED_IBSS)
6095 ath10k_control_ibss(arvif, vif);
6096
6097 if (changed & BSS_CHANGED_BEACON_INT) {
6098 arvif->beacon_interval = info->beacon_int;
6099 vdev_param = ar->wmi.vdev_param->beacon_interval;
6100 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6101 arvif->beacon_interval);
6102 ath10k_dbg(ar, ATH10K_DBG_MAC,
6103 "mac vdev %d beacon_interval %d\n",
6104 arvif->vdev_id, arvif->beacon_interval);
6105
6106 if (ret)
6107 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
6108 arvif->vdev_id, ret);
6109 }
6110
6111 if (changed & BSS_CHANGED_BEACON) {
6112 ath10k_dbg(ar, ATH10K_DBG_MAC,
6113 "vdev %d set beacon tx mode to staggered\n",
6114 arvif->vdev_id);
6115
6116 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
6117 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
6118 WMI_BEACON_STAGGERED_MODE);
6119 if (ret)
6120 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
6121 arvif->vdev_id, ret);
6122
6123 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6124 if (ret)
6125 ath10k_warn(ar, "failed to update beacon template: %d\n",
6126 ret);
6127
6128 if (ieee80211_vif_is_mesh(vif)) {
6129 /* mesh doesn't use SSID but firmware needs it */
6130 arvif->u.ap.ssid_len = 4;
6131 memcpy(arvif->u.ap.ssid, "mesh", arvif->u.ap.ssid_len);
6132 }
6133 }
6134
6135 if (changed & BSS_CHANGED_AP_PROBE_RESP) {
6136 ret = ath10k_mac_setup_prb_tmpl(arvif);
6137 if (ret)
6138 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
6139 arvif->vdev_id, ret);
6140 }
6141
6142 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
6143 arvif->dtim_period = info->dtim_period;
6144
6145 ath10k_dbg(ar, ATH10K_DBG_MAC,
6146 "mac vdev %d dtim_period %d\n",
6147 arvif->vdev_id, arvif->dtim_period);
6148
6149 vdev_param = ar->wmi.vdev_param->dtim_period;
6150 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6151 arvif->dtim_period);
6152 if (ret)
6153 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
6154 arvif->vdev_id, ret);
6155 }
6156
6157 if (changed & BSS_CHANGED_SSID &&
6158 vif->type == NL80211_IFTYPE_AP) {
6159 arvif->u.ap.ssid_len = vif->cfg.ssid_len;
6160 if (vif->cfg.ssid_len)
6161 memcpy(arvif->u.ap.ssid, vif->cfg.ssid,
6162 vif->cfg.ssid_len);
6163 arvif->u.ap.hidden_ssid = info->hidden_ssid;
6164 }
6165
6166 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
6167 ether_addr_copy(arvif->bssid, info->bssid);
6168
6169 if (changed & BSS_CHANGED_FTM_RESPONDER &&
6170 arvif->ftm_responder != info->ftm_responder &&
6171 test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) {
6172 arvif->ftm_responder = info->ftm_responder;
6173
6174 vdev_param = ar->wmi.vdev_param->rtt_responder_role;
6175 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6176 arvif->ftm_responder);
6177
6178 ath10k_dbg(ar, ATH10K_DBG_MAC,
6179 "mac vdev %d ftm_responder %d:ret %d\n",
6180 arvif->vdev_id, arvif->ftm_responder, ret);
6181 }
6182
6183 if (changed & BSS_CHANGED_BEACON_ENABLED)
6184 ath10k_control_beaconing(arvif, info);
6185
6186 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
6187 arvif->use_cts_prot = info->use_cts_prot;
6188
6189 ret = ath10k_recalc_rtscts_prot(arvif);
6190 if (ret)
6191 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
6192 arvif->vdev_id, ret);
6193
6194 if (ath10k_mac_can_set_cts_prot(arvif)) {
6195 ret = ath10k_mac_set_cts_prot(arvif);
6196 if (ret)
6197 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n",
6198 arvif->vdev_id, ret);
6199 }
6200 }
6201
6202 if (changed & BSS_CHANGED_ERP_SLOT) {
6203 if (info->use_short_slot)
6204 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
6205
6206 else
6207 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
6208
6209 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
6210 arvif->vdev_id, slottime);
6211
6212 vdev_param = ar->wmi.vdev_param->slot_time;
6213 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6214 slottime);
6215 if (ret)
6216 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
6217 arvif->vdev_id, ret);
6218 }
6219
6220 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
6221 if (info->use_short_preamble)
6222 preamble = WMI_VDEV_PREAMBLE_SHORT;
6223 else
6224 preamble = WMI_VDEV_PREAMBLE_LONG;
6225
6226 ath10k_dbg(ar, ATH10K_DBG_MAC,
6227 "mac vdev %d preamble %dn",
6228 arvif->vdev_id, preamble);
6229
6230 vdev_param = ar->wmi.vdev_param->preamble;
6231 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6232 preamble);
6233 if (ret)
6234 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
6235 arvif->vdev_id, ret);
6236 }
6237
6238 if (changed & BSS_CHANGED_ASSOC) {
6239 if (vif->cfg.assoc) {
6240 /* Workaround: Make sure monitor vdev is not running
6241 * when associating to prevent some firmware revisions
6242 * (e.g. 10.1 and 10.2) from crashing.
6243 */
6244 if (ar->monitor_started)
6245 ath10k_monitor_stop(ar);
6246 ath10k_bss_assoc(hw, vif, info);
6247 ath10k_monitor_recalc(ar);
6248 } else {
6249 ath10k_bss_disassoc(hw, vif);
6250 }
6251 }
6252
6253 if (changed & BSS_CHANGED_TXPOWER) {
6254 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
6255 arvif->vdev_id, info->txpower);
6256
6257 arvif->txpower = info->txpower;
6258 ret = ath10k_mac_txpower_recalc(ar);
6259 if (ret)
6260 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
6261 }
6262
6263 if (changed & BSS_CHANGED_PS) {
6264 arvif->ps = vif->cfg.ps;
6265
6266 ret = ath10k_config_ps(ar);
6267 if (ret)
6268 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
6269 arvif->vdev_id, ret);
6270 }
6271
6272 if (changed & BSS_CHANGED_MCAST_RATE &&
6273 !ath10k_mac_vif_chan(arvif->vif, &def)) {
6274 band = def.chan->band;
6275 mcast_rate = vif->bss_conf.mcast_rate[band];
6276 if (mcast_rate > 0)
6277 rateidx = mcast_rate - 1;
6278 else
6279 rateidx = ffs(vif->bss_conf.basic_rates) - 1;
6280
6281 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)
6282 rateidx += ATH10K_MAC_FIRST_OFDM_RATE_IDX;
6283
6284 bitrate = ath10k_wmi_legacy_rates[rateidx].bitrate;
6285 hw_value = ath10k_wmi_legacy_rates[rateidx].hw_value;
6286 if (ath10k_mac_bitrate_is_cck(bitrate))
6287 preamble = WMI_RATE_PREAMBLE_CCK;
6288 else
6289 preamble = WMI_RATE_PREAMBLE_OFDM;
6290
6291 rate = ATH10K_HW_RATECODE(hw_value, 0, preamble);
6292
6293 ath10k_dbg(ar, ATH10K_DBG_MAC,
6294 "mac vdev %d mcast_rate %x\n",
6295 arvif->vdev_id, rate);
6296
6297 vdev_param = ar->wmi.vdev_param->mcast_data_rate;
6298 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
6299 vdev_param, rate);
6300 if (ret)
6301 ath10k_warn(ar,
6302 "failed to set mcast rate on vdev %i: %d\n",
6303 arvif->vdev_id, ret);
6304
6305 vdev_param = ar->wmi.vdev_param->bcast_data_rate;
6306 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
6307 vdev_param, rate);
6308 if (ret)
6309 ath10k_warn(ar,
6310 "failed to set bcast rate on vdev %i: %d\n",
6311 arvif->vdev_id, ret);
6312 }
6313
6314 if (changed & BSS_CHANGED_BASIC_RATES &&
6315 !ath10k_mac_vif_chan(arvif->vif, &def))
6316 ath10k_recalculate_mgmt_rate(ar, vif, &def);
6317
6318 mutex_unlock(&ar->conf_mutex);
6319 }
6320
ath10k_mac_op_set_coverage_class(struct ieee80211_hw * hw,s16 value)6321 static void ath10k_mac_op_set_coverage_class(struct ieee80211_hw *hw, s16 value)
6322 {
6323 struct ath10k *ar = hw->priv;
6324
6325 /* This function should never be called if setting the coverage class
6326 * is not supported on this hardware.
6327 */
6328 if (!ar->hw_params.hw_ops->set_coverage_class) {
6329 WARN_ON_ONCE(1);
6330 return;
6331 }
6332 ar->hw_params.hw_ops->set_coverage_class(ar, value);
6333 }
6334
6335 struct ath10k_mac_tdls_iter_data {
6336 u32 num_tdls_stations;
6337 struct ieee80211_vif *curr_vif;
6338 };
6339
ath10k_mac_tdls_vif_stations_count_iter(void * data,struct ieee80211_sta * sta)6340 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
6341 struct ieee80211_sta *sta)
6342 {
6343 struct ath10k_mac_tdls_iter_data *iter_data = data;
6344 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6345 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
6346
6347 if (sta->tdls && sta_vif == iter_data->curr_vif)
6348 iter_data->num_tdls_stations++;
6349 }
6350
ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw * hw,struct ieee80211_vif * vif)6351 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
6352 struct ieee80211_vif *vif)
6353 {
6354 struct ath10k_mac_tdls_iter_data data = {};
6355
6356 data.curr_vif = vif;
6357
6358 ieee80211_iterate_stations_atomic(hw,
6359 ath10k_mac_tdls_vif_stations_count_iter,
6360 &data);
6361 return data.num_tdls_stations;
6362 }
6363
ath10k_hw_scan(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_scan_request * hw_req)6364 static int ath10k_hw_scan(struct ieee80211_hw *hw,
6365 struct ieee80211_vif *vif,
6366 struct ieee80211_scan_request *hw_req)
6367 {
6368 struct ath10k *ar = hw->priv;
6369 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6370 struct cfg80211_scan_request *req = &hw_req->req;
6371 struct wmi_start_scan_arg arg;
6372 int ret = 0;
6373 int i;
6374 u32 scan_timeout;
6375
6376 mutex_lock(&ar->conf_mutex);
6377
6378 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) {
6379 ret = -EBUSY;
6380 goto exit;
6381 }
6382
6383 spin_lock_bh(&ar->data_lock);
6384 switch (ar->scan.state) {
6385 case ATH10K_SCAN_IDLE:
6386 reinit_completion(&ar->scan.started);
6387 reinit_completion(&ar->scan.completed);
6388 ar->scan.state = ATH10K_SCAN_STARTING;
6389 ar->scan.is_roc = false;
6390 ar->scan.vdev_id = arvif->vdev_id;
6391 ret = 0;
6392 break;
6393 case ATH10K_SCAN_STARTING:
6394 case ATH10K_SCAN_RUNNING:
6395 case ATH10K_SCAN_ABORTING:
6396 ret = -EBUSY;
6397 break;
6398 }
6399 spin_unlock_bh(&ar->data_lock);
6400
6401 if (ret)
6402 goto exit;
6403
6404 memset(&arg, 0, sizeof(arg));
6405 ath10k_wmi_start_scan_init(ar, &arg);
6406 arg.vdev_id = arvif->vdev_id;
6407 arg.scan_id = ATH10K_SCAN_ID;
6408
6409 if (req->ie_len) {
6410 arg.ie_len = req->ie_len;
6411 memcpy(arg.ie, req->ie, arg.ie_len);
6412 }
6413
6414 if (req->n_ssids) {
6415 arg.n_ssids = req->n_ssids;
6416 for (i = 0; i < arg.n_ssids; i++) {
6417 arg.ssids[i].len = req->ssids[i].ssid_len;
6418 arg.ssids[i].ssid = req->ssids[i].ssid;
6419 }
6420 } else {
6421 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
6422 }
6423
6424 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6425 arg.scan_ctrl_flags |= WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ;
6426 ether_addr_copy(arg.mac_addr.addr, req->mac_addr);
6427 ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask);
6428 }
6429
6430 if (req->n_channels) {
6431 arg.n_channels = req->n_channels;
6432 for (i = 0; i < arg.n_channels; i++)
6433 arg.channels[i] = req->channels[i]->center_freq;
6434 }
6435
6436 /* if duration is set, default dwell times will be overwritten */
6437 if (req->duration) {
6438 arg.dwell_time_active = req->duration;
6439 arg.dwell_time_passive = req->duration;
6440 arg.burst_duration_ms = req->duration;
6441
6442 scan_timeout = min_t(u32, arg.max_rest_time *
6443 (arg.n_channels - 1) + (req->duration +
6444 ATH10K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) *
6445 arg.n_channels, arg.max_scan_time);
6446 } else {
6447 scan_timeout = arg.max_scan_time;
6448 }
6449
6450 /* Add a 200ms margin to account for event/command processing */
6451 scan_timeout += 200;
6452
6453 ret = ath10k_start_scan(ar, &arg);
6454 if (ret) {
6455 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
6456 spin_lock_bh(&ar->data_lock);
6457 ar->scan.state = ATH10K_SCAN_IDLE;
6458 spin_unlock_bh(&ar->data_lock);
6459 }
6460
6461 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
6462 msecs_to_jiffies(scan_timeout));
6463
6464 exit:
6465 mutex_unlock(&ar->conf_mutex);
6466 return ret;
6467 }
6468
ath10k_cancel_hw_scan(struct ieee80211_hw * hw,struct ieee80211_vif * vif)6469 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
6470 struct ieee80211_vif *vif)
6471 {
6472 struct ath10k *ar = hw->priv;
6473
6474 mutex_lock(&ar->conf_mutex);
6475 ath10k_scan_abort(ar);
6476 mutex_unlock(&ar->conf_mutex);
6477
6478 cancel_delayed_work_sync(&ar->scan.timeout);
6479 }
6480
ath10k_set_key_h_def_keyidx(struct ath10k * ar,struct ath10k_vif * arvif,enum set_key_cmd cmd,struct ieee80211_key_conf * key)6481 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
6482 struct ath10k_vif *arvif,
6483 enum set_key_cmd cmd,
6484 struct ieee80211_key_conf *key)
6485 {
6486 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
6487 int ret;
6488
6489 /* 10.1 firmware branch requires default key index to be set to group
6490 * key index after installing it. Otherwise FW/HW Txes corrupted
6491 * frames with multi-vif APs. This is not required for main firmware
6492 * branch (e.g. 636).
6493 *
6494 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
6495 *
6496 * FIXME: It remains unknown if this is required for multi-vif STA
6497 * interfaces on 10.1.
6498 */
6499
6500 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
6501 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
6502 return;
6503
6504 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
6505 return;
6506
6507 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
6508 return;
6509
6510 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
6511 return;
6512
6513 if (cmd != SET_KEY)
6514 return;
6515
6516 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6517 key->keyidx);
6518 if (ret)
6519 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
6520 arvif->vdev_id, ret);
6521 }
6522
ath10k_set_key(struct ieee80211_hw * hw,enum set_key_cmd cmd,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key)6523 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
6524 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
6525 struct ieee80211_key_conf *key)
6526 {
6527 struct ath10k *ar = hw->priv;
6528 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6529 struct ath10k_sta *arsta;
6530 struct ath10k_peer *peer;
6531 const u8 *peer_addr;
6532 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
6533 key->cipher == WLAN_CIPHER_SUITE_WEP104;
6534 int ret = 0;
6535 int ret2;
6536 u32 flags = 0;
6537 u32 flags2;
6538
6539 /* this one needs to be done in software */
6540 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
6541 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
6542 key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
6543 key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
6544 return 1;
6545
6546 if (arvif->nohwcrypt)
6547 return 1;
6548
6549 if (key->keyidx > WMI_MAX_KEY_INDEX)
6550 return -ENOSPC;
6551
6552 mutex_lock(&ar->conf_mutex);
6553
6554 if (sta) {
6555 arsta = (struct ath10k_sta *)sta->drv_priv;
6556 peer_addr = sta->addr;
6557 spin_lock_bh(&ar->data_lock);
6558 arsta->ucast_cipher = key->cipher;
6559 spin_unlock_bh(&ar->data_lock);
6560 } else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
6561 peer_addr = vif->bss_conf.bssid;
6562 } else {
6563 peer_addr = vif->addr;
6564 }
6565
6566 key->hw_key_idx = key->keyidx;
6567
6568 if (is_wep) {
6569 if (cmd == SET_KEY)
6570 arvif->wep_keys[key->keyidx] = key;
6571 else
6572 arvif->wep_keys[key->keyidx] = NULL;
6573 }
6574
6575 /* the peer should not disappear in mid-way (unless FW goes awry) since
6576 * we already hold conf_mutex. we just make sure its there now.
6577 */
6578 spin_lock_bh(&ar->data_lock);
6579 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
6580 spin_unlock_bh(&ar->data_lock);
6581
6582 if (!peer) {
6583 if (cmd == SET_KEY) {
6584 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
6585 peer_addr);
6586 ret = -EOPNOTSUPP;
6587 goto exit;
6588 } else {
6589 /* if the peer doesn't exist there is no key to disable anymore */
6590 goto exit;
6591 }
6592 }
6593
6594 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
6595 flags |= WMI_KEY_PAIRWISE;
6596 else
6597 flags |= WMI_KEY_GROUP;
6598
6599 if (is_wep) {
6600 if (cmd == DISABLE_KEY)
6601 ath10k_clear_vdev_key(arvif, key);
6602
6603 /* When WEP keys are uploaded it's possible that there are
6604 * stations associated already (e.g. when merging) without any
6605 * keys. Static WEP needs an explicit per-peer key upload.
6606 */
6607 if (vif->type == NL80211_IFTYPE_ADHOC &&
6608 cmd == SET_KEY)
6609 ath10k_mac_vif_update_wep_key(arvif, key);
6610
6611 /* 802.1x never sets the def_wep_key_idx so each set_key()
6612 * call changes default tx key.
6613 *
6614 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
6615 * after first set_key().
6616 */
6617 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
6618 flags |= WMI_KEY_TX_USAGE;
6619 }
6620
6621 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
6622 if (ret) {
6623 WARN_ON(ret > 0);
6624 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
6625 arvif->vdev_id, peer_addr, ret);
6626 goto exit;
6627 }
6628
6629 /* mac80211 sets static WEP keys as groupwise while firmware requires
6630 * them to be installed twice as both pairwise and groupwise.
6631 */
6632 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
6633 flags2 = flags;
6634 flags2 &= ~WMI_KEY_GROUP;
6635 flags2 |= WMI_KEY_PAIRWISE;
6636
6637 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
6638 if (ret) {
6639 WARN_ON(ret > 0);
6640 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
6641 arvif->vdev_id, peer_addr, ret);
6642 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
6643 peer_addr, flags);
6644 if (ret2) {
6645 WARN_ON(ret2 > 0);
6646 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
6647 arvif->vdev_id, peer_addr, ret2);
6648 }
6649 goto exit;
6650 }
6651 }
6652
6653 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
6654
6655 spin_lock_bh(&ar->data_lock);
6656 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
6657 if (peer && cmd == SET_KEY)
6658 peer->keys[key->keyidx] = key;
6659 else if (peer && cmd == DISABLE_KEY)
6660 peer->keys[key->keyidx] = NULL;
6661 else if (peer == NULL)
6662 /* impossible unless FW goes crazy */
6663 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
6664 spin_unlock_bh(&ar->data_lock);
6665
6666 if (sta && sta->tdls)
6667 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6668 ar->wmi.peer_param->authorize, 1);
6669 else if (sta && cmd == SET_KEY && (key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
6670 ath10k_wmi_peer_set_param(ar, arvif->vdev_id, peer_addr,
6671 ar->wmi.peer_param->authorize, 1);
6672
6673 exit:
6674 mutex_unlock(&ar->conf_mutex);
6675 return ret;
6676 }
6677
ath10k_set_default_unicast_key(struct ieee80211_hw * hw,struct ieee80211_vif * vif,int keyidx)6678 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
6679 struct ieee80211_vif *vif,
6680 int keyidx)
6681 {
6682 struct ath10k *ar = hw->priv;
6683 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6684 int ret;
6685
6686 mutex_lock(&arvif->ar->conf_mutex);
6687
6688 if (arvif->ar->state != ATH10K_STATE_ON)
6689 goto unlock;
6690
6691 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
6692 arvif->vdev_id, keyidx);
6693
6694 ret = ath10k_wmi_vdev_set_param(arvif->ar,
6695 arvif->vdev_id,
6696 arvif->ar->wmi.vdev_param->def_keyid,
6697 keyidx);
6698
6699 if (ret) {
6700 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
6701 arvif->vdev_id,
6702 ret);
6703 goto unlock;
6704 }
6705
6706 arvif->def_wep_key_idx = keyidx;
6707
6708 unlock:
6709 mutex_unlock(&arvif->ar->conf_mutex);
6710 }
6711
ath10k_sta_rc_update_wk(struct work_struct * wk)6712 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
6713 {
6714 struct ath10k *ar;
6715 struct ath10k_vif *arvif;
6716 struct ath10k_sta *arsta;
6717 struct ieee80211_sta *sta;
6718 struct cfg80211_chan_def def;
6719 enum nl80211_band band;
6720 const u8 *ht_mcs_mask;
6721 const u16 *vht_mcs_mask;
6722 u32 changed, bw, nss, smps;
6723 int err;
6724
6725 arsta = container_of(wk, struct ath10k_sta, update_wk);
6726 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
6727 arvif = arsta->arvif;
6728 ar = arvif->ar;
6729
6730 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
6731 return;
6732
6733 band = def.chan->band;
6734 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
6735 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
6736
6737 spin_lock_bh(&ar->data_lock);
6738
6739 changed = arsta->changed;
6740 arsta->changed = 0;
6741
6742 bw = arsta->bw;
6743 nss = arsta->nss;
6744 smps = arsta->smps;
6745
6746 spin_unlock_bh(&ar->data_lock);
6747
6748 mutex_lock(&ar->conf_mutex);
6749
6750 nss = max_t(u32, 1, nss);
6751 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6752 ath10k_mac_max_vht_nss(vht_mcs_mask)));
6753
6754 if (changed & IEEE80211_RC_BW_CHANGED) {
6755 enum wmi_phy_mode mode;
6756
6757 mode = chan_to_phymode(&def);
6758 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM peer bw %d phymode %d\n",
6759 sta->addr, bw, mode);
6760
6761 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6762 ar->wmi.peer_param->phymode, mode);
6763 if (err) {
6764 ath10k_warn(ar, "failed to update STA %pM peer phymode %d: %d\n",
6765 sta->addr, mode, err);
6766 goto exit;
6767 }
6768
6769 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6770 ar->wmi.peer_param->chan_width, bw);
6771 if (err)
6772 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
6773 sta->addr, bw, err);
6774 }
6775
6776 if (changed & IEEE80211_RC_NSS_CHANGED) {
6777 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM nss %d\n",
6778 sta->addr, nss);
6779
6780 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6781 ar->wmi.peer_param->nss, nss);
6782 if (err)
6783 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
6784 sta->addr, nss, err);
6785 }
6786
6787 if (changed & IEEE80211_RC_SMPS_CHANGED) {
6788 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM smps %d\n",
6789 sta->addr, smps);
6790
6791 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6792 ar->wmi.peer_param->smps_state, smps);
6793 if (err)
6794 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
6795 sta->addr, smps, err);
6796 }
6797
6798 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
6799 ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM supp rates\n",
6800 sta->addr);
6801
6802 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
6803 if (err)
6804 ath10k_warn(ar, "failed to reassociate station: %pM\n",
6805 sta->addr);
6806 }
6807
6808 exit:
6809 mutex_unlock(&ar->conf_mutex);
6810 }
6811
ath10k_mac_inc_num_stations(struct ath10k_vif * arvif,struct ieee80211_sta * sta)6812 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
6813 struct ieee80211_sta *sta)
6814 {
6815 struct ath10k *ar = arvif->ar;
6816
6817 lockdep_assert_held(&ar->conf_mutex);
6818
6819 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
6820 return 0;
6821
6822 if (ar->num_stations >= ar->max_num_stations)
6823 return -ENOBUFS;
6824
6825 ar->num_stations++;
6826
6827 return 0;
6828 }
6829
ath10k_mac_dec_num_stations(struct ath10k_vif * arvif,struct ieee80211_sta * sta)6830 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
6831 struct ieee80211_sta *sta)
6832 {
6833 struct ath10k *ar = arvif->ar;
6834
6835 lockdep_assert_held(&ar->conf_mutex);
6836
6837 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
6838 return;
6839
6840 ar->num_stations--;
6841 }
6842
ath10k_sta_set_txpwr(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)6843 static int ath10k_sta_set_txpwr(struct ieee80211_hw *hw,
6844 struct ieee80211_vif *vif,
6845 struct ieee80211_sta *sta)
6846 {
6847 struct ath10k *ar = hw->priv;
6848 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6849 int ret = 0;
6850 s16 txpwr;
6851
6852 if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
6853 txpwr = 0;
6854 } else {
6855 txpwr = sta->deflink.txpwr.power;
6856 if (!txpwr)
6857 return -EINVAL;
6858 }
6859
6860 if (txpwr > ATH10K_TX_POWER_MAX_VAL || txpwr < ATH10K_TX_POWER_MIN_VAL)
6861 return -EINVAL;
6862
6863 mutex_lock(&ar->conf_mutex);
6864
6865 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6866 ar->wmi.peer_param->use_fixed_power, txpwr);
6867 if (ret) {
6868 ath10k_warn(ar, "failed to set tx power for station ret: %d\n",
6869 ret);
6870 goto out;
6871 }
6872
6873 out:
6874 mutex_unlock(&ar->conf_mutex);
6875 return ret;
6876 }
6877
6878 struct ath10k_mac_iter_tid_conf_data {
6879 struct ieee80211_vif *curr_vif;
6880 struct ath10k *ar;
6881 bool reset_config;
6882 };
6883
6884 static bool
ath10k_mac_bitrate_mask_has_single_rate(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,int * vht_num_rates)6885 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
6886 enum nl80211_band band,
6887 const struct cfg80211_bitrate_mask *mask,
6888 int *vht_num_rates)
6889 {
6890 int num_rates = 0;
6891 int i, tmp;
6892
6893 num_rates += hweight32(mask->control[band].legacy);
6894
6895 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6896 num_rates += hweight8(mask->control[band].ht_mcs[i]);
6897
6898 *vht_num_rates = 0;
6899 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6900 tmp = hweight16(mask->control[band].vht_mcs[i]);
6901 num_rates += tmp;
6902 *vht_num_rates += tmp;
6903 }
6904
6905 return num_rates == 1;
6906 }
6907
6908 static int
ath10k_mac_bitrate_mask_get_single_rate(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,u8 * rate,u8 * nss,bool vht_only)6909 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6910 enum nl80211_band band,
6911 const struct cfg80211_bitrate_mask *mask,
6912 u8 *rate, u8 *nss, bool vht_only)
6913 {
6914 int rate_idx;
6915 int i;
6916 u16 bitrate;
6917 u8 preamble;
6918 u8 hw_rate;
6919
6920 if (vht_only)
6921 goto next;
6922
6923 if (hweight32(mask->control[band].legacy) == 1) {
6924 rate_idx = ffs(mask->control[band].legacy) - 1;
6925
6926 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)
6927 rate_idx += ATH10K_MAC_FIRST_OFDM_RATE_IDX;
6928
6929 hw_rate = ath10k_wmi_legacy_rates[rate_idx].hw_value;
6930 bitrate = ath10k_wmi_legacy_rates[rate_idx].bitrate;
6931
6932 if (ath10k_mac_bitrate_is_cck(bitrate))
6933 preamble = WMI_RATE_PREAMBLE_CCK;
6934 else
6935 preamble = WMI_RATE_PREAMBLE_OFDM;
6936
6937 *nss = 1;
6938 *rate = preamble << 6 |
6939 (*nss - 1) << 4 |
6940 hw_rate << 0;
6941
6942 return 0;
6943 }
6944
6945 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6946 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6947 *nss = i + 1;
6948 *rate = WMI_RATE_PREAMBLE_HT << 6 |
6949 (*nss - 1) << 4 |
6950 (ffs(mask->control[band].ht_mcs[i]) - 1);
6951
6952 return 0;
6953 }
6954 }
6955
6956 next:
6957 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6958 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6959 *nss = i + 1;
6960 *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6961 (*nss - 1) << 4 |
6962 (ffs(mask->control[band].vht_mcs[i]) - 1);
6963
6964 return 0;
6965 }
6966 }
6967
6968 return -EINVAL;
6969 }
6970
ath10k_mac_validate_rate_mask(struct ath10k * ar,struct ieee80211_sta * sta,u32 rate_ctrl_flag,u8 nss)6971 static int ath10k_mac_validate_rate_mask(struct ath10k *ar,
6972 struct ieee80211_sta *sta,
6973 u32 rate_ctrl_flag, u8 nss)
6974 {
6975 struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
6976 struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
6977
6978 if (nss > sta->deflink.rx_nss) {
6979 ath10k_warn(ar, "Invalid nss field, configured %u limit %u\n",
6980 nss, sta->deflink.rx_nss);
6981 return -EINVAL;
6982 }
6983
6984 if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_VHT) {
6985 if (!vht_cap->vht_supported) {
6986 ath10k_warn(ar, "Invalid VHT rate for sta %pM\n",
6987 sta->addr);
6988 return -EINVAL;
6989 }
6990 } else if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_HT) {
6991 if (!ht_cap->ht_supported || vht_cap->vht_supported) {
6992 ath10k_warn(ar, "Invalid HT rate for sta %pM\n",
6993 sta->addr);
6994 return -EINVAL;
6995 }
6996 } else {
6997 if (ht_cap->ht_supported || vht_cap->vht_supported)
6998 return -EINVAL;
6999 }
7000
7001 return 0;
7002 }
7003
7004 static int
ath10k_mac_tid_bitrate_config(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 * rate_ctrl_flag,u8 * rate_ctrl,enum nl80211_tx_rate_setting txrate_type,const struct cfg80211_bitrate_mask * mask)7005 ath10k_mac_tid_bitrate_config(struct ath10k *ar,
7006 struct ieee80211_vif *vif,
7007 struct ieee80211_sta *sta,
7008 u32 *rate_ctrl_flag, u8 *rate_ctrl,
7009 enum nl80211_tx_rate_setting txrate_type,
7010 const struct cfg80211_bitrate_mask *mask)
7011 {
7012 struct cfg80211_chan_def def;
7013 enum nl80211_band band;
7014 u8 nss, rate;
7015 int vht_num_rates, ret;
7016
7017 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
7018 return -EINVAL;
7019
7020 if (txrate_type == NL80211_TX_RATE_AUTOMATIC) {
7021 *rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO;
7022 *rate_ctrl_flag = 0;
7023 return 0;
7024 }
7025
7026 band = def.chan->band;
7027
7028 if (!ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask,
7029 &vht_num_rates)) {
7030 return -EINVAL;
7031 }
7032
7033 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
7034 &rate, &nss, false);
7035 if (ret) {
7036 ath10k_warn(ar, "failed to get single rate: %d\n",
7037 ret);
7038 return ret;
7039 }
7040
7041 *rate_ctrl_flag = rate;
7042
7043 if (sta && ath10k_mac_validate_rate_mask(ar, sta, *rate_ctrl_flag, nss))
7044 return -EINVAL;
7045
7046 if (txrate_type == NL80211_TX_RATE_FIXED)
7047 *rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_FIXED_RATE;
7048 else if (txrate_type == NL80211_TX_RATE_LIMITED &&
7049 (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT,
7050 ar->wmi.svc_map)))
7051 *rate_ctrl = WMI_PEER_TID_CONFIG_RATE_UPPER_CAP;
7052 else
7053 return -EOPNOTSUPP;
7054
7055 return 0;
7056 }
7057
ath10k_mac_set_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ieee80211_vif * vif,u32 changed,struct wmi_per_peer_per_tid_cfg_arg * arg)7058 static int ath10k_mac_set_tid_config(struct ath10k *ar, struct ieee80211_sta *sta,
7059 struct ieee80211_vif *vif, u32 changed,
7060 struct wmi_per_peer_per_tid_cfg_arg *arg)
7061 {
7062 struct ath10k_vif *arvif = (void *)vif->drv_priv;
7063 struct ath10k_sta *arsta;
7064 int ret;
7065
7066 if (sta) {
7067 if (!sta->wme)
7068 return -ENOTSUPP;
7069
7070 arsta = (struct ath10k_sta *)sta->drv_priv;
7071
7072 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7073 if ((arsta->retry_long[arg->tid] > 0 ||
7074 arsta->rate_code[arg->tid] > 0 ||
7075 arsta->ampdu[arg->tid] ==
7076 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) &&
7077 arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) {
7078 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK);
7079 arg->ack_policy = 0;
7080 arg->aggr_control = 0;
7081 arg->rate_ctrl = 0;
7082 arg->rcode_flags = 0;
7083 }
7084 }
7085
7086 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7087 if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK ||
7088 arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {
7089 arg->aggr_control = 0;
7090 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
7091 }
7092 }
7093
7094 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7095 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7096 if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK ||
7097 arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {
7098 arg->rate_ctrl = 0;
7099 arg->rcode_flags = 0;
7100 }
7101 }
7102
7103 ether_addr_copy(arg->peer_macaddr.addr, sta->addr);
7104
7105 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, arg);
7106 if (ret)
7107 return ret;
7108
7109 /* Store the configured parameters in success case */
7110 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7111 arsta->noack[arg->tid] = arg->ack_policy;
7112 arg->ack_policy = 0;
7113 arg->aggr_control = 0;
7114 arg->rate_ctrl = 0;
7115 arg->rcode_flags = 0;
7116 }
7117
7118 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {
7119 arsta->retry_long[arg->tid] = arg->retry_count;
7120 arg->retry_count = 0;
7121 }
7122
7123 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7124 arsta->ampdu[arg->tid] = arg->aggr_control;
7125 arg->aggr_control = 0;
7126 }
7127
7128 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7129 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7130 arsta->rate_ctrl[arg->tid] = arg->rate_ctrl;
7131 arg->rate_ctrl = 0;
7132 arg->rcode_flags = 0;
7133 }
7134
7135 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7136 arsta->rtscts[arg->tid] = arg->rtscts_ctrl;
7137 arg->ext_tid_cfg_bitmap = 0;
7138 }
7139 } else {
7140 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7141 if ((arvif->retry_long[arg->tid] ||
7142 arvif->rate_code[arg->tid] ||
7143 arvif->ampdu[arg->tid] ==
7144 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) &&
7145 arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) {
7146 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK);
7147 } else {
7148 arvif->noack[arg->tid] = arg->ack_policy;
7149 arvif->ampdu[arg->tid] = arg->aggr_control;
7150 arvif->rate_ctrl[arg->tid] = arg->rate_ctrl;
7151 }
7152 }
7153
7154 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {
7155 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK)
7156 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
7157 else
7158 arvif->retry_long[arg->tid] = arg->retry_count;
7159 }
7160
7161 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7162 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK)
7163 changed &= ~BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);
7164 else
7165 arvif->ampdu[arg->tid] = arg->aggr_control;
7166 }
7167
7168 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7169 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7170 if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {
7171 changed &= ~(BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7172 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE));
7173 } else {
7174 arvif->rate_ctrl[arg->tid] = arg->rate_ctrl;
7175 arvif->rate_code[arg->tid] = arg->rcode_flags;
7176 }
7177 }
7178
7179 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7180 arvif->rtscts[arg->tid] = arg->rtscts_ctrl;
7181 arg->ext_tid_cfg_bitmap = 0;
7182 }
7183
7184 if (changed)
7185 arvif->tid_conf_changed[arg->tid] |= changed;
7186 }
7187
7188 return 0;
7189 }
7190
7191 static int
ath10k_mac_parse_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ieee80211_vif * vif,struct cfg80211_tid_cfg * tid_conf,struct wmi_per_peer_per_tid_cfg_arg * arg)7192 ath10k_mac_parse_tid_config(struct ath10k *ar,
7193 struct ieee80211_sta *sta,
7194 struct ieee80211_vif *vif,
7195 struct cfg80211_tid_cfg *tid_conf,
7196 struct wmi_per_peer_per_tid_cfg_arg *arg)
7197 {
7198 u32 changed = tid_conf->mask;
7199 int ret = 0, i = 0;
7200
7201 if (!changed)
7202 return -EINVAL;
7203
7204 while (i < ATH10K_TID_MAX) {
7205 if (!(tid_conf->tids & BIT(i))) {
7206 i++;
7207 continue;
7208 }
7209
7210 arg->tid = i;
7211
7212 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7213 if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE) {
7214 arg->ack_policy = WMI_PEER_TID_CONFIG_NOACK;
7215 arg->rate_ctrl =
7216 WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE;
7217 arg->aggr_control =
7218 WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;
7219 } else {
7220 arg->ack_policy =
7221 WMI_PEER_TID_CONFIG_ACK;
7222 arg->rate_ctrl =
7223 WMI_TID_CONFIG_RATE_CONTROL_AUTO;
7224 arg->aggr_control =
7225 WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;
7226 }
7227 }
7228
7229 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG))
7230 arg->retry_count = tid_conf->retry_long;
7231
7232 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7233 if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE)
7234 arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;
7235 else
7236 arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;
7237 }
7238
7239 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7240 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7241 ret = ath10k_mac_tid_bitrate_config(ar, vif, sta,
7242 &arg->rcode_flags,
7243 &arg->rate_ctrl,
7244 tid_conf->txrate_type,
7245 &tid_conf->txrate_mask);
7246 if (ret) {
7247 ath10k_warn(ar, "failed to configure bitrate mask %d\n",
7248 ret);
7249 arg->rcode_flags = 0;
7250 arg->rate_ctrl = 0;
7251 }
7252 }
7253
7254 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7255 if (tid_conf->rtscts)
7256 arg->rtscts_ctrl = tid_conf->rtscts;
7257
7258 arg->ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG;
7259 }
7260
7261 ret = ath10k_mac_set_tid_config(ar, sta, vif, changed, arg);
7262 if (ret)
7263 return ret;
7264 i++;
7265 }
7266
7267 return ret;
7268 }
7269
ath10k_mac_reset_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ath10k_vif * arvif,u8 tids)7270 static int ath10k_mac_reset_tid_config(struct ath10k *ar,
7271 struct ieee80211_sta *sta,
7272 struct ath10k_vif *arvif,
7273 u8 tids)
7274 {
7275 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
7276 struct wmi_per_peer_per_tid_cfg_arg arg;
7277 int ret = 0, i = 0;
7278
7279 arg.vdev_id = arvif->vdev_id;
7280 while (i < ATH10K_TID_MAX) {
7281 if (!(tids & BIT(i))) {
7282 i++;
7283 continue;
7284 }
7285
7286 arg.tid = i;
7287 arg.ack_policy = WMI_PEER_TID_CONFIG_ACK;
7288 arg.retry_count = ATH10K_MAX_RETRY_COUNT;
7289 arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO;
7290 arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;
7291 arg.rtscts_ctrl = WMI_TID_CONFIG_RTSCTS_CONTROL_ENABLE;
7292 arg.ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG;
7293
7294 ether_addr_copy(arg.peer_macaddr.addr, sta->addr);
7295
7296 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);
7297 if (ret)
7298 return ret;
7299
7300 if (!arvif->tids_rst) {
7301 arsta->retry_long[i] = -1;
7302 arsta->noack[i] = -1;
7303 arsta->ampdu[i] = -1;
7304 arsta->rate_code[i] = -1;
7305 arsta->rate_ctrl[i] = 0;
7306 arsta->rtscts[i] = -1;
7307 } else {
7308 arvif->retry_long[i] = 0;
7309 arvif->noack[i] = 0;
7310 arvif->ampdu[i] = 0;
7311 arvif->rate_code[i] = 0;
7312 arvif->rate_ctrl[i] = 0;
7313 arvif->rtscts[i] = 0;
7314 }
7315
7316 i++;
7317 }
7318
7319 return ret;
7320 }
7321
ath10k_sta_tid_cfg_wk(struct work_struct * wk)7322 static void ath10k_sta_tid_cfg_wk(struct work_struct *wk)
7323 {
7324 struct wmi_per_peer_per_tid_cfg_arg arg = {};
7325 struct ieee80211_sta *sta;
7326 struct ath10k_sta *arsta;
7327 struct ath10k_vif *arvif;
7328 struct ath10k *ar;
7329 bool config_apply;
7330 int ret, i;
7331 u32 changed;
7332 u8 nss;
7333
7334 arsta = container_of(wk, struct ath10k_sta, tid_config_wk);
7335 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
7336 arvif = arsta->arvif;
7337 ar = arvif->ar;
7338
7339 mutex_lock(&ar->conf_mutex);
7340
7341 if (arvif->tids_rst) {
7342 ret = ath10k_mac_reset_tid_config(ar, sta, arvif,
7343 arvif->tids_rst);
7344 goto exit;
7345 }
7346
7347 ether_addr_copy(arg.peer_macaddr.addr, sta->addr);
7348
7349 for (i = 0; i < ATH10K_TID_MAX; i++) {
7350 config_apply = false;
7351 changed = arvif->tid_conf_changed[i];
7352
7353 if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7354 if (arsta->noack[i] != -1) {
7355 arg.ack_policy = 0;
7356 } else {
7357 config_apply = true;
7358 arg.ack_policy = arvif->noack[i];
7359 arg.aggr_control = arvif->ampdu[i];
7360 arg.rate_ctrl = arvif->rate_ctrl[i];
7361 }
7362 }
7363
7364 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {
7365 if (arsta->retry_long[i] != -1 ||
7366 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||
7367 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {
7368 arg.retry_count = 0;
7369 } else {
7370 arg.retry_count = arvif->retry_long[i];
7371 config_apply = true;
7372 }
7373 }
7374
7375 if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7376 if (arsta->ampdu[i] != -1 ||
7377 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||
7378 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {
7379 arg.aggr_control = 0;
7380 } else {
7381 arg.aggr_control = arvif->ampdu[i];
7382 config_apply = true;
7383 }
7384 }
7385
7386 if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7387 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7388 nss = ATH10K_HW_NSS(arvif->rate_code[i]);
7389 ret = ath10k_mac_validate_rate_mask(ar, sta,
7390 arvif->rate_code[i],
7391 nss);
7392 if (ret &&
7393 arvif->rate_ctrl[i] > WMI_TID_CONFIG_RATE_CONTROL_AUTO) {
7394 arg.rate_ctrl = 0;
7395 arg.rcode_flags = 0;
7396 }
7397
7398 if (arsta->rate_ctrl[i] >
7399 WMI_TID_CONFIG_RATE_CONTROL_AUTO ||
7400 arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||
7401 arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {
7402 arg.rate_ctrl = 0;
7403 arg.rcode_flags = 0;
7404 } else {
7405 arg.rate_ctrl = arvif->rate_ctrl[i];
7406 arg.rcode_flags = arvif->rate_code[i];
7407 config_apply = true;
7408 }
7409 }
7410
7411 if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7412 if (arsta->rtscts[i]) {
7413 arg.rtscts_ctrl = 0;
7414 arg.ext_tid_cfg_bitmap = 0;
7415 } else {
7416 arg.rtscts_ctrl = arvif->rtscts[i] - 1;
7417 arg.ext_tid_cfg_bitmap =
7418 WMI_EXT_TID_RTS_CTS_CONFIG;
7419 config_apply = true;
7420 }
7421 }
7422
7423 arg.tid = i;
7424
7425 if (config_apply) {
7426 ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);
7427 if (ret)
7428 ath10k_warn(ar, "failed to set per tid config for sta %pM: %d\n",
7429 sta->addr, ret);
7430 }
7431
7432 arg.ack_policy = 0;
7433 arg.retry_count = 0;
7434 arg.aggr_control = 0;
7435 arg.rate_ctrl = 0;
7436 arg.rcode_flags = 0;
7437 }
7438
7439 exit:
7440 mutex_unlock(&ar->conf_mutex);
7441 }
7442
ath10k_mac_vif_stations_tid_conf(void * data,struct ieee80211_sta * sta)7443 static void ath10k_mac_vif_stations_tid_conf(void *data,
7444 struct ieee80211_sta *sta)
7445 {
7446 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
7447 struct ath10k_mac_iter_tid_conf_data *iter_data = data;
7448 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
7449
7450 if (sta_vif != iter_data->curr_vif || !sta->wme)
7451 return;
7452
7453 ieee80211_queue_work(iter_data->ar->hw, &arsta->tid_config_wk);
7454 }
7455
ath10k_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)7456 static int ath10k_sta_state(struct ieee80211_hw *hw,
7457 struct ieee80211_vif *vif,
7458 struct ieee80211_sta *sta,
7459 enum ieee80211_sta_state old_state,
7460 enum ieee80211_sta_state new_state)
7461 {
7462 struct ath10k *ar = hw->priv;
7463 struct ath10k_vif *arvif = (void *)vif->drv_priv;
7464 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
7465 struct ath10k_peer *peer;
7466 int ret = 0;
7467 int i;
7468
7469 if (old_state == IEEE80211_STA_NOTEXIST &&
7470 new_state == IEEE80211_STA_NONE) {
7471 memset(arsta, 0, sizeof(*arsta));
7472 arsta->arvif = arvif;
7473 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
7474 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
7475 INIT_WORK(&arsta->tid_config_wk, ath10k_sta_tid_cfg_wk);
7476
7477 for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
7478 ath10k_mac_txq_init(sta->txq[i]);
7479 }
7480
7481 /* cancel must be done outside the mutex to avoid deadlock */
7482 if ((old_state == IEEE80211_STA_NONE &&
7483 new_state == IEEE80211_STA_NOTEXIST)) {
7484 cancel_work_sync(&arsta->update_wk);
7485 cancel_work_sync(&arsta->tid_config_wk);
7486 }
7487
7488 mutex_lock(&ar->conf_mutex);
7489
7490 if (old_state == IEEE80211_STA_NOTEXIST &&
7491 new_state == IEEE80211_STA_NONE) {
7492 /*
7493 * New station addition.
7494 */
7495 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
7496 u32 num_tdls_stations;
7497
7498 ath10k_dbg(ar, ATH10K_DBG_STA,
7499 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
7500 arvif->vdev_id, sta->addr,
7501 ar->num_stations + 1, ar->max_num_stations,
7502 ar->num_peers + 1, ar->max_num_peers);
7503
7504 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
7505
7506 if (sta->tdls) {
7507 if (num_tdls_stations >= ar->max_num_tdls_vdevs) {
7508 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
7509 arvif->vdev_id,
7510 ar->max_num_tdls_vdevs);
7511 ret = -ELNRNG;
7512 goto exit;
7513 }
7514 peer_type = WMI_PEER_TYPE_TDLS;
7515 }
7516
7517 ret = ath10k_mac_inc_num_stations(arvif, sta);
7518 if (ret) {
7519 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
7520 ar->max_num_stations);
7521 goto exit;
7522 }
7523
7524 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {
7525 arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats),
7526 GFP_KERNEL);
7527 if (!arsta->tx_stats) {
7528 ath10k_mac_dec_num_stations(arvif, sta);
7529 ret = -ENOMEM;
7530 goto exit;
7531 }
7532 }
7533
7534 ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id,
7535 sta->addr, peer_type);
7536 if (ret) {
7537 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
7538 sta->addr, arvif->vdev_id, ret);
7539 ath10k_mac_dec_num_stations(arvif, sta);
7540 kfree(arsta->tx_stats);
7541 goto exit;
7542 }
7543
7544 spin_lock_bh(&ar->data_lock);
7545
7546 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);
7547 if (!peer) {
7548 ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
7549 vif->addr, arvif->vdev_id);
7550 spin_unlock_bh(&ar->data_lock);
7551 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
7552 ath10k_mac_dec_num_stations(arvif, sta);
7553 kfree(arsta->tx_stats);
7554 ret = -ENOENT;
7555 goto exit;
7556 }
7557
7558 arsta->peer_id = find_first_bit(peer->peer_ids,
7559 ATH10K_MAX_NUM_PEER_IDS);
7560
7561 spin_unlock_bh(&ar->data_lock);
7562
7563 if (!sta->tdls)
7564 goto exit;
7565
7566 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
7567 WMI_TDLS_ENABLE_ACTIVE);
7568 if (ret) {
7569 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
7570 arvif->vdev_id, ret);
7571 ath10k_peer_delete(ar, arvif->vdev_id,
7572 sta->addr);
7573 ath10k_mac_dec_num_stations(arvif, sta);
7574 kfree(arsta->tx_stats);
7575 goto exit;
7576 }
7577
7578 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
7579 WMI_TDLS_PEER_STATE_PEERING);
7580 if (ret) {
7581 ath10k_warn(ar,
7582 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
7583 sta->addr, arvif->vdev_id, ret);
7584 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
7585 ath10k_mac_dec_num_stations(arvif, sta);
7586 kfree(arsta->tx_stats);
7587
7588 if (num_tdls_stations != 0)
7589 goto exit;
7590 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
7591 WMI_TDLS_DISABLE);
7592 }
7593 } else if ((old_state == IEEE80211_STA_NONE &&
7594 new_state == IEEE80211_STA_NOTEXIST)) {
7595 /*
7596 * Existing station deletion.
7597 */
7598 ath10k_dbg(ar, ATH10K_DBG_STA,
7599 "mac vdev %d peer delete %pM sta %pK (sta gone)\n",
7600 arvif->vdev_id, sta->addr, sta);
7601
7602 if (sta->tdls) {
7603 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id,
7604 sta,
7605 WMI_TDLS_PEER_STATE_TEARDOWN);
7606 if (ret)
7607 ath10k_warn(ar, "failed to update tdls peer state for %pM state %d: %i\n",
7608 sta->addr,
7609 WMI_TDLS_PEER_STATE_TEARDOWN, ret);
7610 }
7611
7612 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
7613 if (ret)
7614 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
7615 sta->addr, arvif->vdev_id, ret);
7616
7617 ath10k_mac_dec_num_stations(arvif, sta);
7618
7619 spin_lock_bh(&ar->data_lock);
7620 for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
7621 peer = ar->peer_map[i];
7622 if (!peer)
7623 continue;
7624
7625 if (peer->sta == sta) {
7626 ath10k_warn(ar, "found sta peer %pM (ptr %pK id %d) entry on vdev %i after it was supposedly removed\n",
7627 sta->addr, peer, i, arvif->vdev_id);
7628 peer->sta = NULL;
7629
7630 /* Clean up the peer object as well since we
7631 * must have failed to do this above.
7632 */
7633 ath10k_peer_map_cleanup(ar, peer);
7634 }
7635 }
7636 spin_unlock_bh(&ar->data_lock);
7637
7638 if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {
7639 kfree(arsta->tx_stats);
7640 arsta->tx_stats = NULL;
7641 }
7642
7643 for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
7644 ath10k_mac_txq_unref(ar, sta->txq[i]);
7645
7646 if (!sta->tdls)
7647 goto exit;
7648
7649 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
7650 goto exit;
7651
7652 /* This was the last tdls peer in current vif */
7653 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
7654 WMI_TDLS_DISABLE);
7655 if (ret) {
7656 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
7657 arvif->vdev_id, ret);
7658 }
7659 } else if (old_state == IEEE80211_STA_AUTH &&
7660 new_state == IEEE80211_STA_ASSOC &&
7661 (vif->type == NL80211_IFTYPE_AP ||
7662 vif->type == NL80211_IFTYPE_MESH_POINT ||
7663 vif->type == NL80211_IFTYPE_ADHOC)) {
7664 /*
7665 * New association.
7666 */
7667 ath10k_dbg(ar, ATH10K_DBG_STA, "mac sta %pM associated\n",
7668 sta->addr);
7669
7670 ret = ath10k_station_assoc(ar, vif, sta, false);
7671 if (ret)
7672 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
7673 sta->addr, arvif->vdev_id, ret);
7674 } else if (old_state == IEEE80211_STA_ASSOC &&
7675 new_state == IEEE80211_STA_AUTHORIZED &&
7676 sta->tdls) {
7677 /*
7678 * Tdls station authorized.
7679 */
7680 ath10k_dbg(ar, ATH10K_DBG_STA, "mac tdls sta %pM authorized\n",
7681 sta->addr);
7682
7683 ret = ath10k_station_assoc(ar, vif, sta, false);
7684 if (ret) {
7685 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
7686 sta->addr, arvif->vdev_id, ret);
7687 goto exit;
7688 }
7689
7690 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
7691 WMI_TDLS_PEER_STATE_CONNECTED);
7692 if (ret)
7693 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
7694 sta->addr, arvif->vdev_id, ret);
7695 } else if (old_state == IEEE80211_STA_ASSOC &&
7696 new_state == IEEE80211_STA_AUTH &&
7697 (vif->type == NL80211_IFTYPE_AP ||
7698 vif->type == NL80211_IFTYPE_MESH_POINT ||
7699 vif->type == NL80211_IFTYPE_ADHOC)) {
7700 /*
7701 * Disassociation.
7702 */
7703 ath10k_dbg(ar, ATH10K_DBG_STA, "mac sta %pM disassociated\n",
7704 sta->addr);
7705
7706 ret = ath10k_station_disassoc(ar, vif, sta);
7707 if (ret)
7708 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
7709 sta->addr, arvif->vdev_id, ret);
7710 }
7711 exit:
7712 mutex_unlock(&ar->conf_mutex);
7713 return ret;
7714 }
7715
ath10k_conf_tx_uapsd(struct ath10k * ar,struct ieee80211_vif * vif,u16 ac,bool enable)7716 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
7717 u16 ac, bool enable)
7718 {
7719 struct ath10k_vif *arvif = (void *)vif->drv_priv;
7720 struct wmi_sta_uapsd_auto_trig_arg arg = {};
7721 u32 prio = 0, acc = 0;
7722 u32 value = 0;
7723 int ret = 0;
7724
7725 lockdep_assert_held(&ar->conf_mutex);
7726
7727 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
7728 return 0;
7729
7730 switch (ac) {
7731 case IEEE80211_AC_VO:
7732 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
7733 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
7734 prio = 7;
7735 acc = 3;
7736 break;
7737 case IEEE80211_AC_VI:
7738 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
7739 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
7740 prio = 5;
7741 acc = 2;
7742 break;
7743 case IEEE80211_AC_BE:
7744 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
7745 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
7746 prio = 2;
7747 acc = 1;
7748 break;
7749 case IEEE80211_AC_BK:
7750 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
7751 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
7752 prio = 0;
7753 acc = 0;
7754 break;
7755 }
7756
7757 if (enable)
7758 arvif->u.sta.uapsd |= value;
7759 else
7760 arvif->u.sta.uapsd &= ~value;
7761
7762 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
7763 WMI_STA_PS_PARAM_UAPSD,
7764 arvif->u.sta.uapsd);
7765 if (ret) {
7766 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
7767 goto exit;
7768 }
7769
7770 if (arvif->u.sta.uapsd)
7771 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
7772 else
7773 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
7774
7775 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
7776 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
7777 value);
7778 if (ret)
7779 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
7780
7781 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
7782 if (ret) {
7783 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
7784 arvif->vdev_id, ret);
7785 return ret;
7786 }
7787
7788 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
7789 if (ret) {
7790 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
7791 arvif->vdev_id, ret);
7792 return ret;
7793 }
7794
7795 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
7796 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
7797 /* Only userspace can make an educated decision when to send
7798 * trigger frame. The following effectively disables u-UAPSD
7799 * autotrigger in firmware (which is enabled by default
7800 * provided the autotrigger service is available).
7801 */
7802
7803 arg.wmm_ac = acc;
7804 arg.user_priority = prio;
7805 arg.service_interval = 0;
7806 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
7807 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
7808
7809 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
7810 arvif->bssid, &arg, 1);
7811 if (ret) {
7812 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
7813 ret);
7814 return ret;
7815 }
7816 }
7817
7818 exit:
7819 return ret;
7820 }
7821
ath10k_conf_tx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,unsigned int link_id,u16 ac,const struct ieee80211_tx_queue_params * params)7822 static int ath10k_conf_tx(struct ieee80211_hw *hw,
7823 struct ieee80211_vif *vif,
7824 unsigned int link_id, u16 ac,
7825 const struct ieee80211_tx_queue_params *params)
7826 {
7827 struct ath10k *ar = hw->priv;
7828 struct ath10k_vif *arvif = (void *)vif->drv_priv;
7829 struct wmi_wmm_params_arg *p = NULL;
7830 int ret;
7831
7832 mutex_lock(&ar->conf_mutex);
7833
7834 switch (ac) {
7835 case IEEE80211_AC_VO:
7836 p = &arvif->wmm_params.ac_vo;
7837 break;
7838 case IEEE80211_AC_VI:
7839 p = &arvif->wmm_params.ac_vi;
7840 break;
7841 case IEEE80211_AC_BE:
7842 p = &arvif->wmm_params.ac_be;
7843 break;
7844 case IEEE80211_AC_BK:
7845 p = &arvif->wmm_params.ac_bk;
7846 break;
7847 }
7848
7849 if (WARN_ON(!p)) {
7850 ret = -EINVAL;
7851 goto exit;
7852 }
7853
7854 p->cwmin = params->cw_min;
7855 p->cwmax = params->cw_max;
7856 p->aifs = params->aifs;
7857
7858 /*
7859 * The channel time duration programmed in the HW is in absolute
7860 * microseconds, while mac80211 gives the txop in units of
7861 * 32 microseconds.
7862 */
7863 p->txop = params->txop * 32;
7864
7865 if (ar->wmi.ops->gen_vdev_wmm_conf) {
7866 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
7867 &arvif->wmm_params);
7868 if (ret) {
7869 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
7870 arvif->vdev_id, ret);
7871 goto exit;
7872 }
7873 } else {
7874 /* This won't work well with multi-interface cases but it's
7875 * better than nothing.
7876 */
7877 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
7878 if (ret) {
7879 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
7880 goto exit;
7881 }
7882 }
7883
7884 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
7885 if (ret)
7886 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
7887
7888 exit:
7889 mutex_unlock(&ar->conf_mutex);
7890 return ret;
7891 }
7892
ath10k_remain_on_channel(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_channel * chan,int duration,enum ieee80211_roc_type type)7893 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
7894 struct ieee80211_vif *vif,
7895 struct ieee80211_channel *chan,
7896 int duration,
7897 enum ieee80211_roc_type type)
7898 {
7899 struct ath10k *ar = hw->priv;
7900 struct ath10k_vif *arvif = (void *)vif->drv_priv;
7901 struct wmi_start_scan_arg arg;
7902 int ret = 0;
7903 u32 scan_time_msec;
7904
7905 mutex_lock(&ar->conf_mutex);
7906
7907 if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) {
7908 ret = -EBUSY;
7909 goto exit;
7910 }
7911
7912 spin_lock_bh(&ar->data_lock);
7913 switch (ar->scan.state) {
7914 case ATH10K_SCAN_IDLE:
7915 reinit_completion(&ar->scan.started);
7916 reinit_completion(&ar->scan.completed);
7917 reinit_completion(&ar->scan.on_channel);
7918 ar->scan.state = ATH10K_SCAN_STARTING;
7919 ar->scan.is_roc = true;
7920 ar->scan.vdev_id = arvif->vdev_id;
7921 ar->scan.roc_freq = chan->center_freq;
7922 ar->scan.roc_notify = true;
7923 ret = 0;
7924 break;
7925 case ATH10K_SCAN_STARTING:
7926 case ATH10K_SCAN_RUNNING:
7927 case ATH10K_SCAN_ABORTING:
7928 ret = -EBUSY;
7929 break;
7930 }
7931 spin_unlock_bh(&ar->data_lock);
7932
7933 if (ret)
7934 goto exit;
7935
7936 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
7937
7938 memset(&arg, 0, sizeof(arg));
7939 ath10k_wmi_start_scan_init(ar, &arg);
7940 arg.vdev_id = arvif->vdev_id;
7941 arg.scan_id = ATH10K_SCAN_ID;
7942 arg.n_channels = 1;
7943 arg.channels[0] = chan->center_freq;
7944 arg.dwell_time_active = scan_time_msec;
7945 arg.dwell_time_passive = scan_time_msec;
7946 arg.max_scan_time = scan_time_msec;
7947 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
7948 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
7949 arg.burst_duration_ms = duration;
7950
7951 ret = ath10k_start_scan(ar, &arg);
7952 if (ret) {
7953 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
7954 spin_lock_bh(&ar->data_lock);
7955 ar->scan.state = ATH10K_SCAN_IDLE;
7956 spin_unlock_bh(&ar->data_lock);
7957 goto exit;
7958 }
7959
7960 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
7961 if (ret == 0) {
7962 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
7963
7964 ret = ath10k_scan_stop(ar);
7965 if (ret)
7966 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
7967
7968 ret = -ETIMEDOUT;
7969 goto exit;
7970 }
7971
7972 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
7973 msecs_to_jiffies(duration));
7974
7975 ret = 0;
7976 exit:
7977 mutex_unlock(&ar->conf_mutex);
7978 return ret;
7979 }
7980
ath10k_cancel_remain_on_channel(struct ieee80211_hw * hw,struct ieee80211_vif * vif)7981 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw,
7982 struct ieee80211_vif *vif)
7983 {
7984 struct ath10k *ar = hw->priv;
7985
7986 mutex_lock(&ar->conf_mutex);
7987
7988 spin_lock_bh(&ar->data_lock);
7989 ar->scan.roc_notify = false;
7990 spin_unlock_bh(&ar->data_lock);
7991
7992 ath10k_scan_abort(ar);
7993
7994 mutex_unlock(&ar->conf_mutex);
7995
7996 cancel_delayed_work_sync(&ar->scan.timeout);
7997
7998 return 0;
7999 }
8000
8001 /*
8002 * Both RTS and Fragmentation threshold are interface-specific
8003 * in ath10k, but device-specific in mac80211.
8004 */
8005
ath10k_set_rts_threshold(struct ieee80211_hw * hw,u32 value)8006 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
8007 {
8008 struct ath10k *ar = hw->priv;
8009 struct ath10k_vif *arvif;
8010 int ret = 0;
8011
8012 mutex_lock(&ar->conf_mutex);
8013 list_for_each_entry(arvif, &ar->arvifs, list) {
8014 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
8015 arvif->vdev_id, value);
8016
8017 ret = ath10k_mac_set_rts(arvif, value);
8018 if (ret) {
8019 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
8020 arvif->vdev_id, ret);
8021 break;
8022 }
8023 }
8024 mutex_unlock(&ar->conf_mutex);
8025
8026 return ret;
8027 }
8028
ath10k_mac_op_set_frag_threshold(struct ieee80211_hw * hw,u32 value)8029 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
8030 {
8031 /* Even though there's a WMI enum for fragmentation threshold no known
8032 * firmware actually implements it. Moreover it is not possible to rely
8033 * frame fragmentation to mac80211 because firmware clears the "more
8034 * fragments" bit in frame control making it impossible for remote
8035 * devices to reassemble frames.
8036 *
8037 * Hence implement a dummy callback just to say fragmentation isn't
8038 * supported. This effectively prevents mac80211 from doing frame
8039 * fragmentation in software.
8040 */
8041 return -EOPNOTSUPP;
8042 }
8043
ath10k_mac_wait_tx_complete(struct ath10k * ar)8044 void ath10k_mac_wait_tx_complete(struct ath10k *ar)
8045 {
8046 bool skip;
8047 long time_left;
8048
8049 /* mac80211 doesn't care if we really xmit queued frames or not
8050 * we'll collect those frames either way if we stop/delete vdevs
8051 */
8052
8053 if (ar->state == ATH10K_STATE_WEDGED)
8054 return;
8055
8056 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
8057 bool empty;
8058
8059 spin_lock_bh(&ar->htt.tx_lock);
8060 empty = (ar->htt.num_pending_tx == 0);
8061 spin_unlock_bh(&ar->htt.tx_lock);
8062
8063 skip = (ar->state == ATH10K_STATE_WEDGED) ||
8064 test_bit(ATH10K_FLAG_CRASH_FLUSH,
8065 &ar->dev_flags);
8066
8067 (empty || skip);
8068 }), ATH10K_FLUSH_TIMEOUT_HZ);
8069
8070 if (time_left == 0 || skip)
8071 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
8072 skip, ar->state, time_left);
8073 }
8074
ath10k_flush(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u32 queues,bool drop)8075 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
8076 u32 queues, bool drop)
8077 {
8078 struct ath10k *ar = hw->priv;
8079 struct ath10k_vif *arvif;
8080 u32 bitmap;
8081
8082 if (drop) {
8083 if (vif && vif->type == NL80211_IFTYPE_STATION) {
8084 bitmap = ~(1 << WMI_MGMT_TID);
8085 list_for_each_entry(arvif, &ar->arvifs, list) {
8086 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
8087 ath10k_wmi_peer_flush(ar, arvif->vdev_id,
8088 arvif->bssid, bitmap);
8089 }
8090 ath10k_htt_flush_tx(&ar->htt);
8091 }
8092 return;
8093 }
8094
8095 mutex_lock(&ar->conf_mutex);
8096 ath10k_mac_wait_tx_complete(ar);
8097 mutex_unlock(&ar->conf_mutex);
8098 }
8099
8100 /* TODO: Implement this function properly
8101 * For now it is needed to reply to Probe Requests in IBSS mode.
8102 * Probably we need this information from FW.
8103 */
ath10k_tx_last_beacon(struct ieee80211_hw * hw)8104 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
8105 {
8106 return 1;
8107 }
8108
ath10k_reconfig_complete(struct ieee80211_hw * hw,enum ieee80211_reconfig_type reconfig_type)8109 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
8110 enum ieee80211_reconfig_type reconfig_type)
8111 {
8112 struct ath10k *ar = hw->priv;
8113 struct ath10k_vif *arvif;
8114
8115 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
8116 return;
8117
8118 mutex_lock(&ar->conf_mutex);
8119
8120 /* If device failed to restart it will be in a different state, e.g.
8121 * ATH10K_STATE_WEDGED
8122 */
8123 if (ar->state == ATH10K_STATE_RESTARTED) {
8124 ath10k_info(ar, "device successfully recovered\n");
8125 ar->state = ATH10K_STATE_ON;
8126 ieee80211_wake_queues(ar->hw);
8127 clear_bit(ATH10K_FLAG_RESTARTING, &ar->dev_flags);
8128 if (ar->hw_params.hw_restart_disconnect) {
8129 list_for_each_entry(arvif, &ar->arvifs, list) {
8130 if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)
8131 ieee80211_hw_restart_disconnect(arvif->vif);
8132 }
8133 }
8134 }
8135
8136 mutex_unlock(&ar->conf_mutex);
8137 }
8138
8139 static void
ath10k_mac_update_bss_chan_survey(struct ath10k * ar,struct ieee80211_channel * channel)8140 ath10k_mac_update_bss_chan_survey(struct ath10k *ar,
8141 struct ieee80211_channel *channel)
8142 {
8143 int ret;
8144 enum wmi_bss_survey_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
8145
8146 lockdep_assert_held(&ar->conf_mutex);
8147
8148 if (!test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map) ||
8149 (ar->rx_channel != channel))
8150 return;
8151
8152 if (ar->scan.state != ATH10K_SCAN_IDLE) {
8153 ath10k_dbg(ar, ATH10K_DBG_MAC, "ignoring bss chan info request while scanning..\n");
8154 return;
8155 }
8156
8157 reinit_completion(&ar->bss_survey_done);
8158
8159 ret = ath10k_wmi_pdev_bss_chan_info_request(ar, type);
8160 if (ret) {
8161 ath10k_warn(ar, "failed to send pdev bss chan info request\n");
8162 return;
8163 }
8164
8165 ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8166 if (!ret) {
8167 ath10k_warn(ar, "bss channel survey timed out\n");
8168 return;
8169 }
8170 }
8171
ath10k_get_survey(struct ieee80211_hw * hw,int idx,struct survey_info * survey)8172 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
8173 struct survey_info *survey)
8174 {
8175 struct ath10k *ar = hw->priv;
8176 struct ieee80211_supported_band *sband;
8177 struct survey_info *ar_survey = &ar->survey[idx];
8178 int ret = 0;
8179
8180 mutex_lock(&ar->conf_mutex);
8181
8182 sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8183 if (sband && idx >= sband->n_channels) {
8184 idx -= sband->n_channels;
8185 sband = NULL;
8186 }
8187
8188 if (!sband)
8189 sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8190
8191 if (!sband || idx >= sband->n_channels) {
8192 ret = -ENOENT;
8193 goto exit;
8194 }
8195
8196 ath10k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8197
8198 spin_lock_bh(&ar->data_lock);
8199 memcpy(survey, ar_survey, sizeof(*survey));
8200 spin_unlock_bh(&ar->data_lock);
8201
8202 survey->channel = &sband->channels[idx];
8203
8204 if (ar->rx_channel == survey->channel)
8205 survey->filled |= SURVEY_INFO_IN_USE;
8206
8207 exit:
8208 mutex_unlock(&ar->conf_mutex);
8209 return ret;
8210 }
8211
8212 static bool
ath10k_mac_bitrate_mask_get_single_nss(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,int * nss)8213 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
8214 enum nl80211_band band,
8215 const struct cfg80211_bitrate_mask *mask,
8216 int *nss)
8217 {
8218 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
8219 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
8220 u8 ht_nss_mask = 0;
8221 u8 vht_nss_mask = 0;
8222 int i;
8223
8224 if (mask->control[band].legacy)
8225 return false;
8226
8227 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
8228 if (mask->control[band].ht_mcs[i] == 0)
8229 continue;
8230 else if (mask->control[band].ht_mcs[i] ==
8231 sband->ht_cap.mcs.rx_mask[i])
8232 ht_nss_mask |= BIT(i);
8233 else
8234 return false;
8235 }
8236
8237 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
8238 if (mask->control[band].vht_mcs[i] == 0)
8239 continue;
8240 else if (mask->control[band].vht_mcs[i] ==
8241 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
8242 vht_nss_mask |= BIT(i);
8243 else
8244 return false;
8245 }
8246
8247 if (ht_nss_mask != vht_nss_mask)
8248 return false;
8249
8250 if (ht_nss_mask == 0)
8251 return false;
8252
8253 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
8254 return false;
8255
8256 *nss = fls(ht_nss_mask);
8257
8258 return true;
8259 }
8260
ath10k_mac_set_fixed_rate_params(struct ath10k_vif * arvif,u8 rate,u8 nss,u8 sgi,u8 ldpc)8261 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
8262 u8 rate, u8 nss, u8 sgi, u8 ldpc)
8263 {
8264 struct ath10k *ar = arvif->ar;
8265 u32 vdev_param;
8266 int ret;
8267
8268 lockdep_assert_held(&ar->conf_mutex);
8269
8270 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n",
8271 arvif->vdev_id, rate, nss, sgi);
8272
8273 vdev_param = ar->wmi.vdev_param->fixed_rate;
8274 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
8275 if (ret) {
8276 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
8277 rate, ret);
8278 return ret;
8279 }
8280
8281 vdev_param = ar->wmi.vdev_param->nss;
8282 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
8283 if (ret) {
8284 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
8285 return ret;
8286 }
8287
8288 vdev_param = ar->wmi.vdev_param->sgi;
8289 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
8290 if (ret) {
8291 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
8292 return ret;
8293 }
8294
8295 vdev_param = ar->wmi.vdev_param->ldpc;
8296 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
8297 if (ret) {
8298 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
8299 return ret;
8300 }
8301
8302 return 0;
8303 }
8304
8305 static bool
ath10k_mac_can_set_bitrate_mask(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,bool allow_pfr)8306 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
8307 enum nl80211_band band,
8308 const struct cfg80211_bitrate_mask *mask,
8309 bool allow_pfr)
8310 {
8311 int i;
8312 u16 vht_mcs;
8313
8314 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
8315 * to express all VHT MCS rate masks. Effectively only the following
8316 * ranges can be used: none, 0-7, 0-8 and 0-9.
8317 */
8318 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8319 vht_mcs = mask->control[band].vht_mcs[i];
8320
8321 switch (vht_mcs) {
8322 case 0:
8323 case BIT(8) - 1:
8324 case BIT(9) - 1:
8325 case BIT(10) - 1:
8326 break;
8327 default:
8328 if (!allow_pfr)
8329 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
8330 return false;
8331 }
8332 }
8333
8334 return true;
8335 }
8336
ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k * ar,struct ath10k_vif * arvif,struct ieee80211_sta * sta)8337 static bool ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k *ar,
8338 struct ath10k_vif *arvif,
8339 struct ieee80211_sta *sta)
8340 {
8341 int err;
8342 u8 rate = arvif->vht_pfr;
8343
8344 /* skip non vht and multiple rate peers */
8345 if (!sta->deflink.vht_cap.vht_supported || arvif->vht_num_rates != 1)
8346 return false;
8347
8348 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
8349 WMI_PEER_PARAM_FIXED_RATE, rate);
8350 if (err)
8351 ath10k_warn(ar, "failed to enable STA %pM peer fixed rate: %d\n",
8352 sta->addr, err);
8353
8354 return true;
8355 }
8356
ath10k_mac_set_bitrate_mask_iter(void * data,struct ieee80211_sta * sta)8357 static void ath10k_mac_set_bitrate_mask_iter(void *data,
8358 struct ieee80211_sta *sta)
8359 {
8360 struct ath10k_vif *arvif = data;
8361 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
8362 struct ath10k *ar = arvif->ar;
8363
8364 if (arsta->arvif != arvif)
8365 return;
8366
8367 if (ath10k_mac_set_vht_bitrate_mask_fixup(ar, arvif, sta))
8368 return;
8369
8370 spin_lock_bh(&ar->data_lock);
8371 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
8372 spin_unlock_bh(&ar->data_lock);
8373
8374 ieee80211_queue_work(ar->hw, &arsta->update_wk);
8375 }
8376
ath10k_mac_clr_bitrate_mask_iter(void * data,struct ieee80211_sta * sta)8377 static void ath10k_mac_clr_bitrate_mask_iter(void *data,
8378 struct ieee80211_sta *sta)
8379 {
8380 struct ath10k_vif *arvif = data;
8381 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
8382 struct ath10k *ar = arvif->ar;
8383 int err;
8384
8385 /* clear vht peers only */
8386 if (arsta->arvif != arvif || !sta->deflink.vht_cap.vht_supported)
8387 return;
8388
8389 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
8390 WMI_PEER_PARAM_FIXED_RATE,
8391 WMI_FIXED_RATE_NONE);
8392 if (err)
8393 ath10k_warn(ar, "failed to clear STA %pM peer fixed rate: %d\n",
8394 sta->addr, err);
8395 }
8396
ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw * hw,struct ieee80211_vif * vif,const struct cfg80211_bitrate_mask * mask)8397 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
8398 struct ieee80211_vif *vif,
8399 const struct cfg80211_bitrate_mask *mask)
8400 {
8401 struct ath10k_vif *arvif = (void *)vif->drv_priv;
8402 struct cfg80211_chan_def def;
8403 struct ath10k *ar = arvif->ar;
8404 enum nl80211_band band;
8405 const u8 *ht_mcs_mask;
8406 const u16 *vht_mcs_mask;
8407 u8 rate;
8408 u8 nss;
8409 u8 sgi;
8410 u8 ldpc;
8411 int single_nss;
8412 int ret;
8413 int vht_num_rates, allow_pfr;
8414 u8 vht_pfr;
8415 bool update_bitrate_mask = true;
8416
8417 if (ath10k_mac_vif_chan(vif, &def))
8418 return -EPERM;
8419
8420 band = def.chan->band;
8421 ht_mcs_mask = mask->control[band].ht_mcs;
8422 vht_mcs_mask = mask->control[band].vht_mcs;
8423 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
8424
8425 sgi = mask->control[band].gi;
8426 if (sgi == NL80211_TXRATE_FORCE_LGI)
8427 return -EINVAL;
8428
8429 allow_pfr = test_bit(ATH10K_FW_FEATURE_PEER_FIXED_RATE,
8430 ar->normal_mode_fw.fw_file.fw_features);
8431 if (allow_pfr) {
8432 mutex_lock(&ar->conf_mutex);
8433 ieee80211_iterate_stations_atomic(ar->hw,
8434 ath10k_mac_clr_bitrate_mask_iter,
8435 arvif);
8436 mutex_unlock(&ar->conf_mutex);
8437 }
8438
8439 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask,
8440 &vht_num_rates)) {
8441 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
8442 &rate, &nss,
8443 false);
8444 if (ret) {
8445 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
8446 arvif->vdev_id, ret);
8447 return ret;
8448 }
8449 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
8450 &single_nss)) {
8451 rate = WMI_FIXED_RATE_NONE;
8452 nss = single_nss;
8453 } else {
8454 rate = WMI_FIXED_RATE_NONE;
8455 nss = min(ar->num_rf_chains,
8456 max(ath10k_mac_max_ht_nss(ht_mcs_mask),
8457 ath10k_mac_max_vht_nss(vht_mcs_mask)));
8458
8459 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask,
8460 allow_pfr)) {
8461 u8 vht_nss;
8462
8463 if (!allow_pfr || vht_num_rates != 1)
8464 return -EINVAL;
8465
8466 /* Reach here, firmware supports peer fixed rate and has
8467 * single vht rate, and don't update vif birate_mask, as
8468 * the rate only for specific peer.
8469 */
8470 ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
8471 &vht_pfr,
8472 &vht_nss,
8473 true);
8474 update_bitrate_mask = false;
8475 } else {
8476 vht_pfr = 0;
8477 }
8478
8479 mutex_lock(&ar->conf_mutex);
8480
8481 if (update_bitrate_mask)
8482 arvif->bitrate_mask = *mask;
8483 arvif->vht_num_rates = vht_num_rates;
8484 arvif->vht_pfr = vht_pfr;
8485 ieee80211_iterate_stations_atomic(ar->hw,
8486 ath10k_mac_set_bitrate_mask_iter,
8487 arvif);
8488
8489 mutex_unlock(&ar->conf_mutex);
8490 }
8491
8492 mutex_lock(&ar->conf_mutex);
8493
8494 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
8495 if (ret) {
8496 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
8497 arvif->vdev_id, ret);
8498 goto exit;
8499 }
8500
8501 exit:
8502 mutex_unlock(&ar->conf_mutex);
8503
8504 return ret;
8505 }
8506
ath10k_sta_rc_update(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 changed)8507 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
8508 struct ieee80211_vif *vif,
8509 struct ieee80211_sta *sta,
8510 u32 changed)
8511 {
8512 struct ath10k *ar = hw->priv;
8513 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
8514 struct ath10k_vif *arvif = (void *)vif->drv_priv;
8515 struct ath10k_peer *peer;
8516 u32 bw, smps;
8517
8518 spin_lock_bh(&ar->data_lock);
8519
8520 peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);
8521 if (!peer) {
8522 spin_unlock_bh(&ar->data_lock);
8523 ath10k_warn(ar, "mac sta rc update failed to find peer %pM on vdev %i\n",
8524 sta->addr, arvif->vdev_id);
8525 return;
8526 }
8527
8528 ath10k_dbg(ar, ATH10K_DBG_STA,
8529 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
8530 sta->addr, changed, sta->deflink.bandwidth,
8531 sta->deflink.rx_nss,
8532 sta->deflink.smps_mode);
8533
8534 if (changed & IEEE80211_RC_BW_CHANGED) {
8535 bw = WMI_PEER_CHWIDTH_20MHZ;
8536
8537 switch (sta->deflink.bandwidth) {
8538 case IEEE80211_STA_RX_BW_20:
8539 bw = WMI_PEER_CHWIDTH_20MHZ;
8540 break;
8541 case IEEE80211_STA_RX_BW_40:
8542 bw = WMI_PEER_CHWIDTH_40MHZ;
8543 break;
8544 case IEEE80211_STA_RX_BW_80:
8545 bw = WMI_PEER_CHWIDTH_80MHZ;
8546 break;
8547 case IEEE80211_STA_RX_BW_160:
8548 bw = WMI_PEER_CHWIDTH_160MHZ;
8549 break;
8550 default:
8551 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
8552 sta->deflink.bandwidth, sta->addr);
8553 bw = WMI_PEER_CHWIDTH_20MHZ;
8554 break;
8555 }
8556
8557 arsta->bw = bw;
8558 }
8559
8560 if (changed & IEEE80211_RC_NSS_CHANGED)
8561 arsta->nss = sta->deflink.rx_nss;
8562
8563 if (changed & IEEE80211_RC_SMPS_CHANGED) {
8564 smps = WMI_PEER_SMPS_PS_NONE;
8565
8566 switch (sta->deflink.smps_mode) {
8567 case IEEE80211_SMPS_AUTOMATIC:
8568 case IEEE80211_SMPS_OFF:
8569 smps = WMI_PEER_SMPS_PS_NONE;
8570 break;
8571 case IEEE80211_SMPS_STATIC:
8572 smps = WMI_PEER_SMPS_STATIC;
8573 break;
8574 case IEEE80211_SMPS_DYNAMIC:
8575 smps = WMI_PEER_SMPS_DYNAMIC;
8576 break;
8577 case IEEE80211_SMPS_NUM_MODES:
8578 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
8579 sta->deflink.smps_mode, sta->addr);
8580 smps = WMI_PEER_SMPS_PS_NONE;
8581 break;
8582 }
8583
8584 arsta->smps = smps;
8585 }
8586
8587 arsta->changed |= changed;
8588
8589 spin_unlock_bh(&ar->data_lock);
8590
8591 ieee80211_queue_work(hw, &arsta->update_wk);
8592 }
8593
ath10k_offset_tsf(struct ieee80211_hw * hw,struct ieee80211_vif * vif,s64 tsf_offset)8594 static void ath10k_offset_tsf(struct ieee80211_hw *hw,
8595 struct ieee80211_vif *vif, s64 tsf_offset)
8596 {
8597 struct ath10k *ar = hw->priv;
8598 struct ath10k_vif *arvif = (void *)vif->drv_priv;
8599 u32 offset, vdev_param;
8600 int ret;
8601
8602 if (tsf_offset < 0) {
8603 vdev_param = ar->wmi.vdev_param->dec_tsf;
8604 offset = -tsf_offset;
8605 } else {
8606 vdev_param = ar->wmi.vdev_param->inc_tsf;
8607 offset = tsf_offset;
8608 }
8609
8610 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
8611 vdev_param, offset);
8612
8613 if (ret && ret != -EOPNOTSUPP)
8614 ath10k_warn(ar, "failed to set tsf offset %d cmd %d: %d\n",
8615 offset, vdev_param, ret);
8616 }
8617
ath10k_ampdu_action(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_ampdu_params * params)8618 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
8619 struct ieee80211_vif *vif,
8620 struct ieee80211_ampdu_params *params)
8621 {
8622 struct ath10k *ar = hw->priv;
8623 struct ath10k_vif *arvif = (void *)vif->drv_priv;
8624 struct ieee80211_sta *sta = params->sta;
8625 enum ieee80211_ampdu_mlme_action action = params->action;
8626 u16 tid = params->tid;
8627
8628 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %u action %d\n",
8629 arvif->vdev_id, sta->addr, tid, action);
8630
8631 switch (action) {
8632 case IEEE80211_AMPDU_RX_START:
8633 case IEEE80211_AMPDU_RX_STOP:
8634 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
8635 * creation/removal. Do we need to verify this?
8636 */
8637 return 0;
8638 case IEEE80211_AMPDU_TX_START:
8639 case IEEE80211_AMPDU_TX_STOP_CONT:
8640 case IEEE80211_AMPDU_TX_STOP_FLUSH:
8641 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
8642 case IEEE80211_AMPDU_TX_OPERATIONAL:
8643 /* Firmware offloads Tx aggregation entirely so deny mac80211
8644 * Tx aggregation requests.
8645 */
8646 return -EOPNOTSUPP;
8647 }
8648
8649 return -EINVAL;
8650 }
8651
8652 static void
ath10k_mac_update_rx_channel(struct ath10k * ar,struct ieee80211_chanctx_conf * ctx,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs)8653 ath10k_mac_update_rx_channel(struct ath10k *ar,
8654 struct ieee80211_chanctx_conf *ctx,
8655 struct ieee80211_vif_chanctx_switch *vifs,
8656 int n_vifs)
8657 {
8658 struct cfg80211_chan_def *def = NULL;
8659
8660 /* Both locks are required because ar->rx_channel is modified. This
8661 * allows readers to hold either lock.
8662 */
8663 lockdep_assert_held(&ar->conf_mutex);
8664 lockdep_assert_held(&ar->data_lock);
8665
8666 WARN_ON(ctx && vifs);
8667 WARN_ON(vifs && !n_vifs);
8668
8669 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
8670 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
8671 * ppdu on Rx may reduce performance on low-end systems. It should be
8672 * possible to make tables/hashmaps to speed the lookup up (be vary of
8673 * cpu data cache lines though regarding sizes) but to keep the initial
8674 * implementation simple and less intrusive fallback to the slow lookup
8675 * only for multi-channel cases. Single-channel cases will remain to
8676 * use the old channel derival and thus performance should not be
8677 * affected much.
8678 */
8679 rcu_read_lock();
8680 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
8681 ieee80211_iter_chan_contexts_atomic(ar->hw,
8682 ath10k_mac_get_any_chandef_iter,
8683 &def);
8684
8685 if (vifs)
8686 def = &vifs[0].new_ctx->def;
8687
8688 ar->rx_channel = def->chan;
8689 } else if ((ctx && ath10k_mac_num_chanctxs(ar) == 0) ||
8690 (ctx && (ar->state == ATH10K_STATE_RESTARTED))) {
8691 /* During driver restart due to firmware assert, since mac80211
8692 * already has valid channel context for given radio, channel
8693 * context iteration return num_chanctx > 0. So fix rx_channel
8694 * when restart is in progress.
8695 */
8696 ar->rx_channel = ctx->def.chan;
8697 } else {
8698 ar->rx_channel = NULL;
8699 }
8700 rcu_read_unlock();
8701 }
8702
8703 static void
ath10k_mac_update_vif_chan(struct ath10k * ar,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs)8704 ath10k_mac_update_vif_chan(struct ath10k *ar,
8705 struct ieee80211_vif_chanctx_switch *vifs,
8706 int n_vifs)
8707 {
8708 struct ath10k_vif *arvif;
8709 int ret;
8710 int i;
8711
8712 lockdep_assert_held(&ar->conf_mutex);
8713
8714 /* First stop monitor interface. Some FW versions crash if there's a
8715 * lone monitor interface.
8716 */
8717 if (ar->monitor_started)
8718 ath10k_monitor_stop(ar);
8719
8720 for (i = 0; i < n_vifs; i++) {
8721 arvif = (void *)vifs[i].vif->drv_priv;
8722
8723 ath10k_dbg(ar, ATH10K_DBG_MAC,
8724 "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n",
8725 arvif->vdev_id,
8726 vifs[i].old_ctx->def.chan->center_freq,
8727 vifs[i].new_ctx->def.chan->center_freq,
8728 vifs[i].old_ctx->def.width,
8729 vifs[i].new_ctx->def.width);
8730
8731 if (WARN_ON(!arvif->is_started))
8732 continue;
8733
8734 if (WARN_ON(!arvif->is_up))
8735 continue;
8736
8737 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
8738 if (ret) {
8739 ath10k_warn(ar, "failed to down vdev %d: %d\n",
8740 arvif->vdev_id, ret);
8741 continue;
8742 }
8743 }
8744
8745 /* All relevant vdevs are downed and associated channel resources
8746 * should be available for the channel switch now.
8747 */
8748
8749 spin_lock_bh(&ar->data_lock);
8750 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
8751 spin_unlock_bh(&ar->data_lock);
8752
8753 for (i = 0; i < n_vifs; i++) {
8754 arvif = (void *)vifs[i].vif->drv_priv;
8755
8756 if (WARN_ON(!arvif->is_started))
8757 continue;
8758
8759 if (WARN_ON(!arvif->is_up))
8760 continue;
8761
8762 ret = ath10k_mac_setup_bcn_tmpl(arvif);
8763 if (ret)
8764 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
8765 ret);
8766
8767 ret = ath10k_mac_setup_prb_tmpl(arvif);
8768 if (ret)
8769 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
8770 ret);
8771
8772 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
8773 if (ret) {
8774 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
8775 arvif->vdev_id, ret);
8776 continue;
8777 }
8778
8779 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
8780 arvif->bssid);
8781 if (ret) {
8782 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
8783 arvif->vdev_id, ret);
8784 continue;
8785 }
8786 }
8787
8788 ath10k_monitor_recalc(ar);
8789 }
8790
8791 static int
ath10k_mac_op_add_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx)8792 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
8793 struct ieee80211_chanctx_conf *ctx)
8794 {
8795 struct ath10k *ar = hw->priv;
8796
8797 ath10k_dbg(ar, ATH10K_DBG_MAC,
8798 "mac chanctx add freq %u width %d ptr %pK\n",
8799 ctx->def.chan->center_freq, ctx->def.width, ctx);
8800
8801 mutex_lock(&ar->conf_mutex);
8802
8803 spin_lock_bh(&ar->data_lock);
8804 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
8805 spin_unlock_bh(&ar->data_lock);
8806
8807 ath10k_recalc_radar_detection(ar);
8808 ath10k_monitor_recalc(ar);
8809
8810 mutex_unlock(&ar->conf_mutex);
8811
8812 return 0;
8813 }
8814
8815 static void
ath10k_mac_op_remove_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx)8816 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
8817 struct ieee80211_chanctx_conf *ctx)
8818 {
8819 struct ath10k *ar = hw->priv;
8820
8821 ath10k_dbg(ar, ATH10K_DBG_MAC,
8822 "mac chanctx remove freq %u width %d ptr %pK\n",
8823 ctx->def.chan->center_freq, ctx->def.width, ctx);
8824
8825 mutex_lock(&ar->conf_mutex);
8826
8827 spin_lock_bh(&ar->data_lock);
8828 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
8829 spin_unlock_bh(&ar->data_lock);
8830
8831 ath10k_recalc_radar_detection(ar);
8832 ath10k_monitor_recalc(ar);
8833
8834 mutex_unlock(&ar->conf_mutex);
8835 }
8836
8837 struct ath10k_mac_change_chanctx_arg {
8838 struct ieee80211_chanctx_conf *ctx;
8839 struct ieee80211_vif_chanctx_switch *vifs;
8840 int n_vifs;
8841 int next_vif;
8842 };
8843
8844 static void
ath10k_mac_change_chanctx_cnt_iter(void * data,u8 * mac,struct ieee80211_vif * vif)8845 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
8846 struct ieee80211_vif *vif)
8847 {
8848 struct ath10k_mac_change_chanctx_arg *arg = data;
8849
8850 if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
8851 return;
8852
8853 arg->n_vifs++;
8854 }
8855
8856 static void
ath10k_mac_change_chanctx_fill_iter(void * data,u8 * mac,struct ieee80211_vif * vif)8857 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
8858 struct ieee80211_vif *vif)
8859 {
8860 struct ath10k_mac_change_chanctx_arg *arg = data;
8861 struct ieee80211_chanctx_conf *ctx;
8862
8863 ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
8864 if (ctx != arg->ctx)
8865 return;
8866
8867 if (WARN_ON(arg->next_vif == arg->n_vifs))
8868 return;
8869
8870 arg->vifs[arg->next_vif].vif = vif;
8871 arg->vifs[arg->next_vif].old_ctx = ctx;
8872 arg->vifs[arg->next_vif].new_ctx = ctx;
8873 arg->next_vif++;
8874 }
8875
8876 static void
ath10k_mac_op_change_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx,u32 changed)8877 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
8878 struct ieee80211_chanctx_conf *ctx,
8879 u32 changed)
8880 {
8881 struct ath10k *ar = hw->priv;
8882 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
8883
8884 mutex_lock(&ar->conf_mutex);
8885
8886 ath10k_dbg(ar, ATH10K_DBG_MAC,
8887 "mac chanctx change freq %u width %d ptr %pK changed %x\n",
8888 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
8889
8890 /* This shouldn't really happen because channel switching should use
8891 * switch_vif_chanctx().
8892 */
8893 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
8894 goto unlock;
8895
8896 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
8897 ieee80211_iterate_active_interfaces_atomic(
8898 hw,
8899 ATH10K_ITER_NORMAL_FLAGS,
8900 ath10k_mac_change_chanctx_cnt_iter,
8901 &arg);
8902 if (arg.n_vifs == 0)
8903 goto radar;
8904
8905 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
8906 GFP_KERNEL);
8907 if (!arg.vifs)
8908 goto radar;
8909
8910 ieee80211_iterate_active_interfaces_atomic(
8911 hw,
8912 ATH10K_ITER_NORMAL_FLAGS,
8913 ath10k_mac_change_chanctx_fill_iter,
8914 &arg);
8915 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
8916 kfree(arg.vifs);
8917 }
8918
8919 radar:
8920 ath10k_recalc_radar_detection(ar);
8921
8922 /* FIXME: How to configure Rx chains properly? */
8923
8924 /* No other actions are actually necessary. Firmware maintains channel
8925 * definitions per vdev internally and there's no host-side channel
8926 * context abstraction to configure, e.g. channel width.
8927 */
8928
8929 unlock:
8930 mutex_unlock(&ar->conf_mutex);
8931 }
8932
8933 static int
ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * link_conf,struct ieee80211_chanctx_conf * ctx)8934 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
8935 struct ieee80211_vif *vif,
8936 struct ieee80211_bss_conf *link_conf,
8937 struct ieee80211_chanctx_conf *ctx)
8938 {
8939 struct ath10k *ar = hw->priv;
8940 struct ath10k_vif *arvif = (void *)vif->drv_priv;
8941 int ret;
8942
8943 mutex_lock(&ar->conf_mutex);
8944
8945 ath10k_dbg(ar, ATH10K_DBG_MAC,
8946 "mac chanctx assign ptr %pK vdev_id %i\n",
8947 ctx, arvif->vdev_id);
8948
8949 if (WARN_ON(arvif->is_started)) {
8950 mutex_unlock(&ar->conf_mutex);
8951 return -EBUSY;
8952 }
8953
8954 ret = ath10k_vdev_start(arvif, &ctx->def);
8955 if (ret) {
8956 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
8957 arvif->vdev_id, vif->addr,
8958 ctx->def.chan->center_freq, ret);
8959 goto err;
8960 }
8961
8962 arvif->is_started = true;
8963
8964 ret = ath10k_mac_vif_setup_ps(arvif);
8965 if (ret) {
8966 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
8967 arvif->vdev_id, ret);
8968 goto err_stop;
8969 }
8970
8971 if (vif->type == NL80211_IFTYPE_MONITOR) {
8972 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
8973 if (ret) {
8974 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
8975 arvif->vdev_id, ret);
8976 goto err_stop;
8977 }
8978
8979 arvif->is_up = true;
8980 }
8981
8982 if (ath10k_mac_can_set_cts_prot(arvif)) {
8983 ret = ath10k_mac_set_cts_prot(arvif);
8984 if (ret)
8985 ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n",
8986 arvif->vdev_id, ret);
8987 }
8988
8989 if (ath10k_peer_stats_enabled(ar) &&
8990 ar->hw_params.tx_stats_over_pktlog) {
8991 ar->pktlog_filter |= ATH10K_PKTLOG_PEER_STATS;
8992 ret = ath10k_wmi_pdev_pktlog_enable(ar,
8993 ar->pktlog_filter);
8994 if (ret) {
8995 ath10k_warn(ar, "failed to enable pktlog %d\n", ret);
8996 goto err_stop;
8997 }
8998 }
8999
9000 mutex_unlock(&ar->conf_mutex);
9001 return 0;
9002
9003 err_stop:
9004 ath10k_vdev_stop(arvif);
9005 arvif->is_started = false;
9006 ath10k_mac_vif_setup_ps(arvif);
9007
9008 err:
9009 mutex_unlock(&ar->conf_mutex);
9010 return ret;
9011 }
9012
9013 static void
ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * link_conf,struct ieee80211_chanctx_conf * ctx)9014 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
9015 struct ieee80211_vif *vif,
9016 struct ieee80211_bss_conf *link_conf,
9017 struct ieee80211_chanctx_conf *ctx)
9018 {
9019 struct ath10k *ar = hw->priv;
9020 struct ath10k_vif *arvif = (void *)vif->drv_priv;
9021 int ret;
9022
9023 mutex_lock(&ar->conf_mutex);
9024
9025 ath10k_dbg(ar, ATH10K_DBG_MAC,
9026 "mac chanctx unassign ptr %pK vdev_id %i\n",
9027 ctx, arvif->vdev_id);
9028
9029 WARN_ON(!arvif->is_started);
9030
9031 if (vif->type == NL80211_IFTYPE_MONITOR) {
9032 WARN_ON(!arvif->is_up);
9033
9034 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
9035 if (ret)
9036 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
9037 arvif->vdev_id, ret);
9038
9039 arvif->is_up = false;
9040 }
9041
9042 ret = ath10k_vdev_stop(arvif);
9043 if (ret)
9044 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
9045 arvif->vdev_id, ret);
9046
9047 arvif->is_started = false;
9048
9049 mutex_unlock(&ar->conf_mutex);
9050 }
9051
9052 static int
ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs,enum ieee80211_chanctx_switch_mode mode)9053 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
9054 struct ieee80211_vif_chanctx_switch *vifs,
9055 int n_vifs,
9056 enum ieee80211_chanctx_switch_mode mode)
9057 {
9058 struct ath10k *ar = hw->priv;
9059
9060 mutex_lock(&ar->conf_mutex);
9061
9062 ath10k_dbg(ar, ATH10K_DBG_MAC,
9063 "mac chanctx switch n_vifs %d mode %d\n",
9064 n_vifs, mode);
9065 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
9066
9067 mutex_unlock(&ar->conf_mutex);
9068 return 0;
9069 }
9070
ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)9071 static void ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw *hw,
9072 struct ieee80211_vif *vif,
9073 struct ieee80211_sta *sta)
9074 {
9075 struct ath10k *ar;
9076 struct ath10k_peer *peer;
9077
9078 ar = hw->priv;
9079
9080 list_for_each_entry(peer, &ar->peers, list)
9081 if (peer->sta == sta)
9082 peer->removed = true;
9083 }
9084
9085 /* HT MCS parameters with Nss = 1 */
9086 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss1[] = {
9087 /* MCS L20 L40 S20 S40 */
9088 {0, { 65, 135, 72, 150} },
9089 {1, { 130, 270, 144, 300} },
9090 {2, { 195, 405, 217, 450} },
9091 {3, { 260, 540, 289, 600} },
9092 {4, { 390, 810, 433, 900} },
9093 {5, { 520, 1080, 578, 1200} },
9094 {6, { 585, 1215, 650, 1350} },
9095 {7, { 650, 1350, 722, 1500} }
9096 };
9097
9098 /* HT MCS parameters with Nss = 2 */
9099 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss2[] = {
9100 /* MCS L20 L40 S20 S40 */
9101 {0, {130, 270, 144, 300} },
9102 {1, {260, 540, 289, 600} },
9103 {2, {390, 810, 433, 900} },
9104 {3, {520, 1080, 578, 1200} },
9105 {4, {780, 1620, 867, 1800} },
9106 {5, {1040, 2160, 1156, 2400} },
9107 {6, {1170, 2430, 1300, 2700} },
9108 {7, {1300, 2700, 1444, 3000} }
9109 };
9110
9111 /* MCS parameters with Nss = 1 */
9112 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss1[] = {
9113 /* MCS L80 S80 L40 S40 L20 S20 */
9114 {0, {293, 325}, {135, 150}, {65, 72} },
9115 {1, {585, 650}, {270, 300}, {130, 144} },
9116 {2, {878, 975}, {405, 450}, {195, 217} },
9117 {3, {1170, 1300}, {540, 600}, {260, 289} },
9118 {4, {1755, 1950}, {810, 900}, {390, 433} },
9119 {5, {2340, 2600}, {1080, 1200}, {520, 578} },
9120 {6, {2633, 2925}, {1215, 1350}, {585, 650} },
9121 {7, {2925, 3250}, {1350, 1500}, {650, 722} },
9122 {8, {3510, 3900}, {1620, 1800}, {780, 867} },
9123 {9, {3900, 4333}, {1800, 2000}, {780, 867} }
9124 };
9125
9126 /*MCS parameters with Nss = 2 */
9127 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss2[] = {
9128 /* MCS L80 S80 L40 S40 L20 S20 */
9129 {0, {585, 650}, {270, 300}, {130, 144} },
9130 {1, {1170, 1300}, {540, 600}, {260, 289} },
9131 {2, {1755, 1950}, {810, 900}, {390, 433} },
9132 {3, {2340, 2600}, {1080, 1200}, {520, 578} },
9133 {4, {3510, 3900}, {1620, 1800}, {780, 867} },
9134 {5, {4680, 5200}, {2160, 2400}, {1040, 1156} },
9135 {6, {5265, 5850}, {2430, 2700}, {1170, 1300} },
9136 {7, {5850, 6500}, {2700, 3000}, {1300, 1444} },
9137 {8, {7020, 7800}, {3240, 3600}, {1560, 1733} },
9138 {9, {7800, 8667}, {3600, 4000}, {1560, 1733} }
9139 };
9140
ath10k_mac_get_rate_flags_ht(struct ath10k * ar,u32 rate,u8 nss,u8 mcs,u8 * flags,u8 * bw)9141 static void ath10k_mac_get_rate_flags_ht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs,
9142 u8 *flags, u8 *bw)
9143 {
9144 struct ath10k_index_ht_data_rate_type *mcs_rate;
9145 u8 index;
9146 size_t len_nss1 = ARRAY_SIZE(supported_ht_mcs_rate_nss1);
9147 size_t len_nss2 = ARRAY_SIZE(supported_ht_mcs_rate_nss2);
9148
9149 if (mcs >= (len_nss1 + len_nss2)) {
9150 ath10k_warn(ar, "not supported mcs %d in current rate table", mcs);
9151 return;
9152 }
9153
9154 mcs_rate = (struct ath10k_index_ht_data_rate_type *)
9155 ((nss == 1) ? &supported_ht_mcs_rate_nss1 :
9156 &supported_ht_mcs_rate_nss2);
9157
9158 if (mcs >= len_nss1)
9159 index = mcs - len_nss1;
9160 else
9161 index = mcs;
9162
9163 if (rate == mcs_rate[index].supported_rate[0]) {
9164 *bw = RATE_INFO_BW_20;
9165 } else if (rate == mcs_rate[index].supported_rate[1]) {
9166 *bw |= RATE_INFO_BW_40;
9167 } else if (rate == mcs_rate[index].supported_rate[2]) {
9168 *bw |= RATE_INFO_BW_20;
9169 *flags |= RATE_INFO_FLAGS_SHORT_GI;
9170 } else if (rate == mcs_rate[index].supported_rate[3]) {
9171 *bw |= RATE_INFO_BW_40;
9172 *flags |= RATE_INFO_FLAGS_SHORT_GI;
9173 } else {
9174 ath10k_warn(ar, "invalid ht params rate %d 100kbps nss %d mcs %d",
9175 rate, nss, mcs);
9176 }
9177 }
9178
ath10k_mac_get_rate_flags_vht(struct ath10k * ar,u32 rate,u8 nss,u8 mcs,u8 * flags,u8 * bw)9179 static void ath10k_mac_get_rate_flags_vht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs,
9180 u8 *flags, u8 *bw)
9181 {
9182 struct ath10k_index_vht_data_rate_type *mcs_rate;
9183
9184 mcs_rate = (struct ath10k_index_vht_data_rate_type *)
9185 ((nss == 1) ? &supported_vht_mcs_rate_nss1 :
9186 &supported_vht_mcs_rate_nss2);
9187
9188 if (rate == mcs_rate[mcs].supported_VHT80_rate[0]) {
9189 *bw = RATE_INFO_BW_80;
9190 } else if (rate == mcs_rate[mcs].supported_VHT80_rate[1]) {
9191 *bw = RATE_INFO_BW_80;
9192 *flags |= RATE_INFO_FLAGS_SHORT_GI;
9193 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[0]) {
9194 *bw = RATE_INFO_BW_40;
9195 } else if (rate == mcs_rate[mcs].supported_VHT40_rate[1]) {
9196 *bw = RATE_INFO_BW_40;
9197 *flags |= RATE_INFO_FLAGS_SHORT_GI;
9198 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[0]) {
9199 *bw = RATE_INFO_BW_20;
9200 } else if (rate == mcs_rate[mcs].supported_VHT20_rate[1]) {
9201 *bw = RATE_INFO_BW_20;
9202 *flags |= RATE_INFO_FLAGS_SHORT_GI;
9203 } else {
9204 ath10k_warn(ar, "invalid vht params rate %d 100kbps nss %d mcs %d",
9205 rate, nss, mcs);
9206 }
9207 }
9208
ath10k_mac_get_rate_flags(struct ath10k * ar,u32 rate,enum ath10k_phy_mode mode,u8 nss,u8 mcs,u8 * flags,u8 * bw)9209 static void ath10k_mac_get_rate_flags(struct ath10k *ar, u32 rate,
9210 enum ath10k_phy_mode mode, u8 nss, u8 mcs,
9211 u8 *flags, u8 *bw)
9212 {
9213 if (mode == ATH10K_PHY_MODE_HT) {
9214 *flags = RATE_INFO_FLAGS_MCS;
9215 ath10k_mac_get_rate_flags_ht(ar, rate, nss, mcs, flags, bw);
9216 } else if (mode == ATH10K_PHY_MODE_VHT) {
9217 *flags = RATE_INFO_FLAGS_VHT_MCS;
9218 ath10k_mac_get_rate_flags_vht(ar, rate, nss, mcs, flags, bw);
9219 }
9220 }
9221
ath10k_mac_parse_bitrate(struct ath10k * ar,u32 rate_code,u32 bitrate_kbps,struct rate_info * rate)9222 static void ath10k_mac_parse_bitrate(struct ath10k *ar, u32 rate_code,
9223 u32 bitrate_kbps, struct rate_info *rate)
9224 {
9225 enum ath10k_phy_mode mode = ATH10K_PHY_MODE_LEGACY;
9226 enum wmi_rate_preamble preamble = WMI_TLV_GET_HW_RC_PREAM_V1(rate_code);
9227 u8 nss = WMI_TLV_GET_HW_RC_NSS_V1(rate_code) + 1;
9228 u8 mcs = WMI_TLV_GET_HW_RC_RATE_V1(rate_code);
9229 u8 flags = 0, bw = 0;
9230
9231 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac parse rate code 0x%x bitrate %d kbps\n",
9232 rate_code, bitrate_kbps);
9233
9234 if (preamble == WMI_RATE_PREAMBLE_HT)
9235 mode = ATH10K_PHY_MODE_HT;
9236 else if (preamble == WMI_RATE_PREAMBLE_VHT)
9237 mode = ATH10K_PHY_MODE_VHT;
9238
9239 ath10k_mac_get_rate_flags(ar, bitrate_kbps / 100, mode, nss, mcs, &flags, &bw);
9240
9241 ath10k_dbg(ar, ATH10K_DBG_MAC,
9242 "mac parse bitrate preamble %d mode %d nss %d mcs %d flags %x bw %d\n",
9243 preamble, mode, nss, mcs, flags, bw);
9244
9245 rate->flags = flags;
9246 rate->bw = bw;
9247 rate->legacy = bitrate_kbps / 100;
9248 rate->nss = nss;
9249 rate->mcs = mcs;
9250 }
9251
ath10k_mac_sta_get_peer_stats_info(struct ath10k * ar,struct ieee80211_sta * sta,struct station_info * sinfo)9252 static void ath10k_mac_sta_get_peer_stats_info(struct ath10k *ar,
9253 struct ieee80211_sta *sta,
9254 struct station_info *sinfo)
9255 {
9256 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
9257 struct ath10k_peer *peer;
9258 unsigned long time_left;
9259 int ret;
9260
9261 if (!(ar->hw_params.supports_peer_stats_info &&
9262 arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA))
9263 return;
9264
9265 spin_lock_bh(&ar->data_lock);
9266 peer = ath10k_peer_find(ar, arsta->arvif->vdev_id, sta->addr);
9267 spin_unlock_bh(&ar->data_lock);
9268 if (!peer)
9269 return;
9270
9271 reinit_completion(&ar->peer_stats_info_complete);
9272
9273 ret = ath10k_wmi_request_peer_stats_info(ar,
9274 arsta->arvif->vdev_id,
9275 WMI_REQUEST_ONE_PEER_STATS_INFO,
9276 arsta->arvif->bssid,
9277 0);
9278 if (ret && ret != -EOPNOTSUPP) {
9279 ath10k_warn(ar, "could not request peer stats info: %d\n", ret);
9280 return;
9281 }
9282
9283 time_left = wait_for_completion_timeout(&ar->peer_stats_info_complete, 3 * HZ);
9284 if (time_left == 0) {
9285 ath10k_warn(ar, "timed out waiting peer stats info\n");
9286 return;
9287 }
9288
9289 if (arsta->rx_rate_code != 0 && arsta->rx_bitrate_kbps != 0) {
9290 ath10k_mac_parse_bitrate(ar, arsta->rx_rate_code,
9291 arsta->rx_bitrate_kbps,
9292 &sinfo->rxrate);
9293
9294 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
9295 arsta->rx_rate_code = 0;
9296 arsta->rx_bitrate_kbps = 0;
9297 }
9298
9299 if (arsta->tx_rate_code != 0 && arsta->tx_bitrate_kbps != 0) {
9300 ath10k_mac_parse_bitrate(ar, arsta->tx_rate_code,
9301 arsta->tx_bitrate_kbps,
9302 &sinfo->txrate);
9303
9304 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
9305 arsta->tx_rate_code = 0;
9306 arsta->tx_bitrate_kbps = 0;
9307 }
9308 }
9309
ath10k_sta_statistics(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct station_info * sinfo)9310 static void ath10k_sta_statistics(struct ieee80211_hw *hw,
9311 struct ieee80211_vif *vif,
9312 struct ieee80211_sta *sta,
9313 struct station_info *sinfo)
9314 {
9315 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
9316 struct ath10k *ar = arsta->arvif->ar;
9317
9318 if (!ath10k_peer_stats_enabled(ar))
9319 return;
9320
9321 mutex_lock(&ar->conf_mutex);
9322 ath10k_debug_fw_stats_request(ar);
9323 mutex_unlock(&ar->conf_mutex);
9324
9325 sinfo->rx_duration = arsta->rx_duration;
9326 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
9327
9328 if (arsta->txrate.legacy || arsta->txrate.nss) {
9329 if (arsta->txrate.legacy) {
9330 sinfo->txrate.legacy = arsta->txrate.legacy;
9331 } else {
9332 sinfo->txrate.mcs = arsta->txrate.mcs;
9333 sinfo->txrate.nss = arsta->txrate.nss;
9334 sinfo->txrate.bw = arsta->txrate.bw;
9335 }
9336 sinfo->txrate.flags = arsta->txrate.flags;
9337 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
9338 }
9339
9340 if (ar->htt.disable_tx_comp) {
9341 sinfo->tx_failed = arsta->tx_failed;
9342 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
9343 }
9344
9345 sinfo->tx_retries = arsta->tx_retries;
9346 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);
9347
9348 ath10k_mac_sta_get_peer_stats_info(ar, sta, sinfo);
9349 }
9350
ath10k_mac_op_set_tid_config(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct cfg80211_tid_config * tid_config)9351 static int ath10k_mac_op_set_tid_config(struct ieee80211_hw *hw,
9352 struct ieee80211_vif *vif,
9353 struct ieee80211_sta *sta,
9354 struct cfg80211_tid_config *tid_config)
9355 {
9356 struct ath10k *ar = hw->priv;
9357 struct ath10k_vif *arvif = (void *)vif->drv_priv;
9358 struct ath10k_mac_iter_tid_conf_data data = {};
9359 struct wmi_per_peer_per_tid_cfg_arg arg = {};
9360 int ret, i;
9361
9362 mutex_lock(&ar->conf_mutex);
9363 arg.vdev_id = arvif->vdev_id;
9364
9365 arvif->tids_rst = 0;
9366 memset(arvif->tid_conf_changed, 0, sizeof(arvif->tid_conf_changed));
9367
9368 for (i = 0; i < tid_config->n_tid_conf; i++) {
9369 ret = ath10k_mac_parse_tid_config(ar, sta, vif,
9370 &tid_config->tid_conf[i],
9371 &arg);
9372 if (ret)
9373 goto exit;
9374 }
9375
9376 ret = 0;
9377
9378 if (sta)
9379 goto exit;
9380
9381 arvif->tids_rst = 0;
9382 data.curr_vif = vif;
9383 data.ar = ar;
9384
9385 ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf,
9386 &data);
9387
9388 exit:
9389 mutex_unlock(&ar->conf_mutex);
9390 return ret;
9391 }
9392
ath10k_mac_op_reset_tid_config(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u8 tids)9393 static int ath10k_mac_op_reset_tid_config(struct ieee80211_hw *hw,
9394 struct ieee80211_vif *vif,
9395 struct ieee80211_sta *sta,
9396 u8 tids)
9397 {
9398 struct ath10k_vif *arvif = (void *)vif->drv_priv;
9399 struct ath10k_mac_iter_tid_conf_data data = {};
9400 struct ath10k *ar = hw->priv;
9401 int ret = 0;
9402
9403 mutex_lock(&ar->conf_mutex);
9404
9405 if (sta) {
9406 arvif->tids_rst = 0;
9407 ret = ath10k_mac_reset_tid_config(ar, sta, arvif, tids);
9408 goto exit;
9409 }
9410
9411 arvif->tids_rst = tids;
9412 data.curr_vif = vif;
9413 data.ar = ar;
9414 ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf,
9415 &data);
9416
9417 exit:
9418 mutex_unlock(&ar->conf_mutex);
9419 return ret;
9420 }
9421
9422 static const struct ieee80211_ops ath10k_ops = {
9423 .tx = ath10k_mac_op_tx,
9424 .wake_tx_queue = ath10k_mac_op_wake_tx_queue,
9425 .start = ath10k_start,
9426 .stop = ath10k_stop,
9427 .config = ath10k_config,
9428 .add_interface = ath10k_add_interface,
9429 .update_vif_offload = ath10k_update_vif_offload,
9430 .remove_interface = ath10k_remove_interface,
9431 .configure_filter = ath10k_configure_filter,
9432 .bss_info_changed = ath10k_bss_info_changed,
9433 .set_coverage_class = ath10k_mac_op_set_coverage_class,
9434 .hw_scan = ath10k_hw_scan,
9435 .cancel_hw_scan = ath10k_cancel_hw_scan,
9436 .set_key = ath10k_set_key,
9437 .set_default_unicast_key = ath10k_set_default_unicast_key,
9438 .sta_state = ath10k_sta_state,
9439 .sta_set_txpwr = ath10k_sta_set_txpwr,
9440 .conf_tx = ath10k_conf_tx,
9441 .remain_on_channel = ath10k_remain_on_channel,
9442 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
9443 .set_rts_threshold = ath10k_set_rts_threshold,
9444 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,
9445 .flush = ath10k_flush,
9446 .tx_last_beacon = ath10k_tx_last_beacon,
9447 .set_antenna = ath10k_set_antenna,
9448 .get_antenna = ath10k_get_antenna,
9449 .reconfig_complete = ath10k_reconfig_complete,
9450 .get_survey = ath10k_get_survey,
9451 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,
9452 .sta_rc_update = ath10k_sta_rc_update,
9453 .offset_tsf = ath10k_offset_tsf,
9454 .ampdu_action = ath10k_ampdu_action,
9455 .get_et_sset_count = ath10k_debug_get_et_sset_count,
9456 .get_et_stats = ath10k_debug_get_et_stats,
9457 .get_et_strings = ath10k_debug_get_et_strings,
9458 .add_chanctx = ath10k_mac_op_add_chanctx,
9459 .remove_chanctx = ath10k_mac_op_remove_chanctx,
9460 .change_chanctx = ath10k_mac_op_change_chanctx,
9461 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,
9462 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,
9463 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,
9464 .sta_pre_rcu_remove = ath10k_mac_op_sta_pre_rcu_remove,
9465 .sta_statistics = ath10k_sta_statistics,
9466 .set_tid_config = ath10k_mac_op_set_tid_config,
9467 .reset_tid_config = ath10k_mac_op_reset_tid_config,
9468
9469 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
9470
9471 #ifdef CONFIG_PM
9472 .suspend = ath10k_wow_op_suspend,
9473 .resume = ath10k_wow_op_resume,
9474 .set_wakeup = ath10k_wow_op_set_wakeup,
9475 #endif
9476 #ifdef CONFIG_MAC80211_DEBUGFS
9477 .sta_add_debugfs = ath10k_sta_add_debugfs,
9478 #endif
9479 .set_sar_specs = ath10k_mac_set_sar_specs,
9480 };
9481
9482 #define CHAN2G(_channel, _freq, _flags) { \
9483 .band = NL80211_BAND_2GHZ, \
9484 .hw_value = (_channel), \
9485 .center_freq = (_freq), \
9486 .flags = (_flags), \
9487 .max_antenna_gain = 0, \
9488 .max_power = 30, \
9489 }
9490
9491 #define CHAN5G(_channel, _freq, _flags) { \
9492 .band = NL80211_BAND_5GHZ, \
9493 .hw_value = (_channel), \
9494 .center_freq = (_freq), \
9495 .flags = (_flags), \
9496 .max_antenna_gain = 0, \
9497 .max_power = 30, \
9498 }
9499
9500 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
9501 CHAN2G(1, 2412, 0),
9502 CHAN2G(2, 2417, 0),
9503 CHAN2G(3, 2422, 0),
9504 CHAN2G(4, 2427, 0),
9505 CHAN2G(5, 2432, 0),
9506 CHAN2G(6, 2437, 0),
9507 CHAN2G(7, 2442, 0),
9508 CHAN2G(8, 2447, 0),
9509 CHAN2G(9, 2452, 0),
9510 CHAN2G(10, 2457, 0),
9511 CHAN2G(11, 2462, 0),
9512 CHAN2G(12, 2467, 0),
9513 CHAN2G(13, 2472, 0),
9514 CHAN2G(14, 2484, 0),
9515 };
9516
9517 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
9518 CHAN5G(36, 5180, 0),
9519 CHAN5G(40, 5200, 0),
9520 CHAN5G(44, 5220, 0),
9521 CHAN5G(48, 5240, 0),
9522 CHAN5G(52, 5260, 0),
9523 CHAN5G(56, 5280, 0),
9524 CHAN5G(60, 5300, 0),
9525 CHAN5G(64, 5320, 0),
9526 CHAN5G(100, 5500, 0),
9527 CHAN5G(104, 5520, 0),
9528 CHAN5G(108, 5540, 0),
9529 CHAN5G(112, 5560, 0),
9530 CHAN5G(116, 5580, 0),
9531 CHAN5G(120, 5600, 0),
9532 CHAN5G(124, 5620, 0),
9533 CHAN5G(128, 5640, 0),
9534 CHAN5G(132, 5660, 0),
9535 CHAN5G(136, 5680, 0),
9536 CHAN5G(140, 5700, 0),
9537 CHAN5G(144, 5720, 0),
9538 CHAN5G(149, 5745, 0),
9539 CHAN5G(153, 5765, 0),
9540 CHAN5G(157, 5785, 0),
9541 CHAN5G(161, 5805, 0),
9542 CHAN5G(165, 5825, 0),
9543 CHAN5G(169, 5845, 0),
9544 CHAN5G(173, 5865, 0),
9545 /* If you add more, you may need to change ATH10K_MAX_5G_CHAN */
9546 /* And you will definitely need to change ATH10K_NUM_CHANS in core.h */
9547 };
9548
ath10k_mac_create(size_t priv_size)9549 struct ath10k *ath10k_mac_create(size_t priv_size)
9550 {
9551 struct ieee80211_hw *hw;
9552 struct ieee80211_ops *ops;
9553 struct ath10k *ar;
9554
9555 ops = kmemdup(&ath10k_ops, sizeof(ath10k_ops), GFP_KERNEL);
9556 if (!ops)
9557 return NULL;
9558
9559 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, ops);
9560 if (!hw) {
9561 kfree(ops);
9562 return NULL;
9563 }
9564
9565 ar = hw->priv;
9566 ar->hw = hw;
9567 ar->ops = ops;
9568
9569 return ar;
9570 }
9571
ath10k_mac_destroy(struct ath10k * ar)9572 void ath10k_mac_destroy(struct ath10k *ar)
9573 {
9574 struct ieee80211_ops *ops = ar->ops;
9575
9576 ieee80211_free_hw(ar->hw);
9577 kfree(ops);
9578 }
9579
9580 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
9581 {
9582 .max = 8,
9583 .types = BIT(NL80211_IFTYPE_STATION)
9584 | BIT(NL80211_IFTYPE_P2P_CLIENT)
9585 },
9586 {
9587 .max = 3,
9588 .types = BIT(NL80211_IFTYPE_P2P_GO)
9589 },
9590 {
9591 .max = 1,
9592 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
9593 },
9594 {
9595 .max = 7,
9596 .types = BIT(NL80211_IFTYPE_AP)
9597 #ifdef CONFIG_MAC80211_MESH
9598 | BIT(NL80211_IFTYPE_MESH_POINT)
9599 #endif
9600 },
9601 };
9602
9603 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
9604 {
9605 .max = 8,
9606 .types = BIT(NL80211_IFTYPE_AP)
9607 #ifdef CONFIG_MAC80211_MESH
9608 | BIT(NL80211_IFTYPE_MESH_POINT)
9609 #endif
9610 },
9611 {
9612 .max = 1,
9613 .types = BIT(NL80211_IFTYPE_STATION)
9614 },
9615 };
9616
9617 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
9618 {
9619 .limits = ath10k_if_limits,
9620 .n_limits = ARRAY_SIZE(ath10k_if_limits),
9621 .max_interfaces = 8,
9622 .num_different_channels = 1,
9623 .beacon_int_infra_match = true,
9624 },
9625 };
9626
9627 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
9628 {
9629 .limits = ath10k_10x_if_limits,
9630 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
9631 .max_interfaces = 8,
9632 .num_different_channels = 1,
9633 .beacon_int_infra_match = true,
9634 .beacon_int_min_gcd = 1,
9635 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
9636 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9637 BIT(NL80211_CHAN_WIDTH_20) |
9638 BIT(NL80211_CHAN_WIDTH_40) |
9639 BIT(NL80211_CHAN_WIDTH_80),
9640 #endif
9641 },
9642 };
9643
9644 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
9645 {
9646 .max = 2,
9647 .types = BIT(NL80211_IFTYPE_STATION),
9648 },
9649 {
9650 .max = 2,
9651 .types = BIT(NL80211_IFTYPE_AP) |
9652 #ifdef CONFIG_MAC80211_MESH
9653 BIT(NL80211_IFTYPE_MESH_POINT) |
9654 #endif
9655 BIT(NL80211_IFTYPE_P2P_CLIENT) |
9656 BIT(NL80211_IFTYPE_P2P_GO),
9657 },
9658 {
9659 .max = 1,
9660 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
9661 },
9662 };
9663
9664 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
9665 {
9666 .max = 2,
9667 .types = BIT(NL80211_IFTYPE_STATION),
9668 },
9669 {
9670 .max = 2,
9671 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
9672 },
9673 {
9674 .max = 1,
9675 .types = BIT(NL80211_IFTYPE_AP) |
9676 #ifdef CONFIG_MAC80211_MESH
9677 BIT(NL80211_IFTYPE_MESH_POINT) |
9678 #endif
9679 BIT(NL80211_IFTYPE_P2P_GO),
9680 },
9681 {
9682 .max = 1,
9683 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
9684 },
9685 };
9686
9687 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
9688 {
9689 .max = 1,
9690 .types = BIT(NL80211_IFTYPE_STATION),
9691 },
9692 {
9693 .max = 1,
9694 .types = BIT(NL80211_IFTYPE_ADHOC),
9695 },
9696 };
9697
9698 /* FIXME: This is not thoroughly tested. These combinations may over- or
9699 * underestimate hw/fw capabilities.
9700 */
9701 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
9702 {
9703 .limits = ath10k_tlv_if_limit,
9704 .num_different_channels = 1,
9705 .max_interfaces = 4,
9706 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
9707 },
9708 {
9709 .limits = ath10k_tlv_if_limit_ibss,
9710 .num_different_channels = 1,
9711 .max_interfaces = 2,
9712 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
9713 },
9714 };
9715
9716 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
9717 {
9718 .limits = ath10k_tlv_if_limit,
9719 .num_different_channels = 1,
9720 .max_interfaces = 4,
9721 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
9722 },
9723 {
9724 .limits = ath10k_tlv_qcs_if_limit,
9725 .num_different_channels = 2,
9726 .max_interfaces = 4,
9727 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
9728 },
9729 {
9730 .limits = ath10k_tlv_if_limit_ibss,
9731 .num_different_channels = 1,
9732 .max_interfaces = 2,
9733 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
9734 },
9735 };
9736
9737 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
9738 {
9739 .max = 1,
9740 .types = BIT(NL80211_IFTYPE_STATION),
9741 },
9742 {
9743 .max = 16,
9744 .types = BIT(NL80211_IFTYPE_AP)
9745 #ifdef CONFIG_MAC80211_MESH
9746 | BIT(NL80211_IFTYPE_MESH_POINT)
9747 #endif
9748 },
9749 };
9750
9751 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
9752 {
9753 .limits = ath10k_10_4_if_limits,
9754 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
9755 .max_interfaces = 16,
9756 .num_different_channels = 1,
9757 .beacon_int_infra_match = true,
9758 .beacon_int_min_gcd = 1,
9759 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
9760 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9761 BIT(NL80211_CHAN_WIDTH_20) |
9762 BIT(NL80211_CHAN_WIDTH_40) |
9763 BIT(NL80211_CHAN_WIDTH_80) |
9764 BIT(NL80211_CHAN_WIDTH_80P80) |
9765 BIT(NL80211_CHAN_WIDTH_160),
9766 #endif
9767 },
9768 };
9769
9770 static const struct
9771 ieee80211_iface_combination ath10k_10_4_bcn_int_if_comb[] = {
9772 {
9773 .limits = ath10k_10_4_if_limits,
9774 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
9775 .max_interfaces = 16,
9776 .num_different_channels = 1,
9777 .beacon_int_infra_match = true,
9778 .beacon_int_min_gcd = 100,
9779 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
9780 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9781 BIT(NL80211_CHAN_WIDTH_20) |
9782 BIT(NL80211_CHAN_WIDTH_40) |
9783 BIT(NL80211_CHAN_WIDTH_80) |
9784 BIT(NL80211_CHAN_WIDTH_80P80) |
9785 BIT(NL80211_CHAN_WIDTH_160),
9786 #endif
9787 },
9788 };
9789
ath10k_get_arvif_iter(void * data,u8 * mac,struct ieee80211_vif * vif)9790 static void ath10k_get_arvif_iter(void *data, u8 *mac,
9791 struct ieee80211_vif *vif)
9792 {
9793 struct ath10k_vif_iter *arvif_iter = data;
9794 struct ath10k_vif *arvif = (void *)vif->drv_priv;
9795
9796 if (arvif->vdev_id == arvif_iter->vdev_id)
9797 arvif_iter->arvif = arvif;
9798 }
9799
ath10k_get_arvif(struct ath10k * ar,u32 vdev_id)9800 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
9801 {
9802 struct ath10k_vif_iter arvif_iter;
9803
9804 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
9805 arvif_iter.vdev_id = vdev_id;
9806
9807 ieee80211_iterate_active_interfaces_atomic(ar->hw,
9808 ATH10K_ITER_RESUME_FLAGS,
9809 ath10k_get_arvif_iter,
9810 &arvif_iter);
9811 if (!arvif_iter.arvif) {
9812 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
9813 return NULL;
9814 }
9815
9816 return arvif_iter.arvif;
9817 }
9818
9819 #define WRD_METHOD "WRDD"
9820 #define WRDD_WIFI (0x07)
9821
ath10k_mac_wrdd_get_mcc(struct ath10k * ar,union acpi_object * wrdd)9822 static u32 ath10k_mac_wrdd_get_mcc(struct ath10k *ar, union acpi_object *wrdd)
9823 {
9824 union acpi_object *mcc_pkg;
9825 union acpi_object *domain_type;
9826 union acpi_object *mcc_value;
9827 u32 i;
9828
9829 if (wrdd->type != ACPI_TYPE_PACKAGE ||
9830 wrdd->package.count < 2 ||
9831 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER ||
9832 wrdd->package.elements[0].integer.value != 0) {
9833 ath10k_warn(ar, "ignoring malformed/unsupported wrdd structure\n");
9834 return 0;
9835 }
9836
9837 for (i = 1; i < wrdd->package.count; ++i) {
9838 mcc_pkg = &wrdd->package.elements[i];
9839
9840 if (mcc_pkg->type != ACPI_TYPE_PACKAGE)
9841 continue;
9842 if (mcc_pkg->package.count < 2)
9843 continue;
9844 if (mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER ||
9845 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER)
9846 continue;
9847
9848 domain_type = &mcc_pkg->package.elements[0];
9849 if (domain_type->integer.value != WRDD_WIFI)
9850 continue;
9851
9852 mcc_value = &mcc_pkg->package.elements[1];
9853 return mcc_value->integer.value;
9854 }
9855 return 0;
9856 }
9857
ath10k_mac_get_wrdd_regulatory(struct ath10k * ar,u16 * rd)9858 static int ath10k_mac_get_wrdd_regulatory(struct ath10k *ar, u16 *rd)
9859 {
9860 acpi_handle root_handle;
9861 acpi_handle handle;
9862 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL};
9863 acpi_status status;
9864 u32 alpha2_code;
9865 char alpha2[3];
9866
9867 root_handle = ACPI_HANDLE(ar->dev);
9868 if (!root_handle)
9869 return -EOPNOTSUPP;
9870
9871 status = acpi_get_handle(root_handle, (acpi_string)WRD_METHOD, &handle);
9872 if (ACPI_FAILURE(status)) {
9873 ath10k_dbg(ar, ATH10K_DBG_BOOT,
9874 "failed to get wrd method %d\n", status);
9875 return -EIO;
9876 }
9877
9878 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd);
9879 if (ACPI_FAILURE(status)) {
9880 ath10k_dbg(ar, ATH10K_DBG_BOOT,
9881 "failed to call wrdc %d\n", status);
9882 return -EIO;
9883 }
9884
9885 alpha2_code = ath10k_mac_wrdd_get_mcc(ar, wrdd.pointer);
9886 kfree(wrdd.pointer);
9887 if (!alpha2_code)
9888 return -EIO;
9889
9890 alpha2[0] = (alpha2_code >> 8) & 0xff;
9891 alpha2[1] = (alpha2_code >> 0) & 0xff;
9892 alpha2[2] = '\0';
9893
9894 ath10k_dbg(ar, ATH10K_DBG_BOOT,
9895 "regulatory hint from WRDD (alpha2-code): %s\n", alpha2);
9896
9897 *rd = ath_regd_find_country_by_name(alpha2);
9898 if (*rd == 0xffff)
9899 return -EIO;
9900
9901 *rd |= COUNTRY_ERD_FLAG;
9902 return 0;
9903 }
9904
ath10k_mac_init_rd(struct ath10k * ar)9905 static int ath10k_mac_init_rd(struct ath10k *ar)
9906 {
9907 int ret;
9908 u16 rd;
9909
9910 ret = ath10k_mac_get_wrdd_regulatory(ar, &rd);
9911 if (ret) {
9912 ath10k_dbg(ar, ATH10K_DBG_BOOT,
9913 "fallback to eeprom programmed regulatory settings\n");
9914 rd = ar->hw_eeprom_rd;
9915 }
9916
9917 ar->ath_common.regulatory.current_rd = rd;
9918 return 0;
9919 }
9920
ath10k_mac_register(struct ath10k * ar)9921 int ath10k_mac_register(struct ath10k *ar)
9922 {
9923 static const u32 cipher_suites[] = {
9924 WLAN_CIPHER_SUITE_WEP40,
9925 WLAN_CIPHER_SUITE_WEP104,
9926 WLAN_CIPHER_SUITE_TKIP,
9927 WLAN_CIPHER_SUITE_CCMP,
9928
9929 /* Do not add hardware supported ciphers before this line.
9930 * Allow software encryption for all chips. Don't forget to
9931 * update n_cipher_suites below.
9932 */
9933 WLAN_CIPHER_SUITE_AES_CMAC,
9934 WLAN_CIPHER_SUITE_BIP_CMAC_256,
9935 WLAN_CIPHER_SUITE_BIP_GMAC_128,
9936 WLAN_CIPHER_SUITE_BIP_GMAC_256,
9937
9938 /* Only QCA99x0 and QCA4019 variants support GCMP-128, GCMP-256
9939 * and CCMP-256 in hardware.
9940 */
9941 WLAN_CIPHER_SUITE_GCMP,
9942 WLAN_CIPHER_SUITE_GCMP_256,
9943 WLAN_CIPHER_SUITE_CCMP_256,
9944 };
9945 struct ieee80211_supported_band *band;
9946 void *channels;
9947 int ret;
9948
9949 if (!is_valid_ether_addr(ar->mac_addr)) {
9950 ath10k_warn(ar, "invalid MAC address; choosing random\n");
9951 eth_random_addr(ar->mac_addr);
9952 }
9953 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
9954
9955 SET_IEEE80211_DEV(ar->hw, ar->dev);
9956
9957 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
9958 ARRAY_SIZE(ath10k_5ghz_channels)) !=
9959 ATH10K_NUM_CHANS);
9960
9961 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
9962 channels = kmemdup(ath10k_2ghz_channels,
9963 sizeof(ath10k_2ghz_channels),
9964 GFP_KERNEL);
9965 if (!channels) {
9966 ret = -ENOMEM;
9967 goto err_free;
9968 }
9969
9970 band = &ar->mac.sbands[NL80211_BAND_2GHZ];
9971 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
9972 band->channels = channels;
9973
9974 if (ar->hw_params.cck_rate_map_rev2) {
9975 band->n_bitrates = ath10k_g_rates_rev2_size;
9976 band->bitrates = ath10k_g_rates_rev2;
9977 } else {
9978 band->n_bitrates = ath10k_g_rates_size;
9979 band->bitrates = ath10k_g_rates;
9980 }
9981
9982 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
9983 }
9984
9985 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
9986 channels = kmemdup(ath10k_5ghz_channels,
9987 sizeof(ath10k_5ghz_channels),
9988 GFP_KERNEL);
9989 if (!channels) {
9990 ret = -ENOMEM;
9991 goto err_free;
9992 }
9993
9994 band = &ar->mac.sbands[NL80211_BAND_5GHZ];
9995 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
9996 band->channels = channels;
9997 band->n_bitrates = ath10k_a_rates_size;
9998 band->bitrates = ath10k_a_rates;
9999 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
10000 }
10001
10002 wiphy_read_of_freq_limits(ar->hw->wiphy);
10003 ath10k_mac_setup_ht_vht_cap(ar);
10004
10005 ar->hw->wiphy->interface_modes =
10006 BIT(NL80211_IFTYPE_STATION) |
10007 BIT(NL80211_IFTYPE_AP) |
10008 BIT(NL80211_IFTYPE_MESH_POINT);
10009
10010 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
10011 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
10012
10013 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->normal_mode_fw.fw_file.fw_features))
10014 ar->hw->wiphy->interface_modes |=
10015 BIT(NL80211_IFTYPE_P2P_DEVICE) |
10016 BIT(NL80211_IFTYPE_P2P_CLIENT) |
10017 BIT(NL80211_IFTYPE_P2P_GO);
10018
10019 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
10020
10021 if (!test_bit(ATH10K_FW_FEATURE_NO_PS,
10022 ar->running_fw->fw_file.fw_features)) {
10023 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
10024 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
10025 }
10026
10027 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
10028 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
10029 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
10030 ieee80211_hw_set(ar->hw, AP_LINK_PS);
10031 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
10032 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
10033 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
10034 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
10035 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
10036 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
10037 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
10038 ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
10039 ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
10040
10041 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
10042 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
10043
10044 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
10045 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
10046
10047 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
10048 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
10049
10050 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
10051 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
10052 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
10053 }
10054
10055 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
10056 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
10057
10058 if (test_bit(WMI_SERVICE_NLO, ar->wmi.svc_map)) {
10059 ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
10060 ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
10061 ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
10062 ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
10063 ar->hw->wiphy->max_sched_scan_plan_interval =
10064 WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
10065 ar->hw->wiphy->max_sched_scan_plan_iterations =
10066 WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
10067 ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
10068 }
10069
10070 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
10071 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
10072 ar->hw->txq_data_size = sizeof(struct ath10k_txq);
10073
10074 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
10075
10076 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
10077 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
10078
10079 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
10080 * that userspace (e.g. wpa_supplicant/hostapd) can generate
10081 * correct Probe Responses. This is more of a hack advert..
10082 */
10083 ar->hw->wiphy->probe_resp_offload |=
10084 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
10085 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
10086 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
10087 }
10088
10089 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map) ||
10090 test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map)) {
10091 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
10092 if (test_bit(WMI_SERVICE_TDLS_WIDER_BANDWIDTH, ar->wmi.svc_map))
10093 ieee80211_hw_set(ar->hw, TDLS_WIDER_BW);
10094 }
10095
10096 if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map))
10097 ieee80211_hw_set(ar->hw, SUPPORTS_TDLS_BUFFER_STA);
10098
10099 if (ath10k_frame_mode == ATH10K_HW_TXRX_ETHERNET) {
10100 if (ar->wmi.vdev_param->tx_encap_type !=
10101 WMI_VDEV_PARAM_UNSUPPORTED)
10102 ieee80211_hw_set(ar->hw, SUPPORTS_TX_ENCAP_OFFLOAD);
10103 }
10104
10105 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
10106 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
10107 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
10108
10109 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
10110 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
10111 NL80211_FEATURE_AP_SCAN;
10112
10113 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
10114
10115 ret = ath10k_wow_init(ar);
10116 if (ret) {
10117 ath10k_warn(ar, "failed to init wow: %d\n", ret);
10118 goto err_free;
10119 }
10120
10121 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
10122 wiphy_ext_feature_set(ar->hw->wiphy,
10123 NL80211_EXT_FEATURE_SET_SCAN_DWELL);
10124 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_AQL);
10125
10126 if (ar->hw_params.mcast_frame_registration)
10127 wiphy_ext_feature_set(ar->hw->wiphy,
10128 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS);
10129
10130 if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map) ||
10131 test_bit(WMI_SERVICE_HTT_MGMT_TX_COMP_VALID_FLAGS, ar->wmi.svc_map))
10132 wiphy_ext_feature_set(ar->hw->wiphy,
10133 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT);
10134
10135 if (ath10k_peer_stats_enabled(ar) ||
10136 test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map))
10137 wiphy_ext_feature_set(ar->hw->wiphy,
10138 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS);
10139
10140 if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map))
10141 wiphy_ext_feature_set(ar->hw->wiphy,
10142 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);
10143
10144 if (test_bit(WMI_SERVICE_TX_PWR_PER_PEER, ar->wmi.svc_map))
10145 wiphy_ext_feature_set(ar->hw->wiphy,
10146 NL80211_EXT_FEATURE_STA_TX_PWR);
10147
10148 if (test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map)) {
10149 ar->hw->wiphy->tid_config_support.vif |=
10150 BIT(NL80211_TID_CONFIG_ATTR_NOACK) |
10151 BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT) |
10152 BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG) |
10153 BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL) |
10154 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
10155 BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE);
10156
10157 if (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT,
10158 ar->wmi.svc_map)) {
10159 ar->hw->wiphy->tid_config_support.vif |=
10160 BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);
10161 }
10162
10163 ar->hw->wiphy->tid_config_support.peer =
10164 ar->hw->wiphy->tid_config_support.vif;
10165 ar->hw->wiphy->max_data_retry_count = ATH10K_MAX_RETRY_COUNT;
10166 } else {
10167 ar->ops->set_tid_config = NULL;
10168 }
10169 /*
10170 * on LL hardware queues are managed entirely by the FW
10171 * so we only advertise to mac we can do the queues thing
10172 */
10173 ar->hw->queues = IEEE80211_MAX_QUEUES;
10174
10175 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
10176 * something that vdev_ids can't reach so that we don't stop the queue
10177 * accidentally.
10178 */
10179 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
10180
10181 switch (ar->running_fw->fw_file.wmi_op_version) {
10182 case ATH10K_FW_WMI_OP_VERSION_MAIN:
10183 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
10184 ar->hw->wiphy->n_iface_combinations =
10185 ARRAY_SIZE(ath10k_if_comb);
10186 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
10187 break;
10188 case ATH10K_FW_WMI_OP_VERSION_TLV:
10189 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
10190 ar->hw->wiphy->iface_combinations =
10191 ath10k_tlv_qcs_if_comb;
10192 ar->hw->wiphy->n_iface_combinations =
10193 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
10194 } else {
10195 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
10196 ar->hw->wiphy->n_iface_combinations =
10197 ARRAY_SIZE(ath10k_tlv_if_comb);
10198 }
10199 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
10200 break;
10201 case ATH10K_FW_WMI_OP_VERSION_10_1:
10202 case ATH10K_FW_WMI_OP_VERSION_10_2:
10203 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
10204 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
10205 ar->hw->wiphy->n_iface_combinations =
10206 ARRAY_SIZE(ath10k_10x_if_comb);
10207 break;
10208 case ATH10K_FW_WMI_OP_VERSION_10_4:
10209 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
10210 ar->hw->wiphy->n_iface_combinations =
10211 ARRAY_SIZE(ath10k_10_4_if_comb);
10212 if (test_bit(WMI_SERVICE_VDEV_DIFFERENT_BEACON_INTERVAL_SUPPORT,
10213 ar->wmi.svc_map)) {
10214 ar->hw->wiphy->iface_combinations =
10215 ath10k_10_4_bcn_int_if_comb;
10216 ar->hw->wiphy->n_iface_combinations =
10217 ARRAY_SIZE(ath10k_10_4_bcn_int_if_comb);
10218 }
10219 break;
10220 case ATH10K_FW_WMI_OP_VERSION_UNSET:
10221 case ATH10K_FW_WMI_OP_VERSION_MAX:
10222 WARN_ON(1);
10223 ret = -EINVAL;
10224 goto err_free;
10225 }
10226
10227 if (ar->hw_params.dynamic_sar_support)
10228 ar->hw->wiphy->sar_capa = &ath10k_sar_capa;
10229
10230 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
10231 ar->hw->netdev_features = NETIF_F_HW_CSUM;
10232
10233 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
10234 /* Init ath dfs pattern detector */
10235 ar->ath_common.debug_mask = ATH_DBG_DFS;
10236 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
10237 NL80211_DFS_UNSET);
10238
10239 if (!ar->dfs_detector)
10240 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
10241 }
10242
10243 ret = ath10k_mac_init_rd(ar);
10244 if (ret) {
10245 ath10k_err(ar, "failed to derive regdom: %d\n", ret);
10246 goto err_dfs_detector_exit;
10247 }
10248
10249 /* Disable set_coverage_class for chipsets that do not support it. */
10250 if (!ar->hw_params.hw_ops->set_coverage_class)
10251 ar->ops->set_coverage_class = NULL;
10252
10253 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
10254 ath10k_reg_notifier);
10255 if (ret) {
10256 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
10257 goto err_dfs_detector_exit;
10258 }
10259
10260 if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) {
10261 ar->hw->wiphy->features |=
10262 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
10263 }
10264
10265 ar->hw->wiphy->cipher_suites = cipher_suites;
10266
10267 /* QCA988x and QCA6174 family chips do not support CCMP-256, GCMP-128
10268 * and GCMP-256 ciphers in hardware. Fetch number of ciphers supported
10269 * from chip specific hw_param table.
10270 */
10271 if (!ar->hw_params.n_cipher_suites ||
10272 ar->hw_params.n_cipher_suites > ARRAY_SIZE(cipher_suites)) {
10273 ath10k_err(ar, "invalid hw_params.n_cipher_suites %d\n",
10274 ar->hw_params.n_cipher_suites);
10275 ar->hw_params.n_cipher_suites = 8;
10276 }
10277 ar->hw->wiphy->n_cipher_suites = ar->hw_params.n_cipher_suites;
10278
10279 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
10280
10281 ar->hw->weight_multiplier = ATH10K_AIRTIME_WEIGHT_MULTIPLIER;
10282
10283 ret = ieee80211_register_hw(ar->hw);
10284 if (ret) {
10285 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
10286 goto err_dfs_detector_exit;
10287 }
10288
10289 if (test_bit(WMI_SERVICE_PER_PACKET_SW_ENCRYPT, ar->wmi.svc_map)) {
10290 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
10291 ar->hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);
10292 }
10293
10294 if (!ath_is_world_regd(&ar->ath_common.reg_world_copy) &&
10295 !ath_is_world_regd(&ar->ath_common.regulatory)) {
10296 ret = regulatory_hint(ar->hw->wiphy,
10297 ar->ath_common.regulatory.alpha2);
10298 if (ret)
10299 goto err_unregister;
10300 }
10301
10302 return 0;
10303
10304 err_unregister:
10305 ieee80211_unregister_hw(ar->hw);
10306
10307 err_dfs_detector_exit:
10308 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
10309 ar->dfs_detector->exit(ar->dfs_detector);
10310
10311 err_free:
10312 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
10313 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
10314
10315 SET_IEEE80211_DEV(ar->hw, NULL);
10316 return ret;
10317 }
10318
ath10k_mac_unregister(struct ath10k * ar)10319 void ath10k_mac_unregister(struct ath10k *ar)
10320 {
10321 ieee80211_unregister_hw(ar->hw);
10322
10323 if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
10324 ar->dfs_detector->exit(ar->dfs_detector);
10325
10326 kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
10327 kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
10328
10329 SET_IEEE80211_DEV(ar->hw, NULL);
10330 }
10331