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