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