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