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