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