projects / deliverable / linux.git / blob
? search:


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