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>
37 static int ath10k_send_key(struct ath10k_vif *arvif,
38 struct ieee80211_key_conf *key,
42 struct ath10k *ar = arvif->ar;
43 struct wmi_vdev_install_key_arg arg = {
44 .vdev_id = arvif->vdev_id,
45 .key_idx = key->keyidx,
46 .key_len = key->keylen,
51 lockdep_assert_held(&arvif->ar->conf_mutex);
53 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
54 arg.key_flags = WMI_KEY_PAIRWISE;
56 arg.key_flags = WMI_KEY_GROUP;
58 switch (key->cipher) {
59 case WLAN_CIPHER_SUITE_CCMP:
60 arg.key_cipher = WMI_CIPHER_AES_CCM;
61 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
62 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
64 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
66 case WLAN_CIPHER_SUITE_TKIP:
67 arg.key_cipher = WMI_CIPHER_TKIP;
68 arg.key_txmic_len = 8;
69 arg.key_rxmic_len = 8;
71 case WLAN_CIPHER_SUITE_WEP40:
72 case WLAN_CIPHER_SUITE_WEP104:
73 arg.key_cipher = WMI_CIPHER_WEP;
74 /* AP/IBSS mode requires self-key to be groupwise
75 * Otherwise pairwise key must be set */
76 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
77 arg.key_flags = WMI_KEY_PAIRWISE;
80 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
84 if (cmd == DISABLE_KEY) {
85 arg.key_cipher = WMI_CIPHER_NONE;
89 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
92 static int ath10k_install_key(struct ath10k_vif *arvif,
93 struct ieee80211_key_conf *key,
97 struct ath10k *ar = arvif->ar;
100 lockdep_assert_held(&ar->conf_mutex);
102 reinit_completion(&ar->install_key_done);
104 ret = ath10k_send_key(arvif, key, cmd, macaddr);
108 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
115 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
118 struct ath10k *ar = arvif->ar;
119 struct ath10k_peer *peer;
123 lockdep_assert_held(&ar->conf_mutex);
125 spin_lock_bh(&ar->data_lock);
126 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
127 spin_unlock_bh(&ar->data_lock);
132 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
133 if (arvif->wep_keys[i] == NULL)
136 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
141 spin_lock_bh(&ar->data_lock);
142 peer->keys[i] = arvif->wep_keys[i];
143 spin_unlock_bh(&ar->data_lock);
149 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
152 struct ath10k *ar = arvif->ar;
153 struct ath10k_peer *peer;
158 lockdep_assert_held(&ar->conf_mutex);
160 spin_lock_bh(&ar->data_lock);
161 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
162 spin_unlock_bh(&ar->data_lock);
167 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
168 if (peer->keys[i] == NULL)
171 ret = ath10k_install_key(arvif, peer->keys[i],
173 if (ret && first_errno == 0)
177 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
180 spin_lock_bh(&ar->data_lock);
181 peer->keys[i] = NULL;
182 spin_unlock_bh(&ar->data_lock);
188 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
191 struct ath10k_peer *peer;
194 lockdep_assert_held(&ar->data_lock);
196 /* We don't know which vdev this peer belongs to,
197 * since WMI doesn't give us that information.
199 * FIXME: multi-bss needs to be handled.
201 peer = ath10k_peer_find(ar, 0, addr);
205 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
206 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
213 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
214 struct ieee80211_key_conf *key)
216 struct ath10k *ar = arvif->ar;
217 struct ath10k_peer *peer;
223 lockdep_assert_held(&ar->conf_mutex);
226 /* since ath10k_install_key we can't hold data_lock all the
227 * time, so we try to remove the keys incrementally */
228 spin_lock_bh(&ar->data_lock);
230 list_for_each_entry(peer, &ar->peers, list) {
231 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
232 if (peer->keys[i] == key) {
233 ether_addr_copy(addr, peer->addr);
234 peer->keys[i] = NULL;
239 if (i < ARRAY_SIZE(peer->keys))
242 spin_unlock_bh(&ar->data_lock);
244 if (i == ARRAY_SIZE(peer->keys))
247 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
248 if (ret && first_errno == 0)
252 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
259 /*********************/
260 /* General utilities */
261 /*********************/
263 static inline enum wmi_phy_mode
264 chan_to_phymode(const struct cfg80211_chan_def *chandef)
266 enum wmi_phy_mode phymode = MODE_UNKNOWN;
268 switch (chandef->chan->band) {
269 case IEEE80211_BAND_2GHZ:
270 switch (chandef->width) {
271 case NL80211_CHAN_WIDTH_20_NOHT:
274 case NL80211_CHAN_WIDTH_20:
275 phymode = MODE_11NG_HT20;
277 case NL80211_CHAN_WIDTH_40:
278 phymode = MODE_11NG_HT40;
280 case NL80211_CHAN_WIDTH_5:
281 case NL80211_CHAN_WIDTH_10:
282 case NL80211_CHAN_WIDTH_80:
283 case NL80211_CHAN_WIDTH_80P80:
284 case NL80211_CHAN_WIDTH_160:
285 phymode = MODE_UNKNOWN;
289 case IEEE80211_BAND_5GHZ:
290 switch (chandef->width) {
291 case NL80211_CHAN_WIDTH_20_NOHT:
294 case NL80211_CHAN_WIDTH_20:
295 phymode = MODE_11NA_HT20;
297 case NL80211_CHAN_WIDTH_40:
298 phymode = MODE_11NA_HT40;
300 case NL80211_CHAN_WIDTH_80:
301 phymode = MODE_11AC_VHT80;
303 case NL80211_CHAN_WIDTH_5:
304 case NL80211_CHAN_WIDTH_10:
305 case NL80211_CHAN_WIDTH_80P80:
306 case NL80211_CHAN_WIDTH_160:
307 phymode = MODE_UNKNOWN;
315 WARN_ON(phymode == MODE_UNKNOWN);
319 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
322 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
323 * 0 for no restriction
332 switch (mpdudensity) {
338 /* Our lower layer calculations limit our precision to
354 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
358 lockdep_assert_held(&ar->conf_mutex);
360 if (ar->num_peers >= ar->max_num_peers)
363 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
365 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
370 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
372 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
382 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
384 struct ath10k *ar = arvif->ar;
388 param = ar->wmi.pdev_param->sta_kickout_th;
389 ret = ath10k_wmi_pdev_set_param(ar, param,
390 ATH10K_KICKOUT_THRESHOLD);
392 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
393 arvif->vdev_id, ret);
397 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
398 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
399 ATH10K_KEEPALIVE_MIN_IDLE);
401 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
402 arvif->vdev_id, ret);
406 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
407 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
408 ATH10K_KEEPALIVE_MAX_IDLE);
410 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
411 arvif->vdev_id, ret);
415 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
416 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
417 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
419 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
420 arvif->vdev_id, ret);
427 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
429 struct ath10k *ar = arvif->ar;
432 vdev_param = ar->wmi.vdev_param->rts_threshold;
433 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
436 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
438 struct ath10k *ar = arvif->ar;
441 if (value != 0xFFFFFFFF)
442 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
443 ATH10K_FRAGMT_THRESHOLD_MIN,
444 ATH10K_FRAGMT_THRESHOLD_MAX);
446 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
447 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
450 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
454 lockdep_assert_held(&ar->conf_mutex);
456 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
460 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
469 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
471 struct ath10k_peer *peer, *tmp;
473 lockdep_assert_held(&ar->conf_mutex);
475 spin_lock_bh(&ar->data_lock);
476 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
477 if (peer->vdev_id != vdev_id)
480 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
481 peer->addr, vdev_id);
483 list_del(&peer->list);
487 spin_unlock_bh(&ar->data_lock);
490 static void ath10k_peer_cleanup_all(struct ath10k *ar)
492 struct ath10k_peer *peer, *tmp;
494 lockdep_assert_held(&ar->conf_mutex);
496 spin_lock_bh(&ar->data_lock);
497 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
498 list_del(&peer->list);
501 spin_unlock_bh(&ar->data_lock);
504 ar->num_stations = 0;
507 /************************/
508 /* Interface management */
509 /************************/
511 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
513 struct ath10k *ar = arvif->ar;
515 lockdep_assert_held(&ar->data_lock);
520 if (!arvif->beacon_buf)
521 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
522 arvif->beacon->len, DMA_TO_DEVICE);
524 dev_kfree_skb_any(arvif->beacon);
526 arvif->beacon = NULL;
527 arvif->beacon_sent = false;
530 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
532 struct ath10k *ar = arvif->ar;
534 lockdep_assert_held(&ar->data_lock);
536 ath10k_mac_vif_beacon_free(arvif);
538 if (arvif->beacon_buf) {
539 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
540 arvif->beacon_buf, arvif->beacon_paddr);
541 arvif->beacon_buf = NULL;
545 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
549 lockdep_assert_held(&ar->conf_mutex);
551 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
554 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
555 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
562 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
564 struct cfg80211_chan_def *chandef = &ar->chandef;
565 struct ieee80211_channel *channel = chandef->chan;
566 struct wmi_vdev_start_request_arg arg = {};
569 lockdep_assert_held(&ar->conf_mutex);
571 arg.vdev_id = vdev_id;
572 arg.channel.freq = channel->center_freq;
573 arg.channel.band_center_freq1 = chandef->center_freq1;
575 /* TODO setup this dynamically, what in case we
576 don't have any vifs? */
577 arg.channel.mode = chan_to_phymode(chandef);
578 arg.channel.chan_radar =
579 !!(channel->flags & IEEE80211_CHAN_RADAR);
581 arg.channel.min_power = 0;
582 arg.channel.max_power = channel->max_power * 2;
583 arg.channel.max_reg_power = channel->max_reg_power * 2;
584 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
586 reinit_completion(&ar->vdev_setup_done);
588 ret = ath10k_wmi_vdev_start(ar, &arg);
590 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
595 ret = ath10k_vdev_setup_sync(ar);
597 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i: %d\n",
602 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
604 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
609 ar->monitor_vdev_id = vdev_id;
611 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
612 ar->monitor_vdev_id);
616 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
618 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
619 ar->monitor_vdev_id, ret);
624 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
628 lockdep_assert_held(&ar->conf_mutex);
630 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
632 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
633 ar->monitor_vdev_id, ret);
635 reinit_completion(&ar->vdev_setup_done);
637 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
639 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
640 ar->monitor_vdev_id, ret);
642 ret = ath10k_vdev_setup_sync(ar);
644 ath10k_warn(ar, "failed to synchronise monitor vdev %i: %d\n",
645 ar->monitor_vdev_id, ret);
647 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
648 ar->monitor_vdev_id);
652 static int ath10k_monitor_vdev_create(struct ath10k *ar)
656 lockdep_assert_held(&ar->conf_mutex);
658 if (ar->free_vdev_map == 0) {
659 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
663 bit = __ffs64(ar->free_vdev_map);
665 ar->monitor_vdev_id = bit;
667 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
668 WMI_VDEV_TYPE_MONITOR,
671 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
672 ar->monitor_vdev_id, ret);
676 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
677 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
678 ar->monitor_vdev_id);
683 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
687 lockdep_assert_held(&ar->conf_mutex);
689 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
691 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
692 ar->monitor_vdev_id, ret);
696 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
698 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
699 ar->monitor_vdev_id);
703 static int ath10k_monitor_start(struct ath10k *ar)
707 lockdep_assert_held(&ar->conf_mutex);
709 ret = ath10k_monitor_vdev_create(ar);
711 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
715 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
717 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
718 ath10k_monitor_vdev_delete(ar);
722 ar->monitor_started = true;
723 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
728 static int ath10k_monitor_stop(struct ath10k *ar)
732 lockdep_assert_held(&ar->conf_mutex);
734 ret = ath10k_monitor_vdev_stop(ar);
736 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
740 ret = ath10k_monitor_vdev_delete(ar);
742 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
746 ar->monitor_started = false;
747 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
752 static int ath10k_monitor_recalc(struct ath10k *ar)
756 lockdep_assert_held(&ar->conf_mutex);
758 should_start = ar->monitor ||
759 ar->filter_flags & FIF_PROMISC_IN_BSS ||
760 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
762 ath10k_dbg(ar, ATH10K_DBG_MAC,
763 "mac monitor recalc started? %d should? %d\n",
764 ar->monitor_started, should_start);
766 if (should_start == ar->monitor_started)
770 return ath10k_monitor_start(ar);
772 return ath10k_monitor_stop(ar);
775 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
777 struct ath10k *ar = arvif->ar;
778 u32 vdev_param, rts_cts = 0;
780 lockdep_assert_held(&ar->conf_mutex);
782 vdev_param = ar->wmi.vdev_param->enable_rtscts;
784 if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
785 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
787 if (arvif->num_legacy_stations > 0)
788 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
791 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
795 static int ath10k_start_cac(struct ath10k *ar)
799 lockdep_assert_held(&ar->conf_mutex);
801 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
803 ret = ath10k_monitor_recalc(ar);
805 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
806 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
810 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
811 ar->monitor_vdev_id);
816 static int ath10k_stop_cac(struct ath10k *ar)
818 lockdep_assert_held(&ar->conf_mutex);
820 /* CAC is not running - do nothing */
821 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
824 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
825 ath10k_monitor_stop(ar);
827 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
832 static void ath10k_recalc_radar_detection(struct ath10k *ar)
836 lockdep_assert_held(&ar->conf_mutex);
840 if (!ar->radar_enabled)
843 if (ar->num_started_vdevs > 0)
846 ret = ath10k_start_cac(ar);
849 * Not possible to start CAC on current channel so starting
850 * radiation is not allowed, make this channel DFS_UNAVAILABLE
851 * by indicating that radar was detected.
853 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
854 ieee80211_radar_detected(ar->hw);
858 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, bool restart)
860 struct ath10k *ar = arvif->ar;
861 struct cfg80211_chan_def *chandef = &ar->chandef;
862 struct wmi_vdev_start_request_arg arg = {};
865 lockdep_assert_held(&ar->conf_mutex);
867 reinit_completion(&ar->vdev_setup_done);
869 arg.vdev_id = arvif->vdev_id;
870 arg.dtim_period = arvif->dtim_period;
871 arg.bcn_intval = arvif->beacon_interval;
873 arg.channel.freq = chandef->chan->center_freq;
874 arg.channel.band_center_freq1 = chandef->center_freq1;
875 arg.channel.mode = chan_to_phymode(chandef);
877 arg.channel.min_power = 0;
878 arg.channel.max_power = chandef->chan->max_power * 2;
879 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
880 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
882 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
883 arg.ssid = arvif->u.ap.ssid;
884 arg.ssid_len = arvif->u.ap.ssid_len;
885 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
887 /* For now allow DFS for AP mode */
888 arg.channel.chan_radar =
889 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
890 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
891 arg.ssid = arvif->vif->bss_conf.ssid;
892 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
895 ath10k_dbg(ar, ATH10K_DBG_MAC,
896 "mac vdev %d start center_freq %d phymode %s\n",
897 arg.vdev_id, arg.channel.freq,
898 ath10k_wmi_phymode_str(arg.channel.mode));
901 ret = ath10k_wmi_vdev_restart(ar, &arg);
903 ret = ath10k_wmi_vdev_start(ar, &arg);
906 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
911 ret = ath10k_vdev_setup_sync(ar);
913 ath10k_warn(ar, "failed to synchronise setup for vdev %i: %d\n",
918 ar->num_started_vdevs++;
919 ath10k_recalc_radar_detection(ar);
924 static int ath10k_vdev_start(struct ath10k_vif *arvif)
926 return ath10k_vdev_start_restart(arvif, false);
929 static int ath10k_vdev_restart(struct ath10k_vif *arvif)
931 return ath10k_vdev_start_restart(arvif, true);
934 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
936 struct ath10k *ar = arvif->ar;
939 lockdep_assert_held(&ar->conf_mutex);
941 reinit_completion(&ar->vdev_setup_done);
943 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
945 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
946 arvif->vdev_id, ret);
950 ret = ath10k_vdev_setup_sync(ar);
952 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
953 arvif->vdev_id, ret);
957 WARN_ON(ar->num_started_vdevs == 0);
959 if (ar->num_started_vdevs != 0) {
960 ar->num_started_vdevs--;
961 ath10k_recalc_radar_detection(ar);
967 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
968 struct ieee80211_bss_conf *info)
970 struct ath10k *ar = arvif->ar;
973 lockdep_assert_held(&arvif->ar->conf_mutex);
975 if (!info->enable_beacon) {
976 ath10k_vdev_stop(arvif);
978 arvif->is_started = false;
979 arvif->is_up = false;
981 spin_lock_bh(&arvif->ar->data_lock);
982 ath10k_mac_vif_beacon_free(arvif);
983 spin_unlock_bh(&arvif->ar->data_lock);
988 arvif->tx_seq_no = 0x1000;
990 ret = ath10k_vdev_start(arvif);
995 ether_addr_copy(arvif->bssid, info->bssid);
997 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1000 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1001 arvif->vdev_id, ret);
1002 ath10k_vdev_stop(arvif);
1006 arvif->is_started = true;
1007 arvif->is_up = true;
1009 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1012 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1013 struct ieee80211_bss_conf *info,
1014 const u8 self_peer[ETH_ALEN])
1016 struct ath10k *ar = arvif->ar;
1020 lockdep_assert_held(&arvif->ar->conf_mutex);
1022 if (!info->ibss_joined) {
1023 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
1025 ath10k_warn(ar, "failed to delete IBSS self peer %pM for vdev %d: %d\n",
1026 self_peer, arvif->vdev_id, ret);
1028 if (is_zero_ether_addr(arvif->bssid))
1031 memset(arvif->bssid, 0, ETH_ALEN);
1036 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
1038 ath10k_warn(ar, "failed to create IBSS self peer %pM for vdev %d: %d\n",
1039 self_peer, arvif->vdev_id, ret);
1043 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1044 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1045 ATH10K_DEFAULT_ATIM);
1047 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1048 arvif->vdev_id, ret);
1051 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1053 struct ath10k *ar = arvif->ar;
1058 lockdep_assert_held(&arvif->ar->conf_mutex);
1060 if (arvif->u.sta.uapsd)
1061 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1063 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1065 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1066 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1068 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1069 value, arvif->vdev_id, ret);
1076 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1078 struct ath10k *ar = arvif->ar;
1083 lockdep_assert_held(&arvif->ar->conf_mutex);
1085 if (arvif->u.sta.uapsd)
1086 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1088 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1090 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1091 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1094 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1095 value, arvif->vdev_id, ret);
1102 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1104 struct ath10k *ar = arvif->ar;
1105 struct ieee80211_vif *vif = arvif->vif;
1106 struct ieee80211_conf *conf = &ar->hw->conf;
1107 enum wmi_sta_powersave_param param;
1108 enum wmi_sta_ps_mode psmode;
1112 lockdep_assert_held(&arvif->ar->conf_mutex);
1114 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1117 if (vif->bss_conf.ps) {
1118 psmode = WMI_STA_PS_MODE_ENABLED;
1119 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1121 ps_timeout = conf->dynamic_ps_timeout;
1122 if (ps_timeout == 0) {
1123 /* Firmware doesn't like 0 */
1124 ps_timeout = ieee80211_tu_to_usec(
1125 vif->bss_conf.beacon_int) / 1000;
1128 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1131 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1132 arvif->vdev_id, ret);
1136 psmode = WMI_STA_PS_MODE_DISABLED;
1139 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1140 arvif->vdev_id, psmode ? "enable" : "disable");
1142 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1144 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1145 psmode, arvif->vdev_id, ret);
1152 /**********************/
1153 /* Station management */
1154 /**********************/
1156 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1157 struct ieee80211_vif *vif)
1159 /* Some firmware revisions have unstable STA powersave when listen
1160 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1161 * generate NullFunc frames properly even if buffered frames have been
1162 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1163 * buffered frames. Often pinging the device from AP would simply fail.
1165 * As a workaround set it to 1.
1167 if (vif->type == NL80211_IFTYPE_STATION)
1170 return ar->hw->conf.listen_interval;
1173 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1174 struct ieee80211_vif *vif,
1175 struct ieee80211_sta *sta,
1176 struct wmi_peer_assoc_complete_arg *arg)
1178 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1180 lockdep_assert_held(&ar->conf_mutex);
1182 ether_addr_copy(arg->addr, sta->addr);
1183 arg->vdev_id = arvif->vdev_id;
1184 arg->peer_aid = sta->aid;
1185 arg->peer_flags |= WMI_PEER_AUTH;
1186 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1187 arg->peer_num_spatial_streams = 1;
1188 arg->peer_caps = vif->bss_conf.assoc_capability;
1191 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1192 struct ieee80211_vif *vif,
1193 struct wmi_peer_assoc_complete_arg *arg)
1195 struct ieee80211_bss_conf *info = &vif->bss_conf;
1196 struct cfg80211_bss *bss;
1197 const u8 *rsnie = NULL;
1198 const u8 *wpaie = NULL;
1200 lockdep_assert_held(&ar->conf_mutex);
1202 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1203 info->bssid, NULL, 0, 0, 0);
1205 const struct cfg80211_bss_ies *ies;
1208 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1210 ies = rcu_dereference(bss->ies);
1212 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1213 WLAN_OUI_TYPE_MICROSOFT_WPA,
1217 cfg80211_put_bss(ar->hw->wiphy, bss);
1220 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1221 if (rsnie || wpaie) {
1222 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1223 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1227 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1228 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1232 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1233 struct ieee80211_sta *sta,
1234 struct wmi_peer_assoc_complete_arg *arg)
1236 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1237 const struct ieee80211_supported_band *sband;
1238 const struct ieee80211_rate *rates;
1242 lockdep_assert_held(&ar->conf_mutex);
1244 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1245 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1246 rates = sband->bitrates;
1248 rateset->num_rates = 0;
1250 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1251 if (!(ratemask & 1))
1254 rateset->rates[rateset->num_rates] = rates->hw_value;
1255 rateset->num_rates++;
1259 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1260 struct ieee80211_sta *sta,
1261 struct wmi_peer_assoc_complete_arg *arg)
1263 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1267 lockdep_assert_held(&ar->conf_mutex);
1269 if (!ht_cap->ht_supported)
1272 arg->peer_flags |= WMI_PEER_HT;
1273 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1274 ht_cap->ampdu_factor)) - 1;
1276 arg->peer_mpdu_density =
1277 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1279 arg->peer_ht_caps = ht_cap->cap;
1280 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1282 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1283 arg->peer_flags |= WMI_PEER_LDPC;
1285 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1286 arg->peer_flags |= WMI_PEER_40MHZ;
1287 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1290 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1291 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1293 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1294 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1296 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1297 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1298 arg->peer_flags |= WMI_PEER_STBC;
1301 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1302 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1303 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1304 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1305 arg->peer_rate_caps |= stbc;
1306 arg->peer_flags |= WMI_PEER_STBC;
1309 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1310 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1311 else if (ht_cap->mcs.rx_mask[1])
1312 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1314 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1315 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1316 arg->peer_ht_rates.rates[n++] = i;
1319 * This is a workaround for HT-enabled STAs which break the spec
1320 * and have no HT capabilities RX mask (no HT RX MCS map).
1322 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1323 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1325 * Firmware asserts if such situation occurs.
1328 arg->peer_ht_rates.num_rates = 8;
1329 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1330 arg->peer_ht_rates.rates[i] = i;
1332 arg->peer_ht_rates.num_rates = n;
1333 arg->peer_num_spatial_streams = sta->rx_nss;
1336 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1338 arg->peer_ht_rates.num_rates,
1339 arg->peer_num_spatial_streams);
1342 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1343 struct ath10k_vif *arvif,
1344 struct ieee80211_sta *sta)
1350 lockdep_assert_held(&ar->conf_mutex);
1352 if (sta->wme && sta->uapsd_queues) {
1353 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1354 sta->uapsd_queues, sta->max_sp);
1356 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1357 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1358 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1359 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1360 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1361 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1362 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1363 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1364 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1365 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1366 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1367 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1369 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1370 max_sp = sta->max_sp;
1372 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1374 WMI_AP_PS_PEER_PARAM_UAPSD,
1377 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
1378 arvif->vdev_id, ret);
1382 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1384 WMI_AP_PS_PEER_PARAM_MAX_SP,
1387 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
1388 arvif->vdev_id, ret);
1392 /* TODO setup this based on STA listen interval and
1393 beacon interval. Currently we don't know
1394 sta->listen_interval - mac80211 patch required.
1395 Currently use 10 seconds */
1396 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1397 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1400 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
1401 arvif->vdev_id, ret);
1409 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1410 struct ieee80211_sta *sta,
1411 struct wmi_peer_assoc_complete_arg *arg)
1413 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1416 if (!vht_cap->vht_supported)
1419 arg->peer_flags |= WMI_PEER_VHT;
1420 arg->peer_vht_caps = vht_cap->cap;
1422 ampdu_factor = (vht_cap->cap &
1423 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1424 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1426 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1427 * zero in VHT IE. Using it would result in degraded throughput.
1428 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1429 * it if VHT max_mpdu is smaller. */
1430 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1431 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1432 ampdu_factor)) - 1);
1434 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1435 arg->peer_flags |= WMI_PEER_80MHZ;
1437 arg->peer_vht_rates.rx_max_rate =
1438 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1439 arg->peer_vht_rates.rx_mcs_set =
1440 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1441 arg->peer_vht_rates.tx_max_rate =
1442 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1443 arg->peer_vht_rates.tx_mcs_set =
1444 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1446 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1447 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1450 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1451 struct ieee80211_vif *vif,
1452 struct ieee80211_sta *sta,
1453 struct wmi_peer_assoc_complete_arg *arg)
1455 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1457 switch (arvif->vdev_type) {
1458 case WMI_VDEV_TYPE_AP:
1460 arg->peer_flags |= WMI_PEER_QOS;
1462 if (sta->wme && sta->uapsd_queues) {
1463 arg->peer_flags |= WMI_PEER_APSD;
1464 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1467 case WMI_VDEV_TYPE_STA:
1468 if (vif->bss_conf.qos)
1469 arg->peer_flags |= WMI_PEER_QOS;
1476 static bool ath10k_mac_sta_has_11g_rates(struct ieee80211_sta *sta)
1478 /* First 4 rates in ath10k_rates are CCK (11b) rates. */
1479 return sta->supp_rates[IEEE80211_BAND_2GHZ] >> 4;
1482 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1483 struct ieee80211_vif *vif,
1484 struct ieee80211_sta *sta,
1485 struct wmi_peer_assoc_complete_arg *arg)
1487 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1489 switch (ar->hw->conf.chandef.chan->band) {
1490 case IEEE80211_BAND_2GHZ:
1491 if (sta->ht_cap.ht_supported) {
1492 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1493 phymode = MODE_11NG_HT40;
1495 phymode = MODE_11NG_HT20;
1496 } else if (ath10k_mac_sta_has_11g_rates(sta)) {
1503 case IEEE80211_BAND_5GHZ:
1507 if (sta->vht_cap.vht_supported) {
1508 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1509 phymode = MODE_11AC_VHT80;
1510 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1511 phymode = MODE_11AC_VHT40;
1512 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1513 phymode = MODE_11AC_VHT20;
1514 } else if (sta->ht_cap.ht_supported) {
1515 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1516 phymode = MODE_11NA_HT40;
1518 phymode = MODE_11NA_HT20;
1528 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1529 sta->addr, ath10k_wmi_phymode_str(phymode));
1531 arg->peer_phymode = phymode;
1532 WARN_ON(phymode == MODE_UNKNOWN);
1535 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1536 struct ieee80211_vif *vif,
1537 struct ieee80211_sta *sta,
1538 struct wmi_peer_assoc_complete_arg *arg)
1540 lockdep_assert_held(&ar->conf_mutex);
1542 memset(arg, 0, sizeof(*arg));
1544 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
1545 ath10k_peer_assoc_h_crypto(ar, vif, arg);
1546 ath10k_peer_assoc_h_rates(ar, sta, arg);
1547 ath10k_peer_assoc_h_ht(ar, sta, arg);
1548 ath10k_peer_assoc_h_vht(ar, sta, arg);
1549 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
1550 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
1555 static const u32 ath10k_smps_map[] = {
1556 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1557 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1558 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1559 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1562 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1564 const struct ieee80211_sta_ht_cap *ht_cap)
1568 if (!ht_cap->ht_supported)
1571 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1572 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1574 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1577 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1578 WMI_PEER_SMPS_STATE,
1579 ath10k_smps_map[smps]);
1582 /* can be called only in mac80211 callbacks due to `key_count` usage */
1583 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1584 struct ieee80211_vif *vif,
1585 struct ieee80211_bss_conf *bss_conf)
1587 struct ath10k *ar = hw->priv;
1588 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1589 struct ieee80211_sta_ht_cap ht_cap;
1590 struct wmi_peer_assoc_complete_arg peer_arg;
1591 struct ieee80211_sta *ap_sta;
1594 lockdep_assert_held(&ar->conf_mutex);
1596 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
1597 arvif->vdev_id, arvif->bssid, arvif->aid);
1601 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1603 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
1604 bss_conf->bssid, arvif->vdev_id);
1609 /* ap_sta must be accessed only within rcu section which must be left
1610 * before calling ath10k_setup_peer_smps() which might sleep. */
1611 ht_cap = ap_sta->ht_cap;
1613 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
1615 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
1616 bss_conf->bssid, arvif->vdev_id, ret);
1623 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1625 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
1626 bss_conf->bssid, arvif->vdev_id, ret);
1630 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1632 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
1633 arvif->vdev_id, ret);
1637 ath10k_dbg(ar, ATH10K_DBG_MAC,
1638 "mac vdev %d up (associated) bssid %pM aid %d\n",
1639 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1641 WARN_ON(arvif->is_up);
1643 arvif->aid = bss_conf->aid;
1644 ether_addr_copy(arvif->bssid, bss_conf->bssid);
1646 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1648 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
1649 arvif->vdev_id, ret);
1653 arvif->is_up = true;
1656 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1657 struct ieee80211_vif *vif)
1659 struct ath10k *ar = hw->priv;
1660 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1663 lockdep_assert_held(&ar->conf_mutex);
1665 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
1666 arvif->vdev_id, arvif->bssid);
1668 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1670 ath10k_warn(ar, "faield to down vdev %i: %d\n",
1671 arvif->vdev_id, ret);
1673 arvif->def_wep_key_idx = 0;
1674 arvif->is_up = false;
1677 static int ath10k_station_assoc(struct ath10k *ar,
1678 struct ieee80211_vif *vif,
1679 struct ieee80211_sta *sta,
1682 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1683 struct wmi_peer_assoc_complete_arg peer_arg;
1686 lockdep_assert_held(&ar->conf_mutex);
1688 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
1690 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1691 sta->addr, arvif->vdev_id, ret);
1695 peer_arg.peer_reassoc = reassoc;
1696 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1698 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
1699 sta->addr, arvif->vdev_id, ret);
1703 /* Re-assoc is run only to update supported rates for given station. It
1704 * doesn't make much sense to reconfigure the peer completely.
1707 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
1710 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
1711 arvif->vdev_id, ret);
1715 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1717 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
1718 sta->addr, arvif->vdev_id, ret);
1723 arvif->num_legacy_stations++;
1724 ret = ath10k_recalc_rtscts_prot(arvif);
1726 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1727 arvif->vdev_id, ret);
1732 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1734 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
1735 arvif->vdev_id, ret);
1743 static int ath10k_station_disassoc(struct ath10k *ar,
1744 struct ieee80211_vif *vif,
1745 struct ieee80211_sta *sta)
1747 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1750 lockdep_assert_held(&ar->conf_mutex);
1753 arvif->num_legacy_stations--;
1754 ret = ath10k_recalc_rtscts_prot(arvif);
1756 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1757 arvif->vdev_id, ret);
1762 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1764 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
1765 arvif->vdev_id, ret);
1776 static int ath10k_update_channel_list(struct ath10k *ar)
1778 struct ieee80211_hw *hw = ar->hw;
1779 struct ieee80211_supported_band **bands;
1780 enum ieee80211_band band;
1781 struct ieee80211_channel *channel;
1782 struct wmi_scan_chan_list_arg arg = {0};
1783 struct wmi_channel_arg *ch;
1789 lockdep_assert_held(&ar->conf_mutex);
1791 bands = hw->wiphy->bands;
1792 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1796 for (i = 0; i < bands[band]->n_channels; i++) {
1797 if (bands[band]->channels[i].flags &
1798 IEEE80211_CHAN_DISABLED)
1805 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1806 arg.channels = kzalloc(len, GFP_KERNEL);
1811 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1815 for (i = 0; i < bands[band]->n_channels; i++) {
1816 channel = &bands[band]->channels[i];
1818 if (channel->flags & IEEE80211_CHAN_DISABLED)
1821 ch->allow_ht = true;
1823 /* FIXME: when should we really allow VHT? */
1824 ch->allow_vht = true;
1827 !(channel->flags & IEEE80211_CHAN_NO_IR);
1830 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1833 !!(channel->flags & IEEE80211_CHAN_RADAR);
1835 passive = channel->flags & IEEE80211_CHAN_NO_IR;
1836 ch->passive = passive;
1838 ch->freq = channel->center_freq;
1839 ch->band_center_freq1 = channel->center_freq;
1841 ch->max_power = channel->max_power * 2;
1842 ch->max_reg_power = channel->max_reg_power * 2;
1843 ch->max_antenna_gain = channel->max_antenna_gain * 2;
1844 ch->reg_class_id = 0; /* FIXME */
1846 /* FIXME: why use only legacy modes, why not any
1847 * HT/VHT modes? Would that even make any
1849 if (channel->band == IEEE80211_BAND_2GHZ)
1850 ch->mode = MODE_11G;
1852 ch->mode = MODE_11A;
1854 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1857 ath10k_dbg(ar, ATH10K_DBG_WMI,
1858 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1859 ch - arg.channels, arg.n_channels,
1860 ch->freq, ch->max_power, ch->max_reg_power,
1861 ch->max_antenna_gain, ch->mode);
1867 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1868 kfree(arg.channels);
1873 static enum wmi_dfs_region
1874 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1876 switch (dfs_region) {
1877 case NL80211_DFS_UNSET:
1878 return WMI_UNINIT_DFS_DOMAIN;
1879 case NL80211_DFS_FCC:
1880 return WMI_FCC_DFS_DOMAIN;
1881 case NL80211_DFS_ETSI:
1882 return WMI_ETSI_DFS_DOMAIN;
1883 case NL80211_DFS_JP:
1884 return WMI_MKK4_DFS_DOMAIN;
1886 return WMI_UNINIT_DFS_DOMAIN;
1889 static void ath10k_regd_update(struct ath10k *ar)
1891 struct reg_dmn_pair_mapping *regpair;
1893 enum wmi_dfs_region wmi_dfs_reg;
1894 enum nl80211_dfs_regions nl_dfs_reg;
1896 lockdep_assert_held(&ar->conf_mutex);
1898 ret = ath10k_update_channel_list(ar);
1900 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
1902 regpair = ar->ath_common.regulatory.regpair;
1904 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1905 nl_dfs_reg = ar->dfs_detector->region;
1906 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1908 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1911 /* Target allows setting up per-band regdomain but ath_common provides
1912 * a combined one only */
1913 ret = ath10k_wmi_pdev_set_regdomain(ar,
1914 regpair->reg_domain,
1915 regpair->reg_domain, /* 2ghz */
1916 regpair->reg_domain, /* 5ghz */
1917 regpair->reg_2ghz_ctl,
1918 regpair->reg_5ghz_ctl,
1921 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
1924 static void ath10k_reg_notifier(struct wiphy *wiphy,
1925 struct regulatory_request *request)
1927 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1928 struct ath10k *ar = hw->priv;
1931 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1933 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1934 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1935 request->dfs_region);
1936 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1937 request->dfs_region);
1939 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
1940 request->dfs_region);
1943 mutex_lock(&ar->conf_mutex);
1944 if (ar->state == ATH10K_STATE_ON)
1945 ath10k_regd_update(ar);
1946 mutex_unlock(&ar->conf_mutex);
1953 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1955 if (ieee80211_is_mgmt(hdr->frame_control))
1956 return HTT_DATA_TX_EXT_TID_MGMT;
1958 if (!ieee80211_is_data_qos(hdr->frame_control))
1959 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1961 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1962 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1964 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1967 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
1970 return ath10k_vif_to_arvif(vif)->vdev_id;
1972 if (ar->monitor_started)
1973 return ar->monitor_vdev_id;
1975 ath10k_warn(ar, "failed to resolve vdev id\n");
1979 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1980 * Control in the header.
1982 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
1984 struct ieee80211_hdr *hdr = (void *)skb->data;
1985 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
1988 if (!ieee80211_is_data_qos(hdr->frame_control))
1991 qos_ctl = ieee80211_get_qos_ctl(hdr);
1992 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1993 skb->data, (void *)qos_ctl - (void *)skb->data);
1994 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1996 /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1997 * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1998 * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1999 * it is safe to downgrade to NullFunc.
2001 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
2002 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
2003 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
2007 static void ath10k_tx_wep_key_work(struct work_struct *work)
2009 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
2011 struct ath10k *ar = arvif->ar;
2012 int ret, keyidx = arvif->def_wep_key_newidx;
2014 mutex_lock(&arvif->ar->conf_mutex);
2016 if (arvif->ar->state != ATH10K_STATE_ON)
2019 if (arvif->def_wep_key_idx == keyidx)
2022 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
2023 arvif->vdev_id, keyidx);
2025 ret = ath10k_wmi_vdev_set_param(arvif->ar,
2027 arvif->ar->wmi.vdev_param->def_keyid,
2030 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
2036 arvif->def_wep_key_idx = keyidx;
2039 mutex_unlock(&arvif->ar->conf_mutex);
2042 static void ath10k_tx_h_update_wep_key(struct ieee80211_vif *vif,
2043 struct ieee80211_key_conf *key,
2044 struct sk_buff *skb)
2046 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2047 struct ath10k *ar = arvif->ar;
2048 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2050 if (!ieee80211_has_protected(hdr->frame_control))
2056 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
2057 key->cipher != WLAN_CIPHER_SUITE_WEP104)
2060 if (key->keyidx == arvif->def_wep_key_idx)
2063 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
2064 * queueing frames until key index is updated is not an option because
2065 * sk_buff may need more processing to be done, e.g. offchannel */
2066 arvif->def_wep_key_newidx = key->keyidx;
2067 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
2070 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
2071 struct ieee80211_vif *vif,
2072 struct sk_buff *skb)
2074 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2075 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2077 /* This is case only for P2P_GO */
2078 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
2079 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
2082 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
2083 spin_lock_bh(&ar->data_lock);
2084 if (arvif->u.ap.noa_data)
2085 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
2087 memcpy(skb_put(skb, arvif->u.ap.noa_len),
2088 arvif->u.ap.noa_data,
2089 arvif->u.ap.noa_len);
2090 spin_unlock_bh(&ar->data_lock);
2094 static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar)
2096 /* FIXME: Not really sure since when the behaviour changed. At some
2097 * point new firmware stopped requiring creation of peer entries for
2098 * offchannel tx (and actually creating them causes issues with wmi-htc
2099 * tx credit replenishment and reliability). Assuming it's at least 3.4
2100 * because that's when the `freq` was introduced to TX_FRM HTT command.
2102 return !(ar->htt.target_version_major >= 3 &&
2103 ar->htt.target_version_minor >= 4);
2106 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
2108 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2111 if (ar->htt.target_version_major >= 3) {
2112 /* Since HTT 3.0 there is no separate mgmt tx command */
2113 ret = ath10k_htt_tx(&ar->htt, skb);
2117 if (ieee80211_is_mgmt(hdr->frame_control)) {
2118 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2120 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
2121 ATH10K_MAX_NUM_MGMT_PENDING) {
2122 ath10k_warn(ar, "reached WMI management transmit queue limit\n");
2127 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2128 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2130 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2132 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2134 ieee80211_is_nullfunc(hdr->frame_control)) {
2135 /* FW does not report tx status properly for NullFunc frames
2136 * unless they are sent through mgmt tx path. mac80211 sends
2137 * those frames when it detects link/beacon loss and depends
2138 * on the tx status to be correct. */
2139 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2141 ret = ath10k_htt_tx(&ar->htt, skb);
2146 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
2148 ieee80211_free_txskb(ar->hw, skb);
2152 void ath10k_offchan_tx_purge(struct ath10k *ar)
2154 struct sk_buff *skb;
2157 skb = skb_dequeue(&ar->offchan_tx_queue);
2161 ieee80211_free_txskb(ar->hw, skb);
2165 void ath10k_offchan_tx_work(struct work_struct *work)
2167 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2168 struct ath10k_peer *peer;
2169 struct ieee80211_hdr *hdr;
2170 struct sk_buff *skb;
2171 const u8 *peer_addr;
2175 /* FW requirement: We must create a peer before FW will send out
2176 * an offchannel frame. Otherwise the frame will be stuck and
2177 * never transmitted. We delete the peer upon tx completion.
2178 * It is unlikely that a peer for offchannel tx will already be
2179 * present. However it may be in some rare cases so account for that.
2180 * Otherwise we might remove a legitimate peer and break stuff. */
2183 skb = skb_dequeue(&ar->offchan_tx_queue);
2187 mutex_lock(&ar->conf_mutex);
2189 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2192 hdr = (struct ieee80211_hdr *)skb->data;
2193 peer_addr = ieee80211_get_DA(hdr);
2194 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2196 spin_lock_bh(&ar->data_lock);
2197 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2198 spin_unlock_bh(&ar->data_lock);
2201 /* FIXME: should this use ath10k_warn()? */
2202 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2203 peer_addr, vdev_id);
2206 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2208 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
2209 peer_addr, vdev_id, ret);
2212 spin_lock_bh(&ar->data_lock);
2213 reinit_completion(&ar->offchan_tx_completed);
2214 ar->offchan_tx_skb = skb;
2215 spin_unlock_bh(&ar->data_lock);
2217 ath10k_tx_htt(ar, skb);
2219 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2222 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
2226 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2228 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
2229 peer_addr, vdev_id, ret);
2232 mutex_unlock(&ar->conf_mutex);
2236 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2238 struct sk_buff *skb;
2241 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2245 ieee80211_free_txskb(ar->hw, skb);
2249 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2251 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2252 struct sk_buff *skb;
2256 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2260 ret = ath10k_wmi_mgmt_tx(ar, skb);
2262 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
2264 ieee80211_free_txskb(ar->hw, skb);
2273 void __ath10k_scan_finish(struct ath10k *ar)
2275 lockdep_assert_held(&ar->data_lock);
2277 switch (ar->scan.state) {
2278 case ATH10K_SCAN_IDLE:
2280 case ATH10K_SCAN_RUNNING:
2281 if (ar->scan.is_roc)
2282 ieee80211_remain_on_channel_expired(ar->hw);
2283 case ATH10K_SCAN_ABORTING:
2284 if (!ar->scan.is_roc)
2285 ieee80211_scan_completed(ar->hw,
2287 ATH10K_SCAN_ABORTING));
2289 case ATH10K_SCAN_STARTING:
2290 ar->scan.state = ATH10K_SCAN_IDLE;
2291 ar->scan_channel = NULL;
2292 ath10k_offchan_tx_purge(ar);
2293 cancel_delayed_work(&ar->scan.timeout);
2294 complete_all(&ar->scan.completed);
2299 void ath10k_scan_finish(struct ath10k *ar)
2301 spin_lock_bh(&ar->data_lock);
2302 __ath10k_scan_finish(ar);
2303 spin_unlock_bh(&ar->data_lock);
2306 static int ath10k_scan_stop(struct ath10k *ar)
2308 struct wmi_stop_scan_arg arg = {
2309 .req_id = 1, /* FIXME */
2310 .req_type = WMI_SCAN_STOP_ONE,
2311 .u.scan_id = ATH10K_SCAN_ID,
2315 lockdep_assert_held(&ar->conf_mutex);
2317 ret = ath10k_wmi_stop_scan(ar, &arg);
2319 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
2323 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2325 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
2327 } else if (ret > 0) {
2332 /* Scan state should be updated upon scan completion but in case
2333 * firmware fails to deliver the event (for whatever reason) it is
2334 * desired to clean up scan state anyway. Firmware may have just
2335 * dropped the scan completion event delivery due to transport pipe
2336 * being overflown with data and/or it can recover on its own before
2337 * next scan request is submitted.
2339 spin_lock_bh(&ar->data_lock);
2340 if (ar->scan.state != ATH10K_SCAN_IDLE)
2341 __ath10k_scan_finish(ar);
2342 spin_unlock_bh(&ar->data_lock);
2347 static void ath10k_scan_abort(struct ath10k *ar)
2351 lockdep_assert_held(&ar->conf_mutex);
2353 spin_lock_bh(&ar->data_lock);
2355 switch (ar->scan.state) {
2356 case ATH10K_SCAN_IDLE:
2357 /* This can happen if timeout worker kicked in and called
2358 * abortion while scan completion was being processed.
2361 case ATH10K_SCAN_STARTING:
2362 case ATH10K_SCAN_ABORTING:
2363 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
2364 ath10k_scan_state_str(ar->scan.state),
2367 case ATH10K_SCAN_RUNNING:
2368 ar->scan.state = ATH10K_SCAN_ABORTING;
2369 spin_unlock_bh(&ar->data_lock);
2371 ret = ath10k_scan_stop(ar);
2373 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
2375 spin_lock_bh(&ar->data_lock);
2379 spin_unlock_bh(&ar->data_lock);
2382 void ath10k_scan_timeout_work(struct work_struct *work)
2384 struct ath10k *ar = container_of(work, struct ath10k,
2387 mutex_lock(&ar->conf_mutex);
2388 ath10k_scan_abort(ar);
2389 mutex_unlock(&ar->conf_mutex);
2392 static int ath10k_start_scan(struct ath10k *ar,
2393 const struct wmi_start_scan_arg *arg)
2397 lockdep_assert_held(&ar->conf_mutex);
2399 ret = ath10k_wmi_start_scan(ar, arg);
2403 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2405 ret = ath10k_scan_stop(ar);
2407 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
2412 /* Add a 200ms margin to account for event/command processing */
2413 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
2414 msecs_to_jiffies(arg->max_scan_time+200));
2418 /**********************/
2419 /* mac80211 callbacks */
2420 /**********************/
2422 static void ath10k_tx(struct ieee80211_hw *hw,
2423 struct ieee80211_tx_control *control,
2424 struct sk_buff *skb)
2426 struct ath10k *ar = hw->priv;
2427 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2428 struct ieee80211_vif *vif = info->control.vif;
2429 struct ieee80211_key_conf *key = info->control.hw_key;
2430 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2432 /* We should disable CCK RATE due to P2P */
2433 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2434 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2436 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2437 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2438 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
2440 /* it makes no sense to process injected frames like that */
2441 if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2442 ath10k_tx_h_nwifi(hw, skb);
2443 ath10k_tx_h_update_wep_key(vif, key, skb);
2444 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2445 ath10k_tx_h_seq_no(vif, skb);
2448 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2449 spin_lock_bh(&ar->data_lock);
2450 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
2451 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2452 spin_unlock_bh(&ar->data_lock);
2454 if (ath10k_mac_need_offchan_tx_work(ar)) {
2455 ATH10K_SKB_CB(skb)->htt.freq = 0;
2456 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2458 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
2461 skb_queue_tail(&ar->offchan_tx_queue, skb);
2462 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2467 ath10k_tx_htt(ar, skb);
2470 /* Must not be called with conf_mutex held as workers can use that also. */
2471 void ath10k_drain_tx(struct ath10k *ar)
2473 /* make sure rcu-protected mac80211 tx path itself is drained */
2476 ath10k_offchan_tx_purge(ar);
2477 ath10k_mgmt_over_wmi_tx_purge(ar);
2479 cancel_work_sync(&ar->offchan_tx_work);
2480 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2483 void ath10k_halt(struct ath10k *ar)
2485 struct ath10k_vif *arvif;
2487 lockdep_assert_held(&ar->conf_mutex);
2489 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2490 ar->filter_flags = 0;
2491 ar->monitor = false;
2493 if (ar->monitor_started)
2494 ath10k_monitor_stop(ar);
2496 ar->monitor_started = false;
2498 ath10k_scan_finish(ar);
2499 ath10k_peer_cleanup_all(ar);
2500 ath10k_core_stop(ar);
2501 ath10k_hif_power_down(ar);
2503 spin_lock_bh(&ar->data_lock);
2504 list_for_each_entry(arvif, &ar->arvifs, list)
2505 ath10k_mac_vif_beacon_cleanup(arvif);
2506 spin_unlock_bh(&ar->data_lock);
2509 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2511 struct ath10k *ar = hw->priv;
2513 mutex_lock(&ar->conf_mutex);
2515 if (ar->cfg_tx_chainmask) {
2516 *tx_ant = ar->cfg_tx_chainmask;
2517 *rx_ant = ar->cfg_rx_chainmask;
2519 *tx_ant = ar->supp_tx_chainmask;
2520 *rx_ant = ar->supp_rx_chainmask;
2523 mutex_unlock(&ar->conf_mutex);
2528 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
2530 /* It is not clear that allowing gaps in chainmask
2531 * is helpful. Probably it will not do what user
2532 * is hoping for, so warn in that case.
2534 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
2537 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
2541 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2545 lockdep_assert_held(&ar->conf_mutex);
2547 ath10k_check_chain_mask(ar, tx_ant, "tx");
2548 ath10k_check_chain_mask(ar, rx_ant, "rx");
2550 ar->cfg_tx_chainmask = tx_ant;
2551 ar->cfg_rx_chainmask = rx_ant;
2553 if ((ar->state != ATH10K_STATE_ON) &&
2554 (ar->state != ATH10K_STATE_RESTARTED))
2557 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2560 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
2565 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2568 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
2576 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2578 struct ath10k *ar = hw->priv;
2581 mutex_lock(&ar->conf_mutex);
2582 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2583 mutex_unlock(&ar->conf_mutex);
2587 static int ath10k_start(struct ieee80211_hw *hw)
2589 struct ath10k *ar = hw->priv;
2593 * This makes sense only when restarting hw. It is harmless to call
2594 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2595 * commands will be submitted while restarting.
2597 ath10k_drain_tx(ar);
2599 mutex_lock(&ar->conf_mutex);
2601 switch (ar->state) {
2602 case ATH10K_STATE_OFF:
2603 ar->state = ATH10K_STATE_ON;
2605 case ATH10K_STATE_RESTARTING:
2607 ar->state = ATH10K_STATE_RESTARTED;
2609 case ATH10K_STATE_ON:
2610 case ATH10K_STATE_RESTARTED:
2611 case ATH10K_STATE_WEDGED:
2615 case ATH10K_STATE_UTF:
2620 ret = ath10k_hif_power_up(ar);
2622 ath10k_err(ar, "Could not init hif: %d\n", ret);
2626 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
2628 ath10k_err(ar, "Could not init core: %d\n", ret);
2629 goto err_power_down;
2632 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2634 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
2638 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2640 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
2644 if (ar->cfg_tx_chainmask)
2645 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2646 ar->cfg_rx_chainmask);
2649 * By default FW set ARP frames ac to voice (6). In that case ARP
2650 * exchange is not working properly for UAPSD enabled AP. ARP requests
2651 * which arrives with access category 0 are processed by network stack
2652 * and send back with access category 0, but FW changes access category
2653 * to 6. Set ARP frames access category to best effort (0) solves
2657 ret = ath10k_wmi_pdev_set_param(ar,
2658 ar->wmi.pdev_param->arp_ac_override, 0);
2660 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
2665 ar->num_started_vdevs = 0;
2666 ath10k_regd_update(ar);
2668 ath10k_spectral_start(ar);
2670 mutex_unlock(&ar->conf_mutex);
2674 ath10k_core_stop(ar);
2677 ath10k_hif_power_down(ar);
2680 ar->state = ATH10K_STATE_OFF;
2683 mutex_unlock(&ar->conf_mutex);
2687 static void ath10k_stop(struct ieee80211_hw *hw)
2689 struct ath10k *ar = hw->priv;
2691 ath10k_drain_tx(ar);
2693 mutex_lock(&ar->conf_mutex);
2694 if (ar->state != ATH10K_STATE_OFF) {
2696 ar->state = ATH10K_STATE_OFF;
2698 mutex_unlock(&ar->conf_mutex);
2700 cancel_delayed_work_sync(&ar->scan.timeout);
2701 cancel_work_sync(&ar->restart_work);
2704 static int ath10k_config_ps(struct ath10k *ar)
2706 struct ath10k_vif *arvif;
2709 lockdep_assert_held(&ar->conf_mutex);
2711 list_for_each_entry(arvif, &ar->arvifs, list) {
2712 ret = ath10k_mac_vif_setup_ps(arvif);
2714 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
2722 static const char *chandef_get_width(enum nl80211_chan_width width)
2725 case NL80211_CHAN_WIDTH_20_NOHT:
2727 case NL80211_CHAN_WIDTH_20:
2729 case NL80211_CHAN_WIDTH_40:
2731 case NL80211_CHAN_WIDTH_80:
2733 case NL80211_CHAN_WIDTH_80P80:
2735 case NL80211_CHAN_WIDTH_160:
2737 case NL80211_CHAN_WIDTH_5:
2739 case NL80211_CHAN_WIDTH_10:
2745 static void ath10k_config_chan(struct ath10k *ar)
2747 struct ath10k_vif *arvif;
2750 lockdep_assert_held(&ar->conf_mutex);
2752 ath10k_dbg(ar, ATH10K_DBG_MAC,
2753 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2754 ar->chandef.chan->center_freq,
2755 ar->chandef.center_freq1,
2756 ar->chandef.center_freq2,
2757 chandef_get_width(ar->chandef.width));
2759 /* First stop monitor interface. Some FW versions crash if there's a
2760 * lone monitor interface. */
2761 if (ar->monitor_started)
2762 ath10k_monitor_stop(ar);
2764 list_for_each_entry(arvif, &ar->arvifs, list) {
2765 if (!arvif->is_started)
2771 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2774 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2776 ath10k_warn(ar, "failed to down vdev %d: %d\n",
2777 arvif->vdev_id, ret);
2782 /* all vdevs are downed now - attempt to restart and re-up them */
2784 list_for_each_entry(arvif, &ar->arvifs, list) {
2785 if (!arvif->is_started)
2788 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2791 ret = ath10k_vdev_restart(arvif);
2793 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
2794 arvif->vdev_id, ret);
2801 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2804 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
2805 arvif->vdev_id, ret);
2810 ath10k_monitor_recalc(ar);
2813 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
2818 lockdep_assert_held(&ar->conf_mutex);
2820 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
2822 param = ar->wmi.pdev_param->txpower_limit2g;
2823 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2825 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2830 param = ar->wmi.pdev_param->txpower_limit5g;
2831 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2833 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2841 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
2843 struct ath10k_vif *arvif;
2844 int ret, txpower = -1;
2846 lockdep_assert_held(&ar->conf_mutex);
2848 list_for_each_entry(arvif, &ar->arvifs, list) {
2849 WARN_ON(arvif->txpower < 0);
2852 txpower = arvif->txpower;
2854 txpower = min(txpower, arvif->txpower);
2857 if (WARN_ON(txpower == -1))
2860 ret = ath10k_mac_txpower_setup(ar, txpower);
2862 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
2870 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2872 struct ath10k *ar = hw->priv;
2873 struct ieee80211_conf *conf = &hw->conf;
2876 mutex_lock(&ar->conf_mutex);
2878 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2879 ath10k_dbg(ar, ATH10K_DBG_MAC,
2880 "mac config channel %dMHz flags 0x%x radar %d\n",
2881 conf->chandef.chan->center_freq,
2882 conf->chandef.chan->flags,
2883 conf->radar_enabled);
2885 spin_lock_bh(&ar->data_lock);
2886 ar->rx_channel = conf->chandef.chan;
2887 spin_unlock_bh(&ar->data_lock);
2889 ar->radar_enabled = conf->radar_enabled;
2890 ath10k_recalc_radar_detection(ar);
2892 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2893 ar->chandef = conf->chandef;
2894 ath10k_config_chan(ar);
2898 if (changed & IEEE80211_CONF_CHANGE_PS)
2899 ath10k_config_ps(ar);
2901 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2902 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
2903 ret = ath10k_monitor_recalc(ar);
2905 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
2908 mutex_unlock(&ar->conf_mutex);
2912 static u32 get_nss_from_chainmask(u16 chain_mask)
2914 if ((chain_mask & 0x15) == 0x15)
2916 else if ((chain_mask & 0x7) == 0x7)
2918 else if ((chain_mask & 0x3) == 0x3)
2925 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2926 * because we will send mgmt frames without CCK. This requirement
2927 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2930 static int ath10k_add_interface(struct ieee80211_hw *hw,
2931 struct ieee80211_vif *vif)
2933 struct ath10k *ar = hw->priv;
2934 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2935 enum wmi_sta_powersave_param param;
2941 mutex_lock(&ar->conf_mutex);
2943 memset(arvif, 0, sizeof(*arvif));
2948 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2949 INIT_LIST_HEAD(&arvif->list);
2951 if (ar->free_vdev_map == 0) {
2952 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
2956 bit = __ffs64(ar->free_vdev_map);
2958 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
2959 bit, ar->free_vdev_map);
2961 arvif->vdev_id = bit;
2962 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2964 switch (vif->type) {
2965 case NL80211_IFTYPE_P2P_DEVICE:
2966 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2967 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2969 case NL80211_IFTYPE_UNSPECIFIED:
2970 case NL80211_IFTYPE_STATION:
2971 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2973 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2975 case NL80211_IFTYPE_ADHOC:
2976 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2978 case NL80211_IFTYPE_AP:
2979 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2982 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2984 case NL80211_IFTYPE_MONITOR:
2985 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2992 /* Some firmware revisions don't wait for beacon tx completion before
2993 * sending another SWBA event. This could lead to hardware using old
2994 * (freed) beacon data in some cases, e.g. tx credit starvation
2995 * combined with missed TBTT. This is very very rare.
2997 * On non-IOMMU-enabled hosts this could be a possible security issue
2998 * because hw could beacon some random data on the air. On
2999 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
3000 * device would crash.
3002 * Since there are no beacon tx completions (implicit nor explicit)
3003 * propagated to host the only workaround for this is to allocate a
3004 * DMA-coherent buffer for a lifetime of a vif and use it for all
3005 * beacon tx commands. Worst case for this approach is some beacons may
3006 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
3008 if (vif->type == NL80211_IFTYPE_ADHOC ||
3009 vif->type == NL80211_IFTYPE_AP) {
3010 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
3011 IEEE80211_MAX_FRAME_LEN,
3012 &arvif->beacon_paddr,
3014 if (!arvif->beacon_buf) {
3016 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
3022 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
3023 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
3024 arvif->beacon_buf ? "single-buf" : "per-skb");
3026 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
3027 arvif->vdev_subtype, vif->addr);
3029 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
3030 arvif->vdev_id, ret);
3034 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
3035 list_add(&arvif->list, &ar->arvifs);
3037 vdev_param = ar->wmi.vdev_param->def_keyid;
3038 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
3039 arvif->def_wep_key_idx);
3041 ath10k_warn(ar, "failed to set vdev %i default key id: %d\n",
3042 arvif->vdev_id, ret);
3043 goto err_vdev_delete;
3046 vdev_param = ar->wmi.vdev_param->tx_encap_type;
3047 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3048 ATH10K_HW_TXRX_NATIVE_WIFI);
3049 /* 10.X firmware does not support this VDEV parameter. Do not warn */
3050 if (ret && ret != -EOPNOTSUPP) {
3051 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
3052 arvif->vdev_id, ret);
3053 goto err_vdev_delete;
3056 if (ar->cfg_tx_chainmask) {
3057 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
3059 vdev_param = ar->wmi.vdev_param->nss;
3060 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3063 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
3064 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
3066 goto err_vdev_delete;
3070 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
3071 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
3073 ath10k_warn(ar, "failed to create vdev %i peer for AP: %d\n",
3074 arvif->vdev_id, ret);
3075 goto err_vdev_delete;
3078 ret = ath10k_mac_set_kickout(arvif);
3080 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
3081 arvif->vdev_id, ret);
3082 goto err_peer_delete;
3086 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
3087 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
3088 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3089 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3092 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
3093 arvif->vdev_id, ret);
3094 goto err_peer_delete;
3097 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
3099 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
3100 arvif->vdev_id, ret);
3101 goto err_peer_delete;
3104 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
3106 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
3107 arvif->vdev_id, ret);
3108 goto err_peer_delete;
3112 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
3114 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
3115 arvif->vdev_id, ret);
3116 goto err_peer_delete;
3119 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
3121 ath10k_warn(ar, "failed to set frag threshold for vdev %d: %d\n",
3122 arvif->vdev_id, ret);
3123 goto err_peer_delete;
3126 arvif->txpower = vif->bss_conf.txpower;
3127 ret = ath10k_mac_txpower_recalc(ar);
3129 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3130 goto err_peer_delete;
3133 mutex_unlock(&ar->conf_mutex);
3137 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
3138 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
3141 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3142 ar->free_vdev_map |= 1LL << arvif->vdev_id;
3143 list_del(&arvif->list);
3146 if (arvif->beacon_buf) {
3147 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
3148 arvif->beacon_buf, arvif->beacon_paddr);
3149 arvif->beacon_buf = NULL;
3152 mutex_unlock(&ar->conf_mutex);
3157 static void ath10k_remove_interface(struct ieee80211_hw *hw,
3158 struct ieee80211_vif *vif)
3160 struct ath10k *ar = hw->priv;
3161 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3164 cancel_work_sync(&arvif->wep_key_work);
3166 mutex_lock(&ar->conf_mutex);
3168 spin_lock_bh(&ar->data_lock);
3169 ath10k_mac_vif_beacon_cleanup(arvif);
3170 spin_unlock_bh(&ar->data_lock);
3172 ret = ath10k_spectral_vif_stop(arvif);
3174 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
3175 arvif->vdev_id, ret);
3177 ar->free_vdev_map |= 1LL << arvif->vdev_id;
3178 list_del(&arvif->list);
3180 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
3181 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
3183 ath10k_warn(ar, "failed to remove peer for AP vdev %i: %d\n",
3184 arvif->vdev_id, ret);
3186 kfree(arvif->u.ap.noa_data);
3189 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
3192 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3194 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
3195 arvif->vdev_id, ret);
3197 ath10k_peer_cleanup(ar, arvif->vdev_id);
3199 mutex_unlock(&ar->conf_mutex);
3203 * FIXME: Has to be verified.
3205 #define SUPPORTED_FILTERS \
3206 (FIF_PROMISC_IN_BSS | \
3211 FIF_BCN_PRBRESP_PROMISC | \
3215 static void ath10k_configure_filter(struct ieee80211_hw *hw,
3216 unsigned int changed_flags,
3217 unsigned int *total_flags,
3220 struct ath10k *ar = hw->priv;
3223 mutex_lock(&ar->conf_mutex);
3225 changed_flags &= SUPPORTED_FILTERS;
3226 *total_flags &= SUPPORTED_FILTERS;
3227 ar->filter_flags = *total_flags;
3229 ret = ath10k_monitor_recalc(ar);
3231 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
3233 mutex_unlock(&ar->conf_mutex);
3236 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
3237 struct ieee80211_vif *vif,
3238 struct ieee80211_bss_conf *info,
3241 struct ath10k *ar = hw->priv;
3242 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3244 u32 vdev_param, pdev_param, slottime, preamble;
3246 mutex_lock(&ar->conf_mutex);
3248 if (changed & BSS_CHANGED_IBSS)
3249 ath10k_control_ibss(arvif, info, vif->addr);
3251 if (changed & BSS_CHANGED_BEACON_INT) {
3252 arvif->beacon_interval = info->beacon_int;
3253 vdev_param = ar->wmi.vdev_param->beacon_interval;
3254 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3255 arvif->beacon_interval);
3256 ath10k_dbg(ar, ATH10K_DBG_MAC,
3257 "mac vdev %d beacon_interval %d\n",
3258 arvif->vdev_id, arvif->beacon_interval);
3261 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
3262 arvif->vdev_id, ret);
3265 if (changed & BSS_CHANGED_BEACON) {
3266 ath10k_dbg(ar, ATH10K_DBG_MAC,
3267 "vdev %d set beacon tx mode to staggered\n",
3270 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3271 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
3272 WMI_BEACON_STAGGERED_MODE);
3274 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
3275 arvif->vdev_id, ret);
3278 if (changed & BSS_CHANGED_BEACON_INFO) {
3279 arvif->dtim_period = info->dtim_period;
3281 ath10k_dbg(ar, ATH10K_DBG_MAC,
3282 "mac vdev %d dtim_period %d\n",
3283 arvif->vdev_id, arvif->dtim_period);
3285 vdev_param = ar->wmi.vdev_param->dtim_period;
3286 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3287 arvif->dtim_period);
3289 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
3290 arvif->vdev_id, ret);
3293 if (changed & BSS_CHANGED_SSID &&
3294 vif->type == NL80211_IFTYPE_AP) {
3295 arvif->u.ap.ssid_len = info->ssid_len;
3297 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3298 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3301 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3302 ether_addr_copy(arvif->bssid, info->bssid);
3304 if (changed & BSS_CHANGED_BEACON_ENABLED)
3305 ath10k_control_beaconing(arvif, info);
3307 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3308 arvif->use_cts_prot = info->use_cts_prot;
3309 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3310 arvif->vdev_id, info->use_cts_prot);
3312 ret = ath10k_recalc_rtscts_prot(arvif);
3314 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3315 arvif->vdev_id, ret);
3318 if (changed & BSS_CHANGED_ERP_SLOT) {
3319 if (info->use_short_slot)
3320 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3323 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3325 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3326 arvif->vdev_id, slottime);
3328 vdev_param = ar->wmi.vdev_param->slot_time;
3329 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3332 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
3333 arvif->vdev_id, ret);
3336 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3337 if (info->use_short_preamble)
3338 preamble = WMI_VDEV_PREAMBLE_SHORT;
3340 preamble = WMI_VDEV_PREAMBLE_LONG;
3342 ath10k_dbg(ar, ATH10K_DBG_MAC,
3343 "mac vdev %d preamble %dn",
3344 arvif->vdev_id, preamble);
3346 vdev_param = ar->wmi.vdev_param->preamble;
3347 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3350 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
3351 arvif->vdev_id, ret);
3354 if (changed & BSS_CHANGED_ASSOC) {
3356 /* Workaround: Make sure monitor vdev is not running
3357 * when associating to prevent some firmware revisions
3358 * (e.g. 10.1 and 10.2) from crashing.
3360 if (ar->monitor_started)
3361 ath10k_monitor_stop(ar);
3362 ath10k_bss_assoc(hw, vif, info);
3363 ath10k_monitor_recalc(ar);
3365 ath10k_bss_disassoc(hw, vif);
3369 if (changed & BSS_CHANGED_TXPOWER) {
3370 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3371 arvif->vdev_id, info->txpower);
3373 arvif->txpower = info->txpower;
3374 ret = ath10k_mac_txpower_recalc(ar);
3376 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3379 if (changed & BSS_CHANGED_PS) {
3380 ret = ath10k_mac_vif_setup_ps(arvif);
3382 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
3383 arvif->vdev_id, ret);
3386 mutex_unlock(&ar->conf_mutex);
3389 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3390 struct ieee80211_vif *vif,
3391 struct ieee80211_scan_request *hw_req)
3393 struct ath10k *ar = hw->priv;
3394 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3395 struct cfg80211_scan_request *req = &hw_req->req;
3396 struct wmi_start_scan_arg arg;
3400 mutex_lock(&ar->conf_mutex);
3402 spin_lock_bh(&ar->data_lock);
3403 switch (ar->scan.state) {
3404 case ATH10K_SCAN_IDLE:
3405 reinit_completion(&ar->scan.started);
3406 reinit_completion(&ar->scan.completed);
3407 ar->scan.state = ATH10K_SCAN_STARTING;
3408 ar->scan.is_roc = false;
3409 ar->scan.vdev_id = arvif->vdev_id;
3412 case ATH10K_SCAN_STARTING:
3413 case ATH10K_SCAN_RUNNING:
3414 case ATH10K_SCAN_ABORTING:
3418 spin_unlock_bh(&ar->data_lock);
3423 memset(&arg, 0, sizeof(arg));
3424 ath10k_wmi_start_scan_init(ar, &arg);
3425 arg.vdev_id = arvif->vdev_id;
3426 arg.scan_id = ATH10K_SCAN_ID;
3429 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3432 arg.ie_len = req->ie_len;
3433 memcpy(arg.ie, req->ie, arg.ie_len);
3437 arg.n_ssids = req->n_ssids;
3438 for (i = 0; i < arg.n_ssids; i++) {
3439 arg.ssids[i].len = req->ssids[i].ssid_len;
3440 arg.ssids[i].ssid = req->ssids[i].ssid;
3443 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3446 if (req->n_channels) {
3447 arg.n_channels = req->n_channels;
3448 for (i = 0; i < arg.n_channels; i++)
3449 arg.channels[i] = req->channels[i]->center_freq;
3452 ret = ath10k_start_scan(ar, &arg);
3454 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
3455 spin_lock_bh(&ar->data_lock);
3456 ar->scan.state = ATH10K_SCAN_IDLE;
3457 spin_unlock_bh(&ar->data_lock);
3461 mutex_unlock(&ar->conf_mutex);
3465 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3466 struct ieee80211_vif *vif)
3468 struct ath10k *ar = hw->priv;
3470 mutex_lock(&ar->conf_mutex);
3471 ath10k_scan_abort(ar);
3472 mutex_unlock(&ar->conf_mutex);
3474 cancel_delayed_work_sync(&ar->scan.timeout);
3477 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3478 struct ath10k_vif *arvif,
3479 enum set_key_cmd cmd,
3480 struct ieee80211_key_conf *key)
3482 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3485 /* 10.1 firmware branch requires default key index to be set to group
3486 * key index after installing it. Otherwise FW/HW Txes corrupted
3487 * frames with multi-vif APs. This is not required for main firmware
3488 * branch (e.g. 636).
3490 * FIXME: This has been tested only in AP. It remains unknown if this
3491 * is required for multi-vif STA interfaces on 10.1 */
3493 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3496 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3499 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3502 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3508 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3511 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
3512 arvif->vdev_id, ret);
3515 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3516 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3517 struct ieee80211_key_conf *key)
3519 struct ath10k *ar = hw->priv;
3520 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3521 struct ath10k_peer *peer;
3522 const u8 *peer_addr;
3523 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3524 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3527 if (key->keyidx > WMI_MAX_KEY_INDEX)
3530 mutex_lock(&ar->conf_mutex);
3533 peer_addr = sta->addr;
3534 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3535 peer_addr = vif->bss_conf.bssid;
3537 peer_addr = vif->addr;
3539 key->hw_key_idx = key->keyidx;
3541 /* the peer should not disappear in mid-way (unless FW goes awry) since
3542 * we already hold conf_mutex. we just make sure its there now. */
3543 spin_lock_bh(&ar->data_lock);
3544 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3545 spin_unlock_bh(&ar->data_lock);
3548 if (cmd == SET_KEY) {
3549 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
3554 /* if the peer doesn't exist there is no key to disable
3562 arvif->wep_keys[key->keyidx] = key;
3564 arvif->wep_keys[key->keyidx] = NULL;
3566 if (cmd == DISABLE_KEY)
3567 ath10k_clear_vdev_key(arvif, key);
3570 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3572 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
3573 arvif->vdev_id, peer_addr, ret);
3577 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3579 spin_lock_bh(&ar->data_lock);
3580 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3581 if (peer && cmd == SET_KEY)
3582 peer->keys[key->keyidx] = key;
3583 else if (peer && cmd == DISABLE_KEY)
3584 peer->keys[key->keyidx] = NULL;
3585 else if (peer == NULL)
3586 /* impossible unless FW goes crazy */
3587 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
3588 spin_unlock_bh(&ar->data_lock);
3591 mutex_unlock(&ar->conf_mutex);
3595 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3598 struct ath10k_vif *arvif;
3599 struct ath10k_sta *arsta;
3600 struct ieee80211_sta *sta;
3601 u32 changed, bw, nss, smps;
3604 arsta = container_of(wk, struct ath10k_sta, update_wk);
3605 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3606 arvif = arsta->arvif;
3609 spin_lock_bh(&ar->data_lock);
3611 changed = arsta->changed;
3618 spin_unlock_bh(&ar->data_lock);
3620 mutex_lock(&ar->conf_mutex);
3622 if (changed & IEEE80211_RC_BW_CHANGED) {
3623 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3626 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3627 WMI_PEER_CHAN_WIDTH, bw);
3629 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
3630 sta->addr, bw, err);
3633 if (changed & IEEE80211_RC_NSS_CHANGED) {
3634 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3637 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3640 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
3641 sta->addr, nss, err);
3644 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3645 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3648 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3649 WMI_PEER_SMPS_STATE, smps);
3651 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
3652 sta->addr, smps, err);
3655 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3656 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3659 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
3661 ath10k_warn(ar, "failed to reassociate station: %pM\n",
3665 mutex_unlock(&ar->conf_mutex);
3668 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif)
3670 struct ath10k *ar = arvif->ar;
3672 lockdep_assert_held(&ar->conf_mutex);
3674 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
3675 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
3678 if (ar->num_stations >= ar->max_num_stations)
3686 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif)
3688 struct ath10k *ar = arvif->ar;
3690 lockdep_assert_held(&ar->conf_mutex);
3692 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
3693 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
3699 static int ath10k_sta_state(struct ieee80211_hw *hw,
3700 struct ieee80211_vif *vif,
3701 struct ieee80211_sta *sta,
3702 enum ieee80211_sta_state old_state,
3703 enum ieee80211_sta_state new_state)
3705 struct ath10k *ar = hw->priv;
3706 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3707 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3710 if (old_state == IEEE80211_STA_NOTEXIST &&
3711 new_state == IEEE80211_STA_NONE) {
3712 memset(arsta, 0, sizeof(*arsta));
3713 arsta->arvif = arvif;
3714 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3717 /* cancel must be done outside the mutex to avoid deadlock */
3718 if ((old_state == IEEE80211_STA_NONE &&
3719 new_state == IEEE80211_STA_NOTEXIST))
3720 cancel_work_sync(&arsta->update_wk);
3722 mutex_lock(&ar->conf_mutex);
3724 if (old_state == IEEE80211_STA_NOTEXIST &&
3725 new_state == IEEE80211_STA_NONE) {
3727 * New station addition.
3729 ath10k_dbg(ar, ATH10K_DBG_MAC,
3730 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
3731 arvif->vdev_id, sta->addr,
3732 ar->num_stations + 1, ar->max_num_stations,
3733 ar->num_peers + 1, ar->max_num_peers);
3735 ret = ath10k_mac_inc_num_stations(arvif);
3737 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
3738 ar->max_num_stations);
3742 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3744 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3745 sta->addr, arvif->vdev_id, ret);
3746 ath10k_mac_dec_num_stations(arvif);
3750 if (vif->type == NL80211_IFTYPE_STATION) {
3751 WARN_ON(arvif->is_started);
3753 ret = ath10k_vdev_start(arvif);
3755 ath10k_warn(ar, "failed to start vdev %i: %d\n",
3756 arvif->vdev_id, ret);
3757 WARN_ON(ath10k_peer_delete(ar, arvif->vdev_id,
3759 ath10k_mac_dec_num_stations(arvif);
3763 arvif->is_started = true;
3765 } else if ((old_state == IEEE80211_STA_NONE &&
3766 new_state == IEEE80211_STA_NOTEXIST)) {
3768 * Existing station deletion.
3770 ath10k_dbg(ar, ATH10K_DBG_MAC,
3771 "mac vdev %d peer delete %pM (sta gone)\n",
3772 arvif->vdev_id, sta->addr);
3774 if (vif->type == NL80211_IFTYPE_STATION) {
3775 WARN_ON(!arvif->is_started);
3777 ret = ath10k_vdev_stop(arvif);
3779 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
3780 arvif->vdev_id, ret);
3782 arvif->is_started = false;
3785 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3787 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
3788 sta->addr, arvif->vdev_id, ret);
3790 ath10k_mac_dec_num_stations(arvif);
3791 } else if (old_state == IEEE80211_STA_AUTH &&
3792 new_state == IEEE80211_STA_ASSOC &&
3793 (vif->type == NL80211_IFTYPE_AP ||
3794 vif->type == NL80211_IFTYPE_ADHOC)) {
3798 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
3801 ret = ath10k_station_assoc(ar, vif, sta, false);
3803 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
3804 sta->addr, arvif->vdev_id, ret);
3805 } else if (old_state == IEEE80211_STA_ASSOC &&
3806 new_state == IEEE80211_STA_AUTH &&
3807 (vif->type == NL80211_IFTYPE_AP ||
3808 vif->type == NL80211_IFTYPE_ADHOC)) {
3812 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3815 ret = ath10k_station_disassoc(ar, vif, sta);
3817 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
3818 sta->addr, arvif->vdev_id, ret);
3821 mutex_unlock(&ar->conf_mutex);
3825 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3826 u16 ac, bool enable)
3828 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3832 lockdep_assert_held(&ar->conf_mutex);
3834 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3838 case IEEE80211_AC_VO:
3839 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3840 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3842 case IEEE80211_AC_VI:
3843 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3844 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3846 case IEEE80211_AC_BE:
3847 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3848 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3850 case IEEE80211_AC_BK:
3851 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3852 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3857 arvif->u.sta.uapsd |= value;
3859 arvif->u.sta.uapsd &= ~value;
3861 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3862 WMI_STA_PS_PARAM_UAPSD,
3863 arvif->u.sta.uapsd);
3865 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
3869 if (arvif->u.sta.uapsd)
3870 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3872 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3874 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3875 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3878 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
3880 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
3882 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
3883 arvif->vdev_id, ret);
3887 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
3889 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
3890 arvif->vdev_id, ret);
3898 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3899 struct ieee80211_vif *vif, u16 ac,
3900 const struct ieee80211_tx_queue_params *params)
3902 struct ath10k *ar = hw->priv;
3903 struct wmi_wmm_params_arg *p = NULL;
3906 mutex_lock(&ar->conf_mutex);
3909 case IEEE80211_AC_VO:
3910 p = &ar->wmm_params.ac_vo;
3912 case IEEE80211_AC_VI:
3913 p = &ar->wmm_params.ac_vi;
3915 case IEEE80211_AC_BE:
3916 p = &ar->wmm_params.ac_be;
3918 case IEEE80211_AC_BK:
3919 p = &ar->wmm_params.ac_bk;
3928 p->cwmin = params->cw_min;
3929 p->cwmax = params->cw_max;
3930 p->aifs = params->aifs;
3933 * The channel time duration programmed in the HW is in absolute
3934 * microseconds, while mac80211 gives the txop in units of
3937 p->txop = params->txop * 32;
3939 /* FIXME: FW accepts wmm params per hw, not per vif */
3940 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3942 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
3946 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3948 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
3951 mutex_unlock(&ar->conf_mutex);
3955 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3957 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3958 struct ieee80211_vif *vif,
3959 struct ieee80211_channel *chan,
3961 enum ieee80211_roc_type type)
3963 struct ath10k *ar = hw->priv;
3964 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3965 struct wmi_start_scan_arg arg;
3968 mutex_lock(&ar->conf_mutex);
3970 spin_lock_bh(&ar->data_lock);
3971 switch (ar->scan.state) {
3972 case ATH10K_SCAN_IDLE:
3973 reinit_completion(&ar->scan.started);
3974 reinit_completion(&ar->scan.completed);
3975 reinit_completion(&ar->scan.on_channel);
3976 ar->scan.state = ATH10K_SCAN_STARTING;
3977 ar->scan.is_roc = true;
3978 ar->scan.vdev_id = arvif->vdev_id;
3979 ar->scan.roc_freq = chan->center_freq;
3982 case ATH10K_SCAN_STARTING:
3983 case ATH10K_SCAN_RUNNING:
3984 case ATH10K_SCAN_ABORTING:
3988 spin_unlock_bh(&ar->data_lock);
3993 duration = max(duration, WMI_SCAN_CHAN_MIN_TIME_MSEC);
3995 memset(&arg, 0, sizeof(arg));
3996 ath10k_wmi_start_scan_init(ar, &arg);
3997 arg.vdev_id = arvif->vdev_id;
3998 arg.scan_id = ATH10K_SCAN_ID;
4000 arg.channels[0] = chan->center_freq;
4001 arg.dwell_time_active = duration;
4002 arg.dwell_time_passive = duration;
4003 arg.max_scan_time = 2 * duration;
4004 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4005 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
4007 ret = ath10k_start_scan(ar, &arg);
4009 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
4010 spin_lock_bh(&ar->data_lock);
4011 ar->scan.state = ATH10K_SCAN_IDLE;
4012 spin_unlock_bh(&ar->data_lock);
4016 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
4018 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
4020 ret = ath10k_scan_stop(ar);
4022 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
4030 mutex_unlock(&ar->conf_mutex);
4034 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
4036 struct ath10k *ar = hw->priv;
4038 mutex_lock(&ar->conf_mutex);
4039 ath10k_scan_abort(ar);
4040 mutex_unlock(&ar->conf_mutex);
4042 cancel_delayed_work_sync(&ar->scan.timeout);
4048 * Both RTS and Fragmentation threshold are interface-specific
4049 * in ath10k, but device-specific in mac80211.
4052 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
4054 struct ath10k *ar = hw->priv;
4055 struct ath10k_vif *arvif;
4058 mutex_lock(&ar->conf_mutex);
4059 list_for_each_entry(arvif, &ar->arvifs, list) {
4060 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
4061 arvif->vdev_id, value);
4063 ret = ath10k_mac_set_rts(arvif, value);
4065 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4066 arvif->vdev_id, ret);
4070 mutex_unlock(&ar->conf_mutex);
4075 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
4076 u32 queues, bool drop)
4078 struct ath10k *ar = hw->priv;
4082 /* mac80211 doesn't care if we really xmit queued frames or not
4083 * we'll collect those frames either way if we stop/delete vdevs */
4087 mutex_lock(&ar->conf_mutex);
4089 if (ar->state == ATH10K_STATE_WEDGED)
4092 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
4095 spin_lock_bh(&ar->htt.tx_lock);
4096 empty = (ar->htt.num_pending_tx == 0);
4097 spin_unlock_bh(&ar->htt.tx_lock);
4099 skip = (ar->state == ATH10K_STATE_WEDGED) ||
4100 test_bit(ATH10K_FLAG_CRASH_FLUSH,
4104 }), ATH10K_FLUSH_TIMEOUT_HZ);
4106 if (ret <= 0 || skip)
4107 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %i\n",
4108 skip, ar->state, ret);
4111 mutex_unlock(&ar->conf_mutex);
4114 /* TODO: Implement this function properly
4115 * For now it is needed to reply to Probe Requests in IBSS mode.
4116 * Propably we need this information from FW.
4118 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
4124 static int ath10k_suspend(struct ieee80211_hw *hw,
4125 struct cfg80211_wowlan *wowlan)
4127 struct ath10k *ar = hw->priv;
4130 mutex_lock(&ar->conf_mutex);
4132 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
4134 if (ret == -ETIMEDOUT)
4140 ret = ath10k_hif_suspend(ar);
4142 ath10k_warn(ar, "failed to suspend hif: %d\n", ret);
4149 ret = ath10k_wmi_pdev_resume_target(ar);
4151 ath10k_warn(ar, "failed to resume target: %d\n", ret);
4155 mutex_unlock(&ar->conf_mutex);
4159 static int ath10k_resume(struct ieee80211_hw *hw)
4161 struct ath10k *ar = hw->priv;
4164 mutex_lock(&ar->conf_mutex);
4166 ret = ath10k_hif_resume(ar);
4168 ath10k_warn(ar, "failed to resume hif: %d\n", ret);
4173 ret = ath10k_wmi_pdev_resume_target(ar);
4175 ath10k_warn(ar, "failed to resume target: %d\n", ret);
4182 mutex_unlock(&ar->conf_mutex);
4187 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
4188 enum ieee80211_reconfig_type reconfig_type)
4190 struct ath10k *ar = hw->priv;
4192 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
4195 mutex_lock(&ar->conf_mutex);
4197 /* If device failed to restart it will be in a different state, e.g.
4198 * ATH10K_STATE_WEDGED */
4199 if (ar->state == ATH10K_STATE_RESTARTED) {
4200 ath10k_info(ar, "device successfully recovered\n");
4201 ar->state = ATH10K_STATE_ON;
4202 ieee80211_wake_queues(ar->hw);
4205 mutex_unlock(&ar->conf_mutex);
4208 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
4209 struct survey_info *survey)
4211 struct ath10k *ar = hw->priv;
4212 struct ieee80211_supported_band *sband;
4213 struct survey_info *ar_survey = &ar->survey[idx];
4216 mutex_lock(&ar->conf_mutex);
4218 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
4219 if (sband && idx >= sband->n_channels) {
4220 idx -= sband->n_channels;
4225 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
4227 if (!sband || idx >= sband->n_channels) {
4232 spin_lock_bh(&ar->data_lock);
4233 memcpy(survey, ar_survey, sizeof(*survey));
4234 spin_unlock_bh(&ar->data_lock);
4236 survey->channel = &sband->channels[idx];
4238 if (ar->rx_channel == survey->channel)
4239 survey->filled |= SURVEY_INFO_IN_USE;
4242 mutex_unlock(&ar->conf_mutex);
4246 /* Helper table for legacy fixed_rate/bitrate_mask */
4247 static const u8 cck_ofdm_rate[] = {
4264 /* Check if only one bit set */
4265 static int ath10k_check_single_mask(u32 mask)
4273 mask &= ~BIT(bit - 1);
4281 ath10k_default_bitrate_mask(struct ath10k *ar,
4282 enum ieee80211_band band,
4283 const struct cfg80211_bitrate_mask *mask)
4285 u32 legacy = 0x00ff;
4288 u16 nrf = ar->num_rf_chains;
4290 if (ar->cfg_tx_chainmask)
4291 nrf = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4294 case IEEE80211_BAND_2GHZ:
4298 case IEEE80211_BAND_5GHZ:
4304 if (mask->control[band].legacy != legacy)
4307 for (i = 0; i < nrf; i++)
4308 if (mask->control[band].ht_mcs[i] != ht)
4311 for (i = 0; i < nrf; i++)
4312 if (mask->control[band].vht_mcs[i] != vht)
4319 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
4320 enum ieee80211_band band,
4323 int ht_nss = 0, vht_nss = 0, i;
4326 if (ath10k_check_single_mask(mask->control[band].legacy))
4330 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4331 if (mask->control[band].ht_mcs[i] == 0xff)
4333 else if (mask->control[band].ht_mcs[i] == 0x00)
4342 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4343 if (mask->control[band].vht_mcs[i] == 0x03ff)
4345 else if (mask->control[band].vht_mcs[i] == 0x0000)
4353 if (ht_nss > 0 && vht_nss > 0)
4357 *fixed_nss = ht_nss;
4359 *fixed_nss = vht_nss;
4367 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4368 enum ieee80211_band band,
4369 enum wmi_rate_preamble *preamble)
4371 int legacy = 0, ht = 0, vht = 0, i;
4373 *preamble = WMI_RATE_PREAMBLE_OFDM;
4376 legacy = ath10k_check_single_mask(mask->control[band].legacy);
4381 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4382 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4387 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4388 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4392 /* Currently we support only one fixed_rate */
4393 if ((legacy + ht + vht) != 1)
4397 *preamble = WMI_RATE_PREAMBLE_HT;
4399 *preamble = WMI_RATE_PREAMBLE_VHT;
4405 ath10k_bitrate_mask_rate(struct ath10k *ar,
4406 const struct cfg80211_bitrate_mask *mask,
4407 enum ieee80211_band band,
4411 u8 rate = 0, pream = 0, nss = 0, i;
4412 enum wmi_rate_preamble preamble;
4414 /* Check if single rate correct */
4415 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4421 case WMI_RATE_PREAMBLE_CCK:
4422 case WMI_RATE_PREAMBLE_OFDM:
4423 i = ffs(mask->control[band].legacy) - 1;
4425 if (band == IEEE80211_BAND_2GHZ && i < 4)
4426 pream = WMI_RATE_PREAMBLE_CCK;
4428 if (band == IEEE80211_BAND_5GHZ)
4431 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4434 rate = cck_ofdm_rate[i];
4436 case WMI_RATE_PREAMBLE_HT:
4437 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4438 if (mask->control[band].ht_mcs[i])
4441 if (i == IEEE80211_HT_MCS_MASK_LEN)
4444 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4447 case WMI_RATE_PREAMBLE_VHT:
4448 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4449 if (mask->control[band].vht_mcs[i])
4452 if (i == NL80211_VHT_NSS_MAX)
4455 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4460 *fixed_nss = nss + 1;
4464 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4467 *fixed_rate = pream | nss | rate;
4472 static bool ath10k_get_fixed_rate_nss(struct ath10k *ar,
4473 const struct cfg80211_bitrate_mask *mask,
4474 enum ieee80211_band band,
4478 /* First check full NSS mask, if we can simply limit NSS */
4479 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4482 /* Next Check single rate is set */
4483 return ath10k_bitrate_mask_rate(ar, mask, band, fixed_rate, fixed_nss);
4486 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4491 struct ath10k *ar = arvif->ar;
4495 mutex_lock(&ar->conf_mutex);
4497 if (arvif->fixed_rate == fixed_rate &&
4498 arvif->fixed_nss == fixed_nss &&
4499 arvif->force_sgi == force_sgi)
4502 if (fixed_rate == WMI_FIXED_RATE_NONE)
4503 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4506 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac force sgi\n");
4508 vdev_param = ar->wmi.vdev_param->fixed_rate;
4509 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4510 vdev_param, fixed_rate);
4512 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
4518 arvif->fixed_rate = fixed_rate;
4520 vdev_param = ar->wmi.vdev_param->nss;
4521 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4522 vdev_param, fixed_nss);
4525 ath10k_warn(ar, "failed to set fixed nss param %d: %d\n",
4531 arvif->fixed_nss = fixed_nss;
4533 vdev_param = ar->wmi.vdev_param->sgi;
4534 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4538 ath10k_warn(ar, "failed to set sgi param %d: %d\n",
4544 arvif->force_sgi = force_sgi;
4547 mutex_unlock(&ar->conf_mutex);
4551 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4552 struct ieee80211_vif *vif,
4553 const struct cfg80211_bitrate_mask *mask)
4555 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4556 struct ath10k *ar = arvif->ar;
4557 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4558 u8 fixed_rate = WMI_FIXED_RATE_NONE;
4559 u8 fixed_nss = ar->num_rf_chains;
4562 if (ar->cfg_tx_chainmask)
4563 fixed_nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4565 force_sgi = mask->control[band].gi;
4566 if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4569 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4570 if (!ath10k_get_fixed_rate_nss(ar, mask, band,
4576 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4577 ath10k_warn(ar, "failed to force SGI usage for default rate settings\n");
4581 return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4582 fixed_nss, force_sgi);
4585 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4586 struct ieee80211_vif *vif,
4587 struct ieee80211_sta *sta,
4590 struct ath10k *ar = hw->priv;
4591 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4594 spin_lock_bh(&ar->data_lock);
4596 ath10k_dbg(ar, ATH10K_DBG_MAC,
4597 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4598 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4601 if (changed & IEEE80211_RC_BW_CHANGED) {
4602 bw = WMI_PEER_CHWIDTH_20MHZ;
4604 switch (sta->bandwidth) {
4605 case IEEE80211_STA_RX_BW_20:
4606 bw = WMI_PEER_CHWIDTH_20MHZ;
4608 case IEEE80211_STA_RX_BW_40:
4609 bw = WMI_PEER_CHWIDTH_40MHZ;
4611 case IEEE80211_STA_RX_BW_80:
4612 bw = WMI_PEER_CHWIDTH_80MHZ;
4614 case IEEE80211_STA_RX_BW_160:
4615 ath10k_warn(ar, "Invalid bandwith %d in rc update for %pM\n",
4616 sta->bandwidth, sta->addr);
4617 bw = WMI_PEER_CHWIDTH_20MHZ;
4624 if (changed & IEEE80211_RC_NSS_CHANGED)
4625 arsta->nss = sta->rx_nss;
4627 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4628 smps = WMI_PEER_SMPS_PS_NONE;
4630 switch (sta->smps_mode) {
4631 case IEEE80211_SMPS_AUTOMATIC:
4632 case IEEE80211_SMPS_OFF:
4633 smps = WMI_PEER_SMPS_PS_NONE;
4635 case IEEE80211_SMPS_STATIC:
4636 smps = WMI_PEER_SMPS_STATIC;
4638 case IEEE80211_SMPS_DYNAMIC:
4639 smps = WMI_PEER_SMPS_DYNAMIC;
4641 case IEEE80211_SMPS_NUM_MODES:
4642 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
4643 sta->smps_mode, sta->addr);
4644 smps = WMI_PEER_SMPS_PS_NONE;
4651 arsta->changed |= changed;
4653 spin_unlock_bh(&ar->data_lock);
4655 ieee80211_queue_work(hw, &arsta->update_wk);
4658 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4661 * FIXME: Return 0 for time being. Need to figure out whether FW
4662 * has the API to fetch 64-bit local TSF
4668 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
4669 struct ieee80211_vif *vif,
4670 enum ieee80211_ampdu_mlme_action action,
4671 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4674 struct ath10k *ar = hw->priv;
4675 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4677 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
4678 arvif->vdev_id, sta->addr, tid, action);
4681 case IEEE80211_AMPDU_RX_START:
4682 case IEEE80211_AMPDU_RX_STOP:
4683 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4684 * creation/removal. Do we need to verify this?
4687 case IEEE80211_AMPDU_TX_START:
4688 case IEEE80211_AMPDU_TX_STOP_CONT:
4689 case IEEE80211_AMPDU_TX_STOP_FLUSH:
4690 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4691 case IEEE80211_AMPDU_TX_OPERATIONAL:
4692 /* Firmware offloads Tx aggregation entirely so deny mac80211
4693 * Tx aggregation requests.
4701 static const struct ieee80211_ops ath10k_ops = {
4703 .start = ath10k_start,
4704 .stop = ath10k_stop,
4705 .config = ath10k_config,
4706 .add_interface = ath10k_add_interface,
4707 .remove_interface = ath10k_remove_interface,
4708 .configure_filter = ath10k_configure_filter,
4709 .bss_info_changed = ath10k_bss_info_changed,
4710 .hw_scan = ath10k_hw_scan,
4711 .cancel_hw_scan = ath10k_cancel_hw_scan,
4712 .set_key = ath10k_set_key,
4713 .sta_state = ath10k_sta_state,
4714 .conf_tx = ath10k_conf_tx,
4715 .remain_on_channel = ath10k_remain_on_channel,
4716 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
4717 .set_rts_threshold = ath10k_set_rts_threshold,
4718 .flush = ath10k_flush,
4719 .tx_last_beacon = ath10k_tx_last_beacon,
4720 .set_antenna = ath10k_set_antenna,
4721 .get_antenna = ath10k_get_antenna,
4722 .reconfig_complete = ath10k_reconfig_complete,
4723 .get_survey = ath10k_get_survey,
4724 .set_bitrate_mask = ath10k_set_bitrate_mask,
4725 .sta_rc_update = ath10k_sta_rc_update,
4726 .get_tsf = ath10k_get_tsf,
4727 .ampdu_action = ath10k_ampdu_action,
4728 .get_et_sset_count = ath10k_debug_get_et_sset_count,
4729 .get_et_stats = ath10k_debug_get_et_stats,
4730 .get_et_strings = ath10k_debug_get_et_strings,
4732 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
4735 .suspend = ath10k_suspend,
4736 .resume = ath10k_resume,
4740 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4741 .bitrate = (_rate), \
4742 .flags = (_flags), \
4743 .hw_value = (_rateid), \
4746 #define CHAN2G(_channel, _freq, _flags) { \
4747 .band = IEEE80211_BAND_2GHZ, \
4748 .hw_value = (_channel), \
4749 .center_freq = (_freq), \
4750 .flags = (_flags), \
4751 .max_antenna_gain = 0, \
4755 #define CHAN5G(_channel, _freq, _flags) { \
4756 .band = IEEE80211_BAND_5GHZ, \
4757 .hw_value = (_channel), \
4758 .center_freq = (_freq), \
4759 .flags = (_flags), \
4760 .max_antenna_gain = 0, \
4764 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4774 CHAN2G(10, 2457, 0),
4775 CHAN2G(11, 2462, 0),
4776 CHAN2G(12, 2467, 0),
4777 CHAN2G(13, 2472, 0),
4778 CHAN2G(14, 2484, 0),
4781 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4782 CHAN5G(36, 5180, 0),
4783 CHAN5G(40, 5200, 0),
4784 CHAN5G(44, 5220, 0),
4785 CHAN5G(48, 5240, 0),
4786 CHAN5G(52, 5260, 0),
4787 CHAN5G(56, 5280, 0),
4788 CHAN5G(60, 5300, 0),
4789 CHAN5G(64, 5320, 0),
4790 CHAN5G(100, 5500, 0),
4791 CHAN5G(104, 5520, 0),
4792 CHAN5G(108, 5540, 0),
4793 CHAN5G(112, 5560, 0),
4794 CHAN5G(116, 5580, 0),
4795 CHAN5G(120, 5600, 0),
4796 CHAN5G(124, 5620, 0),
4797 CHAN5G(128, 5640, 0),
4798 CHAN5G(132, 5660, 0),
4799 CHAN5G(136, 5680, 0),
4800 CHAN5G(140, 5700, 0),
4801 CHAN5G(149, 5745, 0),
4802 CHAN5G(153, 5765, 0),
4803 CHAN5G(157, 5785, 0),
4804 CHAN5G(161, 5805, 0),
4805 CHAN5G(165, 5825, 0),
4808 /* Note: Be careful if you re-order these. There is code which depends on this
4811 static struct ieee80211_rate ath10k_rates[] = {
4813 RATETAB_ENT(10, 0x82, 0),
4814 RATETAB_ENT(20, 0x84, 0),
4815 RATETAB_ENT(55, 0x8b, 0),
4816 RATETAB_ENT(110, 0x96, 0),
4818 RATETAB_ENT(60, 0x0c, 0),
4819 RATETAB_ENT(90, 0x12, 0),
4820 RATETAB_ENT(120, 0x18, 0),
4821 RATETAB_ENT(180, 0x24, 0),
4822 RATETAB_ENT(240, 0x30, 0),
4823 RATETAB_ENT(360, 0x48, 0),
4824 RATETAB_ENT(480, 0x60, 0),
4825 RATETAB_ENT(540, 0x6c, 0),
4828 #define ath10k_a_rates (ath10k_rates + 4)
4829 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4830 #define ath10k_g_rates (ath10k_rates + 0)
4831 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4833 struct ath10k *ath10k_mac_create(size_t priv_size)
4835 struct ieee80211_hw *hw;
4838 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
4848 void ath10k_mac_destroy(struct ath10k *ar)
4850 ieee80211_free_hw(ar->hw);
4853 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4856 .types = BIT(NL80211_IFTYPE_STATION)
4857 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4861 .types = BIT(NL80211_IFTYPE_P2P_GO)
4865 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
4869 .types = BIT(NL80211_IFTYPE_AP)
4873 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4876 .types = BIT(NL80211_IFTYPE_AP)
4880 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4882 .limits = ath10k_if_limits,
4883 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4884 .max_interfaces = 8,
4885 .num_different_channels = 1,
4886 .beacon_int_infra_match = true,
4890 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4892 .limits = ath10k_10x_if_limits,
4893 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4894 .max_interfaces = 8,
4895 .num_different_channels = 1,
4896 .beacon_int_infra_match = true,
4897 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4898 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4899 BIT(NL80211_CHAN_WIDTH_20) |
4900 BIT(NL80211_CHAN_WIDTH_40) |
4901 BIT(NL80211_CHAN_WIDTH_80),
4906 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4908 struct ieee80211_sta_vht_cap vht_cap = {0};
4912 vht_cap.vht_supported = 1;
4913 vht_cap.cap = ar->vht_cap_info;
4916 for (i = 0; i < 8; i++) {
4917 if (i < ar->num_rf_chains)
4918 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4920 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4923 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4924 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4929 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4932 struct ieee80211_sta_ht_cap ht_cap = {0};
4934 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4937 ht_cap.ht_supported = 1;
4938 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4939 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4940 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4941 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4942 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4944 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4945 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4947 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4948 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4950 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4953 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4954 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4959 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4960 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4962 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4965 stbc = ar->ht_cap_info;
4966 stbc &= WMI_HT_CAP_RX_STBC;
4967 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4968 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4969 stbc &= IEEE80211_HT_CAP_RX_STBC;
4974 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4975 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4977 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4978 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4980 /* max AMSDU is implicitly taken from vht_cap_info */
4981 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4982 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4984 for (i = 0; i < ar->num_rf_chains; i++)
4985 ht_cap.mcs.rx_mask[i] = 0xFF;
4987 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4992 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4993 struct ieee80211_vif *vif)
4995 struct ath10k_vif_iter *arvif_iter = data;
4996 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4998 if (arvif->vdev_id == arvif_iter->vdev_id)
4999 arvif_iter->arvif = arvif;
5002 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
5004 struct ath10k_vif_iter arvif_iter;
5007 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
5008 arvif_iter.vdev_id = vdev_id;
5010 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
5011 ieee80211_iterate_active_interfaces_atomic(ar->hw,
5013 ath10k_get_arvif_iter,
5015 if (!arvif_iter.arvif) {
5016 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
5020 return arvif_iter.arvif;
5023 int ath10k_mac_register(struct ath10k *ar)
5025 struct ieee80211_supported_band *band;
5026 struct ieee80211_sta_vht_cap vht_cap;
5027 struct ieee80211_sta_ht_cap ht_cap;
5031 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
5033 SET_IEEE80211_DEV(ar->hw, ar->dev);
5035 ht_cap = ath10k_get_ht_cap(ar);
5036 vht_cap = ath10k_create_vht_cap(ar);
5038 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
5039 channels = kmemdup(ath10k_2ghz_channels,
5040 sizeof(ath10k_2ghz_channels),
5047 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
5048 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
5049 band->channels = channels;
5050 band->n_bitrates = ath10k_g_rates_size;
5051 band->bitrates = ath10k_g_rates;
5052 band->ht_cap = ht_cap;
5054 /* vht is not supported in 2.4 GHz */
5056 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
5059 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
5060 channels = kmemdup(ath10k_5ghz_channels,
5061 sizeof(ath10k_5ghz_channels),
5068 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
5069 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
5070 band->channels = channels;
5071 band->n_bitrates = ath10k_a_rates_size;
5072 band->bitrates = ath10k_a_rates;
5073 band->ht_cap = ht_cap;
5074 band->vht_cap = vht_cap;
5075 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
5078 ar->hw->wiphy->interface_modes =
5079 BIT(NL80211_IFTYPE_STATION) |
5080 BIT(NL80211_IFTYPE_AP);
5082 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
5083 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
5085 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
5086 ar->hw->wiphy->interface_modes |=
5087 BIT(NL80211_IFTYPE_P2P_DEVICE) |
5088 BIT(NL80211_IFTYPE_P2P_CLIENT) |
5089 BIT(NL80211_IFTYPE_P2P_GO);
5091 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
5092 IEEE80211_HW_SUPPORTS_PS |
5093 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
5094 IEEE80211_HW_SUPPORTS_UAPSD |
5095 IEEE80211_HW_MFP_CAPABLE |
5096 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
5097 IEEE80211_HW_HAS_RATE_CONTROL |
5098 IEEE80211_HW_AP_LINK_PS |
5099 IEEE80211_HW_SPECTRUM_MGMT;
5101 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
5103 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
5104 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
5106 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
5107 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
5108 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
5111 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
5112 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
5114 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
5115 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
5117 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
5119 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
5120 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
5121 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
5123 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
5124 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
5127 * on LL hardware queues are managed entirely by the FW
5128 * so we only advertise to mac we can do the queues thing
5132 switch (ar->wmi.op_version) {
5133 case ATH10K_FW_WMI_OP_VERSION_MAIN:
5134 case ATH10K_FW_WMI_OP_VERSION_TLV:
5135 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
5136 ar->hw->wiphy->n_iface_combinations =
5137 ARRAY_SIZE(ath10k_if_comb);
5138 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
5140 case ATH10K_FW_WMI_OP_VERSION_10_1:
5141 case ATH10K_FW_WMI_OP_VERSION_10_2:
5142 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
5143 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
5144 ar->hw->wiphy->n_iface_combinations =
5145 ARRAY_SIZE(ath10k_10x_if_comb);
5147 case ATH10K_FW_WMI_OP_VERSION_UNSET:
5148 case ATH10K_FW_WMI_OP_VERSION_MAX:
5154 ar->hw->netdev_features = NETIF_F_HW_CSUM;
5156 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
5157 /* Init ath dfs pattern detector */
5158 ar->ath_common.debug_mask = ATH_DBG_DFS;
5159 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
5162 if (!ar->dfs_detector)
5163 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
5166 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
5167 ath10k_reg_notifier);
5169 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
5173 ret = ieee80211_register_hw(ar->hw);
5175 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
5179 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
5180 ret = regulatory_hint(ar->hw->wiphy,
5181 ar->ath_common.regulatory.alpha2);
5183 goto err_unregister;
5189 ieee80211_unregister_hw(ar->hw);
5191 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5192 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5197 void ath10k_mac_unregister(struct ath10k *ar)
5199 ieee80211_unregister_hw(ar->hw);
5201 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
5202 ar->dfs_detector->exit(ar->dfs_detector);
5204 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5205 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5207 SET_IEEE80211_DEV(ar->hw, NULL);