projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ath10k: replace vdev_id and tid in skb cb
[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 enum ath10k_hw_txrx_mode
3126 ath10k_mac_tx_h_get_txmode(struct ath10k *ar,
3127 struct ieee80211_vif *vif,
3128 struct ieee80211_sta *sta,
3129 struct sk_buff *skb)
3130 {
3131 const struct ieee80211_hdr *hdr = (void *)skb->data;
3132 __le16 fc = hdr->frame_control;
3133
3134 if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3135 return ATH10K_HW_TXRX_RAW;
3136
3137 if (ieee80211_is_mgmt(fc))
3138 return ATH10K_HW_TXRX_MGMT;
3139
3140 /* Workaround:
3141 *
3142 * NullFunc frames are mostly used to ping if a client or AP are still
3143 * reachable and responsive. This implies tx status reports must be
3144 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3145 * come to a conclusion that the other end disappeared and tear down
3146 * BSS connection or it can never disconnect from BSS/client (which is
3147 * the case).
3148 *
3149 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3150 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3151 * which seems to deliver correct tx reports for NullFunc frames. The
3152 * downside of using it is it ignores client powersave state so it can
3153 * end up disconnecting sleeping clients in AP mode. It should fix STA
3154 * mode though because AP don't sleep.
3155 */
3156 if (ar->htt.target_version_major < 3 &&
3157 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3158 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, ar->fw_features))
3159 return ATH10K_HW_TXRX_MGMT;
3160
3161 /* Workaround:
3162 *
3163 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3164 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3165 * to work with Ethernet txmode so use it.
3166 *
3167 * FIXME: Check if raw mode works with TDLS.
3168 */
3169 if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3170 return ATH10K_HW_TXRX_ETHERNET;
3171
3172 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
3173 return ATH10K_HW_TXRX_RAW;
3174
3175 return ATH10K_HW_TXRX_NATIVE_WIFI;
3176 }
3177
3178 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,
3179 struct sk_buff *skb)
3180 {
3181 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3182 const struct ieee80211_hdr *hdr = (void *)skb->data;
3183 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |
3184 IEEE80211_TX_CTL_INJECTED;
3185
3186 if (!ieee80211_has_protected(hdr->frame_control))
3187 return false;
3188
3189 if ((info->flags & mask) == mask)
3190 return false;
3191
3192 if (vif)
3193 return !ath10k_vif_to_arvif(vif)->nohwcrypt;
3194
3195 return true;
3196 }
3197
3198 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3199 * Control in the header.
3200 */
3201 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3202 {
3203 struct ieee80211_hdr *hdr = (void *)skb->data;
3204 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3205 u8 *qos_ctl;
3206
3207 if (!ieee80211_is_data_qos(hdr->frame_control))
3208 return;
3209
3210 qos_ctl = ieee80211_get_qos_ctl(hdr);
3211 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3212 skb->data, (void *)qos_ctl - (void *)skb->data);
3213 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3214
3215 /* Some firmware revisions don't handle sending QoS NullFunc well.
3216 * These frames are mainly used for CQM purposes so it doesn't really
3217 * matter whether QoS NullFunc or NullFunc are sent.
3218 */
3219 hdr = (void *)skb->data;
3220 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3221 cb->flags &= ~ATH10K_SKB_F_QOS;
3222
3223 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3224 }
3225
3226 static void ath10k_tx_h_8023(struct sk_buff *skb)
3227 {
3228 struct ieee80211_hdr *hdr;
3229 struct rfc1042_hdr *rfc1042;
3230 struct ethhdr *eth;
3231 size_t hdrlen;
3232 u8 da[ETH_ALEN];
3233 u8 sa[ETH_ALEN];
3234 __be16 type;
3235
3236 hdr = (void *)skb->data;
3237 hdrlen = ieee80211_hdrlen(hdr->frame_control);
3238 rfc1042 = (void *)skb->data + hdrlen;
3239
3240 ether_addr_copy(da, ieee80211_get_DA(hdr));
3241 ether_addr_copy(sa, ieee80211_get_SA(hdr));
3242 type = rfc1042->snap_type;
3243
3244 skb_pull(skb, hdrlen + sizeof(*rfc1042));
3245 skb_push(skb, sizeof(*eth));
3246
3247 eth = (void *)skb->data;
3248 ether_addr_copy(eth->h_dest, da);
3249 ether_addr_copy(eth->h_source, sa);
3250 eth->h_proto = type;
3251 }
3252
3253 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3254 struct ieee80211_vif *vif,
3255 struct sk_buff *skb)
3256 {
3257 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3258 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3259
3260 /* This is case only for P2P_GO */
3261 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
3262 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
3263 return;
3264
3265 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3266 spin_lock_bh(&ar->data_lock);
3267 if (arvif->u.ap.noa_data)
3268 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3269 GFP_ATOMIC))
3270 memcpy(skb_put(skb, arvif->u.ap.noa_len),
3271 arvif->u.ap.noa_data,
3272 arvif->u.ap.noa_len);
3273 spin_unlock_bh(&ar->data_lock);
3274 }
3275 }
3276
3277 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)
3278 {
3279 /* FIXME: Not really sure since when the behaviour changed. At some
3280 * point new firmware stopped requiring creation of peer entries for
3281 * offchannel tx (and actually creating them causes issues with wmi-htc
3282 * tx credit replenishment and reliability). Assuming it's at least 3.4
3283 * because that's when the `freq` was introduced to TX_FRM HTT command.
3284 */
3285 return (ar->htt.target_version_major >= 3 &&
3286 ar->htt.target_version_minor >= 4 &&
3287 ar->htt.op_version == ATH10K_FW_HTT_OP_VERSION_TLV);
3288 }
3289
3290 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3291 {
3292 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3293 int ret = 0;
3294
3295 spin_lock_bh(&ar->data_lock);
3296
3297 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) {
3298 ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3299 ret = -ENOSPC;
3300 goto unlock;
3301 }
3302
3303 __skb_queue_tail(q, skb);
3304 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3305
3306 unlock:
3307 spin_unlock_bh(&ar->data_lock);
3308
3309 return ret;
3310 }
3311
3312 static void ath10k_mac_tx(struct ath10k *ar, enum ath10k_hw_txrx_mode txmode,
3313 struct sk_buff *skb)
3314 {
3315 struct ath10k_htt *htt = &ar->htt;
3316 int ret = 0;
3317
3318 switch (txmode) {
3319 case ATH10K_HW_TXRX_RAW:
3320 case ATH10K_HW_TXRX_NATIVE_WIFI:
3321 case ATH10K_HW_TXRX_ETHERNET:
3322 ret = ath10k_htt_tx(htt, txmode, skb);
3323 break;
3324 case ATH10K_HW_TXRX_MGMT:
3325 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3326 ar->fw_features))
3327 ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
3328 else if (ar->htt.target_version_major >= 3)
3329 ret = ath10k_htt_tx(htt, txmode, skb);
3330 else
3331 ret = ath10k_htt_mgmt_tx(htt, skb);
3332 break;
3333 }
3334
3335 if (ret) {
3336 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
3337 ret);
3338 ieee80211_free_txskb(ar->hw, skb);
3339 }
3340 }
3341
3342 void ath10k_offchan_tx_purge(struct ath10k *ar)
3343 {
3344 struct sk_buff *skb;
3345
3346 for (;;) {
3347 skb = skb_dequeue(&ar->offchan_tx_queue);
3348 if (!skb)
3349 break;
3350
3351 ieee80211_free_txskb(ar->hw, skb);
3352 }
3353 }
3354
3355 void ath10k_offchan_tx_work(struct work_struct *work)
3356 {
3357 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
3358 struct ath10k_peer *peer;
3359 struct ath10k_vif *arvif;
3360 struct ieee80211_hdr *hdr;
3361 struct ieee80211_vif *vif;
3362 struct ieee80211_sta *sta;
3363 struct sk_buff *skb;
3364 const u8 *peer_addr;
3365 enum ath10k_hw_txrx_mode txmode;
3366 int vdev_id;
3367 int ret;
3368 unsigned long time_left;
3369 bool tmp_peer_created = false;
3370
3371 /* FW requirement: We must create a peer before FW will send out
3372 * an offchannel frame. Otherwise the frame will be stuck and
3373 * never transmitted. We delete the peer upon tx completion.
3374 * It is unlikely that a peer for offchannel tx will already be
3375 * present. However it may be in some rare cases so account for that.
3376 * Otherwise we might remove a legitimate peer and break stuff. */
3377
3378 for (;;) {
3379 skb = skb_dequeue(&ar->offchan_tx_queue);
3380 if (!skb)
3381 break;
3382
3383 mutex_lock(&ar->conf_mutex);
3384
3385 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
3386 skb);
3387
3388 hdr = (struct ieee80211_hdr *)skb->data;
3389 peer_addr = ieee80211_get_DA(hdr);
3390
3391 spin_lock_bh(&ar->data_lock);
3392 vdev_id = ar->scan.vdev_id;
3393 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
3394 spin_unlock_bh(&ar->data_lock);
3395
3396 if (peer)
3397 /* FIXME: should this use ath10k_warn()? */
3398 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
3399 peer_addr, vdev_id);
3400
3401 if (!peer) {
3402 ret = ath10k_peer_create(ar, vdev_id, peer_addr,
3403 WMI_PEER_TYPE_DEFAULT);
3404 if (ret)
3405 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
3406 peer_addr, vdev_id, ret);
3407 tmp_peer_created = (ret == 0);
3408 }
3409
3410 spin_lock_bh(&ar->data_lock);
3411 reinit_completion(&ar->offchan_tx_completed);
3412 ar->offchan_tx_skb = skb;
3413 spin_unlock_bh(&ar->data_lock);
3414
3415 /* It's safe to access vif and sta - conf_mutex guarantees that
3416 * sta_state() and remove_interface() are locked exclusively
3417 * out wrt to this offchannel worker.
3418 */
3419 arvif = ath10k_get_arvif(ar, vdev_id);
3420 if (arvif) {
3421 vif = arvif->vif;
3422 sta = ieee80211_find_sta(vif, peer_addr);
3423 } else {
3424 vif = NULL;
3425 sta = NULL;
3426 }
3427
3428 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3429
3430 ath10k_mac_tx(ar, txmode, skb);
3431
3432 time_left =
3433 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
3434 if (time_left == 0)
3435 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
3436 skb);
3437
3438 if (!peer && tmp_peer_created) {
3439 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
3440 if (ret)
3441 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
3442 peer_addr, vdev_id, ret);
3443 }
3444
3445 mutex_unlock(&ar->conf_mutex);
3446 }
3447 }
3448
3449 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
3450 {
3451 struct sk_buff *skb;
3452
3453 for (;;) {
3454 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3455 if (!skb)
3456 break;
3457
3458 ieee80211_free_txskb(ar->hw, skb);
3459 }
3460 }
3461
3462 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
3463 {
3464 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
3465 struct sk_buff *skb;
3466 int ret;
3467
3468 for (;;) {
3469 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3470 if (!skb)
3471 break;
3472
3473 ret = ath10k_wmi_mgmt_tx(ar, skb);
3474 if (ret) {
3475 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
3476 ret);
3477 ieee80211_free_txskb(ar->hw, skb);
3478 }
3479 }
3480 }
3481
3482 /************/
3483 /* Scanning */
3484 /************/
3485
3486 void __ath10k_scan_finish(struct ath10k *ar)
3487 {
3488 lockdep_assert_held(&ar->data_lock);
3489
3490 switch (ar->scan.state) {
3491 case ATH10K_SCAN_IDLE:
3492 break;
3493 case ATH10K_SCAN_RUNNING:
3494 case ATH10K_SCAN_ABORTING:
3495 if (!ar->scan.is_roc)
3496 ieee80211_scan_completed(ar->hw,
3497 (ar->scan.state ==
3498 ATH10K_SCAN_ABORTING));
3499 else if (ar->scan.roc_notify)
3500 ieee80211_remain_on_channel_expired(ar->hw);
3501 /* fall through */
3502 case ATH10K_SCAN_STARTING:
3503 ar->scan.state = ATH10K_SCAN_IDLE;
3504 ar->scan_channel = NULL;
3505 ar->scan.roc_freq = 0;
3506 ath10k_offchan_tx_purge(ar);
3507 cancel_delayed_work(&ar->scan.timeout);
3508 complete_all(&ar->scan.completed);
3509 break;
3510 }
3511 }
3512
3513 void ath10k_scan_finish(struct ath10k *ar)
3514 {
3515 spin_lock_bh(&ar->data_lock);
3516 __ath10k_scan_finish(ar);
3517 spin_unlock_bh(&ar->data_lock);
3518 }
3519
3520 static int ath10k_scan_stop(struct ath10k *ar)
3521 {
3522 struct wmi_stop_scan_arg arg = {
3523 .req_id = 1, /* FIXME */
3524 .req_type = WMI_SCAN_STOP_ONE,
3525 .u.scan_id = ATH10K_SCAN_ID,
3526 };
3527 int ret;
3528
3529 lockdep_assert_held(&ar->conf_mutex);
3530
3531 ret = ath10k_wmi_stop_scan(ar, &arg);
3532 if (ret) {
3533 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
3534 goto out;
3535 }
3536
3537 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
3538 if (ret == 0) {
3539 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
3540 ret = -ETIMEDOUT;
3541 } else if (ret > 0) {
3542 ret = 0;
3543 }
3544
3545 out:
3546 /* Scan state should be updated upon scan completion but in case
3547 * firmware fails to deliver the event (for whatever reason) it is
3548 * desired to clean up scan state anyway. Firmware may have just
3549 * dropped the scan completion event delivery due to transport pipe
3550 * being overflown with data and/or it can recover on its own before
3551 * next scan request is submitted.
3552 */
3553 spin_lock_bh(&ar->data_lock);
3554 if (ar->scan.state != ATH10K_SCAN_IDLE)
3555 __ath10k_scan_finish(ar);
3556 spin_unlock_bh(&ar->data_lock);
3557
3558 return ret;
3559 }
3560
3561 static void ath10k_scan_abort(struct ath10k *ar)
3562 {
3563 int ret;
3564
3565 lockdep_assert_held(&ar->conf_mutex);
3566
3567 spin_lock_bh(&ar->data_lock);
3568
3569 switch (ar->scan.state) {
3570 case ATH10K_SCAN_IDLE:
3571 /* This can happen if timeout worker kicked in and called
3572 * abortion while scan completion was being processed.
3573 */
3574 break;
3575 case ATH10K_SCAN_STARTING:
3576 case ATH10K_SCAN_ABORTING:
3577 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3578 ath10k_scan_state_str(ar->scan.state),
3579 ar->scan.state);
3580 break;
3581 case ATH10K_SCAN_RUNNING:
3582 ar->scan.state = ATH10K_SCAN_ABORTING;
3583 spin_unlock_bh(&ar->data_lock);
3584
3585 ret = ath10k_scan_stop(ar);
3586 if (ret)
3587 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
3588
3589 spin_lock_bh(&ar->data_lock);
3590 break;
3591 }
3592
3593 spin_unlock_bh(&ar->data_lock);
3594 }
3595
3596 void ath10k_scan_timeout_work(struct work_struct *work)
3597 {
3598 struct ath10k *ar = container_of(work, struct ath10k,
3599 scan.timeout.work);
3600
3601 mutex_lock(&ar->conf_mutex);
3602 ath10k_scan_abort(ar);
3603 mutex_unlock(&ar->conf_mutex);
3604 }
3605
3606 static int ath10k_start_scan(struct ath10k *ar,
3607 const struct wmi_start_scan_arg *arg)
3608 {
3609 int ret;
3610
3611 lockdep_assert_held(&ar->conf_mutex);
3612
3613 ret = ath10k_wmi_start_scan(ar, arg);
3614 if (ret)
3615 return ret;
3616
3617 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
3618 if (ret == 0) {
3619 ret = ath10k_scan_stop(ar);
3620 if (ret)
3621 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3622
3623 return -ETIMEDOUT;
3624 }
3625
3626 /* If we failed to start the scan, return error code at
3627 * this point. This is probably due to some issue in the
3628 * firmware, but no need to wedge the driver due to that...
3629 */
3630 spin_lock_bh(&ar->data_lock);
3631 if (ar->scan.state == ATH10K_SCAN_IDLE) {
3632 spin_unlock_bh(&ar->data_lock);
3633 return -EINVAL;
3634 }
3635 spin_unlock_bh(&ar->data_lock);
3636
3637 return 0;
3638 }
3639
3640 /**********************/
3641 /* mac80211 callbacks */
3642 /**********************/
3643
3644 static void ath10k_tx(struct ieee80211_hw *hw,
3645 struct ieee80211_tx_control *control,
3646 struct sk_buff *skb)
3647 {
3648 struct ath10k *ar = hw->priv;
3649 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
3650 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3651 struct ieee80211_vif *vif = info->control.vif;
3652 struct ieee80211_sta *sta = control->sta;
3653 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3654 enum ath10k_hw_txrx_mode txmode;
3655
3656 /* We should disable CCK RATE due to P2P */
3657 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
3658 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3659
3660 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3661
3662 skb_cb->flags = 0;
3663 if (!ath10k_tx_h_use_hwcrypto(vif, skb))
3664 skb_cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3665
3666 if (ieee80211_is_mgmt(hdr->frame_control))
3667 skb_cb->flags |= ATH10K_SKB_F_MGMT;
3668
3669 if (ieee80211_is_data_qos(hdr->frame_control))
3670 skb_cb->flags |= ATH10K_SKB_F_QOS;
3671
3672 skb_cb->vif = vif;
3673
3674 switch (txmode) {
3675 case ATH10K_HW_TXRX_MGMT:
3676 case ATH10K_HW_TXRX_NATIVE_WIFI:
3677 ath10k_tx_h_nwifi(hw, skb);
3678 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
3679 ath10k_tx_h_seq_no(vif, skb);
3680 break;
3681 case ATH10K_HW_TXRX_ETHERNET:
3682 ath10k_tx_h_8023(skb);
3683 break;
3684 case ATH10K_HW_TXRX_RAW:
3685 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
3686 WARN_ON_ONCE(1);
3687 ieee80211_free_txskb(hw, skb);
3688 return;
3689 }
3690 }
3691
3692 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
3693 if (!ath10k_mac_tx_frm_has_freq(ar)) {
3694 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
3695 skb);
3696
3697 skb_queue_tail(&ar->offchan_tx_queue, skb);
3698 ieee80211_queue_work(hw, &ar->offchan_tx_work);
3699 return;
3700 }
3701 }
3702
3703 ath10k_mac_tx(ar, txmode, skb);
3704 }
3705
3706 /* Must not be called with conf_mutex held as workers can use that also. */
3707 void ath10k_drain_tx(struct ath10k *ar)
3708 {
3709 /* make sure rcu-protected mac80211 tx path itself is drained */
3710 synchronize_net();
3711
3712 ath10k_offchan_tx_purge(ar);
3713 ath10k_mgmt_over_wmi_tx_purge(ar);
3714
3715 cancel_work_sync(&ar->offchan_tx_work);
3716 cancel_work_sync(&ar->wmi_mgmt_tx_work);
3717 }
3718
3719 void ath10k_halt(struct ath10k *ar)
3720 {
3721 struct ath10k_vif *arvif;
3722
3723 lockdep_assert_held(&ar->conf_mutex);
3724
3725 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
3726 ar->filter_flags = 0;
3727 ar->monitor = false;
3728 ar->monitor_arvif = NULL;
3729
3730 if (ar->monitor_started)
3731 ath10k_monitor_stop(ar);
3732
3733 ar->monitor_started = false;
3734 ar->tx_paused = 0;
3735
3736 ath10k_scan_finish(ar);
3737 ath10k_peer_cleanup_all(ar);
3738 ath10k_core_stop(ar);
3739 ath10k_hif_power_down(ar);
3740
3741 spin_lock_bh(&ar->data_lock);
3742 list_for_each_entry(arvif, &ar->arvifs, list)
3743 ath10k_mac_vif_beacon_cleanup(arvif);
3744 spin_unlock_bh(&ar->data_lock);
3745 }
3746
3747 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
3748 {
3749 struct ath10k *ar = hw->priv;
3750
3751 mutex_lock(&ar->conf_mutex);
3752
3753 *tx_ant = ar->cfg_tx_chainmask;
3754 *rx_ant = ar->cfg_rx_chainmask;
3755
3756 mutex_unlock(&ar->conf_mutex);
3757
3758 return 0;
3759 }
3760
3761 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
3762 {
3763 /* It is not clear that allowing gaps in chainmask
3764 * is helpful. Probably it will not do what user
3765 * is hoping for, so warn in that case.
3766 */
3767 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
3768 return;
3769
3770 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
3771 dbg, cm);
3772 }
3773
3774 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
3775 {
3776 int nsts = ar->vht_cap_info;
3777
3778 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
3779 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
3780
3781 /* If firmware does not deliver to host number of space-time
3782 * streams supported, assume it support up to 4 BF STS and return
3783 * the value for VHT CAP: nsts-1)
3784 */
3785 if (nsts == 0)
3786 return 3;
3787
3788 return nsts;
3789 }
3790
3791 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
3792 {
3793 int sound_dim = ar->vht_cap_info;
3794
3795 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
3796 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
3797
3798 /* If the sounding dimension is not advertised by the firmware,
3799 * let's use a default value of 1
3800 */
3801 if (sound_dim == 0)
3802 return 1;
3803
3804 return sound_dim;
3805 }
3806
3807 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3808 {
3809 struct ieee80211_sta_vht_cap vht_cap = {0};
3810 u16 mcs_map;
3811 u32 val;
3812 int i;
3813
3814 vht_cap.vht_supported = 1;
3815 vht_cap.cap = ar->vht_cap_info;
3816
3817 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
3818 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
3819 val = ath10k_mac_get_vht_cap_bf_sts(ar);
3820 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
3821 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
3822
3823 vht_cap.cap |= val;
3824 }
3825
3826 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
3827 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
3828 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
3829 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
3830 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
3831
3832 vht_cap.cap |= val;
3833 }
3834
3835 mcs_map = 0;
3836 for (i = 0; i < 8; i++) {
3837 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))
3838 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
3839 else
3840 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
3841 }
3842
3843 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3844 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3845
3846 return vht_cap;
3847 }
3848
3849 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3850 {
3851 int i;
3852 struct ieee80211_sta_ht_cap ht_cap = {0};
3853
3854 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3855 return ht_cap;
3856
3857 ht_cap.ht_supported = 1;
3858 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3859 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3860 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3861 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3862 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
3863
3864 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3865 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3866
3867 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3868 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3869
3870 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3871 u32 smps;
3872
3873 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3874 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3875
3876 ht_cap.cap |= smps;
3877 }
3878
3879 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3880 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3881
3882 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3883 u32 stbc;
3884
3885 stbc = ar->ht_cap_info;
3886 stbc &= WMI_HT_CAP_RX_STBC;
3887 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3888 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3889 stbc &= IEEE80211_HT_CAP_RX_STBC;
3890
3891 ht_cap.cap |= stbc;
3892 }
3893
3894 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3895 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3896
3897 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3898 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3899
3900 /* max AMSDU is implicitly taken from vht_cap_info */
3901 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3902 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3903
3904 for (i = 0; i < ar->num_rf_chains; i++) {
3905 if (ar->cfg_rx_chainmask & BIT(i))
3906 ht_cap.mcs.rx_mask[i] = 0xFF;
3907 }
3908
3909 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3910
3911 return ht_cap;
3912 }
3913
3914 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
3915 {
3916 struct ieee80211_supported_band *band;
3917 struct ieee80211_sta_vht_cap vht_cap;
3918 struct ieee80211_sta_ht_cap ht_cap;
3919
3920 ht_cap = ath10k_get_ht_cap(ar);
3921 vht_cap = ath10k_create_vht_cap(ar);
3922
3923 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3924 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3925 band->ht_cap = ht_cap;
3926
3927 /* Enable the VHT support at 2.4 GHz */
3928 band->vht_cap = vht_cap;
3929 }
3930 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3931 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3932 band->ht_cap = ht_cap;
3933 band->vht_cap = vht_cap;
3934 }
3935 }
3936
3937 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
3938 {
3939 int ret;
3940
3941 lockdep_assert_held(&ar->conf_mutex);
3942
3943 ath10k_check_chain_mask(ar, tx_ant, "tx");
3944 ath10k_check_chain_mask(ar, rx_ant, "rx");
3945
3946 ar->cfg_tx_chainmask = tx_ant;
3947 ar->cfg_rx_chainmask = rx_ant;
3948
3949 if ((ar->state != ATH10K_STATE_ON) &&
3950 (ar->state != ATH10K_STATE_RESTARTED))
3951 return 0;
3952
3953 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
3954 tx_ant);
3955 if (ret) {
3956 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
3957 ret, tx_ant);
3958 return ret;
3959 }
3960
3961 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
3962 rx_ant);
3963 if (ret) {
3964 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
3965 ret, rx_ant);
3966 return ret;
3967 }
3968
3969 /* Reload HT/VHT capability */
3970 ath10k_mac_setup_ht_vht_cap(ar);
3971
3972 return 0;
3973 }
3974
3975 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
3976 {
3977 struct ath10k *ar = hw->priv;
3978 int ret;
3979
3980 mutex_lock(&ar->conf_mutex);
3981 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
3982 mutex_unlock(&ar->conf_mutex);
3983 return ret;
3984 }
3985
3986 static int ath10k_start(struct ieee80211_hw *hw)
3987 {
3988 struct ath10k *ar = hw->priv;
3989 u32 burst_enable;
3990 int ret = 0;
3991
3992 /*
3993 * This makes sense only when restarting hw. It is harmless to call
3994 * uncoditionally. This is necessary to make sure no HTT/WMI tx
3995 * commands will be submitted while restarting.
3996 */
3997 ath10k_drain_tx(ar);
3998
3999 mutex_lock(&ar->conf_mutex);
4000
4001 switch (ar->state) {
4002 case ATH10K_STATE_OFF:
4003 ar->state = ATH10K_STATE_ON;
4004 break;
4005 case ATH10K_STATE_RESTARTING:
4006 ath10k_halt(ar);
4007 ar->state = ATH10K_STATE_RESTARTED;
4008 break;
4009 case ATH10K_STATE_ON:
4010 case ATH10K_STATE_RESTARTED:
4011 case ATH10K_STATE_WEDGED:
4012 WARN_ON(1);
4013 ret = -EINVAL;
4014 goto err;
4015 case ATH10K_STATE_UTF:
4016 ret = -EBUSY;
4017 goto err;
4018 }
4019
4020 ret = ath10k_hif_power_up(ar);
4021 if (ret) {
4022 ath10k_err(ar, "Could not init hif: %d\n", ret);
4023 goto err_off;
4024 }
4025
4026 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
4027 if (ret) {
4028 ath10k_err(ar, "Could not init core: %d\n", ret);
4029 goto err_power_down;
4030 }
4031
4032 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
4033 if (ret) {
4034 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
4035 goto err_core_stop;
4036 }
4037
4038 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
4039 if (ret) {
4040 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
4041 goto err_core_stop;
4042 }
4043
4044 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
4045 ret = ath10k_wmi_adaptive_qcs(ar, true);
4046 if (ret) {
4047 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
4048 ret);
4049 goto err_core_stop;
4050 }
4051 }
4052
4053 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
4054 burst_enable = ar->wmi.pdev_param->burst_enable;
4055 ret = ath10k_wmi_pdev_set_param(ar, burst_enable, 0);
4056 if (ret) {
4057 ath10k_warn(ar, "failed to disable burst: %d\n", ret);
4058 goto err_core_stop;
4059 }
4060 }
4061
4062 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
4063
4064 /*
4065 * By default FW set ARP frames ac to voice (6). In that case ARP
4066 * exchange is not working properly for UAPSD enabled AP. ARP requests
4067 * which arrives with access category 0 are processed by network stack
4068 * and send back with access category 0, but FW changes access category
4069 * to 6. Set ARP frames access category to best effort (0) solves
4070 * this problem.
4071 */
4072
4073 ret = ath10k_wmi_pdev_set_param(ar,
4074 ar->wmi.pdev_param->arp_ac_override, 0);
4075 if (ret) {
4076 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
4077 ret);
4078 goto err_core_stop;
4079 }
4080
4081 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
4082 ar->fw_features)) {
4083 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
4084 WMI_CCA_DETECT_LEVEL_AUTO,
4085 WMI_CCA_DETECT_MARGIN_AUTO);
4086 if (ret) {
4087 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
4088 ret);
4089 goto err_core_stop;
4090 }
4091 }
4092
4093 ret = ath10k_wmi_pdev_set_param(ar,
4094 ar->wmi.pdev_param->ani_enable, 1);
4095 if (ret) {
4096 ath10k_warn(ar, "failed to enable ani by default: %d\n",
4097 ret);
4098 goto err_core_stop;
4099 }
4100
4101 ar->ani_enabled = true;
4102
4103 ar->num_started_vdevs = 0;
4104 ath10k_regd_update(ar);
4105
4106 ath10k_spectral_start(ar);
4107 ath10k_thermal_set_throttling(ar);
4108
4109 mutex_unlock(&ar->conf_mutex);
4110 return 0;
4111
4112 err_core_stop:
4113 ath10k_core_stop(ar);
4114
4115 err_power_down:
4116 ath10k_hif_power_down(ar);
4117
4118 err_off:
4119 ar->state = ATH10K_STATE_OFF;
4120
4121 err:
4122 mutex_unlock(&ar->conf_mutex);
4123 return ret;
4124 }
4125
4126 static void ath10k_stop(struct ieee80211_hw *hw)
4127 {
4128 struct ath10k *ar = hw->priv;
4129
4130 ath10k_drain_tx(ar);
4131
4132 mutex_lock(&ar->conf_mutex);
4133 if (ar->state != ATH10K_STATE_OFF) {
4134 ath10k_halt(ar);
4135 ar->state = ATH10K_STATE_OFF;
4136 }
4137 mutex_unlock(&ar->conf_mutex);
4138
4139 cancel_delayed_work_sync(&ar->scan.timeout);
4140 cancel_work_sync(&ar->restart_work);
4141 }
4142
4143 static int ath10k_config_ps(struct ath10k *ar)
4144 {
4145 struct ath10k_vif *arvif;
4146 int ret = 0;
4147
4148 lockdep_assert_held(&ar->conf_mutex);
4149
4150 list_for_each_entry(arvif, &ar->arvifs, list) {
4151 ret = ath10k_mac_vif_setup_ps(arvif);
4152 if (ret) {
4153 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
4154 break;
4155 }
4156 }
4157
4158 return ret;
4159 }
4160
4161 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
4162 {
4163 int ret;
4164 u32 param;
4165
4166 lockdep_assert_held(&ar->conf_mutex);
4167
4168 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
4169
4170 param = ar->wmi.pdev_param->txpower_limit2g;
4171 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4172 if (ret) {
4173 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
4174 txpower, ret);
4175 return ret;
4176 }
4177
4178 param = ar->wmi.pdev_param->txpower_limit5g;
4179 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4180 if (ret) {
4181 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
4182 txpower, ret);
4183 return ret;
4184 }
4185
4186 return 0;
4187 }
4188
4189 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4190 {
4191 struct ath10k_vif *arvif;
4192 int ret, txpower = -1;
4193
4194 lockdep_assert_held(&ar->conf_mutex);
4195
4196 list_for_each_entry(arvif, &ar->arvifs, list) {
4197 WARN_ON(arvif->txpower < 0);
4198
4199 if (txpower == -1)
4200 txpower = arvif->txpower;
4201 else
4202 txpower = min(txpower, arvif->txpower);
4203 }
4204
4205 if (WARN_ON(txpower == -1))
4206 return -EINVAL;
4207
4208 ret = ath10k_mac_txpower_setup(ar, txpower);
4209 if (ret) {
4210 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4211 txpower, ret);
4212 return ret;
4213 }
4214
4215 return 0;
4216 }
4217
4218 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4219 {
4220 struct ath10k *ar = hw->priv;
4221 struct ieee80211_conf *conf = &hw->conf;
4222 int ret = 0;
4223
4224 mutex_lock(&ar->conf_mutex);
4225
4226 if (changed & IEEE80211_CONF_CHANGE_PS)
4227 ath10k_config_ps(ar);
4228
4229 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4230 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4231 ret = ath10k_monitor_recalc(ar);
4232 if (ret)
4233 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4234 }
4235
4236 mutex_unlock(&ar->conf_mutex);
4237 return ret;
4238 }
4239
4240 static u32 get_nss_from_chainmask(u16 chain_mask)
4241 {
4242 if ((chain_mask & 0x15) == 0x15)
4243 return 4;
4244 else if ((chain_mask & 0x7) == 0x7)
4245 return 3;
4246 else if ((chain_mask & 0x3) == 0x3)
4247 return 2;
4248 return 1;
4249 }
4250
4251 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4252 {
4253 u32 value = 0;
4254 struct ath10k *ar = arvif->ar;
4255 int nsts;
4256 int sound_dim;
4257
4258 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4259 return 0;
4260
4261 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4262 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4263 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4264 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4265
4266 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4267 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4268 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4269 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4270
4271 if (!value)
4272 return 0;
4273
4274 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4275 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4276
4277 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4278 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4279 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4280
4281 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4282 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4283
4284 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4285 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4286 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4287
4288 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4289 ar->wmi.vdev_param->txbf, value);
4290 }
4291
4292 /*
4293 * TODO:
4294 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4295 * because we will send mgmt frames without CCK. This requirement
4296 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4297 * in the TX packet.
4298 */
4299 static int ath10k_add_interface(struct ieee80211_hw *hw,
4300 struct ieee80211_vif *vif)
4301 {
4302 struct ath10k *ar = hw->priv;
4303 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4304 enum wmi_sta_powersave_param param;
4305 int ret = 0;
4306 u32 value;
4307 int bit;
4308 int i;
4309 u32 vdev_param;
4310
4311 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4312
4313 mutex_lock(&ar->conf_mutex);
4314
4315 memset(arvif, 0, sizeof(*arvif));
4316
4317 arvif->ar = ar;
4318 arvif->vif = vif;
4319
4320 INIT_LIST_HEAD(&arvif->list);
4321 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4322 INIT_DELAYED_WORK(&arvif->connection_loss_work,
4323 ath10k_mac_vif_sta_connection_loss_work);
4324
4325 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4326 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4327 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4328 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4329 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4330 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4331 }
4332
4333 if (ar->num_peers >= ar->max_num_peers) {
4334 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4335 ret = -ENOBUFS;
4336 goto err;
4337 }
4338
4339 if (ar->free_vdev_map == 0) {
4340 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4341 ret = -EBUSY;
4342 goto err;
4343 }
4344 bit = __ffs64(ar->free_vdev_map);
4345
4346 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4347 bit, ar->free_vdev_map);
4348
4349 arvif->vdev_id = bit;
4350 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
4351
4352 switch (vif->type) {
4353 case NL80211_IFTYPE_P2P_DEVICE:
4354 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4355 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
4356 break;
4357 case NL80211_IFTYPE_UNSPECIFIED:
4358 case NL80211_IFTYPE_STATION:
4359 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4360 if (vif->p2p)
4361 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
4362 break;
4363 case NL80211_IFTYPE_ADHOC:
4364 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4365 break;
4366 case NL80211_IFTYPE_MESH_POINT:
4367 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4368 ret = -EINVAL;
4369 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
4370 goto err;
4371 }
4372 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4373 break;
4374 case NL80211_IFTYPE_AP:
4375 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4376
4377 if (vif->p2p)
4378 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
4379 break;
4380 case NL80211_IFTYPE_MONITOR:
4381 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4382 break;
4383 default:
4384 WARN_ON(1);
4385 break;
4386 }
4387
4388 /* Using vdev_id as queue number will make it very easy to do per-vif
4389 * tx queue locking. This shouldn't wrap due to interface combinations
4390 * but do a modulo for correctness sake and prevent using offchannel tx
4391 * queues for regular vif tx.
4392 */
4393 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4394 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4395 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4396
4397 /* Some firmware revisions don't wait for beacon tx completion before
4398 * sending another SWBA event. This could lead to hardware using old
4399 * (freed) beacon data in some cases, e.g. tx credit starvation
4400 * combined with missed TBTT. This is very very rare.
4401 *
4402 * On non-IOMMU-enabled hosts this could be a possible security issue
4403 * because hw could beacon some random data on the air. On
4404 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4405 * device would crash.
4406 *
4407 * Since there are no beacon tx completions (implicit nor explicit)
4408 * propagated to host the only workaround for this is to allocate a
4409 * DMA-coherent buffer for a lifetime of a vif and use it for all
4410 * beacon tx commands. Worst case for this approach is some beacons may
4411 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4412 */
4413 if (vif->type == NL80211_IFTYPE_ADHOC ||
4414 vif->type == NL80211_IFTYPE_MESH_POINT ||
4415 vif->type == NL80211_IFTYPE_AP) {
4416 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4417 IEEE80211_MAX_FRAME_LEN,
4418 &arvif->beacon_paddr,
4419 GFP_ATOMIC);
4420 if (!arvif->beacon_buf) {
4421 ret = -ENOMEM;
4422 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4423 ret);
4424 goto err;
4425 }
4426 }
4427 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4428 arvif->nohwcrypt = true;
4429
4430 if (arvif->nohwcrypt &&
4431 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4432 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4433 goto err;
4434 }
4435
4436 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4437 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4438 arvif->beacon_buf ? "single-buf" : "per-skb");
4439
4440 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4441 arvif->vdev_subtype, vif->addr);
4442 if (ret) {
4443 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4444 arvif->vdev_id, ret);
4445 goto err;
4446 }
4447
4448 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4449 list_add(&arvif->list, &ar->arvifs);
4450
4451 /* It makes no sense to have firmware do keepalives. mac80211 already
4452 * takes care of this with idle connection polling.
4453 */
4454 ret = ath10k_mac_vif_disable_keepalive(arvif);
4455 if (ret) {
4456 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4457 arvif->vdev_id, ret);
4458 goto err_vdev_delete;
4459 }
4460
4461 arvif->def_wep_key_idx = -1;
4462
4463 vdev_param = ar->wmi.vdev_param->tx_encap_type;
4464 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4465 ATH10K_HW_TXRX_NATIVE_WIFI);
4466 /* 10.X firmware does not support this VDEV parameter. Do not warn */
4467 if (ret && ret != -EOPNOTSUPP) {
4468 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4469 arvif->vdev_id, ret);
4470 goto err_vdev_delete;
4471 }
4472
4473 if (ar->cfg_tx_chainmask) {
4474 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4475
4476 vdev_param = ar->wmi.vdev_param->nss;
4477 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4478 nss);
4479 if (ret) {
4480 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4481 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4482 ret);
4483 goto err_vdev_delete;
4484 }
4485 }
4486
4487 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4488 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4489 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4490 WMI_PEER_TYPE_DEFAULT);
4491 if (ret) {
4492 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4493 arvif->vdev_id, ret);
4494 goto err_vdev_delete;
4495 }
4496 }
4497
4498 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4499 ret = ath10k_mac_set_kickout(arvif);
4500 if (ret) {
4501 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4502 arvif->vdev_id, ret);
4503 goto err_peer_delete;
4504 }
4505 }
4506
4507 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4508 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4509 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4510 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4511 param, value);
4512 if (ret) {
4513 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4514 arvif->vdev_id, ret);
4515 goto err_peer_delete;
4516 }
4517
4518 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4519 if (ret) {
4520 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4521 arvif->vdev_id, ret);
4522 goto err_peer_delete;
4523 }
4524
4525 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4526 if (ret) {
4527 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4528 arvif->vdev_id, ret);
4529 goto err_peer_delete;
4530 }
4531 }
4532
4533 ret = ath10k_mac_set_txbf_conf(arvif);
4534 if (ret) {
4535 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4536 arvif->vdev_id, ret);
4537 goto err_peer_delete;
4538 }
4539
4540 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4541 if (ret) {
4542 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4543 arvif->vdev_id, ret);
4544 goto err_peer_delete;
4545 }
4546
4547 arvif->txpower = vif->bss_conf.txpower;
4548 ret = ath10k_mac_txpower_recalc(ar);
4549 if (ret) {
4550 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4551 goto err_peer_delete;
4552 }
4553
4554 if (vif->type == NL80211_IFTYPE_MONITOR) {
4555 ar->monitor_arvif = arvif;
4556 ret = ath10k_monitor_recalc(ar);
4557 if (ret) {
4558 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4559 goto err_peer_delete;
4560 }
4561 }
4562
4563 spin_lock_bh(&ar->htt.tx_lock);
4564 if (!ar->tx_paused)
4565 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4566 spin_unlock_bh(&ar->htt.tx_lock);
4567
4568 mutex_unlock(&ar->conf_mutex);
4569 return 0;
4570
4571 err_peer_delete:
4572 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4573 arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4574 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4575
4576 err_vdev_delete:
4577 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4578 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4579 list_del(&arvif->list);
4580
4581 err:
4582 if (arvif->beacon_buf) {
4583 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4584 arvif->beacon_buf, arvif->beacon_paddr);
4585 arvif->beacon_buf = NULL;
4586 }
4587
4588 mutex_unlock(&ar->conf_mutex);
4589
4590 return ret;
4591 }
4592
4593 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4594 {
4595 int i;
4596
4597 for (i = 0; i < BITS_PER_LONG; i++)
4598 ath10k_mac_vif_tx_unlock(arvif, i);
4599 }
4600
4601 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4602 struct ieee80211_vif *vif)
4603 {
4604 struct ath10k *ar = hw->priv;
4605 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4606 int ret;
4607
4608 cancel_work_sync(&arvif->ap_csa_work);
4609 cancel_delayed_work_sync(&arvif->connection_loss_work);
4610
4611 mutex_lock(&ar->conf_mutex);
4612
4613 spin_lock_bh(&ar->data_lock);
4614 ath10k_mac_vif_beacon_cleanup(arvif);
4615 spin_unlock_bh(&ar->data_lock);
4616
4617 ret = ath10k_spectral_vif_stop(arvif);
4618 if (ret)
4619 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4620 arvif->vdev_id, ret);
4621
4622 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4623 list_del(&arvif->list);
4624
4625 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4626 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4627 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4628 vif->addr);
4629 if (ret)
4630 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4631 arvif->vdev_id, ret);
4632
4633 kfree(arvif->u.ap.noa_data);
4634 }
4635
4636 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4637 arvif->vdev_id);
4638
4639 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4640 if (ret)
4641 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4642 arvif->vdev_id, ret);
4643
4644 /* Some firmware revisions don't notify host about self-peer removal
4645 * until after associated vdev is deleted.
4646 */
4647 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4648 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4649 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4650 vif->addr);
4651 if (ret)
4652 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4653 arvif->vdev_id, ret);
4654
4655 spin_lock_bh(&ar->data_lock);
4656 ar->num_peers--;
4657 spin_unlock_bh(&ar->data_lock);
4658 }
4659
4660 ath10k_peer_cleanup(ar, arvif->vdev_id);
4661
4662 if (vif->type == NL80211_IFTYPE_MONITOR) {
4663 ar->monitor_arvif = NULL;
4664 ret = ath10k_monitor_recalc(ar);
4665 if (ret)
4666 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4667 }
4668
4669 spin_lock_bh(&ar->htt.tx_lock);
4670 ath10k_mac_vif_tx_unlock_all(arvif);
4671 spin_unlock_bh(&ar->htt.tx_lock);
4672
4673 mutex_unlock(&ar->conf_mutex);
4674 }
4675
4676 /*
4677 * FIXME: Has to be verified.
4678 */
4679 #define SUPPORTED_FILTERS \
4680 (FIF_ALLMULTI | \
4681 FIF_CONTROL | \
4682 FIF_PSPOLL | \
4683 FIF_OTHER_BSS | \
4684 FIF_BCN_PRBRESP_PROMISC | \
4685 FIF_PROBE_REQ | \
4686 FIF_FCSFAIL)
4687
4688 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4689 unsigned int changed_flags,
4690 unsigned int *total_flags,
4691 u64 multicast)
4692 {
4693 struct ath10k *ar = hw->priv;
4694 int ret;
4695
4696 mutex_lock(&ar->conf_mutex);
4697
4698 changed_flags &= SUPPORTED_FILTERS;
4699 *total_flags &= SUPPORTED_FILTERS;
4700 ar->filter_flags = *total_flags;
4701
4702 ret = ath10k_monitor_recalc(ar);
4703 if (ret)
4704 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4705
4706 mutex_unlock(&ar->conf_mutex);
4707 }
4708
4709 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4710 struct ieee80211_vif *vif,
4711 struct ieee80211_bss_conf *info,
4712 u32 changed)
4713 {
4714 struct ath10k *ar = hw->priv;
4715 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4716 int ret = 0;
4717 u32 vdev_param, pdev_param, slottime, preamble;
4718
4719 mutex_lock(&ar->conf_mutex);
4720
4721 if (changed & BSS_CHANGED_IBSS)
4722 ath10k_control_ibss(arvif, info, vif->addr);
4723
4724 if (changed & BSS_CHANGED_BEACON_INT) {
4725 arvif->beacon_interval = info->beacon_int;
4726 vdev_param = ar->wmi.vdev_param->beacon_interval;
4727 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4728 arvif->beacon_interval);
4729 ath10k_dbg(ar, ATH10K_DBG_MAC,
4730 "mac vdev %d beacon_interval %d\n",
4731 arvif->vdev_id, arvif->beacon_interval);
4732
4733 if (ret)
4734 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4735 arvif->vdev_id, ret);
4736 }
4737
4738 if (changed & BSS_CHANGED_BEACON) {
4739 ath10k_dbg(ar, ATH10K_DBG_MAC,
4740 "vdev %d set beacon tx mode to staggered\n",
4741 arvif->vdev_id);
4742
4743 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4744 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4745 WMI_BEACON_STAGGERED_MODE);
4746 if (ret)
4747 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4748 arvif->vdev_id, ret);
4749
4750 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4751 if (ret)
4752 ath10k_warn(ar, "failed to update beacon template: %d\n",
4753 ret);
4754
4755 if (ieee80211_vif_is_mesh(vif)) {
4756 /* mesh doesn't use SSID but firmware needs it */
4757 strncpy(arvif->u.ap.ssid, "mesh",
4758 sizeof(arvif->u.ap.ssid));
4759 arvif->u.ap.ssid_len = 4;
4760 }
4761 }
4762
4763 if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4764 ret = ath10k_mac_setup_prb_tmpl(arvif);
4765 if (ret)
4766 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4767 arvif->vdev_id, ret);
4768 }
4769
4770 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4771 arvif->dtim_period = info->dtim_period;
4772
4773 ath10k_dbg(ar, ATH10K_DBG_MAC,
4774 "mac vdev %d dtim_period %d\n",
4775 arvif->vdev_id, arvif->dtim_period);
4776
4777 vdev_param = ar->wmi.vdev_param->dtim_period;
4778 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4779 arvif->dtim_period);
4780 if (ret)
4781 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4782 arvif->vdev_id, ret);
4783 }
4784
4785 if (changed & BSS_CHANGED_SSID &&
4786 vif->type == NL80211_IFTYPE_AP) {
4787 arvif->u.ap.ssid_len = info->ssid_len;
4788 if (info->ssid_len)
4789 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4790 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4791 }
4792
4793 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4794 ether_addr_copy(arvif->bssid, info->bssid);
4795
4796 if (changed & BSS_CHANGED_BEACON_ENABLED)
4797 ath10k_control_beaconing(arvif, info);
4798
4799 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4800 arvif->use_cts_prot = info->use_cts_prot;
4801 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4802 arvif->vdev_id, info->use_cts_prot);
4803
4804 ret = ath10k_recalc_rtscts_prot(arvif);
4805 if (ret)
4806 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4807 arvif->vdev_id, ret);
4808
4809 vdev_param = ar->wmi.vdev_param->protection_mode;
4810 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4811 info->use_cts_prot ? 1 : 0);
4812 if (ret)
4813 ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4814 info->use_cts_prot, arvif->vdev_id, ret);
4815 }
4816
4817 if (changed & BSS_CHANGED_ERP_SLOT) {
4818 if (info->use_short_slot)
4819 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4820
4821 else
4822 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4823
4824 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4825 arvif->vdev_id, slottime);
4826
4827 vdev_param = ar->wmi.vdev_param->slot_time;
4828 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4829 slottime);
4830 if (ret)
4831 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4832 arvif->vdev_id, ret);
4833 }
4834
4835 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4836 if (info->use_short_preamble)
4837 preamble = WMI_VDEV_PREAMBLE_SHORT;
4838 else
4839 preamble = WMI_VDEV_PREAMBLE_LONG;
4840
4841 ath10k_dbg(ar, ATH10K_DBG_MAC,
4842 "mac vdev %d preamble %dn",
4843 arvif->vdev_id, preamble);
4844
4845 vdev_param = ar->wmi.vdev_param->preamble;
4846 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4847 preamble);
4848 if (ret)
4849 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4850 arvif->vdev_id, ret);
4851 }
4852
4853 if (changed & BSS_CHANGED_ASSOC) {
4854 if (info->assoc) {
4855 /* Workaround: Make sure monitor vdev is not running
4856 * when associating to prevent some firmware revisions
4857 * (e.g. 10.1 and 10.2) from crashing.
4858 */
4859 if (ar->monitor_started)
4860 ath10k_monitor_stop(ar);
4861 ath10k_bss_assoc(hw, vif, info);
4862 ath10k_monitor_recalc(ar);
4863 } else {
4864 ath10k_bss_disassoc(hw, vif);
4865 }
4866 }
4867
4868 if (changed & BSS_CHANGED_TXPOWER) {
4869 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4870 arvif->vdev_id, info->txpower);
4871
4872 arvif->txpower = info->txpower;
4873 ret = ath10k_mac_txpower_recalc(ar);
4874 if (ret)
4875 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4876 }
4877
4878 if (changed & BSS_CHANGED_PS) {
4879 arvif->ps = vif->bss_conf.ps;
4880
4881 ret = ath10k_config_ps(ar);
4882 if (ret)
4883 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4884 arvif->vdev_id, ret);
4885 }
4886
4887 mutex_unlock(&ar->conf_mutex);
4888 }
4889
4890 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4891 struct ieee80211_vif *vif,
4892 struct ieee80211_scan_request *hw_req)
4893 {
4894 struct ath10k *ar = hw->priv;
4895 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4896 struct cfg80211_scan_request *req = &hw_req->req;
4897 struct wmi_start_scan_arg arg;
4898 int ret = 0;
4899 int i;
4900
4901 mutex_lock(&ar->conf_mutex);
4902
4903 spin_lock_bh(&ar->data_lock);
4904 switch (ar->scan.state) {
4905 case ATH10K_SCAN_IDLE:
4906 reinit_completion(&ar->scan.started);
4907 reinit_completion(&ar->scan.completed);
4908 ar->scan.state = ATH10K_SCAN_STARTING;
4909 ar->scan.is_roc = false;
4910 ar->scan.vdev_id = arvif->vdev_id;
4911 ret = 0;
4912 break;
4913 case ATH10K_SCAN_STARTING:
4914 case ATH10K_SCAN_RUNNING:
4915 case ATH10K_SCAN_ABORTING:
4916 ret = -EBUSY;
4917 break;
4918 }
4919 spin_unlock_bh(&ar->data_lock);
4920
4921 if (ret)
4922 goto exit;
4923
4924 memset(&arg, 0, sizeof(arg));
4925 ath10k_wmi_start_scan_init(ar, &arg);
4926 arg.vdev_id = arvif->vdev_id;
4927 arg.scan_id = ATH10K_SCAN_ID;
4928
4929 if (req->ie_len) {
4930 arg.ie_len = req->ie_len;
4931 memcpy(arg.ie, req->ie, arg.ie_len);
4932 }
4933
4934 if (req->n_ssids) {
4935 arg.n_ssids = req->n_ssids;
4936 for (i = 0; i < arg.n_ssids; i++) {
4937 arg.ssids[i].len = req->ssids[i].ssid_len;
4938 arg.ssids[i].ssid = req->ssids[i].ssid;
4939 }
4940 } else {
4941 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4942 }
4943
4944 if (req->n_channels) {
4945 arg.n_channels = req->n_channels;
4946 for (i = 0; i < arg.n_channels; i++)
4947 arg.channels[i] = req->channels[i]->center_freq;
4948 }
4949
4950 ret = ath10k_start_scan(ar, &arg);
4951 if (ret) {
4952 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4953 spin_lock_bh(&ar->data_lock);
4954 ar->scan.state = ATH10K_SCAN_IDLE;
4955 spin_unlock_bh(&ar->data_lock);
4956 }
4957
4958 /* Add a 200ms margin to account for event/command processing */
4959 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4960 msecs_to_jiffies(arg.max_scan_time +
4961 200));
4962
4963 exit:
4964 mutex_unlock(&ar->conf_mutex);
4965 return ret;
4966 }
4967
4968 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4969 struct ieee80211_vif *vif)
4970 {
4971 struct ath10k *ar = hw->priv;
4972
4973 mutex_lock(&ar->conf_mutex);
4974 ath10k_scan_abort(ar);
4975 mutex_unlock(&ar->conf_mutex);
4976
4977 cancel_delayed_work_sync(&ar->scan.timeout);
4978 }
4979
4980 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4981 struct ath10k_vif *arvif,
4982 enum set_key_cmd cmd,
4983 struct ieee80211_key_conf *key)
4984 {
4985 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
4986 int ret;
4987
4988 /* 10.1 firmware branch requires default key index to be set to group
4989 * key index after installing it. Otherwise FW/HW Txes corrupted
4990 * frames with multi-vif APs. This is not required for main firmware
4991 * branch (e.g. 636).
4992 *
4993 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4994 *
4995 * FIXME: It remains unknown if this is required for multi-vif STA
4996 * interfaces on 10.1.
4997 */
4998
4999 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
5000 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
5001 return;
5002
5003 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
5004 return;
5005
5006 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
5007 return;
5008
5009 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5010 return;
5011
5012 if (cmd != SET_KEY)
5013 return;
5014
5015 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5016 key->keyidx);
5017 if (ret)
5018 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
5019 arvif->vdev_id, ret);
5020 }
5021
5022 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5023 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
5024 struct ieee80211_key_conf *key)
5025 {
5026 struct ath10k *ar = hw->priv;
5027 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5028 struct ath10k_peer *peer;
5029 const u8 *peer_addr;
5030 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5031 key->cipher == WLAN_CIPHER_SUITE_WEP104;
5032 int ret = 0;
5033 int ret2;
5034 u32 flags = 0;
5035 u32 flags2;
5036
5037 /* this one needs to be done in software */
5038 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
5039 return 1;
5040
5041 if (arvif->nohwcrypt)
5042 return 1;
5043
5044 if (key->keyidx > WMI_MAX_KEY_INDEX)
5045 return -ENOSPC;
5046
5047 mutex_lock(&ar->conf_mutex);
5048
5049 if (sta)
5050 peer_addr = sta->addr;
5051 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
5052 peer_addr = vif->bss_conf.bssid;
5053 else
5054 peer_addr = vif->addr;
5055
5056 key->hw_key_idx = key->keyidx;
5057
5058 if (is_wep) {
5059 if (cmd == SET_KEY)
5060 arvif->wep_keys[key->keyidx] = key;
5061 else
5062 arvif->wep_keys[key->keyidx] = NULL;
5063 }
5064
5065 /* the peer should not disappear in mid-way (unless FW goes awry) since
5066 * we already hold conf_mutex. we just make sure its there now. */
5067 spin_lock_bh(&ar->data_lock);
5068 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5069 spin_unlock_bh(&ar->data_lock);
5070
5071 if (!peer) {
5072 if (cmd == SET_KEY) {
5073 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5074 peer_addr);
5075 ret = -EOPNOTSUPP;
5076 goto exit;
5077 } else {
5078 /* if the peer doesn't exist there is no key to disable
5079 * anymore */
5080 goto exit;
5081 }
5082 }
5083
5084 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5085 flags |= WMI_KEY_PAIRWISE;
5086 else
5087 flags |= WMI_KEY_GROUP;
5088
5089 if (is_wep) {
5090 if (cmd == DISABLE_KEY)
5091 ath10k_clear_vdev_key(arvif, key);
5092
5093 /* When WEP keys are uploaded it's possible that there are
5094 * stations associated already (e.g. when merging) without any
5095 * keys. Static WEP needs an explicit per-peer key upload.
5096 */
5097 if (vif->type == NL80211_IFTYPE_ADHOC &&
5098 cmd == SET_KEY)
5099 ath10k_mac_vif_update_wep_key(arvif, key);
5100
5101 /* 802.1x never sets the def_wep_key_idx so each set_key()
5102 * call changes default tx key.
5103 *
5104 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5105 * after first set_key().
5106 */
5107 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
5108 flags |= WMI_KEY_TX_USAGE;
5109 }
5110
5111 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
5112 if (ret) {
5113 WARN_ON(ret > 0);
5114 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
5115 arvif->vdev_id, peer_addr, ret);
5116 goto exit;
5117 }
5118
5119 /* mac80211 sets static WEP keys as groupwise while firmware requires
5120 * them to be installed twice as both pairwise and groupwise.
5121 */
5122 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
5123 flags2 = flags;
5124 flags2 &= ~WMI_KEY_GROUP;
5125 flags2 |= WMI_KEY_PAIRWISE;
5126
5127 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
5128 if (ret) {
5129 WARN_ON(ret > 0);
5130 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5131 arvif->vdev_id, peer_addr, ret);
5132 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
5133 peer_addr, flags);
5134 if (ret2) {
5135 WARN_ON(ret2 > 0);
5136 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5137 arvif->vdev_id, peer_addr, ret2);
5138 }
5139 goto exit;
5140 }
5141 }
5142
5143 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5144
5145 spin_lock_bh(&ar->data_lock);
5146 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5147 if (peer && cmd == SET_KEY)
5148 peer->keys[key->keyidx] = key;
5149 else if (peer && cmd == DISABLE_KEY)
5150 peer->keys[key->keyidx] = NULL;
5151 else if (peer == NULL)
5152 /* impossible unless FW goes crazy */
5153 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5154 spin_unlock_bh(&ar->data_lock);
5155
5156 exit:
5157 mutex_unlock(&ar->conf_mutex);
5158 return ret;
5159 }
5160
5161 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5162 struct ieee80211_vif *vif,
5163 int keyidx)
5164 {
5165 struct ath10k *ar = hw->priv;
5166 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5167 int ret;
5168
5169 mutex_lock(&arvif->ar->conf_mutex);
5170
5171 if (arvif->ar->state != ATH10K_STATE_ON)
5172 goto unlock;
5173
5174 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5175 arvif->vdev_id, keyidx);
5176
5177 ret = ath10k_wmi_vdev_set_param(arvif->ar,
5178 arvif->vdev_id,
5179 arvif->ar->wmi.vdev_param->def_keyid,
5180 keyidx);
5181
5182 if (ret) {
5183 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5184 arvif->vdev_id,
5185 ret);
5186 goto unlock;
5187 }
5188
5189 arvif->def_wep_key_idx = keyidx;
5190
5191 unlock:
5192 mutex_unlock(&arvif->ar->conf_mutex);
5193 }
5194
5195 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5196 {
5197 struct ath10k *ar;
5198 struct ath10k_vif *arvif;
5199 struct ath10k_sta *arsta;
5200 struct ieee80211_sta *sta;
5201 struct cfg80211_chan_def def;
5202 enum ieee80211_band band;
5203 const u8 *ht_mcs_mask;
5204 const u16 *vht_mcs_mask;
5205 u32 changed, bw, nss, smps;
5206 int err;
5207
5208 arsta = container_of(wk, struct ath10k_sta, update_wk);
5209 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5210 arvif = arsta->arvif;
5211 ar = arvif->ar;
5212
5213 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5214 return;
5215
5216 band = def.chan->band;
5217 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5218 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5219
5220 spin_lock_bh(&ar->data_lock);
5221
5222 changed = arsta->changed;
5223 arsta->changed = 0;
5224
5225 bw = arsta->bw;
5226 nss = arsta->nss;
5227 smps = arsta->smps;
5228
5229 spin_unlock_bh(&ar->data_lock);
5230
5231 mutex_lock(&ar->conf_mutex);
5232
5233 nss = max_t(u32, 1, nss);
5234 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5235 ath10k_mac_max_vht_nss(vht_mcs_mask)));
5236
5237 if (changed & IEEE80211_RC_BW_CHANGED) {
5238 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5239 sta->addr, bw);
5240
5241 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5242 WMI_PEER_CHAN_WIDTH, bw);
5243 if (err)
5244 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5245 sta->addr, bw, err);
5246 }
5247
5248 if (changed & IEEE80211_RC_NSS_CHANGED) {
5249 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5250 sta->addr, nss);
5251
5252 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5253 WMI_PEER_NSS, nss);
5254 if (err)
5255 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5256 sta->addr, nss, err);
5257 }
5258
5259 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5260 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5261 sta->addr, smps);
5262
5263 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5264 WMI_PEER_SMPS_STATE, smps);
5265 if (err)
5266 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5267 sta->addr, smps, err);
5268 }
5269
5270 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5271 changed & IEEE80211_RC_NSS_CHANGED) {
5272 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5273 sta->addr);
5274
5275 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5276 if (err)
5277 ath10k_warn(ar, "failed to reassociate station: %pM\n",
5278 sta->addr);
5279 }
5280
5281 mutex_unlock(&ar->conf_mutex);
5282 }
5283
5284 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5285 struct ieee80211_sta *sta)
5286 {
5287 struct ath10k *ar = arvif->ar;
5288
5289 lockdep_assert_held(&ar->conf_mutex);
5290
5291 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5292 return 0;
5293
5294 if (ar->num_stations >= ar->max_num_stations)
5295 return -ENOBUFS;
5296
5297 ar->num_stations++;
5298
5299 return 0;
5300 }
5301
5302 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5303 struct ieee80211_sta *sta)
5304 {
5305 struct ath10k *ar = arvif->ar;
5306
5307 lockdep_assert_held(&ar->conf_mutex);
5308
5309 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5310 return;
5311
5312 ar->num_stations--;
5313 }
5314
5315 struct ath10k_mac_tdls_iter_data {
5316 u32 num_tdls_stations;
5317 struct ieee80211_vif *curr_vif;
5318 };
5319
5320 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5321 struct ieee80211_sta *sta)
5322 {
5323 struct ath10k_mac_tdls_iter_data *iter_data = data;
5324 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5325 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5326
5327 if (sta->tdls && sta_vif == iter_data->curr_vif)
5328 iter_data->num_tdls_stations++;
5329 }
5330
5331 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5332 struct ieee80211_vif *vif)
5333 {
5334 struct ath10k_mac_tdls_iter_data data = {};
5335
5336 data.curr_vif = vif;
5337
5338 ieee80211_iterate_stations_atomic(hw,
5339 ath10k_mac_tdls_vif_stations_count_iter,
5340 &data);
5341 return data.num_tdls_stations;
5342 }
5343
5344 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5345 struct ieee80211_vif *vif)
5346 {
5347 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5348 int *num_tdls_vifs = data;
5349
5350 if (vif->type != NL80211_IFTYPE_STATION)
5351 return;
5352
5353 if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5354 (*num_tdls_vifs)++;
5355 }
5356
5357 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5358 {
5359 int num_tdls_vifs = 0;
5360
5361 ieee80211_iterate_active_interfaces_atomic(hw,
5362 IEEE80211_IFACE_ITER_NORMAL,
5363 ath10k_mac_tdls_vifs_count_iter,
5364 &num_tdls_vifs);
5365 return num_tdls_vifs;
5366 }
5367
5368 static int ath10k_sta_state(struct ieee80211_hw *hw,
5369 struct ieee80211_vif *vif,
5370 struct ieee80211_sta *sta,
5371 enum ieee80211_sta_state old_state,
5372 enum ieee80211_sta_state new_state)
5373 {
5374 struct ath10k *ar = hw->priv;
5375 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5376 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5377 int ret = 0;
5378
5379 if (old_state == IEEE80211_STA_NOTEXIST &&
5380 new_state == IEEE80211_STA_NONE) {
5381 memset(arsta, 0, sizeof(*arsta));
5382 arsta->arvif = arvif;
5383 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5384 }
5385
5386 /* cancel must be done outside the mutex to avoid deadlock */
5387 if ((old_state == IEEE80211_STA_NONE &&
5388 new_state == IEEE80211_STA_NOTEXIST))
5389 cancel_work_sync(&arsta->update_wk);
5390
5391 mutex_lock(&ar->conf_mutex);
5392
5393 if (old_state == IEEE80211_STA_NOTEXIST &&
5394 new_state == IEEE80211_STA_NONE) {
5395 /*
5396 * New station addition.
5397 */
5398 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5399 u32 num_tdls_stations;
5400 u32 num_tdls_vifs;
5401
5402 ath10k_dbg(ar, ATH10K_DBG_MAC,
5403 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5404 arvif->vdev_id, sta->addr,
5405 ar->num_stations + 1, ar->max_num_stations,
5406 ar->num_peers + 1, ar->max_num_peers);
5407
5408 ret = ath10k_mac_inc_num_stations(arvif, sta);
5409 if (ret) {
5410 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5411 ar->max_num_stations);
5412 goto exit;
5413 }
5414
5415 if (sta->tdls)
5416 peer_type = WMI_PEER_TYPE_TDLS;
5417
5418 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5419 peer_type);
5420 if (ret) {
5421 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5422 sta->addr, arvif->vdev_id, ret);
5423 ath10k_mac_dec_num_stations(arvif, sta);
5424 goto exit;
5425 }
5426
5427 if (!sta->tdls)
5428 goto exit;
5429
5430 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5431 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5432
5433 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5434 num_tdls_stations == 0) {
5435 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5436 arvif->vdev_id, ar->max_num_tdls_vdevs);
5437 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5438 ath10k_mac_dec_num_stations(arvif, sta);
5439 ret = -ENOBUFS;
5440 goto exit;
5441 }
5442
5443 if (num_tdls_stations == 0) {
5444 /* This is the first tdls peer in current vif */
5445 enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5446
5447 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5448 state);
5449 if (ret) {
5450 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5451 arvif->vdev_id, ret);
5452 ath10k_peer_delete(ar, arvif->vdev_id,
5453 sta->addr);
5454 ath10k_mac_dec_num_stations(arvif, sta);
5455 goto exit;
5456 }
5457 }
5458
5459 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5460 WMI_TDLS_PEER_STATE_PEERING);
5461 if (ret) {
5462 ath10k_warn(ar,
5463 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5464 sta->addr, arvif->vdev_id, ret);
5465 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5466 ath10k_mac_dec_num_stations(arvif, sta);
5467
5468 if (num_tdls_stations != 0)
5469 goto exit;
5470 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5471 WMI_TDLS_DISABLE);
5472 }
5473 } else if ((old_state == IEEE80211_STA_NONE &&
5474 new_state == IEEE80211_STA_NOTEXIST)) {
5475 /*
5476 * Existing station deletion.
5477 */
5478 ath10k_dbg(ar, ATH10K_DBG_MAC,
5479 "mac vdev %d peer delete %pM (sta gone)\n",
5480 arvif->vdev_id, sta->addr);
5481
5482 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5483 if (ret)
5484 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5485 sta->addr, arvif->vdev_id, ret);
5486
5487 ath10k_mac_dec_num_stations(arvif, sta);
5488
5489 if (!sta->tdls)
5490 goto exit;
5491
5492 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5493 goto exit;
5494
5495 /* This was the last tdls peer in current vif */
5496 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5497 WMI_TDLS_DISABLE);
5498 if (ret) {
5499 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5500 arvif->vdev_id, ret);
5501 }
5502 } else if (old_state == IEEE80211_STA_AUTH &&
5503 new_state == IEEE80211_STA_ASSOC &&
5504 (vif->type == NL80211_IFTYPE_AP ||
5505 vif->type == NL80211_IFTYPE_MESH_POINT ||
5506 vif->type == NL80211_IFTYPE_ADHOC)) {
5507 /*
5508 * New association.
5509 */
5510 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5511 sta->addr);
5512
5513 ret = ath10k_station_assoc(ar, vif, sta, false);
5514 if (ret)
5515 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5516 sta->addr, arvif->vdev_id, ret);
5517 } else if (old_state == IEEE80211_STA_ASSOC &&
5518 new_state == IEEE80211_STA_AUTHORIZED &&
5519 sta->tdls) {
5520 /*
5521 * Tdls station authorized.
5522 */
5523 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5524 sta->addr);
5525
5526 ret = ath10k_station_assoc(ar, vif, sta, false);
5527 if (ret) {
5528 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5529 sta->addr, arvif->vdev_id, ret);
5530 goto exit;
5531 }
5532
5533 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5534 WMI_TDLS_PEER_STATE_CONNECTED);
5535 if (ret)
5536 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5537 sta->addr, arvif->vdev_id, ret);
5538 } else if (old_state == IEEE80211_STA_ASSOC &&
5539 new_state == IEEE80211_STA_AUTH &&
5540 (vif->type == NL80211_IFTYPE_AP ||
5541 vif->type == NL80211_IFTYPE_MESH_POINT ||
5542 vif->type == NL80211_IFTYPE_ADHOC)) {
5543 /*
5544 * Disassociation.
5545 */
5546 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5547 sta->addr);
5548
5549 ret = ath10k_station_disassoc(ar, vif, sta);
5550 if (ret)
5551 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5552 sta->addr, arvif->vdev_id, ret);
5553 }
5554 exit:
5555 mutex_unlock(&ar->conf_mutex);
5556 return ret;
5557 }
5558
5559 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5560 u16 ac, bool enable)
5561 {
5562 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5563 struct wmi_sta_uapsd_auto_trig_arg arg = {};
5564 u32 prio = 0, acc = 0;
5565 u32 value = 0;
5566 int ret = 0;
5567
5568 lockdep_assert_held(&ar->conf_mutex);
5569
5570 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5571 return 0;
5572
5573 switch (ac) {
5574 case IEEE80211_AC_VO:
5575 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5576 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5577 prio = 7;
5578 acc = 3;
5579 break;
5580 case IEEE80211_AC_VI:
5581 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5582 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5583 prio = 5;
5584 acc = 2;
5585 break;
5586 case IEEE80211_AC_BE:
5587 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5588 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5589 prio = 2;
5590 acc = 1;
5591 break;
5592 case IEEE80211_AC_BK:
5593 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5594 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5595 prio = 0;
5596 acc = 0;
5597 break;
5598 }
5599
5600 if (enable)
5601 arvif->u.sta.uapsd |= value;
5602 else
5603 arvif->u.sta.uapsd &= ~value;
5604
5605 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5606 WMI_STA_PS_PARAM_UAPSD,
5607 arvif->u.sta.uapsd);
5608 if (ret) {
5609 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5610 goto exit;
5611 }
5612
5613 if (arvif->u.sta.uapsd)
5614 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5615 else
5616 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5617
5618 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5619 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5620 value);
5621 if (ret)
5622 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5623
5624 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5625 if (ret) {
5626 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5627 arvif->vdev_id, ret);
5628 return ret;
5629 }
5630
5631 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5632 if (ret) {
5633 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5634 arvif->vdev_id, ret);
5635 return ret;
5636 }
5637
5638 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5639 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5640 /* Only userspace can make an educated decision when to send
5641 * trigger frame. The following effectively disables u-UAPSD
5642 * autotrigger in firmware (which is enabled by default
5643 * provided the autotrigger service is available).
5644 */
5645
5646 arg.wmm_ac = acc;
5647 arg.user_priority = prio;
5648 arg.service_interval = 0;
5649 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5650 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5651
5652 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5653 arvif->bssid, &arg, 1);
5654 if (ret) {
5655 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5656 ret);
5657 return ret;
5658 }
5659 }
5660
5661 exit:
5662 return ret;
5663 }
5664
5665 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5666 struct ieee80211_vif *vif, u16 ac,
5667 const struct ieee80211_tx_queue_params *params)
5668 {
5669 struct ath10k *ar = hw->priv;
5670 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5671 struct wmi_wmm_params_arg *p = NULL;
5672 int ret;
5673
5674 mutex_lock(&ar->conf_mutex);
5675
5676 switch (ac) {
5677 case IEEE80211_AC_VO:
5678 p = &arvif->wmm_params.ac_vo;
5679 break;
5680 case IEEE80211_AC_VI:
5681 p = &arvif->wmm_params.ac_vi;
5682 break;
5683 case IEEE80211_AC_BE:
5684 p = &arvif->wmm_params.ac_be;
5685 break;
5686 case IEEE80211_AC_BK:
5687 p = &arvif->wmm_params.ac_bk;
5688 break;
5689 }
5690
5691 if (WARN_ON(!p)) {
5692 ret = -EINVAL;
5693 goto exit;
5694 }
5695
5696 p->cwmin = params->cw_min;
5697 p->cwmax = params->cw_max;
5698 p->aifs = params->aifs;
5699
5700 /*
5701 * The channel time duration programmed in the HW is in absolute
5702 * microseconds, while mac80211 gives the txop in units of
5703 * 32 microseconds.
5704 */
5705 p->txop = params->txop * 32;
5706
5707 if (ar->wmi.ops->gen_vdev_wmm_conf) {
5708 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5709 &arvif->wmm_params);
5710 if (ret) {
5711 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5712 arvif->vdev_id, ret);
5713 goto exit;
5714 }
5715 } else {
5716 /* This won't work well with multi-interface cases but it's
5717 * better than nothing.
5718 */
5719 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5720 if (ret) {
5721 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5722 goto exit;
5723 }
5724 }
5725
5726 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5727 if (ret)
5728 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5729
5730 exit:
5731 mutex_unlock(&ar->conf_mutex);
5732 return ret;
5733 }
5734
5735 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5736
5737 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5738 struct ieee80211_vif *vif,
5739 struct ieee80211_channel *chan,
5740 int duration,
5741 enum ieee80211_roc_type type)
5742 {
5743 struct ath10k *ar = hw->priv;
5744 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5745 struct wmi_start_scan_arg arg;
5746 int ret = 0;
5747 u32 scan_time_msec;
5748
5749 mutex_lock(&ar->conf_mutex);
5750
5751 spin_lock_bh(&ar->data_lock);
5752 switch (ar->scan.state) {
5753 case ATH10K_SCAN_IDLE:
5754 reinit_completion(&ar->scan.started);
5755 reinit_completion(&ar->scan.completed);
5756 reinit_completion(&ar->scan.on_channel);
5757 ar->scan.state = ATH10K_SCAN_STARTING;
5758 ar->scan.is_roc = true;
5759 ar->scan.vdev_id = arvif->vdev_id;
5760 ar->scan.roc_freq = chan->center_freq;
5761 ar->scan.roc_notify = true;
5762 ret = 0;
5763 break;
5764 case ATH10K_SCAN_STARTING:
5765 case ATH10K_SCAN_RUNNING:
5766 case ATH10K_SCAN_ABORTING:
5767 ret = -EBUSY;
5768 break;
5769 }
5770 spin_unlock_bh(&ar->data_lock);
5771
5772 if (ret)
5773 goto exit;
5774
5775 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5776
5777 memset(&arg, 0, sizeof(arg));
5778 ath10k_wmi_start_scan_init(ar, &arg);
5779 arg.vdev_id = arvif->vdev_id;
5780 arg.scan_id = ATH10K_SCAN_ID;
5781 arg.n_channels = 1;
5782 arg.channels[0] = chan->center_freq;
5783 arg.dwell_time_active = scan_time_msec;
5784 arg.dwell_time_passive = scan_time_msec;
5785 arg.max_scan_time = scan_time_msec;
5786 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5787 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5788 arg.burst_duration_ms = duration;
5789
5790 ret = ath10k_start_scan(ar, &arg);
5791 if (ret) {
5792 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5793 spin_lock_bh(&ar->data_lock);
5794 ar->scan.state = ATH10K_SCAN_IDLE;
5795 spin_unlock_bh(&ar->data_lock);
5796 goto exit;
5797 }
5798
5799 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5800 if (ret == 0) {
5801 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5802
5803 ret = ath10k_scan_stop(ar);
5804 if (ret)
5805 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5806
5807 ret = -ETIMEDOUT;
5808 goto exit;
5809 }
5810
5811 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5812 msecs_to_jiffies(duration));
5813
5814 ret = 0;
5815 exit:
5816 mutex_unlock(&ar->conf_mutex);
5817 return ret;
5818 }
5819
5820 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5821 {
5822 struct ath10k *ar = hw->priv;
5823
5824 mutex_lock(&ar->conf_mutex);
5825
5826 spin_lock_bh(&ar->data_lock);
5827 ar->scan.roc_notify = false;
5828 spin_unlock_bh(&ar->data_lock);
5829
5830 ath10k_scan_abort(ar);
5831
5832 mutex_unlock(&ar->conf_mutex);
5833
5834 cancel_delayed_work_sync(&ar->scan.timeout);
5835
5836 return 0;
5837 }
5838
5839 /*
5840 * Both RTS and Fragmentation threshold are interface-specific
5841 * in ath10k, but device-specific in mac80211.
5842 */
5843
5844 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5845 {
5846 struct ath10k *ar = hw->priv;
5847 struct ath10k_vif *arvif;
5848 int ret = 0;
5849
5850 mutex_lock(&ar->conf_mutex);
5851 list_for_each_entry(arvif, &ar->arvifs, list) {
5852 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5853 arvif->vdev_id, value);
5854
5855 ret = ath10k_mac_set_rts(arvif, value);
5856 if (ret) {
5857 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5858 arvif->vdev_id, ret);
5859 break;
5860 }
5861 }
5862 mutex_unlock(&ar->conf_mutex);
5863
5864 return ret;
5865 }
5866
5867 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5868 {
5869 /* Even though there's a WMI enum for fragmentation threshold no known
5870 * firmware actually implements it. Moreover it is not possible to rely
5871 * frame fragmentation to mac80211 because firmware clears the "more
5872 * fragments" bit in frame control making it impossible for remote
5873 * devices to reassemble frames.
5874 *
5875 * Hence implement a dummy callback just to say fragmentation isn't
5876 * supported. This effectively prevents mac80211 from doing frame
5877 * fragmentation in software.
5878 */
5879 return -EOPNOTSUPP;
5880 }
5881
5882 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5883 u32 queues, bool drop)
5884 {
5885 struct ath10k *ar = hw->priv;
5886 bool skip;
5887 long time_left;
5888
5889 /* mac80211 doesn't care if we really xmit queued frames or not
5890 * we'll collect those frames either way if we stop/delete vdevs */
5891 if (drop)
5892 return;
5893
5894 mutex_lock(&ar->conf_mutex);
5895
5896 if (ar->state == ATH10K_STATE_WEDGED)
5897 goto skip;
5898
5899 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5900 bool empty;
5901
5902 spin_lock_bh(&ar->htt.tx_lock);
5903 empty = (ar->htt.num_pending_tx == 0);
5904 spin_unlock_bh(&ar->htt.tx_lock);
5905
5906 skip = (ar->state == ATH10K_STATE_WEDGED) ||
5907 test_bit(ATH10K_FLAG_CRASH_FLUSH,
5908 &ar->dev_flags);
5909
5910 (empty || skip);
5911 }), ATH10K_FLUSH_TIMEOUT_HZ);
5912
5913 if (time_left == 0 || skip)
5914 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5915 skip, ar->state, time_left);
5916
5917 skip:
5918 mutex_unlock(&ar->conf_mutex);
5919 }
5920
5921 /* TODO: Implement this function properly
5922 * For now it is needed to reply to Probe Requests in IBSS mode.
5923 * Propably we need this information from FW.
5924 */
5925 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5926 {
5927 return 1;
5928 }
5929
5930 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5931 enum ieee80211_reconfig_type reconfig_type)
5932 {
5933 struct ath10k *ar = hw->priv;
5934
5935 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5936 return;
5937
5938 mutex_lock(&ar->conf_mutex);
5939
5940 /* If device failed to restart it will be in a different state, e.g.
5941 * ATH10K_STATE_WEDGED */
5942 if (ar->state == ATH10K_STATE_RESTARTED) {
5943 ath10k_info(ar, "device successfully recovered\n");
5944 ar->state = ATH10K_STATE_ON;
5945 ieee80211_wake_queues(ar->hw);
5946 }
5947
5948 mutex_unlock(&ar->conf_mutex);
5949 }
5950
5951 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5952 struct survey_info *survey)
5953 {
5954 struct ath10k *ar = hw->priv;
5955 struct ieee80211_supported_band *sband;
5956 struct survey_info *ar_survey = &ar->survey[idx];
5957 int ret = 0;
5958
5959 mutex_lock(&ar->conf_mutex);
5960
5961 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5962 if (sband && idx >= sband->n_channels) {
5963 idx -= sband->n_channels;
5964 sband = NULL;
5965 }
5966
5967 if (!sband)
5968 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5969
5970 if (!sband || idx >= sband->n_channels) {
5971 ret = -ENOENT;
5972 goto exit;
5973 }
5974
5975 spin_lock_bh(&ar->data_lock);
5976 memcpy(survey, ar_survey, sizeof(*survey));
5977 spin_unlock_bh(&ar->data_lock);
5978
5979 survey->channel = &sband->channels[idx];
5980
5981 if (ar->rx_channel == survey->channel)
5982 survey->filled |= SURVEY_INFO_IN_USE;
5983
5984 exit:
5985 mutex_unlock(&ar->conf_mutex);
5986 return ret;
5987 }
5988
5989 static bool
5990 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
5991 enum ieee80211_band band,
5992 const struct cfg80211_bitrate_mask *mask)
5993 {
5994 int num_rates = 0;
5995 int i;
5996
5997 num_rates += hweight32(mask->control[band].legacy);
5998
5999 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6000 num_rates += hweight8(mask->control[band].ht_mcs[i]);
6001
6002 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
6003 num_rates += hweight16(mask->control[band].vht_mcs[i]);
6004
6005 return num_rates == 1;
6006 }
6007
6008 static bool
6009 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
6010 enum ieee80211_band band,
6011 const struct cfg80211_bitrate_mask *mask,
6012 int *nss)
6013 {
6014 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6015 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6016 u8 ht_nss_mask = 0;
6017 u8 vht_nss_mask = 0;
6018 int i;
6019
6020 if (mask->control[band].legacy)
6021 return false;
6022
6023 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6024 if (mask->control[band].ht_mcs[i] == 0)
6025 continue;
6026 else if (mask->control[band].ht_mcs[i] ==
6027 sband->ht_cap.mcs.rx_mask[i])
6028 ht_nss_mask |= BIT(i);
6029 else
6030 return false;
6031 }
6032
6033 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6034 if (mask->control[band].vht_mcs[i] == 0)
6035 continue;
6036 else if (mask->control[band].vht_mcs[i] ==
6037 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6038 vht_nss_mask |= BIT(i);
6039 else
6040 return false;
6041 }
6042
6043 if (ht_nss_mask != vht_nss_mask)
6044 return false;
6045
6046 if (ht_nss_mask == 0)
6047 return false;
6048
6049 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6050 return false;
6051
6052 *nss = fls(ht_nss_mask);
6053
6054 return true;
6055 }
6056
6057 static int
6058 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6059 enum ieee80211_band band,
6060 const struct cfg80211_bitrate_mask *mask,
6061 u8 *rate, u8 *nss)
6062 {
6063 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6064 int rate_idx;
6065 int i;
6066 u16 bitrate;
6067 u8 preamble;
6068 u8 hw_rate;
6069
6070 if (hweight32(mask->control[band].legacy) == 1) {
6071 rate_idx = ffs(mask->control[band].legacy) - 1;
6072
6073 hw_rate = sband->bitrates[rate_idx].hw_value;
6074 bitrate = sband->bitrates[rate_idx].bitrate;
6075
6076 if (ath10k_mac_bitrate_is_cck(bitrate))
6077 preamble = WMI_RATE_PREAMBLE_CCK;
6078 else
6079 preamble = WMI_RATE_PREAMBLE_OFDM;
6080
6081 *nss = 1;
6082 *rate = preamble << 6 |
6083 (*nss - 1) << 4 |
6084 hw_rate << 0;
6085
6086 return 0;
6087 }
6088
6089 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6090 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6091 *nss = i + 1;
6092 *rate = WMI_RATE_PREAMBLE_HT << 6 |
6093 (*nss - 1) << 4 |
6094 (ffs(mask->control[band].ht_mcs[i]) - 1);
6095
6096 return 0;
6097 }
6098 }
6099
6100 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6101 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6102 *nss = i + 1;
6103 *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6104 (*nss - 1) << 4 |
6105 (ffs(mask->control[band].vht_mcs[i]) - 1);
6106
6107 return 0;
6108 }
6109 }
6110
6111 return -EINVAL;
6112 }
6113
6114 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
6115 u8 rate, u8 nss, u8 sgi, u8 ldpc)
6116 {
6117 struct ath10k *ar = arvif->ar;
6118 u32 vdev_param;
6119 int ret;
6120
6121 lockdep_assert_held(&ar->conf_mutex);
6122
6123 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6124 arvif->vdev_id, rate, nss, sgi);
6125
6126 vdev_param = ar->wmi.vdev_param->fixed_rate;
6127 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
6128 if (ret) {
6129 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
6130 rate, ret);
6131 return ret;
6132 }
6133
6134 vdev_param = ar->wmi.vdev_param->nss;
6135 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
6136 if (ret) {
6137 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6138 return ret;
6139 }
6140
6141 vdev_param = ar->wmi.vdev_param->sgi;
6142 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6143 if (ret) {
6144 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6145 return ret;
6146 }
6147
6148 vdev_param = ar->wmi.vdev_param->ldpc;
6149 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6150 if (ret) {
6151 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6152 return ret;
6153 }
6154
6155 return 0;
6156 }
6157
6158 static bool
6159 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6160 enum ieee80211_band band,
6161 const struct cfg80211_bitrate_mask *mask)
6162 {
6163 int i;
6164 u16 vht_mcs;
6165
6166 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6167 * to express all VHT MCS rate masks. Effectively only the following
6168 * ranges can be used: none, 0-7, 0-8 and 0-9.
6169 */
6170 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6171 vht_mcs = mask->control[band].vht_mcs[i];
6172
6173 switch (vht_mcs) {
6174 case 0:
6175 case BIT(8) - 1:
6176 case BIT(9) - 1:
6177 case BIT(10) - 1:
6178 break;
6179 default:
6180 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6181 return false;
6182 }
6183 }
6184
6185 return true;
6186 }
6187
6188 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6189 struct ieee80211_sta *sta)
6190 {
6191 struct ath10k_vif *arvif = data;
6192 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6193 struct ath10k *ar = arvif->ar;
6194
6195 if (arsta->arvif != arvif)
6196 return;
6197
6198 spin_lock_bh(&ar->data_lock);
6199 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6200 spin_unlock_bh(&ar->data_lock);
6201
6202 ieee80211_queue_work(ar->hw, &arsta->update_wk);
6203 }
6204
6205 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6206 struct ieee80211_vif *vif,
6207 const struct cfg80211_bitrate_mask *mask)
6208 {
6209 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6210 struct cfg80211_chan_def def;
6211 struct ath10k *ar = arvif->ar;
6212 enum ieee80211_band band;
6213 const u8 *ht_mcs_mask;
6214 const u16 *vht_mcs_mask;
6215 u8 rate;
6216 u8 nss;
6217 u8 sgi;
6218 u8 ldpc;
6219 int single_nss;
6220 int ret;
6221
6222 if (ath10k_mac_vif_chan(vif, &def))
6223 return -EPERM;
6224
6225 band = def.chan->band;
6226 ht_mcs_mask = mask->control[band].ht_mcs;
6227 vht_mcs_mask = mask->control[band].vht_mcs;
6228 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6229
6230 sgi = mask->control[band].gi;
6231 if (sgi == NL80211_TXRATE_FORCE_LGI)
6232 return -EINVAL;
6233
6234 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6235 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6236 &rate, &nss);
6237 if (ret) {
6238 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6239 arvif->vdev_id, ret);
6240 return ret;
6241 }
6242 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6243 &single_nss)) {
6244 rate = WMI_FIXED_RATE_NONE;
6245 nss = single_nss;
6246 } else {
6247 rate = WMI_FIXED_RATE_NONE;
6248 nss = min(ar->num_rf_chains,
6249 max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6250 ath10k_mac_max_vht_nss(vht_mcs_mask)));
6251
6252 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6253 return -EINVAL;
6254
6255 mutex_lock(&ar->conf_mutex);
6256
6257 arvif->bitrate_mask = *mask;
6258 ieee80211_iterate_stations_atomic(ar->hw,
6259 ath10k_mac_set_bitrate_mask_iter,
6260 arvif);
6261
6262 mutex_unlock(&ar->conf_mutex);
6263 }
6264
6265 mutex_lock(&ar->conf_mutex);
6266
6267 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6268 if (ret) {
6269 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6270 arvif->vdev_id, ret);
6271 goto exit;
6272 }
6273
6274 exit:
6275 mutex_unlock(&ar->conf_mutex);
6276
6277 return ret;
6278 }
6279
6280 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6281 struct ieee80211_vif *vif,
6282 struct ieee80211_sta *sta,
6283 u32 changed)
6284 {
6285 struct ath10k *ar = hw->priv;
6286 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6287 u32 bw, smps;
6288
6289 spin_lock_bh(&ar->data_lock);
6290
6291 ath10k_dbg(ar, ATH10K_DBG_MAC,
6292 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6293 sta->addr, changed, sta->bandwidth, sta->rx_nss,
6294 sta->smps_mode);
6295
6296 if (changed & IEEE80211_RC_BW_CHANGED) {
6297 bw = WMI_PEER_CHWIDTH_20MHZ;
6298
6299 switch (sta->bandwidth) {
6300 case IEEE80211_STA_RX_BW_20:
6301 bw = WMI_PEER_CHWIDTH_20MHZ;
6302 break;
6303 case IEEE80211_STA_RX_BW_40:
6304 bw = WMI_PEER_CHWIDTH_40MHZ;
6305 break;
6306 case IEEE80211_STA_RX_BW_80:
6307 bw = WMI_PEER_CHWIDTH_80MHZ;
6308 break;
6309 case IEEE80211_STA_RX_BW_160:
6310 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6311 sta->bandwidth, sta->addr);
6312 bw = WMI_PEER_CHWIDTH_20MHZ;
6313 break;
6314 }
6315
6316 arsta->bw = bw;
6317 }
6318
6319 if (changed & IEEE80211_RC_NSS_CHANGED)
6320 arsta->nss = sta->rx_nss;
6321
6322 if (changed & IEEE80211_RC_SMPS_CHANGED) {
6323 smps = WMI_PEER_SMPS_PS_NONE;
6324
6325 switch (sta->smps_mode) {
6326 case IEEE80211_SMPS_AUTOMATIC:
6327 case IEEE80211_SMPS_OFF:
6328 smps = WMI_PEER_SMPS_PS_NONE;
6329 break;
6330 case IEEE80211_SMPS_STATIC:
6331 smps = WMI_PEER_SMPS_STATIC;
6332 break;
6333 case IEEE80211_SMPS_DYNAMIC:
6334 smps = WMI_PEER_SMPS_DYNAMIC;
6335 break;
6336 case IEEE80211_SMPS_NUM_MODES:
6337 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6338 sta->smps_mode, sta->addr);
6339 smps = WMI_PEER_SMPS_PS_NONE;
6340 break;
6341 }
6342
6343 arsta->smps = smps;
6344 }
6345
6346 arsta->changed |= changed;
6347
6348 spin_unlock_bh(&ar->data_lock);
6349
6350 ieee80211_queue_work(hw, &arsta->update_wk);
6351 }
6352
6353 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6354 {
6355 /*
6356 * FIXME: Return 0 for time being. Need to figure out whether FW
6357 * has the API to fetch 64-bit local TSF
6358 */
6359
6360 return 0;
6361 }
6362
6363 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6364 struct ieee80211_vif *vif,
6365 enum ieee80211_ampdu_mlme_action action,
6366 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
6367 u8 buf_size, bool amsdu)
6368 {
6369 struct ath10k *ar = hw->priv;
6370 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6371
6372 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6373 arvif->vdev_id, sta->addr, tid, action);
6374
6375 switch (action) {
6376 case IEEE80211_AMPDU_RX_START:
6377 case IEEE80211_AMPDU_RX_STOP:
6378 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6379 * creation/removal. Do we need to verify this?
6380 */
6381 return 0;
6382 case IEEE80211_AMPDU_TX_START:
6383 case IEEE80211_AMPDU_TX_STOP_CONT:
6384 case IEEE80211_AMPDU_TX_STOP_FLUSH:
6385 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6386 case IEEE80211_AMPDU_TX_OPERATIONAL:
6387 /* Firmware offloads Tx aggregation entirely so deny mac80211
6388 * Tx aggregation requests.
6389 */
6390 return -EOPNOTSUPP;
6391 }
6392
6393 return -EINVAL;
6394 }
6395
6396 static void
6397 ath10k_mac_update_rx_channel(struct ath10k *ar,
6398 struct ieee80211_chanctx_conf *ctx,
6399 struct ieee80211_vif_chanctx_switch *vifs,
6400 int n_vifs)
6401 {
6402 struct cfg80211_chan_def *def = NULL;
6403
6404 /* Both locks are required because ar->rx_channel is modified. This
6405 * allows readers to hold either lock.
6406 */
6407 lockdep_assert_held(&ar->conf_mutex);
6408 lockdep_assert_held(&ar->data_lock);
6409
6410 WARN_ON(ctx && vifs);
6411 WARN_ON(vifs && n_vifs != 1);
6412
6413 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6414 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6415 * ppdu on Rx may reduce performance on low-end systems. It should be
6416 * possible to make tables/hashmaps to speed the lookup up (be vary of
6417 * cpu data cache lines though regarding sizes) but to keep the initial
6418 * implementation simple and less intrusive fallback to the slow lookup
6419 * only for multi-channel cases. Single-channel cases will remain to
6420 * use the old channel derival and thus performance should not be
6421 * affected much.
6422 */
6423 rcu_read_lock();
6424 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6425 ieee80211_iter_chan_contexts_atomic(ar->hw,
6426 ath10k_mac_get_any_chandef_iter,
6427 &def);
6428
6429 if (vifs)
6430 def = &vifs[0].new_ctx->def;
6431
6432 ar->rx_channel = def->chan;
6433 } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6434 ar->rx_channel = ctx->def.chan;
6435 } else {
6436 ar->rx_channel = NULL;
6437 }
6438 rcu_read_unlock();
6439 }
6440
6441 static void
6442 ath10k_mac_update_vif_chan(struct ath10k *ar,
6443 struct ieee80211_vif_chanctx_switch *vifs,
6444 int n_vifs)
6445 {
6446 struct ath10k_vif *arvif;
6447 int ret;
6448 int i;
6449
6450 lockdep_assert_held(&ar->conf_mutex);
6451
6452 /* First stop monitor interface. Some FW versions crash if there's a
6453 * lone monitor interface.
6454 */
6455 if (ar->monitor_started)
6456 ath10k_monitor_stop(ar);
6457
6458 for (i = 0; i < n_vifs; i++) {
6459 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6460
6461 ath10k_dbg(ar, ATH10K_DBG_MAC,
6462 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6463 arvif->vdev_id,
6464 vifs[i].old_ctx->def.chan->center_freq,
6465 vifs[i].new_ctx->def.chan->center_freq,
6466 vifs[i].old_ctx->def.width,
6467 vifs[i].new_ctx->def.width);
6468
6469 if (WARN_ON(!arvif->is_started))
6470 continue;
6471
6472 if (WARN_ON(!arvif->is_up))
6473 continue;
6474
6475 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6476 if (ret) {
6477 ath10k_warn(ar, "failed to down vdev %d: %d\n",
6478 arvif->vdev_id, ret);
6479 continue;
6480 }
6481 }
6482
6483 /* All relevant vdevs are downed and associated channel resources
6484 * should be available for the channel switch now.
6485 */
6486
6487 spin_lock_bh(&ar->data_lock);
6488 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6489 spin_unlock_bh(&ar->data_lock);
6490
6491 for (i = 0; i < n_vifs; i++) {
6492 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6493
6494 if (WARN_ON(!arvif->is_started))
6495 continue;
6496
6497 if (WARN_ON(!arvif->is_up))
6498 continue;
6499
6500 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6501 if (ret)
6502 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6503 ret);
6504
6505 ret = ath10k_mac_setup_prb_tmpl(arvif);
6506 if (ret)
6507 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6508 ret);
6509
6510 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6511 if (ret) {
6512 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6513 arvif->vdev_id, ret);
6514 continue;
6515 }
6516
6517 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6518 arvif->bssid);
6519 if (ret) {
6520 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6521 arvif->vdev_id, ret);
6522 continue;
6523 }
6524 }
6525
6526 ath10k_monitor_recalc(ar);
6527 }
6528
6529 static int
6530 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6531 struct ieee80211_chanctx_conf *ctx)
6532 {
6533 struct ath10k *ar = hw->priv;
6534
6535 ath10k_dbg(ar, ATH10K_DBG_MAC,
6536 "mac chanctx add freq %hu width %d ptr %p\n",
6537 ctx->def.chan->center_freq, ctx->def.width, ctx);
6538
6539 mutex_lock(&ar->conf_mutex);
6540
6541 spin_lock_bh(&ar->data_lock);
6542 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6543 spin_unlock_bh(&ar->data_lock);
6544
6545 ath10k_recalc_radar_detection(ar);
6546 ath10k_monitor_recalc(ar);
6547
6548 mutex_unlock(&ar->conf_mutex);
6549
6550 return 0;
6551 }
6552
6553 static void
6554 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6555 struct ieee80211_chanctx_conf *ctx)
6556 {
6557 struct ath10k *ar = hw->priv;
6558
6559 ath10k_dbg(ar, ATH10K_DBG_MAC,
6560 "mac chanctx remove freq %hu width %d ptr %p\n",
6561 ctx->def.chan->center_freq, ctx->def.width, ctx);
6562
6563 mutex_lock(&ar->conf_mutex);
6564
6565 spin_lock_bh(&ar->data_lock);
6566 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6567 spin_unlock_bh(&ar->data_lock);
6568
6569 ath10k_recalc_radar_detection(ar);
6570 ath10k_monitor_recalc(ar);
6571
6572 mutex_unlock(&ar->conf_mutex);
6573 }
6574
6575 struct ath10k_mac_change_chanctx_arg {
6576 struct ieee80211_chanctx_conf *ctx;
6577 struct ieee80211_vif_chanctx_switch *vifs;
6578 int n_vifs;
6579 int next_vif;
6580 };
6581
6582 static void
6583 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6584 struct ieee80211_vif *vif)
6585 {
6586 struct ath10k_mac_change_chanctx_arg *arg = data;
6587
6588 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6589 return;
6590
6591 arg->n_vifs++;
6592 }
6593
6594 static void
6595 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6596 struct ieee80211_vif *vif)
6597 {
6598 struct ath10k_mac_change_chanctx_arg *arg = data;
6599 struct ieee80211_chanctx_conf *ctx;
6600
6601 ctx = rcu_access_pointer(vif->chanctx_conf);
6602 if (ctx != arg->ctx)
6603 return;
6604
6605 if (WARN_ON(arg->next_vif == arg->n_vifs))
6606 return;
6607
6608 arg->vifs[arg->next_vif].vif = vif;
6609 arg->vifs[arg->next_vif].old_ctx = ctx;
6610 arg->vifs[arg->next_vif].new_ctx = ctx;
6611 arg->next_vif++;
6612 }
6613
6614 static void
6615 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6616 struct ieee80211_chanctx_conf *ctx,
6617 u32 changed)
6618 {
6619 struct ath10k *ar = hw->priv;
6620 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
6621
6622 mutex_lock(&ar->conf_mutex);
6623
6624 ath10k_dbg(ar, ATH10K_DBG_MAC,
6625 "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6626 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6627
6628 /* This shouldn't really happen because channel switching should use
6629 * switch_vif_chanctx().
6630 */
6631 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6632 goto unlock;
6633
6634 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
6635 ieee80211_iterate_active_interfaces_atomic(
6636 hw,
6637 IEEE80211_IFACE_ITER_NORMAL,
6638 ath10k_mac_change_chanctx_cnt_iter,
6639 &arg);
6640 if (arg.n_vifs == 0)
6641 goto radar;
6642
6643 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
6644 GFP_KERNEL);
6645 if (!arg.vifs)
6646 goto radar;
6647
6648 ieee80211_iterate_active_interfaces_atomic(
6649 hw,
6650 IEEE80211_IFACE_ITER_NORMAL,
6651 ath10k_mac_change_chanctx_fill_iter,
6652 &arg);
6653 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6654 kfree(arg.vifs);
6655 }
6656
6657 radar:
6658 ath10k_recalc_radar_detection(ar);
6659
6660 /* FIXME: How to configure Rx chains properly? */
6661
6662 /* No other actions are actually necessary. Firmware maintains channel
6663 * definitions per vdev internally and there's no host-side channel
6664 * context abstraction to configure, e.g. channel width.
6665 */
6666
6667 unlock:
6668 mutex_unlock(&ar->conf_mutex);
6669 }
6670
6671 static int
6672 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6673 struct ieee80211_vif *vif,
6674 struct ieee80211_chanctx_conf *ctx)
6675 {
6676 struct ath10k *ar = hw->priv;
6677 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6678 int ret;
6679
6680 mutex_lock(&ar->conf_mutex);
6681
6682 ath10k_dbg(ar, ATH10K_DBG_MAC,
6683 "mac chanctx assign ptr %p vdev_id %i\n",
6684 ctx, arvif->vdev_id);
6685
6686 if (WARN_ON(arvif->is_started)) {
6687 mutex_unlock(&ar->conf_mutex);
6688 return -EBUSY;
6689 }
6690
6691 ret = ath10k_vdev_start(arvif, &ctx->def);
6692 if (ret) {
6693 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6694 arvif->vdev_id, vif->addr,
6695 ctx->def.chan->center_freq, ret);
6696 goto err;
6697 }
6698
6699 arvif->is_started = true;
6700
6701 ret = ath10k_mac_vif_setup_ps(arvif);
6702 if (ret) {
6703 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6704 arvif->vdev_id, ret);
6705 goto err_stop;
6706 }
6707
6708 if (vif->type == NL80211_IFTYPE_MONITOR) {
6709 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6710 if (ret) {
6711 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6712 arvif->vdev_id, ret);
6713 goto err_stop;
6714 }
6715
6716 arvif->is_up = true;
6717 }
6718
6719 mutex_unlock(&ar->conf_mutex);
6720 return 0;
6721
6722 err_stop:
6723 ath10k_vdev_stop(arvif);
6724 arvif->is_started = false;
6725 ath10k_mac_vif_setup_ps(arvif);
6726
6727 err:
6728 mutex_unlock(&ar->conf_mutex);
6729 return ret;
6730 }
6731
6732 static void
6733 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6734 struct ieee80211_vif *vif,
6735 struct ieee80211_chanctx_conf *ctx)
6736 {
6737 struct ath10k *ar = hw->priv;
6738 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6739 int ret;
6740
6741 mutex_lock(&ar->conf_mutex);
6742
6743 ath10k_dbg(ar, ATH10K_DBG_MAC,
6744 "mac chanctx unassign ptr %p vdev_id %i\n",
6745 ctx, arvif->vdev_id);
6746
6747 WARN_ON(!arvif->is_started);
6748
6749 if (vif->type == NL80211_IFTYPE_MONITOR) {
6750 WARN_ON(!arvif->is_up);
6751
6752 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6753 if (ret)
6754 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6755 arvif->vdev_id, ret);
6756
6757 arvif->is_up = false;
6758 }
6759
6760 ret = ath10k_vdev_stop(arvif);
6761 if (ret)
6762 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6763 arvif->vdev_id, ret);
6764
6765 arvif->is_started = false;
6766
6767 mutex_unlock(&ar->conf_mutex);
6768 }
6769
6770 static int
6771 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6772 struct ieee80211_vif_chanctx_switch *vifs,
6773 int n_vifs,
6774 enum ieee80211_chanctx_switch_mode mode)
6775 {
6776 struct ath10k *ar = hw->priv;
6777
6778 mutex_lock(&ar->conf_mutex);
6779
6780 ath10k_dbg(ar, ATH10K_DBG_MAC,
6781 "mac chanctx switch n_vifs %d mode %d\n",
6782 n_vifs, mode);
6783 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
6784
6785 mutex_unlock(&ar->conf_mutex);
6786 return 0;
6787 }
6788
6789 static const struct ieee80211_ops ath10k_ops = {
6790 .tx = ath10k_tx,
6791 .start = ath10k_start,
6792 .stop = ath10k_stop,
6793 .config = ath10k_config,
6794 .add_interface = ath10k_add_interface,
6795 .remove_interface = ath10k_remove_interface,
6796 .configure_filter = ath10k_configure_filter,
6797 .bss_info_changed = ath10k_bss_info_changed,
6798 .hw_scan = ath10k_hw_scan,
6799 .cancel_hw_scan = ath10k_cancel_hw_scan,
6800 .set_key = ath10k_set_key,
6801 .set_default_unicast_key = ath10k_set_default_unicast_key,
6802 .sta_state = ath10k_sta_state,
6803 .conf_tx = ath10k_conf_tx,
6804 .remain_on_channel = ath10k_remain_on_channel,
6805 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
6806 .set_rts_threshold = ath10k_set_rts_threshold,
6807 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,
6808 .flush = ath10k_flush,
6809 .tx_last_beacon = ath10k_tx_last_beacon,
6810 .set_antenna = ath10k_set_antenna,
6811 .get_antenna = ath10k_get_antenna,
6812 .reconfig_complete = ath10k_reconfig_complete,
6813 .get_survey = ath10k_get_survey,
6814 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,
6815 .sta_rc_update = ath10k_sta_rc_update,
6816 .get_tsf = ath10k_get_tsf,
6817 .ampdu_action = ath10k_ampdu_action,
6818 .get_et_sset_count = ath10k_debug_get_et_sset_count,
6819 .get_et_stats = ath10k_debug_get_et_stats,
6820 .get_et_strings = ath10k_debug_get_et_strings,
6821 .add_chanctx = ath10k_mac_op_add_chanctx,
6822 .remove_chanctx = ath10k_mac_op_remove_chanctx,
6823 .change_chanctx = ath10k_mac_op_change_chanctx,
6824 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,
6825 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,
6826 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,
6827
6828 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6829
6830 #ifdef CONFIG_PM
6831 .suspend = ath10k_wow_op_suspend,
6832 .resume = ath10k_wow_op_resume,
6833 #endif
6834 #ifdef CONFIG_MAC80211_DEBUGFS
6835 .sta_add_debugfs = ath10k_sta_add_debugfs,
6836 #endif
6837 };
6838
6839 #define CHAN2G(_channel, _freq, _flags) { \
6840 .band = IEEE80211_BAND_2GHZ, \
6841 .hw_value = (_channel), \
6842 .center_freq = (_freq), \
6843 .flags = (_flags), \
6844 .max_antenna_gain = 0, \
6845 .max_power = 30, \
6846 }
6847
6848 #define CHAN5G(_channel, _freq, _flags) { \
6849 .band = IEEE80211_BAND_5GHZ, \
6850 .hw_value = (_channel), \
6851 .center_freq = (_freq), \
6852 .flags = (_flags), \
6853 .max_antenna_gain = 0, \
6854 .max_power = 30, \
6855 }
6856
6857 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6858 CHAN2G(1, 2412, 0),
6859 CHAN2G(2, 2417, 0),
6860 CHAN2G(3, 2422, 0),
6861 CHAN2G(4, 2427, 0),
6862 CHAN2G(5, 2432, 0),
6863 CHAN2G(6, 2437, 0),
6864 CHAN2G(7, 2442, 0),
6865 CHAN2G(8, 2447, 0),
6866 CHAN2G(9, 2452, 0),
6867 CHAN2G(10, 2457, 0),
6868 CHAN2G(11, 2462, 0),
6869 CHAN2G(12, 2467, 0),
6870 CHAN2G(13, 2472, 0),
6871 CHAN2G(14, 2484, 0),
6872 };
6873
6874 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6875 CHAN5G(36, 5180, 0),
6876 CHAN5G(40, 5200, 0),
6877 CHAN5G(44, 5220, 0),
6878 CHAN5G(48, 5240, 0),
6879 CHAN5G(52, 5260, 0),
6880 CHAN5G(56, 5280, 0),
6881 CHAN5G(60, 5300, 0),
6882 CHAN5G(64, 5320, 0),
6883 CHAN5G(100, 5500, 0),
6884 CHAN5G(104, 5520, 0),
6885 CHAN5G(108, 5540, 0),
6886 CHAN5G(112, 5560, 0),
6887 CHAN5G(116, 5580, 0),
6888 CHAN5G(120, 5600, 0),
6889 CHAN5G(124, 5620, 0),
6890 CHAN5G(128, 5640, 0),
6891 CHAN5G(132, 5660, 0),
6892 CHAN5G(136, 5680, 0),
6893 CHAN5G(140, 5700, 0),
6894 CHAN5G(144, 5720, 0),
6895 CHAN5G(149, 5745, 0),
6896 CHAN5G(153, 5765, 0),
6897 CHAN5G(157, 5785, 0),
6898 CHAN5G(161, 5805, 0),
6899 CHAN5G(165, 5825, 0),
6900 };
6901
6902 struct ath10k *ath10k_mac_create(size_t priv_size)
6903 {
6904 struct ieee80211_hw *hw;
6905 struct ath10k *ar;
6906
6907 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6908 if (!hw)
6909 return NULL;
6910
6911 ar = hw->priv;
6912 ar->hw = hw;
6913
6914 return ar;
6915 }
6916
6917 void ath10k_mac_destroy(struct ath10k *ar)
6918 {
6919 ieee80211_free_hw(ar->hw);
6920 }
6921
6922 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6923 {
6924 .max = 8,
6925 .types = BIT(NL80211_IFTYPE_STATION)
6926 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6927 },
6928 {
6929 .max = 3,
6930 .types = BIT(NL80211_IFTYPE_P2P_GO)
6931 },
6932 {
6933 .max = 1,
6934 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
6935 },
6936 {
6937 .max = 7,
6938 .types = BIT(NL80211_IFTYPE_AP)
6939 #ifdef CONFIG_MAC80211_MESH
6940 | BIT(NL80211_IFTYPE_MESH_POINT)
6941 #endif
6942 },
6943 };
6944
6945 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6946 {
6947 .max = 8,
6948 .types = BIT(NL80211_IFTYPE_AP)
6949 #ifdef CONFIG_MAC80211_MESH
6950 | BIT(NL80211_IFTYPE_MESH_POINT)
6951 #endif
6952 },
6953 };
6954
6955 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6956 {
6957 .limits = ath10k_if_limits,
6958 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6959 .max_interfaces = 8,
6960 .num_different_channels = 1,
6961 .beacon_int_infra_match = true,
6962 },
6963 };
6964
6965 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6966 {
6967 .limits = ath10k_10x_if_limits,
6968 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6969 .max_interfaces = 8,
6970 .num_different_channels = 1,
6971 .beacon_int_infra_match = true,
6972 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6973 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6974 BIT(NL80211_CHAN_WIDTH_20) |
6975 BIT(NL80211_CHAN_WIDTH_40) |
6976 BIT(NL80211_CHAN_WIDTH_80),
6977 #endif
6978 },
6979 };
6980
6981 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
6982 {
6983 .max = 2,
6984 .types = BIT(NL80211_IFTYPE_STATION),
6985 },
6986 {
6987 .max = 2,
6988 .types = BIT(NL80211_IFTYPE_AP) |
6989 #ifdef CONFIG_MAC80211_MESH
6990 BIT(NL80211_IFTYPE_MESH_POINT) |
6991 #endif
6992 BIT(NL80211_IFTYPE_P2P_CLIENT) |
6993 BIT(NL80211_IFTYPE_P2P_GO),
6994 },
6995 {
6996 .max = 1,
6997 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6998 },
6999 };
7000
7001 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
7002 {
7003 .max = 2,
7004 .types = BIT(NL80211_IFTYPE_STATION),
7005 },
7006 {
7007 .max = 2,
7008 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
7009 },
7010 {
7011 .max = 1,
7012 .types = BIT(NL80211_IFTYPE_AP) |
7013 #ifdef CONFIG_MAC80211_MESH
7014 BIT(NL80211_IFTYPE_MESH_POINT) |
7015 #endif
7016 BIT(NL80211_IFTYPE_P2P_GO),
7017 },
7018 {
7019 .max = 1,
7020 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7021 },
7022 };
7023
7024 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
7025 {
7026 .max = 1,
7027 .types = BIT(NL80211_IFTYPE_STATION),
7028 },
7029 {
7030 .max = 1,
7031 .types = BIT(NL80211_IFTYPE_ADHOC),
7032 },
7033 };
7034
7035 /* FIXME: This is not thouroughly tested. These combinations may over- or
7036 * underestimate hw/fw capabilities.
7037 */
7038 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
7039 {
7040 .limits = ath10k_tlv_if_limit,
7041 .num_different_channels = 1,
7042 .max_interfaces = 4,
7043 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7044 },
7045 {
7046 .limits = ath10k_tlv_if_limit_ibss,
7047 .num_different_channels = 1,
7048 .max_interfaces = 2,
7049 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7050 },
7051 };
7052
7053 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
7054 {
7055 .limits = ath10k_tlv_if_limit,
7056 .num_different_channels = 1,
7057 .max_interfaces = 4,
7058 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7059 },
7060 {
7061 .limits = ath10k_tlv_qcs_if_limit,
7062 .num_different_channels = 2,
7063 .max_interfaces = 4,
7064 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
7065 },
7066 {
7067 .limits = ath10k_tlv_if_limit_ibss,
7068 .num_different_channels = 1,
7069 .max_interfaces = 2,
7070 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7071 },
7072 };
7073
7074 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
7075 {
7076 .max = 1,
7077 .types = BIT(NL80211_IFTYPE_STATION),
7078 },
7079 {
7080 .max = 16,
7081 .types = BIT(NL80211_IFTYPE_AP)
7082 #ifdef CONFIG_MAC80211_MESH
7083 | BIT(NL80211_IFTYPE_MESH_POINT)
7084 #endif
7085 },
7086 };
7087
7088 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
7089 {
7090 .limits = ath10k_10_4_if_limits,
7091 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
7092 .max_interfaces = 16,
7093 .num_different_channels = 1,
7094 .beacon_int_infra_match = true,
7095 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7096 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7097 BIT(NL80211_CHAN_WIDTH_20) |
7098 BIT(NL80211_CHAN_WIDTH_40) |
7099 BIT(NL80211_CHAN_WIDTH_80),
7100 #endif
7101 },
7102 };
7103
7104 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7105 struct ieee80211_vif *vif)
7106 {
7107 struct ath10k_vif_iter *arvif_iter = data;
7108 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7109
7110 if (arvif->vdev_id == arvif_iter->vdev_id)
7111 arvif_iter->arvif = arvif;
7112 }
7113
7114 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7115 {
7116 struct ath10k_vif_iter arvif_iter;
7117 u32 flags;
7118
7119 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7120 arvif_iter.vdev_id = vdev_id;
7121
7122 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7123 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7124 flags,
7125 ath10k_get_arvif_iter,
7126 &arvif_iter);
7127 if (!arvif_iter.arvif) {
7128 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7129 return NULL;
7130 }
7131
7132 return arvif_iter.arvif;
7133 }
7134
7135 int ath10k_mac_register(struct ath10k *ar)
7136 {
7137 static const u32 cipher_suites[] = {
7138 WLAN_CIPHER_SUITE_WEP40,
7139 WLAN_CIPHER_SUITE_WEP104,
7140 WLAN_CIPHER_SUITE_TKIP,
7141 WLAN_CIPHER_SUITE_CCMP,
7142 WLAN_CIPHER_SUITE_AES_CMAC,
7143 };
7144 struct ieee80211_supported_band *band;
7145 void *channels;
7146 int ret;
7147
7148 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7149
7150 SET_IEEE80211_DEV(ar->hw, ar->dev);
7151
7152 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7153 ARRAY_SIZE(ath10k_5ghz_channels)) !=
7154 ATH10K_NUM_CHANS);
7155
7156 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7157 channels = kmemdup(ath10k_2ghz_channels,
7158 sizeof(ath10k_2ghz_channels),
7159 GFP_KERNEL);
7160 if (!channels) {
7161 ret = -ENOMEM;
7162 goto err_free;
7163 }
7164
7165 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7166 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7167 band->channels = channels;
7168 band->n_bitrates = ath10k_g_rates_size;
7169 band->bitrates = ath10k_g_rates;
7170
7171 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7172 }
7173
7174 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7175 channels = kmemdup(ath10k_5ghz_channels,
7176 sizeof(ath10k_5ghz_channels),
7177 GFP_KERNEL);
7178 if (!channels) {
7179 ret = -ENOMEM;
7180 goto err_free;
7181 }
7182
7183 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7184 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7185 band->channels = channels;
7186 band->n_bitrates = ath10k_a_rates_size;
7187 band->bitrates = ath10k_a_rates;
7188 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7189 }
7190
7191 ath10k_mac_setup_ht_vht_cap(ar);
7192
7193 ar->hw->wiphy->interface_modes =
7194 BIT(NL80211_IFTYPE_STATION) |
7195 BIT(NL80211_IFTYPE_AP) |
7196 BIT(NL80211_IFTYPE_MESH_POINT);
7197
7198 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
7199 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
7200
7201 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7202 ar->hw->wiphy->interface_modes |=
7203 BIT(NL80211_IFTYPE_P2P_DEVICE) |
7204 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7205 BIT(NL80211_IFTYPE_P2P_GO);
7206
7207 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7208 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7209 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7210 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7211 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7212 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7213 ieee80211_hw_set(ar->hw, AP_LINK_PS);
7214 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7215 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7216 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7217 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7218 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7219 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7220 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7221
7222 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7223 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7224
7225 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7226 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7227
7228 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7229 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7230
7231 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7232 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7233 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7234 }
7235
7236 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7237 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7238
7239 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7240 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7241
7242 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7243
7244 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7245 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7246
7247 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7248 * that userspace (e.g. wpa_supplicant/hostapd) can generate
7249 * correct Probe Responses. This is more of a hack advert..
7250 */
7251 ar->hw->wiphy->probe_resp_offload |=
7252 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7253 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7254 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7255 }
7256
7257 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7258 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7259
7260 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7261 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7262 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7263
7264 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7265 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7266
7267 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7268
7269 ret = ath10k_wow_init(ar);
7270 if (ret) {
7271 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7272 goto err_free;
7273 }
7274
7275 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7276
7277 /*
7278 * on LL hardware queues are managed entirely by the FW
7279 * so we only advertise to mac we can do the queues thing
7280 */
7281 ar->hw->queues = IEEE80211_MAX_QUEUES;
7282
7283 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7284 * something that vdev_ids can't reach so that we don't stop the queue
7285 * accidentally.
7286 */
7287 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7288
7289 switch (ar->wmi.op_version) {
7290 case ATH10K_FW_WMI_OP_VERSION_MAIN:
7291 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7292 ar->hw->wiphy->n_iface_combinations =
7293 ARRAY_SIZE(ath10k_if_comb);
7294 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7295 break;
7296 case ATH10K_FW_WMI_OP_VERSION_TLV:
7297 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7298 ar->hw->wiphy->iface_combinations =
7299 ath10k_tlv_qcs_if_comb;
7300 ar->hw->wiphy->n_iface_combinations =
7301 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7302 } else {
7303 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7304 ar->hw->wiphy->n_iface_combinations =
7305 ARRAY_SIZE(ath10k_tlv_if_comb);
7306 }
7307 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7308 break;
7309 case ATH10K_FW_WMI_OP_VERSION_10_1:
7310 case ATH10K_FW_WMI_OP_VERSION_10_2:
7311 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7312 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7313 ar->hw->wiphy->n_iface_combinations =
7314 ARRAY_SIZE(ath10k_10x_if_comb);
7315 break;
7316 case ATH10K_FW_WMI_OP_VERSION_10_4:
7317 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7318 ar->hw->wiphy->n_iface_combinations =
7319 ARRAY_SIZE(ath10k_10_4_if_comb);
7320 break;
7321 case ATH10K_FW_WMI_OP_VERSION_UNSET:
7322 case ATH10K_FW_WMI_OP_VERSION_MAX:
7323 WARN_ON(1);
7324 ret = -EINVAL;
7325 goto err_free;
7326 }
7327
7328 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7329 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7330
7331 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7332 /* Init ath dfs pattern detector */
7333 ar->ath_common.debug_mask = ATH_DBG_DFS;
7334 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7335 NL80211_DFS_UNSET);
7336
7337 if (!ar->dfs_detector)
7338 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7339 }
7340
7341 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7342 ath10k_reg_notifier);
7343 if (ret) {
7344 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7345 goto err_dfs_detector_exit;
7346 }
7347
7348 ar->hw->wiphy->cipher_suites = cipher_suites;
7349 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7350
7351 ret = ieee80211_register_hw(ar->hw);
7352 if (ret) {
7353 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7354 goto err_dfs_detector_exit;
7355 }
7356
7357 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7358 ret = regulatory_hint(ar->hw->wiphy,
7359 ar->ath_common.regulatory.alpha2);
7360 if (ret)
7361 goto err_unregister;
7362 }
7363
7364 return 0;
7365
7366 err_unregister:
7367 ieee80211_unregister_hw(ar->hw);
7368
7369 err_dfs_detector_exit:
7370 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7371 ar->dfs_detector->exit(ar->dfs_detector);
7372
7373 err_free:
7374 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7375 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7376
7377 SET_IEEE80211_DEV(ar->hw, NULL);
7378 return ret;
7379 }
7380
7381 void ath10k_mac_unregister(struct ath10k *ar)
7382 {
7383 ieee80211_unregister_hw(ar->hw);
7384
7385 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7386 ar->dfs_detector->exit(ar->dfs_detector);
7387
7388 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7389 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7390
7391 SET_IEEE80211_DEV(ar->hw, NULL);
7392 }
Linux kernel - Deliverables
This page took 0.225403 seconds and 5 git commands to generate.