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