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