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