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