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