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 (rate->hw_value == hw_rate)
103 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
104 rate->hw_value_short == hw_rate)
111 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
116 for (i = 0; i < sband->n_bitrates; i++)
117 if (sband->bitrates[i].bitrate == bitrate)
123 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
125 switch ((mcs_map >> (2 * nss)) & 0x3) {
126 case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
127 case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
128 case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
134 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
138 for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
139 if (ht_mcs_mask[nss])
146 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
150 for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
151 if (vht_mcs_mask[nss])
161 static int ath10k_send_key(struct ath10k_vif *arvif,
162 struct ieee80211_key_conf *key,
163 enum set_key_cmd cmd,
164 const u8 *macaddr, u32 flags)
166 struct ath10k *ar = arvif->ar;
167 struct wmi_vdev_install_key_arg arg = {
168 .vdev_id = arvif->vdev_id,
169 .key_idx = key->keyidx,
170 .key_len = key->keylen,
171 .key_data = key->key,
176 lockdep_assert_held(&arvif->ar->conf_mutex);
178 switch (key->cipher) {
179 case WLAN_CIPHER_SUITE_CCMP:
180 arg.key_cipher = WMI_CIPHER_AES_CCM;
181 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
183 case WLAN_CIPHER_SUITE_TKIP:
184 arg.key_cipher = WMI_CIPHER_TKIP;
185 arg.key_txmic_len = 8;
186 arg.key_rxmic_len = 8;
188 case WLAN_CIPHER_SUITE_WEP40:
189 case WLAN_CIPHER_SUITE_WEP104:
190 arg.key_cipher = WMI_CIPHER_WEP;
192 case WLAN_CIPHER_SUITE_AES_CMAC:
196 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
200 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
201 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
203 if (cmd == DISABLE_KEY) {
204 arg.key_cipher = WMI_CIPHER_NONE;
208 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
211 static int ath10k_install_key(struct ath10k_vif *arvif,
212 struct ieee80211_key_conf *key,
213 enum set_key_cmd cmd,
214 const u8 *macaddr, u32 flags)
216 struct ath10k *ar = arvif->ar;
218 unsigned long time_left;
220 lockdep_assert_held(&ar->conf_mutex);
222 reinit_completion(&ar->install_key_done);
224 if (arvif->nohwcrypt)
227 ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
231 time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
238 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
241 struct ath10k *ar = arvif->ar;
242 struct ath10k_peer *peer;
247 lockdep_assert_held(&ar->conf_mutex);
249 if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&
250 arvif->vif->type != NL80211_IFTYPE_ADHOC))
253 spin_lock_bh(&ar->data_lock);
254 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
255 spin_unlock_bh(&ar->data_lock);
260 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
261 if (arvif->wep_keys[i] == NULL)
264 switch (arvif->vif->type) {
265 case NL80211_IFTYPE_AP:
266 flags = WMI_KEY_PAIRWISE;
268 if (arvif->def_wep_key_idx == i)
269 flags |= WMI_KEY_TX_USAGE;
271 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
272 SET_KEY, addr, flags);
276 case NL80211_IFTYPE_ADHOC:
277 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
283 ret = ath10k_install_key(arvif, arvif->wep_keys[i],
284 SET_KEY, addr, WMI_KEY_GROUP);
293 spin_lock_bh(&ar->data_lock);
294 peer->keys[i] = arvif->wep_keys[i];
295 spin_unlock_bh(&ar->data_lock);
298 /* In some cases (notably with static WEP IBSS with multiple keys)
299 * multicast Tx becomes broken. Both pairwise and groupwise keys are
300 * installed already. Using WMI_KEY_TX_USAGE in different combinations
301 * didn't seem help. Using def_keyid vdev parameter seems to be
302 * effective so use that.
304 * FIXME: Revisit. Perhaps this can be done in a less hacky way.
306 if (arvif->vif->type != NL80211_IFTYPE_ADHOC)
309 if (arvif->def_wep_key_idx == -1)
312 ret = ath10k_wmi_vdev_set_param(arvif->ar,
314 arvif->ar->wmi.vdev_param->def_keyid,
315 arvif->def_wep_key_idx);
317 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
318 arvif->vdev_id, ret);
325 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
328 struct ath10k *ar = arvif->ar;
329 struct ath10k_peer *peer;
335 lockdep_assert_held(&ar->conf_mutex);
337 spin_lock_bh(&ar->data_lock);
338 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
339 spin_unlock_bh(&ar->data_lock);
344 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
345 if (peer->keys[i] == NULL)
348 /* key flags are not required to delete the key */
349 ret = ath10k_install_key(arvif, peer->keys[i],
350 DISABLE_KEY, addr, flags);
351 if (ret < 0 && first_errno == 0)
355 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
358 spin_lock_bh(&ar->data_lock);
359 peer->keys[i] = NULL;
360 spin_unlock_bh(&ar->data_lock);
366 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
369 struct ath10k_peer *peer;
372 lockdep_assert_held(&ar->data_lock);
374 /* We don't know which vdev this peer belongs to,
375 * since WMI doesn't give us that information.
377 * FIXME: multi-bss needs to be handled.
379 peer = ath10k_peer_find(ar, 0, addr);
383 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
384 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
391 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
392 struct ieee80211_key_conf *key)
394 struct ath10k *ar = arvif->ar;
395 struct ath10k_peer *peer;
402 lockdep_assert_held(&ar->conf_mutex);
405 /* since ath10k_install_key we can't hold data_lock all the
406 * time, so we try to remove the keys incrementally */
407 spin_lock_bh(&ar->data_lock);
409 list_for_each_entry(peer, &ar->peers, list) {
410 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
411 if (peer->keys[i] == key) {
412 ether_addr_copy(addr, peer->addr);
413 peer->keys[i] = NULL;
418 if (i < ARRAY_SIZE(peer->keys))
421 spin_unlock_bh(&ar->data_lock);
423 if (i == ARRAY_SIZE(peer->keys))
425 /* key flags are not required to delete the key */
426 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
427 if (ret < 0 && first_errno == 0)
431 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
438 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
439 struct ieee80211_key_conf *key)
441 struct ath10k *ar = arvif->ar;
442 struct ath10k_peer *peer;
445 lockdep_assert_held(&ar->conf_mutex);
447 list_for_each_entry(peer, &ar->peers, list) {
448 if (!memcmp(peer->addr, arvif->vif->addr, ETH_ALEN))
451 if (!memcmp(peer->addr, arvif->bssid, ETH_ALEN))
454 if (peer->keys[key->keyidx] == key)
457 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
458 arvif->vdev_id, key->keyidx);
460 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
462 ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
463 arvif->vdev_id, peer->addr, ret);
471 /*********************/
472 /* General utilities */
473 /*********************/
475 static inline enum wmi_phy_mode
476 chan_to_phymode(const struct cfg80211_chan_def *chandef)
478 enum wmi_phy_mode phymode = MODE_UNKNOWN;
480 switch (chandef->chan->band) {
481 case IEEE80211_BAND_2GHZ:
482 switch (chandef->width) {
483 case NL80211_CHAN_WIDTH_20_NOHT:
484 if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
489 case NL80211_CHAN_WIDTH_20:
490 phymode = MODE_11NG_HT20;
492 case NL80211_CHAN_WIDTH_40:
493 phymode = MODE_11NG_HT40;
495 case NL80211_CHAN_WIDTH_5:
496 case NL80211_CHAN_WIDTH_10:
497 case NL80211_CHAN_WIDTH_80:
498 case NL80211_CHAN_WIDTH_80P80:
499 case NL80211_CHAN_WIDTH_160:
500 phymode = MODE_UNKNOWN;
504 case IEEE80211_BAND_5GHZ:
505 switch (chandef->width) {
506 case NL80211_CHAN_WIDTH_20_NOHT:
509 case NL80211_CHAN_WIDTH_20:
510 phymode = MODE_11NA_HT20;
512 case NL80211_CHAN_WIDTH_40:
513 phymode = MODE_11NA_HT40;
515 case NL80211_CHAN_WIDTH_80:
516 phymode = MODE_11AC_VHT80;
518 case NL80211_CHAN_WIDTH_5:
519 case NL80211_CHAN_WIDTH_10:
520 case NL80211_CHAN_WIDTH_80P80:
521 case NL80211_CHAN_WIDTH_160:
522 phymode = MODE_UNKNOWN;
530 WARN_ON(phymode == MODE_UNKNOWN);
534 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
537 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
538 * 0 for no restriction
547 switch (mpdudensity) {
553 /* Our lower layer calculations limit our precision to
569 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
570 struct cfg80211_chan_def *def)
572 struct ieee80211_chanctx_conf *conf;
575 conf = rcu_dereference(vif->chanctx_conf);
587 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
588 struct ieee80211_chanctx_conf *conf,
596 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
600 ieee80211_iter_chan_contexts_atomic(ar->hw,
601 ath10k_mac_num_chanctxs_iter,
608 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
609 struct ieee80211_chanctx_conf *conf,
612 struct cfg80211_chan_def **def = data;
617 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
618 enum wmi_peer_type peer_type)
620 struct ath10k_vif *arvif;
624 lockdep_assert_held(&ar->conf_mutex);
626 num_peers = ar->num_peers;
628 /* Each vdev consumes a peer entry as well */
629 list_for_each_entry(arvif, &ar->arvifs, list)
632 if (num_peers >= ar->max_num_peers)
635 ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
637 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
642 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
644 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
654 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
656 struct ath10k *ar = arvif->ar;
660 param = ar->wmi.pdev_param->sta_kickout_th;
661 ret = ath10k_wmi_pdev_set_param(ar, param,
662 ATH10K_KICKOUT_THRESHOLD);
664 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
665 arvif->vdev_id, ret);
669 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
670 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
671 ATH10K_KEEPALIVE_MIN_IDLE);
673 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
674 arvif->vdev_id, ret);
678 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
679 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
680 ATH10K_KEEPALIVE_MAX_IDLE);
682 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
683 arvif->vdev_id, ret);
687 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
688 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
689 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
691 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
692 arvif->vdev_id, ret);
699 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
701 struct ath10k *ar = arvif->ar;
704 vdev_param = ar->wmi.vdev_param->rts_threshold;
705 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
708 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
712 lockdep_assert_held(&ar->conf_mutex);
714 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
718 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
727 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
729 struct ath10k_peer *peer, *tmp;
731 lockdep_assert_held(&ar->conf_mutex);
733 spin_lock_bh(&ar->data_lock);
734 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
735 if (peer->vdev_id != vdev_id)
738 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
739 peer->addr, vdev_id);
741 list_del(&peer->list);
745 spin_unlock_bh(&ar->data_lock);
748 static void ath10k_peer_cleanup_all(struct ath10k *ar)
750 struct ath10k_peer *peer, *tmp;
752 lockdep_assert_held(&ar->conf_mutex);
754 spin_lock_bh(&ar->data_lock);
755 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
756 list_del(&peer->list);
759 spin_unlock_bh(&ar->data_lock);
762 ar->num_stations = 0;
765 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
766 struct ieee80211_sta *sta,
767 enum wmi_tdls_peer_state state)
770 struct wmi_tdls_peer_update_cmd_arg arg = {};
771 struct wmi_tdls_peer_capab_arg cap = {};
772 struct wmi_channel_arg chan_arg = {};
774 lockdep_assert_held(&ar->conf_mutex);
776 arg.vdev_id = vdev_id;
777 arg.peer_state = state;
778 ether_addr_copy(arg.addr, sta->addr);
780 cap.peer_max_sp = sta->max_sp;
781 cap.peer_uapsd_queues = sta->uapsd_queues;
783 if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
784 !sta->tdls_initiator)
785 cap.is_peer_responder = 1;
787 ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
789 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
790 arg.addr, vdev_id, ret);
797 /************************/
798 /* Interface management */
799 /************************/
801 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
803 struct ath10k *ar = arvif->ar;
805 lockdep_assert_held(&ar->data_lock);
810 if (!arvif->beacon_buf)
811 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
812 arvif->beacon->len, DMA_TO_DEVICE);
814 if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
815 arvif->beacon_state != ATH10K_BEACON_SENT))
818 dev_kfree_skb_any(arvif->beacon);
820 arvif->beacon = NULL;
821 arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
824 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
826 struct ath10k *ar = arvif->ar;
828 lockdep_assert_held(&ar->data_lock);
830 ath10k_mac_vif_beacon_free(arvif);
832 if (arvif->beacon_buf) {
833 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
834 arvif->beacon_buf, arvif->beacon_paddr);
835 arvif->beacon_buf = NULL;
839 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
841 unsigned long time_left;
843 lockdep_assert_held(&ar->conf_mutex);
845 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
848 time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
849 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
856 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
858 struct cfg80211_chan_def *chandef = NULL;
859 struct ieee80211_channel *channel = NULL;
860 struct wmi_vdev_start_request_arg arg = {};
863 lockdep_assert_held(&ar->conf_mutex);
865 ieee80211_iter_chan_contexts_atomic(ar->hw,
866 ath10k_mac_get_any_chandef_iter,
868 if (WARN_ON_ONCE(!chandef))
871 channel = chandef->chan;
873 arg.vdev_id = vdev_id;
874 arg.channel.freq = channel->center_freq;
875 arg.channel.band_center_freq1 = chandef->center_freq1;
877 /* TODO setup this dynamically, what in case we
878 don't have any vifs? */
879 arg.channel.mode = chan_to_phymode(chandef);
880 arg.channel.chan_radar =
881 !!(channel->flags & IEEE80211_CHAN_RADAR);
883 arg.channel.min_power = 0;
884 arg.channel.max_power = channel->max_power * 2;
885 arg.channel.max_reg_power = channel->max_reg_power * 2;
886 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
888 reinit_completion(&ar->vdev_setup_done);
890 ret = ath10k_wmi_vdev_start(ar, &arg);
892 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
897 ret = ath10k_vdev_setup_sync(ar);
899 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
904 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
906 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
911 ar->monitor_vdev_id = vdev_id;
913 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
914 ar->monitor_vdev_id);
918 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
920 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
921 ar->monitor_vdev_id, ret);
926 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
930 lockdep_assert_held(&ar->conf_mutex);
932 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
934 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
935 ar->monitor_vdev_id, ret);
937 reinit_completion(&ar->vdev_setup_done);
939 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
941 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
942 ar->monitor_vdev_id, ret);
944 ret = ath10k_vdev_setup_sync(ar);
946 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
947 ar->monitor_vdev_id, ret);
949 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
950 ar->monitor_vdev_id);
954 static int ath10k_monitor_vdev_create(struct ath10k *ar)
958 lockdep_assert_held(&ar->conf_mutex);
960 if (ar->free_vdev_map == 0) {
961 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
965 bit = __ffs64(ar->free_vdev_map);
967 ar->monitor_vdev_id = bit;
969 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
970 WMI_VDEV_TYPE_MONITOR,
973 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
974 ar->monitor_vdev_id, ret);
978 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
979 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
980 ar->monitor_vdev_id);
985 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
989 lockdep_assert_held(&ar->conf_mutex);
991 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
993 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
994 ar->monitor_vdev_id, ret);
998 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
1000 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
1001 ar->monitor_vdev_id);
1005 static int ath10k_monitor_start(struct ath10k *ar)
1009 lockdep_assert_held(&ar->conf_mutex);
1011 ret = ath10k_monitor_vdev_create(ar);
1013 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1017 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
1019 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1020 ath10k_monitor_vdev_delete(ar);
1024 ar->monitor_started = true;
1025 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1030 static int ath10k_monitor_stop(struct ath10k *ar)
1034 lockdep_assert_held(&ar->conf_mutex);
1036 ret = ath10k_monitor_vdev_stop(ar);
1038 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1042 ret = ath10k_monitor_vdev_delete(ar);
1044 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1048 ar->monitor_started = false;
1049 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1054 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1058 /* At least one chanctx is required to derive a channel to start
1061 num_ctx = ath10k_mac_num_chanctxs(ar);
1065 /* If there's already an existing special monitor interface then don't
1066 * bother creating another monitor vdev.
1068 if (ar->monitor_arvif)
1071 return ar->monitor ||
1072 ar->filter_flags & FIF_OTHER_BSS ||
1073 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1076 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)
1080 num_ctx = ath10k_mac_num_chanctxs(ar);
1082 /* FIXME: Current interface combinations and cfg80211/mac80211 code
1083 * shouldn't allow this but make sure to prevent handling the following
1084 * case anyway since multi-channel DFS hasn't been tested at all.
1086 if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)
1092 static int ath10k_monitor_recalc(struct ath10k *ar)
1098 lockdep_assert_held(&ar->conf_mutex);
1100 needed = ath10k_mac_monitor_vdev_is_needed(ar);
1101 allowed = ath10k_mac_monitor_vdev_is_allowed(ar);
1103 ath10k_dbg(ar, ATH10K_DBG_MAC,
1104 "mac monitor recalc started? %d needed? %d allowed? %d\n",
1105 ar->monitor_started, needed, allowed);
1107 if (WARN_ON(needed && !allowed)) {
1108 if (ar->monitor_started) {
1109 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");
1111 ret = ath10k_monitor_stop(ar);
1113 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n",
1121 if (needed == ar->monitor_started)
1125 return ath10k_monitor_start(ar);
1127 return ath10k_monitor_stop(ar);
1130 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
1132 struct ath10k *ar = arvif->ar;
1133 u32 vdev_param, rts_cts = 0;
1135 lockdep_assert_held(&ar->conf_mutex);
1137 vdev_param = ar->wmi.vdev_param->enable_rtscts;
1139 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
1141 if (arvif->num_legacy_stations > 0)
1142 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
1143 WMI_RTSCTS_PROFILE);
1145 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,
1146 WMI_RTSCTS_PROFILE);
1148 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1152 static int ath10k_start_cac(struct ath10k *ar)
1156 lockdep_assert_held(&ar->conf_mutex);
1158 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1160 ret = ath10k_monitor_recalc(ar);
1162 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
1163 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1167 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
1168 ar->monitor_vdev_id);
1173 static int ath10k_stop_cac(struct ath10k *ar)
1175 lockdep_assert_held(&ar->conf_mutex);
1177 /* CAC is not running - do nothing */
1178 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
1181 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1182 ath10k_monitor_stop(ar);
1184 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
1189 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,
1190 struct ieee80211_chanctx_conf *conf,
1195 if (!*ret && conf->radar_enabled)
1199 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)
1201 bool has_radar = false;
1203 ieee80211_iter_chan_contexts_atomic(ar->hw,
1204 ath10k_mac_has_radar_iter,
1210 static void ath10k_recalc_radar_detection(struct ath10k *ar)
1214 lockdep_assert_held(&ar->conf_mutex);
1216 ath10k_stop_cac(ar);
1218 if (!ath10k_mac_has_radar_enabled(ar))
1221 if (ar->num_started_vdevs > 0)
1224 ret = ath10k_start_cac(ar);
1227 * Not possible to start CAC on current channel so starting
1228 * radiation is not allowed, make this channel DFS_UNAVAILABLE
1229 * by indicating that radar was detected.
1231 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
1232 ieee80211_radar_detected(ar->hw);
1236 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
1238 struct ath10k *ar = arvif->ar;
1241 lockdep_assert_held(&ar->conf_mutex);
1243 reinit_completion(&ar->vdev_setup_done);
1245 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
1247 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
1248 arvif->vdev_id, ret);
1252 ret = ath10k_vdev_setup_sync(ar);
1254 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
1255 arvif->vdev_id, ret);
1259 WARN_ON(ar->num_started_vdevs == 0);
1261 if (ar->num_started_vdevs != 0) {
1262 ar->num_started_vdevs--;
1263 ath10k_recalc_radar_detection(ar);
1269 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,
1270 const struct cfg80211_chan_def *chandef,
1273 struct ath10k *ar = arvif->ar;
1274 struct wmi_vdev_start_request_arg arg = {};
1277 lockdep_assert_held(&ar->conf_mutex);
1279 reinit_completion(&ar->vdev_setup_done);
1281 arg.vdev_id = arvif->vdev_id;
1282 arg.dtim_period = arvif->dtim_period;
1283 arg.bcn_intval = arvif->beacon_interval;
1285 arg.channel.freq = chandef->chan->center_freq;
1286 arg.channel.band_center_freq1 = chandef->center_freq1;
1287 arg.channel.mode = chan_to_phymode(chandef);
1289 arg.channel.min_power = 0;
1290 arg.channel.max_power = chandef->chan->max_power * 2;
1291 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
1292 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
1294 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1295 arg.ssid = arvif->u.ap.ssid;
1296 arg.ssid_len = arvif->u.ap.ssid_len;
1297 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
1299 /* For now allow DFS for AP mode */
1300 arg.channel.chan_radar =
1301 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
1302 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
1303 arg.ssid = arvif->vif->bss_conf.ssid;
1304 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
1307 ath10k_dbg(ar, ATH10K_DBG_MAC,
1308 "mac vdev %d start center_freq %d phymode %s\n",
1309 arg.vdev_id, arg.channel.freq,
1310 ath10k_wmi_phymode_str(arg.channel.mode));
1313 ret = ath10k_wmi_vdev_restart(ar, &arg);
1315 ret = ath10k_wmi_vdev_start(ar, &arg);
1318 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
1323 ret = ath10k_vdev_setup_sync(ar);
1326 "failed to synchronize setup for vdev %i restart %d: %d\n",
1327 arg.vdev_id, restart, ret);
1331 ar->num_started_vdevs++;
1332 ath10k_recalc_radar_detection(ar);
1337 static int ath10k_vdev_start(struct ath10k_vif *arvif,
1338 const struct cfg80211_chan_def *def)
1340 return ath10k_vdev_start_restart(arvif, def, false);
1343 static int ath10k_vdev_restart(struct ath10k_vif *arvif,
1344 const struct cfg80211_chan_def *def)
1346 return ath10k_vdev_start_restart(arvif, def, true);
1349 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
1350 struct sk_buff *bcn)
1352 struct ath10k *ar = arvif->ar;
1353 struct ieee80211_mgmt *mgmt;
1357 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1360 if (arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1363 mgmt = (void *)bcn->data;
1364 p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1365 mgmt->u.beacon.variable,
1366 bcn->len - (mgmt->u.beacon.variable -
1371 ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1373 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1374 arvif->vdev_id, ret);
1381 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1382 u8 oui_type, size_t ie_offset)
1389 if (WARN_ON(skb->len < ie_offset))
1392 ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1393 skb->data + ie_offset,
1394 skb->len - ie_offset);
1399 end = skb->data + skb->len;
1402 if (WARN_ON(next > end))
1405 memmove(ie, next, end - next);
1406 skb_trim(skb, skb->len - len);
1411 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1413 struct ath10k *ar = arvif->ar;
1414 struct ieee80211_hw *hw = ar->hw;
1415 struct ieee80211_vif *vif = arvif->vif;
1416 struct ieee80211_mutable_offsets offs = {};
1417 struct sk_buff *bcn;
1420 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1423 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
1424 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
1427 bcn = ieee80211_beacon_get_template(hw, vif, &offs);
1429 ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1433 ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1435 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1440 /* P2P IE is inserted by firmware automatically (as configured above)
1441 * so remove it from the base beacon template to avoid duplicate P2P
1442 * IEs in beacon frames.
1444 ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1445 offsetof(struct ieee80211_mgmt,
1446 u.beacon.variable));
1448 ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1453 ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1461 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1463 struct ath10k *ar = arvif->ar;
1464 struct ieee80211_hw *hw = ar->hw;
1465 struct ieee80211_vif *vif = arvif->vif;
1466 struct sk_buff *prb;
1469 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1472 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1475 prb = ieee80211_proberesp_get(hw, vif);
1477 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1481 ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1485 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1493 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)
1495 struct ath10k *ar = arvif->ar;
1496 struct cfg80211_chan_def def;
1499 /* When originally vdev is started during assign_vif_chanctx() some
1500 * information is missing, notably SSID. Firmware revisions with beacon
1501 * offloading require the SSID to be provided during vdev (re)start to
1502 * handle hidden SSID properly.
1504 * Vdev restart must be done after vdev has been both started and
1505 * upped. Otherwise some firmware revisions (at least 10.2) fail to
1506 * deliver vdev restart response event causing timeouts during vdev
1507 * syncing in ath10k.
1509 * Note: The vdev down/up and template reinstallation could be skipped
1510 * since only wmi-tlv firmware are known to have beacon offload and
1511 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1512 * response delivery. It's probably more robust to keep it as is.
1514 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1517 if (WARN_ON(!arvif->is_started))
1520 if (WARN_ON(!arvif->is_up))
1523 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
1526 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1528 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",
1529 arvif->vdev_id, ret);
1533 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1534 * firmware will crash upon vdev up.
1537 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1539 ath10k_warn(ar, "failed to update beacon template: %d\n", ret);
1543 ret = ath10k_mac_setup_prb_tmpl(arvif);
1545 ath10k_warn(ar, "failed to update presp template: %d\n", ret);
1549 ret = ath10k_vdev_restart(arvif, &def);
1551 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",
1552 arvif->vdev_id, ret);
1556 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1559 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",
1560 arvif->vdev_id, ret);
1567 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1568 struct ieee80211_bss_conf *info)
1570 struct ath10k *ar = arvif->ar;
1573 lockdep_assert_held(&arvif->ar->conf_mutex);
1575 if (!info->enable_beacon) {
1576 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1578 ath10k_warn(ar, "failed to down vdev_id %i: %d\n",
1579 arvif->vdev_id, ret);
1581 arvif->is_up = false;
1583 spin_lock_bh(&arvif->ar->data_lock);
1584 ath10k_mac_vif_beacon_free(arvif);
1585 spin_unlock_bh(&arvif->ar->data_lock);
1590 arvif->tx_seq_no = 0x1000;
1593 ether_addr_copy(arvif->bssid, info->bssid);
1595 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1598 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1599 arvif->vdev_id, ret);
1603 arvif->is_up = true;
1605 ret = ath10k_mac_vif_fix_hidden_ssid(arvif);
1607 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1608 arvif->vdev_id, ret);
1612 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1615 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1616 struct ieee80211_bss_conf *info,
1617 const u8 self_peer[ETH_ALEN])
1619 struct ath10k *ar = arvif->ar;
1623 lockdep_assert_held(&arvif->ar->conf_mutex);
1625 if (!info->ibss_joined) {
1626 if (is_zero_ether_addr(arvif->bssid))
1629 eth_zero_addr(arvif->bssid);
1634 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1635 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1636 ATH10K_DEFAULT_ATIM);
1638 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1639 arvif->vdev_id, ret);
1642 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1644 struct ath10k *ar = arvif->ar;
1649 lockdep_assert_held(&arvif->ar->conf_mutex);
1651 if (arvif->u.sta.uapsd)
1652 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1654 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1656 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1657 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1659 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1660 value, arvif->vdev_id, ret);
1667 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1669 struct ath10k *ar = arvif->ar;
1674 lockdep_assert_held(&arvif->ar->conf_mutex);
1676 if (arvif->u.sta.uapsd)
1677 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1679 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1681 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1682 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1685 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1686 value, arvif->vdev_id, ret);
1693 static int ath10k_mac_num_vifs_started(struct ath10k *ar)
1695 struct ath10k_vif *arvif;
1698 lockdep_assert_held(&ar->conf_mutex);
1700 list_for_each_entry(arvif, &ar->arvifs, list)
1701 if (arvif->is_started)
1707 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1709 struct ath10k *ar = arvif->ar;
1710 struct ieee80211_vif *vif = arvif->vif;
1711 struct ieee80211_conf *conf = &ar->hw->conf;
1712 enum wmi_sta_powersave_param param;
1713 enum wmi_sta_ps_mode psmode;
1718 lockdep_assert_held(&arvif->ar->conf_mutex);
1720 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1723 enable_ps = arvif->ps;
1725 if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&
1726 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,
1728 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",
1733 if (!arvif->is_started) {
1734 /* mac80211 can update vif powersave state while disconnected.
1735 * Firmware doesn't behave nicely and consumes more power than
1736 * necessary if PS is disabled on a non-started vdev. Hence
1737 * force-enable PS for non-running vdevs.
1739 psmode = WMI_STA_PS_MODE_ENABLED;
1740 } else if (enable_ps) {
1741 psmode = WMI_STA_PS_MODE_ENABLED;
1742 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1744 ps_timeout = conf->dynamic_ps_timeout;
1745 if (ps_timeout == 0) {
1746 /* Firmware doesn't like 0 */
1747 ps_timeout = ieee80211_tu_to_usec(
1748 vif->bss_conf.beacon_int) / 1000;
1751 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1754 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1755 arvif->vdev_id, ret);
1759 psmode = WMI_STA_PS_MODE_DISABLED;
1762 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1763 arvif->vdev_id, psmode ? "enable" : "disable");
1765 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1767 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1768 psmode, arvif->vdev_id, ret);
1775 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1777 struct ath10k *ar = arvif->ar;
1778 struct wmi_sta_keepalive_arg arg = {};
1781 lockdep_assert_held(&arvif->ar->conf_mutex);
1783 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1786 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1789 /* Some firmware revisions have a bug and ignore the `enabled` field.
1790 * Instead use the interval to disable the keepalive.
1792 arg.vdev_id = arvif->vdev_id;
1794 arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
1795 arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
1797 ret = ath10k_wmi_sta_keepalive(ar, &arg);
1799 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
1800 arvif->vdev_id, ret);
1807 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)
1809 struct ath10k *ar = arvif->ar;
1810 struct ieee80211_vif *vif = arvif->vif;
1813 lockdep_assert_held(&arvif->ar->conf_mutex);
1815 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))
1818 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1821 if (!vif->csa_active)
1827 if (!ieee80211_csa_is_complete(vif)) {
1828 ieee80211_csa_update_counter(vif);
1830 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1832 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
1835 ret = ath10k_mac_setup_prb_tmpl(arvif);
1837 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
1840 ieee80211_csa_finish(vif);
1844 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)
1846 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1848 struct ath10k *ar = arvif->ar;
1850 mutex_lock(&ar->conf_mutex);
1851 ath10k_mac_vif_ap_csa_count_down(arvif);
1852 mutex_unlock(&ar->conf_mutex);
1855 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,
1856 struct ieee80211_vif *vif)
1858 struct sk_buff *skb = data;
1859 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1860 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1862 if (vif->type != NL80211_IFTYPE_STATION)
1865 if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1868 cancel_delayed_work(&arvif->connection_loss_work);
1871 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)
1873 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1874 IEEE80211_IFACE_ITER_NORMAL,
1875 ath10k_mac_handle_beacon_iter,
1879 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1880 struct ieee80211_vif *vif)
1882 u32 *vdev_id = data;
1883 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1884 struct ath10k *ar = arvif->ar;
1885 struct ieee80211_hw *hw = ar->hw;
1887 if (arvif->vdev_id != *vdev_id)
1893 ieee80211_beacon_loss(vif);
1895 /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1896 * (done by mac80211) succeeds but beacons do not resume then it
1897 * doesn't make sense to continue operation. Queue connection loss work
1898 * which can be cancelled when beacon is received.
1900 ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1901 ATH10K_CONNECTION_LOSS_HZ);
1904 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)
1906 ieee80211_iterate_active_interfaces_atomic(ar->hw,
1907 IEEE80211_IFACE_ITER_NORMAL,
1908 ath10k_mac_handle_beacon_miss_iter,
1912 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1914 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1915 connection_loss_work.work);
1916 struct ieee80211_vif *vif = arvif->vif;
1921 ieee80211_connection_loss(vif);
1924 /**********************/
1925 /* Station management */
1926 /**********************/
1928 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1929 struct ieee80211_vif *vif)
1931 /* Some firmware revisions have unstable STA powersave when listen
1932 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1933 * generate NullFunc frames properly even if buffered frames have been
1934 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1935 * buffered frames. Often pinging the device from AP would simply fail.
1937 * As a workaround set it to 1.
1939 if (vif->type == NL80211_IFTYPE_STATION)
1942 return ar->hw->conf.listen_interval;
1945 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1946 struct ieee80211_vif *vif,
1947 struct ieee80211_sta *sta,
1948 struct wmi_peer_assoc_complete_arg *arg)
1950 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1953 lockdep_assert_held(&ar->conf_mutex);
1955 if (vif->type == NL80211_IFTYPE_STATION)
1956 aid = vif->bss_conf.aid;
1960 ether_addr_copy(arg->addr, sta->addr);
1961 arg->vdev_id = arvif->vdev_id;
1962 arg->peer_aid = aid;
1963 arg->peer_flags |= WMI_PEER_AUTH;
1964 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1965 arg->peer_num_spatial_streams = 1;
1966 arg->peer_caps = vif->bss_conf.assoc_capability;
1969 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1970 struct ieee80211_vif *vif,
1971 struct wmi_peer_assoc_complete_arg *arg)
1973 struct ieee80211_bss_conf *info = &vif->bss_conf;
1974 struct cfg80211_chan_def def;
1975 struct cfg80211_bss *bss;
1976 const u8 *rsnie = NULL;
1977 const u8 *wpaie = NULL;
1979 lockdep_assert_held(&ar->conf_mutex);
1981 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
1984 bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1985 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1987 const struct cfg80211_bss_ies *ies;
1990 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1992 ies = rcu_dereference(bss->ies);
1994 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1995 WLAN_OUI_TYPE_MICROSOFT_WPA,
1999 cfg80211_put_bss(ar->hw->wiphy, bss);
2002 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
2003 if (rsnie || wpaie) {
2004 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
2005 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
2009 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
2010 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
2014 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
2015 struct ieee80211_vif *vif,
2016 struct ieee80211_sta *sta,
2017 struct wmi_peer_assoc_complete_arg *arg)
2019 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2020 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
2021 struct cfg80211_chan_def def;
2022 const struct ieee80211_supported_band *sband;
2023 const struct ieee80211_rate *rates;
2024 enum ieee80211_band band;
2029 lockdep_assert_held(&ar->conf_mutex);
2031 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2034 band = def.chan->band;
2035 sband = ar->hw->wiphy->bands[band];
2036 ratemask = sta->supp_rates[band];
2037 ratemask &= arvif->bitrate_mask.control[band].legacy;
2038 rates = sband->bitrates;
2040 rateset->num_rates = 0;
2042 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
2043 if (!(ratemask & 1))
2046 rate = ath10k_mac_bitrate_to_rate(rates->bitrate);
2047 rateset->rates[rateset->num_rates] = rate;
2048 rateset->num_rates++;
2053 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
2057 for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
2058 if (ht_mcs_mask[nss])
2065 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
2069 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
2070 if (vht_mcs_mask[nss])
2076 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
2077 struct ieee80211_vif *vif,
2078 struct ieee80211_sta *sta,
2079 struct wmi_peer_assoc_complete_arg *arg)
2081 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2082 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2083 struct cfg80211_chan_def def;
2084 enum ieee80211_band band;
2085 const u8 *ht_mcs_mask;
2086 const u16 *vht_mcs_mask;
2091 lockdep_assert_held(&ar->conf_mutex);
2093 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2096 if (!ht_cap->ht_supported)
2099 band = def.chan->band;
2100 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2101 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2103 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&
2104 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2107 arg->peer_flags |= WMI_PEER_HT;
2108 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2109 ht_cap->ampdu_factor)) - 1;
2111 arg->peer_mpdu_density =
2112 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
2114 arg->peer_ht_caps = ht_cap->cap;
2115 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
2117 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
2118 arg->peer_flags |= WMI_PEER_LDPC;
2120 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
2121 arg->peer_flags |= WMI_PEER_40MHZ;
2122 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
2125 if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
2126 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
2127 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2129 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
2130 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2133 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
2134 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
2135 arg->peer_flags |= WMI_PEER_STBC;
2138 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
2139 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
2140 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
2141 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
2142 arg->peer_rate_caps |= stbc;
2143 arg->peer_flags |= WMI_PEER_STBC;
2146 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
2147 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
2148 else if (ht_cap->mcs.rx_mask[1])
2149 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
2151 for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
2152 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
2153 (ht_mcs_mask[i / 8] & BIT(i % 8))) {
2154 max_nss = (i / 8) + 1;
2155 arg->peer_ht_rates.rates[n++] = i;
2159 * This is a workaround for HT-enabled STAs which break the spec
2160 * and have no HT capabilities RX mask (no HT RX MCS map).
2162 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2163 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2165 * Firmware asserts if such situation occurs.
2168 arg->peer_ht_rates.num_rates = 8;
2169 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
2170 arg->peer_ht_rates.rates[i] = i;
2172 arg->peer_ht_rates.num_rates = n;
2173 arg->peer_num_spatial_streams = min(sta->rx_nss, max_nss);
2176 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
2178 arg->peer_ht_rates.num_rates,
2179 arg->peer_num_spatial_streams);
2182 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
2183 struct ath10k_vif *arvif,
2184 struct ieee80211_sta *sta)
2190 lockdep_assert_held(&ar->conf_mutex);
2192 if (sta->wme && sta->uapsd_queues) {
2193 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2194 sta->uapsd_queues, sta->max_sp);
2196 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2197 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2198 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2199 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2200 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2201 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2202 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2203 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2204 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2205 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2206 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2207 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2209 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2210 max_sp = sta->max_sp;
2212 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2214 WMI_AP_PS_PEER_PARAM_UAPSD,
2217 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2218 arvif->vdev_id, ret);
2222 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2224 WMI_AP_PS_PEER_PARAM_MAX_SP,
2227 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2228 arvif->vdev_id, ret);
2232 /* TODO setup this based on STA listen interval and
2233 beacon interval. Currently we don't know
2234 sta->listen_interval - mac80211 patch required.
2235 Currently use 10 seconds */
2236 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
2237 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
2240 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2241 arvif->vdev_id, ret);
2250 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
2251 const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
2258 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
2259 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
2263 idx_limit = fls(mcs_map) - 1;
2267 switch (idx_limit) {
2268 case 0: /* fall through */
2269 case 1: /* fall through */
2270 case 2: /* fall through */
2271 case 3: /* fall through */
2272 case 4: /* fall through */
2273 case 5: /* fall through */
2274 case 6: /* fall through */
2276 /* see ath10k_mac_can_set_bitrate_mask() */
2280 mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2283 mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2286 mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2289 mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2293 tx_mcs_set &= ~(0x3 << (nss * 2));
2294 tx_mcs_set |= mcs << (nss * 2);
2300 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
2301 struct ieee80211_vif *vif,
2302 struct ieee80211_sta *sta,
2303 struct wmi_peer_assoc_complete_arg *arg)
2305 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
2306 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2307 struct cfg80211_chan_def def;
2308 enum ieee80211_band band;
2309 const u16 *vht_mcs_mask;
2312 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2315 if (!vht_cap->vht_supported)
2318 band = def.chan->band;
2319 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2321 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2324 arg->peer_flags |= WMI_PEER_VHT;
2326 if (def.chan->band == IEEE80211_BAND_2GHZ)
2327 arg->peer_flags |= WMI_PEER_VHT_2G;
2329 arg->peer_vht_caps = vht_cap->cap;
2331 ampdu_factor = (vht_cap->cap &
2332 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2333 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2335 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2336 * zero in VHT IE. Using it would result in degraded throughput.
2337 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2338 * it if VHT max_mpdu is smaller. */
2339 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2340 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2341 ampdu_factor)) - 1);
2343 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2344 arg->peer_flags |= WMI_PEER_80MHZ;
2346 arg->peer_vht_rates.rx_max_rate =
2347 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2348 arg->peer_vht_rates.rx_mcs_set =
2349 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2350 arg->peer_vht_rates.tx_max_rate =
2351 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2352 arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(
2353 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2355 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
2356 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
2359 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
2360 struct ieee80211_vif *vif,
2361 struct ieee80211_sta *sta,
2362 struct wmi_peer_assoc_complete_arg *arg)
2364 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2366 switch (arvif->vdev_type) {
2367 case WMI_VDEV_TYPE_AP:
2369 arg->peer_flags |= WMI_PEER_QOS;
2371 if (sta->wme && sta->uapsd_queues) {
2372 arg->peer_flags |= WMI_PEER_APSD;
2373 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
2376 case WMI_VDEV_TYPE_STA:
2377 if (vif->bss_conf.qos)
2378 arg->peer_flags |= WMI_PEER_QOS;
2380 case WMI_VDEV_TYPE_IBSS:
2382 arg->peer_flags |= WMI_PEER_QOS;
2388 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
2389 sta->addr, !!(arg->peer_flags & WMI_PEER_QOS));
2392 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2394 return sta->supp_rates[IEEE80211_BAND_2GHZ] >>
2395 ATH10K_MAC_FIRST_OFDM_RATE_IDX;
2398 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
2399 struct ieee80211_vif *vif,
2400 struct ieee80211_sta *sta,
2401 struct wmi_peer_assoc_complete_arg *arg)
2403 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2404 struct cfg80211_chan_def def;
2405 enum ieee80211_band band;
2406 const u8 *ht_mcs_mask;
2407 const u16 *vht_mcs_mask;
2408 enum wmi_phy_mode phymode = MODE_UNKNOWN;
2410 if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2413 band = def.chan->band;
2414 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2415 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2418 case IEEE80211_BAND_2GHZ:
2419 if (sta->vht_cap.vht_supported &&
2420 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2421 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2422 phymode = MODE_11AC_VHT40;
2424 phymode = MODE_11AC_VHT20;
2425 } else if (sta->ht_cap.ht_supported &&
2426 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2427 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2428 phymode = MODE_11NG_HT40;
2430 phymode = MODE_11NG_HT20;
2431 } else if (ath10k_mac_sta_has_ofdm_only(sta)) {
2438 case IEEE80211_BAND_5GHZ:
2442 if (sta->vht_cap.vht_supported &&
2443 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2444 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2445 phymode = MODE_11AC_VHT80;
2446 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2447 phymode = MODE_11AC_VHT40;
2448 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
2449 phymode = MODE_11AC_VHT20;
2450 } else if (sta->ht_cap.ht_supported &&
2451 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2452 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40)
2453 phymode = MODE_11NA_HT40;
2455 phymode = MODE_11NA_HT20;
2465 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
2466 sta->addr, ath10k_wmi_phymode_str(phymode));
2468 arg->peer_phymode = phymode;
2469 WARN_ON(phymode == MODE_UNKNOWN);
2472 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
2473 struct ieee80211_vif *vif,
2474 struct ieee80211_sta *sta,
2475 struct wmi_peer_assoc_complete_arg *arg)
2477 lockdep_assert_held(&ar->conf_mutex);
2479 memset(arg, 0, sizeof(*arg));
2481 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
2482 ath10k_peer_assoc_h_crypto(ar, vif, arg);
2483 ath10k_peer_assoc_h_rates(ar, vif, sta, arg);
2484 ath10k_peer_assoc_h_ht(ar, vif, sta, arg);
2485 ath10k_peer_assoc_h_vht(ar, vif, sta, arg);
2486 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
2487 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
2492 static const u32 ath10k_smps_map[] = {
2493 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
2494 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
2495 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
2496 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
2499 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
2501 const struct ieee80211_sta_ht_cap *ht_cap)
2505 if (!ht_cap->ht_supported)
2508 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2509 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2511 if (smps >= ARRAY_SIZE(ath10k_smps_map))
2514 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
2515 WMI_PEER_SMPS_STATE,
2516 ath10k_smps_map[smps]);
2519 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,
2520 struct ieee80211_vif *vif,
2521 struct ieee80211_sta_vht_cap vht_cap)
2523 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2528 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC)
2531 if (!(ar->vht_cap_info &
2532 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2533 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
2534 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2535 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))
2538 param = ar->wmi.vdev_param->txbf;
2541 if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))
2544 /* The following logic is correct. If a remote STA advertises support
2545 * for being a beamformer then we should enable us being a beamformee.
2548 if (ar->vht_cap_info &
2549 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2550 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
2551 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
2552 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2554 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
2555 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
2558 if (ar->vht_cap_info &
2559 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2560 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
2561 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
2562 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2564 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
2565 value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
2568 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)
2569 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2571 if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)
2572 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2574 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);
2576 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",
2584 /* can be called only in mac80211 callbacks due to `key_count` usage */
2585 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
2586 struct ieee80211_vif *vif,
2587 struct ieee80211_bss_conf *bss_conf)
2589 struct ath10k *ar = hw->priv;
2590 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2591 struct ieee80211_sta_ht_cap ht_cap;
2592 struct ieee80211_sta_vht_cap vht_cap;
2593 struct wmi_peer_assoc_complete_arg peer_arg;
2594 struct ieee80211_sta *ap_sta;
2597 lockdep_assert_held(&ar->conf_mutex);
2599 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2600 arvif->vdev_id, arvif->bssid, arvif->aid);
2604 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2606 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
2607 bss_conf->bssid, arvif->vdev_id);
2612 /* ap_sta must be accessed only within rcu section which must be left
2613 * before calling ath10k_setup_peer_smps() which might sleep. */
2614 ht_cap = ap_sta->ht_cap;
2615 vht_cap = ap_sta->vht_cap;
2617 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
2619 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
2620 bss_conf->bssid, arvif->vdev_id, ret);
2627 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2629 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
2630 bss_conf->bssid, arvif->vdev_id, ret);
2634 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
2636 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
2637 arvif->vdev_id, ret);
2641 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2643 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
2644 arvif->vdev_id, bss_conf->bssid, ret);
2648 ath10k_dbg(ar, ATH10K_DBG_MAC,
2649 "mac vdev %d up (associated) bssid %pM aid %d\n",
2650 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
2652 WARN_ON(arvif->is_up);
2654 arvif->aid = bss_conf->aid;
2655 ether_addr_copy(arvif->bssid, bss_conf->bssid);
2657 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2659 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
2660 arvif->vdev_id, ret);
2664 arvif->is_up = true;
2666 /* Workaround: Some firmware revisions (tested with qca6174
2667 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
2668 * poked with peer param command.
2670 ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
2671 WMI_PEER_DUMMY_VAR, 1);
2673 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
2674 arvif->bssid, arvif->vdev_id, ret);
2679 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
2680 struct ieee80211_vif *vif)
2682 struct ath10k *ar = hw->priv;
2683 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2684 struct ieee80211_sta_vht_cap vht_cap = {};
2687 lockdep_assert_held(&ar->conf_mutex);
2689 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2690 arvif->vdev_id, arvif->bssid);
2692 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2694 ath10k_warn(ar, "faield to down vdev %i: %d\n",
2695 arvif->vdev_id, ret);
2697 arvif->def_wep_key_idx = -1;
2699 ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2701 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",
2702 arvif->vdev_id, ret);
2706 arvif->is_up = false;
2708 cancel_delayed_work_sync(&arvif->connection_loss_work);
2711 static int ath10k_station_assoc(struct ath10k *ar,
2712 struct ieee80211_vif *vif,
2713 struct ieee80211_sta *sta,
2716 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2717 struct wmi_peer_assoc_complete_arg peer_arg;
2720 lockdep_assert_held(&ar->conf_mutex);
2722 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
2724 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
2725 sta->addr, arvif->vdev_id, ret);
2729 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2731 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
2732 sta->addr, arvif->vdev_id, ret);
2736 /* Re-assoc is run only to update supported rates for given station. It
2737 * doesn't make much sense to reconfigure the peer completely.
2740 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
2743 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
2744 arvif->vdev_id, ret);
2748 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
2750 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
2751 sta->addr, arvif->vdev_id, ret);
2756 arvif->num_legacy_stations++;
2757 ret = ath10k_recalc_rtscts_prot(arvif);
2759 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2760 arvif->vdev_id, ret);
2765 /* Plumb cached keys only for static WEP */
2766 if (arvif->def_wep_key_idx != -1) {
2767 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
2769 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
2770 arvif->vdev_id, ret);
2779 static int ath10k_station_disassoc(struct ath10k *ar,
2780 struct ieee80211_vif *vif,
2781 struct ieee80211_sta *sta)
2783 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2786 lockdep_assert_held(&ar->conf_mutex);
2789 arvif->num_legacy_stations--;
2790 ret = ath10k_recalc_rtscts_prot(arvif);
2792 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2793 arvif->vdev_id, ret);
2798 ret = ath10k_clear_peer_keys(arvif, sta->addr);
2800 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
2801 arvif->vdev_id, ret);
2812 static int ath10k_update_channel_list(struct ath10k *ar)
2814 struct ieee80211_hw *hw = ar->hw;
2815 struct ieee80211_supported_band **bands;
2816 enum ieee80211_band band;
2817 struct ieee80211_channel *channel;
2818 struct wmi_scan_chan_list_arg arg = {0};
2819 struct wmi_channel_arg *ch;
2825 lockdep_assert_held(&ar->conf_mutex);
2827 bands = hw->wiphy->bands;
2828 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2832 for (i = 0; i < bands[band]->n_channels; i++) {
2833 if (bands[band]->channels[i].flags &
2834 IEEE80211_CHAN_DISABLED)
2841 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
2842 arg.channels = kzalloc(len, GFP_KERNEL);
2847 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2851 for (i = 0; i < bands[band]->n_channels; i++) {
2852 channel = &bands[band]->channels[i];
2854 if (channel->flags & IEEE80211_CHAN_DISABLED)
2857 ch->allow_ht = true;
2859 /* FIXME: when should we really allow VHT? */
2860 ch->allow_vht = true;
2863 !(channel->flags & IEEE80211_CHAN_NO_IR);
2866 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
2869 !!(channel->flags & IEEE80211_CHAN_RADAR);
2871 passive = channel->flags & IEEE80211_CHAN_NO_IR;
2872 ch->passive = passive;
2874 ch->freq = channel->center_freq;
2875 ch->band_center_freq1 = channel->center_freq;
2877 ch->max_power = channel->max_power * 2;
2878 ch->max_reg_power = channel->max_reg_power * 2;
2879 ch->max_antenna_gain = channel->max_antenna_gain * 2;
2880 ch->reg_class_id = 0; /* FIXME */
2882 /* FIXME: why use only legacy modes, why not any
2883 * HT/VHT modes? Would that even make any
2885 if (channel->band == IEEE80211_BAND_2GHZ)
2886 ch->mode = MODE_11G;
2888 ch->mode = MODE_11A;
2890 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
2893 ath10k_dbg(ar, ATH10K_DBG_WMI,
2894 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
2895 ch - arg.channels, arg.n_channels,
2896 ch->freq, ch->max_power, ch->max_reg_power,
2897 ch->max_antenna_gain, ch->mode);
2903 ret = ath10k_wmi_scan_chan_list(ar, &arg);
2904 kfree(arg.channels);
2909 static enum wmi_dfs_region
2910 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
2912 switch (dfs_region) {
2913 case NL80211_DFS_UNSET:
2914 return WMI_UNINIT_DFS_DOMAIN;
2915 case NL80211_DFS_FCC:
2916 return WMI_FCC_DFS_DOMAIN;
2917 case NL80211_DFS_ETSI:
2918 return WMI_ETSI_DFS_DOMAIN;
2919 case NL80211_DFS_JP:
2920 return WMI_MKK4_DFS_DOMAIN;
2922 return WMI_UNINIT_DFS_DOMAIN;
2925 static void ath10k_regd_update(struct ath10k *ar)
2927 struct reg_dmn_pair_mapping *regpair;
2929 enum wmi_dfs_region wmi_dfs_reg;
2930 enum nl80211_dfs_regions nl_dfs_reg;
2932 lockdep_assert_held(&ar->conf_mutex);
2934 ret = ath10k_update_channel_list(ar);
2936 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
2938 regpair = ar->ath_common.regulatory.regpair;
2940 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2941 nl_dfs_reg = ar->dfs_detector->region;
2942 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
2944 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
2947 /* Target allows setting up per-band regdomain but ath_common provides
2948 * a combined one only */
2949 ret = ath10k_wmi_pdev_set_regdomain(ar,
2950 regpair->reg_domain,
2951 regpair->reg_domain, /* 2ghz */
2952 regpair->reg_domain, /* 5ghz */
2953 regpair->reg_2ghz_ctl,
2954 regpair->reg_5ghz_ctl,
2957 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
2960 static void ath10k_reg_notifier(struct wiphy *wiphy,
2961 struct regulatory_request *request)
2963 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
2964 struct ath10k *ar = hw->priv;
2967 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
2969 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2970 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
2971 request->dfs_region);
2972 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
2973 request->dfs_region);
2975 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
2976 request->dfs_region);
2979 mutex_lock(&ar->conf_mutex);
2980 if (ar->state == ATH10K_STATE_ON)
2981 ath10k_regd_update(ar);
2982 mutex_unlock(&ar->conf_mutex);
2989 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
2991 lockdep_assert_held(&ar->htt.tx_lock);
2993 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
2994 ar->tx_paused |= BIT(reason);
2995 ieee80211_stop_queues(ar->hw);
2998 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,
2999 struct ieee80211_vif *vif)
3001 struct ath10k *ar = data;
3002 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3004 if (arvif->tx_paused)
3007 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3010 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)
3012 lockdep_assert_held(&ar->htt.tx_lock);
3014 WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3015 ar->tx_paused &= ~BIT(reason);
3020 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3021 IEEE80211_IFACE_ITER_RESUME_ALL,
3022 ath10k_mac_tx_unlock_iter,
3025 ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue);
3028 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)
3030 struct ath10k *ar = arvif->ar;
3032 lockdep_assert_held(&ar->htt.tx_lock);
3034 WARN_ON(reason >= BITS_PER_LONG);
3035 arvif->tx_paused |= BIT(reason);
3036 ieee80211_stop_queue(ar->hw, arvif->vdev_id);
3039 void ath10k_mac_vif_tx_unlock(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);
3051 if (arvif->tx_paused)
3054 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3057 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,
3058 enum wmi_tlv_tx_pause_id pause_id,
3059 enum wmi_tlv_tx_pause_action action)
3061 struct ath10k *ar = arvif->ar;
3063 lockdep_assert_held(&ar->htt.tx_lock);
3066 case WMI_TLV_TX_PAUSE_ACTION_STOP:
3067 ath10k_mac_vif_tx_lock(arvif, pause_id);
3069 case WMI_TLV_TX_PAUSE_ACTION_WAKE:
3070 ath10k_mac_vif_tx_unlock(arvif, pause_id);
3073 ath10k_warn(ar, "received unknown tx pause action %d on vdev %i, ignoring\n",
3074 action, arvif->vdev_id);
3079 struct ath10k_mac_tx_pause {
3081 enum wmi_tlv_tx_pause_id pause_id;
3082 enum wmi_tlv_tx_pause_action action;
3085 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,
3086 struct ieee80211_vif *vif)
3088 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3089 struct ath10k_mac_tx_pause *arg = data;
3091 if (arvif->vdev_id != arg->vdev_id)
3094 ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);
3097 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id,
3098 enum wmi_tlv_tx_pause_id pause_id,
3099 enum wmi_tlv_tx_pause_action action)
3101 struct ath10k_mac_tx_pause arg = {
3103 .pause_id = pause_id,
3107 spin_lock_bh(&ar->htt.tx_lock);
3108 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3109 IEEE80211_IFACE_ITER_RESUME_ALL,
3110 ath10k_mac_handle_tx_pause_iter,
3112 spin_unlock_bh(&ar->htt.tx_lock);
3115 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
3117 if (ieee80211_is_mgmt(hdr->frame_control))
3118 return HTT_DATA_TX_EXT_TID_MGMT;
3120 if (!ieee80211_is_data_qos(hdr->frame_control))
3121 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
3123 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
3124 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
3126 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
3129 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
3132 return ath10k_vif_to_arvif(vif)->vdev_id;
3134 if (ar->monitor_started)
3135 return ar->monitor_vdev_id;
3137 ath10k_warn(ar, "failed to resolve vdev id\n");
3141 static enum ath10k_hw_txrx_mode
3142 ath10k_tx_h_get_txmode(struct ath10k *ar, struct ieee80211_vif *vif,
3143 struct ieee80211_sta *sta, struct sk_buff *skb)
3145 const struct ieee80211_hdr *hdr = (void *)skb->data;
3146 __le16 fc = hdr->frame_control;
3148 if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3149 return ATH10K_HW_TXRX_RAW;
3151 if (ieee80211_is_mgmt(fc))
3152 return ATH10K_HW_TXRX_MGMT;
3156 * NullFunc frames are mostly used to ping if a client or AP are still
3157 * reachable and responsive. This implies tx status reports must be
3158 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3159 * come to a conclusion that the other end disappeared and tear down
3160 * BSS connection or it can never disconnect from BSS/client (which is
3163 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3164 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3165 * which seems to deliver correct tx reports for NullFunc frames. The
3166 * downside of using it is it ignores client powersave state so it can
3167 * end up disconnecting sleeping clients in AP mode. It should fix STA
3168 * mode though because AP don't sleep.
3170 if (ar->htt.target_version_major < 3 &&
3171 (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3172 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, ar->fw_features))
3173 return ATH10K_HW_TXRX_MGMT;
3177 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3178 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3179 * to work with Ethernet txmode so use it.
3181 * FIXME: Check if raw mode works with TDLS.
3183 if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3184 return ATH10K_HW_TXRX_ETHERNET;
3186 if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
3187 return ATH10K_HW_TXRX_RAW;
3189 return ATH10K_HW_TXRX_NATIVE_WIFI;
3192 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,
3193 struct sk_buff *skb) {
3194 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3195 const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |
3196 IEEE80211_TX_CTL_INJECTED;
3197 if ((info->flags & mask) == mask)
3200 return !ath10k_vif_to_arvif(vif)->nohwcrypt;
3204 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3205 * Control in the header.
3207 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3209 struct ieee80211_hdr *hdr = (void *)skb->data;
3210 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3213 if (!ieee80211_is_data_qos(hdr->frame_control))
3216 qos_ctl = ieee80211_get_qos_ctl(hdr);
3217 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3218 skb->data, (void *)qos_ctl - (void *)skb->data);
3219 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3221 /* Some firmware revisions don't handle sending QoS NullFunc well.
3222 * These frames are mainly used for CQM purposes so it doesn't really
3223 * matter whether QoS NullFunc or NullFunc are sent.
3225 hdr = (void *)skb->data;
3226 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3227 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
3229 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3232 static void ath10k_tx_h_8023(struct sk_buff *skb)
3234 struct ieee80211_hdr *hdr;
3235 struct rfc1042_hdr *rfc1042;
3242 hdr = (void *)skb->data;
3243 hdrlen = ieee80211_hdrlen(hdr->frame_control);
3244 rfc1042 = (void *)skb->data + hdrlen;
3246 ether_addr_copy(da, ieee80211_get_DA(hdr));
3247 ether_addr_copy(sa, ieee80211_get_SA(hdr));
3248 type = rfc1042->snap_type;
3250 skb_pull(skb, hdrlen + sizeof(*rfc1042));
3251 skb_push(skb, sizeof(*eth));
3253 eth = (void *)skb->data;
3254 ether_addr_copy(eth->h_dest, da);
3255 ether_addr_copy(eth->h_source, sa);
3256 eth->h_proto = type;
3259 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3260 struct ieee80211_vif *vif,
3261 struct sk_buff *skb)
3263 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3264 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3266 /* This is case only for P2P_GO */
3267 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
3268 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
3271 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3272 spin_lock_bh(&ar->data_lock);
3273 if (arvif->u.ap.noa_data)
3274 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3276 memcpy(skb_put(skb, arvif->u.ap.noa_len),
3277 arvif->u.ap.noa_data,
3278 arvif->u.ap.noa_len);
3279 spin_unlock_bh(&ar->data_lock);
3283 static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar)
3285 /* FIXME: Not really sure since when the behaviour changed. At some
3286 * point new firmware stopped requiring creation of peer entries for
3287 * offchannel tx (and actually creating them causes issues with wmi-htc
3288 * tx credit replenishment and reliability). Assuming it's at least 3.4
3289 * because that's when the `freq` was introduced to TX_FRM HTT command.
3291 return !(ar->htt.target_version_major >= 3 &&
3292 ar->htt.target_version_minor >= 4);
3295 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3297 struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3300 spin_lock_bh(&ar->data_lock);
3302 if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) {
3303 ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3308 __skb_queue_tail(q, skb);
3309 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3312 spin_unlock_bh(&ar->data_lock);
3317 static void ath10k_mac_tx(struct ath10k *ar, struct sk_buff *skb)
3319 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3320 struct ath10k_htt *htt = &ar->htt;
3323 switch (cb->txmode) {
3324 case ATH10K_HW_TXRX_RAW:
3325 case ATH10K_HW_TXRX_NATIVE_WIFI:
3326 case ATH10K_HW_TXRX_ETHERNET:
3327 ret = ath10k_htt_tx(htt, skb);
3329 case ATH10K_HW_TXRX_MGMT:
3330 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3332 ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
3333 else if (ar->htt.target_version_major >= 3)
3334 ret = ath10k_htt_tx(htt, skb);
3336 ret = ath10k_htt_mgmt_tx(htt, skb);
3341 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
3343 ieee80211_free_txskb(ar->hw, skb);
3347 void ath10k_offchan_tx_purge(struct ath10k *ar)
3349 struct sk_buff *skb;
3352 skb = skb_dequeue(&ar->offchan_tx_queue);
3356 ieee80211_free_txskb(ar->hw, skb);
3360 void ath10k_offchan_tx_work(struct work_struct *work)
3362 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
3363 struct ath10k_peer *peer;
3364 struct ieee80211_hdr *hdr;
3365 struct sk_buff *skb;
3366 const u8 *peer_addr;
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);
3391 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
3393 spin_lock_bh(&ar->data_lock);
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 ath10k_mac_tx(ar, skb);
3419 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
3421 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
3424 if (!peer && tmp_peer_created) {
3425 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
3427 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
3428 peer_addr, vdev_id, ret);
3431 mutex_unlock(&ar->conf_mutex);
3435 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
3437 struct sk_buff *skb;
3440 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3444 ieee80211_free_txskb(ar->hw, skb);
3448 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
3450 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
3451 struct sk_buff *skb;
3455 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3459 ret = ath10k_wmi_mgmt_tx(ar, skb);
3461 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
3463 ieee80211_free_txskb(ar->hw, skb);
3472 void __ath10k_scan_finish(struct ath10k *ar)
3474 lockdep_assert_held(&ar->data_lock);
3476 switch (ar->scan.state) {
3477 case ATH10K_SCAN_IDLE:
3479 case ATH10K_SCAN_RUNNING:
3480 case ATH10K_SCAN_ABORTING:
3481 if (!ar->scan.is_roc)
3482 ieee80211_scan_completed(ar->hw,
3484 ATH10K_SCAN_ABORTING));
3485 else if (ar->scan.roc_notify)
3486 ieee80211_remain_on_channel_expired(ar->hw);
3488 case ATH10K_SCAN_STARTING:
3489 ar->scan.state = ATH10K_SCAN_IDLE;
3490 ar->scan_channel = NULL;
3491 ath10k_offchan_tx_purge(ar);
3492 cancel_delayed_work(&ar->scan.timeout);
3493 complete_all(&ar->scan.completed);
3498 void ath10k_scan_finish(struct ath10k *ar)
3500 spin_lock_bh(&ar->data_lock);
3501 __ath10k_scan_finish(ar);
3502 spin_unlock_bh(&ar->data_lock);
3505 static int ath10k_scan_stop(struct ath10k *ar)
3507 struct wmi_stop_scan_arg arg = {
3508 .req_id = 1, /* FIXME */
3509 .req_type = WMI_SCAN_STOP_ONE,
3510 .u.scan_id = ATH10K_SCAN_ID,
3514 lockdep_assert_held(&ar->conf_mutex);
3516 ret = ath10k_wmi_stop_scan(ar, &arg);
3518 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
3522 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
3524 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
3526 } else if (ret > 0) {
3531 /* Scan state should be updated upon scan completion but in case
3532 * firmware fails to deliver the event (for whatever reason) it is
3533 * desired to clean up scan state anyway. Firmware may have just
3534 * dropped the scan completion event delivery due to transport pipe
3535 * being overflown with data and/or it can recover on its own before
3536 * next scan request is submitted.
3538 spin_lock_bh(&ar->data_lock);
3539 if (ar->scan.state != ATH10K_SCAN_IDLE)
3540 __ath10k_scan_finish(ar);
3541 spin_unlock_bh(&ar->data_lock);
3546 static void ath10k_scan_abort(struct ath10k *ar)
3550 lockdep_assert_held(&ar->conf_mutex);
3552 spin_lock_bh(&ar->data_lock);
3554 switch (ar->scan.state) {
3555 case ATH10K_SCAN_IDLE:
3556 /* This can happen if timeout worker kicked in and called
3557 * abortion while scan completion was being processed.
3560 case ATH10K_SCAN_STARTING:
3561 case ATH10K_SCAN_ABORTING:
3562 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3563 ath10k_scan_state_str(ar->scan.state),
3566 case ATH10K_SCAN_RUNNING:
3567 ar->scan.state = ATH10K_SCAN_ABORTING;
3568 spin_unlock_bh(&ar->data_lock);
3570 ret = ath10k_scan_stop(ar);
3572 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
3574 spin_lock_bh(&ar->data_lock);
3578 spin_unlock_bh(&ar->data_lock);
3581 void ath10k_scan_timeout_work(struct work_struct *work)
3583 struct ath10k *ar = container_of(work, struct ath10k,
3586 mutex_lock(&ar->conf_mutex);
3587 ath10k_scan_abort(ar);
3588 mutex_unlock(&ar->conf_mutex);
3591 static int ath10k_start_scan(struct ath10k *ar,
3592 const struct wmi_start_scan_arg *arg)
3596 lockdep_assert_held(&ar->conf_mutex);
3598 ret = ath10k_wmi_start_scan(ar, arg);
3602 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
3604 ret = ath10k_scan_stop(ar);
3606 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3611 /* If we failed to start the scan, return error code at
3612 * this point. This is probably due to some issue in the
3613 * firmware, but no need to wedge the driver due to that...
3615 spin_lock_bh(&ar->data_lock);
3616 if (ar->scan.state == ATH10K_SCAN_IDLE) {
3617 spin_unlock_bh(&ar->data_lock);
3620 spin_unlock_bh(&ar->data_lock);
3625 /**********************/
3626 /* mac80211 callbacks */
3627 /**********************/
3629 static void ath10k_tx(struct ieee80211_hw *hw,
3630 struct ieee80211_tx_control *control,
3631 struct sk_buff *skb)
3633 struct ath10k *ar = hw->priv;
3634 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3635 struct ieee80211_vif *vif = info->control.vif;
3636 struct ieee80211_sta *sta = control->sta;
3637 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3638 __le16 fc = hdr->frame_control;
3640 /* We should disable CCK RATE due to P2P */
3641 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
3642 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3644 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
3645 ATH10K_SKB_CB(skb)->htt.freq = 0;
3646 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
3647 ATH10K_SKB_CB(skb)->htt.nohwcrypt = !ath10k_tx_h_use_hwcrypto(vif, skb);
3648 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
3649 ATH10K_SKB_CB(skb)->txmode = ath10k_tx_h_get_txmode(ar, vif, sta, skb);
3650 ATH10K_SKB_CB(skb)->is_protected = ieee80211_has_protected(fc);
3652 switch (ATH10K_SKB_CB(skb)->txmode) {
3653 case ATH10K_HW_TXRX_MGMT:
3654 case ATH10K_HW_TXRX_NATIVE_WIFI:
3655 ath10k_tx_h_nwifi(hw, skb);
3656 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
3657 ath10k_tx_h_seq_no(vif, skb);
3659 case ATH10K_HW_TXRX_ETHERNET:
3660 ath10k_tx_h_8023(skb);
3662 case ATH10K_HW_TXRX_RAW:
3663 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
3665 ieee80211_free_txskb(hw, skb);
3670 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
3671 spin_lock_bh(&ar->data_lock);
3672 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
3673 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
3674 spin_unlock_bh(&ar->data_lock);
3676 if (ath10k_mac_need_offchan_tx_work(ar)) {
3677 ATH10K_SKB_CB(skb)->htt.freq = 0;
3678 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
3680 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
3683 skb_queue_tail(&ar->offchan_tx_queue, skb);
3684 ieee80211_queue_work(hw, &ar->offchan_tx_work);
3689 ath10k_mac_tx(ar, skb);
3692 /* Must not be called with conf_mutex held as workers can use that also. */
3693 void ath10k_drain_tx(struct ath10k *ar)
3695 /* make sure rcu-protected mac80211 tx path itself is drained */
3698 ath10k_offchan_tx_purge(ar);
3699 ath10k_mgmt_over_wmi_tx_purge(ar);
3701 cancel_work_sync(&ar->offchan_tx_work);
3702 cancel_work_sync(&ar->wmi_mgmt_tx_work);
3705 void ath10k_halt(struct ath10k *ar)
3707 struct ath10k_vif *arvif;
3709 lockdep_assert_held(&ar->conf_mutex);
3711 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
3712 ar->filter_flags = 0;
3713 ar->monitor = false;
3714 ar->monitor_arvif = NULL;
3716 if (ar->monitor_started)
3717 ath10k_monitor_stop(ar);
3719 ar->monitor_started = false;
3722 ath10k_scan_finish(ar);
3723 ath10k_peer_cleanup_all(ar);
3724 ath10k_core_stop(ar);
3725 ath10k_hif_power_down(ar);
3727 spin_lock_bh(&ar->data_lock);
3728 list_for_each_entry(arvif, &ar->arvifs, list)
3729 ath10k_mac_vif_beacon_cleanup(arvif);
3730 spin_unlock_bh(&ar->data_lock);
3733 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
3735 struct ath10k *ar = hw->priv;
3737 mutex_lock(&ar->conf_mutex);
3739 if (ar->cfg_tx_chainmask) {
3740 *tx_ant = ar->cfg_tx_chainmask;
3741 *rx_ant = ar->cfg_rx_chainmask;
3743 *tx_ant = ar->supp_tx_chainmask;
3744 *rx_ant = ar->supp_rx_chainmask;
3747 mutex_unlock(&ar->conf_mutex);
3752 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
3754 /* It is not clear that allowing gaps in chainmask
3755 * is helpful. Probably it will not do what user
3756 * is hoping for, so warn in that case.
3758 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
3761 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
3765 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
3769 lockdep_assert_held(&ar->conf_mutex);
3771 ath10k_check_chain_mask(ar, tx_ant, "tx");
3772 ath10k_check_chain_mask(ar, rx_ant, "rx");
3774 ar->cfg_tx_chainmask = tx_ant;
3775 ar->cfg_rx_chainmask = rx_ant;
3777 if ((ar->state != ATH10K_STATE_ON) &&
3778 (ar->state != ATH10K_STATE_RESTARTED))
3781 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
3784 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
3789 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
3792 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
3800 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
3802 struct ath10k *ar = hw->priv;
3805 mutex_lock(&ar->conf_mutex);
3806 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
3807 mutex_unlock(&ar->conf_mutex);
3811 static int ath10k_start(struct ieee80211_hw *hw)
3813 struct ath10k *ar = hw->priv;
3818 * This makes sense only when restarting hw. It is harmless to call
3819 * uncoditionally. This is necessary to make sure no HTT/WMI tx
3820 * commands will be submitted while restarting.
3822 ath10k_drain_tx(ar);
3824 mutex_lock(&ar->conf_mutex);
3826 switch (ar->state) {
3827 case ATH10K_STATE_OFF:
3828 ar->state = ATH10K_STATE_ON;
3830 case ATH10K_STATE_RESTARTING:
3832 ar->state = ATH10K_STATE_RESTARTED;
3834 case ATH10K_STATE_ON:
3835 case ATH10K_STATE_RESTARTED:
3836 case ATH10K_STATE_WEDGED:
3840 case ATH10K_STATE_UTF:
3845 ret = ath10k_hif_power_up(ar);
3847 ath10k_err(ar, "Could not init hif: %d\n", ret);
3851 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
3853 ath10k_err(ar, "Could not init core: %d\n", ret);
3854 goto err_power_down;
3857 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
3859 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
3863 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
3865 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
3869 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
3870 ret = ath10k_wmi_adaptive_qcs(ar, true);
3872 ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
3878 if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
3879 burst_enable = ar->wmi.pdev_param->burst_enable;
3880 ret = ath10k_wmi_pdev_set_param(ar, burst_enable, 0);
3882 ath10k_warn(ar, "failed to disable burst: %d\n", ret);
3887 if (ar->cfg_tx_chainmask)
3888 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
3889 ar->cfg_rx_chainmask);
3892 * By default FW set ARP frames ac to voice (6). In that case ARP
3893 * exchange is not working properly for UAPSD enabled AP. ARP requests
3894 * which arrives with access category 0 are processed by network stack
3895 * and send back with access category 0, but FW changes access category
3896 * to 6. Set ARP frames access category to best effort (0) solves
3900 ret = ath10k_wmi_pdev_set_param(ar,
3901 ar->wmi.pdev_param->arp_ac_override, 0);
3903 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
3908 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
3910 ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
3911 WMI_CCA_DETECT_LEVEL_AUTO,
3912 WMI_CCA_DETECT_MARGIN_AUTO);
3914 ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
3920 ret = ath10k_wmi_pdev_set_param(ar,
3921 ar->wmi.pdev_param->ani_enable, 1);
3923 ath10k_warn(ar, "failed to enable ani by default: %d\n",
3928 ar->ani_enabled = true;
3930 ar->num_started_vdevs = 0;
3931 ath10k_regd_update(ar);
3933 ath10k_spectral_start(ar);
3934 ath10k_thermal_set_throttling(ar);
3936 mutex_unlock(&ar->conf_mutex);
3940 ath10k_core_stop(ar);
3943 ath10k_hif_power_down(ar);
3946 ar->state = ATH10K_STATE_OFF;
3949 mutex_unlock(&ar->conf_mutex);
3953 static void ath10k_stop(struct ieee80211_hw *hw)
3955 struct ath10k *ar = hw->priv;
3957 ath10k_drain_tx(ar);
3959 mutex_lock(&ar->conf_mutex);
3960 if (ar->state != ATH10K_STATE_OFF) {
3962 ar->state = ATH10K_STATE_OFF;
3964 mutex_unlock(&ar->conf_mutex);
3966 cancel_delayed_work_sync(&ar->scan.timeout);
3967 cancel_work_sync(&ar->restart_work);
3970 static int ath10k_config_ps(struct ath10k *ar)
3972 struct ath10k_vif *arvif;
3975 lockdep_assert_held(&ar->conf_mutex);
3977 list_for_each_entry(arvif, &ar->arvifs, list) {
3978 ret = ath10k_mac_vif_setup_ps(arvif);
3980 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
3988 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
3993 lockdep_assert_held(&ar->conf_mutex);
3995 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
3997 param = ar->wmi.pdev_param->txpower_limit2g;
3998 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4000 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
4005 param = ar->wmi.pdev_param->txpower_limit5g;
4006 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
4008 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
4016 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
4018 struct ath10k_vif *arvif;
4019 int ret, txpower = -1;
4021 lockdep_assert_held(&ar->conf_mutex);
4023 list_for_each_entry(arvif, &ar->arvifs, list) {
4024 WARN_ON(arvif->txpower < 0);
4027 txpower = arvif->txpower;
4029 txpower = min(txpower, arvif->txpower);
4032 if (WARN_ON(txpower == -1))
4035 ret = ath10k_mac_txpower_setup(ar, txpower);
4037 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4045 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4047 struct ath10k *ar = hw->priv;
4048 struct ieee80211_conf *conf = &hw->conf;
4051 mutex_lock(&ar->conf_mutex);
4053 if (changed & IEEE80211_CONF_CHANGE_PS)
4054 ath10k_config_ps(ar);
4056 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4057 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4058 ret = ath10k_monitor_recalc(ar);
4060 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4063 mutex_unlock(&ar->conf_mutex);
4067 static u32 get_nss_from_chainmask(u16 chain_mask)
4069 if ((chain_mask & 0x15) == 0x15)
4071 else if ((chain_mask & 0x7) == 0x7)
4073 else if ((chain_mask & 0x3) == 0x3)
4078 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
4080 int nsts = ar->vht_cap_info;
4082 nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4083 nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4085 /* If firmware does not deliver to host number of space-time
4086 * streams supported, assume it support up to 4 BF STS and return
4087 * the value for VHT CAP: nsts-1)
4095 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
4097 int sound_dim = ar->vht_cap_info;
4099 sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4100 sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4102 /* If the sounding dimension is not advertised by the firmware,
4103 * let's use a default value of 1
4111 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
4114 struct ath10k *ar = arvif->ar;
4118 if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
4121 nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
4122 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4123 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
4124 value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
4126 sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4127 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4128 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
4129 value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
4134 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
4135 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
4137 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
4138 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
4139 WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
4141 if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
4142 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
4144 if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
4145 value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
4146 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
4148 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4149 ar->wmi.vdev_param->txbf, value);
4154 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4155 * because we will send mgmt frames without CCK. This requirement
4156 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4159 static int ath10k_add_interface(struct ieee80211_hw *hw,
4160 struct ieee80211_vif *vif)
4162 struct ath10k *ar = hw->priv;
4163 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4164 enum wmi_sta_powersave_param param;
4171 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4173 mutex_lock(&ar->conf_mutex);
4175 memset(arvif, 0, sizeof(*arvif));
4180 INIT_LIST_HEAD(&arvif->list);
4181 INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4182 INIT_DELAYED_WORK(&arvif->connection_loss_work,
4183 ath10k_mac_vif_sta_connection_loss_work);
4185 for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4186 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4187 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4188 sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4189 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4190 sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4193 if (ar->num_peers >= ar->max_num_peers) {
4194 ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4199 if (ar->free_vdev_map == 0) {
4200 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4204 bit = __ffs64(ar->free_vdev_map);
4206 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4207 bit, ar->free_vdev_map);
4209 arvif->vdev_id = bit;
4210 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
4212 switch (vif->type) {
4213 case NL80211_IFTYPE_P2P_DEVICE:
4214 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4215 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
4217 case NL80211_IFTYPE_UNSPECIFIED:
4218 case NL80211_IFTYPE_STATION:
4219 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4221 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
4223 case NL80211_IFTYPE_ADHOC:
4224 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4226 case NL80211_IFTYPE_MESH_POINT:
4227 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4229 ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
4232 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4234 case NL80211_IFTYPE_AP:
4235 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4238 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
4240 case NL80211_IFTYPE_MONITOR:
4241 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4248 /* Using vdev_id as queue number will make it very easy to do per-vif
4249 * tx queue locking. This shouldn't wrap due to interface combinations
4250 * but do a modulo for correctness sake and prevent using offchannel tx
4251 * queues for regular vif tx.
4253 vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4254 for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4255 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4257 /* Some firmware revisions don't wait for beacon tx completion before
4258 * sending another SWBA event. This could lead to hardware using old
4259 * (freed) beacon data in some cases, e.g. tx credit starvation
4260 * combined with missed TBTT. This is very very rare.
4262 * On non-IOMMU-enabled hosts this could be a possible security issue
4263 * because hw could beacon some random data on the air. On
4264 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4265 * device would crash.
4267 * Since there are no beacon tx completions (implicit nor explicit)
4268 * propagated to host the only workaround for this is to allocate a
4269 * DMA-coherent buffer for a lifetime of a vif and use it for all
4270 * beacon tx commands. Worst case for this approach is some beacons may
4271 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4273 if (vif->type == NL80211_IFTYPE_ADHOC ||
4274 vif->type == NL80211_IFTYPE_MESH_POINT ||
4275 vif->type == NL80211_IFTYPE_AP) {
4276 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4277 IEEE80211_MAX_FRAME_LEN,
4278 &arvif->beacon_paddr,
4280 if (!arvif->beacon_buf) {
4282 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4287 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
4288 arvif->nohwcrypt = true;
4290 if (arvif->nohwcrypt &&
4291 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
4292 ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
4296 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4297 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4298 arvif->beacon_buf ? "single-buf" : "per-skb");
4300 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4301 arvif->vdev_subtype, vif->addr);
4303 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4304 arvif->vdev_id, ret);
4308 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4309 list_add(&arvif->list, &ar->arvifs);
4311 /* It makes no sense to have firmware do keepalives. mac80211 already
4312 * takes care of this with idle connection polling.
4314 ret = ath10k_mac_vif_disable_keepalive(arvif);
4316 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4317 arvif->vdev_id, ret);
4318 goto err_vdev_delete;
4321 arvif->def_wep_key_idx = -1;
4323 vdev_param = ar->wmi.vdev_param->tx_encap_type;
4324 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4325 ATH10K_HW_TXRX_NATIVE_WIFI);
4326 /* 10.X firmware does not support this VDEV parameter. Do not warn */
4327 if (ret && ret != -EOPNOTSUPP) {
4328 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4329 arvif->vdev_id, ret);
4330 goto err_vdev_delete;
4333 if (ar->cfg_tx_chainmask) {
4334 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4336 vdev_param = ar->wmi.vdev_param->nss;
4337 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4340 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4341 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4343 goto err_vdev_delete;
4347 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4348 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4349 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4350 WMI_PEER_TYPE_DEFAULT);
4352 ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4353 arvif->vdev_id, ret);
4354 goto err_vdev_delete;
4358 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4359 ret = ath10k_mac_set_kickout(arvif);
4361 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4362 arvif->vdev_id, ret);
4363 goto err_peer_delete;
4367 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4368 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4369 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4370 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4373 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4374 arvif->vdev_id, ret);
4375 goto err_peer_delete;
4378 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4380 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4381 arvif->vdev_id, ret);
4382 goto err_peer_delete;
4385 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4387 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4388 arvif->vdev_id, ret);
4389 goto err_peer_delete;
4393 ret = ath10k_mac_set_txbf_conf(arvif);
4395 ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
4396 arvif->vdev_id, ret);
4397 goto err_peer_delete;
4400 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4402 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4403 arvif->vdev_id, ret);
4404 goto err_peer_delete;
4407 arvif->txpower = vif->bss_conf.txpower;
4408 ret = ath10k_mac_txpower_recalc(ar);
4410 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4411 goto err_peer_delete;
4414 if (vif->type == NL80211_IFTYPE_MONITOR) {
4415 ar->monitor_arvif = arvif;
4416 ret = ath10k_monitor_recalc(ar);
4418 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4419 goto err_peer_delete;
4423 spin_lock_bh(&ar->htt.tx_lock);
4425 ieee80211_wake_queue(ar->hw, arvif->vdev_id);
4426 spin_unlock_bh(&ar->htt.tx_lock);
4428 mutex_unlock(&ar->conf_mutex);
4432 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4433 arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4434 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4437 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4438 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4439 list_del(&arvif->list);
4442 if (arvif->beacon_buf) {
4443 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4444 arvif->beacon_buf, arvif->beacon_paddr);
4445 arvif->beacon_buf = NULL;
4448 mutex_unlock(&ar->conf_mutex);
4453 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4457 for (i = 0; i < BITS_PER_LONG; i++)
4458 ath10k_mac_vif_tx_unlock(arvif, i);
4461 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4462 struct ieee80211_vif *vif)
4464 struct ath10k *ar = hw->priv;
4465 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4468 cancel_work_sync(&arvif->ap_csa_work);
4469 cancel_delayed_work_sync(&arvif->connection_loss_work);
4471 mutex_lock(&ar->conf_mutex);
4473 spin_lock_bh(&ar->data_lock);
4474 ath10k_mac_vif_beacon_cleanup(arvif);
4475 spin_unlock_bh(&ar->data_lock);
4477 ret = ath10k_spectral_vif_stop(arvif);
4479 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4480 arvif->vdev_id, ret);
4482 ar->free_vdev_map |= 1LL << arvif->vdev_id;
4483 list_del(&arvif->list);
4485 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4486 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4487 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4490 ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4491 arvif->vdev_id, ret);
4493 kfree(arvif->u.ap.noa_data);
4496 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4499 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4501 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4502 arvif->vdev_id, ret);
4504 /* Some firmware revisions don't notify host about self-peer removal
4505 * until after associated vdev is deleted.
4507 if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4508 arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4509 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4512 ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4513 arvif->vdev_id, ret);
4515 spin_lock_bh(&ar->data_lock);
4517 spin_unlock_bh(&ar->data_lock);
4520 ath10k_peer_cleanup(ar, arvif->vdev_id);
4522 if (vif->type == NL80211_IFTYPE_MONITOR) {
4523 ar->monitor_arvif = NULL;
4524 ret = ath10k_monitor_recalc(ar);
4526 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4529 spin_lock_bh(&ar->htt.tx_lock);
4530 ath10k_mac_vif_tx_unlock_all(arvif);
4531 spin_unlock_bh(&ar->htt.tx_lock);
4533 mutex_unlock(&ar->conf_mutex);
4537 * FIXME: Has to be verified.
4539 #define SUPPORTED_FILTERS \
4544 FIF_BCN_PRBRESP_PROMISC | \
4548 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4549 unsigned int changed_flags,
4550 unsigned int *total_flags,
4553 struct ath10k *ar = hw->priv;
4556 mutex_lock(&ar->conf_mutex);
4558 changed_flags &= SUPPORTED_FILTERS;
4559 *total_flags &= SUPPORTED_FILTERS;
4560 ar->filter_flags = *total_flags;
4562 ret = ath10k_monitor_recalc(ar);
4564 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4566 mutex_unlock(&ar->conf_mutex);
4569 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4570 struct ieee80211_vif *vif,
4571 struct ieee80211_bss_conf *info,
4574 struct ath10k *ar = hw->priv;
4575 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4577 u32 vdev_param, pdev_param, slottime, preamble;
4579 mutex_lock(&ar->conf_mutex);
4581 if (changed & BSS_CHANGED_IBSS)
4582 ath10k_control_ibss(arvif, info, vif->addr);
4584 if (changed & BSS_CHANGED_BEACON_INT) {
4585 arvif->beacon_interval = info->beacon_int;
4586 vdev_param = ar->wmi.vdev_param->beacon_interval;
4587 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4588 arvif->beacon_interval);
4589 ath10k_dbg(ar, ATH10K_DBG_MAC,
4590 "mac vdev %d beacon_interval %d\n",
4591 arvif->vdev_id, arvif->beacon_interval);
4594 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4595 arvif->vdev_id, ret);
4598 if (changed & BSS_CHANGED_BEACON) {
4599 ath10k_dbg(ar, ATH10K_DBG_MAC,
4600 "vdev %d set beacon tx mode to staggered\n",
4603 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4604 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4605 WMI_BEACON_STAGGERED_MODE);
4607 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4608 arvif->vdev_id, ret);
4610 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4612 ath10k_warn(ar, "failed to update beacon template: %d\n",
4615 if (ieee80211_vif_is_mesh(vif)) {
4616 /* mesh doesn't use SSID but firmware needs it */
4617 strncpy(arvif->u.ap.ssid, "mesh",
4618 sizeof(arvif->u.ap.ssid));
4619 arvif->u.ap.ssid_len = 4;
4623 if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4624 ret = ath10k_mac_setup_prb_tmpl(arvif);
4626 ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4627 arvif->vdev_id, ret);
4630 if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4631 arvif->dtim_period = info->dtim_period;
4633 ath10k_dbg(ar, ATH10K_DBG_MAC,
4634 "mac vdev %d dtim_period %d\n",
4635 arvif->vdev_id, arvif->dtim_period);
4637 vdev_param = ar->wmi.vdev_param->dtim_period;
4638 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4639 arvif->dtim_period);
4641 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4642 arvif->vdev_id, ret);
4645 if (changed & BSS_CHANGED_SSID &&
4646 vif->type == NL80211_IFTYPE_AP) {
4647 arvif->u.ap.ssid_len = info->ssid_len;
4649 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4650 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4653 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4654 ether_addr_copy(arvif->bssid, info->bssid);
4656 if (changed & BSS_CHANGED_BEACON_ENABLED)
4657 ath10k_control_beaconing(arvif, info);
4659 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4660 arvif->use_cts_prot = info->use_cts_prot;
4661 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4662 arvif->vdev_id, info->use_cts_prot);
4664 ret = ath10k_recalc_rtscts_prot(arvif);
4666 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4667 arvif->vdev_id, ret);
4669 vdev_param = ar->wmi.vdev_param->protection_mode;
4670 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4671 info->use_cts_prot ? 1 : 0);
4673 ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4674 info->use_cts_prot, arvif->vdev_id, ret);
4677 if (changed & BSS_CHANGED_ERP_SLOT) {
4678 if (info->use_short_slot)
4679 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4682 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4684 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4685 arvif->vdev_id, slottime);
4687 vdev_param = ar->wmi.vdev_param->slot_time;
4688 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4691 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4692 arvif->vdev_id, ret);
4695 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4696 if (info->use_short_preamble)
4697 preamble = WMI_VDEV_PREAMBLE_SHORT;
4699 preamble = WMI_VDEV_PREAMBLE_LONG;
4701 ath10k_dbg(ar, ATH10K_DBG_MAC,
4702 "mac vdev %d preamble %dn",
4703 arvif->vdev_id, preamble);
4705 vdev_param = ar->wmi.vdev_param->preamble;
4706 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4709 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4710 arvif->vdev_id, ret);
4713 if (changed & BSS_CHANGED_ASSOC) {
4715 /* Workaround: Make sure monitor vdev is not running
4716 * when associating to prevent some firmware revisions
4717 * (e.g. 10.1 and 10.2) from crashing.
4719 if (ar->monitor_started)
4720 ath10k_monitor_stop(ar);
4721 ath10k_bss_assoc(hw, vif, info);
4722 ath10k_monitor_recalc(ar);
4724 ath10k_bss_disassoc(hw, vif);
4728 if (changed & BSS_CHANGED_TXPOWER) {
4729 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4730 arvif->vdev_id, info->txpower);
4732 arvif->txpower = info->txpower;
4733 ret = ath10k_mac_txpower_recalc(ar);
4735 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4738 if (changed & BSS_CHANGED_PS) {
4739 arvif->ps = vif->bss_conf.ps;
4741 ret = ath10k_config_ps(ar);
4743 ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4744 arvif->vdev_id, ret);
4747 mutex_unlock(&ar->conf_mutex);
4750 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4751 struct ieee80211_vif *vif,
4752 struct ieee80211_scan_request *hw_req)
4754 struct ath10k *ar = hw->priv;
4755 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4756 struct cfg80211_scan_request *req = &hw_req->req;
4757 struct wmi_start_scan_arg arg;
4761 mutex_lock(&ar->conf_mutex);
4763 spin_lock_bh(&ar->data_lock);
4764 switch (ar->scan.state) {
4765 case ATH10K_SCAN_IDLE:
4766 reinit_completion(&ar->scan.started);
4767 reinit_completion(&ar->scan.completed);
4768 ar->scan.state = ATH10K_SCAN_STARTING;
4769 ar->scan.is_roc = false;
4770 ar->scan.vdev_id = arvif->vdev_id;
4773 case ATH10K_SCAN_STARTING:
4774 case ATH10K_SCAN_RUNNING:
4775 case ATH10K_SCAN_ABORTING:
4779 spin_unlock_bh(&ar->data_lock);
4784 memset(&arg, 0, sizeof(arg));
4785 ath10k_wmi_start_scan_init(ar, &arg);
4786 arg.vdev_id = arvif->vdev_id;
4787 arg.scan_id = ATH10K_SCAN_ID;
4790 arg.ie_len = req->ie_len;
4791 memcpy(arg.ie, req->ie, arg.ie_len);
4795 arg.n_ssids = req->n_ssids;
4796 for (i = 0; i < arg.n_ssids; i++) {
4797 arg.ssids[i].len = req->ssids[i].ssid_len;
4798 arg.ssids[i].ssid = req->ssids[i].ssid;
4801 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4804 if (req->n_channels) {
4805 arg.n_channels = req->n_channels;
4806 for (i = 0; i < arg.n_channels; i++)
4807 arg.channels[i] = req->channels[i]->center_freq;
4810 ret = ath10k_start_scan(ar, &arg);
4812 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4813 spin_lock_bh(&ar->data_lock);
4814 ar->scan.state = ATH10K_SCAN_IDLE;
4815 spin_unlock_bh(&ar->data_lock);
4818 /* Add a 200ms margin to account for event/command processing */
4819 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
4820 msecs_to_jiffies(arg.max_scan_time +
4824 mutex_unlock(&ar->conf_mutex);
4828 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4829 struct ieee80211_vif *vif)
4831 struct ath10k *ar = hw->priv;
4833 mutex_lock(&ar->conf_mutex);
4834 ath10k_scan_abort(ar);
4835 mutex_unlock(&ar->conf_mutex);
4837 cancel_delayed_work_sync(&ar->scan.timeout);
4840 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4841 struct ath10k_vif *arvif,
4842 enum set_key_cmd cmd,
4843 struct ieee80211_key_conf *key)
4845 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
4848 /* 10.1 firmware branch requires default key index to be set to group
4849 * key index after installing it. Otherwise FW/HW Txes corrupted
4850 * frames with multi-vif APs. This is not required for main firmware
4851 * branch (e.g. 636).
4853 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4855 * FIXME: It remains unknown if this is required for multi-vif STA
4856 * interfaces on 10.1.
4859 if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
4860 arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
4863 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
4866 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
4869 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4875 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4878 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
4879 arvif->vdev_id, ret);
4882 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4883 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
4884 struct ieee80211_key_conf *key)
4886 struct ath10k *ar = hw->priv;
4887 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4888 struct ath10k_peer *peer;
4889 const u8 *peer_addr;
4890 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
4891 key->cipher == WLAN_CIPHER_SUITE_WEP104;
4897 /* this one needs to be done in software */
4898 if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
4901 if (arvif->nohwcrypt)
4904 if (key->keyidx > WMI_MAX_KEY_INDEX)
4907 mutex_lock(&ar->conf_mutex);
4910 peer_addr = sta->addr;
4911 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
4912 peer_addr = vif->bss_conf.bssid;
4914 peer_addr = vif->addr;
4916 key->hw_key_idx = key->keyidx;
4920 arvif->wep_keys[key->keyidx] = key;
4922 arvif->wep_keys[key->keyidx] = NULL;
4925 /* the peer should not disappear in mid-way (unless FW goes awry) since
4926 * we already hold conf_mutex. we just make sure its there now. */
4927 spin_lock_bh(&ar->data_lock);
4928 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
4929 spin_unlock_bh(&ar->data_lock);
4932 if (cmd == SET_KEY) {
4933 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
4938 /* if the peer doesn't exist there is no key to disable
4944 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4945 flags |= WMI_KEY_PAIRWISE;
4947 flags |= WMI_KEY_GROUP;
4950 if (cmd == DISABLE_KEY)
4951 ath10k_clear_vdev_key(arvif, key);
4953 /* When WEP keys are uploaded it's possible that there are
4954 * stations associated already (e.g. when merging) without any
4955 * keys. Static WEP needs an explicit per-peer key upload.
4957 if (vif->type == NL80211_IFTYPE_ADHOC &&
4959 ath10k_mac_vif_update_wep_key(arvif, key);
4961 /* 802.1x never sets the def_wep_key_idx so each set_key()
4962 * call changes default tx key.
4964 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
4965 * after first set_key().
4967 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
4968 flags |= WMI_KEY_TX_USAGE;
4971 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
4974 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
4975 arvif->vdev_id, peer_addr, ret);
4979 /* mac80211 sets static WEP keys as groupwise while firmware requires
4980 * them to be installed twice as both pairwise and groupwise.
4982 if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
4984 flags2 &= ~WMI_KEY_GROUP;
4985 flags2 |= WMI_KEY_PAIRWISE;
4987 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
4990 ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
4991 arvif->vdev_id, peer_addr, ret);
4992 ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
4996 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
4997 arvif->vdev_id, peer_addr, ret2);
5003 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
5005 spin_lock_bh(&ar->data_lock);
5006 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
5007 if (peer && cmd == SET_KEY)
5008 peer->keys[key->keyidx] = key;
5009 else if (peer && cmd == DISABLE_KEY)
5010 peer->keys[key->keyidx] = NULL;
5011 else if (peer == NULL)
5012 /* impossible unless FW goes crazy */
5013 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5014 spin_unlock_bh(&ar->data_lock);
5017 mutex_unlock(&ar->conf_mutex);
5021 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
5022 struct ieee80211_vif *vif,
5025 struct ath10k *ar = hw->priv;
5026 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5029 mutex_lock(&arvif->ar->conf_mutex);
5031 if (arvif->ar->state != ATH10K_STATE_ON)
5034 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
5035 arvif->vdev_id, keyidx);
5037 ret = ath10k_wmi_vdev_set_param(arvif->ar,
5039 arvif->ar->wmi.vdev_param->def_keyid,
5043 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
5049 arvif->def_wep_key_idx = keyidx;
5052 mutex_unlock(&arvif->ar->conf_mutex);
5055 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
5058 struct ath10k_vif *arvif;
5059 struct ath10k_sta *arsta;
5060 struct ieee80211_sta *sta;
5061 struct cfg80211_chan_def def;
5062 enum ieee80211_band band;
5063 const u8 *ht_mcs_mask;
5064 const u16 *vht_mcs_mask;
5065 u32 changed, bw, nss, smps;
5068 arsta = container_of(wk, struct ath10k_sta, update_wk);
5069 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
5070 arvif = arsta->arvif;
5073 if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
5076 band = def.chan->band;
5077 ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
5078 vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
5080 spin_lock_bh(&ar->data_lock);
5082 changed = arsta->changed;
5089 spin_unlock_bh(&ar->data_lock);
5091 mutex_lock(&ar->conf_mutex);
5093 nss = max_t(u32, 1, nss);
5094 nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5095 ath10k_mac_max_vht_nss(vht_mcs_mask)));
5097 if (changed & IEEE80211_RC_BW_CHANGED) {
5098 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
5101 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5102 WMI_PEER_CHAN_WIDTH, bw);
5104 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
5105 sta->addr, bw, err);
5108 if (changed & IEEE80211_RC_NSS_CHANGED) {
5109 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
5112 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5115 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
5116 sta->addr, nss, err);
5119 if (changed & IEEE80211_RC_SMPS_CHANGED) {
5120 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
5123 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
5124 WMI_PEER_SMPS_STATE, smps);
5126 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
5127 sta->addr, smps, err);
5130 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
5131 changed & IEEE80211_RC_NSS_CHANGED) {
5132 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
5135 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
5137 ath10k_warn(ar, "failed to reassociate station: %pM\n",
5141 mutex_unlock(&ar->conf_mutex);
5144 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
5145 struct ieee80211_sta *sta)
5147 struct ath10k *ar = arvif->ar;
5149 lockdep_assert_held(&ar->conf_mutex);
5151 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5154 if (ar->num_stations >= ar->max_num_stations)
5162 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5163 struct ieee80211_sta *sta)
5165 struct ath10k *ar = arvif->ar;
5167 lockdep_assert_held(&ar->conf_mutex);
5169 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5175 struct ath10k_mac_tdls_iter_data {
5176 u32 num_tdls_stations;
5177 struct ieee80211_vif *curr_vif;
5180 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5181 struct ieee80211_sta *sta)
5183 struct ath10k_mac_tdls_iter_data *iter_data = data;
5184 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5185 struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5187 if (sta->tdls && sta_vif == iter_data->curr_vif)
5188 iter_data->num_tdls_stations++;
5191 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5192 struct ieee80211_vif *vif)
5194 struct ath10k_mac_tdls_iter_data data = {};
5196 data.curr_vif = vif;
5198 ieee80211_iterate_stations_atomic(hw,
5199 ath10k_mac_tdls_vif_stations_count_iter,
5201 return data.num_tdls_stations;
5204 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5205 struct ieee80211_vif *vif)
5207 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5208 int *num_tdls_vifs = data;
5210 if (vif->type != NL80211_IFTYPE_STATION)
5213 if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5217 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5219 int num_tdls_vifs = 0;
5221 ieee80211_iterate_active_interfaces_atomic(hw,
5222 IEEE80211_IFACE_ITER_NORMAL,
5223 ath10k_mac_tdls_vifs_count_iter,
5225 return num_tdls_vifs;
5228 static int ath10k_sta_state(struct ieee80211_hw *hw,
5229 struct ieee80211_vif *vif,
5230 struct ieee80211_sta *sta,
5231 enum ieee80211_sta_state old_state,
5232 enum ieee80211_sta_state new_state)
5234 struct ath10k *ar = hw->priv;
5235 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5236 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5239 if (old_state == IEEE80211_STA_NOTEXIST &&
5240 new_state == IEEE80211_STA_NONE) {
5241 memset(arsta, 0, sizeof(*arsta));
5242 arsta->arvif = arvif;
5243 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5246 /* cancel must be done outside the mutex to avoid deadlock */
5247 if ((old_state == IEEE80211_STA_NONE &&
5248 new_state == IEEE80211_STA_NOTEXIST))
5249 cancel_work_sync(&arsta->update_wk);
5251 mutex_lock(&ar->conf_mutex);
5253 if (old_state == IEEE80211_STA_NOTEXIST &&
5254 new_state == IEEE80211_STA_NONE) {
5256 * New station addition.
5258 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5259 u32 num_tdls_stations;
5262 ath10k_dbg(ar, ATH10K_DBG_MAC,
5263 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5264 arvif->vdev_id, sta->addr,
5265 ar->num_stations + 1, ar->max_num_stations,
5266 ar->num_peers + 1, ar->max_num_peers);
5268 ret = ath10k_mac_inc_num_stations(arvif, sta);
5270 ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5271 ar->max_num_stations);
5276 peer_type = WMI_PEER_TYPE_TDLS;
5278 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5281 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5282 sta->addr, arvif->vdev_id, ret);
5283 ath10k_mac_dec_num_stations(arvif, sta);
5290 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5291 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5293 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5294 num_tdls_stations == 0) {
5295 ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5296 arvif->vdev_id, ar->max_num_tdls_vdevs);
5297 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5298 ath10k_mac_dec_num_stations(arvif, sta);
5303 if (num_tdls_stations == 0) {
5304 /* This is the first tdls peer in current vif */
5305 enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5307 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5310 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5311 arvif->vdev_id, ret);
5312 ath10k_peer_delete(ar, arvif->vdev_id,
5314 ath10k_mac_dec_num_stations(arvif, sta);
5319 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5320 WMI_TDLS_PEER_STATE_PEERING);
5323 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5324 sta->addr, arvif->vdev_id, ret);
5325 ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5326 ath10k_mac_dec_num_stations(arvif, sta);
5328 if (num_tdls_stations != 0)
5330 ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5333 } else if ((old_state == IEEE80211_STA_NONE &&
5334 new_state == IEEE80211_STA_NOTEXIST)) {
5336 * Existing station deletion.
5338 ath10k_dbg(ar, ATH10K_DBG_MAC,
5339 "mac vdev %d peer delete %pM (sta gone)\n",
5340 arvif->vdev_id, sta->addr);
5342 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5344 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5345 sta->addr, arvif->vdev_id, ret);
5347 ath10k_mac_dec_num_stations(arvif, sta);
5352 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5355 /* This was the last tdls peer in current vif */
5356 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5359 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5360 arvif->vdev_id, ret);
5362 } else if (old_state == IEEE80211_STA_AUTH &&
5363 new_state == IEEE80211_STA_ASSOC &&
5364 (vif->type == NL80211_IFTYPE_AP ||
5365 vif->type == NL80211_IFTYPE_MESH_POINT ||
5366 vif->type == NL80211_IFTYPE_ADHOC)) {
5370 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5373 ret = ath10k_station_assoc(ar, vif, sta, false);
5375 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5376 sta->addr, arvif->vdev_id, ret);
5377 } else if (old_state == IEEE80211_STA_ASSOC &&
5378 new_state == IEEE80211_STA_AUTHORIZED &&
5381 * Tdls station authorized.
5383 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5386 ret = ath10k_station_assoc(ar, vif, sta, false);
5388 ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5389 sta->addr, arvif->vdev_id, ret);
5393 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5394 WMI_TDLS_PEER_STATE_CONNECTED);
5396 ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5397 sta->addr, arvif->vdev_id, ret);
5398 } else if (old_state == IEEE80211_STA_ASSOC &&
5399 new_state == IEEE80211_STA_AUTH &&
5400 (vif->type == NL80211_IFTYPE_AP ||
5401 vif->type == NL80211_IFTYPE_MESH_POINT ||
5402 vif->type == NL80211_IFTYPE_ADHOC)) {
5406 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5409 ret = ath10k_station_disassoc(ar, vif, sta);
5411 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5412 sta->addr, arvif->vdev_id, ret);
5415 mutex_unlock(&ar->conf_mutex);
5419 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5420 u16 ac, bool enable)
5422 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5423 struct wmi_sta_uapsd_auto_trig_arg arg = {};
5424 u32 prio = 0, acc = 0;
5428 lockdep_assert_held(&ar->conf_mutex);
5430 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5434 case IEEE80211_AC_VO:
5435 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5436 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5440 case IEEE80211_AC_VI:
5441 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5442 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5446 case IEEE80211_AC_BE:
5447 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5448 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5452 case IEEE80211_AC_BK:
5453 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5454 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5461 arvif->u.sta.uapsd |= value;
5463 arvif->u.sta.uapsd &= ~value;
5465 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5466 WMI_STA_PS_PARAM_UAPSD,
5467 arvif->u.sta.uapsd);
5469 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5473 if (arvif->u.sta.uapsd)
5474 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5476 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5478 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5479 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5482 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5484 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5486 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5487 arvif->vdev_id, ret);
5491 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5493 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5494 arvif->vdev_id, ret);
5498 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5499 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5500 /* Only userspace can make an educated decision when to send
5501 * trigger frame. The following effectively disables u-UAPSD
5502 * autotrigger in firmware (which is enabled by default
5503 * provided the autotrigger service is available).
5507 arg.user_priority = prio;
5508 arg.service_interval = 0;
5509 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5510 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5512 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5513 arvif->bssid, &arg, 1);
5515 ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5525 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5526 struct ieee80211_vif *vif, u16 ac,
5527 const struct ieee80211_tx_queue_params *params)
5529 struct ath10k *ar = hw->priv;
5530 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5531 struct wmi_wmm_params_arg *p = NULL;
5534 mutex_lock(&ar->conf_mutex);
5537 case IEEE80211_AC_VO:
5538 p = &arvif->wmm_params.ac_vo;
5540 case IEEE80211_AC_VI:
5541 p = &arvif->wmm_params.ac_vi;
5543 case IEEE80211_AC_BE:
5544 p = &arvif->wmm_params.ac_be;
5546 case IEEE80211_AC_BK:
5547 p = &arvif->wmm_params.ac_bk;
5556 p->cwmin = params->cw_min;
5557 p->cwmax = params->cw_max;
5558 p->aifs = params->aifs;
5561 * The channel time duration programmed in the HW is in absolute
5562 * microseconds, while mac80211 gives the txop in units of
5565 p->txop = params->txop * 32;
5567 if (ar->wmi.ops->gen_vdev_wmm_conf) {
5568 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5569 &arvif->wmm_params);
5571 ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5572 arvif->vdev_id, ret);
5576 /* This won't work well with multi-interface cases but it's
5577 * better than nothing.
5579 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5581 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5586 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5588 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5591 mutex_unlock(&ar->conf_mutex);
5595 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5597 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5598 struct ieee80211_vif *vif,
5599 struct ieee80211_channel *chan,
5601 enum ieee80211_roc_type type)
5603 struct ath10k *ar = hw->priv;
5604 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5605 struct wmi_start_scan_arg arg;
5609 mutex_lock(&ar->conf_mutex);
5611 spin_lock_bh(&ar->data_lock);
5612 switch (ar->scan.state) {
5613 case ATH10K_SCAN_IDLE:
5614 reinit_completion(&ar->scan.started);
5615 reinit_completion(&ar->scan.completed);
5616 reinit_completion(&ar->scan.on_channel);
5617 ar->scan.state = ATH10K_SCAN_STARTING;
5618 ar->scan.is_roc = true;
5619 ar->scan.vdev_id = arvif->vdev_id;
5620 ar->scan.roc_freq = chan->center_freq;
5621 ar->scan.roc_notify = true;
5624 case ATH10K_SCAN_STARTING:
5625 case ATH10K_SCAN_RUNNING:
5626 case ATH10K_SCAN_ABORTING:
5630 spin_unlock_bh(&ar->data_lock);
5635 scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5637 memset(&arg, 0, sizeof(arg));
5638 ath10k_wmi_start_scan_init(ar, &arg);
5639 arg.vdev_id = arvif->vdev_id;
5640 arg.scan_id = ATH10K_SCAN_ID;
5642 arg.channels[0] = chan->center_freq;
5643 arg.dwell_time_active = scan_time_msec;
5644 arg.dwell_time_passive = scan_time_msec;
5645 arg.max_scan_time = scan_time_msec;
5646 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5647 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5648 arg.burst_duration_ms = duration;
5650 ret = ath10k_start_scan(ar, &arg);
5652 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5653 spin_lock_bh(&ar->data_lock);
5654 ar->scan.state = ATH10K_SCAN_IDLE;
5655 spin_unlock_bh(&ar->data_lock);
5659 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5661 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5663 ret = ath10k_scan_stop(ar);
5665 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5671 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5672 msecs_to_jiffies(duration));
5676 mutex_unlock(&ar->conf_mutex);
5680 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5682 struct ath10k *ar = hw->priv;
5684 mutex_lock(&ar->conf_mutex);
5686 spin_lock_bh(&ar->data_lock);
5687 ar->scan.roc_notify = false;
5688 spin_unlock_bh(&ar->data_lock);
5690 ath10k_scan_abort(ar);
5692 mutex_unlock(&ar->conf_mutex);
5694 cancel_delayed_work_sync(&ar->scan.timeout);
5700 * Both RTS and Fragmentation threshold are interface-specific
5701 * in ath10k, but device-specific in mac80211.
5704 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5706 struct ath10k *ar = hw->priv;
5707 struct ath10k_vif *arvif;
5710 mutex_lock(&ar->conf_mutex);
5711 list_for_each_entry(arvif, &ar->arvifs, list) {
5712 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5713 arvif->vdev_id, value);
5715 ret = ath10k_mac_set_rts(arvif, value);
5717 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5718 arvif->vdev_id, ret);
5722 mutex_unlock(&ar->conf_mutex);
5727 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5729 /* Even though there's a WMI enum for fragmentation threshold no known
5730 * firmware actually implements it. Moreover it is not possible to rely
5731 * frame fragmentation to mac80211 because firmware clears the "more
5732 * fragments" bit in frame control making it impossible for remote
5733 * devices to reassemble frames.
5735 * Hence implement a dummy callback just to say fragmentation isn't
5736 * supported. This effectively prevents mac80211 from doing frame
5737 * fragmentation in software.
5742 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5743 u32 queues, bool drop)
5745 struct ath10k *ar = hw->priv;
5749 /* mac80211 doesn't care if we really xmit queued frames or not
5750 * we'll collect those frames either way if we stop/delete vdevs */
5754 mutex_lock(&ar->conf_mutex);
5756 if (ar->state == ATH10K_STATE_WEDGED)
5759 time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5762 spin_lock_bh(&ar->htt.tx_lock);
5763 empty = (ar->htt.num_pending_tx == 0);
5764 spin_unlock_bh(&ar->htt.tx_lock);
5766 skip = (ar->state == ATH10K_STATE_WEDGED) ||
5767 test_bit(ATH10K_FLAG_CRASH_FLUSH,
5771 }), ATH10K_FLUSH_TIMEOUT_HZ);
5773 if (time_left == 0 || skip)
5774 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5775 skip, ar->state, time_left);
5778 mutex_unlock(&ar->conf_mutex);
5781 /* TODO: Implement this function properly
5782 * For now it is needed to reply to Probe Requests in IBSS mode.
5783 * Propably we need this information from FW.
5785 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5790 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5791 enum ieee80211_reconfig_type reconfig_type)
5793 struct ath10k *ar = hw->priv;
5795 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5798 mutex_lock(&ar->conf_mutex);
5800 /* If device failed to restart it will be in a different state, e.g.
5801 * ATH10K_STATE_WEDGED */
5802 if (ar->state == ATH10K_STATE_RESTARTED) {
5803 ath10k_info(ar, "device successfully recovered\n");
5804 ar->state = ATH10K_STATE_ON;
5805 ieee80211_wake_queues(ar->hw);
5808 mutex_unlock(&ar->conf_mutex);
5811 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5812 struct survey_info *survey)
5814 struct ath10k *ar = hw->priv;
5815 struct ieee80211_supported_band *sband;
5816 struct survey_info *ar_survey = &ar->survey[idx];
5819 mutex_lock(&ar->conf_mutex);
5821 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5822 if (sband && idx >= sband->n_channels) {
5823 idx -= sband->n_channels;
5828 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5830 if (!sband || idx >= sband->n_channels) {
5835 spin_lock_bh(&ar->data_lock);
5836 memcpy(survey, ar_survey, sizeof(*survey));
5837 spin_unlock_bh(&ar->data_lock);
5839 survey->channel = &sband->channels[idx];
5841 if (ar->rx_channel == survey->channel)
5842 survey->filled |= SURVEY_INFO_IN_USE;
5845 mutex_unlock(&ar->conf_mutex);
5850 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
5851 enum ieee80211_band band,
5852 const struct cfg80211_bitrate_mask *mask)
5857 num_rates += hweight32(mask->control[band].legacy);
5859 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
5860 num_rates += hweight8(mask->control[band].ht_mcs[i]);
5862 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
5863 num_rates += hweight16(mask->control[band].vht_mcs[i]);
5865 return num_rates == 1;
5869 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
5870 enum ieee80211_band band,
5871 const struct cfg80211_bitrate_mask *mask,
5874 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
5875 u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5877 u8 vht_nss_mask = 0;
5880 if (mask->control[band].legacy)
5883 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
5884 if (mask->control[band].ht_mcs[i] == 0)
5886 else if (mask->control[band].ht_mcs[i] ==
5887 sband->ht_cap.mcs.rx_mask[i])
5888 ht_nss_mask |= BIT(i);
5893 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
5894 if (mask->control[band].vht_mcs[i] == 0)
5896 else if (mask->control[band].vht_mcs[i] ==
5897 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
5898 vht_nss_mask |= BIT(i);
5903 if (ht_nss_mask != vht_nss_mask)
5906 if (ht_nss_mask == 0)
5909 if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
5912 *nss = fls(ht_nss_mask);
5918 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
5919 enum ieee80211_band band,
5920 const struct cfg80211_bitrate_mask *mask,
5923 struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
5930 if (hweight32(mask->control[band].legacy) == 1) {
5931 rate_idx = ffs(mask->control[band].legacy) - 1;
5933 hw_rate = sband->bitrates[rate_idx].hw_value;
5934 bitrate = sband->bitrates[rate_idx].bitrate;
5936 if (ath10k_mac_bitrate_is_cck(bitrate))
5937 preamble = WMI_RATE_PREAMBLE_CCK;
5939 preamble = WMI_RATE_PREAMBLE_OFDM;
5942 *rate = preamble << 6 |
5949 for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
5950 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
5952 *rate = WMI_RATE_PREAMBLE_HT << 6 |
5954 (ffs(mask->control[band].ht_mcs[i]) - 1);
5960 for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
5961 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
5963 *rate = WMI_RATE_PREAMBLE_VHT << 6 |
5965 (ffs(mask->control[band].vht_mcs[i]) - 1);
5974 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
5975 u8 rate, u8 nss, u8 sgi, u8 ldpc)
5977 struct ath10k *ar = arvif->ar;
5981 lockdep_assert_held(&ar->conf_mutex);
5983 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
5984 arvif->vdev_id, rate, nss, sgi);
5986 vdev_param = ar->wmi.vdev_param->fixed_rate;
5987 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
5989 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
5994 vdev_param = ar->wmi.vdev_param->nss;
5995 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
5997 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
6001 vdev_param = ar->wmi.vdev_param->sgi;
6002 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
6004 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
6008 vdev_param = ar->wmi.vdev_param->ldpc;
6009 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
6011 ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
6019 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
6020 enum ieee80211_band band,
6021 const struct cfg80211_bitrate_mask *mask)
6026 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6027 * to express all VHT MCS rate masks. Effectively only the following
6028 * ranges can be used: none, 0-7, 0-8 and 0-9.
6030 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
6031 vht_mcs = mask->control[band].vht_mcs[i];
6040 ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6048 static void ath10k_mac_set_bitrate_mask_iter(void *data,
6049 struct ieee80211_sta *sta)
6051 struct ath10k_vif *arvif = data;
6052 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6053 struct ath10k *ar = arvif->ar;
6055 if (arsta->arvif != arvif)
6058 spin_lock_bh(&ar->data_lock);
6059 arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
6060 spin_unlock_bh(&ar->data_lock);
6062 ieee80211_queue_work(ar->hw, &arsta->update_wk);
6065 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
6066 struct ieee80211_vif *vif,
6067 const struct cfg80211_bitrate_mask *mask)
6069 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6070 struct cfg80211_chan_def def;
6071 struct ath10k *ar = arvif->ar;
6072 enum ieee80211_band band;
6073 const u8 *ht_mcs_mask;
6074 const u16 *vht_mcs_mask;
6082 if (ath10k_mac_vif_chan(vif, &def))
6085 band = def.chan->band;
6086 ht_mcs_mask = mask->control[band].ht_mcs;
6087 vht_mcs_mask = mask->control[band].vht_mcs;
6088 ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
6090 sgi = mask->control[band].gi;
6091 if (sgi == NL80211_TXRATE_FORCE_LGI)
6094 if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
6095 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6098 ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
6099 arvif->vdev_id, ret);
6102 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
6104 rate = WMI_FIXED_RATE_NONE;
6107 rate = WMI_FIXED_RATE_NONE;
6108 nss = min(ar->num_rf_chains,
6109 max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6110 ath10k_mac_max_vht_nss(vht_mcs_mask)));
6112 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
6115 mutex_lock(&ar->conf_mutex);
6117 arvif->bitrate_mask = *mask;
6118 ieee80211_iterate_stations_atomic(ar->hw,
6119 ath10k_mac_set_bitrate_mask_iter,
6122 mutex_unlock(&ar->conf_mutex);
6125 mutex_lock(&ar->conf_mutex);
6127 ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
6129 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
6130 arvif->vdev_id, ret);
6135 mutex_unlock(&ar->conf_mutex);
6140 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
6141 struct ieee80211_vif *vif,
6142 struct ieee80211_sta *sta,
6145 struct ath10k *ar = hw->priv;
6146 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6149 spin_lock_bh(&ar->data_lock);
6151 ath10k_dbg(ar, ATH10K_DBG_MAC,
6152 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6153 sta->addr, changed, sta->bandwidth, sta->rx_nss,
6156 if (changed & IEEE80211_RC_BW_CHANGED) {
6157 bw = WMI_PEER_CHWIDTH_20MHZ;
6159 switch (sta->bandwidth) {
6160 case IEEE80211_STA_RX_BW_20:
6161 bw = WMI_PEER_CHWIDTH_20MHZ;
6163 case IEEE80211_STA_RX_BW_40:
6164 bw = WMI_PEER_CHWIDTH_40MHZ;
6166 case IEEE80211_STA_RX_BW_80:
6167 bw = WMI_PEER_CHWIDTH_80MHZ;
6169 case IEEE80211_STA_RX_BW_160:
6170 ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
6171 sta->bandwidth, sta->addr);
6172 bw = WMI_PEER_CHWIDTH_20MHZ;
6179 if (changed & IEEE80211_RC_NSS_CHANGED)
6180 arsta->nss = sta->rx_nss;
6182 if (changed & IEEE80211_RC_SMPS_CHANGED) {
6183 smps = WMI_PEER_SMPS_PS_NONE;
6185 switch (sta->smps_mode) {
6186 case IEEE80211_SMPS_AUTOMATIC:
6187 case IEEE80211_SMPS_OFF:
6188 smps = WMI_PEER_SMPS_PS_NONE;
6190 case IEEE80211_SMPS_STATIC:
6191 smps = WMI_PEER_SMPS_STATIC;
6193 case IEEE80211_SMPS_DYNAMIC:
6194 smps = WMI_PEER_SMPS_DYNAMIC;
6196 case IEEE80211_SMPS_NUM_MODES:
6197 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6198 sta->smps_mode, sta->addr);
6199 smps = WMI_PEER_SMPS_PS_NONE;
6206 arsta->changed |= changed;
6208 spin_unlock_bh(&ar->data_lock);
6210 ieee80211_queue_work(hw, &arsta->update_wk);
6213 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6216 * FIXME: Return 0 for time being. Need to figure out whether FW
6217 * has the API to fetch 64-bit local TSF
6223 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6224 struct ieee80211_vif *vif,
6225 enum ieee80211_ampdu_mlme_action action,
6226 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
6227 u8 buf_size, bool amsdu)
6229 struct ath10k *ar = hw->priv;
6230 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6232 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6233 arvif->vdev_id, sta->addr, tid, action);
6236 case IEEE80211_AMPDU_RX_START:
6237 case IEEE80211_AMPDU_RX_STOP:
6238 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6239 * creation/removal. Do we need to verify this?
6242 case IEEE80211_AMPDU_TX_START:
6243 case IEEE80211_AMPDU_TX_STOP_CONT:
6244 case IEEE80211_AMPDU_TX_STOP_FLUSH:
6245 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6246 case IEEE80211_AMPDU_TX_OPERATIONAL:
6247 /* Firmware offloads Tx aggregation entirely so deny mac80211
6248 * Tx aggregation requests.
6257 ath10k_mac_update_rx_channel(struct ath10k *ar,
6258 struct ieee80211_chanctx_conf *ctx,
6259 struct ieee80211_vif_chanctx_switch *vifs,
6262 struct cfg80211_chan_def *def = NULL;
6264 /* Both locks are required because ar->rx_channel is modified. This
6265 * allows readers to hold either lock.
6267 lockdep_assert_held(&ar->conf_mutex);
6268 lockdep_assert_held(&ar->data_lock);
6270 WARN_ON(ctx && vifs);
6271 WARN_ON(vifs && n_vifs != 1);
6273 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6274 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6275 * ppdu on Rx may reduce performance on low-end systems. It should be
6276 * possible to make tables/hashmaps to speed the lookup up (be vary of
6277 * cpu data cache lines though regarding sizes) but to keep the initial
6278 * implementation simple and less intrusive fallback to the slow lookup
6279 * only for multi-channel cases. Single-channel cases will remain to
6280 * use the old channel derival and thus performance should not be
6284 if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6285 ieee80211_iter_chan_contexts_atomic(ar->hw,
6286 ath10k_mac_get_any_chandef_iter,
6290 def = &vifs[0].new_ctx->def;
6292 ar->rx_channel = def->chan;
6293 } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6294 ar->rx_channel = ctx->def.chan;
6296 ar->rx_channel = NULL;
6302 ath10k_mac_update_vif_chan(struct ath10k *ar,
6303 struct ieee80211_vif_chanctx_switch *vifs,
6306 struct ath10k_vif *arvif;
6310 lockdep_assert_held(&ar->conf_mutex);
6312 /* First stop monitor interface. Some FW versions crash if there's a
6313 * lone monitor interface.
6315 if (ar->monitor_started)
6316 ath10k_monitor_stop(ar);
6318 for (i = 0; i < n_vifs; i++) {
6319 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6321 ath10k_dbg(ar, ATH10K_DBG_MAC,
6322 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6324 vifs[i].old_ctx->def.chan->center_freq,
6325 vifs[i].new_ctx->def.chan->center_freq,
6326 vifs[i].old_ctx->def.width,
6327 vifs[i].new_ctx->def.width);
6329 if (WARN_ON(!arvif->is_started))
6332 if (WARN_ON(!arvif->is_up))
6335 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6337 ath10k_warn(ar, "failed to down vdev %d: %d\n",
6338 arvif->vdev_id, ret);
6343 /* All relevant vdevs are downed and associated channel resources
6344 * should be available for the channel switch now.
6347 spin_lock_bh(&ar->data_lock);
6348 ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6349 spin_unlock_bh(&ar->data_lock);
6351 for (i = 0; i < n_vifs; i++) {
6352 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6354 if (WARN_ON(!arvif->is_started))
6357 if (WARN_ON(!arvif->is_up))
6360 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6362 ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6365 ret = ath10k_mac_setup_prb_tmpl(arvif);
6367 ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6370 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6372 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6373 arvif->vdev_id, ret);
6377 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6380 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6381 arvif->vdev_id, ret);
6386 ath10k_monitor_recalc(ar);
6390 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6391 struct ieee80211_chanctx_conf *ctx)
6393 struct ath10k *ar = hw->priv;
6395 ath10k_dbg(ar, ATH10K_DBG_MAC,
6396 "mac chanctx add freq %hu width %d ptr %p\n",
6397 ctx->def.chan->center_freq, ctx->def.width, ctx);
6399 mutex_lock(&ar->conf_mutex);
6401 spin_lock_bh(&ar->data_lock);
6402 ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6403 spin_unlock_bh(&ar->data_lock);
6405 ath10k_recalc_radar_detection(ar);
6406 ath10k_monitor_recalc(ar);
6408 mutex_unlock(&ar->conf_mutex);
6414 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6415 struct ieee80211_chanctx_conf *ctx)
6417 struct ath10k *ar = hw->priv;
6419 ath10k_dbg(ar, ATH10K_DBG_MAC,
6420 "mac chanctx remove freq %hu width %d ptr %p\n",
6421 ctx->def.chan->center_freq, ctx->def.width, ctx);
6423 mutex_lock(&ar->conf_mutex);
6425 spin_lock_bh(&ar->data_lock);
6426 ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6427 spin_unlock_bh(&ar->data_lock);
6429 ath10k_recalc_radar_detection(ar);
6430 ath10k_monitor_recalc(ar);
6432 mutex_unlock(&ar->conf_mutex);
6435 struct ath10k_mac_change_chanctx_arg {
6436 struct ieee80211_chanctx_conf *ctx;
6437 struct ieee80211_vif_chanctx_switch *vifs;
6443 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
6444 struct ieee80211_vif *vif)
6446 struct ath10k_mac_change_chanctx_arg *arg = data;
6448 if (rcu_access_pointer(vif->chanctx_conf) != arg->ctx)
6455 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
6456 struct ieee80211_vif *vif)
6458 struct ath10k_mac_change_chanctx_arg *arg = data;
6459 struct ieee80211_chanctx_conf *ctx;
6461 ctx = rcu_access_pointer(vif->chanctx_conf);
6462 if (ctx != arg->ctx)
6465 if (WARN_ON(arg->next_vif == arg->n_vifs))
6468 arg->vifs[arg->next_vif].vif = vif;
6469 arg->vifs[arg->next_vif].old_ctx = ctx;
6470 arg->vifs[arg->next_vif].new_ctx = ctx;
6475 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6476 struct ieee80211_chanctx_conf *ctx,
6479 struct ath10k *ar = hw->priv;
6480 struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
6482 mutex_lock(&ar->conf_mutex);
6484 ath10k_dbg(ar, ATH10K_DBG_MAC,
6485 "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6486 ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6488 /* This shouldn't really happen because channel switching should use
6489 * switch_vif_chanctx().
6491 if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6494 if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
6495 ieee80211_iterate_active_interfaces_atomic(
6497 IEEE80211_IFACE_ITER_NORMAL,
6498 ath10k_mac_change_chanctx_cnt_iter,
6500 if (arg.n_vifs == 0)
6503 arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
6508 ieee80211_iterate_active_interfaces_atomic(
6510 IEEE80211_IFACE_ITER_NORMAL,
6511 ath10k_mac_change_chanctx_fill_iter,
6513 ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
6518 ath10k_recalc_radar_detection(ar);
6520 /* FIXME: How to configure Rx chains properly? */
6522 /* No other actions are actually necessary. Firmware maintains channel
6523 * definitions per vdev internally and there's no host-side channel
6524 * context abstraction to configure, e.g. channel width.
6528 mutex_unlock(&ar->conf_mutex);
6532 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6533 struct ieee80211_vif *vif,
6534 struct ieee80211_chanctx_conf *ctx)
6536 struct ath10k *ar = hw->priv;
6537 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6540 mutex_lock(&ar->conf_mutex);
6542 ath10k_dbg(ar, ATH10K_DBG_MAC,
6543 "mac chanctx assign ptr %p vdev_id %i\n",
6544 ctx, arvif->vdev_id);
6546 if (WARN_ON(arvif->is_started)) {
6547 mutex_unlock(&ar->conf_mutex);
6551 ret = ath10k_vdev_start(arvif, &ctx->def);
6553 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6554 arvif->vdev_id, vif->addr,
6555 ctx->def.chan->center_freq, ret);
6559 arvif->is_started = true;
6561 ret = ath10k_mac_vif_setup_ps(arvif);
6563 ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
6564 arvif->vdev_id, ret);
6568 if (vif->type == NL80211_IFTYPE_MONITOR) {
6569 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6571 ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6572 arvif->vdev_id, ret);
6576 arvif->is_up = true;
6579 mutex_unlock(&ar->conf_mutex);
6583 ath10k_vdev_stop(arvif);
6584 arvif->is_started = false;
6585 ath10k_mac_vif_setup_ps(arvif);
6588 mutex_unlock(&ar->conf_mutex);
6593 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6594 struct ieee80211_vif *vif,
6595 struct ieee80211_chanctx_conf *ctx)
6597 struct ath10k *ar = hw->priv;
6598 struct ath10k_vif *arvif = (void *)vif->drv_priv;
6601 mutex_lock(&ar->conf_mutex);
6603 ath10k_dbg(ar, ATH10K_DBG_MAC,
6604 "mac chanctx unassign ptr %p vdev_id %i\n",
6605 ctx, arvif->vdev_id);
6607 WARN_ON(!arvif->is_started);
6609 if (vif->type == NL80211_IFTYPE_MONITOR) {
6610 WARN_ON(!arvif->is_up);
6612 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6614 ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6615 arvif->vdev_id, ret);
6617 arvif->is_up = false;
6620 ret = ath10k_vdev_stop(arvif);
6622 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6623 arvif->vdev_id, ret);
6625 arvif->is_started = false;
6627 mutex_unlock(&ar->conf_mutex);
6631 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6632 struct ieee80211_vif_chanctx_switch *vifs,
6634 enum ieee80211_chanctx_switch_mode mode)
6636 struct ath10k *ar = hw->priv;
6638 mutex_lock(&ar->conf_mutex);
6640 ath10k_dbg(ar, ATH10K_DBG_MAC,
6641 "mac chanctx switch n_vifs %d mode %d\n",
6643 ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
6645 mutex_unlock(&ar->conf_mutex);
6649 static const struct ieee80211_ops ath10k_ops = {
6651 .start = ath10k_start,
6652 .stop = ath10k_stop,
6653 .config = ath10k_config,
6654 .add_interface = ath10k_add_interface,
6655 .remove_interface = ath10k_remove_interface,
6656 .configure_filter = ath10k_configure_filter,
6657 .bss_info_changed = ath10k_bss_info_changed,
6658 .hw_scan = ath10k_hw_scan,
6659 .cancel_hw_scan = ath10k_cancel_hw_scan,
6660 .set_key = ath10k_set_key,
6661 .set_default_unicast_key = ath10k_set_default_unicast_key,
6662 .sta_state = ath10k_sta_state,
6663 .conf_tx = ath10k_conf_tx,
6664 .remain_on_channel = ath10k_remain_on_channel,
6665 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
6666 .set_rts_threshold = ath10k_set_rts_threshold,
6667 .set_frag_threshold = ath10k_mac_op_set_frag_threshold,
6668 .flush = ath10k_flush,
6669 .tx_last_beacon = ath10k_tx_last_beacon,
6670 .set_antenna = ath10k_set_antenna,
6671 .get_antenna = ath10k_get_antenna,
6672 .reconfig_complete = ath10k_reconfig_complete,
6673 .get_survey = ath10k_get_survey,
6674 .set_bitrate_mask = ath10k_mac_op_set_bitrate_mask,
6675 .sta_rc_update = ath10k_sta_rc_update,
6676 .get_tsf = ath10k_get_tsf,
6677 .ampdu_action = ath10k_ampdu_action,
6678 .get_et_sset_count = ath10k_debug_get_et_sset_count,
6679 .get_et_stats = ath10k_debug_get_et_stats,
6680 .get_et_strings = ath10k_debug_get_et_strings,
6681 .add_chanctx = ath10k_mac_op_add_chanctx,
6682 .remove_chanctx = ath10k_mac_op_remove_chanctx,
6683 .change_chanctx = ath10k_mac_op_change_chanctx,
6684 .assign_vif_chanctx = ath10k_mac_op_assign_vif_chanctx,
6685 .unassign_vif_chanctx = ath10k_mac_op_unassign_vif_chanctx,
6686 .switch_vif_chanctx = ath10k_mac_op_switch_vif_chanctx,
6688 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6691 .suspend = ath10k_wow_op_suspend,
6692 .resume = ath10k_wow_op_resume,
6694 #ifdef CONFIG_MAC80211_DEBUGFS
6695 .sta_add_debugfs = ath10k_sta_add_debugfs,
6699 #define CHAN2G(_channel, _freq, _flags) { \
6700 .band = IEEE80211_BAND_2GHZ, \
6701 .hw_value = (_channel), \
6702 .center_freq = (_freq), \
6703 .flags = (_flags), \
6704 .max_antenna_gain = 0, \
6708 #define CHAN5G(_channel, _freq, _flags) { \
6709 .band = IEEE80211_BAND_5GHZ, \
6710 .hw_value = (_channel), \
6711 .center_freq = (_freq), \
6712 .flags = (_flags), \
6713 .max_antenna_gain = 0, \
6717 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6727 CHAN2G(10, 2457, 0),
6728 CHAN2G(11, 2462, 0),
6729 CHAN2G(12, 2467, 0),
6730 CHAN2G(13, 2472, 0),
6731 CHAN2G(14, 2484, 0),
6734 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6735 CHAN5G(36, 5180, 0),
6736 CHAN5G(40, 5200, 0),
6737 CHAN5G(44, 5220, 0),
6738 CHAN5G(48, 5240, 0),
6739 CHAN5G(52, 5260, 0),
6740 CHAN5G(56, 5280, 0),
6741 CHAN5G(60, 5300, 0),
6742 CHAN5G(64, 5320, 0),
6743 CHAN5G(100, 5500, 0),
6744 CHAN5G(104, 5520, 0),
6745 CHAN5G(108, 5540, 0),
6746 CHAN5G(112, 5560, 0),
6747 CHAN5G(116, 5580, 0),
6748 CHAN5G(120, 5600, 0),
6749 CHAN5G(124, 5620, 0),
6750 CHAN5G(128, 5640, 0),
6751 CHAN5G(132, 5660, 0),
6752 CHAN5G(136, 5680, 0),
6753 CHAN5G(140, 5700, 0),
6754 CHAN5G(144, 5720, 0),
6755 CHAN5G(149, 5745, 0),
6756 CHAN5G(153, 5765, 0),
6757 CHAN5G(157, 5785, 0),
6758 CHAN5G(161, 5805, 0),
6759 CHAN5G(165, 5825, 0),
6762 struct ath10k *ath10k_mac_create(size_t priv_size)
6764 struct ieee80211_hw *hw;
6767 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6777 void ath10k_mac_destroy(struct ath10k *ar)
6779 ieee80211_free_hw(ar->hw);
6782 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6785 .types = BIT(NL80211_IFTYPE_STATION)
6786 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6790 .types = BIT(NL80211_IFTYPE_P2P_GO)
6794 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
6798 .types = BIT(NL80211_IFTYPE_AP)
6799 #ifdef CONFIG_MAC80211_MESH
6800 | BIT(NL80211_IFTYPE_MESH_POINT)
6805 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6808 .types = BIT(NL80211_IFTYPE_AP)
6809 #ifdef CONFIG_MAC80211_MESH
6810 | BIT(NL80211_IFTYPE_MESH_POINT)
6815 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6817 .limits = ath10k_if_limits,
6818 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6819 .max_interfaces = 8,
6820 .num_different_channels = 1,
6821 .beacon_int_infra_match = true,
6825 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6827 .limits = ath10k_10x_if_limits,
6828 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6829 .max_interfaces = 8,
6830 .num_different_channels = 1,
6831 .beacon_int_infra_match = true,
6832 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6833 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6834 BIT(NL80211_CHAN_WIDTH_20) |
6835 BIT(NL80211_CHAN_WIDTH_40) |
6836 BIT(NL80211_CHAN_WIDTH_80),
6841 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
6844 .types = BIT(NL80211_IFTYPE_STATION),
6848 .types = BIT(NL80211_IFTYPE_AP) |
6849 #ifdef CONFIG_MAC80211_MESH
6850 BIT(NL80211_IFTYPE_MESH_POINT) |
6852 BIT(NL80211_IFTYPE_P2P_CLIENT) |
6853 BIT(NL80211_IFTYPE_P2P_GO),
6857 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6861 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
6864 .types = BIT(NL80211_IFTYPE_STATION),
6868 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
6872 .types = BIT(NL80211_IFTYPE_AP) |
6873 #ifdef CONFIG_MAC80211_MESH
6874 BIT(NL80211_IFTYPE_MESH_POINT) |
6876 BIT(NL80211_IFTYPE_P2P_GO),
6880 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6884 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
6887 .types = BIT(NL80211_IFTYPE_STATION),
6891 .types = BIT(NL80211_IFTYPE_ADHOC),
6895 /* FIXME: This is not thouroughly tested. These combinations may over- or
6896 * underestimate hw/fw capabilities.
6898 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
6900 .limits = ath10k_tlv_if_limit,
6901 .num_different_channels = 1,
6902 .max_interfaces = 4,
6903 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
6906 .limits = ath10k_tlv_if_limit_ibss,
6907 .num_different_channels = 1,
6908 .max_interfaces = 2,
6909 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
6913 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
6915 .limits = ath10k_tlv_if_limit,
6916 .num_different_channels = 1,
6917 .max_interfaces = 4,
6918 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
6921 .limits = ath10k_tlv_qcs_if_limit,
6922 .num_different_channels = 2,
6923 .max_interfaces = 4,
6924 .n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
6927 .limits = ath10k_tlv_if_limit_ibss,
6928 .num_different_channels = 1,
6929 .max_interfaces = 2,
6930 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
6934 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
6937 .types = BIT(NL80211_IFTYPE_STATION),
6941 .types = BIT(NL80211_IFTYPE_AP)
6942 #ifdef CONFIG_MAC80211_MESH
6943 | BIT(NL80211_IFTYPE_MESH_POINT)
6948 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
6950 .limits = ath10k_10_4_if_limits,
6951 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
6952 .max_interfaces = 16,
6953 .num_different_channels = 1,
6954 .beacon_int_infra_match = true,
6955 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6956 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6957 BIT(NL80211_CHAN_WIDTH_20) |
6958 BIT(NL80211_CHAN_WIDTH_40) |
6959 BIT(NL80211_CHAN_WIDTH_80),
6964 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
6966 struct ieee80211_sta_vht_cap vht_cap = {0};
6971 vht_cap.vht_supported = 1;
6972 vht_cap.cap = ar->vht_cap_info;
6974 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
6975 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
6976 val = ath10k_mac_get_vht_cap_bf_sts(ar);
6977 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
6978 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
6983 if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
6984 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
6985 val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
6986 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
6987 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
6993 for (i = 0; i < 8; i++) {
6994 if (i < ar->num_rf_chains)
6995 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
6997 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
7000 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
7001 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
7006 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
7009 struct ieee80211_sta_ht_cap ht_cap = {0};
7011 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
7014 ht_cap.ht_supported = 1;
7015 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
7016 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
7017 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
7018 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
7019 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
7021 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
7022 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
7024 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
7025 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
7027 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
7030 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
7031 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
7036 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
7037 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
7039 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
7042 stbc = ar->ht_cap_info;
7043 stbc &= WMI_HT_CAP_RX_STBC;
7044 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
7045 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
7046 stbc &= IEEE80211_HT_CAP_RX_STBC;
7051 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
7052 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
7054 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
7055 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
7057 /* max AMSDU is implicitly taken from vht_cap_info */
7058 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
7059 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
7061 for (i = 0; i < ar->num_rf_chains; i++)
7062 ht_cap.mcs.rx_mask[i] = 0xFF;
7064 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
7069 static void ath10k_get_arvif_iter(void *data, u8 *mac,
7070 struct ieee80211_vif *vif)
7072 struct ath10k_vif_iter *arvif_iter = data;
7073 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
7075 if (arvif->vdev_id == arvif_iter->vdev_id)
7076 arvif_iter->arvif = arvif;
7079 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
7081 struct ath10k_vif_iter arvif_iter;
7084 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
7085 arvif_iter.vdev_id = vdev_id;
7087 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
7088 ieee80211_iterate_active_interfaces_atomic(ar->hw,
7090 ath10k_get_arvif_iter,
7092 if (!arvif_iter.arvif) {
7093 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
7097 return arvif_iter.arvif;
7100 int ath10k_mac_register(struct ath10k *ar)
7102 static const u32 cipher_suites[] = {
7103 WLAN_CIPHER_SUITE_WEP40,
7104 WLAN_CIPHER_SUITE_WEP104,
7105 WLAN_CIPHER_SUITE_TKIP,
7106 WLAN_CIPHER_SUITE_CCMP,
7107 WLAN_CIPHER_SUITE_AES_CMAC,
7109 struct ieee80211_supported_band *band;
7110 struct ieee80211_sta_vht_cap vht_cap;
7111 struct ieee80211_sta_ht_cap ht_cap;
7115 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
7117 SET_IEEE80211_DEV(ar->hw, ar->dev);
7119 ht_cap = ath10k_get_ht_cap(ar);
7120 vht_cap = ath10k_create_vht_cap(ar);
7122 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
7123 ARRAY_SIZE(ath10k_5ghz_channels)) !=
7126 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
7127 channels = kmemdup(ath10k_2ghz_channels,
7128 sizeof(ath10k_2ghz_channels),
7135 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
7136 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
7137 band->channels = channels;
7138 band->n_bitrates = ath10k_g_rates_size;
7139 band->bitrates = ath10k_g_rates;
7140 band->ht_cap = ht_cap;
7142 /* Enable the VHT support at 2.4 GHz */
7143 band->vht_cap = vht_cap;
7145 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
7148 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
7149 channels = kmemdup(ath10k_5ghz_channels,
7150 sizeof(ath10k_5ghz_channels),
7157 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
7158 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
7159 band->channels = channels;
7160 band->n_bitrates = ath10k_a_rates_size;
7161 band->bitrates = ath10k_a_rates;
7162 band->ht_cap = ht_cap;
7163 band->vht_cap = vht_cap;
7164 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
7167 ar->hw->wiphy->interface_modes =
7168 BIT(NL80211_IFTYPE_STATION) |
7169 BIT(NL80211_IFTYPE_AP) |
7170 BIT(NL80211_IFTYPE_MESH_POINT);
7172 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
7173 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
7175 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
7176 ar->hw->wiphy->interface_modes |=
7177 BIT(NL80211_IFTYPE_P2P_DEVICE) |
7178 BIT(NL80211_IFTYPE_P2P_CLIENT) |
7179 BIT(NL80211_IFTYPE_P2P_GO);
7181 ieee80211_hw_set(ar->hw, SIGNAL_DBM);
7182 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
7183 ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
7184 ieee80211_hw_set(ar->hw, MFP_CAPABLE);
7185 ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
7186 ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
7187 ieee80211_hw_set(ar->hw, AP_LINK_PS);
7188 ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
7189 ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
7190 ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
7191 ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
7192 ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
7193 ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
7194 ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
7196 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7197 ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
7199 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
7200 ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
7202 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
7203 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
7205 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
7206 ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
7207 ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
7210 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
7211 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
7213 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
7214 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
7216 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
7218 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
7219 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
7221 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7222 * that userspace (e.g. wpa_supplicant/hostapd) can generate
7223 * correct Probe Responses. This is more of a hack advert..
7225 ar->hw->wiphy->probe_resp_offload |=
7226 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
7227 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
7228 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
7231 if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
7232 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7234 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
7235 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
7236 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
7238 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
7239 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
7241 ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
7243 ret = ath10k_wow_init(ar);
7245 ath10k_warn(ar, "failed to init wow: %d\n", ret);
7249 wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
7252 * on LL hardware queues are managed entirely by the FW
7253 * so we only advertise to mac we can do the queues thing
7255 ar->hw->queues = IEEE80211_MAX_QUEUES;
7257 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7258 * something that vdev_ids can't reach so that we don't stop the queue
7261 ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
7263 switch (ar->wmi.op_version) {
7264 case ATH10K_FW_WMI_OP_VERSION_MAIN:
7265 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
7266 ar->hw->wiphy->n_iface_combinations =
7267 ARRAY_SIZE(ath10k_if_comb);
7268 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7270 case ATH10K_FW_WMI_OP_VERSION_TLV:
7271 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
7272 ar->hw->wiphy->iface_combinations =
7273 ath10k_tlv_qcs_if_comb;
7274 ar->hw->wiphy->n_iface_combinations =
7275 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
7277 ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
7278 ar->hw->wiphy->n_iface_combinations =
7279 ARRAY_SIZE(ath10k_tlv_if_comb);
7281 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
7283 case ATH10K_FW_WMI_OP_VERSION_10_1:
7284 case ATH10K_FW_WMI_OP_VERSION_10_2:
7285 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
7286 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
7287 ar->hw->wiphy->n_iface_combinations =
7288 ARRAY_SIZE(ath10k_10x_if_comb);
7290 case ATH10K_FW_WMI_OP_VERSION_10_4:
7291 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
7292 ar->hw->wiphy->n_iface_combinations =
7293 ARRAY_SIZE(ath10k_10_4_if_comb);
7295 case ATH10K_FW_WMI_OP_VERSION_UNSET:
7296 case ATH10K_FW_WMI_OP_VERSION_MAX:
7302 if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
7303 ar->hw->netdev_features = NETIF_F_HW_CSUM;
7305 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
7306 /* Init ath dfs pattern detector */
7307 ar->ath_common.debug_mask = ATH_DBG_DFS;
7308 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
7311 if (!ar->dfs_detector)
7312 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
7315 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7316 ath10k_reg_notifier);
7318 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7319 goto err_dfs_detector_exit;
7322 ar->hw->wiphy->cipher_suites = cipher_suites;
7323 ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7325 ret = ieee80211_register_hw(ar->hw);
7327 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7328 goto err_dfs_detector_exit;
7331 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7332 ret = regulatory_hint(ar->hw->wiphy,
7333 ar->ath_common.regulatory.alpha2);
7335 goto err_unregister;
7341 ieee80211_unregister_hw(ar->hw);
7343 err_dfs_detector_exit:
7344 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7345 ar->dfs_detector->exit(ar->dfs_detector);
7348 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7349 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7351 SET_IEEE80211_DEV(ar->hw, NULL);
7355 void ath10k_mac_unregister(struct ath10k *ar)
7357 ieee80211_unregister_hw(ar->hw);
7359 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7360 ar->dfs_detector->exit(ar->dfs_detector);
7362 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7363 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7365 SET_IEEE80211_DEV(ar->hw, NULL);