?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix a kmap leak in virtio_console
[linux/fpc-iii.git] / drivers / net / wireless / ath / ath10k / mac.c
blob776e364eadcd76c82ed37a64e20601f5bb1926ab
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
30 /**********/
31 /* Crypto */
32 /**********/
33
34 static int ath10k_send_key(struct ath10k_vif *arvif,
35 struct ieee80211_key_conf *key,
36 enum set_key_cmd cmd,
37 const u8 *macaddr)
38 {
39 struct wmi_vdev_install_key_arg arg = {
40 .vdev_id = arvif->vdev_id,
41 .key_idx = key->keyidx,
42 .key_len = key->keylen,
43 .key_data = key->key,
44 .macaddr = macaddr,
45 };
46
47 lockdep_assert_held(&arvif->ar->conf_mutex);
48
49 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
50 arg.key_flags = WMI_KEY_PAIRWISE;
51 else
52 arg.key_flags = WMI_KEY_GROUP;
53
54 switch (key->cipher) {
55 case WLAN_CIPHER_SUITE_CCMP:
56 arg.key_cipher = WMI_CIPHER_AES_CCM;
57 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
58 break;
59 case WLAN_CIPHER_SUITE_TKIP:
60 arg.key_cipher = WMI_CIPHER_TKIP;
61 arg.key_txmic_len = 8;
62 arg.key_rxmic_len = 8;
63 break;
64 case WLAN_CIPHER_SUITE_WEP40:
65 case WLAN_CIPHER_SUITE_WEP104:
66 arg.key_cipher = WMI_CIPHER_WEP;
67 /* AP/IBSS mode requires self-key to be groupwise
68 * Otherwise pairwise key must be set */
69 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
70 arg.key_flags = WMI_KEY_PAIRWISE;
71 break;
72 default:
73 ath10k_warn("cipher %d is not supported\n", key->cipher);
74 return -EOPNOTSUPP;
75 }
76
77 if (cmd == DISABLE_KEY) {
78 arg.key_cipher = WMI_CIPHER_NONE;
79 arg.key_data = NULL;
80 }
81
82 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
83 }
84
85 static int ath10k_install_key(struct ath10k_vif *arvif,
86 struct ieee80211_key_conf *key,
87 enum set_key_cmd cmd,
88 const u8 *macaddr)
89 {
90 struct ath10k *ar = arvif->ar;
91 int ret;
92
93 lockdep_assert_held(&ar->conf_mutex);
94
95 reinit_completion(&ar->install_key_done);
96
97 ret = ath10k_send_key(arvif, key, cmd, macaddr);
98 if (ret)
99 return ret;
100
101 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
102 if (ret == 0)
103 return -ETIMEDOUT;
104
105 return 0;
106 }
107
108 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
109 const u8 *addr)
110 {
111 struct ath10k *ar = arvif->ar;
112 struct ath10k_peer *peer;
113 int ret;
114 int i;
115
116 lockdep_assert_held(&ar->conf_mutex);
117
118 spin_lock_bh(&ar->data_lock);
119 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
120 spin_unlock_bh(&ar->data_lock);
121
122 if (!peer)
123 return -ENOENT;
124
125 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
126 if (arvif->wep_keys[i] == NULL)
127 continue;
128
129 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
130 addr);
131 if (ret)
132 return ret;
133
134 peer->keys[i] = arvif->wep_keys[i];
135 }
136
137 return 0;
138 }
139
140 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
141 const u8 *addr)
142 {
143 struct ath10k *ar = arvif->ar;
144 struct ath10k_peer *peer;
145 int first_errno = 0;
146 int ret;
147 int i;
148
149 lockdep_assert_held(&ar->conf_mutex);
150
151 spin_lock_bh(&ar->data_lock);
152 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
153 spin_unlock_bh(&ar->data_lock);
154
155 if (!peer)
156 return -ENOENT;
157
158 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
159 if (peer->keys[i] == NULL)
160 continue;
161
162 ret = ath10k_install_key(arvif, peer->keys[i],
163 DISABLE_KEY, addr);
164 if (ret && first_errno == 0)
165 first_errno = ret;
166
167 if (ret)
168 ath10k_warn("could not remove peer wep key %d (%d)\n",
169 i, ret);
170
171 peer->keys[i] = NULL;
172 }
173
174 return first_errno;
175 }
176
177 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
178 struct ieee80211_key_conf *key)
179 {
180 struct ath10k *ar = arvif->ar;
181 struct ath10k_peer *peer;
182 u8 addr[ETH_ALEN];
183 int first_errno = 0;
184 int ret;
185 int i;
186
187 lockdep_assert_held(&ar->conf_mutex);
188
189 for (;;) {
190 /* since ath10k_install_key we can't hold data_lock all the
191 * time, so we try to remove the keys incrementally */
192 spin_lock_bh(&ar->data_lock);
193 i = 0;
194 list_for_each_entry(peer, &ar->peers, list) {
195 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
196 if (peer->keys[i] == key) {
197 memcpy(addr, peer->addr, ETH_ALEN);
198 peer->keys[i] = NULL;
199 break;
200 }
201 }
202
203 if (i < ARRAY_SIZE(peer->keys))
204 break;
205 }
206 spin_unlock_bh(&ar->data_lock);
207
208 if (i == ARRAY_SIZE(peer->keys))
209 break;
210
211 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
212 if (ret && first_errno == 0)
213 first_errno = ret;
214
215 if (ret)
216 ath10k_warn("could not remove key for %pM\n", addr);
217 }
218
219 return first_errno;
220 }
221
222
223 /*********************/
224 /* General utilities */
225 /*********************/
226
227 static inline enum wmi_phy_mode
228 chan_to_phymode(const struct cfg80211_chan_def *chandef)
229 {
230 enum wmi_phy_mode phymode = MODE_UNKNOWN;
231
232 switch (chandef->chan->band) {
233 case IEEE80211_BAND_2GHZ:
234 switch (chandef->width) {
235 case NL80211_CHAN_WIDTH_20_NOHT:
236 phymode = MODE_11G;
237 break;
238 case NL80211_CHAN_WIDTH_20:
239 phymode = MODE_11NG_HT20;
240 break;
241 case NL80211_CHAN_WIDTH_40:
242 phymode = MODE_11NG_HT40;
243 break;
244 case NL80211_CHAN_WIDTH_5:
245 case NL80211_CHAN_WIDTH_10:
246 case NL80211_CHAN_WIDTH_80:
247 case NL80211_CHAN_WIDTH_80P80:
248 case NL80211_CHAN_WIDTH_160:
249 phymode = MODE_UNKNOWN;
250 break;
251 }
252 break;
253 case IEEE80211_BAND_5GHZ:
254 switch (chandef->width) {
255 case NL80211_CHAN_WIDTH_20_NOHT:
256 phymode = MODE_11A;
257 break;
258 case NL80211_CHAN_WIDTH_20:
259 phymode = MODE_11NA_HT20;
260 break;
261 case NL80211_CHAN_WIDTH_40:
262 phymode = MODE_11NA_HT40;
263 break;
264 case NL80211_CHAN_WIDTH_80:
265 phymode = MODE_11AC_VHT80;
266 break;
267 case NL80211_CHAN_WIDTH_5:
268 case NL80211_CHAN_WIDTH_10:
269 case NL80211_CHAN_WIDTH_80P80:
270 case NL80211_CHAN_WIDTH_160:
271 phymode = MODE_UNKNOWN;
272 break;
273 }
274 break;
275 default:
276 break;
277 }
278
279 WARN_ON(phymode == MODE_UNKNOWN);
280 return phymode;
281 }
282
283 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
284 {
285 /*
286 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
287 * 0 for no restriction
288 * 1 for 1/4 us
289 * 2 for 1/2 us
290 * 3 for 1 us
291 * 4 for 2 us
292 * 5 for 4 us
293 * 6 for 8 us
294 * 7 for 16 us
295 */
296 switch (mpdudensity) {
297 case 0:
298 return 0;
299 case 1:
300 case 2:
301 case 3:
302 /* Our lower layer calculations limit our precision to
303 1 microsecond */
304 return 1;
305 case 4:
306 return 2;
307 case 5:
308 return 4;
309 case 6:
310 return 8;
311 case 7:
312 return 16;
313 default:
314 return 0;
315 }
316 }
317
318 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
319 {
320 int ret;
321
322 lockdep_assert_held(&ar->conf_mutex);
323
324 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
325 if (ret) {
326 ath10k_warn("Failed to create wmi peer: %i\n", ret);
327 return ret;
328 }
329
330 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
331 if (ret) {
332 ath10k_warn("Failed to wait for created wmi peer: %i\n", ret);
333 return ret;
334 }
335 spin_lock_bh(&ar->data_lock);
336 ar->num_peers++;
337 spin_unlock_bh(&ar->data_lock);
338
339 return 0;
340 }
341
342 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
343 {
344 struct ath10k *ar = arvif->ar;
345 u32 vdev_param;
346
347 if (value != 0xFFFFFFFF)
348 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
349 ATH10K_RTS_MAX);
350
351 vdev_param = ar->wmi.vdev_param->rts_threshold;
352 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
353 }
354
355 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
356 {
357 struct ath10k *ar = arvif->ar;
358 u32 vdev_param;
359
360 if (value != 0xFFFFFFFF)
361 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
362 ATH10K_FRAGMT_THRESHOLD_MIN,
363 ATH10K_FRAGMT_THRESHOLD_MAX);
364
365 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
366 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
367 }
368
369 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
370 {
371 int ret;
372
373 lockdep_assert_held(&ar->conf_mutex);
374
375 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
376 if (ret)
377 return ret;
378
379 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
380 if (ret)
381 return ret;
382
383 spin_lock_bh(&ar->data_lock);
384 ar->num_peers--;
385 spin_unlock_bh(&ar->data_lock);
386
387 return 0;
388 }
389
390 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
391 {
392 struct ath10k_peer *peer, *tmp;
393
394 lockdep_assert_held(&ar->conf_mutex);
395
396 spin_lock_bh(&ar->data_lock);
397 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
398 if (peer->vdev_id != vdev_id)
399 continue;
400
401 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
402 peer->addr, vdev_id);
403
404 list_del(&peer->list);
405 kfree(peer);
406 ar->num_peers--;
407 }
408 spin_unlock_bh(&ar->data_lock);
409 }
410
411 static void ath10k_peer_cleanup_all(struct ath10k *ar)
412 {
413 struct ath10k_peer *peer, *tmp;
414
415 lockdep_assert_held(&ar->conf_mutex);
416
417 spin_lock_bh(&ar->data_lock);
418 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
419 list_del(&peer->list);
420 kfree(peer);
421 }
422 ar->num_peers = 0;
423 spin_unlock_bh(&ar->data_lock);
424 }
425
426 /************************/
427 /* Interface management */
428 /************************/
429
430 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
431 {
432 int ret;
433
434 lockdep_assert_held(&ar->conf_mutex);
435
436 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
437 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
438 if (ret == 0)
439 return -ETIMEDOUT;
440
441 return 0;
442 }
443
444 static int ath10k_vdev_start(struct ath10k_vif *arvif)
445 {
446 struct ath10k *ar = arvif->ar;
447 struct ieee80211_conf *conf = &ar->hw->conf;
448 struct ieee80211_channel *channel = conf->chandef.chan;
449 struct wmi_vdev_start_request_arg arg = {};
450 int ret = 0;
451
452 lockdep_assert_held(&ar->conf_mutex);
453
454 reinit_completion(&ar->vdev_setup_done);
455
456 arg.vdev_id = arvif->vdev_id;
457 arg.dtim_period = arvif->dtim_period;
458 arg.bcn_intval = arvif->beacon_interval;
459
460 arg.channel.freq = channel->center_freq;
461
462 arg.channel.band_center_freq1 = conf->chandef.center_freq1;
463
464 arg.channel.mode = chan_to_phymode(&conf->chandef);
465
466 arg.channel.min_power = 0;
467 arg.channel.max_power = channel->max_power * 2;
468 arg.channel.max_reg_power = channel->max_reg_power * 2;
469 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
470
471 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
472 arg.ssid = arvif->u.ap.ssid;
473 arg.ssid_len = arvif->u.ap.ssid_len;
474 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
475
476 /* For now allow DFS for AP mode */
477 arg.channel.chan_radar =
478 !!(channel->flags & IEEE80211_CHAN_RADAR);
479 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
480 arg.ssid = arvif->vif->bss_conf.ssid;
481 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
482 }
483
484 ath10k_dbg(ATH10K_DBG_MAC,
485 "mac vdev %d start center_freq %d phymode %s\n",
486 arg.vdev_id, arg.channel.freq,
487 ath10k_wmi_phymode_str(arg.channel.mode));
488
489 ret = ath10k_wmi_vdev_start(ar, &arg);
490 if (ret) {
491 ath10k_warn("WMI vdev start failed: ret %d\n", ret);
492 return ret;
493 }
494
495 ret = ath10k_vdev_setup_sync(ar);
496 if (ret) {
497 ath10k_warn("vdev setup failed %d\n", ret);
498 return ret;
499 }
500
501 return ret;
502 }
503
504 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
505 {
506 struct ath10k *ar = arvif->ar;
507 int ret;
508
509 lockdep_assert_held(&ar->conf_mutex);
510
511 reinit_completion(&ar->vdev_setup_done);
512
513 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
514 if (ret) {
515 ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
516 return ret;
517 }
518
519 ret = ath10k_vdev_setup_sync(ar);
520 if (ret) {
521 ath10k_warn("vdev setup failed %d\n", ret);
522 return ret;
523 }
524
525 return ret;
526 }
527
528 static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)
529 {
530 struct ieee80211_channel *channel = ar->hw->conf.chandef.chan;
531 struct wmi_vdev_start_request_arg arg = {};
532 int ret = 0;
533
534 lockdep_assert_held(&ar->conf_mutex);
535
536 if (!ar->monitor_present) {
537 ath10k_warn("mac montor stop -- monitor is not present\n");
538 return -EINVAL;
539 }
540
541 arg.vdev_id = vdev_id;
542 arg.channel.freq = channel->center_freq;
543 arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1;
544
545 /* TODO setup this dynamically, what in case we
546 don't have any vifs? */
547 arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef);
548 arg.channel.chan_radar =
549 !!(channel->flags & IEEE80211_CHAN_RADAR);
550
551 arg.channel.min_power = 0;
552 arg.channel.max_power = channel->max_power * 2;
553 arg.channel.max_reg_power = channel->max_reg_power * 2;
554 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
555
556 ret = ath10k_wmi_vdev_start(ar, &arg);
557 if (ret) {
558 ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
559 return ret;
560 }
561
562 ret = ath10k_vdev_setup_sync(ar);
563 if (ret) {
564 ath10k_warn("Monitor vdev setup failed %d\n", ret);
565 return ret;
566 }
567
568 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
569 if (ret) {
570 ath10k_warn("Monitor vdev up failed: %d\n", ret);
571 goto vdev_stop;
572 }
573
574 ar->monitor_vdev_id = vdev_id;
575 ar->monitor_enabled = true;
576
577 return 0;
578
579 vdev_stop:
580 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
581 if (ret)
582 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
583
584 return ret;
585 }
586
587 static int ath10k_monitor_stop(struct ath10k *ar)
588 {
589 int ret = 0;
590
591 lockdep_assert_held(&ar->conf_mutex);
592
593 if (!ar->monitor_present) {
594 ath10k_warn("mac montor stop -- monitor is not present\n");
595 return -EINVAL;
596 }
597
598 if (!ar->monitor_enabled) {
599 ath10k_warn("mac montor stop -- monitor is not enabled\n");
600 return -EINVAL;
601 }
602
603 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
604 if (ret)
605 ath10k_warn("Monitor vdev down failed: %d\n", ret);
606
607 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
608 if (ret)
609 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
610
611 ret = ath10k_vdev_setup_sync(ar);
612 if (ret)
613 ath10k_warn("Monitor_down sync failed: %d\n", ret);
614
615 ar->monitor_enabled = false;
616 return ret;
617 }
618
619 static int ath10k_monitor_create(struct ath10k *ar)
620 {
621 int bit, ret = 0;
622
623 lockdep_assert_held(&ar->conf_mutex);
624
625 if (ar->monitor_present) {
626 ath10k_warn("Monitor mode already enabled\n");
627 return 0;
628 }
629
630 bit = ffs(ar->free_vdev_map);
631 if (bit == 0) {
632 ath10k_warn("No free VDEV slots\n");
633 return -ENOMEM;
634 }
635
636 ar->monitor_vdev_id = bit - 1;
637 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
638
639 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
640 WMI_VDEV_TYPE_MONITOR,
641 0, ar->mac_addr);
642 if (ret) {
643 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
644 goto vdev_fail;
645 }
646
647 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
648 ar->monitor_vdev_id);
649
650 ar->monitor_present = true;
651 return 0;
652
653 vdev_fail:
654 /*
655 * Restore the ID to the global map.
656 */
657 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
658 return ret;
659 }
660
661 static int ath10k_monitor_destroy(struct ath10k *ar)
662 {
663 int ret = 0;
664
665 lockdep_assert_held(&ar->conf_mutex);
666
667 if (!ar->monitor_present)
668 return 0;
669
670 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
671 if (ret) {
672 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret);
673 return ret;
674 }
675
676 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
677 ar->monitor_present = false;
678
679 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
680 ar->monitor_vdev_id);
681 return ret;
682 }
683
684 static int ath10k_start_cac(struct ath10k *ar)
685 {
686 int ret;
687
688 lockdep_assert_held(&ar->conf_mutex);
689
690 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
691
692 ret = ath10k_monitor_create(ar);
693 if (ret) {
694 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
695 return ret;
696 }
697
698 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
699 if (ret) {
700 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
701 ath10k_monitor_destroy(ar);
702 return ret;
703 }
704
705 ath10k_dbg(ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
706 ar->monitor_vdev_id);
707
708 return 0;
709 }
710
711 static int ath10k_stop_cac(struct ath10k *ar)
712 {
713 lockdep_assert_held(&ar->conf_mutex);
714
715 /* CAC is not running - do nothing */
716 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
717 return 0;
718
719 ath10k_monitor_stop(ar);
720 ath10k_monitor_destroy(ar);
721 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
722
723 ath10k_dbg(ATH10K_DBG_MAC, "mac cac finished\n");
724
725 return 0;
726 }
727
728 static const char *ath10k_dfs_state(enum nl80211_dfs_state dfs_state)
729 {
730 switch (dfs_state) {
731 case NL80211_DFS_USABLE:
732 return "USABLE";
733 case NL80211_DFS_UNAVAILABLE:
734 return "UNAVAILABLE";
735 case NL80211_DFS_AVAILABLE:
736 return "AVAILABLE";
737 default:
738 WARN_ON(1);
739 return "bug";
740 }
741 }
742
743 static void ath10k_config_radar_detection(struct ath10k *ar)
744 {
745 struct ieee80211_channel *chan = ar->hw->conf.chandef.chan;
746 bool radar = ar->hw->conf.radar_enabled;
747 bool chan_radar = !!(chan->flags & IEEE80211_CHAN_RADAR);
748 enum nl80211_dfs_state dfs_state = chan->dfs_state;
749 int ret;
750
751 lockdep_assert_held(&ar->conf_mutex);
752
753 ath10k_dbg(ATH10K_DBG_MAC,
754 "mac radar config update: chan %dMHz radar %d chan radar %d chan state %s\n",
755 chan->center_freq, radar, chan_radar,
756 ath10k_dfs_state(dfs_state));
757
758 /*
759 * It's safe to call it even if CAC is not started.
760 * This call here guarantees changing channel, etc. will stop CAC.
761 */
762 ath10k_stop_cac(ar);
763
764 if (!radar)
765 return;
766
767 if (!chan_radar)
768 return;
769
770 if (dfs_state != NL80211_DFS_USABLE)
771 return;
772
773 ret = ath10k_start_cac(ar);
774 if (ret) {
775 /*
776 * Not possible to start CAC on current channel so starting
777 * radiation is not allowed, make this channel DFS_UNAVAILABLE
778 * by indicating that radar was detected.
779 */
780 ath10k_warn("failed to start CAC (%d)\n", ret);
781 ieee80211_radar_detected(ar->hw);
782 }
783 }
784
785 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
786 struct ieee80211_bss_conf *info)
787 {
788 int ret = 0;
789
790 lockdep_assert_held(&arvif->ar->conf_mutex);
791
792 if (!info->enable_beacon) {
793 ath10k_vdev_stop(arvif);
794 return;
795 }
796
797 arvif->tx_seq_no = 0x1000;
798
799 ret = ath10k_vdev_start(arvif);
800 if (ret)
801 return;
802
803 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
804 if (ret) {
805 ath10k_warn("Failed to bring up VDEV: %d\n",
806 arvif->vdev_id);
807 return;
808 }
809 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
810 }
811
812 static void ath10k_control_ibss(struct ath10k_vif *arvif,
813 struct ieee80211_bss_conf *info,
814 const u8 self_peer[ETH_ALEN])
815 {
816 u32 vdev_param;
817 int ret = 0;
818
819 lockdep_assert_held(&arvif->ar->conf_mutex);
820
821 if (!info->ibss_joined) {
822 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
823 if (ret)
824 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
825 self_peer, arvif->vdev_id, ret);
826
827 if (is_zero_ether_addr(arvif->u.ibss.bssid))
828 return;
829
830 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
831 arvif->u.ibss.bssid);
832 if (ret) {
833 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
834 arvif->u.ibss.bssid, arvif->vdev_id, ret);
835 return;
836 }
837
838 memset(arvif->u.ibss.bssid, 0, ETH_ALEN);
839
840 return;
841 }
842
843 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
844 if (ret) {
845 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
846 self_peer, arvif->vdev_id, ret);
847 return;
848 }
849
850 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
851 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
852 ATH10K_DEFAULT_ATIM);
853 if (ret)
854 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
855 arvif->vdev_id, ret);
856 }
857
858 /*
859 * Review this when mac80211 gains per-interface powersave support.
860 */
861 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
862 {
863 struct ath10k *ar = arvif->ar;
864 struct ieee80211_conf *conf = &ar->hw->conf;
865 enum wmi_sta_powersave_param param;
866 enum wmi_sta_ps_mode psmode;
867 int ret;
868
869 lockdep_assert_held(&arvif->ar->conf_mutex);
870
871 if (arvif->vif->type != NL80211_IFTYPE_STATION)
872 return 0;
873
874 if (conf->flags & IEEE80211_CONF_PS) {
875 psmode = WMI_STA_PS_MODE_ENABLED;
876 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
877
878 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
879 conf->dynamic_ps_timeout);
880 if (ret) {
881 ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
882 arvif->vdev_id);
883 return ret;
884 }
885 } else {
886 psmode = WMI_STA_PS_MODE_DISABLED;
887 }
888
889 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
890 arvif->vdev_id, psmode ? "enable" : "disable");
891
892 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
893 if (ret) {
894 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
895 psmode, arvif->vdev_id);
896 return ret;
897 }
898
899 return 0;
900 }
901
902 /**********************/
903 /* Station management */
904 /**********************/
905
906 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
907 struct ath10k_vif *arvif,
908 struct ieee80211_sta *sta,
909 struct ieee80211_bss_conf *bss_conf,
910 struct wmi_peer_assoc_complete_arg *arg)
911 {
912 lockdep_assert_held(&ar->conf_mutex);
913
914 memcpy(arg->addr, sta->addr, ETH_ALEN);
915 arg->vdev_id = arvif->vdev_id;
916 arg->peer_aid = sta->aid;
917 arg->peer_flags |= WMI_PEER_AUTH;
918
919 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
920 /*
921 * Seems FW have problems with Power Save in STA
922 * mode when we setup this parameter to high (eg. 5).
923 * Often we see that FW don't send NULL (with clean P flags)
924 * frame even there is info about buffered frames in beacons.
925 * Sometimes we have to wait more than 10 seconds before FW
926 * will wakeup. Often sending one ping from AP to our device
927 * just fail (more than 50%).
928 *
929 * Seems setting this FW parameter to 1 couse FW
930 * will check every beacon and will wakup immediately
931 * after detection buffered data.
932 */
933 arg->peer_listen_intval = 1;
934 else
935 arg->peer_listen_intval = ar->hw->conf.listen_interval;
936
937 arg->peer_num_spatial_streams = 1;
938
939 /*
940 * The assoc capabilities are available only in managed mode.
941 */
942 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
943 arg->peer_caps = bss_conf->assoc_capability;
944 }
945
946 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
947 struct ath10k_vif *arvif,
948 struct wmi_peer_assoc_complete_arg *arg)
949 {
950 struct ieee80211_vif *vif = arvif->vif;
951 struct ieee80211_bss_conf *info = &vif->bss_conf;
952 struct cfg80211_bss *bss;
953 const u8 *rsnie = NULL;
954 const u8 *wpaie = NULL;
955
956 lockdep_assert_held(&ar->conf_mutex);
957
958 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
959 info->bssid, NULL, 0, 0, 0);
960 if (bss) {
961 const struct cfg80211_bss_ies *ies;
962
963 rcu_read_lock();
964 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
965
966 ies = rcu_dereference(bss->ies);
967
968 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
969 WLAN_OUI_TYPE_MICROSOFT_WPA,
970 ies->data,
971 ies->len);
972 rcu_read_unlock();
973 cfg80211_put_bss(ar->hw->wiphy, bss);
974 }
975
976 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
977 if (rsnie || wpaie) {
978 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
979 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
980 }
981
982 if (wpaie) {
983 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
984 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
985 }
986 }
987
988 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
989 struct ieee80211_sta *sta,
990 struct wmi_peer_assoc_complete_arg *arg)
991 {
992 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
993 const struct ieee80211_supported_band *sband;
994 const struct ieee80211_rate *rates;
995 u32 ratemask;
996 int i;
997
998 lockdep_assert_held(&ar->conf_mutex);
999
1000 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1001 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1002 rates = sband->bitrates;
1003
1004 rateset->num_rates = 0;
1005
1006 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1007 if (!(ratemask & 1))
1008 continue;
1009
1010 rateset->rates[rateset->num_rates] = rates->hw_value;
1011 rateset->num_rates++;
1012 }
1013 }
1014
1015 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1016 struct ieee80211_sta *sta,
1017 struct wmi_peer_assoc_complete_arg *arg)
1018 {
1019 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1020 int smps;
1021 int i, n;
1022
1023 lockdep_assert_held(&ar->conf_mutex);
1024
1025 if (!ht_cap->ht_supported)
1026 return;
1027
1028 arg->peer_flags |= WMI_PEER_HT;
1029 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1030 ht_cap->ampdu_factor)) - 1;
1031
1032 arg->peer_mpdu_density =
1033 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1034
1035 arg->peer_ht_caps = ht_cap->cap;
1036 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1037
1038 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1039 arg->peer_flags |= WMI_PEER_LDPC;
1040
1041 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1042 arg->peer_flags |= WMI_PEER_40MHZ;
1043 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1044 }
1045
1046 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1047 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1048
1049 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1050 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1051
1052 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1053 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1054 arg->peer_flags |= WMI_PEER_STBC;
1055 }
1056
1057 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1058 u32 stbc;
1059 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1060 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1061 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1062 arg->peer_rate_caps |= stbc;
1063 arg->peer_flags |= WMI_PEER_STBC;
1064 }
1065
1066 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1067 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1068
1069 if (smps == WLAN_HT_CAP_SM_PS_STATIC) {
1070 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
1071 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS;
1072 } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) {
1073 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
1074 arg->peer_flags |= WMI_PEER_DYN_MIMOPS;
1075 }
1076
1077 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1078 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1079 else if (ht_cap->mcs.rx_mask[1])
1080 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1081
1082 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1083 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1084 arg->peer_ht_rates.rates[n++] = i;
1085
1086 arg->peer_ht_rates.num_rates = n;
1087 arg->peer_num_spatial_streams = max((n+7) / 8, 1);
1088
1089 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1090 arg->addr,
1091 arg->peer_ht_rates.num_rates,
1092 arg->peer_num_spatial_streams);
1093 }
1094
1095 static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
1096 struct ath10k_vif *arvif,
1097 struct ieee80211_sta *sta,
1098 struct ieee80211_bss_conf *bss_conf,
1099 struct wmi_peer_assoc_complete_arg *arg)
1100 {
1101 u32 uapsd = 0;
1102 u32 max_sp = 0;
1103
1104 lockdep_assert_held(&ar->conf_mutex);
1105
1106 if (sta->wme)
1107 arg->peer_flags |= WMI_PEER_QOS;
1108
1109 if (sta->wme && sta->uapsd_queues) {
1110 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1111 sta->uapsd_queues, sta->max_sp);
1112
1113 arg->peer_flags |= WMI_PEER_APSD;
1114 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1115
1116 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1117 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1118 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1119 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1120 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1121 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1122 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1123 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1124 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1125 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1126 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1127 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1128
1129
1130 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1131 max_sp = sta->max_sp;
1132
1133 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1134 sta->addr,
1135 WMI_AP_PS_PEER_PARAM_UAPSD,
1136 uapsd);
1137
1138 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1139 sta->addr,
1140 WMI_AP_PS_PEER_PARAM_MAX_SP,
1141 max_sp);
1142
1143 /* TODO setup this based on STA listen interval and
1144 beacon interval. Currently we don't know
1145 sta->listen_interval - mac80211 patch required.
1146 Currently use 10 seconds */
1147 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1148 sta->addr,
1149 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1150 10);
1151 }
1152 }
1153
1154 static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar,
1155 struct ath10k_vif *arvif,
1156 struct ieee80211_sta *sta,
1157 struct ieee80211_bss_conf *bss_conf,
1158 struct wmi_peer_assoc_complete_arg *arg)
1159 {
1160 if (bss_conf->qos)
1161 arg->peer_flags |= WMI_PEER_QOS;
1162 }
1163
1164 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1165 struct ieee80211_sta *sta,
1166 struct wmi_peer_assoc_complete_arg *arg)
1167 {
1168 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1169 u8 ampdu_factor;
1170
1171 if (!vht_cap->vht_supported)
1172 return;
1173
1174 arg->peer_flags |= WMI_PEER_VHT;
1175 arg->peer_vht_caps = vht_cap->cap;
1176
1177
1178 ampdu_factor = (vht_cap->cap &
1179 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1180 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1181
1182 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1183 * zero in VHT IE. Using it would result in degraded throughput.
1184 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1185 * it if VHT max_mpdu is smaller. */
1186 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1187 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1188 ampdu_factor)) - 1);
1189
1190 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1191 arg->peer_flags |= WMI_PEER_80MHZ;
1192
1193 arg->peer_vht_rates.rx_max_rate =
1194 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1195 arg->peer_vht_rates.rx_mcs_set =
1196 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1197 arg->peer_vht_rates.tx_max_rate =
1198 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1199 arg->peer_vht_rates.tx_mcs_set =
1200 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1201
1202 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1203 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1204 }
1205
1206 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1207 struct ath10k_vif *arvif,
1208 struct ieee80211_sta *sta,
1209 struct ieee80211_bss_conf *bss_conf,
1210 struct wmi_peer_assoc_complete_arg *arg)
1211 {
1212 switch (arvif->vdev_type) {
1213 case WMI_VDEV_TYPE_AP:
1214 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg);
1215 break;
1216 case WMI_VDEV_TYPE_STA:
1217 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg);
1218 break;
1219 default:
1220 break;
1221 }
1222 }
1223
1224 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1225 struct ath10k_vif *arvif,
1226 struct ieee80211_sta *sta,
1227 struct wmi_peer_assoc_complete_arg *arg)
1228 {
1229 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1230
1231 switch (ar->hw->conf.chandef.chan->band) {
1232 case IEEE80211_BAND_2GHZ:
1233 if (sta->ht_cap.ht_supported) {
1234 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1235 phymode = MODE_11NG_HT40;
1236 else
1237 phymode = MODE_11NG_HT20;
1238 } else {
1239 phymode = MODE_11G;
1240 }
1241
1242 break;
1243 case IEEE80211_BAND_5GHZ:
1244 /*
1245 * Check VHT first.
1246 */
1247 if (sta->vht_cap.vht_supported) {
1248 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1249 phymode = MODE_11AC_VHT80;
1250 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1251 phymode = MODE_11AC_VHT40;
1252 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1253 phymode = MODE_11AC_VHT20;
1254 } else if (sta->ht_cap.ht_supported) {
1255 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1256 phymode = MODE_11NA_HT40;
1257 else
1258 phymode = MODE_11NA_HT20;
1259 } else {
1260 phymode = MODE_11A;
1261 }
1262
1263 break;
1264 default:
1265 break;
1266 }
1267
1268 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1269 sta->addr, ath10k_wmi_phymode_str(phymode));
1270
1271 arg->peer_phymode = phymode;
1272 WARN_ON(phymode == MODE_UNKNOWN);
1273 }
1274
1275 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1276 struct ath10k_vif *arvif,
1277 struct ieee80211_sta *sta,
1278 struct ieee80211_bss_conf *bss_conf,
1279 struct wmi_peer_assoc_complete_arg *arg)
1280 {
1281 lockdep_assert_held(&ar->conf_mutex);
1282
1283 memset(arg, 0, sizeof(*arg));
1284
1285 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1286 ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1287 ath10k_peer_assoc_h_rates(ar, sta, arg);
1288 ath10k_peer_assoc_h_ht(ar, sta, arg);
1289 ath10k_peer_assoc_h_vht(ar, sta, arg);
1290 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1291 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
1292
1293 return 0;
1294 }
1295
1296 /* can be called only in mac80211 callbacks due to `key_count` usage */
1297 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1298 struct ieee80211_vif *vif,
1299 struct ieee80211_bss_conf *bss_conf)
1300 {
1301 struct ath10k *ar = hw->priv;
1302 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1303 struct wmi_peer_assoc_complete_arg peer_arg;
1304 struct ieee80211_sta *ap_sta;
1305 int ret;
1306
1307 lockdep_assert_held(&ar->conf_mutex);
1308
1309 rcu_read_lock();
1310
1311 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1312 if (!ap_sta) {
1313 ath10k_warn("Failed to find station entry for %pM\n",
1314 bss_conf->bssid);
1315 rcu_read_unlock();
1316 return;
1317 }
1318
1319 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1320 bss_conf, &peer_arg);
1321 if (ret) {
1322 ath10k_warn("Peer assoc prepare failed for %pM\n: %d",
1323 bss_conf->bssid, ret);
1324 rcu_read_unlock();
1325 return;
1326 }
1327
1328 rcu_read_unlock();
1329
1330 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1331 if (ret) {
1332 ath10k_warn("Peer assoc failed for %pM\n: %d",
1333 bss_conf->bssid, ret);
1334 return;
1335 }
1336
1337 ath10k_dbg(ATH10K_DBG_MAC,
1338 "mac vdev %d up (associated) bssid %pM aid %d\n",
1339 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1340
1341 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
1342 bss_conf->bssid);
1343 if (ret)
1344 ath10k_warn("VDEV: %d up failed: ret %d\n",
1345 arvif->vdev_id, ret);
1346 }
1347
1348 /*
1349 * FIXME: flush TIDs
1350 */
1351 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1352 struct ieee80211_vif *vif)
1353 {
1354 struct ath10k *ar = hw->priv;
1355 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1356 int ret;
1357
1358 lockdep_assert_held(&ar->conf_mutex);
1359
1360 /*
1361 * For some reason, calling VDEV-DOWN before VDEV-STOP
1362 * makes the FW to send frames via HTT after disassociation.
1363 * No idea why this happens, even though VDEV-DOWN is supposed
1364 * to be analogous to link down, so just stop the VDEV.
1365 */
1366 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1367 arvif->vdev_id);
1368
1369 /* FIXME: check return value */
1370 ret = ath10k_vdev_stop(arvif);
1371
1372 /*
1373 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1374 * report beacons from previously associated network through HTT.
1375 * This in turn would spam mac80211 WARN_ON if we bring down all
1376 * interfaces as it expects there is no rx when no interface is
1377 * running.
1378 */
1379 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1380
1381 /* FIXME: why don't we print error if wmi call fails? */
1382 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1383
1384 arvif->def_wep_key_idx = 0;
1385 }
1386
1387 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1388 struct ieee80211_sta *sta)
1389 {
1390 struct wmi_peer_assoc_complete_arg peer_arg;
1391 int ret = 0;
1392
1393 lockdep_assert_held(&ar->conf_mutex);
1394
1395 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1396 if (ret) {
1397 ath10k_warn("WMI peer assoc prepare failed for %pM\n",
1398 sta->addr);
1399 return ret;
1400 }
1401
1402 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1403 if (ret) {
1404 ath10k_warn("Peer assoc failed for STA %pM\n: %d",
1405 sta->addr, ret);
1406 return ret;
1407 }
1408
1409 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1410 if (ret) {
1411 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1412 return ret;
1413 }
1414
1415 return ret;
1416 }
1417
1418 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1419 struct ieee80211_sta *sta)
1420 {
1421 int ret = 0;
1422
1423 lockdep_assert_held(&ar->conf_mutex);
1424
1425 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1426 if (ret) {
1427 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1428 return ret;
1429 }
1430
1431 return ret;
1432 }
1433
1434 /**************/
1435 /* Regulatory */
1436 /**************/
1437
1438 static int ath10k_update_channel_list(struct ath10k *ar)
1439 {
1440 struct ieee80211_hw *hw = ar->hw;
1441 struct ieee80211_supported_band **bands;
1442 enum ieee80211_band band;
1443 struct ieee80211_channel *channel;
1444 struct wmi_scan_chan_list_arg arg = {0};
1445 struct wmi_channel_arg *ch;
1446 bool passive;
1447 int len;
1448 int ret;
1449 int i;
1450
1451 lockdep_assert_held(&ar->conf_mutex);
1452
1453 bands = hw->wiphy->bands;
1454 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1455 if (!bands[band])
1456 continue;
1457
1458 for (i = 0; i < bands[band]->n_channels; i++) {
1459 if (bands[band]->channels[i].flags &
1460 IEEE80211_CHAN_DISABLED)
1461 continue;
1462
1463 arg.n_channels++;
1464 }
1465 }
1466
1467 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1468 arg.channels = kzalloc(len, GFP_KERNEL);
1469 if (!arg.channels)
1470 return -ENOMEM;
1471
1472 ch = arg.channels;
1473 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1474 if (!bands[band])
1475 continue;
1476
1477 for (i = 0; i < bands[band]->n_channels; i++) {
1478 channel = &bands[band]->channels[i];
1479
1480 if (channel->flags & IEEE80211_CHAN_DISABLED)
1481 continue;
1482
1483 ch->allow_ht = true;
1484
1485 /* FIXME: when should we really allow VHT? */
1486 ch->allow_vht = true;
1487
1488 ch->allow_ibss =
1489 !(channel->flags & IEEE80211_CHAN_NO_IR);
1490
1491 ch->ht40plus =
1492 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1493
1494 ch->chan_radar =
1495 !!(channel->flags & IEEE80211_CHAN_RADAR);
1496
1497 passive = channel->flags & IEEE80211_CHAN_NO_IR;
1498 ch->passive = passive;
1499
1500 ch->freq = channel->center_freq;
1501 ch->min_power = 0;
1502 ch->max_power = channel->max_power * 2;
1503 ch->max_reg_power = channel->max_reg_power * 2;
1504 ch->max_antenna_gain = channel->max_antenna_gain * 2;
1505 ch->reg_class_id = 0; /* FIXME */
1506
1507 /* FIXME: why use only legacy modes, why not any
1508 * HT/VHT modes? Would that even make any
1509 * difference? */
1510 if (channel->band == IEEE80211_BAND_2GHZ)
1511 ch->mode = MODE_11G;
1512 else
1513 ch->mode = MODE_11A;
1514
1515 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1516 continue;
1517
1518 ath10k_dbg(ATH10K_DBG_WMI,
1519 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1520 ch - arg.channels, arg.n_channels,
1521 ch->freq, ch->max_power, ch->max_reg_power,
1522 ch->max_antenna_gain, ch->mode);
1523
1524 ch++;
1525 }
1526 }
1527
1528 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1529 kfree(arg.channels);
1530
1531 return ret;
1532 }
1533
1534 static void ath10k_regd_update(struct ath10k *ar)
1535 {
1536 struct reg_dmn_pair_mapping *regpair;
1537 int ret;
1538
1539 lockdep_assert_held(&ar->conf_mutex);
1540
1541 ret = ath10k_update_channel_list(ar);
1542 if (ret)
1543 ath10k_warn("could not update channel list (%d)\n", ret);
1544
1545 regpair = ar->ath_common.regulatory.regpair;
1546
1547 /* Target allows setting up per-band regdomain but ath_common provides
1548 * a combined one only */
1549 ret = ath10k_wmi_pdev_set_regdomain(ar,
1550 regpair->regDmnEnum,
1551 regpair->regDmnEnum, /* 2ghz */
1552 regpair->regDmnEnum, /* 5ghz */
1553 regpair->reg_2ghz_ctl,
1554 regpair->reg_5ghz_ctl);
1555 if (ret)
1556 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
1557 }
1558
1559 static void ath10k_reg_notifier(struct wiphy *wiphy,
1560 struct regulatory_request *request)
1561 {
1562 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1563 struct ath10k *ar = hw->priv;
1564 bool result;
1565
1566 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1567
1568 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1569 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1570 request->dfs_region);
1571 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1572 request->dfs_region);
1573 if (!result)
1574 ath10k_warn("dfs region 0x%X not supported, will trigger radar for every pulse\n",
1575 request->dfs_region);
1576 }
1577
1578 mutex_lock(&ar->conf_mutex);
1579 if (ar->state == ATH10K_STATE_ON)
1580 ath10k_regd_update(ar);
1581 mutex_unlock(&ar->conf_mutex);
1582 }
1583
1584 /***************/
1585 /* TX handlers */
1586 /***************/
1587
1588 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1589 {
1590 if (ieee80211_is_mgmt(hdr->frame_control))
1591 return HTT_DATA_TX_EXT_TID_MGMT;
1592
1593 if (!ieee80211_is_data_qos(hdr->frame_control))
1594 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1595
1596 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1597 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1598
1599 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1600 }
1601
1602 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar,
1603 struct ieee80211_tx_info *info)
1604 {
1605 if (info->control.vif)
1606 return ath10k_vif_to_arvif(info->control.vif)->vdev_id;
1607
1608 if (ar->monitor_enabled)
1609 return ar->monitor_vdev_id;
1610
1611 ath10k_warn("could not resolve vdev id\n");
1612 return 0;
1613 }
1614
1615 /*
1616 * Frames sent to the FW have to be in "Native Wifi" format.
1617 * Strip the QoS field from the 802.11 header.
1618 */
1619 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1620 struct ieee80211_tx_control *control,
1621 struct sk_buff *skb)
1622 {
1623 struct ieee80211_hdr *hdr = (void *)skb->data;
1624 u8 *qos_ctl;
1625
1626 if (!ieee80211_is_data_qos(hdr->frame_control))
1627 return;
1628
1629 qos_ctl = ieee80211_get_qos_ctl(hdr);
1630 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1631 skb->data, (void *)qos_ctl - (void *)skb->data);
1632 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1633 }
1634
1635 static void ath10k_tx_wep_key_work(struct work_struct *work)
1636 {
1637 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1638 wep_key_work);
1639 int ret, keyidx = arvif->def_wep_key_newidx;
1640
1641 if (arvif->def_wep_key_idx == keyidx)
1642 return;
1643
1644 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1645 arvif->vdev_id, keyidx);
1646
1647 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1648 arvif->vdev_id,
1649 arvif->ar->wmi.vdev_param->def_keyid,
1650 keyidx);
1651 if (ret) {
1652 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1653 return;
1654 }
1655
1656 arvif->def_wep_key_idx = keyidx;
1657 }
1658
1659 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1660 {
1661 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1662 struct ieee80211_vif *vif = info->control.vif;
1663 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1664 struct ath10k *ar = arvif->ar;
1665 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1666 struct ieee80211_key_conf *key = info->control.hw_key;
1667
1668 if (!ieee80211_has_protected(hdr->frame_control))
1669 return;
1670
1671 if (!key)
1672 return;
1673
1674 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1675 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1676 return;
1677
1678 if (key->keyidx == arvif->def_wep_key_idx)
1679 return;
1680
1681 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1682 * queueing frames until key index is updated is not an option because
1683 * sk_buff may need more processing to be done, e.g. offchannel */
1684 arvif->def_wep_key_newidx = key->keyidx;
1685 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1686 }
1687
1688 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1689 {
1690 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1691 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1692 struct ieee80211_vif *vif = info->control.vif;
1693 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1694
1695 /* This is case only for P2P_GO */
1696 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1697 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1698 return;
1699
1700 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1701 spin_lock_bh(&ar->data_lock);
1702 if (arvif->u.ap.noa_data)
1703 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1704 GFP_ATOMIC))
1705 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1706 arvif->u.ap.noa_data,
1707 arvif->u.ap.noa_len);
1708 spin_unlock_bh(&ar->data_lock);
1709 }
1710 }
1711
1712 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1713 {
1714 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1715 int ret = 0;
1716
1717 if (ar->htt.target_version_major >= 3) {
1718 /* Since HTT 3.0 there is no separate mgmt tx command */
1719 ret = ath10k_htt_tx(&ar->htt, skb);
1720 goto exit;
1721 }
1722
1723 if (ieee80211_is_mgmt(hdr->frame_control)) {
1724 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1725 ar->fw_features)) {
1726 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
1727 ATH10K_MAX_NUM_MGMT_PENDING) {
1728 ath10k_warn("wmi mgmt_tx queue limit reached\n");
1729 ret = -EBUSY;
1730 goto exit;
1731 }
1732
1733 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
1734 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
1735 } else {
1736 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1737 }
1738 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1739 ar->fw_features) &&
1740 ieee80211_is_nullfunc(hdr->frame_control)) {
1741 /* FW does not report tx status properly for NullFunc frames
1742 * unless they are sent through mgmt tx path. mac80211 sends
1743 * those frames when it detects link/beacon loss and depends
1744 * on the tx status to be correct. */
1745 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1746 } else {
1747 ret = ath10k_htt_tx(&ar->htt, skb);
1748 }
1749
1750 exit:
1751 if (ret) {
1752 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1753 ieee80211_free_txskb(ar->hw, skb);
1754 }
1755 }
1756
1757 void ath10k_offchan_tx_purge(struct ath10k *ar)
1758 {
1759 struct sk_buff *skb;
1760
1761 for (;;) {
1762 skb = skb_dequeue(&ar->offchan_tx_queue);
1763 if (!skb)
1764 break;
1765
1766 ieee80211_free_txskb(ar->hw, skb);
1767 }
1768 }
1769
1770 void ath10k_offchan_tx_work(struct work_struct *work)
1771 {
1772 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1773 struct ath10k_peer *peer;
1774 struct ieee80211_hdr *hdr;
1775 struct sk_buff *skb;
1776 const u8 *peer_addr;
1777 int vdev_id;
1778 int ret;
1779
1780 /* FW requirement: We must create a peer before FW will send out
1781 * an offchannel frame. Otherwise the frame will be stuck and
1782 * never transmitted. We delete the peer upon tx completion.
1783 * It is unlikely that a peer for offchannel tx will already be
1784 * present. However it may be in some rare cases so account for that.
1785 * Otherwise we might remove a legitimate peer and break stuff. */
1786
1787 for (;;) {
1788 skb = skb_dequeue(&ar->offchan_tx_queue);
1789 if (!skb)
1790 break;
1791
1792 mutex_lock(&ar->conf_mutex);
1793
1794 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
1795 skb);
1796
1797 hdr = (struct ieee80211_hdr *)skb->data;
1798 peer_addr = ieee80211_get_DA(hdr);
1799 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
1800
1801 spin_lock_bh(&ar->data_lock);
1802 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1803 spin_unlock_bh(&ar->data_lock);
1804
1805 if (peer)
1806 /* FIXME: should this use ath10k_warn()? */
1807 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1808 peer_addr, vdev_id);
1809
1810 if (!peer) {
1811 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1812 if (ret)
1813 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1814 peer_addr, vdev_id, ret);
1815 }
1816
1817 spin_lock_bh(&ar->data_lock);
1818 reinit_completion(&ar->offchan_tx_completed);
1819 ar->offchan_tx_skb = skb;
1820 spin_unlock_bh(&ar->data_lock);
1821
1822 ath10k_tx_htt(ar, skb);
1823
1824 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1825 3 * HZ);
1826 if (ret <= 0)
1827 ath10k_warn("timed out waiting for offchannel skb %p\n",
1828 skb);
1829
1830 if (!peer) {
1831 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1832 if (ret)
1833 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1834 peer_addr, vdev_id, ret);
1835 }
1836
1837 mutex_unlock(&ar->conf_mutex);
1838 }
1839 }
1840
1841 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
1842 {
1843 struct sk_buff *skb;
1844
1845 for (;;) {
1846 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
1847 if (!skb)
1848 break;
1849
1850 ieee80211_free_txskb(ar->hw, skb);
1851 }
1852 }
1853
1854 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
1855 {
1856 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
1857 struct sk_buff *skb;
1858 int ret;
1859
1860 for (;;) {
1861 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
1862 if (!skb)
1863 break;
1864
1865 ret = ath10k_wmi_mgmt_tx(ar, skb);
1866 if (ret) {
1867 ath10k_warn("wmi mgmt_tx failed (%d)\n", ret);
1868 ieee80211_free_txskb(ar->hw, skb);
1869 }
1870 }
1871 }
1872
1873 /************/
1874 /* Scanning */
1875 /************/
1876
1877 /*
1878 * This gets called if we dont get a heart-beat during scan.
1879 * This may indicate the FW has hung and we need to abort the
1880 * scan manually to prevent cancel_hw_scan() from deadlocking
1881 */
1882 void ath10k_reset_scan(unsigned long ptr)
1883 {
1884 struct ath10k *ar = (struct ath10k *)ptr;
1885
1886 spin_lock_bh(&ar->data_lock);
1887 if (!ar->scan.in_progress) {
1888 spin_unlock_bh(&ar->data_lock);
1889 return;
1890 }
1891
1892 ath10k_warn("scan timeout. resetting. fw issue?\n");
1893
1894 if (ar->scan.is_roc)
1895 ieee80211_remain_on_channel_expired(ar->hw);
1896 else
1897 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
1898
1899 ar->scan.in_progress = false;
1900 complete_all(&ar->scan.completed);
1901 spin_unlock_bh(&ar->data_lock);
1902 }
1903
1904 static int ath10k_abort_scan(struct ath10k *ar)
1905 {
1906 struct wmi_stop_scan_arg arg = {
1907 .req_id = 1, /* FIXME */
1908 .req_type = WMI_SCAN_STOP_ONE,
1909 .u.scan_id = ATH10K_SCAN_ID,
1910 };
1911 int ret;
1912
1913 lockdep_assert_held(&ar->conf_mutex);
1914
1915 del_timer_sync(&ar->scan.timeout);
1916
1917 spin_lock_bh(&ar->data_lock);
1918 if (!ar->scan.in_progress) {
1919 spin_unlock_bh(&ar->data_lock);
1920 return 0;
1921 }
1922
1923 ar->scan.aborting = true;
1924 spin_unlock_bh(&ar->data_lock);
1925
1926 ret = ath10k_wmi_stop_scan(ar, &arg);
1927 if (ret) {
1928 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
1929 spin_lock_bh(&ar->data_lock);
1930 ar->scan.in_progress = false;
1931 ath10k_offchan_tx_purge(ar);
1932 spin_unlock_bh(&ar->data_lock);
1933 return -EIO;
1934 }
1935
1936 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
1937 if (ret == 0)
1938 ath10k_warn("timed out while waiting for scan to stop\n");
1939
1940 /* scan completion may be done right after we timeout here, so let's
1941 * check the in_progress and tell mac80211 scan is completed. if we
1942 * don't do that and FW fails to send us scan completion indication
1943 * then userspace won't be able to scan anymore */
1944 ret = 0;
1945
1946 spin_lock_bh(&ar->data_lock);
1947 if (ar->scan.in_progress) {
1948 ath10k_warn("could not stop scan. its still in progress\n");
1949 ar->scan.in_progress = false;
1950 ath10k_offchan_tx_purge(ar);
1951 ret = -ETIMEDOUT;
1952 }
1953 spin_unlock_bh(&ar->data_lock);
1954
1955 return ret;
1956 }
1957
1958 static int ath10k_start_scan(struct ath10k *ar,
1959 const struct wmi_start_scan_arg *arg)
1960 {
1961 int ret;
1962
1963 lockdep_assert_held(&ar->conf_mutex);
1964
1965 ret = ath10k_wmi_start_scan(ar, arg);
1966 if (ret)
1967 return ret;
1968
1969 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
1970 if (ret == 0) {
1971 ath10k_abort_scan(ar);
1972 return ret;
1973 }
1974
1975 /* the scan can complete earlier, before we even
1976 * start the timer. in that case the timer handler
1977 * checks ar->scan.in_progress and bails out if its
1978 * false. Add a 200ms margin to account event/command
1979 * processing. */
1980 mod_timer(&ar->scan.timeout, jiffies +
1981 msecs_to_jiffies(arg->max_scan_time+200));
1982 return 0;
1983 }
1984
1985 /**********************/
1986 /* mac80211 callbacks */
1987 /**********************/
1988
1989 static void ath10k_tx(struct ieee80211_hw *hw,
1990 struct ieee80211_tx_control *control,
1991 struct sk_buff *skb)
1992 {
1993 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1994 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1995 struct ath10k *ar = hw->priv;
1996 u8 tid, vdev_id;
1997
1998 /* We should disable CCK RATE due to P2P */
1999 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2000 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2001
2002 /* we must calculate tid before we apply qos workaround
2003 * as we'd lose the qos control field */
2004 tid = ath10k_tx_h_get_tid(hdr);
2005 vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
2006
2007 /* it makes no sense to process injected frames like that */
2008 if (info->control.vif &&
2009 info->control.vif->type != NL80211_IFTYPE_MONITOR) {
2010 ath10k_tx_h_qos_workaround(hw, control, skb);
2011 ath10k_tx_h_update_wep_key(skb);
2012 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
2013 ath10k_tx_h_seq_no(skb);
2014 }
2015
2016 ATH10K_SKB_CB(skb)->vdev_id = vdev_id;
2017 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2018 ATH10K_SKB_CB(skb)->htt.tid = tid;
2019
2020 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2021 spin_lock_bh(&ar->data_lock);
2022 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2023 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2024 spin_unlock_bh(&ar->data_lock);
2025
2026 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2027
2028 skb_queue_tail(&ar->offchan_tx_queue, skb);
2029 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2030 return;
2031 }
2032
2033 ath10k_tx_htt(ar, skb);
2034 }
2035
2036 /*
2037 * Initialize various parameters with default vaules.
2038 */
2039 void ath10k_halt(struct ath10k *ar)
2040 {
2041 lockdep_assert_held(&ar->conf_mutex);
2042
2043 ath10k_stop_cac(ar);
2044 del_timer_sync(&ar->scan.timeout);
2045 ath10k_offchan_tx_purge(ar);
2046 ath10k_mgmt_over_wmi_tx_purge(ar);
2047 ath10k_peer_cleanup_all(ar);
2048 ath10k_core_stop(ar);
2049 ath10k_hif_power_down(ar);
2050
2051 spin_lock_bh(&ar->data_lock);
2052 if (ar->scan.in_progress) {
2053 del_timer(&ar->scan.timeout);
2054 ar->scan.in_progress = false;
2055 ieee80211_scan_completed(ar->hw, true);
2056 }
2057 spin_unlock_bh(&ar->data_lock);
2058 }
2059
2060 static int ath10k_start(struct ieee80211_hw *hw)
2061 {
2062 struct ath10k *ar = hw->priv;
2063 int ret = 0;
2064
2065 mutex_lock(&ar->conf_mutex);
2066
2067 if (ar->state != ATH10K_STATE_OFF &&
2068 ar->state != ATH10K_STATE_RESTARTING) {
2069 ret = -EINVAL;
2070 goto exit;
2071 }
2072
2073 ret = ath10k_hif_power_up(ar);
2074 if (ret) {
2075 ath10k_err("could not init hif (%d)\n", ret);
2076 ar->state = ATH10K_STATE_OFF;
2077 goto exit;
2078 }
2079
2080 ret = ath10k_core_start(ar);
2081 if (ret) {
2082 ath10k_err("could not init core (%d)\n", ret);
2083 ath10k_hif_power_down(ar);
2084 ar->state = ATH10K_STATE_OFF;
2085 goto exit;
2086 }
2087
2088 if (ar->state == ATH10K_STATE_OFF)
2089 ar->state = ATH10K_STATE_ON;
2090 else if (ar->state == ATH10K_STATE_RESTARTING)
2091 ar->state = ATH10K_STATE_RESTARTED;
2092
2093 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2094 if (ret)
2095 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
2096 ret);
2097
2098 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2099 if (ret)
2100 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
2101 ret);
2102
2103 ath10k_regd_update(ar);
2104
2105 exit:
2106 mutex_unlock(&ar->conf_mutex);
2107 return 0;
2108 }
2109
2110 static void ath10k_stop(struct ieee80211_hw *hw)
2111 {
2112 struct ath10k *ar = hw->priv;
2113
2114 mutex_lock(&ar->conf_mutex);
2115 if (ar->state == ATH10K_STATE_ON ||
2116 ar->state == ATH10K_STATE_RESTARTED ||
2117 ar->state == ATH10K_STATE_WEDGED)
2118 ath10k_halt(ar);
2119
2120 ar->state = ATH10K_STATE_OFF;
2121 mutex_unlock(&ar->conf_mutex);
2122
2123 ath10k_mgmt_over_wmi_tx_purge(ar);
2124
2125 cancel_work_sync(&ar->offchan_tx_work);
2126 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2127 cancel_work_sync(&ar->restart_work);
2128 }
2129
2130 static int ath10k_config_ps(struct ath10k *ar)
2131 {
2132 struct ath10k_vif *arvif;
2133 int ret = 0;
2134
2135 lockdep_assert_held(&ar->conf_mutex);
2136
2137 list_for_each_entry(arvif, &ar->arvifs, list) {
2138 ret = ath10k_mac_vif_setup_ps(arvif);
2139 if (ret) {
2140 ath10k_warn("could not setup powersave (%d)\n", ret);
2141 break;
2142 }
2143 }
2144
2145 return ret;
2146 }
2147
2148 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2149 {
2150 struct ath10k *ar = hw->priv;
2151 struct ieee80211_conf *conf = &hw->conf;
2152 int ret = 0;
2153 u32 param;
2154
2155 mutex_lock(&ar->conf_mutex);
2156
2157 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2158 ath10k_dbg(ATH10K_DBG_MAC,
2159 "mac config channel %d mhz flags 0x%x\n",
2160 conf->chandef.chan->center_freq,
2161 conf->chandef.chan->flags);
2162
2163 spin_lock_bh(&ar->data_lock);
2164 ar->rx_channel = conf->chandef.chan;
2165 spin_unlock_bh(&ar->data_lock);
2166
2167 ath10k_config_radar_detection(ar);
2168 }
2169
2170 if (changed & IEEE80211_CONF_CHANGE_POWER) {
2171 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2172 hw->conf.power_level);
2173
2174 param = ar->wmi.pdev_param->txpower_limit2g;
2175 ret = ath10k_wmi_pdev_set_param(ar, param,
2176 hw->conf.power_level * 2);
2177 if (ret)
2178 ath10k_warn("mac failed to set 2g txpower %d (%d)\n",
2179 hw->conf.power_level, ret);
2180
2181 param = ar->wmi.pdev_param->txpower_limit5g;
2182 ret = ath10k_wmi_pdev_set_param(ar, param,
2183 hw->conf.power_level * 2);
2184 if (ret)
2185 ath10k_warn("mac failed to set 5g txpower %d (%d)\n",
2186 hw->conf.power_level, ret);
2187 }
2188
2189 if (changed & IEEE80211_CONF_CHANGE_PS)
2190 ath10k_config_ps(ar);
2191
2192 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2193 if (conf->flags & IEEE80211_CONF_MONITOR)
2194 ret = ath10k_monitor_create(ar);
2195 else
2196 ret = ath10k_monitor_destroy(ar);
2197 }
2198
2199 mutex_unlock(&ar->conf_mutex);
2200 return ret;
2201 }
2202
2203 /*
2204 * TODO:
2205 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2206 * because we will send mgmt frames without CCK. This requirement
2207 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2208 * in the TX packet.
2209 */
2210 static int ath10k_add_interface(struct ieee80211_hw *hw,
2211 struct ieee80211_vif *vif)
2212 {
2213 struct ath10k *ar = hw->priv;
2214 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2215 enum wmi_sta_powersave_param param;
2216 int ret = 0;
2217 u32 value, param_id;
2218 int bit;
2219 u32 vdev_param;
2220
2221 mutex_lock(&ar->conf_mutex);
2222
2223 memset(arvif, 0, sizeof(*arvif));
2224
2225 arvif->ar = ar;
2226 arvif->vif = vif;
2227
2228 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2229 INIT_LIST_HEAD(&arvif->list);
2230
2231 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
2232 ath10k_warn("Only one monitor interface allowed\n");
2233 ret = -EBUSY;
2234 goto err;
2235 }
2236
2237 bit = ffs(ar->free_vdev_map);
2238 if (bit == 0) {
2239 ret = -EBUSY;
2240 goto err;
2241 }
2242
2243 arvif->vdev_id = bit - 1;
2244 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2245
2246 if (ar->p2p)
2247 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2248
2249 switch (vif->type) {
2250 case NL80211_IFTYPE_UNSPECIFIED:
2251 case NL80211_IFTYPE_STATION:
2252 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2253 if (vif->p2p)
2254 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2255 break;
2256 case NL80211_IFTYPE_ADHOC:
2257 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2258 break;
2259 case NL80211_IFTYPE_AP:
2260 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2261
2262 if (vif->p2p)
2263 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2264 break;
2265 case NL80211_IFTYPE_MONITOR:
2266 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2267 break;
2268 default:
2269 WARN_ON(1);
2270 break;
2271 }
2272
2273 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
2274 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2275
2276 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2277 arvif->vdev_subtype, vif->addr);
2278 if (ret) {
2279 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
2280 goto err;
2281 }
2282
2283 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2284 list_add(&arvif->list, &ar->arvifs);
2285
2286 vdev_param = ar->wmi.vdev_param->def_keyid;
2287 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2288 arvif->def_wep_key_idx);
2289 if (ret) {
2290 ath10k_warn("Failed to set default keyid: %d\n", ret);
2291 goto err_vdev_delete;
2292 }
2293
2294 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2295 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2296 ATH10K_HW_TXRX_NATIVE_WIFI);
2297 /* 10.X firmware does not support this VDEV parameter. Do not warn */
2298 if (ret && ret != -EOPNOTSUPP) {
2299 ath10k_warn("Failed to set TX encap: %d\n", ret);
2300 goto err_vdev_delete;
2301 }
2302
2303 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2304 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2305 if (ret) {
2306 ath10k_warn("Failed to create peer for AP: %d\n", ret);
2307 goto err_vdev_delete;
2308 }
2309
2310 param_id = ar->wmi.pdev_param->sta_kickout_th;
2311
2312 /* Disable STA KICKOUT functionality in FW */
2313 ret = ath10k_wmi_pdev_set_param(ar, param_id, 0);
2314 if (ret)
2315 ath10k_warn("Failed to disable STA KICKOUT\n");
2316 }
2317
2318 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2319 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2320 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2321 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2322 param, value);
2323 if (ret) {
2324 ath10k_warn("Failed to set RX wake policy: %d\n", ret);
2325 goto err_peer_delete;
2326 }
2327
2328 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2329 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2330 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2331 param, value);
2332 if (ret) {
2333 ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
2334 goto err_peer_delete;
2335 }
2336
2337 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2338 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2339 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2340 param, value);
2341 if (ret) {
2342 ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
2343 goto err_peer_delete;
2344 }
2345 }
2346
2347 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2348 if (ret) {
2349 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n",
2350 arvif->vdev_id, ret);
2351 goto err_peer_delete;
2352 }
2353
2354 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2355 if (ret) {
2356 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n",
2357 arvif->vdev_id, ret);
2358 goto err_peer_delete;
2359 }
2360
2361 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2362 ar->monitor_present = true;
2363
2364 mutex_unlock(&ar->conf_mutex);
2365 return 0;
2366
2367 err_peer_delete:
2368 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2369 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2370
2371 err_vdev_delete:
2372 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2373 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2374 list_del(&arvif->list);
2375
2376 err:
2377 mutex_unlock(&ar->conf_mutex);
2378
2379 return ret;
2380 }
2381
2382 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2383 struct ieee80211_vif *vif)
2384 {
2385 struct ath10k *ar = hw->priv;
2386 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2387 int ret;
2388
2389 mutex_lock(&ar->conf_mutex);
2390
2391 cancel_work_sync(&arvif->wep_key_work);
2392
2393 spin_lock_bh(&ar->data_lock);
2394 if (arvif->beacon) {
2395 dev_kfree_skb_any(arvif->beacon);
2396 arvif->beacon = NULL;
2397 }
2398 spin_unlock_bh(&ar->data_lock);
2399
2400 ar->free_vdev_map |= 1 << (arvif->vdev_id);
2401 list_del(&arvif->list);
2402
2403 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2404 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2405 if (ret)
2406 ath10k_warn("Failed to remove peer for AP: %d\n", ret);
2407
2408 kfree(arvif->u.ap.noa_data);
2409 }
2410
2411 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev delete %d (remove interface)\n",
2412 arvif->vdev_id);
2413
2414 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2415 if (ret)
2416 ath10k_warn("WMI vdev delete failed: %d\n", ret);
2417
2418 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2419 ar->monitor_present = false;
2420
2421 ath10k_peer_cleanup(ar, arvif->vdev_id);
2422
2423 mutex_unlock(&ar->conf_mutex);
2424 }
2425
2426 /*
2427 * FIXME: Has to be verified.
2428 */
2429 #define SUPPORTED_FILTERS \
2430 (FIF_PROMISC_IN_BSS | \
2431 FIF_ALLMULTI | \
2432 FIF_CONTROL | \
2433 FIF_PSPOLL | \
2434 FIF_OTHER_BSS | \
2435 FIF_BCN_PRBRESP_PROMISC | \
2436 FIF_PROBE_REQ | \
2437 FIF_FCSFAIL)
2438
2439 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2440 unsigned int changed_flags,
2441 unsigned int *total_flags,
2442 u64 multicast)
2443 {
2444 struct ath10k *ar = hw->priv;
2445 int ret;
2446
2447 mutex_lock(&ar->conf_mutex);
2448
2449 changed_flags &= SUPPORTED_FILTERS;
2450 *total_flags &= SUPPORTED_FILTERS;
2451 ar->filter_flags = *total_flags;
2452
2453 /* Monitor must not be started if it wasn't created first.
2454 * Promiscuous mode may be started on a non-monitor interface - in
2455 * such case the monitor vdev is not created so starting the
2456 * monitor makes no sense. Since ath10k uses no special RX filters
2457 * (only BSS filter in STA mode) there's no need for any special
2458 * action here. */
2459 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2460 !ar->monitor_enabled && ar->monitor_present) {
2461 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d start\n",
2462 ar->monitor_vdev_id);
2463
2464 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
2465 if (ret)
2466 ath10k_warn("Unable to start monitor mode\n");
2467 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2468 ar->monitor_enabled && ar->monitor_present) {
2469 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d stop\n",
2470 ar->monitor_vdev_id);
2471
2472 ret = ath10k_monitor_stop(ar);
2473 if (ret)
2474 ath10k_warn("Unable to stop monitor mode\n");
2475 }
2476
2477 mutex_unlock(&ar->conf_mutex);
2478 }
2479
2480 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2481 struct ieee80211_vif *vif,
2482 struct ieee80211_bss_conf *info,
2483 u32 changed)
2484 {
2485 struct ath10k *ar = hw->priv;
2486 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2487 int ret = 0;
2488 u32 vdev_param, pdev_param;
2489
2490 mutex_lock(&ar->conf_mutex);
2491
2492 if (changed & BSS_CHANGED_IBSS)
2493 ath10k_control_ibss(arvif, info, vif->addr);
2494
2495 if (changed & BSS_CHANGED_BEACON_INT) {
2496 arvif->beacon_interval = info->beacon_int;
2497 vdev_param = ar->wmi.vdev_param->beacon_interval;
2498 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2499 arvif->beacon_interval);
2500 ath10k_dbg(ATH10K_DBG_MAC,
2501 "mac vdev %d beacon_interval %d\n",
2502 arvif->vdev_id, arvif->beacon_interval);
2503
2504 if (ret)
2505 ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
2506 arvif->vdev_id);
2507 }
2508
2509 if (changed & BSS_CHANGED_BEACON) {
2510 ath10k_dbg(ATH10K_DBG_MAC,
2511 "vdev %d set beacon tx mode to staggered\n",
2512 arvif->vdev_id);
2513
2514 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
2515 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
2516 WMI_BEACON_STAGGERED_MODE);
2517 if (ret)
2518 ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
2519 arvif->vdev_id);
2520 }
2521
2522 if (changed & BSS_CHANGED_BEACON_INFO) {
2523 arvif->dtim_period = info->dtim_period;
2524
2525 ath10k_dbg(ATH10K_DBG_MAC,
2526 "mac vdev %d dtim_period %d\n",
2527 arvif->vdev_id, arvif->dtim_period);
2528
2529 vdev_param = ar->wmi.vdev_param->dtim_period;
2530 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2531 arvif->dtim_period);
2532 if (ret)
2533 ath10k_warn("Failed to set dtim period for VDEV: %d\n",
2534 arvif->vdev_id);
2535 }
2536
2537 if (changed & BSS_CHANGED_SSID &&
2538 vif->type == NL80211_IFTYPE_AP) {
2539 arvif->u.ap.ssid_len = info->ssid_len;
2540 if (info->ssid_len)
2541 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2542 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2543 }
2544
2545 if (changed & BSS_CHANGED_BSSID) {
2546 if (!is_zero_ether_addr(info->bssid)) {
2547 ath10k_dbg(ATH10K_DBG_MAC,
2548 "mac vdev %d create peer %pM\n",
2549 arvif->vdev_id, info->bssid);
2550
2551 ret = ath10k_peer_create(ar, arvif->vdev_id,
2552 info->bssid);
2553 if (ret)
2554 ath10k_warn("Failed to add peer %pM for vdev %d when changin bssid: %i\n",
2555 info->bssid, arvif->vdev_id, ret);
2556
2557 if (vif->type == NL80211_IFTYPE_STATION) {
2558 /*
2559 * this is never erased as we it for crypto key
2560 * clearing; this is FW requirement
2561 */
2562 memcpy(arvif->u.sta.bssid, info->bssid,
2563 ETH_ALEN);
2564
2565 ath10k_dbg(ATH10K_DBG_MAC,
2566 "mac vdev %d start %pM\n",
2567 arvif->vdev_id, info->bssid);
2568
2569 /* FIXME: check return value */
2570 ret = ath10k_vdev_start(arvif);
2571 }
2572
2573 /*
2574 * Mac80211 does not keep IBSS bssid when leaving IBSS,
2575 * so driver need to store it. It is needed when leaving
2576 * IBSS in order to remove BSSID peer.
2577 */
2578 if (vif->type == NL80211_IFTYPE_ADHOC)
2579 memcpy(arvif->u.ibss.bssid, info->bssid,
2580 ETH_ALEN);
2581 }
2582 }
2583
2584 if (changed & BSS_CHANGED_BEACON_ENABLED)
2585 ath10k_control_beaconing(arvif, info);
2586
2587 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2588 u32 cts_prot;
2589 if (info->use_cts_prot)
2590 cts_prot = 1;
2591 else
2592 cts_prot = 0;
2593
2594 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
2595 arvif->vdev_id, cts_prot);
2596
2597 vdev_param = ar->wmi.vdev_param->enable_rtscts;
2598 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2599 cts_prot);
2600 if (ret)
2601 ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2602 arvif->vdev_id);
2603 }
2604
2605 if (changed & BSS_CHANGED_ERP_SLOT) {
2606 u32 slottime;
2607 if (info->use_short_slot)
2608 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2609
2610 else
2611 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2612
2613 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
2614 arvif->vdev_id, slottime);
2615
2616 vdev_param = ar->wmi.vdev_param->slot_time;
2617 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2618 slottime);
2619 if (ret)
2620 ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2621 arvif->vdev_id);
2622 }
2623
2624 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2625 u32 preamble;
2626 if (info->use_short_preamble)
2627 preamble = WMI_VDEV_PREAMBLE_SHORT;
2628 else
2629 preamble = WMI_VDEV_PREAMBLE_LONG;
2630
2631 ath10k_dbg(ATH10K_DBG_MAC,
2632 "mac vdev %d preamble %dn",
2633 arvif->vdev_id, preamble);
2634
2635 vdev_param = ar->wmi.vdev_param->preamble;
2636 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2637 preamble);
2638 if (ret)
2639 ath10k_warn("Failed to set preamble for VDEV: %d\n",
2640 arvif->vdev_id);
2641 }
2642
2643 if (changed & BSS_CHANGED_ASSOC) {
2644 if (info->assoc)
2645 ath10k_bss_assoc(hw, vif, info);
2646 }
2647
2648 mutex_unlock(&ar->conf_mutex);
2649 }
2650
2651 static int ath10k_hw_scan(struct ieee80211_hw *hw,
2652 struct ieee80211_vif *vif,
2653 struct cfg80211_scan_request *req)
2654 {
2655 struct ath10k *ar = hw->priv;
2656 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2657 struct wmi_start_scan_arg arg;
2658 int ret = 0;
2659 int i;
2660
2661 mutex_lock(&ar->conf_mutex);
2662
2663 spin_lock_bh(&ar->data_lock);
2664 if (ar->scan.in_progress) {
2665 spin_unlock_bh(&ar->data_lock);
2666 ret = -EBUSY;
2667 goto exit;
2668 }
2669
2670 reinit_completion(&ar->scan.started);
2671 reinit_completion(&ar->scan.completed);
2672 ar->scan.in_progress = true;
2673 ar->scan.aborting = false;
2674 ar->scan.is_roc = false;
2675 ar->scan.vdev_id = arvif->vdev_id;
2676 spin_unlock_bh(&ar->data_lock);
2677
2678 memset(&arg, 0, sizeof(arg));
2679 ath10k_wmi_start_scan_init(ar, &arg);
2680 arg.vdev_id = arvif->vdev_id;
2681 arg.scan_id = ATH10K_SCAN_ID;
2682
2683 if (!req->no_cck)
2684 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2685
2686 if (req->ie_len) {
2687 arg.ie_len = req->ie_len;
2688 memcpy(arg.ie, req->ie, arg.ie_len);
2689 }
2690
2691 if (req->n_ssids) {
2692 arg.n_ssids = req->n_ssids;
2693 for (i = 0; i < arg.n_ssids; i++) {
2694 arg.ssids[i].len = req->ssids[i].ssid_len;
2695 arg.ssids[i].ssid = req->ssids[i].ssid;
2696 }
2697 } else {
2698 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2699 }
2700
2701 if (req->n_channels) {
2702 arg.n_channels = req->n_channels;
2703 for (i = 0; i < arg.n_channels; i++)
2704 arg.channels[i] = req->channels[i]->center_freq;
2705 }
2706
2707 ret = ath10k_start_scan(ar, &arg);
2708 if (ret) {
2709 ath10k_warn("could not start hw scan (%d)\n", ret);
2710 spin_lock_bh(&ar->data_lock);
2711 ar->scan.in_progress = false;
2712 spin_unlock_bh(&ar->data_lock);
2713 }
2714
2715 exit:
2716 mutex_unlock(&ar->conf_mutex);
2717 return ret;
2718 }
2719
2720 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2721 struct ieee80211_vif *vif)
2722 {
2723 struct ath10k *ar = hw->priv;
2724 int ret;
2725
2726 mutex_lock(&ar->conf_mutex);
2727 ret = ath10k_abort_scan(ar);
2728 if (ret) {
2729 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2730 ret);
2731 ieee80211_scan_completed(hw, 1 /* aborted */);
2732 }
2733 mutex_unlock(&ar->conf_mutex);
2734 }
2735
2736 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
2737 struct ath10k_vif *arvif,
2738 enum set_key_cmd cmd,
2739 struct ieee80211_key_conf *key)
2740 {
2741 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
2742 int ret;
2743
2744 /* 10.1 firmware branch requires default key index to be set to group
2745 * key index after installing it. Otherwise FW/HW Txes corrupted
2746 * frames with multi-vif APs. This is not required for main firmware
2747 * branch (e.g. 636).
2748 *
2749 * FIXME: This has been tested only in AP. It remains unknown if this
2750 * is required for multi-vif STA interfaces on 10.1 */
2751
2752 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
2753 return;
2754
2755 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
2756 return;
2757
2758 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
2759 return;
2760
2761 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
2762 return;
2763
2764 if (cmd != SET_KEY)
2765 return;
2766
2767 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2768 key->keyidx);
2769 if (ret)
2770 ath10k_warn("failed to set group key as default key: %d\n",
2771 ret);
2772 }
2773
2774 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2775 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2776 struct ieee80211_key_conf *key)
2777 {
2778 struct ath10k *ar = hw->priv;
2779 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2780 struct ath10k_peer *peer;
2781 const u8 *peer_addr;
2782 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2783 key->cipher == WLAN_CIPHER_SUITE_WEP104;
2784 int ret = 0;
2785
2786 if (key->keyidx > WMI_MAX_KEY_INDEX)
2787 return -ENOSPC;
2788
2789 mutex_lock(&ar->conf_mutex);
2790
2791 if (sta)
2792 peer_addr = sta->addr;
2793 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
2794 peer_addr = vif->bss_conf.bssid;
2795 else
2796 peer_addr = vif->addr;
2797
2798 key->hw_key_idx = key->keyidx;
2799
2800 /* the peer should not disappear in mid-way (unless FW goes awry) since
2801 * we already hold conf_mutex. we just make sure its there now. */
2802 spin_lock_bh(&ar->data_lock);
2803 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2804 spin_unlock_bh(&ar->data_lock);
2805
2806 if (!peer) {
2807 if (cmd == SET_KEY) {
2808 ath10k_warn("cannot install key for non-existent peer %pM\n",
2809 peer_addr);
2810 ret = -EOPNOTSUPP;
2811 goto exit;
2812 } else {
2813 /* if the peer doesn't exist there is no key to disable
2814 * anymore */
2815 goto exit;
2816 }
2817 }
2818
2819 if (is_wep) {
2820 if (cmd == SET_KEY)
2821 arvif->wep_keys[key->keyidx] = key;
2822 else
2823 arvif->wep_keys[key->keyidx] = NULL;
2824
2825 if (cmd == DISABLE_KEY)
2826 ath10k_clear_vdev_key(arvif, key);
2827 }
2828
2829 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
2830 if (ret) {
2831 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
2832 goto exit;
2833 }
2834
2835 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
2836
2837 spin_lock_bh(&ar->data_lock);
2838 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2839 if (peer && cmd == SET_KEY)
2840 peer->keys[key->keyidx] = key;
2841 else if (peer && cmd == DISABLE_KEY)
2842 peer->keys[key->keyidx] = NULL;
2843 else if (peer == NULL)
2844 /* impossible unless FW goes crazy */
2845 ath10k_warn("peer %pM disappeared!\n", peer_addr);
2846 spin_unlock_bh(&ar->data_lock);
2847
2848 exit:
2849 mutex_unlock(&ar->conf_mutex);
2850 return ret;
2851 }
2852
2853 static int ath10k_sta_state(struct ieee80211_hw *hw,
2854 struct ieee80211_vif *vif,
2855 struct ieee80211_sta *sta,
2856 enum ieee80211_sta_state old_state,
2857 enum ieee80211_sta_state new_state)
2858 {
2859 struct ath10k *ar = hw->priv;
2860 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2861 int max_num_peers;
2862 int ret = 0;
2863
2864 mutex_lock(&ar->conf_mutex);
2865
2866 if (old_state == IEEE80211_STA_NOTEXIST &&
2867 new_state == IEEE80211_STA_NONE &&
2868 vif->type != NL80211_IFTYPE_STATION) {
2869 /*
2870 * New station addition.
2871 */
2872 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
2873 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
2874 else
2875 max_num_peers = TARGET_NUM_PEERS;
2876
2877 if (ar->num_peers >= max_num_peers) {
2878 ath10k_warn("Number of peers exceeded: peers number %d (max peers %d)\n",
2879 ar->num_peers, max_num_peers);
2880 ret = -ENOBUFS;
2881 goto exit;
2882 }
2883
2884 ath10k_dbg(ATH10K_DBG_MAC,
2885 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
2886 arvif->vdev_id, sta->addr, ar->num_peers);
2887
2888 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
2889 if (ret)
2890 ath10k_warn("Failed to add peer %pM for vdev %d when adding a new sta: %i\n",
2891 sta->addr, arvif->vdev_id, ret);
2892 } else if ((old_state == IEEE80211_STA_NONE &&
2893 new_state == IEEE80211_STA_NOTEXIST)) {
2894 /*
2895 * Existing station deletion.
2896 */
2897 ath10k_dbg(ATH10K_DBG_MAC,
2898 "mac vdev %d peer delete %pM (sta gone)\n",
2899 arvif->vdev_id, sta->addr);
2900 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
2901 if (ret)
2902 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
2903 sta->addr, arvif->vdev_id);
2904
2905 if (vif->type == NL80211_IFTYPE_STATION)
2906 ath10k_bss_disassoc(hw, vif);
2907 } else if (old_state == IEEE80211_STA_AUTH &&
2908 new_state == IEEE80211_STA_ASSOC &&
2909 (vif->type == NL80211_IFTYPE_AP ||
2910 vif->type == NL80211_IFTYPE_ADHOC)) {
2911 /*
2912 * New association.
2913 */
2914 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
2915 sta->addr);
2916
2917 ret = ath10k_station_assoc(ar, arvif, sta);
2918 if (ret)
2919 ath10k_warn("Failed to associate station: %pM\n",
2920 sta->addr);
2921 } else if (old_state == IEEE80211_STA_ASSOC &&
2922 new_state == IEEE80211_STA_AUTH &&
2923 (vif->type == NL80211_IFTYPE_AP ||
2924 vif->type == NL80211_IFTYPE_ADHOC)) {
2925 /*
2926 * Disassociation.
2927 */
2928 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
2929 sta->addr);
2930
2931 ret = ath10k_station_disassoc(ar, arvif, sta);
2932 if (ret)
2933 ath10k_warn("Failed to disassociate station: %pM\n",
2934 sta->addr);
2935 }
2936 exit:
2937 mutex_unlock(&ar->conf_mutex);
2938 return ret;
2939 }
2940
2941 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
2942 u16 ac, bool enable)
2943 {
2944 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2945 u32 value = 0;
2946 int ret = 0;
2947
2948 lockdep_assert_held(&ar->conf_mutex);
2949
2950 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
2951 return 0;
2952
2953 switch (ac) {
2954 case IEEE80211_AC_VO:
2955 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
2956 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
2957 break;
2958 case IEEE80211_AC_VI:
2959 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
2960 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
2961 break;
2962 case IEEE80211_AC_BE:
2963 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
2964 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
2965 break;
2966 case IEEE80211_AC_BK:
2967 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
2968 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
2969 break;
2970 }
2971
2972 if (enable)
2973 arvif->u.sta.uapsd |= value;
2974 else
2975 arvif->u.sta.uapsd &= ~value;
2976
2977 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2978 WMI_STA_PS_PARAM_UAPSD,
2979 arvif->u.sta.uapsd);
2980 if (ret) {
2981 ath10k_warn("could not set uapsd params %d\n", ret);
2982 goto exit;
2983 }
2984
2985 if (arvif->u.sta.uapsd)
2986 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
2987 else
2988 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2989
2990 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2991 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
2992 value);
2993 if (ret)
2994 ath10k_warn("could not set rx wake param %d\n", ret);
2995
2996 exit:
2997 return ret;
2998 }
2999
3000 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3001 struct ieee80211_vif *vif, u16 ac,
3002 const struct ieee80211_tx_queue_params *params)
3003 {
3004 struct ath10k *ar = hw->priv;
3005 struct wmi_wmm_params_arg *p = NULL;
3006 int ret;
3007
3008 mutex_lock(&ar->conf_mutex);
3009
3010 switch (ac) {
3011 case IEEE80211_AC_VO:
3012 p = &ar->wmm_params.ac_vo;
3013 break;
3014 case IEEE80211_AC_VI:
3015 p = &ar->wmm_params.ac_vi;
3016 break;
3017 case IEEE80211_AC_BE:
3018 p = &ar->wmm_params.ac_be;
3019 break;
3020 case IEEE80211_AC_BK:
3021 p = &ar->wmm_params.ac_bk;
3022 break;
3023 }
3024
3025 if (WARN_ON(!p)) {
3026 ret = -EINVAL;
3027 goto exit;
3028 }
3029
3030 p->cwmin = params->cw_min;
3031 p->cwmax = params->cw_max;
3032 p->aifs = params->aifs;
3033
3034 /*
3035 * The channel time duration programmed in the HW is in absolute
3036 * microseconds, while mac80211 gives the txop in units of
3037 * 32 microseconds.
3038 */
3039 p->txop = params->txop * 32;
3040
3041 /* FIXME: FW accepts wmm params per hw, not per vif */
3042 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3043 if (ret) {
3044 ath10k_warn("could not set wmm params %d\n", ret);
3045 goto exit;
3046 }
3047
3048 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3049 if (ret)
3050 ath10k_warn("could not set sta uapsd %d\n", ret);
3051
3052 exit:
3053 mutex_unlock(&ar->conf_mutex);
3054 return ret;
3055 }
3056
3057 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3058
3059 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3060 struct ieee80211_vif *vif,
3061 struct ieee80211_channel *chan,
3062 int duration,
3063 enum ieee80211_roc_type type)
3064 {
3065 struct ath10k *ar = hw->priv;
3066 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3067 struct wmi_start_scan_arg arg;
3068 int ret;
3069
3070 mutex_lock(&ar->conf_mutex);
3071
3072 spin_lock_bh(&ar->data_lock);
3073 if (ar->scan.in_progress) {
3074 spin_unlock_bh(&ar->data_lock);
3075 ret = -EBUSY;
3076 goto exit;
3077 }
3078
3079 reinit_completion(&ar->scan.started);
3080 reinit_completion(&ar->scan.completed);
3081 reinit_completion(&ar->scan.on_channel);
3082 ar->scan.in_progress = true;
3083 ar->scan.aborting = false;
3084 ar->scan.is_roc = true;
3085 ar->scan.vdev_id = arvif->vdev_id;
3086 ar->scan.roc_freq = chan->center_freq;
3087 spin_unlock_bh(&ar->data_lock);
3088
3089 memset(&arg, 0, sizeof(arg));
3090 ath10k_wmi_start_scan_init(ar, &arg);
3091 arg.vdev_id = arvif->vdev_id;
3092 arg.scan_id = ATH10K_SCAN_ID;
3093 arg.n_channels = 1;
3094 arg.channels[0] = chan->center_freq;
3095 arg.dwell_time_active = duration;
3096 arg.dwell_time_passive = duration;
3097 arg.max_scan_time = 2 * duration;
3098 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3099 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3100
3101 ret = ath10k_start_scan(ar, &arg);
3102 if (ret) {
3103 ath10k_warn("could not start roc scan (%d)\n", ret);
3104 spin_lock_bh(&ar->data_lock);
3105 ar->scan.in_progress = false;
3106 spin_unlock_bh(&ar->data_lock);
3107 goto exit;
3108 }
3109
3110 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3111 if (ret == 0) {
3112 ath10k_warn("could not switch to channel for roc scan\n");
3113 ath10k_abort_scan(ar);
3114 ret = -ETIMEDOUT;
3115 goto exit;
3116 }
3117
3118 ret = 0;
3119 exit:
3120 mutex_unlock(&ar->conf_mutex);
3121 return ret;
3122 }
3123
3124 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3125 {
3126 struct ath10k *ar = hw->priv;
3127
3128 mutex_lock(&ar->conf_mutex);
3129 ath10k_abort_scan(ar);
3130 mutex_unlock(&ar->conf_mutex);
3131
3132 return 0;
3133 }
3134
3135 /*
3136 * Both RTS and Fragmentation threshold are interface-specific
3137 * in ath10k, but device-specific in mac80211.
3138 */
3139
3140 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3141 {
3142 struct ath10k *ar = hw->priv;
3143 struct ath10k_vif *arvif;
3144 int ret = 0;
3145
3146 mutex_lock(&ar->conf_mutex);
3147 list_for_each_entry(arvif, &ar->arvifs, list) {
3148 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3149 arvif->vdev_id, value);
3150
3151 ret = ath10k_mac_set_rts(arvif, value);
3152 if (ret) {
3153 ath10k_warn("could not set rts threshold for vdev %d (%d)\n",
3154 arvif->vdev_id, ret);
3155 break;
3156 }
3157 }
3158 mutex_unlock(&ar->conf_mutex);
3159
3160 return ret;
3161 }
3162
3163 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3164 {
3165 struct ath10k *ar = hw->priv;
3166 struct ath10k_vif *arvif;
3167 int ret = 0;
3168
3169 mutex_lock(&ar->conf_mutex);
3170 list_for_each_entry(arvif, &ar->arvifs, list) {
3171 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3172 arvif->vdev_id, value);
3173
3174 ret = ath10k_mac_set_rts(arvif, value);
3175 if (ret) {
3176 ath10k_warn("could not set fragmentation threshold for vdev %d (%d)\n",
3177 arvif->vdev_id, ret);
3178 break;
3179 }
3180 }
3181 mutex_unlock(&ar->conf_mutex);
3182
3183 return ret;
3184 }
3185
3186 static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
3187 {
3188 struct ath10k *ar = hw->priv;
3189 bool skip;
3190 int ret;
3191
3192 /* mac80211 doesn't care if we really xmit queued frames or not
3193 * we'll collect those frames either way if we stop/delete vdevs */
3194 if (drop)
3195 return;
3196
3197 mutex_lock(&ar->conf_mutex);
3198
3199 if (ar->state == ATH10K_STATE_WEDGED)
3200 goto skip;
3201
3202 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3203 bool empty;
3204
3205 spin_lock_bh(&ar->htt.tx_lock);
3206 empty = (ar->htt.num_pending_tx == 0);
3207 spin_unlock_bh(&ar->htt.tx_lock);
3208
3209 skip = (ar->state == ATH10K_STATE_WEDGED);
3210
3211 (empty || skip);
3212 }), ATH10K_FLUSH_TIMEOUT_HZ);
3213
3214 if (ret <= 0 || skip)
3215 ath10k_warn("tx not flushed\n");
3216
3217 skip:
3218 mutex_unlock(&ar->conf_mutex);
3219 }
3220
3221 /* TODO: Implement this function properly
3222 * For now it is needed to reply to Probe Requests in IBSS mode.
3223 * Propably we need this information from FW.
3224 */
3225 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3226 {
3227 return 1;
3228 }
3229
3230 #ifdef CONFIG_PM
3231 static int ath10k_suspend(struct ieee80211_hw *hw,
3232 struct cfg80211_wowlan *wowlan)
3233 {
3234 struct ath10k *ar = hw->priv;
3235 int ret;
3236
3237 ar->is_target_paused = false;
3238
3239 ret = ath10k_wmi_pdev_suspend_target(ar);
3240 if (ret) {
3241 ath10k_warn("could not suspend target (%d)\n", ret);
3242 return 1;
3243 }
3244
3245 ret = wait_event_interruptible_timeout(ar->event_queue,
3246 ar->is_target_paused == true,
3247 1 * HZ);
3248 if (ret < 0) {
3249 ath10k_warn("suspend interrupted (%d)\n", ret);
3250 goto resume;
3251 } else if (ret == 0) {
3252 ath10k_warn("suspend timed out - target pause event never came\n");
3253 goto resume;
3254 }
3255
3256 ret = ath10k_hif_suspend(ar);
3257 if (ret) {
3258 ath10k_warn("could not suspend hif (%d)\n", ret);
3259 goto resume;
3260 }
3261
3262 return 0;
3263 resume:
3264 ret = ath10k_wmi_pdev_resume_target(ar);
3265 if (ret)
3266 ath10k_warn("could not resume target (%d)\n", ret);
3267 return 1;
3268 }
3269
3270 static int ath10k_resume(struct ieee80211_hw *hw)
3271 {
3272 struct ath10k *ar = hw->priv;
3273 int ret;
3274
3275 ret = ath10k_hif_resume(ar);
3276 if (ret) {
3277 ath10k_warn("could not resume hif (%d)\n", ret);
3278 return 1;
3279 }
3280
3281 ret = ath10k_wmi_pdev_resume_target(ar);
3282 if (ret) {
3283 ath10k_warn("could not resume target (%d)\n", ret);
3284 return 1;
3285 }
3286
3287 return 0;
3288 }
3289 #endif
3290
3291 static void ath10k_restart_complete(struct ieee80211_hw *hw)
3292 {
3293 struct ath10k *ar = hw->priv;
3294
3295 mutex_lock(&ar->conf_mutex);
3296
3297 /* If device failed to restart it will be in a different state, e.g.
3298 * ATH10K_STATE_WEDGED */
3299 if (ar->state == ATH10K_STATE_RESTARTED) {
3300 ath10k_info("device successfully recovered\n");
3301 ar->state = ATH10K_STATE_ON;
3302 }
3303
3304 mutex_unlock(&ar->conf_mutex);
3305 }
3306
3307 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3308 struct survey_info *survey)
3309 {
3310 struct ath10k *ar = hw->priv;
3311 struct ieee80211_supported_band *sband;
3312 struct survey_info *ar_survey = &ar->survey[idx];
3313 int ret = 0;
3314
3315 mutex_lock(&ar->conf_mutex);
3316
3317 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3318 if (sband && idx >= sband->n_channels) {
3319 idx -= sband->n_channels;
3320 sband = NULL;
3321 }
3322
3323 if (!sband)
3324 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3325
3326 if (!sband || idx >= sband->n_channels) {
3327 ret = -ENOENT;
3328 goto exit;
3329 }
3330
3331 spin_lock_bh(&ar->data_lock);
3332 memcpy(survey, ar_survey, sizeof(*survey));
3333 spin_unlock_bh(&ar->data_lock);
3334
3335 survey->channel = &sband->channels[idx];
3336
3337 exit:
3338 mutex_unlock(&ar->conf_mutex);
3339 return ret;
3340 }
3341
3342 /* Helper table for legacy fixed_rate/bitrate_mask */
3343 static const u8 cck_ofdm_rate[] = {
3344 /* CCK */
3345 3, /* 1Mbps */
3346 2, /* 2Mbps */
3347 1, /* 5.5Mbps */
3348 0, /* 11Mbps */
3349 /* OFDM */
3350 3, /* 6Mbps */
3351 7, /* 9Mbps */
3352 2, /* 12Mbps */
3353 6, /* 18Mbps */
3354 1, /* 24Mbps */
3355 5, /* 36Mbps */
3356 0, /* 48Mbps */
3357 4, /* 54Mbps */
3358 };
3359
3360 /* Check if only one bit set */
3361 static int ath10k_check_single_mask(u32 mask)
3362 {
3363 int bit;
3364
3365 bit = ffs(mask);
3366 if (!bit)
3367 return 0;
3368
3369 mask &= ~BIT(bit - 1);
3370 if (mask)
3371 return 2;
3372
3373 return 1;
3374 }
3375
3376 static bool
3377 ath10k_default_bitrate_mask(struct ath10k *ar,
3378 enum ieee80211_band band,
3379 const struct cfg80211_bitrate_mask *mask)
3380 {
3381 u32 legacy = 0x00ff;
3382 u8 ht = 0xff, i;
3383 u16 vht = 0x3ff;
3384
3385 switch (band) {
3386 case IEEE80211_BAND_2GHZ:
3387 legacy = 0x00fff;
3388 vht = 0;
3389 break;
3390 case IEEE80211_BAND_5GHZ:
3391 break;
3392 default:
3393 return false;
3394 }
3395
3396 if (mask->control[band].legacy != legacy)
3397 return false;
3398
3399 for (i = 0; i < ar->num_rf_chains; i++)
3400 if (mask->control[band].ht_mcs[i] != ht)
3401 return false;
3402
3403 for (i = 0; i < ar->num_rf_chains; i++)
3404 if (mask->control[band].vht_mcs[i] != vht)
3405 return false;
3406
3407 return true;
3408 }
3409
3410 static bool
3411 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
3412 enum ieee80211_band band,
3413 u8 *fixed_nss)
3414 {
3415 int ht_nss = 0, vht_nss = 0, i;
3416
3417 /* check legacy */
3418 if (ath10k_check_single_mask(mask->control[band].legacy))
3419 return false;
3420
3421 /* check HT */
3422 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3423 if (mask->control[band].ht_mcs[i] == 0xff)
3424 continue;
3425 else if (mask->control[band].ht_mcs[i] == 0x00)
3426 break;
3427 else
3428 return false;
3429 }
3430
3431 ht_nss = i;
3432
3433 /* check VHT */
3434 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3435 if (mask->control[band].vht_mcs[i] == 0x03ff)
3436 continue;
3437 else if (mask->control[band].vht_mcs[i] == 0x0000)
3438 break;
3439 else
3440 return false;
3441 }
3442
3443 vht_nss = i;
3444
3445 if (ht_nss > 0 && vht_nss > 0)
3446 return false;
3447
3448 if (ht_nss)
3449 *fixed_nss = ht_nss;
3450 else if (vht_nss)
3451 *fixed_nss = vht_nss;
3452 else
3453 return false;
3454
3455 return true;
3456 }
3457
3458 static bool
3459 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
3460 enum ieee80211_band band,
3461 enum wmi_rate_preamble *preamble)
3462 {
3463 int legacy = 0, ht = 0, vht = 0, i;
3464
3465 *preamble = WMI_RATE_PREAMBLE_OFDM;
3466
3467 /* check legacy */
3468 legacy = ath10k_check_single_mask(mask->control[band].legacy);
3469 if (legacy > 1)
3470 return false;
3471
3472 /* check HT */
3473 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3474 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
3475 if (ht > 1)
3476 return false;
3477
3478 /* check VHT */
3479 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3480 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
3481 if (vht > 1)
3482 return false;
3483
3484 /* Currently we support only one fixed_rate */
3485 if ((legacy + ht + vht) != 1)
3486 return false;
3487
3488 if (ht)
3489 *preamble = WMI_RATE_PREAMBLE_HT;
3490 else if (vht)
3491 *preamble = WMI_RATE_PREAMBLE_VHT;
3492
3493 return true;
3494 }
3495
3496 static bool
3497 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask,
3498 enum ieee80211_band band,
3499 u8 *fixed_rate,
3500 u8 *fixed_nss)
3501 {
3502 u8 rate = 0, pream = 0, nss = 0, i;
3503 enum wmi_rate_preamble preamble;
3504
3505 /* Check if single rate correct */
3506 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
3507 return false;
3508
3509 pream = preamble;
3510
3511 switch (preamble) {
3512 case WMI_RATE_PREAMBLE_CCK:
3513 case WMI_RATE_PREAMBLE_OFDM:
3514 i = ffs(mask->control[band].legacy) - 1;
3515
3516 if (band == IEEE80211_BAND_2GHZ && i < 4)
3517 pream = WMI_RATE_PREAMBLE_CCK;
3518
3519 if (band == IEEE80211_BAND_5GHZ)
3520 i += 4;
3521
3522 if (i >= ARRAY_SIZE(cck_ofdm_rate))
3523 return false;
3524
3525 rate = cck_ofdm_rate[i];
3526 break;
3527 case WMI_RATE_PREAMBLE_HT:
3528 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3529 if (mask->control[band].ht_mcs[i])
3530 break;
3531
3532 if (i == IEEE80211_HT_MCS_MASK_LEN)
3533 return false;
3534
3535 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
3536 nss = i;
3537 break;
3538 case WMI_RATE_PREAMBLE_VHT:
3539 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3540 if (mask->control[band].vht_mcs[i])
3541 break;
3542
3543 if (i == NL80211_VHT_NSS_MAX)
3544 return false;
3545
3546 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
3547 nss = i;
3548 break;
3549 }
3550
3551 *fixed_nss = nss + 1;
3552 nss <<= 4;
3553 pream <<= 6;
3554
3555 ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
3556 pream, nss, rate);
3557
3558 *fixed_rate = pream | nss | rate;
3559
3560 return true;
3561 }
3562
3563 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask,
3564 enum ieee80211_band band,
3565 u8 *fixed_rate,
3566 u8 *fixed_nss)
3567 {
3568 /* First check full NSS mask, if we can simply limit NSS */
3569 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
3570 return true;
3571
3572 /* Next Check single rate is set */
3573 return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss);
3574 }
3575
3576 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
3577 u8 fixed_rate,
3578 u8 fixed_nss)
3579 {
3580 struct ath10k *ar = arvif->ar;
3581 u32 vdev_param;
3582 int ret = 0;
3583
3584 mutex_lock(&ar->conf_mutex);
3585
3586 if (arvif->fixed_rate == fixed_rate &&
3587 arvif->fixed_nss == fixed_nss)
3588 goto exit;
3589
3590 if (fixed_rate == WMI_FIXED_RATE_NONE)
3591 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
3592
3593 vdev_param = ar->wmi.vdev_param->fixed_rate;
3594 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
3595 vdev_param, fixed_rate);
3596 if (ret) {
3597 ath10k_warn("Could not set fixed_rate param 0x%02x: %d\n",
3598 fixed_rate, ret);
3599 ret = -EINVAL;
3600 goto exit;
3601 }
3602
3603 arvif->fixed_rate = fixed_rate;
3604
3605 vdev_param = ar->wmi.vdev_param->nss;
3606 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
3607 vdev_param, fixed_nss);
3608
3609 if (ret) {
3610 ath10k_warn("Could not set fixed_nss param %d: %d\n",
3611 fixed_nss, ret);
3612 ret = -EINVAL;
3613 goto exit;
3614 }
3615
3616 arvif->fixed_nss = fixed_nss;
3617
3618 exit:
3619 mutex_unlock(&ar->conf_mutex);
3620 return ret;
3621 }
3622
3623 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
3624 struct ieee80211_vif *vif,
3625 const struct cfg80211_bitrate_mask *mask)
3626 {
3627 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3628 struct ath10k *ar = arvif->ar;
3629 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
3630 u8 fixed_rate = WMI_FIXED_RATE_NONE;
3631 u8 fixed_nss = ar->num_rf_chains;
3632
3633 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
3634 if (!ath10k_get_fixed_rate_nss(mask, band,
3635 &fixed_rate,
3636 &fixed_nss))
3637 return -EINVAL;
3638 }
3639
3640 return ath10k_set_fixed_rate_param(arvif, fixed_rate, fixed_nss);
3641 }
3642
3643 static const struct ieee80211_ops ath10k_ops = {
3644 .tx = ath10k_tx,
3645 .start = ath10k_start,
3646 .stop = ath10k_stop,
3647 .config = ath10k_config,
3648 .add_interface = ath10k_add_interface,
3649 .remove_interface = ath10k_remove_interface,
3650 .configure_filter = ath10k_configure_filter,
3651 .bss_info_changed = ath10k_bss_info_changed,
3652 .hw_scan = ath10k_hw_scan,
3653 .cancel_hw_scan = ath10k_cancel_hw_scan,
3654 .set_key = ath10k_set_key,
3655 .sta_state = ath10k_sta_state,
3656 .conf_tx = ath10k_conf_tx,
3657 .remain_on_channel = ath10k_remain_on_channel,
3658 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
3659 .set_rts_threshold = ath10k_set_rts_threshold,
3660 .set_frag_threshold = ath10k_set_frag_threshold,
3661 .flush = ath10k_flush,
3662 .tx_last_beacon = ath10k_tx_last_beacon,
3663 .restart_complete = ath10k_restart_complete,
3664 .get_survey = ath10k_get_survey,
3665 .set_bitrate_mask = ath10k_set_bitrate_mask,
3666 #ifdef CONFIG_PM
3667 .suspend = ath10k_suspend,
3668 .resume = ath10k_resume,
3669 #endif
3670 };
3671
3672 #define RATETAB_ENT(_rate, _rateid, _flags) { \
3673 .bitrate = (_rate), \
3674 .flags = (_flags), \
3675 .hw_value = (_rateid), \
3676 }
3677
3678 #define CHAN2G(_channel, _freq, _flags) { \
3679 .band = IEEE80211_BAND_2GHZ, \
3680 .hw_value = (_channel), \
3681 .center_freq = (_freq), \
3682 .flags = (_flags), \
3683 .max_antenna_gain = 0, \
3684 .max_power = 30, \
3685 }
3686
3687 #define CHAN5G(_channel, _freq, _flags) { \
3688 .band = IEEE80211_BAND_5GHZ, \
3689 .hw_value = (_channel), \
3690 .center_freq = (_freq), \
3691 .flags = (_flags), \
3692 .max_antenna_gain = 0, \
3693 .max_power = 30, \
3694 }
3695
3696 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
3697 CHAN2G(1, 2412, 0),
3698 CHAN2G(2, 2417, 0),
3699 CHAN2G(3, 2422, 0),
3700 CHAN2G(4, 2427, 0),
3701 CHAN2G(5, 2432, 0),
3702 CHAN2G(6, 2437, 0),
3703 CHAN2G(7, 2442, 0),
3704 CHAN2G(8, 2447, 0),
3705 CHAN2G(9, 2452, 0),
3706 CHAN2G(10, 2457, 0),
3707 CHAN2G(11, 2462, 0),
3708 CHAN2G(12, 2467, 0),
3709 CHAN2G(13, 2472, 0),
3710 CHAN2G(14, 2484, 0),
3711 };
3712
3713 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
3714 CHAN5G(36, 5180, 0),
3715 CHAN5G(40, 5200, 0),
3716 CHAN5G(44, 5220, 0),
3717 CHAN5G(48, 5240, 0),
3718 CHAN5G(52, 5260, 0),
3719 CHAN5G(56, 5280, 0),
3720 CHAN5G(60, 5300, 0),
3721 CHAN5G(64, 5320, 0),
3722 CHAN5G(100, 5500, 0),
3723 CHAN5G(104, 5520, 0),
3724 CHAN5G(108, 5540, 0),
3725 CHAN5G(112, 5560, 0),
3726 CHAN5G(116, 5580, 0),
3727 CHAN5G(120, 5600, 0),
3728 CHAN5G(124, 5620, 0),
3729 CHAN5G(128, 5640, 0),
3730 CHAN5G(132, 5660, 0),
3731 CHAN5G(136, 5680, 0),
3732 CHAN5G(140, 5700, 0),
3733 CHAN5G(149, 5745, 0),
3734 CHAN5G(153, 5765, 0),
3735 CHAN5G(157, 5785, 0),
3736 CHAN5G(161, 5805, 0),
3737 CHAN5G(165, 5825, 0),
3738 };
3739
3740 static struct ieee80211_rate ath10k_rates[] = {
3741 /* CCK */
3742 RATETAB_ENT(10, 0x82, 0),
3743 RATETAB_ENT(20, 0x84, 0),
3744 RATETAB_ENT(55, 0x8b, 0),
3745 RATETAB_ENT(110, 0x96, 0),
3746 /* OFDM */
3747 RATETAB_ENT(60, 0x0c, 0),
3748 RATETAB_ENT(90, 0x12, 0),
3749 RATETAB_ENT(120, 0x18, 0),
3750 RATETAB_ENT(180, 0x24, 0),
3751 RATETAB_ENT(240, 0x30, 0),
3752 RATETAB_ENT(360, 0x48, 0),
3753 RATETAB_ENT(480, 0x60, 0),
3754 RATETAB_ENT(540, 0x6c, 0),
3755 };
3756
3757 #define ath10k_a_rates (ath10k_rates + 4)
3758 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
3759 #define ath10k_g_rates (ath10k_rates + 0)
3760 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
3761
3762 struct ath10k *ath10k_mac_create(void)
3763 {
3764 struct ieee80211_hw *hw;
3765 struct ath10k *ar;
3766
3767 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
3768 if (!hw)
3769 return NULL;
3770
3771 ar = hw->priv;
3772 ar->hw = hw;
3773
3774 return ar;
3775 }
3776
3777 void ath10k_mac_destroy(struct ath10k *ar)
3778 {
3779 ieee80211_free_hw(ar->hw);
3780 }
3781
3782 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
3783 {
3784 .max = 8,
3785 .types = BIT(NL80211_IFTYPE_STATION)
3786 | BIT(NL80211_IFTYPE_P2P_CLIENT)
3787 },
3788 {
3789 .max = 3,
3790 .types = BIT(NL80211_IFTYPE_P2P_GO)
3791 },
3792 {
3793 .max = 7,
3794 .types = BIT(NL80211_IFTYPE_AP)
3795 },
3796 };
3797
3798 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
3799 {
3800 .max = 8,
3801 .types = BIT(NL80211_IFTYPE_AP)
3802 },
3803 };
3804
3805 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
3806 {
3807 .limits = ath10k_if_limits,
3808 .n_limits = ARRAY_SIZE(ath10k_if_limits),
3809 .max_interfaces = 8,
3810 .num_different_channels = 1,
3811 .beacon_int_infra_match = true,
3812 },
3813 };
3814
3815 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
3816 {
3817 .limits = ath10k_10x_if_limits,
3818 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
3819 .max_interfaces = 8,
3820 .num_different_channels = 1,
3821 .beacon_int_infra_match = true,
3822 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
3823 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
3824 BIT(NL80211_CHAN_WIDTH_20) |
3825 BIT(NL80211_CHAN_WIDTH_40) |
3826 BIT(NL80211_CHAN_WIDTH_80),
3827 #endif
3828 },
3829 };
3830
3831 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3832 {
3833 struct ieee80211_sta_vht_cap vht_cap = {0};
3834 u16 mcs_map;
3835 int i;
3836
3837 vht_cap.vht_supported = 1;
3838 vht_cap.cap = ar->vht_cap_info;
3839
3840 mcs_map = 0;
3841 for (i = 0; i < 8; i++) {
3842 if (i < ar->num_rf_chains)
3843 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
3844 else
3845 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
3846 }
3847
3848 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3849 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3850
3851 return vht_cap;
3852 }
3853
3854 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3855 {
3856 int i;
3857 struct ieee80211_sta_ht_cap ht_cap = {0};
3858
3859 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3860 return ht_cap;
3861
3862 ht_cap.ht_supported = 1;
3863 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3864 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3865 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3866 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3867 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
3868
3869 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3870 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3871
3872 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3873 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3874
3875 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3876 u32 smps;
3877
3878 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3879 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3880
3881 ht_cap.cap |= smps;
3882 }
3883
3884 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3885 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3886
3887 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3888 u32 stbc;
3889
3890 stbc = ar->ht_cap_info;
3891 stbc &= WMI_HT_CAP_RX_STBC;
3892 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3893 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3894 stbc &= IEEE80211_HT_CAP_RX_STBC;
3895
3896 ht_cap.cap |= stbc;
3897 }
3898
3899 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3900 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3901
3902 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3903 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3904
3905 /* max AMSDU is implicitly taken from vht_cap_info */
3906 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3907 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3908
3909 for (i = 0; i < ar->num_rf_chains; i++)
3910 ht_cap.mcs.rx_mask[i] = 0xFF;
3911
3912 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3913
3914 return ht_cap;
3915 }
3916
3917
3918 static void ath10k_get_arvif_iter(void *data, u8 *mac,
3919 struct ieee80211_vif *vif)
3920 {
3921 struct ath10k_vif_iter *arvif_iter = data;
3922 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3923
3924 if (arvif->vdev_id == arvif_iter->vdev_id)
3925 arvif_iter->arvif = arvif;
3926 }
3927
3928 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
3929 {
3930 struct ath10k_vif_iter arvif_iter;
3931 u32 flags;
3932
3933 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
3934 arvif_iter.vdev_id = vdev_id;
3935
3936 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
3937 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3938 flags,
3939 ath10k_get_arvif_iter,
3940 &arvif_iter);
3941 if (!arvif_iter.arvif) {
3942 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
3943 return NULL;
3944 }
3945
3946 return arvif_iter.arvif;
3947 }
3948
3949 int ath10k_mac_register(struct ath10k *ar)
3950 {
3951 struct ieee80211_supported_band *band;
3952 struct ieee80211_sta_vht_cap vht_cap;
3953 struct ieee80211_sta_ht_cap ht_cap;
3954 void *channels;
3955 int ret;
3956
3957 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
3958
3959 SET_IEEE80211_DEV(ar->hw, ar->dev);
3960
3961 ht_cap = ath10k_get_ht_cap(ar);
3962 vht_cap = ath10k_create_vht_cap(ar);
3963
3964 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3965 channels = kmemdup(ath10k_2ghz_channels,
3966 sizeof(ath10k_2ghz_channels),
3967 GFP_KERNEL);
3968 if (!channels) {
3969 ret = -ENOMEM;
3970 goto err_free;
3971 }
3972
3973 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3974 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
3975 band->channels = channels;
3976 band->n_bitrates = ath10k_g_rates_size;
3977 band->bitrates = ath10k_g_rates;
3978 band->ht_cap = ht_cap;
3979
3980 /* vht is not supported in 2.4 GHz */
3981
3982 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
3983 }
3984
3985 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3986 channels = kmemdup(ath10k_5ghz_channels,
3987 sizeof(ath10k_5ghz_channels),
3988 GFP_KERNEL);
3989 if (!channels) {
3990 ret = -ENOMEM;
3991 goto err_free;
3992 }
3993
3994 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3995 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
3996 band->channels = channels;
3997 band->n_bitrates = ath10k_a_rates_size;
3998 band->bitrates = ath10k_a_rates;
3999 band->ht_cap = ht_cap;
4000 band->vht_cap = vht_cap;
4001 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4002 }
4003
4004 ar->hw->wiphy->interface_modes =
4005 BIT(NL80211_IFTYPE_STATION) |
4006 BIT(NL80211_IFTYPE_ADHOC) |
4007 BIT(NL80211_IFTYPE_AP);
4008
4009 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4010 ar->hw->wiphy->interface_modes |=
4011 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4012 BIT(NL80211_IFTYPE_P2P_GO);
4013
4014 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4015 IEEE80211_HW_SUPPORTS_PS |
4016 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4017 IEEE80211_HW_SUPPORTS_UAPSD |
4018 IEEE80211_HW_MFP_CAPABLE |
4019 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4020 IEEE80211_HW_HAS_RATE_CONTROL |
4021 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
4022 IEEE80211_HW_WANT_MONITOR_VIF |
4023 IEEE80211_HW_AP_LINK_PS;
4024
4025 /* MSDU can have HTT TX fragment pushed in front. The additional 4
4026 * bytes is used for padding/alignment if necessary. */
4027 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4028
4029 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4030 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
4031
4032 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4033 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4034 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4035 }
4036
4037 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4038 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4039
4040 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4041
4042 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4043
4044 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4045 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4046
4047 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4048 /*
4049 * on LL hardware queues are managed entirely by the FW
4050 * so we only advertise to mac we can do the queues thing
4051 */
4052 ar->hw->queues = 4;
4053
4054 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4055 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4056 ar->hw->wiphy->n_iface_combinations =
4057 ARRAY_SIZE(ath10k_10x_if_comb);
4058 } else {
4059 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4060 ar->hw->wiphy->n_iface_combinations =
4061 ARRAY_SIZE(ath10k_if_comb);
4062 }
4063
4064 ar->hw->netdev_features = NETIF_F_HW_CSUM;
4065
4066 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4067 /* Init ath dfs pattern detector */
4068 ar->ath_common.debug_mask = ATH_DBG_DFS;
4069 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4070 NL80211_DFS_UNSET);
4071
4072 if (!ar->dfs_detector)
4073 ath10k_warn("dfs pattern detector init failed\n");
4074 }
4075
4076 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4077 ath10k_reg_notifier);
4078 if (ret) {
4079 ath10k_err("Regulatory initialization failed\n");
4080 goto err_free;
4081 }
4082
4083 ret = ieee80211_register_hw(ar->hw);
4084 if (ret) {
4085 ath10k_err("ieee80211 registration failed: %d\n", ret);
4086 goto err_free;
4087 }
4088
4089 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4090 ret = regulatory_hint(ar->hw->wiphy,
4091 ar->ath_common.regulatory.alpha2);
4092 if (ret)
4093 goto err_unregister;
4094 }
4095
4096 return 0;
4097
4098 err_unregister:
4099 ieee80211_unregister_hw(ar->hw);
4100 err_free:
4101 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4102 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4103
4104 return ret;
4105 }
4106
4107 void ath10k_mac_unregister(struct ath10k *ar)
4108 {
4109 ieee80211_unregister_hw(ar->hw);
4110
4111 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4112 ar->dfs_detector->exit(ar->dfs_detector);
4113
4114 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4115 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4116
4117 SET_IEEE80211_DEV(ar->hw, NULL);
4118 }
Linux with added FPC-III support