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