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