?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.11-rc3
[cris-mirror.git] / drivers / net / wireless / ath / ath10k / mac.c
blobda5c333d0d4bc434a4ef04e0606b982428549430
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 "core.h"
24 #include "debug.h"
25 #include "wmi.h"
26 #include "htt.h"
27 #include "txrx.h"
28
29 /**********/
30 /* Crypto */
31 /**********/
32
33 static int ath10k_send_key(struct ath10k_vif *arvif,
34 struct ieee80211_key_conf *key,
35 enum set_key_cmd cmd,
36 const u8 *macaddr)
37 {
38 struct wmi_vdev_install_key_arg arg = {
39 .vdev_id = arvif->vdev_id,
40 .key_idx = key->keyidx,
41 .key_len = key->keylen,
42 .key_data = key->key,
43 .macaddr = macaddr,
44 };
45
46 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
47 arg.key_flags = WMI_KEY_PAIRWISE;
48 else
49 arg.key_flags = WMI_KEY_GROUP;
50
51 switch (key->cipher) {
52 case WLAN_CIPHER_SUITE_CCMP:
53 arg.key_cipher = WMI_CIPHER_AES_CCM;
54 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
55 break;
56 case WLAN_CIPHER_SUITE_TKIP:
57 arg.key_cipher = WMI_CIPHER_TKIP;
58 arg.key_txmic_len = 8;
59 arg.key_rxmic_len = 8;
60 break;
61 case WLAN_CIPHER_SUITE_WEP40:
62 case WLAN_CIPHER_SUITE_WEP104:
63 arg.key_cipher = WMI_CIPHER_WEP;
64 /* AP/IBSS mode requires self-key to be groupwise
65 * Otherwise pairwise key must be set */
66 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
67 arg.key_flags = WMI_KEY_PAIRWISE;
68 break;
69 default:
70 ath10k_warn("cipher %d is not supported\n", key->cipher);
71 return -EOPNOTSUPP;
72 }
73
74 if (cmd == DISABLE_KEY) {
75 arg.key_cipher = WMI_CIPHER_NONE;
76 arg.key_data = NULL;
77 }
78
79 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
80 }
81
82 static int ath10k_install_key(struct ath10k_vif *arvif,
83 struct ieee80211_key_conf *key,
84 enum set_key_cmd cmd,
85 const u8 *macaddr)
86 {
87 struct ath10k *ar = arvif->ar;
88 int ret;
89
90 INIT_COMPLETION(ar->install_key_done);
91
92 ret = ath10k_send_key(arvif, key, cmd, macaddr);
93 if (ret)
94 return ret;
95
96 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
97 if (ret == 0)
98 return -ETIMEDOUT;
99
100 return 0;
101 }
102
103 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
104 const u8 *addr)
105 {
106 struct ath10k *ar = arvif->ar;
107 struct ath10k_peer *peer;
108 int ret;
109 int i;
110
111 lockdep_assert_held(&ar->conf_mutex);
112
113 spin_lock_bh(&ar->data_lock);
114 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
115 spin_unlock_bh(&ar->data_lock);
116
117 if (!peer)
118 return -ENOENT;
119
120 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
121 if (arvif->wep_keys[i] == NULL)
122 continue;
123
124 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
125 addr);
126 if (ret)
127 return ret;
128
129 peer->keys[i] = arvif->wep_keys[i];
130 }
131
132 return 0;
133 }
134
135 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
136 const u8 *addr)
137 {
138 struct ath10k *ar = arvif->ar;
139 struct ath10k_peer *peer;
140 int first_errno = 0;
141 int ret;
142 int i;
143
144 lockdep_assert_held(&ar->conf_mutex);
145
146 spin_lock_bh(&ar->data_lock);
147 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
148 spin_unlock_bh(&ar->data_lock);
149
150 if (!peer)
151 return -ENOENT;
152
153 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
154 if (peer->keys[i] == NULL)
155 continue;
156
157 ret = ath10k_install_key(arvif, peer->keys[i],
158 DISABLE_KEY, addr);
159 if (ret && first_errno == 0)
160 first_errno = ret;
161
162 if (ret)
163 ath10k_warn("could not remove peer wep key %d (%d)\n",
164 i, ret);
165
166 peer->keys[i] = NULL;
167 }
168
169 return first_errno;
170 }
171
172 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
173 struct ieee80211_key_conf *key)
174 {
175 struct ath10k *ar = arvif->ar;
176 struct ath10k_peer *peer;
177 u8 addr[ETH_ALEN];
178 int first_errno = 0;
179 int ret;
180 int i;
181
182 lockdep_assert_held(&ar->conf_mutex);
183
184 for (;;) {
185 /* since ath10k_install_key we can't hold data_lock all the
186 * time, so we try to remove the keys incrementally */
187 spin_lock_bh(&ar->data_lock);
188 i = 0;
189 list_for_each_entry(peer, &ar->peers, list) {
190 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
191 if (peer->keys[i] == key) {
192 memcpy(addr, peer->addr, ETH_ALEN);
193 peer->keys[i] = NULL;
194 break;
195 }
196 }
197
198 if (i < ARRAY_SIZE(peer->keys))
199 break;
200 }
201 spin_unlock_bh(&ar->data_lock);
202
203 if (i == ARRAY_SIZE(peer->keys))
204 break;
205
206 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
207 if (ret && first_errno == 0)
208 first_errno = ret;
209
210 if (ret)
211 ath10k_warn("could not remove key for %pM\n", addr);
212 }
213
214 return first_errno;
215 }
216
217
218 /*********************/
219 /* General utilities */
220 /*********************/
221
222 static inline enum wmi_phy_mode
223 chan_to_phymode(const struct cfg80211_chan_def *chandef)
224 {
225 enum wmi_phy_mode phymode = MODE_UNKNOWN;
226
227 switch (chandef->chan->band) {
228 case IEEE80211_BAND_2GHZ:
229 switch (chandef->width) {
230 case NL80211_CHAN_WIDTH_20_NOHT:
231 phymode = MODE_11G;
232 break;
233 case NL80211_CHAN_WIDTH_20:
234 phymode = MODE_11NG_HT20;
235 break;
236 case NL80211_CHAN_WIDTH_40:
237 phymode = MODE_11NG_HT40;
238 break;
239 case NL80211_CHAN_WIDTH_5:
240 case NL80211_CHAN_WIDTH_10:
241 case NL80211_CHAN_WIDTH_80:
242 case NL80211_CHAN_WIDTH_80P80:
243 case NL80211_CHAN_WIDTH_160:
244 phymode = MODE_UNKNOWN;
245 break;
246 }
247 break;
248 case IEEE80211_BAND_5GHZ:
249 switch (chandef->width) {
250 case NL80211_CHAN_WIDTH_20_NOHT:
251 phymode = MODE_11A;
252 break;
253 case NL80211_CHAN_WIDTH_20:
254 phymode = MODE_11NA_HT20;
255 break;
256 case NL80211_CHAN_WIDTH_40:
257 phymode = MODE_11NA_HT40;
258 break;
259 case NL80211_CHAN_WIDTH_80:
260 phymode = MODE_11AC_VHT80;
261 break;
262 case NL80211_CHAN_WIDTH_5:
263 case NL80211_CHAN_WIDTH_10:
264 case NL80211_CHAN_WIDTH_80P80:
265 case NL80211_CHAN_WIDTH_160:
266 phymode = MODE_UNKNOWN;
267 break;
268 }
269 break;
270 default:
271 break;
272 }
273
274 WARN_ON(phymode == MODE_UNKNOWN);
275 return phymode;
276 }
277
278 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
279 {
280 /*
281 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
282 * 0 for no restriction
283 * 1 for 1/4 us
284 * 2 for 1/2 us
285 * 3 for 1 us
286 * 4 for 2 us
287 * 5 for 4 us
288 * 6 for 8 us
289 * 7 for 16 us
290 */
291 switch (mpdudensity) {
292 case 0:
293 return 0;
294 case 1:
295 case 2:
296 case 3:
297 /* Our lower layer calculations limit our precision to
298 1 microsecond */
299 return 1;
300 case 4:
301 return 2;
302 case 5:
303 return 4;
304 case 6:
305 return 8;
306 case 7:
307 return 16;
308 default:
309 return 0;
310 }
311 }
312
313 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
314 {
315 int ret;
316
317 lockdep_assert_held(&ar->conf_mutex);
318
319 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
320 if (ret)
321 return ret;
322
323 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
324 if (ret)
325 return ret;
326
327 return 0;
328 }
329
330 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
331 {
332 int ret;
333
334 lockdep_assert_held(&ar->conf_mutex);
335
336 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
337 if (ret)
338 return ret;
339
340 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
341 if (ret)
342 return ret;
343
344 return 0;
345 }
346
347 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
348 {
349 struct ath10k_peer *peer, *tmp;
350
351 lockdep_assert_held(&ar->conf_mutex);
352
353 spin_lock_bh(&ar->data_lock);
354 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
355 if (peer->vdev_id != vdev_id)
356 continue;
357
358 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
359 peer->addr, vdev_id);
360
361 list_del(&peer->list);
362 kfree(peer);
363 }
364 spin_unlock_bh(&ar->data_lock);
365 }
366
367 /************************/
368 /* Interface management */
369 /************************/
370
371 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
372 {
373 int ret;
374
375 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
376 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
377 if (ret == 0)
378 return -ETIMEDOUT;
379
380 return 0;
381 }
382
383 static int ath10k_vdev_start(struct ath10k_vif *arvif)
384 {
385 struct ath10k *ar = arvif->ar;
386 struct ieee80211_conf *conf = &ar->hw->conf;
387 struct ieee80211_channel *channel = conf->chandef.chan;
388 struct wmi_vdev_start_request_arg arg = {};
389 int ret = 0;
390
391 lockdep_assert_held(&ar->conf_mutex);
392
393 INIT_COMPLETION(ar->vdev_setup_done);
394
395 arg.vdev_id = arvif->vdev_id;
396 arg.dtim_period = arvif->dtim_period;
397 arg.bcn_intval = arvif->beacon_interval;
398
399 arg.channel.freq = channel->center_freq;
400
401 arg.channel.band_center_freq1 = conf->chandef.center_freq1;
402
403 arg.channel.mode = chan_to_phymode(&conf->chandef);
404
405 arg.channel.min_power = channel->max_power * 3;
406 arg.channel.max_power = channel->max_power * 4;
407 arg.channel.max_reg_power = channel->max_reg_power * 4;
408 arg.channel.max_antenna_gain = channel->max_antenna_gain;
409
410 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
411 arg.ssid = arvif->u.ap.ssid;
412 arg.ssid_len = arvif->u.ap.ssid_len;
413 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
414 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
415 arg.ssid = arvif->vif->bss_conf.ssid;
416 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
417 }
418
419 ret = ath10k_wmi_vdev_start(ar, &arg);
420 if (ret) {
421 ath10k_warn("WMI vdev start failed: ret %d\n", ret);
422 return ret;
423 }
424
425 ret = ath10k_vdev_setup_sync(ar);
426 if (ret) {
427 ath10k_warn("vdev setup failed %d\n", ret);
428 return ret;
429 }
430
431 return ret;
432 }
433
434 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
435 {
436 struct ath10k *ar = arvif->ar;
437 int ret;
438
439 lockdep_assert_held(&ar->conf_mutex);
440
441 INIT_COMPLETION(ar->vdev_setup_done);
442
443 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
444 if (ret) {
445 ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
446 return ret;
447 }
448
449 ret = ath10k_vdev_setup_sync(ar);
450 if (ret) {
451 ath10k_warn("vdev setup failed %d\n", ret);
452 return ret;
453 }
454
455 return ret;
456 }
457
458 static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)
459 {
460 struct ieee80211_channel *channel = ar->hw->conf.chandef.chan;
461 struct wmi_vdev_start_request_arg arg = {};
462 enum nl80211_channel_type type;
463 int ret = 0;
464
465 lockdep_assert_held(&ar->conf_mutex);
466
467 type = cfg80211_get_chandef_type(&ar->hw->conf.chandef);
468
469 arg.vdev_id = vdev_id;
470 arg.channel.freq = channel->center_freq;
471 arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1;
472
473 /* TODO setup this dynamically, what in case we
474 don't have any vifs? */
475 arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef);
476
477 arg.channel.min_power = channel->max_power * 3;
478 arg.channel.max_power = channel->max_power * 4;
479 arg.channel.max_reg_power = channel->max_reg_power * 4;
480 arg.channel.max_antenna_gain = channel->max_antenna_gain;
481
482 ret = ath10k_wmi_vdev_start(ar, &arg);
483 if (ret) {
484 ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
485 return ret;
486 }
487
488 ret = ath10k_vdev_setup_sync(ar);
489 if (ret) {
490 ath10k_warn("Monitor vdev setup failed %d\n", ret);
491 return ret;
492 }
493
494 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
495 if (ret) {
496 ath10k_warn("Monitor vdev up failed: %d\n", ret);
497 goto vdev_stop;
498 }
499
500 ar->monitor_vdev_id = vdev_id;
501 ar->monitor_enabled = true;
502
503 return 0;
504
505 vdev_stop:
506 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
507 if (ret)
508 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
509
510 return ret;
511 }
512
513 static int ath10k_monitor_stop(struct ath10k *ar)
514 {
515 int ret = 0;
516
517 lockdep_assert_held(&ar->conf_mutex);
518
519 /* For some reasons, ath10k_wmi_vdev_down() here couse
520 * often ath10k_wmi_vdev_stop() to fail. Next we could
521 * not run monitor vdev and driver reload
522 * required. Don't see such problems we skip
523 * ath10k_wmi_vdev_down() here.
524 */
525
526 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
527 if (ret)
528 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
529
530 ret = ath10k_vdev_setup_sync(ar);
531 if (ret)
532 ath10k_warn("Monitor_down sync failed: %d\n", ret);
533
534 ar->monitor_enabled = false;
535 return ret;
536 }
537
538 static int ath10k_monitor_create(struct ath10k *ar)
539 {
540 int bit, ret = 0;
541
542 lockdep_assert_held(&ar->conf_mutex);
543
544 if (ar->monitor_present) {
545 ath10k_warn("Monitor mode already enabled\n");
546 return 0;
547 }
548
549 bit = ffs(ar->free_vdev_map);
550 if (bit == 0) {
551 ath10k_warn("No free VDEV slots\n");
552 return -ENOMEM;
553 }
554
555 ar->monitor_vdev_id = bit - 1;
556 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
557
558 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
559 WMI_VDEV_TYPE_MONITOR,
560 0, ar->mac_addr);
561 if (ret) {
562 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
563 goto vdev_fail;
564 }
565
566 ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface created, vdev id: %d\n",
567 ar->monitor_vdev_id);
568
569 ar->monitor_present = true;
570 return 0;
571
572 vdev_fail:
573 /*
574 * Restore the ID to the global map.
575 */
576 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
577 return ret;
578 }
579
580 static int ath10k_monitor_destroy(struct ath10k *ar)
581 {
582 int ret = 0;
583
584 lockdep_assert_held(&ar->conf_mutex);
585
586 if (!ar->monitor_present)
587 return 0;
588
589 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
590 if (ret) {
591 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret);
592 return ret;
593 }
594
595 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
596 ar->monitor_present = false;
597
598 ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface destroyed, vdev id: %d\n",
599 ar->monitor_vdev_id);
600 return ret;
601 }
602
603 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
604 struct ieee80211_bss_conf *info)
605 {
606 int ret = 0;
607
608 if (!info->enable_beacon) {
609 ath10k_vdev_stop(arvif);
610 return;
611 }
612
613 arvif->tx_seq_no = 0x1000;
614
615 ret = ath10k_vdev_start(arvif);
616 if (ret)
617 return;
618
619 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
620 if (ret) {
621 ath10k_warn("Failed to bring up VDEV: %d\n",
622 arvif->vdev_id);
623 return;
624 }
625 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d up\n", arvif->vdev_id);
626 }
627
628 static void ath10k_control_ibss(struct ath10k_vif *arvif,
629 struct ieee80211_bss_conf *info,
630 const u8 self_peer[ETH_ALEN])
631 {
632 int ret = 0;
633
634 if (!info->ibss_joined) {
635 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
636 if (ret)
637 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
638 self_peer, arvif->vdev_id, ret);
639
640 if (is_zero_ether_addr(arvif->u.ibss.bssid))
641 return;
642
643 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
644 arvif->u.ibss.bssid);
645 if (ret) {
646 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
647 arvif->u.ibss.bssid, arvif->vdev_id, ret);
648 return;
649 }
650
651 memset(arvif->u.ibss.bssid, 0, ETH_ALEN);
652
653 return;
654 }
655
656 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
657 if (ret) {
658 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
659 self_peer, arvif->vdev_id, ret);
660 return;
661 }
662
663 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
664 WMI_VDEV_PARAM_ATIM_WINDOW,
665 ATH10K_DEFAULT_ATIM);
666 if (ret)
667 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
668 arvif->vdev_id, ret);
669 }
670
671 /*
672 * Review this when mac80211 gains per-interface powersave support.
673 */
674 static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
675 {
676 struct ath10k_generic_iter *ar_iter = data;
677 struct ieee80211_conf *conf = &ar_iter->ar->hw->conf;
678 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
679 enum wmi_sta_powersave_param param;
680 enum wmi_sta_ps_mode psmode;
681 int ret;
682
683 if (vif->type != NL80211_IFTYPE_STATION)
684 return;
685
686 if (conf->flags & IEEE80211_CONF_PS) {
687 psmode = WMI_STA_PS_MODE_ENABLED;
688 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
689
690 ret = ath10k_wmi_set_sta_ps_param(ar_iter->ar,
691 arvif->vdev_id,
692 param,
693 conf->dynamic_ps_timeout);
694 if (ret) {
695 ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
696 arvif->vdev_id);
697 return;
698 }
699
700 ar_iter->ret = ret;
701 } else {
702 psmode = WMI_STA_PS_MODE_DISABLED;
703 }
704
705 ar_iter->ret = ath10k_wmi_set_psmode(ar_iter->ar, arvif->vdev_id,
706 psmode);
707 if (ar_iter->ret)
708 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
709 psmode, arvif->vdev_id);
710 else
711 ath10k_dbg(ATH10K_DBG_MAC, "Set PS Mode: %d for VDEV: %d\n",
712 psmode, arvif->vdev_id);
713 }
714
715 /**********************/
716 /* Station management */
717 /**********************/
718
719 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
720 struct ath10k_vif *arvif,
721 struct ieee80211_sta *sta,
722 struct ieee80211_bss_conf *bss_conf,
723 struct wmi_peer_assoc_complete_arg *arg)
724 {
725 memcpy(arg->addr, sta->addr, ETH_ALEN);
726 arg->vdev_id = arvif->vdev_id;
727 arg->peer_aid = sta->aid;
728 arg->peer_flags |= WMI_PEER_AUTH;
729
730 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
731 /*
732 * Seems FW have problems with Power Save in STA
733 * mode when we setup this parameter to high (eg. 5).
734 * Often we see that FW don't send NULL (with clean P flags)
735 * frame even there is info about buffered frames in beacons.
736 * Sometimes we have to wait more than 10 seconds before FW
737 * will wakeup. Often sending one ping from AP to our device
738 * just fail (more than 50%).
739 *
740 * Seems setting this FW parameter to 1 couse FW
741 * will check every beacon and will wakup immediately
742 * after detection buffered data.
743 */
744 arg->peer_listen_intval = 1;
745 else
746 arg->peer_listen_intval = ar->hw->conf.listen_interval;
747
748 arg->peer_num_spatial_streams = 1;
749
750 /*
751 * The assoc capabilities are available only in managed mode.
752 */
753 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
754 arg->peer_caps = bss_conf->assoc_capability;
755 }
756
757 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
758 struct ath10k_vif *arvif,
759 struct wmi_peer_assoc_complete_arg *arg)
760 {
761 struct ieee80211_vif *vif = arvif->vif;
762 struct ieee80211_bss_conf *info = &vif->bss_conf;
763 struct cfg80211_bss *bss;
764 const u8 *rsnie = NULL;
765 const u8 *wpaie = NULL;
766
767 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
768 info->bssid, NULL, 0, 0, 0);
769 if (bss) {
770 const struct cfg80211_bss_ies *ies;
771
772 rcu_read_lock();
773 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
774
775 ies = rcu_dereference(bss->ies);
776
777 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
778 WLAN_OUI_TYPE_MICROSOFT_WPA,
779 ies->data,
780 ies->len);
781 rcu_read_unlock();
782 cfg80211_put_bss(ar->hw->wiphy, bss);
783 }
784
785 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
786 if (rsnie || wpaie) {
787 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
788 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
789 }
790
791 if (wpaie) {
792 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
793 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
794 }
795 }
796
797 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
798 struct ieee80211_sta *sta,
799 struct wmi_peer_assoc_complete_arg *arg)
800 {
801 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
802 const struct ieee80211_supported_band *sband;
803 const struct ieee80211_rate *rates;
804 u32 ratemask;
805 int i;
806
807 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
808 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
809 rates = sband->bitrates;
810
811 rateset->num_rates = 0;
812
813 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
814 if (!(ratemask & 1))
815 continue;
816
817 rateset->rates[rateset->num_rates] = rates->hw_value;
818 rateset->num_rates++;
819 }
820 }
821
822 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
823 struct ieee80211_sta *sta,
824 struct wmi_peer_assoc_complete_arg *arg)
825 {
826 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
827 int smps;
828 int i, n;
829
830 if (!ht_cap->ht_supported)
831 return;
832
833 arg->peer_flags |= WMI_PEER_HT;
834 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
835 ht_cap->ampdu_factor)) - 1;
836
837 arg->peer_mpdu_density =
838 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
839
840 arg->peer_ht_caps = ht_cap->cap;
841 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
842
843 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
844 arg->peer_flags |= WMI_PEER_LDPC;
845
846 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
847 arg->peer_flags |= WMI_PEER_40MHZ;
848 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
849 }
850
851 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
852 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
853
854 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
855 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
856
857 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
858 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
859 arg->peer_flags |= WMI_PEER_STBC;
860 }
861
862 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
863 u32 stbc;
864 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
865 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
866 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
867 arg->peer_rate_caps |= stbc;
868 arg->peer_flags |= WMI_PEER_STBC;
869 }
870
871 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
872 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
873
874 if (smps == WLAN_HT_CAP_SM_PS_STATIC) {
875 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
876 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS;
877 } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) {
878 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
879 arg->peer_flags |= WMI_PEER_DYN_MIMOPS;
880 }
881
882 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
883 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
884 else if (ht_cap->mcs.rx_mask[1])
885 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
886
887 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
888 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
889 arg->peer_ht_rates.rates[n++] = i;
890
891 arg->peer_ht_rates.num_rates = n;
892 arg->peer_num_spatial_streams = max((n+7) / 8, 1);
893
894 ath10k_dbg(ATH10K_DBG_MAC, "mcs cnt %d nss %d\n",
895 arg->peer_ht_rates.num_rates,
896 arg->peer_num_spatial_streams);
897 }
898
899 static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
900 struct ath10k_vif *arvif,
901 struct ieee80211_sta *sta,
902 struct ieee80211_bss_conf *bss_conf,
903 struct wmi_peer_assoc_complete_arg *arg)
904 {
905 u32 uapsd = 0;
906 u32 max_sp = 0;
907
908 if (sta->wme)
909 arg->peer_flags |= WMI_PEER_QOS;
910
911 if (sta->wme && sta->uapsd_queues) {
912 ath10k_dbg(ATH10K_DBG_MAC, "uapsd_queues: 0x%X, max_sp: %d\n",
913 sta->uapsd_queues, sta->max_sp);
914
915 arg->peer_flags |= WMI_PEER_APSD;
916 arg->peer_flags |= WMI_RC_UAPSD_FLAG;
917
918 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
919 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
920 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
921 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
922 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
923 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
924 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
925 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
926 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
927 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
928 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
929 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
930
931
932 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
933 max_sp = sta->max_sp;
934
935 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
936 sta->addr,
937 WMI_AP_PS_PEER_PARAM_UAPSD,
938 uapsd);
939
940 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
941 sta->addr,
942 WMI_AP_PS_PEER_PARAM_MAX_SP,
943 max_sp);
944
945 /* TODO setup this based on STA listen interval and
946 beacon interval. Currently we don't know
947 sta->listen_interval - mac80211 patch required.
948 Currently use 10 seconds */
949 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
950 sta->addr,
951 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
952 10);
953 }
954 }
955
956 static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar,
957 struct ath10k_vif *arvif,
958 struct ieee80211_sta *sta,
959 struct ieee80211_bss_conf *bss_conf,
960 struct wmi_peer_assoc_complete_arg *arg)
961 {
962 if (bss_conf->qos)
963 arg->peer_flags |= WMI_PEER_QOS;
964 }
965
966 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
967 struct ieee80211_sta *sta,
968 struct wmi_peer_assoc_complete_arg *arg)
969 {
970 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
971
972 if (!vht_cap->vht_supported)
973 return;
974
975 arg->peer_flags |= WMI_PEER_VHT;
976
977 arg->peer_vht_caps = vht_cap->cap;
978
979 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
980 arg->peer_flags |= WMI_PEER_80MHZ;
981
982 arg->peer_vht_rates.rx_max_rate =
983 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
984 arg->peer_vht_rates.rx_mcs_set =
985 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
986 arg->peer_vht_rates.tx_max_rate =
987 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
988 arg->peer_vht_rates.tx_mcs_set =
989 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
990
991 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer\n");
992 }
993
994 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
995 struct ath10k_vif *arvif,
996 struct ieee80211_sta *sta,
997 struct ieee80211_bss_conf *bss_conf,
998 struct wmi_peer_assoc_complete_arg *arg)
999 {
1000 switch (arvif->vdev_type) {
1001 case WMI_VDEV_TYPE_AP:
1002 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg);
1003 break;
1004 case WMI_VDEV_TYPE_STA:
1005 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg);
1006 break;
1007 default:
1008 break;
1009 }
1010 }
1011
1012 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1013 struct ath10k_vif *arvif,
1014 struct ieee80211_sta *sta,
1015 struct wmi_peer_assoc_complete_arg *arg)
1016 {
1017 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1018
1019 /* FIXME: add VHT */
1020
1021 switch (ar->hw->conf.chandef.chan->band) {
1022 case IEEE80211_BAND_2GHZ:
1023 if (sta->ht_cap.ht_supported) {
1024 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1025 phymode = MODE_11NG_HT40;
1026 else
1027 phymode = MODE_11NG_HT20;
1028 } else {
1029 phymode = MODE_11G;
1030 }
1031
1032 break;
1033 case IEEE80211_BAND_5GHZ:
1034 if (sta->ht_cap.ht_supported) {
1035 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1036 phymode = MODE_11NA_HT40;
1037 else
1038 phymode = MODE_11NA_HT20;
1039 } else {
1040 phymode = MODE_11A;
1041 }
1042
1043 break;
1044 default:
1045 break;
1046 }
1047
1048 arg->peer_phymode = phymode;
1049 WARN_ON(phymode == MODE_UNKNOWN);
1050 }
1051
1052 static int ath10k_peer_assoc(struct ath10k *ar,
1053 struct ath10k_vif *arvif,
1054 struct ieee80211_sta *sta,
1055 struct ieee80211_bss_conf *bss_conf)
1056 {
1057 struct wmi_peer_assoc_complete_arg arg;
1058
1059 memset(&arg, 0, sizeof(struct wmi_peer_assoc_complete_arg));
1060
1061 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, &arg);
1062 ath10k_peer_assoc_h_crypto(ar, arvif, &arg);
1063 ath10k_peer_assoc_h_rates(ar, sta, &arg);
1064 ath10k_peer_assoc_h_ht(ar, sta, &arg);
1065 ath10k_peer_assoc_h_vht(ar, sta, &arg);
1066 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, &arg);
1067 ath10k_peer_assoc_h_phymode(ar, arvif, sta, &arg);
1068
1069 return ath10k_wmi_peer_assoc(ar, &arg);
1070 }
1071
1072 /* can be called only in mac80211 callbacks due to `key_count` usage */
1073 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1074 struct ieee80211_vif *vif,
1075 struct ieee80211_bss_conf *bss_conf)
1076 {
1077 struct ath10k *ar = hw->priv;
1078 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1079 struct ieee80211_sta *ap_sta;
1080 int ret;
1081
1082 rcu_read_lock();
1083
1084 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1085 if (!ap_sta) {
1086 ath10k_warn("Failed to find station entry for %pM\n",
1087 bss_conf->bssid);
1088 rcu_read_unlock();
1089 return;
1090 }
1091
1092 ret = ath10k_peer_assoc(ar, arvif, ap_sta, bss_conf);
1093 if (ret) {
1094 ath10k_warn("Peer assoc failed for %pM\n", bss_conf->bssid);
1095 rcu_read_unlock();
1096 return;
1097 }
1098
1099 rcu_read_unlock();
1100
1101 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
1102 bss_conf->bssid);
1103 if (ret)
1104 ath10k_warn("VDEV: %d up failed: ret %d\n",
1105 arvif->vdev_id, ret);
1106 else
1107 ath10k_dbg(ATH10K_DBG_MAC,
1108 "VDEV: %d associated, BSSID: %pM, AID: %d\n",
1109 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1110 }
1111
1112 /*
1113 * FIXME: flush TIDs
1114 */
1115 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1116 struct ieee80211_vif *vif)
1117 {
1118 struct ath10k *ar = hw->priv;
1119 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1120 int ret;
1121
1122 /*
1123 * For some reason, calling VDEV-DOWN before VDEV-STOP
1124 * makes the FW to send frames via HTT after disassociation.
1125 * No idea why this happens, even though VDEV-DOWN is supposed
1126 * to be analogous to link down, so just stop the VDEV.
1127 */
1128 ret = ath10k_vdev_stop(arvif);
1129 if (!ret)
1130 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d stopped\n",
1131 arvif->vdev_id);
1132
1133 /*
1134 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1135 * report beacons from previously associated network through HTT.
1136 * This in turn would spam mac80211 WARN_ON if we bring down all
1137 * interfaces as it expects there is no rx when no interface is
1138 * running.
1139 */
1140 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1141 if (ret)
1142 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n",
1143 arvif->vdev_id, ret);
1144
1145 ath10k_wmi_flush_tx(ar);
1146
1147 arvif->def_wep_key_index = 0;
1148 }
1149
1150 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1151 struct ieee80211_sta *sta)
1152 {
1153 int ret = 0;
1154
1155 ret = ath10k_peer_assoc(ar, arvif, sta, NULL);
1156 if (ret) {
1157 ath10k_warn("WMI peer assoc failed for %pM\n", sta->addr);
1158 return ret;
1159 }
1160
1161 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1162 if (ret) {
1163 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1164 return ret;
1165 }
1166
1167 return ret;
1168 }
1169
1170 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1171 struct ieee80211_sta *sta)
1172 {
1173 int ret = 0;
1174
1175 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1176 if (ret) {
1177 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1178 return ret;
1179 }
1180
1181 return ret;
1182 }
1183
1184 /**************/
1185 /* Regulatory */
1186 /**************/
1187
1188 static int ath10k_update_channel_list(struct ath10k *ar)
1189 {
1190 struct ieee80211_hw *hw = ar->hw;
1191 struct ieee80211_supported_band **bands;
1192 enum ieee80211_band band;
1193 struct ieee80211_channel *channel;
1194 struct wmi_scan_chan_list_arg arg = {0};
1195 struct wmi_channel_arg *ch;
1196 bool passive;
1197 int len;
1198 int ret;
1199 int i;
1200
1201 bands = hw->wiphy->bands;
1202 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1203 if (!bands[band])
1204 continue;
1205
1206 for (i = 0; i < bands[band]->n_channels; i++) {
1207 if (bands[band]->channels[i].flags &
1208 IEEE80211_CHAN_DISABLED)
1209 continue;
1210
1211 arg.n_channels++;
1212 }
1213 }
1214
1215 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1216 arg.channels = kzalloc(len, GFP_KERNEL);
1217 if (!arg.channels)
1218 return -ENOMEM;
1219
1220 ch = arg.channels;
1221 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1222 if (!bands[band])
1223 continue;
1224
1225 for (i = 0; i < bands[band]->n_channels; i++) {
1226 channel = &bands[band]->channels[i];
1227
1228 if (channel->flags & IEEE80211_CHAN_DISABLED)
1229 continue;
1230
1231 ch->allow_ht = true;
1232
1233 /* FIXME: when should we really allow VHT? */
1234 ch->allow_vht = true;
1235
1236 ch->allow_ibss =
1237 !(channel->flags & IEEE80211_CHAN_NO_IBSS);
1238
1239 ch->ht40plus =
1240 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1241
1242 passive = channel->flags & IEEE80211_CHAN_PASSIVE_SCAN;
1243 ch->passive = passive;
1244
1245 ch->freq = channel->center_freq;
1246 ch->min_power = channel->max_power * 3;
1247 ch->max_power = channel->max_power * 4;
1248 ch->max_reg_power = channel->max_reg_power * 4;
1249 ch->max_antenna_gain = channel->max_antenna_gain;
1250 ch->reg_class_id = 0; /* FIXME */
1251
1252 /* FIXME: why use only legacy modes, why not any
1253 * HT/VHT modes? Would that even make any
1254 * difference? */
1255 if (channel->band == IEEE80211_BAND_2GHZ)
1256 ch->mode = MODE_11G;
1257 else
1258 ch->mode = MODE_11A;
1259
1260 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1261 continue;
1262
1263 ath10k_dbg(ATH10K_DBG_WMI,
1264 "%s: [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1265 __func__, ch - arg.channels, arg.n_channels,
1266 ch->freq, ch->max_power, ch->max_reg_power,
1267 ch->max_antenna_gain, ch->mode);
1268
1269 ch++;
1270 }
1271 }
1272
1273 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1274 kfree(arg.channels);
1275
1276 return ret;
1277 }
1278
1279 static void ath10k_reg_notifier(struct wiphy *wiphy,
1280 struct regulatory_request *request)
1281 {
1282 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1283 struct reg_dmn_pair_mapping *regpair;
1284 struct ath10k *ar = hw->priv;
1285 int ret;
1286
1287 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1288
1289 ret = ath10k_update_channel_list(ar);
1290 if (ret)
1291 ath10k_warn("could not update channel list (%d)\n", ret);
1292
1293 regpair = ar->ath_common.regulatory.regpair;
1294 /* Target allows setting up per-band regdomain but ath_common provides
1295 * a combined one only */
1296 ret = ath10k_wmi_pdev_set_regdomain(ar,
1297 regpair->regDmnEnum,
1298 regpair->regDmnEnum, /* 2ghz */
1299 regpair->regDmnEnum, /* 5ghz */
1300 regpair->reg_2ghz_ctl,
1301 regpair->reg_5ghz_ctl);
1302 if (ret)
1303 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
1304 }
1305
1306 /***************/
1307 /* TX handlers */
1308 /***************/
1309
1310 /*
1311 * Frames sent to the FW have to be in "Native Wifi" format.
1312 * Strip the QoS field from the 802.11 header.
1313 */
1314 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1315 struct ieee80211_tx_control *control,
1316 struct sk_buff *skb)
1317 {
1318 struct ieee80211_hdr *hdr = (void *)skb->data;
1319 u8 *qos_ctl;
1320
1321 if (!ieee80211_is_data_qos(hdr->frame_control))
1322 return;
1323
1324 qos_ctl = ieee80211_get_qos_ctl(hdr);
1325 memmove(qos_ctl, qos_ctl + IEEE80211_QOS_CTL_LEN,
1326 skb->len - ieee80211_hdrlen(hdr->frame_control));
1327 skb_trim(skb, skb->len - IEEE80211_QOS_CTL_LEN);
1328 }
1329
1330 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1331 {
1332 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1333 struct ieee80211_vif *vif = info->control.vif;
1334 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1335 struct ath10k *ar = arvif->ar;
1336 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1337 struct ieee80211_key_conf *key = info->control.hw_key;
1338 int ret;
1339
1340 /* TODO AP mode should be implemented */
1341 if (vif->type != NL80211_IFTYPE_STATION)
1342 return;
1343
1344 if (!ieee80211_has_protected(hdr->frame_control))
1345 return;
1346
1347 if (!key)
1348 return;
1349
1350 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1351 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1352 return;
1353
1354 if (key->keyidx == arvif->def_wep_key_index)
1355 return;
1356
1357 ath10k_dbg(ATH10K_DBG_MAC, "new wep keyidx will be %d\n", key->keyidx);
1358
1359 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1360 WMI_VDEV_PARAM_DEF_KEYID,
1361 key->keyidx);
1362 if (ret) {
1363 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1364 return;
1365 }
1366
1367 arvif->def_wep_key_index = key->keyidx;
1368 }
1369
1370 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1371 {
1372 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1373 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1374 struct ieee80211_vif *vif = info->control.vif;
1375 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1376
1377 /* This is case only for P2P_GO */
1378 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1379 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1380 return;
1381
1382 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1383 spin_lock_bh(&ar->data_lock);
1384 if (arvif->u.ap.noa_data)
1385 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1386 GFP_ATOMIC))
1387 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1388 arvif->u.ap.noa_data,
1389 arvif->u.ap.noa_len);
1390 spin_unlock_bh(&ar->data_lock);
1391 }
1392 }
1393
1394 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1395 {
1396 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1397 int ret;
1398
1399 if (ieee80211_is_mgmt(hdr->frame_control))
1400 ret = ath10k_htt_mgmt_tx(ar->htt, skb);
1401 else if (ieee80211_is_nullfunc(hdr->frame_control))
1402 /* FW does not report tx status properly for NullFunc frames
1403 * unless they are sent through mgmt tx path. mac80211 sends
1404 * those frames when it detects link/beacon loss and depends on
1405 * the tx status to be correct. */
1406 ret = ath10k_htt_mgmt_tx(ar->htt, skb);
1407 else
1408 ret = ath10k_htt_tx(ar->htt, skb);
1409
1410 if (ret) {
1411 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1412 ieee80211_free_txskb(ar->hw, skb);
1413 }
1414 }
1415
1416 void ath10k_offchan_tx_purge(struct ath10k *ar)
1417 {
1418 struct sk_buff *skb;
1419
1420 for (;;) {
1421 skb = skb_dequeue(&ar->offchan_tx_queue);
1422 if (!skb)
1423 break;
1424
1425 ieee80211_free_txskb(ar->hw, skb);
1426 }
1427 }
1428
1429 void ath10k_offchan_tx_work(struct work_struct *work)
1430 {
1431 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1432 struct ath10k_peer *peer;
1433 struct ieee80211_hdr *hdr;
1434 struct sk_buff *skb;
1435 const u8 *peer_addr;
1436 int vdev_id;
1437 int ret;
1438
1439 /* FW requirement: We must create a peer before FW will send out
1440 * an offchannel frame. Otherwise the frame will be stuck and
1441 * never transmitted. We delete the peer upon tx completion.
1442 * It is unlikely that a peer for offchannel tx will already be
1443 * present. However it may be in some rare cases so account for that.
1444 * Otherwise we might remove a legitimate peer and break stuff. */
1445
1446 for (;;) {
1447 skb = skb_dequeue(&ar->offchan_tx_queue);
1448 if (!skb)
1449 break;
1450
1451 mutex_lock(&ar->conf_mutex);
1452
1453 ath10k_dbg(ATH10K_DBG_MAC, "processing offchannel skb %p\n",
1454 skb);
1455
1456 hdr = (struct ieee80211_hdr *)skb->data;
1457 peer_addr = ieee80211_get_DA(hdr);
1458 vdev_id = ATH10K_SKB_CB(skb)->htt.vdev_id;
1459
1460 spin_lock_bh(&ar->data_lock);
1461 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1462 spin_unlock_bh(&ar->data_lock);
1463
1464 if (peer)
1465 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1466 peer_addr, vdev_id);
1467
1468 if (!peer) {
1469 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1470 if (ret)
1471 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1472 peer_addr, vdev_id, ret);
1473 }
1474
1475 spin_lock_bh(&ar->data_lock);
1476 INIT_COMPLETION(ar->offchan_tx_completed);
1477 ar->offchan_tx_skb = skb;
1478 spin_unlock_bh(&ar->data_lock);
1479
1480 ath10k_tx_htt(ar, skb);
1481
1482 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1483 3 * HZ);
1484 if (ret <= 0)
1485 ath10k_warn("timed out waiting for offchannel skb %p\n",
1486 skb);
1487
1488 if (!peer) {
1489 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1490 if (ret)
1491 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1492 peer_addr, vdev_id, ret);
1493 }
1494
1495 mutex_unlock(&ar->conf_mutex);
1496 }
1497 }
1498
1499 /************/
1500 /* Scanning */
1501 /************/
1502
1503 /*
1504 * This gets called if we dont get a heart-beat during scan.
1505 * This may indicate the FW has hung and we need to abort the
1506 * scan manually to prevent cancel_hw_scan() from deadlocking
1507 */
1508 void ath10k_reset_scan(unsigned long ptr)
1509 {
1510 struct ath10k *ar = (struct ath10k *)ptr;
1511
1512 spin_lock_bh(&ar->data_lock);
1513 if (!ar->scan.in_progress) {
1514 spin_unlock_bh(&ar->data_lock);
1515 return;
1516 }
1517
1518 ath10k_warn("scan timeout. resetting. fw issue?\n");
1519
1520 if (ar->scan.is_roc)
1521 ieee80211_remain_on_channel_expired(ar->hw);
1522 else
1523 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
1524
1525 ar->scan.in_progress = false;
1526 complete_all(&ar->scan.completed);
1527 spin_unlock_bh(&ar->data_lock);
1528 }
1529
1530 static int ath10k_abort_scan(struct ath10k *ar)
1531 {
1532 struct wmi_stop_scan_arg arg = {
1533 .req_id = 1, /* FIXME */
1534 .req_type = WMI_SCAN_STOP_ONE,
1535 .u.scan_id = ATH10K_SCAN_ID,
1536 };
1537 int ret;
1538
1539 lockdep_assert_held(&ar->conf_mutex);
1540
1541 del_timer_sync(&ar->scan.timeout);
1542
1543 spin_lock_bh(&ar->data_lock);
1544 if (!ar->scan.in_progress) {
1545 spin_unlock_bh(&ar->data_lock);
1546 return 0;
1547 }
1548
1549 ar->scan.aborting = true;
1550 spin_unlock_bh(&ar->data_lock);
1551
1552 ret = ath10k_wmi_stop_scan(ar, &arg);
1553 if (ret) {
1554 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
1555 return -EIO;
1556 }
1557
1558 ath10k_wmi_flush_tx(ar);
1559
1560 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
1561 if (ret == 0)
1562 ath10k_warn("timed out while waiting for scan to stop\n");
1563
1564 /* scan completion may be done right after we timeout here, so let's
1565 * check the in_progress and tell mac80211 scan is completed. if we
1566 * don't do that and FW fails to send us scan completion indication
1567 * then userspace won't be able to scan anymore */
1568 ret = 0;
1569
1570 spin_lock_bh(&ar->data_lock);
1571 if (ar->scan.in_progress) {
1572 ath10k_warn("could not stop scan. its still in progress\n");
1573 ar->scan.in_progress = false;
1574 ath10k_offchan_tx_purge(ar);
1575 ret = -ETIMEDOUT;
1576 }
1577 spin_unlock_bh(&ar->data_lock);
1578
1579 return ret;
1580 }
1581
1582 static int ath10k_start_scan(struct ath10k *ar,
1583 const struct wmi_start_scan_arg *arg)
1584 {
1585 int ret;
1586
1587 lockdep_assert_held(&ar->conf_mutex);
1588
1589 ret = ath10k_wmi_start_scan(ar, arg);
1590 if (ret)
1591 return ret;
1592
1593 /* make sure we submit the command so the completion
1594 * timeout makes sense */
1595 ath10k_wmi_flush_tx(ar);
1596
1597 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
1598 if (ret == 0) {
1599 ath10k_abort_scan(ar);
1600 return ret;
1601 }
1602
1603 /* the scan can complete earlier, before we even
1604 * start the timer. in that case the timer handler
1605 * checks ar->scan.in_progress and bails out if its
1606 * false. Add a 200ms margin to account event/command
1607 * processing. */
1608 mod_timer(&ar->scan.timeout, jiffies +
1609 msecs_to_jiffies(arg->max_scan_time+200));
1610 return 0;
1611 }
1612
1613 /**********************/
1614 /* mac80211 callbacks */
1615 /**********************/
1616
1617 static void ath10k_tx(struct ieee80211_hw *hw,
1618 struct ieee80211_tx_control *control,
1619 struct sk_buff *skb)
1620 {
1621 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1622 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1623 struct ath10k *ar = hw->priv;
1624 struct ath10k_vif *arvif = NULL;
1625 u32 vdev_id = 0;
1626 u8 tid;
1627
1628 if (info->control.vif) {
1629 arvif = ath10k_vif_to_arvif(info->control.vif);
1630 vdev_id = arvif->vdev_id;
1631 } else if (ar->monitor_enabled) {
1632 vdev_id = ar->monitor_vdev_id;
1633 }
1634
1635 /* We should disable CCK RATE due to P2P */
1636 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
1637 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
1638
1639 /* we must calculate tid before we apply qos workaround
1640 * as we'd lose the qos control field */
1641 tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1642 if (ieee80211_is_data_qos(hdr->frame_control) &&
1643 is_unicast_ether_addr(ieee80211_get_DA(hdr))) {
1644 u8 *qc = ieee80211_get_qos_ctl(hdr);
1645 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1646 }
1647
1648 ath10k_tx_h_qos_workaround(hw, control, skb);
1649 ath10k_tx_h_update_wep_key(skb);
1650 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
1651 ath10k_tx_h_seq_no(skb);
1652
1653 memset(ATH10K_SKB_CB(skb), 0, sizeof(*ATH10K_SKB_CB(skb)));
1654 ATH10K_SKB_CB(skb)->htt.vdev_id = vdev_id;
1655 ATH10K_SKB_CB(skb)->htt.tid = tid;
1656
1657 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
1658 spin_lock_bh(&ar->data_lock);
1659 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
1660 ATH10K_SKB_CB(skb)->htt.vdev_id = ar->scan.vdev_id;
1661 spin_unlock_bh(&ar->data_lock);
1662
1663 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
1664
1665 skb_queue_tail(&ar->offchan_tx_queue, skb);
1666 ieee80211_queue_work(hw, &ar->offchan_tx_work);
1667 return;
1668 }
1669
1670 ath10k_tx_htt(ar, skb);
1671 }
1672
1673 /*
1674 * Initialize various parameters with default vaules.
1675 */
1676 static int ath10k_start(struct ieee80211_hw *hw)
1677 {
1678 struct ath10k *ar = hw->priv;
1679 int ret;
1680
1681 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 1);
1682 if (ret)
1683 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
1684 ret);
1685
1686 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 0);
1687 if (ret)
1688 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
1689 ret);
1690
1691 return 0;
1692 }
1693
1694 static void ath10k_stop(struct ieee80211_hw *hw)
1695 {
1696 struct ath10k *ar = hw->priv;
1697
1698 /* avoid leaks in case FW never confirms scan for offchannel */
1699 cancel_work_sync(&ar->offchan_tx_work);
1700 ath10k_offchan_tx_purge(ar);
1701 }
1702
1703 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
1704 {
1705 struct ath10k_generic_iter ar_iter;
1706 struct ath10k *ar = hw->priv;
1707 struct ieee80211_conf *conf = &hw->conf;
1708 int ret = 0;
1709 u32 flags;
1710
1711 mutex_lock(&ar->conf_mutex);
1712
1713 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1714 ath10k_dbg(ATH10K_DBG_MAC, "Config channel %d mhz\n",
1715 conf->chandef.chan->center_freq);
1716 spin_lock_bh(&ar->data_lock);
1717 ar->rx_channel = conf->chandef.chan;
1718 spin_unlock_bh(&ar->data_lock);
1719 }
1720
1721 if (changed & IEEE80211_CONF_CHANGE_PS) {
1722 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
1723 ar_iter.ar = ar;
1724 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
1725
1726 ieee80211_iterate_active_interfaces_atomic(hw,
1727 flags,
1728 ath10k_ps_iter,
1729 &ar_iter);
1730
1731 ret = ar_iter.ret;
1732 }
1733
1734 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1735 if (conf->flags & IEEE80211_CONF_MONITOR)
1736 ret = ath10k_monitor_create(ar);
1737 else
1738 ret = ath10k_monitor_destroy(ar);
1739 }
1740
1741 mutex_unlock(&ar->conf_mutex);
1742 return ret;
1743 }
1744
1745 /*
1746 * TODO:
1747 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
1748 * because we will send mgmt frames without CCK. This requirement
1749 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
1750 * in the TX packet.
1751 */
1752 static int ath10k_add_interface(struct ieee80211_hw *hw,
1753 struct ieee80211_vif *vif)
1754 {
1755 struct ath10k *ar = hw->priv;
1756 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1757 enum wmi_sta_powersave_param param;
1758 int ret = 0;
1759 u32 value;
1760 int bit;
1761
1762 mutex_lock(&ar->conf_mutex);
1763
1764 arvif->ar = ar;
1765 arvif->vif = vif;
1766
1767 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
1768 ath10k_warn("Only one monitor interface allowed\n");
1769 ret = -EBUSY;
1770 goto exit;
1771 }
1772
1773 bit = ffs(ar->free_vdev_map);
1774 if (bit == 0) {
1775 ret = -EBUSY;
1776 goto exit;
1777 }
1778
1779 arvif->vdev_id = bit - 1;
1780 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
1781 ar->free_vdev_map &= ~(1 << arvif->vdev_id);
1782
1783 if (ar->p2p)
1784 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
1785
1786 switch (vif->type) {
1787 case NL80211_IFTYPE_UNSPECIFIED:
1788 case NL80211_IFTYPE_STATION:
1789 arvif->vdev_type = WMI_VDEV_TYPE_STA;
1790 if (vif->p2p)
1791 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
1792 break;
1793 case NL80211_IFTYPE_ADHOC:
1794 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
1795 break;
1796 case NL80211_IFTYPE_AP:
1797 arvif->vdev_type = WMI_VDEV_TYPE_AP;
1798
1799 if (vif->p2p)
1800 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
1801 break;
1802 case NL80211_IFTYPE_MONITOR:
1803 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
1804 break;
1805 default:
1806 WARN_ON(1);
1807 break;
1808 }
1809
1810 ath10k_dbg(ATH10K_DBG_MAC, "Add interface: id %d type %d subtype %d\n",
1811 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
1812
1813 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
1814 arvif->vdev_subtype, vif->addr);
1815 if (ret) {
1816 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
1817 goto exit;
1818 }
1819
1820 ret = ath10k_wmi_vdev_set_param(ar, 0, WMI_VDEV_PARAM_DEF_KEYID,
1821 arvif->def_wep_key_index);
1822 if (ret)
1823 ath10k_warn("Failed to set default keyid: %d\n", ret);
1824
1825 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1826 WMI_VDEV_PARAM_TX_ENCAP_TYPE,
1827 ATH10K_HW_TXRX_NATIVE_WIFI);
1828 if (ret)
1829 ath10k_warn("Failed to set TX encap: %d\n", ret);
1830
1831 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1832 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
1833 if (ret) {
1834 ath10k_warn("Failed to create peer for AP: %d\n", ret);
1835 goto exit;
1836 }
1837 }
1838
1839 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
1840 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
1841 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
1842 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1843 param, value);
1844 if (ret)
1845 ath10k_warn("Failed to set RX wake policy: %d\n", ret);
1846
1847 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1848 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1849 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1850 param, value);
1851 if (ret)
1852 ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
1853
1854 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1855 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1856 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1857 param, value);
1858 if (ret)
1859 ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
1860 }
1861
1862 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
1863 ar->monitor_present = true;
1864
1865 exit:
1866 mutex_unlock(&ar->conf_mutex);
1867 return ret;
1868 }
1869
1870 static void ath10k_remove_interface(struct ieee80211_hw *hw,
1871 struct ieee80211_vif *vif)
1872 {
1873 struct ath10k *ar = hw->priv;
1874 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1875 int ret;
1876
1877 mutex_lock(&ar->conf_mutex);
1878
1879 ath10k_dbg(ATH10K_DBG_MAC, "Remove interface: id %d\n", arvif->vdev_id);
1880
1881 ar->free_vdev_map |= 1 << (arvif->vdev_id);
1882
1883 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1884 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
1885 if (ret)
1886 ath10k_warn("Failed to remove peer for AP: %d\n", ret);
1887
1888 kfree(arvif->u.ap.noa_data);
1889 }
1890
1891 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
1892 if (ret)
1893 ath10k_warn("WMI vdev delete failed: %d\n", ret);
1894
1895 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
1896 ar->monitor_present = false;
1897
1898 ath10k_peer_cleanup(ar, arvif->vdev_id);
1899
1900 mutex_unlock(&ar->conf_mutex);
1901 }
1902
1903 /*
1904 * FIXME: Has to be verified.
1905 */
1906 #define SUPPORTED_FILTERS \
1907 (FIF_PROMISC_IN_BSS | \
1908 FIF_ALLMULTI | \
1909 FIF_CONTROL | \
1910 FIF_PSPOLL | \
1911 FIF_OTHER_BSS | \
1912 FIF_BCN_PRBRESP_PROMISC | \
1913 FIF_PROBE_REQ | \
1914 FIF_FCSFAIL)
1915
1916 static void ath10k_configure_filter(struct ieee80211_hw *hw,
1917 unsigned int changed_flags,
1918 unsigned int *total_flags,
1919 u64 multicast)
1920 {
1921 struct ath10k *ar = hw->priv;
1922 int ret;
1923
1924 mutex_lock(&ar->conf_mutex);
1925
1926 changed_flags &= SUPPORTED_FILTERS;
1927 *total_flags &= SUPPORTED_FILTERS;
1928 ar->filter_flags = *total_flags;
1929
1930 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
1931 !ar->monitor_enabled) {
1932 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
1933 if (ret)
1934 ath10k_warn("Unable to start monitor mode\n");
1935 else
1936 ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode started\n");
1937 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
1938 ar->monitor_enabled) {
1939 ret = ath10k_monitor_stop(ar);
1940 if (ret)
1941 ath10k_warn("Unable to stop monitor mode\n");
1942 else
1943 ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode stopped\n");
1944 }
1945
1946 mutex_unlock(&ar->conf_mutex);
1947 }
1948
1949 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
1950 struct ieee80211_vif *vif,
1951 struct ieee80211_bss_conf *info,
1952 u32 changed)
1953 {
1954 struct ath10k *ar = hw->priv;
1955 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1956 int ret = 0;
1957
1958 mutex_lock(&ar->conf_mutex);
1959
1960 if (changed & BSS_CHANGED_IBSS)
1961 ath10k_control_ibss(arvif, info, vif->addr);
1962
1963 if (changed & BSS_CHANGED_BEACON_INT) {
1964 arvif->beacon_interval = info->beacon_int;
1965 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1966 WMI_VDEV_PARAM_BEACON_INTERVAL,
1967 arvif->beacon_interval);
1968 if (ret)
1969 ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
1970 arvif->vdev_id);
1971 else
1972 ath10k_dbg(ATH10K_DBG_MAC,
1973 "Beacon interval: %d set for VDEV: %d\n",
1974 arvif->beacon_interval, arvif->vdev_id);
1975 }
1976
1977 if (changed & BSS_CHANGED_BEACON) {
1978 ret = ath10k_wmi_pdev_set_param(ar,
1979 WMI_PDEV_PARAM_BEACON_TX_MODE,
1980 WMI_BEACON_STAGGERED_MODE);
1981 if (ret)
1982 ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
1983 arvif->vdev_id);
1984 else
1985 ath10k_dbg(ATH10K_DBG_MAC,
1986 "Set staggered beacon mode for VDEV: %d\n",
1987 arvif->vdev_id);
1988 }
1989
1990 if (changed & BSS_CHANGED_BEACON_INFO) {
1991 arvif->dtim_period = info->dtim_period;
1992
1993 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1994 WMI_VDEV_PARAM_DTIM_PERIOD,
1995 arvif->dtim_period);
1996 if (ret)
1997 ath10k_warn("Failed to set dtim period for VDEV: %d\n",
1998 arvif->vdev_id);
1999 else
2000 ath10k_dbg(ATH10K_DBG_MAC,
2001 "Set dtim period: %d for VDEV: %d\n",
2002 arvif->dtim_period, arvif->vdev_id);
2003 }
2004
2005 if (changed & BSS_CHANGED_SSID &&
2006 vif->type == NL80211_IFTYPE_AP) {
2007 arvif->u.ap.ssid_len = info->ssid_len;
2008 if (info->ssid_len)
2009 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2010 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2011 }
2012
2013 if (changed & BSS_CHANGED_BSSID) {
2014 if (!is_zero_ether_addr(info->bssid)) {
2015 ret = ath10k_peer_create(ar, arvif->vdev_id,
2016 info->bssid);
2017 if (ret)
2018 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2019 info->bssid, arvif->vdev_id);
2020 else
2021 ath10k_dbg(ATH10K_DBG_MAC,
2022 "Added peer: %pM for VDEV: %d\n",
2023 info->bssid, arvif->vdev_id);
2024
2025
2026 if (vif->type == NL80211_IFTYPE_STATION) {
2027 /*
2028 * this is never erased as we it for crypto key
2029 * clearing; this is FW requirement
2030 */
2031 memcpy(arvif->u.sta.bssid, info->bssid,
2032 ETH_ALEN);
2033
2034 ret = ath10k_vdev_start(arvif);
2035 if (!ret)
2036 ath10k_dbg(ATH10K_DBG_MAC,
2037 "VDEV: %d started with BSSID: %pM\n",
2038 arvif->vdev_id, info->bssid);
2039 }
2040
2041 /*
2042 * Mac80211 does not keep IBSS bssid when leaving IBSS,
2043 * so driver need to store it. It is needed when leaving
2044 * IBSS in order to remove BSSID peer.
2045 */
2046 if (vif->type == NL80211_IFTYPE_ADHOC)
2047 memcpy(arvif->u.ibss.bssid, info->bssid,
2048 ETH_ALEN);
2049 }
2050 }
2051
2052 if (changed & BSS_CHANGED_BEACON_ENABLED)
2053 ath10k_control_beaconing(arvif, info);
2054
2055 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2056 u32 cts_prot;
2057 if (info->use_cts_prot)
2058 cts_prot = 1;
2059 else
2060 cts_prot = 0;
2061
2062 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2063 WMI_VDEV_PARAM_ENABLE_RTSCTS,
2064 cts_prot);
2065 if (ret)
2066 ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2067 arvif->vdev_id);
2068 else
2069 ath10k_dbg(ATH10K_DBG_MAC,
2070 "Set CTS prot: %d for VDEV: %d\n",
2071 cts_prot, arvif->vdev_id);
2072 }
2073
2074 if (changed & BSS_CHANGED_ERP_SLOT) {
2075 u32 slottime;
2076 if (info->use_short_slot)
2077 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2078
2079 else
2080 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2081
2082 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2083 WMI_VDEV_PARAM_SLOT_TIME,
2084 slottime);
2085 if (ret)
2086 ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2087 arvif->vdev_id);
2088 else
2089 ath10k_dbg(ATH10K_DBG_MAC,
2090 "Set slottime: %d for VDEV: %d\n",
2091 slottime, arvif->vdev_id);
2092 }
2093
2094 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2095 u32 preamble;
2096 if (info->use_short_preamble)
2097 preamble = WMI_VDEV_PREAMBLE_SHORT;
2098 else
2099 preamble = WMI_VDEV_PREAMBLE_LONG;
2100
2101 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2102 WMI_VDEV_PARAM_PREAMBLE,
2103 preamble);
2104 if (ret)
2105 ath10k_warn("Failed to set preamble for VDEV: %d\n",
2106 arvif->vdev_id);
2107 else
2108 ath10k_dbg(ATH10K_DBG_MAC,
2109 "Set preamble: %d for VDEV: %d\n",
2110 preamble, arvif->vdev_id);
2111 }
2112
2113 if (changed & BSS_CHANGED_ASSOC) {
2114 if (info->assoc)
2115 ath10k_bss_assoc(hw, vif, info);
2116 }
2117
2118 mutex_unlock(&ar->conf_mutex);
2119 }
2120
2121 static int ath10k_hw_scan(struct ieee80211_hw *hw,
2122 struct ieee80211_vif *vif,
2123 struct cfg80211_scan_request *req)
2124 {
2125 struct ath10k *ar = hw->priv;
2126 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2127 struct wmi_start_scan_arg arg;
2128 int ret = 0;
2129 int i;
2130
2131 mutex_lock(&ar->conf_mutex);
2132
2133 spin_lock_bh(&ar->data_lock);
2134 if (ar->scan.in_progress) {
2135 spin_unlock_bh(&ar->data_lock);
2136 ret = -EBUSY;
2137 goto exit;
2138 }
2139
2140 INIT_COMPLETION(ar->scan.started);
2141 INIT_COMPLETION(ar->scan.completed);
2142 ar->scan.in_progress = true;
2143 ar->scan.aborting = false;
2144 ar->scan.is_roc = false;
2145 ar->scan.vdev_id = arvif->vdev_id;
2146 spin_unlock_bh(&ar->data_lock);
2147
2148 memset(&arg, 0, sizeof(arg));
2149 ath10k_wmi_start_scan_init(ar, &arg);
2150 arg.vdev_id = arvif->vdev_id;
2151 arg.scan_id = ATH10K_SCAN_ID;
2152
2153 if (!req->no_cck)
2154 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2155
2156 if (req->ie_len) {
2157 arg.ie_len = req->ie_len;
2158 memcpy(arg.ie, req->ie, arg.ie_len);
2159 }
2160
2161 if (req->n_ssids) {
2162 arg.n_ssids = req->n_ssids;
2163 for (i = 0; i < arg.n_ssids; i++) {
2164 arg.ssids[i].len = req->ssids[i].ssid_len;
2165 arg.ssids[i].ssid = req->ssids[i].ssid;
2166 }
2167 }
2168
2169 if (req->n_channels) {
2170 arg.n_channels = req->n_channels;
2171 for (i = 0; i < arg.n_channels; i++)
2172 arg.channels[i] = req->channels[i]->center_freq;
2173 }
2174
2175 ret = ath10k_start_scan(ar, &arg);
2176 if (ret) {
2177 ath10k_warn("could not start hw scan (%d)\n", ret);
2178 spin_lock_bh(&ar->data_lock);
2179 ar->scan.in_progress = false;
2180 spin_unlock_bh(&ar->data_lock);
2181 }
2182
2183 exit:
2184 mutex_unlock(&ar->conf_mutex);
2185 return ret;
2186 }
2187
2188 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2189 struct ieee80211_vif *vif)
2190 {
2191 struct ath10k *ar = hw->priv;
2192 int ret;
2193
2194 mutex_lock(&ar->conf_mutex);
2195 ret = ath10k_abort_scan(ar);
2196 if (ret) {
2197 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2198 ret);
2199 ieee80211_scan_completed(hw, 1 /* aborted */);
2200 }
2201 mutex_unlock(&ar->conf_mutex);
2202 }
2203
2204 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2205 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2206 struct ieee80211_key_conf *key)
2207 {
2208 struct ath10k *ar = hw->priv;
2209 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2210 struct ath10k_peer *peer;
2211 const u8 *peer_addr;
2212 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2213 key->cipher == WLAN_CIPHER_SUITE_WEP104;
2214 int ret = 0;
2215
2216 if (key->keyidx > WMI_MAX_KEY_INDEX)
2217 return -ENOSPC;
2218
2219 mutex_lock(&ar->conf_mutex);
2220
2221 if (sta)
2222 peer_addr = sta->addr;
2223 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
2224 peer_addr = vif->bss_conf.bssid;
2225 else
2226 peer_addr = vif->addr;
2227
2228 key->hw_key_idx = key->keyidx;
2229
2230 /* the peer should not disappear in mid-way (unless FW goes awry) since
2231 * we already hold conf_mutex. we just make sure its there now. */
2232 spin_lock_bh(&ar->data_lock);
2233 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2234 spin_unlock_bh(&ar->data_lock);
2235
2236 if (!peer) {
2237 if (cmd == SET_KEY) {
2238 ath10k_warn("cannot install key for non-existent peer %pM\n",
2239 peer_addr);
2240 ret = -EOPNOTSUPP;
2241 goto exit;
2242 } else {
2243 /* if the peer doesn't exist there is no key to disable
2244 * anymore */
2245 goto exit;
2246 }
2247 }
2248
2249 if (is_wep) {
2250 if (cmd == SET_KEY)
2251 arvif->wep_keys[key->keyidx] = key;
2252 else
2253 arvif->wep_keys[key->keyidx] = NULL;
2254
2255 if (cmd == DISABLE_KEY)
2256 ath10k_clear_vdev_key(arvif, key);
2257 }
2258
2259 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
2260 if (ret) {
2261 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
2262 goto exit;
2263 }
2264
2265 spin_lock_bh(&ar->data_lock);
2266 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2267 if (peer && cmd == SET_KEY)
2268 peer->keys[key->keyidx] = key;
2269 else if (peer && cmd == DISABLE_KEY)
2270 peer->keys[key->keyidx] = NULL;
2271 else if (peer == NULL)
2272 /* impossible unless FW goes crazy */
2273 ath10k_warn("peer %pM disappeared!\n", peer_addr);
2274 spin_unlock_bh(&ar->data_lock);
2275
2276 exit:
2277 mutex_unlock(&ar->conf_mutex);
2278 return ret;
2279 }
2280
2281 static int ath10k_sta_state(struct ieee80211_hw *hw,
2282 struct ieee80211_vif *vif,
2283 struct ieee80211_sta *sta,
2284 enum ieee80211_sta_state old_state,
2285 enum ieee80211_sta_state new_state)
2286 {
2287 struct ath10k *ar = hw->priv;
2288 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2289 int ret = 0;
2290
2291 mutex_lock(&ar->conf_mutex);
2292
2293 if (old_state == IEEE80211_STA_NOTEXIST &&
2294 new_state == IEEE80211_STA_NONE &&
2295 vif->type != NL80211_IFTYPE_STATION) {
2296 /*
2297 * New station addition.
2298 */
2299 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
2300 if (ret)
2301 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2302 sta->addr, arvif->vdev_id);
2303 else
2304 ath10k_dbg(ATH10K_DBG_MAC,
2305 "Added peer: %pM for VDEV: %d\n",
2306 sta->addr, arvif->vdev_id);
2307 } else if ((old_state == IEEE80211_STA_NONE &&
2308 new_state == IEEE80211_STA_NOTEXIST)) {
2309 /*
2310 * Existing station deletion.
2311 */
2312 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
2313 if (ret)
2314 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
2315 sta->addr, arvif->vdev_id);
2316 else
2317 ath10k_dbg(ATH10K_DBG_MAC,
2318 "Removed peer: %pM for VDEV: %d\n",
2319 sta->addr, arvif->vdev_id);
2320
2321 if (vif->type == NL80211_IFTYPE_STATION)
2322 ath10k_bss_disassoc(hw, vif);
2323 } else if (old_state == IEEE80211_STA_AUTH &&
2324 new_state == IEEE80211_STA_ASSOC &&
2325 (vif->type == NL80211_IFTYPE_AP ||
2326 vif->type == NL80211_IFTYPE_ADHOC)) {
2327 /*
2328 * New association.
2329 */
2330 ret = ath10k_station_assoc(ar, arvif, sta);
2331 if (ret)
2332 ath10k_warn("Failed to associate station: %pM\n",
2333 sta->addr);
2334 else
2335 ath10k_dbg(ATH10K_DBG_MAC,
2336 "Station %pM moved to assoc state\n",
2337 sta->addr);
2338 } else if (old_state == IEEE80211_STA_ASSOC &&
2339 new_state == IEEE80211_STA_AUTH &&
2340 (vif->type == NL80211_IFTYPE_AP ||
2341 vif->type == NL80211_IFTYPE_ADHOC)) {
2342 /*
2343 * Disassociation.
2344 */
2345 ret = ath10k_station_disassoc(ar, arvif, sta);
2346 if (ret)
2347 ath10k_warn("Failed to disassociate station: %pM\n",
2348 sta->addr);
2349 else
2350 ath10k_dbg(ATH10K_DBG_MAC,
2351 "Station %pM moved to disassociated state\n",
2352 sta->addr);
2353 }
2354
2355 mutex_unlock(&ar->conf_mutex);
2356 return ret;
2357 }
2358
2359 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
2360 u16 ac, bool enable)
2361 {
2362 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2363 u32 value = 0;
2364 int ret = 0;
2365
2366 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
2367 return 0;
2368
2369 switch (ac) {
2370 case IEEE80211_AC_VO:
2371 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
2372 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
2373 break;
2374 case IEEE80211_AC_VI:
2375 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
2376 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
2377 break;
2378 case IEEE80211_AC_BE:
2379 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
2380 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
2381 break;
2382 case IEEE80211_AC_BK:
2383 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
2384 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
2385 break;
2386 }
2387
2388 if (enable)
2389 arvif->u.sta.uapsd |= value;
2390 else
2391 arvif->u.sta.uapsd &= ~value;
2392
2393 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2394 WMI_STA_PS_PARAM_UAPSD,
2395 arvif->u.sta.uapsd);
2396 if (ret) {
2397 ath10k_warn("could not set uapsd params %d\n", ret);
2398 goto exit;
2399 }
2400
2401 if (arvif->u.sta.uapsd)
2402 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
2403 else
2404 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2405
2406 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2407 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
2408 value);
2409 if (ret)
2410 ath10k_warn("could not set rx wake param %d\n", ret);
2411
2412 exit:
2413 return ret;
2414 }
2415
2416 static int ath10k_conf_tx(struct ieee80211_hw *hw,
2417 struct ieee80211_vif *vif, u16 ac,
2418 const struct ieee80211_tx_queue_params *params)
2419 {
2420 struct ath10k *ar = hw->priv;
2421 struct wmi_wmm_params_arg *p = NULL;
2422 int ret;
2423
2424 mutex_lock(&ar->conf_mutex);
2425
2426 switch (ac) {
2427 case IEEE80211_AC_VO:
2428 p = &ar->wmm_params.ac_vo;
2429 break;
2430 case IEEE80211_AC_VI:
2431 p = &ar->wmm_params.ac_vi;
2432 break;
2433 case IEEE80211_AC_BE:
2434 p = &ar->wmm_params.ac_be;
2435 break;
2436 case IEEE80211_AC_BK:
2437 p = &ar->wmm_params.ac_bk;
2438 break;
2439 }
2440
2441 if (WARN_ON(!p)) {
2442 ret = -EINVAL;
2443 goto exit;
2444 }
2445
2446 p->cwmin = params->cw_min;
2447 p->cwmax = params->cw_max;
2448 p->aifs = params->aifs;
2449
2450 /*
2451 * The channel time duration programmed in the HW is in absolute
2452 * microseconds, while mac80211 gives the txop in units of
2453 * 32 microseconds.
2454 */
2455 p->txop = params->txop * 32;
2456
2457 /* FIXME: FW accepts wmm params per hw, not per vif */
2458 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
2459 if (ret) {
2460 ath10k_warn("could not set wmm params %d\n", ret);
2461 goto exit;
2462 }
2463
2464 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
2465 if (ret)
2466 ath10k_warn("could not set sta uapsd %d\n", ret);
2467
2468 exit:
2469 mutex_unlock(&ar->conf_mutex);
2470 return ret;
2471 }
2472
2473 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
2474
2475 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
2476 struct ieee80211_vif *vif,
2477 struct ieee80211_channel *chan,
2478 int duration,
2479 enum ieee80211_roc_type type)
2480 {
2481 struct ath10k *ar = hw->priv;
2482 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2483 struct wmi_start_scan_arg arg;
2484 int ret;
2485
2486 mutex_lock(&ar->conf_mutex);
2487
2488 spin_lock_bh(&ar->data_lock);
2489 if (ar->scan.in_progress) {
2490 spin_unlock_bh(&ar->data_lock);
2491 ret = -EBUSY;
2492 goto exit;
2493 }
2494
2495 INIT_COMPLETION(ar->scan.started);
2496 INIT_COMPLETION(ar->scan.completed);
2497 INIT_COMPLETION(ar->scan.on_channel);
2498 ar->scan.in_progress = true;
2499 ar->scan.aborting = false;
2500 ar->scan.is_roc = true;
2501 ar->scan.vdev_id = arvif->vdev_id;
2502 ar->scan.roc_freq = chan->center_freq;
2503 spin_unlock_bh(&ar->data_lock);
2504
2505 memset(&arg, 0, sizeof(arg));
2506 ath10k_wmi_start_scan_init(ar, &arg);
2507 arg.vdev_id = arvif->vdev_id;
2508 arg.scan_id = ATH10K_SCAN_ID;
2509 arg.n_channels = 1;
2510 arg.channels[0] = chan->center_freq;
2511 arg.dwell_time_active = duration;
2512 arg.dwell_time_passive = duration;
2513 arg.max_scan_time = 2 * duration;
2514 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2515 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
2516
2517 ret = ath10k_start_scan(ar, &arg);
2518 if (ret) {
2519 ath10k_warn("could not start roc scan (%d)\n", ret);
2520 spin_lock_bh(&ar->data_lock);
2521 ar->scan.in_progress = false;
2522 spin_unlock_bh(&ar->data_lock);
2523 goto exit;
2524 }
2525
2526 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
2527 if (ret == 0) {
2528 ath10k_warn("could not switch to channel for roc scan\n");
2529 ath10k_abort_scan(ar);
2530 ret = -ETIMEDOUT;
2531 goto exit;
2532 }
2533
2534 ret = 0;
2535 exit:
2536 mutex_unlock(&ar->conf_mutex);
2537 return ret;
2538 }
2539
2540 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
2541 {
2542 struct ath10k *ar = hw->priv;
2543
2544 mutex_lock(&ar->conf_mutex);
2545 ath10k_abort_scan(ar);
2546 mutex_unlock(&ar->conf_mutex);
2547
2548 return 0;
2549 }
2550
2551 /*
2552 * Both RTS and Fragmentation threshold are interface-specific
2553 * in ath10k, but device-specific in mac80211.
2554 */
2555 static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2556 {
2557 struct ath10k_generic_iter *ar_iter = data;
2558 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2559 u32 rts = ar_iter->ar->hw->wiphy->rts_threshold;
2560
2561 rts = min_t(u32, rts, ATH10K_RTS_MAX);
2562
2563 ar_iter->ret = ath10k_wmi_vdev_set_param(ar_iter->ar, arvif->vdev_id,
2564 WMI_VDEV_PARAM_RTS_THRESHOLD,
2565 rts);
2566 if (ar_iter->ret)
2567 ath10k_warn("Failed to set RTS threshold for VDEV: %d\n",
2568 arvif->vdev_id);
2569 else
2570 ath10k_dbg(ATH10K_DBG_MAC,
2571 "Set RTS threshold: %d for VDEV: %d\n",
2572 rts, arvif->vdev_id);
2573 }
2574
2575 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2576 {
2577 struct ath10k_generic_iter ar_iter;
2578 struct ath10k *ar = hw->priv;
2579
2580 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2581 ar_iter.ar = ar;
2582
2583 mutex_lock(&ar->conf_mutex);
2584 ieee80211_iterate_active_interfaces(hw, IEEE80211_IFACE_ITER_RESUME_ALL,
2585 ath10k_set_rts_iter, &ar_iter);
2586 mutex_unlock(&ar->conf_mutex);
2587
2588 return ar_iter.ret;
2589 }
2590
2591 static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2592 {
2593 struct ath10k_generic_iter *ar_iter = data;
2594 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2595 u32 frag = ar_iter->ar->hw->wiphy->frag_threshold;
2596 int ret;
2597
2598 frag = clamp_t(u32, frag,
2599 ATH10K_FRAGMT_THRESHOLD_MIN,
2600 ATH10K_FRAGMT_THRESHOLD_MAX);
2601
2602 ret = ath10k_wmi_vdev_set_param(ar_iter->ar, arvif->vdev_id,
2603 WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
2604 frag);
2605
2606 ar_iter->ret = ret;
2607 if (ar_iter->ret)
2608 ath10k_warn("Failed to set frag threshold for VDEV: %d\n",
2609 arvif->vdev_id);
2610 else
2611 ath10k_dbg(ATH10K_DBG_MAC,
2612 "Set frag threshold: %d for VDEV: %d\n",
2613 frag, arvif->vdev_id);
2614 }
2615
2616 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2617 {
2618 struct ath10k_generic_iter ar_iter;
2619 struct ath10k *ar = hw->priv;
2620
2621 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2622 ar_iter.ar = ar;
2623
2624 mutex_lock(&ar->conf_mutex);
2625 ieee80211_iterate_active_interfaces(hw, IEEE80211_IFACE_ITER_RESUME_ALL,
2626 ath10k_set_frag_iter, &ar_iter);
2627 mutex_unlock(&ar->conf_mutex);
2628
2629 return ar_iter.ret;
2630 }
2631
2632 static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
2633 {
2634 struct ath10k *ar = hw->priv;
2635 int ret;
2636
2637 /* mac80211 doesn't care if we really xmit queued frames or not
2638 * we'll collect those frames either way if we stop/delete vdevs */
2639 if (drop)
2640 return;
2641
2642 ret = wait_event_timeout(ar->htt->empty_tx_wq, ({
2643 bool empty;
2644 spin_lock_bh(&ar->htt->tx_lock);
2645 empty = bitmap_empty(ar->htt->used_msdu_ids,
2646 ar->htt->max_num_pending_tx);
2647 spin_unlock_bh(&ar->htt->tx_lock);
2648 (empty);
2649 }), ATH10K_FLUSH_TIMEOUT_HZ);
2650 if (ret <= 0)
2651 ath10k_warn("tx not flushed\n");
2652 }
2653
2654 /* TODO: Implement this function properly
2655 * For now it is needed to reply to Probe Requests in IBSS mode.
2656 * Propably we need this information from FW.
2657 */
2658 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
2659 {
2660 return 1;
2661 }
2662
2663 static const struct ieee80211_ops ath10k_ops = {
2664 .tx = ath10k_tx,
2665 .start = ath10k_start,
2666 .stop = ath10k_stop,
2667 .config = ath10k_config,
2668 .add_interface = ath10k_add_interface,
2669 .remove_interface = ath10k_remove_interface,
2670 .configure_filter = ath10k_configure_filter,
2671 .bss_info_changed = ath10k_bss_info_changed,
2672 .hw_scan = ath10k_hw_scan,
2673 .cancel_hw_scan = ath10k_cancel_hw_scan,
2674 .set_key = ath10k_set_key,
2675 .sta_state = ath10k_sta_state,
2676 .conf_tx = ath10k_conf_tx,
2677 .remain_on_channel = ath10k_remain_on_channel,
2678 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
2679 .set_rts_threshold = ath10k_set_rts_threshold,
2680 .set_frag_threshold = ath10k_set_frag_threshold,
2681 .flush = ath10k_flush,
2682 .tx_last_beacon = ath10k_tx_last_beacon,
2683 };
2684
2685 #define RATETAB_ENT(_rate, _rateid, _flags) { \
2686 .bitrate = (_rate), \
2687 .flags = (_flags), \
2688 .hw_value = (_rateid), \
2689 }
2690
2691 #define CHAN2G(_channel, _freq, _flags) { \
2692 .band = IEEE80211_BAND_2GHZ, \
2693 .hw_value = (_channel), \
2694 .center_freq = (_freq), \
2695 .flags = (_flags), \
2696 .max_antenna_gain = 0, \
2697 .max_power = 30, \
2698 }
2699
2700 #define CHAN5G(_channel, _freq, _flags) { \
2701 .band = IEEE80211_BAND_5GHZ, \
2702 .hw_value = (_channel), \
2703 .center_freq = (_freq), \
2704 .flags = (_flags), \
2705 .max_antenna_gain = 0, \
2706 .max_power = 30, \
2707 }
2708
2709 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
2710 CHAN2G(1, 2412, 0),
2711 CHAN2G(2, 2417, 0),
2712 CHAN2G(3, 2422, 0),
2713 CHAN2G(4, 2427, 0),
2714 CHAN2G(5, 2432, 0),
2715 CHAN2G(6, 2437, 0),
2716 CHAN2G(7, 2442, 0),
2717 CHAN2G(8, 2447, 0),
2718 CHAN2G(9, 2452, 0),
2719 CHAN2G(10, 2457, 0),
2720 CHAN2G(11, 2462, 0),
2721 CHAN2G(12, 2467, 0),
2722 CHAN2G(13, 2472, 0),
2723 CHAN2G(14, 2484, 0),
2724 };
2725
2726 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
2727 CHAN5G(36, 5180, 0),
2728 CHAN5G(40, 5200, 0),
2729 CHAN5G(44, 5220, 0),
2730 CHAN5G(48, 5240, 0),
2731 CHAN5G(52, 5260, 0),
2732 CHAN5G(56, 5280, 0),
2733 CHAN5G(60, 5300, 0),
2734 CHAN5G(64, 5320, 0),
2735 CHAN5G(100, 5500, 0),
2736 CHAN5G(104, 5520, 0),
2737 CHAN5G(108, 5540, 0),
2738 CHAN5G(112, 5560, 0),
2739 CHAN5G(116, 5580, 0),
2740 CHAN5G(120, 5600, 0),
2741 CHAN5G(124, 5620, 0),
2742 CHAN5G(128, 5640, 0),
2743 CHAN5G(132, 5660, 0),
2744 CHAN5G(136, 5680, 0),
2745 CHAN5G(140, 5700, 0),
2746 CHAN5G(149, 5745, 0),
2747 CHAN5G(153, 5765, 0),
2748 CHAN5G(157, 5785, 0),
2749 CHAN5G(161, 5805, 0),
2750 CHAN5G(165, 5825, 0),
2751 };
2752
2753 static struct ieee80211_rate ath10k_rates[] = {
2754 /* CCK */
2755 RATETAB_ENT(10, 0x82, 0),
2756 RATETAB_ENT(20, 0x84, 0),
2757 RATETAB_ENT(55, 0x8b, 0),
2758 RATETAB_ENT(110, 0x96, 0),
2759 /* OFDM */
2760 RATETAB_ENT(60, 0x0c, 0),
2761 RATETAB_ENT(90, 0x12, 0),
2762 RATETAB_ENT(120, 0x18, 0),
2763 RATETAB_ENT(180, 0x24, 0),
2764 RATETAB_ENT(240, 0x30, 0),
2765 RATETAB_ENT(360, 0x48, 0),
2766 RATETAB_ENT(480, 0x60, 0),
2767 RATETAB_ENT(540, 0x6c, 0),
2768 };
2769
2770 #define ath10k_a_rates (ath10k_rates + 4)
2771 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
2772 #define ath10k_g_rates (ath10k_rates + 0)
2773 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
2774
2775 struct ath10k *ath10k_mac_create(void)
2776 {
2777 struct ieee80211_hw *hw;
2778 struct ath10k *ar;
2779
2780 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
2781 if (!hw)
2782 return NULL;
2783
2784 ar = hw->priv;
2785 ar->hw = hw;
2786
2787 return ar;
2788 }
2789
2790 void ath10k_mac_destroy(struct ath10k *ar)
2791 {
2792 ieee80211_free_hw(ar->hw);
2793 }
2794
2795 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
2796 {
2797 .max = 8,
2798 .types = BIT(NL80211_IFTYPE_STATION)
2799 | BIT(NL80211_IFTYPE_P2P_CLIENT)
2800 | BIT(NL80211_IFTYPE_P2P_GO)
2801 | BIT(NL80211_IFTYPE_AP)
2802 }
2803 };
2804
2805 static const struct ieee80211_iface_combination ath10k_if_comb = {
2806 .limits = ath10k_if_limits,
2807 .n_limits = ARRAY_SIZE(ath10k_if_limits),
2808 .max_interfaces = 8,
2809 .num_different_channels = 1,
2810 .beacon_int_infra_match = true,
2811 };
2812
2813 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
2814 {
2815 struct ieee80211_sta_vht_cap vht_cap = {0};
2816 u16 mcs_map;
2817
2818 vht_cap.vht_supported = 1;
2819 vht_cap.cap = ar->vht_cap_info;
2820
2821 /* FIXME: check dynamically how many streams board supports */
2822 mcs_map = IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
2823 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
2824 IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
2825 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
2826 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
2827 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
2828 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
2829 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14;
2830
2831 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
2832 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
2833
2834 return vht_cap;
2835 }
2836
2837 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
2838 {
2839 int i;
2840 struct ieee80211_sta_ht_cap ht_cap = {0};
2841
2842 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
2843 return ht_cap;
2844
2845 ht_cap.ht_supported = 1;
2846 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
2847 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
2848 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2849 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
2850 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
2851
2852 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
2853 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
2854
2855 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
2856 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
2857
2858 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
2859 u32 smps;
2860
2861 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
2862 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
2863
2864 ht_cap.cap |= smps;
2865 }
2866
2867 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
2868 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
2869
2870 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
2871 u32 stbc;
2872
2873 stbc = ar->ht_cap_info;
2874 stbc &= WMI_HT_CAP_RX_STBC;
2875 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
2876 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
2877 stbc &= IEEE80211_HT_CAP_RX_STBC;
2878
2879 ht_cap.cap |= stbc;
2880 }
2881
2882 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
2883 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
2884
2885 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
2886 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
2887
2888 /* max AMSDU is implicitly taken from vht_cap_info */
2889 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
2890 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
2891
2892 for (i = 0; i < WMI_MAX_SPATIAL_STREAM; i++)
2893 ht_cap.mcs.rx_mask[i] = 0xFF;
2894
2895 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
2896
2897 return ht_cap;
2898 }
2899
2900
2901 static void ath10k_get_arvif_iter(void *data, u8 *mac,
2902 struct ieee80211_vif *vif)
2903 {
2904 struct ath10k_vif_iter *arvif_iter = data;
2905 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2906
2907 if (arvif->vdev_id == arvif_iter->vdev_id)
2908 arvif_iter->arvif = arvif;
2909 }
2910
2911 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
2912 {
2913 struct ath10k_vif_iter arvif_iter;
2914 u32 flags;
2915
2916 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
2917 arvif_iter.vdev_id = vdev_id;
2918
2919 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
2920 ieee80211_iterate_active_interfaces_atomic(ar->hw,
2921 flags,
2922 ath10k_get_arvif_iter,
2923 &arvif_iter);
2924 if (!arvif_iter.arvif) {
2925 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
2926 return NULL;
2927 }
2928
2929 return arvif_iter.arvif;
2930 }
2931
2932 int ath10k_mac_register(struct ath10k *ar)
2933 {
2934 struct ieee80211_supported_band *band;
2935 struct ieee80211_sta_vht_cap vht_cap;
2936 struct ieee80211_sta_ht_cap ht_cap;
2937 void *channels;
2938 int ret;
2939
2940 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
2941
2942 SET_IEEE80211_DEV(ar->hw, ar->dev);
2943
2944 ht_cap = ath10k_get_ht_cap(ar);
2945 vht_cap = ath10k_create_vht_cap(ar);
2946
2947 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
2948 channels = kmemdup(ath10k_2ghz_channels,
2949 sizeof(ath10k_2ghz_channels),
2950 GFP_KERNEL);
2951 if (!channels)
2952 return -ENOMEM;
2953
2954 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
2955 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
2956 band->channels = channels;
2957 band->n_bitrates = ath10k_g_rates_size;
2958 band->bitrates = ath10k_g_rates;
2959 band->ht_cap = ht_cap;
2960
2961 /* vht is not supported in 2.4 GHz */
2962
2963 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
2964 }
2965
2966 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
2967 channels = kmemdup(ath10k_5ghz_channels,
2968 sizeof(ath10k_5ghz_channels),
2969 GFP_KERNEL);
2970 if (!channels) {
2971 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
2972 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
2973 kfree(band->channels);
2974 }
2975 return -ENOMEM;
2976 }
2977
2978 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
2979 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
2980 band->channels = channels;
2981 band->n_bitrates = ath10k_a_rates_size;
2982 band->bitrates = ath10k_a_rates;
2983 band->ht_cap = ht_cap;
2984 band->vht_cap = vht_cap;
2985 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
2986 }
2987
2988 ar->hw->wiphy->interface_modes =
2989 BIT(NL80211_IFTYPE_STATION) |
2990 BIT(NL80211_IFTYPE_ADHOC) |
2991 BIT(NL80211_IFTYPE_AP) |
2992 BIT(NL80211_IFTYPE_P2P_CLIENT) |
2993 BIT(NL80211_IFTYPE_P2P_GO);
2994
2995 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2996 IEEE80211_HW_SUPPORTS_PS |
2997 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
2998 IEEE80211_HW_SUPPORTS_UAPSD |
2999 IEEE80211_HW_MFP_CAPABLE |
3000 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3001 IEEE80211_HW_HAS_RATE_CONTROL |
3002 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
3003 IEEE80211_HW_WANT_MONITOR_VIF |
3004 IEEE80211_HW_AP_LINK_PS;
3005
3006 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
3007 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
3008
3009 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
3010 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
3011 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
3012 }
3013
3014 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
3015 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
3016
3017 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
3018
3019 ar->hw->channel_change_time = 5000;
3020 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
3021
3022 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3023 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
3024
3025 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
3026 /*
3027 * on LL hardware queues are managed entirely by the FW
3028 * so we only advertise to mac we can do the queues thing
3029 */
3030 ar->hw->queues = 4;
3031
3032 ar->hw->wiphy->iface_combinations = &ath10k_if_comb;
3033 ar->hw->wiphy->n_iface_combinations = 1;
3034
3035 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
3036 ath10k_reg_notifier);
3037 if (ret) {
3038 ath10k_err("Regulatory initialization failed\n");
3039 return ret;
3040 }
3041
3042 ret = ieee80211_register_hw(ar->hw);
3043 if (ret) {
3044 ath10k_err("ieee80211 registration failed: %d\n", ret);
3045 return ret;
3046 }
3047
3048 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
3049 ret = regulatory_hint(ar->hw->wiphy,
3050 ar->ath_common.regulatory.alpha2);
3051 if (ret)
3052 goto exit;
3053 }
3054
3055 return 0;
3056 exit:
3057 ieee80211_unregister_hw(ar->hw);
3058 return ret;
3059 }
3060
3061 void ath10k_mac_unregister(struct ath10k *ar)
3062 {
3063 ieee80211_unregister_hw(ar->hw);
3064
3065 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3066 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3067
3068 SET_IEEE80211_DEV(ar->hw, NULL);
3069 }
CRIS linux kernel tree