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