projects / deliverable / linux.git / blob
? search:


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