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