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 param = ar->wmi.pdev_param->pmf_qos;
4035 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4037 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
4041 param = ar->wmi.pdev_param->dynamic_bw;
4042 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4044 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
4048 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
4049 ret = ath10k_wmi_adaptive_qcs(ar, true);
4051 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
4057 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
4058 param = ar->wmi.pdev_param->burst_enable;
4059 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
4061 ath10k_warn(ar, "failed to disable burst: %d\n", ret);
4066 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
4069 * By default FW set ARP frames ac to voice (6). In that case ARP
4070 * exchange is not working properly for UAPSD enabled AP. ARP requests
4071 * which arrives with access category 0 are processed by network stack
4072 * and send back with access category 0, but FW changes access category
4073 * to 6. Set ARP frames access category to best effort (0) solves
4077 param = ar->wmi.pdev_param->arp_ac_override;
4078 ret = ath10k_wmi_pdev_set_param(ar, param, 0);
4080 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
4085 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
4087 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
4088 WMI_CCA_DETECT_LEVEL_AUTO,
4089 WMI_CCA_DETECT_MARGIN_AUTO);
4091 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
4097 param = ar->wmi.pdev_param->ani_enable;
4098 ret = ath10k_wmi_pdev_set_param(ar, param, 1);
4100 ath10k_warn(ar, "failed to enable ani by default: %d\n",
4105 ar->ani_enabled = true;
4107 if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
4108 param = ar->wmi.pdev_param->peer_stats_update_period;
4109 ret = ath10k_wmi_pdev_set_param(ar, param,
4110 PEER_DEFAULT_STATS_UPDATE_PERIOD);
4113 "failed to set peer stats period : %d\n",
4119 ar->num_started_vdevs = 0;
4120 ath10k_regd_update(ar);
4122 ath10k_spectral_start(ar);
4123 ath10k_thermal_set_throttling(ar);
4125 mutex_unlock(&ar->conf_mutex);
4129 ath10k_core_stop(ar);
4132 ath10k_hif_power_down(ar);
4135 ar->state = ATH10K_STATE_OFF;
4138 mutex_unlock(&ar->conf_mutex);
4142 static void ath10k_stop(struct ieee80211_hw *hw)
4144 struct ath10k *ar = hw->priv;
4146 ath10k_drain_tx(ar);
4148 mutex_lock(&ar->conf_mutex);
4149 if (ar->state != ATH10K_STATE_OFF) {
4151 ar->state = ATH10K_STATE_OFF;
4153 mutex_unlock(&ar->conf_mutex);
4155 cancel_delayed_work_sync(&ar->scan.timeout);
4156 cancel_work_sync(&ar->restart_work);
4159 static int ath10k_config_ps(struct ath10k *ar)
4161 struct ath10k_vif *arvif;
4164 lockdep_assert_held(&ar->conf_mutex);
4166 list_for_each_entry(arvif, &ar->arvifs, list) {
4167 ret = ath10k_mac_vif_setup_ps(arvif);
4169 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
4177 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
4182 lockdep_assert_held(&ar->conf_mutex);
4184 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
4186 param = ar->wmi.pdev_param->txpower_limit2g;
4187 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4189 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
4194 param = ar->wmi.pdev_param->txpower_limit5g;
4195 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4197 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
4205 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4207 struct ath10k_vif *arvif;
4208 int ret, txpower = -1;
4210 lockdep_assert_held(&ar->conf_mutex);
4212 list_for_each_entry(arvif, &ar->arvifs, list) {
4213 WARN_ON(arvif->txpower < 0);
4216 txpower = arvif->txpower;
4218 txpower = min(txpower, arvif->txpower);
4221 if (WARN_ON(txpower == -1))
4224 ret = ath10k_mac_txpower_setup(ar, txpower);
4226 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4234 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4236 struct ath10k *ar = hw->priv;
4237 struct ieee80211_conf *conf = &hw->conf;
4240 mutex_lock(&ar->conf_mutex);
4242 if (changed & IEEE80211_CONF_CHANGE_PS)
4243 ath10k_config_ps(ar);
4245 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4246 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4247 ret = ath10k_monitor_recalc(ar);
4249 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4252 mutex_unlock(&ar->conf_mutex);
4256 static u32 get_nss_from_chainmask(u16 chain_mask)
4258 if ((chain_mask & 0xf) == 0xf)
4260 else if ((chain_mask & 0x7) == 0x7)
4262 else if ((chain_mask & 0x3) == 0x3)
4267 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4270 struct ath10k *ar = arvif->ar;
4274 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4277 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4278 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4279 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4280 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4282 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4283 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4284 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4285 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4290 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4291 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4293 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4294 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4295 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4297 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4298 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4300 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4301 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4302 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4304 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4305 ar->wmi.vdev_param->txbf, value);
4310 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4311 * because we will send mgmt frames without CCK. This requirement
4312 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4315 static int ath10k_add_interface(struct ieee80211_hw *hw,
4316 struct ieee80211_vif *vif)
4318 struct ath10k *ar = hw->priv;
4319 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4320 enum wmi_sta_powersave_param param;
4327 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4329 mutex_lock(&ar->conf_mutex);
4331 memset(arvif, 0, sizeof(*arvif));
4336 INIT_LIST_HEAD(&arvif->list);
4337 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4338 INIT_DELAYED_WORK(&arvif->connection_loss_work,
4339 ath10k_mac_vif_sta_connection_loss_work);
4341 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4342 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4343 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4344 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4345 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4346 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4349 if (ar->num_peers >= ar->max_num_peers) {
4350 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4355 if (ar->free_vdev_map == 0) {
4356 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4360 bit = __ffs64(ar->free_vdev_map);
4362 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4363 bit, ar->free_vdev_map);
4365 arvif->vdev_id = bit;
4366 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
4368 switch (vif->type) {
4369 case NL80211_IFTYPE_P2P_DEVICE:
4370 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4371 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
4373 case NL80211_IFTYPE_UNSPECIFIED:
4374 case NL80211_IFTYPE_STATION:
4375 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4377 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
4379 case NL80211_IFTYPE_ADHOC:
4380 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4382 case NL80211_IFTYPE_MESH_POINT:
4383 if (test_bit(WMI_SERVICE_MESH, ar->wmi.svc_map)) {
4384 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_MESH;
4385 } else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4387 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
4390 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4392 case NL80211_IFTYPE_AP:
4393 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4396 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
4398 case NL80211_IFTYPE_MONITOR:
4399 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4406 /* Using vdev_id as queue number will make it very easy to do per-vif
4407 * tx queue locking. This shouldn't wrap due to interface combinations
4408 * but do a modulo for correctness sake and prevent using offchannel tx
4409 * queues for regular vif tx.
4411 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4412 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4413 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4415 /* Some firmware revisions don't wait for beacon tx completion before
4416 * sending another SWBA event. This could lead to hardware using old
4417 * (freed) beacon data in some cases, e.g. tx credit starvation
4418 * combined with missed TBTT. This is very very rare.
4420 * On non-IOMMU-enabled hosts this could be a possible security issue
4421 * because hw could beacon some random data on the air. On
4422 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4423 * device would crash.
4425 * Since there are no beacon tx completions (implicit nor explicit)
4426 * propagated to host the only workaround for this is to allocate a
4427 * DMA-coherent buffer for a lifetime of a vif and use it for all
4428 * beacon tx commands. Worst case for this approach is some beacons may
4429 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4431 if (vif->type == NL80211_IFTYPE_ADHOC ||
4432 vif->type == NL80211_IFTYPE_MESH_POINT ||
4433 vif->type == NL80211_IFTYPE_AP) {
4434 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4435 IEEE80211_MAX_FRAME_LEN,
4436 &arvif->beacon_paddr,
4438 if (!arvif->beacon_buf) {
4440 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4445 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4446 arvif->nohwcrypt = true;
4448 if (arvif->nohwcrypt &&
4449 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4450 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4454 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4455 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4456 arvif->beacon_buf ? "single-buf" : "per-skb");
4458 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4459 arvif->vdev_subtype, vif->addr);
4461 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4462 arvif->vdev_id, ret);
4466 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4467 list_add(&arvif->list, &ar->arvifs);
4469 /* It makes no sense to have firmware do keepalives. mac80211 already
4470 * takes care of this with idle connection polling.
4472 ret = ath10k_mac_vif_disable_keepalive(arvif);
4474 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4475 arvif->vdev_id, ret);
4476 goto err_vdev_delete;
4479 arvif->def_wep_key_idx = -1;
4481 vdev_param = ar->wmi.vdev_param->tx_encap_type;
4482 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4483 ATH10K_HW_TXRX_NATIVE_WIFI);
4484 /* 10.X firmware does not support this VDEV parameter. Do not warn */
4485 if (ret && ret != -EOPNOTSUPP) {
4486 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4487 arvif->vdev_id, ret);
4488 goto err_vdev_delete;
4491 if (ar->cfg_tx_chainmask) {
4492 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4494 vdev_param = ar->wmi.vdev_param->nss;
4495 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4498 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4499 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4501 goto err_vdev_delete;
4505 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4506 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4507 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4508 WMI_PEER_TYPE_DEFAULT);
4510 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4511 arvif->vdev_id, ret);
4512 goto err_vdev_delete;
4516 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4517 ret = ath10k_mac_set_kickout(arvif);
4519 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4520 arvif->vdev_id, ret);
4521 goto err_peer_delete;
4525 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4526 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4527 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4528 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4531 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4532 arvif->vdev_id, ret);
4533 goto err_peer_delete;
4536 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4538 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4539 arvif->vdev_id, ret);
4540 goto err_peer_delete;
4543 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4545 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4546 arvif->vdev_id, ret);
4547 goto err_peer_delete;
4551 ret = ath10k_mac_set_txbf_conf(arvif);
4553 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4554 arvif->vdev_id, ret);
4555 goto err_peer_delete;
4558 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4560 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4561 arvif->vdev_id, ret);
4562 goto err_peer_delete;
4565 arvif->txpower = vif->bss_conf.txpower;
4566 ret = ath10k_mac_txpower_recalc(ar);
4568 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4569 goto err_peer_delete;
4572 if (vif->type == NL80211_IFTYPE_MONITOR) {
4573 ar->monitor_arvif = arvif;
4574 ret = ath10k_monitor_recalc(ar);
4576 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4577 goto err_peer_delete;
4581 spin_lock_bh(&ar->htt.tx_lock);
4583 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4584 spin_unlock_bh(&ar->htt.tx_lock);
4586 mutex_unlock(&ar->conf_mutex);
4590 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4591 arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4592 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4595 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4596 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4597 list_del(&arvif->list);
4600 if (arvif->beacon_buf) {
4601 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4602 arvif->beacon_buf, arvif->beacon_paddr);
4603 arvif->beacon_buf = NULL;
4606 mutex_unlock(&ar->conf_mutex);
4611 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4615 for (i = 0; i < BITS_PER_LONG; i++)
4616 ath10k_mac_vif_tx_unlock(arvif, i);
4619 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4620 struct ieee80211_vif *vif)
4622 struct ath10k *ar = hw->priv;
4623 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4626 cancel_work_sync(&arvif->ap_csa_work);
4627 cancel_delayed_work_sync(&arvif->connection_loss_work);
4629 mutex_lock(&ar->conf_mutex);
4631 spin_lock_bh(&ar->data_lock);
4632 ath10k_mac_vif_beacon_cleanup(arvif);
4633 spin_unlock_bh(&ar->data_lock);
4635 ret = ath10k_spectral_vif_stop(arvif);
4637 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4638 arvif->vdev_id, ret);
4640 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4641 list_del(&arvif->list);
4643 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4644 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4645 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4648 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4649 arvif->vdev_id, ret);
4651 kfree(arvif->u.ap.noa_data);
4654 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4657 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4659 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4660 arvif->vdev_id, ret);
4662 /* Some firmware revisions don't notify host about self-peer removal
4663 * until after associated vdev is deleted.
4665 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4666 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4667 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4670 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4671 arvif->vdev_id, ret);
4673 spin_lock_bh(&ar->data_lock);
4675 spin_unlock_bh(&ar->data_lock);
4678 ath10k_peer_cleanup(ar, arvif->vdev_id);
4680 if (vif->type == NL80211_IFTYPE_MONITOR) {
4681 ar->monitor_arvif = NULL;
4682 ret = ath10k_monitor_recalc(ar);
4684 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4687 spin_lock_bh(&ar->htt.tx_lock);
4688 ath10k_mac_vif_tx_unlock_all(arvif);
4689 spin_unlock_bh(&ar->htt.tx_lock);
4691 mutex_unlock(&ar->conf_mutex);
4695 * FIXME: Has to be verified.
4697 #define SUPPORTED_FILTERS \
4702 FIF_BCN_PRBRESP_PROMISC | \
4706 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4707 unsigned int changed_flags,
4708 unsigned int *total_flags,
4711 struct ath10k *ar = hw->priv;
4714 mutex_lock(&ar->conf_mutex);
4716 changed_flags &= SUPPORTED_FILTERS;
4717 *total_flags &= SUPPORTED_FILTERS;
4718 ar->filter_flags = *total_flags;
4720 ret = ath10k_monitor_recalc(ar);
4722 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4724 mutex_unlock(&ar->conf_mutex);
4727 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4728 struct ieee80211_vif *vif,
4729 struct ieee80211_bss_conf *info,
4732 struct ath10k *ar = hw->priv;
4733 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4735 u32 vdev_param, pdev_param, slottime, preamble;
4737 mutex_lock(&ar->conf_mutex);
4739 if (changed & BSS_CHANGED_IBSS)
4740 ath10k_control_ibss(arvif, info, vif->addr);
4742 if (changed & BSS_CHANGED_BEACON_INT) {
4743 arvif->beacon_interval = info->beacon_int;
4744 vdev_param = ar->wmi.vdev_param->beacon_interval;
4745 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4746 arvif->beacon_interval);
4747 ath10k_dbg(ar, ATH10K_DBG_MAC,
4748 "mac vdev %d beacon_interval %d\n",
4749 arvif->vdev_id, arvif->beacon_interval);
4752 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4753 arvif->vdev_id, ret);
4756 if (changed & BSS_CHANGED_BEACON) {
4757 ath10k_dbg(ar, ATH10K_DBG_MAC,
4758 "vdev %d set beacon tx mode to staggered\n",
4761 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4762 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4763 WMI_BEACON_STAGGERED_MODE);
4765 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4766 arvif->vdev_id, ret);
4768 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4770 ath10k_warn(ar, "failed to update beacon template: %d\n",
4773 if (ieee80211_vif_is_mesh(vif)) {
4774 /* mesh doesn't use SSID but firmware needs it */
4775 strncpy(arvif->u.ap.ssid, "mesh",
4776 sizeof(arvif->u.ap.ssid));
4777 arvif->u.ap.ssid_len = 4;
4781 if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4782 ret = ath10k_mac_setup_prb_tmpl(arvif);
4784 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4785 arvif->vdev_id, ret);
4788 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4789 arvif->dtim_period = info->dtim_period;
4791 ath10k_dbg(ar, ATH10K_DBG_MAC,
4792 "mac vdev %d dtim_period %d\n",
4793 arvif->vdev_id, arvif->dtim_period);
4795 vdev_param = ar->wmi.vdev_param->dtim_period;
4796 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4797 arvif->dtim_period);
4799 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4800 arvif->vdev_id, ret);
4803 if (changed & BSS_CHANGED_SSID &&
4804 vif->type == NL80211_IFTYPE_AP) {
4805 arvif->u.ap.ssid_len = info->ssid_len;
4807 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4808 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4811 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4812 ether_addr_copy(arvif->bssid, info->bssid);
4814 if (changed & BSS_CHANGED_BEACON_ENABLED)
4815 ath10k_control_beaconing(arvif, info);
4817 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4818 arvif->use_cts_prot = info->use_cts_prot;
4819 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4820 arvif->vdev_id, info->use_cts_prot);
4822 ret = ath10k_recalc_rtscts_prot(arvif);
4824 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4825 arvif->vdev_id, ret);
4827 vdev_param = ar->wmi.vdev_param->protection_mode;
4828 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4829 info->use_cts_prot ? 1 : 0);
4831 ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4832 info->use_cts_prot, arvif->vdev_id, ret);
4835 if (changed & BSS_CHANGED_ERP_SLOT) {
4836 if (info->use_short_slot)
4837 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4840 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4842 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4843 arvif->vdev_id, slottime);
4845 vdev_param = ar->wmi.vdev_param->slot_time;
4846 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4849 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4850 arvif->vdev_id, ret);
4853 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4854 if (info->use_short_preamble)
4855 preamble = WMI_VDEV_PREAMBLE_SHORT;
4857 preamble = WMI_VDEV_PREAMBLE_LONG;
4859 ath10k_dbg(ar, ATH10K_DBG_MAC,
4860 "mac vdev %d preamble %dn",
4861 arvif->vdev_id, preamble);
4863 vdev_param = ar->wmi.vdev_param->preamble;
4864 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4867 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4868 arvif->vdev_id, ret);
4871 if (changed & BSS_CHANGED_ASSOC) {
4873 /* Workaround: Make sure monitor vdev is not running
4874 * when associating to prevent some firmware revisions
4875 * (e.g. 10.1 and 10.2) from crashing.
4877 if (ar->monitor_started)
4878 ath10k_monitor_stop(ar);
4879 ath10k_bss_assoc(hw, vif, info);
4880 ath10k_monitor_recalc(ar);
4882 ath10k_bss_disassoc(hw, vif);
4886 if (changed & BSS_CHANGED_TXPOWER) {
4887 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4888 arvif->vdev_id, info->txpower);
4890 arvif->txpower = info->txpower;
4891 ret = ath10k_mac_txpower_recalc(ar);
4893 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4896 if (changed & BSS_CHANGED_PS) {
4897 arvif->ps = vif->bss_conf.ps;
4899 ret = ath10k_config_ps(ar);
4901 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4902 arvif->vdev_id, ret);
4905 mutex_unlock(&ar->conf_mutex);
4908 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4909 struct ieee80211_vif *vif,
4910 struct ieee80211_scan_request *hw_req)
4912 struct ath10k *ar = hw->priv;
4913 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4914 struct cfg80211_scan_request *req = &hw_req->req;
4915 struct wmi_start_scan_arg arg;
4919 mutex_lock(&ar->conf_mutex);
4921 spin_lock_bh(&ar->data_lock);
4922 switch (ar->scan.state) {
4923 case ATH10K_SCAN_IDLE:
4924 reinit_completion(&ar->scan.started);
4925 reinit_completion(&ar->scan.completed);
4926 ar->scan.state = ATH10K_SCAN_STARTING;
4927 ar->scan.is_roc = false;
4928 ar->scan.vdev_id = arvif->vdev_id;
4931 case ATH10K_SCAN_STARTING:
4932 case ATH10K_SCAN_RUNNING:
4933 case ATH10K_SCAN_ABORTING:
4937 spin_unlock_bh(&ar->data_lock);
4942 memset(&arg, 0, sizeof(arg));
4943 ath10k_wmi_start_scan_init(ar, &arg);
4944 arg.vdev_id = arvif->vdev_id;
4945 arg.scan_id = ATH10K_SCAN_ID;
4948 arg.ie_len = req->ie_len;
4949 memcpy(arg.ie, req->ie, arg.ie_len);
4953 arg.n_ssids = req->n_ssids;
4954 for (i = 0; i < arg.n_ssids; i++) {
4955 arg.ssids[i].len = req->ssids[i].ssid_len;
4956 arg.ssids[i].ssid = req->ssids[i].ssid;
4959 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4962 if (req->n_channels) {
4963 arg.n_channels = req->n_channels;
4964 for (i = 0; i < arg.n_channels; i++)
4965 arg.channels[i] = req->channels[i]->center_freq;
4968 ret = ath10k_start_scan(ar, &arg);
4970 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4971 spin_lock_bh(&ar->data_lock);
4972 ar->scan.state = ATH10K_SCAN_IDLE;
4973 spin_unlock_bh(&ar->data_lock);
4976 /* Add a 200ms margin to account for event/command processing */
4977 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4978 msecs_to_jiffies(arg.max_scan_time +
4982 mutex_unlock(&ar->conf_mutex);
4986 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4987 struct ieee80211_vif *vif)
4989 struct ath10k *ar = hw->priv;
4991 mutex_lock(&ar->conf_mutex);
4992 ath10k_scan_abort(ar);
4993 mutex_unlock(&ar->conf_mutex);
4995 cancel_delayed_work_sync(&ar->scan.timeout);
4998 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4999 struct ath10k_vif *arvif,
5000 enum set_key_cmd cmd,
5001 struct ieee80211_key_conf *key)
5003 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
5006 /* 10.1 firmware branch requires default key index to be set to group
5007 * key index after installing it. Otherwise FW/HW Txes corrupted
5008 * frames with multi-vif APs. This is not required for main firmware
5009 * branch (e.g. 636).
5011 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
5013 * FIXME: It remains unknown if this is required for multi-vif STA
5014 * interfaces on 10.1.
5017 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
5018 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
5021 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
5024 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
5027 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5033 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5036 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
5037 arvif->vdev_id, ret);
5040 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5041 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
5042 struct ieee80211_key_conf *key)
5044 struct ath10k *ar = hw->priv;
5045 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5046 struct ath10k_peer *peer;
5047 const u8 *peer_addr;
5048 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5049 key->cipher == WLAN_CIPHER_SUITE_WEP104;
5055 /* this one needs to be done in software */
5056 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
5059 if (arvif->nohwcrypt)
5062 if (key->keyidx > WMI_MAX_KEY_INDEX)
5065 mutex_lock(&ar->conf_mutex);
5068 peer_addr = sta->addr;
5069 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
5070 peer_addr = vif->bss_conf.bssid;
5072 peer_addr = vif->addr;
5074 key->hw_key_idx = key->keyidx;
5078 arvif->wep_keys[key->keyidx] = key;
5080 arvif->wep_keys[key->keyidx] = NULL;
5083 /* the peer should not disappear in mid-way (unless FW goes awry) since
5084 * we already hold conf_mutex. we just make sure its there now. */
5085 spin_lock_bh(&ar->data_lock);
5086 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5087 spin_unlock_bh(&ar->data_lock);
5090 if (cmd == SET_KEY) {
5091 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5096 /* if the peer doesn't exist there is no key to disable
5102 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
5103 flags |= WMI_KEY_PAIRWISE;
5105 flags |= WMI_KEY_GROUP;
5108 if (cmd == DISABLE_KEY)
5109 ath10k_clear_vdev_key(arvif, key);
5111 /* When WEP keys are uploaded it's possible that there are
5112 * stations associated already (e.g. when merging) without any
5113 * keys. Static WEP needs an explicit per-peer key upload.
5115 if (vif->type == NL80211_IFTYPE_ADHOC &&
5117 ath10k_mac_vif_update_wep_key(arvif, key);
5119 /* 802.1x never sets the def_wep_key_idx so each set_key()
5120 * call changes default tx key.
5122 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5123 * after first set_key().
5125 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
5126 flags |= WMI_KEY_TX_USAGE;
5129 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
5132 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
5133 arvif->vdev_id, peer_addr, ret);
5137 /* mac80211 sets static WEP keys as groupwise while firmware requires
5138 * them to be installed twice as both pairwise and groupwise.
5140 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
5142 flags2 &= ~WMI_KEY_GROUP;
5143 flags2 |= WMI_KEY_PAIRWISE;
5145 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
5148 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5149 arvif->vdev_id, peer_addr, ret);
5150 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
5154 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5155 arvif->vdev_id, peer_addr, ret2);
5161 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5163 spin_lock_bh(&ar->data_lock);
5164 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5165 if (peer && cmd == SET_KEY)
5166 peer->keys[key->keyidx] = key;
5167 else if (peer && cmd == DISABLE_KEY)
5168 peer->keys[key->keyidx] = NULL;
5169 else if (peer == NULL)
5170 /* impossible unless FW goes crazy */
5171 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5172 spin_unlock_bh(&ar->data_lock);
5175 mutex_unlock(&ar->conf_mutex);
5179 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5180 struct ieee80211_vif *vif,
5183 struct ath10k *ar = hw->priv;
5184 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5187 mutex_lock(&arvif->ar->conf_mutex);
5189 if (arvif->ar->state != ATH10K_STATE_ON)
5192 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5193 arvif->vdev_id, keyidx);
5195 ret = ath10k_wmi_vdev_set_param(arvif->ar,
5197 arvif->ar->wmi.vdev_param->def_keyid,
5201 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5207 arvif->def_wep_key_idx = keyidx;
5210 mutex_unlock(&arvif->ar->conf_mutex);
5213 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5216 struct ath10k_vif *arvif;
5217 struct ath10k_sta *arsta;
5218 struct ieee80211_sta *sta;
5219 struct cfg80211_chan_def def;
5220 enum ieee80211_band band;
5221 const u8 *ht_mcs_mask;
5222 const u16 *vht_mcs_mask;
5223 u32 changed, bw, nss, smps;
5226 arsta = container_of(wk, struct ath10k_sta, update_wk);
5227 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5228 arvif = arsta->arvif;
5231 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5234 band = def.chan->band;
5235 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5236 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5238 spin_lock_bh(&ar->data_lock);
5240 changed = arsta->changed;
5247 spin_unlock_bh(&ar->data_lock);
5249 mutex_lock(&ar->conf_mutex);
5251 nss = max_t(u32, 1, nss);
5252 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5253 ath10k_mac_max_vht_nss(vht_mcs_mask)));
5255 if (changed & IEEE80211_RC_BW_CHANGED) {
5256 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5259 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5260 WMI_PEER_CHAN_WIDTH, bw);
5262 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5263 sta->addr, bw, err);
5266 if (changed & IEEE80211_RC_NSS_CHANGED) {
5267 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5270 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5273 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5274 sta->addr, nss, err);
5277 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5278 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5281 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5282 WMI_PEER_SMPS_STATE, smps);
5284 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5285 sta->addr, smps, err);
5288 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5289 changed & IEEE80211_RC_NSS_CHANGED) {
5290 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5293 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5295 ath10k_warn(ar, "failed to reassociate station: %pM\n",
5299 mutex_unlock(&ar->conf_mutex);
5302 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5303 struct ieee80211_sta *sta)
5305 struct ath10k *ar = arvif->ar;
5307 lockdep_assert_held(&ar->conf_mutex);
5309 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5312 if (ar->num_stations >= ar->max_num_stations)
5320 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5321 struct ieee80211_sta *sta)
5323 struct ath10k *ar = arvif->ar;
5325 lockdep_assert_held(&ar->conf_mutex);
5327 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5333 struct ath10k_mac_tdls_iter_data {
5334 u32 num_tdls_stations;
5335 struct ieee80211_vif *curr_vif;
5338 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5339 struct ieee80211_sta *sta)
5341 struct ath10k_mac_tdls_iter_data *iter_data = data;
5342 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5343 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5345 if (sta->tdls && sta_vif == iter_data->curr_vif)
5346 iter_data->num_tdls_stations++;
5349 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5350 struct ieee80211_vif *vif)
5352 struct ath10k_mac_tdls_iter_data data = {};
5354 data.curr_vif = vif;
5356 ieee80211_iterate_stations_atomic(hw,
5357 ath10k_mac_tdls_vif_stations_count_iter,
5359 return data.num_tdls_stations;
5362 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5363 struct ieee80211_vif *vif)
5365 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5366 int *num_tdls_vifs = data;
5368 if (vif->type != NL80211_IFTYPE_STATION)
5371 if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5375 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5377 int num_tdls_vifs = 0;
5379 ieee80211_iterate_active_interfaces_atomic(hw,
5380 IEEE80211_IFACE_ITER_NORMAL,
5381 ath10k_mac_tdls_vifs_count_iter,
5383 return num_tdls_vifs;
5386 static int ath10k_sta_state(struct ieee80211_hw *hw,
5387 struct ieee80211_vif *vif,
5388 struct ieee80211_sta *sta,
5389 enum ieee80211_sta_state old_state,
5390 enum ieee80211_sta_state new_state)
5392 struct ath10k *ar = hw->priv;
5393 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5394 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5397 if (old_state == IEEE80211_STA_NOTEXIST &&
5398 new_state == IEEE80211_STA_NONE) {
5399 memset(arsta, 0, sizeof(*arsta));
5400 arsta->arvif = arvif;
5401 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5404 /* cancel must be done outside the mutex to avoid deadlock */
5405 if ((old_state == IEEE80211_STA_NONE &&
5406 new_state == IEEE80211_STA_NOTEXIST))
5407 cancel_work_sync(&arsta->update_wk);
5409 mutex_lock(&ar->conf_mutex);
5411 if (old_state == IEEE80211_STA_NOTEXIST &&
5412 new_state == IEEE80211_STA_NONE) {
5414 * New station addition.
5416 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5417 u32 num_tdls_stations;
5420 ath10k_dbg(ar, ATH10K_DBG_MAC,
5421 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5422 arvif->vdev_id, sta->addr,
5423 ar->num_stations + 1, ar->max_num_stations,
5424 ar->num_peers + 1, ar->max_num_peers);
5426 ret = ath10k_mac_inc_num_stations(arvif, sta);
5428 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5429 ar->max_num_stations);
5434 peer_type = WMI_PEER_TYPE_TDLS;
5436 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5439 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5440 sta->addr, arvif->vdev_id, ret);
5441 ath10k_mac_dec_num_stations(arvif, sta);
5448 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5449 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5451 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5452 num_tdls_stations == 0) {
5453 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5454 arvif->vdev_id, ar->max_num_tdls_vdevs);
5455 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5456 ath10k_mac_dec_num_stations(arvif, sta);
5461 if (num_tdls_stations == 0) {
5462 /* This is the first tdls peer in current vif */
5463 enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5465 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5468 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5469 arvif->vdev_id, ret);
5470 ath10k_peer_delete(ar, arvif->vdev_id,
5472 ath10k_mac_dec_num_stations(arvif, sta);
5477 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5478 WMI_TDLS_PEER_STATE_PEERING);
5481 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5482 sta->addr, arvif->vdev_id, ret);
5483 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5484 ath10k_mac_dec_num_stations(arvif, sta);
5486 if (num_tdls_stations != 0)
5488 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5491 } else if ((old_state == IEEE80211_STA_NONE &&
5492 new_state == IEEE80211_STA_NOTEXIST)) {
5494 * Existing station deletion.
5496 ath10k_dbg(ar, ATH10K_DBG_MAC,
5497 "mac vdev %d peer delete %pM (sta gone)\n",
5498 arvif->vdev_id, sta->addr);
5500 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5502 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5503 sta->addr, arvif->vdev_id, ret);
5505 ath10k_mac_dec_num_stations(arvif, sta);
5510 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5513 /* This was the last tdls peer in current vif */
5514 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5517 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5518 arvif->vdev_id, ret);
5520 } else if (old_state == IEEE80211_STA_AUTH &&
5521 new_state == IEEE80211_STA_ASSOC &&
5522 (vif->type == NL80211_IFTYPE_AP ||
5523 vif->type == NL80211_IFTYPE_MESH_POINT ||
5524 vif->type == NL80211_IFTYPE_ADHOC)) {
5528 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5531 ret = ath10k_station_assoc(ar, vif, sta, false);
5533 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5534 sta->addr, arvif->vdev_id, ret);
5535 } else if (old_state == IEEE80211_STA_ASSOC &&
5536 new_state == IEEE80211_STA_AUTHORIZED &&
5539 * Tdls station authorized.
5541 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5544 ret = ath10k_station_assoc(ar, vif, sta, false);
5546 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5547 sta->addr, arvif->vdev_id, ret);
5551 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5552 WMI_TDLS_PEER_STATE_CONNECTED);
5554 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5555 sta->addr, arvif->vdev_id, ret);
5556 } else if (old_state == IEEE80211_STA_ASSOC &&
5557 new_state == IEEE80211_STA_AUTH &&
5558 (vif->type == NL80211_IFTYPE_AP ||
5559 vif->type == NL80211_IFTYPE_MESH_POINT ||
5560 vif->type == NL80211_IFTYPE_ADHOC)) {
5564 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5567 ret = ath10k_station_disassoc(ar, vif, sta);
5569 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5570 sta->addr, arvif->vdev_id, ret);
5573 mutex_unlock(&ar->conf_mutex);
5577 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5578 u16 ac, bool enable)
5580 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5581 struct wmi_sta_uapsd_auto_trig_arg arg = {};
5582 u32 prio = 0, acc = 0;
5586 lockdep_assert_held(&ar->conf_mutex);
5588 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5592 case IEEE80211_AC_VO:
5593 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5594 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5598 case IEEE80211_AC_VI:
5599 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5600 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5604 case IEEE80211_AC_BE:
5605 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5606 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5610 case IEEE80211_AC_BK:
5611 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5612 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5619 arvif->u.sta.uapsd |= value;
5621 arvif->u.sta.uapsd &= ~value;
5623 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5624 WMI_STA_PS_PARAM_UAPSD,
5625 arvif->u.sta.uapsd);
5627 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5631 if (arvif->u.sta.uapsd)
5632 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5634 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5636 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5637 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5640 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5642 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5644 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5645 arvif->vdev_id, ret);
5649 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5651 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5652 arvif->vdev_id, ret);
5656 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5657 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5658 /* Only userspace can make an educated decision when to send
5659 * trigger frame. The following effectively disables u-UAPSD
5660 * autotrigger in firmware (which is enabled by default
5661 * provided the autotrigger service is available).
5665 arg.user_priority = prio;
5666 arg.service_interval = 0;
5667 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5668 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5670 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5671 arvif->bssid, &arg, 1);
5673 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5683 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5684 struct ieee80211_vif *vif, u16 ac,
5685 const struct ieee80211_tx_queue_params *params)
5687 struct ath10k *ar = hw->priv;
5688 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5689 struct wmi_wmm_params_arg *p = NULL;
5692 mutex_lock(&ar->conf_mutex);
5695 case IEEE80211_AC_VO:
5696 p = &arvif->wmm_params.ac_vo;
5698 case IEEE80211_AC_VI:
5699 p = &arvif->wmm_params.ac_vi;
5701 case IEEE80211_AC_BE:
5702 p = &arvif->wmm_params.ac_be;
5704 case IEEE80211_AC_BK:
5705 p = &arvif->wmm_params.ac_bk;
5714 p->cwmin = params->cw_min;
5715 p->cwmax = params->cw_max;
5716 p->aifs = params->aifs;
5719 * The channel time duration programmed in the HW is in absolute
5720 * microseconds, while mac80211 gives the txop in units of
5723 p->txop = params->txop * 32;
5725 if (ar->wmi.ops->gen_vdev_wmm_conf) {
5726 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5727 &arvif->wmm_params);
5729 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5730 arvif->vdev_id, ret);
5734 /* This won't work well with multi-interface cases but it's
5735 * better than nothing.
5737 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5739 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5744 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5746 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5749 mutex_unlock(&ar->conf_mutex);
5753 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5755 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5756 struct ieee80211_vif *vif,
5757 struct ieee80211_channel *chan,
5759 enum ieee80211_roc_type type)
5761 struct ath10k *ar = hw->priv;
5762 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5763 struct wmi_start_scan_arg arg;
5767 mutex_lock(&ar->conf_mutex);
5769 spin_lock_bh(&ar->data_lock);
5770 switch (ar->scan.state) {
5771 case ATH10K_SCAN_IDLE:
5772 reinit_completion(&ar->scan.started);
5773 reinit_completion(&ar->scan.completed);
5774 reinit_completion(&ar->scan.on_channel);
5775 ar->scan.state = ATH10K_SCAN_STARTING;
5776 ar->scan.is_roc = true;
5777 ar->scan.vdev_id = arvif->vdev_id;
5778 ar->scan.roc_freq = chan->center_freq;
5779 ar->scan.roc_notify = true;
5782 case ATH10K_SCAN_STARTING:
5783 case ATH10K_SCAN_RUNNING:
5784 case ATH10K_SCAN_ABORTING:
5788 spin_unlock_bh(&ar->data_lock);
5793 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5795 memset(&arg, 0, sizeof(arg));
5796 ath10k_wmi_start_scan_init(ar, &arg);
5797 arg.vdev_id = arvif->vdev_id;
5798 arg.scan_id = ATH10K_SCAN_ID;
5800 arg.channels[0] = chan->center_freq;
5801 arg.dwell_time_active = scan_time_msec;
5802 arg.dwell_time_passive = scan_time_msec;
5803 arg.max_scan_time = scan_time_msec;
5804 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5805 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5806 arg.burst_duration_ms = duration;
5808 ret = ath10k_start_scan(ar, &arg);
5810 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5811 spin_lock_bh(&ar->data_lock);
5812 ar->scan.state = ATH10K_SCAN_IDLE;
5813 spin_unlock_bh(&ar->data_lock);
5817 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5819 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5821 ret = ath10k_scan_stop(ar);
5823 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5829 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5830 msecs_to_jiffies(duration));
5834 mutex_unlock(&ar->conf_mutex);
5838 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5840 struct ath10k *ar = hw->priv;
5842 mutex_lock(&ar->conf_mutex);
5844 spin_lock_bh(&ar->data_lock);
5845 ar->scan.roc_notify = false;
5846 spin_unlock_bh(&ar->data_lock);
5848 ath10k_scan_abort(ar);
5850 mutex_unlock(&ar->conf_mutex);
5852 cancel_delayed_work_sync(&ar->scan.timeout);
5858 * Both RTS and Fragmentation threshold are interface-specific
5859 * in ath10k, but device-specific in mac80211.
5862 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5864 struct ath10k *ar = hw->priv;
5865 struct ath10k_vif *arvif;
5868 mutex_lock(&ar->conf_mutex);
5869 list_for_each_entry(arvif, &ar->arvifs, list) {
5870 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5871 arvif->vdev_id, value);
5873 ret = ath10k_mac_set_rts(arvif, value);
5875 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5876 arvif->vdev_id, ret);
5880 mutex_unlock(&ar->conf_mutex);
5885 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5887 /* Even though there's a WMI enum for fragmentation threshold no known
5888 * firmware actually implements it. Moreover it is not possible to rely
5889 * frame fragmentation to mac80211 because firmware clears the "more
5890 * fragments" bit in frame control making it impossible for remote
5891 * devices to reassemble frames.
5893 * Hence implement a dummy callback just to say fragmentation isn't
5894 * supported. This effectively prevents mac80211 from doing frame
5895 * fragmentation in software.
5900 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5901 u32 queues, bool drop)
5903 struct ath10k *ar = hw->priv;
5907 /* mac80211 doesn't care if we really xmit queued frames or not
5908 * we'll collect those frames either way if we stop/delete vdevs */
5912 mutex_lock(&ar->conf_mutex);
5914 if (ar->state == ATH10K_STATE_WEDGED)
5917 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5920 spin_lock_bh(&ar->htt.tx_lock);
5921 empty = (ar->htt.num_pending_tx == 0);
5922 spin_unlock_bh(&ar->htt.tx_lock);
5924 skip = (ar->state == ATH10K_STATE_WEDGED) ||
5925 test_bit(ATH10K_FLAG_CRASH_FLUSH,
5929 }), ATH10K_FLUSH_TIMEOUT_HZ);
5931 if (time_left == 0 || skip)
5932 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5933 skip, ar->state, time_left);
5936 mutex_unlock(&ar->conf_mutex);
5939 /* TODO: Implement this function properly
5940 * For now it is needed to reply to Probe Requests in IBSS mode.
5941 * Propably we need this information from FW.
5943 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5948 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5949 enum ieee80211_reconfig_type reconfig_type)
5951 struct ath10k *ar = hw->priv;
5953 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5956 mutex_lock(&ar->conf_mutex);
5958 /* If device failed to restart it will be in a different state, e.g.
5959 * ATH10K_STATE_WEDGED */
5960 if (ar->state == ATH10K_STATE_RESTARTED) {
5961 ath10k_info(ar, "device successfully recovered\n");
5962 ar->state = ATH10K_STATE_ON;
5963 ieee80211_wake_queues(ar->hw);
5966 mutex_unlock(&ar->conf_mutex);
5969 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5970 struct survey_info *survey)
5972 struct ath10k *ar = hw->priv;
5973 struct ieee80211_supported_band *sband;
5974 struct survey_info *ar_survey = &ar->survey[idx];
5977 mutex_lock(&ar->conf_mutex);
5979 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5980 if (sband && idx >= sband->n_channels) {
5981 idx -= sband->n_channels;
5986 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5988 if (!sband || idx >= sband->n_channels) {
5993 spin_lock_bh(&ar->data_lock);
5994 memcpy(survey, ar_survey, sizeof(*survey));
5995 spin_unlock_bh(&ar->data_lock);
5997 survey->channel = &sband->channels[idx];
5999 if (ar->rx_channel == survey->channel)
6000 survey->filled |= SURVEY_INFO_IN_USE;
6003 mutex_unlock(&ar->conf_mutex);
6008 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
6009 enum ieee80211_band band,
6010 const struct cfg80211_bitrate_mask *mask)
6015 num_rates += hweight32(mask->control[band].legacy);
6017 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6018 num_rates += hweight8(mask->control[band].ht_mcs[i]);
6020 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
6021 num_rates += hweight16(mask->control[band].vht_mcs[i]);
6023 return num_rates == 1;
6027 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
6028 enum ieee80211_band band,
6029 const struct cfg80211_bitrate_mask *mask,
6032 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6033 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
6035 u8 vht_nss_mask = 0;
6038 if (mask->control[band].legacy)
6041 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6042 if (mask->control[band].ht_mcs[i] == 0)
6044 else if (mask->control[band].ht_mcs[i] ==
6045 sband->ht_cap.mcs.rx_mask[i])
6046 ht_nss_mask |= BIT(i);
6051 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6052 if (mask->control[band].vht_mcs[i] == 0)
6054 else if (mask->control[band].vht_mcs[i] ==
6055 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
6056 vht_nss_mask |= BIT(i);
6061 if (ht_nss_mask != vht_nss_mask)
6064 if (ht_nss_mask == 0)
6067 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
6070 *nss = fls(ht_nss_mask);
6076 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6077 enum ieee80211_band band,
6078 const struct cfg80211_bitrate_mask *mask,
6081 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
6088 if (hweight32(mask->control[band].legacy) == 1) {
6089 rate_idx = ffs(mask->control[band].legacy) - 1;
6091 hw_rate = sband->bitrates[rate_idx].hw_value;
6092 bitrate = sband->bitrates[rate_idx].bitrate;
6094 if (ath10k_mac_bitrate_is_cck(bitrate))
6095 preamble = WMI_RATE_PREAMBLE_CCK;
6097 preamble = WMI_RATE_PREAMBLE_OFDM;
6100 *rate = preamble << 6 |
6107 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6108 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6110 *rate = WMI_RATE_PREAMBLE_HT << 6 |
6112 (ffs(mask->control[band].ht_mcs[i]) - 1);
6118 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6119 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6121 *rate = WMI_RATE_PREAMBLE_VHT << 6 |
6123 (ffs(mask->control[band].vht_mcs[i]) - 1);
6132 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
6133 u8 rate, u8 nss, u8 sgi, u8 ldpc)
6135 struct ath10k *ar = arvif->ar;
6139 lockdep_assert_held(&ar->conf_mutex);
6141 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6142 arvif->vdev_id, rate, nss, sgi);
6144 vdev_param = ar->wmi.vdev_param->fixed_rate;
6145 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
6147 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
6152 vdev_param = ar->wmi.vdev_param->nss;
6153 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
6155 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6159 vdev_param = ar->wmi.vdev_param->sgi;
6160 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6162 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6166 vdev_param = ar->wmi.vdev_param->ldpc;
6167 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6169 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6177 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6178 enum ieee80211_band band,
6179 const struct cfg80211_bitrate_mask *mask)
6184 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6185 * to express all VHT MCS rate masks. Effectively only the following
6186 * ranges can be used: none, 0-7, 0-8 and 0-9.
6188 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6189 vht_mcs = mask->control[band].vht_mcs[i];
6198 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6206 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6207 struct ieee80211_sta *sta)
6209 struct ath10k_vif *arvif = data;
6210 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6211 struct ath10k *ar = arvif->ar;
6213 if (arsta->arvif != arvif)
6216 spin_lock_bh(&ar->data_lock);
6217 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6218 spin_unlock_bh(&ar->data_lock);
6220 ieee80211_queue_work(ar->hw, &arsta->update_wk);
6223 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6224 struct ieee80211_vif *vif,
6225 const struct cfg80211_bitrate_mask *mask)
6227 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6228 struct cfg80211_chan_def def;
6229 struct ath10k *ar = arvif->ar;
6230 enum ieee80211_band band;
6231 const u8 *ht_mcs_mask;
6232 const u16 *vht_mcs_mask;
6240 if (ath10k_mac_vif_chan(vif, &def))
6243 band = def.chan->band;
6244 ht_mcs_mask = mask->control[band].ht_mcs;
6245 vht_mcs_mask = mask->control[band].vht_mcs;
6246 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6248 sgi = mask->control[band].gi;
6249 if (sgi == NL80211_TXRATE_FORCE_LGI)
6252 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6253 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6256 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6257 arvif->vdev_id, ret);
6260 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6262 rate = WMI_FIXED_RATE_NONE;
6265 rate = WMI_FIXED_RATE_NONE;
6266 nss = min(ar->num_rf_chains,
6267 max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6268 ath10k_mac_max_vht_nss(vht_mcs_mask)));
6270 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6273 mutex_lock(&ar->conf_mutex);
6275 arvif->bitrate_mask = *mask;
6276 ieee80211_iterate_stations_atomic(ar->hw,
6277 ath10k_mac_set_bitrate_mask_iter,
6280 mutex_unlock(&ar->conf_mutex);
6283 mutex_lock(&ar->conf_mutex);
6285 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6287 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6288 arvif->vdev_id, ret);
6293 mutex_unlock(&ar->conf_mutex);
6298 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6299 struct ieee80211_vif *vif,
6300 struct ieee80211_sta *sta,
6303 struct ath10k *ar = hw->priv;
6304 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6307 spin_lock_bh(&ar->data_lock);
6309 ath10k_dbg(ar, ATH10K_DBG_MAC,
6310 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6311 sta->addr, changed, sta->bandwidth, sta->rx_nss,
6314 if (changed & IEEE80211_RC_BW_CHANGED) {
6315 bw = WMI_PEER_CHWIDTH_20MHZ;
6317 switch (sta->bandwidth) {
6318 case IEEE80211_STA_RX_BW_20:
6319 bw = WMI_PEER_CHWIDTH_20MHZ;
6321 case IEEE80211_STA_RX_BW_40:
6322 bw = WMI_PEER_CHWIDTH_40MHZ;
6324 case IEEE80211_STA_RX_BW_80:
6325 bw = WMI_PEER_CHWIDTH_80MHZ;
6327 case IEEE80211_STA_RX_BW_160:
6328 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6329 sta->bandwidth, sta->addr);
6330 bw = WMI_PEER_CHWIDTH_20MHZ;
6337 if (changed & IEEE80211_RC_NSS_CHANGED)
6338 arsta->nss = sta->rx_nss;
6340 if (changed & IEEE80211_RC_SMPS_CHANGED) {
6341 smps = WMI_PEER_SMPS_PS_NONE;
6343 switch (sta->smps_mode) {
6344 case IEEE80211_SMPS_AUTOMATIC:
6345 case IEEE80211_SMPS_OFF:
6346 smps = WMI_PEER_SMPS_PS_NONE;
6348 case IEEE80211_SMPS_STATIC:
6349 smps = WMI_PEER_SMPS_STATIC;
6351 case IEEE80211_SMPS_DYNAMIC:
6352 smps = WMI_PEER_SMPS_DYNAMIC;
6354 case IEEE80211_SMPS_NUM_MODES:
6355 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6356 sta->smps_mode, sta->addr);
6357 smps = WMI_PEER_SMPS_PS_NONE;
6364 arsta->changed |= changed;
6366 spin_unlock_bh(&ar->data_lock);
6368 ieee80211_queue_work(hw, &arsta->update_wk);
6371 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6374 * FIXME: Return 0 for time being. Need to figure out whether FW
6375 * has the API to fetch 64-bit local TSF
6381 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6382 struct ieee80211_vif *vif,
6383 enum ieee80211_ampdu_mlme_action action,
6384 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
6385 u8 buf_size, bool amsdu)
6387 struct ath10k *ar = hw->priv;
6388 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6390 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6391 arvif->vdev_id, sta->addr, tid, action);
6394 case IEEE80211_AMPDU_RX_START:
6395 case IEEE80211_AMPDU_RX_STOP:
6396 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6397 * creation/removal. Do we need to verify this?
6400 case IEEE80211_AMPDU_TX_START:
6401 case IEEE80211_AMPDU_TX_STOP_CONT:
6402 case IEEE80211_AMPDU_TX_STOP_FLUSH:
6403 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6404 case IEEE80211_AMPDU_TX_OPERATIONAL:
6405 /* Firmware offloads Tx aggregation entirely so deny mac80211
6406 * Tx aggregation requests.
6415 ath10k_mac_update_rx_channel(struct ath10k *ar,
6416 struct ieee80211_chanctx_conf *ctx,
6417 struct ieee80211_vif_chanctx_switch *vifs,
6420 struct cfg80211_chan_def *def = NULL;
6422 /* Both locks are required because ar->rx_channel is modified. This
6423 * allows readers to hold either lock.
6425 lockdep_assert_held(&ar->conf_mutex);
6426 lockdep_assert_held(&ar->data_lock);
6428 WARN_ON(ctx && vifs);
6429 WARN_ON(vifs && n_vifs != 1);
6431 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6432 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6433 * ppdu on Rx may reduce performance on low-end systems. It should be
6434 * possible to make tables/hashmaps to speed the lookup up (be vary of
6435 * cpu data cache lines though regarding sizes) but to keep the initial
6436 * implementation simple and less intrusive fallback to the slow lookup
6437 * only for multi-channel cases. Single-channel cases will remain to
6438 * use the old channel derival and thus performance should not be
6442 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6443 ieee80211_iter_chan_contexts_atomic(ar->hw,
6444 ath10k_mac_get_any_chandef_iter,
6448 def = &vifs[0].new_ctx->def;
6450 ar->rx_channel = def->chan;
6451 } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6452 ar->rx_channel = ctx->def.chan;
6454 ar->rx_channel = NULL;
6460 ath10k_mac_update_vif_chan(struct ath10k *ar,
6461 struct ieee80211_vif_chanctx_switch *vifs,
6464 struct ath10k_vif *arvif;
6468 lockdep_assert_held(&ar->conf_mutex);
6470 /* First stop monitor interface. Some FW versions crash if there's a
6471 * lone monitor interface.
6473 if (ar->monitor_started)
6474 ath10k_monitor_stop(ar);
6476 for (i = 0; i < n_vifs; i++) {
6477 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6479 ath10k_dbg(ar, ATH10K_DBG_MAC,
6480 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6482 vifs[i].old_ctx->def.chan->center_freq,
6483 vifs[i].new_ctx->def.chan->center_freq,
6484 vifs[i].old_ctx->def.width,
6485 vifs[i].new_ctx->def.width);
6487 if (WARN_ON(!arvif->is_started))
6490 if (WARN_ON(!arvif->is_up))
6493 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6495 ath10k_warn(ar, "failed to down vdev %d: %d\n",
6496 arvif->vdev_id, ret);
6501 /* All relevant vdevs are downed and associated channel resources
6502 * should be available for the channel switch now.
6505 spin_lock_bh(&ar->data_lock);
6506 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6507 spin_unlock_bh(&ar->data_lock);
6509 for (i = 0; i < n_vifs; i++) {
6510 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6512 if (WARN_ON(!arvif->is_started))
6515 if (WARN_ON(!arvif->is_up))
6518 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6520 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6523 ret = ath10k_mac_setup_prb_tmpl(arvif);
6525 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6528 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6530 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6531 arvif->vdev_id, ret);
6535 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6538 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6539 arvif->vdev_id, ret);
6544 ath10k_monitor_recalc(ar);
6548 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6549 struct ieee80211_chanctx_conf *ctx)
6551 struct ath10k *ar = hw->priv;
6553 ath10k_dbg(ar, ATH10K_DBG_MAC,
6554 "mac chanctx add freq %hu width %d ptr %p\n",
6555 ctx->def.chan->center_freq, ctx->def.width, ctx);
6557 mutex_lock(&ar->conf_mutex);
6559 spin_lock_bh(&ar->data_lock);
6560 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6561 spin_unlock_bh(&ar->data_lock);
6563 ath10k_recalc_radar_detection(ar);
6564 ath10k_monitor_recalc(ar);
6566 mutex_unlock(&ar->conf_mutex);
6572 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6573 struct ieee80211_chanctx_conf *ctx)
6575 struct ath10k *ar = hw->priv;
6577 ath10k_dbg(ar, ATH10K_DBG_MAC,
6578 "mac chanctx remove freq %hu width %d ptr %p\n",
6579 ctx->def.chan->center_freq, ctx->def.width, ctx);
6581 mutex_lock(&ar->conf_mutex);
6583 spin_lock_bh(&ar->data_lock);
6584 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6585 spin_unlock_bh(&ar->data_lock);
6587 ath10k_recalc_radar_detection(ar);
6588 ath10k_monitor_recalc(ar);
6590 mutex_unlock(&ar->conf_mutex);
6593 struct ath10k_mac_change_chanctx_arg {
6594 struct ieee80211_chanctx_conf *ctx;
6595 struct ieee80211_vif_chanctx_switch *vifs;
6601 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6602 struct ieee80211_vif *vif)
6604 struct ath10k_mac_change_chanctx_arg *arg = data;
6606 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6613 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6614 struct ieee80211_vif *vif)
6616 struct ath10k_mac_change_chanctx_arg *arg = data;
6617 struct ieee80211_chanctx_conf *ctx;
6619 ctx = rcu_access_pointer(vif->chanctx_conf);
6620 if (ctx != arg->ctx)
6623 if (WARN_ON(arg->next_vif == arg->n_vifs))
6626 arg->vifs[arg->next_vif].vif = vif;
6627 arg->vifs[arg->next_vif].old_ctx = ctx;
6628 arg->vifs[arg->next_vif].new_ctx = ctx;
6633 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6634 struct ieee80211_chanctx_conf *ctx,
6637 struct ath10k *ar = hw->priv;
6638 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
6640 mutex_lock(&ar->conf_mutex);
6642 ath10k_dbg(ar, ATH10K_DBG_MAC,
6643 "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6644 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6646 /* This shouldn't really happen because channel switching should use
6647 * switch_vif_chanctx().
6649 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6652 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
6653 ieee80211_iterate_active_interfaces_atomic(
6655 IEEE80211_IFACE_ITER_NORMAL,
6656 ath10k_mac_change_chanctx_cnt_iter,
6658 if (arg.n_vifs == 0)
6661 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
6666 ieee80211_iterate_active_interfaces_atomic(
6668 IEEE80211_IFACE_ITER_NORMAL,
6669 ath10k_mac_change_chanctx_fill_iter,
6671 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6676 ath10k_recalc_radar_detection(ar);
6678 /* FIXME: How to configure Rx chains properly? */
6680 /* No other actions are actually necessary. Firmware maintains channel
6681 * definitions per vdev internally and there's no host-side channel
6682 * context abstraction to configure, e.g. channel width.
6686 mutex_unlock(&ar->conf_mutex);
6690 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6691 struct ieee80211_vif *vif,
6692 struct ieee80211_chanctx_conf *ctx)
6694 struct ath10k *ar = hw->priv;
6695 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6698 mutex_lock(&ar->conf_mutex);
6700 ath10k_dbg(ar, ATH10K_DBG_MAC,
6701 "mac chanctx assign ptr %p vdev_id %i\n",
6702 ctx, arvif->vdev_id);
6704 if (WARN_ON(arvif->is_started)) {
6705 mutex_unlock(&ar->conf_mutex);
6709 ret = ath10k_vdev_start(arvif, &ctx->def);
6711 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6712 arvif->vdev_id, vif->addr,
6713 ctx->def.chan->center_freq, ret);
6717 arvif->is_started = true;
6719 ret = ath10k_mac_vif_setup_ps(arvif);
6721 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6722 arvif->vdev_id, ret);
6726 if (vif->type == NL80211_IFTYPE_MONITOR) {
6727 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6729 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6730 arvif->vdev_id, ret);
6734 arvif->is_up = true;
6737 mutex_unlock(&ar->conf_mutex);
6741 ath10k_vdev_stop(arvif);
6742 arvif->is_started = false;
6743 ath10k_mac_vif_setup_ps(arvif);
6746 mutex_unlock(&ar->conf_mutex);
6751 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6752 struct ieee80211_vif *vif,
6753 struct ieee80211_chanctx_conf *ctx)
6755 struct ath10k *ar = hw->priv;
6756 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6759 mutex_lock(&ar->conf_mutex);
6761 ath10k_dbg(ar, ATH10K_DBG_MAC,
6762 "mac chanctx unassign ptr %p vdev_id %i\n",
6763 ctx, arvif->vdev_id);
6765 WARN_ON(!arvif->is_started);
6767 if (vif->type == NL80211_IFTYPE_MONITOR) {
6768 WARN_ON(!arvif->is_up);
6770 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6772 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6773 arvif->vdev_id, ret);
6775 arvif->is_up = false;
6778 ret = ath10k_vdev_stop(arvif);
6780 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6781 arvif->vdev_id, ret);
6783 arvif->is_started = false;
6785 mutex_unlock(&ar->conf_mutex);
6789 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6790 struct ieee80211_vif_chanctx_switch *vifs,
6792 enum ieee80211_chanctx_switch_mode mode)
6794 struct ath10k *ar = hw->priv;
6796 mutex_lock(&ar->conf_mutex);
6798 ath10k_dbg(ar, ATH10K_DBG_MAC,
6799 "mac chanctx switch n_vifs %d mode %d\n",
6801 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
6803 mutex_unlock(&ar->conf_mutex);
6807 static const struct ieee80211_ops ath10k_ops = {
6809 .start = ath10k_start,
6810 .stop = ath10k_stop,
6811 .config = ath10k_config,
6812 .add_interface = ath10k_add_interface,
6813 .remove_interface = ath10k_remove_interface,
6814 .configure_filter = ath10k_configure_filter,
6815 .bss_info_changed = ath10k_bss_info_changed,
6816 .hw_scan = ath10k_hw_scan,
6817 .cancel_hw_scan = ath10k_cancel_hw_scan,
6818 .set_key = ath10k_set_key,
6819 .set_default_unicast_key = ath10k_set_default_unicast_key,
6820 .sta_state = ath10k_sta_state,
6821 .conf_tx = ath10k_conf_tx,
6822 .remain_on_channel = ath10k_remain_on_channel,
6823 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
6824 .set_rts_threshold = ath10k_set_rts_threshold,
6825 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,
6826 .flush = ath10k_flush,
6827 .tx_last_beacon = ath10k_tx_last_beacon,
6828 .set_antenna = ath10k_set_antenna,
6829 .get_antenna = ath10k_get_antenna,
6830 .reconfig_complete = ath10k_reconfig_complete,
6831 .get_survey = ath10k_get_survey,
6832 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,
6833 .sta_rc_update = ath10k_sta_rc_update,
6834 .get_tsf = ath10k_get_tsf,
6835 .ampdu_action = ath10k_ampdu_action,
6836 .get_et_sset_count = ath10k_debug_get_et_sset_count,
6837 .get_et_stats = ath10k_debug_get_et_stats,
6838 .get_et_strings = ath10k_debug_get_et_strings,
6839 .add_chanctx = ath10k_mac_op_add_chanctx,
6840 .remove_chanctx = ath10k_mac_op_remove_chanctx,
6841 .change_chanctx = ath10k_mac_op_change_chanctx,
6842 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,
6843 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,
6844 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,
6846 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6849 .suspend = ath10k_wow_op_suspend,
6850 .resume = ath10k_wow_op_resume,
6852 #ifdef CONFIG_MAC80211_DEBUGFS
6853 .sta_add_debugfs = ath10k_sta_add_debugfs,
6857 #define CHAN2G(_channel, _freq, _flags) { \
6858 .band = IEEE80211_BAND_2GHZ, \
6859 .hw_value = (_channel), \
6860 .center_freq = (_freq), \
6861 .flags = (_flags), \
6862 .max_antenna_gain = 0, \
6866 #define CHAN5G(_channel, _freq, _flags) { \
6867 .band = IEEE80211_BAND_5GHZ, \
6868 .hw_value = (_channel), \
6869 .center_freq = (_freq), \
6870 .flags = (_flags), \
6871 .max_antenna_gain = 0, \
6875 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6885 CHAN2G(10, 2457, 0),
6886 CHAN2G(11, 2462, 0),
6887 CHAN2G(12, 2467, 0),
6888 CHAN2G(13, 2472, 0),
6889 CHAN2G(14, 2484, 0),
6892 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6893 CHAN5G(36, 5180, 0),
6894 CHAN5G(40, 5200, 0),
6895 CHAN5G(44, 5220, 0),
6896 CHAN5G(48, 5240, 0),
6897 CHAN5G(52, 5260, 0),
6898 CHAN5G(56, 5280, 0),
6899 CHAN5G(60, 5300, 0),
6900 CHAN5G(64, 5320, 0),
6901 CHAN5G(100, 5500, 0),
6902 CHAN5G(104, 5520, 0),
6903 CHAN5G(108, 5540, 0),
6904 CHAN5G(112, 5560, 0),
6905 CHAN5G(116, 5580, 0),
6906 CHAN5G(120, 5600, 0),
6907 CHAN5G(124, 5620, 0),
6908 CHAN5G(128, 5640, 0),
6909 CHAN5G(132, 5660, 0),
6910 CHAN5G(136, 5680, 0),
6911 CHAN5G(140, 5700, 0),
6912 CHAN5G(144, 5720, 0),
6913 CHAN5G(149, 5745, 0),
6914 CHAN5G(153, 5765, 0),
6915 CHAN5G(157, 5785, 0),
6916 CHAN5G(161, 5805, 0),
6917 CHAN5G(165, 5825, 0),
6920 struct ath10k *ath10k_mac_create(size_t priv_size)
6922 struct ieee80211_hw *hw;
6925 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6935 void ath10k_mac_destroy(struct ath10k *ar)
6937 ieee80211_free_hw(ar->hw);
6940 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6943 .types = BIT(NL80211_IFTYPE_STATION)
6944 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6948 .types = BIT(NL80211_IFTYPE_P2P_GO)
6952 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
6956 .types = BIT(NL80211_IFTYPE_AP)
6957 #ifdef CONFIG_MAC80211_MESH
6958 | BIT(NL80211_IFTYPE_MESH_POINT)
6963 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6966 .types = BIT(NL80211_IFTYPE_AP)
6967 #ifdef CONFIG_MAC80211_MESH
6968 | BIT(NL80211_IFTYPE_MESH_POINT)
6973 .types = BIT(NL80211_IFTYPE_STATION)
6977 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6979 .limits = ath10k_if_limits,
6980 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6981 .max_interfaces = 8,
6982 .num_different_channels = 1,
6983 .beacon_int_infra_match = true,
6987 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6989 .limits = ath10k_10x_if_limits,
6990 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6991 .max_interfaces = 8,
6992 .num_different_channels = 1,
6993 .beacon_int_infra_match = true,
6994 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6995 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6996 BIT(NL80211_CHAN_WIDTH_20) |
6997 BIT(NL80211_CHAN_WIDTH_40) |
6998 BIT(NL80211_CHAN_WIDTH_80),
7003 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
7006 .types = BIT(NL80211_IFTYPE_STATION),
7010 .types = BIT(NL80211_IFTYPE_AP) |
7011 #ifdef CONFIG_MAC80211_MESH
7012 BIT(NL80211_IFTYPE_MESH_POINT) |
7014 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7015 BIT(NL80211_IFTYPE_P2P_GO),
7019 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7023 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
7026 .types = BIT(NL80211_IFTYPE_STATION),
7030 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
7034 .types = BIT(NL80211_IFTYPE_AP) |
7035 #ifdef CONFIG_MAC80211_MESH
7036 BIT(NL80211_IFTYPE_MESH_POINT) |
7038 BIT(NL80211_IFTYPE_P2P_GO),
7042 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
7046 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
7049 .types = BIT(NL80211_IFTYPE_STATION),
7053 .types = BIT(NL80211_IFTYPE_ADHOC),
7057 /* FIXME: This is not thouroughly tested. These combinations may over- or
7058 * underestimate hw/fw capabilities.
7060 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
7062 .limits = ath10k_tlv_if_limit,
7063 .num_different_channels = 1,
7064 .max_interfaces = 4,
7065 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7068 .limits = ath10k_tlv_if_limit_ibss,
7069 .num_different_channels = 1,
7070 .max_interfaces = 2,
7071 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7075 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
7077 .limits = ath10k_tlv_if_limit,
7078 .num_different_channels = 1,
7079 .max_interfaces = 4,
7080 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
7083 .limits = ath10k_tlv_qcs_if_limit,
7084 .num_different_channels = 2,
7085 .max_interfaces = 4,
7086 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
7089 .limits = ath10k_tlv_if_limit_ibss,
7090 .num_different_channels = 1,
7091 .max_interfaces = 2,
7092 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
7096 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
7099 .types = BIT(NL80211_IFTYPE_STATION),
7103 .types = BIT(NL80211_IFTYPE_AP)
7104 #ifdef CONFIG_MAC80211_MESH
7105 | BIT(NL80211_IFTYPE_MESH_POINT)
7110 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
7112 .limits = ath10k_10_4_if_limits,
7113 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
7114 .max_interfaces = 16,
7115 .num_different_channels = 1,
7116 .beacon_int_infra_match = true,
7117 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7118 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
7119 BIT(NL80211_CHAN_WIDTH_20) |
7120 BIT(NL80211_CHAN_WIDTH_40) |
7121 BIT(NL80211_CHAN_WIDTH_80),
7126 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7127 struct ieee80211_vif *vif)
7129 struct ath10k_vif_iter *arvif_iter = data;
7130 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7132 if (arvif->vdev_id == arvif_iter->vdev_id)
7133 arvif_iter->arvif = arvif;
7136 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7138 struct ath10k_vif_iter arvif_iter;
7141 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7142 arvif_iter.vdev_id = vdev_id;
7144 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7145 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7147 ath10k_get_arvif_iter,
7149 if (!arvif_iter.arvif) {
7150 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7154 return arvif_iter.arvif;
7157 int ath10k_mac_register(struct ath10k *ar)
7159 static const u32 cipher_suites[] = {
7160 WLAN_CIPHER_SUITE_WEP40,
7161 WLAN_CIPHER_SUITE_WEP104,
7162 WLAN_CIPHER_SUITE_TKIP,
7163 WLAN_CIPHER_SUITE_CCMP,
7164 WLAN_CIPHER_SUITE_AES_CMAC,
7166 struct ieee80211_supported_band *band;
7170 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7172 SET_IEEE80211_DEV(ar->hw, ar->dev);
7174 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7175 ARRAY_SIZE(ath10k_5ghz_channels)) !=
7178 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7179 channels = kmemdup(ath10k_2ghz_channels,
7180 sizeof(ath10k_2ghz_channels),
7187 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7188 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7189 band->channels = channels;
7190 band->n_bitrates = ath10k_g_rates_size;
7191 band->bitrates = ath10k_g_rates;
7193 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7196 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7197 channels = kmemdup(ath10k_5ghz_channels,
7198 sizeof(ath10k_5ghz_channels),
7205 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7206 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7207 band->channels = channels;
7208 band->n_bitrates = ath10k_a_rates_size;
7209 band->bitrates = ath10k_a_rates;
7210 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7213 ath10k_mac_setup_ht_vht_cap(ar);
7215 ar->hw->wiphy->interface_modes =
7216 BIT(NL80211_IFTYPE_STATION) |
7217 BIT(NL80211_IFTYPE_AP) |
7218 BIT(NL80211_IFTYPE_MESH_POINT);
7220 ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
7221 ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
7223 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7224 ar->hw->wiphy->interface_modes |=
7225 BIT(NL80211_IFTYPE_P2P_DEVICE) |
7226 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7227 BIT(NL80211_IFTYPE_P2P_GO);
7229 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7230 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7231 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7232 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7233 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7234 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7235 ieee80211_hw_set(ar->hw, AP_LINK_PS);
7236 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7237 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7238 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7239 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7240 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7241 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7242 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7244 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7245 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7247 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7248 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7250 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7251 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7253 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7254 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7255 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7258 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7259 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7261 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7262 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7264 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7266 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7267 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7269 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7270 * that userspace (e.g. wpa_supplicant/hostapd) can generate
7271 * correct Probe Responses. This is more of a hack advert..
7273 ar->hw->wiphy->probe_resp_offload |=
7274 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7275 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7276 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7279 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7280 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7282 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7283 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7284 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7286 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7287 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7289 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7291 ret = ath10k_wow_init(ar);
7293 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7297 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7300 * on LL hardware queues are managed entirely by the FW
7301 * so we only advertise to mac we can do the queues thing
7303 ar->hw->queues = IEEE80211_MAX_QUEUES;
7305 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7306 * something that vdev_ids can't reach so that we don't stop the queue
7309 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7311 switch (ar->wmi.op_version) {
7312 case ATH10K_FW_WMI_OP_VERSION_MAIN:
7313 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7314 ar->hw->wiphy->n_iface_combinations =
7315 ARRAY_SIZE(ath10k_if_comb);
7316 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7318 case ATH10K_FW_WMI_OP_VERSION_TLV:
7319 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7320 ar->hw->wiphy->iface_combinations =
7321 ath10k_tlv_qcs_if_comb;
7322 ar->hw->wiphy->n_iface_combinations =
7323 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7325 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7326 ar->hw->wiphy->n_iface_combinations =
7327 ARRAY_SIZE(ath10k_tlv_if_comb);
7329 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7331 case ATH10K_FW_WMI_OP_VERSION_10_1:
7332 case ATH10K_FW_WMI_OP_VERSION_10_2:
7333 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7334 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7335 ar->hw->wiphy->n_iface_combinations =
7336 ARRAY_SIZE(ath10k_10x_if_comb);
7338 case ATH10K_FW_WMI_OP_VERSION_10_4:
7339 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7340 ar->hw->wiphy->n_iface_combinations =
7341 ARRAY_SIZE(ath10k_10_4_if_comb);
7343 case ATH10K_FW_WMI_OP_VERSION_UNSET:
7344 case ATH10K_FW_WMI_OP_VERSION_MAX:
7350 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7351 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7353 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7354 /* Init ath dfs pattern detector */
7355 ar->ath_common.debug_mask = ATH_DBG_DFS;
7356 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7359 if (!ar->dfs_detector)
7360 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7363 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7364 ath10k_reg_notifier);
7366 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7367 goto err_dfs_detector_exit;
7370 ar->hw->wiphy->cipher_suites = cipher_suites;
7371 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7373 ret = ieee80211_register_hw(ar->hw);
7375 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7376 goto err_dfs_detector_exit;
7379 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7380 ret = regulatory_hint(ar->hw->wiphy,
7381 ar->ath_common.regulatory.alpha2);
7383 goto err_unregister;
7389 ieee80211_unregister_hw(ar->hw);
7391 err_dfs_detector_exit:
7392 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7393 ar->dfs_detector->exit(ar->dfs_detector);
7396 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7397 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7399 SET_IEEE80211_DEV(ar->hw, NULL);
7403 void ath10k_mac_unregister(struct ath10k *ar)
7405 ieee80211_unregister_hw(ar->hw);
7407 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7408 ar->dfs_detector->exit(ar->dfs_detector);
7410 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7411 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7413 SET_IEEE80211_DEV(ar->hw, NULL);