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