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