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