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