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