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>
39 static struct ieee80211_rate ath10k_rates[] = {
41 .hw_value = ATH10K_HW_RATE_CCK_LP_1M },
43 .hw_value = ATH10K_HW_RATE_CCK_LP_2M,
44 .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M,
45 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
47 .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M,
48 .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M,
49 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
51 .hw_value = ATH10K_HW_RATE_CCK_LP_11M,
52 .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M,
53 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
55 { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
56 { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
57 { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
58 { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
59 { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
60 { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
61 { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
62 { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
65 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4
67 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)
68 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \
69 ATH10K_MAC_FIRST_OFDM_RATE_IDX)
70 #define ath10k_g_rates (ath10k_rates + 0)
71 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
73 static bool ath10k_mac_bitrate_is_cck(int bitrate)
86 static u8 ath10k_mac_bitrate_to_rate(int bitrate)
88 return DIV_ROUND_UP(bitrate, 5) |
89 (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
92 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
95 const struct ieee80211_rate *rate;
98 for (i = 0; i < sband->n_bitrates; i++) {
99 rate = &sband->bitrates[i];
101 if (ath10k_mac_bitrate_is_cck(rate->bitrate) != cck)
104 if (rate->hw_value == hw_rate)
106 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
107 rate->hw_value_short == hw_rate)
114 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
119 for (i = 0; i < sband->n_bitrates; i++)
120 if (sband->bitrates[i].bitrate == bitrate)
126 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
128 switch ((mcs_map >> (2 * nss)) & 0x3) {
129 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
130 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
131 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
137 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
141 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
142 if (ht_mcs_mask[nss])
149 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
153 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
154 if (vht_mcs_mask[nss])
164 static int ath10k_send_key(struct ath10k_vif *arvif,
165 struct ieee80211_key_conf *key,
166 enum set_key_cmd cmd,
167 const u8 *macaddr, u32 flags)
169 struct ath10k *ar = arvif->ar;
170 struct wmi_vdev_install_key_arg arg = {
171 .vdev_id = arvif->vdev_id,
172 .key_idx = key->keyidx,
173 .key_len = key->keylen,
174 .key_data = key->key,
179 lockdep_assert_held(&arvif->ar->conf_mutex);
181 switch (key->cipher) {
182 case WLAN_CIPHER_SUITE_CCMP:
183 arg.key_cipher = WMI_CIPHER_AES_CCM;
184 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
186 case WLAN_CIPHER_SUITE_TKIP:
187 arg.key_cipher = WMI_CIPHER_TKIP;
188 arg.key_txmic_len = 8;
189 arg.key_rxmic_len = 8;
191 case WLAN_CIPHER_SUITE_WEP40:
192 case WLAN_CIPHER_SUITE_WEP104:
193 arg.key_cipher = WMI_CIPHER_WEP;
195 case WLAN_CIPHER_SUITE_AES_CMAC:
199 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
203 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
204 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
206 if (cmd == DISABLE_KEY) {
207 arg.key_cipher = WMI_CIPHER_NONE;
211 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
214 static int ath10k_install_key(struct ath10k_vif *arvif,
215 struct ieee80211_key_conf *key,
216 enum set_key_cmd cmd,
217 const u8 *macaddr, u32 flags)
219 struct ath10k *ar = arvif->ar;
221 unsigned long time_left;
223 lockdep_assert_held(&ar->conf_mutex);
225 reinit_completion(&ar->install_key_done);
227 if (arvif->nohwcrypt)
230 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
234 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
241 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
244 struct ath10k *ar = arvif->ar;
245 struct ath10k_peer *peer;
250 lockdep_assert_held(&ar->conf_mutex);
252 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&
253 arvif->vif->type != NL80211_IFTYPE_ADHOC &&
254 arvif->vif->type != NL80211_IFTYPE_MESH_POINT))
257 spin_lock_bh(&ar->data_lock);
258 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
259 spin_unlock_bh(&ar->data_lock);
264 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
265 if (arvif->wep_keys[i] == NULL)
268 switch (arvif->vif->type) {
269 case NL80211_IFTYPE_AP:
270 flags = WMI_KEY_PAIRWISE;
272 if (arvif->def_wep_key_idx == i)
273 flags |= WMI_KEY_TX_USAGE;
275 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
276 SET_KEY, addr, flags);
280 case NL80211_IFTYPE_ADHOC:
281 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
287 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
288 SET_KEY, addr, WMI_KEY_GROUP);
297 spin_lock_bh(&ar->data_lock);
298 peer->keys[i] = arvif->wep_keys[i];
299 spin_unlock_bh(&ar->data_lock);
302 /* In some cases (notably with static WEP IBSS with multiple keys)
303 * multicast Tx becomes broken. Both pairwise and groupwise keys are
304 * installed already. Using WMI_KEY_TX_USAGE in different combinations
305 * didn't seem help. Using def_keyid vdev parameter seems to be
306 * effective so use that.
308 * FIXME: Revisit. Perhaps this can be done in a less hacky way.
310 if (arvif->vif->type != NL80211_IFTYPE_ADHOC)
313 if (arvif->def_wep_key_idx == -1)
316 ret = ath10k_wmi_vdev_set_param(arvif->ar,
318 arvif->ar->wmi.vdev_param->def_keyid,
319 arvif->def_wep_key_idx);
321 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
322 arvif->vdev_id, ret);
329 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
332 struct ath10k *ar = arvif->ar;
333 struct ath10k_peer *peer;
339 lockdep_assert_held(&ar->conf_mutex);
341 spin_lock_bh(&ar->data_lock);
342 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
343 spin_unlock_bh(&ar->data_lock);
348 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
349 if (peer->keys[i] == NULL)
352 /* key flags are not required to delete the key */
353 ret = ath10k_install_key(arvif, peer->keys[i],
354 DISABLE_KEY, addr, flags);
355 if (ret < 0 && first_errno == 0)
359 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
362 spin_lock_bh(&ar->data_lock);
363 peer->keys[i] = NULL;
364 spin_unlock_bh(&ar->data_lock);
370 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
373 struct ath10k_peer *peer;
376 lockdep_assert_held(&ar->data_lock);
378 /* We don't know which vdev this peer belongs to,
379 * since WMI doesn't give us that information.
381 * FIXME: multi-bss needs to be handled.
383 peer = ath10k_peer_find(ar, 0, addr);
387 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
388 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
395 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
396 struct ieee80211_key_conf *key)
398 struct ath10k *ar = arvif->ar;
399 struct ath10k_peer *peer;
406 lockdep_assert_held(&ar->conf_mutex);
409 /* since ath10k_install_key we can't hold data_lock all the
410 * time, so we try to remove the keys incrementally */
411 spin_lock_bh(&ar->data_lock);
413 list_for_each_entry(peer, &ar->peers, list) {
414 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
415 if (peer->keys[i] == key) {
416 ether_addr_copy(addr, peer->addr);
417 peer->keys[i] = NULL;
422 if (i < ARRAY_SIZE(peer->keys))
425 spin_unlock_bh(&ar->data_lock);
427 if (i == ARRAY_SIZE(peer->keys))
429 /* key flags are not required to delete the key */
430 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
431 if (ret < 0 && first_errno == 0)
435 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
442 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
443 struct ieee80211_key_conf *key)
445 struct ath10k *ar = arvif->ar;
446 struct ath10k_peer *peer;
449 lockdep_assert_held(&ar->conf_mutex);
451 list_for_each_entry(peer, &ar->peers, list) {
452 if (!memcmp(peer->addr, arvif->vif->addr, ETH_ALEN))
455 if (!memcmp(peer->addr, arvif->bssid, ETH_ALEN))
458 if (peer->keys[key->keyidx] == key)
461 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
462 arvif->vdev_id, key->keyidx);
464 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
466 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
467 arvif->vdev_id, peer->addr, ret);
475 /*********************/
476 /* General utilities */
477 /*********************/
479 static inline enum wmi_phy_mode
480 chan_to_phymode(const struct cfg80211_chan_def *chandef)
482 enum wmi_phy_mode phymode = MODE_UNKNOWN;
484 switch (chandef->chan->band) {
485 case IEEE80211_BAND_2GHZ:
486 switch (chandef->width) {
487 case NL80211_CHAN_WIDTH_20_NOHT:
488 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
493 case NL80211_CHAN_WIDTH_20:
494 phymode = MODE_11NG_HT20;
496 case NL80211_CHAN_WIDTH_40:
497 phymode = MODE_11NG_HT40;
499 case NL80211_CHAN_WIDTH_5:
500 case NL80211_CHAN_WIDTH_10:
501 case NL80211_CHAN_WIDTH_80:
502 case NL80211_CHAN_WIDTH_80P80:
503 case NL80211_CHAN_WIDTH_160:
504 phymode = MODE_UNKNOWN;
508 case IEEE80211_BAND_5GHZ:
509 switch (chandef->width) {
510 case NL80211_CHAN_WIDTH_20_NOHT:
513 case NL80211_CHAN_WIDTH_20:
514 phymode = MODE_11NA_HT20;
516 case NL80211_CHAN_WIDTH_40:
517 phymode = MODE_11NA_HT40;
519 case NL80211_CHAN_WIDTH_80:
520 phymode = MODE_11AC_VHT80;
522 case NL80211_CHAN_WIDTH_5:
523 case NL80211_CHAN_WIDTH_10:
524 case NL80211_CHAN_WIDTH_80P80:
525 case NL80211_CHAN_WIDTH_160:
526 phymode = MODE_UNKNOWN;
534 WARN_ON(phymode == MODE_UNKNOWN);
538 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
541 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
542 * 0 for no restriction
551 switch (mpdudensity) {
557 /* Our lower layer calculations limit our precision to
573 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
574 struct cfg80211_chan_def *def)
576 struct ieee80211_chanctx_conf *conf;
579 conf = rcu_dereference(vif->chanctx_conf);
591 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
592 struct ieee80211_chanctx_conf *conf,
600 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
604 ieee80211_iter_chan_contexts_atomic(ar->hw,
605 ath10k_mac_num_chanctxs_iter,
612 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
613 struct ieee80211_chanctx_conf *conf,
616 struct cfg80211_chan_def **def = data;
621 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
622 enum wmi_peer_type peer_type)
624 struct ath10k_vif *arvif;
628 lockdep_assert_held(&ar->conf_mutex);
630 num_peers = ar->num_peers;
632 /* Each vdev consumes a peer entry as well */
633 list_for_each_entry(arvif, &ar->arvifs, list)
636 if (num_peers >= ar->max_num_peers)
639 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
641 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
646 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
648 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
658 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
660 struct ath10k *ar = arvif->ar;
664 param = ar->wmi.pdev_param->sta_kickout_th;
665 ret = ath10k_wmi_pdev_set_param(ar, param,
666 ATH10K_KICKOUT_THRESHOLD);
668 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
669 arvif->vdev_id, ret);
673 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
674 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
675 ATH10K_KEEPALIVE_MIN_IDLE);
677 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
678 arvif->vdev_id, ret);
682 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
683 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
684 ATH10K_KEEPALIVE_MAX_IDLE);
686 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
687 arvif->vdev_id, ret);
691 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
692 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
693 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
695 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
696 arvif->vdev_id, ret);
703 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
705 struct ath10k *ar = arvif->ar;
708 vdev_param = ar->wmi.vdev_param->rts_threshold;
709 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
712 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
716 lockdep_assert_held(&ar->conf_mutex);
718 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
722 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
731 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
733 struct ath10k_peer *peer, *tmp;
735 lockdep_assert_held(&ar->conf_mutex);
737 spin_lock_bh(&ar->data_lock);
738 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
739 if (peer->vdev_id != vdev_id)
742 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
743 peer->addr, vdev_id);
745 list_del(&peer->list);
749 spin_unlock_bh(&ar->data_lock);
752 static void ath10k_peer_cleanup_all(struct ath10k *ar)
754 struct ath10k_peer *peer, *tmp;
756 lockdep_assert_held(&ar->conf_mutex);
758 spin_lock_bh(&ar->data_lock);
759 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
760 list_del(&peer->list);
763 spin_unlock_bh(&ar->data_lock);
766 ar->num_stations = 0;
769 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
770 struct ieee80211_sta *sta,
771 enum wmi_tdls_peer_state state)
774 struct wmi_tdls_peer_update_cmd_arg arg = {};
775 struct wmi_tdls_peer_capab_arg cap = {};
776 struct wmi_channel_arg chan_arg = {};
778 lockdep_assert_held(&ar->conf_mutex);
780 arg.vdev_id = vdev_id;
781 arg.peer_state = state;
782 ether_addr_copy(arg.addr, sta->addr);
784 cap.peer_max_sp = sta->max_sp;
785 cap.peer_uapsd_queues = sta->uapsd_queues;
787 if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
788 !sta->tdls_initiator)
789 cap.is_peer_responder = 1;
791 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
793 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
794 arg.addr, vdev_id, ret);
801 /************************/
802 /* Interface management */
803 /************************/
805 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
807 struct ath10k *ar = arvif->ar;
809 lockdep_assert_held(&ar->data_lock);
814 if (!arvif->beacon_buf)
815 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
816 arvif->beacon->len, DMA_TO_DEVICE);
818 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
819 arvif->beacon_state != ATH10K_BEACON_SENT))
822 dev_kfree_skb_any(arvif->beacon);
824 arvif->beacon = NULL;
825 arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
828 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
830 struct ath10k *ar = arvif->ar;
832 lockdep_assert_held(&ar->data_lock);
834 ath10k_mac_vif_beacon_free(arvif);
836 if (arvif->beacon_buf) {
837 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
838 arvif->beacon_buf, arvif->beacon_paddr);
839 arvif->beacon_buf = NULL;
843 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
845 unsigned long time_left;
847 lockdep_assert_held(&ar->conf_mutex);
849 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
852 time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
853 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
860 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
862 struct cfg80211_chan_def *chandef = NULL;
863 struct ieee80211_channel *channel = NULL;
864 struct wmi_vdev_start_request_arg arg = {};
867 lockdep_assert_held(&ar->conf_mutex);
869 ieee80211_iter_chan_contexts_atomic(ar->hw,
870 ath10k_mac_get_any_chandef_iter,
872 if (WARN_ON_ONCE(!chandef))
875 channel = chandef->chan;
877 arg.vdev_id = vdev_id;
878 arg.channel.freq = channel->center_freq;
879 arg.channel.band_center_freq1 = chandef->center_freq1;
881 /* TODO setup this dynamically, what in case we
882 don't have any vifs? */
883 arg.channel.mode = chan_to_phymode(chandef);
884 arg.channel.chan_radar =
885 !!(channel->flags & IEEE80211_CHAN_RADAR);
887 arg.channel.min_power = 0;
888 arg.channel.max_power = channel->max_power * 2;
889 arg.channel.max_reg_power = channel->max_reg_power * 2;
890 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
892 reinit_completion(&ar->vdev_setup_done);
894 ret = ath10k_wmi_vdev_start(ar, &arg);
896 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
901 ret = ath10k_vdev_setup_sync(ar);
903 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
908 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
910 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
915 ar->monitor_vdev_id = vdev_id;
917 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
918 ar->monitor_vdev_id);
922 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
924 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
925 ar->monitor_vdev_id, ret);
930 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
934 lockdep_assert_held(&ar->conf_mutex);
936 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
938 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
939 ar->monitor_vdev_id, ret);
941 reinit_completion(&ar->vdev_setup_done);
943 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
945 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
946 ar->monitor_vdev_id, ret);
948 ret = ath10k_vdev_setup_sync(ar);
950 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
951 ar->monitor_vdev_id, ret);
953 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
954 ar->monitor_vdev_id);
958 static int ath10k_monitor_vdev_create(struct ath10k *ar)
962 lockdep_assert_held(&ar->conf_mutex);
964 if (ar->free_vdev_map == 0) {
965 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
969 bit = __ffs64(ar->free_vdev_map);
971 ar->monitor_vdev_id = bit;
973 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
974 WMI_VDEV_TYPE_MONITOR,
977 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
978 ar->monitor_vdev_id, ret);
982 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
983 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
984 ar->monitor_vdev_id);
989 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
993 lockdep_assert_held(&ar->conf_mutex);
995 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
997 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
998 ar->monitor_vdev_id, ret);
1002 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
1004 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
1005 ar->monitor_vdev_id);
1009 static int ath10k_monitor_start(struct ath10k *ar)
1013 lockdep_assert_held(&ar->conf_mutex);
1015 ret = ath10k_monitor_vdev_create(ar);
1017 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1021 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
1023 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1024 ath10k_monitor_vdev_delete(ar);
1028 ar->monitor_started = true;
1029 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1034 static int ath10k_monitor_stop(struct ath10k *ar)
1038 lockdep_assert_held(&ar->conf_mutex);
1040 ret = ath10k_monitor_vdev_stop(ar);
1042 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1046 ret = ath10k_monitor_vdev_delete(ar);
1048 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1052 ar->monitor_started = false;
1053 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1058 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1062 /* At least one chanctx is required to derive a channel to start
1065 num_ctx = ath10k_mac_num_chanctxs(ar);
1069 /* If there's already an existing special monitor interface then don't
1070 * bother creating another monitor vdev.
1072 if (ar->monitor_arvif)
1075 return ar->monitor ||
1076 ar->filter_flags & FIF_OTHER_BSS ||
1077 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1080 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)
1084 num_ctx = ath10k_mac_num_chanctxs(ar);
1086 /* FIXME: Current interface combinations and cfg80211/mac80211 code
1087 * shouldn't allow this but make sure to prevent handling the following
1088 * case anyway since multi-channel DFS hasn't been tested at all.
1090 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)
1096 static int ath10k_monitor_recalc(struct ath10k *ar)
1102 lockdep_assert_held(&ar->conf_mutex);
1104 needed = ath10k_mac_monitor_vdev_is_needed(ar);
1105 allowed = ath10k_mac_monitor_vdev_is_allowed(ar);
1107 ath10k_dbg(ar, ATH10K_DBG_MAC,
1108 "mac monitor recalc started? %d needed? %d allowed? %d\n",
1109 ar->monitor_started, needed, allowed);
1111 if (WARN_ON(needed && !allowed)) {
1112 if (ar->monitor_started) {
1113 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");
1115 ret = ath10k_monitor_stop(ar);
1117 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n",
1125 if (needed == ar->monitor_started)
1129 return ath10k_monitor_start(ar);
1131 return ath10k_monitor_stop(ar);
1134 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
1136 struct ath10k *ar = arvif->ar;
1137 u32 vdev_param, rts_cts = 0;
1139 lockdep_assert_held(&ar->conf_mutex);
1141 vdev_param = ar->wmi.vdev_param->enable_rtscts;
1143 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
1145 if (arvif->num_legacy_stations > 0)
1146 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
1147 WMI_RTSCTS_PROFILE);
1149 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,
1150 WMI_RTSCTS_PROFILE);
1152 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1156 static int ath10k_start_cac(struct ath10k *ar)
1160 lockdep_assert_held(&ar->conf_mutex);
1162 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1164 ret = ath10k_monitor_recalc(ar);
1166 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
1167 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1171 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
1172 ar->monitor_vdev_id);
1177 static int ath10k_stop_cac(struct ath10k *ar)
1179 lockdep_assert_held(&ar->conf_mutex);
1181 /* CAC is not running - do nothing */
1182 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
1185 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1186 ath10k_monitor_stop(ar);
1188 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
1193 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,
1194 struct ieee80211_chanctx_conf *conf,
1199 if (!*ret && conf->radar_enabled)
1203 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)
1205 bool has_radar = false;
1207 ieee80211_iter_chan_contexts_atomic(ar->hw,
1208 ath10k_mac_has_radar_iter,
1214 static void ath10k_recalc_radar_detection(struct ath10k *ar)
1218 lockdep_assert_held(&ar->conf_mutex);
1220 ath10k_stop_cac(ar);
1222 if (!ath10k_mac_has_radar_enabled(ar))
1225 if (ar->num_started_vdevs > 0)
1228 ret = ath10k_start_cac(ar);
1231 * Not possible to start CAC on current channel so starting
1232 * radiation is not allowed, make this channel DFS_UNAVAILABLE
1233 * by indicating that radar was detected.
1235 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
1236 ieee80211_radar_detected(ar->hw);
1240 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
1242 struct ath10k *ar = arvif->ar;
1245 lockdep_assert_held(&ar->conf_mutex);
1247 reinit_completion(&ar->vdev_setup_done);
1249 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
1251 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
1252 arvif->vdev_id, ret);
1256 ret = ath10k_vdev_setup_sync(ar);
1258 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
1259 arvif->vdev_id, ret);
1263 WARN_ON(ar->num_started_vdevs == 0);
1265 if (ar->num_started_vdevs != 0) {
1266 ar->num_started_vdevs--;
1267 ath10k_recalc_radar_detection(ar);
1273 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,
1274 const struct cfg80211_chan_def *chandef,
1277 struct ath10k *ar = arvif->ar;
1278 struct wmi_vdev_start_request_arg arg = {};
1281 lockdep_assert_held(&ar->conf_mutex);
1283 reinit_completion(&ar->vdev_setup_done);
1285 arg.vdev_id = arvif->vdev_id;
1286 arg.dtim_period = arvif->dtim_period;
1287 arg.bcn_intval = arvif->beacon_interval;
1289 arg.channel.freq = chandef->chan->center_freq;
1290 arg.channel.band_center_freq1 = chandef->center_freq1;
1291 arg.channel.mode = chan_to_phymode(chandef);
1293 arg.channel.min_power = 0;
1294 arg.channel.max_power = chandef->chan->max_power * 2;
1295 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
1296 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
1298 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1299 arg.ssid = arvif->u.ap.ssid;
1300 arg.ssid_len = arvif->u.ap.ssid_len;
1301 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
1303 /* For now allow DFS for AP mode */
1304 arg.channel.chan_radar =
1305 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
1306 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
1307 arg.ssid = arvif->vif->bss_conf.ssid;
1308 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
1311 ath10k_dbg(ar, ATH10K_DBG_MAC,
1312 "mac vdev %d start center_freq %d phymode %s\n",
1313 arg.vdev_id, arg.channel.freq,
1314 ath10k_wmi_phymode_str(arg.channel.mode));
1317 ret = ath10k_wmi_vdev_restart(ar, &arg);
1319 ret = ath10k_wmi_vdev_start(ar, &arg);
1322 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
1327 ret = ath10k_vdev_setup_sync(ar);
1330 "failed to synchronize setup for vdev %i restart %d: %d\n",
1331 arg.vdev_id, restart, ret);
1335 ar->num_started_vdevs++;
1336 ath10k_recalc_radar_detection(ar);
1341 static int ath10k_vdev_start(struct ath10k_vif *arvif,
1342 const struct cfg80211_chan_def *def)
1344 return ath10k_vdev_start_restart(arvif, def, false);
1347 static int ath10k_vdev_restart(struct ath10k_vif *arvif,
1348 const struct cfg80211_chan_def *def)
1350 return ath10k_vdev_start_restart(arvif, def, true);
1353 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
1354 struct sk_buff *bcn)
1356 struct ath10k *ar = arvif->ar;
1357 struct ieee80211_mgmt *mgmt;
1361 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1364 if (arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1367 mgmt = (void *)bcn->data;
1368 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1369 mgmt->u.beacon.variable,
1370 bcn->len - (mgmt->u.beacon.variable -
1375 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1377 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1378 arvif->vdev_id, ret);
1385 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1386 u8 oui_type, size_t ie_offset)
1393 if (WARN_ON(skb->len < ie_offset))
1396 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1397 skb->data + ie_offset,
1398 skb->len - ie_offset);
1403 end = skb->data + skb->len;
1406 if (WARN_ON(next > end))
1409 memmove(ie, next, end - next);
1410 skb_trim(skb, skb->len - len);
1415 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1417 struct ath10k *ar = arvif->ar;
1418 struct ieee80211_hw *hw = ar->hw;
1419 struct ieee80211_vif *vif = arvif->vif;
1420 struct ieee80211_mutable_offsets offs = {};
1421 struct sk_buff *bcn;
1424 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1427 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
1428 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
1431 bcn = ieee80211_beacon_get_template(hw, vif, &offs);
1433 ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1437 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1439 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1444 /* P2P IE is inserted by firmware automatically (as configured above)
1445 * so remove it from the base beacon template to avoid duplicate P2P
1446 * IEs in beacon frames.
1448 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1449 offsetof(struct ieee80211_mgmt,
1450 u.beacon.variable));
1452 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1457 ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1465 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1467 struct ath10k *ar = arvif->ar;
1468 struct ieee80211_hw *hw = ar->hw;
1469 struct ieee80211_vif *vif = arvif->vif;
1470 struct sk_buff *prb;
1473 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1476 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1479 prb = ieee80211_proberesp_get(hw, vif);
1481 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1485 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1489 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1497 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)
1499 struct ath10k *ar = arvif->ar;
1500 struct cfg80211_chan_def def;
1503 /* When originally vdev is started during assign_vif_chanctx() some
1504 * information is missing, notably SSID. Firmware revisions with beacon
1505 * offloading require the SSID to be provided during vdev (re)start to
1506 * handle hidden SSID properly.
1508 * Vdev restart must be done after vdev has been both started and
1509 * upped. Otherwise some firmware revisions (at least 10.2) fail to
1510 * deliver vdev restart response event causing timeouts during vdev
1511 * syncing in ath10k.
1513 * Note: The vdev down/up and template reinstallation could be skipped
1514 * since only wmi-tlv firmware are known to have beacon offload and
1515 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1516 * response delivery. It's probably more robust to keep it as is.
1518 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1521 if (WARN_ON(!arvif->is_started))
1524 if (WARN_ON(!arvif->is_up))
1527 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
1530 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1532 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",
1533 arvif->vdev_id, ret);
1537 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1538 * firmware will crash upon vdev up.
1541 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1543 ath10k_warn(ar, "failed to update beacon template: %d\n", ret);
1547 ret = ath10k_mac_setup_prb_tmpl(arvif);
1549 ath10k_warn(ar, "failed to update presp template: %d\n", ret);
1553 ret = ath10k_vdev_restart(arvif, &def);
1555 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",
1556 arvif->vdev_id, ret);
1560 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1563 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",
1564 arvif->vdev_id, ret);
1571 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1572 struct ieee80211_bss_conf *info)
1574 struct ath10k *ar = arvif->ar;
1577 lockdep_assert_held(&arvif->ar->conf_mutex);
1579 if (!info->enable_beacon) {
1580 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1582 ath10k_warn(ar, "failed to down vdev_id %i: %d\n",
1583 arvif->vdev_id, ret);
1585 arvif->is_up = false;
1587 spin_lock_bh(&arvif->ar->data_lock);
1588 ath10k_mac_vif_beacon_free(arvif);
1589 spin_unlock_bh(&arvif->ar->data_lock);
1594 arvif->tx_seq_no = 0x1000;
1597 ether_addr_copy(arvif->bssid, info->bssid);
1599 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1602 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1603 arvif->vdev_id, ret);
1607 arvif->is_up = true;
1609 ret = ath10k_mac_vif_fix_hidden_ssid(arvif);
1611 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1612 arvif->vdev_id, ret);
1616 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1619 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1620 struct ieee80211_bss_conf *info,
1621 const u8 self_peer[ETH_ALEN])
1623 struct ath10k *ar = arvif->ar;
1627 lockdep_assert_held(&arvif->ar->conf_mutex);
1629 if (!info->ibss_joined) {
1630 if (is_zero_ether_addr(arvif->bssid))
1633 eth_zero_addr(arvif->bssid);
1638 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1639 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1640 ATH10K_DEFAULT_ATIM);
1642 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1643 arvif->vdev_id, ret);
1646 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1648 struct ath10k *ar = arvif->ar;
1653 lockdep_assert_held(&arvif->ar->conf_mutex);
1655 if (arvif->u.sta.uapsd)
1656 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1658 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1660 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1661 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1663 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1664 value, arvif->vdev_id, ret);
1671 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1673 struct ath10k *ar = arvif->ar;
1678 lockdep_assert_held(&arvif->ar->conf_mutex);
1680 if (arvif->u.sta.uapsd)
1681 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1683 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1685 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1686 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1689 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1690 value, arvif->vdev_id, ret);
1697 static int ath10k_mac_num_vifs_started(struct ath10k *ar)
1699 struct ath10k_vif *arvif;
1702 lockdep_assert_held(&ar->conf_mutex);
1704 list_for_each_entry(arvif, &ar->arvifs, list)
1705 if (arvif->is_started)
1711 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1713 struct ath10k *ar = arvif->ar;
1714 struct ieee80211_vif *vif = arvif->vif;
1715 struct ieee80211_conf *conf = &ar->hw->conf;
1716 enum wmi_sta_powersave_param param;
1717 enum wmi_sta_ps_mode psmode;
1722 lockdep_assert_held(&arvif->ar->conf_mutex);
1724 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1727 enable_ps = arvif->ps;
1729 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&
1730 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,
1732 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",
1737 if (!arvif->is_started) {
1738 /* mac80211 can update vif powersave state while disconnected.
1739 * Firmware doesn't behave nicely and consumes more power than
1740 * necessary if PS is disabled on a non-started vdev. Hence
1741 * force-enable PS for non-running vdevs.
1743 psmode = WMI_STA_PS_MODE_ENABLED;
1744 } else if (enable_ps) {
1745 psmode = WMI_STA_PS_MODE_ENABLED;
1746 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1748 ps_timeout = conf->dynamic_ps_timeout;
1749 if (ps_timeout == 0) {
1750 /* Firmware doesn't like 0 */
1751 ps_timeout = ieee80211_tu_to_usec(
1752 vif->bss_conf.beacon_int) / 1000;
1755 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1758 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1759 arvif->vdev_id, ret);
1763 psmode = WMI_STA_PS_MODE_DISABLED;
1766 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1767 arvif->vdev_id, psmode ? "enable" : "disable");
1769 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1771 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1772 psmode, arvif->vdev_id, ret);
1779 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1781 struct ath10k *ar = arvif->ar;
1782 struct wmi_sta_keepalive_arg arg = {};
1785 lockdep_assert_held(&arvif->ar->conf_mutex);
1787 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1790 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1793 /* Some firmware revisions have a bug and ignore the `enabled` field.
1794 * Instead use the interval to disable the keepalive.
1796 arg.vdev_id = arvif->vdev_id;
1798 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
1799 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
1801 ret = ath10k_wmi_sta_keepalive(ar, &arg);
1803 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
1804 arvif->vdev_id, ret);
1811 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)
1813 struct ath10k *ar = arvif->ar;
1814 struct ieee80211_vif *vif = arvif->vif;
1817 lockdep_assert_held(&arvif->ar->conf_mutex);
1819 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))
1822 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1825 if (!vif->csa_active)
1831 if (!ieee80211_csa_is_complete(vif)) {
1832 ieee80211_csa_update_counter(vif);
1834 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1836 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
1839 ret = ath10k_mac_setup_prb_tmpl(arvif);
1841 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
1844 ieee80211_csa_finish(vif);
1848 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)
1850 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1852 struct ath10k *ar = arvif->ar;
1854 mutex_lock(&ar->conf_mutex);
1855 ath10k_mac_vif_ap_csa_count_down(arvif);
1856 mutex_unlock(&ar->conf_mutex);
1859 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,
1860 struct ieee80211_vif *vif)
1862 struct sk_buff *skb = data;
1863 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1864 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1866 if (vif->type != NL80211_IFTYPE_STATION)
1869 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1872 cancel_delayed_work(&arvif->connection_loss_work);
1875 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)
1877 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1878 IEEE80211_IFACE_ITER_NORMAL,
1879 ath10k_mac_handle_beacon_iter,
1883 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1884 struct ieee80211_vif *vif)
1886 u32 *vdev_id = data;
1887 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1888 struct ath10k *ar = arvif->ar;
1889 struct ieee80211_hw *hw = ar->hw;
1891 if (arvif->vdev_id != *vdev_id)
1897 ieee80211_beacon_loss(vif);
1899 /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1900 * (done by mac80211) succeeds but beacons do not resume then it
1901 * doesn't make sense to continue operation. Queue connection loss work
1902 * which can be cancelled when beacon is received.
1904 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1905 ATH10K_CONNECTION_LOSS_HZ);
1908 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)
1910 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1911 IEEE80211_IFACE_ITER_NORMAL,
1912 ath10k_mac_handle_beacon_miss_iter,
1916 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1918 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1919 connection_loss_work.work);
1920 struct ieee80211_vif *vif = arvif->vif;
1925 ieee80211_connection_loss(vif);
1928 /**********************/
1929 /* Station management */
1930 /**********************/
1932 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1933 struct ieee80211_vif *vif)
1935 /* Some firmware revisions have unstable STA powersave when listen
1936 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1937 * generate NullFunc frames properly even if buffered frames have been
1938 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1939 * buffered frames. Often pinging the device from AP would simply fail.
1941 * As a workaround set it to 1.
1943 if (vif->type == NL80211_IFTYPE_STATION)
1946 return ar->hw->conf.listen_interval;
1949 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1950 struct ieee80211_vif *vif,
1951 struct ieee80211_sta *sta,
1952 struct wmi_peer_assoc_complete_arg *arg)
1954 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1957 lockdep_assert_held(&ar->conf_mutex);
1959 if (vif->type == NL80211_IFTYPE_STATION)
1960 aid = vif->bss_conf.aid;
1964 ether_addr_copy(arg->addr, sta->addr);
1965 arg->vdev_id = arvif->vdev_id;
1966 arg->peer_aid = aid;
1967 arg->peer_flags |= arvif->ar->wmi.peer_flags->auth;
1968 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1969 arg->peer_num_spatial_streams = 1;
1970 arg->peer_caps = vif->bss_conf.assoc_capability;
1973 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1974 struct ieee80211_vif *vif,
1975 struct ieee80211_sta *sta,
1976 struct wmi_peer_assoc_complete_arg *arg)
1978 struct ieee80211_bss_conf *info = &vif->bss_conf;
1979 struct cfg80211_chan_def def;
1980 struct cfg80211_bss *bss;
1981 const u8 *rsnie = NULL;
1982 const u8 *wpaie = NULL;
1984 lockdep_assert_held(&ar->conf_mutex);
1986 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
1989 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1990 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1992 const struct cfg80211_bss_ies *ies;
1995 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1997 ies = rcu_dereference(bss->ies);
1999 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
2000 WLAN_OUI_TYPE_MICROSOFT_WPA,
2004 cfg80211_put_bss(ar->hw->wiphy, bss);
2007 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
2008 if (rsnie || wpaie) {
2009 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
2010 arg->peer_flags |= ar->wmi.peer_flags->need_ptk_4_way;
2014 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
2015 arg->peer_flags |= ar->wmi.peer_flags->need_gtk_2_way;
2019 test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT, ar->fw_features)) {
2020 arg->peer_flags |= ar->wmi.peer_flags->pmf;
2024 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
2025 struct ieee80211_vif *vif,
2026 struct ieee80211_sta *sta,
2027 struct wmi_peer_assoc_complete_arg *arg)
2029 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2030 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
2031 struct cfg80211_chan_def def;
2032 const struct ieee80211_supported_band *sband;
2033 const struct ieee80211_rate *rates;
2034 enum ieee80211_band band;
2039 lockdep_assert_held(&ar->conf_mutex);
2041 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2044 band = def.chan->band;
2045 sband = ar->hw->wiphy->bands[band];
2046 ratemask = sta->supp_rates[band];
2047 ratemask &= arvif->bitrate_mask.control[band].legacy;
2048 rates = sband->bitrates;
2050 rateset->num_rates = 0;
2052 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
2053 if (!(ratemask & 1))
2056 rate = ath10k_mac_bitrate_to_rate(rates->bitrate);
2057 rateset->rates[rateset->num_rates] = rate;
2058 rateset->num_rates++;
2063 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
2067 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
2068 if (ht_mcs_mask[nss])
2075 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
2079 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
2080 if (vht_mcs_mask[nss])
2086 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
2087 struct ieee80211_vif *vif,
2088 struct ieee80211_sta *sta,
2089 struct wmi_peer_assoc_complete_arg *arg)
2091 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2092 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2093 struct cfg80211_chan_def def;
2094 enum ieee80211_band band;
2095 const u8 *ht_mcs_mask;
2096 const u16 *vht_mcs_mask;
2101 lockdep_assert_held(&ar->conf_mutex);
2103 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2106 if (!ht_cap->ht_supported)
2109 band = def.chan->band;
2110 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2111 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2113 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&
2114 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2117 arg->peer_flags |= ar->wmi.peer_flags->ht;
2118 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2119 ht_cap->ampdu_factor)) - 1;
2121 arg->peer_mpdu_density =
2122 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
2124 arg->peer_ht_caps = ht_cap->cap;
2125 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
2127 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
2128 arg->peer_flags |= ar->wmi.peer_flags->ldbc;
2130 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
2131 arg->peer_flags |= ar->wmi.peer_flags->bw40;
2132 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
2135 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
2136 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
2137 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2139 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
2140 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2143 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
2144 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
2145 arg->peer_flags |= ar->wmi.peer_flags->stbc;
2148 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
2149 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
2150 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
2151 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
2152 arg->peer_rate_caps |= stbc;
2153 arg->peer_flags |= ar->wmi.peer_flags->stbc;
2156 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
2157 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
2158 else if (ht_cap->mcs.rx_mask[1])
2159 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
2161 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
2162 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
2163 (ht_mcs_mask[i / 8] & BIT(i % 8))) {
2164 max_nss = (i / 8) + 1;
2165 arg->peer_ht_rates.rates[n++] = i;
2169 * This is a workaround for HT-enabled STAs which break the spec
2170 * and have no HT capabilities RX mask (no HT RX MCS map).
2172 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2173 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2175 * Firmware asserts if such situation occurs.
2178 arg->peer_ht_rates.num_rates = 8;
2179 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
2180 arg->peer_ht_rates.rates[i] = i;
2182 arg->peer_ht_rates.num_rates = n;
2183 arg->peer_num_spatial_streams = min(sta->rx_nss, max_nss);
2186 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
2188 arg->peer_ht_rates.num_rates,
2189 arg->peer_num_spatial_streams);
2192 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
2193 struct ath10k_vif *arvif,
2194 struct ieee80211_sta *sta)
2200 lockdep_assert_held(&ar->conf_mutex);
2202 if (sta->wme && sta->uapsd_queues) {
2203 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2204 sta->uapsd_queues, sta->max_sp);
2206 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2207 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2208 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2209 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2210 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2211 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2212 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2213 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2214 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2215 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2216 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2217 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2219 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2220 max_sp = sta->max_sp;
2222 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2224 WMI_AP_PS_PEER_PARAM_UAPSD,
2227 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2228 arvif->vdev_id, ret);
2232 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2234 WMI_AP_PS_PEER_PARAM_MAX_SP,
2237 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2238 arvif->vdev_id, ret);
2242 /* TODO setup this based on STA listen interval and
2243 beacon interval. Currently we don't know
2244 sta->listen_interval - mac80211 patch required.
2245 Currently use 10 seconds */
2246 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
2247 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
2250 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2251 arvif->vdev_id, ret);
2260 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
2261 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
2268 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
2269 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
2273 idx_limit = fls(mcs_map) - 1;
2277 switch (idx_limit) {
2278 case 0: /* fall through */
2279 case 1: /* fall through */
2280 case 2: /* fall through */
2281 case 3: /* fall through */
2282 case 4: /* fall through */
2283 case 5: /* fall through */
2284 case 6: /* fall through */
2286 /* see ath10k_mac_can_set_bitrate_mask() */
2290 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2293 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2296 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2299 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2303 tx_mcs_set &= ~(0x3 << (nss * 2));
2304 tx_mcs_set |= mcs << (nss * 2);
2310 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
2311 struct ieee80211_vif *vif,
2312 struct ieee80211_sta *sta,
2313 struct wmi_peer_assoc_complete_arg *arg)
2315 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
2316 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2317 struct cfg80211_chan_def def;
2318 enum ieee80211_band band;
2319 const u16 *vht_mcs_mask;
2322 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2325 if (!vht_cap->vht_supported)
2328 band = def.chan->band;
2329 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2331 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2334 arg->peer_flags |= ar->wmi.peer_flags->vht;
2336 if (def.chan->band == IEEE80211_BAND_2GHZ)
2337 arg->peer_flags |= ar->wmi.peer_flags->vht_2g;
2339 arg->peer_vht_caps = vht_cap->cap;
2341 ampdu_factor = (vht_cap->cap &
2342 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2343 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2345 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2346 * zero in VHT IE. Using it would result in degraded throughput.
2347 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2348 * it if VHT max_mpdu is smaller. */
2349 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2350 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2351 ampdu_factor)) - 1);
2353 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2354 arg->peer_flags |= ar->wmi.peer_flags->bw80;
2356 arg->peer_vht_rates.rx_max_rate =
2357 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2358 arg->peer_vht_rates.rx_mcs_set =
2359 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2360 arg->peer_vht_rates.tx_max_rate =
2361 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2362 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(
2363 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2365 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
2366 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
2369 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
2370 struct ieee80211_vif *vif,
2371 struct ieee80211_sta *sta,
2372 struct wmi_peer_assoc_complete_arg *arg)
2374 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2376 switch (arvif->vdev_type) {
2377 case WMI_VDEV_TYPE_AP:
2379 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2381 if (sta->wme && sta->uapsd_queues) {
2382 arg->peer_flags |= arvif->ar->wmi.peer_flags->apsd;
2383 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
2386 case WMI_VDEV_TYPE_STA:
2387 if (vif->bss_conf.qos)
2388 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2390 case WMI_VDEV_TYPE_IBSS:
2392 arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2398 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
2399 sta->addr, !!(arg->peer_flags &
2400 arvif->ar->wmi.peer_flags->qos));
2403 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2405 return sta->supp_rates[IEEE80211_BAND_2GHZ] >>
2406 ATH10K_MAC_FIRST_OFDM_RATE_IDX;
2409 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
2410 struct ieee80211_vif *vif,
2411 struct ieee80211_sta *sta,
2412 struct wmi_peer_assoc_complete_arg *arg)
2414 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2415 struct cfg80211_chan_def def;
2416 enum ieee80211_band band;
2417 const u8 *ht_mcs_mask;
2418 const u16 *vht_mcs_mask;
2419 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2421 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2424 band = def.chan->band;
2425 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2426 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2429 case IEEE80211_BAND_2GHZ:
2430 if (sta->vht_cap.vht_supported &&
2431 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2432 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2433 phymode = MODE_11AC_VHT40;
2435 phymode = MODE_11AC_VHT20;
2436 } else if (sta->ht_cap.ht_supported &&
2437 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2438 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2439 phymode = MODE_11NG_HT40;
2441 phymode = MODE_11NG_HT20;
2442 } else if (ath10k_mac_sta_has_ofdm_only(sta)) {
2449 case IEEE80211_BAND_5GHZ:
2453 if (sta->vht_cap.vht_supported &&
2454 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2455 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2456 phymode = MODE_11AC_VHT80;
2457 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2458 phymode = MODE_11AC_VHT40;
2459 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
2460 phymode = MODE_11AC_VHT20;
2461 } else if (sta->ht_cap.ht_supported &&
2462 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2463 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40)
2464 phymode = MODE_11NA_HT40;
2466 phymode = MODE_11NA_HT20;
2476 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
2477 sta->addr, ath10k_wmi_phymode_str(phymode));
2479 arg->peer_phymode = phymode;
2480 WARN_ON(phymode == MODE_UNKNOWN);
2483 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
2484 struct ieee80211_vif *vif,
2485 struct ieee80211_sta *sta,
2486 struct wmi_peer_assoc_complete_arg *arg)
2488 lockdep_assert_held(&ar->conf_mutex);
2490 memset(arg, 0, sizeof(*arg));
2492 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
2493 ath10k_peer_assoc_h_crypto(ar, vif, sta, arg);
2494 ath10k_peer_assoc_h_rates(ar, vif, sta, arg);
2495 ath10k_peer_assoc_h_ht(ar, vif, sta, arg);
2496 ath10k_peer_assoc_h_vht(ar, vif, sta, arg);
2497 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
2498 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
2503 static const u32 ath10k_smps_map[] = {
2504 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
2505 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
2506 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
2507 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
2510 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
2512 const struct ieee80211_sta_ht_cap *ht_cap)
2516 if (!ht_cap->ht_supported)
2519 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2520 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2522 if (smps >= ARRAY_SIZE(ath10k_smps_map))
2525 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
2526 WMI_PEER_SMPS_STATE,
2527 ath10k_smps_map[smps]);
2530 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,
2531 struct ieee80211_vif *vif,
2532 struct ieee80211_sta_vht_cap vht_cap)
2534 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2539 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC)
2542 if (!(ar->vht_cap_info &
2543 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2544 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
2545 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2546 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))
2549 param = ar->wmi.vdev_param->txbf;
2552 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))
2555 /* The following logic is correct. If a remote STA advertises support
2556 * for being a beamformer then we should enable us being a beamformee.
2559 if (ar->vht_cap_info &
2560 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2561 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
2562 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
2563 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2565 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
2566 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
2569 if (ar->vht_cap_info &
2570 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2571 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
2572 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
2573 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2575 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
2576 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
2579 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)
2580 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2582 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)
2583 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2585 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);
2587 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",
2595 /* can be called only in mac80211 callbacks due to `key_count` usage */
2596 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
2597 struct ieee80211_vif *vif,
2598 struct ieee80211_bss_conf *bss_conf)
2600 struct ath10k *ar = hw->priv;
2601 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2602 struct ieee80211_sta_ht_cap ht_cap;
2603 struct ieee80211_sta_vht_cap vht_cap;
2604 struct wmi_peer_assoc_complete_arg peer_arg;
2605 struct ieee80211_sta *ap_sta;
2608 lockdep_assert_held(&ar->conf_mutex);
2610 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2611 arvif->vdev_id, arvif->bssid, arvif->aid);
2615 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2617 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
2618 bss_conf->bssid, arvif->vdev_id);
2623 /* ap_sta must be accessed only within rcu section which must be left
2624 * before calling ath10k_setup_peer_smps() which might sleep. */
2625 ht_cap = ap_sta->ht_cap;
2626 vht_cap = ap_sta->vht_cap;
2628 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
2630 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
2631 bss_conf->bssid, arvif->vdev_id, ret);
2638 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2640 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
2641 bss_conf->bssid, arvif->vdev_id, ret);
2645 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
2647 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
2648 arvif->vdev_id, ret);
2652 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2654 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
2655 arvif->vdev_id, bss_conf->bssid, ret);
2659 ath10k_dbg(ar, ATH10K_DBG_MAC,
2660 "mac vdev %d up (associated) bssid %pM aid %d\n",
2661 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
2663 WARN_ON(arvif->is_up);
2665 arvif->aid = bss_conf->aid;
2666 ether_addr_copy(arvif->bssid, bss_conf->bssid);
2668 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2670 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
2671 arvif->vdev_id, ret);
2675 arvif->is_up = true;
2677 /* Workaround: Some firmware revisions (tested with qca6174
2678 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
2679 * poked with peer param command.
2681 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
2682 WMI_PEER_DUMMY_VAR, 1);
2684 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
2685 arvif->bssid, arvif->vdev_id, ret);
2690 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
2691 struct ieee80211_vif *vif)
2693 struct ath10k *ar = hw->priv;
2694 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2695 struct ieee80211_sta_vht_cap vht_cap = {};
2698 lockdep_assert_held(&ar->conf_mutex);
2700 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2701 arvif->vdev_id, arvif->bssid);
2703 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2705 ath10k_warn(ar, "faield to down vdev %i: %d\n",
2706 arvif->vdev_id, ret);
2708 arvif->def_wep_key_idx = -1;
2710 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2712 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",
2713 arvif->vdev_id, ret);
2717 arvif->is_up = false;
2719 cancel_delayed_work_sync(&arvif->connection_loss_work);
2722 static int ath10k_station_assoc(struct ath10k *ar,
2723 struct ieee80211_vif *vif,
2724 struct ieee80211_sta *sta,
2727 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2728 struct wmi_peer_assoc_complete_arg peer_arg;
2731 lockdep_assert_held(&ar->conf_mutex);
2733 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
2735 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
2736 sta->addr, arvif->vdev_id, ret);
2740 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2742 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
2743 sta->addr, arvif->vdev_id, ret);
2747 /* Re-assoc is run only to update supported rates for given station. It
2748 * doesn't make much sense to reconfigure the peer completely.
2751 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
2754 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
2755 arvif->vdev_id, ret);
2759 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
2761 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
2762 sta->addr, arvif->vdev_id, ret);
2767 arvif->num_legacy_stations++;
2768 ret = ath10k_recalc_rtscts_prot(arvif);
2770 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2771 arvif->vdev_id, ret);
2776 /* Plumb cached keys only for static WEP */
2777 if (arvif->def_wep_key_idx != -1) {
2778 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
2780 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
2781 arvif->vdev_id, ret);
2790 static int ath10k_station_disassoc(struct ath10k *ar,
2791 struct ieee80211_vif *vif,
2792 struct ieee80211_sta *sta)
2794 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2797 lockdep_assert_held(&ar->conf_mutex);
2800 arvif->num_legacy_stations--;
2801 ret = ath10k_recalc_rtscts_prot(arvif);
2803 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2804 arvif->vdev_id, ret);
2809 ret = ath10k_clear_peer_keys(arvif, sta->addr);
2811 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
2812 arvif->vdev_id, ret);
2823 static int ath10k_update_channel_list(struct ath10k *ar)
2825 struct ieee80211_hw *hw = ar->hw;
2826 struct ieee80211_supported_band **bands;
2827 enum ieee80211_band band;
2828 struct ieee80211_channel *channel;
2829 struct wmi_scan_chan_list_arg arg = {0};
2830 struct wmi_channel_arg *ch;
2836 lockdep_assert_held(&ar->conf_mutex);
2838 bands = hw->wiphy->bands;
2839 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2843 for (i = 0; i < bands[band]->n_channels; i++) {
2844 if (bands[band]->channels[i].flags &
2845 IEEE80211_CHAN_DISABLED)
2852 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
2853 arg.channels = kzalloc(len, GFP_KERNEL);
2858 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2862 for (i = 0; i < bands[band]->n_channels; i++) {
2863 channel = &bands[band]->channels[i];
2865 if (channel->flags & IEEE80211_CHAN_DISABLED)
2868 ch->allow_ht = true;
2870 /* FIXME: when should we really allow VHT? */
2871 ch->allow_vht = true;
2874 !(channel->flags & IEEE80211_CHAN_NO_IR);
2877 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
2880 !!(channel->flags & IEEE80211_CHAN_RADAR);
2882 passive = channel->flags & IEEE80211_CHAN_NO_IR;
2883 ch->passive = passive;
2885 ch->freq = channel->center_freq;
2886 ch->band_center_freq1 = channel->center_freq;
2888 ch->max_power = channel->max_power * 2;
2889 ch->max_reg_power = channel->max_reg_power * 2;
2890 ch->max_antenna_gain = channel->max_antenna_gain * 2;
2891 ch->reg_class_id = 0; /* FIXME */
2893 /* FIXME: why use only legacy modes, why not any
2894 * HT/VHT modes? Would that even make any
2896 if (channel->band == IEEE80211_BAND_2GHZ)
2897 ch->mode = MODE_11G;
2899 ch->mode = MODE_11A;
2901 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
2904 ath10k_dbg(ar, ATH10K_DBG_WMI,
2905 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
2906 ch - arg.channels, arg.n_channels,
2907 ch->freq, ch->max_power, ch->max_reg_power,
2908 ch->max_antenna_gain, ch->mode);
2914 ret = ath10k_wmi_scan_chan_list(ar, &arg);
2915 kfree(arg.channels);
2920 static enum wmi_dfs_region
2921 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
2923 switch (dfs_region) {
2924 case NL80211_DFS_UNSET:
2925 return WMI_UNINIT_DFS_DOMAIN;
2926 case NL80211_DFS_FCC:
2927 return WMI_FCC_DFS_DOMAIN;
2928 case NL80211_DFS_ETSI:
2929 return WMI_ETSI_DFS_DOMAIN;
2930 case NL80211_DFS_JP:
2931 return WMI_MKK4_DFS_DOMAIN;
2933 return WMI_UNINIT_DFS_DOMAIN;
2936 static void ath10k_regd_update(struct ath10k *ar)
2938 struct reg_dmn_pair_mapping *regpair;
2940 enum wmi_dfs_region wmi_dfs_reg;
2941 enum nl80211_dfs_regions nl_dfs_reg;
2943 lockdep_assert_held(&ar->conf_mutex);
2945 ret = ath10k_update_channel_list(ar);
2947 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
2949 regpair = ar->ath_common.regulatory.regpair;
2951 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2952 nl_dfs_reg = ar->dfs_detector->region;
2953 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
2955 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
2958 /* Target allows setting up per-band regdomain but ath_common provides
2959 * a combined one only */
2960 ret = ath10k_wmi_pdev_set_regdomain(ar,
2961 regpair->reg_domain,
2962 regpair->reg_domain, /* 2ghz */
2963 regpair->reg_domain, /* 5ghz */
2964 regpair->reg_2ghz_ctl,
2965 regpair->reg_5ghz_ctl,
2968 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
2971 static void ath10k_reg_notifier(struct wiphy *wiphy,
2972 struct regulatory_request *request)
2974 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
2975 struct ath10k *ar = hw->priv;
2978 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
2980 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2981 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
2982 request->dfs_region);
2983 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
2984 request->dfs_region);
2986 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
2987 request->dfs_region);
2990 mutex_lock(&ar->conf_mutex);
2991 if (ar->state == ATH10K_STATE_ON)
2992 ath10k_regd_update(ar);
2993 mutex_unlock(&ar->conf_mutex);
3000 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
3002 lockdep_assert_held(&ar->htt.tx_lock);
3004 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3005 ar->tx_paused |= BIT(reason);
3006 ieee80211_stop_queues(ar->hw);
3009 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,
3010 struct ieee80211_vif *vif)
3012 struct ath10k *ar = data;
3013 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3015 if (arvif->tx_paused)
3018 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3021 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)
3023 lockdep_assert_held(&ar->htt.tx_lock);
3025 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3026 ar->tx_paused &= ~BIT(reason);
3031 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3032 IEEE80211_IFACE_ITER_RESUME_ALL,
3033 ath10k_mac_tx_unlock_iter,
3036 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue);
3039 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)
3041 struct ath10k *ar = arvif->ar;
3043 lockdep_assert_held(&ar->htt.tx_lock);
3045 WARN_ON(reason >= BITS_PER_LONG);
3046 arvif->tx_paused |= BIT(reason);
3047 ieee80211_stop_queue(ar->hw, arvif->vdev_id);
3050 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason)
3052 struct ath10k *ar = arvif->ar;
3054 lockdep_assert_held(&ar->htt.tx_lock);
3056 WARN_ON(reason >= BITS_PER_LONG);
3057 arvif->tx_paused &= ~BIT(reason);
3062 if (arvif->tx_paused)
3065 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3068 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,
3069 enum wmi_tlv_tx_pause_id pause_id,
3070 enum wmi_tlv_tx_pause_action action)
3072 struct ath10k *ar = arvif->ar;
3074 lockdep_assert_held(&ar->htt.tx_lock);
3077 case WMI_TLV_TX_PAUSE_ACTION_STOP:
3078 ath10k_mac_vif_tx_lock(arvif, pause_id);
3080 case WMI_TLV_TX_PAUSE_ACTION_WAKE:
3081 ath10k_mac_vif_tx_unlock(arvif, pause_id);
3084 ath10k_warn(ar, "received unknown tx pause action %d on vdev %i, ignoring\n",
3085 action, arvif->vdev_id);
3090 struct ath10k_mac_tx_pause {
3092 enum wmi_tlv_tx_pause_id pause_id;
3093 enum wmi_tlv_tx_pause_action action;
3096 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,
3097 struct ieee80211_vif *vif)
3099 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3100 struct ath10k_mac_tx_pause *arg = data;
3102 if (arvif->vdev_id != arg->vdev_id)
3105 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);
3108 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id,
3109 enum wmi_tlv_tx_pause_id pause_id,
3110 enum wmi_tlv_tx_pause_action action)
3112 struct ath10k_mac_tx_pause arg = {
3114 .pause_id = pause_id,
3118 spin_lock_bh(&ar->htt.tx_lock);
3119 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3120 IEEE80211_IFACE_ITER_RESUME_ALL,
3121 ath10k_mac_handle_tx_pause_iter,
3123 spin_unlock_bh(&ar->htt.tx_lock);
3126 static enum ath10k_hw_txrx_mode
3127 ath10k_mac_tx_h_get_txmode(struct ath10k *ar,
3128 struct ieee80211_vif *vif,
3129 struct ieee80211_sta *sta,
3130 struct sk_buff *skb)
3132 const struct ieee80211_hdr *hdr = (void *)skb->data;
3133 __le16 fc = hdr->frame_control;
3135 if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3136 return ATH10K_HW_TXRX_RAW;
3138 if (ieee80211_is_mgmt(fc))
3139 return ATH10K_HW_TXRX_MGMT;
3143 * NullFunc frames are mostly used to ping if a client or AP are still
3144 * reachable and responsive. This implies tx status reports must be
3145 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3146 * come to a conclusion that the other end disappeared and tear down
3147 * BSS connection or it can never disconnect from BSS/client (which is
3150 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3151 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3152 * which seems to deliver correct tx reports for NullFunc frames. The
3153 * downside of using it is it ignores client powersave state so it can
3154 * end up disconnecting sleeping clients in AP mode. It should fix STA
3155 * mode though because AP don't sleep.
3157 if (ar->htt.target_version_major < 3 &&
3158 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3159 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, ar->fw_features))
3160 return ATH10K_HW_TXRX_MGMT;
3164 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3165 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3166 * to work with Ethernet txmode so use it.
3168 * FIXME: Check if raw mode works with TDLS.
3170 if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3171 return ATH10K_HW_TXRX_ETHERNET;
3173 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
3174 return ATH10K_HW_TXRX_RAW;
3176 return ATH10K_HW_TXRX_NATIVE_WIFI;
3179 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,
3180 struct sk_buff *skb)
3182 const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3183 const struct ieee80211_hdr *hdr = (void *)skb->data;
3184 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |
3185 IEEE80211_TX_CTL_INJECTED;
3187 if (!ieee80211_has_protected(hdr->frame_control))
3190 if ((info->flags & mask) == mask)
3194 return !ath10k_vif_to_arvif(vif)->nohwcrypt;
3199 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3200 * Control in the header.
3202 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3204 struct ieee80211_hdr *hdr = (void *)skb->data;
3205 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3208 if (!ieee80211_is_data_qos(hdr->frame_control))
3211 qos_ctl = ieee80211_get_qos_ctl(hdr);
3212 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3213 skb->data, (void *)qos_ctl - (void *)skb->data);
3214 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3216 /* Some firmware revisions don't handle sending QoS NullFunc well.
3217 * These frames are mainly used for CQM purposes so it doesn't really
3218 * matter whether QoS NullFunc or NullFunc are sent.
3220 hdr = (void *)skb->data;
3221 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3222 cb->flags &= ~ATH10K_SKB_F_QOS;
3224 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3227 static void ath10k_tx_h_8023(struct sk_buff *skb)
3229 struct ieee80211_hdr *hdr;
3230 struct rfc1042_hdr *rfc1042;
3237 hdr = (void *)skb->data;
3238 hdrlen = ieee80211_hdrlen(hdr->frame_control);
3239 rfc1042 = (void *)skb->data + hdrlen;
3241 ether_addr_copy(da, ieee80211_get_DA(hdr));
3242 ether_addr_copy(sa, ieee80211_get_SA(hdr));
3243 type = rfc1042->snap_type;
3245 skb_pull(skb, hdrlen + sizeof(*rfc1042));
3246 skb_push(skb, sizeof(*eth));
3248 eth = (void *)skb->data;
3249 ether_addr_copy(eth->h_dest, da);
3250 ether_addr_copy(eth->h_source, sa);
3251 eth->h_proto = type;
3254 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3255 struct ieee80211_vif *vif,
3256 struct sk_buff *skb)
3258 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3259 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3261 /* This is case only for P2P_GO */
3262 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
3263 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
3266 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3267 spin_lock_bh(&ar->data_lock);
3268 if (arvif->u.ap.noa_data)
3269 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3271 memcpy(skb_put(skb, arvif->u.ap.noa_len),
3272 arvif->u.ap.noa_data,
3273 arvif->u.ap.noa_len);
3274 spin_unlock_bh(&ar->data_lock);
3278 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)
3280 /* FIXME: Not really sure since when the behaviour changed. At some
3281 * point new firmware stopped requiring creation of peer entries for
3282 * offchannel tx (and actually creating them causes issues with wmi-htc
3283 * tx credit replenishment and reliability). Assuming it's at least 3.4
3284 * because that's when the `freq` was introduced to TX_FRM HTT command.
3286 return (ar->htt.target_version_major >= 3 &&
3287 ar->htt.target_version_minor >= 4 &&
3288 ar->htt.op_version == ATH10K_FW_HTT_OP_VERSION_TLV);
3291 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3293 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3296 spin_lock_bh(&ar->data_lock);
3298 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) {
3299 ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3304 __skb_queue_tail(q, skb);
3305 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3308 spin_unlock_bh(&ar->data_lock);
3313 static void ath10k_mac_tx(struct ath10k *ar, enum ath10k_hw_txrx_mode txmode,
3314 struct sk_buff *skb)
3316 struct ath10k_htt *htt = &ar->htt;
3320 case ATH10K_HW_TXRX_RAW:
3321 case ATH10K_HW_TXRX_NATIVE_WIFI:
3322 case ATH10K_HW_TXRX_ETHERNET:
3323 ret = ath10k_htt_tx(htt, txmode, skb);
3325 case ATH10K_HW_TXRX_MGMT:
3326 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3328 ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
3329 else if (ar->htt.target_version_major >= 3)
3330 ret = ath10k_htt_tx(htt, txmode, skb);
3332 ret = ath10k_htt_mgmt_tx(htt, skb);
3337 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
3339 ieee80211_free_txskb(ar->hw, skb);
3343 void ath10k_offchan_tx_purge(struct ath10k *ar)
3345 struct sk_buff *skb;
3348 skb = skb_dequeue(&ar->offchan_tx_queue);
3352 ieee80211_free_txskb(ar->hw, skb);
3356 void ath10k_offchan_tx_work(struct work_struct *work)
3358 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
3359 struct ath10k_peer *peer;
3360 struct ath10k_vif *arvif;
3361 struct ieee80211_hdr *hdr;
3362 struct ieee80211_vif *vif;
3363 struct ieee80211_sta *sta;
3364 struct sk_buff *skb;
3365 const u8 *peer_addr;
3366 enum ath10k_hw_txrx_mode txmode;
3369 unsigned long time_left;
3370 bool tmp_peer_created = false;
3372 /* FW requirement: We must create a peer before FW will send out
3373 * an offchannel frame. Otherwise the frame will be stuck and
3374 * never transmitted. We delete the peer upon tx completion.
3375 * It is unlikely that a peer for offchannel tx will already be
3376 * present. However it may be in some rare cases so account for that.
3377 * Otherwise we might remove a legitimate peer and break stuff. */
3380 skb = skb_dequeue(&ar->offchan_tx_queue);
3384 mutex_lock(&ar->conf_mutex);
3386 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
3389 hdr = (struct ieee80211_hdr *)skb->data;
3390 peer_addr = ieee80211_get_DA(hdr);
3392 spin_lock_bh(&ar->data_lock);
3393 vdev_id = ar->scan.vdev_id;
3394 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
3395 spin_unlock_bh(&ar->data_lock);
3398 /* FIXME: should this use ath10k_warn()? */
3399 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
3400 peer_addr, vdev_id);
3403 ret = ath10k_peer_create(ar, vdev_id, peer_addr,
3404 WMI_PEER_TYPE_DEFAULT);
3406 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
3407 peer_addr, vdev_id, ret);
3408 tmp_peer_created = (ret == 0);
3411 spin_lock_bh(&ar->data_lock);
3412 reinit_completion(&ar->offchan_tx_completed);
3413 ar->offchan_tx_skb = skb;
3414 spin_unlock_bh(&ar->data_lock);
3416 /* It's safe to access vif and sta - conf_mutex guarantees that
3417 * sta_state() and remove_interface() are locked exclusively
3418 * out wrt to this offchannel worker.
3420 arvif = ath10k_get_arvif(ar, vdev_id);
3423 sta = ieee80211_find_sta(vif, peer_addr);
3429 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3431 ath10k_mac_tx(ar, txmode, skb);
3434 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
3436 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
3439 if (!peer && tmp_peer_created) {
3440 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
3442 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
3443 peer_addr, vdev_id, ret);
3446 mutex_unlock(&ar->conf_mutex);
3450 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
3452 struct sk_buff *skb;
3455 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3459 ieee80211_free_txskb(ar->hw, skb);
3463 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
3465 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
3466 struct sk_buff *skb;
3470 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3474 ret = ath10k_wmi_mgmt_tx(ar, skb);
3476 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
3478 ieee80211_free_txskb(ar->hw, skb);
3487 void __ath10k_scan_finish(struct ath10k *ar)
3489 lockdep_assert_held(&ar->data_lock);
3491 switch (ar->scan.state) {
3492 case ATH10K_SCAN_IDLE:
3494 case ATH10K_SCAN_RUNNING:
3495 case ATH10K_SCAN_ABORTING:
3496 if (!ar->scan.is_roc)
3497 ieee80211_scan_completed(ar->hw,
3499 ATH10K_SCAN_ABORTING));
3500 else if (ar->scan.roc_notify)
3501 ieee80211_remain_on_channel_expired(ar->hw);
3503 case ATH10K_SCAN_STARTING:
3504 ar->scan.state = ATH10K_SCAN_IDLE;
3505 ar->scan_channel = NULL;
3506 ar->scan.roc_freq = 0;
3507 ath10k_offchan_tx_purge(ar);
3508 cancel_delayed_work(&ar->scan.timeout);
3509 complete_all(&ar->scan.completed);
3514 void ath10k_scan_finish(struct ath10k *ar)
3516 spin_lock_bh(&ar->data_lock);
3517 __ath10k_scan_finish(ar);
3518 spin_unlock_bh(&ar->data_lock);
3521 static int ath10k_scan_stop(struct ath10k *ar)
3523 struct wmi_stop_scan_arg arg = {
3524 .req_id = 1, /* FIXME */
3525 .req_type = WMI_SCAN_STOP_ONE,
3526 .u.scan_id = ATH10K_SCAN_ID,
3530 lockdep_assert_held(&ar->conf_mutex);
3532 ret = ath10k_wmi_stop_scan(ar, &arg);
3534 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
3538 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
3540 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
3542 } else if (ret > 0) {
3547 /* Scan state should be updated upon scan completion but in case
3548 * firmware fails to deliver the event (for whatever reason) it is
3549 * desired to clean up scan state anyway. Firmware may have just
3550 * dropped the scan completion event delivery due to transport pipe
3551 * being overflown with data and/or it can recover on its own before
3552 * next scan request is submitted.
3554 spin_lock_bh(&ar->data_lock);
3555 if (ar->scan.state != ATH10K_SCAN_IDLE)
3556 __ath10k_scan_finish(ar);
3557 spin_unlock_bh(&ar->data_lock);
3562 static void ath10k_scan_abort(struct ath10k *ar)
3566 lockdep_assert_held(&ar->conf_mutex);
3568 spin_lock_bh(&ar->data_lock);
3570 switch (ar->scan.state) {
3571 case ATH10K_SCAN_IDLE:
3572 /* This can happen if timeout worker kicked in and called
3573 * abortion while scan completion was being processed.
3576 case ATH10K_SCAN_STARTING:
3577 case ATH10K_SCAN_ABORTING:
3578 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3579 ath10k_scan_state_str(ar->scan.state),
3582 case ATH10K_SCAN_RUNNING:
3583 ar->scan.state = ATH10K_SCAN_ABORTING;
3584 spin_unlock_bh(&ar->data_lock);
3586 ret = ath10k_scan_stop(ar);
3588 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
3590 spin_lock_bh(&ar->data_lock);
3594 spin_unlock_bh(&ar->data_lock);
3597 void ath10k_scan_timeout_work(struct work_struct *work)
3599 struct ath10k *ar = container_of(work, struct ath10k,
3602 mutex_lock(&ar->conf_mutex);
3603 ath10k_scan_abort(ar);
3604 mutex_unlock(&ar->conf_mutex);
3607 static int ath10k_start_scan(struct ath10k *ar,
3608 const struct wmi_start_scan_arg *arg)
3612 lockdep_assert_held(&ar->conf_mutex);
3614 ret = ath10k_wmi_start_scan(ar, arg);
3618 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
3620 ret = ath10k_scan_stop(ar);
3622 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3627 /* If we failed to start the scan, return error code at
3628 * this point. This is probably due to some issue in the
3629 * firmware, but no need to wedge the driver due to that...
3631 spin_lock_bh(&ar->data_lock);
3632 if (ar->scan.state == ATH10K_SCAN_IDLE) {
3633 spin_unlock_bh(&ar->data_lock);
3636 spin_unlock_bh(&ar->data_lock);
3641 /**********************/
3642 /* mac80211 callbacks */
3643 /**********************/
3645 static void ath10k_tx(struct ieee80211_hw *hw,
3646 struct ieee80211_tx_control *control,
3647 struct sk_buff *skb)
3649 struct ath10k *ar = hw->priv;
3650 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
3651 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3652 struct ieee80211_vif *vif = info->control.vif;
3653 struct ieee80211_sta *sta = control->sta;
3654 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3655 enum ath10k_hw_txrx_mode txmode;
3657 /* We should disable CCK RATE due to P2P */
3658 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
3659 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3661 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
3664 if (!ath10k_tx_h_use_hwcrypto(vif, skb))
3665 skb_cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3667 if (ieee80211_is_mgmt(hdr->frame_control))
3668 skb_cb->flags |= ATH10K_SKB_F_MGMT;
3670 if (ieee80211_is_data_qos(hdr->frame_control))
3671 skb_cb->flags |= ATH10K_SKB_F_QOS;
3676 case ATH10K_HW_TXRX_MGMT:
3677 case ATH10K_HW_TXRX_NATIVE_WIFI:
3678 ath10k_tx_h_nwifi(hw, skb);
3679 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
3680 ath10k_tx_h_seq_no(vif, skb);
3682 case ATH10K_HW_TXRX_ETHERNET:
3683 ath10k_tx_h_8023(skb);
3685 case ATH10K_HW_TXRX_RAW:
3686 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
3688 ieee80211_free_txskb(hw, skb);
3693 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
3694 if (!ath10k_mac_tx_frm_has_freq(ar)) {
3695 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
3698 skb_queue_tail(&ar->offchan_tx_queue, skb);
3699 ieee80211_queue_work(hw, &ar->offchan_tx_work);
3704 ath10k_mac_tx(ar, txmode, skb);
3707 /* Must not be called with conf_mutex held as workers can use that also. */
3708 void ath10k_drain_tx(struct ath10k *ar)
3710 /* make sure rcu-protected mac80211 tx path itself is drained */
3713 ath10k_offchan_tx_purge(ar);
3714 ath10k_mgmt_over_wmi_tx_purge(ar);
3716 cancel_work_sync(&ar->offchan_tx_work);
3717 cancel_work_sync(&ar->wmi_mgmt_tx_work);
3720 void ath10k_halt(struct ath10k *ar)
3722 struct ath10k_vif *arvif;
3724 lockdep_assert_held(&ar->conf_mutex);
3726 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
3727 ar->filter_flags = 0;
3728 ar->monitor = false;
3729 ar->monitor_arvif = NULL;
3731 if (ar->monitor_started)
3732 ath10k_monitor_stop(ar);
3734 ar->monitor_started = false;
3737 ath10k_scan_finish(ar);
3738 ath10k_peer_cleanup_all(ar);
3739 ath10k_core_stop(ar);
3740 ath10k_hif_power_down(ar);
3742 spin_lock_bh(&ar->data_lock);
3743 list_for_each_entry(arvif, &ar->arvifs, list)
3744 ath10k_mac_vif_beacon_cleanup(arvif);
3745 spin_unlock_bh(&ar->data_lock);
3748 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
3750 struct ath10k *ar = hw->priv;
3752 mutex_lock(&ar->conf_mutex);
3754 *tx_ant = ar->cfg_tx_chainmask;
3755 *rx_ant = ar->cfg_rx_chainmask;
3757 mutex_unlock(&ar->conf_mutex);
3762 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
3764 /* It is not clear that allowing gaps in chainmask
3765 * is helpful. Probably it will not do what user
3766 * is hoping for, so warn in that case.
3768 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
3771 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
3775 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
3777 int nsts = ar->vht_cap_info;
3779 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
3780 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
3782 /* If firmware does not deliver to host number of space-time
3783 * streams supported, assume it support up to 4 BF STS and return
3784 * the value for VHT CAP: nsts-1)
3792 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
3794 int sound_dim = ar->vht_cap_info;
3796 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
3797 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
3799 /* If the sounding dimension is not advertised by the firmware,
3800 * let's use a default value of 1
3808 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3810 struct ieee80211_sta_vht_cap vht_cap = {0};
3815 vht_cap.vht_supported = 1;
3816 vht_cap.cap = ar->vht_cap_info;
3818 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
3819 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
3820 val = ath10k_mac_get_vht_cap_bf_sts(ar);
3821 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
3822 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
3827 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
3828 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
3829 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
3830 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
3831 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
3837 for (i = 0; i < 8; i++) {
3838 if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))
3839 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
3841 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
3844 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3845 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3850 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3853 struct ieee80211_sta_ht_cap ht_cap = {0};
3855 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3858 ht_cap.ht_supported = 1;
3859 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3860 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3861 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3862 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3864 WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT;
3866 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3867 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3869 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3870 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3872 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3875 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3876 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3881 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3882 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3884 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3887 stbc = ar->ht_cap_info;
3888 stbc &= WMI_HT_CAP_RX_STBC;
3889 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3890 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3891 stbc &= IEEE80211_HT_CAP_RX_STBC;
3896 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3897 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3899 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3900 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3902 /* max AMSDU is implicitly taken from vht_cap_info */
3903 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3904 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3906 for (i = 0; i < ar->num_rf_chains; i++) {
3907 if (ar->cfg_rx_chainmask & BIT(i))
3908 ht_cap.mcs.rx_mask[i] = 0xFF;
3911 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3916 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
3918 struct ieee80211_supported_band *band;
3919 struct ieee80211_sta_vht_cap vht_cap;
3920 struct ieee80211_sta_ht_cap ht_cap;
3922 ht_cap = ath10k_get_ht_cap(ar);
3923 vht_cap = ath10k_create_vht_cap(ar);
3925 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3926 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3927 band->ht_cap = ht_cap;
3929 /* Enable the VHT support at 2.4 GHz */
3930 band->vht_cap = vht_cap;
3932 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3933 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3934 band->ht_cap = ht_cap;
3935 band->vht_cap = vht_cap;
3939 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
3943 lockdep_assert_held(&ar->conf_mutex);
3945 ath10k_check_chain_mask(ar, tx_ant, "tx");
3946 ath10k_check_chain_mask(ar, rx_ant, "rx");
3948 ar->cfg_tx_chainmask = tx_ant;
3949 ar->cfg_rx_chainmask = rx_ant;
3951 if ((ar->state != ATH10K_STATE_ON) &&
3952 (ar->state != ATH10K_STATE_RESTARTED))
3955 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
3958 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
3963 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
3966 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
3971 /* Reload HT/VHT capability */
3972 ath10k_mac_setup_ht_vht_cap(ar);
3977 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
3979 struct ath10k *ar = hw->priv;
3982 mutex_lock(&ar->conf_mutex);
3983 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
3984 mutex_unlock(&ar->conf_mutex);
3988 static int ath10k_start(struct ieee80211_hw *hw)
3990 struct ath10k *ar = hw->priv;
3995 * This makes sense only when restarting hw. It is harmless to call
3996 * uncoditionally. This is necessary to make sure no HTT/WMI tx
3997 * commands will be submitted while restarting.
3999 ath10k_drain_tx(ar);
4001 mutex_lock(&ar->conf_mutex);
4003 switch (ar->state) {
4004 case ATH10K_STATE_OFF:
4005 ar->state = ATH10K_STATE_ON;
4007 case ATH10K_STATE_RESTARTING:
4009 ar->state = ATH10K_STATE_RESTARTED;
4011 case ATH10K_STATE_ON:
4012 case ATH10K_STATE_RESTARTED:
4013 case ATH10K_STATE_WEDGED:
4017 case ATH10K_STATE_UTF:
4022 ret = ath10k_hif_power_up(ar);
4024 ath10k_err(ar, "Could not init hif: %d\n", ret);
4028 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
4030 ath10k_err(ar, "Could not init core: %d\n", ret);
4031 goto err_power_down;
4034 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
4036 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
4040 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
4042 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
4046 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
4047 ret = ath10k_wmi_adaptive_qcs(ar, true);
4049 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
4055 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
4056 burst_enable = ar->wmi.pdev_param->burst_enable;
4057 ret = ath10k_wmi_pdev_set_param(ar, burst_enable, 0);
4059 ath10k_warn(ar, "failed to disable burst: %d\n", ret);
4064 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
4067 * By default FW set ARP frames ac to voice (6). In that case ARP
4068 * exchange is not working properly for UAPSD enabled AP. ARP requests
4069 * which arrives with access category 0 are processed by network stack
4070 * and send back with access category 0, but FW changes access category
4071 * to 6. Set ARP frames access category to best effort (0) solves
4075 ret = ath10k_wmi_pdev_set_param(ar,
4076 ar->wmi.pdev_param->arp_ac_override, 0);
4078 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
4083 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
4085 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
4086 WMI_CCA_DETECT_LEVEL_AUTO,
4087 WMI_CCA_DETECT_MARGIN_AUTO);
4089 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
4095 ret = ath10k_wmi_pdev_set_param(ar,
4096 ar->wmi.pdev_param->ani_enable, 1);
4098 ath10k_warn(ar, "failed to enable ani by default: %d\n",
4103 ar->ani_enabled = true;
4105 ar->num_started_vdevs = 0;
4106 ath10k_regd_update(ar);
4108 ath10k_spectral_start(ar);
4109 ath10k_thermal_set_throttling(ar);
4111 mutex_unlock(&ar->conf_mutex);
4115 ath10k_core_stop(ar);
4118 ath10k_hif_power_down(ar);
4121 ar->state = ATH10K_STATE_OFF;
4124 mutex_unlock(&ar->conf_mutex);
4128 static void ath10k_stop(struct ieee80211_hw *hw)
4130 struct ath10k *ar = hw->priv;
4132 ath10k_drain_tx(ar);
4134 mutex_lock(&ar->conf_mutex);
4135 if (ar->state != ATH10K_STATE_OFF) {
4137 ar->state = ATH10K_STATE_OFF;
4139 mutex_unlock(&ar->conf_mutex);
4141 cancel_delayed_work_sync(&ar->scan.timeout);
4142 cancel_work_sync(&ar->restart_work);
4145 static int ath10k_config_ps(struct ath10k *ar)
4147 struct ath10k_vif *arvif;
4150 lockdep_assert_held(&ar->conf_mutex);
4152 list_for_each_entry(arvif, &ar->arvifs, list) {
4153 ret = ath10k_mac_vif_setup_ps(arvif);
4155 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
4163 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
4168 lockdep_assert_held(&ar->conf_mutex);
4170 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
4172 param = ar->wmi.pdev_param->txpower_limit2g;
4173 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4175 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
4180 param = ar->wmi.pdev_param->txpower_limit5g;
4181 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4183 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
4191 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4193 struct ath10k_vif *arvif;
4194 int ret, txpower = -1;
4196 lockdep_assert_held(&ar->conf_mutex);
4198 list_for_each_entry(arvif, &ar->arvifs, list) {
4199 WARN_ON(arvif->txpower < 0);
4202 txpower = arvif->txpower;
4204 txpower = min(txpower, arvif->txpower);
4207 if (WARN_ON(txpower == -1))
4210 ret = ath10k_mac_txpower_setup(ar, txpower);
4212 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4220 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4222 struct ath10k *ar = hw->priv;
4223 struct ieee80211_conf *conf = &hw->conf;
4226 mutex_lock(&ar->conf_mutex);
4228 if (changed & IEEE80211_CONF_CHANGE_PS)
4229 ath10k_config_ps(ar);
4231 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4232 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4233 ret = ath10k_monitor_recalc(ar);
4235 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4238 mutex_unlock(&ar->conf_mutex);
4242 static u32 get_nss_from_chainmask(u16 chain_mask)
4244 if ((chain_mask & 0xf) == 0xf)
4246 else if ((chain_mask & 0x7) == 0x7)
4248 else if ((chain_mask & 0x3) == 0x3)
4253 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4256 struct ath10k *ar = arvif->ar;
4260 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4263 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4264 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4265 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4266 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4268 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4269 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4270 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4271 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4276 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4277 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4279 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4280 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4281 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4283 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4284 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4286 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4287 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4288 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4290 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4291 ar->wmi.vdev_param->txbf, value);
4296 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4297 * because we will send mgmt frames without CCK. This requirement
4298 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4301 static int ath10k_add_interface(struct ieee80211_hw *hw,
4302 struct ieee80211_vif *vif)
4304 struct ath10k *ar = hw->priv;
4305 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4306 enum wmi_sta_powersave_param param;
4313 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4315 mutex_lock(&ar->conf_mutex);
4317 memset(arvif, 0, sizeof(*arvif));
4322 INIT_LIST_HEAD(&arvif->list);
4323 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4324 INIT_DELAYED_WORK(&arvif->connection_loss_work,
4325 ath10k_mac_vif_sta_connection_loss_work);
4327 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4328 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4329 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4330 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4331 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4332 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4335 if (ar->num_peers >= ar->max_num_peers) {
4336 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4341 if (ar->free_vdev_map == 0) {
4342 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4346 bit = __ffs64(ar->free_vdev_map);
4348 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4349 bit, ar->free_vdev_map);
4351 arvif->vdev_id = bit;
4352 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
4354 switch (vif->type) {
4355 case NL80211_IFTYPE_P2P_DEVICE:
4356 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4357 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
4359 case NL80211_IFTYPE_UNSPECIFIED:
4360 case NL80211_IFTYPE_STATION:
4361 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4363 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
4365 case NL80211_IFTYPE_ADHOC:
4366 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4368 case NL80211_IFTYPE_MESH_POINT:
4369 if (test_bit(WMI_SERVICE_MESH, ar->wmi.svc_map)) {
4370 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH;
4371 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4373 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
4376 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4378 case NL80211_IFTYPE_AP:
4379 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4382 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
4384 case NL80211_IFTYPE_MONITOR:
4385 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4392 /* Using vdev_id as queue number will make it very easy to do per-vif
4393 * tx queue locking. This shouldn't wrap due to interface combinations
4394 * but do a modulo for correctness sake and prevent using offchannel tx
4395 * queues for regular vif tx.
4397 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4398 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4399 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4401 /* Some firmware revisions don't wait for beacon tx completion before
4402 * sending another SWBA event. This could lead to hardware using old
4403 * (freed) beacon data in some cases, e.g. tx credit starvation
4404 * combined with missed TBTT. This is very very rare.
4406 * On non-IOMMU-enabled hosts this could be a possible security issue
4407 * because hw could beacon some random data on the air. On
4408 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4409 * device would crash.
4411 * Since there are no beacon tx completions (implicit nor explicit)
4412 * propagated to host the only workaround for this is to allocate a
4413 * DMA-coherent buffer for a lifetime of a vif and use it for all
4414 * beacon tx commands. Worst case for this approach is some beacons may
4415 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4417 if (vif->type == NL80211_IFTYPE_ADHOC ||
4418 vif->type == NL80211_IFTYPE_MESH_POINT ||
4419 vif->type == NL80211_IFTYPE_AP) {
4420 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4421 IEEE80211_MAX_FRAME_LEN,
4422 &arvif->beacon_paddr,
4424 if (!arvif->beacon_buf) {
4426 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4431 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4432 arvif->nohwcrypt = true;
4434 if (arvif->nohwcrypt &&
4435 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4436 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4440 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4441 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4442 arvif->beacon_buf ? "single-buf" : "per-skb");
4444 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4445 arvif->vdev_subtype, vif->addr);
4447 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4448 arvif->vdev_id, ret);
4452 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4453 list_add(&arvif->list, &ar->arvifs);
4455 /* It makes no sense to have firmware do keepalives. mac80211 already
4456 * takes care of this with idle connection polling.
4458 ret = ath10k_mac_vif_disable_keepalive(arvif);
4460 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4461 arvif->vdev_id, ret);
4462 goto err_vdev_delete;
4465 arvif->def_wep_key_idx = -1;
4467 vdev_param = ar->wmi.vdev_param->tx_encap_type;
4468 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4469 ATH10K_HW_TXRX_NATIVE_WIFI);
4470 /* 10.X firmware does not support this VDEV parameter. Do not warn */
4471 if (ret && ret != -EOPNOTSUPP) {
4472 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4473 arvif->vdev_id, ret);
4474 goto err_vdev_delete;
4477 if (ar->cfg_tx_chainmask) {
4478 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4480 vdev_param = ar->wmi.vdev_param->nss;
4481 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4484 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4485 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4487 goto err_vdev_delete;
4491 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4492 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4493 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4494 WMI_PEER_TYPE_DEFAULT);
4496 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4497 arvif->vdev_id, ret);
4498 goto err_vdev_delete;
4502 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4503 ret = ath10k_mac_set_kickout(arvif);
4505 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4506 arvif->vdev_id, ret);
4507 goto err_peer_delete;
4511 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4512 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4513 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4514 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4517 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4518 arvif->vdev_id, ret);
4519 goto err_peer_delete;
4522 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4524 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4525 arvif->vdev_id, ret);
4526 goto err_peer_delete;
4529 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4531 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4532 arvif->vdev_id, ret);
4533 goto err_peer_delete;
4537 ret = ath10k_mac_set_txbf_conf(arvif);
4539 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4540 arvif->vdev_id, ret);
4541 goto err_peer_delete;
4544 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4546 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4547 arvif->vdev_id, ret);
4548 goto err_peer_delete;
4551 arvif->txpower = vif->bss_conf.txpower;
4552 ret = ath10k_mac_txpower_recalc(ar);
4554 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4555 goto err_peer_delete;
4558 if (vif->type == NL80211_IFTYPE_MONITOR) {
4559 ar->monitor_arvif = arvif;
4560 ret = ath10k_monitor_recalc(ar);
4562 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4563 goto err_peer_delete;
4567 spin_lock_bh(&ar->htt.tx_lock);
4569 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4570 spin_unlock_bh(&ar->htt.tx_lock);
4572 mutex_unlock(&ar->conf_mutex);
4576 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4577 arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4578 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4581 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4582 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4583 list_del(&arvif->list);
4586 if (arvif->beacon_buf) {
4587 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4588 arvif->beacon_buf, arvif->beacon_paddr);
4589 arvif->beacon_buf = NULL;
4592 mutex_unlock(&ar->conf_mutex);
4597 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4601 for (i = 0; i < BITS_PER_LONG; i++)
4602 ath10k_mac_vif_tx_unlock(arvif, i);
4605 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4606 struct ieee80211_vif *vif)
4608 struct ath10k *ar = hw->priv;
4609 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4612 cancel_work_sync(&arvif->ap_csa_work);
4613 cancel_delayed_work_sync(&arvif->connection_loss_work);
4615 mutex_lock(&ar->conf_mutex);
4617 spin_lock_bh(&ar->data_lock);
4618 ath10k_mac_vif_beacon_cleanup(arvif);
4619 spin_unlock_bh(&ar->data_lock);
4621 ret = ath10k_spectral_vif_stop(arvif);
4623 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4624 arvif->vdev_id, ret);
4626 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4627 list_del(&arvif->list);
4629 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4630 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4631 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4634 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4635 arvif->vdev_id, ret);
4637 kfree(arvif->u.ap.noa_data);
4640 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4643 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4645 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4646 arvif->vdev_id, ret);
4648 /* Some firmware revisions don't notify host about self-peer removal
4649 * until after associated vdev is deleted.
4651 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4652 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4653 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4656 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4657 arvif->vdev_id, ret);
4659 spin_lock_bh(&ar->data_lock);
4661 spin_unlock_bh(&ar->data_lock);
4664 ath10k_peer_cleanup(ar, arvif->vdev_id);
4666 if (vif->type == NL80211_IFTYPE_MONITOR) {
4667 ar->monitor_arvif = NULL;
4668 ret = ath10k_monitor_recalc(ar);
4670 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4673 spin_lock_bh(&ar->htt.tx_lock);
4674 ath10k_mac_vif_tx_unlock_all(arvif);
4675 spin_unlock_bh(&ar->htt.tx_lock);
4677 mutex_unlock(&ar->conf_mutex);
4681 * FIXME: Has to be verified.
4683 #define SUPPORTED_FILTERS \
4688 FIF_BCN_PRBRESP_PROMISC | \
4692 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4693 unsigned int changed_flags,
4694 unsigned int *total_flags,
4697 struct ath10k *ar = hw->priv;
4700 mutex_lock(&ar->conf_mutex);
4702 changed_flags &= SUPPORTED_FILTERS;
4703 *total_flags &= SUPPORTED_FILTERS;
4704 ar->filter_flags = *total_flags;
4706 ret = ath10k_monitor_recalc(ar);
4708 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4710 mutex_unlock(&ar->conf_mutex);
4713 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4714 struct ieee80211_vif *vif,
4715 struct ieee80211_bss_conf *info,
4718 struct ath10k *ar = hw->priv;
4719 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4721 u32 vdev_param, pdev_param, slottime, preamble;
4723 mutex_lock(&ar->conf_mutex);
4725 if (changed & BSS_CHANGED_IBSS)
4726 ath10k_control_ibss(arvif, info, vif->addr);
4728 if (changed & BSS_CHANGED_BEACON_INT) {
4729 arvif->beacon_interval = info->beacon_int;
4730 vdev_param = ar->wmi.vdev_param->beacon_interval;
4731 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4732 arvif->beacon_interval);
4733 ath10k_dbg(ar, ATH10K_DBG_MAC,
4734 "mac vdev %d beacon_interval %d\n",
4735 arvif->vdev_id, arvif->beacon_interval);
4738 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4739 arvif->vdev_id, ret);
4742 if (changed & BSS_CHANGED_BEACON) {
4743 ath10k_dbg(ar, ATH10K_DBG_MAC,
4744 "vdev %d set beacon tx mode to staggered\n",
4747 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4748 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4749 WMI_BEACON_STAGGERED_MODE);
4751 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4752 arvif->vdev_id, ret);
4754 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4756 ath10k_warn(ar, "failed to update beacon template: %d\n",
4759 if (ieee80211_vif_is_mesh(vif)) {
4760 /* mesh doesn't use SSID but firmware needs it */
4761 strncpy(arvif->u.ap.ssid, "mesh",
4762 sizeof(arvif->u.ap.ssid));
4763 arvif->u.ap.ssid_len = 4;
4767 if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4768 ret = ath10k_mac_setup_prb_tmpl(arvif);
4770 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4771 arvif->vdev_id, ret);
4774 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4775 arvif->dtim_period = info->dtim_period;
4777 ath10k_dbg(ar, ATH10K_DBG_MAC,
4778 "mac vdev %d dtim_period %d\n",
4779 arvif->vdev_id, arvif->dtim_period);
4781 vdev_param = ar->wmi.vdev_param->dtim_period;
4782 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4783 arvif->dtim_period);
4785 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4786 arvif->vdev_id, ret);
4789 if (changed & BSS_CHANGED_SSID &&
4790 vif->type == NL80211_IFTYPE_AP) {
4791 arvif->u.ap.ssid_len = info->ssid_len;
4793 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4794 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4797 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4798 ether_addr_copy(arvif->bssid, info->bssid);
4800 if (changed & BSS_CHANGED_BEACON_ENABLED)
4801 ath10k_control_beaconing(arvif, info);
4803 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4804 arvif->use_cts_prot = info->use_cts_prot;
4805 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4806 arvif->vdev_id, info->use_cts_prot);
4808 ret = ath10k_recalc_rtscts_prot(arvif);
4810 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4811 arvif->vdev_id, ret);
4813 vdev_param = ar->wmi.vdev_param->protection_mode;
4814 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4815 info->use_cts_prot ? 1 : 0);
4817 ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4818 info->use_cts_prot, arvif->vdev_id, ret);
4821 if (changed & BSS_CHANGED_ERP_SLOT) {
4822 if (info->use_short_slot)
4823 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4826 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4828 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4829 arvif->vdev_id, slottime);
4831 vdev_param = ar->wmi.vdev_param->slot_time;
4832 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4835 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4836 arvif->vdev_id, ret);
4839 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4840 if (info->use_short_preamble)
4841 preamble = WMI_VDEV_PREAMBLE_SHORT;
4843 preamble = WMI_VDEV_PREAMBLE_LONG;
4845 ath10k_dbg(ar, ATH10K_DBG_MAC,
4846 "mac vdev %d preamble %dn",
4847 arvif->vdev_id, preamble);
4849 vdev_param = ar->wmi.vdev_param->preamble;
4850 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4853 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4854 arvif->vdev_id, ret);
4857 if (changed & BSS_CHANGED_ASSOC) {
4859 /* Workaround: Make sure monitor vdev is not running
4860 * when associating to prevent some firmware revisions
4861 * (e.g. 10.1 and 10.2) from crashing.
4863 if (ar->monitor_started)
4864 ath10k_monitor_stop(ar);
4865 ath10k_bss_assoc(hw, vif, info);
4866 ath10k_monitor_recalc(ar);
4868 ath10k_bss_disassoc(hw, vif);
4872 if (changed & BSS_CHANGED_TXPOWER) {
4873 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4874 arvif->vdev_id, info->txpower);
4876 arvif->txpower = info->txpower;
4877 ret = ath10k_mac_txpower_recalc(ar);
4879 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4882 if (changed & BSS_CHANGED_PS) {
4883 arvif->ps = vif->bss_conf.ps;
4885 ret = ath10k_config_ps(ar);
4887 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4888 arvif->vdev_id, ret);
4891 mutex_unlock(&ar->conf_mutex);
4894 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4895 struct ieee80211_vif *vif,
4896 struct ieee80211_scan_request *hw_req)
4898 struct ath10k *ar = hw->priv;
4899 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4900 struct cfg80211_scan_request *req = &hw_req->req;
4901 struct wmi_start_scan_arg arg;
4905 mutex_lock(&ar->conf_mutex);
4907 spin_lock_bh(&ar->data_lock);
4908 switch (ar->scan.state) {
4909 case ATH10K_SCAN_IDLE:
4910 reinit_completion(&ar->scan.started);
4911 reinit_completion(&ar->scan.completed);
4912 ar->scan.state = ATH10K_SCAN_STARTING;
4913 ar->scan.is_roc = false;
4914 ar->scan.vdev_id = arvif->vdev_id;
4917 case ATH10K_SCAN_STARTING:
4918 case ATH10K_SCAN_RUNNING:
4919 case ATH10K_SCAN_ABORTING:
4923 spin_unlock_bh(&ar->data_lock);
4928 memset(&arg, 0, sizeof(arg));
4929 ath10k_wmi_start_scan_init(ar, &arg);
4930 arg.vdev_id = arvif->vdev_id;
4931 arg.scan_id = ATH10K_SCAN_ID;
4934 arg.ie_len = req->ie_len;
4935 memcpy(arg.ie, req->ie, arg.ie_len);
4939 arg.n_ssids = req->n_ssids;
4940 for (i = 0; i < arg.n_ssids; i++) {
4941 arg.ssids[i].len = req->ssids[i].ssid_len;
4942 arg.ssids[i].ssid = req->ssids[i].ssid;
4945 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4948 if (req->n_channels) {
4949 arg.n_channels = req->n_channels;
4950 for (i = 0; i < arg.n_channels; i++)
4951 arg.channels[i] = req->channels[i]->center_freq;
4954 ret = ath10k_start_scan(ar, &arg);
4956 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4957 spin_lock_bh(&ar->data_lock);
4958 ar->scan.state = ATH10K_SCAN_IDLE;
4959 spin_unlock_bh(&ar->data_lock);
4962 /* Add a 200ms margin to account for event/command processing */
4963 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4964 msecs_to_jiffies(arg.max_scan_time +
4968 mutex_unlock(&ar->conf_mutex);
4972 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4973 struct ieee80211_vif *vif)
4975 struct ath10k *ar = hw->priv;
4977 mutex_lock(&ar->conf_mutex);
4978 ath10k_scan_abort(ar);
4979 mutex_unlock(&ar->conf_mutex);
4981 cancel_delayed_work_sync(&ar->scan.timeout);
4984 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4985 struct ath10k_vif *arvif,
4986 enum set_key_cmd cmd,
4987 struct ieee80211_key_conf *key)
4989 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
4992 /* 10.1 firmware branch requires default key index to be set to group
4993 * key index after installing it. Otherwise FW/HW Txes corrupted
4994 * frames with multi-vif APs. This is not required for main firmware
4995 * branch (e.g. 636).
4997 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4999 * FIXME: It remains unknown if this is required for multi-vif STA
5000 * interfaces on 10.1.
5003 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
5004 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
5007 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
5010 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
5013 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5019 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5022 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
5023 arvif->vdev_id, ret);
5026 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5027 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
5028 struct ieee80211_key_conf *key)
5030 struct ath10k *ar = hw->priv;
5031 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5032 struct ath10k_peer *peer;
5033 const u8 *peer_addr;
5034 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5035 key->cipher == WLAN_CIPHER_SUITE_WEP104;
5041 /* this one needs to be done in software */
5042 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
5045 if (arvif->nohwcrypt)
5048 if (key->keyidx > WMI_MAX_KEY_INDEX)
5051 mutex_lock(&ar->conf_mutex);
5054 peer_addr = sta->addr;
5055 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
5056 peer_addr = vif->bss_conf.bssid;
5058 peer_addr = vif->addr;
5060 key->hw_key_idx = key->keyidx;
5064 arvif->wep_keys[key->keyidx] = key;
5066 arvif->wep_keys[key->keyidx] = NULL;
5069 /* the peer should not disappear in mid-way (unless FW goes awry) since
5070 * we already hold conf_mutex. we just make sure its there now. */
5071 spin_lock_bh(&ar->data_lock);
5072 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5073 spin_unlock_bh(&ar->data_lock);
5076 if (cmd == SET_KEY) {
5077 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5082 /* if the peer doesn't exist there is no key to disable
5088 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5089 flags |= WMI_KEY_PAIRWISE;
5091 flags |= WMI_KEY_GROUP;
5094 if (cmd == DISABLE_KEY)
5095 ath10k_clear_vdev_key(arvif, key);
5097 /* When WEP keys are uploaded it's possible that there are
5098 * stations associated already (e.g. when merging) without any
5099 * keys. Static WEP needs an explicit per-peer key upload.
5101 if (vif->type == NL80211_IFTYPE_ADHOC &&
5103 ath10k_mac_vif_update_wep_key(arvif, key);
5105 /* 802.1x never sets the def_wep_key_idx so each set_key()
5106 * call changes default tx key.
5108 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5109 * after first set_key().
5111 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
5112 flags |= WMI_KEY_TX_USAGE;
5115 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
5118 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
5119 arvif->vdev_id, peer_addr, ret);
5123 /* mac80211 sets static WEP keys as groupwise while firmware requires
5124 * them to be installed twice as both pairwise and groupwise.
5126 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
5128 flags2 &= ~WMI_KEY_GROUP;
5129 flags2 |= WMI_KEY_PAIRWISE;
5131 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
5134 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5135 arvif->vdev_id, peer_addr, ret);
5136 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
5140 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5141 arvif->vdev_id, peer_addr, ret2);
5147 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5149 spin_lock_bh(&ar->data_lock);
5150 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5151 if (peer && cmd == SET_KEY)
5152 peer->keys[key->keyidx] = key;
5153 else if (peer && cmd == DISABLE_KEY)
5154 peer->keys[key->keyidx] = NULL;
5155 else if (peer == NULL)
5156 /* impossible unless FW goes crazy */
5157 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5158 spin_unlock_bh(&ar->data_lock);
5161 mutex_unlock(&ar->conf_mutex);
5165 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5166 struct ieee80211_vif *vif,
5169 struct ath10k *ar = hw->priv;
5170 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5173 mutex_lock(&arvif->ar->conf_mutex);
5175 if (arvif->ar->state != ATH10K_STATE_ON)
5178 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5179 arvif->vdev_id, keyidx);
5181 ret = ath10k_wmi_vdev_set_param(arvif->ar,
5183 arvif->ar->wmi.vdev_param->def_keyid,
5187 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5193 arvif->def_wep_key_idx = keyidx;
5196 mutex_unlock(&arvif->ar->conf_mutex);
5199 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5202 struct ath10k_vif *arvif;
5203 struct ath10k_sta *arsta;
5204 struct ieee80211_sta *sta;
5205 struct cfg80211_chan_def def;
5206 enum ieee80211_band band;
5207 const u8 *ht_mcs_mask;
5208 const u16 *vht_mcs_mask;
5209 u32 changed, bw, nss, smps;
5212 arsta = container_of(wk, struct ath10k_sta, update_wk);
5213 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5214 arvif = arsta->arvif;
5217 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5220 band = def.chan->band;
5221 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5222 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5224 spin_lock_bh(&ar->data_lock);
5226 changed = arsta->changed;
5233 spin_unlock_bh(&ar->data_lock);
5235 mutex_lock(&ar->conf_mutex);
5237 nss = max_t(u32, 1, nss);
5238 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5239 ath10k_mac_max_vht_nss(vht_mcs_mask)));
5241 if (changed & IEEE80211_RC_BW_CHANGED) {
5242 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5245 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5246 WMI_PEER_CHAN_WIDTH, bw);
5248 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5249 sta->addr, bw, err);
5252 if (changed & IEEE80211_RC_NSS_CHANGED) {
5253 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5256 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5259 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5260 sta->addr, nss, err);
5263 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5264 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5267 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5268 WMI_PEER_SMPS_STATE, smps);
5270 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5271 sta->addr, smps, err);
5274 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5275 changed & IEEE80211_RC_NSS_CHANGED) {
5276 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5279 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5281 ath10k_warn(ar, "failed to reassociate station: %pM\n",
5285 mutex_unlock(&ar->conf_mutex);
5288 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5289 struct ieee80211_sta *sta)
5291 struct ath10k *ar = arvif->ar;
5293 lockdep_assert_held(&ar->conf_mutex);
5295 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5298 if (ar->num_stations >= ar->max_num_stations)
5306 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5307 struct ieee80211_sta *sta)
5309 struct ath10k *ar = arvif->ar;
5311 lockdep_assert_held(&ar->conf_mutex);
5313 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5319 struct ath10k_mac_tdls_iter_data {
5320 u32 num_tdls_stations;
5321 struct ieee80211_vif *curr_vif;
5324 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5325 struct ieee80211_sta *sta)
5327 struct ath10k_mac_tdls_iter_data *iter_data = data;
5328 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5329 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5331 if (sta->tdls && sta_vif == iter_data->curr_vif)
5332 iter_data->num_tdls_stations++;
5335 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5336 struct ieee80211_vif *vif)
5338 struct ath10k_mac_tdls_iter_data data = {};
5340 data.curr_vif = vif;
5342 ieee80211_iterate_stations_atomic(hw,
5343 ath10k_mac_tdls_vif_stations_count_iter,
5345 return data.num_tdls_stations;
5348 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5349 struct ieee80211_vif *vif)
5351 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5352 int *num_tdls_vifs = data;
5354 if (vif->type != NL80211_IFTYPE_STATION)
5357 if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5361 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5363 int num_tdls_vifs = 0;
5365 ieee80211_iterate_active_interfaces_atomic(hw,
5366 IEEE80211_IFACE_ITER_NORMAL,
5367 ath10k_mac_tdls_vifs_count_iter,
5369 return num_tdls_vifs;
5372 static int ath10k_sta_state(struct ieee80211_hw *hw,
5373 struct ieee80211_vif *vif,
5374 struct ieee80211_sta *sta,
5375 enum ieee80211_sta_state old_state,
5376 enum ieee80211_sta_state new_state)
5378 struct ath10k *ar = hw->priv;
5379 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5380 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5383 if (old_state == IEEE80211_STA_NOTEXIST &&
5384 new_state == IEEE80211_STA_NONE) {
5385 memset(arsta, 0, sizeof(*arsta));
5386 arsta->arvif = arvif;
5387 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5390 /* cancel must be done outside the mutex to avoid deadlock */
5391 if ((old_state == IEEE80211_STA_NONE &&
5392 new_state == IEEE80211_STA_NOTEXIST))
5393 cancel_work_sync(&arsta->update_wk);
5395 mutex_lock(&ar->conf_mutex);
5397 if (old_state == IEEE80211_STA_NOTEXIST &&
5398 new_state == IEEE80211_STA_NONE) {
5400 * New station addition.
5402 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5403 u32 num_tdls_stations;
5406 ath10k_dbg(ar, ATH10K_DBG_MAC,
5407 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5408 arvif->vdev_id, sta->addr,
5409 ar->num_stations + 1, ar->max_num_stations,
5410 ar->num_peers + 1, ar->max_num_peers);
5412 ret = ath10k_mac_inc_num_stations(arvif, sta);
5414 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5415 ar->max_num_stations);
5420 peer_type = WMI_PEER_TYPE_TDLS;
5422 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5425 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5426 sta->addr, arvif->vdev_id, ret);
5427 ath10k_mac_dec_num_stations(arvif, sta);
5434 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5435 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5437 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5438 num_tdls_stations == 0) {
5439 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5440 arvif->vdev_id, ar->max_num_tdls_vdevs);
5441 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5442 ath10k_mac_dec_num_stations(arvif, sta);
5447 if (num_tdls_stations == 0) {
5448 /* This is the first tdls peer in current vif */
5449 enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5451 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5454 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5455 arvif->vdev_id, ret);
5456 ath10k_peer_delete(ar, arvif->vdev_id,
5458 ath10k_mac_dec_num_stations(arvif, sta);
5463 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5464 WMI_TDLS_PEER_STATE_PEERING);
5467 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5468 sta->addr, arvif->vdev_id, ret);
5469 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5470 ath10k_mac_dec_num_stations(arvif, sta);
5472 if (num_tdls_stations != 0)
5474 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5477 } else if ((old_state == IEEE80211_STA_NONE &&
5478 new_state == IEEE80211_STA_NOTEXIST)) {
5480 * Existing station deletion.
5482 ath10k_dbg(ar, ATH10K_DBG_MAC,
5483 "mac vdev %d peer delete %pM (sta gone)\n",
5484 arvif->vdev_id, sta->addr);
5486 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5488 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5489 sta->addr, arvif->vdev_id, ret);
5491 ath10k_mac_dec_num_stations(arvif, sta);
5496 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5499 /* This was the last tdls peer in current vif */
5500 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5503 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5504 arvif->vdev_id, ret);
5506 } else if (old_state == IEEE80211_STA_AUTH &&
5507 new_state == IEEE80211_STA_ASSOC &&
5508 (vif->type == NL80211_IFTYPE_AP ||
5509 vif->type == NL80211_IFTYPE_MESH_POINT ||
5510 vif->type == NL80211_IFTYPE_ADHOC)) {
5514 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5517 ret = ath10k_station_assoc(ar, vif, sta, false);
5519 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5520 sta->addr, arvif->vdev_id, ret);
5521 } else if (old_state == IEEE80211_STA_ASSOC &&
5522 new_state == IEEE80211_STA_AUTHORIZED &&
5525 * Tdls station authorized.
5527 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5530 ret = ath10k_station_assoc(ar, vif, sta, false);
5532 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5533 sta->addr, arvif->vdev_id, ret);
5537 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5538 WMI_TDLS_PEER_STATE_CONNECTED);
5540 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5541 sta->addr, arvif->vdev_id, ret);
5542 } else if (old_state == IEEE80211_STA_ASSOC &&
5543 new_state == IEEE80211_STA_AUTH &&
5544 (vif->type == NL80211_IFTYPE_AP ||
5545 vif->type == NL80211_IFTYPE_MESH_POINT ||
5546 vif->type == NL80211_IFTYPE_ADHOC)) {
5550 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5553 ret = ath10k_station_disassoc(ar, vif, sta);
5555 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5556 sta->addr, arvif->vdev_id, ret);
5559 mutex_unlock(&ar->conf_mutex);
5563 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5564 u16 ac, bool enable)
5566 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5567 struct wmi_sta_uapsd_auto_trig_arg arg = {};
5568 u32 prio = 0, acc = 0;
5572 lockdep_assert_held(&ar->conf_mutex);
5574 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5578 case IEEE80211_AC_VO:
5579 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5580 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5584 case IEEE80211_AC_VI:
5585 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5586 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5590 case IEEE80211_AC_BE:
5591 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5592 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5596 case IEEE80211_AC_BK:
5597 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5598 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5605 arvif->u.sta.uapsd |= value;
5607 arvif->u.sta.uapsd &= ~value;
5609 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5610 WMI_STA_PS_PARAM_UAPSD,
5611 arvif->u.sta.uapsd);
5613 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5617 if (arvif->u.sta.uapsd)
5618 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5620 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5622 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5623 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5626 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5628 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5630 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5631 arvif->vdev_id, ret);
5635 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5637 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5638 arvif->vdev_id, ret);
5642 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5643 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5644 /* Only userspace can make an educated decision when to send
5645 * trigger frame. The following effectively disables u-UAPSD
5646 * autotrigger in firmware (which is enabled by default
5647 * provided the autotrigger service is available).
5651 arg.user_priority = prio;
5652 arg.service_interval = 0;
5653 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5654 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5656 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5657 arvif->bssid, &arg, 1);
5659 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5669 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5670 struct ieee80211_vif *vif, u16 ac,
5671 const struct ieee80211_tx_queue_params *params)
5673 struct ath10k *ar = hw->priv;
5674 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5675 struct wmi_wmm_params_arg *p = NULL;
5678 mutex_lock(&ar->conf_mutex);
5681 case IEEE80211_AC_VO:
5682 p = &arvif->wmm_params.ac_vo;
5684 case IEEE80211_AC_VI:
5685 p = &arvif->wmm_params.ac_vi;
5687 case IEEE80211_AC_BE:
5688 p = &arvif->wmm_params.ac_be;
5690 case IEEE80211_AC_BK:
5691 p = &arvif->wmm_params.ac_bk;
5700 p->cwmin = params->cw_min;
5701 p->cwmax = params->cw_max;
5702 p->aifs = params->aifs;
5705 * The channel time duration programmed in the HW is in absolute
5706 * microseconds, while mac80211 gives the txop in units of
5709 p->txop = params->txop * 32;
5711 if (ar->wmi.ops->gen_vdev_wmm_conf) {
5712 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5713 &arvif->wmm_params);
5715 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5716 arvif->vdev_id, ret);
5720 /* This won't work well with multi-interface cases but it's
5721 * better than nothing.
5723 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5725 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5730 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5732 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5735 mutex_unlock(&ar->conf_mutex);
5739 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5741 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5742 struct ieee80211_vif *vif,
5743 struct ieee80211_channel *chan,
5745 enum ieee80211_roc_type type)
5747 struct ath10k *ar = hw->priv;
5748 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5749 struct wmi_start_scan_arg arg;
5753 mutex_lock(&ar->conf_mutex);
5755 spin_lock_bh(&ar->data_lock);
5756 switch (ar->scan.state) {
5757 case ATH10K_SCAN_IDLE:
5758 reinit_completion(&ar->scan.started);
5759 reinit_completion(&ar->scan.completed);
5760 reinit_completion(&ar->scan.on_channel);
5761 ar->scan.state = ATH10K_SCAN_STARTING;
5762 ar->scan.is_roc = true;
5763 ar->scan.vdev_id = arvif->vdev_id;
5764 ar->scan.roc_freq = chan->center_freq;
5765 ar->scan.roc_notify = true;
5768 case ATH10K_SCAN_STARTING:
5769 case ATH10K_SCAN_RUNNING:
5770 case ATH10K_SCAN_ABORTING:
5774 spin_unlock_bh(&ar->data_lock);
5779 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5781 memset(&arg, 0, sizeof(arg));
5782 ath10k_wmi_start_scan_init(ar, &arg);
5783 arg.vdev_id = arvif->vdev_id;
5784 arg.scan_id = ATH10K_SCAN_ID;
5786 arg.channels[0] = chan->center_freq;
5787 arg.dwell_time_active = scan_time_msec;
5788 arg.dwell_time_passive = scan_time_msec;
5789 arg.max_scan_time = scan_time_msec;
5790 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5791 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5792 arg.burst_duration_ms = duration;
5794 ret = ath10k_start_scan(ar, &arg);
5796 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5797 spin_lock_bh(&ar->data_lock);
5798 ar->scan.state = ATH10K_SCAN_IDLE;
5799 spin_unlock_bh(&ar->data_lock);
5803 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5805 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5807 ret = ath10k_scan_stop(ar);
5809 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5815 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5816 msecs_to_jiffies(duration));
5820 mutex_unlock(&ar->conf_mutex);
5824 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5826 struct ath10k *ar = hw->priv;
5828 mutex_lock(&ar->conf_mutex);
5830 spin_lock_bh(&ar->data_lock);
5831 ar->scan.roc_notify = false;
5832 spin_unlock_bh(&ar->data_lock);
5834 ath10k_scan_abort(ar);
5836 mutex_unlock(&ar->conf_mutex);
5838 cancel_delayed_work_sync(&ar->scan.timeout);
5844 * Both RTS and Fragmentation threshold are interface-specific
5845 * in ath10k, but device-specific in mac80211.
5848 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5850 struct ath10k *ar = hw->priv;
5851 struct ath10k_vif *arvif;
5854 mutex_lock(&ar->conf_mutex);
5855 list_for_each_entry(arvif, &ar->arvifs, list) {
5856 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5857 arvif->vdev_id, value);
5859 ret = ath10k_mac_set_rts(arvif, value);
5861 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5862 arvif->vdev_id, ret);
5866 mutex_unlock(&ar->conf_mutex);
5871 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5873 /* Even though there's a WMI enum for fragmentation threshold no known
5874 * firmware actually implements it. Moreover it is not possible to rely
5875 * frame fragmentation to mac80211 because firmware clears the "more
5876 * fragments" bit in frame control making it impossible for remote
5877 * devices to reassemble frames.
5879 * Hence implement a dummy callback just to say fragmentation isn't
5880 * supported. This effectively prevents mac80211 from doing frame
5881 * fragmentation in software.
5886 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5887 u32 queues, bool drop)
5889 struct ath10k *ar = hw->priv;
5893 /* mac80211 doesn't care if we really xmit queued frames or not
5894 * we'll collect those frames either way if we stop/delete vdevs */
5898 mutex_lock(&ar->conf_mutex);
5900 if (ar->state == ATH10K_STATE_WEDGED)
5903 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5906 spin_lock_bh(&ar->htt.tx_lock);
5907 empty = (ar->htt.num_pending_tx == 0);
5908 spin_unlock_bh(&ar->htt.tx_lock);
5910 skip = (ar->state == ATH10K_STATE_WEDGED) ||
5911 test_bit(ATH10K_FLAG_CRASH_FLUSH,
5915 }), ATH10K_FLUSH_TIMEOUT_HZ);
5917 if (time_left == 0 || skip)
5918 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5919 skip, ar->state, time_left);
5922 mutex_unlock(&ar->conf_mutex);
5925 /* TODO: Implement this function properly
5926 * For now it is needed to reply to Probe Requests in IBSS mode.
5927 * Propably we need this information from FW.
5929 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5934 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5935 enum ieee80211_reconfig_type reconfig_type)
5937 struct ath10k *ar = hw->priv;
5939 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5942 mutex_lock(&ar->conf_mutex);
5944 /* If device failed to restart it will be in a different state, e.g.
5945 * ATH10K_STATE_WEDGED */
5946 if (ar->state == ATH10K_STATE_RESTARTED) {
5947 ath10k_info(ar, "device successfully recovered\n");
5948 ar->state = ATH10K_STATE_ON;
5949 ieee80211_wake_queues(ar->hw);
5952 mutex_unlock(&ar->conf_mutex);
5955 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5956 struct survey_info *survey)
5958 struct ath10k *ar = hw->priv;
5959 struct ieee80211_supported_band *sband;
5960 struct survey_info *ar_survey = &ar->survey[idx];
5963 mutex_lock(&ar->conf_mutex);
5965 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5966 if (sband && idx >= sband->n_channels) {
5967 idx -= sband->n_channels;
5972 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5974 if (!sband || idx >= sband->n_channels) {
5979 spin_lock_bh(&ar->data_lock);
5980 memcpy(survey, ar_survey, sizeof(*survey));
5981 spin_unlock_bh(&ar->data_lock);
5983 survey->channel = &sband->channels[idx];
5985 if (ar->rx_channel == survey->channel)
5986 survey->filled |= SURVEY_INFO_IN_USE;
5989 mutex_unlock(&ar->conf_mutex);
5994 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
5995 enum ieee80211_band band,
5996 const struct cfg80211_bitrate_mask *mask)
6001 num_rates += hweight32(mask->control[band].legacy);
6003 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6004 num_rates += hweight8(mask->control[band].ht_mcs[i]);
6006 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
6007 num_rates += hweight16(mask->control[band].vht_mcs[i]);
6009 return num_rates == 1;
6013 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
6014 enum ieee80211_band band,
6015 const struct cfg80211_bitrate_mask *mask,
6018 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6019 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6021 u8 vht_nss_mask = 0;
6024 if (mask->control[band].legacy)
6027 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6028 if (mask->control[band].ht_mcs[i] == 0)
6030 else if (mask->control[band].ht_mcs[i] ==
6031 sband->ht_cap.mcs.rx_mask[i])
6032 ht_nss_mask |= BIT(i);
6037 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6038 if (mask->control[band].vht_mcs[i] == 0)
6040 else if (mask->control[band].vht_mcs[i] ==
6041 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6042 vht_nss_mask |= BIT(i);
6047 if (ht_nss_mask != vht_nss_mask)
6050 if (ht_nss_mask == 0)
6053 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6056 *nss = fls(ht_nss_mask);
6062 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6063 enum ieee80211_band band,
6064 const struct cfg80211_bitrate_mask *mask,
6067 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6074 if (hweight32(mask->control[band].legacy) == 1) {
6075 rate_idx = ffs(mask->control[band].legacy) - 1;
6077 hw_rate = sband->bitrates[rate_idx].hw_value;
6078 bitrate = sband->bitrates[rate_idx].bitrate;
6080 if (ath10k_mac_bitrate_is_cck(bitrate))
6081 preamble = WMI_RATE_PREAMBLE_CCK;
6083 preamble = WMI_RATE_PREAMBLE_OFDM;
6086 *rate = preamble << 6 |
6093 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6094 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6096 *rate = WMI_RATE_PREAMBLE_HT << 6 |
6098 (ffs(mask->control[band].ht_mcs[i]) - 1);
6104 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6105 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6107 *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6109 (ffs(mask->control[band].vht_mcs[i]) - 1);
6118 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
6119 u8 rate, u8 nss, u8 sgi, u8 ldpc)
6121 struct ath10k *ar = arvif->ar;
6125 lockdep_assert_held(&ar->conf_mutex);
6127 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6128 arvif->vdev_id, rate, nss, sgi);
6130 vdev_param = ar->wmi.vdev_param->fixed_rate;
6131 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
6133 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
6138 vdev_param = ar->wmi.vdev_param->nss;
6139 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
6141 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6145 vdev_param = ar->wmi.vdev_param->sgi;
6146 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6148 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6152 vdev_param = ar->wmi.vdev_param->ldpc;
6153 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6155 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6163 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6164 enum ieee80211_band band,
6165 const struct cfg80211_bitrate_mask *mask)
6170 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6171 * to express all VHT MCS rate masks. Effectively only the following
6172 * ranges can be used: none, 0-7, 0-8 and 0-9.
6174 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6175 vht_mcs = mask->control[band].vht_mcs[i];
6184 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6192 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6193 struct ieee80211_sta *sta)
6195 struct ath10k_vif *arvif = data;
6196 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6197 struct ath10k *ar = arvif->ar;
6199 if (arsta->arvif != arvif)
6202 spin_lock_bh(&ar->data_lock);
6203 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6204 spin_unlock_bh(&ar->data_lock);
6206 ieee80211_queue_work(ar->hw, &arsta->update_wk);
6209 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6210 struct ieee80211_vif *vif,
6211 const struct cfg80211_bitrate_mask *mask)
6213 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6214 struct cfg80211_chan_def def;
6215 struct ath10k *ar = arvif->ar;
6216 enum ieee80211_band band;
6217 const u8 *ht_mcs_mask;
6218 const u16 *vht_mcs_mask;
6226 if (ath10k_mac_vif_chan(vif, &def))
6229 band = def.chan->band;
6230 ht_mcs_mask = mask->control[band].ht_mcs;
6231 vht_mcs_mask = mask->control[band].vht_mcs;
6232 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6234 sgi = mask->control[band].gi;
6235 if (sgi == NL80211_TXRATE_FORCE_LGI)
6238 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6239 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6242 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6243 arvif->vdev_id, ret);
6246 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6248 rate = WMI_FIXED_RATE_NONE;
6251 rate = WMI_FIXED_RATE_NONE;
6252 nss = min(ar->num_rf_chains,
6253 max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6254 ath10k_mac_max_vht_nss(vht_mcs_mask)));
6256 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6259 mutex_lock(&ar->conf_mutex);
6261 arvif->bitrate_mask = *mask;
6262 ieee80211_iterate_stations_atomic(ar->hw,
6263 ath10k_mac_set_bitrate_mask_iter,
6266 mutex_unlock(&ar->conf_mutex);
6269 mutex_lock(&ar->conf_mutex);
6271 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6273 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6274 arvif->vdev_id, ret);
6279 mutex_unlock(&ar->conf_mutex);
6284 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6285 struct ieee80211_vif *vif,
6286 struct ieee80211_sta *sta,
6289 struct ath10k *ar = hw->priv;
6290 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6293 spin_lock_bh(&ar->data_lock);
6295 ath10k_dbg(ar, ATH10K_DBG_MAC,
6296 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6297 sta->addr, changed, sta->bandwidth, sta->rx_nss,
6300 if (changed & IEEE80211_RC_BW_CHANGED) {
6301 bw = WMI_PEER_CHWIDTH_20MHZ;
6303 switch (sta->bandwidth) {
6304 case IEEE80211_STA_RX_BW_20:
6305 bw = WMI_PEER_CHWIDTH_20MHZ;
6307 case IEEE80211_STA_RX_BW_40:
6308 bw = WMI_PEER_CHWIDTH_40MHZ;
6310 case IEEE80211_STA_RX_BW_80:
6311 bw = WMI_PEER_CHWIDTH_80MHZ;
6313 case IEEE80211_STA_RX_BW_160:
6314 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6315 sta->bandwidth, sta->addr);
6316 bw = WMI_PEER_CHWIDTH_20MHZ;
6323 if (changed & IEEE80211_RC_NSS_CHANGED)
6324 arsta->nss = sta->rx_nss;
6326 if (changed & IEEE80211_RC_SMPS_CHANGED) {
6327 smps = WMI_PEER_SMPS_PS_NONE;
6329 switch (sta->smps_mode) {
6330 case IEEE80211_SMPS_AUTOMATIC:
6331 case IEEE80211_SMPS_OFF:
6332 smps = WMI_PEER_SMPS_PS_NONE;
6334 case IEEE80211_SMPS_STATIC:
6335 smps = WMI_PEER_SMPS_STATIC;
6337 case IEEE80211_SMPS_DYNAMIC:
6338 smps = WMI_PEER_SMPS_DYNAMIC;
6340 case IEEE80211_SMPS_NUM_MODES:
6341 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6342 sta->smps_mode, sta->addr);
6343 smps = WMI_PEER_SMPS_PS_NONE;
6350 arsta->changed |= changed;
6352 spin_unlock_bh(&ar->data_lock);
6354 ieee80211_queue_work(hw, &arsta->update_wk);
6357 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6360 * FIXME: Return 0 for time being. Need to figure out whether FW
6361 * has the API to fetch 64-bit local TSF
6367 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6368 struct ieee80211_vif *vif,
6369 struct ieee80211_ampdu_params *params)
6371 struct ath10k *ar = hw->priv;
6372 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6373 struct ieee80211_sta *sta = params->sta;
6374 enum ieee80211_ampdu_mlme_action action = params->action;
6375 u16 tid = params->tid;
6377 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6378 arvif->vdev_id, sta->addr, tid, action);
6381 case IEEE80211_AMPDU_RX_START:
6382 case IEEE80211_AMPDU_RX_STOP:
6383 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6384 * creation/removal. Do we need to verify this?
6387 case IEEE80211_AMPDU_TX_START:
6388 case IEEE80211_AMPDU_TX_STOP_CONT:
6389 case IEEE80211_AMPDU_TX_STOP_FLUSH:
6390 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6391 case IEEE80211_AMPDU_TX_OPERATIONAL:
6392 /* Firmware offloads Tx aggregation entirely so deny mac80211
6393 * Tx aggregation requests.
6402 ath10k_mac_update_rx_channel(struct ath10k *ar,
6403 struct ieee80211_chanctx_conf *ctx,
6404 struct ieee80211_vif_chanctx_switch *vifs,
6407 struct cfg80211_chan_def *def = NULL;
6409 /* Both locks are required because ar->rx_channel is modified. This
6410 * allows readers to hold either lock.
6412 lockdep_assert_held(&ar->conf_mutex);
6413 lockdep_assert_held(&ar->data_lock);
6415 WARN_ON(ctx && vifs);
6416 WARN_ON(vifs && n_vifs != 1);
6418 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6419 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6420 * ppdu on Rx may reduce performance on low-end systems. It should be
6421 * possible to make tables/hashmaps to speed the lookup up (be vary of
6422 * cpu data cache lines though regarding sizes) but to keep the initial
6423 * implementation simple and less intrusive fallback to the slow lookup
6424 * only for multi-channel cases. Single-channel cases will remain to
6425 * use the old channel derival and thus performance should not be
6429 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6430 ieee80211_iter_chan_contexts_atomic(ar->hw,
6431 ath10k_mac_get_any_chandef_iter,
6435 def = &vifs[0].new_ctx->def;
6437 ar->rx_channel = def->chan;
6438 } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6439 ar->rx_channel = ctx->def.chan;
6441 ar->rx_channel = NULL;
6447 ath10k_mac_update_vif_chan(struct ath10k *ar,
6448 struct ieee80211_vif_chanctx_switch *vifs,
6451 struct ath10k_vif *arvif;
6455 lockdep_assert_held(&ar->conf_mutex);
6457 /* First stop monitor interface. Some FW versions crash if there's a
6458 * lone monitor interface.
6460 if (ar->monitor_started)
6461 ath10k_monitor_stop(ar);
6463 for (i = 0; i < n_vifs; i++) {
6464 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6466 ath10k_dbg(ar, ATH10K_DBG_MAC,
6467 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6469 vifs[i].old_ctx->def.chan->center_freq,
6470 vifs[i].new_ctx->def.chan->center_freq,
6471 vifs[i].old_ctx->def.width,
6472 vifs[i].new_ctx->def.width);
6474 if (WARN_ON(!arvif->is_started))
6477 if (WARN_ON(!arvif->is_up))
6480 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6482 ath10k_warn(ar, "failed to down vdev %d: %d\n",
6483 arvif->vdev_id, ret);
6488 /* All relevant vdevs are downed and associated channel resources
6489 * should be available for the channel switch now.
6492 spin_lock_bh(&ar->data_lock);
6493 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6494 spin_unlock_bh(&ar->data_lock);
6496 for (i = 0; i < n_vifs; i++) {
6497 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6499 if (WARN_ON(!arvif->is_started))
6502 if (WARN_ON(!arvif->is_up))
6505 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6507 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6510 ret = ath10k_mac_setup_prb_tmpl(arvif);
6512 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6515 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6517 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6518 arvif->vdev_id, ret);
6522 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6525 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6526 arvif->vdev_id, ret);
6531 ath10k_monitor_recalc(ar);
6535 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6536 struct ieee80211_chanctx_conf *ctx)
6538 struct ath10k *ar = hw->priv;
6540 ath10k_dbg(ar, ATH10K_DBG_MAC,
6541 "mac chanctx add freq %hu width %d ptr %p\n",
6542 ctx->def.chan->center_freq, ctx->def.width, ctx);
6544 mutex_lock(&ar->conf_mutex);
6546 spin_lock_bh(&ar->data_lock);
6547 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6548 spin_unlock_bh(&ar->data_lock);
6550 ath10k_recalc_radar_detection(ar);
6551 ath10k_monitor_recalc(ar);
6553 mutex_unlock(&ar->conf_mutex);
6559 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6560 struct ieee80211_chanctx_conf *ctx)
6562 struct ath10k *ar = hw->priv;
6564 ath10k_dbg(ar, ATH10K_DBG_MAC,
6565 "mac chanctx remove freq %hu width %d ptr %p\n",
6566 ctx->def.chan->center_freq, ctx->def.width, ctx);
6568 mutex_lock(&ar->conf_mutex);
6570 spin_lock_bh(&ar->data_lock);
6571 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6572 spin_unlock_bh(&ar->data_lock);
6574 ath10k_recalc_radar_detection(ar);
6575 ath10k_monitor_recalc(ar);
6577 mutex_unlock(&ar->conf_mutex);
6580 struct ath10k_mac_change_chanctx_arg {
6581 struct ieee80211_chanctx_conf *ctx;
6582 struct ieee80211_vif_chanctx_switch *vifs;
6588 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6589 struct ieee80211_vif *vif)
6591 struct ath10k_mac_change_chanctx_arg *arg = data;
6593 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6600 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6601 struct ieee80211_vif *vif)
6603 struct ath10k_mac_change_chanctx_arg *arg = data;
6604 struct ieee80211_chanctx_conf *ctx;
6606 ctx = rcu_access_pointer(vif->chanctx_conf);
6607 if (ctx != arg->ctx)
6610 if (WARN_ON(arg->next_vif == arg->n_vifs))
6613 arg->vifs[arg->next_vif].vif = vif;
6614 arg->vifs[arg->next_vif].old_ctx = ctx;
6615 arg->vifs[arg->next_vif].new_ctx = ctx;
6620 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6621 struct ieee80211_chanctx_conf *ctx,
6624 struct ath10k *ar = hw->priv;
6625 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
6627 mutex_lock(&ar->conf_mutex);
6629 ath10k_dbg(ar, ATH10K_DBG_MAC,
6630 "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6631 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6633 /* This shouldn't really happen because channel switching should use
6634 * switch_vif_chanctx().
6636 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6639 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
6640 ieee80211_iterate_active_interfaces_atomic(
6642 IEEE80211_IFACE_ITER_NORMAL,
6643 ath10k_mac_change_chanctx_cnt_iter,
6645 if (arg.n_vifs == 0)
6648 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
6653 ieee80211_iterate_active_interfaces_atomic(
6655 IEEE80211_IFACE_ITER_NORMAL,
6656 ath10k_mac_change_chanctx_fill_iter,
6658 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6663 ath10k_recalc_radar_detection(ar);
6665 /* FIXME: How to configure Rx chains properly? */
6667 /* No other actions are actually necessary. Firmware maintains channel
6668 * definitions per vdev internally and there's no host-side channel
6669 * context abstraction to configure, e.g. channel width.
6673 mutex_unlock(&ar->conf_mutex);
6677 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6678 struct ieee80211_vif *vif,
6679 struct ieee80211_chanctx_conf *ctx)
6681 struct ath10k *ar = hw->priv;
6682 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6685 mutex_lock(&ar->conf_mutex);
6687 ath10k_dbg(ar, ATH10K_DBG_MAC,
6688 "mac chanctx assign ptr %p vdev_id %i\n",
6689 ctx, arvif->vdev_id);
6691 if (WARN_ON(arvif->is_started)) {
6692 mutex_unlock(&ar->conf_mutex);
6696 ret = ath10k_vdev_start(arvif, &ctx->def);
6698 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6699 arvif->vdev_id, vif->addr,
6700 ctx->def.chan->center_freq, ret);
6704 arvif->is_started = true;
6706 ret = ath10k_mac_vif_setup_ps(arvif);
6708 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6709 arvif->vdev_id, ret);
6713 if (vif->type == NL80211_IFTYPE_MONITOR) {
6714 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6716 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6717 arvif->vdev_id, ret);
6721 arvif->is_up = true;
6724 mutex_unlock(&ar->conf_mutex);
6728 ath10k_vdev_stop(arvif);
6729 arvif->is_started = false;
6730 ath10k_mac_vif_setup_ps(arvif);
6733 mutex_unlock(&ar->conf_mutex);
6738 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6739 struct ieee80211_vif *vif,
6740 struct ieee80211_chanctx_conf *ctx)
6742 struct ath10k *ar = hw->priv;
6743 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6746 mutex_lock(&ar->conf_mutex);
6748 ath10k_dbg(ar, ATH10K_DBG_MAC,
6749 "mac chanctx unassign ptr %p vdev_id %i\n",
6750 ctx, arvif->vdev_id);
6752 WARN_ON(!arvif->is_started);
6754 if (vif->type == NL80211_IFTYPE_MONITOR) {
6755 WARN_ON(!arvif->is_up);
6757 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6759 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6760 arvif->vdev_id, ret);
6762 arvif->is_up = false;
6765 ret = ath10k_vdev_stop(arvif);
6767 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6768 arvif->vdev_id, ret);
6770 arvif->is_started = false;
6772 mutex_unlock(&ar->conf_mutex);
6776 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6777 struct ieee80211_vif_chanctx_switch *vifs,
6779 enum ieee80211_chanctx_switch_mode mode)
6781 struct ath10k *ar = hw->priv;
6783 mutex_lock(&ar->conf_mutex);
6785 ath10k_dbg(ar, ATH10K_DBG_MAC,
6786 "mac chanctx switch n_vifs %d mode %d\n",
6788 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
6790 mutex_unlock(&ar->conf_mutex);
6794 static const struct ieee80211_ops ath10k_ops = {
6796 .start = ath10k_start,
6797 .stop = ath10k_stop,
6798 .config = ath10k_config,
6799 .add_interface = ath10k_add_interface,
6800 .remove_interface = ath10k_remove_interface,
6801 .configure_filter = ath10k_configure_filter,
6802 .bss_info_changed = ath10k_bss_info_changed,
6803 .hw_scan = ath10k_hw_scan,
6804 .cancel_hw_scan = ath10k_cancel_hw_scan,
6805 .set_key = ath10k_set_key,
6806 .set_default_unicast_key = ath10k_set_default_unicast_key,
6807 .sta_state = ath10k_sta_state,
6808 .conf_tx = ath10k_conf_tx,
6809 .remain_on_channel = ath10k_remain_on_channel,
6810 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
6811 .set_rts_threshold = ath10k_set_rts_threshold,
6812 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,
6813 .flush = ath10k_flush,
6814 .tx_last_beacon = ath10k_tx_last_beacon,
6815 .set_antenna = ath10k_set_antenna,
6816 .get_antenna = ath10k_get_antenna,
6817 .reconfig_complete = ath10k_reconfig_complete,
6818 .get_survey = ath10k_get_survey,
6819 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,
6820 .sta_rc_update = ath10k_sta_rc_update,
6821 .get_tsf = ath10k_get_tsf,
6822 .ampdu_action = ath10k_ampdu_action,
6823 .get_et_sset_count = ath10k_debug_get_et_sset_count,
6824 .get_et_stats = ath10k_debug_get_et_stats,
6825 .get_et_strings = ath10k_debug_get_et_strings,
6826 .add_chanctx = ath10k_mac_op_add_chanctx,
6827 .remove_chanctx = ath10k_mac_op_remove_chanctx,
6828 .change_chanctx = ath10k_mac_op_change_chanctx,
6829 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,
6830 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,
6831 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,
6833 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6836 .suspend = ath10k_wow_op_suspend,
6837 .resume = ath10k_wow_op_resume,
6839 #ifdef CONFIG_MAC80211_DEBUGFS
6840 .sta_add_debugfs = ath10k_sta_add_debugfs,
6844 #define CHAN2G(_channel, _freq, _flags) { \
6845 .band = IEEE80211_BAND_2GHZ, \
6846 .hw_value = (_channel), \
6847 .center_freq = (_freq), \
6848 .flags = (_flags), \
6849 .max_antenna_gain = 0, \
6853 #define CHAN5G(_channel, _freq, _flags) { \
6854 .band = IEEE80211_BAND_5GHZ, \
6855 .hw_value = (_channel), \
6856 .center_freq = (_freq), \
6857 .flags = (_flags), \
6858 .max_antenna_gain = 0, \
6862 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6872 CHAN2G(10, 2457, 0),
6873 CHAN2G(11, 2462, 0),
6874 CHAN2G(12, 2467, 0),
6875 CHAN2G(13, 2472, 0),
6876 CHAN2G(14, 2484, 0),
6879 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6880 CHAN5G(36, 5180, 0),
6881 CHAN5G(40, 5200, 0),
6882 CHAN5G(44, 5220, 0),
6883 CHAN5G(48, 5240, 0),
6884 CHAN5G(52, 5260, 0),
6885 CHAN5G(56, 5280, 0),
6886 CHAN5G(60, 5300, 0),
6887 CHAN5G(64, 5320, 0),
6888 CHAN5G(100, 5500, 0),
6889 CHAN5G(104, 5520, 0),
6890 CHAN5G(108, 5540, 0),
6891 CHAN5G(112, 5560, 0),
6892 CHAN5G(116, 5580, 0),
6893 CHAN5G(120, 5600, 0),
6894 CHAN5G(124, 5620, 0),
6895 CHAN5G(128, 5640, 0),
6896 CHAN5G(132, 5660, 0),
6897 CHAN5G(136, 5680, 0),
6898 CHAN5G(140, 5700, 0),
6899 CHAN5G(144, 5720, 0),
6900 CHAN5G(149, 5745, 0),
6901 CHAN5G(153, 5765, 0),
6902 CHAN5G(157, 5785, 0),
6903 CHAN5G(161, 5805, 0),
6904 CHAN5G(165, 5825, 0),
6907 struct ath10k *ath10k_mac_create(size_t priv_size)
6909 struct ieee80211_hw *hw;
6912 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6922 void ath10k_mac_destroy(struct ath10k *ar)
6924 ieee80211_free_hw(ar->hw);
6927 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6930 .types = BIT(NL80211_IFTYPE_STATION)
6931 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6935 .types = BIT(NL80211_IFTYPE_P2P_GO)
6939 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
6943 .types = BIT(NL80211_IFTYPE_AP)
6944 #ifdef CONFIG_MAC80211_MESH
6945 | BIT(NL80211_IFTYPE_MESH_POINT)
6950 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6953 .types = BIT(NL80211_IFTYPE_AP)
6954 #ifdef CONFIG_MAC80211_MESH
6955 | BIT(NL80211_IFTYPE_MESH_POINT)
6960 .types = BIT(NL80211_IFTYPE_STATION)
6964 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6966 .limits = ath10k_if_limits,
6967 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6968 .max_interfaces = 8,
6969 .num_different_channels = 1,
6970 .beacon_int_infra_match = true,
6974 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6976 .limits = ath10k_10x_if_limits,
6977 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6978 .max_interfaces = 8,
6979 .num_different_channels = 1,
6980 .beacon_int_infra_match = true,
6981 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6982 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6983 BIT(NL80211_CHAN_WIDTH_20) |
6984 BIT(NL80211_CHAN_WIDTH_40) |
6985 BIT(NL80211_CHAN_WIDTH_80),
6990 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
6993 .types = BIT(NL80211_IFTYPE_STATION),
6997 .types = BIT(NL80211_IFTYPE_AP) |
6998 #ifdef CONFIG_MAC80211_MESH
6999 BIT(NL80211_IFTYPE_MESH_POINT) |
7001 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7002 BIT(NL80211_IFTYPE_P2P_GO),
7006 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7010 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
7013 .types = BIT(NL80211_IFTYPE_STATION),
7017 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
7021 .types = BIT(NL80211_IFTYPE_AP) |
7022 #ifdef CONFIG_MAC80211_MESH
7023 BIT(NL80211_IFTYPE_MESH_POINT) |
7025 BIT(NL80211_IFTYPE_P2P_GO),
7029 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7033 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
7036 .types = BIT(NL80211_IFTYPE_STATION),
7040 .types = BIT(NL80211_IFTYPE_ADHOC),
7044 /* FIXME: This is not thouroughly tested. These combinations may over- or
7045 * underestimate hw/fw capabilities.
7047 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
7049 .limits = ath10k_tlv_if_limit,
7050 .num_different_channels = 1,
7051 .max_interfaces = 4,
7052 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7055 .limits = ath10k_tlv_if_limit_ibss,
7056 .num_different_channels = 1,
7057 .max_interfaces = 2,
7058 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7062 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
7064 .limits = ath10k_tlv_if_limit,
7065 .num_different_channels = 1,
7066 .max_interfaces = 4,
7067 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7070 .limits = ath10k_tlv_qcs_if_limit,
7071 .num_different_channels = 2,
7072 .max_interfaces = 4,
7073 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
7076 .limits = ath10k_tlv_if_limit_ibss,
7077 .num_different_channels = 1,
7078 .max_interfaces = 2,
7079 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7083 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
7086 .types = BIT(NL80211_IFTYPE_STATION),
7090 .types = BIT(NL80211_IFTYPE_AP)
7091 #ifdef CONFIG_MAC80211_MESH
7092 | BIT(NL80211_IFTYPE_MESH_POINT)
7097 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
7099 .limits = ath10k_10_4_if_limits,
7100 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
7101 .max_interfaces = 16,
7102 .num_different_channels = 1,
7103 .beacon_int_infra_match = true,
7104 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7105 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7106 BIT(NL80211_CHAN_WIDTH_20) |
7107 BIT(NL80211_CHAN_WIDTH_40) |
7108 BIT(NL80211_CHAN_WIDTH_80),
7113 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7114 struct ieee80211_vif *vif)
7116 struct ath10k_vif_iter *arvif_iter = data;
7117 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7119 if (arvif->vdev_id == arvif_iter->vdev_id)
7120 arvif_iter->arvif = arvif;
7123 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7125 struct ath10k_vif_iter arvif_iter;
7128 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7129 arvif_iter.vdev_id = vdev_id;
7131 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7132 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7134 ath10k_get_arvif_iter,
7136 if (!arvif_iter.arvif) {
7137 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7141 return arvif_iter.arvif;
7144 int ath10k_mac_register(struct ath10k *ar)
7146 static const u32 cipher_suites[] = {
7147 WLAN_CIPHER_SUITE_WEP40,
7148 WLAN_CIPHER_SUITE_WEP104,
7149 WLAN_CIPHER_SUITE_TKIP,
7150 WLAN_CIPHER_SUITE_CCMP,
7151 WLAN_CIPHER_SUITE_AES_CMAC,
7153 struct ieee80211_supported_band *band;
7157 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7159 SET_IEEE80211_DEV(ar->hw, ar->dev);
7161 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7162 ARRAY_SIZE(ath10k_5ghz_channels)) !=
7165 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7166 channels = kmemdup(ath10k_2ghz_channels,
7167 sizeof(ath10k_2ghz_channels),
7174 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7175 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7176 band->channels = channels;
7177 band->n_bitrates = ath10k_g_rates_size;
7178 band->bitrates = ath10k_g_rates;
7180 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7183 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7184 channels = kmemdup(ath10k_5ghz_channels,
7185 sizeof(ath10k_5ghz_channels),
7192 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7193 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7194 band->channels = channels;
7195 band->n_bitrates = ath10k_a_rates_size;
7196 band->bitrates = ath10k_a_rates;
7197 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7200 ath10k_mac_setup_ht_vht_cap(ar);
7202 ar->hw->wiphy->interface_modes =
7203 BIT(NL80211_IFTYPE_STATION) |
7204 BIT(NL80211_IFTYPE_AP) |
7205 BIT(NL80211_IFTYPE_MESH_POINT);
7207 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
7208 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
7210 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7211 ar->hw->wiphy->interface_modes |=
7212 BIT(NL80211_IFTYPE_P2P_DEVICE) |
7213 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7214 BIT(NL80211_IFTYPE_P2P_GO);
7216 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7217 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7218 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7219 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7220 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7221 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7222 ieee80211_hw_set(ar->hw, AP_LINK_PS);
7223 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7224 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7225 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7226 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7227 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7228 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7229 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7231 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7232 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7234 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7235 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7237 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7238 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7240 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7241 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7242 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7245 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7246 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7248 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7249 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7251 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7253 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7254 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7256 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7257 * that userspace (e.g. wpa_supplicant/hostapd) can generate
7258 * correct Probe Responses. This is more of a hack advert..
7260 ar->hw->wiphy->probe_resp_offload |=
7261 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7262 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7263 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7266 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7267 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7269 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7270 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7271 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7273 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7274 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7276 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7278 ret = ath10k_wow_init(ar);
7280 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7284 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7287 * on LL hardware queues are managed entirely by the FW
7288 * so we only advertise to mac we can do the queues thing
7290 ar->hw->queues = IEEE80211_MAX_QUEUES;
7292 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7293 * something that vdev_ids can't reach so that we don't stop the queue
7296 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7298 switch (ar->wmi.op_version) {
7299 case ATH10K_FW_WMI_OP_VERSION_MAIN:
7300 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7301 ar->hw->wiphy->n_iface_combinations =
7302 ARRAY_SIZE(ath10k_if_comb);
7303 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7305 case ATH10K_FW_WMI_OP_VERSION_TLV:
7306 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7307 ar->hw->wiphy->iface_combinations =
7308 ath10k_tlv_qcs_if_comb;
7309 ar->hw->wiphy->n_iface_combinations =
7310 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7312 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7313 ar->hw->wiphy->n_iface_combinations =
7314 ARRAY_SIZE(ath10k_tlv_if_comb);
7316 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7318 case ATH10K_FW_WMI_OP_VERSION_10_1:
7319 case ATH10K_FW_WMI_OP_VERSION_10_2:
7320 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7321 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7322 ar->hw->wiphy->n_iface_combinations =
7323 ARRAY_SIZE(ath10k_10x_if_comb);
7325 case ATH10K_FW_WMI_OP_VERSION_10_4:
7326 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7327 ar->hw->wiphy->n_iface_combinations =
7328 ARRAY_SIZE(ath10k_10_4_if_comb);
7330 case ATH10K_FW_WMI_OP_VERSION_UNSET:
7331 case ATH10K_FW_WMI_OP_VERSION_MAX:
7337 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7338 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7340 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7341 /* Init ath dfs pattern detector */
7342 ar->ath_common.debug_mask = ATH_DBG_DFS;
7343 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7346 if (!ar->dfs_detector)
7347 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7350 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7351 ath10k_reg_notifier);
7353 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7354 goto err_dfs_detector_exit;
7357 ar->hw->wiphy->cipher_suites = cipher_suites;
7358 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7360 ret = ieee80211_register_hw(ar->hw);
7362 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7363 goto err_dfs_detector_exit;
7366 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7367 ret = regulatory_hint(ar->hw->wiphy,
7368 ar->ath_common.regulatory.alpha2);
7370 goto err_unregister;
7376 ieee80211_unregister_hw(ar->hw);
7378 err_dfs_detector_exit:
7379 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7380 ar->dfs_detector->exit(ar->dfs_detector);
7383 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7384 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7386 SET_IEEE80211_DEV(ar->hw, NULL);
7390 void ath10k_mac_unregister(struct ath10k *ar)
7392 ieee80211_unregister_hw(ar->hw);
7394 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7395 ar->dfs_detector->exit(ar->dfs_detector);
7397 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7398 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7400 SET_IEEE80211_DEV(ar->hw, NULL);