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