projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath10k: fix SMPS support
[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;
5e3dd157
KV		 1085 int i, n;
1086
548db54c
MK		 1087 lockdep_assert_held(&ar->conf_mutex);
1088
5e3dd157
KV		 1089 if (!ht_cap->ht_supported)
1090 return;
1091
1092 arg->peer_flags |= WMI_PEER_HT;
1093 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1094 ht_cap->ampdu_factor)) - 1;
1095
1096 arg->peer_mpdu_density =
1097 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1098
1099 arg->peer_ht_caps = ht_cap->cap;
1100 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1101
1102 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1103 arg->peer_flags |= WMI_PEER_LDPC;
1104
1105 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1106 arg->peer_flags |= WMI_PEER_40MHZ;
1107 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1108 }
1109
1110 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1111 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1112
1113 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1114 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1115
1116 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1117 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1118 arg->peer_flags |= WMI_PEER_STBC;
1119 }
1120
1121 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1122 u32 stbc;
1123 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1124 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1125 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1126 arg->peer_rate_caps |= stbc;
1127 arg->peer_flags |= WMI_PEER_STBC;
1128 }
1129
5e3dd157
KV		 1130 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1131 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1132 else if (ht_cap->mcs.rx_mask[1])
1133 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1134
1135 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1136 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1137 arg->peer_ht_rates.rates[n++] = i;
1138
fd71f807
BM		 1139 /*
1140 * This is a workaround for HT-enabled STAs which break the spec
1141 * and have no HT capabilities RX mask (no HT RX MCS map).
1142 *
1143 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1144 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1145 *
1146 * Firmware asserts if such situation occurs.
1147 */
1148 if (n == 0) {
1149 arg->peer_ht_rates.num_rates = 8;
1150 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1151 arg->peer_ht_rates.rates[i] = i;
1152 } else {
1153 arg->peer_ht_rates.num_rates = n;
1154 arg->peer_num_spatial_streams = sta->rx_nss;
1155 }
5e3dd157 1156
60c3daa8
KV		 1157 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1158 arg->addr,
5e3dd157
KV		 1159 arg->peer_ht_rates.num_rates,
1160 arg->peer_num_spatial_streams);
1161}
1162
d3d3ff42
JD		 1163static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1164 struct ath10k_vif *arvif,
1165 struct ieee80211_sta *sta)
5e3dd157
KV		 1166{
1167 u32 uapsd = 0;
1168 u32 max_sp = 0;
d3d3ff42 1169 int ret = 0;
5e3dd157 1170
548db54c
MK		 1171 lockdep_assert_held(&ar->conf_mutex);
1172
5e3dd157 1173 if (sta->wme && sta->uapsd_queues) {
60c3daa8 1174 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
5e3dd157
KV		 1175 sta->uapsd_queues, sta->max_sp);
1176
5e3dd157
KV		 1177 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1178 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1179 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1180 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1181 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1182 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1183 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1184 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1185 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1186 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1187 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1188 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1189
1190
1191 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1192 max_sp = sta->max_sp;
1193
d3d3ff42
JD		 1194 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1195 sta->addr,
1196 WMI_AP_PS_PEER_PARAM_UAPSD,
1197 uapsd);
1198 if (ret) {
1199 ath10k_warn("failed to set ap ps peer param uapsd: %d\n",
1200 ret);
1201 return ret;
1202 }
5e3dd157 1203
d3d3ff42
JD		 1204 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1205 sta->addr,
1206 WMI_AP_PS_PEER_PARAM_MAX_SP,
1207 max_sp);
1208 if (ret) {
1209 ath10k_warn("failed to set ap ps peer param max sp: %d\n",
1210 ret);
1211 return ret;
1212 }
5e3dd157
KV		 1213
1214 /* TODO setup this based on STA listen interval and
1215 beacon interval. Currently we don't know
1216 sta->listen_interval - mac80211 patch required.
1217 Currently use 10 seconds */
d3d3ff42
JD		 1218 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1219 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 10);
1220 if (ret) {
1221 ath10k_warn("failed to set ap ps peer param ageout time: %d\n",
1222 ret);
1223 return ret;
1224 }
5e3dd157 1225 }
5e3dd157 1226
d3d3ff42 1227 return 0;
5e3dd157
KV		 1228}
1229
1230static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1231 struct ieee80211_sta *sta,
1232 struct wmi_peer_assoc_complete_arg *arg)
1233{
1234 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
a24b88b5 1235 u8 ampdu_factor;
5e3dd157
KV		 1236
1237 if (!vht_cap->vht_supported)
1238 return;
1239
1240 arg->peer_flags |= WMI_PEER_VHT;
5e3dd157
KV		 1241 arg->peer_vht_caps = vht_cap->cap;
1242
a24b88b5
SM		 1243
1244 ampdu_factor = (vht_cap->cap &
1245 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1246 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1247
1248 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1249 * zero in VHT IE. Using it would result in degraded throughput.
1250 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1251 * it if VHT max_mpdu is smaller. */
1252 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1253 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1254 ampdu_factor)) - 1);
1255
5e3dd157
KV		 1256 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1257 arg->peer_flags |= WMI_PEER_80MHZ;
1258
1259 arg->peer_vht_rates.rx_max_rate =
1260 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1261 arg->peer_vht_rates.rx_mcs_set =
1262 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1263 arg->peer_vht_rates.tx_max_rate =
1264 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1265 arg->peer_vht_rates.tx_mcs_set =
1266 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1267
60c3daa8
KV		 1268 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1269 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
5e3dd157
KV		 1270}
1271
1272static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1273 struct ath10k_vif *arvif,
1274 struct ieee80211_sta *sta,
1275 struct ieee80211_bss_conf *bss_conf,
1276 struct wmi_peer_assoc_complete_arg *arg)
1277{
1278 switch (arvif->vdev_type) {
1279 case WMI_VDEV_TYPE_AP:
d3d3ff42
JD		 1280 if (sta->wme)
1281 arg->peer_flags |= WMI_PEER_QOS;
1282
1283 if (sta->wme && sta->uapsd_queues) {
1284 arg->peer_flags |= WMI_PEER_APSD;
1285 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1286 }
5e3dd157
KV		 1287 break;
1288 case WMI_VDEV_TYPE_STA:
d3d3ff42
JD		 1289 if (bss_conf->qos)
1290 arg->peer_flags |= WMI_PEER_QOS;
5e3dd157
KV		 1291 break;
1292 default:
1293 break;
1294 }
1295}
1296
1297static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1298 struct ath10k_vif *arvif,
1299 struct ieee80211_sta *sta,
1300 struct wmi_peer_assoc_complete_arg *arg)
1301{
1302 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1303
5e3dd157
KV		 1304 switch (ar->hw->conf.chandef.chan->band) {
1305 case IEEE80211_BAND_2GHZ:
1306 if (sta->ht_cap.ht_supported) {
1307 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1308 phymode = MODE_11NG_HT40;
1309 else
1310 phymode = MODE_11NG_HT20;
1311 } else {
1312 phymode = MODE_11G;
1313 }
1314
1315 break;
1316 case IEEE80211_BAND_5GHZ:
7cc45e98
SM		 1317 /*
1318 * Check VHT first.
1319 */
1320 if (sta->vht_cap.vht_supported) {
1321 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1322 phymode = MODE_11AC_VHT80;
1323 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1324 phymode = MODE_11AC_VHT40;
1325 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1326 phymode = MODE_11AC_VHT20;
1327 } else if (sta->ht_cap.ht_supported) {
5e3dd157
KV		 1328 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1329 phymode = MODE_11NA_HT40;
1330 else
1331 phymode = MODE_11NA_HT20;
1332 } else {
1333 phymode = MODE_11A;
1334 }
1335
1336 break;
1337 default:
1338 break;
1339 }
1340
38a1d47e
KV		 1341 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1342 sta->addr, ath10k_wmi_phymode_str(phymode));
60c3daa8 1343
5e3dd157
KV		 1344 arg->peer_phymode = phymode;
1345 WARN_ON(phymode == MODE_UNKNOWN);
1346}
1347
b9ada65d
KV		 1348static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1349 struct ath10k_vif *arvif,
1350 struct ieee80211_sta *sta,
1351 struct ieee80211_bss_conf *bss_conf,
1352 struct wmi_peer_assoc_complete_arg *arg)
5e3dd157 1353{
548db54c
MK		 1354 lockdep_assert_held(&ar->conf_mutex);
1355
b9ada65d 1356 memset(arg, 0, sizeof(*arg));
5e3dd157 1357
b9ada65d
KV		 1358 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1359 ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1360 ath10k_peer_assoc_h_rates(ar, sta, arg);
1361 ath10k_peer_assoc_h_ht(ar, sta, arg);
1362 ath10k_peer_assoc_h_vht(ar, sta, arg);
1363 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1364 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
5e3dd157 1365
b9ada65d 1366 return 0;
5e3dd157
KV		 1367}
1368
90046f50
MK		 1369static const u32 ath10k_smps_map[] = {
1370 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1371 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1372 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1373 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1374};
1375
1376static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1377 const u8 *addr,
1378 const struct ieee80211_sta_ht_cap *ht_cap)
1379{
1380 int smps;
1381
1382 if (!ht_cap->ht_supported)
1383 return 0;
1384
1385 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1386 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1387
1388 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1389 return -EINVAL;
1390
1391 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1392 WMI_PEER_SMPS_STATE,
1393 ath10k_smps_map[smps]);
1394}
1395
5e3dd157
KV		 1396/* can be called only in mac80211 callbacks due to `key_count` usage */
1397static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1398 struct ieee80211_vif *vif,
1399 struct ieee80211_bss_conf *bss_conf)
1400{
1401 struct ath10k *ar = hw->priv;
1402 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
90046f50 1403 struct ieee80211_sta_ht_cap ht_cap;
b9ada65d 1404 struct wmi_peer_assoc_complete_arg peer_arg;
5e3dd157
KV		 1405 struct ieee80211_sta *ap_sta;
1406 int ret;
1407
548db54c
MK		 1408 lockdep_assert_held(&ar->conf_mutex);
1409
5e3dd157
KV		 1410 rcu_read_lock();
1411
1412 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1413 if (!ap_sta) {
1414 ath10k_warn("Failed to find station entry for %pM\n",
1415 bss_conf->bssid);
1416 rcu_read_unlock();
1417 return;
1418 }
1419
90046f50
MK		 1420 /* ap_sta must be accessed only within rcu section which must be left
1421 * before calling ath10k_setup_peer_smps() which might sleep. */
1422 ht_cap = ap_sta->ht_cap;
1423
b9ada65d
KV		 1424 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1425 bss_conf, &peer_arg);
5e3dd157 1426 if (ret) {
b9ada65d
KV		 1427 ath10k_warn("Peer assoc prepare failed for %pM\n: %d",
1428 bss_conf->bssid, ret);
5e3dd157
KV		 1429 rcu_read_unlock();
1430 return;
1431 }
1432
1433 rcu_read_unlock();
1434
b9ada65d
KV		 1435 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1436 if (ret) {
1437 ath10k_warn("Peer assoc failed for %pM\n: %d",
1438 bss_conf->bssid, ret);
1439 return;
1440 }
1441
90046f50
MK		 1442 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1443 if (ret) {
1444 ath10k_warn("failed to setup peer SMPS: %d\n", ret);
1445 return;
1446 }
1447
60c3daa8
KV		 1448 ath10k_dbg(ATH10K_DBG_MAC,
1449 "mac vdev %d up (associated) bssid %pM aid %d\n",
1450 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1451
c930f744
MK		 1452 arvif->aid = bss_conf->aid;
1453 memcpy(arvif->bssid, bss_conf->bssid, ETH_ALEN);
1454
1455 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1456 if (ret) {
5e3dd157
KV		 1457 ath10k_warn("VDEV: %d up failed: ret %d\n",
1458 arvif->vdev_id, ret);
c930f744
MK		 1459 return;
1460 }
1461
1462 arvif->is_up = true;
5e3dd157
KV		 1463}
1464
1465/*
1466 * FIXME: flush TIDs
1467 */
1468static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1469 struct ieee80211_vif *vif)
1470{
1471 struct ath10k *ar = hw->priv;
1472 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1473 int ret;
1474
548db54c
MK		 1475 lockdep_assert_held(&ar->conf_mutex);
1476
5e3dd157
KV		 1477 /*
1478 * For some reason, calling VDEV-DOWN before VDEV-STOP
1479 * makes the FW to send frames via HTT after disassociation.
1480 * No idea why this happens, even though VDEV-DOWN is supposed
1481 * to be analogous to link down, so just stop the VDEV.
1482 */
60c3daa8
KV		 1483 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1484 arvif->vdev_id);
1485
1486 /* FIXME: check return value */
5e3dd157 1487 ret = ath10k_vdev_stop(arvif);
5e3dd157
KV		 1488
1489 /*
1490 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1491 * report beacons from previously associated network through HTT.
1492 * This in turn would spam mac80211 WARN_ON if we bring down all
1493 * interfaces as it expects there is no rx when no interface is
1494 * running.
1495 */
60c3daa8
KV		 1496 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1497
1498 /* FIXME: why don't we print error if wmi call fails? */
5e3dd157 1499 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
5e3dd157 1500
cc4827b9 1501 arvif->def_wep_key_idx = 0;
c930f744
MK		 1502
1503 arvif->is_started = false;
1504 arvif->is_up = false;
5e3dd157
KV		 1505}
1506
1507static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1508 struct ieee80211_sta *sta)
1509{
b9ada65d 1510 struct wmi_peer_assoc_complete_arg peer_arg;
5e3dd157
KV		 1511 int ret = 0;
1512
548db54c
MK		 1513 lockdep_assert_held(&ar->conf_mutex);
1514
b9ada65d
KV		 1515 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1516 if (ret) {
1517 ath10k_warn("WMI peer assoc prepare failed for %pM\n",
1518 sta->addr);
1519 return ret;
1520 }
1521
1522 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
5e3dd157 1523 if (ret) {
b9ada65d
KV		 1524 ath10k_warn("Peer assoc failed for STA %pM\n: %d",
1525 sta->addr, ret);
5e3dd157
KV		 1526 return ret;
1527 }
1528
90046f50
MK		 1529 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, &sta->ht_cap);
1530 if (ret) {
1531 ath10k_warn("failed to setup peer SMPS: %d\n", ret);
1532 return ret;
1533 }
1534
5e3dd157
KV		 1535 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1536 if (ret) {
1537 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1538 return ret;
1539 }
1540
d3d3ff42
JD		 1541 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1542 if (ret) {
1543 ath10k_warn("could not set qos params for STA %pM, %d\n",
1544 sta->addr, ret);
1545 return ret;
1546 }
1547
5e3dd157
KV		 1548 return ret;
1549}
1550
1551static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1552 struct ieee80211_sta *sta)
1553{
1554 int ret = 0;
1555
548db54c
MK		 1556 lockdep_assert_held(&ar->conf_mutex);
1557
5e3dd157
KV		 1558 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1559 if (ret) {
1560 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1561 return ret;
1562 }
1563
1564 return ret;
1565}
1566
1567/**************/
1568/* Regulatory */
1569/**************/
1570
1571static int ath10k_update_channel_list(struct ath10k *ar)
1572{
1573 struct ieee80211_hw *hw = ar->hw;
1574 struct ieee80211_supported_band **bands;
1575 enum ieee80211_band band;
1576 struct ieee80211_channel *channel;
1577 struct wmi_scan_chan_list_arg arg = {0};
1578 struct wmi_channel_arg *ch;
1579 bool passive;
1580 int len;
1581 int ret;
1582 int i;
1583
548db54c
MK		 1584 lockdep_assert_held(&ar->conf_mutex);
1585
5e3dd157
KV		 1586 bands = hw->wiphy->bands;
1587 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1588 if (!bands[band])
1589 continue;
1590
1591 for (i = 0; i < bands[band]->n_channels; i++) {
1592 if (bands[band]->channels[i].flags &
1593 IEEE80211_CHAN_DISABLED)
1594 continue;
1595
1596 arg.n_channels++;
1597 }
1598 }
1599
1600 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1601 arg.channels = kzalloc(len, GFP_KERNEL);
1602 if (!arg.channels)
1603 return -ENOMEM;
1604
1605 ch = arg.channels;
1606 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1607 if (!bands[band])
1608 continue;
1609
1610 for (i = 0; i < bands[band]->n_channels; i++) {
1611 channel = &bands[band]->channels[i];
1612
1613 if (channel->flags & IEEE80211_CHAN_DISABLED)
1614 continue;
1615
1616 ch->allow_ht = true;
1617
1618 /* FIXME: when should we really allow VHT? */
1619 ch->allow_vht = true;
1620
1621 ch->allow_ibss =
8fe02e16 1622 !(channel->flags & IEEE80211_CHAN_NO_IR);
5e3dd157
KV		 1623
1624 ch->ht40plus =
1625 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1626
e8a50f8b
MP		 1627 ch->chan_radar =
1628 !!(channel->flags & IEEE80211_CHAN_RADAR);
1629
8fe02e16 1630 passive = channel->flags & IEEE80211_CHAN_NO_IR;
5e3dd157
KV		 1631 ch->passive = passive;
1632
1633 ch->freq = channel->center_freq;
89c5c843 1634 ch->min_power = 0;
02256930
MK		 1635 ch->max_power = channel->max_power * 2;
1636 ch->max_reg_power = channel->max_reg_power * 2;
1637 ch->max_antenna_gain = channel->max_antenna_gain * 2;
5e3dd157
KV		 1638 ch->reg_class_id = 0; /* FIXME */
1639
1640 /* FIXME: why use only legacy modes, why not any
1641 * HT/VHT modes? Would that even make any
1642 * difference? */
1643 if (channel->band == IEEE80211_BAND_2GHZ)
1644 ch->mode = MODE_11G;
1645 else
1646 ch->mode = MODE_11A;
1647
1648 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1649 continue;
1650
1651 ath10k_dbg(ATH10K_DBG_WMI,
60c3daa8
KV		 1652 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1653 ch - arg.channels, arg.n_channels,
5e3dd157
KV		 1654 ch->freq, ch->max_power, ch->max_reg_power,
1655 ch->max_antenna_gain, ch->mode);
1656
1657 ch++;
1658 }
1659 }
1660
1661 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1662 kfree(arg.channels);
1663
1664 return ret;
1665}
1666
f7843d7f 1667static void ath10k_regd_update(struct ath10k *ar)
5e3dd157 1668{
5e3dd157 1669 struct reg_dmn_pair_mapping *regpair;
5e3dd157
KV		 1670 int ret;
1671
f7843d7f 1672 lockdep_assert_held(&ar->conf_mutex);
5e3dd157
KV		 1673
1674 ret = ath10k_update_channel_list(ar);
1675 if (ret)
1676 ath10k_warn("could not update channel list (%d)\n", ret);
1677
1678 regpair = ar->ath_common.regulatory.regpair;
f7843d7f 1679
5e3dd157
KV		 1680 /* Target allows setting up per-band regdomain but ath_common provides
1681 * a combined one only */
1682 ret = ath10k_wmi_pdev_set_regdomain(ar,
ef8c0017
KV		 1683 regpair->reg_domain,
1684 regpair->reg_domain, /* 2ghz */
1685 regpair->reg_domain, /* 5ghz */
5e3dd157
KV		 1686 regpair->reg_2ghz_ctl,
1687 regpair->reg_5ghz_ctl);
1688 if (ret)
1689 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
f7843d7f 1690}
548db54c 1691
f7843d7f
MK		 1692static void ath10k_reg_notifier(struct wiphy *wiphy,
1693 struct regulatory_request *request)
1694{
1695 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1696 struct ath10k *ar = hw->priv;
9702c686 1697 bool result;
f7843d7f
MK		 1698
1699 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1700
9702c686
JD		 1701 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1702 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1703 request->dfs_region);
1704 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1705 request->dfs_region);
1706 if (!result)
1707 ath10k_warn("dfs region 0x%X not supported, will trigger radar for every pulse\n",
1708 request->dfs_region);
1709 }
1710
f7843d7f
MK		 1711 mutex_lock(&ar->conf_mutex);
1712 if (ar->state == ATH10K_STATE_ON)
1713 ath10k_regd_update(ar);
548db54c 1714 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 1715}
1716
1717/***************/
1718/* TX handlers */
1719/***************/
1720
42c3aa6f
MK		 1721static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1722{
1723 if (ieee80211_is_mgmt(hdr->frame_control))
1724 return HTT_DATA_TX_EXT_TID_MGMT;
1725
1726 if (!ieee80211_is_data_qos(hdr->frame_control))
1727 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1728
1729 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1730 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1731
1732 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1733}
1734
ddb6ad77
MK		 1735static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar,
1736 struct ieee80211_tx_info *info)
1737{
1738 if (info->control.vif)
1739 return ath10k_vif_to_arvif(info->control.vif)->vdev_id;
1740
1741 if (ar->monitor_enabled)
1742 return ar->monitor_vdev_id;
1743
1744 ath10k_warn("could not resolve vdev id\n");
1745 return 0;
1746}
1747
5e3dd157
KV		 1748/*
1749 * Frames sent to the FW have to be in "Native Wifi" format.
1750 * Strip the QoS field from the 802.11 header.
1751 */
1752static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1753 struct ieee80211_tx_control *control,
1754 struct sk_buff *skb)
1755{
1756 struct ieee80211_hdr *hdr = (void *)skb->data;
1757 u8 *qos_ctl;
1758
1759 if (!ieee80211_is_data_qos(hdr->frame_control))
1760 return;
1761
1762 qos_ctl = ieee80211_get_qos_ctl(hdr);
ba0ccd7a
MK		 1763 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1764 skb->data, (void *)qos_ctl - (void *)skb->data);
1765 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
5e3dd157
KV		 1766}
1767
cc4827b9
MK		 1768static void ath10k_tx_wep_key_work(struct work_struct *work)
1769{
1770 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1771 wep_key_work);
1772 int ret, keyidx = arvif->def_wep_key_newidx;
1773
1774 if (arvif->def_wep_key_idx == keyidx)
1775 return;
1776
1777 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1778 arvif->vdev_id, keyidx);
1779
1780 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1781 arvif->vdev_id,
1782 arvif->ar->wmi.vdev_param->def_keyid,
1783 keyidx);
1784 if (ret) {
1785 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1786 return;
1787 }
1788
1789 arvif->def_wep_key_idx = keyidx;
1790}
1791
5e3dd157
KV		 1792static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1793{
1794 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1795 struct ieee80211_vif *vif = info->control.vif;
1796 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1797 struct ath10k *ar = arvif->ar;
1798 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1799 struct ieee80211_key_conf *key = info->control.hw_key;
5e3dd157 1800
5e3dd157
KV		 1801 if (!ieee80211_has_protected(hdr->frame_control))
1802 return;
1803
1804 if (!key)
1805 return;
1806
1807 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1808 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1809 return;
1810
cc4827b9 1811 if (key->keyidx == arvif->def_wep_key_idx)
5e3dd157 1812 return;
5e3dd157 1813
cc4827b9
MK		 1814 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1815 * queueing frames until key index is updated is not an option because
1816 * sk_buff may need more processing to be done, e.g. offchannel */
1817 arvif->def_wep_key_newidx = key->keyidx;
1818 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
5e3dd157
KV		 1819}
1820
1821static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1822{
1823 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1824 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1825 struct ieee80211_vif *vif = info->control.vif;
1826 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1827
1828 /* This is case only for P2P_GO */
1829 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1830 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1831 return;
1832
1833 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1834 spin_lock_bh(&ar->data_lock);
1835 if (arvif->u.ap.noa_data)
1836 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1837 GFP_ATOMIC))
1838 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1839 arvif->u.ap.noa_data,
1840 arvif->u.ap.noa_len);
1841 spin_unlock_bh(&ar->data_lock);
1842 }
1843}
1844
1845static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1846{
1847 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5e00d31a 1848 int ret = 0;
5e3dd157 1849
961d4c38
MK		 1850 if (ar->htt.target_version_major >= 3) {
1851 /* Since HTT 3.0 there is no separate mgmt tx command */
1852 ret = ath10k_htt_tx(&ar->htt, skb);
1853 goto exit;
1854 }
1855
5e00d31a
BM		 1856 if (ieee80211_is_mgmt(hdr->frame_control)) {
1857 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1858 ar->fw_features)) {
1859 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
1860 ATH10K_MAX_NUM_MGMT_PENDING) {
1861 ath10k_warn("wmi mgmt_tx queue limit reached\n");
1862 ret = -EBUSY;
1863 goto exit;
1864 }
1865
1866 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
1867 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
1868 } else {
1869 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1870 }
1871 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1872 ar->fw_features) &&
1873 ieee80211_is_nullfunc(hdr->frame_control)) {
5e3dd157
KV		 1874 /* FW does not report tx status properly for NullFunc frames
1875 * unless they are sent through mgmt tx path. mac80211 sends
5e00d31a
BM		 1876 * those frames when it detects link/beacon loss and depends
1877 * on the tx status to be correct. */
edb8236d 1878 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
5e00d31a 1879 } else {
edb8236d 1880 ret = ath10k_htt_tx(&ar->htt, skb);
5e00d31a 1881 }
5e3dd157 1882
961d4c38 1883exit:
5e3dd157
KV		 1884 if (ret) {
1885 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1886 ieee80211_free_txskb(ar->hw, skb);
1887 }
1888}
1889
1890void ath10k_offchan_tx_purge(struct ath10k *ar)
1891{
1892 struct sk_buff *skb;
1893
1894 for (;;) {
1895 skb = skb_dequeue(&ar->offchan_tx_queue);
1896 if (!skb)
1897 break;
1898
1899 ieee80211_free_txskb(ar->hw, skb);
1900 }
1901}
1902
1903void ath10k_offchan_tx_work(struct work_struct *work)
1904{
1905 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1906 struct ath10k_peer *peer;
1907 struct ieee80211_hdr *hdr;
1908 struct sk_buff *skb;
1909 const u8 *peer_addr;
1910 int vdev_id;
1911 int ret;
1912
1913 /* FW requirement: We must create a peer before FW will send out
1914 * an offchannel frame. Otherwise the frame will be stuck and
1915 * never transmitted. We delete the peer upon tx completion.
1916 * It is unlikely that a peer for offchannel tx will already be
1917 * present. However it may be in some rare cases so account for that.
1918 * Otherwise we might remove a legitimate peer and break stuff. */
1919
1920 for (;;) {
1921 skb = skb_dequeue(&ar->offchan_tx_queue);
1922 if (!skb)
1923 break;
1924
1925 mutex_lock(&ar->conf_mutex);
1926
60c3daa8 1927 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
5e3dd157
KV		 1928 skb);
1929
1930 hdr = (struct ieee80211_hdr *)skb->data;
1931 peer_addr = ieee80211_get_DA(hdr);
5e00d31a 1932 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
5e3dd157
KV		 1933
1934 spin_lock_bh(&ar->data_lock);
1935 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1936 spin_unlock_bh(&ar->data_lock);
1937
1938 if (peer)
60c3daa8 1939 /* FIXME: should this use ath10k_warn()? */
5e3dd157
KV		 1940 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1941 peer_addr, vdev_id);
1942
1943 if (!peer) {
1944 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1945 if (ret)
1946 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1947 peer_addr, vdev_id, ret);
1948 }
1949
1950 spin_lock_bh(&ar->data_lock);
16735d02 1951 reinit_completion(&ar->offchan_tx_completed);
5e3dd157
KV		 1952 ar->offchan_tx_skb = skb;
1953 spin_unlock_bh(&ar->data_lock);
1954
1955 ath10k_tx_htt(ar, skb);
1956
1957 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1958 3 * HZ);
1959 if (ret <= 0)
1960 ath10k_warn("timed out waiting for offchannel skb %p\n",
1961 skb);
1962
1963 if (!peer) {
1964 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1965 if (ret)
1966 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1967 peer_addr, vdev_id, ret);
1968 }
1969
1970 mutex_unlock(&ar->conf_mutex);
1971 }
1972}
1973
5e00d31a
BM		 1974void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
1975{
1976 struct sk_buff *skb;
1977
1978 for (;;) {
1979 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
1980 if (!skb)
1981 break;
1982
1983 ieee80211_free_txskb(ar->hw, skb);
1984 }
1985}
1986
1987void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
1988{
1989 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
1990 struct sk_buff *skb;
1991 int ret;
1992
1993 for (;;) {
1994 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
1995 if (!skb)
1996 break;
1997
1998 ret = ath10k_wmi_mgmt_tx(ar, skb);
5fb5e41f 1999 if (ret) {
5e00d31a 2000 ath10k_warn("wmi mgmt_tx failed (%d)\n", ret);
5fb5e41f
MK		 2001 ieee80211_free_txskb(ar->hw, skb);
2002 }
5e00d31a
BM		 2003 }
2004}
2005
5e3dd157
KV		 2006/************/
2007/* Scanning */
2008/************/
2009
2010/*
2011 * This gets called if we dont get a heart-beat during scan.
2012 * This may indicate the FW has hung and we need to abort the
2013 * scan manually to prevent cancel_hw_scan() from deadlocking
2014 */
2015void ath10k_reset_scan(unsigned long ptr)
2016{
2017 struct ath10k *ar = (struct ath10k *)ptr;
2018
2019 spin_lock_bh(&ar->data_lock);
2020 if (!ar->scan.in_progress) {
2021 spin_unlock_bh(&ar->data_lock);
2022 return;
2023 }
2024
2025 ath10k_warn("scan timeout. resetting. fw issue?\n");
2026
2027 if (ar->scan.is_roc)
2028 ieee80211_remain_on_channel_expired(ar->hw);
2029 else
2030 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
2031
2032 ar->scan.in_progress = false;
2033 complete_all(&ar->scan.completed);
2034 spin_unlock_bh(&ar->data_lock);
2035}
2036
2037static int ath10k_abort_scan(struct ath10k *ar)
2038{
2039 struct wmi_stop_scan_arg arg = {
2040 .req_id = 1, /* FIXME */
2041 .req_type = WMI_SCAN_STOP_ONE,
2042 .u.scan_id = ATH10K_SCAN_ID,
2043 };
2044 int ret;
2045
2046 lockdep_assert_held(&ar->conf_mutex);
2047
2048 del_timer_sync(&ar->scan.timeout);
2049
2050 spin_lock_bh(&ar->data_lock);
2051 if (!ar->scan.in_progress) {
2052 spin_unlock_bh(&ar->data_lock);
2053 return 0;
2054 }
2055
2056 ar->scan.aborting = true;
2057 spin_unlock_bh(&ar->data_lock);
2058
2059 ret = ath10k_wmi_stop_scan(ar, &arg);
2060 if (ret) {
2061 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
adb8c9b7
MK		 2062 spin_lock_bh(&ar->data_lock);
2063 ar->scan.in_progress = false;
2064 ath10k_offchan_tx_purge(ar);
2065 spin_unlock_bh(&ar->data_lock);
5e3dd157
KV		 2066 return -EIO;
2067 }
2068
5e3dd157
KV		 2069 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2070 if (ret == 0)
2071 ath10k_warn("timed out while waiting for scan to stop\n");
2072
2073 /* scan completion may be done right after we timeout here, so let's
2074 * check the in_progress and tell mac80211 scan is completed. if we
2075 * don't do that and FW fails to send us scan completion indication
2076 * then userspace won't be able to scan anymore */
2077 ret = 0;
2078
2079 spin_lock_bh(&ar->data_lock);
2080 if (ar->scan.in_progress) {
2081 ath10k_warn("could not stop scan. its still in progress\n");
2082 ar->scan.in_progress = false;
2083 ath10k_offchan_tx_purge(ar);
2084 ret = -ETIMEDOUT;
2085 }
2086 spin_unlock_bh(&ar->data_lock);
2087
2088 return ret;
2089}
2090
2091static int ath10k_start_scan(struct ath10k *ar,
2092 const struct wmi_start_scan_arg *arg)
2093{
2094 int ret;
2095
2096 lockdep_assert_held(&ar->conf_mutex);
2097
2098 ret = ath10k_wmi_start_scan(ar, arg);
2099 if (ret)
2100 return ret;
2101
5e3dd157
KV		 2102 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2103 if (ret == 0) {
2104 ath10k_abort_scan(ar);
2105 return ret;
2106 }
2107
2108 /* the scan can complete earlier, before we even
2109 * start the timer. in that case the timer handler
2110 * checks ar->scan.in_progress and bails out if its
2111 * false. Add a 200ms margin to account event/command
2112 * processing. */
2113 mod_timer(&ar->scan.timeout, jiffies +
2114 msecs_to_jiffies(arg->max_scan_time+200));
2115 return 0;
2116}
2117
2118/**********************/
2119/* mac80211 callbacks */
2120/**********************/
2121
2122static void ath10k_tx(struct ieee80211_hw *hw,
2123 struct ieee80211_tx_control *control,
2124 struct sk_buff *skb)
2125{
2126 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2127 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2128 struct ath10k *ar = hw->priv;
ddb6ad77 2129 u8 tid, vdev_id;
5e3dd157
KV		 2130
2131 /* We should disable CCK RATE due to P2P */
2132 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2133 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2134
2135 /* we must calculate tid before we apply qos workaround
2136 * as we'd lose the qos control field */
42c3aa6f 2137 tid = ath10k_tx_h_get_tid(hdr);
ddb6ad77 2138 vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
5e3dd157 2139
cf84bd4d
MK		 2140 /* it makes no sense to process injected frames like that */
2141 if (info->control.vif &&
2142 info->control.vif->type != NL80211_IFTYPE_MONITOR) {
2143 ath10k_tx_h_qos_workaround(hw, control, skb);
2144 ath10k_tx_h_update_wep_key(skb);
2145 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
2146 ath10k_tx_h_seq_no(skb);
2147 }
5e3dd157 2148
5e00d31a 2149 ATH10K_SKB_CB(skb)->vdev_id = vdev_id;
27bb178d 2150 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
5e3dd157
KV		 2151 ATH10K_SKB_CB(skb)->htt.tid = tid;
2152
2153 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2154 spin_lock_bh(&ar->data_lock);
2155 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
5e00d31a 2156 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
5e3dd157
KV		 2157 spin_unlock_bh(&ar->data_lock);
2158
2159 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2160
2161 skb_queue_tail(&ar->offchan_tx_queue, skb);
2162 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2163 return;
2164 }
2165
2166 ath10k_tx_htt(ar, skb);
2167}
2168
2169/*
2170 * Initialize various parameters with default vaules.
2171 */
affd3217 2172void ath10k_halt(struct ath10k *ar)
818bdd16
MK		 2173{
2174 lockdep_assert_held(&ar->conf_mutex);
2175
e8a50f8b 2176 ath10k_stop_cac(ar);
818bdd16
MK		 2177 del_timer_sync(&ar->scan.timeout);
2178 ath10k_offchan_tx_purge(ar);
5e00d31a 2179 ath10k_mgmt_over_wmi_tx_purge(ar);
818bdd16
MK		 2180 ath10k_peer_cleanup_all(ar);
2181 ath10k_core_stop(ar);
2182 ath10k_hif_power_down(ar);
2183
2184 spin_lock_bh(&ar->data_lock);
2185 if (ar->scan.in_progress) {
2186 del_timer(&ar->scan.timeout);
2187 ar->scan.in_progress = false;
2188 ieee80211_scan_completed(ar->hw, true);
2189 }
2190 spin_unlock_bh(&ar->data_lock);
2191}
2192
5e3dd157
KV		 2193static int ath10k_start(struct ieee80211_hw *hw)
2194{
2195 struct ath10k *ar = hw->priv;
818bdd16 2196 int ret = 0;
5e3dd157 2197
548db54c
MK		 2198 mutex_lock(&ar->conf_mutex);
2199
affd3217
MK		 2200 if (ar->state != ATH10K_STATE_OFF &&
2201 ar->state != ATH10K_STATE_RESTARTING) {
818bdd16
MK		 2202 ret = -EINVAL;
2203 goto exit;
2204 }
2205
2206 ret = ath10k_hif_power_up(ar);
2207 if (ret) {
2208 ath10k_err("could not init hif (%d)\n", ret);
2209 ar->state = ATH10K_STATE_OFF;
2210 goto exit;
2211 }
2212
2213 ret = ath10k_core_start(ar);
2214 if (ret) {
2215 ath10k_err("could not init core (%d)\n", ret);
2216 ath10k_hif_power_down(ar);
2217 ar->state = ATH10K_STATE_OFF;
2218 goto exit;
2219 }
2220
affd3217
MK		 2221 if (ar->state == ATH10K_STATE_OFF)
2222 ar->state = ATH10K_STATE_ON;
2223 else if (ar->state == ATH10K_STATE_RESTARTING)
2224 ar->state = ATH10K_STATE_RESTARTED;
2225
226a339b 2226 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
5e3dd157
KV		 2227 if (ret)
2228 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
2229 ret);
2230
c4dd0d01 2231 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
5e3dd157
KV		 2232 if (ret)
2233 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
2234 ret);
2235
ab6258ed
MP		 2236 /*
2237 * By default FW set ARP frames ac to voice (6). In that case ARP
2238 * exchange is not working properly for UAPSD enabled AP. ARP requests
2239 * which arrives with access category 0 are processed by network stack
2240 * and send back with access category 0, but FW changes access category
2241 * to 6. Set ARP frames access category to best effort (0) solves
2242 * this problem.
2243 */
2244
2245 ret = ath10k_wmi_pdev_set_param(ar,
2246 ar->wmi.pdev_param->arp_ac_override, 0);
2247 if (ret) {
2248 ath10k_warn("could not set arp ac override parameter: %d\n",
2249 ret);
2250 goto exit;
2251 }
2252
f7843d7f 2253 ath10k_regd_update(ar);
c60bdd83 2254 ret = 0;
f7843d7f 2255
818bdd16 2256exit:
548db54c 2257 mutex_unlock(&ar->conf_mutex);
c60bdd83 2258 return ret;
5e3dd157
KV		 2259}
2260
2261static void ath10k_stop(struct ieee80211_hw *hw)
2262{
2263 struct ath10k *ar = hw->priv;
2264
548db54c 2265 mutex_lock(&ar->conf_mutex);
affd3217
MK		 2266 if (ar->state == ATH10K_STATE_ON ||
2267 ar->state == ATH10K_STATE_RESTARTED ||
2268 ar->state == ATH10K_STATE_WEDGED)
818bdd16 2269 ath10k_halt(ar);
a96d7745 2270
f7843d7f 2271 ar->state = ATH10K_STATE_OFF;
548db54c
MK		 2272 mutex_unlock(&ar->conf_mutex);
2273
5e00d31a
BM		 2274 ath10k_mgmt_over_wmi_tx_purge(ar);
2275
548db54c 2276 cancel_work_sync(&ar->offchan_tx_work);
5e00d31a 2277 cancel_work_sync(&ar->wmi_mgmt_tx_work);
affd3217 2278 cancel_work_sync(&ar->restart_work);
5e3dd157
KV		 2279}
2280
ad088bfa 2281static int ath10k_config_ps(struct ath10k *ar)
5e3dd157 2282{
ad088bfa
MK		 2283 struct ath10k_vif *arvif;
2284 int ret = 0;
affd3217
MK		 2285
2286 lockdep_assert_held(&ar->conf_mutex);
2287
ad088bfa
MK		 2288 list_for_each_entry(arvif, &ar->arvifs, list) {
2289 ret = ath10k_mac_vif_setup_ps(arvif);
2290 if (ret) {
2291 ath10k_warn("could not setup powersave (%d)\n", ret);
2292 break;
2293 }
2294 }
affd3217 2295
ad088bfa 2296 return ret;
affd3217
MK		 2297}
2298
c930f744
MK		 2299static const char *chandef_get_width(enum nl80211_chan_width width)
2300{
2301 switch (width) {
2302 case NL80211_CHAN_WIDTH_20_NOHT:
2303 return "20 (noht)";
2304 case NL80211_CHAN_WIDTH_20:
2305 return "20";
2306 case NL80211_CHAN_WIDTH_40:
2307 return "40";
2308 case NL80211_CHAN_WIDTH_80:
2309 return "80";
2310 case NL80211_CHAN_WIDTH_80P80:
2311 return "80+80";
2312 case NL80211_CHAN_WIDTH_160:
2313 return "160";
2314 case NL80211_CHAN_WIDTH_5:
2315 return "5";
2316 case NL80211_CHAN_WIDTH_10:
2317 return "10";
2318 }
2319 return "?";
2320}
2321
2322static void ath10k_config_chan(struct ath10k *ar)
2323{
2324 struct ath10k_vif *arvif;
2325 bool monitor_was_enabled;
2326 int ret;
2327
2328 lockdep_assert_held(&ar->conf_mutex);
2329
2330 ath10k_dbg(ATH10K_DBG_MAC,
2331 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2332 ar->chandef.chan->center_freq,
2333 ar->chandef.center_freq1,
2334 ar->chandef.center_freq2,
2335 chandef_get_width(ar->chandef.width));
2336
2337 /* First stop monitor interface. Some FW versions crash if there's a
2338 * lone monitor interface. */
2339 monitor_was_enabled = ar->monitor_enabled;
2340
2341 if (ar->monitor_enabled)
2342 ath10k_monitor_stop(ar);
2343
2344 list_for_each_entry(arvif, &ar->arvifs, list) {
2345 if (!arvif->is_started)
2346 continue;
2347
2348 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2349 continue;
2350
2351 ret = ath10k_vdev_stop(arvif);
2352 if (ret) {
2353 ath10k_warn("could not stop vdev %d (%d)\n",
2354 arvif->vdev_id, ret);
2355 continue;
2356 }
2357 }
2358
2359 /* all vdevs are now stopped - now attempt to restart them */
2360
2361 list_for_each_entry(arvif, &ar->arvifs, list) {
2362 if (!arvif->is_started)
2363 continue;
2364
2365 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2366 continue;
2367
2368 ret = ath10k_vdev_start(arvif);
2369 if (ret) {
2370 ath10k_warn("could not start vdev %d (%d)\n",
2371 arvif->vdev_id, ret);
2372 continue;
2373 }
2374
2375 if (!arvif->is_up)
2376 continue;
2377
2378 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2379 arvif->bssid);
2380 if (ret) {
2381 ath10k_warn("could not bring vdev up %d (%d)\n",
2382 arvif->vdev_id, ret);
2383 continue;
2384 }
2385 }
2386
2387 if (monitor_was_enabled)
2388 ath10k_monitor_start(ar, ar->monitor_vdev_id);
2389}
2390
affd3217
MK		 2391static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2392{
5e3dd157
KV		 2393 struct ath10k *ar = hw->priv;
2394 struct ieee80211_conf *conf = &hw->conf;
2395 int ret = 0;
5474efe8 2396 u32 param;
5e3dd157
KV		 2397
2398 mutex_lock(&ar->conf_mutex);
2399
2400 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
e8a50f8b
MP		 2401 ath10k_dbg(ATH10K_DBG_MAC,
2402 "mac config channel %d mhz flags 0x%x\n",
2403 conf->chandef.chan->center_freq,
2404 conf->chandef.chan->flags);
2405
5e3dd157
KV		 2406 spin_lock_bh(&ar->data_lock);
2407 ar->rx_channel = conf->chandef.chan;
2408 spin_unlock_bh(&ar->data_lock);
e8a50f8b
MP		 2409
2410 ath10k_config_radar_detection(ar);
c930f744
MK		 2411
2412 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2413 ar->chandef = conf->chandef;
2414 ath10k_config_chan(ar);
2415 }
5e3dd157
KV		 2416 }
2417
5474efe8
MK		 2418 if (changed & IEEE80211_CONF_CHANGE_POWER) {
2419 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2420 hw->conf.power_level);
2421
2422 param = ar->wmi.pdev_param->txpower_limit2g;
2423 ret = ath10k_wmi_pdev_set_param(ar, param,
2424 hw->conf.power_level * 2);
2425 if (ret)
2426 ath10k_warn("mac failed to set 2g txpower %d (%d)\n",
2427 hw->conf.power_level, ret);
2428
2429 param = ar->wmi.pdev_param->txpower_limit5g;
2430 ret = ath10k_wmi_pdev_set_param(ar, param,
2431 hw->conf.power_level * 2);
2432 if (ret)
2433 ath10k_warn("mac failed to set 5g txpower %d (%d)\n",
2434 hw->conf.power_level, ret);
5e3dd157
KV		 2435 }
2436
affd3217
MK		 2437 if (changed & IEEE80211_CONF_CHANGE_PS)
2438 ath10k_config_ps(ar);
5e3dd157
KV		 2439
2440 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2441 if (conf->flags & IEEE80211_CONF_MONITOR)
2442 ret = ath10k_monitor_create(ar);
2443 else
2444 ret = ath10k_monitor_destroy(ar);
2445 }
2446
2447 mutex_unlock(&ar->conf_mutex);
2448 return ret;
2449}
2450
2451/*
2452 * TODO:
2453 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2454 * because we will send mgmt frames without CCK. This requirement
2455 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2456 * in the TX packet.
2457 */
2458static int ath10k_add_interface(struct ieee80211_hw *hw,
2459 struct ieee80211_vif *vif)
2460{
2461 struct ath10k *ar = hw->priv;
2462 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2463 enum wmi_sta_powersave_param param;
2464 int ret = 0;
5a13e76e 2465 u32 value;
5e3dd157 2466 int bit;
6d1506e7 2467 u32 vdev_param;
5e3dd157
KV		 2468
2469 mutex_lock(&ar->conf_mutex);
2470
0dbd09e6
MK		 2471 memset(arvif, 0, sizeof(*arvif));
2472
5e3dd157
KV		 2473 arvif->ar = ar;
2474 arvif->vif = vif;
2475
cc4827b9 2476 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
e63b33f3 2477 INIT_LIST_HEAD(&arvif->list);
cc4827b9 2478
5e3dd157
KV		 2479 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
2480 ath10k_warn("Only one monitor interface allowed\n");
2481 ret = -EBUSY;
9dad14ae 2482 goto err;
5e3dd157
KV		 2483 }
2484
2485 bit = ffs(ar->free_vdev_map);
2486 if (bit == 0) {
2487 ret = -EBUSY;
9dad14ae 2488 goto err;
5e3dd157
KV		 2489 }
2490
2491 arvif->vdev_id = bit - 1;
2492 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
5e3dd157
KV		 2493
2494 if (ar->p2p)
2495 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2496
2497 switch (vif->type) {
2498 case NL80211_IFTYPE_UNSPECIFIED:
2499 case NL80211_IFTYPE_STATION:
2500 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2501 if (vif->p2p)
2502 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2503 break;
2504 case NL80211_IFTYPE_ADHOC:
2505 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2506 break;
2507 case NL80211_IFTYPE_AP:
2508 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2509
2510 if (vif->p2p)
2511 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2512 break;
2513 case NL80211_IFTYPE_MONITOR:
2514 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2515 break;
2516 default:
2517 WARN_ON(1);
2518 break;
2519 }
2520
60c3daa8 2521 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
5e3dd157
KV		 2522 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2523
2524 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2525 arvif->vdev_subtype, vif->addr);
2526 if (ret) {
2527 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
9dad14ae 2528 goto err;
5e3dd157
KV		 2529 }
2530
9dad14ae 2531 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
0579119f 2532 list_add(&arvif->list, &ar->arvifs);
9dad14ae 2533
6d1506e7
BM		 2534 vdev_param = ar->wmi.vdev_param->def_keyid;
2535 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
cc4827b9 2536 arvif->def_wep_key_idx);
9dad14ae 2537 if (ret) {
5e3dd157 2538 ath10k_warn("Failed to set default keyid: %d\n", ret);
9dad14ae
MK		 2539 goto err_vdev_delete;
2540 }
5e3dd157 2541
6d1506e7
BM		 2542 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2543 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157 2544 ATH10K_HW_TXRX_NATIVE_WIFI);
ebc9abdd 2545 /* 10.X firmware does not support this VDEV parameter. Do not warn */
9dad14ae 2546 if (ret && ret != -EOPNOTSUPP) {
5e3dd157 2547 ath10k_warn("Failed to set TX encap: %d\n", ret);
9dad14ae
MK		 2548 goto err_vdev_delete;
2549 }
5e3dd157
KV		 2550
2551 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2552 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2553 if (ret) {
2554 ath10k_warn("Failed to create peer for AP: %d\n", ret);
9dad14ae 2555 goto err_vdev_delete;
5e3dd157 2556 }
cdf07409 2557
5a13e76e
KV		 2558 ret = ath10k_mac_set_kickout(arvif);
2559 if (ret) {
2560 ath10k_warn("Failed to set kickout parameters: %d\n",
2561 ret);
2562 goto err_peer_delete;
2563 }
5e3dd157
KV		 2564 }
2565
2566 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2567 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2568 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2569 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2570 param, value);
9dad14ae 2571 if (ret) {
5e3dd157 2572 ath10k_warn("Failed to set RX wake policy: %d\n", ret);
9dad14ae
MK		 2573 goto err_peer_delete;
2574 }
5e3dd157
KV		 2575
2576 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2577 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2578 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2579 param, value);
9dad14ae 2580 if (ret) {
5e3dd157 2581 ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
9dad14ae
MK		 2582 goto err_peer_delete;
2583 }
5e3dd157
KV		 2584
2585 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2586 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2587 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2588 param, value);
9dad14ae 2589 if (ret) {
5e3dd157 2590 ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
9dad14ae
MK		 2591 goto err_peer_delete;
2592 }
5e3dd157
KV		 2593 }
2594
424121c3 2595 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
9dad14ae 2596 if (ret) {
679c54a6
MK		 2597 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n",
2598 arvif->vdev_id, ret);
9dad14ae
MK		 2599 goto err_peer_delete;
2600 }
679c54a6 2601
424121c3 2602 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
9dad14ae 2603 if (ret) {
679c54a6
MK		 2604 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n",
2605 arvif->vdev_id, ret);
9dad14ae
MK		 2606 goto err_peer_delete;
2607 }
679c54a6 2608
5e3dd157
KV		 2609 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2610 ar->monitor_present = true;
2611
5e3dd157 2612 mutex_unlock(&ar->conf_mutex);
9dad14ae
MK		 2613 return 0;
2614
2615err_peer_delete:
2616 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2617 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2618
2619err_vdev_delete:
2620 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2621 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
0579119f 2622 list_del(&arvif->list);
9dad14ae
MK		 2623
2624err:
2625 mutex_unlock(&ar->conf_mutex);
2626
5e3dd157
KV		 2627 return ret;
2628}
2629
2630static void ath10k_remove_interface(struct ieee80211_hw *hw,
2631 struct ieee80211_vif *vif)
2632{
2633 struct ath10k *ar = hw->priv;
2634 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2635 int ret;
2636
2637 mutex_lock(&ar->conf_mutex);
2638
cc4827b9
MK		 2639 cancel_work_sync(&arvif->wep_key_work);
2640
ed54388a
MK		 2641 spin_lock_bh(&ar->data_lock);
2642 if (arvif->beacon) {
2643 dev_kfree_skb_any(arvif->beacon);
2644 arvif->beacon = NULL;
2645 }
2646 spin_unlock_bh(&ar->data_lock);
2647
5e3dd157 2648 ar->free_vdev_map |= 1 << (arvif->vdev_id);
0579119f 2649 list_del(&arvif->list);
5e3dd157
KV		 2650
2651 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2652 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2653 if (ret)
2654 ath10k_warn("Failed to remove peer for AP: %d\n", ret);
2655
2656 kfree(arvif->u.ap.noa_data);
2657 }
2658
60c3daa8
KV		 2659 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev delete %d (remove interface)\n",
2660 arvif->vdev_id);
2661
5e3dd157
KV		 2662 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2663 if (ret)
2664 ath10k_warn("WMI vdev delete failed: %d\n", ret);
2665
2666 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2667 ar->monitor_present = false;
2668
2669 ath10k_peer_cleanup(ar, arvif->vdev_id);
2670
2671 mutex_unlock(&ar->conf_mutex);
2672}
2673
2674/*
2675 * FIXME: Has to be verified.
2676 */
2677#define SUPPORTED_FILTERS \
2678 (FIF_PROMISC_IN_BSS | \
2679 FIF_ALLMULTI | \
2680 FIF_CONTROL | \
2681 FIF_PSPOLL | \
2682 FIF_OTHER_BSS | \
2683 FIF_BCN_PRBRESP_PROMISC | \
2684 FIF_PROBE_REQ | \
2685 FIF_FCSFAIL)
2686
2687static void ath10k_configure_filter(struct ieee80211_hw *hw,
2688 unsigned int changed_flags,
2689 unsigned int *total_flags,
2690 u64 multicast)
2691{
2692 struct ath10k *ar = hw->priv;
2693 int ret;
2694
2695 mutex_lock(&ar->conf_mutex);
2696
2697 changed_flags &= SUPPORTED_FILTERS;
2698 *total_flags &= SUPPORTED_FILTERS;
2699 ar->filter_flags = *total_flags;
2700
afd0922e
MK		 2701 /* Monitor must not be started if it wasn't created first.
2702 * Promiscuous mode may be started on a non-monitor interface - in
2703 * such case the monitor vdev is not created so starting the
2704 * monitor makes no sense. Since ath10k uses no special RX filters
2705 * (only BSS filter in STA mode) there's no need for any special
2706 * action here. */
5e3dd157 2707 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
afd0922e 2708 !ar->monitor_enabled && ar->monitor_present) {
60c3daa8
KV		 2709 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d start\n",
2710 ar->monitor_vdev_id);
2711
5e3dd157
KV		 2712 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
2713 if (ret)
2714 ath10k_warn("Unable to start monitor mode\n");
5e3dd157 2715 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
afd0922e 2716 ar->monitor_enabled && ar->monitor_present) {
60c3daa8
KV		 2717 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d stop\n",
2718 ar->monitor_vdev_id);
2719
5e3dd157
KV		 2720 ret = ath10k_monitor_stop(ar);
2721 if (ret)
2722 ath10k_warn("Unable to stop monitor mode\n");
5e3dd157
KV		 2723 }
2724
2725 mutex_unlock(&ar->conf_mutex);
2726}
2727
2728static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2729 struct ieee80211_vif *vif,
2730 struct ieee80211_bss_conf *info,
2731 u32 changed)
2732{
2733 struct ath10k *ar = hw->priv;
2734 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2735 int ret = 0;
226a339b 2736 u32 vdev_param, pdev_param;
5e3dd157
KV		 2737
2738 mutex_lock(&ar->conf_mutex);
2739
2740 if (changed & BSS_CHANGED_IBSS)
2741 ath10k_control_ibss(arvif, info, vif->addr);
2742
2743 if (changed & BSS_CHANGED_BEACON_INT) {
2744 arvif->beacon_interval = info->beacon_int;
6d1506e7
BM		 2745 vdev_param = ar->wmi.vdev_param->beacon_interval;
2746 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157 2747 arvif->beacon_interval);
60c3daa8
KV		 2748 ath10k_dbg(ATH10K_DBG_MAC,
2749 "mac vdev %d beacon_interval %d\n",
2750 arvif->vdev_id, arvif->beacon_interval);
2751
5e3dd157
KV		 2752 if (ret)
2753 ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
2754 arvif->vdev_id);
5e3dd157
KV		 2755 }
2756
2757 if (changed & BSS_CHANGED_BEACON) {
60c3daa8
KV		 2758 ath10k_dbg(ATH10K_DBG_MAC,
2759 "vdev %d set beacon tx mode to staggered\n",
2760 arvif->vdev_id);
2761
226a339b
BM		 2762 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
2763 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
5e3dd157
KV		 2764 WMI_BEACON_STAGGERED_MODE);
2765 if (ret)
2766 ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
2767 arvif->vdev_id);
5e3dd157
KV		 2768 }
2769
b70727e8 2770 if (changed & BSS_CHANGED_BEACON_INFO) {
5e3dd157
KV		 2771 arvif->dtim_period = info->dtim_period;
2772
60c3daa8
KV		 2773 ath10k_dbg(ATH10K_DBG_MAC,
2774 "mac vdev %d dtim_period %d\n",
2775 arvif->vdev_id, arvif->dtim_period);
2776
6d1506e7
BM		 2777 vdev_param = ar->wmi.vdev_param->dtim_period;
2778 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2779 arvif->dtim_period);
2780 if (ret)
2781 ath10k_warn("Failed to set dtim period for VDEV: %d\n",
2782 arvif->vdev_id);
5e3dd157
KV		 2783 }
2784
2785 if (changed & BSS_CHANGED_SSID &&
2786 vif->type == NL80211_IFTYPE_AP) {
2787 arvif->u.ap.ssid_len = info->ssid_len;
2788 if (info->ssid_len)
2789 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2790 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2791 }
2792
2793 if (changed & BSS_CHANGED_BSSID) {
2794 if (!is_zero_ether_addr(info->bssid)) {
60c3daa8
KV		 2795 ath10k_dbg(ATH10K_DBG_MAC,
2796 "mac vdev %d create peer %pM\n",
2797 arvif->vdev_id, info->bssid);
2798
5e3dd157
KV		 2799 ret = ath10k_peer_create(ar, arvif->vdev_id,
2800 info->bssid);
2801 if (ret)
479398b0
BG		 2802 ath10k_warn("Failed to add peer %pM for vdev %d when changin bssid: %i\n",
2803 info->bssid, arvif->vdev_id, ret);
5e3dd157
KV		 2804
2805 if (vif->type == NL80211_IFTYPE_STATION) {
2806 /*
2807 * this is never erased as we it for crypto key
2808 * clearing; this is FW requirement
2809 */
c930f744 2810 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
5e3dd157 2811
60c3daa8
KV		 2812 ath10k_dbg(ATH10K_DBG_MAC,
2813 "mac vdev %d start %pM\n",
2814 arvif->vdev_id, info->bssid);
2815
5e3dd157 2816 ret = ath10k_vdev_start(arvif);
c930f744
MK		 2817 if (ret) {
2818 ath10k_warn("failed to start vdev: %d\n",
2819 ret);
75459e33 2820 goto exit;
c930f744
MK		 2821 }
2822
2823 arvif->is_started = true;
5e3dd157
KV		 2824 }
2825
2826 /*
2827 * Mac80211 does not keep IBSS bssid when leaving IBSS,
2828 * so driver need to store it. It is needed when leaving
2829 * IBSS in order to remove BSSID peer.
2830 */
2831 if (vif->type == NL80211_IFTYPE_ADHOC)
c930f744 2832 memcpy(arvif->bssid, info->bssid,
5e3dd157
KV		 2833 ETH_ALEN);
2834 }
2835 }
2836
2837 if (changed & BSS_CHANGED_BEACON_ENABLED)
2838 ath10k_control_beaconing(arvif, info);
2839
2840 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2841 u32 cts_prot;
2842 if (info->use_cts_prot)
2843 cts_prot = 1;
2844 else
2845 cts_prot = 0;
2846
60c3daa8
KV		 2847 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
2848 arvif->vdev_id, cts_prot);
2849
6d1506e7
BM		 2850 vdev_param = ar->wmi.vdev_param->enable_rtscts;
2851 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2852 cts_prot);
2853 if (ret)
2854 ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2855 arvif->vdev_id);
5e3dd157
KV		 2856 }
2857
2858 if (changed & BSS_CHANGED_ERP_SLOT) {
2859 u32 slottime;
2860 if (info->use_short_slot)
2861 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2862
2863 else
2864 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2865
60c3daa8
KV		 2866 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
2867 arvif->vdev_id, slottime);
2868
6d1506e7
BM		 2869 vdev_param = ar->wmi.vdev_param->slot_time;
2870 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2871 slottime);
2872 if (ret)
2873 ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2874 arvif->vdev_id);
5e3dd157
KV		 2875 }
2876
2877 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2878 u32 preamble;
2879 if (info->use_short_preamble)
2880 preamble = WMI_VDEV_PREAMBLE_SHORT;
2881 else
2882 preamble = WMI_VDEV_PREAMBLE_LONG;
2883
60c3daa8
KV		 2884 ath10k_dbg(ATH10K_DBG_MAC,
2885 "mac vdev %d preamble %dn",
2886 arvif->vdev_id, preamble);
2887
6d1506e7
BM		 2888 vdev_param = ar->wmi.vdev_param->preamble;
2889 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 2890 preamble);
2891 if (ret)
2892 ath10k_warn("Failed to set preamble for VDEV: %d\n",
2893 arvif->vdev_id);
5e3dd157
KV		 2894 }
2895
2896 if (changed & BSS_CHANGED_ASSOC) {
2897 if (info->assoc)
2898 ath10k_bss_assoc(hw, vif, info);
2899 }
2900
75459e33 2901exit:
5e3dd157
KV		 2902 mutex_unlock(&ar->conf_mutex);
2903}
2904
2905static int ath10k_hw_scan(struct ieee80211_hw *hw,
2906 struct ieee80211_vif *vif,
2907 struct cfg80211_scan_request *req)
2908{
2909 struct ath10k *ar = hw->priv;
2910 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2911 struct wmi_start_scan_arg arg;
2912 int ret = 0;
2913 int i;
2914
2915 mutex_lock(&ar->conf_mutex);
2916
2917 spin_lock_bh(&ar->data_lock);
2918 if (ar->scan.in_progress) {
2919 spin_unlock_bh(&ar->data_lock);
2920 ret = -EBUSY;
2921 goto exit;
2922 }
2923
16735d02
WS		 2924 reinit_completion(&ar->scan.started);
2925 reinit_completion(&ar->scan.completed);
5e3dd157
KV		 2926 ar->scan.in_progress = true;
2927 ar->scan.aborting = false;
2928 ar->scan.is_roc = false;
2929 ar->scan.vdev_id = arvif->vdev_id;
2930 spin_unlock_bh(&ar->data_lock);
2931
2932 memset(&arg, 0, sizeof(arg));
2933 ath10k_wmi_start_scan_init(ar, &arg);
2934 arg.vdev_id = arvif->vdev_id;
2935 arg.scan_id = ATH10K_SCAN_ID;
2936
2937 if (!req->no_cck)
2938 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2939
2940 if (req->ie_len) {
2941 arg.ie_len = req->ie_len;
2942 memcpy(arg.ie, req->ie, arg.ie_len);
2943 }
2944
2945 if (req->n_ssids) {
2946 arg.n_ssids = req->n_ssids;
2947 for (i = 0; i < arg.n_ssids; i++) {
2948 arg.ssids[i].len = req->ssids[i].ssid_len;
2949 arg.ssids[i].ssid = req->ssids[i].ssid;
2950 }
dcd4a561
MK		 2951 } else {
2952 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5e3dd157
KV		 2953 }
2954
2955 if (req->n_channels) {
2956 arg.n_channels = req->n_channels;
2957 for (i = 0; i < arg.n_channels; i++)
2958 arg.channels[i] = req->channels[i]->center_freq;
2959 }
2960
2961 ret = ath10k_start_scan(ar, &arg);
2962 if (ret) {
2963 ath10k_warn("could not start hw scan (%d)\n", ret);
2964 spin_lock_bh(&ar->data_lock);
2965 ar->scan.in_progress = false;
2966 spin_unlock_bh(&ar->data_lock);
2967 }
2968
2969exit:
2970 mutex_unlock(&ar->conf_mutex);
2971 return ret;
2972}
2973
2974static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2975 struct ieee80211_vif *vif)
2976{
2977 struct ath10k *ar = hw->priv;
2978 int ret;
2979
2980 mutex_lock(&ar->conf_mutex);
2981 ret = ath10k_abort_scan(ar);
2982 if (ret) {
2983 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2984 ret);
2985 ieee80211_scan_completed(hw, 1 /* aborted */);
2986 }
2987 mutex_unlock(&ar->conf_mutex);
2988}
2989
cfb27d29
MK		 2990static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
2991 struct ath10k_vif *arvif,
2992 enum set_key_cmd cmd,
2993 struct ieee80211_key_conf *key)
2994{
2995 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
2996 int ret;
2997
2998 /* 10.1 firmware branch requires default key index to be set to group
2999 * key index after installing it. Otherwise FW/HW Txes corrupted
3000 * frames with multi-vif APs. This is not required for main firmware
3001 * branch (e.g. 636).
3002 *
3003 * FIXME: This has been tested only in AP. It remains unknown if this
3004 * is required for multi-vif STA interfaces on 10.1 */
3005
3006 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3007 return;
3008
3009 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3010 return;
3011
3012 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3013 return;
3014
3015 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3016 return;
3017
3018 if (cmd != SET_KEY)
3019 return;
3020
3021 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3022 key->keyidx);
3023 if (ret)
3024 ath10k_warn("failed to set group key as default key: %d\n",
3025 ret);
3026}
3027
5e3dd157
KV		 3028static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3029 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3030 struct ieee80211_key_conf *key)
3031{
3032 struct ath10k *ar = hw->priv;
3033 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3034 struct ath10k_peer *peer;
3035 const u8 *peer_addr;
3036 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3037 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3038 int ret = 0;
3039
3040 if (key->keyidx > WMI_MAX_KEY_INDEX)
3041 return -ENOSPC;
3042
3043 mutex_lock(&ar->conf_mutex);
3044
3045 if (sta)
3046 peer_addr = sta->addr;
3047 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3048 peer_addr = vif->bss_conf.bssid;
3049 else
3050 peer_addr = vif->addr;
3051
3052 key->hw_key_idx = key->keyidx;
3053
3054 /* the peer should not disappear in mid-way (unless FW goes awry) since
3055 * we already hold conf_mutex. we just make sure its there now. */
3056 spin_lock_bh(&ar->data_lock);
3057 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3058 spin_unlock_bh(&ar->data_lock);
3059
3060 if (!peer) {
3061 if (cmd == SET_KEY) {
3062 ath10k_warn("cannot install key for non-existent peer %pM\n",
3063 peer_addr);
3064 ret = -EOPNOTSUPP;
3065 goto exit;
3066 } else {
3067 /* if the peer doesn't exist there is no key to disable
3068 * anymore */
3069 goto exit;
3070 }
3071 }
3072
3073 if (is_wep) {
3074 if (cmd == SET_KEY)
3075 arvif->wep_keys[key->keyidx] = key;
3076 else
3077 arvif->wep_keys[key->keyidx] = NULL;
3078
3079 if (cmd == DISABLE_KEY)
3080 ath10k_clear_vdev_key(arvif, key);
3081 }
3082
3083 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3084 if (ret) {
3085 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
3086 goto exit;
3087 }
3088
cfb27d29
MK		 3089 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3090
5e3dd157
KV		 3091 spin_lock_bh(&ar->data_lock);
3092 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3093 if (peer && cmd == SET_KEY)
3094 peer->keys[key->keyidx] = key;
3095 else if (peer && cmd == DISABLE_KEY)
3096 peer->keys[key->keyidx] = NULL;
3097 else if (peer == NULL)
3098 /* impossible unless FW goes crazy */
3099 ath10k_warn("peer %pM disappeared!\n", peer_addr);
3100 spin_unlock_bh(&ar->data_lock);
3101
3102exit:
3103 mutex_unlock(&ar->conf_mutex);
3104 return ret;
3105}
3106
3107static int ath10k_sta_state(struct ieee80211_hw *hw,
3108 struct ieee80211_vif *vif,
3109 struct ieee80211_sta *sta,
3110 enum ieee80211_sta_state old_state,
3111 enum ieee80211_sta_state new_state)
3112{
3113 struct ath10k *ar = hw->priv;
3114 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
0e759f36 3115 int max_num_peers;
5e3dd157
KV		 3116 int ret = 0;
3117
3118 mutex_lock(&ar->conf_mutex);
3119
3120 if (old_state == IEEE80211_STA_NOTEXIST &&
3121 new_state == IEEE80211_STA_NONE &&
3122 vif->type != NL80211_IFTYPE_STATION) {
3123 /*
3124 * New station addition.
3125 */
0e759f36
BM		 3126 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3127 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3128 else
3129 max_num_peers = TARGET_NUM_PEERS;
3130
3131 if (ar->num_peers >= max_num_peers) {
3132 ath10k_warn("Number of peers exceeded: peers number %d (max peers %d)\n",
3133 ar->num_peers, max_num_peers);
3134 ret = -ENOBUFS;
3135 goto exit;
3136 }
3137
60c3daa8 3138 ath10k_dbg(ATH10K_DBG_MAC,
0e759f36
BM		 3139 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3140 arvif->vdev_id, sta->addr, ar->num_peers);
60c3daa8 3141
5e3dd157
KV		 3142 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3143 if (ret)
479398b0
BG		 3144 ath10k_warn("Failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3145 sta->addr, arvif->vdev_id, ret);
5e3dd157
KV		 3146 } else if ((old_state == IEEE80211_STA_NONE &&
3147 new_state == IEEE80211_STA_NOTEXIST)) {
3148 /*
3149 * Existing station deletion.
3150 */
60c3daa8
KV		 3151 ath10k_dbg(ATH10K_DBG_MAC,
3152 "mac vdev %d peer delete %pM (sta gone)\n",
3153 arvif->vdev_id, sta->addr);
5e3dd157
KV		 3154 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3155 if (ret)
3156 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
3157 sta->addr, arvif->vdev_id);
5e3dd157
KV		 3158
3159 if (vif->type == NL80211_IFTYPE_STATION)
3160 ath10k_bss_disassoc(hw, vif);
3161 } else if (old_state == IEEE80211_STA_AUTH &&
3162 new_state == IEEE80211_STA_ASSOC &&
3163 (vif->type == NL80211_IFTYPE_AP ||
3164 vif->type == NL80211_IFTYPE_ADHOC)) {
3165 /*
3166 * New association.
3167 */
60c3daa8
KV		 3168 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
3169 sta->addr);
3170
5e3dd157
KV		 3171 ret = ath10k_station_assoc(ar, arvif, sta);
3172 if (ret)
3173 ath10k_warn("Failed to associate station: %pM\n",
3174 sta->addr);
5e3dd157
KV		 3175 } else if (old_state == IEEE80211_STA_ASSOC &&
3176 new_state == IEEE80211_STA_AUTH &&
3177 (vif->type == NL80211_IFTYPE_AP ||
3178 vif->type == NL80211_IFTYPE_ADHOC)) {
3179 /*
3180 * Disassociation.
3181 */
60c3daa8
KV		 3182 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3183 sta->addr);
3184
5e3dd157
KV		 3185 ret = ath10k_station_disassoc(ar, arvif, sta);
3186 if (ret)
3187 ath10k_warn("Failed to disassociate station: %pM\n",
3188 sta->addr);
5e3dd157 3189 }
0e759f36 3190exit:
5e3dd157
KV		 3191 mutex_unlock(&ar->conf_mutex);
3192 return ret;
3193}
3194
3195static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3196 u16 ac, bool enable)
3197{
3198 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3199 u32 value = 0;
3200 int ret = 0;
3201
548db54c
MK		 3202 lockdep_assert_held(&ar->conf_mutex);
3203
5e3dd157
KV		 3204 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3205 return 0;
3206
3207 switch (ac) {
3208 case IEEE80211_AC_VO:
3209 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3210 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3211 break;
3212 case IEEE80211_AC_VI:
3213 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3214 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3215 break;
3216 case IEEE80211_AC_BE:
3217 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3218 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3219 break;
3220 case IEEE80211_AC_BK:
3221 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3222 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3223 break;
3224 }
3225
3226 if (enable)
3227 arvif->u.sta.uapsd |= value;
3228 else
3229 arvif->u.sta.uapsd &= ~value;
3230
3231 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3232 WMI_STA_PS_PARAM_UAPSD,
3233 arvif->u.sta.uapsd);
3234 if (ret) {
3235 ath10k_warn("could not set uapsd params %d\n", ret);
3236 goto exit;
3237 }
3238
3239 if (arvif->u.sta.uapsd)
3240 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3241 else
3242 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3243
3244 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3245 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3246 value);
3247 if (ret)
3248 ath10k_warn("could not set rx wake param %d\n", ret);
3249
3250exit:
3251 return ret;
3252}
3253
3254static int ath10k_conf_tx(struct ieee80211_hw *hw,
3255 struct ieee80211_vif *vif, u16 ac,
3256 const struct ieee80211_tx_queue_params *params)
3257{
3258 struct ath10k *ar = hw->priv;
3259 struct wmi_wmm_params_arg *p = NULL;
3260 int ret;
3261
3262 mutex_lock(&ar->conf_mutex);
3263
3264 switch (ac) {
3265 case IEEE80211_AC_VO:
3266 p = &ar->wmm_params.ac_vo;
3267 break;
3268 case IEEE80211_AC_VI:
3269 p = &ar->wmm_params.ac_vi;
3270 break;
3271 case IEEE80211_AC_BE:
3272 p = &ar->wmm_params.ac_be;
3273 break;
3274 case IEEE80211_AC_BK:
3275 p = &ar->wmm_params.ac_bk;
3276 break;
3277 }
3278
3279 if (WARN_ON(!p)) {
3280 ret = -EINVAL;
3281 goto exit;
3282 }
3283
3284 p->cwmin = params->cw_min;
3285 p->cwmax = params->cw_max;
3286 p->aifs = params->aifs;
3287
3288 /*
3289 * The channel time duration programmed in the HW is in absolute
3290 * microseconds, while mac80211 gives the txop in units of
3291 * 32 microseconds.
3292 */
3293 p->txop = params->txop * 32;
3294
3295 /* FIXME: FW accepts wmm params per hw, not per vif */
3296 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3297 if (ret) {
3298 ath10k_warn("could not set wmm params %d\n", ret);
3299 goto exit;
3300 }
3301
3302 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3303 if (ret)
3304 ath10k_warn("could not set sta uapsd %d\n", ret);
3305
3306exit:
3307 mutex_unlock(&ar->conf_mutex);
3308 return ret;
3309}
3310
3311#define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3312
3313static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3314 struct ieee80211_vif *vif,
3315 struct ieee80211_channel *chan,
3316 int duration,
3317 enum ieee80211_roc_type type)
3318{
3319 struct ath10k *ar = hw->priv;
3320 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3321 struct wmi_start_scan_arg arg;
3322 int ret;
3323
3324 mutex_lock(&ar->conf_mutex);
3325
3326 spin_lock_bh(&ar->data_lock);
3327 if (ar->scan.in_progress) {
3328 spin_unlock_bh(&ar->data_lock);
3329 ret = -EBUSY;
3330 goto exit;
3331 }
3332
16735d02
WS		 3333 reinit_completion(&ar->scan.started);
3334 reinit_completion(&ar->scan.completed);
3335 reinit_completion(&ar->scan.on_channel);
5e3dd157
KV		 3336 ar->scan.in_progress = true;
3337 ar->scan.aborting = false;
3338 ar->scan.is_roc = true;
3339 ar->scan.vdev_id = arvif->vdev_id;
3340 ar->scan.roc_freq = chan->center_freq;
3341 spin_unlock_bh(&ar->data_lock);
3342
3343 memset(&arg, 0, sizeof(arg));
3344 ath10k_wmi_start_scan_init(ar, &arg);
3345 arg.vdev_id = arvif->vdev_id;
3346 arg.scan_id = ATH10K_SCAN_ID;
3347 arg.n_channels = 1;
3348 arg.channels[0] = chan->center_freq;
3349 arg.dwell_time_active = duration;
3350 arg.dwell_time_passive = duration;
3351 arg.max_scan_time = 2 * duration;
3352 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3353 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3354
3355 ret = ath10k_start_scan(ar, &arg);
3356 if (ret) {
3357 ath10k_warn("could not start roc scan (%d)\n", ret);
3358 spin_lock_bh(&ar->data_lock);
3359 ar->scan.in_progress = false;
3360 spin_unlock_bh(&ar->data_lock);
3361 goto exit;
3362 }
3363
3364 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3365 if (ret == 0) {
3366 ath10k_warn("could not switch to channel for roc scan\n");
3367 ath10k_abort_scan(ar);
3368 ret = -ETIMEDOUT;
3369 goto exit;
3370 }
3371
3372 ret = 0;
3373exit:
3374 mutex_unlock(&ar->conf_mutex);
3375 return ret;
3376}
3377
3378static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3379{
3380 struct ath10k *ar = hw->priv;
3381
3382 mutex_lock(&ar->conf_mutex);
3383 ath10k_abort_scan(ar);
3384 mutex_unlock(&ar->conf_mutex);
3385
3386 return 0;
3387}
3388
3389/*
3390 * Both RTS and Fragmentation threshold are interface-specific
3391 * in ath10k, but device-specific in mac80211.
3392 */
5e3dd157 3393
ad088bfa
MK		 3394static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3395{
3396 struct ath10k *ar = hw->priv;
3397 struct ath10k_vif *arvif;
3398 int ret = 0;
548db54c 3399
5e3dd157 3400 mutex_lock(&ar->conf_mutex);
ad088bfa
MK		 3401 list_for_each_entry(arvif, &ar->arvifs, list) {
3402 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3403 arvif->vdev_id, value);
3404
3405 ret = ath10k_mac_set_rts(arvif, value);
3406 if (ret) {
3407 ath10k_warn("could not set rts threshold for vdev %d (%d)\n",
3408 arvif->vdev_id, ret);
3409 break;
3410 }
3411 }
5e3dd157
KV		 3412 mutex_unlock(&ar->conf_mutex);
3413
ad088bfa 3414 return ret;
5e3dd157
KV		 3415}
3416
ad088bfa 3417static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5e3dd157 3418{
ad088bfa
MK		 3419 struct ath10k *ar = hw->priv;
3420 struct ath10k_vif *arvif;
3421 int ret = 0;
548db54c 3422
5e3dd157 3423 mutex_lock(&ar->conf_mutex);
ad088bfa
MK		 3424 list_for_each_entry(arvif, &ar->arvifs, list) {
3425 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3426 arvif->vdev_id, value);
3427
3428 ret = ath10k_mac_set_rts(arvif, value);
3429 if (ret) {
3430 ath10k_warn("could not set fragmentation threshold for vdev %d (%d)\n",
3431 arvif->vdev_id, ret);
3432 break;
3433 }
3434 }
5e3dd157
KV		 3435 mutex_unlock(&ar->conf_mutex);
3436
ad088bfa 3437 return ret;
5e3dd157
KV		 3438}
3439
3440static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
3441{
3442 struct ath10k *ar = hw->priv;
affd3217 3443 bool skip;
5e3dd157
KV		 3444 int ret;
3445
3446 /* mac80211 doesn't care if we really xmit queued frames or not
3447 * we'll collect those frames either way if we stop/delete vdevs */
3448 if (drop)
3449 return;
3450
548db54c
MK		 3451 mutex_lock(&ar->conf_mutex);
3452
affd3217
MK		 3453 if (ar->state == ATH10K_STATE_WEDGED)
3454 goto skip;
3455
edb8236d 3456 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
5e3dd157 3457 bool empty;
affd3217 3458
edb8236d 3459 spin_lock_bh(&ar->htt.tx_lock);
0945baf7 3460 empty = (ar->htt.num_pending_tx == 0);
edb8236d 3461 spin_unlock_bh(&ar->htt.tx_lock);
affd3217
MK		 3462
3463 skip = (ar->state == ATH10K_STATE_WEDGED);
3464
3465 (empty || skip);
5e3dd157 3466 }), ATH10K_FLUSH_TIMEOUT_HZ);
affd3217
MK		 3467
3468 if (ret <= 0 || skip)
5e3dd157 3469 ath10k_warn("tx not flushed\n");
548db54c 3470
affd3217 3471skip:
548db54c 3472 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 3473}
3474
3475/* TODO: Implement this function properly
3476 * For now it is needed to reply to Probe Requests in IBSS mode.
3477 * Propably we need this information from FW.
3478 */
3479static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3480{
3481 return 1;
3482}
3483
8cd13cad
MK		 3484#ifdef CONFIG_PM
3485static int ath10k_suspend(struct ieee80211_hw *hw,
3486 struct cfg80211_wowlan *wowlan)
3487{
3488 struct ath10k *ar = hw->priv;
3489 int ret;
3490
9042e17d
MP		 3491 mutex_lock(&ar->conf_mutex);
3492
00f5482b 3493 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
8cd13cad 3494 if (ret) {
00f5482b
MP		 3495 if (ret == -ETIMEDOUT)
3496 goto resume;
9042e17d
MP		 3497 ret = 1;
3498 goto exit;
8cd13cad
MK		 3499 }
3500
8cd13cad
MK		 3501 ret = ath10k_hif_suspend(ar);
3502 if (ret) {
3503 ath10k_warn("could not suspend hif (%d)\n", ret);
3504 goto resume;
3505 }
3506
9042e17d
MP		 3507 ret = 0;
3508 goto exit;
8cd13cad
MK		 3509resume:
3510 ret = ath10k_wmi_pdev_resume_target(ar);
3511 if (ret)
3512 ath10k_warn("could not resume target (%d)\n", ret);
9042e17d
MP		 3513
3514 ret = 1;
3515exit:
3516 mutex_unlock(&ar->conf_mutex);
3517 return ret;
8cd13cad
MK		 3518}
3519
3520static int ath10k_resume(struct ieee80211_hw *hw)
3521{
3522 struct ath10k *ar = hw->priv;
3523 int ret;
3524
9042e17d
MP		 3525 mutex_lock(&ar->conf_mutex);
3526
8cd13cad
MK		 3527 ret = ath10k_hif_resume(ar);
3528 if (ret) {
3529 ath10k_warn("could not resume hif (%d)\n", ret);
9042e17d
MP		 3530 ret = 1;
3531 goto exit;
8cd13cad
MK		 3532 }
3533
3534 ret = ath10k_wmi_pdev_resume_target(ar);
3535 if (ret) {
3536 ath10k_warn("could not resume target (%d)\n", ret);
9042e17d
MP		 3537 ret = 1;
3538 goto exit;
8cd13cad
MK		 3539 }
3540
9042e17d
MP		 3541 ret = 0;
3542exit:
3543 mutex_unlock(&ar->conf_mutex);
3544 return ret;
8cd13cad
MK		 3545}
3546#endif
3547
affd3217
MK		 3548static void ath10k_restart_complete(struct ieee80211_hw *hw)
3549{
3550 struct ath10k *ar = hw->priv;
3551
3552 mutex_lock(&ar->conf_mutex);
3553
3554 /* If device failed to restart it will be in a different state, e.g.
3555 * ATH10K_STATE_WEDGED */
3556 if (ar->state == ATH10K_STATE_RESTARTED) {
3557 ath10k_info("device successfully recovered\n");
3558 ar->state = ATH10K_STATE_ON;
3559 }
3560
3561 mutex_unlock(&ar->conf_mutex);
3562}
3563
2e1dea40
MK		 3564static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3565 struct survey_info *survey)
3566{
3567 struct ath10k *ar = hw->priv;
3568 struct ieee80211_supported_band *sband;
3569 struct survey_info *ar_survey = &ar->survey[idx];
3570 int ret = 0;
3571
3572 mutex_lock(&ar->conf_mutex);
3573
3574 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3575 if (sband && idx >= sband->n_channels) {
3576 idx -= sband->n_channels;
3577 sband = NULL;
3578 }
3579
3580 if (!sband)
3581 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3582
3583 if (!sband || idx >= sband->n_channels) {
3584 ret = -ENOENT;
3585 goto exit;
3586 }
3587
3588 spin_lock_bh(&ar->data_lock);
3589 memcpy(survey, ar_survey, sizeof(*survey));
3590 spin_unlock_bh(&ar->data_lock);
3591
3592 survey->channel = &sband->channels[idx];
3593
3594exit:
3595 mutex_unlock(&ar->conf_mutex);
3596 return ret;
3597}
3598
51ab1a0a
JD		 3599/* Helper table for legacy fixed_rate/bitrate_mask */
3600static const u8 cck_ofdm_rate[] = {
3601 /* CCK */
3602 3, /* 1Mbps */
3603 2, /* 2Mbps */
3604 1, /* 5.5Mbps */
3605 0, /* 11Mbps */
3606 /* OFDM */
3607 3, /* 6Mbps */
3608 7, /* 9Mbps */
3609 2, /* 12Mbps */
3610 6, /* 18Mbps */
3611 1, /* 24Mbps */
3612 5, /* 36Mbps */
3613 0, /* 48Mbps */
3614 4, /* 54Mbps */
3615};
3616
3617/* Check if only one bit set */
3618static int ath10k_check_single_mask(u32 mask)
3619{
3620 int bit;
3621
3622 bit = ffs(mask);
3623 if (!bit)
3624 return 0;
3625
3626 mask &= ~BIT(bit - 1);
3627 if (mask)
3628 return 2;
3629
3630 return 1;
3631}
3632
3633static bool
3634ath10k_default_bitrate_mask(struct ath10k *ar,
3635 enum ieee80211_band band,
3636 const struct cfg80211_bitrate_mask *mask)
3637{
3638 u32 legacy = 0x00ff;
3639 u8 ht = 0xff, i;
3640 u16 vht = 0x3ff;
3641
3642 switch (band) {
3643 case IEEE80211_BAND_2GHZ:
3644 legacy = 0x00fff;
3645 vht = 0;
3646 break;
3647 case IEEE80211_BAND_5GHZ:
3648 break;
3649 default:
3650 return false;
3651 }
3652
3653 if (mask->control[band].legacy != legacy)
3654 return false;
3655
3656 for (i = 0; i < ar->num_rf_chains; i++)
3657 if (mask->control[band].ht_mcs[i] != ht)
3658 return false;
3659
3660 for (i = 0; i < ar->num_rf_chains; i++)
3661 if (mask->control[band].vht_mcs[i] != vht)
3662 return false;
3663
3664 return true;
3665}
3666
3667static bool
3668ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
3669 enum ieee80211_band band,
3670 u8 *fixed_nss)
3671{
3672 int ht_nss = 0, vht_nss = 0, i;
3673
3674 /* check legacy */
3675 if (ath10k_check_single_mask(mask->control[band].legacy))
3676 return false;
3677
3678 /* check HT */
3679 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3680 if (mask->control[band].ht_mcs[i] == 0xff)
3681 continue;
3682 else if (mask->control[band].ht_mcs[i] == 0x00)
3683 break;
3684 else
3685 return false;
3686 }
3687
3688 ht_nss = i;
3689
3690 /* check VHT */
3691 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3692 if (mask->control[band].vht_mcs[i] == 0x03ff)
3693 continue;
3694 else if (mask->control[band].vht_mcs[i] == 0x0000)
3695 break;
3696 else
3697 return false;
3698 }
3699
3700 vht_nss = i;
3701
3702 if (ht_nss > 0 && vht_nss > 0)
3703 return false;
3704
3705 if (ht_nss)
3706 *fixed_nss = ht_nss;
3707 else if (vht_nss)
3708 *fixed_nss = vht_nss;
3709 else
3710 return false;
3711
3712 return true;
3713}
3714
3715static bool
3716ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
3717 enum ieee80211_band band,
3718 enum wmi_rate_preamble *preamble)
3719{
3720 int legacy = 0, ht = 0, vht = 0, i;
3721
3722 *preamble = WMI_RATE_PREAMBLE_OFDM;
3723
3724 /* check legacy */
3725 legacy = ath10k_check_single_mask(mask->control[band].legacy);
3726 if (legacy > 1)
3727 return false;
3728
3729 /* check HT */
3730 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3731 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
3732 if (ht > 1)
3733 return false;
3734
3735 /* check VHT */
3736 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3737 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
3738 if (vht > 1)
3739 return false;
3740
3741 /* Currently we support only one fixed_rate */
3742 if ((legacy + ht + vht) != 1)
3743 return false;
3744
3745 if (ht)
3746 *preamble = WMI_RATE_PREAMBLE_HT;
3747 else if (vht)
3748 *preamble = WMI_RATE_PREAMBLE_VHT;
3749
3750 return true;
3751}
3752
3753static bool
3754ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask,
3755 enum ieee80211_band band,
3756 u8 *fixed_rate,
3757 u8 *fixed_nss)
3758{
3759 u8 rate = 0, pream = 0, nss = 0, i;
3760 enum wmi_rate_preamble preamble;
3761
3762 /* Check if single rate correct */
3763 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
3764 return false;
3765
3766 pream = preamble;
3767
3768 switch (preamble) {
3769 case WMI_RATE_PREAMBLE_CCK:
3770 case WMI_RATE_PREAMBLE_OFDM:
3771 i = ffs(mask->control[band].legacy) - 1;
3772
3773 if (band == IEEE80211_BAND_2GHZ && i < 4)
3774 pream = WMI_RATE_PREAMBLE_CCK;
3775
3776 if (band == IEEE80211_BAND_5GHZ)
3777 i += 4;
3778
3779 if (i >= ARRAY_SIZE(cck_ofdm_rate))
3780 return false;
3781
3782 rate = cck_ofdm_rate[i];
3783 break;
3784 case WMI_RATE_PREAMBLE_HT:
3785 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3786 if (mask->control[band].ht_mcs[i])
3787 break;
3788
3789 if (i == IEEE80211_HT_MCS_MASK_LEN)
3790 return false;
3791
3792 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
3793 nss = i;
3794 break;
3795 case WMI_RATE_PREAMBLE_VHT:
3796 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3797 if (mask->control[band].vht_mcs[i])
3798 break;
3799
3800 if (i == NL80211_VHT_NSS_MAX)
3801 return false;
3802
3803 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
3804 nss = i;
3805 break;
3806 }
3807
3808 *fixed_nss = nss + 1;
3809 nss <<= 4;
3810 pream <<= 6;
3811
3812 ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
3813 pream, nss, rate);
3814
3815 *fixed_rate = pream | nss | rate;
3816
3817 return true;
3818}
3819
3820static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask,
3821 enum ieee80211_band band,
3822 u8 *fixed_rate,
3823 u8 *fixed_nss)
3824{
3825 /* First check full NSS mask, if we can simply limit NSS */
3826 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
3827 return true;
3828
3829 /* Next Check single rate is set */
3830 return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss);
3831}
3832
3833static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
3834 u8 fixed_rate,
3835 u8 fixed_nss)
3836{
3837 struct ath10k *ar = arvif->ar;
3838 u32 vdev_param;
3839 int ret = 0;
3840
3841 mutex_lock(&ar->conf_mutex);
3842
3843 if (arvif->fixed_rate == fixed_rate &&
3844 arvif->fixed_nss == fixed_nss)
3845 goto exit;
3846
3847 if (fixed_rate == WMI_FIXED_RATE_NONE)
3848 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
3849
3850 vdev_param = ar->wmi.vdev_param->fixed_rate;
3851 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
3852 vdev_param, fixed_rate);
3853 if (ret) {
3854 ath10k_warn("Could not set fixed_rate param 0x%02x: %d\n",
3855 fixed_rate, ret);
3856 ret = -EINVAL;
3857 goto exit;
3858 }
3859
3860 arvif->fixed_rate = fixed_rate;
3861
3862 vdev_param = ar->wmi.vdev_param->nss;
3863 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
3864 vdev_param, fixed_nss);
3865
3866 if (ret) {
3867 ath10k_warn("Could not set fixed_nss param %d: %d\n",
3868 fixed_nss, ret);
3869 ret = -EINVAL;
3870 goto exit;
3871 }
3872
3873 arvif->fixed_nss = fixed_nss;
3874
3875exit:
3876 mutex_unlock(&ar->conf_mutex);
3877 return ret;
3878}
3879
3880static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
3881 struct ieee80211_vif *vif,
3882 const struct cfg80211_bitrate_mask *mask)
3883{
3884 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3885 struct ath10k *ar = arvif->ar;
3886 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
3887 u8 fixed_rate = WMI_FIXED_RATE_NONE;
3888 u8 fixed_nss = ar->num_rf_chains;
3889
3890 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
3891 if (!ath10k_get_fixed_rate_nss(mask, band,
3892 &fixed_rate,
3893 &fixed_nss))
3894 return -EINVAL;
3895 }
3896
3897 return ath10k_set_fixed_rate_param(arvif, fixed_rate, fixed_nss);
3898}
3899
c2df44b3
MK		 3900static void ath10k_channel_switch_beacon(struct ieee80211_hw *hw,
3901 struct ieee80211_vif *vif,
3902 struct cfg80211_chan_def *chandef)
3903{
3904 /* there's no need to do anything here. vif->csa_active is enough */
3905 return;
3906}
3907
5e3dd157
KV		 3908static const struct ieee80211_ops ath10k_ops = {
3909 .tx = ath10k_tx,
3910 .start = ath10k_start,
3911 .stop = ath10k_stop,
3912 .config = ath10k_config,
3913 .add_interface = ath10k_add_interface,
3914 .remove_interface = ath10k_remove_interface,
3915 .configure_filter = ath10k_configure_filter,
3916 .bss_info_changed = ath10k_bss_info_changed,
3917 .hw_scan = ath10k_hw_scan,
3918 .cancel_hw_scan = ath10k_cancel_hw_scan,
3919 .set_key = ath10k_set_key,
3920 .sta_state = ath10k_sta_state,
3921 .conf_tx = ath10k_conf_tx,
3922 .remain_on_channel = ath10k_remain_on_channel,
3923 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
3924 .set_rts_threshold = ath10k_set_rts_threshold,
3925 .set_frag_threshold = ath10k_set_frag_threshold,
3926 .flush = ath10k_flush,
3927 .tx_last_beacon = ath10k_tx_last_beacon,
affd3217 3928 .restart_complete = ath10k_restart_complete,
2e1dea40 3929 .get_survey = ath10k_get_survey,
51ab1a0a 3930 .set_bitrate_mask = ath10k_set_bitrate_mask,
c2df44b3 3931 .channel_switch_beacon = ath10k_channel_switch_beacon,
8cd13cad
MK		 3932#ifdef CONFIG_PM
3933 .suspend = ath10k_suspend,
3934 .resume = ath10k_resume,
3935#endif
5e3dd157
KV		 3936};
3937
3938#define RATETAB_ENT(_rate, _rateid, _flags) { \
3939 .bitrate = (_rate), \
3940 .flags = (_flags), \
3941 .hw_value = (_rateid), \
3942}
3943
3944#define CHAN2G(_channel, _freq, _flags) { \
3945 .band = IEEE80211_BAND_2GHZ, \
3946 .hw_value = (_channel), \
3947 .center_freq = (_freq), \
3948 .flags = (_flags), \
3949 .max_antenna_gain = 0, \
3950 .max_power = 30, \
3951}
3952
3953#define CHAN5G(_channel, _freq, _flags) { \
3954 .band = IEEE80211_BAND_5GHZ, \
3955 .hw_value = (_channel), \
3956 .center_freq = (_freq), \
3957 .flags = (_flags), \
3958 .max_antenna_gain = 0, \
3959 .max_power = 30, \
3960}
3961
3962static const struct ieee80211_channel ath10k_2ghz_channels[] = {
3963 CHAN2G(1, 2412, 0),
3964 CHAN2G(2, 2417, 0),
3965 CHAN2G(3, 2422, 0),
3966 CHAN2G(4, 2427, 0),
3967 CHAN2G(5, 2432, 0),
3968 CHAN2G(6, 2437, 0),
3969 CHAN2G(7, 2442, 0),
3970 CHAN2G(8, 2447, 0),
3971 CHAN2G(9, 2452, 0),
3972 CHAN2G(10, 2457, 0),
3973 CHAN2G(11, 2462, 0),
3974 CHAN2G(12, 2467, 0),
3975 CHAN2G(13, 2472, 0),
3976 CHAN2G(14, 2484, 0),
3977};
3978
3979static const struct ieee80211_channel ath10k_5ghz_channels[] = {
429ff56a
MK		 3980 CHAN5G(36, 5180, 0),
3981 CHAN5G(40, 5200, 0),
3982 CHAN5G(44, 5220, 0),
3983 CHAN5G(48, 5240, 0),
3984 CHAN5G(52, 5260, 0),
3985 CHAN5G(56, 5280, 0),
3986 CHAN5G(60, 5300, 0),
3987 CHAN5G(64, 5320, 0),
3988 CHAN5G(100, 5500, 0),
3989 CHAN5G(104, 5520, 0),
3990 CHAN5G(108, 5540, 0),
3991 CHAN5G(112, 5560, 0),
3992 CHAN5G(116, 5580, 0),
3993 CHAN5G(120, 5600, 0),
3994 CHAN5G(124, 5620, 0),
3995 CHAN5G(128, 5640, 0),
3996 CHAN5G(132, 5660, 0),
3997 CHAN5G(136, 5680, 0),
3998 CHAN5G(140, 5700, 0),
3999 CHAN5G(149, 5745, 0),
4000 CHAN5G(153, 5765, 0),
4001 CHAN5G(157, 5785, 0),
4002 CHAN5G(161, 5805, 0),
4003 CHAN5G(165, 5825, 0),
5e3dd157
KV		 4004};
4005
4006static struct ieee80211_rate ath10k_rates[] = {
4007 /* CCK */
4008 RATETAB_ENT(10, 0x82, 0),
4009 RATETAB_ENT(20, 0x84, 0),
4010 RATETAB_ENT(55, 0x8b, 0),
4011 RATETAB_ENT(110, 0x96, 0),
4012 /* OFDM */
4013 RATETAB_ENT(60, 0x0c, 0),
4014 RATETAB_ENT(90, 0x12, 0),
4015 RATETAB_ENT(120, 0x18, 0),
4016 RATETAB_ENT(180, 0x24, 0),
4017 RATETAB_ENT(240, 0x30, 0),
4018 RATETAB_ENT(360, 0x48, 0),
4019 RATETAB_ENT(480, 0x60, 0),
4020 RATETAB_ENT(540, 0x6c, 0),
4021};
4022
4023#define ath10k_a_rates (ath10k_rates + 4)
4024#define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4025#define ath10k_g_rates (ath10k_rates + 0)
4026#define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4027
4028struct ath10k *ath10k_mac_create(void)
4029{
4030 struct ieee80211_hw *hw;
4031 struct ath10k *ar;
4032
4033 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
4034 if (!hw)
4035 return NULL;
4036
4037 ar = hw->priv;
4038 ar->hw = hw;
4039
4040 return ar;
4041}
4042
4043void ath10k_mac_destroy(struct ath10k *ar)
4044{
4045 ieee80211_free_hw(ar->hw);
4046}
4047
4048static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4049 {
4050 .max = 8,
4051 .types = BIT(NL80211_IFTYPE_STATION)
4052 | BIT(NL80211_IFTYPE_P2P_CLIENT)
d531cb85
MK		 4053 },
4054 {
4055 .max = 3,
4056 .types = BIT(NL80211_IFTYPE_P2P_GO)
4057 },
4058 {
4059 .max = 7,
4060 .types = BIT(NL80211_IFTYPE_AP)
4061 },
5e3dd157
KV		 4062};
4063
f259509b 4064static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
e8a50f8b
MP		 4065 {
4066 .max = 8,
4067 .types = BIT(NL80211_IFTYPE_AP)
4068 },
4069};
e8a50f8b
MP		 4070
4071static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4072 {
4073 .limits = ath10k_if_limits,
4074 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4075 .max_interfaces = 8,
4076 .num_different_channels = 1,
4077 .beacon_int_infra_match = true,
4078 },
f259509b
BM		 4079};
4080
4081static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
e8a50f8b 4082 {
f259509b
BM		 4083 .limits = ath10k_10x_if_limits,
4084 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
e8a50f8b
MP		 4085 .max_interfaces = 8,
4086 .num_different_channels = 1,
4087 .beacon_int_infra_match = true,
f259509b 4088#ifdef CONFIG_ATH10K_DFS_CERTIFIED
e8a50f8b
MP		 4089 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4090 BIT(NL80211_CHAN_WIDTH_20) |
4091 BIT(NL80211_CHAN_WIDTH_40) |
4092 BIT(NL80211_CHAN_WIDTH_80),
e8a50f8b 4093#endif
f259509b 4094 },
5e3dd157
KV		 4095};
4096
4097static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4098{
4099 struct ieee80211_sta_vht_cap vht_cap = {0};
4100 u16 mcs_map;
8865bee4 4101 int i;
5e3dd157
KV		 4102
4103 vht_cap.vht_supported = 1;
4104 vht_cap.cap = ar->vht_cap_info;
4105
8865bee4
MK		 4106 mcs_map = 0;
4107 for (i = 0; i < 8; i++) {
4108 if (i < ar->num_rf_chains)
4109 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4110 else
4111 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4112 }
5e3dd157
KV		 4113
4114 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4115 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4116
4117 return vht_cap;
4118}
4119
4120static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4121{
4122 int i;
4123 struct ieee80211_sta_ht_cap ht_cap = {0};
4124
4125 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4126 return ht_cap;
4127
4128 ht_cap.ht_supported = 1;
4129 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4130 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4131 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4132 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4133 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4134
4135 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4136 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4137
4138 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4139 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4140
4141 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4142 u32 smps;
4143
4144 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4145 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4146
4147 ht_cap.cap |= smps;
4148 }
4149
4150 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4151 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4152
4153 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4154 u32 stbc;
4155
4156 stbc = ar->ht_cap_info;
4157 stbc &= WMI_HT_CAP_RX_STBC;
4158 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4159 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4160 stbc &= IEEE80211_HT_CAP_RX_STBC;
4161
4162 ht_cap.cap |= stbc;
4163 }
4164
4165 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4166 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4167
4168 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4169 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4170
4171 /* max AMSDU is implicitly taken from vht_cap_info */
4172 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4173 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4174
8865bee4 4175 for (i = 0; i < ar->num_rf_chains; i++)
5e3dd157
KV		 4176 ht_cap.mcs.rx_mask[i] = 0xFF;
4177
4178 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4179
4180 return ht_cap;
4181}
4182
4183
4184static void ath10k_get_arvif_iter(void *data, u8 *mac,
4185 struct ieee80211_vif *vif)
4186{
4187 struct ath10k_vif_iter *arvif_iter = data;
4188 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4189
4190 if (arvif->vdev_id == arvif_iter->vdev_id)
4191 arvif_iter->arvif = arvif;
4192}
4193
4194struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4195{
4196 struct ath10k_vif_iter arvif_iter;
4197 u32 flags;
4198
4199 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4200 arvif_iter.vdev_id = vdev_id;
4201
4202 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4203 ieee80211_iterate_active_interfaces_atomic(ar->hw,
4204 flags,
4205 ath10k_get_arvif_iter,
4206 &arvif_iter);
4207 if (!arvif_iter.arvif) {
4208 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
4209 return NULL;
4210 }
4211
4212 return arvif_iter.arvif;
4213}
4214
4215int ath10k_mac_register(struct ath10k *ar)
4216{
4217 struct ieee80211_supported_band *band;
4218 struct ieee80211_sta_vht_cap vht_cap;
4219 struct ieee80211_sta_ht_cap ht_cap;
4220 void *channels;
4221 int ret;
4222
4223 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4224
4225 SET_IEEE80211_DEV(ar->hw, ar->dev);
4226
4227 ht_cap = ath10k_get_ht_cap(ar);
4228 vht_cap = ath10k_create_vht_cap(ar);
4229
4230 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4231 channels = kmemdup(ath10k_2ghz_channels,
4232 sizeof(ath10k_2ghz_channels),
4233 GFP_KERNEL);
d6015b27
MK		 4234 if (!channels) {
4235 ret = -ENOMEM;
4236 goto err_free;
4237 }
5e3dd157
KV		 4238
4239 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4240 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4241 band->channels = channels;
4242 band->n_bitrates = ath10k_g_rates_size;
4243 band->bitrates = ath10k_g_rates;
4244 band->ht_cap = ht_cap;
4245
4246 /* vht is not supported in 2.4 GHz */
4247
4248 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4249 }
4250
4251 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4252 channels = kmemdup(ath10k_5ghz_channels,
4253 sizeof(ath10k_5ghz_channels),
4254 GFP_KERNEL);
4255 if (!channels) {
d6015b27
MK		 4256 ret = -ENOMEM;
4257 goto err_free;
5e3dd157
KV		 4258 }
4259
4260 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4261 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4262 band->channels = channels;
4263 band->n_bitrates = ath10k_a_rates_size;
4264 band->bitrates = ath10k_a_rates;
4265 band->ht_cap = ht_cap;
4266 band->vht_cap = vht_cap;
4267 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4268 }
4269
4270 ar->hw->wiphy->interface_modes =
4271 BIT(NL80211_IFTYPE_STATION) |
4272 BIT(NL80211_IFTYPE_ADHOC) |
d354181f
BM		 4273 BIT(NL80211_IFTYPE_AP);
4274
4275 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4276 ar->hw->wiphy->interface_modes |=
4277 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4278 BIT(NL80211_IFTYPE_P2P_GO);
5e3dd157
KV		 4279
4280 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4281 IEEE80211_HW_SUPPORTS_PS |
4282 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4283 IEEE80211_HW_SUPPORTS_UAPSD |
4284 IEEE80211_HW_MFP_CAPABLE |
4285 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4286 IEEE80211_HW_HAS_RATE_CONTROL |
4287 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
4288 IEEE80211_HW_WANT_MONITOR_VIF |
4289 IEEE80211_HW_AP_LINK_PS;
4290
1f8bb151
MK		 4291 /* MSDU can have HTT TX fragment pushed in front. The additional 4
4292 * bytes is used for padding/alignment if necessary. */
4293 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4294
5e3dd157
KV		 4295 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4296 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
4297
4298 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4299 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4300 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4301 }
4302
4303 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4304 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4305
4306 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4307
5e3dd157
KV		 4308 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4309
4310 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
c2df44b3 4311 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
5e3dd157
KV		 4312 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4313
4314 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4315 /*
4316 * on LL hardware queues are managed entirely by the FW
4317 * so we only advertise to mac we can do the queues thing
4318 */
4319 ar->hw->queues = 4;
4320
f259509b
BM		 4321 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4322 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4323 ar->hw->wiphy->n_iface_combinations =
4324 ARRAY_SIZE(ath10k_10x_if_comb);
4325 } else {
4326 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4327 ar->hw->wiphy->n_iface_combinations =
4328 ARRAY_SIZE(ath10k_if_comb);
4329 }
5e3dd157 4330
7c199997
MK		 4331 ar->hw->netdev_features = NETIF_F_HW_CSUM;
4332
9702c686
JD		 4333 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4334 /* Init ath dfs pattern detector */
4335 ar->ath_common.debug_mask = ATH_DBG_DFS;
4336 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4337 NL80211_DFS_UNSET);
4338
4339 if (!ar->dfs_detector)
4340 ath10k_warn("dfs pattern detector init failed\n");
4341 }
4342
5e3dd157
KV		 4343 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4344 ath10k_reg_notifier);
4345 if (ret) {
4346 ath10k_err("Regulatory initialization failed\n");
d6015b27 4347 goto err_free;
5e3dd157
KV		 4348 }
4349
4350 ret = ieee80211_register_hw(ar->hw);
4351 if (ret) {
4352 ath10k_err("ieee80211 registration failed: %d\n", ret);
d6015b27 4353 goto err_free;
5e3dd157
KV		 4354 }
4355
4356 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4357 ret = regulatory_hint(ar->hw->wiphy,
4358 ar->ath_common.regulatory.alpha2);
4359 if (ret)
d6015b27 4360 goto err_unregister;
5e3dd157
KV		 4361 }
4362
4363 return 0;
d6015b27
MK		 4364
4365err_unregister:
5e3dd157 4366 ieee80211_unregister_hw(ar->hw);
d6015b27
MK		 4367err_free:
4368 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4369 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4370
5e3dd157
KV		 4371 return ret;
4372}
4373
4374void ath10k_mac_unregister(struct ath10k *ar)
4375{
4376 ieee80211_unregister_hw(ar->hw);
4377
9702c686
JD		 4378 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4379 ar->dfs_detector->exit(ar->dfs_detector);
4380
5e3dd157
KV		 4381 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4382 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4383
4384 SET_IEEE80211_DEV(ar->hw, NULL);
4385}
Linux kernel - Deliverables
This page took 0.517859 seconds and 5 git commands to generate.