2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
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.
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.
20 #include <net/mac80211.h>
21 #include <linux/etherdevice.h>
35 static int ath10k_send_key(struct ath10k_vif *arvif,
36 struct ieee80211_key_conf *key,
40 struct ath10k *ar = arvif->ar;
41 struct wmi_vdev_install_key_arg arg = {
42 .vdev_id = arvif->vdev_id,
43 .key_idx = key->keyidx,
44 .key_len = key->keylen,
49 lockdep_assert_held(&arvif->ar->conf_mutex);
51 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
52 arg.key_flags = WMI_KEY_PAIRWISE;
54 arg.key_flags = WMI_KEY_GROUP;
56 switch (key->cipher) {
57 case WLAN_CIPHER_SUITE_CCMP:
58 arg.key_cipher = WMI_CIPHER_AES_CCM;
59 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
60 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
62 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
64 case WLAN_CIPHER_SUITE_TKIP:
65 arg.key_cipher = WMI_CIPHER_TKIP;
66 arg.key_txmic_len = 8;
67 arg.key_rxmic_len = 8;
69 case WLAN_CIPHER_SUITE_WEP40:
70 case WLAN_CIPHER_SUITE_WEP104:
71 arg.key_cipher = WMI_CIPHER_WEP;
72 /* AP/IBSS mode requires self-key to be groupwise
73 * Otherwise pairwise key must be set */
74 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
75 arg.key_flags = WMI_KEY_PAIRWISE;
78 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
82 if (cmd == DISABLE_KEY) {
83 arg.key_cipher = WMI_CIPHER_NONE;
87 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
90 static int ath10k_install_key(struct ath10k_vif *arvif,
91 struct ieee80211_key_conf *key,
95 struct ath10k *ar = arvif->ar;
98 lockdep_assert_held(&ar->conf_mutex);
100 reinit_completion(&ar->install_key_done);
102 ret = ath10k_send_key(arvif, key, cmd, macaddr);
106 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
113 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
116 struct ath10k *ar = arvif->ar;
117 struct ath10k_peer *peer;
121 lockdep_assert_held(&ar->conf_mutex);
123 spin_lock_bh(&ar->data_lock);
124 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
125 spin_unlock_bh(&ar->data_lock);
130 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
131 if (arvif->wep_keys[i] == NULL)
134 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
139 peer->keys[i] = arvif->wep_keys[i];
145 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
148 struct ath10k *ar = arvif->ar;
149 struct ath10k_peer *peer;
154 lockdep_assert_held(&ar->conf_mutex);
156 spin_lock_bh(&ar->data_lock);
157 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
158 spin_unlock_bh(&ar->data_lock);
163 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
164 if (peer->keys[i] == NULL)
167 ret = ath10k_install_key(arvif, peer->keys[i],
169 if (ret && first_errno == 0)
173 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
176 peer->keys[i] = NULL;
182 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
183 struct ieee80211_key_conf *key)
185 struct ath10k *ar = arvif->ar;
186 struct ath10k_peer *peer;
192 lockdep_assert_held(&ar->conf_mutex);
195 /* since ath10k_install_key we can't hold data_lock all the
196 * time, so we try to remove the keys incrementally */
197 spin_lock_bh(&ar->data_lock);
199 list_for_each_entry(peer, &ar->peers, list) {
200 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
201 if (peer->keys[i] == key) {
202 ether_addr_copy(addr, peer->addr);
203 peer->keys[i] = NULL;
208 if (i < ARRAY_SIZE(peer->keys))
211 spin_unlock_bh(&ar->data_lock);
213 if (i == ARRAY_SIZE(peer->keys))
216 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
217 if (ret && first_errno == 0)
221 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
228 /*********************/
229 /* General utilities */
230 /*********************/
232 static inline enum wmi_phy_mode
233 chan_to_phymode(const struct cfg80211_chan_def *chandef)
235 enum wmi_phy_mode phymode = MODE_UNKNOWN;
237 switch (chandef->chan->band) {
238 case IEEE80211_BAND_2GHZ:
239 switch (chandef->width) {
240 case NL80211_CHAN_WIDTH_20_NOHT:
243 case NL80211_CHAN_WIDTH_20:
244 phymode = MODE_11NG_HT20;
246 case NL80211_CHAN_WIDTH_40:
247 phymode = MODE_11NG_HT40;
249 case NL80211_CHAN_WIDTH_5:
250 case NL80211_CHAN_WIDTH_10:
251 case NL80211_CHAN_WIDTH_80:
252 case NL80211_CHAN_WIDTH_80P80:
253 case NL80211_CHAN_WIDTH_160:
254 phymode = MODE_UNKNOWN;
258 case IEEE80211_BAND_5GHZ:
259 switch (chandef->width) {
260 case NL80211_CHAN_WIDTH_20_NOHT:
263 case NL80211_CHAN_WIDTH_20:
264 phymode = MODE_11NA_HT20;
266 case NL80211_CHAN_WIDTH_40:
267 phymode = MODE_11NA_HT40;
269 case NL80211_CHAN_WIDTH_80:
270 phymode = MODE_11AC_VHT80;
272 case NL80211_CHAN_WIDTH_5:
273 case NL80211_CHAN_WIDTH_10:
274 case NL80211_CHAN_WIDTH_80P80:
275 case NL80211_CHAN_WIDTH_160:
276 phymode = MODE_UNKNOWN;
284 WARN_ON(phymode == MODE_UNKNOWN);
288 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
291 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
292 * 0 for no restriction
301 switch (mpdudensity) {
307 /* Our lower layer calculations limit our precision to
323 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
327 lockdep_assert_held(&ar->conf_mutex);
329 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
331 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
336 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
338 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
342 spin_lock_bh(&ar->data_lock);
344 spin_unlock_bh(&ar->data_lock);
349 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
351 struct ath10k *ar = arvif->ar;
355 param = ar->wmi.pdev_param->sta_kickout_th;
356 ret = ath10k_wmi_pdev_set_param(ar, param,
357 ATH10K_KICKOUT_THRESHOLD);
359 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
360 arvif->vdev_id, ret);
364 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
365 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
366 ATH10K_KEEPALIVE_MIN_IDLE);
368 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
369 arvif->vdev_id, ret);
373 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
374 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
375 ATH10K_KEEPALIVE_MAX_IDLE);
377 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
378 arvif->vdev_id, ret);
382 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
383 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
384 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
386 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
387 arvif->vdev_id, ret);
394 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
396 struct ath10k *ar = arvif->ar;
399 if (value != 0xFFFFFFFF)
400 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
403 vdev_param = ar->wmi.vdev_param->rts_threshold;
404 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
407 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
409 struct ath10k *ar = arvif->ar;
412 if (value != 0xFFFFFFFF)
413 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
414 ATH10K_FRAGMT_THRESHOLD_MIN,
415 ATH10K_FRAGMT_THRESHOLD_MAX);
417 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
418 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
421 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
425 lockdep_assert_held(&ar->conf_mutex);
427 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
431 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
435 spin_lock_bh(&ar->data_lock);
437 spin_unlock_bh(&ar->data_lock);
442 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
444 struct ath10k_peer *peer, *tmp;
446 lockdep_assert_held(&ar->conf_mutex);
448 spin_lock_bh(&ar->data_lock);
449 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
450 if (peer->vdev_id != vdev_id)
453 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
454 peer->addr, vdev_id);
456 list_del(&peer->list);
460 spin_unlock_bh(&ar->data_lock);
463 static void ath10k_peer_cleanup_all(struct ath10k *ar)
465 struct ath10k_peer *peer, *tmp;
467 lockdep_assert_held(&ar->conf_mutex);
469 spin_lock_bh(&ar->data_lock);
470 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
471 list_del(&peer->list);
475 spin_unlock_bh(&ar->data_lock);
478 /************************/
479 /* Interface management */
480 /************************/
482 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
484 struct ath10k *ar = arvif->ar;
486 lockdep_assert_held(&ar->data_lock);
491 if (!arvif->beacon_buf)
492 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
493 arvif->beacon->len, DMA_TO_DEVICE);
495 dev_kfree_skb_any(arvif->beacon);
497 arvif->beacon = NULL;
498 arvif->beacon_sent = false;
501 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
503 struct ath10k *ar = arvif->ar;
505 lockdep_assert_held(&ar->data_lock);
507 ath10k_mac_vif_beacon_free(arvif);
509 if (arvif->beacon_buf) {
510 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
511 arvif->beacon_buf, arvif->beacon_paddr);
512 arvif->beacon_buf = NULL;
516 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
520 lockdep_assert_held(&ar->conf_mutex);
522 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
525 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
526 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
533 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
535 struct cfg80211_chan_def *chandef = &ar->chandef;
536 struct ieee80211_channel *channel = chandef->chan;
537 struct wmi_vdev_start_request_arg arg = {};
540 lockdep_assert_held(&ar->conf_mutex);
542 arg.vdev_id = vdev_id;
543 arg.channel.freq = channel->center_freq;
544 arg.channel.band_center_freq1 = chandef->center_freq1;
546 /* TODO setup this dynamically, what in case we
547 don't have any vifs? */
548 arg.channel.mode = chan_to_phymode(chandef);
549 arg.channel.chan_radar =
550 !!(channel->flags & IEEE80211_CHAN_RADAR);
552 arg.channel.min_power = 0;
553 arg.channel.max_power = channel->max_power * 2;
554 arg.channel.max_reg_power = channel->max_reg_power * 2;
555 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
557 reinit_completion(&ar->vdev_setup_done);
559 ret = ath10k_wmi_vdev_start(ar, &arg);
561 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
566 ret = ath10k_vdev_setup_sync(ar);
568 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i: %d\n",
573 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
575 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
580 ar->monitor_vdev_id = vdev_id;
582 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
583 ar->monitor_vdev_id);
587 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
589 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
590 ar->monitor_vdev_id, ret);
595 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
599 lockdep_assert_held(&ar->conf_mutex);
601 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
603 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
604 ar->monitor_vdev_id, ret);
606 reinit_completion(&ar->vdev_setup_done);
608 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
610 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
611 ar->monitor_vdev_id, ret);
613 ret = ath10k_vdev_setup_sync(ar);
615 ath10k_warn(ar, "failed to synchronise monitor vdev %i: %d\n",
616 ar->monitor_vdev_id, ret);
618 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
619 ar->monitor_vdev_id);
623 static int ath10k_monitor_vdev_create(struct ath10k *ar)
627 lockdep_assert_held(&ar->conf_mutex);
629 if (ar->free_vdev_map == 0) {
630 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
634 bit = __ffs64(ar->free_vdev_map);
636 ar->monitor_vdev_id = bit;
638 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
639 WMI_VDEV_TYPE_MONITOR,
642 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
643 ar->monitor_vdev_id, ret);
647 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
648 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
649 ar->monitor_vdev_id);
654 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
658 lockdep_assert_held(&ar->conf_mutex);
660 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
662 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
663 ar->monitor_vdev_id, ret);
667 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
669 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
670 ar->monitor_vdev_id);
674 static int ath10k_monitor_start(struct ath10k *ar)
678 lockdep_assert_held(&ar->conf_mutex);
680 ret = ath10k_monitor_vdev_create(ar);
682 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
686 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
688 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
689 ath10k_monitor_vdev_delete(ar);
693 ar->monitor_started = true;
694 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
699 static int ath10k_monitor_stop(struct ath10k *ar)
703 lockdep_assert_held(&ar->conf_mutex);
705 ret = ath10k_monitor_vdev_stop(ar);
707 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
711 ret = ath10k_monitor_vdev_delete(ar);
713 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
717 ar->monitor_started = false;
718 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
723 static int ath10k_monitor_recalc(struct ath10k *ar)
727 lockdep_assert_held(&ar->conf_mutex);
729 should_start = ar->monitor ||
730 ar->filter_flags & FIF_PROMISC_IN_BSS ||
731 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
733 ath10k_dbg(ar, ATH10K_DBG_MAC,
734 "mac monitor recalc started? %d should? %d\n",
735 ar->monitor_started, should_start);
737 if (should_start == ar->monitor_started)
741 return ath10k_monitor_start(ar);
743 return ath10k_monitor_stop(ar);
746 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
748 struct ath10k *ar = arvif->ar;
749 u32 vdev_param, rts_cts = 0;
751 lockdep_assert_held(&ar->conf_mutex);
753 vdev_param = ar->wmi.vdev_param->enable_rtscts;
755 if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
756 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
758 if (arvif->num_legacy_stations > 0)
759 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
762 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
766 static int ath10k_start_cac(struct ath10k *ar)
770 lockdep_assert_held(&ar->conf_mutex);
772 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
774 ret = ath10k_monitor_recalc(ar);
776 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
777 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
781 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
782 ar->monitor_vdev_id);
787 static int ath10k_stop_cac(struct ath10k *ar)
789 lockdep_assert_held(&ar->conf_mutex);
791 /* CAC is not running - do nothing */
792 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
795 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
796 ath10k_monitor_stop(ar);
798 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
803 static void ath10k_recalc_radar_detection(struct ath10k *ar)
807 lockdep_assert_held(&ar->conf_mutex);
811 if (!ar->radar_enabled)
814 if (ar->num_started_vdevs > 0)
817 ret = ath10k_start_cac(ar);
820 * Not possible to start CAC on current channel so starting
821 * radiation is not allowed, make this channel DFS_UNAVAILABLE
822 * by indicating that radar was detected.
824 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
825 ieee80211_radar_detected(ar->hw);
829 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, bool restart)
831 struct ath10k *ar = arvif->ar;
832 struct cfg80211_chan_def *chandef = &ar->chandef;
833 struct wmi_vdev_start_request_arg arg = {};
836 lockdep_assert_held(&ar->conf_mutex);
838 reinit_completion(&ar->vdev_setup_done);
840 arg.vdev_id = arvif->vdev_id;
841 arg.dtim_period = arvif->dtim_period;
842 arg.bcn_intval = arvif->beacon_interval;
844 arg.channel.freq = chandef->chan->center_freq;
845 arg.channel.band_center_freq1 = chandef->center_freq1;
846 arg.channel.mode = chan_to_phymode(chandef);
848 arg.channel.min_power = 0;
849 arg.channel.max_power = chandef->chan->max_power * 2;
850 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
851 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
853 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
854 arg.ssid = arvif->u.ap.ssid;
855 arg.ssid_len = arvif->u.ap.ssid_len;
856 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
858 /* For now allow DFS for AP mode */
859 arg.channel.chan_radar =
860 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
861 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
862 arg.ssid = arvif->vif->bss_conf.ssid;
863 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
866 ath10k_dbg(ar, ATH10K_DBG_MAC,
867 "mac vdev %d start center_freq %d phymode %s\n",
868 arg.vdev_id, arg.channel.freq,
869 ath10k_wmi_phymode_str(arg.channel.mode));
872 ret = ath10k_wmi_vdev_restart(ar, &arg);
874 ret = ath10k_wmi_vdev_start(ar, &arg);
877 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
882 ret = ath10k_vdev_setup_sync(ar);
884 ath10k_warn(ar, "failed to synchronise setup for vdev %i: %d\n",
889 ar->num_started_vdevs++;
890 ath10k_recalc_radar_detection(ar);
895 static int ath10k_vdev_start(struct ath10k_vif *arvif)
897 return ath10k_vdev_start_restart(arvif, false);
900 static int ath10k_vdev_restart(struct ath10k_vif *arvif)
902 return ath10k_vdev_start_restart(arvif, true);
905 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
907 struct ath10k *ar = arvif->ar;
910 lockdep_assert_held(&ar->conf_mutex);
912 reinit_completion(&ar->vdev_setup_done);
914 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
916 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
917 arvif->vdev_id, ret);
921 ret = ath10k_vdev_setup_sync(ar);
923 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
924 arvif->vdev_id, ret);
928 WARN_ON(ar->num_started_vdevs == 0);
930 if (ar->num_started_vdevs != 0) {
931 ar->num_started_vdevs--;
932 ath10k_recalc_radar_detection(ar);
938 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
939 struct ieee80211_bss_conf *info)
941 struct ath10k *ar = arvif->ar;
944 lockdep_assert_held(&arvif->ar->conf_mutex);
946 if (!info->enable_beacon) {
947 ath10k_vdev_stop(arvif);
949 arvif->is_started = false;
950 arvif->is_up = false;
952 spin_lock_bh(&arvif->ar->data_lock);
953 ath10k_mac_vif_beacon_free(arvif);
954 spin_unlock_bh(&arvif->ar->data_lock);
959 arvif->tx_seq_no = 0x1000;
961 ret = ath10k_vdev_start(arvif);
966 ether_addr_copy(arvif->bssid, info->bssid);
968 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
971 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
972 arvif->vdev_id, ret);
973 ath10k_vdev_stop(arvif);
977 arvif->is_started = true;
980 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
983 static void ath10k_control_ibss(struct ath10k_vif *arvif,
984 struct ieee80211_bss_conf *info,
985 const u8 self_peer[ETH_ALEN])
987 struct ath10k *ar = arvif->ar;
991 lockdep_assert_held(&arvif->ar->conf_mutex);
993 if (!info->ibss_joined) {
994 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
996 ath10k_warn(ar, "failed to delete IBSS self peer %pM for vdev %d: %d\n",
997 self_peer, arvif->vdev_id, ret);
999 if (is_zero_ether_addr(arvif->bssid))
1002 memset(arvif->bssid, 0, ETH_ALEN);
1007 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
1009 ath10k_warn(ar, "failed to create IBSS self peer %pM for vdev %d: %d\n",
1010 self_peer, arvif->vdev_id, ret);
1014 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1015 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1016 ATH10K_DEFAULT_ATIM);
1018 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1019 arvif->vdev_id, ret);
1023 * Review this when mac80211 gains per-interface powersave support.
1025 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1027 struct ath10k *ar = arvif->ar;
1028 struct ieee80211_conf *conf = &ar->hw->conf;
1029 enum wmi_sta_powersave_param param;
1030 enum wmi_sta_ps_mode psmode;
1033 lockdep_assert_held(&arvif->ar->conf_mutex);
1035 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1038 if (conf->flags & IEEE80211_CONF_PS) {
1039 psmode = WMI_STA_PS_MODE_ENABLED;
1040 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1042 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1043 conf->dynamic_ps_timeout);
1045 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1046 arvif->vdev_id, ret);
1050 psmode = WMI_STA_PS_MODE_DISABLED;
1053 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1054 arvif->vdev_id, psmode ? "enable" : "disable");
1056 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1058 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1059 psmode, arvif->vdev_id, ret);
1066 /**********************/
1067 /* Station management */
1068 /**********************/
1070 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1071 struct ieee80211_vif *vif)
1073 /* Some firmware revisions have unstable STA powersave when listen
1074 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1075 * generate NullFunc frames properly even if buffered frames have been
1076 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1077 * buffered frames. Often pinging the device from AP would simply fail.
1079 * As a workaround set it to 1.
1081 if (vif->type == NL80211_IFTYPE_STATION)
1084 return ar->hw->conf.listen_interval;
1087 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1088 struct ieee80211_vif *vif,
1089 struct ieee80211_sta *sta,
1090 struct wmi_peer_assoc_complete_arg *arg)
1092 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1094 lockdep_assert_held(&ar->conf_mutex);
1096 ether_addr_copy(arg->addr, sta->addr);
1097 arg->vdev_id = arvif->vdev_id;
1098 arg->peer_aid = sta->aid;
1099 arg->peer_flags |= WMI_PEER_AUTH;
1100 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1101 arg->peer_num_spatial_streams = 1;
1102 arg->peer_caps = vif->bss_conf.assoc_capability;
1105 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1106 struct ieee80211_vif *vif,
1107 struct wmi_peer_assoc_complete_arg *arg)
1109 struct ieee80211_bss_conf *info = &vif->bss_conf;
1110 struct cfg80211_bss *bss;
1111 const u8 *rsnie = NULL;
1112 const u8 *wpaie = NULL;
1114 lockdep_assert_held(&ar->conf_mutex);
1116 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1117 info->bssid, NULL, 0, 0, 0);
1119 const struct cfg80211_bss_ies *ies;
1122 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1124 ies = rcu_dereference(bss->ies);
1126 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1127 WLAN_OUI_TYPE_MICROSOFT_WPA,
1131 cfg80211_put_bss(ar->hw->wiphy, bss);
1134 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1135 if (rsnie || wpaie) {
1136 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1137 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1141 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1142 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1146 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1147 struct ieee80211_sta *sta,
1148 struct wmi_peer_assoc_complete_arg *arg)
1150 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1151 const struct ieee80211_supported_band *sband;
1152 const struct ieee80211_rate *rates;
1156 lockdep_assert_held(&ar->conf_mutex);
1158 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1159 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1160 rates = sband->bitrates;
1162 rateset->num_rates = 0;
1164 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1165 if (!(ratemask & 1))
1168 rateset->rates[rateset->num_rates] = rates->hw_value;
1169 rateset->num_rates++;
1173 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1174 struct ieee80211_sta *sta,
1175 struct wmi_peer_assoc_complete_arg *arg)
1177 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1181 lockdep_assert_held(&ar->conf_mutex);
1183 if (!ht_cap->ht_supported)
1186 arg->peer_flags |= WMI_PEER_HT;
1187 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1188 ht_cap->ampdu_factor)) - 1;
1190 arg->peer_mpdu_density =
1191 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1193 arg->peer_ht_caps = ht_cap->cap;
1194 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1196 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1197 arg->peer_flags |= WMI_PEER_LDPC;
1199 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1200 arg->peer_flags |= WMI_PEER_40MHZ;
1201 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1204 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1205 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1207 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1208 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1210 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1211 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1212 arg->peer_flags |= WMI_PEER_STBC;
1215 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1216 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1217 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1218 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1219 arg->peer_rate_caps |= stbc;
1220 arg->peer_flags |= WMI_PEER_STBC;
1223 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1224 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1225 else if (ht_cap->mcs.rx_mask[1])
1226 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1228 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1229 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1230 arg->peer_ht_rates.rates[n++] = i;
1233 * This is a workaround for HT-enabled STAs which break the spec
1234 * and have no HT capabilities RX mask (no HT RX MCS map).
1236 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1237 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1239 * Firmware asserts if such situation occurs.
1242 arg->peer_ht_rates.num_rates = 8;
1243 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1244 arg->peer_ht_rates.rates[i] = i;
1246 arg->peer_ht_rates.num_rates = n;
1247 arg->peer_num_spatial_streams = sta->rx_nss;
1250 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1252 arg->peer_ht_rates.num_rates,
1253 arg->peer_num_spatial_streams);
1256 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1257 struct ath10k_vif *arvif,
1258 struct ieee80211_sta *sta)
1264 lockdep_assert_held(&ar->conf_mutex);
1266 if (sta->wme && sta->uapsd_queues) {
1267 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1268 sta->uapsd_queues, sta->max_sp);
1270 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1271 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1272 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1273 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1274 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1275 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1276 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1277 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1278 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1279 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1280 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1281 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1283 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1284 max_sp = sta->max_sp;
1286 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1288 WMI_AP_PS_PEER_PARAM_UAPSD,
1291 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
1292 arvif->vdev_id, ret);
1296 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1298 WMI_AP_PS_PEER_PARAM_MAX_SP,
1301 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
1302 arvif->vdev_id, ret);
1306 /* TODO setup this based on STA listen interval and
1307 beacon interval. Currently we don't know
1308 sta->listen_interval - mac80211 patch required.
1309 Currently use 10 seconds */
1310 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1311 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1314 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
1315 arvif->vdev_id, ret);
1323 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1324 struct ieee80211_sta *sta,
1325 struct wmi_peer_assoc_complete_arg *arg)
1327 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1330 if (!vht_cap->vht_supported)
1333 arg->peer_flags |= WMI_PEER_VHT;
1334 arg->peer_vht_caps = vht_cap->cap;
1336 ampdu_factor = (vht_cap->cap &
1337 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1338 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1340 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1341 * zero in VHT IE. Using it would result in degraded throughput.
1342 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1343 * it if VHT max_mpdu is smaller. */
1344 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1345 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1346 ampdu_factor)) - 1);
1348 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1349 arg->peer_flags |= WMI_PEER_80MHZ;
1351 arg->peer_vht_rates.rx_max_rate =
1352 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1353 arg->peer_vht_rates.rx_mcs_set =
1354 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1355 arg->peer_vht_rates.tx_max_rate =
1356 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1357 arg->peer_vht_rates.tx_mcs_set =
1358 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1360 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1361 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1364 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1365 struct ieee80211_vif *vif,
1366 struct ieee80211_sta *sta,
1367 struct wmi_peer_assoc_complete_arg *arg)
1369 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1371 switch (arvif->vdev_type) {
1372 case WMI_VDEV_TYPE_AP:
1374 arg->peer_flags |= WMI_PEER_QOS;
1376 if (sta->wme && sta->uapsd_queues) {
1377 arg->peer_flags |= WMI_PEER_APSD;
1378 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1381 case WMI_VDEV_TYPE_STA:
1382 if (vif->bss_conf.qos)
1383 arg->peer_flags |= WMI_PEER_QOS;
1390 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1391 struct ieee80211_vif *vif,
1392 struct ieee80211_sta *sta,
1393 struct wmi_peer_assoc_complete_arg *arg)
1395 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1397 switch (ar->hw->conf.chandef.chan->band) {
1398 case IEEE80211_BAND_2GHZ:
1399 if (sta->ht_cap.ht_supported) {
1400 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1401 phymode = MODE_11NG_HT40;
1403 phymode = MODE_11NG_HT20;
1409 case IEEE80211_BAND_5GHZ:
1413 if (sta->vht_cap.vht_supported) {
1414 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1415 phymode = MODE_11AC_VHT80;
1416 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1417 phymode = MODE_11AC_VHT40;
1418 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1419 phymode = MODE_11AC_VHT20;
1420 } else if (sta->ht_cap.ht_supported) {
1421 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1422 phymode = MODE_11NA_HT40;
1424 phymode = MODE_11NA_HT20;
1434 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1435 sta->addr, ath10k_wmi_phymode_str(phymode));
1437 arg->peer_phymode = phymode;
1438 WARN_ON(phymode == MODE_UNKNOWN);
1441 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1442 struct ieee80211_vif *vif,
1443 struct ieee80211_sta *sta,
1444 struct wmi_peer_assoc_complete_arg *arg)
1446 lockdep_assert_held(&ar->conf_mutex);
1448 memset(arg, 0, sizeof(*arg));
1450 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
1451 ath10k_peer_assoc_h_crypto(ar, vif, arg);
1452 ath10k_peer_assoc_h_rates(ar, sta, arg);
1453 ath10k_peer_assoc_h_ht(ar, sta, arg);
1454 ath10k_peer_assoc_h_vht(ar, sta, arg);
1455 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
1456 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
1461 static const u32 ath10k_smps_map[] = {
1462 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1463 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1464 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1465 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1468 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1470 const struct ieee80211_sta_ht_cap *ht_cap)
1474 if (!ht_cap->ht_supported)
1477 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1478 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1480 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1483 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1484 WMI_PEER_SMPS_STATE,
1485 ath10k_smps_map[smps]);
1488 /* can be called only in mac80211 callbacks due to `key_count` usage */
1489 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1490 struct ieee80211_vif *vif,
1491 struct ieee80211_bss_conf *bss_conf)
1493 struct ath10k *ar = hw->priv;
1494 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1495 struct ieee80211_sta_ht_cap ht_cap;
1496 struct wmi_peer_assoc_complete_arg peer_arg;
1497 struct ieee80211_sta *ap_sta;
1500 lockdep_assert_held(&ar->conf_mutex);
1502 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
1503 arvif->vdev_id, arvif->bssid, arvif->aid);
1507 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1509 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
1510 bss_conf->bssid, arvif->vdev_id);
1515 /* ap_sta must be accessed only within rcu section which must be left
1516 * before calling ath10k_setup_peer_smps() which might sleep. */
1517 ht_cap = ap_sta->ht_cap;
1519 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
1521 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
1522 bss_conf->bssid, arvif->vdev_id, ret);
1529 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1531 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
1532 bss_conf->bssid, arvif->vdev_id, ret);
1536 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1538 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
1539 arvif->vdev_id, ret);
1543 ath10k_dbg(ar, ATH10K_DBG_MAC,
1544 "mac vdev %d up (associated) bssid %pM aid %d\n",
1545 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1547 WARN_ON(arvif->is_up);
1549 arvif->aid = bss_conf->aid;
1550 ether_addr_copy(arvif->bssid, bss_conf->bssid);
1552 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1554 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
1555 arvif->vdev_id, ret);
1559 arvif->is_up = true;
1562 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1563 struct ieee80211_vif *vif)
1565 struct ath10k *ar = hw->priv;
1566 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1569 lockdep_assert_held(&ar->conf_mutex);
1571 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
1572 arvif->vdev_id, arvif->bssid);
1574 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1576 ath10k_warn(ar, "faield to down vdev %i: %d\n",
1577 arvif->vdev_id, ret);
1579 arvif->def_wep_key_idx = 0;
1580 arvif->is_up = false;
1583 static int ath10k_station_assoc(struct ath10k *ar,
1584 struct ieee80211_vif *vif,
1585 struct ieee80211_sta *sta,
1588 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1589 struct wmi_peer_assoc_complete_arg peer_arg;
1592 lockdep_assert_held(&ar->conf_mutex);
1594 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
1596 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1597 sta->addr, arvif->vdev_id, ret);
1601 peer_arg.peer_reassoc = reassoc;
1602 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1604 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
1605 sta->addr, arvif->vdev_id, ret);
1609 /* Re-assoc is run only to update supported rates for given station. It
1610 * doesn't make much sense to reconfigure the peer completely.
1613 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
1616 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
1617 arvif->vdev_id, ret);
1621 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1623 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
1624 sta->addr, arvif->vdev_id, ret);
1629 arvif->num_legacy_stations++;
1630 ret = ath10k_recalc_rtscts_prot(arvif);
1632 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1633 arvif->vdev_id, ret);
1638 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1640 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
1641 arvif->vdev_id, ret);
1649 static int ath10k_station_disassoc(struct ath10k *ar,
1650 struct ieee80211_vif *vif,
1651 struct ieee80211_sta *sta)
1653 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1656 lockdep_assert_held(&ar->conf_mutex);
1659 arvif->num_legacy_stations--;
1660 ret = ath10k_recalc_rtscts_prot(arvif);
1662 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1663 arvif->vdev_id, ret);
1668 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1670 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
1671 arvif->vdev_id, ret);
1682 static int ath10k_update_channel_list(struct ath10k *ar)
1684 struct ieee80211_hw *hw = ar->hw;
1685 struct ieee80211_supported_band **bands;
1686 enum ieee80211_band band;
1687 struct ieee80211_channel *channel;
1688 struct wmi_scan_chan_list_arg arg = {0};
1689 struct wmi_channel_arg *ch;
1695 lockdep_assert_held(&ar->conf_mutex);
1697 bands = hw->wiphy->bands;
1698 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1702 for (i = 0; i < bands[band]->n_channels; i++) {
1703 if (bands[band]->channels[i].flags &
1704 IEEE80211_CHAN_DISABLED)
1711 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1712 arg.channels = kzalloc(len, GFP_KERNEL);
1717 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1721 for (i = 0; i < bands[band]->n_channels; i++) {
1722 channel = &bands[band]->channels[i];
1724 if (channel->flags & IEEE80211_CHAN_DISABLED)
1727 ch->allow_ht = true;
1729 /* FIXME: when should we really allow VHT? */
1730 ch->allow_vht = true;
1733 !(channel->flags & IEEE80211_CHAN_NO_IR);
1736 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1739 !!(channel->flags & IEEE80211_CHAN_RADAR);
1741 passive = channel->flags & IEEE80211_CHAN_NO_IR;
1742 ch->passive = passive;
1744 ch->freq = channel->center_freq;
1745 ch->band_center_freq1 = channel->center_freq;
1747 ch->max_power = channel->max_power * 2;
1748 ch->max_reg_power = channel->max_reg_power * 2;
1749 ch->max_antenna_gain = channel->max_antenna_gain * 2;
1750 ch->reg_class_id = 0; /* FIXME */
1752 /* FIXME: why use only legacy modes, why not any
1753 * HT/VHT modes? Would that even make any
1755 if (channel->band == IEEE80211_BAND_2GHZ)
1756 ch->mode = MODE_11G;
1758 ch->mode = MODE_11A;
1760 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1763 ath10k_dbg(ar, ATH10K_DBG_WMI,
1764 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1765 ch - arg.channels, arg.n_channels,
1766 ch->freq, ch->max_power, ch->max_reg_power,
1767 ch->max_antenna_gain, ch->mode);
1773 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1774 kfree(arg.channels);
1779 static enum wmi_dfs_region
1780 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1782 switch (dfs_region) {
1783 case NL80211_DFS_UNSET:
1784 return WMI_UNINIT_DFS_DOMAIN;
1785 case NL80211_DFS_FCC:
1786 return WMI_FCC_DFS_DOMAIN;
1787 case NL80211_DFS_ETSI:
1788 return WMI_ETSI_DFS_DOMAIN;
1789 case NL80211_DFS_JP:
1790 return WMI_MKK4_DFS_DOMAIN;
1792 return WMI_UNINIT_DFS_DOMAIN;
1795 static void ath10k_regd_update(struct ath10k *ar)
1797 struct reg_dmn_pair_mapping *regpair;
1799 enum wmi_dfs_region wmi_dfs_reg;
1800 enum nl80211_dfs_regions nl_dfs_reg;
1802 lockdep_assert_held(&ar->conf_mutex);
1804 ret = ath10k_update_channel_list(ar);
1806 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
1808 regpair = ar->ath_common.regulatory.regpair;
1810 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1811 nl_dfs_reg = ar->dfs_detector->region;
1812 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1814 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1817 /* Target allows setting up per-band regdomain but ath_common provides
1818 * a combined one only */
1819 ret = ath10k_wmi_pdev_set_regdomain(ar,
1820 regpair->reg_domain,
1821 regpair->reg_domain, /* 2ghz */
1822 regpair->reg_domain, /* 5ghz */
1823 regpair->reg_2ghz_ctl,
1824 regpair->reg_5ghz_ctl,
1827 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
1830 static void ath10k_reg_notifier(struct wiphy *wiphy,
1831 struct regulatory_request *request)
1833 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1834 struct ath10k *ar = hw->priv;
1837 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1839 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1840 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1841 request->dfs_region);
1842 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1843 request->dfs_region);
1845 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
1846 request->dfs_region);
1849 mutex_lock(&ar->conf_mutex);
1850 if (ar->state == ATH10K_STATE_ON)
1851 ath10k_regd_update(ar);
1852 mutex_unlock(&ar->conf_mutex);
1859 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1861 if (ieee80211_is_mgmt(hdr->frame_control))
1862 return HTT_DATA_TX_EXT_TID_MGMT;
1864 if (!ieee80211_is_data_qos(hdr->frame_control))
1865 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1867 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1868 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1870 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1873 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
1876 return ath10k_vif_to_arvif(vif)->vdev_id;
1878 if (ar->monitor_started)
1879 return ar->monitor_vdev_id;
1881 ath10k_warn(ar, "failed to resolve vdev id\n");
1885 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1886 * Control in the header.
1888 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
1890 struct ieee80211_hdr *hdr = (void *)skb->data;
1891 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
1894 if (!ieee80211_is_data_qos(hdr->frame_control))
1897 qos_ctl = ieee80211_get_qos_ctl(hdr);
1898 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1899 skb->data, (void *)qos_ctl - (void *)skb->data);
1900 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1902 /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1903 * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1904 * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1905 * it is safe to downgrade to NullFunc.
1907 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
1908 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1909 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1913 static void ath10k_tx_wep_key_work(struct work_struct *work)
1915 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1917 struct ath10k *ar = arvif->ar;
1918 int ret, keyidx = arvif->def_wep_key_newidx;
1920 mutex_lock(&arvif->ar->conf_mutex);
1922 if (arvif->ar->state != ATH10K_STATE_ON)
1925 if (arvif->def_wep_key_idx == keyidx)
1928 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1929 arvif->vdev_id, keyidx);
1931 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1933 arvif->ar->wmi.vdev_param->def_keyid,
1936 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
1942 arvif->def_wep_key_idx = keyidx;
1945 mutex_unlock(&arvif->ar->conf_mutex);
1948 static void ath10k_tx_h_update_wep_key(struct ieee80211_vif *vif,
1949 struct ieee80211_key_conf *key,
1950 struct sk_buff *skb)
1952 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1953 struct ath10k *ar = arvif->ar;
1954 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1956 if (!ieee80211_has_protected(hdr->frame_control))
1962 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1963 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1966 if (key->keyidx == arvif->def_wep_key_idx)
1969 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1970 * queueing frames until key index is updated is not an option because
1971 * sk_buff may need more processing to be done, e.g. offchannel */
1972 arvif->def_wep_key_newidx = key->keyidx;
1973 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1976 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
1977 struct ieee80211_vif *vif,
1978 struct sk_buff *skb)
1980 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1981 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1983 /* This is case only for P2P_GO */
1984 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1985 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1988 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1989 spin_lock_bh(&ar->data_lock);
1990 if (arvif->u.ap.noa_data)
1991 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1993 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1994 arvif->u.ap.noa_data,
1995 arvif->u.ap.noa_len);
1996 spin_unlock_bh(&ar->data_lock);
2000 static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar)
2002 /* FIXME: Not really sure since when the behaviour changed. At some
2003 * point new firmware stopped requiring creation of peer entries for
2004 * offchannel tx (and actually creating them causes issues with wmi-htc
2005 * tx credit replenishment and reliability). Assuming it's at least 3.4
2006 * because that's when the `freq` was introduced to TX_FRM HTT command.
2008 return !(ar->htt.target_version_major >= 3 &&
2009 ar->htt.target_version_minor >= 4);
2012 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
2014 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2017 if (ar->htt.target_version_major >= 3) {
2018 /* Since HTT 3.0 there is no separate mgmt tx command */
2019 ret = ath10k_htt_tx(&ar->htt, skb);
2023 if (ieee80211_is_mgmt(hdr->frame_control)) {
2024 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2026 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
2027 ATH10K_MAX_NUM_MGMT_PENDING) {
2028 ath10k_warn(ar, "reached WMI management transmit queue limit\n");
2033 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2034 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2036 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2038 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2040 ieee80211_is_nullfunc(hdr->frame_control)) {
2041 /* FW does not report tx status properly for NullFunc frames
2042 * unless they are sent through mgmt tx path. mac80211 sends
2043 * those frames when it detects link/beacon loss and depends
2044 * on the tx status to be correct. */
2045 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2047 ret = ath10k_htt_tx(&ar->htt, skb);
2052 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
2054 ieee80211_free_txskb(ar->hw, skb);
2058 void ath10k_offchan_tx_purge(struct ath10k *ar)
2060 struct sk_buff *skb;
2063 skb = skb_dequeue(&ar->offchan_tx_queue);
2067 ieee80211_free_txskb(ar->hw, skb);
2071 void ath10k_offchan_tx_work(struct work_struct *work)
2073 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2074 struct ath10k_peer *peer;
2075 struct ieee80211_hdr *hdr;
2076 struct sk_buff *skb;
2077 const u8 *peer_addr;
2081 /* FW requirement: We must create a peer before FW will send out
2082 * an offchannel frame. Otherwise the frame will be stuck and
2083 * never transmitted. We delete the peer upon tx completion.
2084 * It is unlikely that a peer for offchannel tx will already be
2085 * present. However it may be in some rare cases so account for that.
2086 * Otherwise we might remove a legitimate peer and break stuff. */
2089 skb = skb_dequeue(&ar->offchan_tx_queue);
2093 mutex_lock(&ar->conf_mutex);
2095 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2098 hdr = (struct ieee80211_hdr *)skb->data;
2099 peer_addr = ieee80211_get_DA(hdr);
2100 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2102 spin_lock_bh(&ar->data_lock);
2103 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2104 spin_unlock_bh(&ar->data_lock);
2107 /* FIXME: should this use ath10k_warn()? */
2108 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2109 peer_addr, vdev_id);
2112 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2114 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
2115 peer_addr, vdev_id, ret);
2118 spin_lock_bh(&ar->data_lock);
2119 reinit_completion(&ar->offchan_tx_completed);
2120 ar->offchan_tx_skb = skb;
2121 spin_unlock_bh(&ar->data_lock);
2123 ath10k_tx_htt(ar, skb);
2125 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2128 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
2132 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2134 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
2135 peer_addr, vdev_id, ret);
2138 mutex_unlock(&ar->conf_mutex);
2142 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2144 struct sk_buff *skb;
2147 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2151 ieee80211_free_txskb(ar->hw, skb);
2155 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2157 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2158 struct sk_buff *skb;
2162 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2166 ret = ath10k_wmi_mgmt_tx(ar, skb);
2168 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
2170 ieee80211_free_txskb(ar->hw, skb);
2179 void __ath10k_scan_finish(struct ath10k *ar)
2181 lockdep_assert_held(&ar->data_lock);
2183 switch (ar->scan.state) {
2184 case ATH10K_SCAN_IDLE:
2186 case ATH10K_SCAN_RUNNING:
2187 case ATH10K_SCAN_ABORTING:
2188 if (ar->scan.is_roc)
2189 ieee80211_remain_on_channel_expired(ar->hw);
2191 ieee80211_scan_completed(ar->hw,
2193 ATH10K_SCAN_ABORTING));
2195 case ATH10K_SCAN_STARTING:
2196 ar->scan.state = ATH10K_SCAN_IDLE;
2197 ar->scan_channel = NULL;
2198 ath10k_offchan_tx_purge(ar);
2199 cancel_delayed_work(&ar->scan.timeout);
2200 complete_all(&ar->scan.completed);
2205 void ath10k_scan_finish(struct ath10k *ar)
2207 spin_lock_bh(&ar->data_lock);
2208 __ath10k_scan_finish(ar);
2209 spin_unlock_bh(&ar->data_lock);
2212 static int ath10k_scan_stop(struct ath10k *ar)
2214 struct wmi_stop_scan_arg arg = {
2215 .req_id = 1, /* FIXME */
2216 .req_type = WMI_SCAN_STOP_ONE,
2217 .u.scan_id = ATH10K_SCAN_ID,
2221 lockdep_assert_held(&ar->conf_mutex);
2223 ret = ath10k_wmi_stop_scan(ar, &arg);
2225 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
2229 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2231 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
2233 } else if (ret > 0) {
2238 /* Scan state should be updated upon scan completion but in case
2239 * firmware fails to deliver the event (for whatever reason) it is
2240 * desired to clean up scan state anyway. Firmware may have just
2241 * dropped the scan completion event delivery due to transport pipe
2242 * being overflown with data and/or it can recover on its own before
2243 * next scan request is submitted.
2245 spin_lock_bh(&ar->data_lock);
2246 if (ar->scan.state != ATH10K_SCAN_IDLE)
2247 __ath10k_scan_finish(ar);
2248 spin_unlock_bh(&ar->data_lock);
2253 static void ath10k_scan_abort(struct ath10k *ar)
2257 lockdep_assert_held(&ar->conf_mutex);
2259 spin_lock_bh(&ar->data_lock);
2261 switch (ar->scan.state) {
2262 case ATH10K_SCAN_IDLE:
2263 /* This can happen if timeout worker kicked in and called
2264 * abortion while scan completion was being processed.
2267 case ATH10K_SCAN_STARTING:
2268 case ATH10K_SCAN_ABORTING:
2269 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
2270 ath10k_scan_state_str(ar->scan.state),
2273 case ATH10K_SCAN_RUNNING:
2274 ar->scan.state = ATH10K_SCAN_ABORTING;
2275 spin_unlock_bh(&ar->data_lock);
2277 ret = ath10k_scan_stop(ar);
2279 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
2281 spin_lock_bh(&ar->data_lock);
2285 spin_unlock_bh(&ar->data_lock);
2288 void ath10k_scan_timeout_work(struct work_struct *work)
2290 struct ath10k *ar = container_of(work, struct ath10k,
2293 mutex_lock(&ar->conf_mutex);
2294 ath10k_scan_abort(ar);
2295 mutex_unlock(&ar->conf_mutex);
2298 static int ath10k_start_scan(struct ath10k *ar,
2299 const struct wmi_start_scan_arg *arg)
2303 lockdep_assert_held(&ar->conf_mutex);
2305 ret = ath10k_wmi_start_scan(ar, arg);
2309 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2311 ret = ath10k_scan_stop(ar);
2313 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
2318 /* Add a 200ms margin to account for event/command processing */
2319 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
2320 msecs_to_jiffies(arg->max_scan_time+200));
2324 /**********************/
2325 /* mac80211 callbacks */
2326 /**********************/
2328 static void ath10k_tx(struct ieee80211_hw *hw,
2329 struct ieee80211_tx_control *control,
2330 struct sk_buff *skb)
2332 struct ath10k *ar = hw->priv;
2333 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2334 struct ieee80211_vif *vif = info->control.vif;
2335 struct ieee80211_key_conf *key = info->control.hw_key;
2336 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2338 /* We should disable CCK RATE due to P2P */
2339 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2340 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2342 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2343 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2344 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
2346 /* it makes no sense to process injected frames like that */
2347 if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2348 ath10k_tx_h_nwifi(hw, skb);
2349 ath10k_tx_h_update_wep_key(vif, key, skb);
2350 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2351 ath10k_tx_h_seq_no(vif, skb);
2354 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2355 spin_lock_bh(&ar->data_lock);
2356 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
2357 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2358 spin_unlock_bh(&ar->data_lock);
2360 if (ath10k_mac_need_offchan_tx_work(ar)) {
2361 ATH10K_SKB_CB(skb)->htt.freq = 0;
2362 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2364 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
2367 skb_queue_tail(&ar->offchan_tx_queue, skb);
2368 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2373 ath10k_tx_htt(ar, skb);
2376 /* Must not be called with conf_mutex held as workers can use that also. */
2377 void ath10k_drain_tx(struct ath10k *ar)
2379 /* make sure rcu-protected mac80211 tx path itself is drained */
2382 ath10k_offchan_tx_purge(ar);
2383 ath10k_mgmt_over_wmi_tx_purge(ar);
2385 cancel_work_sync(&ar->offchan_tx_work);
2386 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2389 void ath10k_halt(struct ath10k *ar)
2391 struct ath10k_vif *arvif;
2393 lockdep_assert_held(&ar->conf_mutex);
2395 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2396 ar->filter_flags = 0;
2397 ar->monitor = false;
2399 if (ar->monitor_started)
2400 ath10k_monitor_stop(ar);
2402 ar->monitor_started = false;
2404 ath10k_scan_finish(ar);
2405 ath10k_peer_cleanup_all(ar);
2406 ath10k_core_stop(ar);
2407 ath10k_hif_power_down(ar);
2409 spin_lock_bh(&ar->data_lock);
2410 list_for_each_entry(arvif, &ar->arvifs, list)
2411 ath10k_mac_vif_beacon_cleanup(arvif);
2412 spin_unlock_bh(&ar->data_lock);
2415 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2417 struct ath10k *ar = hw->priv;
2419 mutex_lock(&ar->conf_mutex);
2421 if (ar->cfg_tx_chainmask) {
2422 *tx_ant = ar->cfg_tx_chainmask;
2423 *rx_ant = ar->cfg_rx_chainmask;
2425 *tx_ant = ar->supp_tx_chainmask;
2426 *rx_ant = ar->supp_rx_chainmask;
2429 mutex_unlock(&ar->conf_mutex);
2434 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
2436 /* It is not clear that allowing gaps in chainmask
2437 * is helpful. Probably it will not do what user
2438 * is hoping for, so warn in that case.
2440 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
2443 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
2447 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2451 lockdep_assert_held(&ar->conf_mutex);
2453 ath10k_check_chain_mask(ar, tx_ant, "tx");
2454 ath10k_check_chain_mask(ar, rx_ant, "rx");
2456 ar->cfg_tx_chainmask = tx_ant;
2457 ar->cfg_rx_chainmask = rx_ant;
2459 if ((ar->state != ATH10K_STATE_ON) &&
2460 (ar->state != ATH10K_STATE_RESTARTED))
2463 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2466 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
2471 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2474 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
2482 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2484 struct ath10k *ar = hw->priv;
2487 mutex_lock(&ar->conf_mutex);
2488 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2489 mutex_unlock(&ar->conf_mutex);
2493 static int ath10k_start(struct ieee80211_hw *hw)
2495 struct ath10k *ar = hw->priv;
2499 * This makes sense only when restarting hw. It is harmless to call
2500 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2501 * commands will be submitted while restarting.
2503 ath10k_drain_tx(ar);
2505 mutex_lock(&ar->conf_mutex);
2507 switch (ar->state) {
2508 case ATH10K_STATE_OFF:
2509 ar->state = ATH10K_STATE_ON;
2511 case ATH10K_STATE_RESTARTING:
2513 ar->state = ATH10K_STATE_RESTARTED;
2515 case ATH10K_STATE_ON:
2516 case ATH10K_STATE_RESTARTED:
2517 case ATH10K_STATE_WEDGED:
2521 case ATH10K_STATE_UTF:
2526 ret = ath10k_hif_power_up(ar);
2528 ath10k_err(ar, "Could not init hif: %d\n", ret);
2532 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
2534 ath10k_err(ar, "Could not init core: %d\n", ret);
2535 goto err_power_down;
2538 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2540 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
2544 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2546 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
2550 if (ar->cfg_tx_chainmask)
2551 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2552 ar->cfg_rx_chainmask);
2555 * By default FW set ARP frames ac to voice (6). In that case ARP
2556 * exchange is not working properly for UAPSD enabled AP. ARP requests
2557 * which arrives with access category 0 are processed by network stack
2558 * and send back with access category 0, but FW changes access category
2559 * to 6. Set ARP frames access category to best effort (0) solves
2563 ret = ath10k_wmi_pdev_set_param(ar,
2564 ar->wmi.pdev_param->arp_ac_override, 0);
2566 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
2571 ar->num_started_vdevs = 0;
2572 ath10k_regd_update(ar);
2574 ath10k_spectral_start(ar);
2576 mutex_unlock(&ar->conf_mutex);
2580 ath10k_core_stop(ar);
2583 ath10k_hif_power_down(ar);
2586 ar->state = ATH10K_STATE_OFF;
2589 mutex_unlock(&ar->conf_mutex);
2593 static void ath10k_stop(struct ieee80211_hw *hw)
2595 struct ath10k *ar = hw->priv;
2597 ath10k_drain_tx(ar);
2599 mutex_lock(&ar->conf_mutex);
2600 if (ar->state != ATH10K_STATE_OFF) {
2602 ar->state = ATH10K_STATE_OFF;
2604 mutex_unlock(&ar->conf_mutex);
2606 cancel_delayed_work_sync(&ar->scan.timeout);
2607 cancel_work_sync(&ar->restart_work);
2610 static int ath10k_config_ps(struct ath10k *ar)
2612 struct ath10k_vif *arvif;
2615 lockdep_assert_held(&ar->conf_mutex);
2617 list_for_each_entry(arvif, &ar->arvifs, list) {
2618 ret = ath10k_mac_vif_setup_ps(arvif);
2620 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
2628 static const char *chandef_get_width(enum nl80211_chan_width width)
2631 case NL80211_CHAN_WIDTH_20_NOHT:
2633 case NL80211_CHAN_WIDTH_20:
2635 case NL80211_CHAN_WIDTH_40:
2637 case NL80211_CHAN_WIDTH_80:
2639 case NL80211_CHAN_WIDTH_80P80:
2641 case NL80211_CHAN_WIDTH_160:
2643 case NL80211_CHAN_WIDTH_5:
2645 case NL80211_CHAN_WIDTH_10:
2651 static void ath10k_config_chan(struct ath10k *ar)
2653 struct ath10k_vif *arvif;
2656 lockdep_assert_held(&ar->conf_mutex);
2658 ath10k_dbg(ar, ATH10K_DBG_MAC,
2659 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2660 ar->chandef.chan->center_freq,
2661 ar->chandef.center_freq1,
2662 ar->chandef.center_freq2,
2663 chandef_get_width(ar->chandef.width));
2665 /* First stop monitor interface. Some FW versions crash if there's a
2666 * lone monitor interface. */
2667 if (ar->monitor_started)
2668 ath10k_monitor_stop(ar);
2670 list_for_each_entry(arvif, &ar->arvifs, list) {
2671 if (!arvif->is_started)
2677 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2680 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2682 ath10k_warn(ar, "failed to down vdev %d: %d\n",
2683 arvif->vdev_id, ret);
2688 /* all vdevs are downed now - attempt to restart and re-up them */
2690 list_for_each_entry(arvif, &ar->arvifs, list) {
2691 if (!arvif->is_started)
2694 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2697 ret = ath10k_vdev_restart(arvif);
2699 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
2700 arvif->vdev_id, ret);
2707 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2710 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
2711 arvif->vdev_id, ret);
2716 ath10k_monitor_recalc(ar);
2719 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
2724 lockdep_assert_held(&ar->conf_mutex);
2726 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
2728 param = ar->wmi.pdev_param->txpower_limit2g;
2729 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2731 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2736 param = ar->wmi.pdev_param->txpower_limit5g;
2737 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2739 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2747 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
2749 struct ath10k_vif *arvif;
2750 int ret, txpower = -1;
2752 lockdep_assert_held(&ar->conf_mutex);
2754 list_for_each_entry(arvif, &ar->arvifs, list) {
2755 WARN_ON(arvif->txpower < 0);
2758 txpower = arvif->txpower;
2760 txpower = min(txpower, arvif->txpower);
2763 if (WARN_ON(txpower == -1))
2766 ret = ath10k_mac_txpower_setup(ar, txpower);
2768 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
2776 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2778 struct ath10k *ar = hw->priv;
2779 struct ieee80211_conf *conf = &hw->conf;
2782 mutex_lock(&ar->conf_mutex);
2784 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2785 ath10k_dbg(ar, ATH10K_DBG_MAC,
2786 "mac config channel %dMHz flags 0x%x radar %d\n",
2787 conf->chandef.chan->center_freq,
2788 conf->chandef.chan->flags,
2789 conf->radar_enabled);
2791 spin_lock_bh(&ar->data_lock);
2792 ar->rx_channel = conf->chandef.chan;
2793 spin_unlock_bh(&ar->data_lock);
2795 ar->radar_enabled = conf->radar_enabled;
2796 ath10k_recalc_radar_detection(ar);
2798 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2799 ar->chandef = conf->chandef;
2800 ath10k_config_chan(ar);
2804 if (changed & IEEE80211_CONF_CHANGE_PS)
2805 ath10k_config_ps(ar);
2807 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2808 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
2809 ret = ath10k_monitor_recalc(ar);
2811 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
2814 mutex_unlock(&ar->conf_mutex);
2818 static u32 get_nss_from_chainmask(u16 chain_mask)
2820 if ((chain_mask & 0x15) == 0x15)
2822 else if ((chain_mask & 0x7) == 0x7)
2824 else if ((chain_mask & 0x3) == 0x3)
2831 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2832 * because we will send mgmt frames without CCK. This requirement
2833 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2836 static int ath10k_add_interface(struct ieee80211_hw *hw,
2837 struct ieee80211_vif *vif)
2839 struct ath10k *ar = hw->priv;
2840 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2841 enum wmi_sta_powersave_param param;
2847 mutex_lock(&ar->conf_mutex);
2849 memset(arvif, 0, sizeof(*arvif));
2854 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2855 INIT_LIST_HEAD(&arvif->list);
2857 if (ar->free_vdev_map == 0) {
2858 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
2862 bit = __ffs64(ar->free_vdev_map);
2864 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
2865 bit, ar->free_vdev_map);
2867 arvif->vdev_id = bit;
2868 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2871 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2873 switch (vif->type) {
2874 case NL80211_IFTYPE_UNSPECIFIED:
2875 case NL80211_IFTYPE_STATION:
2876 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2878 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2880 case NL80211_IFTYPE_ADHOC:
2881 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2883 case NL80211_IFTYPE_AP:
2884 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2887 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2889 case NL80211_IFTYPE_MONITOR:
2890 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2897 /* Some firmware revisions don't wait for beacon tx completion before
2898 * sending another SWBA event. This could lead to hardware using old
2899 * (freed) beacon data in some cases, e.g. tx credit starvation
2900 * combined with missed TBTT. This is very very rare.
2902 * On non-IOMMU-enabled hosts this could be a possible security issue
2903 * because hw could beacon some random data on the air. On
2904 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
2905 * device would crash.
2907 * Since there are no beacon tx completions (implicit nor explicit)
2908 * propagated to host the only workaround for this is to allocate a
2909 * DMA-coherent buffer for a lifetime of a vif and use it for all
2910 * beacon tx commands. Worst case for this approach is some beacons may
2911 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
2913 if (vif->type == NL80211_IFTYPE_ADHOC ||
2914 vif->type == NL80211_IFTYPE_AP) {
2915 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
2916 IEEE80211_MAX_FRAME_LEN,
2917 &arvif->beacon_paddr,
2919 if (!arvif->beacon_buf) {
2921 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
2927 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
2928 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
2929 arvif->beacon_buf ? "single-buf" : "per-skb");
2931 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2932 arvif->vdev_subtype, vif->addr);
2934 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
2935 arvif->vdev_id, ret);
2939 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
2940 list_add(&arvif->list, &ar->arvifs);
2942 vdev_param = ar->wmi.vdev_param->def_keyid;
2943 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2944 arvif->def_wep_key_idx);
2946 ath10k_warn(ar, "failed to set vdev %i default key id: %d\n",
2947 arvif->vdev_id, ret);
2948 goto err_vdev_delete;
2951 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2952 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2953 ATH10K_HW_TXRX_NATIVE_WIFI);
2954 /* 10.X firmware does not support this VDEV parameter. Do not warn */
2955 if (ret && ret != -EOPNOTSUPP) {
2956 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
2957 arvif->vdev_id, ret);
2958 goto err_vdev_delete;
2961 if (ar->cfg_tx_chainmask) {
2962 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
2964 vdev_param = ar->wmi.vdev_param->nss;
2965 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2968 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
2969 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
2971 goto err_vdev_delete;
2975 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2976 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2978 ath10k_warn(ar, "failed to create vdev %i peer for AP: %d\n",
2979 arvif->vdev_id, ret);
2980 goto err_vdev_delete;
2983 ret = ath10k_mac_set_kickout(arvif);
2985 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
2986 arvif->vdev_id, ret);
2987 goto err_peer_delete;
2991 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2992 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2993 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2994 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2997 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
2998 arvif->vdev_id, ret);
2999 goto err_peer_delete;
3002 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
3003 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
3004 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3007 ath10k_warn(ar, "failed to set vdev %i TX wake thresh: %d\n",
3008 arvif->vdev_id, ret);
3009 goto err_peer_delete;
3012 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
3013 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
3014 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3017 ath10k_warn(ar, "failed to set vdev %i PSPOLL count: %d\n",
3018 arvif->vdev_id, ret);
3019 goto err_peer_delete;
3023 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
3025 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
3026 arvif->vdev_id, ret);
3027 goto err_peer_delete;
3030 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
3032 ath10k_warn(ar, "failed to set frag threshold for vdev %d: %d\n",
3033 arvif->vdev_id, ret);
3034 goto err_peer_delete;
3037 arvif->txpower = vif->bss_conf.txpower;
3038 ret = ath10k_mac_txpower_recalc(ar);
3040 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3041 goto err_peer_delete;
3044 mutex_unlock(&ar->conf_mutex);
3048 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
3049 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
3052 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3053 ar->free_vdev_map |= 1LL << arvif->vdev_id;
3054 list_del(&arvif->list);
3057 if (arvif->beacon_buf) {
3058 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
3059 arvif->beacon_buf, arvif->beacon_paddr);
3060 arvif->beacon_buf = NULL;
3063 mutex_unlock(&ar->conf_mutex);
3068 static void ath10k_remove_interface(struct ieee80211_hw *hw,
3069 struct ieee80211_vif *vif)
3071 struct ath10k *ar = hw->priv;
3072 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3075 mutex_lock(&ar->conf_mutex);
3077 cancel_work_sync(&arvif->wep_key_work);
3079 spin_lock_bh(&ar->data_lock);
3080 ath10k_mac_vif_beacon_cleanup(arvif);
3081 spin_unlock_bh(&ar->data_lock);
3083 ret = ath10k_spectral_vif_stop(arvif);
3085 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
3086 arvif->vdev_id, ret);
3088 ar->free_vdev_map |= 1LL << arvif->vdev_id;
3089 list_del(&arvif->list);
3091 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
3092 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
3094 ath10k_warn(ar, "failed to remove peer for AP vdev %i: %d\n",
3095 arvif->vdev_id, ret);
3097 kfree(arvif->u.ap.noa_data);
3100 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
3103 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3105 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
3106 arvif->vdev_id, ret);
3108 ath10k_peer_cleanup(ar, arvif->vdev_id);
3110 mutex_unlock(&ar->conf_mutex);
3114 * FIXME: Has to be verified.
3116 #define SUPPORTED_FILTERS \
3117 (FIF_PROMISC_IN_BSS | \
3122 FIF_BCN_PRBRESP_PROMISC | \
3126 static void ath10k_configure_filter(struct ieee80211_hw *hw,
3127 unsigned int changed_flags,
3128 unsigned int *total_flags,
3131 struct ath10k *ar = hw->priv;
3134 mutex_lock(&ar->conf_mutex);
3136 changed_flags &= SUPPORTED_FILTERS;
3137 *total_flags &= SUPPORTED_FILTERS;
3138 ar->filter_flags = *total_flags;
3140 ret = ath10k_monitor_recalc(ar);
3142 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
3144 mutex_unlock(&ar->conf_mutex);
3147 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
3148 struct ieee80211_vif *vif,
3149 struct ieee80211_bss_conf *info,
3152 struct ath10k *ar = hw->priv;
3153 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3155 u32 vdev_param, pdev_param, slottime, preamble;
3157 mutex_lock(&ar->conf_mutex);
3159 if (changed & BSS_CHANGED_IBSS)
3160 ath10k_control_ibss(arvif, info, vif->addr);
3162 if (changed & BSS_CHANGED_BEACON_INT) {
3163 arvif->beacon_interval = info->beacon_int;
3164 vdev_param = ar->wmi.vdev_param->beacon_interval;
3165 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3166 arvif->beacon_interval);
3167 ath10k_dbg(ar, ATH10K_DBG_MAC,
3168 "mac vdev %d beacon_interval %d\n",
3169 arvif->vdev_id, arvif->beacon_interval);
3172 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
3173 arvif->vdev_id, ret);
3176 if (changed & BSS_CHANGED_BEACON) {
3177 ath10k_dbg(ar, ATH10K_DBG_MAC,
3178 "vdev %d set beacon tx mode to staggered\n",
3181 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3182 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
3183 WMI_BEACON_STAGGERED_MODE);
3185 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
3186 arvif->vdev_id, ret);
3189 if (changed & BSS_CHANGED_BEACON_INFO) {
3190 arvif->dtim_period = info->dtim_period;
3192 ath10k_dbg(ar, ATH10K_DBG_MAC,
3193 "mac vdev %d dtim_period %d\n",
3194 arvif->vdev_id, arvif->dtim_period);
3196 vdev_param = ar->wmi.vdev_param->dtim_period;
3197 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3198 arvif->dtim_period);
3200 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
3201 arvif->vdev_id, ret);
3204 if (changed & BSS_CHANGED_SSID &&
3205 vif->type == NL80211_IFTYPE_AP) {
3206 arvif->u.ap.ssid_len = info->ssid_len;
3208 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3209 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3212 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3213 ether_addr_copy(arvif->bssid, info->bssid);
3215 if (changed & BSS_CHANGED_BEACON_ENABLED)
3216 ath10k_control_beaconing(arvif, info);
3218 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3219 arvif->use_cts_prot = info->use_cts_prot;
3220 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3221 arvif->vdev_id, info->use_cts_prot);
3223 ret = ath10k_recalc_rtscts_prot(arvif);
3225 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3226 arvif->vdev_id, ret);
3229 if (changed & BSS_CHANGED_ERP_SLOT) {
3230 if (info->use_short_slot)
3231 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3234 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3236 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3237 arvif->vdev_id, slottime);
3239 vdev_param = ar->wmi.vdev_param->slot_time;
3240 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3243 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
3244 arvif->vdev_id, ret);
3247 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3248 if (info->use_short_preamble)
3249 preamble = WMI_VDEV_PREAMBLE_SHORT;
3251 preamble = WMI_VDEV_PREAMBLE_LONG;
3253 ath10k_dbg(ar, ATH10K_DBG_MAC,
3254 "mac vdev %d preamble %dn",
3255 arvif->vdev_id, preamble);
3257 vdev_param = ar->wmi.vdev_param->preamble;
3258 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3261 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
3262 arvif->vdev_id, ret);
3265 if (changed & BSS_CHANGED_ASSOC) {
3267 /* Workaround: Make sure monitor vdev is not running
3268 * when associating to prevent some firmware revisions
3269 * (e.g. 10.1 and 10.2) from crashing.
3271 if (ar->monitor_started)
3272 ath10k_monitor_stop(ar);
3273 ath10k_bss_assoc(hw, vif, info);
3274 ath10k_monitor_recalc(ar);
3276 ath10k_bss_disassoc(hw, vif);
3280 if (changed & BSS_CHANGED_TXPOWER) {
3281 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3282 arvif->vdev_id, info->txpower);
3284 arvif->txpower = info->txpower;
3285 ret = ath10k_mac_txpower_recalc(ar);
3287 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3290 mutex_unlock(&ar->conf_mutex);
3293 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3294 struct ieee80211_vif *vif,
3295 struct ieee80211_scan_request *hw_req)
3297 struct ath10k *ar = hw->priv;
3298 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3299 struct cfg80211_scan_request *req = &hw_req->req;
3300 struct wmi_start_scan_arg arg;
3304 mutex_lock(&ar->conf_mutex);
3306 spin_lock_bh(&ar->data_lock);
3307 switch (ar->scan.state) {
3308 case ATH10K_SCAN_IDLE:
3309 reinit_completion(&ar->scan.started);
3310 reinit_completion(&ar->scan.completed);
3311 ar->scan.state = ATH10K_SCAN_STARTING;
3312 ar->scan.is_roc = false;
3313 ar->scan.vdev_id = arvif->vdev_id;
3316 case ATH10K_SCAN_STARTING:
3317 case ATH10K_SCAN_RUNNING:
3318 case ATH10K_SCAN_ABORTING:
3322 spin_unlock_bh(&ar->data_lock);
3327 memset(&arg, 0, sizeof(arg));
3328 ath10k_wmi_start_scan_init(ar, &arg);
3329 arg.vdev_id = arvif->vdev_id;
3330 arg.scan_id = ATH10K_SCAN_ID;
3333 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3336 arg.ie_len = req->ie_len;
3337 memcpy(arg.ie, req->ie, arg.ie_len);
3341 arg.n_ssids = req->n_ssids;
3342 for (i = 0; i < arg.n_ssids; i++) {
3343 arg.ssids[i].len = req->ssids[i].ssid_len;
3344 arg.ssids[i].ssid = req->ssids[i].ssid;
3347 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3350 if (req->n_channels) {
3351 arg.n_channels = req->n_channels;
3352 for (i = 0; i < arg.n_channels; i++)
3353 arg.channels[i] = req->channels[i]->center_freq;
3356 ret = ath10k_start_scan(ar, &arg);
3358 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
3359 spin_lock_bh(&ar->data_lock);
3360 ar->scan.state = ATH10K_SCAN_IDLE;
3361 spin_unlock_bh(&ar->data_lock);
3365 mutex_unlock(&ar->conf_mutex);
3369 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3370 struct ieee80211_vif *vif)
3372 struct ath10k *ar = hw->priv;
3374 mutex_lock(&ar->conf_mutex);
3375 ath10k_scan_abort(ar);
3376 mutex_unlock(&ar->conf_mutex);
3378 cancel_delayed_work_sync(&ar->scan.timeout);
3381 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3382 struct ath10k_vif *arvif,
3383 enum set_key_cmd cmd,
3384 struct ieee80211_key_conf *key)
3386 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3389 /* 10.1 firmware branch requires default key index to be set to group
3390 * key index after installing it. Otherwise FW/HW Txes corrupted
3391 * frames with multi-vif APs. This is not required for main firmware
3392 * branch (e.g. 636).
3394 * FIXME: This has been tested only in AP. It remains unknown if this
3395 * is required for multi-vif STA interfaces on 10.1 */
3397 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3400 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3403 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3406 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3412 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3415 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
3416 arvif->vdev_id, ret);
3419 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3420 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3421 struct ieee80211_key_conf *key)
3423 struct ath10k *ar = hw->priv;
3424 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3425 struct ath10k_peer *peer;
3426 const u8 *peer_addr;
3427 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3428 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3431 if (key->keyidx > WMI_MAX_KEY_INDEX)
3434 mutex_lock(&ar->conf_mutex);
3437 peer_addr = sta->addr;
3438 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3439 peer_addr = vif->bss_conf.bssid;
3441 peer_addr = vif->addr;
3443 key->hw_key_idx = key->keyidx;
3445 /* the peer should not disappear in mid-way (unless FW goes awry) since
3446 * we already hold conf_mutex. we just make sure its there now. */
3447 spin_lock_bh(&ar->data_lock);
3448 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3449 spin_unlock_bh(&ar->data_lock);
3452 if (cmd == SET_KEY) {
3453 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
3458 /* if the peer doesn't exist there is no key to disable
3466 arvif->wep_keys[key->keyidx] = key;
3468 arvif->wep_keys[key->keyidx] = NULL;
3470 if (cmd == DISABLE_KEY)
3471 ath10k_clear_vdev_key(arvif, key);
3474 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3476 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
3477 arvif->vdev_id, peer_addr, ret);
3481 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3483 spin_lock_bh(&ar->data_lock);
3484 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3485 if (peer && cmd == SET_KEY)
3486 peer->keys[key->keyidx] = key;
3487 else if (peer && cmd == DISABLE_KEY)
3488 peer->keys[key->keyidx] = NULL;
3489 else if (peer == NULL)
3490 /* impossible unless FW goes crazy */
3491 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
3492 spin_unlock_bh(&ar->data_lock);
3495 mutex_unlock(&ar->conf_mutex);
3499 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3502 struct ath10k_vif *arvif;
3503 struct ath10k_sta *arsta;
3504 struct ieee80211_sta *sta;
3505 u32 changed, bw, nss, smps;
3508 arsta = container_of(wk, struct ath10k_sta, update_wk);
3509 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3510 arvif = arsta->arvif;
3513 spin_lock_bh(&ar->data_lock);
3515 changed = arsta->changed;
3522 spin_unlock_bh(&ar->data_lock);
3524 mutex_lock(&ar->conf_mutex);
3526 if (changed & IEEE80211_RC_BW_CHANGED) {
3527 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3530 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3531 WMI_PEER_CHAN_WIDTH, bw);
3533 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
3534 sta->addr, bw, err);
3537 if (changed & IEEE80211_RC_NSS_CHANGED) {
3538 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3541 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3544 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
3545 sta->addr, nss, err);
3548 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3549 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3552 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3553 WMI_PEER_SMPS_STATE, smps);
3555 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
3556 sta->addr, smps, err);
3559 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3560 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3563 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
3565 ath10k_warn(ar, "failed to reassociate station: %pM\n",
3569 mutex_unlock(&ar->conf_mutex);
3572 static int ath10k_sta_state(struct ieee80211_hw *hw,
3573 struct ieee80211_vif *vif,
3574 struct ieee80211_sta *sta,
3575 enum ieee80211_sta_state old_state,
3576 enum ieee80211_sta_state new_state)
3578 struct ath10k *ar = hw->priv;
3579 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3580 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3584 if (old_state == IEEE80211_STA_NOTEXIST &&
3585 new_state == IEEE80211_STA_NONE) {
3586 memset(arsta, 0, sizeof(*arsta));
3587 arsta->arvif = arvif;
3588 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3591 /* cancel must be done outside the mutex to avoid deadlock */
3592 if ((old_state == IEEE80211_STA_NONE &&
3593 new_state == IEEE80211_STA_NOTEXIST))
3594 cancel_work_sync(&arsta->update_wk);
3596 mutex_lock(&ar->conf_mutex);
3598 if (old_state == IEEE80211_STA_NOTEXIST &&
3599 new_state == IEEE80211_STA_NONE) {
3601 * New station addition.
3603 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3604 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3606 max_num_peers = TARGET_NUM_PEERS;
3608 if (ar->num_peers >= max_num_peers) {
3609 ath10k_warn(ar, "number of peers exceeded: peers number %d (max peers %d)\n",
3610 ar->num_peers, max_num_peers);
3615 ath10k_dbg(ar, ATH10K_DBG_MAC,
3616 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3617 arvif->vdev_id, sta->addr, ar->num_peers);
3619 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3621 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3622 sta->addr, arvif->vdev_id, ret);
3624 if (vif->type == NL80211_IFTYPE_STATION) {
3625 WARN_ON(arvif->is_started);
3627 ret = ath10k_vdev_start(arvif);
3629 ath10k_warn(ar, "failed to start vdev %i: %d\n",
3630 arvif->vdev_id, ret);
3631 WARN_ON(ath10k_peer_delete(ar, arvif->vdev_id,
3636 arvif->is_started = true;
3638 } else if ((old_state == IEEE80211_STA_NONE &&
3639 new_state == IEEE80211_STA_NOTEXIST)) {
3641 * Existing station deletion.
3643 ath10k_dbg(ar, ATH10K_DBG_MAC,
3644 "mac vdev %d peer delete %pM (sta gone)\n",
3645 arvif->vdev_id, sta->addr);
3647 if (vif->type == NL80211_IFTYPE_STATION) {
3648 WARN_ON(!arvif->is_started);
3650 ret = ath10k_vdev_stop(arvif);
3652 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
3653 arvif->vdev_id, ret);
3655 arvif->is_started = false;
3658 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3660 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
3661 sta->addr, arvif->vdev_id, ret);
3663 } else if (old_state == IEEE80211_STA_AUTH &&
3664 new_state == IEEE80211_STA_ASSOC &&
3665 (vif->type == NL80211_IFTYPE_AP ||
3666 vif->type == NL80211_IFTYPE_ADHOC)) {
3670 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
3673 ret = ath10k_station_assoc(ar, vif, sta, false);
3675 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
3676 sta->addr, arvif->vdev_id, ret);
3677 } else if (old_state == IEEE80211_STA_ASSOC &&
3678 new_state == IEEE80211_STA_AUTH &&
3679 (vif->type == NL80211_IFTYPE_AP ||
3680 vif->type == NL80211_IFTYPE_ADHOC)) {
3684 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3687 ret = ath10k_station_disassoc(ar, vif, sta);
3689 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
3690 sta->addr, arvif->vdev_id, ret);
3693 mutex_unlock(&ar->conf_mutex);
3697 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3698 u16 ac, bool enable)
3700 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3704 lockdep_assert_held(&ar->conf_mutex);
3706 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3710 case IEEE80211_AC_VO:
3711 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3712 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3714 case IEEE80211_AC_VI:
3715 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3716 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3718 case IEEE80211_AC_BE:
3719 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3720 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3722 case IEEE80211_AC_BK:
3723 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3724 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3729 arvif->u.sta.uapsd |= value;
3731 arvif->u.sta.uapsd &= ~value;
3733 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3734 WMI_STA_PS_PARAM_UAPSD,
3735 arvif->u.sta.uapsd);
3737 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
3741 if (arvif->u.sta.uapsd)
3742 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3744 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3746 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3747 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3750 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
3756 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3757 struct ieee80211_vif *vif, u16 ac,
3758 const struct ieee80211_tx_queue_params *params)
3760 struct ath10k *ar = hw->priv;
3761 struct wmi_wmm_params_arg *p = NULL;
3764 mutex_lock(&ar->conf_mutex);
3767 case IEEE80211_AC_VO:
3768 p = &ar->wmm_params.ac_vo;
3770 case IEEE80211_AC_VI:
3771 p = &ar->wmm_params.ac_vi;
3773 case IEEE80211_AC_BE:
3774 p = &ar->wmm_params.ac_be;
3776 case IEEE80211_AC_BK:
3777 p = &ar->wmm_params.ac_bk;
3786 p->cwmin = params->cw_min;
3787 p->cwmax = params->cw_max;
3788 p->aifs = params->aifs;
3791 * The channel time duration programmed in the HW is in absolute
3792 * microseconds, while mac80211 gives the txop in units of
3795 p->txop = params->txop * 32;
3797 /* FIXME: FW accepts wmm params per hw, not per vif */
3798 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3800 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
3804 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3806 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
3809 mutex_unlock(&ar->conf_mutex);
3813 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3815 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3816 struct ieee80211_vif *vif,
3817 struct ieee80211_channel *chan,
3819 enum ieee80211_roc_type type)
3821 struct ath10k *ar = hw->priv;
3822 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3823 struct wmi_start_scan_arg arg;
3826 mutex_lock(&ar->conf_mutex);
3828 spin_lock_bh(&ar->data_lock);
3829 switch (ar->scan.state) {
3830 case ATH10K_SCAN_IDLE:
3831 reinit_completion(&ar->scan.started);
3832 reinit_completion(&ar->scan.completed);
3833 reinit_completion(&ar->scan.on_channel);
3834 ar->scan.state = ATH10K_SCAN_STARTING;
3835 ar->scan.is_roc = true;
3836 ar->scan.vdev_id = arvif->vdev_id;
3837 ar->scan.roc_freq = chan->center_freq;
3840 case ATH10K_SCAN_STARTING:
3841 case ATH10K_SCAN_RUNNING:
3842 case ATH10K_SCAN_ABORTING:
3846 spin_unlock_bh(&ar->data_lock);
3851 memset(&arg, 0, sizeof(arg));
3852 ath10k_wmi_start_scan_init(ar, &arg);
3853 arg.vdev_id = arvif->vdev_id;
3854 arg.scan_id = ATH10K_SCAN_ID;
3856 arg.channels[0] = chan->center_freq;
3857 arg.dwell_time_active = duration;
3858 arg.dwell_time_passive = duration;
3859 arg.max_scan_time = 2 * duration;
3860 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3861 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3863 ret = ath10k_start_scan(ar, &arg);
3865 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
3866 spin_lock_bh(&ar->data_lock);
3867 ar->scan.state = ATH10K_SCAN_IDLE;
3868 spin_unlock_bh(&ar->data_lock);
3872 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3874 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
3876 ret = ath10k_scan_stop(ar);
3878 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3886 mutex_unlock(&ar->conf_mutex);
3890 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3892 struct ath10k *ar = hw->priv;
3894 mutex_lock(&ar->conf_mutex);
3895 ath10k_scan_abort(ar);
3896 mutex_unlock(&ar->conf_mutex);
3898 cancel_delayed_work_sync(&ar->scan.timeout);
3904 * Both RTS and Fragmentation threshold are interface-specific
3905 * in ath10k, but device-specific in mac80211.
3908 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3910 struct ath10k *ar = hw->priv;
3911 struct ath10k_vif *arvif;
3914 mutex_lock(&ar->conf_mutex);
3915 list_for_each_entry(arvif, &ar->arvifs, list) {
3916 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3917 arvif->vdev_id, value);
3919 ret = ath10k_mac_set_rts(arvif, value);
3921 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
3922 arvif->vdev_id, ret);
3926 mutex_unlock(&ar->conf_mutex);
3931 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3933 struct ath10k *ar = hw->priv;
3934 struct ath10k_vif *arvif;
3937 mutex_lock(&ar->conf_mutex);
3938 list_for_each_entry(arvif, &ar->arvifs, list) {
3939 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3940 arvif->vdev_id, value);
3942 ret = ath10k_mac_set_frag(arvif, value);
3944 ath10k_warn(ar, "failed to set fragmentation threshold for vdev %d: %d\n",
3945 arvif->vdev_id, ret);
3949 mutex_unlock(&ar->conf_mutex);
3954 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3955 u32 queues, bool drop)
3957 struct ath10k *ar = hw->priv;
3961 /* mac80211 doesn't care if we really xmit queued frames or not
3962 * we'll collect those frames either way if we stop/delete vdevs */
3966 mutex_lock(&ar->conf_mutex);
3968 if (ar->state == ATH10K_STATE_WEDGED)
3971 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3974 spin_lock_bh(&ar->htt.tx_lock);
3975 empty = (ar->htt.num_pending_tx == 0);
3976 spin_unlock_bh(&ar->htt.tx_lock);
3978 skip = (ar->state == ATH10K_STATE_WEDGED) ||
3979 test_bit(ATH10K_FLAG_CRASH_FLUSH,
3983 }), ATH10K_FLUSH_TIMEOUT_HZ);
3985 if (ret <= 0 || skip)
3986 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %i\n",
3987 skip, ar->state, ret);
3990 mutex_unlock(&ar->conf_mutex);
3993 /* TODO: Implement this function properly
3994 * For now it is needed to reply to Probe Requests in IBSS mode.
3995 * Propably we need this information from FW.
3997 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
4003 static int ath10k_suspend(struct ieee80211_hw *hw,
4004 struct cfg80211_wowlan *wowlan)
4006 struct ath10k *ar = hw->priv;
4009 mutex_lock(&ar->conf_mutex);
4011 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
4013 if (ret == -ETIMEDOUT)
4019 ret = ath10k_hif_suspend(ar);
4021 ath10k_warn(ar, "failed to suspend hif: %d\n", ret);
4028 ret = ath10k_wmi_pdev_resume_target(ar);
4030 ath10k_warn(ar, "failed to resume target: %d\n", ret);
4034 mutex_unlock(&ar->conf_mutex);
4038 static int ath10k_resume(struct ieee80211_hw *hw)
4040 struct ath10k *ar = hw->priv;
4043 mutex_lock(&ar->conf_mutex);
4045 ret = ath10k_hif_resume(ar);
4047 ath10k_warn(ar, "failed to resume hif: %d\n", ret);
4052 ret = ath10k_wmi_pdev_resume_target(ar);
4054 ath10k_warn(ar, "failed to resume target: %d\n", ret);
4061 mutex_unlock(&ar->conf_mutex);
4066 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
4067 enum ieee80211_reconfig_type reconfig_type)
4069 struct ath10k *ar = hw->priv;
4071 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
4074 mutex_lock(&ar->conf_mutex);
4076 /* If device failed to restart it will be in a different state, e.g.
4077 * ATH10K_STATE_WEDGED */
4078 if (ar->state == ATH10K_STATE_RESTARTED) {
4079 ath10k_info(ar, "device successfully recovered\n");
4080 ar->state = ATH10K_STATE_ON;
4081 ieee80211_wake_queues(ar->hw);
4084 mutex_unlock(&ar->conf_mutex);
4087 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
4088 struct survey_info *survey)
4090 struct ath10k *ar = hw->priv;
4091 struct ieee80211_supported_band *sband;
4092 struct survey_info *ar_survey = &ar->survey[idx];
4095 mutex_lock(&ar->conf_mutex);
4097 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
4098 if (sband && idx >= sband->n_channels) {
4099 idx -= sband->n_channels;
4104 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
4106 if (!sband || idx >= sband->n_channels) {
4111 spin_lock_bh(&ar->data_lock);
4112 memcpy(survey, ar_survey, sizeof(*survey));
4113 spin_unlock_bh(&ar->data_lock);
4115 survey->channel = &sband->channels[idx];
4117 if (ar->rx_channel == survey->channel)
4118 survey->filled |= SURVEY_INFO_IN_USE;
4121 mutex_unlock(&ar->conf_mutex);
4125 /* Helper table for legacy fixed_rate/bitrate_mask */
4126 static const u8 cck_ofdm_rate[] = {
4143 /* Check if only one bit set */
4144 static int ath10k_check_single_mask(u32 mask)
4152 mask &= ~BIT(bit - 1);
4160 ath10k_default_bitrate_mask(struct ath10k *ar,
4161 enum ieee80211_band band,
4162 const struct cfg80211_bitrate_mask *mask)
4164 u32 legacy = 0x00ff;
4167 u16 nrf = ar->num_rf_chains;
4169 if (ar->cfg_tx_chainmask)
4170 nrf = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4173 case IEEE80211_BAND_2GHZ:
4177 case IEEE80211_BAND_5GHZ:
4183 if (mask->control[band].legacy != legacy)
4186 for (i = 0; i < nrf; i++)
4187 if (mask->control[band].ht_mcs[i] != ht)
4190 for (i = 0; i < nrf; i++)
4191 if (mask->control[band].vht_mcs[i] != vht)
4198 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
4199 enum ieee80211_band band,
4202 int ht_nss = 0, vht_nss = 0, i;
4205 if (ath10k_check_single_mask(mask->control[band].legacy))
4209 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4210 if (mask->control[band].ht_mcs[i] == 0xff)
4212 else if (mask->control[band].ht_mcs[i] == 0x00)
4221 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4222 if (mask->control[band].vht_mcs[i] == 0x03ff)
4224 else if (mask->control[band].vht_mcs[i] == 0x0000)
4232 if (ht_nss > 0 && vht_nss > 0)
4236 *fixed_nss = ht_nss;
4238 *fixed_nss = vht_nss;
4246 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4247 enum ieee80211_band band,
4248 enum wmi_rate_preamble *preamble)
4250 int legacy = 0, ht = 0, vht = 0, i;
4252 *preamble = WMI_RATE_PREAMBLE_OFDM;
4255 legacy = ath10k_check_single_mask(mask->control[band].legacy);
4260 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4261 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4266 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4267 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4271 /* Currently we support only one fixed_rate */
4272 if ((legacy + ht + vht) != 1)
4276 *preamble = WMI_RATE_PREAMBLE_HT;
4278 *preamble = WMI_RATE_PREAMBLE_VHT;
4284 ath10k_bitrate_mask_rate(struct ath10k *ar,
4285 const struct cfg80211_bitrate_mask *mask,
4286 enum ieee80211_band band,
4290 u8 rate = 0, pream = 0, nss = 0, i;
4291 enum wmi_rate_preamble preamble;
4293 /* Check if single rate correct */
4294 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4300 case WMI_RATE_PREAMBLE_CCK:
4301 case WMI_RATE_PREAMBLE_OFDM:
4302 i = ffs(mask->control[band].legacy) - 1;
4304 if (band == IEEE80211_BAND_2GHZ && i < 4)
4305 pream = WMI_RATE_PREAMBLE_CCK;
4307 if (band == IEEE80211_BAND_5GHZ)
4310 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4313 rate = cck_ofdm_rate[i];
4315 case WMI_RATE_PREAMBLE_HT:
4316 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4317 if (mask->control[band].ht_mcs[i])
4320 if (i == IEEE80211_HT_MCS_MASK_LEN)
4323 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4326 case WMI_RATE_PREAMBLE_VHT:
4327 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4328 if (mask->control[band].vht_mcs[i])
4331 if (i == NL80211_VHT_NSS_MAX)
4334 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4339 *fixed_nss = nss + 1;
4343 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4346 *fixed_rate = pream | nss | rate;
4351 static bool ath10k_get_fixed_rate_nss(struct ath10k *ar,
4352 const struct cfg80211_bitrate_mask *mask,
4353 enum ieee80211_band band,
4357 /* First check full NSS mask, if we can simply limit NSS */
4358 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4361 /* Next Check single rate is set */
4362 return ath10k_bitrate_mask_rate(ar, mask, band, fixed_rate, fixed_nss);
4365 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4370 struct ath10k *ar = arvif->ar;
4374 mutex_lock(&ar->conf_mutex);
4376 if (arvif->fixed_rate == fixed_rate &&
4377 arvif->fixed_nss == fixed_nss &&
4378 arvif->force_sgi == force_sgi)
4381 if (fixed_rate == WMI_FIXED_RATE_NONE)
4382 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4385 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac force sgi\n");
4387 vdev_param = ar->wmi.vdev_param->fixed_rate;
4388 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4389 vdev_param, fixed_rate);
4391 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
4397 arvif->fixed_rate = fixed_rate;
4399 vdev_param = ar->wmi.vdev_param->nss;
4400 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4401 vdev_param, fixed_nss);
4404 ath10k_warn(ar, "failed to set fixed nss param %d: %d\n",
4410 arvif->fixed_nss = fixed_nss;
4412 vdev_param = ar->wmi.vdev_param->sgi;
4413 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4417 ath10k_warn(ar, "failed to set sgi param %d: %d\n",
4423 arvif->force_sgi = force_sgi;
4426 mutex_unlock(&ar->conf_mutex);
4430 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4431 struct ieee80211_vif *vif,
4432 const struct cfg80211_bitrate_mask *mask)
4434 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4435 struct ath10k *ar = arvif->ar;
4436 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4437 u8 fixed_rate = WMI_FIXED_RATE_NONE;
4438 u8 fixed_nss = ar->num_rf_chains;
4441 if (ar->cfg_tx_chainmask)
4442 fixed_nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4444 force_sgi = mask->control[band].gi;
4445 if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4448 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4449 if (!ath10k_get_fixed_rate_nss(ar, mask, band,
4455 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4456 ath10k_warn(ar, "failed to force SGI usage for default rate settings\n");
4460 return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4461 fixed_nss, force_sgi);
4464 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4465 struct ieee80211_vif *vif,
4466 struct ieee80211_sta *sta,
4469 struct ath10k *ar = hw->priv;
4470 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4473 spin_lock_bh(&ar->data_lock);
4475 ath10k_dbg(ar, ATH10K_DBG_MAC,
4476 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4477 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4480 if (changed & IEEE80211_RC_BW_CHANGED) {
4481 bw = WMI_PEER_CHWIDTH_20MHZ;
4483 switch (sta->bandwidth) {
4484 case IEEE80211_STA_RX_BW_20:
4485 bw = WMI_PEER_CHWIDTH_20MHZ;
4487 case IEEE80211_STA_RX_BW_40:
4488 bw = WMI_PEER_CHWIDTH_40MHZ;
4490 case IEEE80211_STA_RX_BW_80:
4491 bw = WMI_PEER_CHWIDTH_80MHZ;
4493 case IEEE80211_STA_RX_BW_160:
4494 ath10k_warn(ar, "Invalid bandwith %d in rc update for %pM\n",
4495 sta->bandwidth, sta->addr);
4496 bw = WMI_PEER_CHWIDTH_20MHZ;
4503 if (changed & IEEE80211_RC_NSS_CHANGED)
4504 arsta->nss = sta->rx_nss;
4506 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4507 smps = WMI_PEER_SMPS_PS_NONE;
4509 switch (sta->smps_mode) {
4510 case IEEE80211_SMPS_AUTOMATIC:
4511 case IEEE80211_SMPS_OFF:
4512 smps = WMI_PEER_SMPS_PS_NONE;
4514 case IEEE80211_SMPS_STATIC:
4515 smps = WMI_PEER_SMPS_STATIC;
4517 case IEEE80211_SMPS_DYNAMIC:
4518 smps = WMI_PEER_SMPS_DYNAMIC;
4520 case IEEE80211_SMPS_NUM_MODES:
4521 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
4522 sta->smps_mode, sta->addr);
4523 smps = WMI_PEER_SMPS_PS_NONE;
4530 arsta->changed |= changed;
4532 spin_unlock_bh(&ar->data_lock);
4534 ieee80211_queue_work(hw, &arsta->update_wk);
4537 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4540 * FIXME: Return 0 for time being. Need to figure out whether FW
4541 * has the API to fetch 64-bit local TSF
4547 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
4548 struct ieee80211_vif *vif,
4549 enum ieee80211_ampdu_mlme_action action,
4550 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4553 struct ath10k *ar = hw->priv;
4554 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4556 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
4557 arvif->vdev_id, sta->addr, tid, action);
4560 case IEEE80211_AMPDU_RX_START:
4561 case IEEE80211_AMPDU_RX_STOP:
4562 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4563 * creation/removal. Do we need to verify this?
4566 case IEEE80211_AMPDU_TX_START:
4567 case IEEE80211_AMPDU_TX_STOP_CONT:
4568 case IEEE80211_AMPDU_TX_STOP_FLUSH:
4569 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4570 case IEEE80211_AMPDU_TX_OPERATIONAL:
4571 /* Firmware offloads Tx aggregation entirely so deny mac80211
4572 * Tx aggregation requests.
4580 static const struct ieee80211_ops ath10k_ops = {
4582 .start = ath10k_start,
4583 .stop = ath10k_stop,
4584 .config = ath10k_config,
4585 .add_interface = ath10k_add_interface,
4586 .remove_interface = ath10k_remove_interface,
4587 .configure_filter = ath10k_configure_filter,
4588 .bss_info_changed = ath10k_bss_info_changed,
4589 .hw_scan = ath10k_hw_scan,
4590 .cancel_hw_scan = ath10k_cancel_hw_scan,
4591 .set_key = ath10k_set_key,
4592 .sta_state = ath10k_sta_state,
4593 .conf_tx = ath10k_conf_tx,
4594 .remain_on_channel = ath10k_remain_on_channel,
4595 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
4596 .set_rts_threshold = ath10k_set_rts_threshold,
4597 .set_frag_threshold = ath10k_set_frag_threshold,
4598 .flush = ath10k_flush,
4599 .tx_last_beacon = ath10k_tx_last_beacon,
4600 .set_antenna = ath10k_set_antenna,
4601 .get_antenna = ath10k_get_antenna,
4602 .reconfig_complete = ath10k_reconfig_complete,
4603 .get_survey = ath10k_get_survey,
4604 .set_bitrate_mask = ath10k_set_bitrate_mask,
4605 .sta_rc_update = ath10k_sta_rc_update,
4606 .get_tsf = ath10k_get_tsf,
4607 .ampdu_action = ath10k_ampdu_action,
4608 .get_et_sset_count = ath10k_debug_get_et_sset_count,
4609 .get_et_stats = ath10k_debug_get_et_stats,
4610 .get_et_strings = ath10k_debug_get_et_strings,
4612 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
4615 .suspend = ath10k_suspend,
4616 .resume = ath10k_resume,
4620 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4621 .bitrate = (_rate), \
4622 .flags = (_flags), \
4623 .hw_value = (_rateid), \
4626 #define CHAN2G(_channel, _freq, _flags) { \
4627 .band = IEEE80211_BAND_2GHZ, \
4628 .hw_value = (_channel), \
4629 .center_freq = (_freq), \
4630 .flags = (_flags), \
4631 .max_antenna_gain = 0, \
4635 #define CHAN5G(_channel, _freq, _flags) { \
4636 .band = IEEE80211_BAND_5GHZ, \
4637 .hw_value = (_channel), \
4638 .center_freq = (_freq), \
4639 .flags = (_flags), \
4640 .max_antenna_gain = 0, \
4644 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4654 CHAN2G(10, 2457, 0),
4655 CHAN2G(11, 2462, 0),
4656 CHAN2G(12, 2467, 0),
4657 CHAN2G(13, 2472, 0),
4658 CHAN2G(14, 2484, 0),
4661 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4662 CHAN5G(36, 5180, 0),
4663 CHAN5G(40, 5200, 0),
4664 CHAN5G(44, 5220, 0),
4665 CHAN5G(48, 5240, 0),
4666 CHAN5G(52, 5260, 0),
4667 CHAN5G(56, 5280, 0),
4668 CHAN5G(60, 5300, 0),
4669 CHAN5G(64, 5320, 0),
4670 CHAN5G(100, 5500, 0),
4671 CHAN5G(104, 5520, 0),
4672 CHAN5G(108, 5540, 0),
4673 CHAN5G(112, 5560, 0),
4674 CHAN5G(116, 5580, 0),
4675 CHAN5G(120, 5600, 0),
4676 CHAN5G(124, 5620, 0),
4677 CHAN5G(128, 5640, 0),
4678 CHAN5G(132, 5660, 0),
4679 CHAN5G(136, 5680, 0),
4680 CHAN5G(140, 5700, 0),
4681 CHAN5G(149, 5745, 0),
4682 CHAN5G(153, 5765, 0),
4683 CHAN5G(157, 5785, 0),
4684 CHAN5G(161, 5805, 0),
4685 CHAN5G(165, 5825, 0),
4688 static struct ieee80211_rate ath10k_rates[] = {
4690 RATETAB_ENT(10, 0x82, 0),
4691 RATETAB_ENT(20, 0x84, 0),
4692 RATETAB_ENT(55, 0x8b, 0),
4693 RATETAB_ENT(110, 0x96, 0),
4695 RATETAB_ENT(60, 0x0c, 0),
4696 RATETAB_ENT(90, 0x12, 0),
4697 RATETAB_ENT(120, 0x18, 0),
4698 RATETAB_ENT(180, 0x24, 0),
4699 RATETAB_ENT(240, 0x30, 0),
4700 RATETAB_ENT(360, 0x48, 0),
4701 RATETAB_ENT(480, 0x60, 0),
4702 RATETAB_ENT(540, 0x6c, 0),
4705 #define ath10k_a_rates (ath10k_rates + 4)
4706 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4707 #define ath10k_g_rates (ath10k_rates + 0)
4708 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4710 struct ath10k *ath10k_mac_create(size_t priv_size)
4712 struct ieee80211_hw *hw;
4715 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
4725 void ath10k_mac_destroy(struct ath10k *ar)
4727 ieee80211_free_hw(ar->hw);
4730 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4733 .types = BIT(NL80211_IFTYPE_STATION)
4734 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4738 .types = BIT(NL80211_IFTYPE_P2P_GO)
4742 .types = BIT(NL80211_IFTYPE_AP)
4746 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4749 .types = BIT(NL80211_IFTYPE_AP)
4753 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4755 .limits = ath10k_if_limits,
4756 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4757 .max_interfaces = 8,
4758 .num_different_channels = 1,
4759 .beacon_int_infra_match = true,
4763 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4765 .limits = ath10k_10x_if_limits,
4766 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4767 .max_interfaces = 8,
4768 .num_different_channels = 1,
4769 .beacon_int_infra_match = true,
4770 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4771 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4772 BIT(NL80211_CHAN_WIDTH_20) |
4773 BIT(NL80211_CHAN_WIDTH_40) |
4774 BIT(NL80211_CHAN_WIDTH_80),
4779 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4781 struct ieee80211_sta_vht_cap vht_cap = {0};
4785 vht_cap.vht_supported = 1;
4786 vht_cap.cap = ar->vht_cap_info;
4789 for (i = 0; i < 8; i++) {
4790 if (i < ar->num_rf_chains)
4791 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4793 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4796 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4797 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4802 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4805 struct ieee80211_sta_ht_cap ht_cap = {0};
4807 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4810 ht_cap.ht_supported = 1;
4811 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4812 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4813 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4814 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4815 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4817 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4818 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4820 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4821 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4823 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4826 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4827 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4832 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4833 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4835 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4838 stbc = ar->ht_cap_info;
4839 stbc &= WMI_HT_CAP_RX_STBC;
4840 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4841 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4842 stbc &= IEEE80211_HT_CAP_RX_STBC;
4847 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4848 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4850 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4851 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4853 /* max AMSDU is implicitly taken from vht_cap_info */
4854 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4855 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4857 for (i = 0; i < ar->num_rf_chains; i++)
4858 ht_cap.mcs.rx_mask[i] = 0xFF;
4860 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4865 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4866 struct ieee80211_vif *vif)
4868 struct ath10k_vif_iter *arvif_iter = data;
4869 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4871 if (arvif->vdev_id == arvif_iter->vdev_id)
4872 arvif_iter->arvif = arvif;
4875 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4877 struct ath10k_vif_iter arvif_iter;
4880 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4881 arvif_iter.vdev_id = vdev_id;
4883 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4884 ieee80211_iterate_active_interfaces_atomic(ar->hw,
4886 ath10k_get_arvif_iter,
4888 if (!arvif_iter.arvif) {
4889 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
4893 return arvif_iter.arvif;
4896 int ath10k_mac_register(struct ath10k *ar)
4898 struct ieee80211_supported_band *band;
4899 struct ieee80211_sta_vht_cap vht_cap;
4900 struct ieee80211_sta_ht_cap ht_cap;
4904 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4906 SET_IEEE80211_DEV(ar->hw, ar->dev);
4908 ht_cap = ath10k_get_ht_cap(ar);
4909 vht_cap = ath10k_create_vht_cap(ar);
4911 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4912 channels = kmemdup(ath10k_2ghz_channels,
4913 sizeof(ath10k_2ghz_channels),
4920 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4921 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4922 band->channels = channels;
4923 band->n_bitrates = ath10k_g_rates_size;
4924 band->bitrates = ath10k_g_rates;
4925 band->ht_cap = ht_cap;
4927 /* vht is not supported in 2.4 GHz */
4929 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4932 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4933 channels = kmemdup(ath10k_5ghz_channels,
4934 sizeof(ath10k_5ghz_channels),
4941 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4942 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4943 band->channels = channels;
4944 band->n_bitrates = ath10k_a_rates_size;
4945 band->bitrates = ath10k_a_rates;
4946 band->ht_cap = ht_cap;
4947 band->vht_cap = vht_cap;
4948 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4951 ar->hw->wiphy->interface_modes =
4952 BIT(NL80211_IFTYPE_STATION) |
4953 BIT(NL80211_IFTYPE_AP);
4955 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4956 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4958 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4959 ar->hw->wiphy->interface_modes |=
4960 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4961 BIT(NL80211_IFTYPE_P2P_GO);
4963 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4964 IEEE80211_HW_SUPPORTS_PS |
4965 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4966 IEEE80211_HW_SUPPORTS_UAPSD |
4967 IEEE80211_HW_MFP_CAPABLE |
4968 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4969 IEEE80211_HW_HAS_RATE_CONTROL |
4970 IEEE80211_HW_AP_LINK_PS |
4971 IEEE80211_HW_SPECTRUM_MGMT;
4973 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
4975 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4976 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
4978 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4979 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4980 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4983 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4984 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4986 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4987 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
4989 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4991 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4992 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
4993 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4995 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4996 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
4999 * on LL hardware queues are managed entirely by the FW
5000 * so we only advertise to mac we can do the queues thing
5004 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
5005 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
5006 ar->hw->wiphy->n_iface_combinations =
5007 ARRAY_SIZE(ath10k_10x_if_comb);
5009 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
5010 ar->hw->wiphy->n_iface_combinations =
5011 ARRAY_SIZE(ath10k_if_comb);
5013 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
5016 ar->hw->netdev_features = NETIF_F_HW_CSUM;
5018 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
5019 /* Init ath dfs pattern detector */
5020 ar->ath_common.debug_mask = ATH_DBG_DFS;
5021 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
5024 if (!ar->dfs_detector)
5025 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
5028 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
5029 ath10k_reg_notifier);
5031 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
5035 ret = ieee80211_register_hw(ar->hw);
5037 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
5041 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
5042 ret = regulatory_hint(ar->hw->wiphy,
5043 ar->ath_common.regulatory.alpha2);
5045 goto err_unregister;
5051 ieee80211_unregister_hw(ar->hw);
5053 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5054 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5059 void ath10k_mac_unregister(struct ath10k *ar)
5061 ieee80211_unregister_hw(ar->hw);
5063 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
5064 ar->dfs_detector->exit(ar->dfs_detector);
5066 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5067 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5069 SET_IEEE80211_DEV(ar->hw, NULL);