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


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