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