]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/net/wireless/ath/ath10k/mac.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:


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