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