]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/wireless/ath/ath10k/mac.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath10k: fix band reporting for mgmt CCK frames on 5GHz
[mirror_ubuntu-artful-kernel.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"
29
30/**********/
31/* Crypto */
32/**********/
33
34static int ath10k_send_key(struct ath10k_vif *arvif,
35 struct ieee80211_key_conf *key,
36 enum set_key_cmd cmd,
37 const u8 *macaddr)
38{
39 struct wmi_vdev_install_key_arg arg = {
40 .vdev_id = arvif->vdev_id,
41 .key_idx = key->keyidx,
42 .key_len = key->keylen,
43 .key_data = key->key,
44 .macaddr = macaddr,
45 };
46
548db54c
MK		 47 lockdep_assert_held(&arvif->ar->conf_mutex);
48
5e3dd157
KV		 49 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
50 arg.key_flags = WMI_KEY_PAIRWISE;
51 else
52 arg.key_flags = WMI_KEY_GROUP;
53
54 switch (key->cipher) {
55 case WLAN_CIPHER_SUITE_CCMP:
56 arg.key_cipher = WMI_CIPHER_AES_CCM;
57 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
58 break;
59 case WLAN_CIPHER_SUITE_TKIP:
5e3dd157
KV		 60 arg.key_cipher = WMI_CIPHER_TKIP;
61 arg.key_txmic_len = 8;
62 arg.key_rxmic_len = 8;
63 break;
64 case WLAN_CIPHER_SUITE_WEP40:
65 case WLAN_CIPHER_SUITE_WEP104:
66 arg.key_cipher = WMI_CIPHER_WEP;
67 /* AP/IBSS mode requires self-key to be groupwise
68 * Otherwise pairwise key must be set */
69 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
70 arg.key_flags = WMI_KEY_PAIRWISE;
71 break;
72 default:
73 ath10k_warn("cipher %d is not supported\n", key->cipher);
74 return -EOPNOTSUPP;
75 }
76
77 if (cmd == DISABLE_KEY) {
78 arg.key_cipher = WMI_CIPHER_NONE;
79 arg.key_data = NULL;
80 }
81
82 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
83}
84
85static int ath10k_install_key(struct ath10k_vif *arvif,
86 struct ieee80211_key_conf *key,
87 enum set_key_cmd cmd,
88 const u8 *macaddr)
89{
90 struct ath10k *ar = arvif->ar;
91 int ret;
92
548db54c
MK		 93 lockdep_assert_held(&ar->conf_mutex);
94
16735d02 95 reinit_completion(&ar->install_key_done);
5e3dd157
KV		 96
97 ret = ath10k_send_key(arvif, key, cmd, macaddr);
98 if (ret)
99 return ret;
100
101 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
102 if (ret == 0)
103 return -ETIMEDOUT;
104
105 return 0;
106}
107
108static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
109 const u8 *addr)
110{
111 struct ath10k *ar = arvif->ar;
112 struct ath10k_peer *peer;
113 int ret;
114 int i;
115
116 lockdep_assert_held(&ar->conf_mutex);
117
118 spin_lock_bh(&ar->data_lock);
119 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
120 spin_unlock_bh(&ar->data_lock);
121
122 if (!peer)
123 return -ENOENT;
124
125 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
126 if (arvif->wep_keys[i] == NULL)
127 continue;
128
129 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
130 addr);
131 if (ret)
132 return ret;
133
134 peer->keys[i] = arvif->wep_keys[i];
135 }
136
137 return 0;
138}
139
140static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
141 const u8 *addr)
142{
143 struct ath10k *ar = arvif->ar;
144 struct ath10k_peer *peer;
145 int first_errno = 0;
146 int ret;
147 int i;
148
149 lockdep_assert_held(&ar->conf_mutex);
150
151 spin_lock_bh(&ar->data_lock);
152 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
153 spin_unlock_bh(&ar->data_lock);
154
155 if (!peer)
156 return -ENOENT;
157
158 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
159 if (peer->keys[i] == NULL)
160 continue;
161
162 ret = ath10k_install_key(arvif, peer->keys[i],
163 DISABLE_KEY, addr);
164 if (ret && first_errno == 0)
165 first_errno = ret;
166
167 if (ret)
168 ath10k_warn("could not remove peer wep key %d (%d)\n",
169 i, ret);
170
171 peer->keys[i] = NULL;
172 }
173
174 return first_errno;
175}
176
177static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
178 struct ieee80211_key_conf *key)
179{
180 struct ath10k *ar = arvif->ar;
181 struct ath10k_peer *peer;
182 u8 addr[ETH_ALEN];
183 int first_errno = 0;
184 int ret;
185 int i;
186
187 lockdep_assert_held(&ar->conf_mutex);
188
189 for (;;) {
190 /* since ath10k_install_key we can't hold data_lock all the
191 * time, so we try to remove the keys incrementally */
192 spin_lock_bh(&ar->data_lock);
193 i = 0;
194 list_for_each_entry(peer, &ar->peers, list) {
195 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
196 if (peer->keys[i] == key) {
197 memcpy(addr, peer->addr, ETH_ALEN);
198 peer->keys[i] = NULL;
199 break;
200 }
201 }
202
203 if (i < ARRAY_SIZE(peer->keys))
204 break;
205 }
206 spin_unlock_bh(&ar->data_lock);
207
208 if (i == ARRAY_SIZE(peer->keys))
209 break;
210
211 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
212 if (ret && first_errno == 0)
213 first_errno = ret;
214
215 if (ret)
216 ath10k_warn("could not remove key for %pM\n", addr);
217 }
218
219 return first_errno;
220}
221
222
223/*********************/
224/* General utilities */
225/*********************/
226
227static inline enum wmi_phy_mode
228chan_to_phymode(const struct cfg80211_chan_def *chandef)
229{
230 enum wmi_phy_mode phymode = MODE_UNKNOWN;
231
232 switch (chandef->chan->band) {
233 case IEEE80211_BAND_2GHZ:
234 switch (chandef->width) {
235 case NL80211_CHAN_WIDTH_20_NOHT:
236 phymode = MODE_11G;
237 break;
238 case NL80211_CHAN_WIDTH_20:
239 phymode = MODE_11NG_HT20;
240 break;
241 case NL80211_CHAN_WIDTH_40:
242 phymode = MODE_11NG_HT40;
243 break;
0f817ed5
JL		 244 case NL80211_CHAN_WIDTH_5:
245 case NL80211_CHAN_WIDTH_10:
5e3dd157
KV		 246 case NL80211_CHAN_WIDTH_80:
247 case NL80211_CHAN_WIDTH_80P80:
248 case NL80211_CHAN_WIDTH_160:
249 phymode = MODE_UNKNOWN;
250 break;
251 }
252 break;
253 case IEEE80211_BAND_5GHZ:
254 switch (chandef->width) {
255 case NL80211_CHAN_WIDTH_20_NOHT:
256 phymode = MODE_11A;
257 break;
258 case NL80211_CHAN_WIDTH_20:
259 phymode = MODE_11NA_HT20;
260 break;
261 case NL80211_CHAN_WIDTH_40:
262 phymode = MODE_11NA_HT40;
263 break;
264 case NL80211_CHAN_WIDTH_80:
265 phymode = MODE_11AC_VHT80;
266 break;
0f817ed5
JL		 267 case NL80211_CHAN_WIDTH_5:
268 case NL80211_CHAN_WIDTH_10:
5e3dd157
KV		 269 case NL80211_CHAN_WIDTH_80P80:
270 case NL80211_CHAN_WIDTH_160:
271 phymode = MODE_UNKNOWN;
272 break;
273 }
274 break;
275 default:
276 break;
277 }
278
279 WARN_ON(phymode == MODE_UNKNOWN);
280 return phymode;
281}
282
283static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
284{
285/*
286 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
287 * 0 for no restriction
288 * 1 for 1/4 us
289 * 2 for 1/2 us
290 * 3 for 1 us
291 * 4 for 2 us
292 * 5 for 4 us
293 * 6 for 8 us
294 * 7 for 16 us
295 */
296 switch (mpdudensity) {
297 case 0:
298 return 0;
299 case 1:
300 case 2:
301 case 3:
302 /* Our lower layer calculations limit our precision to
303 1 microsecond */
304 return 1;
305 case 4:
306 return 2;
307 case 5:
308 return 4;
309 case 6:
310 return 8;
311 case 7:
312 return 16;
313 default:
314 return 0;
315 }
316}
317
318static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
319{
320 int ret;
321
322 lockdep_assert_held(&ar->conf_mutex);
323
324 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
479398b0
BG		 325 if (ret) {
326 ath10k_warn("Failed to create wmi peer: %i\n", ret);
5e3dd157 327 return ret;
479398b0 328 }
5e3dd157
KV		 329
330 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
479398b0
BG		 331 if (ret) {
332 ath10k_warn("Failed to wait for created wmi peer: %i\n", ret);
5e3dd157 333 return ret;
479398b0 334 }
5e3dd157
KV		 335
336 return 0;
337}
338
424121c3
MK		 339static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
340{
6d1506e7
BM		 341 struct ath10k *ar = arvif->ar;
342 u32 vdev_param;
343
424121c3
MK		 344 if (value != 0xFFFFFFFF)
345 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
346 ATH10K_RTS_MAX);
347
6d1506e7
BM		 348 vdev_param = ar->wmi.vdev_param->rts_threshold;
349 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
424121c3
MK		 350}
351
352static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
353{
6d1506e7
BM		 354 struct ath10k *ar = arvif->ar;
355 u32 vdev_param;
356
424121c3
MK		 357 if (value != 0xFFFFFFFF)
358 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
359 ATH10K_FRAGMT_THRESHOLD_MIN,
360 ATH10K_FRAGMT_THRESHOLD_MAX);
361
6d1506e7
BM		 362 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
363 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
424121c3
MK		 364}
365
5e3dd157
KV		 366static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
367{
368 int ret;
369
370 lockdep_assert_held(&ar->conf_mutex);
371
372 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
373 if (ret)
374 return ret;
375
376 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
377 if (ret)
378 return ret;
379
380 return 0;
381}
382
383static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
384{
385 struct ath10k_peer *peer, *tmp;
386
387 lockdep_assert_held(&ar->conf_mutex);
388
389 spin_lock_bh(&ar->data_lock);
390 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
391 if (peer->vdev_id != vdev_id)
392 continue;
393
394 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
395 peer->addr, vdev_id);
396
397 list_del(&peer->list);
398 kfree(peer);
399 }
400 spin_unlock_bh(&ar->data_lock);
401}
402
a96d7745
MK		 403static void ath10k_peer_cleanup_all(struct ath10k *ar)
404{
405 struct ath10k_peer *peer, *tmp;
406
407 lockdep_assert_held(&ar->conf_mutex);
408
409 spin_lock_bh(&ar->data_lock);
410 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
411 list_del(&peer->list);
412 kfree(peer);
413 }
414 spin_unlock_bh(&ar->data_lock);
415}
416
5e3dd157
KV		 417/************************/
418/* Interface management */
419/************************/
420
421static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
422{
423 int ret;
424
548db54c
MK		 425 lockdep_assert_held(&ar->conf_mutex);
426
5e3dd157
KV		 427 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
428 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
429 if (ret == 0)
430 return -ETIMEDOUT;
431
432 return 0;
433}
434
435static int ath10k_vdev_start(struct ath10k_vif *arvif)
436{
437 struct ath10k *ar = arvif->ar;
438 struct ieee80211_conf *conf = &ar->hw->conf;
439 struct ieee80211_channel *channel = conf->chandef.chan;
440 struct wmi_vdev_start_request_arg arg = {};
441 int ret = 0;
442
443 lockdep_assert_held(&ar->conf_mutex);
444
16735d02 445 reinit_completion(&ar->vdev_setup_done);
5e3dd157
KV		 446
447 arg.vdev_id = arvif->vdev_id;
448 arg.dtim_period = arvif->dtim_period;
449 arg.bcn_intval = arvif->beacon_interval;
450
451 arg.channel.freq = channel->center_freq;
452
453 arg.channel.band_center_freq1 = conf->chandef.center_freq1;
454
455 arg.channel.mode = chan_to_phymode(&conf->chandef);
456
89c5c843 457 arg.channel.min_power = 0;
02256930
MK		 458 arg.channel.max_power = channel->max_power * 2;
459 arg.channel.max_reg_power = channel->max_reg_power * 2;
460 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
5e3dd157
KV		 461
462 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
463 arg.ssid = arvif->u.ap.ssid;
464 arg.ssid_len = arvif->u.ap.ssid_len;
465 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
e8a50f8b
MP		 466
467 /* For now allow DFS for AP mode */
468 arg.channel.chan_radar =
469 !!(channel->flags & IEEE80211_CHAN_RADAR);
5e3dd157
KV		 470 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
471 arg.ssid = arvif->vif->bss_conf.ssid;
472 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
473 }
474
38a1d47e
KV		 475 ath10k_dbg(ATH10K_DBG_MAC,
476 "mac vdev %d start center_freq %d phymode %s\n",
477 arg.vdev_id, arg.channel.freq,
478 ath10k_wmi_phymode_str(arg.channel.mode));
479
5e3dd157
KV		 480 ret = ath10k_wmi_vdev_start(ar, &arg);
481 if (ret) {
482 ath10k_warn("WMI vdev start failed: ret %d\n", ret);
483 return ret;
484 }
485
486 ret = ath10k_vdev_setup_sync(ar);
487 if (ret) {
488 ath10k_warn("vdev setup failed %d\n", ret);
489 return ret;
490 }
491
492 return ret;
493}
494
495static int ath10k_vdev_stop(struct ath10k_vif *arvif)
496{
497 struct ath10k *ar = arvif->ar;
498 int ret;
499
500 lockdep_assert_held(&ar->conf_mutex);
501
16735d02 502 reinit_completion(&ar->vdev_setup_done);
5e3dd157
KV		 503
504 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
505 if (ret) {
506 ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
507 return ret;
508 }
509
510 ret = ath10k_vdev_setup_sync(ar);
511 if (ret) {
512 ath10k_warn("vdev setup failed %d\n", ret);
513 return ret;
514 }
515
516 return ret;
517}
518
519static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)
520{
521 struct ieee80211_channel *channel = ar->hw->conf.chandef.chan;
522 struct wmi_vdev_start_request_arg arg = {};
5e3dd157
KV		 523 int ret = 0;
524
525 lockdep_assert_held(&ar->conf_mutex);
526
0ed00eea
MK		 527 if (!ar->monitor_present) {
528 ath10k_warn("mac montor stop -- monitor is not present\n");
529 return -EINVAL;
530 }
531
5e3dd157
KV		 532 arg.vdev_id = vdev_id;
533 arg.channel.freq = channel->center_freq;
534 arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1;
535
536 /* TODO setup this dynamically, what in case we
537 don't have any vifs? */
538 arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef);
e8a50f8b
MP		 539 arg.channel.chan_radar =
540 !!(channel->flags & IEEE80211_CHAN_RADAR);
5e3dd157 541
89c5c843 542 arg.channel.min_power = 0;
02256930
MK		 543 arg.channel.max_power = channel->max_power * 2;
544 arg.channel.max_reg_power = channel->max_reg_power * 2;
545 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
5e3dd157
KV		 546
547 ret = ath10k_wmi_vdev_start(ar, &arg);
548 if (ret) {
549 ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
550 return ret;
551 }
552
553 ret = ath10k_vdev_setup_sync(ar);
554 if (ret) {
555 ath10k_warn("Monitor vdev setup failed %d\n", ret);
556 return ret;
557 }
558
559 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
560 if (ret) {
561 ath10k_warn("Monitor vdev up failed: %d\n", ret);
562 goto vdev_stop;
563 }
564
565 ar->monitor_vdev_id = vdev_id;
566 ar->monitor_enabled = true;
567
568 return 0;
569
570vdev_stop:
571 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
572 if (ret)
573 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
574
575 return ret;
576}
577
578static int ath10k_monitor_stop(struct ath10k *ar)
579{
580 int ret = 0;
581
582 lockdep_assert_held(&ar->conf_mutex);
583
0ed00eea
MK		 584 if (!ar->monitor_present) {
585 ath10k_warn("mac montor stop -- monitor is not present\n");
586 return -EINVAL;
587 }
588
589 if (!ar->monitor_enabled) {
590 ath10k_warn("mac montor stop -- monitor is not enabled\n");
591 return -EINVAL;
592 }
593
52fa0191
MP		 594 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
595 if (ret)
596 ath10k_warn("Monitor vdev down failed: %d\n", ret);
5e3dd157
KV		 597
598 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
599 if (ret)
600 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
601
602 ret = ath10k_vdev_setup_sync(ar);
603 if (ret)
604 ath10k_warn("Monitor_down sync failed: %d\n", ret);
605
606 ar->monitor_enabled = false;
607 return ret;
608}
609
610static int ath10k_monitor_create(struct ath10k *ar)
611{
612 int bit, ret = 0;
613
614 lockdep_assert_held(&ar->conf_mutex);
615
616 if (ar->monitor_present) {
617 ath10k_warn("Monitor mode already enabled\n");
618 return 0;
619 }
620
621 bit = ffs(ar->free_vdev_map);
622 if (bit == 0) {
623 ath10k_warn("No free VDEV slots\n");
624 return -ENOMEM;
625 }
626
627 ar->monitor_vdev_id = bit - 1;
628 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
629
630 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
631 WMI_VDEV_TYPE_MONITOR,
632 0, ar->mac_addr);
633 if (ret) {
634 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
635 goto vdev_fail;
636 }
637
60c3daa8 638 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
5e3dd157
KV		 639 ar->monitor_vdev_id);
640
641 ar->monitor_present = true;
642 return 0;
643
644vdev_fail:
645 /*
646 * Restore the ID to the global map.
647 */
648 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
649 return ret;
650}
651
652static int ath10k_monitor_destroy(struct ath10k *ar)
653{
654 int ret = 0;
655
656 lockdep_assert_held(&ar->conf_mutex);
657
658 if (!ar->monitor_present)
659 return 0;
660
661 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
662 if (ret) {
663 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret);
664 return ret;
665 }
666
667 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
668 ar->monitor_present = false;
669
60c3daa8 670 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
5e3dd157
KV		 671 ar->monitor_vdev_id);
672 return ret;
673}
674
e8a50f8b
MP		 675static int ath10k_start_cac(struct ath10k *ar)
676{
677 int ret;
678
679 lockdep_assert_held(&ar->conf_mutex);
680
681 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
682
683 ret = ath10k_monitor_create(ar);
684 if (ret) {
685 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
686 return ret;
687 }
688
689 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
690 if (ret) {
691 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
692 ath10k_monitor_destroy(ar);
693 return ret;
694 }
695
696 ath10k_dbg(ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
697 ar->monitor_vdev_id);
698
699 return 0;
700}
701
702static int ath10k_stop_cac(struct ath10k *ar)
703{
704 lockdep_assert_held(&ar->conf_mutex);
705
706 /* CAC is not running - do nothing */
707 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
708 return 0;
709
710 ath10k_monitor_stop(ar);
711 ath10k_monitor_destroy(ar);
712 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
713
714 ath10k_dbg(ATH10K_DBG_MAC, "mac cac finished\n");
715
716 return 0;
717}
718
719static const char *ath10k_dfs_state(enum nl80211_dfs_state dfs_state)
720{
721 switch (dfs_state) {
722 case NL80211_DFS_USABLE:
723 return "USABLE";
724 case NL80211_DFS_UNAVAILABLE:
725 return "UNAVAILABLE";
726 case NL80211_DFS_AVAILABLE:
727 return "AVAILABLE";
728 default:
729 WARN_ON(1);
730 return "bug";
731 }
732}
733
734static void ath10k_config_radar_detection(struct ath10k *ar)
735{
736 struct ieee80211_channel *chan = ar->hw->conf.chandef.chan;
737 bool radar = ar->hw->conf.radar_enabled;
738 bool chan_radar = !!(chan->flags & IEEE80211_CHAN_RADAR);
739 enum nl80211_dfs_state dfs_state = chan->dfs_state;
740 int ret;
741
742 lockdep_assert_held(&ar->conf_mutex);
743
744 ath10k_dbg(ATH10K_DBG_MAC,
745 "mac radar config update: chan %dMHz radar %d chan radar %d chan state %s\n",
746 chan->center_freq, radar, chan_radar,
747 ath10k_dfs_state(dfs_state));
748
749 /*
750 * It's safe to call it even if CAC is not started.
751 * This call here guarantees changing channel, etc. will stop CAC.
752 */
753 ath10k_stop_cac(ar);
754
755 if (!radar)
756 return;
757
758 if (!chan_radar)
759 return;
760
761 if (dfs_state != NL80211_DFS_USABLE)
762 return;
763
764 ret = ath10k_start_cac(ar);
765 if (ret) {
766 /*
767 * Not possible to start CAC on current channel so starting
768 * radiation is not allowed, make this channel DFS_UNAVAILABLE
769 * by indicating that radar was detected.
770 */
771 ath10k_warn("failed to start CAC (%d)\n", ret);
772 ieee80211_radar_detected(ar->hw);
773 }
774}
775
5e3dd157
KV		 776static void ath10k_control_beaconing(struct ath10k_vif *arvif,
777 struct ieee80211_bss_conf *info)
778{
779 int ret = 0;
780
548db54c
MK		 781 lockdep_assert_held(&arvif->ar->conf_mutex);
782
5e3dd157
KV		 783 if (!info->enable_beacon) {
784 ath10k_vdev_stop(arvif);
785 return;
786 }
787
788 arvif->tx_seq_no = 0x1000;
789
790 ret = ath10k_vdev_start(arvif);
791 if (ret)
792 return;
793
794 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
795 if (ret) {
796 ath10k_warn("Failed to bring up VDEV: %d\n",
797 arvif->vdev_id);
798 return;
799 }
60c3daa8 800 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
5e3dd157
KV		 801}
802
803static void ath10k_control_ibss(struct ath10k_vif *arvif,
804 struct ieee80211_bss_conf *info,
805 const u8 self_peer[ETH_ALEN])
806{
6d1506e7 807 u32 vdev_param;
5e3dd157
KV		 808 int ret = 0;
809
548db54c
MK		 810 lockdep_assert_held(&arvif->ar->conf_mutex);
811
5e3dd157
KV		 812 if (!info->ibss_joined) {
813 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
814 if (ret)
815 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
816 self_peer, arvif->vdev_id, ret);
817
818 if (is_zero_ether_addr(arvif->u.ibss.bssid))
819 return;
820
821 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
822 arvif->u.ibss.bssid);
823 if (ret) {
824 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
825 arvif->u.ibss.bssid, arvif->vdev_id, ret);
826 return;
827 }
828
829 memset(arvif->u.ibss.bssid, 0, ETH_ALEN);
830
831 return;
832 }
833
834 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
835 if (ret) {
836 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
837 self_peer, arvif->vdev_id, ret);
838 return;
839 }
840
6d1506e7
BM		 841 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
842 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 843 ATH10K_DEFAULT_ATIM);
844 if (ret)
845 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
846 arvif->vdev_id, ret);
847}
848
849/*
850 * Review this when mac80211 gains per-interface powersave support.
851 */
ad088bfa 852static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
5e3dd157 853{
ad088bfa
MK		 854 struct ath10k *ar = arvif->ar;
855 struct ieee80211_conf *conf = &ar->hw->conf;
5e3dd157
KV		 856 enum wmi_sta_powersave_param param;
857 enum wmi_sta_ps_mode psmode;
858 int ret;
859
548db54c
MK		 860 lockdep_assert_held(&arvif->ar->conf_mutex);
861
ad088bfa
MK		 862 if (arvif->vif->type != NL80211_IFTYPE_STATION)
863 return 0;
5e3dd157
KV		 864
865 if (conf->flags & IEEE80211_CONF_PS) {
866 psmode = WMI_STA_PS_MODE_ENABLED;
867 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
868
ad088bfa 869 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
5e3dd157
KV		 870 conf->dynamic_ps_timeout);
871 if (ret) {
872 ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
873 arvif->vdev_id);
ad088bfa 874 return ret;
5e3dd157 875 }
5e3dd157
KV		 876 } else {
877 psmode = WMI_STA_PS_MODE_DISABLED;
878 }
879
60c3daa8
KV		 880 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
881 arvif->vdev_id, psmode ? "enable" : "disable");
882
ad088bfa
MK		 883 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
884 if (ret) {
5e3dd157
KV		 885 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
886 psmode, arvif->vdev_id);
ad088bfa
MK		 887 return ret;
888 }
889
890 return 0;
5e3dd157
KV		 891}
892
893/**********************/
894/* Station management */
895/**********************/
896
897static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
898 struct ath10k_vif *arvif,
899 struct ieee80211_sta *sta,
900 struct ieee80211_bss_conf *bss_conf,
901 struct wmi_peer_assoc_complete_arg *arg)
902{
548db54c
MK		 903 lockdep_assert_held(&ar->conf_mutex);
904
5e3dd157
KV		 905 memcpy(arg->addr, sta->addr, ETH_ALEN);
906 arg->vdev_id = arvif->vdev_id;
907 arg->peer_aid = sta->aid;
908 arg->peer_flags |= WMI_PEER_AUTH;
909
910 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
911 /*
912 * Seems FW have problems with Power Save in STA
913 * mode when we setup this parameter to high (eg. 5).
914 * Often we see that FW don't send NULL (with clean P flags)
915 * frame even there is info about buffered frames in beacons.
916 * Sometimes we have to wait more than 10 seconds before FW
917 * will wakeup. Often sending one ping from AP to our device
918 * just fail (more than 50%).
919 *
920 * Seems setting this FW parameter to 1 couse FW
921 * will check every beacon and will wakup immediately
922 * after detection buffered data.
923 */
924 arg->peer_listen_intval = 1;
925 else
926 arg->peer_listen_intval = ar->hw->conf.listen_interval;
927
928 arg->peer_num_spatial_streams = 1;
929
930 /*
931 * The assoc capabilities are available only in managed mode.
932 */
933 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
934 arg->peer_caps = bss_conf->assoc_capability;
935}
936
937static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
938 struct ath10k_vif *arvif,
939 struct wmi_peer_assoc_complete_arg *arg)
940{
941 struct ieee80211_vif *vif = arvif->vif;
942 struct ieee80211_bss_conf *info = &vif->bss_conf;
943 struct cfg80211_bss *bss;
944 const u8 *rsnie = NULL;
945 const u8 *wpaie = NULL;
946
548db54c
MK		 947 lockdep_assert_held(&ar->conf_mutex);
948
5e3dd157
KV		 949 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
950 info->bssid, NULL, 0, 0, 0);
951 if (bss) {
952 const struct cfg80211_bss_ies *ies;
953
954 rcu_read_lock();
955 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
956
957 ies = rcu_dereference(bss->ies);
958
959 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
960 WLAN_OUI_TYPE_MICROSOFT_WPA,
961 ies->data,
962 ies->len);
963 rcu_read_unlock();
964 cfg80211_put_bss(ar->hw->wiphy, bss);
965 }
966
967 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
968 if (rsnie || wpaie) {
969 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
970 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
971 }
972
973 if (wpaie) {
974 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
975 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
976 }
977}
978
979static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
980 struct ieee80211_sta *sta,
981 struct wmi_peer_assoc_complete_arg *arg)
982{
983 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
984 const struct ieee80211_supported_band *sband;
985 const struct ieee80211_rate *rates;
986 u32 ratemask;
987 int i;
988
548db54c
MK		 989 lockdep_assert_held(&ar->conf_mutex);
990
5e3dd157
KV		 991 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
992 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
993 rates = sband->bitrates;
994
995 rateset->num_rates = 0;
996
997 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
998 if (!(ratemask & 1))
999 continue;
1000
1001 rateset->rates[rateset->num_rates] = rates->hw_value;
1002 rateset->num_rates++;
1003 }
1004}
1005
1006static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1007 struct ieee80211_sta *sta,
1008 struct wmi_peer_assoc_complete_arg *arg)
1009{
1010 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1011 int smps;
1012 int i, n;
1013
548db54c
MK		 1014 lockdep_assert_held(&ar->conf_mutex);
1015
5e3dd157
KV		 1016 if (!ht_cap->ht_supported)
1017 return;
1018
1019 arg->peer_flags |= WMI_PEER_HT;
1020 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1021 ht_cap->ampdu_factor)) - 1;
1022
1023 arg->peer_mpdu_density =
1024 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1025
1026 arg->peer_ht_caps = ht_cap->cap;
1027 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1028
1029 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1030 arg->peer_flags |= WMI_PEER_LDPC;
1031
1032 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1033 arg->peer_flags |= WMI_PEER_40MHZ;
1034 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1035 }
1036
1037 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1038 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1039
1040 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1041 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1042
1043 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1044 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1045 arg->peer_flags |= WMI_PEER_STBC;
1046 }
1047
1048 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1049 u32 stbc;
1050 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1051 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1052 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1053 arg->peer_rate_caps |= stbc;
1054 arg->peer_flags |= WMI_PEER_STBC;
1055 }
1056
1057 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1058 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1059
1060 if (smps == WLAN_HT_CAP_SM_PS_STATIC) {
1061 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
1062 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS;
1063 } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) {
1064 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
1065 arg->peer_flags |= WMI_PEER_DYN_MIMOPS;
1066 }
1067
1068 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1069 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1070 else if (ht_cap->mcs.rx_mask[1])
1071 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1072
1073 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1074 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1075 arg->peer_ht_rates.rates[n++] = i;
1076
1077 arg->peer_ht_rates.num_rates = n;
1078 arg->peer_num_spatial_streams = max((n+7) / 8, 1);
1079
60c3daa8
KV		 1080 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1081 arg->addr,
5e3dd157
KV		 1082 arg->peer_ht_rates.num_rates,
1083 arg->peer_num_spatial_streams);
1084}
1085
1086static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
1087 struct ath10k_vif *arvif,
1088 struct ieee80211_sta *sta,
1089 struct ieee80211_bss_conf *bss_conf,
1090 struct wmi_peer_assoc_complete_arg *arg)
1091{
1092 u32 uapsd = 0;
1093 u32 max_sp = 0;
1094
548db54c
MK		 1095 lockdep_assert_held(&ar->conf_mutex);
1096
5e3dd157
KV		 1097 if (sta->wme)
1098 arg->peer_flags |= WMI_PEER_QOS;
1099
1100 if (sta->wme && sta->uapsd_queues) {
60c3daa8 1101 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
5e3dd157
KV		 1102 sta->uapsd_queues, sta->max_sp);
1103
1104 arg->peer_flags |= WMI_PEER_APSD;
c69029b1 1105 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
5e3dd157
KV		 1106
1107 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1108 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1109 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1110 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1111 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1112 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1113 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1114 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1115 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1116 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1117 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1118 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1119
1120
1121 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1122 max_sp = sta->max_sp;
1123
1124 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1125 sta->addr,
1126 WMI_AP_PS_PEER_PARAM_UAPSD,
1127 uapsd);
1128
1129 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1130 sta->addr,
1131 WMI_AP_PS_PEER_PARAM_MAX_SP,
1132 max_sp);
1133
1134 /* TODO setup this based on STA listen interval and
1135 beacon interval. Currently we don't know
1136 sta->listen_interval - mac80211 patch required.
1137 Currently use 10 seconds */
1138 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1139 sta->addr,
1140 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1141 10);
1142 }
1143}
1144
1145static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar,
1146 struct ath10k_vif *arvif,
1147 struct ieee80211_sta *sta,
1148 struct ieee80211_bss_conf *bss_conf,
1149 struct wmi_peer_assoc_complete_arg *arg)
1150{
1151 if (bss_conf->qos)
1152 arg->peer_flags |= WMI_PEER_QOS;
1153}
1154
1155static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1156 struct ieee80211_sta *sta,
1157 struct wmi_peer_assoc_complete_arg *arg)
1158{
1159 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
a24b88b5 1160 u8 ampdu_factor;
5e3dd157
KV		 1161
1162 if (!vht_cap->vht_supported)
1163 return;
1164
1165 arg->peer_flags |= WMI_PEER_VHT;
5e3dd157
KV		 1166 arg->peer_vht_caps = vht_cap->cap;
1167
a24b88b5
SM		 1168
1169 ampdu_factor = (vht_cap->cap &
1170 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1171 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1172
1173 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1174 * zero in VHT IE. Using it would result in degraded throughput.
1175 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1176 * it if VHT max_mpdu is smaller. */
1177 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1178 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1179 ampdu_factor)) - 1);
1180
5e3dd157
KV		 1181 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1182 arg->peer_flags |= WMI_PEER_80MHZ;
1183
1184 arg->peer_vht_rates.rx_max_rate =
1185 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1186 arg->peer_vht_rates.rx_mcs_set =
1187 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1188 arg->peer_vht_rates.tx_max_rate =
1189 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1190 arg->peer_vht_rates.tx_mcs_set =
1191 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1192
60c3daa8
KV		 1193 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1194 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
5e3dd157
KV		 1195}
1196
1197static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1198 struct ath10k_vif *arvif,
1199 struct ieee80211_sta *sta,
1200 struct ieee80211_bss_conf *bss_conf,
1201 struct wmi_peer_assoc_complete_arg *arg)
1202{
1203 switch (arvif->vdev_type) {
1204 case WMI_VDEV_TYPE_AP:
1205 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg);
1206 break;
1207 case WMI_VDEV_TYPE_STA:
1208 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg);
1209 break;
1210 default:
1211 break;
1212 }
1213}
1214
1215static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1216 struct ath10k_vif *arvif,
1217 struct ieee80211_sta *sta,
1218 struct wmi_peer_assoc_complete_arg *arg)
1219{
1220 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1221
5e3dd157
KV		 1222 switch (ar->hw->conf.chandef.chan->band) {
1223 case IEEE80211_BAND_2GHZ:
1224 if (sta->ht_cap.ht_supported) {
1225 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1226 phymode = MODE_11NG_HT40;
1227 else
1228 phymode = MODE_11NG_HT20;
1229 } else {
1230 phymode = MODE_11G;
1231 }
1232
1233 break;
1234 case IEEE80211_BAND_5GHZ:
7cc45e98
SM		 1235 /*
1236 * Check VHT first.
1237 */
1238 if (sta->vht_cap.vht_supported) {
1239 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1240 phymode = MODE_11AC_VHT80;
1241 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1242 phymode = MODE_11AC_VHT40;
1243 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1244 phymode = MODE_11AC_VHT20;
1245 } else if (sta->ht_cap.ht_supported) {
5e3dd157
KV		 1246 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1247 phymode = MODE_11NA_HT40;
1248 else
1249 phymode = MODE_11NA_HT20;
1250 } else {
1251 phymode = MODE_11A;
1252 }
1253
1254 break;
1255 default:
1256 break;
1257 }
1258
38a1d47e
KV		 1259 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1260 sta->addr, ath10k_wmi_phymode_str(phymode));
60c3daa8 1261
5e3dd157
KV		 1262 arg->peer_phymode = phymode;
1263 WARN_ON(phymode == MODE_UNKNOWN);
1264}
1265
b9ada65d
KV		 1266static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1267 struct ath10k_vif *arvif,
1268 struct ieee80211_sta *sta,
1269 struct ieee80211_bss_conf *bss_conf,
1270 struct wmi_peer_assoc_complete_arg *arg)
5e3dd157 1271{
548db54c
MK		 1272 lockdep_assert_held(&ar->conf_mutex);
1273
b9ada65d 1274 memset(arg, 0, sizeof(*arg));
5e3dd157 1275
b9ada65d
KV		 1276 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1277 ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1278 ath10k_peer_assoc_h_rates(ar, sta, arg);
1279 ath10k_peer_assoc_h_ht(ar, sta, arg);
1280 ath10k_peer_assoc_h_vht(ar, sta, arg);
1281 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1282 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
5e3dd157 1283
b9ada65d 1284 return 0;
5e3dd157
KV		 1285}
1286
1287/* can be called only in mac80211 callbacks due to `key_count` usage */
1288static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1289 struct ieee80211_vif *vif,
1290 struct ieee80211_bss_conf *bss_conf)
1291{
1292 struct ath10k *ar = hw->priv;
1293 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
b9ada65d 1294 struct wmi_peer_assoc_complete_arg peer_arg;
5e3dd157
KV		 1295 struct ieee80211_sta *ap_sta;
1296 int ret;
1297
548db54c
MK		 1298 lockdep_assert_held(&ar->conf_mutex);
1299
5e3dd157
KV		 1300 rcu_read_lock();
1301
1302 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1303 if (!ap_sta) {
1304 ath10k_warn("Failed to find station entry for %pM\n",
1305 bss_conf->bssid);
1306 rcu_read_unlock();
1307 return;
1308 }
1309
b9ada65d
KV		 1310 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1311 bss_conf, &peer_arg);
5e3dd157 1312 if (ret) {
b9ada65d
KV		 1313 ath10k_warn("Peer assoc prepare failed for %pM\n: %d",
1314 bss_conf->bssid, ret);
5e3dd157
KV		 1315 rcu_read_unlock();
1316 return;
1317 }
1318
1319 rcu_read_unlock();
1320
b9ada65d
KV		 1321 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1322 if (ret) {
1323 ath10k_warn("Peer assoc failed for %pM\n: %d",
1324 bss_conf->bssid, ret);
1325 return;
1326 }
1327
60c3daa8
KV		 1328 ath10k_dbg(ATH10K_DBG_MAC,
1329 "mac vdev %d up (associated) bssid %pM aid %d\n",
1330 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1331
5e3dd157
KV		 1332 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
1333 bss_conf->bssid);
1334 if (ret)
1335 ath10k_warn("VDEV: %d up failed: ret %d\n",
1336 arvif->vdev_id, ret);
5e3dd157
KV		 1337}
1338
1339/*
1340 * FIXME: flush TIDs
1341 */
1342static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1343 struct ieee80211_vif *vif)
1344{
1345 struct ath10k *ar = hw->priv;
1346 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1347 int ret;
1348
548db54c
MK		 1349 lockdep_assert_held(&ar->conf_mutex);
1350
5e3dd157
KV		 1351 /*
1352 * For some reason, calling VDEV-DOWN before VDEV-STOP
1353 * makes the FW to send frames via HTT after disassociation.
1354 * No idea why this happens, even though VDEV-DOWN is supposed
1355 * to be analogous to link down, so just stop the VDEV.
1356 */
60c3daa8
KV		 1357 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1358 arvif->vdev_id);
1359
1360 /* FIXME: check return value */
5e3dd157 1361 ret = ath10k_vdev_stop(arvif);
5e3dd157
KV		 1362
1363 /*
1364 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1365 * report beacons from previously associated network through HTT.
1366 * This in turn would spam mac80211 WARN_ON if we bring down all
1367 * interfaces as it expects there is no rx when no interface is
1368 * running.
1369 */
60c3daa8
KV		 1370 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1371
1372 /* FIXME: why don't we print error if wmi call fails? */
5e3dd157 1373 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
5e3dd157 1374
cc4827b9 1375 arvif->def_wep_key_idx = 0;
5e3dd157
KV		 1376}
1377
1378static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1379 struct ieee80211_sta *sta)
1380{
b9ada65d 1381 struct wmi_peer_assoc_complete_arg peer_arg;
5e3dd157
KV		 1382 int ret = 0;
1383
548db54c
MK		 1384 lockdep_assert_held(&ar->conf_mutex);
1385
b9ada65d
KV		 1386 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1387 if (ret) {
1388 ath10k_warn("WMI peer assoc prepare failed for %pM\n",
1389 sta->addr);
1390 return ret;
1391 }
1392
1393 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
5e3dd157 1394 if (ret) {
b9ada65d
KV		 1395 ath10k_warn("Peer assoc failed for STA %pM\n: %d",
1396 sta->addr, ret);
5e3dd157
KV		 1397 return ret;
1398 }
1399
1400 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1401 if (ret) {
1402 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1403 return ret;
1404 }
1405
1406 return ret;
1407}
1408
1409static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1410 struct ieee80211_sta *sta)
1411{
1412 int ret = 0;
1413
548db54c
MK		 1414 lockdep_assert_held(&ar->conf_mutex);
1415
5e3dd157
KV		 1416 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1417 if (ret) {
1418 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1419 return ret;
1420 }
1421
1422 return ret;
1423}
1424
1425/**************/
1426/* Regulatory */
1427/**************/
1428
1429static int ath10k_update_channel_list(struct ath10k *ar)
1430{
1431 struct ieee80211_hw *hw = ar->hw;
1432 struct ieee80211_supported_band **bands;
1433 enum ieee80211_band band;
1434 struct ieee80211_channel *channel;
1435 struct wmi_scan_chan_list_arg arg = {0};
1436 struct wmi_channel_arg *ch;
1437 bool passive;
1438 int len;
1439 int ret;
1440 int i;
1441
548db54c
MK		 1442 lockdep_assert_held(&ar->conf_mutex);
1443
5e3dd157
KV		 1444 bands = hw->wiphy->bands;
1445 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1446 if (!bands[band])
1447 continue;
1448
1449 for (i = 0; i < bands[band]->n_channels; i++) {
1450 if (bands[band]->channels[i].flags &
1451 IEEE80211_CHAN_DISABLED)
1452 continue;
1453
1454 arg.n_channels++;
1455 }
1456 }
1457
1458 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1459 arg.channels = kzalloc(len, GFP_KERNEL);
1460 if (!arg.channels)
1461 return -ENOMEM;
1462
1463 ch = arg.channels;
1464 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1465 if (!bands[band])
1466 continue;
1467
1468 for (i = 0; i < bands[band]->n_channels; i++) {
1469 channel = &bands[band]->channels[i];
1470
1471 if (channel->flags & IEEE80211_CHAN_DISABLED)
1472 continue;
1473
1474 ch->allow_ht = true;
1475
1476 /* FIXME: when should we really allow VHT? */
1477 ch->allow_vht = true;
1478
1479 ch->allow_ibss =
8fe02e16 1480 !(channel->flags & IEEE80211_CHAN_NO_IR);
5e3dd157
KV		 1481
1482 ch->ht40plus =
1483 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1484
e8a50f8b
MP		 1485 ch->chan_radar =
1486 !!(channel->flags & IEEE80211_CHAN_RADAR);
1487
8fe02e16 1488 passive = channel->flags & IEEE80211_CHAN_NO_IR;
5e3dd157
KV		 1489 ch->passive = passive;
1490
1491 ch->freq = channel->center_freq;
89c5c843 1492 ch->min_power = 0;
02256930
MK		 1493 ch->max_power = channel->max_power * 2;
1494 ch->max_reg_power = channel->max_reg_power * 2;
1495 ch->max_antenna_gain = channel->max_antenna_gain * 2;
5e3dd157
KV		 1496 ch->reg_class_id = 0; /* FIXME */
1497
1498 /* FIXME: why use only legacy modes, why not any
1499 * HT/VHT modes? Would that even make any
1500 * difference? */
1501 if (channel->band == IEEE80211_BAND_2GHZ)
1502 ch->mode = MODE_11G;
1503 else
1504 ch->mode = MODE_11A;
1505
1506 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1507 continue;
1508
1509 ath10k_dbg(ATH10K_DBG_WMI,
60c3daa8
KV		 1510 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1511 ch - arg.channels, arg.n_channels,
5e3dd157
KV		 1512 ch->freq, ch->max_power, ch->max_reg_power,
1513 ch->max_antenna_gain, ch->mode);
1514
1515 ch++;
1516 }
1517 }
1518
1519 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1520 kfree(arg.channels);
1521
1522 return ret;
1523}
1524
f7843d7f 1525static void ath10k_regd_update(struct ath10k *ar)
5e3dd157 1526{
5e3dd157 1527 struct reg_dmn_pair_mapping *regpair;
5e3dd157
KV		 1528 int ret;
1529
f7843d7f 1530 lockdep_assert_held(&ar->conf_mutex);
5e3dd157
KV		 1531
1532 ret = ath10k_update_channel_list(ar);
1533 if (ret)
1534 ath10k_warn("could not update channel list (%d)\n", ret);
1535
1536 regpair = ar->ath_common.regulatory.regpair;
f7843d7f 1537
5e3dd157
KV		 1538 /* Target allows setting up per-band regdomain but ath_common provides
1539 * a combined one only */
1540 ret = ath10k_wmi_pdev_set_regdomain(ar,
1541 regpair->regDmnEnum,
1542 regpair->regDmnEnum, /* 2ghz */
1543 regpair->regDmnEnum, /* 5ghz */
1544 regpair->reg_2ghz_ctl,
1545 regpair->reg_5ghz_ctl);
1546 if (ret)
1547 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
f7843d7f 1548}
548db54c 1549
f7843d7f
MK		 1550static void ath10k_reg_notifier(struct wiphy *wiphy,
1551 struct regulatory_request *request)
1552{
1553 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1554 struct ath10k *ar = hw->priv;
9702c686 1555 bool result;
f7843d7f
MK		 1556
1557 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1558
9702c686
JD		 1559 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1560 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1561 request->dfs_region);
1562 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1563 request->dfs_region);
1564 if (!result)
1565 ath10k_warn("dfs region 0x%X not supported, will trigger radar for every pulse\n",
1566 request->dfs_region);
1567 }
1568
f7843d7f
MK		 1569 mutex_lock(&ar->conf_mutex);
1570 if (ar->state == ATH10K_STATE_ON)
1571 ath10k_regd_update(ar);
548db54c 1572 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 1573}
1574
1575/***************/
1576/* TX handlers */
1577/***************/
1578
42c3aa6f
MK		 1579static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1580{
1581 if (ieee80211_is_mgmt(hdr->frame_control))
1582 return HTT_DATA_TX_EXT_TID_MGMT;
1583
1584 if (!ieee80211_is_data_qos(hdr->frame_control))
1585 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1586
1587 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1588 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1589
1590 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1591}
1592
ddb6ad77
MK		 1593static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar,
1594 struct ieee80211_tx_info *info)
1595{
1596 if (info->control.vif)
1597 return ath10k_vif_to_arvif(info->control.vif)->vdev_id;
1598
1599 if (ar->monitor_enabled)
1600 return ar->monitor_vdev_id;
1601
1602 ath10k_warn("could not resolve vdev id\n");
1603 return 0;
1604}
1605
5e3dd157
KV		 1606/*
1607 * Frames sent to the FW have to be in "Native Wifi" format.
1608 * Strip the QoS field from the 802.11 header.
1609 */
1610static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1611 struct ieee80211_tx_control *control,
1612 struct sk_buff *skb)
1613{
1614 struct ieee80211_hdr *hdr = (void *)skb->data;
1615 u8 *qos_ctl;
1616
1617 if (!ieee80211_is_data_qos(hdr->frame_control))
1618 return;
1619
1620 qos_ctl = ieee80211_get_qos_ctl(hdr);
ba0ccd7a
MK		 1621 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1622 skb->data, (void *)qos_ctl - (void *)skb->data);
1623 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
5e3dd157
KV		 1624}
1625
cc4827b9
MK		 1626static void ath10k_tx_wep_key_work(struct work_struct *work)
1627{
1628 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1629 wep_key_work);
1630 int ret, keyidx = arvif->def_wep_key_newidx;
1631
1632 if (arvif->def_wep_key_idx == keyidx)
1633 return;
1634
1635 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1636 arvif->vdev_id, keyidx);
1637
1638 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1639 arvif->vdev_id,
1640 arvif->ar->wmi.vdev_param->def_keyid,
1641 keyidx);
1642 if (ret) {
1643 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1644 return;
1645 }
1646
1647 arvif->def_wep_key_idx = keyidx;
1648}
1649
5e3dd157
KV		 1650static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1651{
1652 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1653 struct ieee80211_vif *vif = info->control.vif;
1654 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1655 struct ath10k *ar = arvif->ar;
1656 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1657 struct ieee80211_key_conf *key = info->control.hw_key;
5e3dd157 1658
5e3dd157
KV		 1659 if (!ieee80211_has_protected(hdr->frame_control))
1660 return;
1661
1662 if (!key)
1663 return;
1664
1665 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1666 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1667 return;
1668
cc4827b9 1669 if (key->keyidx == arvif->def_wep_key_idx)
5e3dd157 1670 return;
5e3dd157 1671
cc4827b9
MK		 1672 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1673 * queueing frames until key index is updated is not an option because
1674 * sk_buff may need more processing to be done, e.g. offchannel */
1675 arvif->def_wep_key_newidx = key->keyidx;
1676 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
5e3dd157
KV		 1677}
1678
1679static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1680{
1681 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1682 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1683 struct ieee80211_vif *vif = info->control.vif;
1684 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1685
1686 /* This is case only for P2P_GO */
1687 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1688 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1689 return;
1690
1691 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1692 spin_lock_bh(&ar->data_lock);
1693 if (arvif->u.ap.noa_data)
1694 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1695 GFP_ATOMIC))
1696 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1697 arvif->u.ap.noa_data,
1698 arvif->u.ap.noa_len);
1699 spin_unlock_bh(&ar->data_lock);
1700 }
1701}
1702
1703static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1704{
1705 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5e00d31a 1706 int ret = 0;
5e3dd157 1707
961d4c38
MK		 1708 if (ar->htt.target_version_major >= 3) {
1709 /* Since HTT 3.0 there is no separate mgmt tx command */
1710 ret = ath10k_htt_tx(&ar->htt, skb);
1711 goto exit;
1712 }
1713
5e00d31a
BM		 1714 if (ieee80211_is_mgmt(hdr->frame_control)) {
1715 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1716 ar->fw_features)) {
1717 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
1718 ATH10K_MAX_NUM_MGMT_PENDING) {
1719 ath10k_warn("wmi mgmt_tx queue limit reached\n");
1720 ret = -EBUSY;
1721 goto exit;
1722 }
1723
1724 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
1725 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
1726 } else {
1727 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1728 }
1729 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1730 ar->fw_features) &&
1731 ieee80211_is_nullfunc(hdr->frame_control)) {
5e3dd157
KV		 1732 /* FW does not report tx status properly for NullFunc frames
1733 * unless they are sent through mgmt tx path. mac80211 sends
5e00d31a
BM		 1734 * those frames when it detects link/beacon loss and depends
1735 * on the tx status to be correct. */
edb8236d 1736 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
5e00d31a 1737 } else {
edb8236d 1738 ret = ath10k_htt_tx(&ar->htt, skb);
5e00d31a 1739 }
5e3dd157 1740
961d4c38 1741exit:
5e3dd157
KV		 1742 if (ret) {
1743 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1744 ieee80211_free_txskb(ar->hw, skb);
1745 }
1746}
1747
1748void ath10k_offchan_tx_purge(struct ath10k *ar)
1749{
1750 struct sk_buff *skb;
1751
1752 for (;;) {
1753 skb = skb_dequeue(&ar->offchan_tx_queue);
1754 if (!skb)
1755 break;
1756
1757 ieee80211_free_txskb(ar->hw, skb);
1758 }
1759}
1760
1761void ath10k_offchan_tx_work(struct work_struct *work)
1762{
1763 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1764 struct ath10k_peer *peer;
1765 struct ieee80211_hdr *hdr;
1766 struct sk_buff *skb;
1767 const u8 *peer_addr;
1768 int vdev_id;
1769 int ret;
1770
1771 /* FW requirement: We must create a peer before FW will send out
1772 * an offchannel frame. Otherwise the frame will be stuck and
1773 * never transmitted. We delete the peer upon tx completion.
1774 * It is unlikely that a peer for offchannel tx will already be
1775 * present. However it may be in some rare cases so account for that.
1776 * Otherwise we might remove a legitimate peer and break stuff. */
1777
1778 for (;;) {
1779 skb = skb_dequeue(&ar->offchan_tx_queue);
1780 if (!skb)
1781 break;
1782
1783 mutex_lock(&ar->conf_mutex);
1784
60c3daa8 1785 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
5e3dd157
KV		 1786 skb);
1787
1788 hdr = (struct ieee80211_hdr *)skb->data;
1789 peer_addr = ieee80211_get_DA(hdr);
5e00d31a 1790 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
5e3dd157
KV		 1791
1792 spin_lock_bh(&ar->data_lock);
1793 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1794 spin_unlock_bh(&ar->data_lock);
1795
1796 if (peer)
60c3daa8 1797 /* FIXME: should this use ath10k_warn()? */
5e3dd157
KV		 1798 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1799 peer_addr, vdev_id);
1800
1801 if (!peer) {
1802 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1803 if (ret)
1804 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1805 peer_addr, vdev_id, ret);
1806 }
1807
1808 spin_lock_bh(&ar->data_lock);
16735d02 1809 reinit_completion(&ar->offchan_tx_completed);
5e3dd157
KV		 1810 ar->offchan_tx_skb = skb;
1811 spin_unlock_bh(&ar->data_lock);
1812
1813 ath10k_tx_htt(ar, skb);
1814
1815 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1816 3 * HZ);
1817 if (ret <= 0)
1818 ath10k_warn("timed out waiting for offchannel skb %p\n",
1819 skb);
1820
1821 if (!peer) {
1822 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1823 if (ret)
1824 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1825 peer_addr, vdev_id, ret);
1826 }
1827
1828 mutex_unlock(&ar->conf_mutex);
1829 }
1830}
1831
5e00d31a
BM		 1832void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
1833{
1834 struct sk_buff *skb;
1835
1836 for (;;) {
1837 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
1838 if (!skb)
1839 break;
1840
1841 ieee80211_free_txskb(ar->hw, skb);
1842 }
1843}
1844
1845void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
1846{
1847 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
1848 struct sk_buff *skb;
1849 int ret;
1850
1851 for (;;) {
1852 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
1853 if (!skb)
1854 break;
1855
1856 ret = ath10k_wmi_mgmt_tx(ar, skb);
5fb5e41f 1857 if (ret) {
5e00d31a 1858 ath10k_warn("wmi mgmt_tx failed (%d)\n", ret);
5fb5e41f
MK		 1859 ieee80211_free_txskb(ar->hw, skb);
1860 }
5e00d31a
BM		 1861 }
1862}
1863
5e3dd157
KV		 1864/************/
1865/* Scanning */
1866/************/
1867
1868/*
1869 * This gets called if we dont get a heart-beat during scan.
1870 * This may indicate the FW has hung and we need to abort the
1871 * scan manually to prevent cancel_hw_scan() from deadlocking
1872 */
1873void ath10k_reset_scan(unsigned long ptr)
1874{
1875 struct ath10k *ar = (struct ath10k *)ptr;
1876
1877 spin_lock_bh(&ar->data_lock);
1878 if (!ar->scan.in_progress) {
1879 spin_unlock_bh(&ar->data_lock);
1880 return;
1881 }
1882
1883 ath10k_warn("scan timeout. resetting. fw issue?\n");
1884
1885 if (ar->scan.is_roc)
1886 ieee80211_remain_on_channel_expired(ar->hw);
1887 else
1888 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
1889
1890 ar->scan.in_progress = false;
1891 complete_all(&ar->scan.completed);
1892 spin_unlock_bh(&ar->data_lock);
1893}
1894
1895static int ath10k_abort_scan(struct ath10k *ar)
1896{
1897 struct wmi_stop_scan_arg arg = {
1898 .req_id = 1, /* FIXME */
1899 .req_type = WMI_SCAN_STOP_ONE,
1900 .u.scan_id = ATH10K_SCAN_ID,
1901 };
1902 int ret;
1903
1904 lockdep_assert_held(&ar->conf_mutex);
1905
1906 del_timer_sync(&ar->scan.timeout);
1907
1908 spin_lock_bh(&ar->data_lock);
1909 if (!ar->scan.in_progress) {
1910 spin_unlock_bh(&ar->data_lock);
1911 return 0;
1912 }
1913
1914 ar->scan.aborting = true;
1915 spin_unlock_bh(&ar->data_lock);
1916
1917 ret = ath10k_wmi_stop_scan(ar, &arg);
1918 if (ret) {
1919 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
adb8c9b7
MK		 1920 spin_lock_bh(&ar->data_lock);
1921 ar->scan.in_progress = false;
1922 ath10k_offchan_tx_purge(ar);
1923 spin_unlock_bh(&ar->data_lock);
5e3dd157
KV		 1924 return -EIO;
1925 }
1926
5e3dd157
KV		 1927 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
1928 if (ret == 0)
1929 ath10k_warn("timed out while waiting for scan to stop\n");
1930
1931 /* scan completion may be done right after we timeout here, so let's
1932 * check the in_progress and tell mac80211 scan is completed. if we
1933 * don't do that and FW fails to send us scan completion indication
1934 * then userspace won't be able to scan anymore */
1935 ret = 0;
1936
1937 spin_lock_bh(&ar->data_lock);
1938 if (ar->scan.in_progress) {
1939 ath10k_warn("could not stop scan. its still in progress\n");
1940 ar->scan.in_progress = false;
1941 ath10k_offchan_tx_purge(ar);
1942 ret = -ETIMEDOUT;
1943 }
1944 spin_unlock_bh(&ar->data_lock);
1945
1946 return ret;
1947}
1948
1949static int ath10k_start_scan(struct ath10k *ar,
1950 const struct wmi_start_scan_arg *arg)
1951{
1952 int ret;
1953
1954 lockdep_assert_held(&ar->conf_mutex);
1955
1956 ret = ath10k_wmi_start_scan(ar, arg);
1957 if (ret)
1958 return ret;
1959
5e3dd157
KV		 1960 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
1961 if (ret == 0) {
1962 ath10k_abort_scan(ar);
1963 return ret;
1964 }
1965
1966 /* the scan can complete earlier, before we even
1967 * start the timer. in that case the timer handler
1968 * checks ar->scan.in_progress and bails out if its
1969 * false. Add a 200ms margin to account event/command
1970 * processing. */
1971 mod_timer(&ar->scan.timeout, jiffies +
1972 msecs_to_jiffies(arg->max_scan_time+200));
1973 return 0;
1974}
1975
1976/**********************/
1977/* mac80211 callbacks */
1978/**********************/
1979
1980static void ath10k_tx(struct ieee80211_hw *hw,
1981 struct ieee80211_tx_control *control,
1982 struct sk_buff *skb)
1983{
1984 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1985 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1986 struct ath10k *ar = hw->priv;
ddb6ad77 1987 u8 tid, vdev_id;
5e3dd157
KV		 1988
1989 /* We should disable CCK RATE due to P2P */
1990 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
1991 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
1992
1993 /* we must calculate tid before we apply qos workaround
1994 * as we'd lose the qos control field */
42c3aa6f 1995 tid = ath10k_tx_h_get_tid(hdr);
ddb6ad77 1996 vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
5e3dd157 1997
cf84bd4d
MK		 1998 /* it makes no sense to process injected frames like that */
1999 if (info->control.vif &&
2000 info->control.vif->type != NL80211_IFTYPE_MONITOR) {
2001 ath10k_tx_h_qos_workaround(hw, control, skb);
2002 ath10k_tx_h_update_wep_key(skb);
2003 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
2004 ath10k_tx_h_seq_no(skb);
2005 }
5e3dd157 2006
5e00d31a 2007 ATH10K_SKB_CB(skb)->vdev_id = vdev_id;
27bb178d 2008 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
5e3dd157
KV		 2009 ATH10K_SKB_CB(skb)->htt.tid = tid;
2010
2011 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2012 spin_lock_bh(&ar->data_lock);
2013 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
5e00d31a 2014 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
5e3dd157
KV		 2015 spin_unlock_bh(&ar->data_lock);
2016
2017 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2018
2019 skb_queue_tail(&ar->offchan_tx_queue, skb);
2020 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2021 return;
2022 }
2023
2024 ath10k_tx_htt(ar, skb);
2025}
2026
2027/*
2028 * Initialize various parameters with default vaules.
2029 */
affd3217 2030void ath10k_halt(struct ath10k *ar)
818bdd16
MK		 2031{
2032 lockdep_assert_held(&ar->conf_mutex);
2033
e8a50f8b 2034 ath10k_stop_cac(ar);
818bdd16
MK		 2035 del_timer_sync(&ar->scan.timeout);
2036 ath10k_offchan_tx_purge(ar);
5e00d31a 2037 ath10k_mgmt_over_wmi_tx_purge(ar);
818bdd16
MK		 2038 ath10k_peer_cleanup_all(ar);
2039 ath10k_core_stop(ar);
2040 ath10k_hif_power_down(ar);
2041
2042 spin_lock_bh(&ar->data_lock);
2043 if (ar->scan.in_progress) {
2044 del_timer(&ar->scan.timeout);
2045 ar->scan.in_progress = false;
2046 ieee80211_scan_completed(ar->hw, true);
2047 }
2048 spin_unlock_bh(&ar->data_lock);
2049}
2050
5e3dd157
KV		 2051static int ath10k_start(struct ieee80211_hw *hw)
2052{
2053 struct ath10k *ar = hw->priv;
818bdd16 2054 int ret = 0;
5e3dd157 2055
548db54c
MK		 2056 mutex_lock(&ar->conf_mutex);
2057
affd3217
MK		 2058 if (ar->state != ATH10K_STATE_OFF &&
2059 ar->state != ATH10K_STATE_RESTARTING) {
818bdd16
MK		 2060 ret = -EINVAL;
2061 goto exit;
2062 }
2063
2064 ret = ath10k_hif_power_up(ar);
2065 if (ret) {
2066 ath10k_err("could not init hif (%d)\n", ret);
2067 ar->state = ATH10K_STATE_OFF;
2068 goto exit;
2069 }
2070
2071 ret = ath10k_core_start(ar);
2072 if (ret) {
2073 ath10k_err("could not init core (%d)\n", ret);
2074 ath10k_hif_power_down(ar);
2075 ar->state = ATH10K_STATE_OFF;
2076 goto exit;
2077 }
2078
affd3217
MK		 2079 if (ar->state == ATH10K_STATE_OFF)
2080 ar->state = ATH10K_STATE_ON;
2081 else if (ar->state == ATH10K_STATE_RESTARTING)
2082 ar->state = ATH10K_STATE_RESTARTED;
2083
226a339b 2084 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
5e3dd157
KV		 2085 if (ret)
2086 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
2087 ret);
2088
c4dd0d01 2089 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
5e3dd157
KV		 2090 if (ret)
2091 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
2092 ret);
2093
f7843d7f
MK		 2094 ath10k_regd_update(ar);
2095
818bdd16 2096exit:
548db54c 2097 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 2098 return 0;
2099}
2100
2101static void ath10k_stop(struct ieee80211_hw *hw)
2102{
2103 struct ath10k *ar = hw->priv;
2104
548db54c 2105 mutex_lock(&ar->conf_mutex);
affd3217
MK		 2106 if (ar->state == ATH10K_STATE_ON ||
2107 ar->state == ATH10K_STATE_RESTARTED ||
2108 ar->state == ATH10K_STATE_WEDGED)
818bdd16 2109 ath10k_halt(ar);
a96d7745 2110
f7843d7f 2111 ar->state = ATH10K_STATE_OFF;
548db54c
MK		 2112 mutex_unlock(&ar->conf_mutex);
2113
5e00d31a
BM		 2114 ath10k_mgmt_over_wmi_tx_purge(ar);
2115
548db54c 2116 cancel_work_sync(&ar->offchan_tx_work);
5e00d31a 2117 cancel_work_sync(&ar->wmi_mgmt_tx_work);
affd3217 2118 cancel_work_sync(&ar->restart_work);
5e3dd157
KV		 2119}
2120
ad088bfa 2121static int ath10k_config_ps(struct ath10k *ar)
5e3dd157 2122{
ad088bfa
MK		 2123 struct ath10k_vif *arvif;
2124 int ret = 0;
affd3217
MK		 2125
2126 lockdep_assert_held(&ar->conf_mutex);
2127
ad088bfa
MK		 2128 list_for_each_entry(arvif, &ar->arvifs, list) {
2129 ret = ath10k_mac_vif_setup_ps(arvif);
2130 if (ret) {
2131 ath10k_warn("could not setup powersave (%d)\n", ret);
2132 break;
2133 }
2134 }
affd3217 2135
ad088bfa 2136 return ret;
affd3217
MK		 2137}
2138
2139static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2140{
5e3dd157
KV		 2141 struct ath10k *ar = hw->priv;
2142 struct ieee80211_conf *conf = &hw->conf;
2143 int ret = 0;
5474efe8 2144 u32 param;
5e3dd157
KV		 2145
2146 mutex_lock(&ar->conf_mutex);
2147
2148 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
e8a50f8b
MP		 2149 ath10k_dbg(ATH10K_DBG_MAC,
2150 "mac config channel %d mhz flags 0x%x\n",
2151 conf->chandef.chan->center_freq,
2152 conf->chandef.chan->flags);
2153
5e3dd157
KV		 2154 spin_lock_bh(&ar->data_lock);
2155 ar->rx_channel = conf->chandef.chan;
2156 spin_unlock_bh(&ar->data_lock);
e8a50f8b
MP		 2157
2158 ath10k_config_radar_detection(ar);
5e3dd157
KV		 2159 }
2160
5474efe8
MK		 2161 if (changed & IEEE80211_CONF_CHANGE_POWER) {
2162 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2163 hw->conf.power_level);
2164
2165 param = ar->wmi.pdev_param->txpower_limit2g;
2166 ret = ath10k_wmi_pdev_set_param(ar, param,
2167 hw->conf.power_level * 2);
2168 if (ret)
2169 ath10k_warn("mac failed to set 2g txpower %d (%d)\n",
2170 hw->conf.power_level, ret);
2171
2172 param = ar->wmi.pdev_param->txpower_limit5g;
2173 ret = ath10k_wmi_pdev_set_param(ar, param,
2174 hw->conf.power_level * 2);
2175 if (ret)
2176 ath10k_warn("mac failed to set 5g txpower %d (%d)\n",
2177 hw->conf.power_level, ret);
5e3dd157
KV		 2178 }
2179
affd3217
MK		 2180 if (changed & IEEE80211_CONF_CHANGE_PS)
2181 ath10k_config_ps(ar);
5e3dd157
KV		 2182
2183 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2184 if (conf->flags & IEEE80211_CONF_MONITOR)
2185 ret = ath10k_monitor_create(ar);
2186 else
2187 ret = ath10k_monitor_destroy(ar);
2188 }
2189
2190 mutex_unlock(&ar->conf_mutex);
2191 return ret;
2192}
2193
2194/*
2195 * TODO:
2196 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2197 * because we will send mgmt frames without CCK. This requirement
2198 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2199 * in the TX packet.
2200 */
2201static int ath10k_add_interface(struct ieee80211_hw *hw,
2202 struct ieee80211_vif *vif)
2203{
2204 struct ath10k *ar = hw->priv;
2205 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2206 enum wmi_sta_powersave_param param;
2207 int ret = 0;
424121c3 2208 u32 value;
5e3dd157 2209 int bit;
6d1506e7 2210 u32 vdev_param;
5e3dd157
KV		 2211
2212 mutex_lock(&ar->conf_mutex);
2213
0dbd09e6
MK		 2214 memset(arvif, 0, sizeof(*arvif));
2215
5e3dd157
KV		 2216 arvif->ar = ar;
2217 arvif->vif = vif;
2218
cc4827b9 2219 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
e63b33f3 2220 INIT_LIST_HEAD(&arvif->list);
cc4827b9 2221
5e3dd157
KV		 2222 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
2223 ath10k_warn("Only one monitor interface allowed\n");
2224 ret = -EBUSY;
9dad14ae 2225 goto err;
5e3dd157
KV		 2226 }
2227
2228 bit = ffs(ar->free_vdev_map);
2229 if (bit == 0) {
2230 ret = -EBUSY;
9dad14ae 2231 goto err;
5e3dd157
KV		 2232 }
2233
2234 arvif->vdev_id = bit - 1;
2235 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
5e3dd157
KV		 2236
2237 if (ar->p2p)
2238 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2239
2240 switch (vif->type) {
2241 case NL80211_IFTYPE_UNSPECIFIED:
2242 case NL80211_IFTYPE_STATION:
2243 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2244 if (vif->p2p)
2245 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2246 break;
2247 case NL80211_IFTYPE_ADHOC:
2248 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2249 break;
2250 case NL80211_IFTYPE_AP:
2251 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2252
2253 if (vif->p2p)
2254 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2255 break;
2256 case NL80211_IFTYPE_MONITOR:
2257 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2258 break;
2259 default:
2260 WARN_ON(1);
2261 break;
2262 }
2263
60c3daa8 2264 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
5e3dd157
KV		 2265 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2266
2267 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2268 arvif->vdev_subtype, vif->addr);
2269 if (ret) {
2270 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
9dad14ae 2271 goto err;
5e3dd157
KV		 2272 }
2273
9dad14ae 2274 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
0579119f 2275 list_add(&arvif->list, &ar->arvifs);
9dad14ae 2276
6d1506e7
BM		 2277 vdev_param = ar->wmi.vdev_param->def_keyid;
2278 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
cc4827b9 2279 arvif->def_wep_key_idx);
9dad14ae 2280 if (ret) {
5e3dd157 2281 ath10k_warn("Failed to set default keyid: %d\n", ret);
9dad14ae
MK		 2282 goto err_vdev_delete;
2283 }
5e3dd157 2284
6d1506e7
BM		 2285 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2286 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157 2287 ATH10K_HW_TXRX_NATIVE_WIFI);
ebc9abdd 2288 /* 10.X firmware does not support this VDEV parameter. Do not warn */
9dad14ae 2289 if (ret && ret != -EOPNOTSUPP) {
5e3dd157 2290 ath10k_warn("Failed to set TX encap: %d\n", ret);
9dad14ae
MK		 2291 goto err_vdev_delete;
2292 }
5e3dd157
KV		 2293
2294 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2295 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2296 if (ret) {
2297 ath10k_warn("Failed to create peer for AP: %d\n", ret);
9dad14ae 2298 goto err_vdev_delete;
5e3dd157
KV		 2299 }
2300 }
2301
2302 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2303 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2304 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2305 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2306 param, value);
9dad14ae 2307 if (ret) {
5e3dd157 2308 ath10k_warn("Failed to set RX wake policy: %d\n", ret);
9dad14ae
MK		 2309 goto err_peer_delete;
2310 }
5e3dd157
KV		 2311
2312 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2313 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2314 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2315 param, value);
9dad14ae 2316 if (ret) {
5e3dd157 2317 ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
9dad14ae
MK		 2318 goto err_peer_delete;
2319 }
5e3dd157
KV		 2320
2321 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2322 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2323 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2324 param, value);
9dad14ae 2325 if (ret) {
5e3dd157 2326 ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
9dad14ae
MK		 2327 goto err_peer_delete;
2328 }
5e3dd157
KV		 2329 }
2330
424121c3 2331 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
9dad14ae 2332 if (ret) {
679c54a6
MK		 2333 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n",
2334 arvif->vdev_id, ret);
9dad14ae
MK		 2335 goto err_peer_delete;
2336 }
679c54a6 2337
424121c3 2338 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
9dad14ae 2339 if (ret) {
679c54a6
MK		 2340 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n",
2341 arvif->vdev_id, ret);
9dad14ae
MK		 2342 goto err_peer_delete;
2343 }
679c54a6 2344
5e3dd157
KV		 2345 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2346 ar->monitor_present = true;
2347
5e3dd157 2348 mutex_unlock(&ar->conf_mutex);
9dad14ae
MK		 2349 return 0;
2350
2351err_peer_delete:
2352 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2353 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2354
2355err_vdev_delete:
2356 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2357 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
0579119f 2358 list_del(&arvif->list);
9dad14ae
MK		 2359
2360err:
2361 mutex_unlock(&ar->conf_mutex);
2362
5e3dd157
KV		 2363 return ret;
2364}
2365
2366static void ath10k_remove_interface(struct ieee80211_hw *hw,
2367 struct ieee80211_vif *vif)
2368{
2369 struct ath10k *ar = hw->priv;
2370 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2371 int ret;
2372
2373 mutex_lock(&ar->conf_mutex);
2374
cc4827b9
MK		 2375 cancel_work_sync(&arvif->wep_key_work);
2376
ed54388a
MK		 2377 spin_lock_bh(&ar->data_lock);
2378 if (arvif->beacon) {
2379 dev_kfree_skb_any(arvif->beacon);
2380 arvif->beacon = NULL;
2381 }
2382 spin_unlock_bh(&ar->data_lock);
2383
5e3dd157 2384 ar->free_vdev_map |= 1 << (arvif->vdev_id);
0579119f 2385 list_del(&arvif->list);
5e3dd157
KV		 2386
2387 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2388 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2389 if (ret)
2390 ath10k_warn("Failed to remove peer for AP: %d\n", ret);
2391
2392 kfree(arvif->u.ap.noa_data);
2393 }
2394
60c3daa8
KV		 2395 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev delete %d (remove interface)\n",
2396 arvif->vdev_id);
2397
5e3dd157
KV		 2398 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2399 if (ret)
2400 ath10k_warn("WMI vdev delete failed: %d\n", ret);
2401
2402 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2403 ar->monitor_present = false;
2404
2405 ath10k_peer_cleanup(ar, arvif->vdev_id);
2406
2407 mutex_unlock(&ar->conf_mutex);
2408}
2409
2410/*
2411 * FIXME: Has to be verified.
2412 */
2413#define SUPPORTED_FILTERS \
2414 (FIF_PROMISC_IN_BSS | \
2415 FIF_ALLMULTI | \
2416 FIF_CONTROL | \
2417 FIF_PSPOLL | \
2418 FIF_OTHER_BSS | \
2419 FIF_BCN_PRBRESP_PROMISC | \
2420 FIF_PROBE_REQ | \
2421 FIF_FCSFAIL)
2422
2423static void ath10k_configure_filter(struct ieee80211_hw *hw,
2424 unsigned int changed_flags,
2425 unsigned int *total_flags,
2426 u64 multicast)
2427{
2428 struct ath10k *ar = hw->priv;
2429 int ret;
2430
2431 mutex_lock(&ar->conf_mutex);
2432
2433 changed_flags &= SUPPORTED_FILTERS;
2434 *total_flags &= SUPPORTED_FILTERS;
2435 ar->filter_flags = *total_flags;
2436
afd0922e
MK		 2437 /* Monitor must not be started if it wasn't created first.
2438 * Promiscuous mode may be started on a non-monitor interface - in
2439 * such case the monitor vdev is not created so starting the
2440 * monitor makes no sense. Since ath10k uses no special RX filters
2441 * (only BSS filter in STA mode) there's no need for any special
2442 * action here. */
5e3dd157 2443 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
afd0922e 2444 !ar->monitor_enabled && ar->monitor_present) {
60c3daa8
KV		 2445 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d start\n",
2446 ar->monitor_vdev_id);
2447
5e3dd157
KV		 2448 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
2449 if (ret)
2450 ath10k_warn("Unable to start monitor mode\n");
5e3dd157 2451 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
afd0922e 2452 ar->monitor_enabled && ar->monitor_present) {
60c3daa8
KV		 2453 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d stop\n",
2454 ar->monitor_vdev_id);
2455
5e3dd157
KV		 2456 ret = ath10k_monitor_stop(ar);
2457 if (ret)
2458 ath10k_warn("Unable to stop monitor mode\n");
5e3dd157
KV		 2459 }
2460
2461 mutex_unlock(&ar->conf_mutex);
2462}
2463
2464static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2465 struct ieee80211_vif *vif,
2466 struct ieee80211_bss_conf *info,
2467 u32 changed)
2468{
2469 struct ath10k *ar = hw->priv;
2470 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2471 int ret = 0;
226a339b 2472 u32 vdev_param, pdev_param;
5e3dd157
KV		 2473
2474 mutex_lock(&ar->conf_mutex);
2475
2476 if (changed & BSS_CHANGED_IBSS)
2477 ath10k_control_ibss(arvif, info, vif->addr);
2478
2479 if (changed & BSS_CHANGED_BEACON_INT) {
2480 arvif->beacon_interval = info->beacon_int;
6d1506e7
BM		 2481 vdev_param = ar->wmi.vdev_param->beacon_interval;
2482 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157 2483 arvif->beacon_interval);
60c3daa8
KV		 2484 ath10k_dbg(ATH10K_DBG_MAC,
2485 "mac vdev %d beacon_interval %d\n",
2486 arvif->vdev_id, arvif->beacon_interval);
2487
5e3dd157
KV		 2488 if (ret)
2489 ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
2490 arvif->vdev_id);
5e3dd157
KV		 2491 }
2492
2493 if (changed & BSS_CHANGED_BEACON) {
60c3daa8
KV		 2494 ath10k_dbg(ATH10K_DBG_MAC,
2495 "vdev %d set beacon tx mode to staggered\n",
2496 arvif->vdev_id);
2497
226a339b
BM		 2498 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
2499 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
5e3dd157
KV		 2500 WMI_BEACON_STAGGERED_MODE);
2501 if (ret)
2502 ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
2503 arvif->vdev_id);
5e3dd157
KV		 2504 }
2505
b70727e8 2506 if (changed & BSS_CHANGED_BEACON_INFO) {
5e3dd157
KV		 2507 arvif->dtim_period = info->dtim_period;
2508
60c3daa8
KV		 2509 ath10k_dbg(ATH10K_DBG_MAC,
2510 "mac vdev %d dtim_period %d\n",
2511 arvif->vdev_id, arvif->dtim_period);
2512
6d1506e7
BM		 2513 vdev_param = ar->wmi.vdev_param->dtim_period;
2514 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2515 arvif->dtim_period);
2516 if (ret)
2517 ath10k_warn("Failed to set dtim period for VDEV: %d\n",
2518 arvif->vdev_id);
5e3dd157
KV		 2519 }
2520
2521 if (changed & BSS_CHANGED_SSID &&
2522 vif->type == NL80211_IFTYPE_AP) {
2523 arvif->u.ap.ssid_len = info->ssid_len;
2524 if (info->ssid_len)
2525 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2526 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2527 }
2528
2529 if (changed & BSS_CHANGED_BSSID) {
2530 if (!is_zero_ether_addr(info->bssid)) {
60c3daa8
KV		 2531 ath10k_dbg(ATH10K_DBG_MAC,
2532 "mac vdev %d create peer %pM\n",
2533 arvif->vdev_id, info->bssid);
2534
5e3dd157
KV		 2535 ret = ath10k_peer_create(ar, arvif->vdev_id,
2536 info->bssid);
2537 if (ret)
479398b0
BG		 2538 ath10k_warn("Failed to add peer %pM for vdev %d when changin bssid: %i\n",
2539 info->bssid, arvif->vdev_id, ret);
5e3dd157
KV		 2540
2541 if (vif->type == NL80211_IFTYPE_STATION) {
2542 /*
2543 * this is never erased as we it for crypto key
2544 * clearing; this is FW requirement
2545 */
2546 memcpy(arvif->u.sta.bssid, info->bssid,
2547 ETH_ALEN);
2548
60c3daa8
KV		 2549 ath10k_dbg(ATH10K_DBG_MAC,
2550 "mac vdev %d start %pM\n",
2551 arvif->vdev_id, info->bssid);
2552
2553 /* FIXME: check return value */
5e3dd157 2554 ret = ath10k_vdev_start(arvif);
5e3dd157
KV		 2555 }
2556
2557 /*
2558 * Mac80211 does not keep IBSS bssid when leaving IBSS,
2559 * so driver need to store it. It is needed when leaving
2560 * IBSS in order to remove BSSID peer.
2561 */
2562 if (vif->type == NL80211_IFTYPE_ADHOC)
2563 memcpy(arvif->u.ibss.bssid, info->bssid,
2564 ETH_ALEN);
2565 }
2566 }
2567
2568 if (changed & BSS_CHANGED_BEACON_ENABLED)
2569 ath10k_control_beaconing(arvif, info);
2570
2571 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2572 u32 cts_prot;
2573 if (info->use_cts_prot)
2574 cts_prot = 1;
2575 else
2576 cts_prot = 0;
2577
60c3daa8
KV		 2578 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
2579 arvif->vdev_id, cts_prot);
2580
6d1506e7
BM		 2581 vdev_param = ar->wmi.vdev_param->enable_rtscts;
2582 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2583 cts_prot);
2584 if (ret)
2585 ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2586 arvif->vdev_id);
5e3dd157
KV		 2587 }
2588
2589 if (changed & BSS_CHANGED_ERP_SLOT) {
2590 u32 slottime;
2591 if (info->use_short_slot)
2592 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2593
2594 else
2595 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2596
60c3daa8
KV		 2597 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
2598 arvif->vdev_id, slottime);
2599
6d1506e7
BM		 2600 vdev_param = ar->wmi.vdev_param->slot_time;
2601 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2602 slottime);
2603 if (ret)
2604 ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2605 arvif->vdev_id);
5e3dd157
KV		 2606 }
2607
2608 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2609 u32 preamble;
2610 if (info->use_short_preamble)
2611 preamble = WMI_VDEV_PREAMBLE_SHORT;
2612 else
2613 preamble = WMI_VDEV_PREAMBLE_LONG;
2614
60c3daa8
KV		 2615 ath10k_dbg(ATH10K_DBG_MAC,
2616 "mac vdev %d preamble %dn",
2617 arvif->vdev_id, preamble);
2618
6d1506e7
BM		 2619 vdev_param = ar->wmi.vdev_param->preamble;
2620 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2621 preamble);
2622 if (ret)
2623 ath10k_warn("Failed to set preamble for VDEV: %d\n",
2624 arvif->vdev_id);
5e3dd157
KV		 2625 }
2626
2627 if (changed & BSS_CHANGED_ASSOC) {
2628 if (info->assoc)
2629 ath10k_bss_assoc(hw, vif, info);
2630 }
2631
2632 mutex_unlock(&ar->conf_mutex);
2633}
2634
2635static int ath10k_hw_scan(struct ieee80211_hw *hw,
2636 struct ieee80211_vif *vif,
2637 struct cfg80211_scan_request *req)
2638{
2639 struct ath10k *ar = hw->priv;
2640 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2641 struct wmi_start_scan_arg arg;
2642 int ret = 0;
2643 int i;
2644
2645 mutex_lock(&ar->conf_mutex);
2646
2647 spin_lock_bh(&ar->data_lock);
2648 if (ar->scan.in_progress) {
2649 spin_unlock_bh(&ar->data_lock);
2650 ret = -EBUSY;
2651 goto exit;
2652 }
2653
16735d02
WS		 2654 reinit_completion(&ar->scan.started);
2655 reinit_completion(&ar->scan.completed);
5e3dd157
KV		 2656 ar->scan.in_progress = true;
2657 ar->scan.aborting = false;
2658 ar->scan.is_roc = false;
2659 ar->scan.vdev_id = arvif->vdev_id;
2660 spin_unlock_bh(&ar->data_lock);
2661
2662 memset(&arg, 0, sizeof(arg));
2663 ath10k_wmi_start_scan_init(ar, &arg);
2664 arg.vdev_id = arvif->vdev_id;
2665 arg.scan_id = ATH10K_SCAN_ID;
2666
2667 if (!req->no_cck)
2668 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2669
2670 if (req->ie_len) {
2671 arg.ie_len = req->ie_len;
2672 memcpy(arg.ie, req->ie, arg.ie_len);
2673 }
2674
2675 if (req->n_ssids) {
2676 arg.n_ssids = req->n_ssids;
2677 for (i = 0; i < arg.n_ssids; i++) {
2678 arg.ssids[i].len = req->ssids[i].ssid_len;
2679 arg.ssids[i].ssid = req->ssids[i].ssid;
2680 }
dcd4a561
MK		 2681 } else {
2682 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5e3dd157
KV		 2683 }
2684
2685 if (req->n_channels) {
2686 arg.n_channels = req->n_channels;
2687 for (i = 0; i < arg.n_channels; i++)
2688 arg.channels[i] = req->channels[i]->center_freq;
2689 }
2690
2691 ret = ath10k_start_scan(ar, &arg);
2692 if (ret) {
2693 ath10k_warn("could not start hw scan (%d)\n", ret);
2694 spin_lock_bh(&ar->data_lock);
2695 ar->scan.in_progress = false;
2696 spin_unlock_bh(&ar->data_lock);
2697 }
2698
2699exit:
2700 mutex_unlock(&ar->conf_mutex);
2701 return ret;
2702}
2703
2704static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2705 struct ieee80211_vif *vif)
2706{
2707 struct ath10k *ar = hw->priv;
2708 int ret;
2709
2710 mutex_lock(&ar->conf_mutex);
2711 ret = ath10k_abort_scan(ar);
2712 if (ret) {
2713 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2714 ret);
2715 ieee80211_scan_completed(hw, 1 /* aborted */);
2716 }
2717 mutex_unlock(&ar->conf_mutex);
2718}
2719
cfb27d29
MK		 2720static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
2721 struct ath10k_vif *arvif,
2722 enum set_key_cmd cmd,
2723 struct ieee80211_key_conf *key)
2724{
2725 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
2726 int ret;
2727
2728 /* 10.1 firmware branch requires default key index to be set to group
2729 * key index after installing it. Otherwise FW/HW Txes corrupted
2730 * frames with multi-vif APs. This is not required for main firmware
2731 * branch (e.g. 636).
2732 *
2733 * FIXME: This has been tested only in AP. It remains unknown if this
2734 * is required for multi-vif STA interfaces on 10.1 */
2735
2736 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
2737 return;
2738
2739 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
2740 return;
2741
2742 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
2743 return;
2744
2745 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
2746 return;
2747
2748 if (cmd != SET_KEY)
2749 return;
2750
2751 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2752 key->keyidx);
2753 if (ret)
2754 ath10k_warn("failed to set group key as default key: %d\n",
2755 ret);
2756}
2757
5e3dd157
KV		 2758static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2759 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2760 struct ieee80211_key_conf *key)
2761{
2762 struct ath10k *ar = hw->priv;
2763 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2764 struct ath10k_peer *peer;
2765 const u8 *peer_addr;
2766 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2767 key->cipher == WLAN_CIPHER_SUITE_WEP104;
2768 int ret = 0;
2769
2770 if (key->keyidx > WMI_MAX_KEY_INDEX)
2771 return -ENOSPC;
2772
2773 mutex_lock(&ar->conf_mutex);
2774
2775 if (sta)
2776 peer_addr = sta->addr;
2777 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
2778 peer_addr = vif->bss_conf.bssid;
2779 else
2780 peer_addr = vif->addr;
2781
2782 key->hw_key_idx = key->keyidx;
2783
2784 /* the peer should not disappear in mid-way (unless FW goes awry) since
2785 * we already hold conf_mutex. we just make sure its there now. */
2786 spin_lock_bh(&ar->data_lock);
2787 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2788 spin_unlock_bh(&ar->data_lock);
2789
2790 if (!peer) {
2791 if (cmd == SET_KEY) {
2792 ath10k_warn("cannot install key for non-existent peer %pM\n",
2793 peer_addr);
2794 ret = -EOPNOTSUPP;
2795 goto exit;
2796 } else {
2797 /* if the peer doesn't exist there is no key to disable
2798 * anymore */
2799 goto exit;
2800 }
2801 }
2802
2803 if (is_wep) {
2804 if (cmd == SET_KEY)
2805 arvif->wep_keys[key->keyidx] = key;
2806 else
2807 arvif->wep_keys[key->keyidx] = NULL;
2808
2809 if (cmd == DISABLE_KEY)
2810 ath10k_clear_vdev_key(arvif, key);
2811 }
2812
2813 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
2814 if (ret) {
2815 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
2816 goto exit;
2817 }
2818
cfb27d29
MK		 2819 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
2820
5e3dd157
KV		 2821 spin_lock_bh(&ar->data_lock);
2822 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2823 if (peer && cmd == SET_KEY)
2824 peer->keys[key->keyidx] = key;
2825 else if (peer && cmd == DISABLE_KEY)
2826 peer->keys[key->keyidx] = NULL;
2827 else if (peer == NULL)
2828 /* impossible unless FW goes crazy */
2829 ath10k_warn("peer %pM disappeared!\n", peer_addr);
2830 spin_unlock_bh(&ar->data_lock);
2831
2832exit:
2833 mutex_unlock(&ar->conf_mutex);
2834 return ret;
2835}
2836
2837static int ath10k_sta_state(struct ieee80211_hw *hw,
2838 struct ieee80211_vif *vif,
2839 struct ieee80211_sta *sta,
2840 enum ieee80211_sta_state old_state,
2841 enum ieee80211_sta_state new_state)
2842{
2843 struct ath10k *ar = hw->priv;
2844 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2845 int ret = 0;
2846
2847 mutex_lock(&ar->conf_mutex);
2848
2849 if (old_state == IEEE80211_STA_NOTEXIST &&
2850 new_state == IEEE80211_STA_NONE &&
2851 vif->type != NL80211_IFTYPE_STATION) {
2852 /*
2853 * New station addition.
2854 */
60c3daa8
KV		 2855 ath10k_dbg(ATH10K_DBG_MAC,
2856 "mac vdev %d peer create %pM (new sta)\n",
2857 arvif->vdev_id, sta->addr);
2858
5e3dd157
KV		 2859 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
2860 if (ret)
479398b0
BG		 2861 ath10k_warn("Failed to add peer %pM for vdev %d when adding a new sta: %i\n",
2862 sta->addr, arvif->vdev_id, ret);
5e3dd157
KV		 2863 } else if ((old_state == IEEE80211_STA_NONE &&
2864 new_state == IEEE80211_STA_NOTEXIST)) {
2865 /*
2866 * Existing station deletion.
2867 */
60c3daa8
KV		 2868 ath10k_dbg(ATH10K_DBG_MAC,
2869 "mac vdev %d peer delete %pM (sta gone)\n",
2870 arvif->vdev_id, sta->addr);
5e3dd157
KV		 2871 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
2872 if (ret)
2873 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
2874 sta->addr, arvif->vdev_id);
5e3dd157
KV		 2875
2876 if (vif->type == NL80211_IFTYPE_STATION)
2877 ath10k_bss_disassoc(hw, vif);
2878 } else if (old_state == IEEE80211_STA_AUTH &&
2879 new_state == IEEE80211_STA_ASSOC &&
2880 (vif->type == NL80211_IFTYPE_AP ||
2881 vif->type == NL80211_IFTYPE_ADHOC)) {
2882 /*
2883 * New association.
2884 */
60c3daa8
KV		 2885 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
2886 sta->addr);
2887
5e3dd157
KV		 2888 ret = ath10k_station_assoc(ar, arvif, sta);
2889 if (ret)
2890 ath10k_warn("Failed to associate station: %pM\n",
2891 sta->addr);
5e3dd157
KV		 2892 } else if (old_state == IEEE80211_STA_ASSOC &&
2893 new_state == IEEE80211_STA_AUTH &&
2894 (vif->type == NL80211_IFTYPE_AP ||
2895 vif->type == NL80211_IFTYPE_ADHOC)) {
2896 /*
2897 * Disassociation.
2898 */
60c3daa8
KV		 2899 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
2900 sta->addr);
2901
5e3dd157
KV		 2902 ret = ath10k_station_disassoc(ar, arvif, sta);
2903 if (ret)
2904 ath10k_warn("Failed to disassociate station: %pM\n",
2905 sta->addr);
5e3dd157
KV		 2906 }
2907
2908 mutex_unlock(&ar->conf_mutex);
2909 return ret;
2910}
2911
2912static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
2913 u16 ac, bool enable)
2914{
2915 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2916 u32 value = 0;
2917 int ret = 0;
2918
548db54c
MK		 2919 lockdep_assert_held(&ar->conf_mutex);
2920
5e3dd157
KV		 2921 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
2922 return 0;
2923
2924 switch (ac) {
2925 case IEEE80211_AC_VO:
2926 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
2927 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
2928 break;
2929 case IEEE80211_AC_VI:
2930 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
2931 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
2932 break;
2933 case IEEE80211_AC_BE:
2934 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
2935 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
2936 break;
2937 case IEEE80211_AC_BK:
2938 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
2939 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
2940 break;
2941 }
2942
2943 if (enable)
2944 arvif->u.sta.uapsd |= value;
2945 else
2946 arvif->u.sta.uapsd &= ~value;
2947
2948 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2949 WMI_STA_PS_PARAM_UAPSD,
2950 arvif->u.sta.uapsd);
2951 if (ret) {
2952 ath10k_warn("could not set uapsd params %d\n", ret);
2953 goto exit;
2954 }
2955
2956 if (arvif->u.sta.uapsd)
2957 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
2958 else
2959 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2960
2961 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2962 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
2963 value);
2964 if (ret)
2965 ath10k_warn("could not set rx wake param %d\n", ret);
2966
2967exit:
2968 return ret;
2969}
2970
2971static int ath10k_conf_tx(struct ieee80211_hw *hw,
2972 struct ieee80211_vif *vif, u16 ac,
2973 const struct ieee80211_tx_queue_params *params)
2974{
2975 struct ath10k *ar = hw->priv;
2976 struct wmi_wmm_params_arg *p = NULL;
2977 int ret;
2978
2979 mutex_lock(&ar->conf_mutex);
2980
2981 switch (ac) {
2982 case IEEE80211_AC_VO:
2983 p = &ar->wmm_params.ac_vo;
2984 break;
2985 case IEEE80211_AC_VI:
2986 p = &ar->wmm_params.ac_vi;
2987 break;
2988 case IEEE80211_AC_BE:
2989 p = &ar->wmm_params.ac_be;
2990 break;
2991 case IEEE80211_AC_BK:
2992 p = &ar->wmm_params.ac_bk;
2993 break;
2994 }
2995
2996 if (WARN_ON(!p)) {
2997 ret = -EINVAL;
2998 goto exit;
2999 }
3000
3001 p->cwmin = params->cw_min;
3002 p->cwmax = params->cw_max;
3003 p->aifs = params->aifs;
3004
3005 /*
3006 * The channel time duration programmed in the HW is in absolute
3007 * microseconds, while mac80211 gives the txop in units of
3008 * 32 microseconds.
3009 */
3010 p->txop = params->txop * 32;
3011
3012 /* FIXME: FW accepts wmm params per hw, not per vif */
3013 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3014 if (ret) {
3015 ath10k_warn("could not set wmm params %d\n", ret);
3016 goto exit;
3017 }
3018
3019 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3020 if (ret)
3021 ath10k_warn("could not set sta uapsd %d\n", ret);
3022
3023exit:
3024 mutex_unlock(&ar->conf_mutex);
3025 return ret;
3026}
3027
3028#define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3029
3030static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3031 struct ieee80211_vif *vif,
3032 struct ieee80211_channel *chan,
3033 int duration,
3034 enum ieee80211_roc_type type)
3035{
3036 struct ath10k *ar = hw->priv;
3037 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3038 struct wmi_start_scan_arg arg;
3039 int ret;
3040
3041 mutex_lock(&ar->conf_mutex);
3042
3043 spin_lock_bh(&ar->data_lock);
3044 if (ar->scan.in_progress) {
3045 spin_unlock_bh(&ar->data_lock);
3046 ret = -EBUSY;
3047 goto exit;
3048 }
3049
16735d02
WS		 3050 reinit_completion(&ar->scan.started);
3051 reinit_completion(&ar->scan.completed);
3052 reinit_completion(&ar->scan.on_channel);
5e3dd157
KV		 3053 ar->scan.in_progress = true;
3054 ar->scan.aborting = false;
3055 ar->scan.is_roc = true;
3056 ar->scan.vdev_id = arvif->vdev_id;
3057 ar->scan.roc_freq = chan->center_freq;
3058 spin_unlock_bh(&ar->data_lock);
3059
3060 memset(&arg, 0, sizeof(arg));
3061 ath10k_wmi_start_scan_init(ar, &arg);
3062 arg.vdev_id = arvif->vdev_id;
3063 arg.scan_id = ATH10K_SCAN_ID;
3064 arg.n_channels = 1;
3065 arg.channels[0] = chan->center_freq;
3066 arg.dwell_time_active = duration;
3067 arg.dwell_time_passive = duration;
3068 arg.max_scan_time = 2 * duration;
3069 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3070 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3071
3072 ret = ath10k_start_scan(ar, &arg);
3073 if (ret) {
3074 ath10k_warn("could not start roc scan (%d)\n", ret);
3075 spin_lock_bh(&ar->data_lock);
3076 ar->scan.in_progress = false;
3077 spin_unlock_bh(&ar->data_lock);
3078 goto exit;
3079 }
3080
3081 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3082 if (ret == 0) {
3083 ath10k_warn("could not switch to channel for roc scan\n");
3084 ath10k_abort_scan(ar);
3085 ret = -ETIMEDOUT;
3086 goto exit;
3087 }
3088
3089 ret = 0;
3090exit:
3091 mutex_unlock(&ar->conf_mutex);
3092 return ret;
3093}
3094
3095static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3096{
3097 struct ath10k *ar = hw->priv;
3098
3099 mutex_lock(&ar->conf_mutex);
3100 ath10k_abort_scan(ar);
3101 mutex_unlock(&ar->conf_mutex);
3102
3103 return 0;
3104}
3105
3106/*
3107 * Both RTS and Fragmentation threshold are interface-specific
3108 * in ath10k, but device-specific in mac80211.
3109 */
5e3dd157 3110
ad088bfa
MK		 3111static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3112{
3113 struct ath10k *ar = hw->priv;
3114 struct ath10k_vif *arvif;
3115 int ret = 0;
548db54c 3116
5e3dd157 3117 mutex_lock(&ar->conf_mutex);
ad088bfa
MK		 3118 list_for_each_entry(arvif, &ar->arvifs, list) {
3119 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3120 arvif->vdev_id, value);
3121
3122 ret = ath10k_mac_set_rts(arvif, value);
3123 if (ret) {
3124 ath10k_warn("could not set rts threshold for vdev %d (%d)\n",
3125 arvif->vdev_id, ret);
3126 break;
3127 }
3128 }
5e3dd157
KV		 3129 mutex_unlock(&ar->conf_mutex);
3130
ad088bfa 3131 return ret;
5e3dd157
KV		 3132}
3133
ad088bfa 3134static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5e3dd157 3135{
ad088bfa
MK		 3136 struct ath10k *ar = hw->priv;
3137 struct ath10k_vif *arvif;
3138 int ret = 0;
548db54c 3139
5e3dd157 3140 mutex_lock(&ar->conf_mutex);
ad088bfa
MK		 3141 list_for_each_entry(arvif, &ar->arvifs, list) {
3142 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3143 arvif->vdev_id, value);
3144
3145 ret = ath10k_mac_set_rts(arvif, value);
3146 if (ret) {
3147 ath10k_warn("could not set fragmentation threshold for vdev %d (%d)\n",
3148 arvif->vdev_id, ret);
3149 break;
3150 }
3151 }
5e3dd157
KV		 3152 mutex_unlock(&ar->conf_mutex);
3153
ad088bfa 3154 return ret;
5e3dd157
KV		 3155}
3156
3157static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
3158{
3159 struct ath10k *ar = hw->priv;
affd3217 3160 bool skip;
5e3dd157
KV		 3161 int ret;
3162
3163 /* mac80211 doesn't care if we really xmit queued frames or not
3164 * we'll collect those frames either way if we stop/delete vdevs */
3165 if (drop)
3166 return;
3167
548db54c
MK		 3168 mutex_lock(&ar->conf_mutex);
3169
affd3217
MK		 3170 if (ar->state == ATH10K_STATE_WEDGED)
3171 goto skip;
3172
edb8236d 3173 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
5e3dd157 3174 bool empty;
affd3217 3175
edb8236d 3176 spin_lock_bh(&ar->htt.tx_lock);
0945baf7 3177 empty = (ar->htt.num_pending_tx == 0);
edb8236d 3178 spin_unlock_bh(&ar->htt.tx_lock);
affd3217
MK		 3179
3180 skip = (ar->state == ATH10K_STATE_WEDGED);
3181
3182 (empty || skip);
5e3dd157 3183 }), ATH10K_FLUSH_TIMEOUT_HZ);
affd3217
MK		 3184
3185 if (ret <= 0 || skip)
5e3dd157 3186 ath10k_warn("tx not flushed\n");
548db54c 3187
affd3217 3188skip:
548db54c 3189 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 3190}
3191
3192/* TODO: Implement this function properly
3193 * For now it is needed to reply to Probe Requests in IBSS mode.
3194 * Propably we need this information from FW.
3195 */
3196static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3197{
3198 return 1;
3199}
3200
8cd13cad
MK		 3201#ifdef CONFIG_PM
3202static int ath10k_suspend(struct ieee80211_hw *hw,
3203 struct cfg80211_wowlan *wowlan)
3204{
3205 struct ath10k *ar = hw->priv;
3206 int ret;
3207
3208 ar->is_target_paused = false;
3209
3210 ret = ath10k_wmi_pdev_suspend_target(ar);
3211 if (ret) {
3212 ath10k_warn("could not suspend target (%d)\n", ret);
3213 return 1;
3214 }
3215
3216 ret = wait_event_interruptible_timeout(ar->event_queue,
3217 ar->is_target_paused == true,
3218 1 * HZ);
3219 if (ret < 0) {
3220 ath10k_warn("suspend interrupted (%d)\n", ret);
3221 goto resume;
3222 } else if (ret == 0) {
3223 ath10k_warn("suspend timed out - target pause event never came\n");
3224 goto resume;
3225 }
3226
3227 ret = ath10k_hif_suspend(ar);
3228 if (ret) {
3229 ath10k_warn("could not suspend hif (%d)\n", ret);
3230 goto resume;
3231 }
3232
3233 return 0;
3234resume:
3235 ret = ath10k_wmi_pdev_resume_target(ar);
3236 if (ret)
3237 ath10k_warn("could not resume target (%d)\n", ret);
3238 return 1;
3239}
3240
3241static int ath10k_resume(struct ieee80211_hw *hw)
3242{
3243 struct ath10k *ar = hw->priv;
3244 int ret;
3245
3246 ret = ath10k_hif_resume(ar);
3247 if (ret) {
3248 ath10k_warn("could not resume hif (%d)\n", ret);
3249 return 1;
3250 }
3251
3252 ret = ath10k_wmi_pdev_resume_target(ar);
3253 if (ret) {
3254 ath10k_warn("could not resume target (%d)\n", ret);
3255 return 1;
3256 }
3257
3258 return 0;
3259}
3260#endif
3261
affd3217
MK		 3262static void ath10k_restart_complete(struct ieee80211_hw *hw)
3263{
3264 struct ath10k *ar = hw->priv;
3265
3266 mutex_lock(&ar->conf_mutex);
3267
3268 /* If device failed to restart it will be in a different state, e.g.
3269 * ATH10K_STATE_WEDGED */
3270 if (ar->state == ATH10K_STATE_RESTARTED) {
3271 ath10k_info("device successfully recovered\n");
3272 ar->state = ATH10K_STATE_ON;
3273 }
3274
3275 mutex_unlock(&ar->conf_mutex);
3276}
3277
2e1dea40
MK		 3278static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3279 struct survey_info *survey)
3280{
3281 struct ath10k *ar = hw->priv;
3282 struct ieee80211_supported_band *sband;
3283 struct survey_info *ar_survey = &ar->survey[idx];
3284 int ret = 0;
3285
3286 mutex_lock(&ar->conf_mutex);
3287
3288 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3289 if (sband && idx >= sband->n_channels) {
3290 idx -= sband->n_channels;
3291 sband = NULL;
3292 }
3293
3294 if (!sband)
3295 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3296
3297 if (!sband || idx >= sband->n_channels) {
3298 ret = -ENOENT;
3299 goto exit;
3300 }
3301
3302 spin_lock_bh(&ar->data_lock);
3303 memcpy(survey, ar_survey, sizeof(*survey));
3304 spin_unlock_bh(&ar->data_lock);
3305
3306 survey->channel = &sband->channels[idx];
3307
3308exit:
3309 mutex_unlock(&ar->conf_mutex);
3310 return ret;
3311}
3312
5e3dd157
KV		 3313static const struct ieee80211_ops ath10k_ops = {
3314 .tx = ath10k_tx,
3315 .start = ath10k_start,
3316 .stop = ath10k_stop,
3317 .config = ath10k_config,
3318 .add_interface = ath10k_add_interface,
3319 .remove_interface = ath10k_remove_interface,
3320 .configure_filter = ath10k_configure_filter,
3321 .bss_info_changed = ath10k_bss_info_changed,
3322 .hw_scan = ath10k_hw_scan,
3323 .cancel_hw_scan = ath10k_cancel_hw_scan,
3324 .set_key = ath10k_set_key,
3325 .sta_state = ath10k_sta_state,
3326 .conf_tx = ath10k_conf_tx,
3327 .remain_on_channel = ath10k_remain_on_channel,
3328 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
3329 .set_rts_threshold = ath10k_set_rts_threshold,
3330 .set_frag_threshold = ath10k_set_frag_threshold,
3331 .flush = ath10k_flush,
3332 .tx_last_beacon = ath10k_tx_last_beacon,
affd3217 3333 .restart_complete = ath10k_restart_complete,
2e1dea40 3334 .get_survey = ath10k_get_survey,
8cd13cad
MK		 3335#ifdef CONFIG_PM
3336 .suspend = ath10k_suspend,
3337 .resume = ath10k_resume,
3338#endif
5e3dd157
KV		 3339};
3340
3341#define RATETAB_ENT(_rate, _rateid, _flags) { \
3342 .bitrate = (_rate), \
3343 .flags = (_flags), \
3344 .hw_value = (_rateid), \
3345}
3346
3347#define CHAN2G(_channel, _freq, _flags) { \
3348 .band = IEEE80211_BAND_2GHZ, \
3349 .hw_value = (_channel), \
3350 .center_freq = (_freq), \
3351 .flags = (_flags), \
3352 .max_antenna_gain = 0, \
3353 .max_power = 30, \
3354}
3355
3356#define CHAN5G(_channel, _freq, _flags) { \
3357 .band = IEEE80211_BAND_5GHZ, \
3358 .hw_value = (_channel), \
3359 .center_freq = (_freq), \
3360 .flags = (_flags), \
3361 .max_antenna_gain = 0, \
3362 .max_power = 30, \
3363}
3364
3365static const struct ieee80211_channel ath10k_2ghz_channels[] = {
3366 CHAN2G(1, 2412, 0),
3367 CHAN2G(2, 2417, 0),
3368 CHAN2G(3, 2422, 0),
3369 CHAN2G(4, 2427, 0),
3370 CHAN2G(5, 2432, 0),
3371 CHAN2G(6, 2437, 0),
3372 CHAN2G(7, 2442, 0),
3373 CHAN2G(8, 2447, 0),
3374 CHAN2G(9, 2452, 0),
3375 CHAN2G(10, 2457, 0),
3376 CHAN2G(11, 2462, 0),
3377 CHAN2G(12, 2467, 0),
3378 CHAN2G(13, 2472, 0),
3379 CHAN2G(14, 2484, 0),
3380};
3381
3382static const struct ieee80211_channel ath10k_5ghz_channels[] = {
429ff56a
MK		 3383 CHAN5G(36, 5180, 0),
3384 CHAN5G(40, 5200, 0),
3385 CHAN5G(44, 5220, 0),
3386 CHAN5G(48, 5240, 0),
3387 CHAN5G(52, 5260, 0),
3388 CHAN5G(56, 5280, 0),
3389 CHAN5G(60, 5300, 0),
3390 CHAN5G(64, 5320, 0),
3391 CHAN5G(100, 5500, 0),
3392 CHAN5G(104, 5520, 0),
3393 CHAN5G(108, 5540, 0),
3394 CHAN5G(112, 5560, 0),
3395 CHAN5G(116, 5580, 0),
3396 CHAN5G(120, 5600, 0),
3397 CHAN5G(124, 5620, 0),
3398 CHAN5G(128, 5640, 0),
3399 CHAN5G(132, 5660, 0),
3400 CHAN5G(136, 5680, 0),
3401 CHAN5G(140, 5700, 0),
3402 CHAN5G(149, 5745, 0),
3403 CHAN5G(153, 5765, 0),
3404 CHAN5G(157, 5785, 0),
3405 CHAN5G(161, 5805, 0),
3406 CHAN5G(165, 5825, 0),
5e3dd157
KV		 3407};
3408
3409static struct ieee80211_rate ath10k_rates[] = {
3410 /* CCK */
3411 RATETAB_ENT(10, 0x82, 0),
3412 RATETAB_ENT(20, 0x84, 0),
3413 RATETAB_ENT(55, 0x8b, 0),
3414 RATETAB_ENT(110, 0x96, 0),
3415 /* OFDM */
3416 RATETAB_ENT(60, 0x0c, 0),
3417 RATETAB_ENT(90, 0x12, 0),
3418 RATETAB_ENT(120, 0x18, 0),
3419 RATETAB_ENT(180, 0x24, 0),
3420 RATETAB_ENT(240, 0x30, 0),
3421 RATETAB_ENT(360, 0x48, 0),
3422 RATETAB_ENT(480, 0x60, 0),
3423 RATETAB_ENT(540, 0x6c, 0),
3424};
3425
3426#define ath10k_a_rates (ath10k_rates + 4)
3427#define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
3428#define ath10k_g_rates (ath10k_rates + 0)
3429#define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
3430
3431struct ath10k *ath10k_mac_create(void)
3432{
3433 struct ieee80211_hw *hw;
3434 struct ath10k *ar;
3435
3436 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
3437 if (!hw)
3438 return NULL;
3439
3440 ar = hw->priv;
3441 ar->hw = hw;
3442
3443 return ar;
3444}
3445
3446void ath10k_mac_destroy(struct ath10k *ar)
3447{
3448 ieee80211_free_hw(ar->hw);
3449}
3450
3451static const struct ieee80211_iface_limit ath10k_if_limits[] = {
3452 {
3453 .max = 8,
3454 .types = BIT(NL80211_IFTYPE_STATION)
3455 | BIT(NL80211_IFTYPE_P2P_CLIENT)
d531cb85
MK		 3456 },
3457 {
3458 .max = 3,
3459 .types = BIT(NL80211_IFTYPE_P2P_GO)
3460 },
3461 {
3462 .max = 7,
3463 .types = BIT(NL80211_IFTYPE_AP)
3464 },
5e3dd157
KV		 3465};
3466
e8a50f8b
MP		 3467#ifdef CONFIG_ATH10K_DFS_CERTIFIED
3468static const struct ieee80211_iface_limit ath10k_if_dfs_limits[] = {
3469 {
3470 .max = 8,
3471 .types = BIT(NL80211_IFTYPE_AP)
3472 },
3473};
3474#endif
3475
3476static const struct ieee80211_iface_combination ath10k_if_comb[] = {
3477 {
3478 .limits = ath10k_if_limits,
3479 .n_limits = ARRAY_SIZE(ath10k_if_limits),
3480 .max_interfaces = 8,
3481 .num_different_channels = 1,
3482 .beacon_int_infra_match = true,
3483 },
3484#ifdef CONFIG_ATH10K_DFS_CERTIFIED
3485 {
3486 .limits = ath10k_if_dfs_limits,
3487 .n_limits = ARRAY_SIZE(ath10k_if_dfs_limits),
3488 .max_interfaces = 8,
3489 .num_different_channels = 1,
3490 .beacon_int_infra_match = true,
3491 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
3492 BIT(NL80211_CHAN_WIDTH_20) |
3493 BIT(NL80211_CHAN_WIDTH_40) |
3494 BIT(NL80211_CHAN_WIDTH_80),
3495 }
3496#endif
5e3dd157
KV		 3497};
3498
3499static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3500{
3501 struct ieee80211_sta_vht_cap vht_cap = {0};
3502 u16 mcs_map;
8865bee4 3503 int i;
5e3dd157
KV		 3504
3505 vht_cap.vht_supported = 1;
3506 vht_cap.cap = ar->vht_cap_info;
3507
8865bee4
MK		 3508 mcs_map = 0;
3509 for (i = 0; i < 8; i++) {
3510 if (i < ar->num_rf_chains)
3511 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
3512 else
3513 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
3514 }
5e3dd157
KV		 3515
3516 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3517 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3518
3519 return vht_cap;
3520}
3521
3522static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3523{
3524 int i;
3525 struct ieee80211_sta_ht_cap ht_cap = {0};
3526
3527 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3528 return ht_cap;
3529
3530 ht_cap.ht_supported = 1;
3531 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3532 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3533 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3534 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3535 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
3536
3537 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3538 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3539
3540 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3541 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3542
3543 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3544 u32 smps;
3545
3546 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3547 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3548
3549 ht_cap.cap |= smps;
3550 }
3551
3552 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3553 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3554
3555 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3556 u32 stbc;
3557
3558 stbc = ar->ht_cap_info;
3559 stbc &= WMI_HT_CAP_RX_STBC;
3560 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3561 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3562 stbc &= IEEE80211_HT_CAP_RX_STBC;
3563
3564 ht_cap.cap |= stbc;
3565 }
3566
3567 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3568 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3569
3570 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3571 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3572
3573 /* max AMSDU is implicitly taken from vht_cap_info */
3574 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3575 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3576
8865bee4 3577 for (i = 0; i < ar->num_rf_chains; i++)
5e3dd157
KV		 3578 ht_cap.mcs.rx_mask[i] = 0xFF;
3579
3580 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3581
3582 return ht_cap;
3583}
3584
3585
3586static void ath10k_get_arvif_iter(void *data, u8 *mac,
3587 struct ieee80211_vif *vif)
3588{
3589 struct ath10k_vif_iter *arvif_iter = data;
3590 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3591
3592 if (arvif->vdev_id == arvif_iter->vdev_id)
3593 arvif_iter->arvif = arvif;
3594}
3595
3596struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
3597{
3598 struct ath10k_vif_iter arvif_iter;
3599 u32 flags;
3600
3601 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
3602 arvif_iter.vdev_id = vdev_id;
3603
3604 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
3605 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3606 flags,
3607 ath10k_get_arvif_iter,
3608 &arvif_iter);
3609 if (!arvif_iter.arvif) {
3610 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
3611 return NULL;
3612 }
3613
3614 return arvif_iter.arvif;
3615}
3616
3617int ath10k_mac_register(struct ath10k *ar)
3618{
3619 struct ieee80211_supported_band *band;
3620 struct ieee80211_sta_vht_cap vht_cap;
3621 struct ieee80211_sta_ht_cap ht_cap;
3622 void *channels;
3623 int ret;
3624
3625 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
3626
3627 SET_IEEE80211_DEV(ar->hw, ar->dev);
3628
3629 ht_cap = ath10k_get_ht_cap(ar);
3630 vht_cap = ath10k_create_vht_cap(ar);
3631
3632 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3633 channels = kmemdup(ath10k_2ghz_channels,
3634 sizeof(ath10k_2ghz_channels),
3635 GFP_KERNEL);
d6015b27
MK		 3636 if (!channels) {
3637 ret = -ENOMEM;
3638 goto err_free;
3639 }
5e3dd157
KV		 3640
3641 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3642 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
3643 band->channels = channels;
3644 band->n_bitrates = ath10k_g_rates_size;
3645 band->bitrates = ath10k_g_rates;
3646 band->ht_cap = ht_cap;
3647
3648 /* vht is not supported in 2.4 GHz */
3649
3650 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
3651 }
3652
3653 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3654 channels = kmemdup(ath10k_5ghz_channels,
3655 sizeof(ath10k_5ghz_channels),
3656 GFP_KERNEL);
3657 if (!channels) {
d6015b27
MK		 3658 ret = -ENOMEM;
3659 goto err_free;
5e3dd157
KV		 3660 }
3661
3662 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3663 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
3664 band->channels = channels;
3665 band->n_bitrates = ath10k_a_rates_size;
3666 band->bitrates = ath10k_a_rates;
3667 band->ht_cap = ht_cap;
3668 band->vht_cap = vht_cap;
3669 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
3670 }
3671
3672 ar->hw->wiphy->interface_modes =
3673 BIT(NL80211_IFTYPE_STATION) |
3674 BIT(NL80211_IFTYPE_ADHOC) |
3675 BIT(NL80211_IFTYPE_AP) |
3676 BIT(NL80211_IFTYPE_P2P_CLIENT) |
3677 BIT(NL80211_IFTYPE_P2P_GO);
3678
3679 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3680 IEEE80211_HW_SUPPORTS_PS |
3681 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
3682 IEEE80211_HW_SUPPORTS_UAPSD |
3683 IEEE80211_HW_MFP_CAPABLE |
3684 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3685 IEEE80211_HW_HAS_RATE_CONTROL |
3686 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
3687 IEEE80211_HW_WANT_MONITOR_VIF |
3688 IEEE80211_HW_AP_LINK_PS;
3689
1f8bb151
MK		 3690 /* MSDU can have HTT TX fragment pushed in front. The additional 4
3691 * bytes is used for padding/alignment if necessary. */
3692 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
3693
5e3dd157
KV		 3694 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
3695 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
3696
3697 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
3698 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
3699 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
3700 }
3701
3702 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
3703 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
3704
3705 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
3706
3707 ar->hw->channel_change_time = 5000;
3708 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
3709
3710 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3711 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
3712
3713 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
3714 /*
3715 * on LL hardware queues are managed entirely by the FW
3716 * so we only advertise to mac we can do the queues thing
3717 */
3718 ar->hw->queues = 4;
3719
e8a50f8b
MP		 3720 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
3721 ar->hw->wiphy->n_iface_combinations = ARRAY_SIZE(ath10k_if_comb);
5e3dd157 3722
7c199997
MK		 3723 ar->hw->netdev_features = NETIF_F_HW_CSUM;
3724
9702c686
JD		 3725 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
3726 /* Init ath dfs pattern detector */
3727 ar->ath_common.debug_mask = ATH_DBG_DFS;
3728 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
3729 NL80211_DFS_UNSET);
3730
3731 if (!ar->dfs_detector)
3732 ath10k_warn("dfs pattern detector init failed\n");
3733 }
3734
5e3dd157
KV		 3735 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
3736 ath10k_reg_notifier);
3737 if (ret) {
3738 ath10k_err("Regulatory initialization failed\n");
d6015b27 3739 goto err_free;
5e3dd157
KV		 3740 }
3741
3742 ret = ieee80211_register_hw(ar->hw);
3743 if (ret) {
3744 ath10k_err("ieee80211 registration failed: %d\n", ret);
d6015b27 3745 goto err_free;
5e3dd157
KV		 3746 }
3747
3748 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
3749 ret = regulatory_hint(ar->hw->wiphy,
3750 ar->ath_common.regulatory.alpha2);
3751 if (ret)
d6015b27 3752 goto err_unregister;
5e3dd157
KV		 3753 }
3754
3755 return 0;
d6015b27
MK		 3756
3757err_unregister:
5e3dd157 3758 ieee80211_unregister_hw(ar->hw);
d6015b27
MK		 3759err_free:
3760 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3761 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3762
5e3dd157
KV		 3763 return ret;
3764}
3765
3766void ath10k_mac_unregister(struct ath10k *ar)
3767{
3768 ieee80211_unregister_hw(ar->hw);
3769
9702c686
JD		 3770 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
3771 ar->dfs_detector->exit(ar->dfs_detector);
3772
5e3dd157
KV		 3773 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3774 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3775
3776 SET_IEEE80211_DEV(ar->hw, NULL);
3777}
Ubuntu Artful kernel mirror