]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/net/wireless/ath/ath10k/mac.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
NFC: pn533: handle interrupted commands in pn533_recv_frame
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / wireless / ath / ath10k / mac.c
1 /*
2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include "mac.h"
19
20 #include <net/mac80211.h>
21 #include <linux/etherdevice.h>
22
23 #include "hif.h"
24 #include "core.h"
25 #include "debug.h"
26 #include "wmi.h"
27 #include "htt.h"
28 #include "txrx.h"
29 #include "testmode.h"
30 #include "wmi.h"
31 #include "wmi-tlv.h"
32 #include "wmi-ops.h"
33 #include "wow.h"
34
35 /*********/
36 /* Rates */
37 /*********/
38
39 static struct ieee80211_rate ath10k_rates[] = {
40 { .bitrate = 10,
41 .hw_value = ATH10K_HW_RATE_CCK_LP_1M },
42 { .bitrate = 20,
43 .hw_value = ATH10K_HW_RATE_CCK_LP_2M,
44 .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M,
45 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
46 { .bitrate = 55,
47 .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M,
48 .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M,
49 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
50 { .bitrate = 110,
51 .hw_value = ATH10K_HW_RATE_CCK_LP_11M,
52 .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M,
53 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
54
55 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
56 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
57 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
58 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
59 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
60 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
61 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
62 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
63 };
64
65 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4
66
67 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)
68 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \
69 ATH10K_MAC_FIRST_OFDM_RATE_IDX)
70 #define ath10k_g_rates (ath10k_rates + 0)
71 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
72
73 static bool ath10k_mac_bitrate_is_cck(int bitrate)
74 {
75 switch (bitrate) {
76 case 10:
77 case 20:
78 case 55:
79 case 110:
80 return true;
81 }
82
83 return false;
84 }
85
86 static u8 ath10k_mac_bitrate_to_rate(int bitrate)
87 {
88 return DIV_ROUND_UP(bitrate, 5) |
89 (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
90 }
91
92 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
93 u8 hw_rate, bool cck)
94 {
95 const struct ieee80211_rate *rate;
96 int i;
97
98 for (i = 0; i < sband->n_bitrates; i++) {
99 rate = &sband->bitrates[i];
100
101 if (ath10k_mac_bitrate_is_cck(rate->bitrate) != cck)
102 continue;
103
104 if (rate->hw_value == hw_rate)
105 return i;
106 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
107 rate->hw_value_short == hw_rate)
108 return i;
109 }
110
111 return 0;
112 }
113
114 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
115 u32 bitrate)
116 {
117 int i;
118
119 for (i = 0; i < sband->n_bitrates; i++)
120 if (sband->bitrates[i].bitrate == bitrate)
121 return i;
122
123 return 0;
124 }
125
126 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
127 {
128 switch ((mcs_map >> (2 * nss)) & 0x3) {
129 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
130 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
131 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
132 }
133 return 0;
134 }
135
136 static u32
137 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
138 {
139 int nss;
140
141 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
142 if (ht_mcs_mask[nss])
143 return nss + 1;
144
145 return 1;
146 }
147
148 static u32
149 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
150 {
151 int nss;
152
153 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
154 if (vht_mcs_mask[nss])
155 return nss + 1;
156
157 return 1;
158 }
159
160 /**********/
161 /* Crypto */
162 /**********/
163
164 static int ath10k_send_key(struct ath10k_vif *arvif,
165 struct ieee80211_key_conf *key,
166 enum set_key_cmd cmd,
167 const u8 *macaddr, u32 flags)
168 {
169 struct ath10k *ar = arvif->ar;
170 struct wmi_vdev_install_key_arg arg = {
171 .vdev_id = arvif->vdev_id,
172 .key_idx = key->keyidx,
173 .key_len = key->keylen,
174 .key_data = key->key,
175 .key_flags = flags,
176 .macaddr = macaddr,
177 };
178
179 lockdep_assert_held(&arvif->ar->conf_mutex);
180
181 switch (key->cipher) {
182 case WLAN_CIPHER_SUITE_CCMP:
183 arg.key_cipher = WMI_CIPHER_AES_CCM;
184 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
185 break;
186 case WLAN_CIPHER_SUITE_TKIP:
187 arg.key_cipher = WMI_CIPHER_TKIP;
188 arg.key_txmic_len = 8;
189 arg.key_rxmic_len = 8;
190 break;
191 case WLAN_CIPHER_SUITE_WEP40:
192 case WLAN_CIPHER_SUITE_WEP104:
193 arg.key_cipher = WMI_CIPHER_WEP;
194 break;
195 case WLAN_CIPHER_SUITE_AES_CMAC:
196 WARN_ON(1);
197 return -EINVAL;
198 default:
199 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
200 return -EOPNOTSUPP;
201 }
202
203 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
204 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
205
206 if (cmd == DISABLE_KEY) {
207 arg.key_cipher = WMI_CIPHER_NONE;
208 arg.key_data = NULL;
209 }
210
211 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
212 }
213
214 static int ath10k_install_key(struct ath10k_vif *arvif,
215 struct ieee80211_key_conf *key,
216 enum set_key_cmd cmd,
217 const u8 *macaddr, u32 flags)
218 {
219 struct ath10k *ar = arvif->ar;
220 int ret;
221 unsigned long time_left;
222
223 lockdep_assert_held(&ar->conf_mutex);
224
225 reinit_completion(&ar->install_key_done);
226
227 if (arvif->nohwcrypt)
228 return 1;
229
230 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
231 if (ret)
232 return ret;
233
234 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
235 if (time_left == 0)
236 return -ETIMEDOUT;
237
238 return 0;
239 }
240
241 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
242 const u8 *addr)
243 {
244 struct ath10k *ar = arvif->ar;
245 struct ath10k_peer *peer;
246 int ret;
247 int i;
248 u32 flags;
249
250 lockdep_assert_held(&ar->conf_mutex);
251
252 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&
253 arvif->vif->type != NL80211_IFTYPE_ADHOC &&
254 arvif->vif->type != NL80211_IFTYPE_MESH_POINT))
255 return -EINVAL;
256
257 spin_lock_bh(&ar->data_lock);
258 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
259 spin_unlock_bh(&ar->data_lock);
260
261 if (!peer)
262 return -ENOENT;
263
264 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
265 if (arvif->wep_keys[i] == NULL)
266 continue;
267
268 switch (arvif->vif->type) {
269 case NL80211_IFTYPE_AP:
270 flags = WMI_KEY_PAIRWISE;
271
272 if (arvif->def_wep_key_idx == i)
273 flags |= WMI_KEY_TX_USAGE;
274
275 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
276 SET_KEY, addr, flags);
277 if (ret < 0)
278 return ret;
279 break;
280 case NL80211_IFTYPE_ADHOC:
281 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
282 SET_KEY, addr,
283 WMI_KEY_PAIRWISE);
284 if (ret < 0)
285 return ret;
286
287 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
288 SET_KEY, addr, WMI_KEY_GROUP);
289 if (ret < 0)
290 return ret;
291 break;
292 default:
293 WARN_ON(1);
294 return -EINVAL;
295 }
296
297 spin_lock_bh(&ar->data_lock);
298 peer->keys[i] = arvif->wep_keys[i];
299 spin_unlock_bh(&ar->data_lock);
300 }
301
302 /* In some cases (notably with static WEP IBSS with multiple keys)
303 * multicast Tx becomes broken. Both pairwise and groupwise keys are
304 * installed already. Using WMI_KEY_TX_USAGE in different combinations
305 * didn't seem help. Using def_keyid vdev parameter seems to be
306 * effective so use that.
307 *
308 * FIXME: Revisit. Perhaps this can be done in a less hacky way.
309 */
310 if (arvif->vif->type != NL80211_IFTYPE_ADHOC)
311 return 0;
312
313 if (arvif->def_wep_key_idx == -1)
314 return 0;
315
316 ret = ath10k_wmi_vdev_set_param(arvif->ar,
317 arvif->vdev_id,
318 arvif->ar->wmi.vdev_param->def_keyid,
319 arvif->def_wep_key_idx);
320 if (ret) {
321 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
322 arvif->vdev_id, ret);
323 return ret;
324 }
325
326 return 0;
327 }
328
329 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
330 const u8 *addr)
331 {
332 struct ath10k *ar = arvif->ar;
333 struct ath10k_peer *peer;
334 int first_errno = 0;
335 int ret;
336 int i;
337 u32 flags = 0;
338
339 lockdep_assert_held(&ar->conf_mutex);
340
341 spin_lock_bh(&ar->data_lock);
342 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
343 spin_unlock_bh(&ar->data_lock);
344
345 if (!peer)
346 return -ENOENT;
347
348 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
349 if (peer->keys[i] == NULL)
350 continue;
351
352 /* key flags are not required to delete the key */
353 ret = ath10k_install_key(arvif, peer->keys[i],
354 DISABLE_KEY, addr, flags);
355 if (ret < 0 && first_errno == 0)
356 first_errno = ret;
357
358 if (ret < 0)
359 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
360 i, ret);
361
362 spin_lock_bh(&ar->data_lock);
363 peer->keys[i] = NULL;
364 spin_unlock_bh(&ar->data_lock);
365 }
366
367 return first_errno;
368 }
369
370 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
371 u8 keyidx)
372 {
373 struct ath10k_peer *peer;
374 int i;
375
376 lockdep_assert_held(&ar->data_lock);
377
378 /* We don't know which vdev this peer belongs to,
379 * since WMI doesn't give us that information.
380 *
381 * FIXME: multi-bss needs to be handled.
382 */
383 peer = ath10k_peer_find(ar, 0, addr);
384 if (!peer)
385 return false;
386
387 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
388 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
389 return true;
390 }
391
392 return false;
393 }
394
395 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
396 struct ieee80211_key_conf *key)
397 {
398 struct ath10k *ar = arvif->ar;
399 struct ath10k_peer *peer;
400 u8 addr[ETH_ALEN];
401 int first_errno = 0;
402 int ret;
403 int i;
404 u32 flags = 0;
405
406 lockdep_assert_held(&ar->conf_mutex);
407
408 for (;;) {
409 /* since ath10k_install_key we can't hold data_lock all the
410 * time, so we try to remove the keys incrementally */
411 spin_lock_bh(&ar->data_lock);
412 i = 0;
413 list_for_each_entry(peer, &ar->peers, list) {
414 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
415 if (peer->keys[i] == key) {
416 ether_addr_copy(addr, peer->addr);
417 peer->keys[i] = NULL;
418 break;
419 }
420 }
421
422 if (i < ARRAY_SIZE(peer->keys))
423 break;
424 }
425 spin_unlock_bh(&ar->data_lock);
426
427 if (i == ARRAY_SIZE(peer->keys))
428 break;
429 /* key flags are not required to delete the key */
430 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
431 if (ret < 0 && first_errno == 0)
432 first_errno = ret;
433
434 if (ret)
435 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
436 addr, ret);
437 }
438
439 return first_errno;
440 }
441
442 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
443 struct ieee80211_key_conf *key)
444 {
445 struct ath10k *ar = arvif->ar;
446 struct ath10k_peer *peer;
447 int ret;
448
449 lockdep_assert_held(&ar->conf_mutex);
450
451 list_for_each_entry(peer, &ar->peers, list) {
452 if (!memcmp(peer->addr, arvif->vif->addr, ETH_ALEN))
453 continue;
454
455 if (!memcmp(peer->addr, arvif->bssid, ETH_ALEN))
456 continue;
457
458 if (peer->keys[key->keyidx] == key)
459 continue;
460
461 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
462 arvif->vdev_id, key->keyidx);
463
464 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
465 if (ret) {
466 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
467 arvif->vdev_id, peer->addr, ret);
468 return ret;
469 }
470 }
471
472 return 0;
473 }
474
475 /*********************/
476 /* General utilities */
477 /*********************/
478
479 static inline enum wmi_phy_mode
480 chan_to_phymode(const struct cfg80211_chan_def *chandef)
481 {
482 enum wmi_phy_mode phymode = MODE_UNKNOWN;
483
484 switch (chandef->chan->band) {
485 case IEEE80211_BAND_2GHZ:
486 switch (chandef->width) {
487 case NL80211_CHAN_WIDTH_20_NOHT:
488 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
489 phymode = MODE_11B;
490 else
491 phymode = MODE_11G;
492 break;
493 case NL80211_CHAN_WIDTH_20:
494 phymode = MODE_11NG_HT20;
495 break;
496 case NL80211_CHAN_WIDTH_40:
497 phymode = MODE_11NG_HT40;
498 break;
499 case NL80211_CHAN_WIDTH_5:
500 case NL80211_CHAN_WIDTH_10:
501 case NL80211_CHAN_WIDTH_80:
502 case NL80211_CHAN_WIDTH_80P80:
503 case NL80211_CHAN_WIDTH_160:
504 phymode = MODE_UNKNOWN;
505 break;
506 }
507 break;
508 case IEEE80211_BAND_5GHZ:
509 switch (chandef->width) {
510 case NL80211_CHAN_WIDTH_20_NOHT:
511 phymode = MODE_11A;
512 break;
513 case NL80211_CHAN_WIDTH_20:
514 phymode = MODE_11NA_HT20;
515 break;
516 case NL80211_CHAN_WIDTH_40:
517 phymode = MODE_11NA_HT40;
518 break;
519 case NL80211_CHAN_WIDTH_80:
520 phymode = MODE_11AC_VHT80;
521 break;
522 case NL80211_CHAN_WIDTH_5:
523 case NL80211_CHAN_WIDTH_10:
524 case NL80211_CHAN_WIDTH_80P80:
525 case NL80211_CHAN_WIDTH_160:
526 phymode = MODE_UNKNOWN;
527 break;
528 }
529 break;
530 default:
531 break;
532 }
533
534 WARN_ON(phymode == MODE_UNKNOWN);
535 return phymode;
536 }
537
538 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
539 {
540 /*
541 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
542 * 0 for no restriction
543 * 1 for 1/4 us
544 * 2 for 1/2 us
545 * 3 for 1 us
546 * 4 for 2 us
547 * 5 for 4 us
548 * 6 for 8 us
549 * 7 for 16 us
550 */
551 switch (mpdudensity) {
552 case 0:
553 return 0;
554 case 1:
555 case 2:
556 case 3:
557 /* Our lower layer calculations limit our precision to
558 1 microsecond */
559 return 1;
560 case 4:
561 return 2;
562 case 5:
563 return 4;
564 case 6:
565 return 8;
566 case 7:
567 return 16;
568 default:
569 return 0;
570 }
571 }
572
573 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
574 struct cfg80211_chan_def *def)
575 {
576 struct ieee80211_chanctx_conf *conf;
577
578 rcu_read_lock();
579 conf = rcu_dereference(vif->chanctx_conf);
580 if (!conf) {
581 rcu_read_unlock();
582 return -ENOENT;
583 }
584
585 *def = conf->def;
586 rcu_read_unlock();
587
588 return 0;
589 }
590
591 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
592 struct ieee80211_chanctx_conf *conf,
593 void *data)
594 {
595 int *num = data;
596
597 (*num)++;
598 }
599
600 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
601 {
602 int num = 0;
603
604 ieee80211_iter_chan_contexts_atomic(ar->hw,
605 ath10k_mac_num_chanctxs_iter,
606 &num);
607
608 return num;
609 }
610
611 static void
612 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
613 struct ieee80211_chanctx_conf *conf,
614 void *data)
615 {
616 struct cfg80211_chan_def **def = data;
617
618 *def = &conf->def;
619 }
620
621 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
622 enum wmi_peer_type peer_type)
623 {
624 struct ath10k_vif *arvif;
625 int num_peers = 0;
626 int ret;
627
628 lockdep_assert_held(&ar->conf_mutex);
629
630 num_peers = ar->num_peers;
631
632 /* Each vdev consumes a peer entry as well */
633 list_for_each_entry(arvif, &ar->arvifs, list)
634 num_peers++;
635
636 if (num_peers >= ar->max_num_peers)
637 return -ENOBUFS;
638
639 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
640 if (ret) {
641 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
642 addr, vdev_id, ret);
643 return ret;
644 }
645
646 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
647 if (ret) {
648 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
649 addr, vdev_id, ret);
650 return ret;
651 }
652
653 ar->num_peers++;
654
655 return 0;
656 }
657
658 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
659 {
660 struct ath10k *ar = arvif->ar;
661 u32 param;
662 int ret;
663
664 param = ar->wmi.pdev_param->sta_kickout_th;
665 ret = ath10k_wmi_pdev_set_param(ar, param,
666 ATH10K_KICKOUT_THRESHOLD);
667 if (ret) {
668 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
669 arvif->vdev_id, ret);
670 return ret;
671 }
672
673 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
674 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
675 ATH10K_KEEPALIVE_MIN_IDLE);
676 if (ret) {
677 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
678 arvif->vdev_id, ret);
679 return ret;
680 }
681
682 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
683 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
684 ATH10K_KEEPALIVE_MAX_IDLE);
685 if (ret) {
686 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
687 arvif->vdev_id, ret);
688 return ret;
689 }
690
691 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
692 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
693 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
694 if (ret) {
695 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
696 arvif->vdev_id, ret);
697 return ret;
698 }
699
700 return 0;
701 }
702
703 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
704 {
705 struct ath10k *ar = arvif->ar;
706 u32 vdev_param;
707
708 vdev_param = ar->wmi.vdev_param->rts_threshold;
709 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
710 }
711
712 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
713 {
714 int ret;
715
716 lockdep_assert_held(&ar->conf_mutex);
717
718 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
719 if (ret)
720 return ret;
721
722 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
723 if (ret)
724 return ret;
725
726 ar->num_peers--;
727
728 return 0;
729 }
730
731 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
732 {
733 struct ath10k_peer *peer, *tmp;
734
735 lockdep_assert_held(&ar->conf_mutex);
736
737 spin_lock_bh(&ar->data_lock);
738 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
739 if (peer->vdev_id != vdev_id)
740 continue;
741
742 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
743 peer->addr, vdev_id);
744
745 list_del(&peer->list);
746 kfree(peer);
747 ar->num_peers--;
748 }
749 spin_unlock_bh(&ar->data_lock);
750 }
751
752 static void ath10k_peer_cleanup_all(struct ath10k *ar)
753 {
754 struct ath10k_peer *peer, *tmp;
755
756 lockdep_assert_held(&ar->conf_mutex);
757
758 spin_lock_bh(&ar->data_lock);
759 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
760 list_del(&peer->list);
761 kfree(peer);
762 }
763 spin_unlock_bh(&ar->data_lock);
764
765 ar->num_peers = 0;
766 ar->num_stations = 0;
767 }
768
769 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
770 struct ieee80211_sta *sta,
771 enum wmi_tdls_peer_state state)
772 {
773 int ret;
774 struct wmi_tdls_peer_update_cmd_arg arg = {};
775 struct wmi_tdls_peer_capab_arg cap = {};
776 struct wmi_channel_arg chan_arg = {};
777
778 lockdep_assert_held(&ar->conf_mutex);
779
780 arg.vdev_id = vdev_id;
781 arg.peer_state = state;
782 ether_addr_copy(arg.addr, sta->addr);
783
784 cap.peer_max_sp = sta->max_sp;
785 cap.peer_uapsd_queues = sta->uapsd_queues;
786
787 if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
788 !sta->tdls_initiator)
789 cap.is_peer_responder = 1;
790
791 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
792 if (ret) {
793 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
794 arg.addr, vdev_id, ret);
795 return ret;
796 }
797
798 return 0;
799 }
800
801 /************************/
802 /* Interface management */
803 /************************/
804
805 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
806 {
807 struct ath10k *ar = arvif->ar;
808
809 lockdep_assert_held(&ar->data_lock);
810
811 if (!arvif->beacon)
812 return;
813
814 if (!arvif->beacon_buf)
815 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
816 arvif->beacon->len, DMA_TO_DEVICE);
817
818 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
819 arvif->beacon_state != ATH10K_BEACON_SENT))
820 return;
821
822 dev_kfree_skb_any(arvif->beacon);
823
824 arvif->beacon = NULL;
825 arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
826 }
827
828 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
829 {
830 struct ath10k *ar = arvif->ar;
831
832 lockdep_assert_held(&ar->data_lock);
833
834 ath10k_mac_vif_beacon_free(arvif);
835
836 if (arvif->beacon_buf) {
837 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
838 arvif->beacon_buf, arvif->beacon_paddr);
839 arvif->beacon_buf = NULL;
840 }
841 }
842
843 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
844 {
845 unsigned long time_left;
846
847 lockdep_assert_held(&ar->conf_mutex);
848
849 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
850 return -ESHUTDOWN;
851
852 time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
853 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
854 if (time_left == 0)
855 return -ETIMEDOUT;
856
857 return 0;
858 }
859
860 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
861 {
862 struct cfg80211_chan_def *chandef = NULL;
863 struct ieee80211_channel *channel = NULL;
864 struct wmi_vdev_start_request_arg arg = {};
865 int ret = 0;
866
867 lockdep_assert_held(&ar->conf_mutex);
868
869 ieee80211_iter_chan_contexts_atomic(ar->hw,
870 ath10k_mac_get_any_chandef_iter,
871 &chandef);
872 if (WARN_ON_ONCE(!chandef))
873 return -ENOENT;
874
875 channel = chandef->chan;
876
877 arg.vdev_id = vdev_id;
878 arg.channel.freq = channel->center_freq;
879 arg.channel.band_center_freq1 = chandef->center_freq1;
880
881 /* TODO setup this dynamically, what in case we
882 don't have any vifs? */
883 arg.channel.mode = chan_to_phymode(chandef);
884 arg.channel.chan_radar =
885 !!(channel->flags & IEEE80211_CHAN_RADAR);
886
887 arg.channel.min_power = 0;
888 arg.channel.max_power = channel->max_power * 2;
889 arg.channel.max_reg_power = channel->max_reg_power * 2;
890 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
891
892 reinit_completion(&ar->vdev_setup_done);
893
894 ret = ath10k_wmi_vdev_start(ar, &arg);
895 if (ret) {
896 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
897 vdev_id, ret);
898 return ret;
899 }
900
901 ret = ath10k_vdev_setup_sync(ar);
902 if (ret) {
903 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
904 vdev_id, ret);
905 return ret;
906 }
907
908 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
909 if (ret) {
910 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
911 vdev_id, ret);
912 goto vdev_stop;
913 }
914
915 ar->monitor_vdev_id = vdev_id;
916
917 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
918 ar->monitor_vdev_id);
919 return 0;
920
921 vdev_stop:
922 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
923 if (ret)
924 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
925 ar->monitor_vdev_id, ret);
926
927 return ret;
928 }
929
930 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
931 {
932 int ret = 0;
933
934 lockdep_assert_held(&ar->conf_mutex);
935
936 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
937 if (ret)
938 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
939 ar->monitor_vdev_id, ret);
940
941 reinit_completion(&ar->vdev_setup_done);
942
943 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
944 if (ret)
945 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
946 ar->monitor_vdev_id, ret);
947
948 ret = ath10k_vdev_setup_sync(ar);
949 if (ret)
950 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
951 ar->monitor_vdev_id, ret);
952
953 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
954 ar->monitor_vdev_id);
955 return ret;
956 }
957
958 static int ath10k_monitor_vdev_create(struct ath10k *ar)
959 {
960 int bit, ret = 0;
961
962 lockdep_assert_held(&ar->conf_mutex);
963
964 if (ar->free_vdev_map == 0) {
965 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
966 return -ENOMEM;
967 }
968
969 bit = __ffs64(ar->free_vdev_map);
970
971 ar->monitor_vdev_id = bit;
972
973 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
974 WMI_VDEV_TYPE_MONITOR,
975 0, ar->mac_addr);
976 if (ret) {
977 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
978 ar->monitor_vdev_id, ret);
979 return ret;
980 }
981
982 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
983 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
984 ar->monitor_vdev_id);
985
986 return 0;
987 }
988
989 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
990 {
991 int ret = 0;
992
993 lockdep_assert_held(&ar->conf_mutex);
994
995 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
996 if (ret) {
997 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
998 ar->monitor_vdev_id, ret);
999 return ret;
1000 }
1001
1002 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
1003
1004 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
1005 ar->monitor_vdev_id);
1006 return ret;
1007 }
1008
1009 static int ath10k_monitor_start(struct ath10k *ar)
1010 {
1011 int ret;
1012
1013 lockdep_assert_held(&ar->conf_mutex);
1014
1015 ret = ath10k_monitor_vdev_create(ar);
1016 if (ret) {
1017 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1018 return ret;
1019 }
1020
1021 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
1022 if (ret) {
1023 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1024 ath10k_monitor_vdev_delete(ar);
1025 return ret;
1026 }
1027
1028 ar->monitor_started = true;
1029 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1030
1031 return 0;
1032 }
1033
1034 static int ath10k_monitor_stop(struct ath10k *ar)
1035 {
1036 int ret;
1037
1038 lockdep_assert_held(&ar->conf_mutex);
1039
1040 ret = ath10k_monitor_vdev_stop(ar);
1041 if (ret) {
1042 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1043 return ret;
1044 }
1045
1046 ret = ath10k_monitor_vdev_delete(ar);
1047 if (ret) {
1048 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1049 return ret;
1050 }
1051
1052 ar->monitor_started = false;
1053 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1054
1055 return 0;
1056 }
1057
1058 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1059 {
1060 int num_ctx;
1061
1062 /* At least one chanctx is required to derive a channel to start
1063 * monitor vdev on.
1064 */
1065 num_ctx = ath10k_mac_num_chanctxs(ar);
1066 if (num_ctx == 0)
1067 return false;
1068
1069 /* If there's already an existing special monitor interface then don't
1070 * bother creating another monitor vdev.
1071 */
1072 if (ar->monitor_arvif)
1073 return false;
1074
1075 return ar->monitor ||
1076 ar->filter_flags & FIF_OTHER_BSS ||
1077 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1078 }
1079
1080 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)
1081 {
1082 int num_ctx;
1083
1084 num_ctx = ath10k_mac_num_chanctxs(ar);
1085
1086 /* FIXME: Current interface combinations and cfg80211/mac80211 code
1087 * shouldn't allow this but make sure to prevent handling the following
1088 * case anyway since multi-channel DFS hasn't been tested at all.
1089 */
1090 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)
1091 return false;
1092
1093 return true;
1094 }
1095
1096 static int ath10k_monitor_recalc(struct ath10k *ar)
1097 {
1098 bool needed;
1099 bool allowed;
1100 int ret;
1101
1102 lockdep_assert_held(&ar->conf_mutex);
1103
1104 needed = ath10k_mac_monitor_vdev_is_needed(ar);
1105 allowed = ath10k_mac_monitor_vdev_is_allowed(ar);
1106
1107 ath10k_dbg(ar, ATH10K_DBG_MAC,
1108 "mac monitor recalc started? %d needed? %d allowed? %d\n",
1109 ar->monitor_started, needed, allowed);
1110
1111 if (WARN_ON(needed && !allowed)) {
1112 if (ar->monitor_started) {
1113 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");
1114
1115 ret = ath10k_monitor_stop(ar);
1116 if (ret)
1117 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n",
1118 ret);
1119 /* not serious */
1120 }
1121
1122 return -EPERM;
1123 }
1124
1125 if (needed == ar->monitor_started)
1126 return 0;
1127
1128 if (needed)
1129 return ath10k_monitor_start(ar);
1130 else
1131 return ath10k_monitor_stop(ar);
1132 }
1133
1134 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
1135 {
1136 struct ath10k *ar = arvif->ar;
1137 u32 vdev_param, rts_cts = 0;
1138
1139 lockdep_assert_held(&ar->conf_mutex);
1140
1141 vdev_param = ar->wmi.vdev_param->enable_rtscts;
1142
1143 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
1144
1145 if (arvif->num_legacy_stations > 0)
1146 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
1147 WMI_RTSCTS_PROFILE);
1148 else
1149 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,
1150 WMI_RTSCTS_PROFILE);
1151
1152 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1153 rts_cts);
1154 }
1155
1156 static int ath10k_start_cac(struct ath10k *ar)
1157 {
1158 int ret;
1159
1160 lockdep_assert_held(&ar->conf_mutex);
1161
1162 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1163
1164 ret = ath10k_monitor_recalc(ar);
1165 if (ret) {
1166 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
1167 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1168 return ret;
1169 }
1170
1171 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
1172 ar->monitor_vdev_id);
1173
1174 return 0;
1175 }
1176
1177 static int ath10k_stop_cac(struct ath10k *ar)
1178 {
1179 lockdep_assert_held(&ar->conf_mutex);
1180
1181 /* CAC is not running - do nothing */
1182 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
1183 return 0;
1184
1185 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1186 ath10k_monitor_stop(ar);
1187
1188 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
1189
1190 return 0;
1191 }
1192
1193 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,
1194 struct ieee80211_chanctx_conf *conf,
1195 void *data)
1196 {
1197 bool *ret = data;
1198
1199 if (!*ret && conf->radar_enabled)
1200 *ret = true;
1201 }
1202
1203 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)
1204 {
1205 bool has_radar = false;
1206
1207 ieee80211_iter_chan_contexts_atomic(ar->hw,
1208 ath10k_mac_has_radar_iter,
1209 &has_radar);
1210
1211 return has_radar;
1212 }
1213
1214 static void ath10k_recalc_radar_detection(struct ath10k *ar)
1215 {
1216 int ret;
1217
1218 lockdep_assert_held(&ar->conf_mutex);
1219
1220 ath10k_stop_cac(ar);
1221
1222 if (!ath10k_mac_has_radar_enabled(ar))
1223 return;
1224
1225 if (ar->num_started_vdevs > 0)
1226 return;
1227
1228 ret = ath10k_start_cac(ar);
1229 if (ret) {
1230 /*
1231 * Not possible to start CAC on current channel so starting
1232 * radiation is not allowed, make this channel DFS_UNAVAILABLE
1233 * by indicating that radar was detected.
1234 */
1235 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
1236 ieee80211_radar_detected(ar->hw);
1237 }
1238 }
1239
1240 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
1241 {
1242 struct ath10k *ar = arvif->ar;
1243 int ret;
1244
1245 lockdep_assert_held(&ar->conf_mutex);
1246
1247 reinit_completion(&ar->vdev_setup_done);
1248
1249 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
1250 if (ret) {
1251 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
1252 arvif->vdev_id, ret);
1253 return ret;
1254 }
1255
1256 ret = ath10k_vdev_setup_sync(ar);
1257 if (ret) {
1258 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
1259 arvif->vdev_id, ret);
1260 return ret;
1261 }
1262
1263 WARN_ON(ar->num_started_vdevs == 0);
1264
1265 if (ar->num_started_vdevs != 0) {
1266 ar->num_started_vdevs--;
1267 ath10k_recalc_radar_detection(ar);
1268 }
1269
1270 return ret;
1271 }
1272
1273 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,
1274 const struct cfg80211_chan_def *chandef,
1275 bool restart)
1276 {
1277 struct ath10k *ar = arvif->ar;
1278 struct wmi_vdev_start_request_arg arg = {};
1279 int ret = 0;
1280
1281 lockdep_assert_held(&ar->conf_mutex);
1282
1283 reinit_completion(&ar->vdev_setup_done);
1284
1285 arg.vdev_id = arvif->vdev_id;
1286 arg.dtim_period = arvif->dtim_period;
1287 arg.bcn_intval = arvif->beacon_interval;
1288
1289 arg.channel.freq = chandef->chan->center_freq;
1290 arg.channel.band_center_freq1 = chandef->center_freq1;
1291 arg.channel.mode = chan_to_phymode(chandef);
1292
1293 arg.channel.min_power = 0;
1294 arg.channel.max_power = chandef->chan->max_power * 2;
1295 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
1296 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
1297
1298 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1299 arg.ssid = arvif->u.ap.ssid;
1300 arg.ssid_len = arvif->u.ap.ssid_len;
1301 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
1302
1303 /* For now allow DFS for AP mode */
1304 arg.channel.chan_radar =
1305 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
1306 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
1307 arg.ssid = arvif->vif->bss_conf.ssid;
1308 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
1309 }
1310
1311 ath10k_dbg(ar, ATH10K_DBG_MAC,
1312 "mac vdev %d start center_freq %d phymode %s\n",
1313 arg.vdev_id, arg.channel.freq,
1314 ath10k_wmi_phymode_str(arg.channel.mode));
1315
1316 if (restart)
1317 ret = ath10k_wmi_vdev_restart(ar, &arg);
1318 else
1319 ret = ath10k_wmi_vdev_start(ar, &arg);
1320
1321 if (ret) {
1322 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
1323 arg.vdev_id, ret);
1324 return ret;
1325 }
1326
1327 ret = ath10k_vdev_setup_sync(ar);
1328 if (ret) {
1329 ath10k_warn(ar,
1330 "failed to synchronize setup for vdev %i restart %d: %d\n",
1331 arg.vdev_id, restart, ret);
1332 return ret;
1333 }
1334
1335 ar->num_started_vdevs++;
1336 ath10k_recalc_radar_detection(ar);
1337
1338 return ret;
1339 }
1340
1341 static int ath10k_vdev_start(struct ath10k_vif *arvif,
1342 const struct cfg80211_chan_def *def)
1343 {
1344 return ath10k_vdev_start_restart(arvif, def, false);
1345 }
1346
1347 static int ath10k_vdev_restart(struct ath10k_vif *arvif,
1348 const struct cfg80211_chan_def *def)
1349 {
1350 return ath10k_vdev_start_restart(arvif, def, true);
1351 }
1352
1353 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
1354 struct sk_buff *bcn)
1355 {
1356 struct ath10k *ar = arvif->ar;
1357 struct ieee80211_mgmt *mgmt;
1358 const u8 *p2p_ie;
1359 int ret;
1360
1361 if (arvif->vif->type != NL80211_IFTYPE_AP || !arvif->vif->p2p)
1362 return 0;
1363
1364 mgmt = (void *)bcn->data;
1365 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1366 mgmt->u.beacon.variable,
1367 bcn->len - (mgmt->u.beacon.variable -
1368 bcn->data));
1369 if (!p2p_ie)
1370 return -ENOENT;
1371
1372 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1373 if (ret) {
1374 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1375 arvif->vdev_id, ret);
1376 return ret;
1377 }
1378
1379 return 0;
1380 }
1381
1382 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1383 u8 oui_type, size_t ie_offset)
1384 {
1385 size_t len;
1386 const u8 *next;
1387 const u8 *end;
1388 u8 *ie;
1389
1390 if (WARN_ON(skb->len < ie_offset))
1391 return -EINVAL;
1392
1393 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1394 skb->data + ie_offset,
1395 skb->len - ie_offset);
1396 if (!ie)
1397 return -ENOENT;
1398
1399 len = ie[1] + 2;
1400 end = skb->data + skb->len;
1401 next = ie + len;
1402
1403 if (WARN_ON(next > end))
1404 return -EINVAL;
1405
1406 memmove(ie, next, end - next);
1407 skb_trim(skb, skb->len - len);
1408
1409 return 0;
1410 }
1411
1412 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1413 {
1414 struct ath10k *ar = arvif->ar;
1415 struct ieee80211_hw *hw = ar->hw;
1416 struct ieee80211_vif *vif = arvif->vif;
1417 struct ieee80211_mutable_offsets offs = {};
1418 struct sk_buff *bcn;
1419 int ret;
1420
1421 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1422 return 0;
1423
1424 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
1425 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
1426 return 0;
1427
1428 bcn = ieee80211_beacon_get_template(hw, vif, &offs);
1429 if (!bcn) {
1430 ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1431 return -EPERM;
1432 }
1433
1434 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1435 if (ret) {
1436 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1437 kfree_skb(bcn);
1438 return ret;
1439 }
1440
1441 /* P2P IE is inserted by firmware automatically (as configured above)
1442 * so remove it from the base beacon template to avoid duplicate P2P
1443 * IEs in beacon frames.
1444 */
1445 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1446 offsetof(struct ieee80211_mgmt,
1447 u.beacon.variable));
1448
1449 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1450 0, NULL, 0);
1451 kfree_skb(bcn);
1452
1453 if (ret) {
1454 ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1455 ret);
1456 return ret;
1457 }
1458
1459 return 0;
1460 }
1461
1462 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1463 {
1464 struct ath10k *ar = arvif->ar;
1465 struct ieee80211_hw *hw = ar->hw;
1466 struct ieee80211_vif *vif = arvif->vif;
1467 struct sk_buff *prb;
1468 int ret;
1469
1470 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1471 return 0;
1472
1473 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1474 return 0;
1475
1476 prb = ieee80211_proberesp_get(hw, vif);
1477 if (!prb) {
1478 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1479 return -EPERM;
1480 }
1481
1482 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1483 kfree_skb(prb);
1484
1485 if (ret) {
1486 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1487 ret);
1488 return ret;
1489 }
1490
1491 return 0;
1492 }
1493
1494 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)
1495 {
1496 struct ath10k *ar = arvif->ar;
1497 struct cfg80211_chan_def def;
1498 int ret;
1499
1500 /* When originally vdev is started during assign_vif_chanctx() some
1501 * information is missing, notably SSID. Firmware revisions with beacon
1502 * offloading require the SSID to be provided during vdev (re)start to
1503 * handle hidden SSID properly.
1504 *
1505 * Vdev restart must be done after vdev has been both started and
1506 * upped. Otherwise some firmware revisions (at least 10.2) fail to
1507 * deliver vdev restart response event causing timeouts during vdev
1508 * syncing in ath10k.
1509 *
1510 * Note: The vdev down/up and template reinstallation could be skipped
1511 * since only wmi-tlv firmware are known to have beacon offload and
1512 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1513 * response delivery. It's probably more robust to keep it as is.
1514 */
1515 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1516 return 0;
1517
1518 if (WARN_ON(!arvif->is_started))
1519 return -EINVAL;
1520
1521 if (WARN_ON(!arvif->is_up))
1522 return -EINVAL;
1523
1524 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
1525 return -EINVAL;
1526
1527 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1528 if (ret) {
1529 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",
1530 arvif->vdev_id, ret);
1531 return ret;
1532 }
1533
1534 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1535 * firmware will crash upon vdev up.
1536 */
1537
1538 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1539 if (ret) {
1540 ath10k_warn(ar, "failed to update beacon template: %d\n", ret);
1541 return ret;
1542 }
1543
1544 ret = ath10k_mac_setup_prb_tmpl(arvif);
1545 if (ret) {
1546 ath10k_warn(ar, "failed to update presp template: %d\n", ret);
1547 return ret;
1548 }
1549
1550 ret = ath10k_vdev_restart(arvif, &def);
1551 if (ret) {
1552 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",
1553 arvif->vdev_id, ret);
1554 return ret;
1555 }
1556
1557 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1558 arvif->bssid);
1559 if (ret) {
1560 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",
1561 arvif->vdev_id, ret);
1562 return ret;
1563 }
1564
1565 return 0;
1566 }
1567
1568 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1569 struct ieee80211_bss_conf *info)
1570 {
1571 struct ath10k *ar = arvif->ar;
1572 int ret = 0;
1573
1574 lockdep_assert_held(&arvif->ar->conf_mutex);
1575
1576 if (!info->enable_beacon) {
1577 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1578 if (ret)
1579 ath10k_warn(ar, "failed to down vdev_id %i: %d\n",
1580 arvif->vdev_id, ret);
1581
1582 arvif->is_up = false;
1583
1584 spin_lock_bh(&arvif->ar->data_lock);
1585 ath10k_mac_vif_beacon_free(arvif);
1586 spin_unlock_bh(&arvif->ar->data_lock);
1587
1588 return;
1589 }
1590
1591 arvif->tx_seq_no = 0x1000;
1592
1593 arvif->aid = 0;
1594 ether_addr_copy(arvif->bssid, info->bssid);
1595
1596 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1597 arvif->bssid);
1598 if (ret) {
1599 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1600 arvif->vdev_id, ret);
1601 return;
1602 }
1603
1604 arvif->is_up = true;
1605
1606 ret = ath10k_mac_vif_fix_hidden_ssid(arvif);
1607 if (ret) {
1608 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1609 arvif->vdev_id, ret);
1610 return;
1611 }
1612
1613 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1614 }
1615
1616 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1617 struct ieee80211_bss_conf *info,
1618 const u8 self_peer[ETH_ALEN])
1619 {
1620 struct ath10k *ar = arvif->ar;
1621 u32 vdev_param;
1622 int ret = 0;
1623
1624 lockdep_assert_held(&arvif->ar->conf_mutex);
1625
1626 if (!info->ibss_joined) {
1627 if (is_zero_ether_addr(arvif->bssid))
1628 return;
1629
1630 eth_zero_addr(arvif->bssid);
1631
1632 return;
1633 }
1634
1635 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1636 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1637 ATH10K_DEFAULT_ATIM);
1638 if (ret)
1639 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1640 arvif->vdev_id, ret);
1641 }
1642
1643 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1644 {
1645 struct ath10k *ar = arvif->ar;
1646 u32 param;
1647 u32 value;
1648 int ret;
1649
1650 lockdep_assert_held(&arvif->ar->conf_mutex);
1651
1652 if (arvif->u.sta.uapsd)
1653 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1654 else
1655 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1656
1657 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1658 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1659 if (ret) {
1660 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1661 value, arvif->vdev_id, ret);
1662 return ret;
1663 }
1664
1665 return 0;
1666 }
1667
1668 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1669 {
1670 struct ath10k *ar = arvif->ar;
1671 u32 param;
1672 u32 value;
1673 int ret;
1674
1675 lockdep_assert_held(&arvif->ar->conf_mutex);
1676
1677 if (arvif->u.sta.uapsd)
1678 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1679 else
1680 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1681
1682 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1683 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1684 param, value);
1685 if (ret) {
1686 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1687 value, arvif->vdev_id, ret);
1688 return ret;
1689 }
1690
1691 return 0;
1692 }
1693
1694 static int ath10k_mac_num_vifs_started(struct ath10k *ar)
1695 {
1696 struct ath10k_vif *arvif;
1697 int num = 0;
1698
1699 lockdep_assert_held(&ar->conf_mutex);
1700
1701 list_for_each_entry(arvif, &ar->arvifs, list)
1702 if (arvif->is_started)
1703 num++;
1704
1705 return num;
1706 }
1707
1708 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1709 {
1710 struct ath10k *ar = arvif->ar;
1711 struct ieee80211_vif *vif = arvif->vif;
1712 struct ieee80211_conf *conf = &ar->hw->conf;
1713 enum wmi_sta_powersave_param param;
1714 enum wmi_sta_ps_mode psmode;
1715 int ret;
1716 int ps_timeout;
1717 bool enable_ps;
1718
1719 lockdep_assert_held(&arvif->ar->conf_mutex);
1720
1721 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1722 return 0;
1723
1724 enable_ps = arvif->ps;
1725
1726 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&
1727 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,
1728 ar->fw_features)) {
1729 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",
1730 arvif->vdev_id);
1731 enable_ps = false;
1732 }
1733
1734 if (!arvif->is_started) {
1735 /* mac80211 can update vif powersave state while disconnected.
1736 * Firmware doesn't behave nicely and consumes more power than
1737 * necessary if PS is disabled on a non-started vdev. Hence
1738 * force-enable PS for non-running vdevs.
1739 */
1740 psmode = WMI_STA_PS_MODE_ENABLED;
1741 } else if (enable_ps) {
1742 psmode = WMI_STA_PS_MODE_ENABLED;
1743 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1744
1745 ps_timeout = conf->dynamic_ps_timeout;
1746 if (ps_timeout == 0) {
1747 /* Firmware doesn't like 0 */
1748 ps_timeout = ieee80211_tu_to_usec(
1749 vif->bss_conf.beacon_int) / 1000;
1750 }
1751
1752 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1753 ps_timeout);
1754 if (ret) {
1755 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1756 arvif->vdev_id, ret);
1757 return ret;
1758 }
1759 } else {
1760 psmode = WMI_STA_PS_MODE_DISABLED;
1761 }
1762
1763 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1764 arvif->vdev_id, psmode ? "enable" : "disable");
1765
1766 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1767 if (ret) {
1768 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1769 psmode, arvif->vdev_id, ret);
1770 return ret;
1771 }
1772
1773 return 0;
1774 }
1775
1776 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1777 {
1778 struct ath10k *ar = arvif->ar;
1779 struct wmi_sta_keepalive_arg arg = {};
1780 int ret;
1781
1782 lockdep_assert_held(&arvif->ar->conf_mutex);
1783
1784 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1785 return 0;
1786
1787 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1788 return 0;
1789
1790 /* Some firmware revisions have a bug and ignore the `enabled` field.
1791 * Instead use the interval to disable the keepalive.
1792 */
1793 arg.vdev_id = arvif->vdev_id;
1794 arg.enabled = 1;
1795 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
1796 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
1797
1798 ret = ath10k_wmi_sta_keepalive(ar, &arg);
1799 if (ret) {
1800 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
1801 arvif->vdev_id, ret);
1802 return ret;
1803 }
1804
1805 return 0;
1806 }
1807
1808 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)
1809 {
1810 struct ath10k *ar = arvif->ar;
1811 struct ieee80211_vif *vif = arvif->vif;
1812 int ret;
1813
1814 lockdep_assert_held(&arvif->ar->conf_mutex);
1815
1816 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))
1817 return;
1818
1819 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1820 return;
1821
1822 if (!vif->csa_active)
1823 return;
1824
1825 if (!arvif->is_up)
1826 return;
1827
1828 if (!ieee80211_csa_is_complete(vif)) {
1829 ieee80211_csa_update_counter(vif);
1830
1831 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1832 if (ret)
1833 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
1834 ret);
1835
1836 ret = ath10k_mac_setup_prb_tmpl(arvif);
1837 if (ret)
1838 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
1839 ret);
1840 } else {
1841 ieee80211_csa_finish(vif);
1842 }
1843 }
1844
1845 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)
1846 {
1847 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1848 ap_csa_work);
1849 struct ath10k *ar = arvif->ar;
1850
1851 mutex_lock(&ar->conf_mutex);
1852 ath10k_mac_vif_ap_csa_count_down(arvif);
1853 mutex_unlock(&ar->conf_mutex);
1854 }
1855
1856 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,
1857 struct ieee80211_vif *vif)
1858 {
1859 struct sk_buff *skb = data;
1860 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1861 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1862
1863 if (vif->type != NL80211_IFTYPE_STATION)
1864 return;
1865
1866 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1867 return;
1868
1869 cancel_delayed_work(&arvif->connection_loss_work);
1870 }
1871
1872 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)
1873 {
1874 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1875 IEEE80211_IFACE_ITER_NORMAL,
1876 ath10k_mac_handle_beacon_iter,
1877 skb);
1878 }
1879
1880 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1881 struct ieee80211_vif *vif)
1882 {
1883 u32 *vdev_id = data;
1884 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1885 struct ath10k *ar = arvif->ar;
1886 struct ieee80211_hw *hw = ar->hw;
1887
1888 if (arvif->vdev_id != *vdev_id)
1889 return;
1890
1891 if (!arvif->is_up)
1892 return;
1893
1894 ieee80211_beacon_loss(vif);
1895
1896 /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1897 * (done by mac80211) succeeds but beacons do not resume then it
1898 * doesn't make sense to continue operation. Queue connection loss work
1899 * which can be cancelled when beacon is received.
1900 */
1901 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1902 ATH10K_CONNECTION_LOSS_HZ);
1903 }
1904
1905 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)
1906 {
1907 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1908 IEEE80211_IFACE_ITER_NORMAL,
1909 ath10k_mac_handle_beacon_miss_iter,
1910 &vdev_id);
1911 }
1912
1913 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1914 {
1915 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1916 connection_loss_work.work);
1917 struct ieee80211_vif *vif = arvif->vif;
1918
1919 if (!arvif->is_up)
1920 return;
1921
1922 ieee80211_connection_loss(vif);
1923 }
1924
1925 /**********************/
1926 /* Station management */
1927 /**********************/
1928
1929 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1930 struct ieee80211_vif *vif)
1931 {
1932 /* Some firmware revisions have unstable STA powersave when listen
1933 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1934 * generate NullFunc frames properly even if buffered frames have been
1935 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1936 * buffered frames. Often pinging the device from AP would simply fail.
1937 *
1938 * As a workaround set it to 1.
1939 */
1940 if (vif->type == NL80211_IFTYPE_STATION)
1941 return 1;
1942
1943 return ar->hw->conf.listen_interval;
1944 }
1945
1946 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1947 struct ieee80211_vif *vif,
1948 struct ieee80211_sta *sta,
1949 struct wmi_peer_assoc_complete_arg *arg)
1950 {
1951 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1952 u32 aid;
1953
1954 lockdep_assert_held(&ar->conf_mutex);
1955
1956 if (vif->type == NL80211_IFTYPE_STATION)
1957 aid = vif->bss_conf.aid;
1958 else
1959 aid = sta->aid;
1960
1961 ether_addr_copy(arg->addr, sta->addr);
1962 arg->vdev_id = arvif->vdev_id;
1963 arg->peer_aid = aid;
1964 arg->peer_flags |= arvif->ar->wmi.peer_flags->auth;
1965 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1966 arg->peer_num_spatial_streams = 1;
1967 arg->peer_caps = vif->bss_conf.assoc_capability;
1968 }
1969
1970 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1971 struct ieee80211_vif *vif,
1972 struct ieee80211_sta *sta,
1973 struct wmi_peer_assoc_complete_arg *arg)
1974 {
1975 struct ieee80211_bss_conf *info = &vif->bss_conf;
1976 struct cfg80211_chan_def def;
1977 struct cfg80211_bss *bss;
1978 const u8 *rsnie = NULL;
1979 const u8 *wpaie = NULL;
1980
1981 lockdep_assert_held(&ar->conf_mutex);
1982
1983 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
1984 return;
1985
1986 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1987 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1988 if (bss) {
1989 const struct cfg80211_bss_ies *ies;
1990
1991 rcu_read_lock();
1992 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1993
1994 ies = rcu_dereference(bss->ies);
1995
1996 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1997 WLAN_OUI_TYPE_MICROSOFT_WPA,
1998 ies->data,
1999 ies->len);
2000 rcu_read_unlock();
2001 cfg80211_put_bss(ar->hw->wiphy, bss);
2002 }
2003
2004 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
2005 if (rsnie || wpaie) {
2006 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
2007 arg->peer_flags |= ar->wmi.peer_flags->need_ptk_4_way;
2008 }
2009
2010 if (wpaie) {
2011 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
2012 arg->peer_flags |= ar->wmi.peer_flags->need_gtk_2_way;
2013 }
2014
2015 if (sta->mfp &&
2016 test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT, ar->fw_features)) {
2017 arg->peer_flags |= ar->wmi.peer_flags->pmf;
2018 }
2019 }
2020
2021 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
2022 struct ieee80211_vif *vif,
2023 struct ieee80211_sta *sta,
2024 struct wmi_peer_assoc_complete_arg *arg)
2025 {
2026 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2027 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
2028 struct cfg80211_chan_def def;
2029 const struct ieee80211_supported_band *sband;
2030 const struct ieee80211_rate *rates;
2031 enum ieee80211_band band;
2032 u32 ratemask;
2033 u8 rate;
2034 int i;
2035
2036 lockdep_assert_held(&ar->conf_mutex);
2037
2038 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2039 return;
2040
2041 band = def.chan->band;
2042 sband = ar->hw->wiphy->bands[band];
2043 ratemask = sta->supp_rates[band];
2044 ratemask &= arvif->bitrate_mask.control[band].legacy;
2045 rates = sband->bitrates;
2046
2047 rateset->num_rates = 0;
2048
2049 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
2050 if (!(ratemask & 1))
2051 continue;
2052
2053 rate = ath10k_mac_bitrate_to_rate(rates->bitrate);
2054 rateset->rates[rateset->num_rates] = rate;
2055 rateset->num_rates++;
2056 }
2057 }
2058
2059 static bool
2060 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
2061 {
2062 int nss;
2063
2064 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
2065 if (ht_mcs_mask[nss])
2066 return false;
2067
2068 return true;
2069 }
2070
2071 static bool
2072 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
2073 {
2074 int nss;
2075
2076 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
2077 if (vht_mcs_mask[nss])
2078 return false;
2079
2080 return true;
2081 }
2082
2083 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
2084 struct ieee80211_vif *vif,
2085 struct ieee80211_sta *sta,
2086 struct wmi_peer_assoc_complete_arg *arg)
2087 {
2088 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2089 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2090 struct cfg80211_chan_def def;
2091 enum ieee80211_band band;
2092 const u8 *ht_mcs_mask;
2093 const u16 *vht_mcs_mask;
2094 int i, n;
2095 u8 max_nss;
2096 u32 stbc;
2097
2098 lockdep_assert_held(&ar->conf_mutex);
2099
2100 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2101 return;
2102
2103 if (!ht_cap->ht_supported)
2104 return;
2105
2106 band = def.chan->band;
2107 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2108 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2109
2110 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&
2111 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2112 return;
2113
2114 arg->peer_flags |= ar->wmi.peer_flags->ht;
2115 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2116 ht_cap->ampdu_factor)) - 1;
2117
2118 arg->peer_mpdu_density =
2119 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
2120
2121 arg->peer_ht_caps = ht_cap->cap;
2122 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
2123
2124 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
2125 arg->peer_flags |= ar->wmi.peer_flags->ldbc;
2126
2127 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
2128 arg->peer_flags |= ar->wmi.peer_flags->bw40;
2129 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
2130 }
2131
2132 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
2133 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
2134 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2135
2136 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
2137 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2138 }
2139
2140 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
2141 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
2142 arg->peer_flags |= ar->wmi.peer_flags->stbc;
2143 }
2144
2145 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
2146 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
2147 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
2148 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
2149 arg->peer_rate_caps |= stbc;
2150 arg->peer_flags |= ar->wmi.peer_flags->stbc;
2151 }
2152
2153 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
2154 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
2155 else if (ht_cap->mcs.rx_mask[1])
2156 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
2157
2158 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
2159 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
2160 (ht_mcs_mask[i / 8] & BIT(i % 8))) {
2161 max_nss = (i / 8) + 1;
2162 arg->peer_ht_rates.rates[n++] = i;
2163 }
2164
2165 /*
2166 * This is a workaround for HT-enabled STAs which break the spec
2167 * and have no HT capabilities RX mask (no HT RX MCS map).
2168 *
2169 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2170 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2171 *
2172 * Firmware asserts if such situation occurs.
2173 */
2174 if (n == 0) {
2175 arg->peer_ht_rates.num_rates = 8;
2176 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
2177 arg->peer_ht_rates.rates[i] = i;
2178 } else {
2179 arg->peer_ht_rates.num_rates = n;
2180 arg->peer_num_spatial_streams = min(sta->rx_nss, max_nss);
2181 }
2182
2183 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
2184 arg->addr,
2185 arg->peer_ht_rates.num_rates,
2186 arg->peer_num_spatial_streams);
2187 }
2188
2189 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
2190 struct ath10k_vif *arvif,
2191 struct ieee80211_sta *sta)
2192 {
2193 u32 uapsd = 0;
2194 u32 max_sp = 0;
2195 int ret = 0;
2196
2197 lockdep_assert_held(&ar->conf_mutex);
2198
2199 if (sta->wme && sta->uapsd_queues) {
2200 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2201 sta->uapsd_queues, sta->max_sp);
2202
2203 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2204 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2205 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2206 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2207 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2208 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2209 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2210 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2211 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2212 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2213 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2214 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2215
2216 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2217 max_sp = sta->max_sp;
2218
2219 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2220 sta->addr,
2221 WMI_AP_PS_PEER_PARAM_UAPSD,
2222 uapsd);
2223 if (ret) {
2224 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2225 arvif->vdev_id, ret);
2226 return ret;
2227 }
2228
2229 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2230 sta->addr,
2231 WMI_AP_PS_PEER_PARAM_MAX_SP,
2232 max_sp);
2233 if (ret) {
2234 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2235 arvif->vdev_id, ret);
2236 return ret;
2237 }
2238
2239 /* TODO setup this based on STA listen interval and
2240 beacon interval. Currently we don't know
2241 sta->listen_interval - mac80211 patch required.
2242 Currently use 10 seconds */
2243 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
2244 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
2245 10);
2246 if (ret) {
2247 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2248 arvif->vdev_id, ret);
2249 return ret;
2250 }
2251 }
2252
2253 return 0;
2254 }
2255
2256 static u16
2257 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
2258 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
2259 {
2260 int idx_limit;
2261 int nss;
2262 u16 mcs_map;
2263 u16 mcs;
2264
2265 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
2266 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
2267 vht_mcs_limit[nss];
2268
2269 if (mcs_map)
2270 idx_limit = fls(mcs_map) - 1;
2271 else
2272 idx_limit = -1;
2273
2274 switch (idx_limit) {
2275 case 0: /* fall through */
2276 case 1: /* fall through */
2277 case 2: /* fall through */
2278 case 3: /* fall through */
2279 case 4: /* fall through */
2280 case 5: /* fall through */
2281 case 6: /* fall through */
2282 default:
2283 /* see ath10k_mac_can_set_bitrate_mask() */
2284 WARN_ON(1);
2285 /* fall through */
2286 case -1:
2287 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2288 break;
2289 case 7:
2290 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2291 break;
2292 case 8:
2293 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2294 break;
2295 case 9:
2296 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2297 break;
2298 }
2299
2300 tx_mcs_set &= ~(0x3 << (nss * 2));
2301 tx_mcs_set |= mcs << (nss * 2);
2302 }
2303
2304 return tx_mcs_set;
2305 }
2306
2307 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
2308 struct ieee80211_vif *vif,
2309 struct ieee80211_sta *sta,
2310 struct wmi_peer_assoc_complete_arg *arg)
2311 {
2312 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
2313 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2314 struct cfg80211_chan_def def;
2315 enum ieee80211_band band;
2316 const u16 *vht_mcs_mask;
2317 u8 ampdu_factor;
2318
2319 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2320 return;
2321
2322 if (!vht_cap->vht_supported)
2323 return;
2324
2325 band = def.chan->band;
2326 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2327
2328 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2329 return;
2330
2331 arg->peer_flags |= ar->wmi.peer_flags->vht;
2332
2333 if (def.chan->band == IEEE80211_BAND_2GHZ)
2334 arg->peer_flags |= ar->wmi.peer_flags->vht_2g;
2335
2336 arg->peer_vht_caps = vht_cap->cap;
2337
2338 ampdu_factor = (vht_cap->cap &
2339 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2340 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2341
2342 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2343 * zero in VHT IE. Using it would result in degraded throughput.
2344 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2345 * it if VHT max_mpdu is smaller. */
2346 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2347 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2348 ampdu_factor)) - 1);
2349
2350 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2351 arg->peer_flags |= ar->wmi.peer_flags->bw80;
2352
2353 arg->peer_vht_rates.rx_max_rate =
2354 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2355 arg->peer_vht_rates.rx_mcs_set =
2356 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2357 arg->peer_vht_rates.tx_max_rate =
2358 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2359 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(
2360 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2361
2362 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
2363 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
2364 }
2365
2366 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
2367 struct ieee80211_vif *vif,
2368 struct ieee80211_sta *sta,
2369 struct wmi_peer_assoc_complete_arg *arg)
2370 {
2371 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2372
2373 switch (arvif->vdev_type) {
2374 case WMI_VDEV_TYPE_AP:
2375 if (sta->wme)
2376 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2377
2378 if (sta->wme && sta->uapsd_queues) {
2379 arg->peer_flags |= arvif->ar->wmi.peer_flags->apsd;
2380 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
2381 }
2382 break;
2383 case WMI_VDEV_TYPE_STA:
2384 if (vif->bss_conf.qos)
2385 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2386 break;
2387 case WMI_VDEV_TYPE_IBSS:
2388 if (sta->wme)
2389 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2390 break;
2391 default:
2392 break;
2393 }
2394
2395 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
2396 sta->addr, !!(arg->peer_flags &
2397 arvif->ar->wmi.peer_flags->qos));
2398 }
2399
2400 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2401 {
2402 return sta->supp_rates[IEEE80211_BAND_2GHZ] >>
2403 ATH10K_MAC_FIRST_OFDM_RATE_IDX;
2404 }
2405
2406 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
2407 struct ieee80211_vif *vif,
2408 struct ieee80211_sta *sta,
2409 struct wmi_peer_assoc_complete_arg *arg)
2410 {
2411 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2412 struct cfg80211_chan_def def;
2413 enum ieee80211_band band;
2414 const u8 *ht_mcs_mask;
2415 const u16 *vht_mcs_mask;
2416 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2417
2418 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2419 return;
2420
2421 band = def.chan->band;
2422 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2423 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2424
2425 switch (band) {
2426 case IEEE80211_BAND_2GHZ:
2427 if (sta->vht_cap.vht_supported &&
2428 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2429 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2430 phymode = MODE_11AC_VHT40;
2431 else
2432 phymode = MODE_11AC_VHT20;
2433 } else if (sta->ht_cap.ht_supported &&
2434 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2435 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2436 phymode = MODE_11NG_HT40;
2437 else
2438 phymode = MODE_11NG_HT20;
2439 } else if (ath10k_mac_sta_has_ofdm_only(sta)) {
2440 phymode = MODE_11G;
2441 } else {
2442 phymode = MODE_11B;
2443 }
2444
2445 break;
2446 case IEEE80211_BAND_5GHZ:
2447 /*
2448 * Check VHT first.
2449 */
2450 if (sta->vht_cap.vht_supported &&
2451 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2452 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2453 phymode = MODE_11AC_VHT80;
2454 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2455 phymode = MODE_11AC_VHT40;
2456 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
2457 phymode = MODE_11AC_VHT20;
2458 } else if (sta->ht_cap.ht_supported &&
2459 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2460 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40)
2461 phymode = MODE_11NA_HT40;
2462 else
2463 phymode = MODE_11NA_HT20;
2464 } else {
2465 phymode = MODE_11A;
2466 }
2467
2468 break;
2469 default:
2470 break;
2471 }
2472
2473 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
2474 sta->addr, ath10k_wmi_phymode_str(phymode));
2475
2476 arg->peer_phymode = phymode;
2477 WARN_ON(phymode == MODE_UNKNOWN);
2478 }
2479
2480 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
2481 struct ieee80211_vif *vif,
2482 struct ieee80211_sta *sta,
2483 struct wmi_peer_assoc_complete_arg *arg)
2484 {
2485 lockdep_assert_held(&ar->conf_mutex);
2486
2487 memset(arg, 0, sizeof(*arg));
2488
2489 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
2490 ath10k_peer_assoc_h_crypto(ar, vif, sta, arg);
2491 ath10k_peer_assoc_h_rates(ar, vif, sta, arg);
2492 ath10k_peer_assoc_h_ht(ar, vif, sta, arg);
2493 ath10k_peer_assoc_h_vht(ar, vif, sta, arg);
2494 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
2495 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
2496
2497 return 0;
2498 }
2499
2500 static const u32 ath10k_smps_map[] = {
2501 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
2502 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
2503 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
2504 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
2505 };
2506
2507 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
2508 const u8 *addr,
2509 const struct ieee80211_sta_ht_cap *ht_cap)
2510 {
2511 int smps;
2512
2513 if (!ht_cap->ht_supported)
2514 return 0;
2515
2516 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2517 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2518
2519 if (smps >= ARRAY_SIZE(ath10k_smps_map))
2520 return -EINVAL;
2521
2522 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
2523 WMI_PEER_SMPS_STATE,
2524 ath10k_smps_map[smps]);
2525 }
2526
2527 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,
2528 struct ieee80211_vif *vif,
2529 struct ieee80211_sta_vht_cap vht_cap)
2530 {
2531 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2532 int ret;
2533 u32 param;
2534 u32 value;
2535
2536 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC)
2537 return 0;
2538
2539 if (!(ar->vht_cap_info &
2540 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2541 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
2542 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2543 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))
2544 return 0;
2545
2546 param = ar->wmi.vdev_param->txbf;
2547 value = 0;
2548
2549 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))
2550 return 0;
2551
2552 /* The following logic is correct. If a remote STA advertises support
2553 * for being a beamformer then we should enable us being a beamformee.
2554 */
2555
2556 if (ar->vht_cap_info &
2557 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2558 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
2559 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
2560 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2561
2562 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
2563 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
2564 }
2565
2566 if (ar->vht_cap_info &
2567 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2568 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
2569 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
2570 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2571
2572 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
2573 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
2574 }
2575
2576 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)
2577 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2578
2579 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)
2580 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2581
2582 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);
2583 if (ret) {
2584 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",
2585 value, ret);
2586 return ret;
2587 }
2588
2589 return 0;
2590 }
2591
2592 /* can be called only in mac80211 callbacks due to `key_count` usage */
2593 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
2594 struct ieee80211_vif *vif,
2595 struct ieee80211_bss_conf *bss_conf)
2596 {
2597 struct ath10k *ar = hw->priv;
2598 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2599 struct ieee80211_sta_ht_cap ht_cap;
2600 struct ieee80211_sta_vht_cap vht_cap;
2601 struct wmi_peer_assoc_complete_arg peer_arg;
2602 struct ieee80211_sta *ap_sta;
2603 int ret;
2604
2605 lockdep_assert_held(&ar->conf_mutex);
2606
2607 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2608 arvif->vdev_id, arvif->bssid, arvif->aid);
2609
2610 rcu_read_lock();
2611
2612 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2613 if (!ap_sta) {
2614 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
2615 bss_conf->bssid, arvif->vdev_id);
2616 rcu_read_unlock();
2617 return;
2618 }
2619
2620 /* ap_sta must be accessed only within rcu section which must be left
2621 * before calling ath10k_setup_peer_smps() which might sleep. */
2622 ht_cap = ap_sta->ht_cap;
2623 vht_cap = ap_sta->vht_cap;
2624
2625 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
2626 if (ret) {
2627 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
2628 bss_conf->bssid, arvif->vdev_id, ret);
2629 rcu_read_unlock();
2630 return;
2631 }
2632
2633 rcu_read_unlock();
2634
2635 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2636 if (ret) {
2637 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
2638 bss_conf->bssid, arvif->vdev_id, ret);
2639 return;
2640 }
2641
2642 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
2643 if (ret) {
2644 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
2645 arvif->vdev_id, ret);
2646 return;
2647 }
2648
2649 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2650 if (ret) {
2651 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
2652 arvif->vdev_id, bss_conf->bssid, ret);
2653 return;
2654 }
2655
2656 ath10k_dbg(ar, ATH10K_DBG_MAC,
2657 "mac vdev %d up (associated) bssid %pM aid %d\n",
2658 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
2659
2660 WARN_ON(arvif->is_up);
2661
2662 arvif->aid = bss_conf->aid;
2663 ether_addr_copy(arvif->bssid, bss_conf->bssid);
2664
2665 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2666 if (ret) {
2667 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
2668 arvif->vdev_id, ret);
2669 return;
2670 }
2671
2672 arvif->is_up = true;
2673
2674 /* Workaround: Some firmware revisions (tested with qca6174
2675 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
2676 * poked with peer param command.
2677 */
2678 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
2679 WMI_PEER_DUMMY_VAR, 1);
2680 if (ret) {
2681 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
2682 arvif->bssid, arvif->vdev_id, ret);
2683 return;
2684 }
2685 }
2686
2687 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
2688 struct ieee80211_vif *vif)
2689 {
2690 struct ath10k *ar = hw->priv;
2691 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2692 struct ieee80211_sta_vht_cap vht_cap = {};
2693 int ret;
2694
2695 lockdep_assert_held(&ar->conf_mutex);
2696
2697 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2698 arvif->vdev_id, arvif->bssid);
2699
2700 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2701 if (ret)
2702 ath10k_warn(ar, "faield to down vdev %i: %d\n",
2703 arvif->vdev_id, ret);
2704
2705 arvif->def_wep_key_idx = -1;
2706
2707 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2708 if (ret) {
2709 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",
2710 arvif->vdev_id, ret);
2711 return;
2712 }
2713
2714 arvif->is_up = false;
2715
2716 cancel_delayed_work_sync(&arvif->connection_loss_work);
2717 }
2718
2719 static int ath10k_station_assoc(struct ath10k *ar,
2720 struct ieee80211_vif *vif,
2721 struct ieee80211_sta *sta,
2722 bool reassoc)
2723 {
2724 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2725 struct wmi_peer_assoc_complete_arg peer_arg;
2726 int ret = 0;
2727
2728 lockdep_assert_held(&ar->conf_mutex);
2729
2730 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
2731 if (ret) {
2732 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
2733 sta->addr, arvif->vdev_id, ret);
2734 return ret;
2735 }
2736
2737 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2738 if (ret) {
2739 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
2740 sta->addr, arvif->vdev_id, ret);
2741 return ret;
2742 }
2743
2744 /* Re-assoc is run only to update supported rates for given station. It
2745 * doesn't make much sense to reconfigure the peer completely.
2746 */
2747 if (!reassoc) {
2748 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
2749 &sta->ht_cap);
2750 if (ret) {
2751 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
2752 arvif->vdev_id, ret);
2753 return ret;
2754 }
2755
2756 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
2757 if (ret) {
2758 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
2759 sta->addr, arvif->vdev_id, ret);
2760 return ret;
2761 }
2762
2763 if (!sta->wme) {
2764 arvif->num_legacy_stations++;
2765 ret = ath10k_recalc_rtscts_prot(arvif);
2766 if (ret) {
2767 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2768 arvif->vdev_id, ret);
2769 return ret;
2770 }
2771 }
2772
2773 /* Plumb cached keys only for static WEP */
2774 if (arvif->def_wep_key_idx != -1) {
2775 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
2776 if (ret) {
2777 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
2778 arvif->vdev_id, ret);
2779 return ret;
2780 }
2781 }
2782 }
2783
2784 return ret;
2785 }
2786
2787 static int ath10k_station_disassoc(struct ath10k *ar,
2788 struct ieee80211_vif *vif,
2789 struct ieee80211_sta *sta)
2790 {
2791 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2792 int ret = 0;
2793
2794 lockdep_assert_held(&ar->conf_mutex);
2795
2796 if (!sta->wme) {
2797 arvif->num_legacy_stations--;
2798 ret = ath10k_recalc_rtscts_prot(arvif);
2799 if (ret) {
2800 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2801 arvif->vdev_id, ret);
2802 return ret;
2803 }
2804 }
2805
2806 ret = ath10k_clear_peer_keys(arvif, sta->addr);
2807 if (ret) {
2808 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
2809 arvif->vdev_id, ret);
2810 return ret;
2811 }
2812
2813 return ret;
2814 }
2815
2816 /**************/
2817 /* Regulatory */
2818 /**************/
2819
2820 static int ath10k_update_channel_list(struct ath10k *ar)
2821 {
2822 struct ieee80211_hw *hw = ar->hw;
2823 struct ieee80211_supported_band **bands;
2824 enum ieee80211_band band;
2825 struct ieee80211_channel *channel;
2826 struct wmi_scan_chan_list_arg arg = {0};
2827 struct wmi_channel_arg *ch;
2828 bool passive;
2829 int len;
2830 int ret;
2831 int i;
2832
2833 lockdep_assert_held(&ar->conf_mutex);
2834
2835 bands = hw->wiphy->bands;
2836 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2837 if (!bands[band])
2838 continue;
2839
2840 for (i = 0; i < bands[band]->n_channels; i++) {
2841 if (bands[band]->channels[i].flags &
2842 IEEE80211_CHAN_DISABLED)
2843 continue;
2844
2845 arg.n_channels++;
2846 }
2847 }
2848
2849 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
2850 arg.channels = kzalloc(len, GFP_KERNEL);
2851 if (!arg.channels)
2852 return -ENOMEM;
2853
2854 ch = arg.channels;
2855 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2856 if (!bands[band])
2857 continue;
2858
2859 for (i = 0; i < bands[band]->n_channels; i++) {
2860 channel = &bands[band]->channels[i];
2861
2862 if (channel->flags & IEEE80211_CHAN_DISABLED)
2863 continue;
2864
2865 ch->allow_ht = true;
2866
2867 /* FIXME: when should we really allow VHT? */
2868 ch->allow_vht = true;
2869
2870 ch->allow_ibss =
2871 !(channel->flags & IEEE80211_CHAN_NO_IR);
2872
2873 ch->ht40plus =
2874 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
2875
2876 ch->chan_radar =
2877 !!(channel->flags & IEEE80211_CHAN_RADAR);
2878
2879 passive = channel->flags & IEEE80211_CHAN_NO_IR;
2880 ch->passive = passive;
2881
2882 ch->freq = channel->center_freq;
2883 ch->band_center_freq1 = channel->center_freq;
2884 ch->min_power = 0;
2885 ch->max_power = channel->max_power * 2;
2886 ch->max_reg_power = channel->max_reg_power * 2;
2887 ch->max_antenna_gain = channel->max_antenna_gain * 2;
2888 ch->reg_class_id = 0; /* FIXME */
2889
2890 /* FIXME: why use only legacy modes, why not any
2891 * HT/VHT modes? Would that even make any
2892 * difference? */
2893 if (channel->band == IEEE80211_BAND_2GHZ)
2894 ch->mode = MODE_11G;
2895 else
2896 ch->mode = MODE_11A;
2897
2898 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
2899 continue;
2900
2901 ath10k_dbg(ar, ATH10K_DBG_WMI,
2902 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
2903 ch - arg.channels, arg.n_channels,
2904 ch->freq, ch->max_power, ch->max_reg_power,
2905 ch->max_antenna_gain, ch->mode);
2906
2907 ch++;
2908 }
2909 }
2910
2911 ret = ath10k_wmi_scan_chan_list(ar, &arg);
2912 kfree(arg.channels);
2913
2914 return ret;
2915 }
2916
2917 static enum wmi_dfs_region
2918 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
2919 {
2920 switch (dfs_region) {
2921 case NL80211_DFS_UNSET:
2922 return WMI_UNINIT_DFS_DOMAIN;
2923 case NL80211_DFS_FCC:
2924 return WMI_FCC_DFS_DOMAIN;
2925 case NL80211_DFS_ETSI:
2926 return WMI_ETSI_DFS_DOMAIN;
2927 case NL80211_DFS_JP:
2928 return WMI_MKK4_DFS_DOMAIN;
2929 }
2930 return WMI_UNINIT_DFS_DOMAIN;
2931 }
2932
2933 static void ath10k_regd_update(struct ath10k *ar)
2934 {
2935 struct reg_dmn_pair_mapping *regpair;
2936 int ret;
2937 enum wmi_dfs_region wmi_dfs_reg;
2938 enum nl80211_dfs_regions nl_dfs_reg;
2939
2940 lockdep_assert_held(&ar->conf_mutex);
2941
2942 ret = ath10k_update_channel_list(ar);
2943 if (ret)
2944 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
2945
2946 regpair = ar->ath_common.regulatory.regpair;
2947
2948 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2949 nl_dfs_reg = ar->dfs_detector->region;
2950 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
2951 } else {
2952 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
2953 }
2954
2955 /* Target allows setting up per-band regdomain but ath_common provides
2956 * a combined one only */
2957 ret = ath10k_wmi_pdev_set_regdomain(ar,
2958 regpair->reg_domain,
2959 regpair->reg_domain, /* 2ghz */
2960 regpair->reg_domain, /* 5ghz */
2961 regpair->reg_2ghz_ctl,
2962 regpair->reg_5ghz_ctl,
2963 wmi_dfs_reg);
2964 if (ret)
2965 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
2966 }
2967
2968 static void ath10k_reg_notifier(struct wiphy *wiphy,
2969 struct regulatory_request *request)
2970 {
2971 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
2972 struct ath10k *ar = hw->priv;
2973 bool result;
2974
2975 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
2976
2977 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2978 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
2979 request->dfs_region);
2980 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
2981 request->dfs_region);
2982 if (!result)
2983 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
2984 request->dfs_region);
2985 }
2986
2987 mutex_lock(&ar->conf_mutex);
2988 if (ar->state == ATH10K_STATE_ON)
2989 ath10k_regd_update(ar);
2990 mutex_unlock(&ar->conf_mutex);
2991 }
2992
2993 /***************/
2994 /* TX handlers */
2995 /***************/
2996
2997 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
2998 {
2999 lockdep_assert_held(&ar->htt.tx_lock);
3000
3001 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3002 ar->tx_paused |= BIT(reason);
3003 ieee80211_stop_queues(ar->hw);
3004 }
3005
3006 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,
3007 struct ieee80211_vif *vif)
3008 {
3009 struct ath10k *ar = data;
3010 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3011
3012 if (arvif->tx_paused)
3013 return;
3014
3015 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3016 }
3017
3018 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)
3019 {
3020 lockdep_assert_held(&ar->htt.tx_lock);
3021
3022 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3023 ar->tx_paused &= ~BIT(reason);
3024
3025 if (ar->tx_paused)
3026 return;
3027
3028 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3029 IEEE80211_IFACE_ITER_RESUME_ALL,
3030 ath10k_mac_tx_unlock_iter,
3031 ar);
3032
3033 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue);
3034 }
3035
3036 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)
3037 {
3038 struct ath10k *ar = arvif->ar;
3039
3040 lockdep_assert_held(&ar->htt.tx_lock);
3041
3042 WARN_ON(reason >= BITS_PER_LONG);
3043 arvif->tx_paused |= BIT(reason);
3044 ieee80211_stop_queue(ar->hw, arvif->vdev_id);
3045 }
3046
3047 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason)
3048 {
3049 struct ath10k *ar = arvif->ar;
3050
3051 lockdep_assert_held(&ar->htt.tx_lock);
3052
3053 WARN_ON(reason >= BITS_PER_LONG);
3054 arvif->tx_paused &= ~BIT(reason);
3055
3056 if (ar->tx_paused)
3057 return;
3058
3059 if (arvif->tx_paused)
3060 return;
3061
3062 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3063 }
3064
3065 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,
3066 enum wmi_tlv_tx_pause_id pause_id,
3067 enum wmi_tlv_tx_pause_action action)
3068 {
3069 struct ath10k *ar = arvif->ar;
3070
3071 lockdep_assert_held(&ar->htt.tx_lock);
3072
3073 switch (action) {
3074 case WMI_TLV_TX_PAUSE_ACTION_STOP:
3075 ath10k_mac_vif_tx_lock(arvif, pause_id);
3076 break;
3077 case WMI_TLV_TX_PAUSE_ACTION_WAKE:
3078 ath10k_mac_vif_tx_unlock(arvif, pause_id);
3079 break;
3080 default:
3081 ath10k_warn(ar, "received unknown tx pause action %d on vdev %i, ignoring\n",
3082 action, arvif->vdev_id);
3083 break;
3084 }
3085 }
3086
3087 struct ath10k_mac_tx_pause {
3088 u32 vdev_id;
3089 enum wmi_tlv_tx_pause_id pause_id;
3090 enum wmi_tlv_tx_pause_action action;
3091 };
3092
3093 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,
3094 struct ieee80211_vif *vif)
3095 {
3096 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3097 struct ath10k_mac_tx_pause *arg = data;
3098
3099 if (arvif->vdev_id != arg->vdev_id)
3100 return;
3101
3102 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);
3103 }
3104
3105 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id,
3106 enum wmi_tlv_tx_pause_id pause_id,
3107 enum wmi_tlv_tx_pause_action action)
3108 {
3109 struct ath10k_mac_tx_pause arg = {
3110 .vdev_id = vdev_id,
3111 .pause_id = pause_id,
3112 .action = action,
3113 };
3114
3115 spin_lock_bh(&ar->htt.tx_lock);
3116 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3117 IEEE80211_IFACE_ITER_RESUME_ALL,
3118 ath10k_mac_handle_tx_pause_iter,
3119 &arg);
3120 spin_unlock_bh(&ar->htt.tx_lock);
3121 }
3122
3123 static enum ath10k_hw_txrx_mode
3124 ath10k_mac_tx_h_get_txmode(struct ath10k *ar,
3125 struct ieee80211_vif *vif,
3126 struct ieee80211_sta *sta,
3127 struct sk_buff *skb)
3128 {
3129 const struct ieee80211_hdr *hdr = (void *)skb->data;
3130 __le16 fc = hdr->frame_control;
3131
3132 if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3133 return ATH10K_HW_TXRX_RAW;
3134
3135 if (ieee80211_is_mgmt(fc))
3136 return ATH10K_HW_TXRX_MGMT;
3137
3138 /* Workaround:
3139 *
3140 * NullFunc frames are mostly used to ping if a client or AP are still
3141 * reachable and responsive. This implies tx status reports must be
3142 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3143 * come to a conclusion that the other end disappeared and tear down
3144 * BSS connection or it can never disconnect from BSS/client (which is
3145 * the case).
3146 *
3147 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3148 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3149 * which seems to deliver correct tx reports for NullFunc frames. The
3150 * downside of using it is it ignores client powersave state so it can
3151 * end up disconnecting sleeping clients in AP mode. It should fix STA
3152 * mode though because AP don't sleep.
3153 */
3154 if (ar->htt.target_version_major < 3 &&
3155 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3156 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, ar->fw_features))
3157 return ATH10K_HW_TXRX_MGMT;
3158
3159 /* Workaround:
3160 *
3161 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3162 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3163 * to work with Ethernet txmode so use it.
3164 *
3165 * FIXME: Check if raw mode works with TDLS.
3166 */
3167 if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3168 return ATH10K_HW_TXRX_ETHERNET;
3169
3170 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
3171 return ATH10K_HW_TXRX_RAW;
3172
3173 return ATH10K_HW_TXRX_NATIVE_WIFI;
3174 }
3175
3176 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,
3177 struct sk_buff *skb)
3178 {
3179 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3180 const struct ieee80211_hdr *hdr = (void *)skb->data;
3181 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |
3182 IEEE80211_TX_CTL_INJECTED;
3183
3184 if (!ieee80211_has_protected(hdr->frame_control))
3185 return false;
3186
3187 if ((info->flags & mask) == mask)
3188 return false;
3189
3190 if (vif)
3191 return !ath10k_vif_to_arvif(vif)->nohwcrypt;
3192
3193 return true;
3194 }
3195
3196 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3197 * Control in the header.
3198 */
3199 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3200 {
3201 struct ieee80211_hdr *hdr = (void *)skb->data;
3202 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3203 u8 *qos_ctl;
3204
3205 if (!ieee80211_is_data_qos(hdr->frame_control))
3206 return;
3207
3208 qos_ctl = ieee80211_get_qos_ctl(hdr);
3209 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3210 skb->data, (void *)qos_ctl - (void *)skb->data);
3211 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3212
3213 /* Some firmware revisions don't handle sending QoS NullFunc well.
3214 * These frames are mainly used for CQM purposes so it doesn't really
3215 * matter whether QoS NullFunc or NullFunc are sent.
3216 */
3217 hdr = (void *)skb->data;
3218 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3219 cb->flags &= ~ATH10K_SKB_F_QOS;
3220
3221 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3222 }
3223
3224 static void ath10k_tx_h_8023(struct sk_buff *skb)
3225 {
3226 struct ieee80211_hdr *hdr;
3227 struct rfc1042_hdr *rfc1042;
3228 struct ethhdr *eth;
3229 size_t hdrlen;
3230 u8 da[ETH_ALEN];
3231 u8 sa[ETH_ALEN];
3232 __be16 type;
3233
3234 hdr = (void *)skb->data;
3235 hdrlen = ieee80211_hdrlen(hdr->frame_control);
3236 rfc1042 = (void *)skb->data + hdrlen;
3237
3238 ether_addr_copy(da, ieee80211_get_DA(hdr));
3239 ether_addr_copy(sa, ieee80211_get_SA(hdr));
3240 type = rfc1042->snap_type;
3241
3242 skb_pull(skb, hdrlen + sizeof(*rfc1042));
3243 skb_push(skb, sizeof(*eth));
3244
3245 eth = (void *)skb->data;
3246 ether_addr_copy(eth->h_dest, da);
3247 ether_addr_copy(eth->h_source, sa);
3248 eth->h_proto = type;
3249 }
3250
3251 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3252 struct ieee80211_vif *vif,
3253 struct sk_buff *skb)
3254 {
3255 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3256 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3257
3258 /* This is case only for P2P_GO */
3259 if (vif->type != NL80211_IFTYPE_AP || !vif->p2p)
3260 return;
3261
3262 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3263 spin_lock_bh(&ar->data_lock);
3264 if (arvif->u.ap.noa_data)
3265 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3266 GFP_ATOMIC))
3267 memcpy(skb_put(skb, arvif->u.ap.noa_len),
3268 arvif->u.ap.noa_data,
3269 arvif->u.ap.noa_len);
3270 spin_unlock_bh(&ar->data_lock);
3271 }
3272 }
3273
3274 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)
3275 {
3276 /* FIXME: Not really sure since when the behaviour changed. At some
3277 * point new firmware stopped requiring creation of peer entries for
3278 * offchannel tx (and actually creating them causes issues with wmi-htc
3279 * tx credit replenishment and reliability). Assuming it's at least 3.4
3280 * because that's when the `freq` was introduced to TX_FRM HTT command.
3281 */
3282 return (ar->htt.target_version_major >= 3 &&
3283 ar->htt.target_version_minor >= 4 &&
3284 ar->htt.op_version == ATH10K_FW_HTT_OP_VERSION_TLV);
3285 }
3286
3287 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3288 {
3289 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3290 int ret = 0;
3291
3292 spin_lock_bh(&ar->data_lock);
3293
3294 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) {
3295 ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3296 ret = -ENOSPC;
3297 goto unlock;
3298 }
3299
3300 __skb_queue_tail(q, skb);
3301 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3302
3303 unlock:
3304 spin_unlock_bh(&ar->data_lock);
3305
3306 return ret;
3307 }
3308
3309 static void ath10k_mac_tx(struct ath10k *ar, enum ath10k_hw_txrx_mode txmode,
3310 struct sk_buff *skb)
3311 {
3312 struct ath10k_htt *htt = &ar->htt;
3313 int ret = 0;
3314
3315 switch (txmode) {
3316 case ATH10K_HW_TXRX_RAW:
3317 case ATH10K_HW_TXRX_NATIVE_WIFI:
3318 case ATH10K_HW_TXRX_ETHERNET:
3319 ret = ath10k_htt_tx(htt, txmode, skb);
3320 break;
3321 case ATH10K_HW_TXRX_MGMT:
3322 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3323 ar->fw_features))
3324 ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
3325 else if (ar->htt.target_version_major >= 3)
3326 ret = ath10k_htt_tx(htt, txmode, skb);
3327 else
3328 ret = ath10k_htt_mgmt_tx(htt, skb);
3329 break;
3330 }
3331
3332 if (ret) {
3333 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
3334 ret);
3335 ieee80211_free_txskb(ar->hw, skb);
3336 }
3337 }
3338
3339 void ath10k_offchan_tx_purge(struct ath10k *ar)
3340 {
3341 struct sk_buff *skb;
3342
3343 for (;;) {
3344 skb = skb_dequeue(&ar->offchan_tx_queue);
3345 if (!skb)
3346 break;
3347
3348 ieee80211_free_txskb(ar->hw, skb);
3349 }
3350 }
3351
3352 void ath10k_offchan_tx_work(struct work_struct *work)
3353 {
3354 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
3355 struct ath10k_peer *peer;
3356 struct ath10k_vif *arvif;
3357 struct ieee80211_hdr *hdr;
3358 struct ieee80211_vif *vif;
3359 struct ieee80211_sta *sta;
3360 struct sk_buff *skb;
3361 const u8 *peer_addr;
3362 enum ath10k_hw_txrx_mode txmode;
3363 int vdev_id;
3364 int ret;
3365 unsigned long time_left;
3366 bool tmp_peer_created = false;
3367
3368 /* FW requirement: We must create a peer before FW will send out
3369 * an offchannel frame. Otherwise the frame will be stuck and
3370 * never transmitted. We delete the peer upon tx completion.
3371 * It is unlikely that a peer for offchannel tx will already be
3372 * present. However it may be in some rare cases so account for that.
3373 * Otherwise we might remove a legitimate peer and break stuff. */
3374
3375 for (;;) {
3376 skb = skb_dequeue(&ar->offchan_tx_queue);
3377 if (!skb)
3378 break;
3379
3380 mutex_lock(&ar->conf_mutex);
3381
3382 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
3383 skb);
3384
3385 hdr = (struct ieee80211_hdr *)skb->data;
3386 peer_addr = ieee80211_get_DA(hdr);
3387
3388 spin_lock_bh(&ar->data_lock);
3389 vdev_id = ar->scan.vdev_id;
3390 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
3391 spin_unlock_bh(&ar->data_lock);
3392
3393 if (peer)
3394 /* FIXME: should this use ath10k_warn()? */
3395 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
3396 peer_addr, vdev_id);
3397
3398 if (!peer) {
3399 ret = ath10k_peer_create(ar, vdev_id, peer_addr,
3400 WMI_PEER_TYPE_DEFAULT);
3401 if (ret)
3402 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
3403 peer_addr, vdev_id, ret);
3404 tmp_peer_created = (ret == 0);
3405 }
3406
3407 spin_lock_bh(&ar->data_lock);
3408 reinit_completion(&ar->offchan_tx_completed);
3409 ar->offchan_tx_skb = skb;
3410 spin_unlock_bh(&ar->data_lock);
3411
3412 /* It's safe to access vif and sta - conf_mutex guarantees that
3413 * sta_state() and remove_interface() are locked exclusively
3414 * out wrt to this offchannel worker.
3415 */
3416 arvif = ath10k_get_arvif(ar, vdev_id);
3417 if (arvif) {
3418 vif = arvif->vif;
3419 sta = ieee80211_find_sta(vif, peer_addr);
3420 } else {
3421 vif = NULL;
3422 sta = NULL;
3423 }
3424
3425 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3426
3427 ath10k_mac_tx(ar, txmode, skb);
3428
3429 time_left =
3430 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
3431 if (time_left == 0)
3432 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
3433 skb);
3434
3435 if (!peer && tmp_peer_created) {
3436 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
3437 if (ret)
3438 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
3439 peer_addr, vdev_id, ret);
3440 }
3441
3442 mutex_unlock(&ar->conf_mutex);
3443 }
3444 }
3445
3446 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
3447 {
3448 struct sk_buff *skb;
3449
3450 for (;;) {
3451 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3452 if (!skb)
3453 break;
3454
3455 ieee80211_free_txskb(ar->hw, skb);
3456 }
3457 }
3458
3459 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
3460 {
3461 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
3462 struct sk_buff *skb;
3463 int ret;
3464
3465 for (;;) {
3466 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3467 if (!skb)
3468 break;
3469
3470 ret = ath10k_wmi_mgmt_tx(ar, skb);
3471 if (ret) {
3472 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
3473 ret);
3474 ieee80211_free_txskb(ar->hw, skb);
3475 }
3476 }
3477 }
3478
3479 /************/
3480 /* Scanning */
3481 /************/
3482
3483 void __ath10k_scan_finish(struct ath10k *ar)
3484 {
3485 lockdep_assert_held(&ar->data_lock);
3486
3487 switch (ar->scan.state) {
3488 case ATH10K_SCAN_IDLE:
3489 break;
3490 case ATH10K_SCAN_RUNNING:
3491 case ATH10K_SCAN_ABORTING:
3492 if (!ar->scan.is_roc)
3493 ieee80211_scan_completed(ar->hw,
3494 (ar->scan.state ==
3495 ATH10K_SCAN_ABORTING));
3496 else if (ar->scan.roc_notify)
3497 ieee80211_remain_on_channel_expired(ar->hw);
3498 /* fall through */
3499 case ATH10K_SCAN_STARTING:
3500 ar->scan.state = ATH10K_SCAN_IDLE;
3501 ar->scan_channel = NULL;
3502 ar->scan.roc_freq = 0;
3503 ath10k_offchan_tx_purge(ar);
3504 cancel_delayed_work(&ar->scan.timeout);
3505 complete_all(&ar->scan.completed);
3506 break;
3507 }
3508 }
3509
3510 void ath10k_scan_finish(struct ath10k *ar)
3511 {
3512 spin_lock_bh(&ar->data_lock);
3513 __ath10k_scan_finish(ar);
3514 spin_unlock_bh(&ar->data_lock);
3515 }
3516
3517 static int ath10k_scan_stop(struct ath10k *ar)
3518 {
3519 struct wmi_stop_scan_arg arg = {
3520 .req_id = 1, /* FIXME */
3521 .req_type = WMI_SCAN_STOP_ONE,
3522 .u.scan_id = ATH10K_SCAN_ID,
3523 };
3524 int ret;
3525
3526 lockdep_assert_held(&ar->conf_mutex);
3527
3528 ret = ath10k_wmi_stop_scan(ar, &arg);
3529 if (ret) {
3530 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
3531 goto out;
3532 }
3533
3534 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
3535 if (ret == 0) {
3536 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
3537 ret = -ETIMEDOUT;
3538 } else if (ret > 0) {
3539 ret = 0;
3540 }
3541
3542 out:
3543 /* Scan state should be updated upon scan completion but in case
3544 * firmware fails to deliver the event (for whatever reason) it is
3545 * desired to clean up scan state anyway. Firmware may have just
3546 * dropped the scan completion event delivery due to transport pipe
3547 * being overflown with data and/or it can recover on its own before
3548 * next scan request is submitted.
3549 */
3550 spin_lock_bh(&ar->data_lock);
3551 if (ar->scan.state != ATH10K_SCAN_IDLE)
3552 __ath10k_scan_finish(ar);
3553 spin_unlock_bh(&ar->data_lock);
3554
3555 return ret;
3556 }
3557
3558 static void ath10k_scan_abort(struct ath10k *ar)
3559 {
3560 int ret;
3561
3562 lockdep_assert_held(&ar->conf_mutex);
3563
3564 spin_lock_bh(&ar->data_lock);
3565
3566 switch (ar->scan.state) {
3567 case ATH10K_SCAN_IDLE:
3568 /* This can happen if timeout worker kicked in and called
3569 * abortion while scan completion was being processed.
3570 */
3571 break;
3572 case ATH10K_SCAN_STARTING:
3573 case ATH10K_SCAN_ABORTING:
3574 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3575 ath10k_scan_state_str(ar->scan.state),
3576 ar->scan.state);
3577 break;
3578 case ATH10K_SCAN_RUNNING:
3579 ar->scan.state = ATH10K_SCAN_ABORTING;
3580 spin_unlock_bh(&ar->data_lock);
3581
3582 ret = ath10k_scan_stop(ar);
3583 if (ret)
3584 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
3585
3586 spin_lock_bh(&ar->data_lock);
3587 break;
3588 }
3589
3590 spin_unlock_bh(&ar->data_lock);
3591 }
3592
3593 void ath10k_scan_timeout_work(struct work_struct *work)
3594 {
3595 struct ath10k *ar = container_of(work, struct ath10k,
3596 scan.timeout.work);
3597
3598 mutex_lock(&ar->conf_mutex);
3599 ath10k_scan_abort(ar);
3600 mutex_unlock(&ar->conf_mutex);
3601 }
3602
3603 static int ath10k_start_scan(struct ath10k *ar,
3604 const struct wmi_start_scan_arg *arg)
3605 {
3606 int ret;
3607
3608 lockdep_assert_held(&ar->conf_mutex);
3609
3610 ret = ath10k_wmi_start_scan(ar, arg);
3611 if (ret)
3612 return ret;
3613
3614 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
3615 if (ret == 0) {
3616 ret = ath10k_scan_stop(ar);
3617 if (ret)
3618 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3619
3620 return -ETIMEDOUT;
3621 }
3622
3623 /* If we failed to start the scan, return error code at
3624 * this point. This is probably due to some issue in the
3625 * firmware, but no need to wedge the driver due to that...
3626 */
3627 spin_lock_bh(&ar->data_lock);
3628 if (ar->scan.state == ATH10K_SCAN_IDLE) {
3629 spin_unlock_bh(&ar->data_lock);
3630 return -EINVAL;
3631 }
3632 spin_unlock_bh(&ar->data_lock);
3633
3634 return 0;
3635 }
3636
3637 /**********************/
3638 /* mac80211 callbacks */
3639 /**********************/
3640
3641 static void ath10k_tx(struct ieee80211_hw *hw,
3642 struct ieee80211_tx_control *control,
3643 struct sk_buff *skb)
3644 {
3645 struct ath10k *ar = hw->priv;
3646 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
3647 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3648 struct ieee80211_vif *vif = info->control.vif;
3649 struct ieee80211_sta *sta = control->sta;
3650 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3651 enum ath10k_hw_txrx_mode txmode;
3652
3653 /* We should disable CCK RATE due to P2P */
3654 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
3655 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3656
3657 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3658
3659 skb_cb->flags = 0;
3660 if (!ath10k_tx_h_use_hwcrypto(vif, skb))
3661 skb_cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3662
3663 if (ieee80211_is_mgmt(hdr->frame_control))
3664 skb_cb->flags |= ATH10K_SKB_F_MGMT;
3665
3666 if (ieee80211_is_data_qos(hdr->frame_control))
3667 skb_cb->flags |= ATH10K_SKB_F_QOS;
3668
3669 skb_cb->vif = vif;
3670
3671 switch (txmode) {
3672 case ATH10K_HW_TXRX_MGMT:
3673 case ATH10K_HW_TXRX_NATIVE_WIFI:
3674 ath10k_tx_h_nwifi(hw, skb);
3675 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
3676 ath10k_tx_h_seq_no(vif, skb);
3677 break;
3678 case ATH10K_HW_TXRX_ETHERNET:
3679 ath10k_tx_h_8023(skb);
3680 break;
3681 case ATH10K_HW_TXRX_RAW:
3682 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
3683 WARN_ON_ONCE(1);
3684 ieee80211_free_txskb(hw, skb);
3685 return;
3686 }
3687 }
3688
3689 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
3690 if (!ath10k_mac_tx_frm_has_freq(ar)) {
3691 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
3692 skb);
3693
3694 skb_queue_tail(&ar->offchan_tx_queue, skb);
3695 ieee80211_queue_work(hw, &ar->offchan_tx_work);
3696 return;
3697 }
3698 }
3699
3700 ath10k_mac_tx(ar, txmode, skb);
3701 }
3702
3703 /* Must not be called with conf_mutex held as workers can use that also. */
3704 void ath10k_drain_tx(struct ath10k *ar)
3705 {
3706 /* make sure rcu-protected mac80211 tx path itself is drained */
3707 synchronize_net();
3708
3709 ath10k_offchan_tx_purge(ar);
3710 ath10k_mgmt_over_wmi_tx_purge(ar);
3711
3712 cancel_work_sync(&ar->offchan_tx_work);
3713 cancel_work_sync(&ar->wmi_mgmt_tx_work);
3714 }
3715
3716 void ath10k_halt(struct ath10k *ar)
3717 {
3718 struct ath10k_vif *arvif;
3719
3720 lockdep_assert_held(&ar->conf_mutex);
3721
3722 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
3723 ar->filter_flags = 0;
3724 ar->monitor = false;
3725 ar->monitor_arvif = NULL;
3726
3727 if (ar->monitor_started)
3728 ath10k_monitor_stop(ar);
3729
3730 ar->monitor_started = false;
3731 ar->tx_paused = 0;
3732
3733 ath10k_scan_finish(ar);
3734 ath10k_peer_cleanup_all(ar);
3735 ath10k_core_stop(ar);
3736 ath10k_hif_power_down(ar);
3737
3738 spin_lock_bh(&ar->data_lock);
3739 list_for_each_entry(arvif, &ar->arvifs, list)
3740 ath10k_mac_vif_beacon_cleanup(arvif);
3741 spin_unlock_bh(&ar->data_lock);
3742 }
3743
3744 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
3745 {
3746 struct ath10k *ar = hw->priv;
3747
3748 mutex_lock(&ar->conf_mutex);
3749
3750 *tx_ant = ar->cfg_tx_chainmask;
3751 *rx_ant = ar->cfg_rx_chainmask;
3752
3753 mutex_unlock(&ar->conf_mutex);
3754
3755 return 0;
3756 }
3757
3758 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
3759 {
3760 /* It is not clear that allowing gaps in chainmask
3761 * is helpful. Probably it will not do what user
3762 * is hoping for, so warn in that case.
3763 */
3764 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
3765 return;
3766
3767 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
3768 dbg, cm);
3769 }
3770
3771 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
3772 {
3773 int nsts = ar->vht_cap_info;
3774
3775 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
3776 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
3777
3778 /* If firmware does not deliver to host number of space-time
3779 * streams supported, assume it support up to 4 BF STS and return
3780 * the value for VHT CAP: nsts-1)
3781 */
3782 if (nsts == 0)
3783 return 3;
3784
3785 return nsts;
3786 }
3787
3788 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
3789 {
3790 int sound_dim = ar->vht_cap_info;
3791
3792 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
3793 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
3794
3795 /* If the sounding dimension is not advertised by the firmware,
3796 * let's use a default value of 1
3797 */
3798 if (sound_dim == 0)
3799 return 1;
3800
3801 return sound_dim;
3802 }
3803
3804 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3805 {
3806 struct ieee80211_sta_vht_cap vht_cap = {0};
3807 u16 mcs_map;
3808 u32 val;
3809 int i;
3810
3811 vht_cap.vht_supported = 1;
3812 vht_cap.cap = ar->vht_cap_info;
3813
3814 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
3815 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
3816 val = ath10k_mac_get_vht_cap_bf_sts(ar);
3817 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
3818 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
3819
3820 vht_cap.cap |= val;
3821 }
3822
3823 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
3824 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
3825 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
3826 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
3827 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
3828
3829 vht_cap.cap |= val;
3830 }
3831
3832 mcs_map = 0;
3833 for (i = 0; i < 8; i++) {
3834 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))
3835 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
3836 else
3837 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
3838 }
3839
3840 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3841 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3842
3843 return vht_cap;
3844 }
3845
3846 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3847 {
3848 int i;
3849 struct ieee80211_sta_ht_cap ht_cap = {0};
3850
3851 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3852 return ht_cap;
3853
3854 ht_cap.ht_supported = 1;
3855 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3856 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3857 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3858 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3859 ht_cap.cap |=
3860 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT;
3861
3862 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3863 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3864
3865 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3866 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3867
3868 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3869 u32 smps;
3870
3871 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3872 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3873
3874 ht_cap.cap |= smps;
3875 }
3876
3877 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3878 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3879
3880 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3881 u32 stbc;
3882
3883 stbc = ar->ht_cap_info;
3884 stbc &= WMI_HT_CAP_RX_STBC;
3885 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3886 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3887 stbc &= IEEE80211_HT_CAP_RX_STBC;
3888
3889 ht_cap.cap |= stbc;
3890 }
3891
3892 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3893 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3894
3895 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3896 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3897
3898 /* max AMSDU is implicitly taken from vht_cap_info */
3899 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3900 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3901
3902 for (i = 0; i < ar->num_rf_chains; i++) {
3903 if (ar->cfg_rx_chainmask & BIT(i))
3904 ht_cap.mcs.rx_mask[i] = 0xFF;
3905 }
3906
3907 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3908
3909 return ht_cap;
3910 }
3911
3912 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
3913 {
3914 struct ieee80211_supported_band *band;
3915 struct ieee80211_sta_vht_cap vht_cap;
3916 struct ieee80211_sta_ht_cap ht_cap;
3917
3918 ht_cap = ath10k_get_ht_cap(ar);
3919 vht_cap = ath10k_create_vht_cap(ar);
3920
3921 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3922 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3923 band->ht_cap = ht_cap;
3924
3925 /* Enable the VHT support at 2.4 GHz */
3926 band->vht_cap = vht_cap;
3927 }
3928 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3929 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3930 band->ht_cap = ht_cap;
3931 band->vht_cap = vht_cap;
3932 }
3933 }
3934
3935 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
3936 {
3937 int ret;
3938
3939 lockdep_assert_held(&ar->conf_mutex);
3940
3941 ath10k_check_chain_mask(ar, tx_ant, "tx");
3942 ath10k_check_chain_mask(ar, rx_ant, "rx");
3943
3944 ar->cfg_tx_chainmask = tx_ant;
3945 ar->cfg_rx_chainmask = rx_ant;
3946
3947 if ((ar->state != ATH10K_STATE_ON) &&
3948 (ar->state != ATH10K_STATE_RESTARTED))
3949 return 0;
3950
3951 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
3952 tx_ant);
3953 if (ret) {
3954 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
3955 ret, tx_ant);
3956 return ret;
3957 }
3958
3959 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
3960 rx_ant);
3961 if (ret) {
3962 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
3963 ret, rx_ant);
3964 return ret;
3965 }
3966
3967 /* Reload HT/VHT capability */
3968 ath10k_mac_setup_ht_vht_cap(ar);
3969
3970 return 0;
3971 }
3972
3973 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
3974 {
3975 struct ath10k *ar = hw->priv;
3976 int ret;
3977
3978 mutex_lock(&ar->conf_mutex);
3979 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
3980 mutex_unlock(&ar->conf_mutex);
3981 return ret;
3982 }
3983
3984 static int ath10k_start(struct ieee80211_hw *hw)
3985 {
3986 struct ath10k *ar = hw->priv;
3987 u32 param;
3988 int ret = 0;
3989
3990 /*
3991 * This makes sense only when restarting hw. It is harmless to call
3992 * uncoditionally. This is necessary to make sure no HTT/WMI tx
3993 * commands will be submitted while restarting.
3994 */
3995 ath10k_drain_tx(ar);
3996
3997 mutex_lock(&ar->conf_mutex);
3998
3999 switch (ar->state) {
4000 case ATH10K_STATE_OFF:
4001 ar->state = ATH10K_STATE_ON;
4002 break;
4003 case ATH10K_STATE_RESTARTING:
4004 ath10k_halt(ar);
4005 ar->state = ATH10K_STATE_RESTARTED;
4006 break;
4007 case ATH10K_STATE_ON:
4008 case ATH10K_STATE_RESTARTED:
4009 case ATH10K_STATE_WEDGED:
4010 WARN_ON(1);
4011 ret = -EINVAL;
4012 goto err;
4013 case ATH10K_STATE_UTF:
4014 ret = -EBUSY;
4015 goto err;
4016 }
4017
4018 ret = ath10k_hif_power_up(ar);
4019 if (ret) {
4020 ath10k_err(ar, "Could not init hif: %d\n", ret);
4021 goto err_off;
4022 }
4023
4024 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
4025 if (ret) {
4026 ath10k_err(ar, "Could not init core: %d\n", ret);
4027 goto err_power_down;
4028 }
4029
4030 param = ar->wmi.pdev_param->pmf_qos;
4031 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4032 if (ret) {
4033 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
4034 goto err_core_stop;
4035 }
4036
4037 param = ar->wmi.pdev_param->dynamic_bw;
4038 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4039 if (ret) {
4040 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
4041 goto err_core_stop;
4042 }
4043
4044 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
4045 ret = ath10k_wmi_adaptive_qcs(ar, true);
4046 if (ret) {
4047 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
4048 ret);
4049 goto err_core_stop;
4050 }
4051 }
4052
4053 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
4054 param = ar->wmi.pdev_param->burst_enable;
4055 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
4056 if (ret) {
4057 ath10k_warn(ar, "failed to disable burst: %d\n", ret);
4058 goto err_core_stop;
4059 }
4060 }
4061
4062 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
4063
4064 /*
4065 * By default FW set ARP frames ac to voice (6). In that case ARP
4066 * exchange is not working properly for UAPSD enabled AP. ARP requests
4067 * which arrives with access category 0 are processed by network stack
4068 * and send back with access category 0, but FW changes access category
4069 * to 6. Set ARP frames access category to best effort (0) solves
4070 * this problem.
4071 */
4072
4073 param = ar->wmi.pdev_param->arp_ac_override;
4074 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
4075 if (ret) {
4076 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
4077 ret);
4078 goto err_core_stop;
4079 }
4080
4081 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
4082 ar->fw_features)) {
4083 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
4084 WMI_CCA_DETECT_LEVEL_AUTO,
4085 WMI_CCA_DETECT_MARGIN_AUTO);
4086 if (ret) {
4087 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
4088 ret);
4089 goto err_core_stop;
4090 }
4091 }
4092
4093 param = ar->wmi.pdev_param->ani_enable;
4094 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4095 if (ret) {
4096 ath10k_warn(ar, "failed to enable ani by default: %d\n",
4097 ret);
4098 goto err_core_stop;
4099 }
4100
4101 ar->ani_enabled = true;
4102
4103 if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
4104 param = ar->wmi.pdev_param->peer_stats_update_period;
4105 ret = ath10k_wmi_pdev_set_param(ar, param,
4106 PEER_DEFAULT_STATS_UPDATE_PERIOD);
4107 if (ret) {
4108 ath10k_warn(ar,
4109 "failed to set peer stats period : %d\n",
4110 ret);
4111 goto err_core_stop;
4112 }
4113 }
4114
4115 ar->num_started_vdevs = 0;
4116 ath10k_regd_update(ar);
4117
4118 ath10k_spectral_start(ar);
4119 ath10k_thermal_set_throttling(ar);
4120
4121 mutex_unlock(&ar->conf_mutex);
4122 return 0;
4123
4124 err_core_stop:
4125 ath10k_core_stop(ar);
4126
4127 err_power_down:
4128 ath10k_hif_power_down(ar);
4129
4130 err_off:
4131 ar->state = ATH10K_STATE_OFF;
4132
4133 err:
4134 mutex_unlock(&ar->conf_mutex);
4135 return ret;
4136 }
4137
4138 static void ath10k_stop(struct ieee80211_hw *hw)
4139 {
4140 struct ath10k *ar = hw->priv;
4141
4142 ath10k_drain_tx(ar);
4143
4144 mutex_lock(&ar->conf_mutex);
4145 if (ar->state != ATH10K_STATE_OFF) {
4146 ath10k_halt(ar);
4147 ar->state = ATH10K_STATE_OFF;
4148 }
4149 mutex_unlock(&ar->conf_mutex);
4150
4151 cancel_delayed_work_sync(&ar->scan.timeout);
4152 cancel_work_sync(&ar->restart_work);
4153 }
4154
4155 static int ath10k_config_ps(struct ath10k *ar)
4156 {
4157 struct ath10k_vif *arvif;
4158 int ret = 0;
4159
4160 lockdep_assert_held(&ar->conf_mutex);
4161
4162 list_for_each_entry(arvif, &ar->arvifs, list) {
4163 ret = ath10k_mac_vif_setup_ps(arvif);
4164 if (ret) {
4165 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
4166 break;
4167 }
4168 }
4169
4170 return ret;
4171 }
4172
4173 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
4174 {
4175 int ret;
4176 u32 param;
4177
4178 lockdep_assert_held(&ar->conf_mutex);
4179
4180 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
4181
4182 param = ar->wmi.pdev_param->txpower_limit2g;
4183 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4184 if (ret) {
4185 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
4186 txpower, ret);
4187 return ret;
4188 }
4189
4190 param = ar->wmi.pdev_param->txpower_limit5g;
4191 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4192 if (ret) {
4193 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
4194 txpower, ret);
4195 return ret;
4196 }
4197
4198 return 0;
4199 }
4200
4201 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4202 {
4203 struct ath10k_vif *arvif;
4204 int ret, txpower = -1;
4205
4206 lockdep_assert_held(&ar->conf_mutex);
4207
4208 list_for_each_entry(arvif, &ar->arvifs, list) {
4209 WARN_ON(arvif->txpower < 0);
4210
4211 if (txpower == -1)
4212 txpower = arvif->txpower;
4213 else
4214 txpower = min(txpower, arvif->txpower);
4215 }
4216
4217 if (WARN_ON(txpower == -1))
4218 return -EINVAL;
4219
4220 ret = ath10k_mac_txpower_setup(ar, txpower);
4221 if (ret) {
4222 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4223 txpower, ret);
4224 return ret;
4225 }
4226
4227 return 0;
4228 }
4229
4230 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4231 {
4232 struct ath10k *ar = hw->priv;
4233 struct ieee80211_conf *conf = &hw->conf;
4234 int ret = 0;
4235
4236 mutex_lock(&ar->conf_mutex);
4237
4238 if (changed & IEEE80211_CONF_CHANGE_PS)
4239 ath10k_config_ps(ar);
4240
4241 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4242 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4243 ret = ath10k_monitor_recalc(ar);
4244 if (ret)
4245 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4246 }
4247
4248 mutex_unlock(&ar->conf_mutex);
4249 return ret;
4250 }
4251
4252 static u32 get_nss_from_chainmask(u16 chain_mask)
4253 {
4254 if ((chain_mask & 0xf) == 0xf)
4255 return 4;
4256 else if ((chain_mask & 0x7) == 0x7)
4257 return 3;
4258 else if ((chain_mask & 0x3) == 0x3)
4259 return 2;
4260 return 1;
4261 }
4262
4263 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4264 {
4265 u32 value = 0;
4266 struct ath10k *ar = arvif->ar;
4267 int nsts;
4268 int sound_dim;
4269
4270 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4271 return 0;
4272
4273 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4274 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4275 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4276 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4277
4278 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4279 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4280 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4281 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4282
4283 if (!value)
4284 return 0;
4285
4286 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4287 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4288
4289 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4290 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4291 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4292
4293 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4294 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4295
4296 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4297 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4298 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4299
4300 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4301 ar->wmi.vdev_param->txbf, value);
4302 }
4303
4304 /*
4305 * TODO:
4306 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4307 * because we will send mgmt frames without CCK. This requirement
4308 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4309 * in the TX packet.
4310 */
4311 static int ath10k_add_interface(struct ieee80211_hw *hw,
4312 struct ieee80211_vif *vif)
4313 {
4314 struct ath10k *ar = hw->priv;
4315 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4316 enum wmi_sta_powersave_param param;
4317 int ret = 0;
4318 u32 value;
4319 int bit;
4320 int i;
4321 u32 vdev_param;
4322
4323 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4324
4325 mutex_lock(&ar->conf_mutex);
4326
4327 memset(arvif, 0, sizeof(*arvif));
4328
4329 arvif->ar = ar;
4330 arvif->vif = vif;
4331
4332 INIT_LIST_HEAD(&arvif->list);
4333 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4334 INIT_DELAYED_WORK(&arvif->connection_loss_work,
4335 ath10k_mac_vif_sta_connection_loss_work);
4336
4337 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4338 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4339 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4340 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4341 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4342 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4343 }
4344
4345 if (ar->num_peers >= ar->max_num_peers) {
4346 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4347 ret = -ENOBUFS;
4348 goto err;
4349 }
4350
4351 if (ar->free_vdev_map == 0) {
4352 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4353 ret = -EBUSY;
4354 goto err;
4355 }
4356 bit = __ffs64(ar->free_vdev_map);
4357
4358 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4359 bit, ar->free_vdev_map);
4360
4361 arvif->vdev_id = bit;
4362 arvif->vdev_subtype =
4363 ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE);
4364
4365 switch (vif->type) {
4366 case NL80211_IFTYPE_P2P_DEVICE:
4367 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4368 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4369 (ar, WMI_VDEV_SUBTYPE_P2P_DEVICE);
4370 break;
4371 case NL80211_IFTYPE_UNSPECIFIED:
4372 case NL80211_IFTYPE_STATION:
4373 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4374 if (vif->p2p)
4375 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4376 (ar, WMI_VDEV_SUBTYPE_P2P_CLIENT);
4377 break;
4378 case NL80211_IFTYPE_ADHOC:
4379 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4380 break;
4381 case NL80211_IFTYPE_MESH_POINT:
4382 if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) {
4383 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4384 (ar, WMI_VDEV_SUBTYPE_MESH_11S);
4385 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4386 ret = -EINVAL;
4387 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
4388 goto err;
4389 }
4390 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4391 break;
4392 case NL80211_IFTYPE_AP:
4393 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4394
4395 if (vif->p2p)
4396 arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
4397 (ar, WMI_VDEV_SUBTYPE_P2P_GO);
4398 break;
4399 case NL80211_IFTYPE_MONITOR:
4400 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4401 break;
4402 default:
4403 WARN_ON(1);
4404 break;
4405 }
4406
4407 /* Using vdev_id as queue number will make it very easy to do per-vif
4408 * tx queue locking. This shouldn't wrap due to interface combinations
4409 * but do a modulo for correctness sake and prevent using offchannel tx
4410 * queues for regular vif tx.
4411 */
4412 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4413 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4414 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4415
4416 /* Some firmware revisions don't wait for beacon tx completion before
4417 * sending another SWBA event. This could lead to hardware using old
4418 * (freed) beacon data in some cases, e.g. tx credit starvation
4419 * combined with missed TBTT. This is very very rare.
4420 *
4421 * On non-IOMMU-enabled hosts this could be a possible security issue
4422 * because hw could beacon some random data on the air. On
4423 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4424 * device would crash.
4425 *
4426 * Since there are no beacon tx completions (implicit nor explicit)
4427 * propagated to host the only workaround for this is to allocate a
4428 * DMA-coherent buffer for a lifetime of a vif and use it for all
4429 * beacon tx commands. Worst case for this approach is some beacons may
4430 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4431 */
4432 if (vif->type == NL80211_IFTYPE_ADHOC ||
4433 vif->type == NL80211_IFTYPE_MESH_POINT ||
4434 vif->type == NL80211_IFTYPE_AP) {
4435 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4436 IEEE80211_MAX_FRAME_LEN,
4437 &arvif->beacon_paddr,
4438 GFP_ATOMIC);
4439 if (!arvif->beacon_buf) {
4440 ret = -ENOMEM;
4441 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4442 ret);
4443 goto err;
4444 }
4445 }
4446 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4447 arvif->nohwcrypt = true;
4448
4449 if (arvif->nohwcrypt &&
4450 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4451 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4452 goto err;
4453 }
4454
4455 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4456 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4457 arvif->beacon_buf ? "single-buf" : "per-skb");
4458
4459 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4460 arvif->vdev_subtype, vif->addr);
4461 if (ret) {
4462 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4463 arvif->vdev_id, ret);
4464 goto err;
4465 }
4466
4467 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4468 list_add(&arvif->list, &ar->arvifs);
4469
4470 /* It makes no sense to have firmware do keepalives. mac80211 already
4471 * takes care of this with idle connection polling.
4472 */
4473 ret = ath10k_mac_vif_disable_keepalive(arvif);
4474 if (ret) {
4475 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4476 arvif->vdev_id, ret);
4477 goto err_vdev_delete;
4478 }
4479
4480 arvif->def_wep_key_idx = -1;
4481
4482 vdev_param = ar->wmi.vdev_param->tx_encap_type;
4483 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4484 ATH10K_HW_TXRX_NATIVE_WIFI);
4485 /* 10.X firmware does not support this VDEV parameter. Do not warn */
4486 if (ret && ret != -EOPNOTSUPP) {
4487 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4488 arvif->vdev_id, ret);
4489 goto err_vdev_delete;
4490 }
4491
4492 if (ar->cfg_tx_chainmask) {
4493 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4494
4495 vdev_param = ar->wmi.vdev_param->nss;
4496 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4497 nss);
4498 if (ret) {
4499 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4500 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4501 ret);
4502 goto err_vdev_delete;
4503 }
4504 }
4505
4506 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4507 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4508 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4509 WMI_PEER_TYPE_DEFAULT);
4510 if (ret) {
4511 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4512 arvif->vdev_id, ret);
4513 goto err_vdev_delete;
4514 }
4515 }
4516
4517 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4518 ret = ath10k_mac_set_kickout(arvif);
4519 if (ret) {
4520 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4521 arvif->vdev_id, ret);
4522 goto err_peer_delete;
4523 }
4524 }
4525
4526 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4527 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4528 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4529 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4530 param, value);
4531 if (ret) {
4532 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4533 arvif->vdev_id, ret);
4534 goto err_peer_delete;
4535 }
4536
4537 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4538 if (ret) {
4539 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4540 arvif->vdev_id, ret);
4541 goto err_peer_delete;
4542 }
4543
4544 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4545 if (ret) {
4546 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4547 arvif->vdev_id, ret);
4548 goto err_peer_delete;
4549 }
4550 }
4551
4552 ret = ath10k_mac_set_txbf_conf(arvif);
4553 if (ret) {
4554 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4555 arvif->vdev_id, ret);
4556 goto err_peer_delete;
4557 }
4558
4559 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4560 if (ret) {
4561 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4562 arvif->vdev_id, ret);
4563 goto err_peer_delete;
4564 }
4565
4566 arvif->txpower = vif->bss_conf.txpower;
4567 ret = ath10k_mac_txpower_recalc(ar);
4568 if (ret) {
4569 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4570 goto err_peer_delete;
4571 }
4572
4573 if (vif->type == NL80211_IFTYPE_MONITOR) {
4574 ar->monitor_arvif = arvif;
4575 ret = ath10k_monitor_recalc(ar);
4576 if (ret) {
4577 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4578 goto err_peer_delete;
4579 }
4580 }
4581
4582 spin_lock_bh(&ar->htt.tx_lock);
4583 if (!ar->tx_paused)
4584 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4585 spin_unlock_bh(&ar->htt.tx_lock);
4586
4587 mutex_unlock(&ar->conf_mutex);
4588 return 0;
4589
4590 err_peer_delete:
4591 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4592 arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4593 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4594
4595 err_vdev_delete:
4596 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4597 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4598 list_del(&arvif->list);
4599
4600 err:
4601 if (arvif->beacon_buf) {
4602 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4603 arvif->beacon_buf, arvif->beacon_paddr);
4604 arvif->beacon_buf = NULL;
4605 }
4606
4607 mutex_unlock(&ar->conf_mutex);
4608
4609 return ret;
4610 }
4611
4612 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4613 {
4614 int i;
4615
4616 for (i = 0; i < BITS_PER_LONG; i++)
4617 ath10k_mac_vif_tx_unlock(arvif, i);
4618 }
4619
4620 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4621 struct ieee80211_vif *vif)
4622 {
4623 struct ath10k *ar = hw->priv;
4624 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4625 int ret;
4626
4627 cancel_work_sync(&arvif->ap_csa_work);
4628 cancel_delayed_work_sync(&arvif->connection_loss_work);
4629
4630 mutex_lock(&ar->conf_mutex);
4631
4632 spin_lock_bh(&ar->data_lock);
4633 ath10k_mac_vif_beacon_cleanup(arvif);
4634 spin_unlock_bh(&ar->data_lock);
4635
4636 ret = ath10k_spectral_vif_stop(arvif);
4637 if (ret)
4638 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4639 arvif->vdev_id, ret);
4640
4641 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4642 list_del(&arvif->list);
4643
4644 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4645 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4646 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4647 vif->addr);
4648 if (ret)
4649 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4650 arvif->vdev_id, ret);
4651
4652 kfree(arvif->u.ap.noa_data);
4653 }
4654
4655 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4656 arvif->vdev_id);
4657
4658 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4659 if (ret)
4660 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4661 arvif->vdev_id, ret);
4662
4663 /* Some firmware revisions don't notify host about self-peer removal
4664 * until after associated vdev is deleted.
4665 */
4666 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4667 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4668 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4669 vif->addr);
4670 if (ret)
4671 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4672 arvif->vdev_id, ret);
4673
4674 spin_lock_bh(&ar->data_lock);
4675 ar->num_peers--;
4676 spin_unlock_bh(&ar->data_lock);
4677 }
4678
4679 ath10k_peer_cleanup(ar, arvif->vdev_id);
4680
4681 if (vif->type == NL80211_IFTYPE_MONITOR) {
4682 ar->monitor_arvif = NULL;
4683 ret = ath10k_monitor_recalc(ar);
4684 if (ret)
4685 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4686 }
4687
4688 spin_lock_bh(&ar->htt.tx_lock);
4689 ath10k_mac_vif_tx_unlock_all(arvif);
4690 spin_unlock_bh(&ar->htt.tx_lock);
4691
4692 mutex_unlock(&ar->conf_mutex);
4693 }
4694
4695 /*
4696 * FIXME: Has to be verified.
4697 */
4698 #define SUPPORTED_FILTERS \
4699 (FIF_ALLMULTI | \
4700 FIF_CONTROL | \
4701 FIF_PSPOLL | \
4702 FIF_OTHER_BSS | \
4703 FIF_BCN_PRBRESP_PROMISC | \
4704 FIF_PROBE_REQ | \
4705 FIF_FCSFAIL)
4706
4707 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4708 unsigned int changed_flags,
4709 unsigned int *total_flags,
4710 u64 multicast)
4711 {
4712 struct ath10k *ar = hw->priv;
4713 int ret;
4714
4715 mutex_lock(&ar->conf_mutex);
4716
4717 changed_flags &= SUPPORTED_FILTERS;
4718 *total_flags &= SUPPORTED_FILTERS;
4719 ar->filter_flags = *total_flags;
4720
4721 ret = ath10k_monitor_recalc(ar);
4722 if (ret)
4723 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4724
4725 mutex_unlock(&ar->conf_mutex);
4726 }
4727
4728 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4729 struct ieee80211_vif *vif,
4730 struct ieee80211_bss_conf *info,
4731 u32 changed)
4732 {
4733 struct ath10k *ar = hw->priv;
4734 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4735 int ret = 0;
4736 u32 vdev_param, pdev_param, slottime, preamble;
4737
4738 mutex_lock(&ar->conf_mutex);
4739
4740 if (changed & BSS_CHANGED_IBSS)
4741 ath10k_control_ibss(arvif, info, vif->addr);
4742
4743 if (changed & BSS_CHANGED_BEACON_INT) {
4744 arvif->beacon_interval = info->beacon_int;
4745 vdev_param = ar->wmi.vdev_param->beacon_interval;
4746 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4747 arvif->beacon_interval);
4748 ath10k_dbg(ar, ATH10K_DBG_MAC,
4749 "mac vdev %d beacon_interval %d\n",
4750 arvif->vdev_id, arvif->beacon_interval);
4751
4752 if (ret)
4753 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4754 arvif->vdev_id, ret);
4755 }
4756
4757 if (changed & BSS_CHANGED_BEACON) {
4758 ath10k_dbg(ar, ATH10K_DBG_MAC,
4759 "vdev %d set beacon tx mode to staggered\n",
4760 arvif->vdev_id);
4761
4762 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4763 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4764 WMI_BEACON_STAGGERED_MODE);
4765 if (ret)
4766 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4767 arvif->vdev_id, ret);
4768
4769 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4770 if (ret)
4771 ath10k_warn(ar, "failed to update beacon template: %d\n",
4772 ret);
4773
4774 if (ieee80211_vif_is_mesh(vif)) {
4775 /* mesh doesn't use SSID but firmware needs it */
4776 strncpy(arvif->u.ap.ssid, "mesh",
4777 sizeof(arvif->u.ap.ssid));
4778 arvif->u.ap.ssid_len = 4;
4779 }
4780 }
4781
4782 if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4783 ret = ath10k_mac_setup_prb_tmpl(arvif);
4784 if (ret)
4785 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4786 arvif->vdev_id, ret);
4787 }
4788
4789 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4790 arvif->dtim_period = info->dtim_period;
4791
4792 ath10k_dbg(ar, ATH10K_DBG_MAC,
4793 "mac vdev %d dtim_period %d\n",
4794 arvif->vdev_id, arvif->dtim_period);
4795
4796 vdev_param = ar->wmi.vdev_param->dtim_period;
4797 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4798 arvif->dtim_period);
4799 if (ret)
4800 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4801 arvif->vdev_id, ret);
4802 }
4803
4804 if (changed & BSS_CHANGED_SSID &&
4805 vif->type == NL80211_IFTYPE_AP) {
4806 arvif->u.ap.ssid_len = info->ssid_len;
4807 if (info->ssid_len)
4808 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4809 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4810 }
4811
4812 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4813 ether_addr_copy(arvif->bssid, info->bssid);
4814
4815 if (changed & BSS_CHANGED_BEACON_ENABLED)
4816 ath10k_control_beaconing(arvif, info);
4817
4818 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4819 arvif->use_cts_prot = info->use_cts_prot;
4820 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4821 arvif->vdev_id, info->use_cts_prot);
4822
4823 ret = ath10k_recalc_rtscts_prot(arvif);
4824 if (ret)
4825 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4826 arvif->vdev_id, ret);
4827
4828 vdev_param = ar->wmi.vdev_param->protection_mode;
4829 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4830 info->use_cts_prot ? 1 : 0);
4831 if (ret)
4832 ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4833 info->use_cts_prot, arvif->vdev_id, ret);
4834 }
4835
4836 if (changed & BSS_CHANGED_ERP_SLOT) {
4837 if (info->use_short_slot)
4838 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4839
4840 else
4841 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4842
4843 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4844 arvif->vdev_id, slottime);
4845
4846 vdev_param = ar->wmi.vdev_param->slot_time;
4847 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4848 slottime);
4849 if (ret)
4850 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4851 arvif->vdev_id, ret);
4852 }
4853
4854 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4855 if (info->use_short_preamble)
4856 preamble = WMI_VDEV_PREAMBLE_SHORT;
4857 else
4858 preamble = WMI_VDEV_PREAMBLE_LONG;
4859
4860 ath10k_dbg(ar, ATH10K_DBG_MAC,
4861 "mac vdev %d preamble %dn",
4862 arvif->vdev_id, preamble);
4863
4864 vdev_param = ar->wmi.vdev_param->preamble;
4865 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4866 preamble);
4867 if (ret)
4868 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4869 arvif->vdev_id, ret);
4870 }
4871
4872 if (changed & BSS_CHANGED_ASSOC) {
4873 if (info->assoc) {
4874 /* Workaround: Make sure monitor vdev is not running
4875 * when associating to prevent some firmware revisions
4876 * (e.g. 10.1 and 10.2) from crashing.
4877 */
4878 if (ar->monitor_started)
4879 ath10k_monitor_stop(ar);
4880 ath10k_bss_assoc(hw, vif, info);
4881 ath10k_monitor_recalc(ar);
4882 } else {
4883 ath10k_bss_disassoc(hw, vif);
4884 }
4885 }
4886
4887 if (changed & BSS_CHANGED_TXPOWER) {
4888 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4889 arvif->vdev_id, info->txpower);
4890
4891 arvif->txpower = info->txpower;
4892 ret = ath10k_mac_txpower_recalc(ar);
4893 if (ret)
4894 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4895 }
4896
4897 if (changed & BSS_CHANGED_PS) {
4898 arvif->ps = vif->bss_conf.ps;
4899
4900 ret = ath10k_config_ps(ar);
4901 if (ret)
4902 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4903 arvif->vdev_id, ret);
4904 }
4905
4906 mutex_unlock(&ar->conf_mutex);
4907 }
4908
4909 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4910 struct ieee80211_vif *vif,
4911 struct ieee80211_scan_request *hw_req)
4912 {
4913 struct ath10k *ar = hw->priv;
4914 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4915 struct cfg80211_scan_request *req = &hw_req->req;
4916 struct wmi_start_scan_arg arg;
4917 int ret = 0;
4918 int i;
4919
4920 mutex_lock(&ar->conf_mutex);
4921
4922 spin_lock_bh(&ar->data_lock);
4923 switch (ar->scan.state) {
4924 case ATH10K_SCAN_IDLE:
4925 reinit_completion(&ar->scan.started);
4926 reinit_completion(&ar->scan.completed);
4927 ar->scan.state = ATH10K_SCAN_STARTING;
4928 ar->scan.is_roc = false;
4929 ar->scan.vdev_id = arvif->vdev_id;
4930 ret = 0;
4931 break;
4932 case ATH10K_SCAN_STARTING:
4933 case ATH10K_SCAN_RUNNING:
4934 case ATH10K_SCAN_ABORTING:
4935 ret = -EBUSY;
4936 break;
4937 }
4938 spin_unlock_bh(&ar->data_lock);
4939
4940 if (ret)
4941 goto exit;
4942
4943 memset(&arg, 0, sizeof(arg));
4944 ath10k_wmi_start_scan_init(ar, &arg);
4945 arg.vdev_id = arvif->vdev_id;
4946 arg.scan_id = ATH10K_SCAN_ID;
4947
4948 if (req->ie_len) {
4949 arg.ie_len = req->ie_len;
4950 memcpy(arg.ie, req->ie, arg.ie_len);
4951 }
4952
4953 if (req->n_ssids) {
4954 arg.n_ssids = req->n_ssids;
4955 for (i = 0; i < arg.n_ssids; i++) {
4956 arg.ssids[i].len = req->ssids[i].ssid_len;
4957 arg.ssids[i].ssid = req->ssids[i].ssid;
4958 }
4959 } else {
4960 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4961 }
4962
4963 if (req->n_channels) {
4964 arg.n_channels = req->n_channels;
4965 for (i = 0; i < arg.n_channels; i++)
4966 arg.channels[i] = req->channels[i]->center_freq;
4967 }
4968
4969 ret = ath10k_start_scan(ar, &arg);
4970 if (ret) {
4971 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4972 spin_lock_bh(&ar->data_lock);
4973 ar->scan.state = ATH10K_SCAN_IDLE;
4974 spin_unlock_bh(&ar->data_lock);
4975 }
4976
4977 /* Add a 200ms margin to account for event/command processing */
4978 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4979 msecs_to_jiffies(arg.max_scan_time +
4980 200));
4981
4982 exit:
4983 mutex_unlock(&ar->conf_mutex);
4984 return ret;
4985 }
4986
4987 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4988 struct ieee80211_vif *vif)
4989 {
4990 struct ath10k *ar = hw->priv;
4991
4992 mutex_lock(&ar->conf_mutex);
4993 ath10k_scan_abort(ar);
4994 mutex_unlock(&ar->conf_mutex);
4995
4996 cancel_delayed_work_sync(&ar->scan.timeout);
4997 }
4998
4999 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
5000 struct ath10k_vif *arvif,
5001 enum set_key_cmd cmd,
5002 struct ieee80211_key_conf *key)
5003 {
5004 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
5005 int ret;
5006
5007 /* 10.1 firmware branch requires default key index to be set to group
5008 * key index after installing it. Otherwise FW/HW Txes corrupted
5009 * frames with multi-vif APs. This is not required for main firmware
5010 * branch (e.g. 636).
5011 *
5012 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
5013 *
5014 * FIXME: It remains unknown if this is required for multi-vif STA
5015 * interfaces on 10.1.
5016 */
5017
5018 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
5019 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
5020 return;
5021
5022 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
5023 return;
5024
5025 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
5026 return;
5027
5028 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5029 return;
5030
5031 if (cmd != SET_KEY)
5032 return;
5033
5034 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5035 key->keyidx);
5036 if (ret)
5037 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
5038 arvif->vdev_id, ret);
5039 }
5040
5041 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5042 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
5043 struct ieee80211_key_conf *key)
5044 {
5045 struct ath10k *ar = hw->priv;
5046 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5047 struct ath10k_peer *peer;
5048 const u8 *peer_addr;
5049 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5050 key->cipher == WLAN_CIPHER_SUITE_WEP104;
5051 int ret = 0;
5052 int ret2;
5053 u32 flags = 0;
5054 u32 flags2;
5055
5056 /* this one needs to be done in software */
5057 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
5058 return 1;
5059
5060 if (arvif->nohwcrypt)
5061 return 1;
5062
5063 if (key->keyidx > WMI_MAX_KEY_INDEX)
5064 return -ENOSPC;
5065
5066 mutex_lock(&ar->conf_mutex);
5067
5068 if (sta)
5069 peer_addr = sta->addr;
5070 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
5071 peer_addr = vif->bss_conf.bssid;
5072 else
5073 peer_addr = vif->addr;
5074
5075 key->hw_key_idx = key->keyidx;
5076
5077 if (is_wep) {
5078 if (cmd == SET_KEY)
5079 arvif->wep_keys[key->keyidx] = key;
5080 else
5081 arvif->wep_keys[key->keyidx] = NULL;
5082 }
5083
5084 /* the peer should not disappear in mid-way (unless FW goes awry) since
5085 * we already hold conf_mutex. we just make sure its there now. */
5086 spin_lock_bh(&ar->data_lock);
5087 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5088 spin_unlock_bh(&ar->data_lock);
5089
5090 if (!peer) {
5091 if (cmd == SET_KEY) {
5092 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5093 peer_addr);
5094 ret = -EOPNOTSUPP;
5095 goto exit;
5096 } else {
5097 /* if the peer doesn't exist there is no key to disable
5098 * anymore */
5099 goto exit;
5100 }
5101 }
5102
5103 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5104 flags |= WMI_KEY_PAIRWISE;
5105 else
5106 flags |= WMI_KEY_GROUP;
5107
5108 if (is_wep) {
5109 if (cmd == DISABLE_KEY)
5110 ath10k_clear_vdev_key(arvif, key);
5111
5112 /* When WEP keys are uploaded it's possible that there are
5113 * stations associated already (e.g. when merging) without any
5114 * keys. Static WEP needs an explicit per-peer key upload.
5115 */
5116 if (vif->type == NL80211_IFTYPE_ADHOC &&
5117 cmd == SET_KEY)
5118 ath10k_mac_vif_update_wep_key(arvif, key);
5119
5120 /* 802.1x never sets the def_wep_key_idx so each set_key()
5121 * call changes default tx key.
5122 *
5123 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5124 * after first set_key().
5125 */
5126 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
5127 flags |= WMI_KEY_TX_USAGE;
5128 }
5129
5130 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
5131 if (ret) {
5132 WARN_ON(ret > 0);
5133 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
5134 arvif->vdev_id, peer_addr, ret);
5135 goto exit;
5136 }
5137
5138 /* mac80211 sets static WEP keys as groupwise while firmware requires
5139 * them to be installed twice as both pairwise and groupwise.
5140 */
5141 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
5142 flags2 = flags;
5143 flags2 &= ~WMI_KEY_GROUP;
5144 flags2 |= WMI_KEY_PAIRWISE;
5145
5146 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
5147 if (ret) {
5148 WARN_ON(ret > 0);
5149 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5150 arvif->vdev_id, peer_addr, ret);
5151 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
5152 peer_addr, flags);
5153 if (ret2) {
5154 WARN_ON(ret2 > 0);
5155 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5156 arvif->vdev_id, peer_addr, ret2);
5157 }
5158 goto exit;
5159 }
5160 }
5161
5162 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5163
5164 spin_lock_bh(&ar->data_lock);
5165 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5166 if (peer && cmd == SET_KEY)
5167 peer->keys[key->keyidx] = key;
5168 else if (peer && cmd == DISABLE_KEY)
5169 peer->keys[key->keyidx] = NULL;
5170 else if (peer == NULL)
5171 /* impossible unless FW goes crazy */
5172 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5173 spin_unlock_bh(&ar->data_lock);
5174
5175 exit:
5176 mutex_unlock(&ar->conf_mutex);
5177 return ret;
5178 }
5179
5180 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5181 struct ieee80211_vif *vif,
5182 int keyidx)
5183 {
5184 struct ath10k *ar = hw->priv;
5185 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5186 int ret;
5187
5188 mutex_lock(&arvif->ar->conf_mutex);
5189
5190 if (arvif->ar->state != ATH10K_STATE_ON)
5191 goto unlock;
5192
5193 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5194 arvif->vdev_id, keyidx);
5195
5196 ret = ath10k_wmi_vdev_set_param(arvif->ar,
5197 arvif->vdev_id,
5198 arvif->ar->wmi.vdev_param->def_keyid,
5199 keyidx);
5200
5201 if (ret) {
5202 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5203 arvif->vdev_id,
5204 ret);
5205 goto unlock;
5206 }
5207
5208 arvif->def_wep_key_idx = keyidx;
5209
5210 unlock:
5211 mutex_unlock(&arvif->ar->conf_mutex);
5212 }
5213
5214 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5215 {
5216 struct ath10k *ar;
5217 struct ath10k_vif *arvif;
5218 struct ath10k_sta *arsta;
5219 struct ieee80211_sta *sta;
5220 struct cfg80211_chan_def def;
5221 enum ieee80211_band band;
5222 const u8 *ht_mcs_mask;
5223 const u16 *vht_mcs_mask;
5224 u32 changed, bw, nss, smps;
5225 int err;
5226
5227 arsta = container_of(wk, struct ath10k_sta, update_wk);
5228 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5229 arvif = arsta->arvif;
5230 ar = arvif->ar;
5231
5232 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5233 return;
5234
5235 band = def.chan->band;
5236 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5237 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5238
5239 spin_lock_bh(&ar->data_lock);
5240
5241 changed = arsta->changed;
5242 arsta->changed = 0;
5243
5244 bw = arsta->bw;
5245 nss = arsta->nss;
5246 smps = arsta->smps;
5247
5248 spin_unlock_bh(&ar->data_lock);
5249
5250 mutex_lock(&ar->conf_mutex);
5251
5252 nss = max_t(u32, 1, nss);
5253 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5254 ath10k_mac_max_vht_nss(vht_mcs_mask)));
5255
5256 if (changed & IEEE80211_RC_BW_CHANGED) {
5257 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5258 sta->addr, bw);
5259
5260 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5261 WMI_PEER_CHAN_WIDTH, bw);
5262 if (err)
5263 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5264 sta->addr, bw, err);
5265 }
5266
5267 if (changed & IEEE80211_RC_NSS_CHANGED) {
5268 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5269 sta->addr, nss);
5270
5271 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5272 WMI_PEER_NSS, nss);
5273 if (err)
5274 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5275 sta->addr, nss, err);
5276 }
5277
5278 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5279 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5280 sta->addr, smps);
5281
5282 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5283 WMI_PEER_SMPS_STATE, smps);
5284 if (err)
5285 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5286 sta->addr, smps, err);
5287 }
5288
5289 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5290 changed & IEEE80211_RC_NSS_CHANGED) {
5291 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5292 sta->addr);
5293
5294 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5295 if (err)
5296 ath10k_warn(ar, "failed to reassociate station: %pM\n",
5297 sta->addr);
5298 }
5299
5300 mutex_unlock(&ar->conf_mutex);
5301 }
5302
5303 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5304 struct ieee80211_sta *sta)
5305 {
5306 struct ath10k *ar = arvif->ar;
5307
5308 lockdep_assert_held(&ar->conf_mutex);
5309
5310 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5311 return 0;
5312
5313 if (ar->num_stations >= ar->max_num_stations)
5314 return -ENOBUFS;
5315
5316 ar->num_stations++;
5317
5318 return 0;
5319 }
5320
5321 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5322 struct ieee80211_sta *sta)
5323 {
5324 struct ath10k *ar = arvif->ar;
5325
5326 lockdep_assert_held(&ar->conf_mutex);
5327
5328 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5329 return;
5330
5331 ar->num_stations--;
5332 }
5333
5334 struct ath10k_mac_tdls_iter_data {
5335 u32 num_tdls_stations;
5336 struct ieee80211_vif *curr_vif;
5337 };
5338
5339 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5340 struct ieee80211_sta *sta)
5341 {
5342 struct ath10k_mac_tdls_iter_data *iter_data = data;
5343 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5344 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5345
5346 if (sta->tdls && sta_vif == iter_data->curr_vif)
5347 iter_data->num_tdls_stations++;
5348 }
5349
5350 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5351 struct ieee80211_vif *vif)
5352 {
5353 struct ath10k_mac_tdls_iter_data data = {};
5354
5355 data.curr_vif = vif;
5356
5357 ieee80211_iterate_stations_atomic(hw,
5358 ath10k_mac_tdls_vif_stations_count_iter,
5359 &data);
5360 return data.num_tdls_stations;
5361 }
5362
5363 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5364 struct ieee80211_vif *vif)
5365 {
5366 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5367 int *num_tdls_vifs = data;
5368
5369 if (vif->type != NL80211_IFTYPE_STATION)
5370 return;
5371
5372 if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5373 (*num_tdls_vifs)++;
5374 }
5375
5376 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5377 {
5378 int num_tdls_vifs = 0;
5379
5380 ieee80211_iterate_active_interfaces_atomic(hw,
5381 IEEE80211_IFACE_ITER_NORMAL,
5382 ath10k_mac_tdls_vifs_count_iter,
5383 &num_tdls_vifs);
5384 return num_tdls_vifs;
5385 }
5386
5387 static int ath10k_sta_state(struct ieee80211_hw *hw,
5388 struct ieee80211_vif *vif,
5389 struct ieee80211_sta *sta,
5390 enum ieee80211_sta_state old_state,
5391 enum ieee80211_sta_state new_state)
5392 {
5393 struct ath10k *ar = hw->priv;
5394 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5395 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5396 int ret = 0;
5397
5398 if (old_state == IEEE80211_STA_NOTEXIST &&
5399 new_state == IEEE80211_STA_NONE) {
5400 memset(arsta, 0, sizeof(*arsta));
5401 arsta->arvif = arvif;
5402 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5403 }
5404
5405 /* cancel must be done outside the mutex to avoid deadlock */
5406 if ((old_state == IEEE80211_STA_NONE &&
5407 new_state == IEEE80211_STA_NOTEXIST))
5408 cancel_work_sync(&arsta->update_wk);
5409
5410 mutex_lock(&ar->conf_mutex);
5411
5412 if (old_state == IEEE80211_STA_NOTEXIST &&
5413 new_state == IEEE80211_STA_NONE) {
5414 /*
5415 * New station addition.
5416 */
5417 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5418 u32 num_tdls_stations;
5419 u32 num_tdls_vifs;
5420
5421 ath10k_dbg(ar, ATH10K_DBG_MAC,
5422 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5423 arvif->vdev_id, sta->addr,
5424 ar->num_stations + 1, ar->max_num_stations,
5425 ar->num_peers + 1, ar->max_num_peers);
5426
5427 ret = ath10k_mac_inc_num_stations(arvif, sta);
5428 if (ret) {
5429 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5430 ar->max_num_stations);
5431 goto exit;
5432 }
5433
5434 if (sta->tdls)
5435 peer_type = WMI_PEER_TYPE_TDLS;
5436
5437 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5438 peer_type);
5439 if (ret) {
5440 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5441 sta->addr, arvif->vdev_id, ret);
5442 ath10k_mac_dec_num_stations(arvif, sta);
5443 goto exit;
5444 }
5445
5446 if (!sta->tdls)
5447 goto exit;
5448
5449 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5450 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5451
5452 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5453 num_tdls_stations == 0) {
5454 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5455 arvif->vdev_id, ar->max_num_tdls_vdevs);
5456 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5457 ath10k_mac_dec_num_stations(arvif, sta);
5458 ret = -ENOBUFS;
5459 goto exit;
5460 }
5461
5462 if (num_tdls_stations == 0) {
5463 /* This is the first tdls peer in current vif */
5464 enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5465
5466 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5467 state);
5468 if (ret) {
5469 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5470 arvif->vdev_id, ret);
5471 ath10k_peer_delete(ar, arvif->vdev_id,
5472 sta->addr);
5473 ath10k_mac_dec_num_stations(arvif, sta);
5474 goto exit;
5475 }
5476 }
5477
5478 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5479 WMI_TDLS_PEER_STATE_PEERING);
5480 if (ret) {
5481 ath10k_warn(ar,
5482 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5483 sta->addr, arvif->vdev_id, ret);
5484 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5485 ath10k_mac_dec_num_stations(arvif, sta);
5486
5487 if (num_tdls_stations != 0)
5488 goto exit;
5489 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5490 WMI_TDLS_DISABLE);
5491 }
5492 } else if ((old_state == IEEE80211_STA_NONE &&
5493 new_state == IEEE80211_STA_NOTEXIST)) {
5494 /*
5495 * Existing station deletion.
5496 */
5497 ath10k_dbg(ar, ATH10K_DBG_MAC,
5498 "mac vdev %d peer delete %pM (sta gone)\n",
5499 arvif->vdev_id, sta->addr);
5500
5501 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5502 if (ret)
5503 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5504 sta->addr, arvif->vdev_id, ret);
5505
5506 ath10k_mac_dec_num_stations(arvif, sta);
5507
5508 if (!sta->tdls)
5509 goto exit;
5510
5511 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5512 goto exit;
5513
5514 /* This was the last tdls peer in current vif */
5515 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5516 WMI_TDLS_DISABLE);
5517 if (ret) {
5518 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5519 arvif->vdev_id, ret);
5520 }
5521 } else if (old_state == IEEE80211_STA_AUTH &&
5522 new_state == IEEE80211_STA_ASSOC &&
5523 (vif->type == NL80211_IFTYPE_AP ||
5524 vif->type == NL80211_IFTYPE_MESH_POINT ||
5525 vif->type == NL80211_IFTYPE_ADHOC)) {
5526 /*
5527 * New association.
5528 */
5529 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5530 sta->addr);
5531
5532 ret = ath10k_station_assoc(ar, vif, sta, false);
5533 if (ret)
5534 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5535 sta->addr, arvif->vdev_id, ret);
5536 } else if (old_state == IEEE80211_STA_ASSOC &&
5537 new_state == IEEE80211_STA_AUTHORIZED &&
5538 sta->tdls) {
5539 /*
5540 * Tdls station authorized.
5541 */
5542 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5543 sta->addr);
5544
5545 ret = ath10k_station_assoc(ar, vif, sta, false);
5546 if (ret) {
5547 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5548 sta->addr, arvif->vdev_id, ret);
5549 goto exit;
5550 }
5551
5552 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5553 WMI_TDLS_PEER_STATE_CONNECTED);
5554 if (ret)
5555 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5556 sta->addr, arvif->vdev_id, ret);
5557 } else if (old_state == IEEE80211_STA_ASSOC &&
5558 new_state == IEEE80211_STA_AUTH &&
5559 (vif->type == NL80211_IFTYPE_AP ||
5560 vif->type == NL80211_IFTYPE_MESH_POINT ||
5561 vif->type == NL80211_IFTYPE_ADHOC)) {
5562 /*
5563 * Disassociation.
5564 */
5565 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5566 sta->addr);
5567
5568 ret = ath10k_station_disassoc(ar, vif, sta);
5569 if (ret)
5570 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5571 sta->addr, arvif->vdev_id, ret);
5572 }
5573 exit:
5574 mutex_unlock(&ar->conf_mutex);
5575 return ret;
5576 }
5577
5578 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5579 u16 ac, bool enable)
5580 {
5581 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5582 struct wmi_sta_uapsd_auto_trig_arg arg = {};
5583 u32 prio = 0, acc = 0;
5584 u32 value = 0;
5585 int ret = 0;
5586
5587 lockdep_assert_held(&ar->conf_mutex);
5588
5589 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5590 return 0;
5591
5592 switch (ac) {
5593 case IEEE80211_AC_VO:
5594 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5595 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5596 prio = 7;
5597 acc = 3;
5598 break;
5599 case IEEE80211_AC_VI:
5600 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5601 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5602 prio = 5;
5603 acc = 2;
5604 break;
5605 case IEEE80211_AC_BE:
5606 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5607 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5608 prio = 2;
5609 acc = 1;
5610 break;
5611 case IEEE80211_AC_BK:
5612 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5613 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5614 prio = 0;
5615 acc = 0;
5616 break;
5617 }
5618
5619 if (enable)
5620 arvif->u.sta.uapsd |= value;
5621 else
5622 arvif->u.sta.uapsd &= ~value;
5623
5624 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5625 WMI_STA_PS_PARAM_UAPSD,
5626 arvif->u.sta.uapsd);
5627 if (ret) {
5628 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5629 goto exit;
5630 }
5631
5632 if (arvif->u.sta.uapsd)
5633 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5634 else
5635 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5636
5637 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5638 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5639 value);
5640 if (ret)
5641 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5642
5643 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5644 if (ret) {
5645 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5646 arvif->vdev_id, ret);
5647 return ret;
5648 }
5649
5650 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5651 if (ret) {
5652 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5653 arvif->vdev_id, ret);
5654 return ret;
5655 }
5656
5657 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5658 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5659 /* Only userspace can make an educated decision when to send
5660 * trigger frame. The following effectively disables u-UAPSD
5661 * autotrigger in firmware (which is enabled by default
5662 * provided the autotrigger service is available).
5663 */
5664
5665 arg.wmm_ac = acc;
5666 arg.user_priority = prio;
5667 arg.service_interval = 0;
5668 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5669 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5670
5671 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5672 arvif->bssid, &arg, 1);
5673 if (ret) {
5674 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5675 ret);
5676 return ret;
5677 }
5678 }
5679
5680 exit:
5681 return ret;
5682 }
5683
5684 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5685 struct ieee80211_vif *vif, u16 ac,
5686 const struct ieee80211_tx_queue_params *params)
5687 {
5688 struct ath10k *ar = hw->priv;
5689 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5690 struct wmi_wmm_params_arg *p = NULL;
5691 int ret;
5692
5693 mutex_lock(&ar->conf_mutex);
5694
5695 switch (ac) {
5696 case IEEE80211_AC_VO:
5697 p = &arvif->wmm_params.ac_vo;
5698 break;
5699 case IEEE80211_AC_VI:
5700 p = &arvif->wmm_params.ac_vi;
5701 break;
5702 case IEEE80211_AC_BE:
5703 p = &arvif->wmm_params.ac_be;
5704 break;
5705 case IEEE80211_AC_BK:
5706 p = &arvif->wmm_params.ac_bk;
5707 break;
5708 }
5709
5710 if (WARN_ON(!p)) {
5711 ret = -EINVAL;
5712 goto exit;
5713 }
5714
5715 p->cwmin = params->cw_min;
5716 p->cwmax = params->cw_max;
5717 p->aifs = params->aifs;
5718
5719 /*
5720 * The channel time duration programmed in the HW is in absolute
5721 * microseconds, while mac80211 gives the txop in units of
5722 * 32 microseconds.
5723 */
5724 p->txop = params->txop * 32;
5725
5726 if (ar->wmi.ops->gen_vdev_wmm_conf) {
5727 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5728 &arvif->wmm_params);
5729 if (ret) {
5730 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5731 arvif->vdev_id, ret);
5732 goto exit;
5733 }
5734 } else {
5735 /* This won't work well with multi-interface cases but it's
5736 * better than nothing.
5737 */
5738 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5739 if (ret) {
5740 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5741 goto exit;
5742 }
5743 }
5744
5745 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5746 if (ret)
5747 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5748
5749 exit:
5750 mutex_unlock(&ar->conf_mutex);
5751 return ret;
5752 }
5753
5754 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5755
5756 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5757 struct ieee80211_vif *vif,
5758 struct ieee80211_channel *chan,
5759 int duration,
5760 enum ieee80211_roc_type type)
5761 {
5762 struct ath10k *ar = hw->priv;
5763 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5764 struct wmi_start_scan_arg arg;
5765 int ret = 0;
5766 u32 scan_time_msec;
5767
5768 mutex_lock(&ar->conf_mutex);
5769
5770 spin_lock_bh(&ar->data_lock);
5771 switch (ar->scan.state) {
5772 case ATH10K_SCAN_IDLE:
5773 reinit_completion(&ar->scan.started);
5774 reinit_completion(&ar->scan.completed);
5775 reinit_completion(&ar->scan.on_channel);
5776 ar->scan.state = ATH10K_SCAN_STARTING;
5777 ar->scan.is_roc = true;
5778 ar->scan.vdev_id = arvif->vdev_id;
5779 ar->scan.roc_freq = chan->center_freq;
5780 ar->scan.roc_notify = true;
5781 ret = 0;
5782 break;
5783 case ATH10K_SCAN_STARTING:
5784 case ATH10K_SCAN_RUNNING:
5785 case ATH10K_SCAN_ABORTING:
5786 ret = -EBUSY;
5787 break;
5788 }
5789 spin_unlock_bh(&ar->data_lock);
5790
5791 if (ret)
5792 goto exit;
5793
5794 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5795
5796 memset(&arg, 0, sizeof(arg));
5797 ath10k_wmi_start_scan_init(ar, &arg);
5798 arg.vdev_id = arvif->vdev_id;
5799 arg.scan_id = ATH10K_SCAN_ID;
5800 arg.n_channels = 1;
5801 arg.channels[0] = chan->center_freq;
5802 arg.dwell_time_active = scan_time_msec;
5803 arg.dwell_time_passive = scan_time_msec;
5804 arg.max_scan_time = scan_time_msec;
5805 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5806 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5807 arg.burst_duration_ms = duration;
5808
5809 ret = ath10k_start_scan(ar, &arg);
5810 if (ret) {
5811 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5812 spin_lock_bh(&ar->data_lock);
5813 ar->scan.state = ATH10K_SCAN_IDLE;
5814 spin_unlock_bh(&ar->data_lock);
5815 goto exit;
5816 }
5817
5818 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5819 if (ret == 0) {
5820 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5821
5822 ret = ath10k_scan_stop(ar);
5823 if (ret)
5824 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5825
5826 ret = -ETIMEDOUT;
5827 goto exit;
5828 }
5829
5830 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5831 msecs_to_jiffies(duration));
5832
5833 ret = 0;
5834 exit:
5835 mutex_unlock(&ar->conf_mutex);
5836 return ret;
5837 }
5838
5839 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5840 {
5841 struct ath10k *ar = hw->priv;
5842
5843 mutex_lock(&ar->conf_mutex);
5844
5845 spin_lock_bh(&ar->data_lock);
5846 ar->scan.roc_notify = false;
5847 spin_unlock_bh(&ar->data_lock);
5848
5849 ath10k_scan_abort(ar);
5850
5851 mutex_unlock(&ar->conf_mutex);
5852
5853 cancel_delayed_work_sync(&ar->scan.timeout);
5854
5855 return 0;
5856 }
5857
5858 /*
5859 * Both RTS and Fragmentation threshold are interface-specific
5860 * in ath10k, but device-specific in mac80211.
5861 */
5862
5863 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5864 {
5865 struct ath10k *ar = hw->priv;
5866 struct ath10k_vif *arvif;
5867 int ret = 0;
5868
5869 mutex_lock(&ar->conf_mutex);
5870 list_for_each_entry(arvif, &ar->arvifs, list) {
5871 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5872 arvif->vdev_id, value);
5873
5874 ret = ath10k_mac_set_rts(arvif, value);
5875 if (ret) {
5876 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5877 arvif->vdev_id, ret);
5878 break;
5879 }
5880 }
5881 mutex_unlock(&ar->conf_mutex);
5882
5883 return ret;
5884 }
5885
5886 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5887 {
5888 /* Even though there's a WMI enum for fragmentation threshold no known
5889 * firmware actually implements it. Moreover it is not possible to rely
5890 * frame fragmentation to mac80211 because firmware clears the "more
5891 * fragments" bit in frame control making it impossible for remote
5892 * devices to reassemble frames.
5893 *
5894 * Hence implement a dummy callback just to say fragmentation isn't
5895 * supported. This effectively prevents mac80211 from doing frame
5896 * fragmentation in software.
5897 */
5898 return -EOPNOTSUPP;
5899 }
5900
5901 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5902 u32 queues, bool drop)
5903 {
5904 struct ath10k *ar = hw->priv;
5905 bool skip;
5906 long time_left;
5907
5908 /* mac80211 doesn't care if we really xmit queued frames or not
5909 * we'll collect those frames either way if we stop/delete vdevs */
5910 if (drop)
5911 return;
5912
5913 mutex_lock(&ar->conf_mutex);
5914
5915 if (ar->state == ATH10K_STATE_WEDGED)
5916 goto skip;
5917
5918 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5919 bool empty;
5920
5921 spin_lock_bh(&ar->htt.tx_lock);
5922 empty = (ar->htt.num_pending_tx == 0);
5923 spin_unlock_bh(&ar->htt.tx_lock);
5924
5925 skip = (ar->state == ATH10K_STATE_WEDGED) ||
5926 test_bit(ATH10K_FLAG_CRASH_FLUSH,
5927 &ar->dev_flags);
5928
5929 (empty || skip);
5930 }), ATH10K_FLUSH_TIMEOUT_HZ);
5931
5932 if (time_left == 0 || skip)
5933 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5934 skip, ar->state, time_left);
5935
5936 skip:
5937 mutex_unlock(&ar->conf_mutex);
5938 }
5939
5940 /* TODO: Implement this function properly
5941 * For now it is needed to reply to Probe Requests in IBSS mode.
5942 * Propably we need this information from FW.
5943 */
5944 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5945 {
5946 return 1;
5947 }
5948
5949 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5950 enum ieee80211_reconfig_type reconfig_type)
5951 {
5952 struct ath10k *ar = hw->priv;
5953
5954 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5955 return;
5956
5957 mutex_lock(&ar->conf_mutex);
5958
5959 /* If device failed to restart it will be in a different state, e.g.
5960 * ATH10K_STATE_WEDGED */
5961 if (ar->state == ATH10K_STATE_RESTARTED) {
5962 ath10k_info(ar, "device successfully recovered\n");
5963 ar->state = ATH10K_STATE_ON;
5964 ieee80211_wake_queues(ar->hw);
5965 }
5966
5967 mutex_unlock(&ar->conf_mutex);
5968 }
5969
5970 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5971 struct survey_info *survey)
5972 {
5973 struct ath10k *ar = hw->priv;
5974 struct ieee80211_supported_band *sband;
5975 struct survey_info *ar_survey = &ar->survey[idx];
5976 int ret = 0;
5977
5978 mutex_lock(&ar->conf_mutex);
5979
5980 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5981 if (sband && idx >= sband->n_channels) {
5982 idx -= sband->n_channels;
5983 sband = NULL;
5984 }
5985
5986 if (!sband)
5987 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5988
5989 if (!sband || idx >= sband->n_channels) {
5990 ret = -ENOENT;
5991 goto exit;
5992 }
5993
5994 spin_lock_bh(&ar->data_lock);
5995 memcpy(survey, ar_survey, sizeof(*survey));
5996 spin_unlock_bh(&ar->data_lock);
5997
5998 survey->channel = &sband->channels[idx];
5999
6000 if (ar->rx_channel == survey->channel)
6001 survey->filled |= SURVEY_INFO_IN_USE;
6002
6003 exit:
6004 mutex_unlock(&ar->conf_mutex);
6005 return ret;
6006 }
6007
6008 static bool
6009 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
6010 enum ieee80211_band band,
6011 const struct cfg80211_bitrate_mask *mask)
6012 {
6013 int num_rates = 0;
6014 int i;
6015
6016 num_rates += hweight32(mask->control[band].legacy);
6017
6018 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6019 num_rates += hweight8(mask->control[band].ht_mcs[i]);
6020
6021 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
6022 num_rates += hweight16(mask->control[band].vht_mcs[i]);
6023
6024 return num_rates == 1;
6025 }
6026
6027 static bool
6028 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
6029 enum ieee80211_band band,
6030 const struct cfg80211_bitrate_mask *mask,
6031 int *nss)
6032 {
6033 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6034 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6035 u8 ht_nss_mask = 0;
6036 u8 vht_nss_mask = 0;
6037 int i;
6038
6039 if (mask->control[band].legacy)
6040 return false;
6041
6042 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6043 if (mask->control[band].ht_mcs[i] == 0)
6044 continue;
6045 else if (mask->control[band].ht_mcs[i] ==
6046 sband->ht_cap.mcs.rx_mask[i])
6047 ht_nss_mask |= BIT(i);
6048 else
6049 return false;
6050 }
6051
6052 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6053 if (mask->control[band].vht_mcs[i] == 0)
6054 continue;
6055 else if (mask->control[band].vht_mcs[i] ==
6056 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6057 vht_nss_mask |= BIT(i);
6058 else
6059 return false;
6060 }
6061
6062 if (ht_nss_mask != vht_nss_mask)
6063 return false;
6064
6065 if (ht_nss_mask == 0)
6066 return false;
6067
6068 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6069 return false;
6070
6071 *nss = fls(ht_nss_mask);
6072
6073 return true;
6074 }
6075
6076 static int
6077 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6078 enum ieee80211_band band,
6079 const struct cfg80211_bitrate_mask *mask,
6080 u8 *rate, u8 *nss)
6081 {
6082 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6083 int rate_idx;
6084 int i;
6085 u16 bitrate;
6086 u8 preamble;
6087 u8 hw_rate;
6088
6089 if (hweight32(mask->control[band].legacy) == 1) {
6090 rate_idx = ffs(mask->control[band].legacy) - 1;
6091
6092 hw_rate = sband->bitrates[rate_idx].hw_value;
6093 bitrate = sband->bitrates[rate_idx].bitrate;
6094
6095 if (ath10k_mac_bitrate_is_cck(bitrate))
6096 preamble = WMI_RATE_PREAMBLE_CCK;
6097 else
6098 preamble = WMI_RATE_PREAMBLE_OFDM;
6099
6100 *nss = 1;
6101 *rate = preamble << 6 |
6102 (*nss - 1) << 4 |
6103 hw_rate << 0;
6104
6105 return 0;
6106 }
6107
6108 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6109 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6110 *nss = i + 1;
6111 *rate = WMI_RATE_PREAMBLE_HT << 6 |
6112 (*nss - 1) << 4 |
6113 (ffs(mask->control[band].ht_mcs[i]) - 1);
6114
6115 return 0;
6116 }
6117 }
6118
6119 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6120 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6121 *nss = i + 1;
6122 *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6123 (*nss - 1) << 4 |
6124 (ffs(mask->control[band].vht_mcs[i]) - 1);
6125
6126 return 0;
6127 }
6128 }
6129
6130 return -EINVAL;
6131 }
6132
6133 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
6134 u8 rate, u8 nss, u8 sgi, u8 ldpc)
6135 {
6136 struct ath10k *ar = arvif->ar;
6137 u32 vdev_param;
6138 int ret;
6139
6140 lockdep_assert_held(&ar->conf_mutex);
6141
6142 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6143 arvif->vdev_id, rate, nss, sgi);
6144
6145 vdev_param = ar->wmi.vdev_param->fixed_rate;
6146 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
6147 if (ret) {
6148 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
6149 rate, ret);
6150 return ret;
6151 }
6152
6153 vdev_param = ar->wmi.vdev_param->nss;
6154 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
6155 if (ret) {
6156 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6157 return ret;
6158 }
6159
6160 vdev_param = ar->wmi.vdev_param->sgi;
6161 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6162 if (ret) {
6163 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6164 return ret;
6165 }
6166
6167 vdev_param = ar->wmi.vdev_param->ldpc;
6168 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6169 if (ret) {
6170 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6171 return ret;
6172 }
6173
6174 return 0;
6175 }
6176
6177 static bool
6178 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6179 enum ieee80211_band band,
6180 const struct cfg80211_bitrate_mask *mask)
6181 {
6182 int i;
6183 u16 vht_mcs;
6184
6185 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6186 * to express all VHT MCS rate masks. Effectively only the following
6187 * ranges can be used: none, 0-7, 0-8 and 0-9.
6188 */
6189 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6190 vht_mcs = mask->control[band].vht_mcs[i];
6191
6192 switch (vht_mcs) {
6193 case 0:
6194 case BIT(8) - 1:
6195 case BIT(9) - 1:
6196 case BIT(10) - 1:
6197 break;
6198 default:
6199 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6200 return false;
6201 }
6202 }
6203
6204 return true;
6205 }
6206
6207 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6208 struct ieee80211_sta *sta)
6209 {
6210 struct ath10k_vif *arvif = data;
6211 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6212 struct ath10k *ar = arvif->ar;
6213
6214 if (arsta->arvif != arvif)
6215 return;
6216
6217 spin_lock_bh(&ar->data_lock);
6218 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6219 spin_unlock_bh(&ar->data_lock);
6220
6221 ieee80211_queue_work(ar->hw, &arsta->update_wk);
6222 }
6223
6224 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6225 struct ieee80211_vif *vif,
6226 const struct cfg80211_bitrate_mask *mask)
6227 {
6228 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6229 struct cfg80211_chan_def def;
6230 struct ath10k *ar = arvif->ar;
6231 enum ieee80211_band band;
6232 const u8 *ht_mcs_mask;
6233 const u16 *vht_mcs_mask;
6234 u8 rate;
6235 u8 nss;
6236 u8 sgi;
6237 u8 ldpc;
6238 int single_nss;
6239 int ret;
6240
6241 if (ath10k_mac_vif_chan(vif, &def))
6242 return -EPERM;
6243
6244 band = def.chan->band;
6245 ht_mcs_mask = mask->control[band].ht_mcs;
6246 vht_mcs_mask = mask->control[band].vht_mcs;
6247 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6248
6249 sgi = mask->control[band].gi;
6250 if (sgi == NL80211_TXRATE_FORCE_LGI)
6251 return -EINVAL;
6252
6253 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6254 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6255 &rate, &nss);
6256 if (ret) {
6257 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6258 arvif->vdev_id, ret);
6259 return ret;
6260 }
6261 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6262 &single_nss)) {
6263 rate = WMI_FIXED_RATE_NONE;
6264 nss = single_nss;
6265 } else {
6266 rate = WMI_FIXED_RATE_NONE;
6267 nss = min(ar->num_rf_chains,
6268 max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6269 ath10k_mac_max_vht_nss(vht_mcs_mask)));
6270
6271 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6272 return -EINVAL;
6273
6274 mutex_lock(&ar->conf_mutex);
6275
6276 arvif->bitrate_mask = *mask;
6277 ieee80211_iterate_stations_atomic(ar->hw,
6278 ath10k_mac_set_bitrate_mask_iter,
6279 arvif);
6280
6281 mutex_unlock(&ar->conf_mutex);
6282 }
6283
6284 mutex_lock(&ar->conf_mutex);
6285
6286 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6287 if (ret) {
6288 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6289 arvif->vdev_id, ret);
6290 goto exit;
6291 }
6292
6293 exit:
6294 mutex_unlock(&ar->conf_mutex);
6295
6296 return ret;
6297 }
6298
6299 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6300 struct ieee80211_vif *vif,
6301 struct ieee80211_sta *sta,
6302 u32 changed)
6303 {
6304 struct ath10k *ar = hw->priv;
6305 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6306 u32 bw, smps;
6307
6308 spin_lock_bh(&ar->data_lock);
6309
6310 ath10k_dbg(ar, ATH10K_DBG_MAC,
6311 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6312 sta->addr, changed, sta->bandwidth, sta->rx_nss,
6313 sta->smps_mode);
6314
6315 if (changed & IEEE80211_RC_BW_CHANGED) {
6316 bw = WMI_PEER_CHWIDTH_20MHZ;
6317
6318 switch (sta->bandwidth) {
6319 case IEEE80211_STA_RX_BW_20:
6320 bw = WMI_PEER_CHWIDTH_20MHZ;
6321 break;
6322 case IEEE80211_STA_RX_BW_40:
6323 bw = WMI_PEER_CHWIDTH_40MHZ;
6324 break;
6325 case IEEE80211_STA_RX_BW_80:
6326 bw = WMI_PEER_CHWIDTH_80MHZ;
6327 break;
6328 case IEEE80211_STA_RX_BW_160:
6329 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6330 sta->bandwidth, sta->addr);
6331 bw = WMI_PEER_CHWIDTH_20MHZ;
6332 break;
6333 }
6334
6335 arsta->bw = bw;
6336 }
6337
6338 if (changed & IEEE80211_RC_NSS_CHANGED)
6339 arsta->nss = sta->rx_nss;
6340
6341 if (changed & IEEE80211_RC_SMPS_CHANGED) {
6342 smps = WMI_PEER_SMPS_PS_NONE;
6343
6344 switch (sta->smps_mode) {
6345 case IEEE80211_SMPS_AUTOMATIC:
6346 case IEEE80211_SMPS_OFF:
6347 smps = WMI_PEER_SMPS_PS_NONE;
6348 break;
6349 case IEEE80211_SMPS_STATIC:
6350 smps = WMI_PEER_SMPS_STATIC;
6351 break;
6352 case IEEE80211_SMPS_DYNAMIC:
6353 smps = WMI_PEER_SMPS_DYNAMIC;
6354 break;
6355 case IEEE80211_SMPS_NUM_MODES:
6356 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6357 sta->smps_mode, sta->addr);
6358 smps = WMI_PEER_SMPS_PS_NONE;
6359 break;
6360 }
6361
6362 arsta->smps = smps;
6363 }
6364
6365 arsta->changed |= changed;
6366
6367 spin_unlock_bh(&ar->data_lock);
6368
6369 ieee80211_queue_work(hw, &arsta->update_wk);
6370 }
6371
6372 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6373 {
6374 /*
6375 * FIXME: Return 0 for time being. Need to figure out whether FW
6376 * has the API to fetch 64-bit local TSF
6377 */
6378
6379 return 0;
6380 }
6381
6382 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6383 struct ieee80211_vif *vif,
6384 struct ieee80211_ampdu_params *params)
6385 {
6386 struct ath10k *ar = hw->priv;
6387 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6388 struct ieee80211_sta *sta = params->sta;
6389 enum ieee80211_ampdu_mlme_action action = params->action;
6390 u16 tid = params->tid;
6391
6392 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6393 arvif->vdev_id, sta->addr, tid, action);
6394
6395 switch (action) {
6396 case IEEE80211_AMPDU_RX_START:
6397 case IEEE80211_AMPDU_RX_STOP:
6398 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6399 * creation/removal. Do we need to verify this?
6400 */
6401 return 0;
6402 case IEEE80211_AMPDU_TX_START:
6403 case IEEE80211_AMPDU_TX_STOP_CONT:
6404 case IEEE80211_AMPDU_TX_STOP_FLUSH:
6405 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6406 case IEEE80211_AMPDU_TX_OPERATIONAL:
6407 /* Firmware offloads Tx aggregation entirely so deny mac80211
6408 * Tx aggregation requests.
6409 */
6410 return -EOPNOTSUPP;
6411 }
6412
6413 return -EINVAL;
6414 }
6415
6416 static void
6417 ath10k_mac_update_rx_channel(struct ath10k *ar,
6418 struct ieee80211_chanctx_conf *ctx,
6419 struct ieee80211_vif_chanctx_switch *vifs,
6420 int n_vifs)
6421 {
6422 struct cfg80211_chan_def *def = NULL;
6423
6424 /* Both locks are required because ar->rx_channel is modified. This
6425 * allows readers to hold either lock.
6426 */
6427 lockdep_assert_held(&ar->conf_mutex);
6428 lockdep_assert_held(&ar->data_lock);
6429
6430 WARN_ON(ctx && vifs);
6431 WARN_ON(vifs && n_vifs != 1);
6432
6433 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6434 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6435 * ppdu on Rx may reduce performance on low-end systems. It should be
6436 * possible to make tables/hashmaps to speed the lookup up (be vary of
6437 * cpu data cache lines though regarding sizes) but to keep the initial
6438 * implementation simple and less intrusive fallback to the slow lookup
6439 * only for multi-channel cases. Single-channel cases will remain to
6440 * use the old channel derival and thus performance should not be
6441 * affected much.
6442 */
6443 rcu_read_lock();
6444 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6445 ieee80211_iter_chan_contexts_atomic(ar->hw,
6446 ath10k_mac_get_any_chandef_iter,
6447 &def);
6448
6449 if (vifs)
6450 def = &vifs[0].new_ctx->def;
6451
6452 ar->rx_channel = def->chan;
6453 } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6454 ar->rx_channel = ctx->def.chan;
6455 } else {
6456 ar->rx_channel = NULL;
6457 }
6458 rcu_read_unlock();
6459 }
6460
6461 static void
6462 ath10k_mac_update_vif_chan(struct ath10k *ar,
6463 struct ieee80211_vif_chanctx_switch *vifs,
6464 int n_vifs)
6465 {
6466 struct ath10k_vif *arvif;
6467 int ret;
6468 int i;
6469
6470 lockdep_assert_held(&ar->conf_mutex);
6471
6472 /* First stop monitor interface. Some FW versions crash if there's a
6473 * lone monitor interface.
6474 */
6475 if (ar->monitor_started)
6476 ath10k_monitor_stop(ar);
6477
6478 for (i = 0; i < n_vifs; i++) {
6479 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6480
6481 ath10k_dbg(ar, ATH10K_DBG_MAC,
6482 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6483 arvif->vdev_id,
6484 vifs[i].old_ctx->def.chan->center_freq,
6485 vifs[i].new_ctx->def.chan->center_freq,
6486 vifs[i].old_ctx->def.width,
6487 vifs[i].new_ctx->def.width);
6488
6489 if (WARN_ON(!arvif->is_started))
6490 continue;
6491
6492 if (WARN_ON(!arvif->is_up))
6493 continue;
6494
6495 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6496 if (ret) {
6497 ath10k_warn(ar, "failed to down vdev %d: %d\n",
6498 arvif->vdev_id, ret);
6499 continue;
6500 }
6501 }
6502
6503 /* All relevant vdevs are downed and associated channel resources
6504 * should be available for the channel switch now.
6505 */
6506
6507 spin_lock_bh(&ar->data_lock);
6508 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6509 spin_unlock_bh(&ar->data_lock);
6510
6511 for (i = 0; i < n_vifs; i++) {
6512 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6513
6514 if (WARN_ON(!arvif->is_started))
6515 continue;
6516
6517 if (WARN_ON(!arvif->is_up))
6518 continue;
6519
6520 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6521 if (ret)
6522 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6523 ret);
6524
6525 ret = ath10k_mac_setup_prb_tmpl(arvif);
6526 if (ret)
6527 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6528 ret);
6529
6530 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6531 if (ret) {
6532 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6533 arvif->vdev_id, ret);
6534 continue;
6535 }
6536
6537 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6538 arvif->bssid);
6539 if (ret) {
6540 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6541 arvif->vdev_id, ret);
6542 continue;
6543 }
6544 }
6545
6546 ath10k_monitor_recalc(ar);
6547 }
6548
6549 static int
6550 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6551 struct ieee80211_chanctx_conf *ctx)
6552 {
6553 struct ath10k *ar = hw->priv;
6554
6555 ath10k_dbg(ar, ATH10K_DBG_MAC,
6556 "mac chanctx add freq %hu width %d ptr %p\n",
6557 ctx->def.chan->center_freq, ctx->def.width, ctx);
6558
6559 mutex_lock(&ar->conf_mutex);
6560
6561 spin_lock_bh(&ar->data_lock);
6562 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6563 spin_unlock_bh(&ar->data_lock);
6564
6565 ath10k_recalc_radar_detection(ar);
6566 ath10k_monitor_recalc(ar);
6567
6568 mutex_unlock(&ar->conf_mutex);
6569
6570 return 0;
6571 }
6572
6573 static void
6574 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6575 struct ieee80211_chanctx_conf *ctx)
6576 {
6577 struct ath10k *ar = hw->priv;
6578
6579 ath10k_dbg(ar, ATH10K_DBG_MAC,
6580 "mac chanctx remove freq %hu width %d ptr %p\n",
6581 ctx->def.chan->center_freq, ctx->def.width, ctx);
6582
6583 mutex_lock(&ar->conf_mutex);
6584
6585 spin_lock_bh(&ar->data_lock);
6586 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6587 spin_unlock_bh(&ar->data_lock);
6588
6589 ath10k_recalc_radar_detection(ar);
6590 ath10k_monitor_recalc(ar);
6591
6592 mutex_unlock(&ar->conf_mutex);
6593 }
6594
6595 struct ath10k_mac_change_chanctx_arg {
6596 struct ieee80211_chanctx_conf *ctx;
6597 struct ieee80211_vif_chanctx_switch *vifs;
6598 int n_vifs;
6599 int next_vif;
6600 };
6601
6602 static void
6603 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6604 struct ieee80211_vif *vif)
6605 {
6606 struct ath10k_mac_change_chanctx_arg *arg = data;
6607
6608 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6609 return;
6610
6611 arg->n_vifs++;
6612 }
6613
6614 static void
6615 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6616 struct ieee80211_vif *vif)
6617 {
6618 struct ath10k_mac_change_chanctx_arg *arg = data;
6619 struct ieee80211_chanctx_conf *ctx;
6620
6621 ctx = rcu_access_pointer(vif->chanctx_conf);
6622 if (ctx != arg->ctx)
6623 return;
6624
6625 if (WARN_ON(arg->next_vif == arg->n_vifs))
6626 return;
6627
6628 arg->vifs[arg->next_vif].vif = vif;
6629 arg->vifs[arg->next_vif].old_ctx = ctx;
6630 arg->vifs[arg->next_vif].new_ctx = ctx;
6631 arg->next_vif++;
6632 }
6633
6634 static void
6635 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6636 struct ieee80211_chanctx_conf *ctx,
6637 u32 changed)
6638 {
6639 struct ath10k *ar = hw->priv;
6640 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
6641
6642 mutex_lock(&ar->conf_mutex);
6643
6644 ath10k_dbg(ar, ATH10K_DBG_MAC,
6645 "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6646 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6647
6648 /* This shouldn't really happen because channel switching should use
6649 * switch_vif_chanctx().
6650 */
6651 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6652 goto unlock;
6653
6654 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
6655 ieee80211_iterate_active_interfaces_atomic(
6656 hw,
6657 IEEE80211_IFACE_ITER_NORMAL,
6658 ath10k_mac_change_chanctx_cnt_iter,
6659 &arg);
6660 if (arg.n_vifs == 0)
6661 goto radar;
6662
6663 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
6664 GFP_KERNEL);
6665 if (!arg.vifs)
6666 goto radar;
6667
6668 ieee80211_iterate_active_interfaces_atomic(
6669 hw,
6670 IEEE80211_IFACE_ITER_NORMAL,
6671 ath10k_mac_change_chanctx_fill_iter,
6672 &arg);
6673 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6674 kfree(arg.vifs);
6675 }
6676
6677 radar:
6678 ath10k_recalc_radar_detection(ar);
6679
6680 /* FIXME: How to configure Rx chains properly? */
6681
6682 /* No other actions are actually necessary. Firmware maintains channel
6683 * definitions per vdev internally and there's no host-side channel
6684 * context abstraction to configure, e.g. channel width.
6685 */
6686
6687 unlock:
6688 mutex_unlock(&ar->conf_mutex);
6689 }
6690
6691 static int
6692 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6693 struct ieee80211_vif *vif,
6694 struct ieee80211_chanctx_conf *ctx)
6695 {
6696 struct ath10k *ar = hw->priv;
6697 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6698 int ret;
6699
6700 mutex_lock(&ar->conf_mutex);
6701
6702 ath10k_dbg(ar, ATH10K_DBG_MAC,
6703 "mac chanctx assign ptr %p vdev_id %i\n",
6704 ctx, arvif->vdev_id);
6705
6706 if (WARN_ON(arvif->is_started)) {
6707 mutex_unlock(&ar->conf_mutex);
6708 return -EBUSY;
6709 }
6710
6711 ret = ath10k_vdev_start(arvif, &ctx->def);
6712 if (ret) {
6713 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6714 arvif->vdev_id, vif->addr,
6715 ctx->def.chan->center_freq, ret);
6716 goto err;
6717 }
6718
6719 arvif->is_started = true;
6720
6721 ret = ath10k_mac_vif_setup_ps(arvif);
6722 if (ret) {
6723 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6724 arvif->vdev_id, ret);
6725 goto err_stop;
6726 }
6727
6728 if (vif->type == NL80211_IFTYPE_MONITOR) {
6729 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6730 if (ret) {
6731 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6732 arvif->vdev_id, ret);
6733 goto err_stop;
6734 }
6735
6736 arvif->is_up = true;
6737 }
6738
6739 mutex_unlock(&ar->conf_mutex);
6740 return 0;
6741
6742 err_stop:
6743 ath10k_vdev_stop(arvif);
6744 arvif->is_started = false;
6745 ath10k_mac_vif_setup_ps(arvif);
6746
6747 err:
6748 mutex_unlock(&ar->conf_mutex);
6749 return ret;
6750 }
6751
6752 static void
6753 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6754 struct ieee80211_vif *vif,
6755 struct ieee80211_chanctx_conf *ctx)
6756 {
6757 struct ath10k *ar = hw->priv;
6758 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6759 int ret;
6760
6761 mutex_lock(&ar->conf_mutex);
6762
6763 ath10k_dbg(ar, ATH10K_DBG_MAC,
6764 "mac chanctx unassign ptr %p vdev_id %i\n",
6765 ctx, arvif->vdev_id);
6766
6767 WARN_ON(!arvif->is_started);
6768
6769 if (vif->type == NL80211_IFTYPE_MONITOR) {
6770 WARN_ON(!arvif->is_up);
6771
6772 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6773 if (ret)
6774 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6775 arvif->vdev_id, ret);
6776
6777 arvif->is_up = false;
6778 }
6779
6780 ret = ath10k_vdev_stop(arvif);
6781 if (ret)
6782 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6783 arvif->vdev_id, ret);
6784
6785 arvif->is_started = false;
6786
6787 mutex_unlock(&ar->conf_mutex);
6788 }
6789
6790 static int
6791 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6792 struct ieee80211_vif_chanctx_switch *vifs,
6793 int n_vifs,
6794 enum ieee80211_chanctx_switch_mode mode)
6795 {
6796 struct ath10k *ar = hw->priv;
6797
6798 mutex_lock(&ar->conf_mutex);
6799
6800 ath10k_dbg(ar, ATH10K_DBG_MAC,
6801 "mac chanctx switch n_vifs %d mode %d\n",
6802 n_vifs, mode);
6803 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
6804
6805 mutex_unlock(&ar->conf_mutex);
6806 return 0;
6807 }
6808
6809 static const struct ieee80211_ops ath10k_ops = {
6810 .tx = ath10k_tx,
6811 .start = ath10k_start,
6812 .stop = ath10k_stop,
6813 .config = ath10k_config,
6814 .add_interface = ath10k_add_interface,
6815 .remove_interface = ath10k_remove_interface,
6816 .configure_filter = ath10k_configure_filter,
6817 .bss_info_changed = ath10k_bss_info_changed,
6818 .hw_scan = ath10k_hw_scan,
6819 .cancel_hw_scan = ath10k_cancel_hw_scan,
6820 .set_key = ath10k_set_key,
6821 .set_default_unicast_key = ath10k_set_default_unicast_key,
6822 .sta_state = ath10k_sta_state,
6823 .conf_tx = ath10k_conf_tx,
6824 .remain_on_channel = ath10k_remain_on_channel,
6825 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
6826 .set_rts_threshold = ath10k_set_rts_threshold,
6827 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,
6828 .flush = ath10k_flush,
6829 .tx_last_beacon = ath10k_tx_last_beacon,
6830 .set_antenna = ath10k_set_antenna,
6831 .get_antenna = ath10k_get_antenna,
6832 .reconfig_complete = ath10k_reconfig_complete,
6833 .get_survey = ath10k_get_survey,
6834 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,
6835 .sta_rc_update = ath10k_sta_rc_update,
6836 .get_tsf = ath10k_get_tsf,
6837 .ampdu_action = ath10k_ampdu_action,
6838 .get_et_sset_count = ath10k_debug_get_et_sset_count,
6839 .get_et_stats = ath10k_debug_get_et_stats,
6840 .get_et_strings = ath10k_debug_get_et_strings,
6841 .add_chanctx = ath10k_mac_op_add_chanctx,
6842 .remove_chanctx = ath10k_mac_op_remove_chanctx,
6843 .change_chanctx = ath10k_mac_op_change_chanctx,
6844 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,
6845 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,
6846 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,
6847
6848 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6849
6850 #ifdef CONFIG_PM
6851 .suspend = ath10k_wow_op_suspend,
6852 .resume = ath10k_wow_op_resume,
6853 #endif
6854 #ifdef CONFIG_MAC80211_DEBUGFS
6855 .sta_add_debugfs = ath10k_sta_add_debugfs,
6856 #endif
6857 };
6858
6859 #define CHAN2G(_channel, _freq, _flags) { \
6860 .band = IEEE80211_BAND_2GHZ, \
6861 .hw_value = (_channel), \
6862 .center_freq = (_freq), \
6863 .flags = (_flags), \
6864 .max_antenna_gain = 0, \
6865 .max_power = 30, \
6866 }
6867
6868 #define CHAN5G(_channel, _freq, _flags) { \
6869 .band = IEEE80211_BAND_5GHZ, \
6870 .hw_value = (_channel), \
6871 .center_freq = (_freq), \
6872 .flags = (_flags), \
6873 .max_antenna_gain = 0, \
6874 .max_power = 30, \
6875 }
6876
6877 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6878 CHAN2G(1, 2412, 0),
6879 CHAN2G(2, 2417, 0),
6880 CHAN2G(3, 2422, 0),
6881 CHAN2G(4, 2427, 0),
6882 CHAN2G(5, 2432, 0),
6883 CHAN2G(6, 2437, 0),
6884 CHAN2G(7, 2442, 0),
6885 CHAN2G(8, 2447, 0),
6886 CHAN2G(9, 2452, 0),
6887 CHAN2G(10, 2457, 0),
6888 CHAN2G(11, 2462, 0),
6889 CHAN2G(12, 2467, 0),
6890 CHAN2G(13, 2472, 0),
6891 CHAN2G(14, 2484, 0),
6892 };
6893
6894 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6895 CHAN5G(36, 5180, 0),
6896 CHAN5G(40, 5200, 0),
6897 CHAN5G(44, 5220, 0),
6898 CHAN5G(48, 5240, 0),
6899 CHAN5G(52, 5260, 0),
6900 CHAN5G(56, 5280, 0),
6901 CHAN5G(60, 5300, 0),
6902 CHAN5G(64, 5320, 0),
6903 CHAN5G(100, 5500, 0),
6904 CHAN5G(104, 5520, 0),
6905 CHAN5G(108, 5540, 0),
6906 CHAN5G(112, 5560, 0),
6907 CHAN5G(116, 5580, 0),
6908 CHAN5G(120, 5600, 0),
6909 CHAN5G(124, 5620, 0),
6910 CHAN5G(128, 5640, 0),
6911 CHAN5G(132, 5660, 0),
6912 CHAN5G(136, 5680, 0),
6913 CHAN5G(140, 5700, 0),
6914 CHAN5G(144, 5720, 0),
6915 CHAN5G(149, 5745, 0),
6916 CHAN5G(153, 5765, 0),
6917 CHAN5G(157, 5785, 0),
6918 CHAN5G(161, 5805, 0),
6919 CHAN5G(165, 5825, 0),
6920 };
6921
6922 struct ath10k *ath10k_mac_create(size_t priv_size)
6923 {
6924 struct ieee80211_hw *hw;
6925 struct ath10k *ar;
6926
6927 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6928 if (!hw)
6929 return NULL;
6930
6931 ar = hw->priv;
6932 ar->hw = hw;
6933
6934 return ar;
6935 }
6936
6937 void ath10k_mac_destroy(struct ath10k *ar)
6938 {
6939 ieee80211_free_hw(ar->hw);
6940 }
6941
6942 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6943 {
6944 .max = 8,
6945 .types = BIT(NL80211_IFTYPE_STATION)
6946 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6947 },
6948 {
6949 .max = 3,
6950 .types = BIT(NL80211_IFTYPE_P2P_GO)
6951 },
6952 {
6953 .max = 1,
6954 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
6955 },
6956 {
6957 .max = 7,
6958 .types = BIT(NL80211_IFTYPE_AP)
6959 #ifdef CONFIG_MAC80211_MESH
6960 | BIT(NL80211_IFTYPE_MESH_POINT)
6961 #endif
6962 },
6963 };
6964
6965 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6966 {
6967 .max = 8,
6968 .types = BIT(NL80211_IFTYPE_AP)
6969 #ifdef CONFIG_MAC80211_MESH
6970 | BIT(NL80211_IFTYPE_MESH_POINT)
6971 #endif
6972 },
6973 {
6974 .max = 1,
6975 .types = BIT(NL80211_IFTYPE_STATION)
6976 },
6977 };
6978
6979 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6980 {
6981 .limits = ath10k_if_limits,
6982 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6983 .max_interfaces = 8,
6984 .num_different_channels = 1,
6985 .beacon_int_infra_match = true,
6986 },
6987 };
6988
6989 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6990 {
6991 .limits = ath10k_10x_if_limits,
6992 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6993 .max_interfaces = 8,
6994 .num_different_channels = 1,
6995 .beacon_int_infra_match = true,
6996 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6997 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6998 BIT(NL80211_CHAN_WIDTH_20) |
6999 BIT(NL80211_CHAN_WIDTH_40) |
7000 BIT(NL80211_CHAN_WIDTH_80),
7001 #endif
7002 },
7003 };
7004
7005 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
7006 {
7007 .max = 2,
7008 .types = BIT(NL80211_IFTYPE_STATION),
7009 },
7010 {
7011 .max = 2,
7012 .types = BIT(NL80211_IFTYPE_AP) |
7013 #ifdef CONFIG_MAC80211_MESH
7014 BIT(NL80211_IFTYPE_MESH_POINT) |
7015 #endif
7016 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7017 BIT(NL80211_IFTYPE_P2P_GO),
7018 },
7019 {
7020 .max = 1,
7021 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7022 },
7023 };
7024
7025 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
7026 {
7027 .max = 2,
7028 .types = BIT(NL80211_IFTYPE_STATION),
7029 },
7030 {
7031 .max = 2,
7032 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
7033 },
7034 {
7035 .max = 1,
7036 .types = BIT(NL80211_IFTYPE_AP) |
7037 #ifdef CONFIG_MAC80211_MESH
7038 BIT(NL80211_IFTYPE_MESH_POINT) |
7039 #endif
7040 BIT(NL80211_IFTYPE_P2P_GO),
7041 },
7042 {
7043 .max = 1,
7044 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7045 },
7046 };
7047
7048 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
7049 {
7050 .max = 1,
7051 .types = BIT(NL80211_IFTYPE_STATION),
7052 },
7053 {
7054 .max = 1,
7055 .types = BIT(NL80211_IFTYPE_ADHOC),
7056 },
7057 };
7058
7059 /* FIXME: This is not thouroughly tested. These combinations may over- or
7060 * underestimate hw/fw capabilities.
7061 */
7062 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
7063 {
7064 .limits = ath10k_tlv_if_limit,
7065 .num_different_channels = 1,
7066 .max_interfaces = 4,
7067 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7068 },
7069 {
7070 .limits = ath10k_tlv_if_limit_ibss,
7071 .num_different_channels = 1,
7072 .max_interfaces = 2,
7073 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7074 },
7075 };
7076
7077 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
7078 {
7079 .limits = ath10k_tlv_if_limit,
7080 .num_different_channels = 1,
7081 .max_interfaces = 4,
7082 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7083 },
7084 {
7085 .limits = ath10k_tlv_qcs_if_limit,
7086 .num_different_channels = 2,
7087 .max_interfaces = 4,
7088 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
7089 },
7090 {
7091 .limits = ath10k_tlv_if_limit_ibss,
7092 .num_different_channels = 1,
7093 .max_interfaces = 2,
7094 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7095 },
7096 };
7097
7098 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
7099 {
7100 .max = 1,
7101 .types = BIT(NL80211_IFTYPE_STATION),
7102 },
7103 {
7104 .max = 16,
7105 .types = BIT(NL80211_IFTYPE_AP)
7106 #ifdef CONFIG_MAC80211_MESH
7107 | BIT(NL80211_IFTYPE_MESH_POINT)
7108 #endif
7109 },
7110 };
7111
7112 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
7113 {
7114 .limits = ath10k_10_4_if_limits,
7115 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
7116 .max_interfaces = 16,
7117 .num_different_channels = 1,
7118 .beacon_int_infra_match = true,
7119 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7120 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7121 BIT(NL80211_CHAN_WIDTH_20) |
7122 BIT(NL80211_CHAN_WIDTH_40) |
7123 BIT(NL80211_CHAN_WIDTH_80),
7124 #endif
7125 },
7126 };
7127
7128 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7129 struct ieee80211_vif *vif)
7130 {
7131 struct ath10k_vif_iter *arvif_iter = data;
7132 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7133
7134 if (arvif->vdev_id == arvif_iter->vdev_id)
7135 arvif_iter->arvif = arvif;
7136 }
7137
7138 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7139 {
7140 struct ath10k_vif_iter arvif_iter;
7141 u32 flags;
7142
7143 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7144 arvif_iter.vdev_id = vdev_id;
7145
7146 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7147 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7148 flags,
7149 ath10k_get_arvif_iter,
7150 &arvif_iter);
7151 if (!arvif_iter.arvif) {
7152 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7153 return NULL;
7154 }
7155
7156 return arvif_iter.arvif;
7157 }
7158
7159 int ath10k_mac_register(struct ath10k *ar)
7160 {
7161 static const u32 cipher_suites[] = {
7162 WLAN_CIPHER_SUITE_WEP40,
7163 WLAN_CIPHER_SUITE_WEP104,
7164 WLAN_CIPHER_SUITE_TKIP,
7165 WLAN_CIPHER_SUITE_CCMP,
7166 WLAN_CIPHER_SUITE_AES_CMAC,
7167 };
7168 struct ieee80211_supported_band *band;
7169 void *channels;
7170 int ret;
7171
7172 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7173
7174 SET_IEEE80211_DEV(ar->hw, ar->dev);
7175
7176 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7177 ARRAY_SIZE(ath10k_5ghz_channels)) !=
7178 ATH10K_NUM_CHANS);
7179
7180 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7181 channels = kmemdup(ath10k_2ghz_channels,
7182 sizeof(ath10k_2ghz_channels),
7183 GFP_KERNEL);
7184 if (!channels) {
7185 ret = -ENOMEM;
7186 goto err_free;
7187 }
7188
7189 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7190 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7191 band->channels = channels;
7192 band->n_bitrates = ath10k_g_rates_size;
7193 band->bitrates = ath10k_g_rates;
7194
7195 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7196 }
7197
7198 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7199 channels = kmemdup(ath10k_5ghz_channels,
7200 sizeof(ath10k_5ghz_channels),
7201 GFP_KERNEL);
7202 if (!channels) {
7203 ret = -ENOMEM;
7204 goto err_free;
7205 }
7206
7207 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7208 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7209 band->channels = channels;
7210 band->n_bitrates = ath10k_a_rates_size;
7211 band->bitrates = ath10k_a_rates;
7212 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7213 }
7214
7215 ath10k_mac_setup_ht_vht_cap(ar);
7216
7217 ar->hw->wiphy->interface_modes =
7218 BIT(NL80211_IFTYPE_STATION) |
7219 BIT(NL80211_IFTYPE_AP) |
7220 BIT(NL80211_IFTYPE_MESH_POINT);
7221
7222 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
7223 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
7224
7225 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7226 ar->hw->wiphy->interface_modes |=
7227 BIT(NL80211_IFTYPE_P2P_DEVICE) |
7228 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7229 BIT(NL80211_IFTYPE_P2P_GO);
7230
7231 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7232 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7233 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7234 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7235 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7236 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7237 ieee80211_hw_set(ar->hw, AP_LINK_PS);
7238 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7239 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7240 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7241 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7242 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7243 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7244 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7245
7246 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7247 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7248
7249 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7250 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7251
7252 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7253 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7254
7255 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7256 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7257 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7258 }
7259
7260 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7261 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7262
7263 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7264 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7265
7266 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7267
7268 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7269 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7270
7271 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7272 * that userspace (e.g. wpa_supplicant/hostapd) can generate
7273 * correct Probe Responses. This is more of a hack advert..
7274 */
7275 ar->hw->wiphy->probe_resp_offload |=
7276 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7277 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7278 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7279 }
7280
7281 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7282 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7283
7284 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7285 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7286 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7287
7288 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7289 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7290
7291 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7292
7293 ret = ath10k_wow_init(ar);
7294 if (ret) {
7295 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7296 goto err_free;
7297 }
7298
7299 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7300
7301 /*
7302 * on LL hardware queues are managed entirely by the FW
7303 * so we only advertise to mac we can do the queues thing
7304 */
7305 ar->hw->queues = IEEE80211_MAX_QUEUES;
7306
7307 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7308 * something that vdev_ids can't reach so that we don't stop the queue
7309 * accidentally.
7310 */
7311 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7312
7313 switch (ar->wmi.op_version) {
7314 case ATH10K_FW_WMI_OP_VERSION_MAIN:
7315 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7316 ar->hw->wiphy->n_iface_combinations =
7317 ARRAY_SIZE(ath10k_if_comb);
7318 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7319 break;
7320 case ATH10K_FW_WMI_OP_VERSION_TLV:
7321 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7322 ar->hw->wiphy->iface_combinations =
7323 ath10k_tlv_qcs_if_comb;
7324 ar->hw->wiphy->n_iface_combinations =
7325 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7326 } else {
7327 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7328 ar->hw->wiphy->n_iface_combinations =
7329 ARRAY_SIZE(ath10k_tlv_if_comb);
7330 }
7331 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7332 break;
7333 case ATH10K_FW_WMI_OP_VERSION_10_1:
7334 case ATH10K_FW_WMI_OP_VERSION_10_2:
7335 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7336 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7337 ar->hw->wiphy->n_iface_combinations =
7338 ARRAY_SIZE(ath10k_10x_if_comb);
7339 break;
7340 case ATH10K_FW_WMI_OP_VERSION_10_4:
7341 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7342 ar->hw->wiphy->n_iface_combinations =
7343 ARRAY_SIZE(ath10k_10_4_if_comb);
7344 break;
7345 case ATH10K_FW_WMI_OP_VERSION_UNSET:
7346 case ATH10K_FW_WMI_OP_VERSION_MAX:
7347 WARN_ON(1);
7348 ret = -EINVAL;
7349 goto err_free;
7350 }
7351
7352 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7353 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7354
7355 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7356 /* Init ath dfs pattern detector */
7357 ar->ath_common.debug_mask = ATH_DBG_DFS;
7358 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7359 NL80211_DFS_UNSET);
7360
7361 if (!ar->dfs_detector)
7362 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7363 }
7364
7365 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7366 ath10k_reg_notifier);
7367 if (ret) {
7368 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7369 goto err_dfs_detector_exit;
7370 }
7371
7372 ar->hw->wiphy->cipher_suites = cipher_suites;
7373 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7374
7375 ret = ieee80211_register_hw(ar->hw);
7376 if (ret) {
7377 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7378 goto err_dfs_detector_exit;
7379 }
7380
7381 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7382 ret = regulatory_hint(ar->hw->wiphy,
7383 ar->ath_common.regulatory.alpha2);
7384 if (ret)
7385 goto err_unregister;
7386 }
7387
7388 return 0;
7389
7390 err_unregister:
7391 ieee80211_unregister_hw(ar->hw);
7392
7393 err_dfs_detector_exit:
7394 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7395 ar->dfs_detector->exit(ar->dfs_detector);
7396
7397 err_free:
7398 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7399 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7400
7401 SET_IEEE80211_DEV(ar->hw, NULL);
7402 return ret;
7403 }
7404
7405 void ath10k_mac_unregister(struct ath10k *ar)
7406 {
7407 ieee80211_unregister_hw(ar->hw);
7408
7409 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7410 ar->dfs_detector->exit(ar->dfs_detector);
7411
7412 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7413 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7414
7415 SET_IEEE80211_DEV(ar->hw, NULL);
7416 }
Ubuntu Hirsute Linux kernel mirror