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