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