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